@empressaio/atom-contract 1.7.0 → 1.9.0

package/dist/property/common.d.ts

@@ -0,0 +1,513 @@
+/**
+ * Shared property reasoning atom substrate (master WDLL 3.2–3.6).
+ *
+ * Property fact / rule / derived kinds reuse 1.8.0 primitives:
+ * {@link ReasoningChain}, {@link AtomInputRef}, {@link PropertyConsequence},
+ * {@link ReasoningReadContract}, {@link ActorRecordAtomInstance},
+ * {@link ObligationAtomInstance}.
+ *
+ * **Calibrated confidence at READ (I-E):** instances MAY carry a
+ * {@link ReasoningThreeAxisConfidence}-shaped asserted snapshot at write
+ * time (including a placeholder `calibratedConfidence` with
+ * `provenance: "asserted"`). At READ, the calibrated axis resolves through
+ * the calibration overlay — it is NOT composed-and-frozen on the instance.
+ * Do not invent a frozen multiply (e.g. no `labeling x district` field).
+ */
+import { z } from "zod";
+import type { AccessPolicy } from "../registration.js";
+import type { AtomTier } from "../conformance/common.js";
+import { type WidthedConfidence } from "../read-contract/common.js";
+import { type ReasoningReadContract } from "../read-contract/reasoning-axes.js";
+/** Central-TX parcel node id: `{county_fips}:{prop_id}`. */
+export declare const PARCEL_NODE_ID_PATTERN: RegExp;
+export declare const PROPERTY_ATOM_TIER: AtomTier;
+export declare const PROPERTY_DEFAULT_ACCESS_POLICY: AccessPolicy;
+export declare const PROPERTY_ACCESS_POLICY_SCHEMA: z.ZodEnum<["public-free", "public-paid", "platform-internal", "tenant-private", "tenant-shared"]>;
+/** Quality gate fields required on every property reasoning atom. */
+export declare const PROPERTY_QUALITY_GATE_FIELDS: {
+    readonly sourceCitation: z.ZodString;
+    readonly extractedAt: z.ZodString;
+    readonly asOf: z.ZodOptional<z.ZodString>;
+};
+/** Honest absence when no zoning polygon stamps the parcel. */
+export declare const ZONING_ABSENCE_KIND: "no-zoning-stamp";
+export declare const ZONING_ABSENCE_SCHEMA: z.ZodObject<{
+    kind: z.ZodLiteral<"no-zoning-stamp">;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "no-zoning-stamp";
+    reason: string;
+}, {
+    kind: "no-zoning-stamp";
+    reason: string;
+}>;
+export type ZoningAbsence = z.infer<typeof ZONING_ABSENCE_SCHEMA>;
+/** Honest absence when setback match falls back to a conservative default. */
+export declare const SETBACK_ABSENCE_KIND: "setback-fallback";
+export declare const SETBACK_ABSENCE_SCHEMA: z.ZodObject<{
+    kind: z.ZodLiteral<"setback-fallback">;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "setback-fallback";
+    reason: string;
+}, {
+    kind: "setback-fallback";
+    reason: string;
+}>;
+export type SetbackAbsence = z.infer<typeof SETBACK_ABSENCE_SCHEMA>;
+export type SetbackMatchBasis = "exact" | "prefix" | "fallback";
+export declare const SETBACK_MATCH_BASIS_VALUES: ReadonlyArray<SetbackMatchBasis>;
+export declare const SETBACK_MATCH_BASIS_SCHEMA: z.ZodEnum<["exact", "prefix", "fallback"]>;
+/**
+ * Per-field provenance consumed from setback JSON (fan gift — do not invent
+ * tiers). Keys are scalar field names (`front`, `side`, `rear`).
+ */
+export interface SetbackFieldProvenanceEntry {
+    atomDid: string;
+    confidence: WidthedConfidence;
+}
+export declare const SETBACK_FIELD_PROVENANCE_ENTRY_SCHEMA: z.ZodObject<{
+    atomDid: z.ZodString;
+    confidence: 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";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    confidence: Readonly<{
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }>;
+    atomDid: string;
+}, {
+    confidence: Readonly<{
+        estimate: number;
+        n: number;
+        intervalWidth: number;
+        provenance: "asserted" | "backtest" | "seed" | "live";
+    }>;
+    atomDid: string;
+}>;
+export declare const SETBACK_FIELD_PROVENANCE_SCHEMA: z.ZodObject<{
+    front: z.ZodOptional<z.ZodObject<{
+        atomDid: z.ZodString;
+        confidence: 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";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    }, {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    }>>;
+    side: z.ZodOptional<z.ZodObject<{
+        atomDid: z.ZodString;
+        confidence: 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";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    }, {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    }>>;
+    rear: z.ZodOptional<z.ZodObject<{
+        atomDid: z.ZodString;
+        confidence: 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";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    }, {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    front?: {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    } | undefined;
+    side?: {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    } | undefined;
+    rear?: {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    } | undefined;
+}, {
+    front?: {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    } | undefined;
+    side?: {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    } | undefined;
+    rear?: {
+        confidence: Readonly<{
+            estimate: number;
+            n: number;
+            intervalWidth: number;
+            provenance: "asserted" | "backtest" | "seed" | "live";
+        }>;
+        atomDid: string;
+    } | undefined;
+}>;
+export type SetbackFieldProvenance = z.infer<typeof SETBACK_FIELD_PROVENANCE_SCHEMA>;
+/** Optional read-contract snapshot on write; calibrated axis resolves at READ. */
+export declare const PROPERTY_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<[import("../read-contract/reasoning-axes.js").PropertyRiskStratum, ...import("../read-contract/reasoning-axes.js").PropertyRiskStratum[]]>;
+            basis: z.ZodString;
+            assertedAt: z.ZodString;
+            auditRef: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+            assertedAt: string;
+            kind: "property-risk";
+            basis: string;
+            auditRef?: string | undefined;
+        }, {
+            stratum: import("../read-contract/reasoning-axes.js").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: import("../read-contract/reasoning-axes.js").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: import("../read-contract/reasoning-axes.js").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: import("../read-contract/reasoning-axes.js").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: import("../read-contract/reasoning-axes.js").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 type PropertyReadContract = ReasoningReadContract;
+//# sourceMappingURL=common.d.ts.map

package/dist/property/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/property/common.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,oCAAoC,CAAC;AAE5C,4DAA4D;AAC5D,eAAO,MAAM,sBAAsB,QAA4B,CAAC;AAEhE,eAAO,MAAM,kBAAkB,EAAE,QAAiB,CAAC;AAEnD,eAAO,MAAM,8BAA8B,EAAE,YAA4B,CAAC;AAE1E,eAAO,MAAM,6BAA6B,mGAAuB,CAAC;AAElE,qEAAqE;AACrE,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAC;AAEX,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,EAAG,iBAA0B,CAAC;AAE9D,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAElE,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,EAAG,kBAA2B,CAAC;AAEhE,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEpE,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEhE,eAAO,MAAM,0BAA0B,EAAE,aAAa,CAAC,iBAAiB,CAIvE,CAAC;AAEF,eAAO,MAAM,0BAA0B,4CAIrC,CAAC;AAEH;;;GAGG;AACH,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhD,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAErF,kFAAkF;AAClF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiC,CAAC;AAE5E,MAAM,MAAM,oBAAoB,GAAG,qBAAqB,CAAC"}

package/dist/property/common.js

@@ -0,0 +1,66 @@
+/**
+ * Shared property reasoning atom substrate (master WDLL 3.2–3.6).
+ *
+ * Property fact / rule / derived kinds reuse 1.8.0 primitives:
+ * {@link ReasoningChain}, {@link AtomInputRef}, {@link PropertyConsequence},
+ * {@link ReasoningReadContract}, {@link ActorRecordAtomInstance},
+ * {@link ObligationAtomInstance}.
+ *
+ * **Calibrated confidence at READ (I-E):** instances MAY carry a
+ * {@link ReasoningThreeAxisConfidence}-shaped asserted snapshot at write
+ * time (including a placeholder `calibratedConfidence` with
+ * `provenance: "asserted"`). At READ, the calibrated axis resolves through
+ * the calibration overlay — it is NOT composed-and-frozen on the instance.
+ * Do not invent a frozen multiply (e.g. no `labeling x district` field).
+ */
+import { z } from "zod";
+import { ACCESS_POLICY_SCHEMA } from "../conformance/common.js";
+import { WIDTHED_CONFIDENCE_SCHEMA, } from "../read-contract/common.js";
+import { REASONING_READ_CONTRACT_SCHEMA, } from "../read-contract/reasoning-axes.js";
+/** Central-TX parcel node id: `{county_fips}:{prop_id}`. */
+export const PARCEL_NODE_ID_PATTERN = /^\d{5}:[A-Za-z0-9._-]+$/;
+export const PROPERTY_ATOM_TIER = "data";
+export const PROPERTY_DEFAULT_ACCESS_POLICY = "public-free";
+export const PROPERTY_ACCESS_POLICY_SCHEMA = ACCESS_POLICY_SCHEMA;
+/** Quality gate fields required on every property reasoning atom. */
+export const PROPERTY_QUALITY_GATE_FIELDS = {
+    sourceCitation: z.string().min(1),
+    extractedAt: z.string().min(1),
+    asOf: z.string().min(1).optional(),
+};
+/** Honest absence when no zoning polygon stamps the parcel. */
+export const ZONING_ABSENCE_KIND = "no-zoning-stamp";
+export const ZONING_ABSENCE_SCHEMA = z.object({
+    kind: z.literal(ZONING_ABSENCE_KIND),
+    reason: z.string().min(1),
+});
+/** Honest absence when setback match falls back to a conservative default. */
+export const SETBACK_ABSENCE_KIND = "setback-fallback";
+export const SETBACK_ABSENCE_SCHEMA = z.object({
+    kind: z.literal(SETBACK_ABSENCE_KIND),
+    reason: z.string().min(1),
+});
+export const SETBACK_MATCH_BASIS_VALUES = [
+    "exact",
+    "prefix",
+    "fallback",
+];
+export const SETBACK_MATCH_BASIS_SCHEMA = z.enum([
+    "exact",
+    "prefix",
+    "fallback",
+]);
+export const SETBACK_FIELD_PROVENANCE_ENTRY_SCHEMA = z.object({
+    atomDid: z.string().min(1),
+    confidence: WIDTHED_CONFIDENCE_SCHEMA,
+});
+export const SETBACK_FIELD_PROVENANCE_SCHEMA = z
+    .object({
+    front: SETBACK_FIELD_PROVENANCE_ENTRY_SCHEMA.optional(),
+    side: SETBACK_FIELD_PROVENANCE_ENTRY_SCHEMA.optional(),
+    rear: SETBACK_FIELD_PROVENANCE_ENTRY_SCHEMA.optional(),
+})
+    .strict();
+/** Optional read-contract snapshot on write; calibrated axis resolves at READ. */
+export const PROPERTY_READ_CONTRACT_SCHEMA = REASONING_READ_CONTRACT_SCHEMA;
+//# sourceMappingURL=common.js.map

package/dist/property/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/property/common.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EACL,yBAAyB,GAE1B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,8BAA8B,GAE/B,MAAM,oCAAoC,CAAC;AAE5C,4DAA4D;AAC5D,MAAM,CAAC,MAAM,sBAAsB,GAAG,yBAAyB,CAAC;AAEhE,MAAM,CAAC,MAAM,kBAAkB,GAAa,MAAM,CAAC;AAEnD,MAAM,CAAC,MAAM,8BAA8B,GAAiB,aAAa,CAAC;AAE1E,MAAM,CAAC,MAAM,6BAA6B,GAAG,oBAAoB,CAAC;AAElE,qEAAqE;AACrE,MAAM,CAAC,MAAM,4BAA4B,GAAG;IAC1C,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACjC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC1B,CAAC;AAEX,+DAA+D;AAC/D,MAAM,CAAC,MAAM,mBAAmB,GAAG,iBAA0B,CAAC;AAE9D,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC;IACpC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC1B,CAAC,CAAC;AAIH,8EAA8E;AAC9E,MAAM,CAAC,MAAM,oBAAoB,GAAG,kBAA2B,CAAC;AAEhE,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC;IACrC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC1B,CAAC,CAAC;AAMH,MAAM,CAAC,MAAM,0BAA0B,GAAqC;IAC1E,OAAO;IACP,QAAQ;IACR,UAAU;CACX,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,IAAI,CAAC;IAC/C,OAAO;IACP,QAAQ;IACR,UAAU;CACX,CAAC,CAAC;AAWH,MAAM,CAAC,MAAM,qCAAqC,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5D,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,UAAU,EAAE,yBAAyB;CACtC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC;KAC7C,MAAM,CAAC;IACN,KAAK,EAAE,qCAAqC,CAAC,QAAQ,EAAE;IACvD,IAAI,EAAE,qCAAqC,CAAC,QAAQ,EAAE;IACtD,IAAI,EAAE,qCAAqC,CAAC,QAAQ,EAAE;CACvD,CAAC;KACD,MAAM,EAAE,CAAC;AAIZ,kFAAkF;AAClF,MAAM,CAAC,MAAM,6BAA6B,GAAG,8BAA8B,CAAC"}

package/dist/property/fixtures.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Property reasoning atom fixtures — master WDLL 3.2–3.6 Central-TX probes.
+ *
+ * Parcel ids are real Central-TX node anchors for grading notes.
+ */
+import type { BuildableEnvelopeAtomInstance } from "./buildable-envelope.js";
+import type { SetbackRuleAtomInstance } from "./setback-rule.js";
+import type { ZoningFactAtomInstance } from "./zoning-fact.js";
+/**
+ * Hays County (48209) — parcel 48209:156346, RS district from city GIS stamp.
+ * WDLL 3.3 zoning FACT probe.
+ */
+export declare const HAYS_ZONING_FACT_FIXTURE: ZoningFactAtomInstance;
+/**
+ * Bexar County (48029) — parcel 48029:410119, null zoning honest-absence.
+ * WDLL 3.3 negative probe — NOT a stamped I-2 invent.
+ */
+export declare const BEXAR_NULL_ZONING_FACT_FIXTURE: ZoningFactAtomInstance;
+/** Comal County (48091) — exact-match setback with typed code atom ref. WDLL 3.4/3.5. */
+export declare const COMAL_SETBACK_RULE_FIXTURE: SetbackRuleAtomInstance;
+/** Travis County prefix-match fixture — WDLL 3.4 prefix grading. */
+export declare const TRAVIS_PREFIX_SETBACK_RULE_FIXTURE: SetbackRuleAtomInstance;
+/** Fallback match with honest-absence — Kyle R1-T / Bexar I-2 fallback grading. */
+export declare const FALLBACK_SETBACK_RULE_FIXTURE: SetbackRuleAtomInstance;
+/**
+ * Derived envelope for 48209:156346 — WDLL 3.6.
+ * Inputs: zoning-fact + setback-rule + geometry + front-edge reference fields.
+ */
+export declare const HAYS_BUILDABLE_ENVELOPE_FIXTURE: BuildableEnvelopeAtomInstance;
+/** Negative — bare string citation instead of AtomInputRef (WDLL 3.5 fail). */
+export declare const NEGATIVE_SETBACK_BARE_STRING_CITATION: {
+    entityType: "setback-rule";
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    front: number;
+    side: number;
+    rear: number;
+    sourceCodeAtomRef: string;
+    matchBasis: "exact";
+    accessPolicy: "public-free";
+    sourceCitation: string;
+    extractedAt: string;
+    atomTier: "data";
+};
+/** Negative — derived without inputAtomRefs. */
+export declare const NEGATIVE_ENVELOPE_NO_INPUT_REFS: {
+    entityType: "buildable-envelope";
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "derived";
+        derivationMethod: "buildable-envelope-inset-v1";
+        inputAtomRefs: [];
+    };
+    accessPolicy: "public-free";
+    sourceCitation: string;
+    extractedAt: string;
+    atomTier: "data";
+};
+/** Negative — zoning with both district and absence. */
+export declare const NEGATIVE_ZONING_DISTRICT_AND_ABSENCE: {
+    entityType: "zoning-fact";
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    district: string;
+    absence: {
+        kind: "no-zoning-stamp";
+        reason: string;
+    };
+    accessPolicy: "public-free";
+    sourceCitation: string;
+    extractedAt: string;
+    atomTier: "data";
+};
+/** Negative — fallback matchBasis without honest-absence. */
+export declare const NEGATIVE_SETBACK_FALLBACK_NO_ABSENCE: {
+    entityType: "setback-rule";
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    front: number;
+    side: number;
+    rear: number;
+    sourceCodeAtomRef: {
+        atomDid: string;
+        role: "rule";
+    };
+    matchBasis: "fallback";
+    accessPolicy: "public-free";
+    sourceCitation: string;
+    extractedAt: string;
+    atomTier: "data";
+};
+//# sourceMappingURL=fixtures.d.ts.map