@empressaio/atom-contract 1.14.0 → 1.16.0

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to `@empressaio/atom-contract` (formerly `@hauska/atom-contract`) are documented here.
 
+## [1.15.0] - 2026-08-09
+
+Additive minor — first-class typed absence for `buildable-envelope`, closing the
+last property-family gap where honest declines lived only as engine-extension
+fields (`warmVerifyDecline` / `warmVerifyDeclineCode`).
+
+### Added
+
+- **`buildable-envelope.absence`** — `{ kind, reason }` where `kind` is one of
+  the fourteen live decline codes lifted from Bastrop store population +
+  `bucketVerifyFailReasons` residual buckets. No invented taxonomy.
+- **`buildable-envelope.verifiedAbsence`** — mandatory whenever `absence` is
+  present (`evaluated: true` + non-empty `provenanceScope`), same fail-closed
+  dialect as site-layer families. Decline envelopes require only a
+  zoning-fact input ref; positive envelopes still require the full
+  zoning-fact + setback-rule + geometry + front-edge chain.
+- `BUILDABLE_ENVELOPE_ABSENCE_KINDS`, `BUILDABLE_ENVELOPE_ABSENCE_SCHEMA`,
+  `toBuildableEnvelopeAbsenceKind` (unknown producer strings collapse to
+  `other-verify-fail`).
+- Fixtures and round-trip tests for every live kind; negative probes for
+  absence-without-verifiedAbsence and verifiedAbsence-without-absence.
+- `PROPERTY_CONFORMANCE_TARGET_VERSION = "1.15.0"`.
+
+### Explicitly NOT in 1.15.0
+
+- Data migration of existing store rows that carry only
+  `warmVerifyDecline*` — readers stay dual-path; rewrite is a separate lane.
+- Changes to envelope geometry / outcome fields (engine extensions unchanged).
+- Any new decline codes beyond the lifted live set.
+
 ## [1.14.0] - 2026-08-08
 
 Additive minor — three county-shape property rails with first-class typed absence:
@@ -80,7 +110,7 @@ shipped, with no producer behind it; this lands the shape so the engine can writ
 - A new relationship layer — `atom_links` already ships.
 - `cad-parcel-roll`, `land-use-fact`, `parcel-owner-facet`, `flood-hazard-fact`,
   `soil-survey-fact` — later rails in the same spec.
-- `buildable-envelope.absence` — still queued.
+- `buildable-envelope.absence` — shipped in 1.15.0.
 
 ## [1.12.0] - 2026-08-05
 

package/dist/conformance/common.d.ts

@@ -22,7 +22,7 @@ export type ReasoningConformanceTargetVersion = typeof REASONING_CONFORMANCE_TAR
 /**
  * Pin property atom kind adopters to this semver (master WDLL 3.2–3.6).
  */
-export declare const PROPERTY_CONFORMANCE_TARGET_VERSION: "1.14.0";
+export declare const PROPERTY_CONFORMANCE_TARGET_VERSION: "1.15.0";
 export type PropertyConformanceTargetVersion = typeof PROPERTY_CONFORMANCE_TARGET_VERSION;
 /** Data-level atoms carry signed history; app-level workflow containers skip it. */
 export type AtomTier = "data" | "app";

package/dist/conformance/common.js

@@ -19,7 +19,7 @@ export const REASONING_CONFORMANCE_TARGET_VERSION = "1.8.0";
 /**
  * Pin property atom kind adopters to this semver (master WDLL 3.2–3.6).
  */
-export const PROPERTY_CONFORMANCE_TARGET_VERSION = "1.14.0";
+export const PROPERTY_CONFORMANCE_TARGET_VERSION = "1.15.0";
 export const ATOM_TIER_VALUES = ["data", "app"];
 export const ACCESS_POLICY_VALUES = [
     "public-free",

package/dist/property/buildable-envelope.d.ts

@@ -4,10 +4,23 @@ import type { AtomTier } from "../conformance/common.js";
 import type { AtomInputRef } from "../reasoning-chain.js";
 import type { ReasoningChain } from "../reasoning-chain.js";
 import type { ReasoningReadContract } from "../read-contract/reasoning-axes.js";
+import { type BuildableEnvelopeAbsence, type SiteLayerVerifiedAbsence } from "./common.js";
 /** Canonical derivation method for buildable envelope inset (master 3.6). */
 export declare const BUILDABLE_ENVELOPE_DERIVATION_METHOD: "buildable-envelope-inset-v1";
 /**
- * Buildable-envelope DERIVED atom — inputs cite fact + rule + reference fields.
+ * Buildable-envelope DERIVED atom — inputs cite fact + rule + reference fields,
+ * OR carry typed absence when the warm/cascade path deliberately declines.
+ *
+ * Typed absence (1.15.0): when the engine refuses to compute an envelope it
+ * emits `absence` (kind = live decline code) plus `verifiedAbsence` with a
+ * non-empty `provenanceScope`. That is the same fail-closed dialect as the
+ * site-layer families (`sourceTier: absent` → `verifiedAbsence`), expressed
+ * for a derived atom that has no source tier.
+ *
+ * Positive envelopes still require zoning-fact + setback-rule + geometry +
+ * front-edge reference inputs. Decline envelopes require only a zoning-fact
+ * fact ref (setbacks and rings may not exist — fabricating them is exactly
+ * the silent-fabrication mode honest absence exists to prevent).
  *
  * No `labeling x district` multiply field. `calibratedConfidence` on
  * {@link readContract} may be a placeholder asserted snapshot at write;
@@ -24,6 +37,13 @@ export interface BuildableEnvelopeAtomInstance {
         derivationMethod: typeof BUILDABLE_ENVELOPE_DERIVATION_METHOD;
         inputAtomRefs: AtomInputRef[];
     };
+    /** Present when warm/cascade evaluation deliberately refused an envelope. */
+    absence?: BuildableEnvelopeAbsence;
+    /**
+     * Required whenever `absence` is present — documents that the decline was
+     * evaluated against named sources (fail-closed; empty scope is a parse error).
+     */
+    verifiedAbsence?: SiteLayerVerifiedAbsence;
     accessPolicy: AccessPolicy;
     sourceCitation: string;
     extractedAt: string;
@@ -31,7 +51,7 @@ export interface BuildableEnvelopeAtomInstance {
     atomTier: AtomTier;
     readContract?: ReasoningReadContract;
 }
-export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodObject<{
+export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodEffects<z.ZodObject<{
     atomTier: z.ZodLiteral<AtomTier>;
     readContract: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
         axes: z.ZodReadonly<z.ZodObject<{
@@ -282,7 +302,7 @@ export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodObject<{
     entityType: z.ZodLiteral<"buildable-envelope">;
     atomDid: z.ZodEffects<z.ZodString, string, string>;
     parcelNodeId: z.ZodEffects<z.ZodString, string, string>;
-    reasoningChain: z.ZodEffects<z.ZodObject<{
+    reasoningChain: z.ZodObject<{
         reasoningKind: z.ZodLiteral<"derived">;
         derivationMethod: z.ZodString;
         inputAtomRefs: z.ZodArray<z.ZodReadonly<z.ZodObject<{
@@ -319,7 +339,36 @@ export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodObject<{
             entityType?: string | undefined;
             citationLabel?: string | undefined;
         }>[];
-    }>, {
+    }>;
+    absence: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<["unzoned-no-district-basis", "no-district-on-record", "no-setback-row", "no-road-adjacency", "front-orientation-unresolved", "superseded-prop-id", "front-orientation", "road-classification-mismatch", "r32-per-edge-inset", "null-inset", "faces-answer", "geometry", "setback-edge-distance", "other-verify-fail"]>;
+        reason: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "unzoned-no-district-basis" | "no-district-on-record" | "no-setback-row" | "no-road-adjacency" | "front-orientation-unresolved" | "superseded-prop-id" | "front-orientation" | "road-classification-mismatch" | "r32-per-edge-inset" | "null-inset" | "faces-answer" | "geometry" | "setback-edge-distance" | "other-verify-fail";
+        reason: string;
+    }, {
+        kind: "unzoned-no-district-basis" | "no-district-on-record" | "no-setback-row" | "no-road-adjacency" | "front-orientation-unresolved" | "superseded-prop-id" | "front-orientation" | "road-classification-mismatch" | "r32-per-edge-inset" | "null-inset" | "faces-answer" | "geometry" | "setback-edge-distance" | "other-verify-fail";
+        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"]>;
+}, "strict", z.ZodTypeAny, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "buildable-envelope";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
         reasoningKind: "derived";
         derivationMethod: string;
         inputAtomRefs: Readonly<{
@@ -328,7 +377,66 @@ export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodObject<{
             entityType?: string | undefined;
             citationLabel?: string | undefined;
         }>[];
-    }, {
+    };
+    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;
+    absence?: {
+        kind: "unzoned-no-district-basis" | "no-district-on-record" | "no-setback-row" | "no-road-adjacency" | "front-orientation-unresolved" | "superseded-prop-id" | "front-orientation" | "road-classification-mismatch" | "r32-per-edge-inset" | "null-inset" | "faces-answer" | "geometry" | "setback-edge-distance" | "other-verify-fail";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+}, {
+    accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
+    entityType: "buildable-envelope";
+    sourceCitation: string;
+    extractedAt: string;
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: {
         reasoningKind: "derived";
         derivationMethod: string;
         inputAtomRefs: Readonly<{
@@ -337,9 +445,59 @@ export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodObject<{
             entityType?: string | undefined;
             citationLabel?: string | undefined;
         }>[];
-    }>;
-    accessPolicy: z.ZodEnum<["public-free", "public-paid", "platform-internal", "tenant-private", "tenant-shared"]>;
-}, "strict", z.ZodTypeAny, {
+    };
+    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;
+    absence?: {
+        kind: "unzoned-no-district-basis" | "no-district-on-record" | "no-setback-row" | "no-road-adjacency" | "front-orientation-unresolved" | "superseded-prop-id" | "front-orientation" | "road-classification-mismatch" | "r32-per-edge-inset" | "null-inset" | "faces-answer" | "geometry" | "setback-edge-distance" | "other-verify-fail";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
+}>, {
     accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
     entityType: "buildable-envelope";
     sourceCitation: string;
@@ -399,6 +557,14 @@ export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodObject<{
             retrievedAtomSetId: string;
         }> | undefined;
     }> | undefined;
+    absence?: {
+        kind: "unzoned-no-district-basis" | "no-district-on-record" | "no-setback-row" | "no-road-adjacency" | "front-orientation-unresolved" | "superseded-prop-id" | "front-orientation" | "road-classification-mismatch" | "r32-per-edge-inset" | "null-inset" | "faces-answer" | "geometry" | "setback-edge-distance" | "other-verify-fail";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
 }, {
     accessPolicy: "public-free" | "public-paid" | "platform-internal" | "tenant-private" | "tenant-shared";
     entityType: "buildable-envelope";
@@ -459,6 +625,14 @@ export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodObject<{
             retrievedAtomSetId: string;
         }> | undefined;
     }> | undefined;
+    absence?: {
+        kind: "unzoned-no-district-basis" | "no-district-on-record" | "no-setback-row" | "no-road-adjacency" | "front-orientation-unresolved" | "superseded-prop-id" | "front-orientation" | "road-classification-mismatch" | "r32-per-edge-inset" | "null-inset" | "faces-answer" | "geometry" | "setback-edge-distance" | "other-verify-fail";
+        reason: string;
+    } | undefined;
+    verifiedAbsence?: {
+        evaluated: true;
+        provenanceScope: string[];
+    } | undefined;
 }>;
 export declare function createBuildableEnvelope(input: z.input<typeof BUILDABLE_ENVELOPE_SCHEMA>): BuildableEnvelopeAtomInstance;
 //# sourceMappingURL=buildable-envelope.d.ts.map

package/dist/property/buildable-envelope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildable-envelope.d.ts","sourceRoot":"","sources":["../../src/property/buildable-envelope.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;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAUhF,6EAA6E;AAC7E,eAAO,MAAM,oCAAoC,EAAG,6BAAsC,CAAC;AAE3F;;;;;;;GAOG;AACH,MAAM,WAAW,6BAA6B;IAC5C,UAAU,EAAE,oBAAoB,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,aAAa,EAAE,SAAS,CAAA;KAAE,CAAC,GAAG;QACtE,gBAAgB,EAAE,OAAO,oCAAoC,CAAC;QAC9D,aAAa,EAAE,YAAY,EAAE,CAAC;KAC/B,CAAC;IACF,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,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4D3B,CAAC;AAEZ,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,GAC/C,6BAA6B,CAE/B"}
+{"version":3,"file":"buildable-envelope.d.ts","sourceRoot":"","sources":["../../src/property/buildable-envelope.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;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,OAAO,EAQL,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC9B,MAAM,aAAa,CAAC;AAErB,6EAA6E;AAC7E,eAAO,MAAM,oCAAoC,EAAG,6BAAsC,CAAC;AAE3F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,6BAA6B;IAC5C,UAAU,EAAE,oBAAoB,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,aAAa,EAAE,SAAS,CAAA;KAAE,CAAC,GAAG;QACtE,gBAAgB,EAAE,OAAO,oCAAoC,CAAC;QAC9D,aAAa,EAAE,YAAY,EAAE,CAAC;KAC/B,CAAC;IACF,6EAA6E;IAC7E,OAAO,CAAC,EAAE,wBAAwB,CAAC;IACnC;;;OAGG;IACH,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,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC;AAED,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FlC,CAAC;AAEL,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,GAC/C,6BAA6B,CAE/B"}

package/dist/property/buildable-envelope.js

@@ -1,6 +1,6 @@
 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";
+import { BUILDABLE_ENVELOPE_ABSENCE_SCHEMA, PARCEL_NODE_ID_PATTERN, PROPERTY_ACCESS_POLICY_SCHEMA, PROPERTY_ATOM_TIER, PROPERTY_QUALITY_GATE_FIELDS, PROPERTY_READ_CONTRACT_SCHEMA, SITE_LAYER_VERIFIED_ABSENCE_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
@@ -18,45 +18,69 @@ export const BUILDABLE_ENVELOPE_SCHEMA = z
         .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");
+    reasoningChain: REASONING_CHAIN_DERIVED_SCHEMA,
+    absence: BUILDABLE_ENVELOPE_ABSENCE_SCHEMA.optional(),
+    verifiedAbsence: SITE_LAYER_VERIFIED_ABSENCE_SCHEMA.optional(),
+    accessPolicy: PROPERTY_ACCESS_POLICY_SCHEMA,
+    ...PROPERTY_QUALITY_GATE_FIELDS,
+    atomTier: z.literal(PROPERTY_ATOM_TIER),
+    readContract: PROPERTY_READ_CONTRACT_SCHEMA.optional(),
+})
+    .strict()
+    .superRefine((data, ctx) => {
+    const chain = data.reasoningChain;
+    if (chain.derivationMethod !== BUILDABLE_ENVELOPE_DERIVATION_METHOD) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `derivationMethod must be ${BUILDABLE_ENVELOPE_DERIVATION_METHOD}`,
+            path: ["reasoningChain", "derivationMethod"],
+        });
+    }
+    const hasAbsence = data.absence !== undefined;
+    const hasVerifiedAbsence = data.verifiedAbsence !== undefined;
+    if (hasAbsence && !hasVerifiedAbsence) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "buildable-envelope absence requires verifiedAbsence (evaluated + provenanceScope)",
+            path: ["verifiedAbsence"],
+        });
+    }
+    if (!hasAbsence && hasVerifiedAbsence) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "verifiedAbsence on buildable-envelope requires per-parcel absence kind",
+            path: ["absence"],
+        });
+    }
+    const hasZoningFact = chain.inputAtomRefs.some((r) => r.role === "fact" && r.entityType === "zoning-fact");
+    if (!hasZoningFact) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "buildable-envelope requires a zoning-fact input ref",
+            path: ["reasoningChain", "inputAtomRefs"],
+        });
+    }
+    // Positive envelopes keep the full derivation chain. Decline envelopes
+    // may lack setback-rule and geometry refs — refusing to invent them.
+    if (!hasAbsence) {
         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"],
+                path: ["reasoningChain", "inputAtomRefs"],
             });
         }
         if (refFieldCount < 2) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
                 message: "buildable-envelope requires geometry + front-edge reference-field inputs",
-                path: ["inputAtomRefs"],
+                path: ["reasoningChain", "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);
 }

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

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

package/dist/property/building-footprint.d.ts

@@ -402,13 +402,6 @@ export declare const BUILDING_FOOTPRINT_SCHEMA: z.ZodEffects<z.ZodObject<{
             retrievedAtomSetId: string;
         }> | undefined;
     }> | undefined;
-    footprintGeometry?: {
-        type: "Polygon";
-        coordinates: [number, number][][];
-    } | {
-        type: "MultiPolygon";
-        coordinates: [number, number][][][];
-    } | undefined;
     absence?: {
         kind: "no-footprint-feature";
         reason: string;
@@ -417,6 +410,13 @@ export declare const BUILDING_FOOTPRINT_SCHEMA: z.ZodEffects<z.ZodObject<{
         evaluated: true;
         provenanceScope: string[];
     } | undefined;
+    footprintGeometry?: {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | {
+        type: "MultiPolygon";
+        coordinates: [number, number][][][];
+    } | undefined;
     structureRole?: "unknown" | "primary" | "accessory" | undefined;
     sourceVintage?: string | undefined;
 }, {
@@ -477,13 +477,6 @@ export declare const BUILDING_FOOTPRINT_SCHEMA: z.ZodEffects<z.ZodObject<{
             retrievedAtomSetId: string;
         }> | undefined;
     }> | undefined;
-    footprintGeometry?: {
-        type: "Polygon";
-        coordinates: [number, number][][];
-    } | {
-        type: "MultiPolygon";
-        coordinates: [number, number][][][];
-    } | undefined;
     absence?: {
         kind: "no-footprint-feature";
         reason: string;
@@ -492,6 +485,13 @@ export declare const BUILDING_FOOTPRINT_SCHEMA: z.ZodEffects<z.ZodObject<{
         evaluated: true;
         provenanceScope: string[];
     } | undefined;
+    footprintGeometry?: {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | {
+        type: "MultiPolygon";
+        coordinates: [number, number][][][];
+    } | undefined;
     structureRole?: "unknown" | "primary" | "accessory" | undefined;
     sourceVintage?: string | undefined;
 }>, {
@@ -552,13 +552,6 @@ export declare const BUILDING_FOOTPRINT_SCHEMA: z.ZodEffects<z.ZodObject<{
             retrievedAtomSetId: string;
         }> | undefined;
     }> | undefined;
-    footprintGeometry?: {
-        type: "Polygon";
-        coordinates: [number, number][][];
-    } | {
-        type: "MultiPolygon";
-        coordinates: [number, number][][][];
-    } | undefined;
     absence?: {
         kind: "no-footprint-feature";
         reason: string;
@@ -567,6 +560,13 @@ export declare const BUILDING_FOOTPRINT_SCHEMA: z.ZodEffects<z.ZodObject<{
         evaluated: true;
         provenanceScope: string[];
     } | undefined;
+    footprintGeometry?: {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | {
+        type: "MultiPolygon";
+        coordinates: [number, number][][][];
+    } | undefined;
     structureRole?: "unknown" | "primary" | "accessory" | undefined;
     sourceVintage?: string | undefined;
 }, {
@@ -627,13 +627,6 @@ export declare const BUILDING_FOOTPRINT_SCHEMA: z.ZodEffects<z.ZodObject<{
             retrievedAtomSetId: string;
         }> | undefined;
     }> | undefined;
-    footprintGeometry?: {
-        type: "Polygon";
-        coordinates: [number, number][][];
-    } | {
-        type: "MultiPolygon";
-        coordinates: [number, number][][][];
-    } | undefined;
     absence?: {
         kind: "no-footprint-feature";
         reason: string;
@@ -642,6 +635,13 @@ export declare const BUILDING_FOOTPRINT_SCHEMA: z.ZodEffects<z.ZodObject<{
         evaluated: true;
         provenanceScope: string[];
     } | undefined;
+    footprintGeometry?: {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | {
+        type: "MultiPolygon";
+        coordinates: [number, number][][][];
+    } | undefined;
     structureRole?: "unknown" | "primary" | "accessory" | undefined;
     sourceVintage?: string | undefined;
 }>;

package/dist/property/common.d.ts

@@ -24,6 +24,13 @@ export declare const PARCEL_NODE_ID_PATTERN: RegExp;
 export declare const ROAD_NODE_ID_PATTERN: RegExp;
 export declare const PROPERTY_ATOM_TIER: AtomTier;
 export declare const PROPERTY_DEFAULT_ACCESS_POLICY: AccessPolicy;
+/**
+ * The paid property tier. Only `owner-fact` uses it today: owner identity was
+ * ruled `public-paid` at the atom level, and its schema pins this value so the
+ * policy cannot be dropped by a writer. Every other property atom pins
+ * `PROPERTY_DEFAULT_ACCESS_POLICY`.
+ */
+export declare const PROPERTY_PAID_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: {
@@ -57,6 +64,41 @@ export declare const SETBACK_ABSENCE_SCHEMA: z.ZodObject<{
     reason: string;
 }>;
 export type SetbackAbsence = z.infer<typeof SETBACK_ABSENCE_SCHEMA>;
+/**
+ * Named decline codes actually written onto `buildable-envelope` atoms.
+ *
+ * Ground truth is Bastrop store population (2026-08-08 grade audit §8.1)
+ * plus the two residual buckets from `bucketVerifyFailReasons` that can be
+ * minted even when a cohort snapshot shows zero rows. Do NOT invent codes
+ * here — expand only when a live producer lands a new string.
+ *
+ * Grouping: each live code is its own kind. Compressing would erase
+ * agent-routing and cert-grade branches (cascade codes grade differently;
+ * edge-label early declines differ from verify-bucket orientation; R32 is
+ * a distinct inset path). The free-text `reason` carries path detail; the
+ * kind is the durable finding identity.
+ */
+export declare const BUILDABLE_ENVELOPE_ABSENCE_KINDS: readonly ["unzoned-no-district-basis", "no-district-on-record", "no-setback-row", "no-road-adjacency", "front-orientation-unresolved", "superseded-prop-id", "front-orientation", "road-classification-mismatch", "r32-per-edge-inset", "null-inset", "faces-answer", "geometry", "setback-edge-distance", "other-verify-fail"];
+export type BuildableEnvelopeAbsenceKind = (typeof BUILDABLE_ENVELOPE_ABSENCE_KINDS)[number];
+export declare const BUILDABLE_ENVELOPE_ABSENCE_SCHEMA: z.ZodObject<{
+    kind: z.ZodEnum<["unzoned-no-district-basis", "no-district-on-record", "no-setback-row", "no-road-adjacency", "front-orientation-unresolved", "superseded-prop-id", "front-orientation", "road-classification-mismatch", "r32-per-edge-inset", "null-inset", "faces-answer", "geometry", "setback-edge-distance", "other-verify-fail"]>;
+    reason: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "unzoned-no-district-basis" | "no-district-on-record" | "no-setback-row" | "no-road-adjacency" | "front-orientation-unresolved" | "superseded-prop-id" | "front-orientation" | "road-classification-mismatch" | "r32-per-edge-inset" | "null-inset" | "faces-answer" | "geometry" | "setback-edge-distance" | "other-verify-fail";
+    reason: string;
+}, {
+    kind: "unzoned-no-district-basis" | "no-district-on-record" | "no-setback-row" | "no-road-adjacency" | "front-orientation-unresolved" | "superseded-prop-id" | "front-orientation" | "road-classification-mismatch" | "r32-per-edge-inset" | "null-inset" | "faces-answer" | "geometry" | "setback-edge-distance" | "other-verify-fail";
+    reason: string;
+}>;
+export type BuildableEnvelopeAbsence = z.infer<typeof BUILDABLE_ENVELOPE_ABSENCE_SCHEMA>;
+/** Residual kind when a producer hands an unknown decline string. */
+export declare const BUILDABLE_ENVELOPE_ABSENCE_FALLBACK_KIND: "other-verify-fail";
+/**
+ * Map a live engine decline-code string onto a contract absence kind.
+ * Unknown codes collapse to {@link BUILDABLE_ENVELOPE_ABSENCE_FALLBACK_KIND}
+ * so writers never invent enum members off-band.
+ */
+export declare function toBuildableEnvelopeAbsenceKind(declineCode: string): BuildableEnvelopeAbsenceKind;
 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"]>;
@@ -803,6 +845,27 @@ export declare const LAND_USE_ABSENCE_SCHEMA: z.ZodObject<{
     reason: string;
 }>;
 export type LandUseAbsence = z.infer<typeof LAND_USE_ABSENCE_SCHEMA>;
+/**
+ * Owner absence kinds. `owner-withheld` is the one that does NOT exist for the
+ * other CAD facets: a CAD may publish a parcel row while suppressing owner
+ * identity (confidentiality elections for judges, peace officers, and victims
+ * of family violence are statutory in Texas). That is a lawful, expected
+ * absence and must be representable as such — never as a missing row and never
+ * as an empty owner name.
+ */
+export declare const OWNER_FACT_ABSENCE_KINDS: readonly ["no-owner-name", "owner-withheld", "no-cad-row", "join-hold"];
+export type OwnerFactAbsenceKind = (typeof OWNER_FACT_ABSENCE_KINDS)[number];
+export declare const OWNER_FACT_ABSENCE_SCHEMA: z.ZodObject<{
+    kind: z.ZodEnum<["no-owner-name", "owner-withheld", "no-cad-row", "join-hold"]>;
+    reason: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "no-cad-row" | "join-hold" | "no-owner-name" | "owner-withheld";
+    reason: string;
+}, {
+    kind: "no-cad-row" | "join-hold" | "no-owner-name" | "owner-withheld";
+    reason: string;
+}>;
+export type OwnerFactAbsence = z.infer<typeof OWNER_FACT_ABSENCE_SCHEMA>;
 /** CAD numeric export may carry acres as a string; accept either form. */
 export declare const LAND_ACRES_SCHEMA: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
 //# sourceMappingURL=common.d.ts.map