@openlup/platform 0.21.0 → 0.23.0

package/dist/fulfillment/providerDispatchError.js

@@ -0,0 +1,5 @@
+/** Adapters translate structured provider failures into the port result before returning.
+ * An unclassified throw after invoking dispatch can follow a successful POST. */
+export function unknownDispatchFailure() {
+    return { kind: "unknown", effectMayHaveSucceeded: true, refusal: { reason: "io_failure", phase: "dispatch", retryable: true } };
+}

package/dist/fulfillment/providerDispatchWorker.d.ts

@@ -0,0 +1,44 @@
+import type { DispatchRecord, FulfillmentDispatchPort, FulfillmentDispatchRequest, FulfillmentStorePort } from "./contracts/index.js";
+export declare function runFulfillmentDispatchWorker(input: {
+    store: FulfillmentStorePort;
+    provider: FulfillmentDispatchPort | null;
+    listCandidates(limit: number): Promise<readonly FulfillmentDispatchRequest[]>;
+    /** Return the original host key bytes, without a new package prefix. */
+    keys: {
+        request(candidate: FulfillmentDispatchRequest): string;
+        mappedAttempt(requestKey: string, mappedAttemptIndex: number): string;
+        acceptance(fulfillmentRef: string): {
+            providerAttemptKey: string;
+            labelKey: string;
+        };
+    };
+    config: {
+        mode: DispatchRecord["mode"];
+        batchLimit: number;
+    };
+    now?: () => Date;
+}): Promise<{
+    redactedFieldCount: number;
+    ok: boolean;
+    skipped: boolean;
+    checked: number;
+    updated: number;
+    failures: number;
+    mode: "shadow" | "stage" | "live";
+    replayed: number;
+    providerCalls: number;
+    readBacks: number;
+    reason: string | undefined;
+} | {
+    redactedFieldCount?: undefined;
+    ok: boolean;
+    skipped: boolean;
+    checked: number;
+    updated: number;
+    failures: number;
+    mode: "shadow" | "stage" | "live";
+    replayed: number;
+    providerCalls: number;
+    readBacks: number;
+    reason: string | undefined;
+}>;

package/dist/fulfillment/providerDispatchWorker.js

@@ -0,0 +1,199 @@
+import { durableStrings, acceptedProviderProof, dispatchEvidence, dispatchResult, localFailureReason, shadowDispatchEvidence } from "./dispatchProjection.js";
+import { acknowledgeAcceptedDispatch, recoverDispatchAcceptanceWrite } from "./providerDispatchAcceptance.js";
+import { unknownDispatchFailure } from "./providerDispatchError.js";
+export async function runFulfillmentDispatchWorker(input) {
+    const privacy = durableStrings();
+    const failure = (stage, error) => localFailureReason(stage, error, privacy);
+    const diagnostics = () => privacy.redactedFieldCount ? { redactedFieldCount: privacy.redactedFieldCount } : {};
+    const result = { ok: true, skipped: false, checked: 0, updated: 0, failures: 0,
+        mode: input.config.mode, replayed: 0, providerCalls: 0, readBacks: 0, reason: undefined };
+    if (input.config.mode !== "shadow") {
+        try {
+            await input.store.markStaleSubmissionsUncertain(new Date((input.now?.() ?? new Date()).getTime() - 5 * 60_000).toISOString());
+        }
+        catch (error) {
+            return { ...result, ok: false, failures: 1, reason: failure("dispatch_stale_submission_sweep_failed", error), ...diagnostics() };
+        }
+    }
+    const candidates = await input.listCandidates(input.config.batchLimit);
+    result.checked = candidates.length;
+    candidateLoop: for (const candidate of candidates) {
+        const requestKey = input.keys.request(candidate);
+        let stage = "dispatch_read_failed";
+        try {
+            let readBack = await input.store.read(requestKey);
+            if (readBack)
+                result.readBacks += 1;
+            if (acceptedProviderProof(readBack)) {
+                const ack = await acknowledgeAcceptedDispatch({ store: input.store, record: readBack, keys: input.keys.acceptance(candidate.fulfillmentRef) });
+                if (ack.replayed)
+                    result.replayed += 1;
+                result.updated += ack.replayed ? 0 : 1;
+                continue;
+            }
+            stage = "dispatch_prepare_failed";
+            const preparation = await input.store.prepare(candidate.fulfillmentRef);
+            if (preparation.disposition === "withheld")
+                continue;
+            stage = "dispatch_candidate_read_failed";
+            const preparedCandidate = await input.store.readCandidate(candidate.fulfillmentRef);
+            if (!preparedCandidate)
+                throw new Error("dispatch_prepared_candidate_missing");
+            if (input.config.mode !== "shadow" && !input.provider) {
+                result.ok = false;
+                result.failures += 1;
+                result.reason ??= "provider_not_configured";
+                continue;
+            }
+            let mappedCandidate = preparedCandidate;
+            let dispatchRef;
+            let evidence;
+            let providerEvidence;
+            let mappedAttemptCount = 0;
+            for (let remapCount = 0;; remapCount += 1) {
+                const request = { ...mappedCandidate, requestKey };
+                stage = "dispatch_command_prepare_failed";
+                const prepared = input.config.mode === "shadow"
+                    ? { kind: "prepared", evidence: shadowDispatchEvidence(request) }
+                    : await input.provider.prepare(request);
+                if (prepared.kind === "refused") {
+                    result.ok = false;
+                    result.failures += 1;
+                    result.reason ??= privacy.token(prepared.refusal.reason) ?? "redacted";
+                    continue candidateLoop;
+                }
+                providerEvidence = dispatchEvidence(prepared.evidence);
+                evidence = { ...providerEvidence, mapping: { source: "dispatch_worker", mode: input.config.mode, shadowMode: input.config.mode === "shadow" } };
+                // Native claims count any JSON change as a remap; attempts compare
+                // the whole JSON. Enrichment must not rewrite an existing identity.
+                if (readBack && sameCommandIdentity(readBack.evidence, evidence))
+                    evidence = dispatchEvidence(readBack.evidence);
+                stage = "dispatch_claim_failed";
+                const claim = await input.store.claim({ requestKey, fulfillmentRef: mappedCandidate.fulfillmentRef,
+                    orderRef: mappedCandidate.orderRef, parcelRef: mappedCandidate.parcelRef, mode: input.config.mode, evidence });
+                if (claim.kind === "refused") {
+                    if (remapCount === 0 && claim.refusal.reason === "contact_stale") {
+                        const refreshed = await input.store.readCandidate(candidate.fulfillmentRef);
+                        if (!refreshed)
+                            throw new Error("dispatch_contact_remap_candidate_missing");
+                        mappedCandidate = refreshed;
+                        continue;
+                    }
+                    result.ok = false;
+                    result.failures += 1;
+                    result.reason ??= privacy.token(claim.refusal.reason) ?? "redacted";
+                    continue candidateLoop;
+                }
+                dispatchRef = claim.record;
+                if (dispatchRef.replayed)
+                    result.replayed += 1;
+                // Re-claim may refresh a correctable draft atomically; readback is authoritative.
+                stage = "dispatch_readback_failed";
+                readBack = await input.store.read(requestKey);
+                if (readBack)
+                    result.readBacks += 1;
+                if (!readBack || readBack.fulfillmentRef !== mappedCandidate.fulfillmentRef)
+                    throw new Error("dispatch_readback_failed");
+                stage = "dispatch_attempt_write_failed";
+                await input.store.recordProviderAttempt(input.keys.mappedAttempt(requestKey, mappedAttemptCount), mappedCandidate.fulfillmentRef, evidence, input.config.mode, "recorded");
+                mappedAttemptCount += 1;
+                if (input.config.mode === "shadow") {
+                    result.updated += dispatchRef.replayed ? 0 : 1;
+                    continue candidateLoop;
+                }
+                if (readBack.status !== "draft") {
+                    result.ok = false;
+                    result.failures += 1;
+                    result.reason ??= `dispatch_not_safe_to_submit:${readBack.status}`;
+                    continue candidateLoop;
+                }
+                stage = "dispatch_begin_failed";
+                const submission = await input.store.begin({ dispatchRef: dispatchRef.dispatchRef, commandFingerprint: evidence.commandFingerprint });
+                if (submission.kind === "refused") {
+                    if (remapCount === 0 && submission.refusal.reason === "contact_stale") {
+                        const refreshed = await input.store.readCandidate(candidate.fulfillmentRef);
+                        if (!refreshed)
+                            throw new Error("dispatch_contact_remap_candidate_missing");
+                        mappedCandidate = refreshed;
+                        continue;
+                    }
+                    result.ok = false;
+                    result.failures += 1;
+                    result.reason ??= privacy.token(submission.refusal.reason) ?? "redacted";
+                    continue candidateLoop;
+                }
+                if (!submission.begun) {
+                    stage = "dispatch_concurrent_read_failed";
+                    const concurrent = await input.store.read(requestKey);
+                    if (concurrent)
+                        result.readBacks += 1;
+                    if (acceptedProviderProof(concurrent)) {
+                        const ack = await acknowledgeAcceptedDispatch({ store: input.store, record: concurrent, keys: input.keys.acceptance(mappedCandidate.fulfillmentRef) });
+                        if (ack.replayed)
+                            result.replayed += 1;
+                        result.updated += ack.replayed ? 0 : 1;
+                    }
+                    else {
+                        result.replayed += 1;
+                    }
+                    continue candidateLoop;
+                }
+                if (submission.record.status !== "submitting")
+                    throw new Error("dispatch_submission_state_invalid");
+                break;
+            }
+            result.providerCalls += 1;
+            let response;
+            try {
+                response = dispatchResult(await input.provider.dispatch({ ...mappedCandidate, requestKey }, providerEvidence));
+            }
+            catch {
+                response = unknownDispatchFailure();
+            }
+            if (response.kind === "accepted" && JSON.stringify(response.evidence) !== JSON.stringify(providerEvidence)) {
+                response = { kind: "unknown", effectMayHaveSucceeded: true, refusal: { reason: "malformed", phase: "acknowledge", retryable: false },
+                    error: { code: "dispatch_acceptance_evidence_mismatch", status: null, retryable: false, mayHaveSucceeded: true } };
+            }
+            if (response.kind !== "accepted") {
+                stage = "dispatch_finalize_failed";
+                await input.store.finalize({ dispatchRef: dispatchRef.dispatchRef, result: response });
+                result.ok = false;
+                result.failures += 1;
+                result.reason ??= response.error?.code ?? response.refusal.reason;
+                continue;
+            }
+            // All ACK paths use the original host keys, ignoring adapter key fields.
+            const acceptance = { ...response, evidence, ...input.keys.acceptance(mappedCandidate.fulfillmentRef) };
+            try {
+                const ack = await input.store.acknowledge({ dispatchRef: dispatchRef.dispatchRef, acceptance });
+                if (ack.replayed)
+                    result.replayed += 1;
+            }
+            catch (error) {
+                const recovery = await recoverDispatchAcceptanceWrite({ store: input.store, requestKey, dispatchRef: dispatchRef.dispatchRef, acceptance, error });
+                result.readBacks += recovery.readBacks;
+                if (recovery.committed) {
+                    result.updated += 1;
+                    continue;
+                }
+                result.ok = false;
+                result.failures += 1;
+                result.reason ??= "dispatch_proof_write_failed_after_provider_acceptance";
+                break;
+            }
+            result.updated += 1;
+        }
+        catch (error) {
+            result.ok = false;
+            result.failures += 1;
+            result.reason ??= failure(stage, error);
+        }
+    }
+    return { ...result, ...diagnostics() };
+}
+function sameCommandIdentity(a, b) {
+    return a.commandFingerprint === b.commandFingerprint && a.providerRef === b.providerRef
+        && a.carrierRef === b.carrierRef && a.serviceRef === b.serviceRef
+        && a.contactRevision.schemaVersion === b.contactRevision.schemaVersion
+        && a.contactRevision.source === b.contactRevision.source && a.contactRevision.revision === b.contactRevision.revision;
+}

package/dist/fulfillment/providerProductSyncWorker.d.ts

@@ -0,0 +1,28 @@
+import type { FulfillmentProductSyncPort, FulfillmentProductSyncProvider } from "./contracts/index.js";
+type ReconciliationConflict = Parameters<FulfillmentProductSyncPort["recordReconciliationEvidence"]>[0]["conflictKind"];
+type SyncIdentity = Parameters<FulfillmentProductSyncPort["recordReconciliationEvidence"]>[0]["identity"];
+interface ProductSyncResult {
+    ok: boolean;
+    pushedProducts: number;
+    pushedPacks: number;
+    skippedProducts: number;
+    pulledSkus: number;
+    ingestedPacks: number;
+    reconciliations: number;
+    replayed: number;
+    failures: number;
+    providerCalls: number;
+    syncRunId: string;
+    reason?: string;
+}
+export declare function runFulfillmentProductSyncWorker(input: {
+    port: FulfillmentProductSyncPort;
+    provider: FulfillmentProductSyncProvider;
+    mode?: "push" | "pull" | "both";
+    now?: () => Date;
+    compatibility: {
+        identity(now: Date): SyncIdentity;
+        evidenceKey(sku: string, ean: string, kind: ReconciliationConflict): string;
+    };
+}): Promise<ProductSyncResult>;
+export {};

package/dist/fulfillment/providerProductSyncWorker.js

@@ -0,0 +1,122 @@
+function packKindForQuantity(quantity) {
+    return quantity > 1 ? "collective" : "unit";
+}
+function reconciliationKindFor(conflict) {
+    switch (conflict) {
+        case "sku_not_found":
+            return "unknown_sku";
+        case "ean_owned_by_other_sku":
+            return "ean_conflict";
+        case "local_locked_mismatch":
+            return "kind_quantity_conflict";
+        default:
+            return null;
+    }
+}
+export async function runFulfillmentProductSyncWorker(input) {
+    const now = input.now?.() ?? new Date();
+    const mode = input.mode ?? "both";
+    const identity = input.compatibility.identity(now);
+    const syncRunId = identity.syncRunId;
+    const result = {
+        ok: true,
+        pushedProducts: 0,
+        pushedPacks: 0,
+        skippedProducts: 0,
+        pulledSkus: 0,
+        ingestedPacks: 0,
+        reconciliations: 0,
+        replayed: 0,
+        failures: 0,
+        providerCalls: 0,
+        syncRunId,
+    };
+    if (mode === "push" || mode === "both")
+        await runPush(input, result);
+    if (mode === "pull" || mode === "both")
+        await runPull(input, result, identity);
+    return result;
+}
+async function runPush(input, result) {
+    const localProducts = await input.port.listLocalProductPacks();
+    for (const product of localProducts) {
+        try {
+            const ensured = await input.provider.ensureProduct(product.sku);
+            result.providerCalls += 1;
+            if (ensured === null) {
+                result.skippedProducts += 1;
+                continue;
+            }
+            result.pushedProducts += ensured.replayed ? 0 : 1;
+            if (ensured.replayed)
+                result.replayed += 1;
+            const existingEans = new Set((await input.provider.getProductPacks(product.sku)).map((pack) => pack.ean));
+            result.providerCalls += 1;
+            for (const pack of product.packs) {
+                if (existingEans.has(pack.ean))
+                    continue;
+                await input.provider.addProductPack(product.sku, { ean: pack.ean, quantity: pack.quantity });
+                result.providerCalls += 1;
+                await input.port.markPackSynced({ sku: product.sku, ean: pack.ean });
+                result.pushedPacks += 1;
+            }
+        }
+        catch (error) {
+            result.ok = false;
+            result.failures += 1;
+            result.reason = result.reason ?? "product_sync_operation_failed";
+        }
+    }
+}
+async function runPull(input, result, identity) {
+    const syncRunId = identity.syncRunId;
+    const skus = await input.provider.listStockedSkus();
+    result.providerCalls += 1;
+    for (const sku of skus.filter((value) => value.trim())) {
+        try {
+            const providerPacks = await input.provider.getProductPacks(sku);
+            result.providerCalls += 1;
+            result.pulledSkus += 1;
+            const activeConflicts = new Set();
+            for (const pack of providerPacks.filter((entry) => entry.ean.trim())) {
+                const upsert = await input.port.upsertPulledPack({
+                    sku,
+                    ean: pack.ean,
+                    quantity: pack.quantity,
+                    kind: packKindForQuantity(pack.quantity),
+                });
+                const conflictKind = reconciliationKindFor(upsert.conflict);
+                if (conflictKind === null) {
+                    if (!upsert.replayed)
+                        result.ingestedPacks += 1;
+                    else
+                        result.replayed += 1;
+                    continue;
+                }
+                activeConflicts.add(conflictKind);
+                const evidence = await input.port.recordReconciliationEvidence({
+                    requestKey: input.compatibility.evidenceKey(sku, pack.ean, conflictKind),
+                    sku,
+                    ean: pack.ean,
+                    conflictKind,
+                    providerQuantity: pack.quantity,
+                    identity, refusal: null,
+                });
+                if (evidence.replayed)
+                    result.replayed += 1;
+                else
+                    result.reconciliations += 1;
+            }
+            await input.port.resolveReconciliationEvidence({
+                sku,
+                activeConflictKinds: [...activeConflicts],
+                syncRunId,
+            });
+        }
+        catch (error) {
+            result.ok = false;
+            result.failures += 1;
+            result.reason = result.reason ?? "product_sync_operation_failed";
+        }
+    }
+}

package/dist/fulfillment/providerReconciliationError.d.ts

@@ -0,0 +1,9 @@
+import type { FulfillmentObservation } from "./contracts/index.js";
+/** Host decoding supplies known domain reasons, never a raw provider error message. */
+export declare function quarantineReconciliationStateConflict(error: unknown, observation: FulfillmentObservation, classify: (error: unknown) => "fulfillment_not_found" | "stock_consumed_requires_label" | null, record: (observation: FulfillmentObservation, reason: "state_conflict", detail: "fulfillment_not_found" | "stock_consumed_requires_label") => Promise<{
+    replayed: boolean;
+}>, result: {
+    quarantined: number;
+    replayed: number;
+    stateConflicts: number;
+}): Promise<unknown | null>;

package/dist/fulfillment/providerReconciliationError.js

@@ -0,0 +1,17 @@
+/** Host decoding supplies known domain reasons, never a raw provider error message. */
+export async function quarantineReconciliationStateConflict(error, observation, classify, record, result) {
+    const reason = classify(error);
+    if (!reason)
+        return error;
+    try {
+        const quarantine = await record(observation, "state_conflict", reason);
+        if (quarantine.replayed)
+            result.replayed += 1;
+        result.quarantined += quarantine.replayed ? 0 : 1;
+        result.stateConflicts += 1;
+        return null;
+    }
+    catch (quarantineError) {
+        return quarantineError;
+    }
+}

package/dist/fulfillment/providerReconciliationTerminalSkip.d.ts

@@ -0,0 +1,2 @@
+/** Off-track rows still write evidence; acceptance and all effects must skip. */
+export declare function isOffTrackFulfillmentStatus(status: string | null | undefined): boolean;

package/dist/fulfillment/providerReconciliationTerminalSkip.js

@@ -0,0 +1,6 @@
+import { FULFILLMENT_STATUS_MAP } from "./statusMap.js";
+const OFF_TRACK_FULFILLMENT_STATUSES = new Set(FULFILLMENT_STATUS_MAP.stages.filter(stage => !stage.onTrack).flatMap(stage => stage.omsFulfillmentStatus));
+/** Off-track rows still write evidence; acceptance and all effects must skip. */
+export function isOffTrackFulfillmentStatus(status) {
+    return status !== null && status !== undefined && OFF_TRACK_FULFILLMENT_STATUSES.has(status);
+}

package/dist/fulfillment/providerReconciliationTimestamp.d.ts

@@ -0,0 +1 @@
+export declare function normalizeReconciliationTimestamp(value: string | null | undefined): string | null;

package/dist/fulfillment/providerReconciliationTimestamp.js

@@ -0,0 +1,27 @@
+const ISO_TIMESTAMP_WITH_EXPLICIT_ZONE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|[+-](\d{2}):?(\d{2}))$/;
+export function normalizeReconciliationTimestamp(value) {
+    const occurredAt = value?.trim();
+    if (!occurredAt)
+        return null;
+    const match = ISO_TIMESTAMP_WITH_EXPLICIT_ZONE.exec(occurredAt);
+    if (!match || !Number.isFinite(Date.parse(occurredAt)))
+        return null;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = Number(match[6]);
+    const offsetHour = match[7] === undefined ? 0 : Number(match[7]);
+    const offsetMinute = match[8] === undefined ? 0 : Number(match[8]);
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const daysInMonth = month === 2
+        ? leapYear ? 29 : 28
+        : [4, 6, 9, 11].includes(month) ? 30 : 31;
+    if (month < 1 || month > 12
+        || day < 1 || day > daysInMonth
+        || hour > 23 || minute > 59 || second > 59
+        || offsetHour > 23 || offsetMinute > 59)
+        return null;
+    return occurredAt;
+}

package/dist/fulfillment/providerReconciliationWorker.d.ts

@@ -0,0 +1,90 @@
+import type { FulfillmentObservation, FulfillmentObservationPagePort, FulfillmentReconciliationObservation, FulfillmentOperationError } from "./contracts/index.js";
+import { enrichTrackingReference } from "./providerTrackingReferences.js";
+type Ingress = Parameters<typeof import("./verifiedIngress.js").verifyAndNormalizeFulfillmentObservation>[0];
+type DispatchRef = NonNullable<Awaited<ReturnType<Ingress["lifecycle"]["findDispatchRef"]>>>;
+type PollEvidence = Pick<FulfillmentObservation, "correlation" | "eventKey" | "providerStatus" | "diagnostics"> | FulfillmentObservation;
+export interface ReconciliationResult {
+    ok: boolean;
+    checked: number;
+    updated: number;
+    trackingRefs: number;
+    quarantined: number;
+    stateConflicts: number;
+    exceptions: number;
+    stale: number;
+    offTrackSkips: number;
+    replayed: number;
+    redactedFieldCount?: number;
+    failures: number;
+    invoiceIssueFailures: number;
+    invoiceIssueRefused: number;
+    invoiceIssueRefusals: {
+        fulfillmentRef: string;
+        identifier: string | null;
+        sqlstate: string;
+        benign: boolean;
+    }[];
+    providerCalls: number;
+    readBacks: number;
+    skipped: boolean;
+    reason?: string;
+    providerError?: FulfillmentOperationError;
+}
+export declare function reconcileFulfillmentObservations(input: {
+    /** Adapter/host maps the private page into typed readback, preserving unknowns. */
+    readPage(input: {
+        page: number;
+        size: number;
+    }): Promise<readonly FulfillmentReconciliationObservation[]>;
+    batchSize: number;
+    page?: number;
+    localPersistence: {
+        /** G17: local persisted chronology, never inferred from dispatch or provider state. */
+        readLocalFulfillmentStatus(ref: string): Promise<string | null>;
+        latestStatusOccurredAt(ref: string): Promise<string | null>;
+        readHandedOverAt(ref: string): Promise<string | null>;
+    };
+    lifecycle: Pick<Ingress["lifecycle"], "recordStatusEvidence" | "effects" | "keys"> & {
+        findDispatchRef(evidence: PollEvidence): Promise<DispatchRef | null>;
+        acknowledgeDispatchAcceptance(ref: DispatchRef, evidence: PollEvidence): Promise<void>;
+        recordQuarantine(observation: PollEvidence | null, reason: "missing_correlation" | "missing_external_ref" | "unknown_status" | "state_conflict", detail?: "fulfillment_not_found" | "stock_consumed_requires_label"): Promise<{
+            replayed: boolean;
+        }>;
+        recordProviderException(ref: DispatchRef, observation: FulfillmentObservation): Promise<{
+            replayed: boolean;
+        }>;
+        readDeliveryCarrier(ref: string): Promise<{
+            carrierRef: string | null;
+            serviceRef: string | null;
+        } | null>;
+        trackingCodecs: Parameters<typeof enrichTrackingReference>[2];
+        issueAccountingInvoice?(ref: string): Promise<void>;
+        /** Private RPC decoding retains permanent/benign distinction and safe refusal identity. */
+        invoiceFailure(error: unknown): {
+            permanent: boolean;
+            identifier: string | null;
+            sqlstate: string | null;
+            benign: boolean;
+        };
+        classifyStateConflict(error: unknown): "fulfillment_not_found" | "stock_consumed_requires_label" | null;
+    };
+}): Promise<ReconciliationResult>;
+/** Host owns scheduling, HTTP and durable job-ledger writes. This operation only projects them. */
+export declare function runFulfillmentReconciliationPage(input: Omit<Parameters<typeof reconcileFulfillmentObservations>[0], "readPage" | "batchSize" | "page"> & {
+    provider: FulfillmentObservationPagePort;
+    pageSize: number;
+    checkpoint: unknown;
+}): Promise<{
+    status: 200 | 502;
+    ledgerStatus: "failed" | "succeeded";
+    result: ReconciliationResult;
+    metadata: {
+        reconciliationPagination: {
+            version: number;
+            page: number;
+            pageSize: number;
+            nextPage: number;
+        };
+    };
+}>;
+export {};