@empressaio/atom-contract 1.7.0 → 1.9.0

package/dist/property/setback-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setback-rule.d.ts","sourceRoot":"","sources":["../../src/property/setback-rule.ts"],"names":[],"mappings":"AAAA,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;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,OAAO,EASL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACvB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,cAAc,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,aAAa,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,iBAAiB,EAAE,YAAY,CAAC;IAChC,uDAAuD;IACvD,eAAe,CAAC,EAAE,sBAAsB,CAAC;IACzC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,qEAAqE;IACrE,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4C5B,CAAC;AAEL,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,GACzC,uBAAuB,CAEzB"}

package/dist/property/setback-rule.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { ATOM_INPUT_REF_SCHEMA } from "../reasoning-chain.js";
+import { REASONING_CHAIN_OBSERVED_SCHEMA } from "../reasoning-chain.js";
+import { PARCEL_NODE_ID_PATTERN, PROPERTY_ACCESS_POLICY_SCHEMA, PROPERTY_ATOM_TIER, PROPERTY_QUALITY_GATE_FIELDS, PROPERTY_READ_CONTRACT_SCHEMA, SETBACK_ABSENCE_SCHEMA, SETBACK_FIELD_PROVENANCE_SCHEMA, SETBACK_MATCH_BASIS_SCHEMA, } from "./common.js";
+export const SETBACK_RULE_SCHEMA = z
+    .object({
+    entityType: z.literal("setback-rule"),
+    atomDid: z
+        .string()
+        .min(1)
+        .refine((val) => /^sbrule_[0-9a-f]{16}$/.test(val), {
+        message: "atomDid must be in format sbrule_<16-hex-chars>",
+    }),
+    parcelNodeId: z
+        .string()
+        .min(1)
+        .refine((val) => PARCEL_NODE_ID_PATTERN.test(val), {
+        message: "parcelNodeId must match {county_fips}:{prop_id}",
+    }),
+    reasoningChain: REASONING_CHAIN_OBSERVED_SCHEMA,
+    front: z.number().nonnegative(),
+    side: z.number().nonnegative(),
+    rear: z.number().nonnegative(),
+    sourceCodeAtomRef: ATOM_INPUT_REF_SCHEMA.superRefine((ref, ctx) => {
+        if (ref.role !== "rule" && ref.role !== "fact") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "sourceCodeAtomRef role must be rule or fact",
+                path: ["role"],
+            });
+        }
+    }),
+    fieldProvenance: SETBACK_FIELD_PROVENANCE_SCHEMA.optional(),
+    matchBasis: SETBACK_MATCH_BASIS_SCHEMA,
+    absence: SETBACK_ABSENCE_SCHEMA.optional(),
+    accessPolicy: PROPERTY_ACCESS_POLICY_SCHEMA,
+    ...PROPERTY_QUALITY_GATE_FIELDS,
+    atomTier: z.literal(PROPERTY_ATOM_TIER),
+    readContract: PROPERTY_READ_CONTRACT_SCHEMA.optional(),
+})
+    .superRefine((data, ctx) => {
+    if (data.matchBasis === "fallback" && !data.absence) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "matchBasis fallback requires honest-absence",
+            path: ["absence"],
+        });
+    }
+});
+export function createSetbackRule(input) {
+    return SETBACK_RULE_SCHEMA.parse(input);
+}
+//# sourceMappingURL=setback-rule.js.map

package/dist/property/setback-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setback-rule.js","sourceRoot":"","sources":["../../src/property/setback-rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAC;AAGxE,OAAO,EACL,sBAAsB,EACtB,6BAA6B,EAC7B,kBAAkB,EAClB,4BAA4B,EAC5B,6BAA6B,EAC7B,sBAAsB,EACtB,+BAA+B,EAC/B,0BAA0B,GAI3B,MAAM,aAAa,CAAC;AAgCrB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC;KACjC,MAAM,CAAC;IACN,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;IACrC,OAAO,EAAE,CAAC;SACP,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QAClD,OAAO,EAAE,iDAAiD;KAC3D,CAAC;IACJ,YAAY,EAAE,CAAC;SACZ,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACjD,OAAO,EAAE,iDAAiD;KAC3D,CAAC;IACJ,cAAc,EAAE,+BAA+B;IAC/C,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE;IAC/B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE;IAC9B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE;IAC9B,iBAAiB,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;QAChE,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC/C,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;gBAC3B,OAAO,EAAE,6CAA6C;gBACtD,IAAI,EAAE,CAAC,MAAM,CAAC;aACf,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;IACF,eAAe,EAAE,+BAA+B,CAAC,QAAQ,EAAE;IAC3D,UAAU,EAAE,0BAA0B;IACtC,OAAO,EAAE,sBAAsB,CAAC,QAAQ,EAAE;IAC1C,YAAY,EAAE,6BAA6B;IAC3C,GAAG,4BAA4B;IAC/B,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACvC,YAAY,EAAE,6BAA6B,CAAC,QAAQ,EAAE;CACvD,CAAC;KACD,WAAW,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;IACzB,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACpD,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;YAC3B,OAAO,EAAE,6CAA6C;YACtD,IAAI,EAAE,CAAC,SAAS,CAAC;SAClB,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC,CAAC;AAEL,MAAM,UAAU,iBAAiB,CAC/B,KAA0C;IAE1C,OAAO,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAA4B,CAAC;AACrE,CAAC"}

package/dist/property/zoning-fact.d.ts

@@ -0,0 +1,538 @@
+import { z } from "zod";
+import type { AccessPolicy } from "../registration.js";
+import type { AtomTier } from "../conformance/common.js";
+import type { ReasoningChain } from "../reasoning-chain.js";
+import type { ReasoningReadContract } from "../read-contract/reasoning-axes.js";
+import { type ZoningAbsence } from "./common.js";
+/**
+ * Zoning FACT atom — observed district value or honest absence.
+ *
+ * `calibratedConfidence` on an optional {@link readContract} snapshot is a
+ * write-time placeholder; at READ the calibrated axis resolves via the
+ * calibration overlay (I-E), not a frozen multiply.
+ */
+export interface ZoningFactAtomInstance {
+    entityType: "zoning-fact";
+    atomDid: string;
+    /** Parcel node anchor, e.g. `48209:156346` (Hays County). */
+    parcelNodeId: string;
+    reasoningChain: Extract<ReasoningChain, {
+        reasoningKind: "observed";
+    }>;
+    /** Present when a zoning polygon stamps the parcel. */
+    district?: string;
+    /** Present when no zoning polygon covers the parcel (honest-absence). */
+    absence?: ZoningAbsence;
+    accessPolicy: AccessPolicy;
+    sourceCitation: string;
+    extractedAt: string;
+    asOf?: string;
+    atomTier: AtomTier;
+    /** Optional asserted snapshot; calibrated axis resolves at READ. */
+    readContract?: ReasoningReadContract;
+}
+export declare const ZONING_FACT_SCHEMA: z.ZodEffects<z.ZodObject<{
+    atomTier: z.ZodLiteral<AtomTier>;
+    readContract: z.ZodOptional<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;
+    }>>>;
+    sourceCitation: z.ZodString;
+    extractedAt: z.ZodString;
+    asOf: z.ZodOptional<z.ZodString>;
+    entityType: z.ZodLiteral<"zoning-fact">;
+    atomDid: z.ZodEffects<z.ZodString, string, string>;
+    parcelNodeId: z.ZodEffects<z.ZodString, string, string>;
+    reasoningChain: z.ZodObject<{
+        reasoningKind: z.ZodLiteral<"observed">;
+    }, "strip", z.ZodTypeAny, {
+        reasoningKind: "observed";
+    }, {
+        reasoningKind: "observed";
+    }>;
+    district: z.ZodOptional<z.ZodString>;
+    absence: z.ZodOptional<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;
+    }>>;
+    accessPolicy: z.ZodEnum<["public-free", "public-paid", "platform-internal", "tenant-private", "tenant-shared"]>;
+}, "strip", z.ZodTypeAny, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "zoning-fact";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    asOf?: string | undefined;
+    readContract?: Readonly<{
+        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;
+    }> | undefined;
+    district?: string | undefined;
+    absence?: {
+        kind: "no-zoning-stamp";
+        reason: string;
+    } | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "zoning-fact";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    asOf?: string | undefined;
+    readContract?: Readonly<{
+        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;
+    }> | undefined;
+    district?: string | undefined;
+    absence?: {
+        kind: "no-zoning-stamp";
+        reason: string;
+    } | undefined;
+}>, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "zoning-fact";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    asOf?: string | undefined;
+    readContract?: Readonly<{
+        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;
+    }> | undefined;
+    district?: string | undefined;
+    absence?: {
+        kind: "no-zoning-stamp";
+        reason: string;
+    } | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "zoning-fact";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    asOf?: string | undefined;
+    readContract?: Readonly<{
+        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;
+    }> | undefined;
+    district?: string | undefined;
+    absence?: {
+        kind: "no-zoning-stamp";
+        reason: string;
+    } | undefined;
+}>;
+export declare function createZoningFact(input: z.input<typeof ZONING_FACT_SCHEMA>): ZoningFactAtomInstance;
+//# sourceMappingURL=zoning-fact.d.ts.map

package/dist/property/zoning-fact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoning-fact.d.ts","sourceRoot":"","sources":["../../src/property/zoning-fact.ts"],"names":[],"mappings":"AAAA,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;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,aAAa,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,aAAa,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC;IACvE,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,oEAAoE;IACpE,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwC3B,CAAC;AAEL,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,GACxC,sBAAsB,CAExB"}

package/dist/property/zoning-fact.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { REASONING_CHAIN_OBSERVED_SCHEMA } from "../reasoning-chain.js";
+import { PARCEL_NODE_ID_PATTERN, PROPERTY_ACCESS_POLICY_SCHEMA, PROPERTY_ATOM_TIER, PROPERTY_QUALITY_GATE_FIELDS, PROPERTY_READ_CONTRACT_SCHEMA, ZONING_ABSENCE_SCHEMA, } from "./common.js";
+export const ZONING_FACT_SCHEMA = z
+    .object({
+    entityType: z.literal("zoning-fact"),
+    atomDid: z
+        .string()
+        .min(1)
+        .refine((val) => /^zfact_[0-9a-f]{16}$/.test(val), {
+        message: "atomDid must be in format zfact_<16-hex-chars>",
+    }),
+    parcelNodeId: z
+        .string()
+        .min(1)
+        .refine((val) => PARCEL_NODE_ID_PATTERN.test(val), {
+        message: "parcelNodeId must match {county_fips}:{prop_id}",
+    }),
+    reasoningChain: REASONING_CHAIN_OBSERVED_SCHEMA,
+    district: z.string().min(1).optional(),
+    absence: ZONING_ABSENCE_SCHEMA.optional(),
+    accessPolicy: PROPERTY_ACCESS_POLICY_SCHEMA,
+    ...PROPERTY_QUALITY_GATE_FIELDS,
+    atomTier: z.literal(PROPERTY_ATOM_TIER),
+    readContract: PROPERTY_READ_CONTRACT_SCHEMA.optional(),
+})
+    .superRefine((data, ctx) => {
+    const hasDistrict = data.district !== undefined && data.district.length > 0;
+    const hasAbsence = data.absence !== undefined;
+    if (hasDistrict && hasAbsence) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "district and absence are mutually exclusive",
+            path: ["district"],
+        });
+    }
+    if (!hasDistrict && !hasAbsence) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "zoning-fact requires district value OR honest-absence",
+            path: ["district"],
+        });
+    }
+});
+export function createZoningFact(input) {
+    return ZONING_FACT_SCHEMA.parse(input);
+}
+//# sourceMappingURL=zoning-fact.js.map

package/dist/property/zoning-fact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoning-fact.js","sourceRoot":"","sources":["../../src/property/zoning-fact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAC;AAGxE,OAAO,EACL,sBAAsB,EACtB,6BAA6B,EAC7B,kBAAkB,EAClB,4BAA4B,EAC5B,6BAA6B,EAC7B,qBAAqB,GAEtB,MAAM,aAAa,CAAC;AA4BrB,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC;KAChC,MAAM,CAAC;IACN,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IACpC,OAAO,EAAE,CAAC;SACP,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACjD,OAAO,EAAE,gDAAgD;KAC1D,CAAC;IACJ,YAAY,EAAE,CAAC;SACZ,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACjD,OAAO,EAAE,iDAAiD;KAC3D,CAAC;IACJ,cAAc,EAAE,+BAA+B;IAC/C,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACtC,OAAO,EAAE,qBAAqB,CAAC,QAAQ,EAAE;IACzC,YAAY,EAAE,6BAA6B;IAC3C,GAAG,4BAA4B;IAC/B,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACvC,YAAY,EAAE,6BAA6B,CAAC,QAAQ,EAAE;CACvD,CAAC;KACD,WAAW,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;IACzB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IAC5E,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC;IAC9C,IAAI,WAAW,IAAI,UAAU,EAAE,CAAC;QAC9B,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;YAC3B,OAAO,EAAE,6CAA6C;YACtD,IAAI,EAAE,CAAC,UAAU,CAAC;SACnB,CAAC,CAAC;IACL,CAAC;IACD,IAAI,CAAC,WAAW,IAAI,CAAC,UAAU,EAAE,CAAC;QAChC,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;YAC3B,OAAO,EAAE,uDAAuD;YAChE,IAAI,EAAE,CAAC,UAAU,CAAC;SACnB,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC,CAAC;AAEL,MAAM,UAAU,gBAAgB,CAC9B,KAAyC;IAEzC,OAAO,kBAAkB,CAAC,KAAK,CAAC,KAAK,CAA2B,CAAC;AACnE,CAAC"}

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

@@ -10,5 +10,6 @@ export * from "./common.js";
 export * from "./consequence.js";
 export * from "./model-attribution.js";
 export * from "./read-contract.js";
+export * from "./reasoning-axes.js";
 export * from "./fixtures.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/read-contract/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/read-contract/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC"}