@empressaio/atom-contract 1.7.0

package/dist/read-contract/model-attribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-attribution.d.ts","sourceRoot":"","sources":["../../src/read-contract/model-attribution.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;2BAQtB,CAAC;AAEd,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEpE;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACrC;AAED,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAS9B,CAAC;AAEd,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,GACpD,qBAAqB,CAEvB"}

package/dist/read-contract/model-attribution.js

@@ -0,0 +1,30 @@
+/**
+ * Model-attribution stamp for the rich raw ledger (F3).
+ *
+ * Stamped on deposit; agreement, posterior, and per-model reliability
+ * are derived at read — never persisted here.
+ */
+import { z } from "zod";
+export const SAMPLING_PARAMS_SCHEMA = z
+    .object({
+    temperature: z.number().optional(),
+    topP: z.number().min(0).max(1).optional(),
+    maxTokens: z.number().int().positive().optional(),
+    seed: z.number().int().optional(),
+})
+    .catchall(z.unknown())
+    .readonly();
+export const MODEL_ATTRIBUTION_STAMP_SCHEMA = z
+    .object({
+    modelId: z.string().min(1),
+    modelVersion: z.string().min(1),
+    promptTemplateVersion: z.string().min(1),
+    contextTemplateVersion: z.string().min(1),
+    samplingParams: SAMPLING_PARAMS_SCHEMA,
+    retrievedAtomSetId: z.string().min(1),
+})
+    .readonly();
+export function createModelAttributionStamp(input) {
+    return MODEL_ATTRIBUTION_STAMP_SCHEMA.parse(input);
+}
+//# sourceMappingURL=model-attribution.js.map

package/dist/read-contract/model-attribution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-attribution.js","sourceRoot":"","sources":["../../src/read-contract/model-attribution.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC;KACpC,MAAM,CAAC;IACN,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACzC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACjD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC;KACD,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;KACrB,QAAQ,EAAE,CAAC;AAiBd,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC;KAC5C,MAAM,CAAC;IACN,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxC,sBAAsB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzC,cAAc,EAAE,sBAAsB;IACtC,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CACtC,CAAC;KACD,QAAQ,EAAE,CAAC;AAEd,MAAM,UAAU,2BAA2B,CACzC,KAAqD;IAErD,OAAO,8BAA8B,CAAC,KAAK,CAAC,KAAK,CAA0B,CAAC;AAC9E,CAAC"}

package/dist/read-contract/read-contract.d.ts

@@ -0,0 +1,455 @@
+/**
+ * Read-contract object (F4) and three-axis confidence contract (F6).
+ *
+ * Returned at read time; derived quantities are not stored. Calibration
+ * provenance (K6) rides on each {@link WidthedConfidence} on the
+ * accuracy and source-quality axes.
+ */
+import { z } from "zod";
+import { WIDTHED_CONFIDENCE_SCHEMA, type WidthedConfidence } from "./common.js";
+import { CONSEQUENCE_AXIS_SCHEMA, type ConsequenceAxis } from "./consequence.js";
+import { MODEL_ATTRIBUTION_STAMP_SCHEMA, type ModelAttributionStamp } from "./model-attribution.js";
+/**
+ * Three distinct confidence axes per the calibration architecture addendum.
+ *
+ * - {@link ThreeAxisConfidence.calibratedConfidence} — accuracy, earned
+ *   (commitment #2 governs only this axis).
+ * - {@link ThreeAxisConfidence.assertedConfidence} — source-quality,
+ *   asserted with provenance on every write.
+ * - {@link ThreeAxisConfidence.consequence} — severity, asserted-audited,
+ *   derived from code risk classifications; no invented scalar.
+ */
+export interface ThreeAxisConfidence {
+    readonly calibratedConfidence: WidthedConfidence;
+    readonly assertedConfidence: WidthedConfidence;
+    readonly consequence: ConsequenceAxis;
+}
+export declare const THREE_AXIS_CONFIDENCE_SCHEMA: z.ZodReadonly<z.ZodObject<{
+    calibratedConfidence: z.ZodReadonly<z.ZodObject<{
+        readonly estimate: z.ZodNumber;
+        readonly n: z.ZodNumber;
+        readonly intervalWidth: z.ZodNumber;
+        readonly provenance: z.ZodEnum<["asserted", "backtest", "seed", "live"]>;
+    }, "strip", z.ZodTypeAny, {
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }, {
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }>>;
+    assertedConfidence: z.ZodReadonly<z.ZodObject<{
+        readonly estimate: z.ZodNumber;
+        readonly n: z.ZodNumber;
+        readonly intervalWidth: z.ZodNumber;
+        readonly provenance: z.ZodEnum<["asserted", "backtest", "seed", "live"]>;
+    }, "strip", z.ZodTypeAny, {
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }, {
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }>>;
+    consequence: z.ZodReadonly<z.ZodObject<{
+        derivation: z.ZodReadonly<z.ZodObject<{
+            source: z.ZodEnum<["asce7-risk-category", "ibc-occupancy-importance", "derived-composite"]>;
+            asce7RiskCategory: z.ZodEnum<["I", "II", "III", "IV"]>;
+            ibcOccupancyGroup: z.ZodOptional<z.ZodString>;
+            ibcImportanceFactor: z.ZodOptional<z.ZodNumber>;
+            jurisdictionCode: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+            asce7RiskCategory: "I" | "II" | "III" | "IV";
+            ibcOccupancyGroup?: string | undefined;
+            ibcImportanceFactor?: number | undefined;
+            jurisdictionCode?: string | undefined;
+        }, {
+            source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+            asce7RiskCategory: "I" | "II" | "III" | "IV";
+            ibcOccupancyGroup?: string | undefined;
+            ibcImportanceFactor?: number | undefined;
+            jurisdictionCode?: string | undefined;
+        }>>;
+        stratum: z.ZodEnum<["routine", "elevated", "critical", "essential"]>;
+        assertedAt: z.ZodString;
+        auditRef: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        derivation: Readonly<{
+            source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+            asce7RiskCategory: "I" | "II" | "III" | "IV";
+            ibcOccupancyGroup?: string | undefined;
+            ibcImportanceFactor?: number | undefined;
+            jurisdictionCode?: string | undefined;
+        }>;
+        stratum: "routine" | "elevated" | "critical" | "essential";
+        assertedAt: string;
+        auditRef?: string | undefined;
+    }, {
+        derivation: Readonly<{
+            source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+            asce7RiskCategory: "I" | "II" | "III" | "IV";
+            ibcOccupancyGroup?: string | undefined;
+            ibcImportanceFactor?: number | undefined;
+            jurisdictionCode?: string | undefined;
+        }>;
+        stratum: "routine" | "elevated" | "critical" | "essential";
+        assertedAt: string;
+        auditRef?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    calibratedConfidence: Readonly<{
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }>;
+    assertedConfidence: Readonly<{
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }>;
+    consequence: Readonly<{
+        derivation: Readonly<{
+            source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+            asce7RiskCategory: "I" | "II" | "III" | "IV";
+            ibcOccupancyGroup?: string | undefined;
+            ibcImportanceFactor?: number | undefined;
+            jurisdictionCode?: string | undefined;
+        }>;
+        stratum: "routine" | "elevated" | "critical" | "essential";
+        assertedAt: string;
+        auditRef?: string | undefined;
+    }>;
+}, {
+    calibratedConfidence: Readonly<{
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }>;
+    assertedConfidence: Readonly<{
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }>;
+    consequence: Readonly<{
+        derivation: Readonly<{
+            source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+            asce7RiskCategory: "I" | "II" | "III" | "IV";
+            ibcOccupancyGroup?: string | undefined;
+            ibcImportanceFactor?: number | undefined;
+            jurisdictionCode?: string | undefined;
+        }>;
+        stratum: "routine" | "elevated" | "critical" | "essential";
+        assertedAt: string;
+        auditRef?: string | undefined;
+    }>;
+}>>;
+/**
+ * The read-contract object every confidence-emitting surface must return.
+ * No bare scalar confidence field exists on this type.
+ */
+export interface ReadContract {
+    readonly axes: ThreeAxisConfidence;
+    /** ISO-8601 timestamp when the read-contract was assembled at read time. */
+    readonly assembledAt: string;
+    /**
+     * Model-attribution stamp from the ledger deposit that sourced this
+     * read. Omitted on deterministic / non-model reads.
+     */
+    readonly modelAttribution?: ModelAttributionStamp;
+}
+export declare const READ_CONTRACT_SCHEMA: z.ZodReadonly<z.ZodObject<{
+    axes: z.ZodReadonly<z.ZodObject<{
+        calibratedConfidence: z.ZodReadonly<z.ZodObject<{
+            readonly estimate: z.ZodNumber;
+            readonly n: z.ZodNumber;
+            readonly intervalWidth: z.ZodNumber;
+            readonly provenance: z.ZodEnum<["asserted", "backtest", "seed", "live"]>;
+        }, "strip", z.ZodTypeAny, {
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }, {
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>>;
+        assertedConfidence: z.ZodReadonly<z.ZodObject<{
+            readonly estimate: z.ZodNumber;
+            readonly n: z.ZodNumber;
+            readonly intervalWidth: z.ZodNumber;
+            readonly provenance: z.ZodEnum<["asserted", "backtest", "seed", "live"]>;
+        }, "strip", z.ZodTypeAny, {
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }, {
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>>;
+        consequence: z.ZodReadonly<z.ZodObject<{
+            derivation: z.ZodReadonly<z.ZodObject<{
+                source: z.ZodEnum<["asce7-risk-category", "ibc-occupancy-importance", "derived-composite"]>;
+                asce7RiskCategory: z.ZodEnum<["I", "II", "III", "IV"]>;
+                ibcOccupancyGroup: z.ZodOptional<z.ZodString>;
+                ibcImportanceFactor: z.ZodOptional<z.ZodNumber>;
+                jurisdictionCode: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+                asce7RiskCategory: "I" | "II" | "III" | "IV";
+                ibcOccupancyGroup?: string | undefined;
+                ibcImportanceFactor?: number | undefined;
+                jurisdictionCode?: string | undefined;
+            }, {
+                source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+                asce7RiskCategory: "I" | "II" | "III" | "IV";
+                ibcOccupancyGroup?: string | undefined;
+                ibcImportanceFactor?: number | undefined;
+                jurisdictionCode?: string | undefined;
+            }>>;
+            stratum: z.ZodEnum<["routine", "elevated", "critical", "essential"]>;
+            assertedAt: z.ZodString;
+            auditRef: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            derivation: Readonly<{
+                source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+                asce7RiskCategory: "I" | "II" | "III" | "IV";
+                ibcOccupancyGroup?: string | undefined;
+                ibcImportanceFactor?: number | undefined;
+                jurisdictionCode?: string | undefined;
+            }>;
+            stratum: "routine" | "elevated" | "critical" | "essential";
+            assertedAt: string;
+            auditRef?: string | undefined;
+        }, {
+            derivation: Readonly<{
+                source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+                asce7RiskCategory: "I" | "II" | "III" | "IV";
+                ibcOccupancyGroup?: string | undefined;
+                ibcImportanceFactor?: number | undefined;
+                jurisdictionCode?: string | undefined;
+            }>;
+            stratum: "routine" | "elevated" | "critical" | "essential";
+            assertedAt: string;
+            auditRef?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        calibratedConfidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        assertedConfidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        consequence: Readonly<{
+            derivation: Readonly<{
+                source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+                asce7RiskCategory: "I" | "II" | "III" | "IV";
+                ibcOccupancyGroup?: string | undefined;
+                ibcImportanceFactor?: number | undefined;
+                jurisdictionCode?: string | undefined;
+            }>;
+            stratum: "routine" | "elevated" | "critical" | "essential";
+            assertedAt: string;
+            auditRef?: string | undefined;
+        }>;
+    }, {
+        calibratedConfidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        assertedConfidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        consequence: Readonly<{
+            derivation: Readonly<{
+                source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+                asce7RiskCategory: "I" | "II" | "III" | "IV";
+                ibcOccupancyGroup?: string | undefined;
+                ibcImportanceFactor?: number | undefined;
+                jurisdictionCode?: string | undefined;
+            }>;
+            stratum: "routine" | "elevated" | "critical" | "essential";
+            assertedAt: string;
+            auditRef?: string | undefined;
+        }>;
+    }>>;
+    assembledAt: z.ZodString;
+    modelAttribution: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        modelVersion: z.ZodString;
+        promptTemplateVersion: z.ZodString;
+        contextTemplateVersion: z.ZodString;
+        samplingParams: z.ZodReadonly<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodUnknown, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodUnknown, "strip">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodUnknown, "strip">>>;
+        retrievedAtomSetId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        modelId: string;
+        modelVersion: string;
+        promptTemplateVersion: string;
+        contextTemplateVersion: string;
+        samplingParams: Readonly<z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodUnknown, "strip">>;
+        retrievedAtomSetId: string;
+    }, {
+        modelId: string;
+        modelVersion: string;
+        promptTemplateVersion: string;
+        contextTemplateVersion: string;
+        samplingParams: Readonly<z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodUnknown, "strip">>;
+        retrievedAtomSetId: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    axes: Readonly<{
+        calibratedConfidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        assertedConfidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        consequence: Readonly<{
+            derivation: Readonly<{
+                source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+                asce7RiskCategory: "I" | "II" | "III" | "IV";
+                ibcOccupancyGroup?: string | undefined;
+                ibcImportanceFactor?: number | undefined;
+                jurisdictionCode?: string | undefined;
+            }>;
+            stratum: "routine" | "elevated" | "critical" | "essential";
+            assertedAt: string;
+            auditRef?: string | undefined;
+        }>;
+    }>;
+    assembledAt: string;
+    modelAttribution?: Readonly<{
+        modelId: string;
+        modelVersion: string;
+        promptTemplateVersion: string;
+        contextTemplateVersion: string;
+        samplingParams: Readonly<z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodUnknown, "strip">>;
+        retrievedAtomSetId: string;
+    }> | undefined;
+}, {
+    axes: Readonly<{
+        calibratedConfidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        assertedConfidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        consequence: Readonly<{
+            derivation: Readonly<{
+                source: "asce7-risk-category" | "ibc-occupancy-importance" | "derived-composite";
+                asce7RiskCategory: "I" | "II" | "III" | "IV";
+                ibcOccupancyGroup?: string | undefined;
+                ibcImportanceFactor?: number | undefined;
+                jurisdictionCode?: string | undefined;
+            }>;
+            stratum: "routine" | "elevated" | "critical" | "essential";
+            assertedAt: string;
+            auditRef?: string | undefined;
+        }>;
+    }>;
+    assembledAt: string;
+    modelAttribution?: Readonly<{
+        modelId: string;
+        modelVersion: string;
+        promptTemplateVersion: string;
+        contextTemplateVersion: string;
+        samplingParams: Readonly<z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodUnknown, "strip">>;
+        retrievedAtomSetId: string;
+    }> | undefined;
+}>>;
+export interface CreateThreeAxisConfidenceInput {
+    calibratedConfidence: z.input<typeof WIDTHED_CONFIDENCE_SCHEMA>;
+    assertedConfidence: z.input<typeof WIDTHED_CONFIDENCE_SCHEMA>;
+    consequence: z.input<typeof CONSEQUENCE_AXIS_SCHEMA>;
+}
+export declare function createThreeAxisConfidence(input: CreateThreeAxisConfidenceInput): ThreeAxisConfidence;
+export interface CreateReadContractInput {
+    axes: CreateThreeAxisConfidenceInput;
+    assembledAt: string;
+    modelAttribution?: z.input<typeof MODEL_ATTRIBUTION_STAMP_SCHEMA>;
+}
+export declare function createReadContract(input: CreateReadContractInput): ReadContract;
+/**
+ * Legacy {@link EngineEnvelopeConfidence} shape still emitted by
+ * engine-core and cortex-api. Migration adapters consume this and
+ * produce a {@link ReadContract}; it is not a valid emission shape
+ * once F4 propagation lands.
+ */
+export interface LegacyEngineEnvelopeConfidence {
+    readonly value: number;
+    readonly kind: "calibrated" | "asserted" | "deterministic";
+}
+//# sourceMappingURL=read-contract.d.ts.map

package/dist/read-contract/read-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-contract.d.ts","sourceRoot":"","sources":["../../src/read-contract/read-contract.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,yBAAyB,EAEzB,KAAK,iBAAiB,EACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,uBAAuB,EAEvB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,8BAA8B,EAC9B,KAAK,qBAAqB,EAC3B,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,oBAAoB,EAAE,iBAAiB,CAAC;IACjD,QAAQ,CAAC,kBAAkB,EAAE,iBAAiB,CAAC;IAC/C,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAC;CACvC;AAED,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAM5B,CAAC;AAEd;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,qBAAqB,CAAC;CACnD;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMpB,CAAC;AAEd,MAAM,WAAW,8BAA8B;IAC7C,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;IAChE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;IAC9D,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;CACtD;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,8BAA8B,GACpC,mBAAmB,CAOrB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,8BAA8B,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;CACnE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,GAAG,YAAY,CAW/E;AAED;;;;;GAKG;AACH,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,UAAU,GAAG,eAAe,CAAC;CAC5D"}

package/dist/read-contract/read-contract.js

@@ -0,0 +1,46 @@
+/**
+ * Read-contract object (F4) and three-axis confidence contract (F6).
+ *
+ * Returned at read time; derived quantities are not stored. Calibration
+ * provenance (K6) rides on each {@link WidthedConfidence} on the
+ * accuracy and source-quality axes.
+ */
+import { z } from "zod";
+import { WIDTHED_CONFIDENCE_SCHEMA, createWidthedConfidence, } from "./common.js";
+import { CONSEQUENCE_AXIS_SCHEMA, createConsequenceAxis, } from "./consequence.js";
+import { MODEL_ATTRIBUTION_STAMP_SCHEMA, } from "./model-attribution.js";
+export const THREE_AXIS_CONFIDENCE_SCHEMA = z
+    .object({
+    calibratedConfidence: WIDTHED_CONFIDENCE_SCHEMA,
+    assertedConfidence: WIDTHED_CONFIDENCE_SCHEMA,
+    consequence: CONSEQUENCE_AXIS_SCHEMA,
+})
+    .readonly();
+export const READ_CONTRACT_SCHEMA = z
+    .object({
+    axes: THREE_AXIS_CONFIDENCE_SCHEMA,
+    assembledAt: z.string().min(1),
+    modelAttribution: MODEL_ATTRIBUTION_STAMP_SCHEMA.optional(),
+})
+    .readonly();
+export function createThreeAxisConfidence(input) {
+    const parsed = THREE_AXIS_CONFIDENCE_SCHEMA.parse(input);
+    return {
+        calibratedConfidence: createWidthedConfidence(parsed.calibratedConfidence),
+        assertedConfidence: createWidthedConfidence(parsed.assertedConfidence),
+        consequence: createConsequenceAxis(parsed.consequence),
+    };
+}
+export function createReadContract(input) {
+    const parsed = READ_CONTRACT_SCHEMA.parse({
+        axes: input.axes,
+        assembledAt: input.assembledAt,
+        modelAttribution: input.modelAttribution,
+    });
+    return {
+        axes: createThreeAxisConfidence(parsed.axes),
+        assembledAt: parsed.assembledAt,
+        modelAttribution: parsed.modelAttribution,
+    };
+}
+//# sourceMappingURL=read-contract.js.map

package/dist/read-contract/read-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-contract.js","sourceRoot":"","sources":["../../src/read-contract/read-contract.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,yBAAyB,EACzB,uBAAuB,GAExB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GAEtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,8BAA8B,GAE/B,MAAM,wBAAwB,CAAC;AAkBhC,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC;KAC1C,MAAM,CAAC;IACN,oBAAoB,EAAE,yBAAyB;IAC/C,kBAAkB,EAAE,yBAAyB;IAC7C,WAAW,EAAE,uBAAuB;CACrC,CAAC;KACD,QAAQ,EAAE,CAAC;AAiBd,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,IAAI,EAAE,4BAA4B;IAClC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,gBAAgB,EAAE,8BAA8B,CAAC,QAAQ,EAAE;CAC5D,CAAC;KACD,QAAQ,EAAE,CAAC;AAQd,MAAM,UAAU,yBAAyB,CACvC,KAAqC;IAErC,MAAM,MAAM,GAAG,4BAA4B,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACzD,OAAO;QACL,oBAAoB,EAAE,uBAAuB,CAAC,MAAM,CAAC,oBAAoB,CAAC;QAC1E,kBAAkB,EAAE,uBAAuB,CAAC,MAAM,CAAC,kBAAkB,CAAC;QACtE,WAAW,EAAE,qBAAqB,CAAC,MAAM,CAAC,WAAW,CAAC;KACvD,CAAC;AACJ,CAAC;AAQD,MAAM,UAAU,kBAAkB,CAAC,KAA8B;IAC/D,MAAM,MAAM,GAAG,oBAAoB,CAAC,KAAK,CAAC;QACxC,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;KACzC,CAAC,CAAC;IACH,OAAO;QACL,IAAI,EAAE,yBAAyB,CAAC,MAAM,CAAC,IAAI,CAAC;QAC5C,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;KAC1C,CAAC;AACJ,CAAC"}