@empressaio/atom-contract 1.7.0 → 1.8.0

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

@@ -0,0 +1,475 @@
+/**
+ * Alternate read-contract axes for property / envelope / non-life-safety
+ * reasoning atoms (Gate B §2.5.2).
+ *
+ * Life-safety surfaces keep {@link ThreeAxisConfidence} with required
+ * ASCE7/IBC {@link ConsequenceAxis}. Property reasoning uses honest
+ * property-risk strata or explicit not-applicable — never stuffed ASCE7.
+ */
+import { z } from "zod";
+import { WIDTHED_CONFIDENCE_SCHEMA, type WidthedConfidence } from "./common.js";
+import { MODEL_ATTRIBUTION_STAMP_SCHEMA, type ModelAttributionStamp } from "./model-attribution.js";
+/** Property-risk stratum — no "essential" invent (life-safety only). */
+export type PropertyRiskStratum = "routine" | "elevated" | "critical";
+export declare const PROPERTY_RISK_STRATA: ReadonlyArray<PropertyRiskStratum>;
+export type PropertyConsequence = {
+    kind: "property-risk";
+    stratum: PropertyRiskStratum;
+    /** Honest basis: e.g. "flood-sfha", "no-buildable-area", "setback-constrained". */
+    basis: string;
+    assertedAt: string;
+    auditRef?: string;
+} | {
+    kind: "not-applicable";
+    reason: string;
+    assertedAt: string;
+};
+export declare const PROPERTY_CONSEQUENCE_PROPERTY_RISK_SCHEMA: z.ZodObject<{
+    kind: z.ZodLiteral<"property-risk">;
+    stratum: z.ZodEnum<[PropertyRiskStratum, ...PropertyRiskStratum[]]>;
+    basis: z.ZodString;
+    assertedAt: z.ZodString;
+    auditRef: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    stratum: PropertyRiskStratum;
+    assertedAt: string;
+    kind: "property-risk";
+    basis: string;
+    auditRef?: string | undefined;
+}, {
+    stratum: PropertyRiskStratum;
+    assertedAt: string;
+    kind: "property-risk";
+    basis: string;
+    auditRef?: string | undefined;
+}>;
+export declare const PROPERTY_CONSEQUENCE_NOT_APPLICABLE_SCHEMA: z.ZodObject<{
+    kind: z.ZodLiteral<"not-applicable">;
+    reason: z.ZodString;
+    assertedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    assertedAt: string;
+    kind: "not-applicable";
+    reason: string;
+}, {
+    assertedAt: string;
+    kind: "not-applicable";
+    reason: string;
+}>;
+export declare const PROPERTY_CONSEQUENCE_SCHEMA: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"property-risk">;
+    stratum: z.ZodEnum<[PropertyRiskStratum, ...PropertyRiskStratum[]]>;
+    basis: z.ZodString;
+    assertedAt: z.ZodString;
+    auditRef: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    stratum: PropertyRiskStratum;
+    assertedAt: string;
+    kind: "property-risk";
+    basis: string;
+    auditRef?: string | undefined;
+}, {
+    stratum: PropertyRiskStratum;
+    assertedAt: string;
+    kind: "property-risk";
+    basis: string;
+    auditRef?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"not-applicable">;
+    reason: z.ZodString;
+    assertedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    assertedAt: string;
+    kind: "not-applicable";
+    reason: string;
+}, {
+    assertedAt: string;
+    kind: "not-applicable";
+    reason: string;
+}>]>;
+export interface ReasoningThreeAxisConfidence {
+    readonly calibratedConfidence: WidthedConfidence;
+    readonly assertedConfidence: WidthedConfidence;
+    readonly consequence: PropertyConsequence;
+}
+export declare const REASONING_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.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"property-risk">;
+        stratum: z.ZodEnum<[PropertyRiskStratum, ...PropertyRiskStratum[]]>;
+        basis: z.ZodString;
+        assertedAt: z.ZodString;
+        auditRef: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        stratum: PropertyRiskStratum;
+        assertedAt: string;
+        kind: "property-risk";
+        basis: string;
+        auditRef?: string | undefined;
+    }, {
+        stratum: PropertyRiskStratum;
+        assertedAt: string;
+        kind: "property-risk";
+        basis: string;
+        auditRef?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"not-applicable">;
+        reason: z.ZodString;
+        assertedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        assertedAt: string;
+        kind: "not-applicable";
+        reason: string;
+    }, {
+        assertedAt: string;
+        kind: "not-applicable";
+        reason: string;
+    }>]>;
+}, "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: {
+        stratum: PropertyRiskStratum;
+        assertedAt: string;
+        kind: "property-risk";
+        basis: string;
+        auditRef?: string | undefined;
+    } | {
+        assertedAt: string;
+        kind: "not-applicable";
+        reason: string;
+    };
+}, {
+    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: {
+        stratum: PropertyRiskStratum;
+        assertedAt: string;
+        kind: "property-risk";
+        basis: string;
+        auditRef?: string | undefined;
+    } | {
+        assertedAt: string;
+        kind: "not-applicable";
+        reason: string;
+    };
+}>>;
+/**
+ * Read-contract for property / envelope reasoning emitters.
+ * Life-safety / ICC code-risk surfaces keep {@link ReadContract}.
+ */
+export interface ReasoningReadContract {
+    readonly axes: ReasoningThreeAxisConfidence;
+    readonly assembledAt: string;
+    readonly modelAttribution?: ModelAttributionStamp;
+}
+export declare const REASONING_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.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"property-risk">;
+            stratum: z.ZodEnum<[PropertyRiskStratum, ...PropertyRiskStratum[]]>;
+            basis: z.ZodString;
+            assertedAt: z.ZodString;
+            auditRef: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            stratum: PropertyRiskStratum;
+            assertedAt: string;
+            kind: "property-risk";
+            basis: string;
+            auditRef?: string | undefined;
+        }, {
+            stratum: PropertyRiskStratum;
+            assertedAt: string;
+            kind: "property-risk";
+            basis: string;
+            auditRef?: string | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"not-applicable">;
+            reason: z.ZodString;
+            assertedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            assertedAt: string;
+            kind: "not-applicable";
+            reason: string;
+        }, {
+            assertedAt: string;
+            kind: "not-applicable";
+            reason: string;
+        }>]>;
+    }, "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: {
+            stratum: PropertyRiskStratum;
+            assertedAt: string;
+            kind: "property-risk";
+            basis: string;
+            auditRef?: string | undefined;
+        } | {
+            assertedAt: string;
+            kind: "not-applicable";
+            reason: string;
+        };
+    }, {
+        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: {
+            stratum: PropertyRiskStratum;
+            assertedAt: string;
+            kind: "property-risk";
+            basis: string;
+            auditRef?: string | undefined;
+        } | {
+            assertedAt: string;
+            kind: "not-applicable";
+            reason: string;
+        };
+    }>>;
+    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: {
+            stratum: PropertyRiskStratum;
+            assertedAt: string;
+            kind: "property-risk";
+            basis: string;
+            auditRef?: string | undefined;
+        } | {
+            assertedAt: string;
+            kind: "not-applicable";
+            reason: string;
+        };
+    }>;
+    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: {
+            stratum: PropertyRiskStratum;
+            assertedAt: string;
+            kind: "property-risk";
+            basis: string;
+            auditRef?: string | undefined;
+        } | {
+            assertedAt: string;
+            kind: "not-applicable";
+            reason: string;
+        };
+    }>;
+    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 declare function createPropertyConsequence(input: z.input<typeof PROPERTY_CONSEQUENCE_SCHEMA>): PropertyConsequence;
+export interface CreateReasoningThreeAxisConfidenceInput {
+    calibratedConfidence: z.input<typeof WIDTHED_CONFIDENCE_SCHEMA>;
+    assertedConfidence: z.input<typeof WIDTHED_CONFIDENCE_SCHEMA>;
+    consequence: z.input<typeof PROPERTY_CONSEQUENCE_SCHEMA>;
+}
+export declare function createReasoningThreeAxisConfidence(input: CreateReasoningThreeAxisConfidenceInput): ReasoningThreeAxisConfidence;
+export interface CreateReasoningReadContractInput {
+    axes: CreateReasoningThreeAxisConfidenceInput;
+    assembledAt: string;
+    modelAttribution?: z.input<typeof MODEL_ATTRIBUTION_STAMP_SCHEMA>;
+}
+export declare function createReasoningReadContract(input: CreateReasoningReadContractInput): ReasoningReadContract;
+/** Runtime validator for property reasoning read-contract emitters. */
+export declare function validateReasoningReadContract(value: unknown): ReasoningReadContract;
+//# sourceMappingURL=reasoning-axes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-axes.d.ts","sourceRoot":"","sources":["../../src/read-contract/reasoning-axes.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,75 @@
+/**
+ * Alternate read-contract axes for property / envelope / non-life-safety
+ * reasoning atoms (Gate B §2.5.2).
+ *
+ * Life-safety surfaces keep {@link ThreeAxisConfidence} with required
+ * ASCE7/IBC {@link ConsequenceAxis}. Property reasoning uses honest
+ * property-risk strata or explicit not-applicable — never stuffed ASCE7.
+ */
+import { z } from "zod";
+import { WIDTHED_CONFIDENCE_SCHEMA, createWidthedConfidence, } from "./common.js";
+import { MODEL_ATTRIBUTION_STAMP_SCHEMA, } from "./model-attribution.js";
+export const PROPERTY_RISK_STRATA = [
+    "routine",
+    "elevated",
+    "critical",
+];
+export const PROPERTY_CONSEQUENCE_PROPERTY_RISK_SCHEMA = z.object({
+    kind: z.literal("property-risk"),
+    stratum: z.enum(PROPERTY_RISK_STRATA),
+    basis: z.string().min(1),
+    assertedAt: z.string().min(1),
+    auditRef: z.string().min(1).optional(),
+});
+export const PROPERTY_CONSEQUENCE_NOT_APPLICABLE_SCHEMA = z.object({
+    kind: z.literal("not-applicable"),
+    reason: z.string().min(1),
+    assertedAt: z.string().min(1),
+});
+export const PROPERTY_CONSEQUENCE_SCHEMA = z.discriminatedUnion("kind", [
+    PROPERTY_CONSEQUENCE_PROPERTY_RISK_SCHEMA,
+    PROPERTY_CONSEQUENCE_NOT_APPLICABLE_SCHEMA,
+]);
+export const REASONING_THREE_AXIS_CONFIDENCE_SCHEMA = z
+    .object({
+    calibratedConfidence: WIDTHED_CONFIDENCE_SCHEMA,
+    assertedConfidence: WIDTHED_CONFIDENCE_SCHEMA,
+    consequence: PROPERTY_CONSEQUENCE_SCHEMA,
+})
+    .readonly();
+export const REASONING_READ_CONTRACT_SCHEMA = z
+    .object({
+    axes: REASONING_THREE_AXIS_CONFIDENCE_SCHEMA,
+    assembledAt: z.string().min(1),
+    modelAttribution: MODEL_ATTRIBUTION_STAMP_SCHEMA.optional(),
+})
+    .readonly();
+export function createPropertyConsequence(input) {
+    return PROPERTY_CONSEQUENCE_SCHEMA.parse(input);
+}
+export function createReasoningThreeAxisConfidence(input) {
+    const parsed = REASONING_THREE_AXIS_CONFIDENCE_SCHEMA.parse(input);
+    return {
+        calibratedConfidence: createWidthedConfidence(parsed.calibratedConfidence),
+        assertedConfidence: createWidthedConfidence(parsed.assertedConfidence),
+        consequence: createPropertyConsequence(parsed.consequence),
+    };
+}
+export function createReasoningReadContract(input) {
+    const parsed = REASONING_READ_CONTRACT_SCHEMA.parse({
+        axes: input.axes,
+        assembledAt: input.assembledAt,
+        modelAttribution: input.modelAttribution,
+    });
+    return {
+        axes: createReasoningThreeAxisConfidence(parsed.axes),
+        assembledAt: parsed.assembledAt,
+        modelAttribution: parsed.modelAttribution,
+    };
+}
+/** Runtime validator for property reasoning read-contract emitters. */
+export function validateReasoningReadContract(value) {
+    const parsed = REASONING_READ_CONTRACT_SCHEMA.parse(value);
+    return createReasoningReadContract(parsed);
+}
+//# sourceMappingURL=reasoning-axes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-axes.js","sourceRoot":"","sources":["../../src/read-contract/reasoning-axes.ts"],"names":[],"mappings":"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"}

package/dist/reasoning/fixtures.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Reasoning-chain conformance fixtures per Gate B §2.3 and §5.7.
+ *
+ * Property entityTypes (zoning-fact, setback-rule, buildable-envelope) are
+ * Phase 1b bindings — named in comments, not registered as full kinds in 1.8.0.
+ */
+import type { AccessPolicy } from "../registration.js";
+import type { ReasoningChain } from "../reasoning-chain.js";
+import { type ReasoningReadContract } from "../read-contract/reasoning-axes.js";
+import type { ObligationAtomInstance } from "../obligation.js";
+import { ICC_ACTOR_RECORD_FIXTURE } from "../actor-record.js";
+/** Stub shape showing how reasoning chain attaches before Phase 1b kinds ship. */
+export interface ReasoningInstanceStub {
+    /** Phase 1b: entityType would be e.g. "zoning-fact". */
+    entityTypeHint: string;
+    reasoningChain: ReasoningChain;
+    sourceCitation: string;
+    extractedAt: string;
+    accessPolicy: AccessPolicy;
+    readContract?: ReasoningReadContract;
+}
+/** Observed fact stub — public-free with provenance fields present. */
+export declare const OBSERVED_FACT_REASONING_STUB: ReasoningInstanceStub;
+/** Derived envelope stub — not-applicable consequence, no stuffed ASCE7. */
+export declare const DERIVED_ENVELOPE_REASONING_STUB: ReasoningInstanceStub;
+/** Negative fixture inputs — validated in tests, not valid instances. */
+export declare const NEGATIVE_DERIVED_NO_INPUT_REFS: {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: [];
+};
+export declare const NEGATIVE_DERIVED_EMPTY_ATOM_DID: {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: {
+        atomDid: string;
+        role: "fact";
+    }[];
+};
+/** Re-export ICC actor for obligation edge demonstrations. */
+export { ICC_ACTOR_RECORD_FIXTURE };
+/**
+ * ICC inbound reference royalty — reuses shipped ObligationAtomInstance shape.
+ * amount omitted with graceTerms pending-rate when commercial rates unset (I-K).
+ */
+export declare const ICC_LICENSE_REFERENCE_OBLIGATION_FIXTURE: ObligationAtomInstance;
+/** Negative obligation fixture — license type without owedToActorDid. */
+export declare const NEGATIVE_ICC_OBLIGATION_MISSING_ACTOR: {
+    entityType: "obligation";
+    obligationDid: string;
+    obligationType: "license-reference-royalty";
+    anchorDid: string;
+    anchorKind: string;
+    dueDate: string;
+    recurrence: string;
+    graceTerms: string;
+    status: "upcoming";
+    confidence: import("../read-contract/common.js").WidthedConfidence;
+    sourceCitation: string;
+    extractedAt: string;
+    accessPolicy: "platform-internal";
+};
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/reasoning/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/reasoning/fixtures.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,oCAAoC,CAAC;AAE5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,kFAAkF;AAClF,MAAM,WAAW,qBAAqB;IACpC,wDAAwD;IACxD,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,cAAc,CAAC;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC;AAgBD,uEAAuE;AACvE,eAAO,MAAM,4BAA4B,EAAE,qBAM1C,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,+BAA+B,EAAE,qBA6C7C,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,8BAA8B;;;mBAGpB,EAAE;CACxB,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;CAI3C,CAAC;AAEF,8DAA8D;AAC9D,OAAO,EAAE,wBAAwB,EAAE,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,wCAAwC,EAAE,sBAetD,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;CAcjD,CAAC"}