@empressaio/atom-contract 1.12.0 → 1.14.0

package/dist/property/land-use-fact.d.ts

@@ -0,0 +1,602 @@
+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 CadRollSourceTier, type LandUseAbsence, type SiteLayerVerifiedAbsence } from "./common.js";
+/**
+ * Land use FACT atom — CAD `property_use_code` or honest absence.
+ *
+ * Cotality `land_use_code` is dead; writers read `cad_property.property_use_code`
+ * only. Never add a cotality sourceTier — Cotality is extinguished.
+ */
+export interface LandUseFactAtomInstance {
+    entityType: "land-use-fact";
+    atomDid: string;
+    parcelNodeId: string;
+    taxYear: number;
+    reasoningChain: Extract<ReasoningChain, {
+        reasoningKind: "observed";
+    }>;
+    sourceTier: CadRollSourceTier;
+    landUseCode?: string;
+    landUseLabel?: string;
+    absence?: LandUseAbsence;
+    verifiedAbsence?: SiteLayerVerifiedAbsence;
+    accessPolicy: AccessPolicy;
+    sourceCitation: string;
+    extractedAt: string;
+    asOf?: string;
+    sourceVintage?: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    evaluatedAt: string;
+    atomTier: AtomTier;
+    readContract?: ReasoningReadContract;
+}
+export declare const LAND_USE_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;
+    }>>>;
+    sourceVintage: z.ZodOptional<z.ZodString>;
+    verificationStatus: z.ZodEnum<["machine", "human", "unsurveyed"]>;
+    sourceAdapter: z.ZodString;
+    evaluatedAt: z.ZodString;
+    sourceCitation: z.ZodString;
+    extractedAt: z.ZodString;
+    asOf: z.ZodOptional<z.ZodString>;
+    entityType: z.ZodLiteral<"land-use-fact">;
+    atomDid: z.ZodEffects<z.ZodString, string, string>;
+    parcelNodeId: z.ZodEffects<z.ZodString, string, string>;
+    taxYear: z.ZodNumber;
+    reasoningChain: z.ZodObject<{
+        reasoningKind: z.ZodLiteral<"observed">;
+    }, "strip", z.ZodTypeAny, {
+        reasoningKind: "observed";
+    }, {
+        reasoningKind: "observed";
+    }>;
+    sourceTier: z.ZodEnum<["cad-authoritative", "absent"]>;
+    landUseCode: z.ZodOptional<z.ZodString>;
+    landUseLabel: z.ZodOptional<z.ZodString>;
+    absence: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<["no-land-use-code", "no-cad-row", "join-hold"]>;
+        reason: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "no-cad-row" | "join-hold" | "no-land-use-code";
+        reason: string;
+    }, {
+        kind: "no-cad-row" | "join-hold" | "no-land-use-code";
+        reason: string;
+    }>>;
+    verifiedAbsence: z.ZodOptional<z.ZodObject<{
+        evaluated: z.ZodLiteral<true>;
+        provenanceScope: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        evaluated: true;
+        provenanceScope: string[];
+    }, {
+        evaluated: true;
+        provenanceScope: 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: "land-use-fact";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    evaluatedAt: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    sourceTier: "cad-authoritative" | "absent";
+    taxYear: number;
+    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;
+    absence?: {
+        kind: "no-cad-row" | "join-hold" | "no-land-use-code";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+    sourceVintage?: string | undefined;
+    landUseCode?: string | undefined;
+    landUseLabel?: string | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "land-use-fact";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    evaluatedAt: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    sourceTier: "cad-authoritative" | "absent";
+    taxYear: number;
+    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;
+    absence?: {
+        kind: "no-cad-row" | "join-hold" | "no-land-use-code";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+    sourceVintage?: string | undefined;
+    landUseCode?: string | undefined;
+    landUseLabel?: string | undefined;
+}>, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "land-use-fact";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    evaluatedAt: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    sourceTier: "cad-authoritative" | "absent";
+    taxYear: number;
+    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;
+    absence?: {
+        kind: "no-cad-row" | "join-hold" | "no-land-use-code";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+    sourceVintage?: string | undefined;
+    landUseCode?: string | undefined;
+    landUseLabel?: string | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "land-use-fact";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    evaluatedAt: string;
+    verificationStatus: "machine" | "human" | "unsurveyed";
+    sourceAdapter: string;
+    parcelNodeId: string;
+    reasoningChain: {
+        reasoningKind: "observed";
+    };
+    atomTier: AtomTier;
+    sourceTier: "cad-authoritative" | "absent";
+    taxYear: number;
+    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;
+    absence?: {
+        kind: "no-cad-row" | "join-hold" | "no-land-use-code";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+    sourceVintage?: string | undefined;
+    landUseCode?: string | undefined;
+    landUseLabel?: string | undefined;
+}>;
+export declare function createLandUseFact(input: z.input<typeof LAND_USE_FACT_SCHEMA>): LandUseFactAtomInstance;
+//# sourceMappingURL=land-use-fact.d.ts.map

package/dist/property/land-use-fact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"land-use-fact.d.ts","sourceRoot":"","sources":["../../src/property/land-use-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,EAWL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC9B,MAAM,aAAa,CAAC;AAErB;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,eAAe,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,aAAa,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC;IACvE,UAAU,EAAE,iBAAiB,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,SAAS,GAAG,OAAO,GAAG,YAAY,CAAC;IACvD,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkF7B,CAAC;AAEL,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,GAC1C,uBAAuB,CAEzB"}

package/dist/property/land-use-fact.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { REASONING_CHAIN_OBSERVED_SCHEMA } from "../reasoning-chain.js";
+import { CAD_ROLL_SOURCE_TIER_SCHEMA, LAND_USE_ABSENCE_SCHEMA, PARCEL_NODE_ID_PATTERN, PROPERTY_ACCESS_POLICY_SCHEMA, PROPERTY_ATOM_TIER, PROPERTY_DEFAULT_ACCESS_POLICY, PROPERTY_QUALITY_GATE_FIELDS, PROPERTY_READ_CONTRACT_SCHEMA, SITE_LAYER_PROVENANCE_FIELDS, SITE_LAYER_VERIFIED_ABSENCE_SCHEMA, } from "./common.js";
+export const LAND_USE_FACT_SCHEMA = z
+    .object({
+    entityType: z.literal("land-use-fact"),
+    atomDid: z
+        .string()
+        .min(1)
+        .refine((val) => /^lufact_[0-9a-f]{16}$/.test(val), {
+        message: "atomDid must be in format lufact_<16-hex-chars>",
+    }),
+    parcelNodeId: z
+        .string()
+        .min(1)
+        .refine((val) => PARCEL_NODE_ID_PATTERN.test(val), {
+        message: "parcelNodeId must match {county_fips}:{prop_id}",
+    }),
+    taxYear: z.number().int(),
+    reasoningChain: REASONING_CHAIN_OBSERVED_SCHEMA,
+    sourceTier: CAD_ROLL_SOURCE_TIER_SCHEMA,
+    landUseCode: z.string().min(1).optional(),
+    landUseLabel: z.string().min(1).optional(),
+    absence: LAND_USE_ABSENCE_SCHEMA.optional(),
+    verifiedAbsence: SITE_LAYER_VERIFIED_ABSENCE_SCHEMA.optional(),
+    accessPolicy: PROPERTY_ACCESS_POLICY_SCHEMA,
+    ...PROPERTY_QUALITY_GATE_FIELDS,
+    ...SITE_LAYER_PROVENANCE_FIELDS,
+    atomTier: z.literal(PROPERTY_ATOM_TIER),
+    readContract: PROPERTY_READ_CONTRACT_SCHEMA.optional(),
+})
+    .superRefine((data, ctx) => {
+    const hasAbsence = data.absence !== undefined;
+    const isAbsentTier = data.sourceTier === "absent";
+    const hasLandUseCode = data.landUseCode !== undefined;
+    const hasLandUseLabel = data.landUseLabel !== undefined;
+    if (data.accessPolicy !== PROPERTY_DEFAULT_ACCESS_POLICY) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "land-use-fact must use accessPolicy public-free",
+            path: ["accessPolicy"],
+        });
+    }
+    if ((hasLandUseCode || hasLandUseLabel) && hasAbsence) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "land use fields and absence are mutually exclusive",
+            path: ["absence"],
+        });
+    }
+    if (isAbsentTier) {
+        if (!data.verifiedAbsence) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "sourceTier absent requires verifiedAbsence (evaluated + provenanceScope)",
+                path: ["verifiedAbsence"],
+            });
+        }
+        if (hasLandUseCode || hasLandUseLabel) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "sourceTier absent must not carry land use claim fields",
+                path: ["sourceTier"],
+            });
+        }
+    }
+    else if (hasAbsence) {
+        if (hasLandUseCode || hasLandUseLabel) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "absence must not coexist with land use claim fields",
+                path: ["absence"],
+            });
+        }
+    }
+    else if (!hasLandUseCode) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "cad-authoritative tier requires landUseCode when no absence",
+            path: ["landUseCode"],
+        });
+    }
+});
+export function createLandUseFact(input) {
+    return LAND_USE_FACT_SCHEMA.parse(input);
+}
+//# sourceMappingURL=land-use-fact.js.map