@empressaio/atom-contract 1.8.0 → 1.9.0

package/dist/property/buildable-envelope.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { REASONING_CHAIN_DERIVED_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, } from "./common.js";
+/** Canonical derivation method for buildable envelope inset (master 3.6). */
+export const BUILDABLE_ENVELOPE_DERIVATION_METHOD = "buildable-envelope-inset-v1";
+export const BUILDABLE_ENVELOPE_SCHEMA = z
+    .object({
+    entityType: z.literal("buildable-envelope"),
+    atomDid: z
+        .string()
+        .min(1)
+        .refine((val) => /^benvelope_[0-9a-f]{16}$/.test(val), {
+        message: "atomDid must be in format benvelope_<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_DERIVED_SCHEMA.superRefine((chain, ctx) => {
+        if (chain.derivationMethod !== BUILDABLE_ENVELOPE_DERIVATION_METHOD) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `derivationMethod must be ${BUILDABLE_ENVELOPE_DERIVATION_METHOD}`,
+                path: ["derivationMethod"],
+            });
+        }
+        const hasZoningFact = chain.inputAtomRefs.some((r) => r.role === "fact" && r.entityType === "zoning-fact");
+        const hasSetbackRule = chain.inputAtomRefs.some((r) => r.role === "rule" && r.entityType === "setback-rule");
+        const refFieldCount = chain.inputAtomRefs.filter((r) => r.role === "reference-field").length;
+        if (!hasZoningFact) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "buildable-envelope requires a zoning-fact input ref",
+                path: ["inputAtomRefs"],
+            });
+        }
+        if (!hasSetbackRule) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "buildable-envelope requires a setback-rule input ref",
+                path: ["inputAtomRefs"],
+            });
+        }
+        if (refFieldCount < 2) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "buildable-envelope requires geometry + front-edge reference-field inputs",
+                path: ["inputAtomRefs"],
+            });
+        }
+    }),
+    accessPolicy: PROPERTY_ACCESS_POLICY_SCHEMA,
+    ...PROPERTY_QUALITY_GATE_FIELDS,
+    atomTier: z.literal(PROPERTY_ATOM_TIER),
+    readContract: PROPERTY_READ_CONTRACT_SCHEMA.optional(),
+})
+    .strict();
+export function createBuildableEnvelope(input) {
+    return BUILDABLE_ENVELOPE_SCHEMA.parse(input);
+}
+//# sourceMappingURL=buildable-envelope.js.map

package/dist/property/buildable-envelope.js.map

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

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"}