@usherlabs/cex-broker 0.2.49 → 0.2.51

package/dist/helpers/market-data-preparation/required-clock-qualification.d.ts

@@ -0,0 +1,43 @@
+import { type ReconstructionObservationSink, type RequiredClockSourceForensicsLedgerWire, type RequiredClockSourceQualificationRecordWire, type SourceObjectInspection } from "../market-data-source-forensics";
+import { type MarketDataVendorBackfillRequest, type ProviderCapability, type ProviderObjectEvidence } from "../market-data-vendor-backfill/contracts";
+export declare const MARKET_DATA_REQUIRED_CLOCK_QUALIFICATION_OPERATION_ID: "market-data-required-clock-qualification/v1";
+export type RequiredClockQualificationAdapter = {
+    capabilityFor(request: MarketDataVendorBackfillRequest): ProviderCapability | undefined;
+    acquire(request: MarketDataVendorBackfillRequest, capability: ProviderCapability, credential: {
+        apiKey: string;
+    }): Promise<unknown>;
+};
+export type RequiredClockQualificationAdapterFactory = (observer: ReconstructionObservationSink) => RequiredClockQualificationAdapter;
+export type MarketDataRequiredClockQualificationInvocation = {
+    operation_id: typeof MARKET_DATA_REQUIRED_CLOCK_QUALIFICATION_OPERATION_ID;
+    attempt_id: string;
+    request: unknown;
+    required_clock: unknown;
+    artifacts: {
+        ledger_file_name: string;
+        qualification_record_file_name: string;
+    };
+};
+export type MarketDataRequiredClockQualificationInput = {
+    invocation: MarketDataRequiredClockQualificationInvocation;
+    attempt_root: string;
+    created_at: string;
+    credential: {
+        api_key: string;
+    };
+    dependencies?: {
+        adapter_factory?: RequiredClockQualificationAdapterFactory;
+        inspect_source_object?: (identity: string, attempt: number) => SourceObjectInspection | Promise<SourceObjectInspection>;
+    };
+};
+export type MarketDataRequiredClockQualificationResult = {
+    operation_id: typeof MARKET_DATA_REQUIRED_CLOCK_QUALIFICATION_OPERATION_ID;
+    normalized_invocation_sha256: string;
+    ledger: RequiredClockSourceForensicsLedgerWire;
+    qualification: RequiredClockSourceQualificationRecordWire;
+    source_dataset_evidence: {
+        objects: ProviderObjectEvidence[];
+        vendor_semantic_digest: string;
+    } | null;
+};
+export declare function runMarketDataRequiredClockQualification(input: MarketDataRequiredClockQualificationInput): Promise<MarketDataRequiredClockQualificationResult>;

package/dist/helpers/market-data-preparation/source-tape-dependencies.d.ts

@@ -0,0 +1,19 @@
+import type { MarketDataSourceTapeDependencies } from "./source-tape-operation";
+export type MarketDataSourceTapeDependencyConfiguration = {
+    attemptRoot: string;
+    archiveForwarder: {
+        url: string;
+        authToken?: string;
+    };
+    clickHouse: {
+        url: string;
+        username?: string;
+        password?: string;
+    };
+};
+type MarketDataSourceTapeDependencyRuntime = {
+    exporterExecutablePath: string;
+    nodeExecutablePath: string;
+};
+export declare function createMarketDataSourceTapeDependenciesForRuntime(configuration: MarketDataSourceTapeDependencyConfiguration, runtime: MarketDataSourceTapeDependencyRuntime): MarketDataSourceTapeDependencies;
+export {};

package/dist/helpers/market-data-preparation/source-tape-operation.d.ts

@@ -0,0 +1,109 @@
+import { type ReconstructionObservationSink, type SourceForensicsLedgerWire, type SourceObjectInspection, type SourceTapeQualificationRecordWire } from "../market-data-source-forensics";
+import type { ArchiveQueryClient } from "../market-data-vendor-backfill/archive-reader";
+import { type ArchiveSelectionWire, type CanonicalScopeWire, type ForwarderBatch, type MarketDataVendorBackfillRequest, type ProviderCapability } from "../market-data-vendor-backfill/contracts";
+import { createSourceTapeArchiveSink, SOURCE_TAPE_SANDBOX_TARGET, type SourceTapeArchiveSinkResult } from "../source-tape";
+import { promoteAndExportSourceTapeSandbox, type SourceTapeExportResult, type SourceTapeSandboxEvidence } from "../source-tape-sandbox";
+import { type CanonicalOrderBookExportResultWire } from "./contracts";
+export declare const MARKET_DATA_SOURCE_TAPE_OPERATION_ID: "market-data-source-tape/v1";
+type PolicyPin = {
+    policy_id: string;
+    policy_sha256: string;
+};
+export type MarketDataSourceTapeInvocation = {
+    operation_id: typeof MARKET_DATA_SOURCE_TAPE_OPERATION_ID;
+    attempt_id: string;
+    request_id: string;
+    scope: CanonicalScopeWire & {
+        exchange: "okx";
+        trading_pair: "ARB-USDC" | "ARB-USDT";
+        market_type: "spot";
+        feed: "ORDERBOOK";
+    };
+    window: {
+        start_at: string;
+        end_at: string;
+    };
+    depth: 100;
+    target: typeof SOURCE_TAPE_SANDBOX_TARGET;
+    production_authorization_id: string;
+    expected_canonical_schema: {
+        schema_id: string;
+        schema_sha256: string;
+    };
+    product_pins: {
+        source_tape_capability: PolicyPin;
+        resource_policy: PolicyPin;
+        adapter_policy: PolicyPin;
+        acquisition_policy: PolicyPin;
+    };
+    artifacts: {
+        ledger_file_name: string;
+        qualification_record_file_name: string;
+        exporter_result_file_name: string;
+    };
+};
+export type SourceTapeAdapter = {
+    capabilityFor(request: MarketDataVendorBackfillRequest): ProviderCapability | undefined;
+    acquire(request: MarketDataVendorBackfillRequest, capability: ProviderCapability, credential: {
+        apiKey: string;
+    }): Promise<unknown>;
+};
+export type MarketDataSourceTapeDependencies = {
+    forwarder: {
+        preflight(input: {
+            authorizationId: string;
+            target: {
+                environment: string;
+                cluster: string;
+            };
+        }): Promise<{
+            forwarderIdentity: {
+                environment: string;
+                cluster: string;
+            };
+            authorization: {
+                authorizationId: string;
+                scope: "production";
+                environment: string;
+                cluster: string;
+                expiresAt: string;
+                credentialValidated: true;
+            };
+        }>;
+        submit(batch: ForwarderBatch): Promise<{
+            ok: boolean;
+            inserted: number;
+        }>;
+    };
+    archive_query: ArchiveQueryClient;
+    archive: {
+        resolveSelection(request: MarketDataVendorBackfillRequest): Promise<ArchiveSelectionWire>;
+    };
+    exporter: {
+        export(request: Parameters<Parameters<typeof promoteAndExportSourceTapeSandbox>[0]["exporter"]["export"]>[0]): Promise<SourceTapeExportResult & {
+            result: CanonicalOrderBookExportResultWire;
+        }>;
+    };
+    adapter_factory?: (observer: ReconstructionObservationSink, sink: ReturnType<typeof createSourceTapeArchiveSink>) => SourceTapeAdapter;
+    inspect_source_object?: (identity: string, attempt: number) => SourceObjectInspection | Promise<SourceObjectInspection>;
+};
+export type MarketDataSourceTapeInput = {
+    invocation: MarketDataSourceTapeInvocation;
+    attempt_root: string;
+    created_at: string;
+    credential: {
+        api_key: string;
+    };
+    dependencies: MarketDataSourceTapeDependencies;
+};
+export type MarketDataSourceTapeResult = {
+    operation_id: typeof MARKET_DATA_SOURCE_TAPE_OPERATION_ID;
+    normalized_invocation_sha256: string;
+    ledger: SourceForensicsLedgerWire;
+    qualification: SourceTapeQualificationRecordWire;
+    sink_result: SourceTapeArchiveSinkResult | null;
+    sandbox_evidence: SourceTapeSandboxEvidence | null;
+    exporter_result: CanonicalOrderBookExportResultWire | null;
+};
+export declare function runMarketDataSourceTape(input: MarketDataSourceTapeInput): Promise<MarketDataSourceTapeResult>;
+export {};

package/dist/helpers/market-data-source-forensics.d.ts

@@ -0,0 +1,400 @@
+import { SOURCE_FORENSICS_LEDGER_SCHEMA_ID, SOURCE_QUALIFICATION_RECORD_SCHEMA_ID } from "./market-data-preparation/contracts";
+import type { CanonicalScopeWire, LowercaseUuid, RequiredClockWire, Sha256Hex } from "./market-data-vendor-backfill/contracts";
+import type { PolicyPin } from "./market-data-vendor-backfill/manifests";
+export declare const SOURCE_FORENSICS_MAX_RECORDS = 100000;
+export declare const SOURCE_FORENSICS_MAX_CANONICAL_JSON_BYTES = 67108864;
+export declare const SOURCE_FORENSICS_RECORD_KINDS: readonly ["sequence_discontinuity", "unanchored_target_interval", "stale_target_interval", "future_state_interval", "provider_object_checksum_conflict"];
+export declare const SOURCE_FORENSICS_CLASSIFICATIONS: readonly ["stable_object_corruption", "mutable_provider_bytes", "provider_row_loss", "object_boundary_order_defect", "valid_inactive_market_state", "unresolved"];
+export declare const SOURCE_FORENSICS_OPERATION_KINDS: readonly ["required_clock_qualification", "source_tape"];
+export type SourceForensicsRecordKind = (typeof SOURCE_FORENSICS_RECORD_KINDS)[number];
+export type SourceForensicsClassification = (typeof SOURCE_FORENSICS_CLASSIFICATIONS)[number];
+export type SourceObjectEvidence = {
+    identity: string;
+    checksums: Sha256Hex[];
+    attempt_count: number;
+    quarantined: boolean;
+};
+export type SourceAnchorEvidence = {
+    event_time_ms: number;
+    sequence: string;
+    object_identity: string;
+    object_checksum: Sha256Hex;
+};
+export type SourceTargetInterval = {
+    start_target_time_ms: number;
+    end_target_time_ms_exclusive: number;
+    target_count: number;
+};
+export type SourceLagDistribution = {
+    lag_1000_ms: number;
+    lag_2000_ms: number;
+    lag_5000_ms: number;
+    lag_10000_ms: number;
+    lag_30000_ms: number;
+    lag_60000_ms: number;
+};
+export type SourceForensicsRecordWire = {
+    record_sha256: Sha256Hex;
+    kind: SourceForensicsRecordKind;
+    scope: CanonicalScopeWire;
+    provider_objects: SourceObjectEvidence[];
+    previous_anchor: SourceAnchorEvidence | null;
+    next_anchor: SourceAnchorEvidence | null;
+    target_interval: SourceTargetInterval | null;
+    lag_distribution: SourceLagDistribution | null;
+    sequence: null | {
+        expected_previous: string;
+        observed_previous: string;
+        observed_final: string;
+        event_time_ms: number;
+    };
+    classification: SourceForensicsClassification | null;
+    adapter_version: string;
+};
+export declare const SOURCE_TARGET_DISPOSITIONS: readonly ["fresh_within_bound", "valid_inactive_market_state", "disqualifying"];
+export type SourceTargetDisposition = (typeof SOURCE_TARGET_DISPOSITIONS)[number];
+export type SourceTargetDispositionWire = {
+    target_id: LowercaseUuid;
+    target_time_ms: number;
+    disposition: SourceTargetDisposition;
+    source_time_ms: number | null;
+    asof_age_ms: number | null;
+    record_sha256s: Sha256Hex[];
+};
+export type SourceInventoryInterval = {
+    start_time_ms: number;
+    end_time_ms_exclusive: number;
+};
+type SourceForensicsSummary = {
+    retained_record_count: number;
+    total_record_count: number;
+    omitted_record_count: number;
+    affected_target_count: number;
+    unresolved_record_count: number;
+};
+type SourceForensicsLedgerBase = {
+    schema_id: typeof SOURCE_FORENSICS_LEDGER_SCHEMA_ID;
+    ledger_sha256: Sha256Hex;
+    operation_kind: (typeof SOURCE_FORENSICS_OPERATION_KINDS)[number];
+    normalized_invocation_sha256: Sha256Hex;
+    request_id: LowercaseUuid;
+    scope: CanonicalScopeWire;
+    window: SourceInventoryInterval;
+    effective_policies: {
+        capability_policy: PolicyPin;
+        resource_policy: PolicyPin;
+        adapter_policy: PolicyPin;
+        acquisition_policy: PolicyPin;
+    };
+    provider_object_inventory: {
+        expected_identities: string[];
+        observed_identities: string[];
+        expected_selected_intervals: SourceInventoryInterval[];
+        observed_selected_intervals: SourceInventoryInterval[];
+        complete: boolean;
+    };
+    provider_objects: SourceObjectEvidence[];
+    records: SourceForensicsRecordWire[];
+    summary: SourceForensicsSummary;
+    limits: {
+        max_records: typeof SOURCE_FORENSICS_MAX_RECORDS;
+        max_canonical_json_bytes: typeof SOURCE_FORENSICS_MAX_CANONICAL_JSON_BYTES;
+    };
+    complete: boolean;
+    incomplete_reason: "forensics_evidence_bound_exceeded" | null;
+};
+export type RequiredClockSourceForensicsLedgerWire = SourceForensicsLedgerBase & {
+    operation_kind: "required_clock_qualification";
+    required_clock: {
+        clock_id: LowercaseUuid;
+        clock_sha256: Sha256Hex;
+        event_count: number;
+    };
+    target_dispositions: SourceTargetDispositionWire[];
+    summary: SourceForensicsSummary & {
+        disposition_complete: boolean;
+        fresh_target_count: number;
+        inactive_target_count: number;
+        disqualifying_target_count: number;
+        omitted_target_disposition_count: number;
+    };
+};
+export type SourceTapeForensicsLedgerWire = SourceForensicsLedgerBase & {
+    operation_kind: "source_tape";
+    source_tape: {
+        product_id: "market-data-source-tape";
+        product_version: "market-data-source-tape/v1";
+        state_count: number;
+    };
+};
+export type SourceForensicsLedgerWire = RequiredClockSourceForensicsLedgerWire | SourceTapeForensicsLedgerWire;
+type SourceQualificationLedgerDescriptor = {
+    schema_id: typeof SOURCE_FORENSICS_LEDGER_SCHEMA_ID;
+    file_name: string;
+    sha256: Sha256Hex;
+    bytes: number;
+    retained_record_count: number;
+    total_record_count: number;
+    omitted_record_count: number;
+    complete: boolean;
+};
+type SourceQualificationRecordBase = {
+    schema_id: typeof SOURCE_QUALIFICATION_RECORD_SCHEMA_ID;
+    record_sha256: Sha256Hex;
+    created_at: string;
+    operation_kind: (typeof SOURCE_FORENSICS_OPERATION_KINDS)[number];
+    normalized_invocation_sha256: Sha256Hex;
+    request_id: LowercaseUuid;
+    scope: CanonicalScopeWire;
+    ledger: SourceQualificationLedgerDescriptor;
+    source_reconstruction_accepted: boolean;
+    source_event_enumeration_eligible: boolean;
+};
+export type RequiredClockSourceQualificationRecordWire = SourceQualificationRecordBase & {
+    operation_kind: "required_clock_qualification";
+    ledger: SourceQualificationLedgerDescriptor & {
+        disposition_complete: boolean;
+        fresh_target_count: number;
+        inactive_target_count: number;
+        disqualifying_target_count: number;
+        omitted_target_disposition_count: number;
+    };
+    qualified: boolean;
+    source_partition_complete: boolean;
+    outcome: {
+        status: "success";
+        reason: "required_clock_qualification_completed";
+        partial_evidence: SourceEvidenceDescriptor[];
+        exporter_result: null;
+    } | {
+        status: "failure";
+        reason: (typeof REQUIRED_CLOCK_QUALIFICATION_FAILURE_REASONS)[number];
+        partial_evidence: SourceEvidenceDescriptor[];
+        exporter_result: null;
+    };
+};
+export declare const REQUIRED_CLOCK_QUALIFICATION_FAILURE_REASONS: readonly ["required_clock_input_invalid", "required_clock_capability_unsupported", "required_clock_credentials_missing", "required_clock_acquisition_failed", "required_clock_reconstruction_failed", "required_clock_classification_failed", "required_clock_evidence_incomplete", "required_clock_internal_failure"];
+export declare const SOURCE_TAPE_FAILURE_REASONS: readonly ["source_tape_input_invalid", "source_tape_capability_unsupported", "source_tape_credentials_missing", "source_tape_acquisition_failed", "source_tape_reconstruction_failed", "source_tape_inventory_incomplete", "source_tape_archive_failed", "source_tape_promotion_failed", "source_tape_selection_failed", "source_tape_export_failed", "source_tape_internal_failure"];
+type SourceTapeQualificationSuccessOutcome = {
+    status: "success";
+    reason: "source_tape_prepared";
+    partial_evidence: SourceEvidenceDescriptor[];
+    exporter_result: SourceTapeExporterResultDescriptor;
+};
+type SourceTapeQualificationFailureOutcome = {
+    status: "failure";
+    reason: (typeof SOURCE_TAPE_FAILURE_REASONS)[number];
+    partial_evidence: SourceEvidenceDescriptor[];
+    exporter_result: null;
+};
+export type SourceTapeQualificationRecordWire = SourceQualificationRecordBase & {
+    operation_kind: "source_tape";
+    ledger: SourceQualificationLedgerDescriptor & {
+        state_count: number;
+    };
+    source_tape_eligible: boolean;
+} & ({
+    initializer: SourceTapeInitializerDescriptor;
+    outcome: SourceTapeQualificationSuccessOutcome;
+} | {
+    initializer: SourceTapeInitializerDescriptor | null;
+    outcome: SourceTapeQualificationFailureOutcome;
+});
+export type SourceTapeInitializerDescriptor = {
+    canonical_snapshot_id: Sha256Hex;
+    source_time_ms: number;
+    sequence: string;
+    semantic_stream_position: 0;
+};
+export type SourceEvidenceDescriptor = {
+    kind: "ledger" | "provider_inventory" | "selection" | "promotion_receipt" | "export_result";
+    file_name: string;
+    sha256: Sha256Hex;
+    bytes: number;
+};
+export type SourceTapeExporterResultDescriptor = {
+    schema_id: "https://schemas.usher.so/cex-canonical-orderbook-export-result/v2";
+    file_name: string;
+    sha256: Sha256Hex;
+    bytes: number;
+    result_sha256: Sha256Hex;
+};
+export type SourceQualificationRecordWire = RequiredClockSourceQualificationRecordWire | SourceTapeQualificationRecordWire;
+export declare const sourceForensicsLedgerCodec: {
+    decode(value: unknown, context?: {
+        requiredClock: RequiredClockWire;
+    }): SourceForensicsLedgerWire;
+};
+export declare const sourceQualificationRecordCodec: {
+    decode(value: unknown): SourceQualificationRecordWire;
+};
+export declare function finalizeSourceForensicsLedger(content: Omit<RequiredClockSourceForensicsLedgerWire, "ledger_sha256"> | Omit<SourceTapeForensicsLedgerWire, "ledger_sha256">): SourceForensicsLedgerWire;
+export declare function finalizeSourceQualificationRecord(content: Omit<RequiredClockSourceQualificationRecordWire, "record_sha256"> | Omit<SourceTapeQualificationRecordWire, "record_sha256">): SourceQualificationRecordWire;
+export type ReconstructionObservation = {
+    type: "provider_object_boundary";
+    object: SourceObjectEvidence;
+} | {
+    type: "snapshot_anchor" | "reanchor";
+    anchor: SourceAnchorEvidence;
+} | {
+    type: "sequence_discontinuity";
+    sequence: NonNullable<SourceForensicsRecordWire["sequence"]>;
+    object: SourceObjectEvidence;
+} | {
+    type: "required_clock_sample";
+    target_time_ms: number;
+    source_time_ms: number | null;
+    lag_ms: number | null;
+    status: "covered" | "unanchored" | "stale" | "future";
+    object: SourceObjectEvidence | null;
+} | {
+    type: "invalidation";
+    event_time_ms: number;
+    reason: string;
+} | {
+    type: "provider_object_checksum_conflict";
+    object: SourceObjectEvidence;
+    affected_target_times_ms: readonly number[];
+};
+export interface ReconstructionObservationSink {
+    observe(observation: ReconstructionObservation): void;
+}
+export declare const NOOP_RECONSTRUCTION_OBSERVER: ReconstructionObservationSink;
+type LedgerContext = {
+    schema_id: typeof SOURCE_FORENSICS_LEDGER_SCHEMA_ID;
+    operation_kind?: "required_clock_qualification" | "source_tape";
+    normalized_invocation_sha256?: Sha256Hex;
+    idempotency_key?: Sha256Hex;
+    request_id: LowercaseUuid;
+    scope: CanonicalScopeWire;
+    window?: SourceInventoryInterval;
+    required_clock?: RequiredClockSourceForensicsLedgerWire["required_clock"];
+    source_tape?: SourceTapeForensicsLedgerWire["source_tape"];
+    effective_policies: SourceForensicsLedgerBase["effective_policies"];
+    adapter_version: string;
+    required_clock_targets?: readonly {
+        target_id: LowercaseUuid;
+        target_time_ms: number;
+    }[];
+    expected_provider_object_identities: readonly string[];
+    expected_selected_intervals?: readonly SourceInventoryInterval[];
+    redact_values?: ReadonlySet<string>;
+};
+/**
+ * Streaming qualification sink. It coalesces target intervals as observations
+ * arrive and never retains more derived records than the configured cap.
+ */
+export declare class BoundedSourceForensicsSink implements ReconstructionObservationSink {
+    private readonly context;
+    private readonly testingLimits;
+    private readonly records;
+    private readonly providerObjects;
+    private readonly affectedTargets;
+    private readonly targetObservations;
+    private previousAnchor;
+    private pendingGapRecord;
+    private lastOmittedRecord;
+    private totalRecordCount;
+    private omittedRecordCount;
+    private sourceTapeStateCount;
+    constructor(context: LedgerContext, testingLimits?: {
+        maxRetainedRecords?: number;
+        maxCanonicalJsonBytes?: number;
+    });
+    setSourceTapeStateCount(stateCount: number): void;
+    observe(observation: ReconstructionObservation): void;
+    classifyRecord(selector: {
+        kind: SourceForensicsRecordKind;
+        target_time_ms: number;
+        object_identity: string;
+    }, classification: SourceForensicsClassification): void;
+    pendingClassificationRequests(): Array<{
+        record_key: string;
+        object_identities: string[];
+    }>;
+    applyRecordClassification(input: {
+        record_key: string;
+        classification: SourceForensicsClassification;
+        objects: SourceObjectEvidence[];
+    }): void;
+    private get retainedLimit();
+    private sanitize;
+    private retainObject;
+    private sanitizeAnchor;
+    private interval;
+    private markAffected;
+    private mergeAdjacent;
+    private append;
+    private accept;
+    finish(): SourceForensicsLedgerWire;
+}
+export declare function classifySourceObjectEvidence(input: {
+    checksums: readonly string[];
+    schemaValid: boolean;
+    sequenceValid: boolean;
+    missingRows: boolean;
+    completeSnapshotDefect: boolean;
+    alternateOrderingClosesGap: boolean;
+    staleWithValidPriorState: boolean;
+}): SourceForensicsClassification;
+export type SourceObjectInspection = {
+    checksum: Sha256Hex;
+    schemaValid: boolean;
+    sequenceValid: boolean;
+    missingRows: boolean;
+    completeSnapshotDefect: boolean;
+    alternateOrderingClosesGap: boolean;
+    staleWithValidPriorState: boolean;
+};
+/**
+ * Runs the qualification-only, bounded source inspection. The callback may
+ * inspect licensed bytes, but this return value deliberately retains only safe
+ * identities, checksums and closed predicates. It cannot repair reconstruction
+ * or make an interval acceptance-eligible.
+ */
+export declare function classifyImplicatedSourceObjects(input: {
+    originalIdentity: string;
+    adjacentIdentities: readonly string[];
+    maxAttempts: number;
+    inspect(identity: string, attempt: number): SourceObjectInspection | Promise<SourceObjectInspection>;
+}): Promise<{
+    classification: SourceForensicsClassification;
+    objects: SourceObjectEvidence[];
+    acceptanceEligible: false;
+}>;
+export declare function classifySourceForensicsRecordsDeduplicated(input: {
+    requests: readonly {
+        record_key: string;
+        object_identities: readonly string[];
+    }[];
+    maxAttempts: number;
+    inspect(identity: string, attempt: number): SourceObjectInspection | Promise<SourceObjectInspection>;
+}): Promise<Array<{
+    record_key: string;
+    classification: SourceForensicsClassification;
+    objects: SourceObjectEvidence[];
+}>>;
+export declare function evaluateSourceQualificationGates(ledgerInput: SourceForensicsLedgerWire, sourceReconstructionAccepted: boolean): {
+    operation_kind: "required_clock_qualification";
+    qualified: boolean;
+    source_partition_complete: boolean;
+    source_event_enumeration_eligible: boolean;
+} | {
+    operation_kind: "source_tape";
+    source_event_enumeration_eligible: boolean;
+    source_tape_eligible: boolean;
+};
+export declare function commitSourceQualificationEvidence(input: {
+    outputDirectory: string;
+    ledgerFileName: string;
+    qualificationFileName: string;
+    ledger: SourceForensicsLedgerWire;
+    createdAt: string;
+    sourceAccepted: boolean;
+    requiredClock?: RequiredClockWire;
+    requiredClockFailureReason?: (typeof REQUIRED_CLOCK_QUALIFICATION_FAILURE_REASONS)[number];
+    sourceTapeInitializer?: SourceTapeInitializerDescriptor;
+    sourceTapeOutcome?: SourceTapeQualificationRecordWire["outcome"];
+    cleanupLicensedPayloads?: () => void | Promise<void>;
+}): Promise<SourceQualificationRecordWire>;
+export {};

package/dist/helpers/market-data-vendor-backfill/conformance-fixtures.d.ts

@@ -1,5 +1,5 @@
 export declare const CONFORMANCE_FIXTURES: Readonly<{
-    fixture_id: "market-data-vendor-backfill-conformance/v1";
+    fixture_id: "market-data-vendor-backfill-conformance/v2";
     documents: {
         required_clock: import("./contracts").RequiredClockWire;
         archive_selection: import("./contracts").ArchiveSelectionWire;
@@ -45,18 +45,17 @@ export declare const CONFORMANCE_FIXTURES: Readonly<{
             };
             product_pins: {
                 capability_policy: {
-                    policy_id: "market-data-vendor-backfill-capabilities/v1";
+                    policy_id: "market-data-vendor-backfill-capabilities/v3";
                     policy_sha256: string;
                 };
                 resource_policy: {
-                    policy_id: "market-data-vendor-backfill-resources/v1";
+                    policy_id: "market-data-vendor-backfill-resources/v2";
                     policy_sha256: string;
                 };
             };
             production_authorization_id: string;
         };
         promotion_receipt: import("./contracts").PromotionReceiptWire;
-        result: import("./contracts").BackfillJobResultWire;
     };
     identities: {
         idempotency_key: string;
@@ -65,7 +64,6 @@ export declare const CONFORMANCE_FIXTURES: Readonly<{
         selection_sha256: string;
         promotion_identity_sha256: string;
         receipt_id: string;
-        result_sha256: string;
         capability_policy_sha256: string;
         resource_policy_sha256: string;
     };