@flaks/onerecord 0.1.2 → 0.2.0

package/dist/codes/fsu-event-codes.js

@@ -1,30 +1,32 @@
-// Codes verified against IATA-Cargo XFSU-Status-Codes.xlsx via the fixture
-// at test/fixtures/iata/xfsu-status-codes.json (Task 37a). Per spec
-// acceptance #2: exactly 26 codes.
+// Codes derived from IATA-Cargo XFSU Status Codes.xlsx via the sibling
+// onerecord-xlsx-tools convert script; pinned by SHA256 of the upstream
+// xlsx blob in test/fixtures/iata/xfsu-status-codes.json. v0.2.0 adopted
+// the upstream 26 codes (Phase 0.2 Outcome C, see spec §2.4); 6 codes
+// changed in each direction vs. the v0.1.x hand-pin.
 export const FSU_EVENT_CODES = Object.freeze({
     ARR: 'ARR',
     AWD: 'AWD',
     AWR: 'AWR',
     BKD: 'BKD',
     CCD: 'CCD',
-    CLR: 'CLR',
     CRC: 'CRC',
     DDL: 'DDL',
     DEP: 'DEP',
     DIS: 'DIS',
     DLV: 'DLV',
+    DOC: 'DOC',
+    DPU: 'DPU',
+    FIW: 'FIW',
     FOH: 'FOH',
-    FOO: 'FOO',
-    FWB: 'FWB',
+    FOW: 'FOW',
     MAN: 'MAN',
     NFD: 'NFD',
-    OFD: 'OFD',
+    OCI: 'OCI',
+    OSI: 'OSI',
     PRE: 'PRE',
     RCF: 'RCF',
-    RCM: 'RCM',
     RCS: 'RCS',
     RCT: 'RCT',
-    RCV: 'RCV',
     TFD: 'TFD',
     TGC: 'TGC',
     TRM: 'TRM',

package/dist/codes/fsu-event-codes.js.map

@@ -1 +1 @@
-{"version":3,"file":"fsu-event-codes.js","sourceRoot":"","sources":["../../src/codes/fsu-event-codes.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,oEAAoE;AACpE,mCAAmC;AACnC,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3C,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;CACF,CAAC,CAAA;AASX,MAAM,UAAU,sBAAsB,CAAC,OAAgB;IACrD,OAAO,eAAe,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC"}
+{"version":3,"file":"fsu-event-codes.js","sourceRoot":"","sources":["../../src/codes/fsu-event-codes.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,wEAAwE;AACxE,yEAAyE;AACzE,sEAAsE;AACtE,qDAAqD;AACrD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3C,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;CACF,CAAC,CAAA;AASX,MAAM,UAAU,sBAAsB,CAAC,OAAgB;IACrD,OAAO,eAAe,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC"}

package/dist/dispatch/context-order.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Per JSON-LD 1.1 §3.7, when `@context` is an array, later items
+ * override earlier ones for term definitions. The OneRecord spec §7.1
+ * doesn't pin the array form explicitly, but consumers relying on the
+ * default `assertContextAllowed`'s set semantics would silently accept
+ * `["https://onerecord.iata.org/ns/cargo", "https://attacker.com/ns"]`
+ * — where the later URL could override cargo term definitions.
+ *
+ * Closes deviation #10 (v0.2.0 — deferral E). Opt-in via dispatch only:
+ * default per-class deserializers preserve v0.1.x set semantics for
+ * non-breaking compatibility.
+ */
+export interface ContextOrderResult {
+    ok: boolean;
+    /** When ok is false, the unallowed last element. */
+    lastUnallowed?: string;
+}
+/**
+ * Check that the LAST element of an array `@context` is in the
+ * allowlist (= the "effective" context for term definitions). String-form
+ * `@context` is delegated to `assertContextAllowed` (set semantics);
+ * this function only fires for array form.
+ *
+ * Returns `{ ok: true }` for non-arrays or arrays where the last
+ * element is allowed.
+ */
+export declare function checkContextOrder(context: unknown, allowedContexts?: readonly string[]): ContextOrderResult;
+//# sourceMappingURL=context-order.d.ts.map

package/dist/dispatch/context-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-order.d.ts","sourceRoot":"","sources":["../../src/dispatch/context-order.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,OAAO,CAAA;IACX,oDAAoD;IACpD,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,eAAe,GAAE,SAAS,MAAM,EAAqB,GACpD,kBAAkB,CAMpB"}

package/dist/dispatch/context-order.js

@@ -0,0 +1,21 @@
+import { ALLOWED_CONTEXTS } from '../context.js';
+/**
+ * Check that the LAST element of an array `@context` is in the
+ * allowlist (= the "effective" context for term definitions). String-form
+ * `@context` is delegated to `assertContextAllowed` (set semantics);
+ * this function only fires for array form.
+ *
+ * Returns `{ ok: true }` for non-arrays or arrays where the last
+ * element is allowed.
+ */
+export function checkContextOrder(context, allowedContexts = ALLOWED_CONTEXTS) {
+    if (!Array.isArray(context) || context.length === 0)
+        return { ok: true };
+    const last = context[context.length - 1];
+    if (typeof last !== 'string')
+        return { ok: true }; // shape error — handled elsewhere
+    if (allowedContexts.includes(last))
+        return { ok: true };
+    return { ok: false, lastUnallowed: last };
+}
+//# sourceMappingURL=context-order.js.map

package/dist/dispatch/context-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-order.js","sourceRoot":"","sources":["../../src/dispatch/context-order.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAqBhD;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAgB,EAChB,kBAAqC,gBAAgB;IAErD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAA;IACxE,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IACxC,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAA,CAAC,kCAAkC;IACpF,IAAI,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAA;IACvD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,CAAA;AAC3C,CAAC"}

package/dist/dispatch/domain-constraints.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Domain-semantic constraints that the v0.1.x Zod schemas mark as
+ * optional but spec §5.x requires. Used by `dispatchGraphWalk` to emit
+ * `domain_constraint_violation` for missing-but-required fields.
+ *
+ * Closes deviation #6 PARTIALLY (v0.2 — deferral F):
+ *  - graph-cardinality (this file) — DONE
+ *  - AWB number consistency between Waybill ↔ embedded Shipments — v0.3
+ *  - total-pieces / total-weight sums between Shipment ↔ Pieces — v0.3
+ *  - reference resolvability for cross-graph IRIs — v0.3
+ *
+ * v0.2 scope chosen for high spec-fidelity-per-LOC ratio: cardinality
+ * is a clear-cut spec rule (`MUST have`) and surfaces meaningful
+ * violations early. The other sub-items require either deeper graph
+ * traversal (sums) or external resolution (resolvability).
+ *
+ * Opt-in via the dispatch path; default per-class deserializers stay
+ * v0.1.x-permissive.
+ */
+export interface DomainConstraint {
+    /** Field that must be present on the root LO. */
+    field: string;
+    /** Cardinality requirement (`required` = present + non-null). */
+    cardinality: 'required';
+    /** Spec section reference for the constraint. */
+    specRef: string;
+}
+export declare const DOMAIN_CONSTRAINTS: Readonly<Record<string, DomainConstraint[]>>;
+export interface DomainConstraintViolation {
+    className: string;
+    field: string;
+    expected: 'required';
+    specRef: string;
+}
+/**
+ * Validate root-level cardinality constraints for the given root class.
+ * Returns the FIRST missing-required-field violation, or undefined if all
+ * required fields are present.
+ *
+ * Only checks root-level constraints — nested LO-in-LO cardinality is
+ * deferred to v0.3 (alongside the other deviation #6 sub-items).
+ */
+export declare function checkDomainConstraints(rootClass: string, root: Record<string, unknown>): DomainConstraintViolation | undefined;
+//# sourceMappingURL=domain-constraints.d.ts.map

package/dist/dispatch/domain-constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-constraints.d.ts","sourceRoot":"","sources":["../../src/dispatch/domain-constraints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAA;IACb,iEAAiE;IACjE,WAAW,EAAE,UAAU,CAAA;IACvB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAe1E,CAAA;AAEF,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,UAAU,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,yBAAyB,GAAG,SAAS,CAuBvC"}

package/dist/dispatch/domain-constraints.js

@@ -0,0 +1,69 @@
+/**
+ * Domain-semantic constraints that the v0.1.x Zod schemas mark as
+ * optional but spec §5.x requires. Used by `dispatchGraphWalk` to emit
+ * `domain_constraint_violation` for missing-but-required fields.
+ *
+ * Closes deviation #6 PARTIALLY (v0.2 — deferral F):
+ *  - graph-cardinality (this file) — DONE
+ *  - AWB number consistency between Waybill ↔ embedded Shipments — v0.3
+ *  - total-pieces / total-weight sums between Shipment ↔ Pieces — v0.3
+ *  - reference resolvability for cross-graph IRIs — v0.3
+ *
+ * v0.2 scope chosen for high spec-fidelity-per-LOC ratio: cardinality
+ * is a clear-cut spec rule (`MUST have`) and surfaces meaningful
+ * violations early. The other sub-items require either deeper graph
+ * traversal (sums) or external resolution (resolvability).
+ *
+ * Opt-in via the dispatch path; default per-class deserializers stay
+ * v0.1.x-permissive.
+ */
+export const DOMAIN_CONSTRAINTS = Object.freeze({
+    Waybill: [
+        {
+            field: 'shipmentInformation',
+            cardinality: 'required',
+            specRef: 'data model 3.2 §5.1',
+        },
+    ],
+    Shipment: [
+        {
+            field: 'containedPieces',
+            cardinality: 'required',
+            specRef: 'data model 3.2 §5.2',
+        },
+    ],
+});
+/**
+ * Validate root-level cardinality constraints for the given root class.
+ * Returns the FIRST missing-required-field violation, or undefined if all
+ * required fields are present.
+ *
+ * Only checks root-level constraints — nested LO-in-LO cardinality is
+ * deferred to v0.3 (alongside the other deviation #6 sub-items).
+ */
+export function checkDomainConstraints(rootClass, root) {
+    const constraints = DOMAIN_CONSTRAINTS[rootClass];
+    if (!constraints)
+        return undefined;
+    for (const c of constraints) {
+        const v = root[c.field];
+        if (v === undefined || v === null) {
+            return {
+                className: rootClass,
+                field: c.field,
+                expected: c.cardinality,
+                specRef: c.specRef,
+            };
+        }
+        if (Array.isArray(v) && v.length === 0) {
+            return {
+                className: rootClass,
+                field: c.field,
+                expected: c.cardinality,
+                specRef: c.specRef,
+            };
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=domain-constraints.js.map

package/dist/dispatch/domain-constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-constraints.js","sourceRoot":"","sources":["../../src/dispatch/domain-constraints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAWH,MAAM,CAAC,MAAM,kBAAkB,GAAiD,MAAM,CAAC,MAAM,CAAC;IAC5F,OAAO,EAAE;QACP;YACE,KAAK,EAAE,qBAAqB;YAC5B,WAAW,EAAE,UAAU;YACvB,OAAO,EAAE,qBAAqB;SAC/B;KACF;IACD,QAAQ,EAAE;QACR;YACE,KAAK,EAAE,iBAAiB;YACxB,WAAW,EAAE,UAAU;YACvB,OAAO,EAAE,qBAAqB;SAC/B;KACF;CACF,CAAC,CAAA;AASF;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CACpC,SAAiB,EACjB,IAA6B;IAE7B,MAAM,WAAW,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAA;IACjD,IAAI,CAAC,WAAW;QAAE,OAAO,SAAS,CAAA;IAClC,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;QACvB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;YAClC,OAAO;gBACL,SAAS,EAAE,SAAS;gBACpB,KAAK,EAAE,CAAC,CAAC,KAAK;gBACd,QAAQ,EAAE,CAAC,CAAC,WAAW;gBACvB,OAAO,EAAE,CAAC,CAAC,OAAO;aACnB,CAAA;QACH,CAAC;QACD,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvC,OAAO;gBACL,SAAS,EAAE,SAAS;gBACpB,KAAK,EAAE,CAAC,CAAC,KAAK;gBACd,QAAQ,EAAE,CAAC,CAAC,WAAW;gBACvB,OAAO,EAAE,CAAC,CAAC,OAAO;aACnB,CAAA;QACH,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC"}

package/dist/dispatch/field-types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Static map: '<Class>.<field>' -> expected `@type` of an embedded
+ * object or IRI-referenced node. Used by `dispatchGraphWalk` to emit
+ * `wrong_type_for_endpoint` when an embedded node's `@type` does not
+ * match the field's contract.
+ *
+ * Coverage: every field in the 32-class data model that points at
+ * another logistics-object node (via `safeIri()` reference or
+ * embedded array). Scalar fields and external-endpoint URLs
+ * (`Subscription.notificationEndpoint`, `ServerInformation.serverEndpoint`)
+ * are intentionally omitted — those don't resolve to a OneRecord type.
+ *
+ * Polymorphic fields are marked with `'*'`. The graph-walker treats
+ * `'*'` as "any logistics-object type accepted".
+ *
+ * Maintenance: when adding a new class or field that holds a
+ * cross-reference, also add the expected-type mapping here. The
+ * graph-walker only checks mapped fields, so omission is silent —
+ * a missing entry means "not validated".
+ */
+export declare const FIELD_TYPES: Readonly<Record<string, string>>;
+/**
+ * Look up the expected `@type` for a given (className, fieldName).
+ * Returns `undefined` for fields not in the map (= not validated by
+ * the graph-walker — either scalar or out-of-scope external URL).
+ * Returns `'*'` for polymorphic fields where any logistics-object
+ * `@type` is valid.
+ */
+export declare function expectedTypeFor(className: string, fieldName: string): string | undefined;
+//# sourceMappingURL=field-types.d.ts.map

package/dist/dispatch/field-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-types.d.ts","sourceRoot":"","sources":["../../src/dispatch/field-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqEvD,CAAA;AAEF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAExF"}

package/dist/dispatch/field-types.js

@@ -0,0 +1,88 @@
+/**
+ * Static map: '<Class>.<field>' -> expected `@type` of an embedded
+ * object or IRI-referenced node. Used by `dispatchGraphWalk` to emit
+ * `wrong_type_for_endpoint` when an embedded node's `@type` does not
+ * match the field's contract.
+ *
+ * Coverage: every field in the 32-class data model that points at
+ * another logistics-object node (via `safeIri()` reference or
+ * embedded array). Scalar fields and external-endpoint URLs
+ * (`Subscription.notificationEndpoint`, `ServerInformation.serverEndpoint`)
+ * are intentionally omitted — those don't resolve to a OneRecord type.
+ *
+ * Polymorphic fields are marked with `'*'`. The graph-walker treats
+ * `'*'` as "any logistics-object type accepted".
+ *
+ * Maintenance: when adding a new class or field that holds a
+ * cross-reference, also add the expected-type mapping here. The
+ * graph-walker only checks mapped fields, so omission is silent —
+ * a missing entry means "not validated".
+ */
+export const FIELD_TYPES = Object.freeze({
+    // Access-delegation
+    'AccessDelegationRequest.accessDelegation': 'AccessDelegation',
+    'AccessDelegation.delegatedTo': 'Party',
+    'AccessDelegation.delegatedFrom': 'Party',
+    // Account number
+    'AccountNumber.issuedBy': 'Organization',
+    // Booking ecosystem
+    'Booking.forBookingRequest': 'BookingRequest',
+    'Booking.forBookingOption': 'BookingOption',
+    'BookingOption.forBookingRequest': 'BookingRequest',
+    'BookingOption.preferences': 'BookingPreferences',
+    'BookingOptionRequest.forBookingOption': 'BookingOption',
+    'BookingRequest.requestor': 'Party',
+    'BookingRequest.preferences': 'BookingPreferences',
+    'BookingSegment.transportMovement': 'TransportMovement',
+    'BookingSegment.loadingLocation': 'Location',
+    'BookingSegment.unloadingLocation': 'Location',
+    'BookingShipment.forShipment': 'Shipment',
+    // Change ecosystem
+    'Change.hasOperation': 'Operation', // embedded array, not IRI ref
+    'ChangeRequest.forLogisticsObject': '*', // polymorphic
+    'ChangeRequest.hasChange': 'Change',
+    // Handling
+    'HandlingService.provider': 'Party',
+    'HandlingService.forShipment': 'Shipment',
+    // Location ↔ Address
+    'Location.address': 'Address',
+    // Logistics event
+    'LogisticsEvent.eventLocation': 'Location',
+    'LogisticsEvent.relatedTransportMovement': 'TransportMovement',
+    // Notification
+    'Notification.relatedLogisticsObject': '*', // polymorphic
+    // Organization / Party
+    'Organization.address': 'Address',
+    'Organization.contactPersons': 'Person',
+    'Party.partyDetails': '*', // polymorphic — Person or Organization
+    'Party.accountNumbers': 'AccountNumber',
+    // Shipment / Piece
+    'Shipment.containedPieces': 'Piece',
+    'Shipment.consignee': 'Party',
+    'Shipment.shipper': 'Party',
+    // Subscription
+    'SubscriptionRequest.subscription': 'Subscription',
+    'Subscription.topic': '*', // polymorphic — any logistics object class IRI
+    'Subscription.subscriber': 'Party',
+    // Transport movement
+    'TransportMovement.departureLocation': 'Location',
+    'TransportMovement.arrivalLocation': 'Location',
+    'TransportMovement.movementTimes': 'MovementTime',
+    // Verification
+    'VerificationRequest.verification': 'Verification',
+    'Verification.verifiedObject': '*', // polymorphic
+    // Waybill
+    'Waybill.shipmentInformation': 'Shipment',
+    'Waybill.referredBookingOption': 'BookingOption',
+});
+/**
+ * Look up the expected `@type` for a given (className, fieldName).
+ * Returns `undefined` for fields not in the map (= not validated by
+ * the graph-walker — either scalar or out-of-scope external URL).
+ * Returns `'*'` for polymorphic fields where any logistics-object
+ * `@type` is valid.
+ */
+export function expectedTypeFor(className, fieldName) {
+    return FIELD_TYPES[`${className}.${fieldName}`];
+}
+//# sourceMappingURL=field-types.js.map

package/dist/dispatch/field-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-types.js","sourceRoot":"","sources":["../../src/dispatch/field-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAqC,MAAM,CAAC,MAAM,CAAC;IACzE,oBAAoB;IACpB,0CAA0C,EAAE,kBAAkB;IAC9D,8BAA8B,EAAE,OAAO;IACvC,gCAAgC,EAAE,OAAO;IAEzC,iBAAiB;IACjB,wBAAwB,EAAE,cAAc;IAExC,oBAAoB;IACpB,2BAA2B,EAAE,gBAAgB;IAC7C,0BAA0B,EAAE,eAAe;IAC3C,iCAAiC,EAAE,gBAAgB;IACnD,2BAA2B,EAAE,oBAAoB;IACjD,uCAAuC,EAAE,eAAe;IACxD,0BAA0B,EAAE,OAAO;IACnC,4BAA4B,EAAE,oBAAoB;IAClD,kCAAkC,EAAE,mBAAmB;IACvD,gCAAgC,EAAE,UAAU;IAC5C,kCAAkC,EAAE,UAAU;IAC9C,6BAA6B,EAAE,UAAU;IAEzC,mBAAmB;IACnB,qBAAqB,EAAE,WAAW,EAAE,8BAA8B;IAClE,kCAAkC,EAAE,GAAG,EAAE,cAAc;IACvD,yBAAyB,EAAE,QAAQ;IAEnC,WAAW;IACX,0BAA0B,EAAE,OAAO;IACnC,6BAA6B,EAAE,UAAU;IAEzC,qBAAqB;IACrB,kBAAkB,EAAE,SAAS;IAE7B,kBAAkB;IAClB,8BAA8B,EAAE,UAAU;IAC1C,yCAAyC,EAAE,mBAAmB;IAE9D,eAAe;IACf,qCAAqC,EAAE,GAAG,EAAE,cAAc;IAE1D,uBAAuB;IACvB,sBAAsB,EAAE,SAAS;IACjC,6BAA6B,EAAE,QAAQ;IACvC,oBAAoB,EAAE,GAAG,EAAE,uCAAuC;IAClE,sBAAsB,EAAE,eAAe;IAEvC,mBAAmB;IACnB,0BAA0B,EAAE,OAAO;IACnC,oBAAoB,EAAE,OAAO;IAC7B,kBAAkB,EAAE,OAAO;IAE3B,eAAe;IACf,kCAAkC,EAAE,cAAc;IAClD,oBAAoB,EAAE,GAAG,EAAE,+CAA+C;IAC1E,yBAAyB,EAAE,OAAO;IAElC,qBAAqB;IACrB,qCAAqC,EAAE,UAAU;IACjD,mCAAmC,EAAE,UAAU;IAC/C,iCAAiC,EAAE,cAAc;IAEjD,eAAe;IACf,kCAAkC,EAAE,cAAc;IAClD,6BAA6B,EAAE,GAAG,EAAE,cAAc;IAElD,UAAU;IACV,6BAA6B,EAAE,UAAU;IACzC,+BAA+B,EAAE,eAAe;CACjD,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,SAAiB,EAAE,SAAiB;IAClE,OAAO,WAAW,CAAC,GAAG,SAAS,IAAI,SAAS,EAAE,CAAC,CAAA;AACjD,CAAC"}

package/dist/dispatch/graph-walk.d.ts

@@ -0,0 +1,23 @@
+import type { ParseResult } from '../result.js';
+/**
+ * Cross-node graph integrity analysis. Runs as a single walk via
+ * `walkGraph`'s visitor; emits at most one of:
+ *  - `duplicate_id_in_graph` — two distinct nodes share an `@id`.
+ *  - `missing_id` — a node embedded in a cross-reference position has no `@id`.
+ *  - `wrong_type_for_endpoint` — a node's `@type` does not match the
+ *    declared expected type for the field that references it.
+ *  - `missing_type` — a non-leaf node lacks `@type`.
+ *  - `iri_not_canonical` — an IRI string is not in canonical form
+ *    (lowercase scheme/host, no default port; RFC 3987 + spec §3.2).
+ *
+ * Returns `ok: true` if the graph is structurally sound (per spec §3.2 + §7.1).
+ *
+ * Does NOT replace per-class Zod schema validation — that runs after this
+ * pass succeeds, in `dispatch.deserialize.<Class>`.
+ *
+ * v0.2: containing-class tracking via path-keyed map of object @types,
+ * so `wrong_type_for_endpoint` and `missing_id` checks fire for all
+ * embedded references, not just direct children of the root.
+ */
+export declare function dispatchGraphWalk(input: unknown, rootClass: string): ParseResult<true>;
+//# sourceMappingURL=graph-walk.d.ts.map

package/dist/dispatch/graph-walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-walk.d.ts","sourceRoot":"","sources":["../../src/dispatch/graph-walk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,cAAc,CAAA;AAO3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,CAmItF"}

package/dist/dispatch/graph-walk.js

@@ -0,0 +1,206 @@
+import { walkGraph } from '../safety/walk-graph.js';
+import { checkContextOrder } from './context-order.js';
+import { checkDomainConstraints } from './domain-constraints.js';
+import { expectedTypeFor } from './field-types.js';
+import { checkIriCanonical, looksLikeIri } from './iri-canonical.js';
+/**
+ * Cross-node graph integrity analysis. Runs as a single walk via
+ * `walkGraph`'s visitor; emits at most one of:
+ *  - `duplicate_id_in_graph` — two distinct nodes share an `@id`.
+ *  - `missing_id` — a node embedded in a cross-reference position has no `@id`.
+ *  - `wrong_type_for_endpoint` — a node's `@type` does not match the
+ *    declared expected type for the field that references it.
+ *  - `missing_type` — a non-leaf node lacks `@type`.
+ *  - `iri_not_canonical` — an IRI string is not in canonical form
+ *    (lowercase scheme/host, no default port; RFC 3987 + spec §3.2).
+ *
+ * Returns `ok: true` if the graph is structurally sound (per spec §3.2 + §7.1).
+ *
+ * Does NOT replace per-class Zod schema validation — that runs after this
+ * pass succeeds, in `dispatch.deserialize.<Class>`.
+ *
+ * v0.2: containing-class tracking via path-keyed map of object @types,
+ * so `wrong_type_for_endpoint` and `missing_id` checks fire for all
+ * embedded references, not just direct children of the root.
+ */
+export function dispatchGraphWalk(input, rootClass) {
+    // context_order_violation (deviation #10 closure, deferral E): if the
+    // root @context is an array, verify the LAST element is allowed.
+    // Per JSON-LD 1.1 §3.7 later items override earlier ones for term
+    // definitions; the last item is the effective cargo-term context.
+    // String-form @context is delegated to assertContextAllowed (already
+    // runs in the per-class deserializer).
+    if (typeof input === 'object' && input !== null && '@context' in input) {
+        const ctx = input['@context'];
+        const orderR = checkContextOrder(ctx);
+        if (!orderR.ok && orderR.lastUnallowed !== undefined) {
+            return {
+                ok: false,
+                error: {
+                    kind: 'context_order_violation',
+                    got: ctx,
+                    lastUnallowed: orderR.lastUnallowed,
+                    path: '$["@context"]',
+                },
+            };
+        }
+    }
+    // domain_constraint_violation (deviation #6 partial closure, deferral F):
+    // root-level cardinality constraints from spec §5.x. Today: Waybill
+    // requires shipmentInformation; Shipment requires containedPieces.
+    // v0.3 expands with AWB consistency, total-pieces/weight sums, and
+    // reference resolvability.
+    if (typeof input === 'object' && input !== null && !Array.isArray(input)) {
+        const violation = checkDomainConstraints(rootClass, input);
+        if (violation) {
+            return {
+                ok: false,
+                error: {
+                    kind: 'domain_constraint_violation',
+                    className: violation.className,
+                    field: violation.field,
+                    expected: violation.expected,
+                    specRef: violation.specRef,
+                    path: `$.${violation.field}`,
+                },
+            };
+        }
+    }
+    const seen = new Map(); // @id -> first path seen
+    // Path-keyed @type lookup: maps each object node's path to its declared
+    // (or root-defaulted) @type. Used to resolve the containing class when
+    // checking wrong_type_for_endpoint / missing_id at any depth.
+    const pathToType = new Map();
+    pathToType.set('$', rootClass);
+    let firstError;
+    const walkR = walkGraph(input, {}, (node, path, _depth) => {
+        if (firstError)
+            return; // short-circuit on first error
+        // iri_not_canonical: check every IRI-shaped string value in the
+        // graph (deviation #9 closure, deferral D). Runs before the
+        // object-only checks below because string values are visited
+        // separately by walkGraph.
+        if (typeof node === 'string' && looksLikeIri(node)) {
+            const r = checkIriCanonical(node);
+            if (!r.canonical && r.reason) {
+                firstError = {
+                    kind: 'iri_not_canonical',
+                    iri: node,
+                    reason: r.reason,
+                    path,
+                };
+            }
+            return;
+        }
+        if (typeof node !== 'object' || node === null || Array.isArray(node))
+            return;
+        const obj = node;
+        const id = typeof obj['@id'] === 'string' ? obj['@id'] : undefined;
+        const type = typeof obj['@type'] === 'string' ? obj['@type'] : undefined;
+        // Record this object's @type by path so children can find their
+        // containing class. Falls back to rootClass for the root path.
+        if (type)
+            pathToType.set(path, type);
+        // missing_type: every non-leaf node must declare @type
+        if (!type && hasObjectChildren(obj)) {
+            firstError = { kind: 'missing_type', path };
+            return;
+        }
+        const parentField = pathToParentField(path);
+        const containingClass = parentField ? containingClassFor(path, pathToType) : undefined;
+        // missing_id: nodes embedded in cross-reference positions must have @id.
+        // Cross-reference positions are fields in FIELD_TYPES for the containing class.
+        if (parentField && containingClass && !id && requiresId(parentField, containingClass)) {
+            firstError = {
+                kind: 'missing_id',
+                objectType: type ?? 'unknown',
+                path,
+            };
+            return;
+        }
+        // duplicate_id_in_graph
+        if (id) {
+            if (seen.has(id)) {
+                firstError = { kind: 'duplicate_id_in_graph', iri: id, path };
+                return;
+            }
+            seen.set(id, path);
+        }
+        // wrong_type_for_endpoint: embedded @type must match the field's
+        // expected class. Now checked at any depth — containing class
+        // resolved via the path-keyed @type map.
+        if (type && parentField && containingClass) {
+            const expected = expectedTypeFor(containingClass, parentField);
+            if (expected && expected !== '*' && expected !== type) {
+                firstError = {
+                    kind: 'wrong_type_for_endpoint',
+                    expected,
+                    got: type,
+                    path,
+                };
+            }
+        }
+    });
+    if (!walkR.ok)
+        return walkR; // safety-limit error
+    if (firstError)
+        return { ok: false, error: firstError };
+    return { ok: true, value: true };
+}
+function hasObjectChildren(obj) {
+    for (const v of Object.values(obj)) {
+        if (typeof v === 'object' && v !== null)
+            return true;
+    }
+    return false;
+}
+/**
+ * Path format: `$`, `$.<field>`, `$.<field>[<n>]`, `$.<field>.<sub>`,
+ * `$.<field>[<n>].<sub>`. Returns the immediate parent field name.
+ * Returns `undefined` for the root path `$`.
+ */
+function pathToParentField(path) {
+    if (path === '$')
+        return undefined;
+    const last = path.split('.').pop();
+    if (!last)
+        return undefined;
+    return last.replace(/\[\d+\]$/, ''); // strip array index suffix
+}
+/**
+ * Resolve the containing class for the node at `path` by looking up the
+ * @type recorded at the parent object's path. Skips array-index segments
+ * (those don't carry their own @type).
+ *
+ * Examples (rootClass = 'Waybill'):
+ *  - `$.shipmentInformation` → parent path `$` → 'Waybill'
+ *  - `$.shipmentInformation.consignee` → parent path `$.shipmentInformation`
+ *    → whatever @type was declared on that node (typically 'Shipment')
+ *  - `$.containedPieces[0]` → strip `[0]` then `.containedPieces` → '$' → 'Waybill'
+ *    (the array container itself isn't an object node so we step past it)
+ *  - `$.containedPieces[0].dimensions` → parent path `$.containedPieces[0]`
+ *    → @type at that path (typically 'Piece')
+ */
+function containingClassFor(path, pathToType) {
+    if (path === '$')
+        return undefined;
+    // Strip the trailing `.field` or `[N]` segment to get the parent path.
+    const stripped = path.replace(/\[\d+\]$/, '');
+    const lastDot = stripped.lastIndexOf('.');
+    if (lastDot < 0)
+        return undefined;
+    let parentPath = stripped.slice(0, lastDot);
+    if (parentPath === '')
+        parentPath = '$';
+    return pathToType.get(parentPath);
+}
+/**
+ * A field requires `@id` on referenced nodes if it's in `FIELD_TYPES`
+ * for the given containing class (= the field points at another
+ * logistics-object node). Scalar fields and unmapped fields don't
+ * require `@id`.
+ */
+function requiresId(parentField, containingClass) {
+    return expectedTypeFor(containingClass, parentField) !== undefined;
+}
+//# sourceMappingURL=graph-walk.js.map

package/dist/dispatch/graph-walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-walk.js","sourceRoot":"","sources":["../../src/dispatch/graph-walk.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEpE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc,EAAE,SAAiB;IACjE,sEAAsE;IACtE,iEAAiE;IACjE,kEAAkE;IAClE,kEAAkE;IAClE,qEAAqE;IACrE,uCAAuC;IACvC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,UAAU,IAAI,KAAK,EAAE,CAAC;QACvE,MAAM,GAAG,GAAI,KAAiC,CAAC,UAAU,CAAC,CAAA;QAC1D,MAAM,MAAM,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAA;QACrC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACrD,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,KAAK,EAAE;oBACL,IAAI,EAAE,yBAAyB;oBAC/B,GAAG,EAAE,GAAe;oBACpB,aAAa,EAAE,MAAM,CAAC,aAAa;oBACnC,IAAI,EAAE,eAAe;iBACtB;aACF,CAAA;QACH,CAAC;IACH,CAAC;IAED,0EAA0E;IAC1E,oEAAoE;IACpE,mEAAmE;IACnE,mEAAmE;IACnE,2BAA2B;IAC3B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzE,MAAM,SAAS,GAAG,sBAAsB,CAAC,SAAS,EAAE,KAAgC,CAAC,CAAA;QACrF,IAAI,SAAS,EAAE,CAAC;YACd,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,KAAK,EAAE;oBACL,IAAI,EAAE,6BAA6B;oBACnC,SAAS,EAAE,SAAS,CAAC,SAAS;oBAC9B,KAAK,EAAE,SAAS,CAAC,KAAK;oBACtB,QAAQ,EAAE,SAAS,CAAC,QAAQ;oBAC5B,OAAO,EAAE,SAAS,CAAC,OAAO;oBAC1B,IAAI,EAAE,KAAK,SAAS,CAAC,KAAK,EAAE;iBAC7B;aACF,CAAA;QACH,CAAC;IACH,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAA,CAAC,yBAAyB;IAChE,wEAAwE;IACxE,uEAAuE;IACvE,8DAA8D;IAC9D,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAA;IAC5C,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA;IAC9B,IAAI,UAAkC,CAAA;IAEtC,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;QACxD,IAAI,UAAU;YAAE,OAAM,CAAC,+BAA+B;QAEtD,gEAAgE;QAChE,4DAA4D;QAC5D,6DAA6D;QAC7D,2BAA2B;QAC3B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;YACnD,MAAM,CAAC,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAA;YACjC,IAAI,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;gBAC7B,UAAU,GAAG;oBACX,IAAI,EAAE,mBAAmB;oBACzB,GAAG,EAAE,IAAI;oBACT,MAAM,EAAE,CAAC,CAAC,MAAM;oBAChB,IAAI;iBACL,CAAA;YACH,CAAC;YACD,OAAM;QACR,CAAC;QAED,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;YAAE,OAAM;QAE5E,MAAM,GAAG,GAAG,IAA+B,CAAA;QAC3C,MAAM,EAAE,GAAG,OAAO,GAAG,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;QAClE,MAAM,IAAI,GAAG,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;QAExE,gEAAgE;QAChE,+DAA+D;QAC/D,IAAI,IAAI;YAAE,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;QAEpC,uDAAuD;QACvD,IAAI,CAAC,IAAI,IAAI,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC;YACpC,UAAU,GAAG,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,CAAA;YAC3C,OAAM;QACR,CAAC;QAED,MAAM,WAAW,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAA;QAC3C,MAAM,eAAe,GAAG,WAAW,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;QAEtF,yEAAyE;QACzE,gFAAgF;QAChF,IAAI,WAAW,IAAI,eAAe,IAAI,CAAC,EAAE,IAAI,UAAU,CAAC,WAAW,EAAE,eAAe,CAAC,EAAE,CAAC;YACtF,UAAU,GAAG;gBACX,IAAI,EAAE,YAAY;gBAClB,UAAU,EAAE,IAAI,IAAI,SAAS;gBAC7B,IAAI;aACL,CAAA;YACD,OAAM;QACR,CAAC;QAED,wBAAwB;QACxB,IAAI,EAAE,EAAE,CAAC;YACP,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;gBACjB,UAAU,GAAG,EAAE,IAAI,EAAE,uBAAuB,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,CAAA;gBAC7D,OAAM;YACR,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;QACpB,CAAC;QAED,iEAAiE;QACjE,8DAA8D;QAC9D,yCAAyC;QACzC,IAAI,IAAI,IAAI,WAAW,IAAI,eAAe,EAAE,CAAC;YAC3C,MAAM,QAAQ,GAAG,eAAe,CAAC,eAAe,EAAE,WAAW,CAAC,CAAA;YAC9D,IAAI,QAAQ,IAAI,QAAQ,KAAK,GAAG,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;gBACtD,UAAU,GAAG;oBACX,IAAI,EAAE,yBAAyB;oBAC/B,QAAQ;oBACR,GAAG,EAAE,IAAI;oBACT,IAAI;iBACL,CAAA;YACH,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,KAAK,CAAC,EAAE;QAAE,OAAO,KAAK,CAAA,CAAC,qBAAqB;IACjD,IAAI,UAAU;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,CAAA;IACvD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;AAClC,CAAC;AAED,SAAS,iBAAiB,CAAC,GAA4B;IACrD,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;YAAE,OAAO,IAAI,CAAA;IACtD,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,IAAY;IACrC,IAAI,IAAI,KAAK,GAAG;QAAE,OAAO,SAAS,CAAA;IAClC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAA;IAClC,IAAI,CAAC,IAAI;QAAE,OAAO,SAAS,CAAA;IAC3B,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA,CAAC,2BAA2B;AACjE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,kBAAkB,CAAC,IAAY,EAAE,UAA+B;IACvE,IAAI,IAAI,KAAK,GAAG;QAAE,OAAO,SAAS,CAAA;IAClC,uEAAuE;IACvE,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;IAC7C,MAAM,OAAO,GAAG,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;IACzC,IAAI,OAAO,GAAG,CAAC;QAAE,OAAO,SAAS,CAAA;IACjC,IAAI,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;IAC3C,IAAI,UAAU,KAAK,EAAE;QAAE,UAAU,GAAG,GAAG,CAAA;IACvC,OAAO,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;AACnC,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,WAAmB,EAAE,eAAuB;IAC9D,OAAO,eAAe,CAAC,eAAe,EAAE,WAAW,CAAC,KAAK,SAAS,CAAA;AACpE,CAAC"}

package/dist/dispatch/index.d.ts

@@ -0,0 +1,30 @@
+import { type ClassName } from '../factory-classes.js';
+import type { ParseResult } from '../result.js';
+/**
+ * Build the per-class deserialize map by wrapping each module's
+ * `deserialize<ClassName>` function with the graph-walk pre-pass.
+ *
+ * Failure of the graph-walk pre-pass returns the underlying ParseError
+ * untouched; per-class Zod validation only runs if the pre-pass passes.
+ */
+type DispatchDeserializeMap = {
+    readonly [C in ClassName]: (raw: unknown) => ParseResult<unknown>;
+};
+/**
+ * Opt-in dispatch facade per spec §13. Use:
+ *   import { dispatch } from '@flaks/onerecord'
+ *   const r = dispatch.deserialize.Waybill(input)
+ *
+ * Each per-class deserializer runs the graph-walk pre-pass before
+ * delegating to the per-class Zod schema. The default per-class
+ * deserializers (`WaybillCodec.deserialize`, `onerecord.deserialize.Waybill`)
+ * are unchanged — graph-walk is opt-in.
+ *
+ * For state-bound graph-walk (per-call limits, IRI strategy etc.), use
+ * `createMapper({ graphWalk: true })` instead.
+ */
+export declare const dispatch: Readonly<{
+    deserialize: Readonly<DispatchDeserializeMap>;
+}>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/dispatch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dispatch/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG/C;;;;;;GAMG;AACH,KAAK,sBAAsB,GAAG;IAC5B,QAAQ,EAAE,CAAC,IAAI,SAAS,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,WAAW,CAAC,OAAO,CAAC;CAClE,CAAA;AAuBD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ;;EAEnB,CAAA"}