@open-mercato/core 0.10.1-develop.7709.1.046124599c → 0.10.1-develop.7714.1.9dbb8200d8

package/dist/modules/wms/commands/asn.js

@@ -0,0 +1,1746 @@
+import { registerCommand } from "@open-mercato/shared/lib/commands";
+import { withAtomicFlush } from "@open-mercato/shared/lib/commands/flush";
+import { emitCrudSideEffects } from "@open-mercato/shared/lib/commands/helpers";
+import { extractUndoPayload } from "@open-mercato/shared/lib/commands/undo";
+import { LockMode } from "@mikro-orm/core";
+import { CrudHttpError } from "@open-mercato/shared/lib/crud/errors";
+import { resolveTranslations } from "@open-mercato/shared/lib/i18n/server";
+import { findOneWithDecryption, findWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { enforceCommandOptimisticLockWithGuards } from "@open-mercato/shared/lib/crud/optimistic-lock-command";
+import {
+  Asn,
+  InventoryBalance,
+  PutawayTask,
+  ReceivingLine,
+  Warehouse,
+  WarehouseLocation
+} from "../data/entities.js";
+import { requireVendorIfPresent as requireVendorIfPresentLookup } from "../lib/asnVendor.js";
+import {
+  asnCloseSchema,
+  asnCreateSchema,
+  asnReceiveLineSchema,
+  asnUpdateSchema,
+  receivingLineCreateSchema,
+  receivingLineUpdateSchema
+} from "../data/validators.js";
+import { emitWmsEvent } from "../events.js";
+import {
+  assertAsnQcTransition,
+  assertReceivingLineLifecycleFieldsForbidden,
+  buildAsnReceivePutawayKey,
+  buildAsnReceiveReferenceId,
+  hasAsnDeleteBlockingLineActivity,
+  isAsnCloseable,
+  resolveAsnReceiveAttempt,
+  resolvePutawayQuantityForAlreadyAtTargetRetry,
+  shouldEnsurePutawayOnAlreadyAtTarget,
+  shouldRecreatePutawayOnAlreadyAtTarget,
+  shouldWriteStockOnQcPass
+} from "../lib/asnReceiving.js";
+import {
+  computeUncommittedPutawaySourceQuantity,
+  selectCoveringOpenPutawayTask
+} from "../lib/putaway.js";
+import {
+  applyInventoryReceiveInTransaction,
+  emitInventoryReceiveSideEffects
+} from "./inventory-actions.js";
+import {
+  asnCrudEvents,
+  asnCrudIndexer,
+  ensureOrganizationScope,
+  ensureTenantScope,
+  normalizeOptionalString,
+  putawayTaskCrudEvents,
+  putawayTaskCrudIndexer,
+  receivingLineCrudEvents,
+  receivingLineCrudIndexer,
+  requireId,
+  toNumericString,
+  WMS_ASN_RESOURCE,
+  WMS_INVENTORY_BALANCE_RESOURCE,
+  WMS_RECEIVING_LINE_RESOURCE
+} from "./shared.js";
+function resolveScope(ctx, fallback) {
+  const tenantId = fallback?.tenantId ?? ctx.auth?.tenantId ?? null;
+  const organizationId = fallback?.organizationId ?? ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null;
+  if (!tenantId || !organizationId) {
+    throw new CrudHttpError(400, { error: "Tenant and organization scope are required." });
+  }
+  return { tenantId, organizationId };
+}
+function resolveEm(ctx) {
+  return ctx.container.resolve("em").fork();
+}
+function toNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+}
+function toJsonValue(value) {
+  if (value === void 0) return void 0;
+  return value ?? null;
+}
+function iso(value) {
+  if (value instanceof Date) return value.toISOString();
+  return new Date(value).toISOString();
+}
+function snapshotAsn(record) {
+  const warehouseId = typeof record.warehouse === "string" ? record.warehouse : record.warehouse.id;
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    warehouseId,
+    vendorId: record.vendorId ?? null,
+    status: record.status,
+    expectedAt: iso(record.expectedAt),
+    referenceNumber: record.referenceNumber ?? null,
+    notes: record.notes ?? null,
+    metadata: record.metadata ?? null,
+    createdAt: iso(record.createdAt),
+    updatedAt: iso(record.updatedAt)
+  };
+}
+function snapshotReceivingLine(record) {
+  const asnId = typeof record.asn === "string" ? record.asn : record.asn.id;
+  return {
+    id: record.id,
+    organizationId: record.organizationId,
+    tenantId: record.tenantId,
+    asnId,
+    catalogVariantId: record.catalogVariantId,
+    expectedQty: record.expectedQty,
+    receivedQty: record.receivedQty,
+    lotNumber: record.lotNumber ?? null,
+    serialNumbers: Array.isArray(record.serialNumbers) ? [...record.serialNumbers] : null,
+    qcStatus: record.qcStatus,
+    targetStagingLocationId: record.targetStagingLocationId ?? null,
+    rejectionReason: record.rejectionReason ?? null,
+    metadata: record.metadata ?? null,
+    createdAt: iso(record.createdAt),
+    updatedAt: iso(record.updatedAt)
+  };
+}
+async function loadAsn(em, ctx, id) {
+  const asn = await findOneWithDecryption(em, Asn, { id, deletedAt: null }, void 0, resolveScope(ctx));
+  if (!asn) throw new CrudHttpError(404, { error: "ASN not found." });
+  ensureTenantScope(ctx, asn.tenantId);
+  ensureOrganizationScope(ctx, asn.organizationId);
+  return asn;
+}
+async function withLockedAsn(em, ctx, id, scope, fn) {
+  return em.transactional(async (trx) => {
+    const asn = await findOneWithDecryption(
+      trx,
+      Asn,
+      { id, deletedAt: null },
+      { lockMode: LockMode.PESSIMISTIC_WRITE },
+      scope
+    );
+    if (!asn) throw new CrudHttpError(404, { error: "ASN not found." });
+    ensureTenantScope(ctx, asn.tenantId);
+    ensureOrganizationScope(ctx, asn.organizationId);
+    return fn(asn, trx);
+  });
+}
+async function withLockedAsnReceivingLine(em, ctx, lineId, scope, options, fn) {
+  return em.transactional(async (trx) => {
+    const unlocked = await findOneWithDecryption(trx, ReceivingLine, { id: lineId }, void 0, scope);
+    if (!unlocked) return null;
+    if (options.requireActiveLine && unlocked.deletedAt) return null;
+    ensureTenantScope(ctx, unlocked.tenantId);
+    ensureOrganizationScope(ctx, unlocked.organizationId);
+    const asnId = typeof unlocked.asn === "string" ? unlocked.asn : unlocked.asn.id;
+    const asn = await findOneWithDecryption(
+      trx,
+      Asn,
+      { id: asnId, deletedAt: null },
+      { lockMode: LockMode.PESSIMISTIC_WRITE },
+      scope
+    );
+    if (!asn) throw new CrudHttpError(404, { error: "ASN not found." });
+    ensureTenantScope(ctx, asn.tenantId);
+    ensureOrganizationScope(ctx, asn.organizationId);
+    const locked = await findOneWithDecryption(
+      trx,
+      ReceivingLine,
+      { id: lineId },
+      { lockMode: LockMode.PESSIMISTIC_WRITE },
+      scope
+    );
+    if (!locked) return null;
+    if (options.requireActiveLine && locked.deletedAt) return null;
+    ensureTenantScope(ctx, locked.tenantId);
+    ensureOrganizationScope(ctx, locked.organizationId);
+    return fn({ asn, line: locked, trx });
+  });
+}
+async function loadReceivingLine(em, ctx, id) {
+  const line = await findOneWithDecryption(
+    em,
+    ReceivingLine,
+    { id, deletedAt: null },
+    void 0,
+    resolveScope(ctx)
+  );
+  if (!line) throw new CrudHttpError(404, { error: "Receiving line not found." });
+  ensureTenantScope(ctx, line.tenantId);
+  ensureOrganizationScope(ctx, line.organizationId);
+  return line;
+}
+async function requireWarehouse(em, ctx, warehouseId, scope) {
+  const warehouse = await findOneWithDecryption(
+    em,
+    Warehouse,
+    { id: warehouseId, deletedAt: null },
+    void 0,
+    scope
+  );
+  if (!warehouse) throw new CrudHttpError(404, { error: "Warehouse not found." });
+  ensureTenantScope(ctx, warehouse.tenantId);
+  ensureOrganizationScope(ctx, warehouse.organizationId);
+  return warehouse;
+}
+async function requireStagingLocation(em, ctx, locationId, warehouseId, scope) {
+  const location = await findOneWithDecryption(
+    em,
+    WarehouseLocation,
+    { id: locationId, deletedAt: null },
+    void 0,
+    scope
+  );
+  if (!location) throw new CrudHttpError(404, { error: "Warehouse location not found." });
+  ensureTenantScope(ctx, location.tenantId);
+  ensureOrganizationScope(ctx, location.organizationId);
+  const locationWarehouseId = typeof location.warehouse === "string" ? location.warehouse : location.warehouse.id;
+  if (locationWarehouseId !== warehouseId) {
+    throw new CrudHttpError(422, { error: "invalid_location" });
+  }
+  if (location.type !== "staging" && location.type !== "dock") {
+    throw new CrudHttpError(422, { error: "invalid_staging_location" });
+  }
+  if (!location.isActive) {
+    throw new CrudHttpError(422, { error: "inactive_location" });
+  }
+  return location;
+}
+async function requireVendorIfPresent(ctx, vendorId, scope) {
+  await requireVendorIfPresentLookup(ctx.container, vendorId, scope);
+}
+function isUniqueConstraintError(error) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  if (code === "23505") return true;
+  const name = error.name;
+  return name === "UniqueConstraintViolationException";
+}
+async function findExistingPutawayForReceipt(em, scope, putawayKey) {
+  return findOneWithDecryption(
+    em,
+    PutawayTask,
+    {
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      putawayKey,
+      deletedAt: null,
+      status: { $in: ["open", "in_progress", "done"] }
+    },
+    void 0,
+    scope
+  );
+}
+async function findCancelledPutawayForReceipt(em, scope, putawayKey) {
+  const rows = await em.getConnection().execute(
+    `select id
+     from wms_putaway_tasks
+     where organization_id = ?
+       and tenant_id = ?
+       and deleted_at is null
+       and status = 'cancelled'
+       and metadata->>'putawayKey' = ?
+     order by updated_at desc
+     limit 1`,
+    [scope.organizationId, scope.tenantId, putawayKey]
+  );
+  const id = rows[0]?.id;
+  if (!id) return null;
+  return findOneWithDecryption(
+    em,
+    PutawayTask,
+    { id, deletedAt: null, status: "cancelled" },
+    void 0,
+    scope
+  );
+}
+async function resolveUncommittedStagingPutawayQuantity(em, scope, input, options) {
+  const serialNumber = input.serialNumber?.trim() ? input.serialNumber.trim() : null;
+  const balance = await findOneWithDecryption(
+    em,
+    InventoryBalance,
+    {
+      warehouse: input.warehouseId,
+      location: input.sourceLocationId,
+      catalogVariantId: input.catalogVariantId,
+      lot: input.lotId ?? null,
+      serialNumber,
+      deletedAt: null
+    },
+    options?.lock ? { lockMode: LockMode.PESSIMISTIC_WRITE } : void 0,
+    scope
+  );
+  if (!balance) return null;
+  const openTasks = await findWithDecryption(
+    em,
+    PutawayTask,
+    {
+      warehouse: input.warehouseId,
+      sourceLocationId: input.sourceLocationId,
+      catalogVariantId: input.catalogVariantId,
+      lotId: input.lotId ?? null,
+      serialNumber,
+      status: { $in: ["open", "in_progress"] },
+      deletedAt: null
+    },
+    void 0,
+    scope
+  );
+  return {
+    remaining: computeUncommittedPutawaySourceQuantity({
+      quantityOnHand: toNumber(balance.quantityOnHand),
+      quantityReserved: toNumber(balance.quantityReserved),
+      quantityAllocated: toNumber(balance.quantityAllocated),
+      openPutawayQuantities: openTasks.map((task) => toNumber(task.quantity))
+    }),
+    openTasks
+  };
+}
+async function findOrCreatePutawayForReceipt(em, scope, putawayKey, input) {
+  const existing = await findExistingPutawayForReceipt(em, scope, putawayKey);
+  if (existing) return { task: existing, created: false };
+  const task = em.create(PutawayTask, {
+    organizationId: scope.organizationId,
+    tenantId: scope.tenantId,
+    warehouse: em.getReference(Warehouse, input.warehouseId),
+    sourceLocationId: input.sourceLocationId,
+    targetLocationId: null,
+    catalogVariantId: input.catalogVariantId,
+    lotId: input.lotId,
+    serialNumber: input.serialNumber?.trim() ? input.serialNumber.trim() : null,
+    quantity: toNumericString(input.quantity),
+    status: "open",
+    assignedTo: null,
+    priority: 5,
+    putawayKey,
+    metadata: {
+      ...input.metadata ?? {},
+      asnId: input.asnId,
+      receivingLineId: input.lineId,
+      putawayKey,
+      source: "asn_receive",
+      ...input.serialNumber?.trim() ? { serialNumber: input.serialNumber.trim() } : {}
+    }
+  });
+  try {
+    await em.persist(task).flush();
+    return { task, created: true };
+  } catch (error) {
+    if (!isUniqueConstraintError(error)) throw error;
+    const raced = await findExistingPutawayForReceipt(em, scope, putawayKey);
+    if (raced) return { task: raced, created: false };
+    throw error;
+  }
+}
+async function emitAsnReceivePutawayCreatedSideEffects(ctx, scope, putaway, warehouseId) {
+  let de = null;
+  try {
+    de = ctx.container.resolve("dataEngine");
+  } catch {
+    de = null;
+  }
+  if (de) {
+    await emitCrudSideEffects({
+      dataEngine: de,
+      action: "created",
+      entity: putaway,
+      identifiers: {
+        id: putaway.id,
+        organizationId: putaway.organizationId,
+        tenantId: putaway.tenantId
+      },
+      indexer: putawayTaskCrudIndexer,
+      events: putawayTaskCrudEvents
+    });
+  }
+  void emitWmsEvent("wms.putaway.created", {
+    id: putaway.id,
+    warehouseId,
+    sourceLocationId: putaway.sourceLocationId,
+    targetLocationId: putaway.targetLocationId ?? null,
+    catalogVariantId: putaway.catalogVariantId,
+    quantity: putaway.quantity,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId
+  }).catch(() => void 0);
+}
+async function buildCrudLog(ctx, input, resultId, actionKey, fallbackLabel, resourceKind) {
+  const { translate } = await resolveTranslations();
+  return {
+    actionLabel: translate(actionKey, fallbackLabel),
+    resourceKind,
+    resourceId: resultId ?? input?.id ?? null,
+    tenantId: input?.tenantId ?? ctx.auth?.tenantId ?? null,
+    organizationId: input?.organizationId ?? ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+  };
+}
+function assertAsnMutable(asn) {
+  if (asn.status === "closed" || asn.status === "received") {
+    throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+  }
+}
+async function hasOpenPutawayForAsn(em, scope, asnId) {
+  const rows = await em.getConnection().execute(
+    `select 1 as hit
+     from wms_putaway_tasks
+     where organization_id = ?
+       and tenant_id = ?
+       and deleted_at is null
+       and status in ('open', 'in_progress')
+       and metadata->>'asnId' = ?
+     limit 1`,
+    [scope.organizationId, scope.tenantId, asnId]
+  );
+  return rows.length > 0;
+}
+function resolveSerialNumbers(input) {
+  if (!input.serialNumbers?.length) return [];
+  return input.serialNumbers.map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function normalizeStoredSerials(values) {
+  if (!values?.length) return [];
+  return values.map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function assertUniqueSerialNumbers(serialNumbers) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const serialNumber of serialNumbers) {
+    if (seen.has(serialNumber)) {
+      throw new CrudHttpError(422, { error: "duplicate_serial" });
+    }
+    seen.add(serialNumber);
+  }
+}
+function assertIncomingSerialsAreNew(incoming, stored) {
+  const known = new Set(normalizeStoredSerials(stored));
+  for (const serialNumber of incoming) {
+    if (known.has(serialNumber)) {
+      throw new CrudHttpError(422, { error: "duplicate_serial" });
+    }
+  }
+}
+function mergeReceivedSerials(stored, incoming) {
+  const next = normalizeStoredSerials(stored);
+  const seen = new Set(next);
+  for (const serialNumber of incoming) {
+    if (seen.has(serialNumber)) continue;
+    seen.add(serialNumber);
+    next.push(serialNumber);
+  }
+  return next;
+}
+function recordReceivedSerials(line, incoming, priorReceivedQty) {
+  if (incoming.length === 0) return;
+  line.serialNumbers = priorReceivedQty > 1e-6 ? mergeReceivedSerials(line.serialNumbers, incoming) : incoming;
+}
+async function emitAsnSideEffects(ctx, affected) {
+  let de = null;
+  try {
+    de = ctx.container.resolve("dataEngine");
+  } catch {
+    de = null;
+  }
+  if (!de) return;
+  for (const { entity, action } of affected.asns ?? []) {
+    await emitCrudSideEffects({
+      dataEngine: de,
+      action,
+      entity,
+      identifiers: {
+        id: entity.id,
+        organizationId: entity.organizationId,
+        tenantId: entity.tenantId
+      },
+      indexer: asnCrudIndexer,
+      events: asnCrudEvents
+    });
+  }
+  for (const { entity, action } of affected.lines ?? []) {
+    await emitCrudSideEffects({
+      dataEngine: de,
+      action,
+      entity,
+      identifiers: {
+        id: entity.id,
+        organizationId: entity.organizationId,
+        tenantId: entity.tenantId
+      },
+      indexer: receivingLineCrudIndexer,
+      events: receivingLineCrudEvents
+    });
+  }
+}
+const createAsnCommand = {
+  id: "wms.asns.create",
+  async execute(rawInput, ctx) {
+    const input = asnCreateSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, input.tenantId);
+    ensureOrganizationScope(ctx, input.organizationId);
+    const em = resolveEm(ctx);
+    const scope = resolveScope(ctx, input);
+    await requireWarehouse(em, ctx, input.warehouseId, scope);
+    await requireVendorIfPresent(ctx, input.vendorId, scope);
+    const status = input.status ?? "draft";
+    const createdLines = [];
+    let asn;
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          asn = em.create(Asn, {
+            organizationId: scope.organizationId,
+            tenantId: scope.tenantId,
+            warehouse: em.getReference(Warehouse, input.warehouseId),
+            vendorId: input.vendorId ?? null,
+            status,
+            expectedAt: input.expectedAt,
+            referenceNumber: normalizeOptionalString(input.referenceNumber ?? void 0),
+            // sourceKey is server/system-only (auth null). Authenticated HTTP creates ignore it.
+            sourceKey: ctx.auth == null ? normalizeOptionalString(input.sourceKey ?? void 0) : null,
+            notes: normalizeOptionalString(input.notes ?? void 0),
+            metadata: toJsonValue(input.metadata ?? null) ?? null
+          });
+          em.persist(asn);
+        },
+        () => {
+          for (const lineInput of input.lines ?? []) {
+            const line = em.create(ReceivingLine, {
+              organizationId: scope.organizationId,
+              tenantId: scope.tenantId,
+              asn,
+              catalogVariantId: lineInput.catalogVariantId,
+              expectedQty: toNumericString(lineInput.expectedQty),
+              receivedQty: "0",
+              lotNumber: normalizeOptionalString(lineInput.lotNumber ?? void 0),
+              serialNumbers: lineInput.serialNumbers ?? null,
+              qcStatus: "pending",
+              targetStagingLocationId: lineInput.targetStagingLocationId ?? null,
+              metadata: toJsonValue(lineInput.metadata ?? null) ?? null
+            });
+            em.persist(line);
+            createdLines.push(line);
+          }
+        }
+      ],
+      { transaction: true, label: "wms.asns.create" }
+    );
+    await emitAsnSideEffects(ctx, {
+      asns: [{ entity: asn, action: "created" }],
+      lines: createdLines.map((entity) => ({ entity, action: "created" }))
+    });
+    void emitWmsEvent("wms.asn.created", {
+      id: asn.id,
+      warehouseId: input.warehouseId,
+      vendorId: input.vendorId ?? null,
+      status: asn.status,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId
+    }).catch(() => void 0);
+    return { asnId: asn.id, lineIds: createdLines.map((line) => line.id) };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    if (!result?.asnId) return null;
+    const em = resolveEm(ctx);
+    const asn = await loadAsn(em, ctx, result.asnId);
+    return snapshotAsn(asn);
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after?.id) return;
+    const em = resolveEm(ctx);
+    const scope = { tenantId: after.tenantId, organizationId: after.organizationId };
+    const existing = await findOneWithDecryption(em, Asn, { id: after.id }, void 0, scope);
+    if (!existing || existing.deletedAt) return;
+    const locked = await withLockedAsn(em, ctx, after.id, scope, async (asn, trx) => {
+      assertAsnMutable(asn);
+      const lines = await findWithDecryption(
+        trx,
+        ReceivingLine,
+        { asn: asn.id, deletedAt: null },
+        void 0,
+        scope
+      );
+      if (hasAsnDeleteBlockingLineActivity(lines)) {
+        throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+      }
+      const deletedAt = /* @__PURE__ */ new Date();
+      asn.deletedAt = deletedAt;
+      for (const line of lines) {
+        line.deletedAt = deletedAt;
+      }
+      await trx.flush();
+      return { asn, lines };
+    });
+    await emitAsnSideEffects(ctx, {
+      asns: [{ entity: locked.asn, action: "deleted" }],
+      lines: locked.lines.map((entity) => ({ entity, action: "deleted" }))
+    });
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(
+      ctx,
+      input,
+      result?.asnId ?? null,
+      "wms.audit.asn.create",
+      "Create ASN",
+      WMS_ASN_RESOURCE
+    );
+    const after = snapshots?.after;
+    return {
+      ...base,
+      snapshotAfter: after,
+      payload: { undo: { after, lineIds: result?.lineIds ?? [] } }
+    };
+  }
+};
+const updateAsnCommand = {
+  id: "wms.asns.update",
+  async prepare(rawInput, ctx) {
+    const id = requireId(rawInput?.id, "ASN");
+    const em = resolveEm(ctx);
+    const asn = await loadAsn(em, ctx, id);
+    assertAsnMutable(asn);
+    return { before: snapshotAsn(asn) };
+  },
+  async execute(rawInput, ctx) {
+    const input = asnUpdateSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, input.tenantId ?? ctx.auth?.tenantId ?? "");
+    if (input.organizationId) ensureOrganizationScope(ctx, input.organizationId);
+    const em = resolveEm(ctx);
+    const asn = await withLockedAsn(em, ctx, input.id, resolveScope(ctx), async (asn2, trx) => {
+      assertAsnMutable(asn2);
+      await enforceCommandOptimisticLockWithGuards(ctx.container, {
+        resourceKind: WMS_ASN_RESOURCE,
+        resourceId: asn2.id,
+        current: asn2.updatedAt,
+        request: ctx.request ?? null
+      });
+      const scope = resolveScope(ctx, {
+        tenantId: asn2.tenantId,
+        organizationId: asn2.organizationId
+      });
+      const lines = await findWithDecryption(
+        trx,
+        ReceivingLine,
+        { asn: asn2.id, deletedAt: null },
+        void 0,
+        scope
+      );
+      if (hasAsnDeleteBlockingLineActivity(lines)) {
+        throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+      }
+      if (input.warehouseId) {
+        await requireWarehouse(trx, ctx, input.warehouseId, scope);
+        asn2.warehouse = trx.getReference(Warehouse, input.warehouseId);
+      }
+      if (input.vendorId !== void 0) {
+        await requireVendorIfPresent(ctx, input.vendorId, scope);
+        asn2.vendorId = input.vendorId;
+      }
+      if (input.status !== void 0) {
+        asn2.status = input.status;
+      }
+      if (input.expectedAt !== void 0) asn2.expectedAt = input.expectedAt;
+      if (input.referenceNumber !== void 0) {
+        asn2.referenceNumber = normalizeOptionalString(input.referenceNumber ?? void 0);
+      }
+      if (input.notes !== void 0) asn2.notes = normalizeOptionalString(input.notes ?? void 0);
+      if (input.metadata !== void 0) asn2.metadata = toJsonValue(input.metadata) ?? null;
+      await trx.flush();
+      return asn2;
+    });
+    await emitAsnSideEffects(ctx, { asns: [{ entity: asn, action: "updated" }] });
+    void emitWmsEvent("wms.asn.updated", {
+      id: asn.id,
+      status: asn.status,
+      tenantId: asn.tenantId,
+      organizationId: asn.organizationId
+    }).catch(() => void 0);
+    return { asnId: asn.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    if (!result?.asnId) return null;
+    const em = resolveEm(ctx);
+    const asn = await loadAsn(em, ctx, result.asnId);
+    return snapshotAsn(asn);
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before?.id) return;
+    const em = resolveEm(ctx);
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const asn = await withLockedAsn(em, ctx, before.id, scope, async (asn2, trx) => {
+      assertAsnMutable(asn2);
+      const lines = await findWithDecryption(
+        trx,
+        ReceivingLine,
+        { asn: asn2.id, deletedAt: null },
+        void 0,
+        scope
+      );
+      if (hasAsnDeleteBlockingLineActivity(lines)) {
+        throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+      }
+      asn2.warehouse = trx.getReference(Warehouse, before.warehouseId);
+      asn2.vendorId = before.vendorId;
+      asn2.status = before.status;
+      asn2.expectedAt = new Date(before.expectedAt);
+      asn2.referenceNumber = before.referenceNumber;
+      asn2.notes = before.notes;
+      asn2.metadata = before.metadata;
+      asn2.deletedAt = null;
+      await trx.flush();
+      return asn2;
+    });
+    await emitAsnSideEffects(ctx, { asns: [{ entity: asn, action: "updated" }] });
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(
+      ctx,
+      input,
+      result?.asnId ?? null,
+      "wms.audit.asn.update",
+      "Update ASN",
+      WMS_ASN_RESOURCE
+    );
+    const before = snapshots?.before;
+    const after = snapshots?.after;
+    return {
+      ...base,
+      snapshotBefore: before,
+      snapshotAfter: after,
+      payload: { undo: { before, after } }
+    };
+  }
+};
+const deleteAsnCommand = {
+  id: "wms.asns.delete",
+  async prepare(rawInput, ctx) {
+    const id = requireId(rawInput?.id, "ASN");
+    const em = resolveEm(ctx);
+    const asn = await loadAsn(em, ctx, id);
+    const lines = await findWithDecryption(
+      em,
+      ReceivingLine,
+      { asn: asn.id, deletedAt: null },
+      void 0,
+      { tenantId: asn.tenantId, organizationId: asn.organizationId }
+    );
+    return {
+      before: snapshotAsn(asn),
+      lineIds: lines.map((line) => line.id)
+    };
+  },
+  async execute(rawInput, ctx) {
+    const id = requireId(rawInput?.id, "ASN");
+    const em = resolveEm(ctx);
+    const locked = await withLockedAsn(em, ctx, id, resolveScope(ctx), async (asn, trx) => {
+      assertAsnMutable(asn);
+      await enforceCommandOptimisticLockWithGuards(ctx.container, {
+        resourceKind: WMS_ASN_RESOURCE,
+        resourceId: asn.id,
+        current: asn.updatedAt,
+        request: ctx.request ?? null
+      });
+      const scope = { tenantId: asn.tenantId, organizationId: asn.organizationId };
+      const lines = await findWithDecryption(
+        trx,
+        ReceivingLine,
+        { asn: asn.id, deletedAt: null },
+        void 0,
+        scope
+      );
+      if (hasAsnDeleteBlockingLineActivity(lines)) {
+        throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+      }
+      if (await hasOpenPutawayForAsn(trx, scope, asn.id)) {
+        throw new CrudHttpError(409, { error: "asn_has_open_putaway" });
+      }
+      const deletedAt = /* @__PURE__ */ new Date();
+      asn.deletedAt = deletedAt;
+      for (const line of lines) {
+        line.deletedAt = deletedAt;
+      }
+      await trx.flush();
+      return { asn, lines };
+    });
+    await emitAsnSideEffects(ctx, {
+      asns: [{ entity: locked.asn, action: "deleted" }],
+      lines: locked.lines.map((entity) => ({ entity, action: "deleted" }))
+    });
+    return { asnId: locked.asn.id, lineIds: locked.lines.map((line) => line.id) };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before?.id) return;
+    const em = resolveEm(ctx);
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const asn = await findOneWithDecryption(em, Asn, { id: before.id }, void 0, scope);
+    if (!asn) return;
+    const sourceKey = normalizeOptionalString(asn.sourceKey ?? void 0);
+    if (sourceKey) {
+      const clash = await findOneWithDecryption(
+        em,
+        Asn,
+        {
+          organizationId: scope.organizationId,
+          tenantId: scope.tenantId,
+          sourceKey,
+          deletedAt: null,
+          id: { $ne: asn.id }
+        },
+        void 0,
+        scope
+      );
+      if (clash) {
+        throw new CrudHttpError(409, { error: "asn_source_key_conflict" });
+      }
+    }
+    asn.deletedAt = null;
+    const lineIds = Array.isArray(payload?.lineIds) ? payload.lineIds : [];
+    const restoredLines = [];
+    if (lineIds.length > 0) {
+      const lines = await findWithDecryption(
+        em,
+        ReceivingLine,
+        { id: { $in: lineIds }, asn: asn.id },
+        void 0,
+        scope
+      );
+      for (const line of lines) {
+        line.deletedAt = null;
+        restoredLines.push(line);
+      }
+    }
+    try {
+      await em.flush();
+    } catch (error) {
+      if (sourceKey && isUniqueConstraintError(error)) {
+        throw new CrudHttpError(409, { error: "asn_source_key_conflict" });
+      }
+      throw error;
+    }
+    await emitAsnSideEffects(ctx, {
+      asns: [{ entity: asn, action: "updated" }],
+      lines: restoredLines.map((entity) => ({ entity, action: "updated" }))
+    });
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(
+      ctx,
+      input,
+      result?.asnId ?? null,
+      "wms.audit.asn.delete",
+      "Delete ASN",
+      WMS_ASN_RESOURCE
+    );
+    const before = snapshots?.before;
+    const lineIds = result?.lineIds ?? [];
+    return {
+      ...base,
+      snapshotBefore: before,
+      payload: { undo: { before, lineIds } }
+    };
+  }
+};
+const createReceivingLineCommand = {
+  id: "wms.receiving-lines.create",
+  async execute(rawInput, ctx) {
+    const input = receivingLineCreateSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, input.tenantId);
+    ensureOrganizationScope(ctx, input.organizationId);
+    const em = resolveEm(ctx);
+    const line = await withLockedAsn(em, ctx, input.asnId, resolveScope(ctx, input), async (asn, trx) => {
+      assertAsnMutable(asn);
+      const created = trx.create(ReceivingLine, {
+        organizationId: asn.organizationId,
+        tenantId: asn.tenantId,
+        asn,
+        catalogVariantId: input.catalogVariantId,
+        expectedQty: toNumericString(input.expectedQty),
+        receivedQty: "0",
+        lotNumber: normalizeOptionalString(input.lotNumber ?? void 0),
+        serialNumbers: input.serialNumbers ?? null,
+        qcStatus: "pending",
+        targetStagingLocationId: input.targetStagingLocationId ?? null,
+        metadata: toJsonValue(input.metadata ?? null) ?? null
+      });
+      trx.persist(created);
+      await trx.flush();
+      return created;
+    });
+    await emitAsnSideEffects(ctx, { lines: [{ entity: line, action: "created" }] });
+    return { lineId: line.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    if (!result?.lineId) return null;
+    const em = resolveEm(ctx);
+    const line = await loadReceivingLine(em, ctx, result.lineId);
+    return snapshotReceivingLine(line);
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after?.id) return;
+    const em = resolveEm(ctx);
+    const scope = { tenantId: after.tenantId, organizationId: after.organizationId };
+    const line = await withLockedAsnReceivingLine(
+      em,
+      ctx,
+      after.id,
+      scope,
+      { requireActiveLine: true },
+      async ({ asn, line: line2, trx }) => {
+        assertAsnMutable(asn);
+        if (hasAsnDeleteBlockingLineActivity([line2])) {
+          throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+        }
+        line2.deletedAt = /* @__PURE__ */ new Date();
+        await trx.flush();
+        return line2;
+      }
+    );
+    if (!line) return;
+    await emitAsnSideEffects(ctx, { lines: [{ entity: line, action: "deleted" }] });
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(
+      ctx,
+      input,
+      result?.lineId ?? null,
+      "wms.audit.receivingLine.create",
+      "Create receiving line",
+      WMS_RECEIVING_LINE_RESOURCE
+    );
+    const after = snapshots?.after;
+    return { ...base, snapshotAfter: after, payload: { undo: { after } } };
+  }
+};
+const updateReceivingLineCommand = {
+  id: "wms.receiving-lines.update",
+  async prepare(rawInput, ctx) {
+    const id = requireId(rawInput?.id, "Receiving line");
+    const em = resolveEm(ctx);
+    const line = await loadReceivingLine(em, ctx, id);
+    return { before: snapshotReceivingLine(line) };
+  },
+  async execute(rawInput, ctx) {
+    assertReceivingLineLifecycleFieldsForbidden(rawInput);
+    const input = receivingLineUpdateSchema.parse(rawInput ?? {});
+    const rootEm = resolveEm(ctx);
+    const line = await rootEm.transactional(async (trx) => {
+      const unlocked = await findOneWithDecryption(
+        trx,
+        ReceivingLine,
+        { id: input.id, deletedAt: null },
+        void 0,
+        resolveScope(ctx)
+      );
+      if (!unlocked) throw new CrudHttpError(404, { error: "Receiving line not found." });
+      ensureTenantScope(ctx, unlocked.tenantId);
+      ensureOrganizationScope(ctx, unlocked.organizationId);
+      const asnId = typeof unlocked.asn === "string" ? unlocked.asn : unlocked.asn.id;
+      const scope = { tenantId: unlocked.tenantId, organizationId: unlocked.organizationId };
+      const asn = await findOneWithDecryption(
+        trx,
+        Asn,
+        { id: asnId, deletedAt: null },
+        { lockMode: LockMode.PESSIMISTIC_WRITE },
+        scope
+      );
+      if (!asn) throw new CrudHttpError(404, { error: "ASN not found." });
+      ensureTenantScope(ctx, asn.tenantId);
+      ensureOrganizationScope(ctx, asn.organizationId);
+      assertAsnMutable(asn);
+      const locked = await findOneWithDecryption(
+        trx,
+        ReceivingLine,
+        { id: input.id, deletedAt: null },
+        { lockMode: LockMode.PESSIMISTIC_WRITE },
+        scope
+      );
+      if (!locked) throw new CrudHttpError(404, { error: "Receiving line not found." });
+      ensureTenantScope(ctx, locked.tenantId);
+      ensureOrganizationScope(ctx, locked.organizationId);
+      await enforceCommandOptimisticLockWithGuards(ctx.container, {
+        resourceKind: WMS_RECEIVING_LINE_RESOURCE,
+        resourceId: locked.id,
+        current: locked.updatedAt,
+        request: ctx.request ?? null
+      });
+      if (hasAsnDeleteBlockingLineActivity([locked])) {
+        throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+      }
+      if (input.catalogVariantId !== void 0) locked.catalogVariantId = input.catalogVariantId;
+      if (input.expectedQty !== void 0) locked.expectedQty = toNumericString(input.expectedQty);
+      if (input.lotNumber !== void 0) {
+        locked.lotNumber = normalizeOptionalString(input.lotNumber ?? void 0);
+      }
+      if (input.serialNumbers !== void 0) locked.serialNumbers = input.serialNumbers;
+      if (input.targetStagingLocationId !== void 0) {
+        locked.targetStagingLocationId = input.targetStagingLocationId;
+      }
+      if (input.metadata !== void 0) locked.metadata = toJsonValue(input.metadata) ?? null;
+      await trx.flush();
+      return locked;
+    });
+    await emitAsnSideEffects(ctx, { lines: [{ entity: line, action: "updated" }] });
+    return { lineId: line.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    if (!result?.lineId) return null;
+    const em = resolveEm(ctx);
+    const line = await loadReceivingLine(em, ctx, result.lineId);
+    return snapshotReceivingLine(line);
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before?.id) return;
+    const em = resolveEm(ctx);
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const line = await withLockedAsnReceivingLine(
+      em,
+      ctx,
+      before.id,
+      scope,
+      { requireActiveLine: false },
+      async ({ asn, line: line2, trx }) => {
+        assertAsnMutable(asn);
+        if (hasAsnDeleteBlockingLineActivity([line2])) {
+          throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+        }
+        if (hasAsnDeleteBlockingLineActivity([before])) {
+          throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+        }
+        line2.catalogVariantId = before.catalogVariantId;
+        line2.expectedQty = before.expectedQty;
+        line2.receivedQty = before.receivedQty;
+        line2.lotNumber = before.lotNumber;
+        line2.serialNumbers = before.serialNumbers;
+        line2.qcStatus = before.qcStatus;
+        line2.targetStagingLocationId = before.targetStagingLocationId;
+        line2.rejectionReason = before.rejectionReason;
+        line2.metadata = before.metadata;
+        line2.deletedAt = null;
+        await trx.flush();
+        return line2;
+      }
+    );
+    if (!line) return;
+    await emitAsnSideEffects(ctx, { lines: [{ entity: line, action: "updated" }] });
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(
+      ctx,
+      input,
+      result?.lineId ?? null,
+      "wms.audit.receivingLine.update",
+      "Update receiving line",
+      WMS_RECEIVING_LINE_RESOURCE
+    );
+    const before = snapshots?.before;
+    const after = snapshots?.after;
+    return {
+      ...base,
+      snapshotBefore: before,
+      snapshotAfter: after,
+      payload: { undo: { before, after } }
+    };
+  }
+};
+const deleteReceivingLineCommand = {
+  id: "wms.receiving-lines.delete",
+  async prepare(rawInput, ctx) {
+    const id = requireId(rawInput?.id, "Receiving line");
+    const em = resolveEm(ctx);
+    const line = await loadReceivingLine(em, ctx, id);
+    return { before: snapshotReceivingLine(line) };
+  },
+  async execute(rawInput, ctx) {
+    const id = requireId(rawInput?.id, "Receiving line");
+    const rootEm = resolveEm(ctx);
+    const line = await rootEm.transactional(async (trx) => {
+      const unlocked = await findOneWithDecryption(
+        trx,
+        ReceivingLine,
+        { id, deletedAt: null },
+        void 0,
+        resolveScope(ctx)
+      );
+      if (!unlocked) throw new CrudHttpError(404, { error: "Receiving line not found." });
+      ensureTenantScope(ctx, unlocked.tenantId);
+      ensureOrganizationScope(ctx, unlocked.organizationId);
+      const asnId = typeof unlocked.asn === "string" ? unlocked.asn : unlocked.asn.id;
+      const scope = { tenantId: unlocked.tenantId, organizationId: unlocked.organizationId };
+      const asn = await findOneWithDecryption(
+        trx,
+        Asn,
+        { id: asnId, deletedAt: null },
+        { lockMode: LockMode.PESSIMISTIC_WRITE },
+        scope
+      );
+      if (!asn) throw new CrudHttpError(404, { error: "ASN not found." });
+      ensureTenantScope(ctx, asn.tenantId);
+      ensureOrganizationScope(ctx, asn.organizationId);
+      assertAsnMutable(asn);
+      const locked = await findOneWithDecryption(
+        trx,
+        ReceivingLine,
+        { id, deletedAt: null },
+        { lockMode: LockMode.PESSIMISTIC_WRITE },
+        scope
+      );
+      if (!locked) throw new CrudHttpError(404, { error: "Receiving line not found." });
+      ensureTenantScope(ctx, locked.tenantId);
+      ensureOrganizationScope(ctx, locked.organizationId);
+      await enforceCommandOptimisticLockWithGuards(ctx.container, {
+        resourceKind: WMS_RECEIVING_LINE_RESOURCE,
+        resourceId: locked.id,
+        current: locked.updatedAt,
+        request: ctx.request ?? null
+      });
+      if (hasAsnDeleteBlockingLineActivity([locked])) {
+        throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+      }
+      locked.deletedAt = /* @__PURE__ */ new Date();
+      await trx.flush();
+      return locked;
+    });
+    await emitAsnSideEffects(ctx, { lines: [{ entity: line, action: "deleted" }] });
+    return { lineId: line.id };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before?.id) return;
+    const em = resolveEm(ctx);
+    const scope = { tenantId: before.tenantId, organizationId: before.organizationId };
+    const line = await withLockedAsnReceivingLine(
+      em,
+      ctx,
+      before.id,
+      scope,
+      { requireActiveLine: false },
+      async ({ asn, line: line2, trx }) => {
+        assertAsnMutable(asn);
+        if (hasAsnDeleteBlockingLineActivity([line2])) {
+          throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+        }
+        if (hasAsnDeleteBlockingLineActivity([before])) {
+          throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+        }
+        line2.deletedAt = null;
+        await trx.flush();
+        return line2;
+      }
+    );
+    if (!line) return;
+    await emitAsnSideEffects(ctx, { lines: [{ entity: line, action: "updated" }] });
+  },
+  buildLog: async ({ input, result, ctx, snapshots }) => {
+    const base = await buildCrudLog(
+      ctx,
+      input,
+      result?.lineId ?? null,
+      "wms.audit.receivingLine.delete",
+      "Delete receiving line",
+      WMS_RECEIVING_LINE_RESOURCE
+    );
+    const before = snapshots?.before;
+    return { ...base, snapshotBefore: before, payload: { undo: { before } } };
+  }
+};
+async function ensureSerialReceiptPutaways(trx, scope, input) {
+  const links = [];
+  for (const serialNumber of input.serialNumbers) {
+    const putawayKey = buildAsnReceivePutawayKey({
+      attemptKey: input.attemptKey,
+      serialNumber
+    });
+    const existing = await findExistingPutawayForReceipt(trx, scope, putawayKey);
+    if (existing) {
+      links.push({ task: existing, created: false });
+      continue;
+    }
+    let lotId = input.lotId;
+    if (input.recreateWhenMissing) {
+      const cancelled = lotId == null ? await findCancelledPutawayForReceipt(trx, scope, putawayKey) : null;
+      if (lotId == null) lotId = cancelled?.lotId ?? null;
+      const availability = await resolveUncommittedStagingPutawayQuantity(
+        trx,
+        scope,
+        {
+          warehouseId: input.warehouseId,
+          sourceLocationId: input.sourceLocationId,
+          catalogVariantId: input.catalogVariantId,
+          lotId,
+          serialNumber
+        },
+        { lock: true }
+      );
+      const canCreate = availability != null && shouldRecreatePutawayOnAlreadyAtTarget({
+        requestedQuantity: 1,
+        remainingAvailable: availability.remaining
+      });
+      if (!canCreate) {
+        const covering = availability ? selectCoveringOpenPutawayTask(
+          availability.openTasks.map((task) => ({
+            task,
+            quantity: toNumber(task.quantity)
+          })),
+          1
+        ) : null;
+        if (covering) links.push({ task: covering.task, created: false });
+        continue;
+      }
+    }
+    links.push(
+      await findOrCreatePutawayForReceipt(trx, scope, putawayKey, {
+        warehouseId: input.warehouseId,
+        sourceLocationId: input.sourceLocationId,
+        catalogVariantId: input.catalogVariantId,
+        lotId,
+        quantity: 1,
+        serialNumber,
+        asnId: input.asnId,
+        lineId: input.lineId,
+        metadata: input.metadata ?? null
+      })
+    );
+  }
+  return links;
+}
+async function emitCreatedReceiptPutaways(ctx, scope, putaways, warehouseId) {
+  for (const entry of putaways) {
+    if (!entry.created) continue;
+    await emitAsnReceivePutawayCreatedSideEffects(ctx, scope, entry.task, warehouseId);
+  }
+}
+const receiveAsnLineCommand = {
+  id: "wms.asns.receive-line",
+  // Stock-affecting on QC pass — align with Phase 1 inventory undo policy.
+  isUndoable: false,
+  async execute(rawInput, ctx) {
+    const input = asnReceiveLineSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, input.tenantId);
+    ensureOrganizationScope(ctx, input.organizationId);
+    const rootEm = resolveEm(ctx);
+    const scope = resolveScope(ctx, input);
+    const serialNumbers = resolveSerialNumbers(input);
+    assertUniqueSerialNumbers(serialNumbers);
+    if (!shouldWriteStockOnQcPass(input.qcStatus)) {
+      const locked = await rootEm.transactional(async (trx) => {
+        const asn = await findOneWithDecryption(
+          trx,
+          Asn,
+          { id: input.asnId, deletedAt: null },
+          { lockMode: LockMode.PESSIMISTIC_WRITE },
+          scope
+        );
+        if (!asn) throw new CrudHttpError(404, { error: "ASN not found." });
+        ensureTenantScope(ctx, asn.tenantId);
+        ensureOrganizationScope(ctx, asn.organizationId);
+        assertAsnMutable(asn);
+        await enforceCommandOptimisticLockWithGuards(ctx.container, {
+          resourceKind: WMS_ASN_RESOURCE,
+          resourceId: asn.id,
+          current: asn.updatedAt,
+          request: ctx.request ?? null
+        });
+        const line = await findOneWithDecryption(
+          trx,
+          ReceivingLine,
+          { id: input.lineId, deletedAt: null },
+          { lockMode: LockMode.PESSIMISTIC_WRITE },
+          scope
+        );
+        if (!line) throw new CrudHttpError(404, { error: "Receiving line not found." });
+        ensureTenantScope(ctx, line.tenantId);
+        ensureOrganizationScope(ctx, line.organizationId);
+        const lineAsnId = typeof line.asn === "string" ? line.asn : line.asn.id;
+        if (lineAsnId !== asn.id) {
+          throw new CrudHttpError(422, { error: "line_asn_mismatch" });
+        }
+        assertAsnQcTransition(line.qcStatus, input.qcStatus);
+        const priorReceivedQty = toNumber(line.receivedQty);
+        const attempt = resolveAsnReceiveAttempt({
+          lineId: line.id,
+          priorReceivedQty,
+          receivedQty: input.receivedQty,
+          targetReceivedQty: input.targetReceivedQty,
+          idempotencyKey: input.idempotencyKey
+        });
+        const warehouseId = typeof asn.warehouse === "string" ? asn.warehouse : asn.warehouse.id;
+        const previousStatus = asn.status;
+        const receivingStarted = asn.status === "draft" || asn.status === "in_transit";
+        let lineUpdated = false;
+        if (attempt.applyQty > 1e-6 && priorReceivedQty === toNumber(line.receivedQty)) {
+          if (serialNumbers.length > 0 && priorReceivedQty > 1e-6) {
+            assertIncomingSerialsAreNew(serialNumbers, line.serialNumbers);
+          }
+          line.receivedQty = toNumericString(attempt.targetReceivedQty);
+          line.qcStatus = "failed";
+          line.rejectionReason = normalizeOptionalString(input.rejectionReason) ?? line.rejectionReason ?? null;
+          if (input.lotNumber !== void 0) {
+            line.lotNumber = normalizeOptionalString(input.lotNumber) ?? line.lotNumber ?? null;
+          }
+          recordReceivedSerials(line, serialNumbers, priorReceivedQty);
+          if (asn.status === "draft") asn.status = "in_transit";
+          asn.updatedAt = /* @__PURE__ */ new Date();
+          line.updatedAt = /* @__PURE__ */ new Date();
+          await trx.flush();
+          lineUpdated = true;
+        }
+        return {
+          asn,
+          line,
+          warehouseId,
+          previousStatus,
+          receivingStarted,
+          lineUpdated
+        };
+      });
+      if (locked.lineUpdated) {
+        await emitAsnSideEffects(ctx, {
+          asns: [{ entity: locked.asn, action: "updated" }],
+          lines: [{ entity: locked.line, action: "updated" }]
+        });
+      }
+      if (locked.lineUpdated && locked.receivingStarted && locked.previousStatus === "draft") {
+        void emitWmsEvent("wms.asn.receiving_started", {
+          id: locked.asn.id,
+          warehouseId: locked.warehouseId,
+          tenantId: scope.tenantId,
+          organizationId: scope.organizationId
+        }).catch(() => void 0);
+      }
+      if (locked.lineUpdated) {
+        void emitWmsEvent("wms.inventory.receipt_qc_failed", {
+          id: locked.line.id,
+          asnId: locked.asn.id,
+          lineId: locked.line.id,
+          catalogVariantId: locked.line.catalogVariantId,
+          receivedQty: toNumericString(input.receivedQty),
+          rejectionReason: locked.line.rejectionReason,
+          tenantId: scope.tenantId,
+          organizationId: scope.organizationId
+        }).catch(() => void 0);
+      }
+      return {
+        movementIds: [],
+        putawayTaskIds: [],
+        lineId: locked.line.id,
+        asnId: locked.asn.id,
+        receivedQty: toNumber(locked.line.receivedQty),
+        asnUpdatedAt: locked.asn.updatedAt.toISOString()
+      };
+    }
+    if (!input.targetStagingLocationId) {
+      throw new CrudHttpError(422, { error: "staging_location_required" });
+    }
+    const outcome = await rootEm.transactional(async (trx) => {
+      const asn = await findOneWithDecryption(
+        trx,
+        Asn,
+        { id: input.asnId, deletedAt: null },
+        { lockMode: LockMode.PESSIMISTIC_WRITE },
+        scope
+      );
+      if (!asn) throw new CrudHttpError(404, { error: "ASN not found." });
+      ensureTenantScope(ctx, asn.tenantId);
+      ensureOrganizationScope(ctx, asn.organizationId);
+      assertAsnMutable(asn);
+      await enforceCommandOptimisticLockWithGuards(ctx.container, {
+        resourceKind: WMS_ASN_RESOURCE,
+        resourceId: asn.id,
+        current: asn.updatedAt,
+        request: ctx.request ?? null
+      });
+      const line = await findOneWithDecryption(
+        trx,
+        ReceivingLine,
+        { id: input.lineId, deletedAt: null },
+        { lockMode: LockMode.PESSIMISTIC_WRITE },
+        scope
+      );
+      if (!line) throw new CrudHttpError(404, { error: "Receiving line not found." });
+      ensureTenantScope(ctx, line.tenantId);
+      ensureOrganizationScope(ctx, line.organizationId);
+      const lineAsnId = typeof line.asn === "string" ? line.asn : line.asn.id;
+      if (lineAsnId !== asn.id) {
+        throw new CrudHttpError(422, { error: "line_asn_mismatch" });
+      }
+      assertAsnQcTransition(line.qcStatus, input.qcStatus);
+      const warehouseId = typeof asn.warehouse === "string" ? asn.warehouse : asn.warehouse.id;
+      await requireStagingLocation(trx, ctx, input.targetStagingLocationId, warehouseId, scope);
+      const priorReceivedQty = toNumber(line.receivedQty);
+      const attempt = resolveAsnReceiveAttempt({
+        lineId: line.id,
+        priorReceivedQty,
+        receivedQty: input.receivedQty,
+        targetReceivedQty: input.targetReceivedQty,
+        idempotencyKey: input.idempotencyKey
+      });
+      const previousStatus = asn.status;
+      const receivingStarted = asn.status === "draft" || asn.status === "in_transit";
+      const aggregatePutawayKey = buildAsnReceivePutawayKey({ attemptKey: attempt.attemptKey });
+      const alreadyAtTarget = attempt.applyQty <= 1e-6;
+      const trackedSerials = serialNumbers.length > 0 ? serialNumbers : normalizeStoredSerials(line.serialNumbers);
+      const putawayShared = {
+        attemptKey: attempt.attemptKey,
+        warehouseId,
+        sourceLocationId: input.targetStagingLocationId,
+        catalogVariantId: line.catalogVariantId,
+        asnId: asn.id,
+        lineId: line.id,
+        metadata: input.metadata ?? null
+      };
+      if (alreadyAtTarget) {
+        if (trackedSerials.length > 0) {
+          const putaways3 = await ensureSerialReceiptPutaways(trx, scope, {
+            ...putawayShared,
+            serialNumbers: trackedSerials,
+            recreateWhenMissing: true,
+            lotId: input.lotId ?? null
+          });
+          return {
+            movementResults: [],
+            putaways: putaways3,
+            lineUpdated: false,
+            asn,
+            line,
+            warehouseId,
+            previousStatus,
+            receivingStarted,
+            applyQty: 0,
+            alreadyAtTarget: true,
+            currentReceivedQty: toNumber(line.receivedQty)
+          };
+        }
+        const existingPutaway = await findExistingPutawayForReceipt(trx, scope, aggregatePutawayKey);
+        const putaways2 = [];
+        if (existingPutaway) {
+          putaways2.push({ task: existingPutaway, created: false });
+        } else if (shouldEnsurePutawayOnAlreadyAtTarget(existingPutaway)) {
+          const cancelled = await findCancelledPutawayForReceipt(trx, scope, aggregatePutawayKey);
+          const lotId2 = input.lotId ?? cancelled?.lotId ?? null;
+          const quantity = resolvePutawayQuantityForAlreadyAtTargetRetry({
+            cancelledTaskQuantity: cancelled ? toNumber(cancelled.quantity) : null,
+            absoluteTargetQty: attempt.targetReceivedQty
+          });
+          if (quantity > 1e-6) {
+            const availability = await resolveUncommittedStagingPutawayQuantity(
+              trx,
+              scope,
+              {
+                warehouseId,
+                sourceLocationId: input.targetStagingLocationId,
+                catalogVariantId: line.catalogVariantId,
+                lotId: lotId2
+              },
+              { lock: true }
+            );
+            if (availability && shouldRecreatePutawayOnAlreadyAtTarget({
+              requestedQuantity: quantity,
+              remainingAvailable: availability.remaining
+            })) {
+              putaways2.push(
+                await findOrCreatePutawayForReceipt(trx, scope, aggregatePutawayKey, {
+                  warehouseId,
+                  sourceLocationId: input.targetStagingLocationId,
+                  catalogVariantId: line.catalogVariantId,
+                  lotId: lotId2,
+                  quantity,
+                  asnId: asn.id,
+                  lineId: line.id,
+                  metadata: input.metadata ?? null
+                })
+              );
+            } else if (availability) {
+              const covering = selectCoveringOpenPutawayTask(
+                availability.openTasks.map((task) => ({
+                  task,
+                  quantity: toNumber(task.quantity)
+                })),
+                quantity
+              );
+              if (covering) putaways2.push({ task: covering.task, created: false });
+            }
+          }
+        }
+        return {
+          movementResults: [],
+          putaways: putaways2,
+          lineUpdated: false,
+          asn,
+          line,
+          warehouseId,
+          previousStatus,
+          receivingStarted,
+          applyQty: 0,
+          alreadyAtTarget: true,
+          currentReceivedQty: toNumber(line.receivedQty)
+        };
+      }
+      if (serialNumbers.length > 0 && priorReceivedQty > 1e-6) {
+        assertIncomingSerialsAreNew(serialNumbers, line.serialNumbers);
+      }
+      if (serialNumbers.length > 0 && serialNumbers.length !== attempt.applyQty) {
+        throw new CrudHttpError(422, { error: "tracking_required" });
+      }
+      const movementResults = [];
+      const receiveOnce = async (quantity, serialNumber) => {
+        const movementPutawayKey = buildAsnReceivePutawayKey({
+          attemptKey: attempt.attemptKey,
+          serialNumber
+        });
+        const receiveInput = {
+          organizationId: scope.organizationId,
+          tenantId: scope.tenantId,
+          warehouseId,
+          locationId: input.targetStagingLocationId,
+          catalogVariantId: line.catalogVariantId,
+          lotId: input.lotId,
+          lotNumber: input.lotNumber ?? line.lotNumber ?? void 0,
+          serialNumber,
+          quantity,
+          referenceType: "po",
+          referenceId: buildAsnReceiveReferenceId({
+            attemptKey: attempt.attemptKey,
+            serialNumber
+          }),
+          performedBy: input.performedBy,
+          receivedAt: input.receivedAt,
+          reasonCode: "asn_receive",
+          metadata: {
+            ...input.metadata ?? {},
+            asnId: asn.id,
+            asnReferenceNumber: asn.referenceNumber ?? null,
+            receivingLineId: line.id,
+            putawayKey: movementPutawayKey,
+            source: "asn_receive"
+          }
+        };
+        movementResults.push(await applyInventoryReceiveInTransaction(trx, ctx, receiveInput));
+      };
+      if (serialNumbers.length > 0) {
+        for (const serialNumber of serialNumbers) {
+          await receiveOnce(1, serialNumber);
+        }
+      } else {
+        await receiveOnce(attempt.applyQty);
+      }
+      const lotId = input.lotId ?? movementResults.find((result) => result.lotId)?.lotId ?? null;
+      const putaways = serialNumbers.length > 0 ? await ensureSerialReceiptPutaways(trx, scope, {
+        ...putawayShared,
+        serialNumbers,
+        recreateWhenMissing: false,
+        lotId
+      }) : [
+        await findOrCreatePutawayForReceipt(trx, scope, aggregatePutawayKey, {
+          warehouseId,
+          sourceLocationId: input.targetStagingLocationId,
+          catalogVariantId: line.catalogVariantId,
+          lotId,
+          quantity: attempt.applyQty,
+          asnId: asn.id,
+          lineId: line.id,
+          metadata: input.metadata ?? null
+        })
+      ];
+      const currentReceived = toNumber(line.receivedQty);
+      let lineUpdated = false;
+      if (currentReceived + 1e-6 < attempt.targetReceivedQty) {
+        line.receivedQty = toNumericString(attempt.targetReceivedQty);
+        line.qcStatus = "passed";
+        line.targetStagingLocationId = input.targetStagingLocationId;
+        line.rejectionReason = null;
+        if (input.lotNumber !== void 0) {
+          line.lotNumber = normalizeOptionalString(input.lotNumber) ?? line.lotNumber ?? null;
+        }
+        recordReceivedSerials(line, serialNumbers, priorReceivedQty);
+        if (asn.status === "draft") asn.status = "in_transit";
+        asn.updatedAt = /* @__PURE__ */ new Date();
+        line.updatedAt = /* @__PURE__ */ new Date();
+        await trx.flush();
+        lineUpdated = true;
+      }
+      return {
+        movementResults,
+        putaways,
+        lineUpdated,
+        asn,
+        line,
+        warehouseId,
+        previousStatus,
+        receivingStarted,
+        applyQty: attempt.applyQty,
+        alreadyAtTarget: false,
+        currentReceivedQty: toNumber(line.receivedQty)
+      };
+    });
+    if (outcome.alreadyAtTarget) {
+      await emitCreatedReceiptPutaways(ctx, scope, outcome.putaways, outcome.warehouseId);
+      return {
+        movementIds: [],
+        putawayTaskIds: outcome.putaways.map((entry) => entry.task.id),
+        lineId: outcome.line.id,
+        asnId: outcome.asn.id,
+        receivedQty: outcome.currentReceivedQty,
+        asnUpdatedAt: outcome.asn.updatedAt.toISOString()
+      };
+    }
+    for (const movementResult of outcome.movementResults) {
+      await emitInventoryReceiveSideEffects(ctx, movementResult);
+    }
+    await emitCreatedReceiptPutaways(ctx, scope, outcome.putaways, outcome.warehouseId);
+    if (outcome.lineUpdated) {
+      await emitAsnSideEffects(ctx, {
+        asns: [{ entity: outcome.asn, action: "updated" }],
+        lines: [{ entity: outcome.line, action: "updated" }]
+      });
+      if (outcome.receivingStarted && outcome.previousStatus === "draft") {
+        void emitWmsEvent("wms.asn.receiving_started", {
+          id: outcome.asn.id,
+          warehouseId: outcome.warehouseId,
+          tenantId: scope.tenantId,
+          organizationId: scope.organizationId
+        }).catch(() => void 0);
+      }
+      void emitWmsEvent("wms.asn.line_received", {
+        id: outcome.line.id,
+        asnId: outcome.asn.id,
+        lineId: outcome.line.id,
+        movementIds: outcome.movementResults.map((result) => result.movementId),
+        catalogVariantId: outcome.line.catalogVariantId,
+        receivedQty: toNumericString(outcome.applyQty),
+        locationId: input.targetStagingLocationId,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId
+      }).catch(() => void 0);
+    }
+    if (outcome.putaways.length === 0) {
+      throw new CrudHttpError(500, { error: "[internal] putaway missing after QC-pass receive" });
+    }
+    return {
+      movementIds: outcome.movementResults.map((result) => result.movementId),
+      putawayTaskIds: outcome.putaways.map((entry) => entry.task.id),
+      lineId: outcome.line.id,
+      asnId: outcome.asn.id,
+      receivedQty: toNumber(outcome.line.receivedQty),
+      asnUpdatedAt: outcome.asn.updatedAt.toISOString()
+    };
+  },
+  buildLog: async ({ input, result, ctx }) => {
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("wms.audit.asn.receiveLine", "Receive ASN line"),
+      resourceKind: WMS_ASN_RESOURCE,
+      resourceId: result?.asnId ?? input?.asnId ?? null,
+      parentResourceKind: WMS_RECEIVING_LINE_RESOURCE,
+      parentResourceId: result?.lineId ?? input?.lineId ?? null,
+      tenantId: input?.tenantId ?? ctx.auth?.tenantId ?? null,
+      organizationId: input?.organizationId ?? ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null,
+      context: { cacheAliases: [WMS_INVENTORY_BALANCE_RESOURCE, WMS_RECEIVING_LINE_RESOURCE] }
+    };
+  }
+};
+const closeAsnCommand = {
+  id: "wms.asns.close",
+  isUndoable: false,
+  async execute(rawInput, ctx) {
+    const input = asnCloseSchema.parse(rawInput ?? {});
+    ensureTenantScope(ctx, input.tenantId);
+    ensureOrganizationScope(ctx, input.organizationId);
+    const em = resolveEm(ctx);
+    const scope = resolveScope(ctx, input);
+    const locked = await em.transactional(async (trx) => {
+      const asn = await findOneWithDecryption(
+        trx,
+        Asn,
+        { id: input.id, deletedAt: null },
+        { lockMode: LockMode.PESSIMISTIC_WRITE },
+        scope
+      );
+      if (!asn) throw new CrudHttpError(404, { error: "ASN not found." });
+      ensureTenantScope(ctx, asn.tenantId);
+      ensureOrganizationScope(ctx, asn.organizationId);
+      await enforceCommandOptimisticLockWithGuards(ctx.container, {
+        resourceKind: WMS_ASN_RESOURCE,
+        resourceId: asn.id,
+        current: asn.updatedAt,
+        request: ctx.request ?? null
+      });
+      if (asn.status === "closed") {
+        return { asn, transitioned: false, emitReceived: false };
+      }
+      if (asn.status === "received") {
+        asn.status = "closed";
+        await trx.flush();
+        return { asn, transitioned: true, emitReceived: false };
+      }
+      const lines = await findWithDecryption(
+        trx,
+        ReceivingLine,
+        { asn: asn.id, deletedAt: null },
+        void 0,
+        { tenantId: asn.tenantId, organizationId: asn.organizationId }
+      );
+      if (!isAsnCloseable(lines, !!input.closeWhenShort)) {
+        throw new CrudHttpError(409, { error: "invalid_receipt_state" });
+      }
+      asn.status = "received";
+      await trx.flush();
+      return { asn, transitioned: true, emitReceived: true };
+    });
+    if (locked.transitioned) {
+      await emitAsnSideEffects(ctx, { asns: [{ entity: locked.asn, action: "updated" }] });
+    }
+    if (locked.emitReceived) {
+      void emitWmsEvent("wms.asn.received", {
+        id: locked.asn.id,
+        status: locked.asn.status,
+        closeWhenShort: !!input.closeWhenShort,
+        tenantId: locked.asn.tenantId,
+        organizationId: locked.asn.organizationId
+      }).catch(() => void 0);
+    }
+    return { asnId: locked.asn.id, status: locked.asn.status };
+  },
+  buildLog: async ({ input, result, ctx }) => buildCrudLog(ctx, input, result?.asnId ?? null, "wms.audit.asn.close", "Complete ASN", WMS_ASN_RESOURCE)
+};
+registerCommand(createAsnCommand);
+registerCommand(updateAsnCommand);
+registerCommand(deleteAsnCommand);
+registerCommand(createReceivingLineCommand);
+registerCommand(updateReceivingLineCommand);
+registerCommand(deleteReceivingLineCommand);
+registerCommand(receiveAsnLineCommand);
+registerCommand(closeAsnCommand);
+//# sourceMappingURL=asn.js.map