import assert from 'node:assert/strict'
import { readFile, mkdir, writeFile } from 'node:fs/promises'
import { dirname, resolve } from 'node:path'
import { fileURLToPath, pathToFileURL } from 'node:url'
import { createHash } from 'node:crypto'
import { stableSnapshot } from './admin-test-env-modules/container-customs-acceptance-matrix.mjs'

const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
const PDA = '/api/platform/v1/first-leg/pda-loading'
const LEG = '/api/platform/v1/first-leg'
const CUSTOMS = '/api/platform/v1/customs/loading-plans'
const TYPES = ['PHOTO_STEP_1', 'PHOTO_STEP_2', 'PHOTO_STEP_3', 'PHOTO_STEP_4', 'SEAL']
const id = value => String(value ?? '')
const positive = value => typeof value === 'string' && /^[1-9]\d*$/.test(value)
const rows = value => Array.isArray(value) ? value : []
const sha = value => createHash('sha256').update(value).digest('hex')
class CheckFailure extends Error {}
function need(condition, message) { if (!condition) throw new CheckFailure(message) }

export function plan() {
  return { plan: true, networkRequests: 0, businessWrites: false,
    cases: ['A: refund PARTIAL 3→2 + same-owner SKIP + buy PICK + skipped refund customer',
      'B: only actual buy row PARTIAL 2→1 + all refund rows SKIP; all actual rows PARTIAL'],
    upstream: 'Use --fixture=NEW to prepare isolated customers/orders/measurements and two confirmed cabinets, or consume two passing manual-pda-batch-fixture reports',
    operations: ['validate both unclaimed tasks before writes', 'claim', 'one atomic batch per task',
      'upload five supplied image files', 'complete and poll', 'actual list/metrics/customs scope',
      'same original completion replay and zero drift', 'all-buy start/complete and refund-send rejection', 'logout own sessions'],
    excluded: ['F01–F40 full regression', 'SQL/deployment', 'historical events or data repair',
      'browser/device proof', 'Outbox/ACK/downstream inventory evidence', 'refund document workflow and XLSX download'],
    manifest: { schemaVersion: 1, runId: 'PARTIAL-ACTUAL-<new-run>', environment: 'TEST',
      cases: ['A', 'B'].map(kind => ({ kind, sourceReport: '<new successful Admin fixture report>',
        actions: [{ itemId: '<PDA item id from taskItems>', action: 'PARTIAL', finalPickedPackageCount: kind === 'A' ? 2 : 1 }],
        evidence: Object.fromEntries(TYPES.map(type => [type, '<supplied PNG or JPEG path>'])), sealNo: '<nonempty seal>' })) },
    execution: 'node --env-file=<authorized TEST test-acceptance.env> scripts/partial-loading-actual-test-env.mjs --execute --environment=TEST --run-id=<new-run> --fixture=<manifest.json>' }
}

export function executionOptions(args, execArgs, env, cwd = process.cwd()) {
  if (!args.length || args.length === 1 && args[0] === '--plan') return { execute: false }
  need([4,5].includes(args.length) && args[0] === '--execute' && args[1] === '--environment=TEST'
    && /^--run-id=PARTIAL-ACTUAL-[A-Za-z0-9_-]{1,40}$/.test(args[2])
    && args[3].startsWith('--fixture=') && args[3].slice(10), 'Explicit TEST, new PARTIAL-ACTUAL run-id and fixture required')
  need(resolve(cwd).replaceAll('\\', '/').toLowerCase() === ROOT.replaceAll('\\', '/').toLowerCase(), 'Run in the TEST backend workspace')
  need(execArgs.length === 1 && execArgs[0].startsWith('--env-file=')
    && resolve(execArgs[0].slice(11)).replaceAll('\\', '/').endsWith('/.codex/env/chongchong-global/test-acceptance.env'), 'Use the authorized TEST env-file')
  need(String(env.CHONGCHONG_ENV).toUpperCase() === 'TEST', 'TEST profile required')
  for (const key of ['CHONGCHONG_ADMIN_API_BASE_URL', 'CHONGCHONG_ADMIN_USERNAME', 'CHONGCHONG_ADMIN_PASSWORD', 'ADMIN_PDA_USERNAME', 'ADMIN_PDA_PASSWORD']) need(Boolean(env[key]), `Missing ${key}`)
  const base = new URL(env.CHONGCHONG_ADMIN_API_BASE_URL)
  need(['https:', 'http:'].includes(base.protocol) && !base.username && !base.password
    && base.pathname === '/api' && !base.search && !base.hash, 'Configured TEST admin API base must end in /api')
  const input = args[3].slice(10)
  const completion = input.startsWith('COMPLETION:') || input.startsWith('VERIFY_A:') || input.startsWith('B_ONLY:')
  need(completion ? args[4] === '--ready-commit=ea9732749a9215e660530035c40afc69fe56a5ae' : args.length === 4,
    'Original-command recovery requires explicit matching controller-ready commit')
  return { execute: true, runId: args[2].slice(9), fixture: input === 'NEW' ? 'NEW' : input.startsWith('RESUME:')
    ? { resumeReport: resolve(input.slice(7)) } : input.startsWith('PREPARED:')
      ? { preparedReport: resolve(input.slice(9)) } : input.startsWith('B_ONLY:') ? { bOnlyReport: resolve(input.slice(7)) }
        : input.startsWith('VERIFY_A:') ? { verifyAReport: resolve(input.slice(9)) }
        : completion ? { completionReport: resolve(input.slice(11)) } : resolve(input),
    gateway: base.origin, ...(completion ? { readyCommit: args[4].slice(15) } : {}) }
}

export function originalCompletionCommand(failedReport) {
  need(failedReport.runId === 'PARTIAL-ACTUAL-20261004-recovery-r7' && failedReport.success === false, 'Bind the original A failed execution')
  const attempts = rows(failedReport.requests).filter(item => item.method === 'POST'
    && item.path === `${PDA}/tasks/2106713892758491138/complete`)
  need(attempts.length === 1 && attempts[0].state === 'RECEIVED' && attempts[0].http === 200 && attempts[0].code === '200', 'Exactly one accepted original completion command required')
  const body = attempts[0].request
  assert.deepEqual(body, { expectedTaskVersion: 2, operationId: 'PARTIAL-ACTUAL-20261004-recovery-r3-A-complete', remark: 'PARTIAL-ACTUAL-20261004-recovery-r3-A' }, 'Original immutable completion payload')
  const command = attempts[0].response?.data?.completionCommand
  need(id(command?.id) === '2106716718935052290' && command.operationId === body.operationId && Number(command.expectedTaskVersion) === 2,
    'Original command identity/version mismatch')
  return { commandId: id(command.id), body: structuredClone(body) }
}

const dataOf = response => {
  need(response.http === 200 && String(response.body?.code) === '200', `API rejected ${response.path}: HTTP=${response.http}, code=${response.body?.code ?? 'missing'}`)
  return response.body.data
}
const selected = (value, names) => Object.fromEntries(names.map(name => [name, value?.[name] ?? null]))
export function stableSource(source) {
  return { summary: selected(source.summary, ['id','tenantId','orderId','orderNo','inboundCode','processStatus','version','packageCount','totalPackageCount','splitStatus','actualGrossWeightKg','actualVolumeCbm']),
    statusHistory: source.statusHistory, palletLocations: source.palletLocations }
}

export async function sourceSnapshot(spec, request) {
  const result = []
  for (const owner of spec.owners) result.push({ owner, view: dataOf(await request('GET', `/api/platform/inbounds/${owner.inboundId}?tenantId=${owner.tenantId}`)) })
  // Failed/completed tasks are not an editable inventory-snapshot surface. The
  // source detail API exposes the persisted block/slot/reservation and allocation
  // quantities needed to prove these already-completed owners do not settle twice.
  return { sources: result, inventory: { allocations: result.map(item => ({ tenantId: item.owner.tenantId,
    inboundId: item.owner.inboundId, palletLocations: item.view.palletLocations })) } }
}

export function verifyOldOwnersUnchanged(before, after, expected) {
  for (const item of before.sources) {
    const current = after.sources.find(row => row.owner.inboundId === item.owner.inboundId)
    need(current, 'Original source disappeared from readback')
    assert.equal(stableSnapshot(stableSource(current.view)), stableSnapshot(stableSource(item.view)), 'Original owner facts/version/history/resources must not repeat')
    const actual = expected.some(row => row.inboundId === item.owner.inboundId && row.actual > 0)
    need(actual ? current.view.summary.processStatus === 'LOADED' : current.view.summary.processStatus !== 'LOADED', 'Whole skipped source cannot become LOADED')
  }
  assert.equal(stableSnapshot(after.inventory), stableSnapshot(before.inventory), 'Original domestic inventory must not be deducted again')
}

export function verifyPhysicalFacts(expected, task) {
  const actual = rows(task.items).filter(row => ['PICKED','PARTIAL'].includes(row.itemStatus) && Number(row.pickedPackageCount) > 0)
  const expectedActual = expected.filter(row => row.actual > 0)
  assert.deepEqual(actual.map(row => id(row.loadingPlanItemId)).sort(), expectedActual.map(row => row.itemId).sort(), 'Original physical item set')
  for (const item of expectedActual) {
    const row = actual.find(row => id(row.loadingPlanItemId) === item.itemId)
    need(Number(row.pickedPackageCount) === item.actual && id(row.tenantId) === item.accountId && id(row.inboundId) === item.inboundId,
      'Original physical count/customer/source drift')
  }
}

async function readSmallPage(path, request) {
  const page = dataOf(await request('GET', path))
  need(Array.isArray(page.records) && Number(page.page) === 1 && Number(page.size) === 200
    && Number(page.total) === page.records.length && new Set(page.records.map(row => id(row.id))).size === page.records.length,
    'Bounded new-sample page incomplete or duplicated')
  return page.records
}

export async function downstreamSnapshot(spec, request) {
  const result = []
  for (const owner of spec.owners) {
    const query = new URLSearchParams({ customerId: owner.tenantId, containerNo: spec.source.containerNo, page: '1', size: '200' })
    const orders = await readSmallPage(`/api/platform/v1/last-leg/orders?${query}`, request)
    const code = spec.expected.find(row => row.inboundId === owner.inboundId)?.frozen.inboundCode
    need(code, 'Frozen original inbound code required for inventory scope')
    const inventory = new URLSearchParams({ customerId: owner.tenantId, inboundCode: code, page: '1', size: '200' })
    const groupedBalances = await readSmallPage(`/api/platform/v1/last-leg/inventory/balances?${inventory}`, request)
    const balances = []
    for (const row of groupedBalances) balances.push(dataOf(await request('GET', `/api/platform/v1/last-leg/inventory/balances/${row.id}?customerId=${owner.tenantId}`)))
    const ledger = await readSmallPage(`/api/platform/v1/last-leg/inventory/ledger?${inventory}`, request)
    const details = []
    for (const order of orders) details.push(dataOf(await request('GET', `/api/platform/v1/last-leg/orders/${order.id}?customerId=${owner.tenantId}`)))
    result.push({ owner, orders, balances, groupedBalances, ledger, details })
  }
  return result
}

export function verifyDownstream(spec, snapshot) {
  let packages = 0
  for (const item of snapshot) {
    const actualRows = spec.expected.filter(row => row.inboundId === item.owner.inboundId && row.actual > 0)
    const expected = actualRows.reduce((sum, row) => sum + row.actual, 0)
    if (!expected) {
      need(!item.orders.length && !item.balances.length && !item.ledger.length, 'Skipped owner must have no tail cargo or transit inventory')
      continue
    }
    need(item.orders.length === 1 && item.details.length === 1, 'Exactly one consumer-created tail order per actual source')
    const order = item.orders[0], detail = item.details[0]
    need(id(order.customerId) === item.owner.tenantId && id(order.sourceInboundId) === item.owner.inboundId
      && id(order.sourceContainerBookingId) === spec.source.containerBookingId && order.containerNo === spec.source.containerNo
      && Number(order.packageCount) === expected, 'Tail materialization must use exact actual customer/source/container boxes')
    need(rows(detail.statusHistory).filter(row => row.toStatus === 'PENDING_ASSIGNMENT' && row.remark === '头程装柜完成自动生成').length === 1,
      'Exactly one actual loading-event creation history')
    need(rows(detail.cargo).length === actualRows.length, 'Skipped SKU cannot enter frozen tail cargo')
    for (const row of actualRows) {
      const cargo = detail.cargo.find(cargo => cargo.skuCode === row.frozen.skuCode)
      need(cargo && Number(cargo.packageCount) === row.actual, 'Tail SKU actual boxes mismatch')
    }
    const sum = (values, field) => values.reduce((total, row) => total + Number(row[field]), 0)
    need(item.balances.every(row => row.customerId === item.owner.tenantId && row.inboundCode === rowCode(actualRows) && id(row.inboundOrderId) === id(order.id)
      && Number(row.availablePackages) === 0 && Number(row.holdPackages) === 0 && Number(row.allocatedPackages) === 0
      && Number(row.pickedPackages) === 0 && Number(row.receivingPackages) === 0 && Number(row.procurementPackages) === 0)
      && sum(item.balances, 'inTransitPackages') === expected && sum(item.balances, 'totalPackages') === 0,
      'Initial transit inventory must equal actual boxes only')
    need(item.ledger.length === actualRows.length && sum(item.ledger, 'deltaPackages') === expected
      && item.ledger.every(row => Number(row.beforePackages) === 0 && Number(row.afterPackages) === Number(row.deltaPackages)
        && row.customerId === item.owner.tenantId && row.inboundCode === rowCode(actualRows) && id(row.inboundOrderId) === id(order.id) && row.businessOrderNo === order.orderNo),
      'One initial inventory movement per actual SKU; no duplicate or skipped movement')
    packages += expected
  }
  return { actualPackages: packages, loadingEventMaterializationVerified: true, directOutboxAckAuditVerified: false }
}
const rowCode = actualRows => actualRows[0].frozen.inboundCode

async function waitDownstream(spec, request, sleep) {
  for (let attempt = 0; attempt < 30; attempt++) {
    const snapshot = await downstreamSnapshot(spec, request)
    const expectedOrders = spec.expected.filter(row => row.actual > 0).map(row => row.inboundId)
    const active = [...new Set(expectedOrders)]
    if (snapshot.reduce((sum, item) => sum + item.orders.length, 0) === active.length) return { snapshot, facts: verifyDownstream(spec, snapshot) }
    await sleep(1000)
  }
  throw new CheckFailure('Loading event materialization did not converge; no source/event replay')
}

export async function recoverOriginalA(spec, original, request, checkpoint, sleep = ms => new Promise(done => setTimeout(done, ms))) {
  const path = `${PDA}/tasks/${spec.source.pdaTaskId}`
  const task = dataOf(await request('GET', `${path}?warehouseId=${spec.source.warehouseId}`, undefined, 'pda'))
  need(task.taskStatus === 'COMPLETION_FAILED' && task.completionCommand?.status === 'FAILED'
    && id(task.completionCommand.id) === original.commandId && task.completionCommand.operationId === original.body.operationId
    && Number(task.completionCommand.expectedTaskVersion) === original.body.expectedTaskVersion, 'Original failed command no longer matches; do not issue another command')
  verifyPhysicalFacts(spec.expected, task)
  const before = await sourceSnapshot(spec, request)
  for (const item of before.sources) {
    const actual = spec.expected.some(row => row.inboundId === item.owner.inboundId && row.actual > 0)
    need(actual ? item.view.summary.processStatus === 'LOADED' : item.view.summary.processStatus !== 'LOADED', 'Original completed/whole-skipped owner baseline mismatch')
  }
  await checkpoint({ stage: 'A_BEFORE_ORIGINAL_RECOVERY', task, original, before })
  try { dataOf(await request('POST', `${path}/complete`, original.body, 'pda')) }
  catch (error) {
    const readback = await request('GET', `${path}?warehouseId=${spec.source.warehouseId}`, undefined, 'pda')
    await checkpoint({ stage: 'A_RECOVERY_REJECTED_OR_UNKNOWN_READBACK', readback })
    throw error // no blind repetition of a write with an uncertain result
  }
  let completed
  for (let attempt = 0; attempt < 60; attempt++) {
    completed = dataOf(await request('GET', `${path}?warehouseId=${spec.source.warehouseId}`, undefined, 'pda'))
    if (completed.taskStatus === 'COMPLETED' && completed.workflowStatus === 'COMPLETED') break
    need(completed.taskStatus === 'COMPLETING', `Original recovery failed: ${completed.completionCommand?.failureStage}/${completed.completionCommand?.failureCode}`)
    await sleep(1000)
  }
  need(completed.taskStatus === 'COMPLETED' && id(completed.completionCommand.id) === original.commandId, 'Same original command must finish')
  verifyPhysicalFacts(spec.expected, completed)
  const after = await sourceSnapshot(spec, request); verifyOldOwnersUnchanged(before, after, spec.expected)
  const detail = dataOf(await request('GET', `${LEG}/loading-lists/${spec.source.loadingPlanId}?warehouseId=${spec.source.warehouseId}`))
  const customs = dataOf(await request('GET', `${CUSTOMS}/${spec.source.loadingPlanId}`))
  const planState = dataOf(await request('GET', `${LEG}/loading-plans/${spec.source.loadingPlanId}/lifecycle?warehouseId=${spec.source.warehouseId}`))
  const facts = verifyActual(spec.expected, detail, customs)
  need(planState.detailResource === 'LOADING_LIST' && planState.planStatus === 'COMPLETED', 'Recovered plan must expose completed loading-list lifecycle')
  const downstream = await waitDownstream(spec, request, sleep)
  await checkpoint({ stage: 'A_AFTER_ORIGINAL_RECOVERY', completed, after, detail, customs, planState, downstream })
  const operations = dataOf(await request('GET', `${path}/operations`, undefined, 'pda'))
  need(rows(operations).filter(row => row.actionType === 'COMPLETE_LOADING').length === 1, 'Recovered completion audit must be unique')
  return { kind: 'A', ...facts, ...downstream.facts, originalCommandId: original.commandId,
    oldOwnersAndDomesticInventoryUnchanged: true, wholeSkippedOwnerNotLoaded: true, completed: true }
}

export async function verifyRecoveredA(spec, original, before, request, checkpoint, sleep = ms => new Promise(done => setTimeout(done, ms))) {
  const path = `${PDA}/tasks/${spec.source.pdaTaskId}`
  const completed = dataOf(await request('GET', `${path}?warehouseId=${spec.source.warehouseId}`, undefined, 'pda'))
  need(completed.taskStatus === 'COMPLETED' && completed.workflowStatus === 'COMPLETED'
    && completed.completionCommand?.status === 'COMPLETED' && id(completed.completionCommand.id) === original.commandId
    && completed.completionCommand.operationId === original.body.operationId
    && Number(completed.completionCommand.expectedTaskVersion) === original.body.expectedTaskVersion, 'Same recovered original command must remain completed')
  verifyPhysicalFacts(spec.expected, completed)
  const after = await sourceSnapshot(spec, request); verifyOldOwnersUnchanged(before, after, spec.expected)
  const detail = dataOf(await request('GET', `${LEG}/loading-lists/${spec.source.loadingPlanId}?warehouseId=${spec.source.warehouseId}`))
  const customs = dataOf(await request('GET', `${CUSTOMS}/${spec.source.loadingPlanId}`))
  const plan = dataOf(await request('GET', `${LEG}/loading-plans/${spec.source.loadingPlanId}/lifecycle?warehouseId=${spec.source.warehouseId}`))
  const facts = verifyActual(spec.expected, detail, customs)
  need(plan.detailResource === 'LOADING_LIST' && plan.planStatus === 'COMPLETED', 'Completed original plan must remain completed')
  const downstream = await waitDownstream(spec, request, sleep)
  const operations = dataOf(await request('GET', `${path}/operations`, undefined, 'pda'))
  need(rows(operations).filter(row => row.actionType === 'COMPLETE_LOADING').length === 1, 'One original completion audit')
  await checkpoint({ stage: 'A_READONLY_VERIFIED_AFTER_ORIGINAL_RECOVERY', completed, after, detail, customs, plan, downstream, operations })
  return { kind: 'A', ...facts, ...downstream.facts, originalCommandId: original.commandId, readOnlyVerification: true,
    oldOwnersAndDomesticAllocationSnapshotsUnchanged: true, wholeSkippedOwnerNotLoaded: true, completed: true }
}

export function validateZeroWorkTask(source, task, ownUserId) {
  need(id(task.id) === source.pdaTaskId && id(task.loadingPlanId) === source.loadingPlanId
    && id(task.containerBookingId) === source.containerBookingId && task.currentContainerNo === source.containerNo
    && task.taskStatus === 'LOADING' && Number(task.version) === Number(source.beforeTaskVersion), 'Original task identity/version changed')
  need(task.workflowStatus === 'UNASSIGNED' && task.assignment == null
    || task.workflowStatus === 'IN_PROGRESS' && id(task.assignment?.assigneeId) === ownUserId,
    'Task must be unassigned or assigned to this own PDA session')
  need(rows(task.items).length > 0 && rows(task.items).every(item => item.itemStatus === 'PENDING'
    && Number(item.pickedPackageCount) === 0), 'Prepared task already has physical work')
}

export function validatePreparedResume(report) {
  need(report.runId === 'PARTIAL-ACTUAL-20261004-recovery-r3' && report.success === false && rows(report.cases).length === 0
    && report.recovery?.originalOwner?.inboundId === '2106706513799155714' && report.recovery?.originalSha256,
    'Only this original-source two-cabinet preparation may continue')
  need(!rows(report.requests).some(item => item.method === 'POST' && /\/pda-loading\/tasks\/\d+\/(claim|batch|complete|evidence)$/.test(item.path)),
    'Preparation continuation cannot repeat any PDA work')
  const prepared = rows(report.preparation).filter(item => item.stage === 'PDA_UNASSIGNED')
  need(prepared.length === 2 && prepared[0].kind === 'A' && prepared[1].kind === 'B'
    && prepared.every(item => item.source?.sourceMarker === `${report.runId}-${item.kind}` && item.spec?.kind === item.kind), 'Exactly the prepared A/B checkpoints required')
  return prepared
}

export function multipartBody(file) {
  if (file instanceof FormData) return file
  need(file?.content !== undefined, 'Multipart descriptor requires content bytes')
  const content = file.content instanceof Uint8Array ? file.content : new Uint8Array(file.content)
  const form = new FormData()
  form.append('file', new Blob([content], { type: file.type || 'application/octet-stream' }), file.name || 'fixture.bin')
  return form
}

export function requestInit(method, body, token, extraHeaders = {}) {
  const headers = new Headers({ Accept: 'application/json', ...extraHeaders })
  if (token) headers.set('Authorization', `Bearer ${token}`)
  if (body instanceof FormData) headers.delete('Content-Type') // fetch supplies the actual boundary
  else if (body !== undefined) headers.set('Content-Type', 'application/json')
  return { method, redirect: 'error', signal: AbortSignal.timeout(30_000), headers,
    body: body === undefined ? undefined : body instanceof FormData ? body : JSON.stringify(body) }
}

export function multipartAdapter(request, roleFor) {
  return (method, path, file, token, headers = {}) => request(method, path, multipartBody(file), roleFor(token), headers)
}

export function validateResumeProof(report, readback) {
  const owner = { tenantId: '2106706477225971713', orderId: '2106706495895306242', inboundId: '2106706513799155714',
    orderNo: 'FL2106706495895306242', inboundCode: 'NYEXX2610040025', marker: 'PARTIAL-ACTUAL-20261004-r1-A-REFUND' }
  need(report.runId === 'PARTIAL-ACTUAL-20261004-r1' && report.success === false && rows(report.cases).length === 0,
    'Only the explicitly authorized failed original run may resume')
  const rejected = rows(report.requests).filter(item => item.path === `/api/platform/v1/files/measurements/${owner.tenantId}/${owner.inboundId}`)
  need(rejected.length === 1 && rejected[0].http === 200 && rejected[0].code === 'S0500' && rejected[0].requestId, 'Original one rejected upload required')
  const summary = readback.inbound?.summary, measurement = readback.measurement
  need(readback.verified === true && readback.sessionClosed === true && id(summary?.id) === owner.inboundId
    && id(summary?.tenantId) === owner.tenantId && id(summary?.orderId) === owner.orderId && summary?.orderNo === owner.orderNo
    && summary?.inboundCode === owner.inboundCode && summary?.processStatus === 'WAIT_MEASURE'
    && measurement?.measurementStatus === 'DRAFT' && rows(measurement.weightResults).length === 0, 'Frozen readback must match original WAIT_MEASURE/DRAFT without weights')
  return owner
}

export function validateResumeLive(owner, frozen, inbound, measurement) {
  const summary = inbound?.summary
  need(id(summary?.id) === owner.inboundId && id(summary?.tenantId) === owner.tenantId && id(summary?.orderId) === owner.orderId
    && summary?.orderNo === owner.orderNo && summary?.inboundCode === owner.inboundCode
    && summary?.processStatus === 'WAIT_MEASURE' && measurement?.measurementStatus === frozen.measurement.measurementStatus
    && ['DRAFT', 'RECEIVED'].includes(measurement?.measurementStatus)
    && rows(measurement.weightResults).length === 0 && id(measurement.measurementId) === id(frozen.measurement.measurementId)
    && measurement.version === frozen.measurement.version && summary.version === frozen.inbound.summary.version,
    'Original sample changed; stop before any recovery write')
}

export async function resumeMeasurementDraft(context, owner, initial) {
  const root = `${LEG}/inbounds/${owner.inboundId}`, query = `tenantId=${owner.tenantId}`
  const ok = response => { need(response.http === 200 && String(response.body?.code) === '200', `Original measurement rejected ${response.path}`); return response.body.data }
  const bytes = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=', 'base64')
  const uploaded = ok(await context.requestMultipart('POST', `/api/platform/v1/files/measurements/${owner.tenantId}/${owner.inboundId}`,
    { content: bytes, type: 'image/png', name: `recovery-weight-${owner.inboundId}.png` }))
  need(uploaded.fileId, 'Original recovery upload did not return a file')
  const declarations = rows(initial.latestDeclaration?.items)
  need(declarations.length === 2 && declarations.map(item => Number(item.packageCount)).sort().join(',') === '1,3', 'Original two-SKU declaration must remain 3+1')
  // Save the two declared SKU identities separately. The generic single-SKU fixture
  // had aggregated all four boxes into the first detail; no carton scanning is repeated.
  const draft = ok(await context.request('PUT', `${root}/measurement/draft?${query}`, {
    measurementId: initial.measurementId, version: initial.version, actualGoodsName: '原样本两SKU恢复测量',
    items: declarations.map(item => ({ inboundDetailId: item.inboundDetailId, itemNo: String(item.itemNo),
      boxSpecification: item.cargoName, packageCount: Number(item.packageCount),
      lengthCm: Number(item.lengthCm), widthCm: Number(item.widthCm), heightCm: Number(item.heightCm),
      intelligentImageFileId: uploaded.fileId, coefficientMode: 'ACTUAL', remark: owner.marker })),
  }))
  const options = ok(await context.request('GET', `${root}/weight-pallet-options?${query}&page=1&size=20&keyword=YW-TP-002`))
  const pallet = rows(options.records).find(item => item.palletCode === 'YW-TP-002')
  need(pallet?.palletId, 'Original source warehouse needs the existing YW-TP-002 pallet')
  const weight = ok(await context.request('POST', `${root}/weight-results?${query}`, { fileId: id(uploaded.fileId),
    palletId: id(pallet.palletId), ocrProvider: 'ADMIN_ACCEPTANCE', ocrRawText: null, ocrWeightValue: null, ocrWeightUnit: null, confidence: null }))
  const confirmed = ok(await context.request('POST', `${root}/weight-results/${weight.id}/confirm?${query}`, {
    version: weight.version, adjustedWeightValue: 100, adjustedWeightUnit: 'KG', adjustmentReason: `${owner.marker} HTTP人工称重夹具` }))
  need(confirmed.recognitionStatus === 'CONFIRMED', 'Original source weight must be confirmed')
  const current = ok(await context.request('GET', `${root}/measurement?${query}`))
  need(id(current.measurementId) === id(draft.measurementId) && current.measurementStatus === 'DRAFT', 'Original draft identity retained')
  const submitted = ok(await context.request('POST', `${root}/measurement/submit?${query}`, { measurementId: current.measurementId, version: current.version }))
  need(submitted.processStatus === 'MEASURE_PENDING', 'Original draft must enter actual measurement review')
  const pending = ok(await context.request('GET', `/api/platform/inbounds/${owner.inboundId}?${query}`))
  ok(await context.request('POST', `/api/platform/v1/inbounds/${owner.inboundId}/measurements/approve?${query}`,
    { measurementId: current.measurementId, expectedVersion: pending.summary.version, reason: null }, context.token,
    { 'Idempotency-Key': `${owner.marker}-recovery-approve` }))
  let final
  for (let attempt = 0; attempt < 30; attempt++) {
    final = ok(await context.request('GET', `${root}/measurement?${query}`))
    if (final.processStatus === 'WAIT_SPLIT' && final.measurementStatus === 'APPROVED') break
    await new Promise(done => setTimeout(done, 1000))
  }
  need(final.processStatus === 'WAIT_SPLIT' && final.measurementStatus === 'APPROVED', 'Original recovery did not reach WAIT_SPLIT')
  need(rows(final.items).length === 2 && rows(final.items).every(item => declarations.some(declaration =>
    id(declaration.inboundDetailId) === id(item.inboundDetailId) && Number(declaration.packageCount) === Number(item.packageCount))), 'Original SKU measurements retain declaration identities and 3+1 counts')
  context.createdResources.inboundMeasurement = { marker: owner.marker, tenantId: owner.tenantId, inboundId: owner.inboundId,
    orderId: owner.orderId, inboundCode: owner.inboundCode, measurementId: id(final.measurementId),
    finalStatus: final.measurementStatus, processStatus: final.processStatus }
}

export function redact(value) {
  if (Array.isArray(value)) return value.map(redact)
  if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([key, child]) =>
    [key, /password|token|secret|authorization/i.test(key) ? '[REDACTED]' : redact(child)]))
  return value
}

// This is a bounded producer, not a run of the full acceptance module list.
// The three reused modules only create qualified customer + submitted/approved/measured order.
export async function prepareFreshCases(runId, context, savePrepared, resume = null) {
  const { run: qualification } = await import('./admin-test-env-modules/merchant-qualification-fixture.mjs')
  const { run: orders } = await import('./admin-test-env-modules/orders.mjs')
  const { run: measurement } = await import('./admin-test-env-modules/inbound-measurement.mjs')
  const { selectSessionPdaOperator } = await import('./admin-test-env-modules/domestic-pda-operator.mjs')
  const { publishPlatformLogisticsChannels, resolveOceanBookingAgent } = await import('./admin-test-env-modules/ocean-booking-fixture.mjs')
  const { ensureMatsonCarrierPartner } = await import('./admin-test-env-modules/carrier-partner-fixture.mjs')
  const { channelGroup } = await import('./admin-test-env-modules/smart-loading-channel-group.mjs')
  const { iso6346ContainerNumber } = await import('./admin-test-env-modules/iso6346-container-number.mjs')
  const ok = response => { need(response.http === 200 && String(response.body?.code) === '200', `Fresh fixture rejected ${response.path}`); return response.body.data }
  const produced = []
  for (const [kind, definitions] of [['A', [['REFUND', 'TAX_REFUND', [3,1]], ['BUY', 'BUY_DECLARATION', [1]], ['SKIP', 'TAX_REFUND', [1]]]],
    ['B', [['BUY', 'BUY_DECLARATION', [2]], ['SKIP', 'TAX_REFUND', [1]]]]]) {
    const owners = []
    for (const [role, taxMode, counts] of definitions) {
      context.marker = `${runId}-${kind}-${role}`
      context.context = { orderProfile: { taxMode, fulfillmentType: 'STANDARD' }, orderFulfillmentType: 'STANDARD',
        waitSplitVariant: { skuCount: counts.length, packageCounts: counts, packageCountPerSku: counts[0] } }
      context.createdResources = {}
      const originalRecovery = resume && kind === 'A' && role === 'REFUND'
      let originalMeasurement
      if (originalRecovery) {
        const original = resume.owner
        const inbound = ok(await context.request('GET', `/api/platform/inbounds/${original.inboundId}?tenantId=${original.tenantId}`))
        const measurementView = ok(await context.request('GET', `${LEG}/inbounds/${original.inboundId}/measurement?tenantId=${original.tenantId}`))
        validateResumeLive(original, resume.readback, inbound, measurementView)
        context.marker = original.marker
        context.createdResources.orders = { ...original, receivingWarehouseId: id(inbound.summary.warehouseId),
          fulfillmentType: 'STANDARD', taxMode: 'TAX_REFUND' }
        await savePrepared({ stage: 'ORIGINAL_RECOVERY_CHECKED', kind, role, ...original, measurementId: measurementView.measurementId,
          inboundVersion: inbound.summary.version, measurementVersion: measurementView.version })
        originalMeasurement = measurementView
      } else {
        await qualification(context, { publishEnvironment: false })
        await orders(context)
      }
      await savePrepared({ stage: 'APPROVED_ORDER', kind, role, tenantId: id(context.createdResources.orders?.tenantId),
        inboundId: id(context.createdResources.orders?.inboundId), orderId: id(context.createdResources.orders?.orderId) })
      if (originalRecovery) await resumeMeasurementDraft(context, resume.owner, originalMeasurement)
      else await measurement(context)
      const source = context.createdResources.inboundMeasurement
      need(source?.inboundId && source.processStatus === 'WAIT_SPLIT' && source.finalStatus === 'APPROVED', 'New legal measurement did not reach WAIT_SPLIT')
      owners.push({ role, taxMode, counts, tenantId: id(source.tenantId), inboundId: id(source.inboundId),
        orderId: id(source.orderId || context.createdResources.orders?.orderId), orderNo: context.createdResources.orders?.orderNo,
        inboundCode: source.inboundCode || context.createdResources.orders?.inboundCode })
      await savePrepared({ stage: 'WAIT_SPLIT', kind, owners: structuredClone(owners) })
    }
    context.marker = `${runId}-${kind}`
    const primary = owners[0]
    const inbound = ok(await context.request('GET', `/api/platform/inbounds/${primary.inboundId}?tenantId=${primary.tenantId}`))
    const warehouseId = id(inbound.summary.warehouseId), channelCode = inbound.summary.channelCode
    need(warehouseId && channelCode, 'Fresh source warehouse/channel missing')
    await publishPlatformLogisticsChannels(context, warehouseId, 'partial-loading-prepare')
    const agent = await resolveOceanBookingAgent(context, 'partial-loading-prepare', 'MATSON', { deploymentBlocker: true })
    const carrier = await ensureMatsonCarrierPartner(context, 'partial-loading-prepare', { deploymentBlocker: true })
    need(agent?.id && carrier?.id, 'Existing booking master data required')
    const container = ok(await context.request('POST', '/api/platform/v1/containers', {
      channelGroupCode: channelGroup(channelCode), warehouseId, containerType: '40HQ', capacityCbm: 68, maxWeightKg: 19500 }))
    const bookingId = id(container.id)
    let smartPlan = ok(await context.request('GET', `/api/platform/v1/first-leg/smart-loading/plans/by-booking/${bookingId}`))
    const planId = id(smartPlan.id)
    await savePrepared({ stage: 'EDITING', kind, owners, containerBookingId: bookingId, loadingPlanId: planId })
    const candidateResponse = ok(await context.request('GET', `/api/platform/v1/first-leg/smart-loading/candidates?bookingId=${bookingId}&warehouseId=${warehouseId}`))
    const candidates = rows(candidateResponse)
    for (const owner of owners) {
      const own = candidates.filter(item => id(item.inboundId) === owner.inboundId && id(item.accountId) === owner.tenantId)
        .sort((a,b) => id(a.inboundDetailId).localeCompare(id(b.inboundDetailId)))
      need(own.length === owner.counts.length, 'Fresh owner candidate SKU set mismatch')
      for (const candidate of own) {
        const packages = Number(candidate.availablePackageCount)
        need(owner.counts.includes(packages), 'Candidate count differs from fresh declared boxes')
        smartPlan = ok(await context.request('POST', `/api/platform/v1/first-leg/smart-loading/plans/${planId}/assignments`, {
          inboundId: owner.inboundId, inboundDetailId: id(candidate.inboundDetailId), packageCount: packages,
          expectedVersion: Number(smartPlan.version), operationId: `${context.marker}-assign-${candidate.inboundDetailId}` }))
      }
    }
    const booking = ok(await context.request('POST', '/api/platform/v1/ocean-bookings', { expectedVersion: 0, data: {
      channelCode: channelGroup(channelCode), warehouseId, billOfLadingNo: `BL-${context.marker}`,
      shippingCompanyId: id(carrier.id), shippingCompanyName: carrier.name, carrierCode: 'MATSON',
      bookingAgentId: id(agent.id), bookingAgentName: agent.name, vesselName: `测试船-${context.marker}`, voyageNo: 'PA-TEST',
      departurePortCode: 'CNSZX', departurePortName: '深圳', destinationPortCode: 'USLAX', destinationPortName: '洛杉矶', placeOfDelivery: 'LAX',
      estimatedSailingAt: '2026-10-05T08:00:00', estimatedArrivalAt: '2026-10-25T08:00:00', remark: context.marker,
      parties: ['SHIPPER','CONSIGNEE','NOTIFY_PARTY'].map(partyType => ({ partyType, partyName: `${context.marker}-${partyType}` })),
      containerRequirements: [{ containerType: '40HQ', containerKind: 'FCL', quantity: 1, capacityCbm: 68, maxWeightKg: 19500 }],
    } }, context.token, { 'Idempotency-Key': `${context.marker}-booking` }))
    const oceanId = id(booking.oceanBooking.id), form = new FormData()
    form.append('expectedVersion', String(booking.oceanBooking.version)); form.append('documentType', 'BOOKING_CONFIRMATION')
    form.append('file', new Blob([`${context.marker} controlled TEST booking confirmation`], { type: 'text/plain' }), `${context.marker}-booking.txt`)
    const document = ok(await context.requestMultipart('POST', `/api/platform/v1/ocean-bookings/${oceanId}/documents/upload`, form,
      context.token, { 'Idempotency-Key': `${context.marker}-booking-file` }))
    const released = ok(await context.request('POST', `/api/platform/v1/ocean-bookings/${oceanId}/release`,
      { expectedVersion: Number(document.bookingVersion), reason: context.marker }, context.token, { 'Idempotency-Key': `${context.marker}-release` }))
    need(released.oceanBooking.status === 'RELEASED', 'New booking release required')
    const currentContainer = ok(await context.request('GET', `/api/platform/v1/containers/domestic/${bookingId}`)).container
    const containerNo = iso6346ContainerNumber(context.marker)
    ok(await context.request('POST', `/api/platform/v1/containers/${bookingId}/ocean-booking-link`, {
      oceanBookingId: oceanId, requirementId: id(released.containerRequirements[0].id), containerNo, expectedVersion: currentContainer.version }))
    const preload = ok(await context.request('GET', `${LEG}/loading-plans/${planId}?warehouseId=${warehouseId}`))
    const operator = selectSessionPdaOperator(ok(await context.request('GET', `/api/platform/v1/iam/users/domestic-pda-operators?warehouseId=${warehouseId}`)), context.pdaToken)
    const confirmation = ok(await context.request('POST', `${LEG}/loading-plans/${planId}/confirm`,
      { expectedVersion: Number(preload.summary.version), assigneeId: id(operator.userId) }, context.token, { 'Idempotency-Key': `${context.marker}-confirm` }))
    const taskId = id(confirmation.readiness.pdaTaskId)
    const task = ok(await context.request('GET', `${PDA}/tasks/${taskId}?warehouseId=${warehouseId}`, undefined, context.pdaToken))
    const source = { schemaVersion: 1, sourceMarker: context.marker, preparedAt: new Date().toISOString(), stage: 'MANUAL_PDA_CLAIM_AND_BATCH_READY',
      pdaTaskId: taskId, loadingPlanId: planId, containerBookingId: bookingId, warehouseId, containerNo,
      cabinetNo: container.cabinetNo, oceanBookingId: oceanId, bookingNo: released.oceanBooking.bookingNo, planNo: smartPlan.planNo,
      beforeTaskVersion: task.version, taskItems: task.items.map(item => ({ id: id(item.id), loadingPlanItemId: id(item.loadingPlanItemId),
        tenantId: id(item.tenantId), inboundId: id(item.inboundId), inboundDetailId: id(item.inboundDetailId), plannedPackageCount: item.plannedPackageCount })) }
    const actions = task.items.map(item => {
      const owner = owners.find(owner => owner.inboundId === id(item.inboundId))
      need(owner, 'Task includes only fresh produced owners')
      const partial = owner === primary && Number(item.plannedPackageCount) === (kind === 'A' ? 3 : 2)
      return { itemId: id(item.id), action: partial ? 'PARTIAL' : owner.role === 'BUY' ? 'PICK' : 'SKIP',
        ...(partial ? { finalPickedPackageCount: kind === 'A' ? 2 : 1 } : {}) }
    })
    const spec = { kind, actions, sealNo: `SEAL-${context.marker}` }
    const freshPreload = ok(await context.request('GET', `${LEG}/loading-plans/${planId}?warehouseId=${warehouseId}`))
    expectedRows(spec, task, freshPreload)
    produced.push({ spec, source, owners })
    await savePrepared({ stage: 'PDA_UNASSIGNED', kind, source, owners, spec })
  }
  return produced
}

export function validateManifest(manifest, runId) {
  need(manifest?.schemaVersion === 1 && manifest.environment === 'TEST' && manifest.runId === runId, 'Fixture run/environment mismatch')
  need(rows(manifest.cases).length === 2 && manifest.cases[0].kind === 'A' && manifest.cases[1].kind === 'B', 'Exactly A then B required')
  for (const item of manifest.cases) {
    need(typeof item.sourceReport === 'string' && item.sourceReport.length > 0, 'New official fixture source report required')
    need(rows(item.actions).length >= 2 && new Set(item.actions.map(row => row.itemId)).size === item.actions.length, 'Every PDA item needs one unique action')
    for (const action of item.actions) need(positive(action.itemId) && ['PICK', 'PARTIAL', 'SKIP'].includes(action.action)
      && (action.action !== 'PARTIAL' || Number.isSafeInteger(action.finalPickedPackageCount) && action.finalPickedPackageCount > 0), 'Invalid PDA action')
    need(typeof item.sealNo === 'string' && item.sealNo.trim().length > 0 && item.sealNo.length <= 64, 'Seal required')
    need(TYPES.every(type => typeof item.evidence?.[type] === 'string' && item.evidence[type]), 'Five supplied evidence paths required')
  }
  return manifest
}

export function fixtureSource(report, runId, gateway, now = Date.now()) {
  const value = report?.createdResources?.manualPdaBatchFixture
  need(report.success === true && report.fatal == null && report.summary?.failed === 0
    && report.gateway?.replace(/\/$/, '') === gateway, 'Official fixture report did not pass in this TEST Gateway')
  need(value?.schemaVersion === 1 && value.stage === 'MANUAL_PDA_CLAIM_AND_BATCH_READY'
    && typeof value.sourceMarker === 'string' && value.sourceMarker.startsWith(`${runId}-`)
    && /^[A-Za-z0-9_-]{1,80}$/.test(value.sourceMarker), 'Fresh run-bound PDA preparation required')
  const age = now - Date.parse(value.preparedAt)
  need(Number.isFinite(age) && age >= 0 && age <= 24 * 3600_000, 'Fixture must be prepared within this run/day')
  for (const key of ['pdaTaskId', 'loadingPlanId', 'containerBookingId', 'warehouseId']) need(positive(value[key]), `Invalid source ${key}`)
  need(rows(value.taskItems).length > 0, 'Missing original PDA identities')
  return value
}

// Decimal arithmetic is exact; no binary floating point at HALF_UP boundaries.
export function scale(value, actual, planned, precision) {
  if (value == null) return null
  const text = String(value)
  need(/^\d+(?:\.\d+)?$/.test(text) && Number.isSafeInteger(actual) && actual > 0
    && Number.isSafeInteger(planned) && planned >= actual, 'Invalid nonnegative frozen decimal/ratio')
  const [whole, fraction = ''] = text.split('.')
  const numerator = BigInt(whole + fraction) * BigInt(actual) * 10n ** BigInt(precision)
  const denominator = BigInt(planned) * 10n ** BigInt(fraction.length)
  const rounded = (2n * numerator + denominator) / (2n * denominator)
  const padded = rounded.toString().padStart(precision + 1, '0')
  return precision ? `${padded.slice(0, -precision)}.${padded.slice(-precision)}` : padded
}

export function expectedRows(caseSpec, task, preload) {
  const byId = new Map(rows(task.items).map(item => [id(item.id), item]))
  need(byId.size === task.items.length && byId.size === caseSpec.actions.length
    && caseSpec.actions.every(item => byId.has(item.itemId)), 'Actions must cover every live PDA item exactly once')
  const planById = new Map(rows(preload.items).map(item => [id(item.itemId), item]))
  need(planById.size === byId.size, 'Preload and PDA scope mismatch')
  const expected = caseSpec.actions.map(action => {
    const pick = byId.get(action.itemId), frozen = planById.get(id(pick.loadingPlanItemId))
    need(frozen && id(frozen.accountId) === id(pick.tenantId) && id(frozen.inboundId) === id(pick.inboundId)
      && id(frozen.inboundDetailId) === id(pick.inboundDetailId), 'Frozen source/customer/detail identity mismatch')
    const planned = Number(pick.plannedPackageCount)
    need(pick.itemStatus === 'PENDING' && Number(pick.pickedPackageCount) === 0 && pick.unitType === 'PACKAGE'
      && !pick.palletId && planned > 0 && Number(frozen.packageCount) === planned, 'Require zero-picked PACKAGE sources')
    const actual = action.action === 'SKIP' ? 0 : action.action === 'PICK' ? planned : action.finalPickedPackageCount
    need(action.action !== 'PARTIAL' || actual < planned, 'PARTIAL must be less than original plan')
    return { action: action.action, pickId: action.itemId, itemId: id(frozen.itemId), accountId: id(frozen.accountId),
      inboundId: id(frozen.inboundId), inboundDetailId: id(frozen.inboundDetailId), taxMode: frozen.customsTaxMode,
      planned, actual, frozen, orderId: id(frozen.orderId) }
  })
  const partial = expected.filter(item => item.action === 'PARTIAL'), full = expected.filter(item => item.action === 'PICK')
  const skipped = expected.filter(item => item.action === 'SKIP'), active = expected.filter(item => item.actual > 0)
  need(expected.every(item => ['TAX_REFUND', 'BUY_DECLARATION'].includes(item.taxMode)), 'Authoritative tax mode required')
  if (caseSpec.kind === 'A') {
    need(partial.length === 1 && partial[0].taxMode === 'TAX_REFUND' && partial[0].planned === 3 && partial[0].actual === 2
      && full.length === 1 && full[0].taxMode === 'BUY_DECLARATION' && full[0].accountId !== partial[0].accountId
      && skipped.some(item => item.inboundId === partial[0].inboundId)
      && skipped.some(item => item.taxMode === 'TAX_REFUND' && !active.some(row => row.accountId === item.accountId)), 'A needs mixed customers, partial refund, same-source skip and entirely skipped refund customer')
  } else {
    need(active.length === 1 && partial.length === 1 && full.length === 0
      && partial[0].taxMode === 'BUY_DECLARATION' && partial[0].planned === 2 && partial[0].actual === 1
      && skipped.length > 0 && skipped.every(item => item.taxMode === 'TAX_REFUND'), 'B must have exactly one actual BUY PARTIAL row and only skipped refund rows')
  }
  return expected
}

export function verifyActual(expected, detail, customs) {
  const active = expected.filter(item => item.actual > 0)
  assert.deepEqual(rows(detail.items).map(item => id(item.itemId)).sort(), active.map(item => item.itemId).sort(), 'Actual loading row set')
  for (const item of active) {
    const actual = detail.items.find(row => id(row.itemId) === item.itemId), frozen = item.frozen
    assert.equal(Number(actual.packageCount), item.actual, 'Actual boxes')
    assert.equal(id(actual.accountId), item.accountId, 'Actual customer')
    assert.equal(id(actual.inboundId), item.inboundId, 'Actual source')
    const units = Number(frozen.unitsPerPackage)
    const quantity = item.actual === item.planned ? Number(frozen.productQuantity)
      : units > 0 ? units * item.actual : Number(scale(frozen.productQuantity, item.actual, item.planned, 0))
    assert.equal(Number(actual.productQuantity), quantity, 'Actual units')
    for (const [field, precision] of [['grossWeightKg', 3], ['netWeightKg', 3], ['dimensionalWeightKg', 3], ['volumeCbm', 4]])
      assert.equal(scale(actual[field], 1, 1, precision), scale(frozen[field], item.actual, item.planned, precision), `Actual ${field}`)
  }
  const boxes = active.reduce((sum, item) => sum + item.actual, 0)
  assert.equal(Number(detail.summary.totalPackageCount), boxes, 'Actual total boxes')
  assert.equal(Number(customs.actualBoxCount), boxes, 'Customs actual boxes')
  const inboundKeys = values => [...new Set(values.map(item => `${id(item.tenantId ?? item.accountId)}:${id(item.inboundId)}`))].sort()
  assert.deepEqual(inboundKeys(rows(customs.inbounds)), inboundKeys(active), 'Customs source/customer set')
  assert.equal(Number(customs.taxRefundCount), new Set(active.filter(item => item.taxMode === 'TAX_REFUND').map(item => item.inboundId)).size, 'Refund coverage excludes skipped rows')
  assert.equal(Number(detail.summary.totalQuantity), detail.items.reduce((sum, item) => sum + Number(item.productQuantity), 0), 'Quantity total')
  for (const [field, summary, precision] of [['grossWeightKg', 'totalGrossWeightKg', 3], ['netWeightKg', 'totalNetWeightKg', 3], ['volumeCbm', 'totalVolumeCbm', 4]]) {
    const sum = detail.items.reduce((value, item) => value + BigInt(scale(item[field] ?? 0, 1, 1, precision).replace('.', '')), 0n)
    assert.equal(BigInt(scale(detail.summary[summary] ?? 0, 1, 1, precision).replace('.', '')), sum, `Actual ${summary}`)
  }
  return { actualBoxes: boxes, actualRows: active.length, taxRefundCount: Number(customs.taxRefundCount) }
}

export async function runCase(spec, source, prepared, request, sleep = ms => new Promise(done => setTimeout(done, ms))) {
  const { expected, task, images } = prepared
  const path = `${PDA}/tasks/${source.pdaTaskId}`, key = suffix => `${source.sourceMarker}-${suffix}`.slice(0, 128)
  const data = response => { need(response.http === 200 && String(response.body?.code) === '200', `API rejected ${response.path}: HTTP=${response.http}, code=${response.body?.code ?? 'missing'}`); return response.body.data }
  const readTask = async () => data(await request('GET', `${path}?warehouseId=${source.warehouseId}`, undefined, 'pda'))
  const claimed = data(await request('POST', `${path}/claim`, { expectedAssignmentVersion: Number(task.assignment?.version ?? 0), operationId: key('claim') }, 'pda'))
  need(claimed.workflowStatus === 'IN_PROGRESS', 'Claim must enter IN_PROGRESS')
  let picked
  // Batch must contain every still-pending row, and forbids SKIP + physical picks
  // for one owner in the same command. Resolve that owner's zero-picked SKU through
  // the formal individual SKIP first; then one atomic batch handles all remaining rows.
  const individualSkips = expected.filter(item => item.action === 'SKIP'
    && expected.some(other => other.inboundId === item.inboundId && other.actual > 0))
  for (const item of individualSkips) {
    const current = await readTask(), row = current.items.find(row => id(row.id) === item.pickId)
    data(await request('POST', `${path}/items/${item.pickId}/skip`, { warehouseId: source.warehouseId,
      version: Number(row.version), operationId: key(`skip-${item.pickId}`), reason: source.sourceMarker }, 'pda'))
  }
  const lines = expected.filter(item => !individualSkips.some(skip => skip.pickId === item.pickId))
  {
    const current = await readTask()
    const inventory = data(await request('GET', `${path}/inventory-snapshot?warehouseId=${source.warehouseId}`, undefined, 'pda'))
    const batch = { warehouseId: source.warehouseId, loadingPlanId: source.loadingPlanId, containerBookingId: source.containerBookingId,
      expectedVersion: Number(current.version), inventorySnapshotToken: inventory.snapshotToken,
      items: lines.map(item => ({ itemId: item.pickId, action: item.action,
        version: Number(current.items.find(row => id(row.id) === item.pickId)?.version),
        ...(item.action === 'PARTIAL' ? { finalPickedPackageCount: item.actual } : item.action === 'PICK' ? { pickedPackageCount: item.actual } : { reason: source.sourceMarker }) })) }
    need(inventory.snapshotToken && batch.items.every(item => Number.isSafeInteger(item.version)), 'Fresh inventory and item versions required')
    picked = data(await request('POST', `${path}/batch`, batch, 'pda', { 'Idempotency-Key': key('resolved-batch') }))
  }
  need(picked.workflowStatus === 'AWAITING_REVIEW' && expected.every(item => {
    const row = rows(picked.items).find(row => id(row.id) === item.pickId)
    return row && Number(row.pickedPackageCount) === item.actual && row.itemStatus === ({ PICK: 'PICKED', PARTIAL: 'PARTIAL', SKIP: 'SKIPPED' })[item.action]
  }), 'Resolved picks and all-PARTIAL B must be persisted before completion')
  for (const type of TYPES) {
    const image = images[type], form = new FormData()
    for (const [name, value] of Object.entries({ warehouseId: source.warehouseId, expectedVersion: 0, evidenceType: type,
      remark: source.sourceMarker, ...(type === 'SEAL' ? { sealNo: spec.sealNo } : {}) })) form.append(name, String(value))
    form.append('file', new Blob([image.bytes], { type: image.type }), `${source.sourceMarker}-${type}.${image.type === 'image/png' ? 'png' : 'jpg'}`)
    data(await request('POST', `${path}/evidence`, form, 'pda', { 'Idempotency-Key': key(`evidence-${type}`) }))
  }
  const evidence = data(await request('GET', `${path}/evidence?warehouseId=${source.warehouseId}`, undefined, 'pda'))
  need(TYPES.every(type => rows(evidence.evidences).some(item => item.evidenceType === type && item.status === 'ACTIVE'
    && (type !== 'SEAL' || item.sealNo === spec.sealNo))), 'Five active evidence types and seal required')
  const ready = await readTask(), body = { expectedTaskVersion: Number(ready.version), operationId: key('complete'), remark: source.sourceMarker }
  data(await request('POST', `${path}/complete`, body, 'pda'))
  let completed
  for (let attempt = 0; attempt < 60; attempt++) {
    completed = await readTask()
    if (completed.taskStatus === 'COMPLETED' && completed.workflowStatus === 'COMPLETED') break
    need(completed.taskStatus === 'COMPLETING', `Completion stopped: task=${completed.taskStatus}, command=${completed.completionCommand?.status ?? 'missing'}, stage=${completed.completionCommand?.failureStage ?? 'missing'}, code=${completed.completionCommand?.failureCode ?? 'missing'}`)
    await sleep(1000)
  }
  need(completed.taskStatus === 'COMPLETED' && completed.workflowStatus === 'COMPLETED', 'Completion polling exhausted')
  const snapshot = async () => ({ task: await readTask(),
    detail: data(await request('GET', `${LEG}/loading-lists/${source.loadingPlanId}?warehouseId=${source.warehouseId}`)),
    customs: data(await request('GET', `${CUSTOMS}/${source.loadingPlanId}`)),
    operations: data(await request('GET', `${path}/operations`, undefined, 'pda')) })
  const before = await snapshot(), facts = verifyActual(expected, before.detail, before.customs)
  need(rows(before.operations).filter(item => item.actionType === 'COMPLETE_LOADING').length === 1, 'One COMPLETE_LOADING audit required')
  data(await request('POST', `${path}/complete`, body, 'pda')) // original key, version and body
  const after = await snapshot()
  assert.equal(stableSnapshot(after), stableSnapshot(before), 'Exact completion replay has zero projection/version/history drift')
  if (spec.kind === 'B') {
    need(before.customs.taxRefundCount === 0 && before.customs.status === 'READY_TO_START', 'Actual all-buy readiness')
    const start = data(await request('POST', `${CUSTOMS}/${source.loadingPlanId}/start`,
      { expectedVersion: before.customs.version, confirm: true, remark: source.sourceMarker }, 'admin', { 'Idempotency-Key': key('customs-start') }))
    need(start.status === 'DECLARING', 'All-buy start')
    const reject = await request('POST', `${CUSTOMS}/${source.loadingPlanId}/send-to-broker`,
      { expectedVersion: start.version, confirm: true, remark: source.sourceMarker }, 'admin', { 'Idempotency-Key': key('refund-send-negative') })
    need(reject.http === 200 && String(reject.body?.code) === 'A0409', 'All-buy must reject refund send')
    const unchanged = data(await request('GET', `${CUSTOMS}/${source.loadingPlanId}`))
    assert.equal(stableSnapshot(unchanged), stableSnapshot(start), 'Rejected refund send leaves customs unchanged')
    const result = data(await request('POST', `${CUSTOMS}/${source.loadingPlanId}/complete-all-buy`,
      { expectedVersion: unchanged.version, confirm: true, remark: source.sourceMarker }, 'admin', { 'Idempotency-Key': key('customs-complete') }))
    need(result.status === 'COMPLETED', 'All-buy completion')
  }
  return { kind: spec.kind, ...facts, source, actions: spec.actions, allActualRowsPartial: expected.filter(item => item.actual > 0).every(item => item.action === 'PARTIAL'),
    completed: true, completionReplayZeroDrift: true }
}

export async function execute(args = process.argv.slice(2), execArgs = process.execArgv, env = process.env) {
  const options = executionOptions(args, execArgs, env)
  if (!options.execute) return plan()
  const directory = resolve(ROOT, 'reports', `partial-loading-actual-${options.runId}`)
  const bOnlyMode = typeof options.fixture === 'object' && options.fixture.bOnlyReport
  const verifyAMode = typeof options.fixture === 'object' && options.fixture.verifyAReport
  const completionMode = typeof options.fixture === 'object' && (options.fixture.completionReport || options.fixture.verifyAReport)
  const preparedMode = typeof options.fixture === 'object' && options.fixture.preparedReport
  const resumeMode = typeof options.fixture === 'object' && options.fixture.resumeReport
  const fresh = options.fixture === 'NEW' || resumeMode
  let resume
  if (resumeMode) {
    const originalBytes = await readFile(options.fixture.resumeReport)
    const readbackPath = resolve(dirname(options.fixture.resumeReport), 'blocked-readback.json')
    const readbackBytes = await readFile(readbackPath), readback = JSON.parse(readbackBytes)
    const original = JSON.parse(originalBytes)
    resume = { owner: validateResumeProof(original, readback), readback,
      originalReport: options.fixture.resumeReport, originalSha256: sha(originalBytes), readbackSha256: sha(readbackBytes) }
    const attemptedPath = resolve(ROOT, 'reports/partial-loading-actual-PARTIAL-ACTUAL-20261004-recovery-r1/report.json')
    let attemptedBytes
    try { attemptedBytes = await readFile(attemptedPath) } catch (error) { if (error.code !== 'ENOENT') throw error }
    if (attemptedBytes) {
      const attempted = JSON.parse(attemptedBytes)
      const mutations = rows(attempted.requests).filter(item => item.method !== 'GET' && !item.path.startsWith('/api/auth/') && !item.path.includes('carton-label-pdf'))
      need(attempted.success === false && attempted.recovery?.originalSha256 === resume.originalSha256
        && mutations.length === 1 && mutations[0].path === `${LEG}/inbounds/${resume.owner.inboundId}/measurement/carton-scans?tenantId=${resume.owner.tenantId}`
        && mutations[0].http === 200 && mutations[0].code === '200' && mutations[0].response.data.created === false
        && mutations[0].response.data.measurementVersion === readback.measurement.version + 1,
        'Prior recovery must prove its sole accepted original re-scan; no blind retry')
      resume.readback = structuredClone(readback)
      resume.readback.measurement.version = mutations[0].response.data.measurementVersion
      resume.readback.measurement.measurementStatus = 'RECEIVED' // the proven scan changed this draft into RECEIVED
      resume.priorRecovery = { report: attemptedPath, sha256: sha(attemptedBytes),
        knownOriginalRescanRequestId: mutations[0].requestId, expectedMeasurementVersion: resume.readback.measurement.version,
        expectedMeasurementStatus: 'RECEIVED' }
    }
  }
  const manifestBytes = bOnlyMode ? await readFile(options.fixture.bOnlyReport) : completionMode ? await readFile(options.fixture.completionReport || options.fixture.verifyAReport) : preparedMode ? await readFile(options.fixture.preparedReport) : fresh ? Buffer.from(resumeMode ? 'RESUME' : 'NEW') : await readFile(options.fixture)
  const manifest = fresh || preparedMode || completionMode || bOnlyMode ? null : validateManifest(JSON.parse(manifestBytes), options.runId)
  const sources = [], specs = []
  let original
  let originalBefore
  let aEventProof
  if (bOnlyMode) {
    const eventProofBytes = await readFile(resolve(ROOT, 'reports/partial-A-completion-event-proof-20261004-r1.json'))
    const eventProof = JSON.parse(eventProofBytes)
    need(eventProof.readOnly === true && eventProof.verified === true && Object.values(eventProof.checks).every(value => value === true)
      && rows(eventProof.rows).length === 2 && rows(eventProof.rows).every(row => row.status === 'PROCESSED' && row.eventVersion === 3),
      'Controller exact A Outbox/ACK/Inbox proof required before B')
    aEventProof = { report: 'reports/partial-A-completion-event-proof-20261004-r1.json', sha256: sha(eventProofBytes), checks: eventProof.checks, events: eventProof.rows }
    let evidence = JSON.parse(manifestBytes)
    need(evidence.success === true && evidence.cases?.length === 1 && evidence.cases[0].kind === 'A'
      && evidence.cases[0].originalCommandId === '2106716718935052290' && evidence.cases[0].actualPackages === 3
      && evidence.cases[0].oldOwnersAndDomesticAllocationSnapshotsUnchanged === true && evidence.cases[0].wholeSkippedOwnerNotLoaded === true,
      'B requires the verified original A recovery first')
    for (let index = 0; index < 2; index++) {
      const parent = await readFile(evidence.completionRecovery.originalReport)
      need(sha(parent) === evidence.completionRecovery.originalSha256, 'A evidence chain SHA changed')
      evidence = JSON.parse(parent)
    }
    originalCompletionCommand(evidence)
    const preparationBytes = await readFile(evidence.preparedRecovery.report)
    need(sha(preparationBytes) === evidence.preparedRecovery.sha256, 'Original prepared B SHA changed')
    const preparation = JSON.parse(preparationBytes), checkpoint = validatePreparedResume(preparation)[1]
    const taskPath = `${PDA}/tasks/${checkpoint.source.pdaTaskId}?warehouseId=${checkpoint.source.warehouseId}`
    const preloadPath = `${LEG}/loading-plans/${checkpoint.source.loadingPlanId}?warehouseId=${checkpoint.source.warehouseId}`
    const initialTask = rows(preparation.requests).filter(row => row.path === taskPath && row.method === 'GET').at(-1).response.data
    const initialPreload = rows(preparation.requests).filter(row => row.path === preloadPath && row.method === 'GET').at(-1).response.data
    const bytes = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=', 'base64')
    specs.push({ ...checkpoint, expected: expectedRows(checkpoint.spec, initialTask, initialPreload),
      images: Object.fromEntries(TYPES.map(type => [type, { bytes, type: 'image/png', sha256: sha(bytes) }])) }); sources.push(checkpoint.source)
  }
  if (completionMode) {
    let failed = JSON.parse(manifestBytes)
    if (verifyAMode) {
      originalBefore = rows(failed.checkpoints).find(row => row.stage === 'A_BEFORE_ORIGINAL_RECOVERY')?.before
      need(originalBefore && failed.completionRecovery?.originalReport, 'Original recovery before snapshot required')
      const originalBytes = await readFile(failed.completionRecovery.originalReport)
      need(sha(originalBytes) === failed.completionRecovery.originalSha256, 'Original failed report SHA changed')
      failed = JSON.parse(originalBytes)
    }
    original = originalCompletionCommand(failed)
    const preparationBytes = await readFile(failed.preparedRecovery.report)
    need(sha(preparationBytes) === failed.preparedRecovery.sha256, 'Original preparation report SHA changed')
    const preparation = JSON.parse(preparationBytes)
    for (const checkpoint of validatePreparedResume(preparation)) {
      const taskPath = `${PDA}/tasks/${checkpoint.source.pdaTaskId}?warehouseId=${checkpoint.source.warehouseId}`
      const preloadPath = `${LEG}/loading-plans/${checkpoint.source.loadingPlanId}?warehouseId=${checkpoint.source.warehouseId}`
      const initialTask = rows(preparation.requests).filter(row => row.path === taskPath && row.method === 'GET').at(-1)?.response?.data
      const initialPreload = rows(preparation.requests).filter(row => row.path === preloadPath && row.method === 'GET').at(-1)?.response?.data
      specs.push({ ...checkpoint, expected: expectedRows(checkpoint.spec, initialTask, initialPreload) }); sources.push(checkpoint.source)
    }
  }
  if (preparedMode) {
    const bytes = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=', 'base64')
    for (const checkpoint of validatePreparedResume(JSON.parse(manifestBytes))) {
      specs.push({ ...checkpoint, images: Object.fromEntries(TYPES.map(type => [type, { bytes, type: 'image/png', sha256: sha(bytes) }])) })
      sources.push(checkpoint.source)
    }
  }
  for (const spec of manifest?.cases || []) {
    const sourceBytes = await readFile(resolve(dirname(options.fixture), spec.sourceReport))
    const source = fixtureSource(JSON.parse(sourceBytes), options.runId, options.gateway)
    const images = {}
    for (const type of TYPES) {
      const bytes = await readFile(resolve(dirname(options.fixture), spec.evidence[type]))
      const png = bytes.subarray(0, 8).equals(Buffer.from([137,80,78,71,13,10,26,10]))
      const jpeg = bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255
      need(bytes.length > 16 && bytes.length <= 20 * 1024 * 1024 && (png || jpeg), 'Evidence must be supplied bounded PNG/JPEG bytes')
      images[type] = { bytes, type: png ? 'image/png' : 'image/jpeg', sha256: sha(bytes) }
    }
    sources.push(source); specs.push({ spec, source, sourceSha256: sha(sourceBytes), images })
  }
  if (!fresh && !bOnlyMode) {
    for (const key of ['pdaTaskId', 'loadingPlanId', 'containerBookingId']) need(new Set(sources.map(value => value[key])).size === 2, 'Two independent new cabinet identities required')
    need(!sources[0].taskItems.some(a => sources[1].taskItems.some(b => id(a.inboundId) === id(b.inboundId))), 'Cases cannot share source inbound resources')
  }
  await mkdir(directory) // exclusive; never overwrite evidence or silently rerun business writes
  const report = { success: false, runId: options.runId, startedAt: new Date().toISOString(), manifestSha256: sha(manifestBytes), requests: [], cases: [], sessions: {},
    ...(bOnlyMode ? { BContinuation: { verifiedAReport: options.fixture.bOnlyReport, verifiedASha256: sha(manifestBytes), readyCommit: options.readyCommit, aEventProof }, syntheticHttpEvidence: true } : {}),
    ...(completionMode ? { completionRecovery: { originalReport: options.fixture.completionReport || options.fixture.verifyAReport, originalSha256: sha(manifestBytes), original, readyCommit: options.readyCommit, BDeferred: true, readOnly: Boolean(verifyAMode) } } : {}),
    ...(preparedMode ? { preparedRecovery: { report: options.fixture.preparedReport, sha256: sha(manifestBytes) }, syntheticHttpEvidence: true } : {}),
    ...(resume ? { recovery: { originalReport: resume.originalReport, originalSha256: resume.originalSha256,
      readbackSha256: resume.readbackSha256, originalOwner: resume.owner, originalCreationSkipped: true, priorRecovery: resume.priorRecovery } } : {}),
    scope: completionMode ? ['direct Outbox/ACK audit', 'raw Warehouse SQL audit', 'browser/device acceptance', 'B deferred in this dispatch'] : plan().excluded,
    fixtures: specs.map(({ spec, source, sourceSha256, images }) => ({ kind: spec.kind, source, sourceSha256,
      ...(images ? { imageHashes: Object.fromEntries(TYPES.map(type => [type, images[type].sha256])) } : {}) })) }
  const sessions = {}, save = () => writeFile(resolve(directory, 'report.json'), JSON.stringify(redact(report), null, 2))
  const nativeFetch = globalThis.fetch
  let requestQueue = Promise.resolve(), transportUnknown = false
  const serialFetch = (url, init) => {
    const pending = requestQueue.then(() => { need(!transportUnknown || init.method === 'GET' || new URL(url).pathname === '/api/auth/logout', 'Earlier unknown transport result; stop new commands and preserve samples'); return nativeFetch(url, init) })
    requestQueue = pending.then(() => {}, () => { transportUnknown = true })
    return pending
  }
  const recordSession = (payload, role) => {
    if (payload?.data?.accessToken) {
      const already = Object.entries(sessions).find(([, value]) => value.token === payload.data.accessToken)
      const name = already?.[0] || (role === 'admin' || role === 'pda' ? role : `customer-${Object.keys(sessions).length}`)
      sessions[name] = { token: payload.data.accessToken, refresh: payload.data.refreshToken }
    }
  }
  async function request(method, path, body, role = 'admin', headers = {}) {
    need(!verifyAMode || method === 'GET' || ['/api/auth/login','/api/auth/logout'].includes(path), 'A post-recovery verification is read-only')
    const auth = path.startsWith('/api/auth/')
    const entry = { method, path, role, intendedAt: new Date().toISOString(), state: 'PENDING',
      ...(auth ? {} : body instanceof FormData ? { multipart: true } : body === undefined ? {} : { request: body }),
      idempotencyKey: headers['Idempotency-Key'] }
    if (body instanceof FormData) {
      entry.multipartParts = []
      for (const [name, value] of body.entries()) entry.multipartParts.push(typeof value === 'string' ? { name, value }
        : { name, fileName: value.name, size: value.size, type: value.type, sha256: sha(new Uint8Array(await value.arrayBuffer())) })
    }
    report.requests.push(entry); await save()
    try {
      const response = await serialFetch(options.gateway + path, requestInit(method, body, sessions[role]?.token, headers))
      const payload = await response.json()
      if (path === '/api/auth/login') recordSession(payload, role)
      Object.assign(entry, { state: 'RECEIVED', http: response.status, code: payload.code, requestId: payload.requestId, traceId: payload.traceId,
        ...(auth ? {} : { response: payload }) }); await save()
      return { method, path, http: response.status, body: payload, requestId: payload.requestId, traceId: payload.traceId }
    } catch { entry.state = 'UNKNOWN'; await save(); throw new CheckFailure(`Transport/response failed: ${method} ${path}; preserve original request, do not auto-retry`) }
  }
  try {
    for (const [role, username, password] of [['admin', env.CHONGCHONG_ADMIN_USERNAME, env.CHONGCHONG_ADMIN_PASSWORD], ['pda', env.ADMIN_PDA_USERNAME, env.ADMIN_PDA_PASSWORD]]) {
      const response = await request('POST', '/api/auth/login', { loginId: username, password }, role)
      const data = response.body?.data
      if (data?.accessToken) sessions[role] = { token: data.accessToken, refresh: data.refreshToken }
      need(response.http === 200 && String(response.body?.code) === '200' && data?.accessToken && data?.refreshToken, 'Incomplete own login session')
      report.sessions[role] = { loggedIn: true, closed: false }
    }
    if (fresh) {
      // Reused producers have a few raw binary/multipart fetches. Instrument them too,
      // serialize through the same queue, persist intent first, and never expose credentials.
      globalThis.fetch = async (url, init = {}) => {
        const parsed = new URL(url); need(parsed.origin === options.gateway, 'Producer network must stay in TEST Gateway')
        const entry = { method: init.method || 'GET', path: parsed.pathname + parsed.search, producerRaw: true, intendedAt: new Date().toISOString(), state: 'PENDING' }
        const form = init.body instanceof FormData
        if (form) {
          entry.multipart = []
          for (const [name, value] of init.body.entries()) entry.multipart.push(typeof value === 'string'
            ? { name, value } : { name, size: value.size, type: value.type, sha256: sha(new Uint8Array(await value.arrayBuffer())) })
        } else if (init.body) { try { entry.request = redact(JSON.parse(init.body)) } catch { entry.requestSha256 = sha(String(init.body)) } }
        report.requests.push(entry); await save()
        let response
        try { response = await serialFetch(url, { ...init, redirect: 'error' }) }
        catch { entry.state = 'UNKNOWN'; await save(); throw new CheckFailure(`Producer transport unknown: ${entry.method} ${entry.path}`) }
        const bytes = new Uint8Array(await response.clone().arrayBuffer())
        entry.http = response.status; entry.state = 'RECEIVED'
        if ((response.headers.get('content-type') || '').includes('json')) {
          const payload = JSON.parse(new TextDecoder().decode(bytes)); entry.code = payload.code
          entry.requestId = payload.requestId; entry.traceId = payload.traceId; entry.response = redact(payload)
          if (parsed.pathname === '/api/auth/login') recordSession(payload, 'producer')
        } else { entry.size = bytes.length; entry.sha256 = sha(bytes) }
        await save(); return response
      }
      const { AcceptanceRun, parseArguments } = await import('./admin-test-env-acceptance.mjs')
      const context = new AcceptanceRun({ ...parseArguments(['--modules','orders,inbound-measurement','--quiet','true']), gateway: options.gateway,
        username: env.CHONGCHONG_ADMIN_USERNAME, password: env.CHONGCHONG_ADMIN_PASSWORD, customerName: '', waitSplitCount: 1,
        routeMode: 'fixed', orderProfileMode: 'fixed' })
      context.token = sessions.admin.token; context.pdaToken = sessions.pda.token
      const originalStep = context.addStep.bind(context)
      context.addStep = (...args) => { const passed = originalStep(...args); if (!passed) throw new CheckFailure(`Fresh producer gate failed: ${args[0]} / ${args[1]}`); return passed }
      const roleFor = token => token ? Object.entries(sessions).find(([, value]) => value.token === token)?.[0] || 'admin' : 'producer'
      context.request = (method, path, body, token = context.token, headers = {}) => {
        need(method === 'GET' || !/^\/api\/platform\/v1\/(suppliers|business-partners|ocean-bookings\/channels)/.test(path), 'Shared booking master data writes require controller coordination')
        return request(method, path, body, roleFor(token), headers)
      }
      const adapter = multipartAdapter(request, roleFor)
      context.requestMultipart = (method, path, file, token = context.token, headers = {}) => adapter(method, path, file, token, headers)
      const freshCases = await prepareFreshCases(options.runId, context, async checkpoint => {
        report.preparation ||= []; report.preparation.push(checkpoint); await save()
      }, resume)
      globalThis.fetch = nativeFetch
      const bytes = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=', 'base64')
      report.syntheticHttpEvidence = true // controlled HTTP fixture; never camera/device proof
      for (const value of freshCases) specs.push({ ...value, images: Object.fromEntries(TYPES.map(type => [type, { bytes, type: 'image/png', sha256: sha(bytes) }])) })
      report.fixtures = specs.map(({ spec, source, owners }) => ({ kind: spec.kind, source, owners }))
      await save()
    }
    const ok = response => { need(response.http === 200 && String(response.body?.code) === '200', `Preflight API rejected ${response.path}`); return response.body.data }
    const ownPdaId = JSON.parse(Buffer.from(sessions.pda.token.split('.')[1], 'base64url').toString()).sub
    need(positive(ownPdaId), 'Own PDA subject required')
    // Both cabinets are checked before the first claim/batch/evidence/complete write.
    if (completionMode) {
      const checkpoint = async snapshot => {
        report.checkpoints ||= []; report.checkpoints.push(snapshot); await save()
      }
      report.cases.push(verifyAMode ? await verifyRecoveredA(specs[0], original, originalBefore, request, checkpoint)
        : await recoverOriginalA(specs[0], original, request, checkpoint))
      report.success = true // this dispatch is A-only; B is explicitly deferred and untouched
    } else {
    for (const item of specs) {
      const { source, spec } = item, path = `${PDA}/tasks/${source.pdaTaskId}`
      const task = ok(await request('GET', `${path}?warehouseId=${source.warehouseId}`, undefined, 'pda'))
      validateZeroWorkTask(source, task, ownPdaId)
      const originalIds = source.taskItems.map(row => id(row.id)).sort()
      assert.deepEqual(task.items.map(row => id(row.id)).sort(), originalIds, 'Source fixture item set')
      const preload = ok(await request('GET', `${LEG}/loading-plans/${source.loadingPlanId}?warehouseId=${source.warehouseId}`))
      need(['EDITING', 'LOADING'].includes(preload.summary.status), 'Zero-pick preload must be EDITING or own claimed LOADING')
      const operations = ok(await request('GET', `${path}/operations`, undefined, 'pda'))
      need(!rows(operations).some(row => ['BATCH', 'COMPLETE_LOADING'].includes(row.actionType))
        && rows(operations).filter(row => row.actionType === 'CLAIM').every(row => row.operationId === `${source.sourceMarker}-claim`),
        'No earlier physical picking/completion or foreign claim allowed')
      const evidence = ok(await request('GET', `${path}/evidence?warehouseId=${source.warehouseId}`, undefined, 'pda'))
      need(!rows(evidence.evidences).some(row => row.status === 'ACTIVE'), 'New task must have empty active evidence baseline')
      item.task = task; item.expected = expectedRows(spec, task, preload)
    }
    for (const item of specs) {
      const result = await runCase(item.spec, item.source, item, request)
      if (bOnlyMode) {
        const downstream = await waitDownstream(item, request, ms => new Promise(done => setTimeout(done, ms)))
        result.downstream = downstream.facts; report.BAfter = { source: await sourceSnapshot(item, request), downstream }
      }
      report.cases.push(result); await save()
    }
    report.success = report.cases.length === (bOnlyMode ? 1 : 2)
    }
  } catch (error) {
    report.failure = error instanceof CheckFailure || error instanceof assert.AssertionError ? error.message : 'Local response/fixture format failure'
  } finally {
    globalThis.fetch = nativeFetch
    // A transport-unknown business command stops all further business writes;
    // own session logout is still allowed and does not replay that command.
    transportUnknown = false
    for (const [role, session] of Object.entries(sessions).reverse()) {
      try {
        const response = await request('POST', '/api/auth/logout', { refreshToken: session.refresh }, role)
        const closed = response.http === 200 && String(response.body?.code) === '200'
        report.sessions[role] = { loggedIn: true, closed }; if (!closed) report.success = false
      } catch { report.sessions[role] = { loggedIn: true, closed: false }; report.success = false }
    }
    report.finishedAt = new Date().toISOString(); await save()
  }
  return { success: report.success, report: resolve(directory, 'report.json') }
}

if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
  execute().then(result => { console.log(JSON.stringify(result)); if (result.success === false) process.exitCode = 1 })
    .catch(() => { console.error('Partial-loading acceptance did not start; check TEST env-file, new run-id and legal fixture manifest.'); process.exitCode = 1 })
}