@empressaio/atom-contract 1.8.0 → 1.10.0

package/CHANGELOG.md

@@ -2,6 +2,77 @@
 
 All notable changes to `@empressaio/atom-contract` (formerly `@hauska/atom-contract`) are documented here.
 
+## [1.10.0] - 2026-07-23
+
+Additive minor — parcel terrain-export derived atom (IFC + CAD formats).
+Consumers on `^1.9.0` stay green until they import the new kind.
+
+### Added
+
+- **`parcel-terrain-model`** on `./property` — derived {@link ReasoningChain}
+  with `derivationMethod: "parcel-terrain-mesh-ifc-v1"`; DEM/topo as
+  `reference-field` input (`citationLabel: usgs-3dep-dem`); format-keyed
+  `artifacts` map (`glb` | `ifc` | `dxf-3dface` | `dxf-contour` |
+  `landxml-tin`); coverage + asserted {@link WidthedConfidence}; default
+  `accessPolicy: public-paid`. One atom, not four — callers select format.
+- Fixture `BASTROP_TERRAIN_EXPORT_FIXTURE` for parcel `48021:27303` with
+  shared triangulation counts across face formats; LandXML marked
+  honest-deferred.
+- `PROPERTY_CONFORMANCE_TARGET_VERSION = "1.10.0"`.
+
+### Explicitly NOT in 1.10.0
+
+- Spine authoring / MCP metering (engine + gate program phases).
+- LandXML TIN emitter runtime (may ship later; contract allows deferred).
+
+## [1.9.0] - 2026-07-23
+
+Additive minor — property reasoning atom kinds (master WDLL 3.2–3.6).
+Consumers on `^1.8.0` stay green until they import `./property`.
+
+### Added
+
+- **`./property` subpath** — three data-tier atom kinds for the parcel
+  reasoning chain:
+  - **`zoning-fact`** — observed {@link ReasoningChain}; district value OR
+    honest-absence (`absence: { kind: "no-zoning-stamp", reason }`);
+    explicit `accessPolicy` (default `public-free`); `sourceCitation` +
+    `extractedAt`; optional {@link ReasoningReadContract} asserted snapshot
+    at write (calibrated axis resolves at READ via overlay — I-E).
+  - **`setback-rule`** — observed rule scalars (`front`/`side`/`rear`);
+    typed `sourceCodeAtomRef: AtomInputRef` (role `rule`|`fact`, NOT bare
+    string); optional `fieldProvenance` map consuming setback JSON
+    `atom_did` + per-field confidence; `matchBasis: exact|prefix|fallback`
+    with honest-absence required on fallback; ICC royalties via separate
+    {@link ObligationAtomInstance} rows (no SourceAttribution type).
+  - **`buildable-envelope`** — derived {@link ReasoningChain} with
+    `derivationMethod: "buildable-envelope-inset-v1"`; `inputAtomRefs` to
+    zoning-fact + setback-rule + geometry/front-edge reference-fields;
+    {@link PropertyConsequence} `not-applicable` for envelope; no
+    `labeling x district` multiply field.
+- Central-TX conformance fixtures with named parcel ids (`48209:156346`,
+  `48029:410119`, `48091:123456`, etc.).
+- Negative fixtures: bare-string setback citation fails; derived without
+  `inputAtomRefs` fails.
+- `PROPERTY_CONFORMANCE_TARGET_VERSION = "1.9.0"` in `./conformance`.
+
+### Explicitly NOT in 1.9.0
+
+- Standalone `SourceAttribution` module or parallel source-obligation type.
+- Gate inbound-meter runtime wiring (Phase 1d).
+- StoragePort / spine atom write path (Phase 3.1).
+
+### Consumer migration notes
+
+- Pin `@empressaio/atom-contract@^1.9.0` when adopting property atom kinds.
+- Import from `@empressaio/atom-contract/property` (re-exports 1.8.0
+  primitives: ReasoningChain, AtomInputRef, PropertyConsequence,
+  ReasoningReadContract, ActorRecord, ObligationAtomInstance).
+- **Calibrated confidence at READ:** instance snapshots MAY carry placeholder
+  `calibratedConfidence` with `provenance: "asserted"` at write time; at READ
+  the calibrated axis resolves through the calibration overlay (migration 0037),
+  not a frozen multiply.
+
 ## [1.8.0] - 2026-07-23
 
 Additive minor — reasoning-chain primitive, property consequence axes,

package/README.md

@@ -276,6 +276,45 @@ import {
 } from "@empressaio/atom-contract/og";
 ```
 
+## Property reasoning atom kinds (master WDLL 3.2–3.6)
+
+Parcel buildable-answer chain atoms ship on the `./property` subpath
+(v1.9.0): `zoning-fact`, `setback-rule`, `buildable-envelope`. All three
+are data-tier (`atomTier: "data"`) and default to `public-free`
+accessPolicy when undeclared on the registration.
+
+**Calibrated confidence at READ (I-E):** instances MAY carry a
+`ReasoningReadContract` 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 add a `labeling x district`
+multiply field.
+
+```ts
+import {
+  ZONING_FACT_SCHEMA,
+  SETBACK_RULE_SCHEMA,
+  BUILDABLE_ENVELOPE_SCHEMA,
+  HAYS_ZONING_FACT_FIXTURE,
+  BEXAR_NULL_ZONING_FACT_FIXTURE,
+  HAYS_BUILDABLE_ENVELOPE_FIXTURE,
+  type ZoningFactAtomInstance,
+  type SetbackRuleAtomInstance,
+  type BuildableEnvelopeAtomInstance,
+} from "@empressaio/atom-contract/property";
+```
+
+| `entityType` | `reasoningKind` | Key fields |
+|---|---|---|
+| `zoning-fact` | `observed` | `district` OR `absence.no-zoning-stamp` |
+| `setback-rule` | `observed` | `front`/`side`/`rear`, typed `sourceCodeAtomRef`, `matchBasis` |
+| `buildable-envelope` | `derived` | `buildable-envelope-inset-v1`, input refs to fact + rule + geometry |
+
+ICC royalties on code citations accrue via core `ObligationAtomInstance`
+rows — no standalone `SourceAttribution` type.
+
+### Encumbrance render modes
+
 | `entityType` | Purpose | Recommended render modes |
 |---|---|---|
 | `recorded-instrument` | Parent instrument; wet PDF via `sourceDocumentCid` | `card`, `compact`, `expanded` |

package/dist/conformance/common.d.ts

@@ -19,6 +19,11 @@ export type AtomConformanceTargetVersion = typeof ATOM_CONFORMANCE_TARGET_VERSIO
  */
 export declare const REASONING_CONFORMANCE_TARGET_VERSION: "1.8.0";
 export type ReasoningConformanceTargetVersion = typeof REASONING_CONFORMANCE_TARGET_VERSION;
+/**
+ * Pin property atom kind adopters to this semver (master WDLL 3.2–3.6).
+ */
+export declare const PROPERTY_CONFORMANCE_TARGET_VERSION: "1.10.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";
 export declare const ATOM_TIER_VALUES: ReadonlyArray<AtomTier>;

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

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/conformance/common.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,+BAA+B,EAAG,OAAgB,CAAC;AAEhE,MAAM,MAAM,4BAA4B,GACtC,OAAO,+BAA+B,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,oCAAoC,EAAG,OAAgB,CAAC;AAErE,MAAM,MAAM,iCAAiC,GAC3C,OAAO,oCAAoC,CAAC;AAE9C,oFAAoF;AACpF,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEtC,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,QAAQ,CAAmB,CAAC;AAEzE,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,YAAY,CAM5D,CAAC;AAEF,eAAO,MAAM,oBAAoB,mGAM/B,CAAC"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/conformance/common.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,+BAA+B,EAAG,OAAgB,CAAC;AAEhE,MAAM,MAAM,4BAA4B,GACtC,OAAO,+BAA+B,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,oCAAoC,EAAG,OAAgB,CAAC;AAErE,MAAM,MAAM,iCAAiC,GAC3C,OAAO,oCAAoC,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,mCAAmC,EAAG,QAAiB,CAAC;AAErE,MAAM,MAAM,gCAAgC,GAC1C,OAAO,mCAAmC,CAAC;AAE7C,oFAAoF;AACpF,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEtC,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,QAAQ,CAAmB,CAAC;AAEzE,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,YAAY,CAM5D,CAAC;AAEF,eAAO,MAAM,oBAAoB,mGAM/B,CAAC"}

package/dist/conformance/common.js

@@ -16,6 +16,10 @@ export const ATOM_CONFORMANCE_TARGET_VERSION = "1.5.0";
  * Distinct from {@link ATOM_CONFORMANCE_TARGET_VERSION} until a unified bump.
  */
 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.10.0";
 export const ATOM_TIER_VALUES = ["data", "app"];
 export const ACCESS_POLICY_VALUES = [
     "public-free",

package/dist/conformance/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/conformance/common.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;GAGG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,OAAgB,CAAC;AAKhE;;;GAGG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,OAAgB,CAAC;AAQrE,MAAM,CAAC,MAAM,gBAAgB,GAA4B,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAEzE,MAAM,CAAC,MAAM,oBAAoB,GAAgC;IAC/D,aAAa;IACb,aAAa;IACb,mBAAmB;IACnB,gBAAgB;IAChB,eAAe;CAChB,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,IAAI,CAAC;IACzC,aAAa;IACb,aAAa;IACb,mBAAmB;IACnB,gBAAgB;IAChB,eAAe;CAChB,CAAC,CAAC"}
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/conformance/common.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;GAGG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,OAAgB,CAAC;AAKhE;;;GAGG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,OAAgB,CAAC;AAKrE;;GAEG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,QAAiB,CAAC;AAQrE,MAAM,CAAC,MAAM,gBAAgB,GAA4B,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAEzE,MAAM,CAAC,MAAM,oBAAoB,GAAgC;IAC/D,aAAa;IACb,aAAa;IACb,mBAAmB;IACnB,gBAAgB;IAChB,eAAe;CAChB,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,IAAI,CAAC;IACzC,aAAa;IACb,aAAa;IACb,mBAAmB;IACnB,gBAAgB;IAChB,eAAe;CAChB,CAAC,CAAC"}

package/dist/conformance/index.d.ts

@@ -4,7 +4,7 @@
  * Import from `@empressaio/atom-contract/conformance`. Validates read-contract,
  * accessPolicy, and signed-history for data-level atoms.
  */
-export { ATOM_CONFORMANCE_TARGET_VERSION, REASONING_CONFORMANCE_TARGET_VERSION, ACCESS_POLICY_VALUES, ACCESS_POLICY_SCHEMA, ATOM_TIER_VALUES, type AtomConformanceTargetVersion, type ReasoningConformanceTargetVersion, type AtomTier, } from "./common.js";
+export { ATOM_CONFORMANCE_TARGET_VERSION, REASONING_CONFORMANCE_TARGET_VERSION, PROPERTY_CONFORMANCE_TARGET_VERSION, ACCESS_POLICY_VALUES, ACCESS_POLICY_SCHEMA, ATOM_TIER_VALUES, type AtomConformanceTargetVersion, type ReasoningConformanceTargetVersion, type PropertyConformanceTargetVersion, type AtomTier, } from "./common.js";
 export { verifyEventChain, type VerifyChainError, type VerifyChainErrorKind, type VerifyChainResult, } from "./verify-chain.js";
 export { validateAtomConformance, type AtomConformanceError, type AtomConformanceErrorCode, type AtomConformanceTarget, type AtomConformanceValidationResult, type ValidateAtomConformanceInput, } from "./validate.js";
 export { buildValidSignedEventChain, SAMPLE_APP_CONFORMANCE_TARGET, SAMPLE_DATA_CONFORMANCE_EVENTS, SAMPLE_DATA_CONFORMANCE_TARGET, } from "./fixtures.js";

package/dist/conformance/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/conformance/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,+BAA+B,EAC/B,oCAAoC,EACpC,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,4BAA4B,EACjC,KAAK,iCAAiC,EACtC,KAAK,QAAQ,GACd,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/conformance/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,+BAA+B,EAC/B,oCAAoC,EACpC,mCAAmC,EACnC,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,4BAA4B,EACjC,KAAK,iCAAiC,EACtC,KAAK,gCAAgC,EACrC,KAAK,QAAQ,GACd,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,eAAe,CAAC"}

package/dist/conformance/index.js

@@ -4,7 +4,7 @@
  * Import from `@empressaio/atom-contract/conformance`. Validates read-contract,
  * accessPolicy, and signed-history for data-level atoms.
  */
-export { ATOM_CONFORMANCE_TARGET_VERSION, REASONING_CONFORMANCE_TARGET_VERSION, ACCESS_POLICY_VALUES, ACCESS_POLICY_SCHEMA, ATOM_TIER_VALUES, } from "./common.js";
+export { ATOM_CONFORMANCE_TARGET_VERSION, REASONING_CONFORMANCE_TARGET_VERSION, PROPERTY_CONFORMANCE_TARGET_VERSION, ACCESS_POLICY_VALUES, ACCESS_POLICY_SCHEMA, ATOM_TIER_VALUES, } from "./common.js";
 export { verifyEventChain, } from "./verify-chain.js";
 export { validateAtomConformance, } from "./validate.js";
 export { buildValidSignedEventChain, SAMPLE_APP_CONFORMANCE_TARGET, SAMPLE_DATA_CONFORMANCE_EVENTS, SAMPLE_DATA_CONFORMANCE_TARGET, } from "./fixtures.js";

package/dist/conformance/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/conformance/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,+BAA+B,EAC/B,oCAAoC,EACpC,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,GAIjB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,gBAAgB,GAIjB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,uBAAuB,GAMxB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/conformance/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,+BAA+B,EAC/B,oCAAoC,EACpC,mCAAmC,EACnC,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,GAKjB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,gBAAgB,GAIjB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,uBAAuB,GAMxB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,eAAe,CAAC"}

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

@@ -0,0 +1,464 @@
+import { z } from "zod";
+import type { AccessPolicy } from "../registration.js";
+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";
+/** 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.
+ *
+ * No `labeling x district` multiply field. `calibratedConfidence` on
+ * {@link readContract} may be a placeholder asserted snapshot at write;
+ * at READ the calibrated axis resolves via overlay (I-E). Envelope uses
+ * {@link PropertyConsequence} `not-applicable`, not life-safety ASCE7 stuffing.
+ */
+export interface BuildableEnvelopeAtomInstance {
+    entityType: "buildable-envelope";
+    atomDid: string;
+    parcelNodeId: string;
+    reasoningChain: Extract<ReasoningChain, {
+        reasoningKind: "derived";
+    }> & {
+        derivationMethod: typeof BUILDABLE_ENVELOPE_DERIVATION_METHOD;
+        inputAtomRefs: AtomInputRef[];
+    };
+    accessPolicy: AccessPolicy;
+    sourceCitation: string;
+    extractedAt: string;
+    asOf?: string;
+    atomTier: AtomTier;
+    readContract?: ReasoningReadContract;
+}
+export declare const BUILDABLE_ENVELOPE_SCHEMA: z.ZodObject<{
+    atomTier: z.ZodLiteral<AtomTier>;
+    readContract: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        axes: z.ZodReadonly<z.ZodObject<{
+            calibratedConfidence: z.ZodReadonly<z.ZodObject<{
+                readonly estimate: z.ZodNumber;
+                readonly n: z.ZodNumber;
+                readonly intervalWidth: z.ZodNumber;
+                readonly provenance: z.ZodEnum<["asserted", "backtest", "seed", "live"]>;
+            }, "strip", z.ZodTypeAny, {
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }, {
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>>;
+            assertedConfidence: z.ZodReadonly<z.ZodObject<{
+                readonly estimate: z.ZodNumber;
+                readonly n: z.ZodNumber;
+                readonly intervalWidth: z.ZodNumber;
+                readonly provenance: z.ZodEnum<["asserted", "backtest", "seed", "live"]>;
+            }, "strip", z.ZodTypeAny, {
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }, {
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>>;
+            consequence: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"property-risk">;
+                stratum: z.ZodEnum<[import("../read-contract/reasoning-axes.js").PropertyRiskStratum, ...import("../read-contract/reasoning-axes.js").PropertyRiskStratum[]]>;
+                basis: z.ZodString;
+                assertedAt: z.ZodString;
+                auditRef: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            }, {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"not-applicable">;
+                reason: z.ZodString;
+                assertedAt: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            }, {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }, {
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }>>;
+        assembledAt: z.ZodString;
+        modelAttribution: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            modelId: z.ZodString;
+            modelVersion: z.ZodString;
+            promptTemplateVersion: z.ZodString;
+            contextTemplateVersion: z.ZodString;
+            samplingParams: z.ZodReadonly<z.ZodObject<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodUnknown, z.objectOutputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">, z.objectInputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>>;
+            retrievedAtomSetId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectOutputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }, {
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectInputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        axes: Readonly<{
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }>;
+        assembledAt: string;
+        modelAttribution?: Readonly<{
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectOutputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }> | undefined;
+    }, {
+        axes: Readonly<{
+            calibratedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            assertedConfidence: Readonly<{
+                estimate: number;
+                n: number;
+                intervalWidth: number;
+                provenance: "asserted" | "backtest" | "seed" | "live";
+            }>;
+            consequence: {
+                stratum: import("../read-contract/reasoning-axes.js").PropertyRiskStratum;
+                assertedAt: string;
+                kind: "property-risk";
+                basis: string;
+                auditRef?: string | undefined;
+            } | {
+                assertedAt: string;
+                kind: "not-applicable";
+                reason: string;
+            };
+        }>;
+        assembledAt: string;
+        modelAttribution?: Readonly<{
+            modelId: string;
+            modelVersion: string;
+            promptTemplateVersion: string;
+            contextTemplateVersion: string;
+            samplingParams: Readonly<z.objectInputType<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.ZodUnknown, "strip">>;
+            retrievedAtomSetId: string;
+        }> | undefined;
+    }>>>;
+    sourceCitation: z.ZodString;
+    extractedAt: z.ZodString;
+    asOf: z.ZodOptional<z.ZodString>;
+    entityType: z.ZodLiteral<"buildable-envelope">;
+    atomDid: z.ZodEffects<z.ZodString, string, string>;
+    parcelNodeId: z.ZodEffects<z.ZodString, string, string>;
+    reasoningChain: z.ZodEffects<z.ZodObject<{
+        reasoningKind: z.ZodLiteral<"derived">;
+        derivationMethod: z.ZodString;
+        inputAtomRefs: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            atomDid: z.ZodString;
+            role: z.ZodEnum<[import("../reasoning-chain.js").AtomInputRefRole, ...import("../reasoning-chain.js").AtomInputRefRole[]]>;
+            entityType: z.ZodOptional<z.ZodString>;
+            citationLabel: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            atomDid: string;
+            role: import("../reasoning-chain.js").AtomInputRefRole;
+            entityType?: string | undefined;
+            citationLabel?: string | undefined;
+        }, {
+            atomDid: string;
+            role: import("../reasoning-chain.js").AtomInputRefRole;
+            entityType?: string | undefined;
+            citationLabel?: string | undefined;
+        }>>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        reasoningKind: "derived";
+        derivationMethod: string;
+        inputAtomRefs: Readonly<{
+            atomDid: string;
+            role: import("../reasoning-chain.js").AtomInputRefRole;
+            entityType?: string | undefined;
+            citationLabel?: string | undefined;
+        }>[];
+    }, {
+        reasoningKind: "derived";
+        derivationMethod: string;
+        inputAtomRefs: Readonly<{
+            atomDid: string;
+            role: import("../reasoning-chain.js").AtomInputRefRole;
+            entityType?: string | undefined;
+            citationLabel?: string | undefined;
+        }>[];
+    }>, {
+        reasoningKind: "derived";
+        derivationMethod: string;
+        inputAtomRefs: Readonly<{
+            atomDid: string;
+            role: import("../reasoning-chain.js").AtomInputRefRole;
+            entityType?: string | undefined;
+            citationLabel?: string | undefined;
+        }>[];
+    }, {
+        reasoningKind: "derived";
+        derivationMethod: string;
+        inputAtomRefs: Readonly<{
+            atomDid: string;
+            role: import("../reasoning-chain.js").AtomInputRefRole;
+            entityType?: string | undefined;
+            citationLabel?: string | undefined;
+        }>[];
+    }>;
+    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<{
+            atomDid: string;
+            role: import("../reasoning-chain.js").AtomInputRefRole;
+            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;
+}, {
+    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<{
+            atomDid: string;
+            role: import("../reasoning-chain.js").AtomInputRefRole;
+            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.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;
+}>;
+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

@@ -0,0 +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"}