@empressaio/atom-contract 1.7.0 → 1.9.0

package/dist/reasoning/fixtures.js

@@ -0,0 +1,127 @@
+/**
+ * Reasoning-chain conformance fixtures per Gate B §2.3 and §5.7.
+ *
+ * Property entityTypes (zoning-fact, setback-rule, buildable-envelope) are
+ * Phase 1b bindings — named in comments, not registered as full kinds in 1.8.0.
+ */
+import { createReasoningReadContract, createReasoningThreeAxisConfidence, } from "../read-contract/reasoning-axes.js";
+import { createWidthedConfidence } from "../read-contract/common.js";
+import { createOgAssertedConfidence } from "../og/common.js";
+import { ICC_ACTOR_RECORD_FIXTURE } from "../actor-record.js";
+const SAMPLE_ASSERTED = createWidthedConfidence({
+    estimate: 0.85,
+    n: 0,
+    intervalWidth: 0.3,
+    provenance: "asserted",
+});
+const SAMPLE_CALIBRATED = createWidthedConfidence({
+    estimate: 0.78,
+    n: 12,
+    intervalWidth: 0.15,
+    provenance: "backtest",
+});
+/** Observed fact stub — public-free with provenance fields present. */
+export const OBSERVED_FACT_REASONING_STUB = {
+    entityTypeHint: "zoning-fact", // Phase 1b binding
+    reasoningChain: { reasoningKind: "observed" },
+    sourceCitation: "Bastrop County Appraisal District parcel record 2024",
+    extractedAt: "2026-07-23T12:00:00.000Z",
+    accessPolicy: "public-free",
+};
+/** Derived envelope stub — not-applicable consequence, no stuffed ASCE7. */
+export const DERIVED_ENVELOPE_REASONING_STUB = {
+    entityTypeHint: "buildable-envelope", // Phase 1b binding
+    reasoningChain: {
+        reasoningKind: "derived",
+        derivationMethod: "buildable-envelope-inset-v1",
+        inputAtomRefs: [
+            {
+                atomDid: "did:hauska:atom:zoning-fact:bastrop-r1-demo",
+                role: "fact",
+                entityType: "zoning-fact",
+                citationLabel: "R-1 zoning district",
+            },
+            {
+                atomDid: "did:hauska:atom:setback-rule:bastrop-front-side-demo",
+                role: "rule",
+                entityType: "setback-rule",
+                citationLabel: "Front and side setback requirements",
+            },
+            {
+                atomDid: "ref:geometry:parcel-footprint-demo",
+                role: "reference-field",
+                citationLabel: "Parcel footprint geometry",
+            },
+            {
+                atomDid: "ref:geometry:front-edge-demo",
+                role: "reference-field",
+                citationLabel: "Front lot line edge",
+            },
+        ],
+    },
+    sourceCitation: "Derived from zoning fact + setback rule + parcel geometry",
+    extractedAt: "2026-07-23T12:00:00.000Z",
+    accessPolicy: "public-free",
+    readContract: createReasoningReadContract({
+        axes: createReasoningThreeAxisConfidence({
+            calibratedConfidence: SAMPLE_CALIBRATED,
+            assertedConfidence: SAMPLE_ASSERTED,
+            consequence: {
+                kind: "not-applicable",
+                reason: "envelope-geometry-derivation-has-no-life-safety-stratum",
+                assertedAt: "2026-07-23T12:00:00.000Z",
+            },
+        }),
+        assembledAt: "2026-07-23T12:00:00.000Z",
+    }),
+};
+/** Negative fixture inputs — validated in tests, not valid instances. */
+export const NEGATIVE_DERIVED_NO_INPUT_REFS = {
+    reasoningKind: "derived",
+    derivationMethod: "buildable-envelope-inset-v1",
+    inputAtomRefs: [],
+};
+export const NEGATIVE_DERIVED_EMPTY_ATOM_DID = {
+    reasoningKind: "derived",
+    derivationMethod: "buildable-envelope-inset-v1",
+    inputAtomRefs: [{ atomDid: "", role: "fact" }],
+};
+/** Re-export ICC actor for obligation edge demonstrations. */
+export { ICC_ACTOR_RECORD_FIXTURE };
+/**
+ * ICC inbound reference royalty — reuses shipped ObligationAtomInstance shape.
+ * amount omitted with graceTerms pending-rate when commercial rates unset (I-K).
+ */
+export const ICC_LICENSE_REFERENCE_OBLIGATION_FIXTURE = {
+    entityType: "obligation",
+    obligationDid: "oblg_a1b2c3d4e5f67890",
+    obligationType: "license-reference-royalty",
+    anchorDid: "did:hauska:atom:code-section:ibc-2024-1003-demo",
+    anchorKind: "code-section",
+    owedToActorDid: ICC_ACTOR_RECORD_FIXTURE.actorId,
+    dueDate: "2026-07-23T12:00:00.000Z",
+    recurrence: "per-reference",
+    graceTerms: "pending-rate",
+    status: "upcoming",
+    confidence: createOgAssertedConfidence(0.9),
+    sourceCitation: "ICC IBC 2024 Section 1003.1",
+    extractedAt: "2026-07-23T12:00:00.000Z",
+    accessPolicy: "platform-internal",
+};
+/** Negative obligation fixture — license type without owedToActorDid. */
+export const NEGATIVE_ICC_OBLIGATION_MISSING_ACTOR = {
+    entityType: "obligation",
+    obligationDid: "oblg_b2c3d4e5f6789012",
+    obligationType: "license-reference-royalty",
+    anchorDid: "did:hauska:atom:code-section:ibc-2024-1003-demo",
+    anchorKind: "code-section",
+    dueDate: "2026-07-23T12:00:00.000Z",
+    recurrence: "per-reference",
+    graceTerms: "pending-rate",
+    status: "upcoming",
+    confidence: createOgAssertedConfidence(0.9),
+    sourceCitation: "ICC IBC 2024 Section 1003.1",
+    extractedAt: "2026-07-23T12:00:00.000Z",
+    accessPolicy: "platform-internal",
+};
+//# sourceMappingURL=fixtures.js.map

package/dist/reasoning/fixtures.js.map

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

package/dist/reasoning/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reasoning-chain primitive and fixtures (Gate B §2.5.1).
+ *
+ * Import from `@empressaio/atom-contract/reasoning`. The main barrel also
+ * exports these symbols; this subpath mirrors `./og` convenience.
+ */
+export * from "../reasoning-chain.js";
+export * from "./fixtures.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reasoning/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC"}

package/dist/reasoning/index.js

@@ -0,0 +1,9 @@
+/**
+ * Reasoning-chain primitive and fixtures (Gate B §2.5.1).
+ *
+ * Import from `@empressaio/atom-contract/reasoning`. The main barrel also
+ * exports these symbols; this subpath mirrors `./og` convenience.
+ */
+export * from "../reasoning-chain.js";
+export * from "./fixtures.js";
+//# sourceMappingURL=index.js.map

package/dist/reasoning/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/reasoning/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC"}

package/dist/reasoning-chain.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Core reasoning-chain primitive per Gate B §2.5.1.
+ *
+ * Generalizes the O&G production-timeseries derived idiom into an
+ * entity-type-agnostic shape for property reasoning and future compliance
+ * findings. O&G streams keep `derivesFromStreamDid`; new code uses
+ * `inputAtomRefs` as the contract-level expression of the `derives-from`
+ * semantic edge (see `./og/common.ts` link vocabulary).
+ *
+ * Composed confidence is NOT frozen on the instance — it resolves at read
+ * via calibration overlay (I-E) + asserted axes on
+ * {@link ReasoningReadContract}.
+ */
+import { z } from "zod";
+/** Role of an input atom or reference field in a derivation chain. */
+export type AtomInputRefRole = "fact" | "rule" | "derived" | "reference-field";
+export declare const ATOM_INPUT_REF_ROLES: ReadonlyArray<AtomInputRefRole>;
+/**
+ * Stable typed pointer to an input atom in a reasoning chain.
+ * Bare strings without resolvable identity fail conformance for
+ * fact / rule / derived roles; reference-field cites external geometry.
+ */
+export interface AtomInputRef {
+    /** DID or atomDid string of the input atom. */
+    atomDid: string;
+    /**
+     * Role of this input in the derivation.
+     * - fact / rule / derived = atom inputs
+     * - reference-field = continuous cited input (geometry, topo, road) not atomized
+     */
+    role: AtomInputRefRole;
+    /** Optional entityType hint for validators / UI (e.g. "zoning-fact", "setback-rule"). */
+    entityType?: string;
+    /** Optional human citation label for inspect-card rendering. */
+    citationLabel?: string;
+}
+export declare const ATOM_INPUT_REF_SCHEMA: z.ZodReadonly<z.ZodObject<{
+    atomDid: z.ZodString;
+    role: z.ZodEnum<[AtomInputRefRole, ...AtomInputRefRole[]]>;
+    entityType: z.ZodOptional<z.ZodString>;
+    citationLabel: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    atomDid: string;
+    role: AtomInputRefRole;
+    entityType?: string | undefined;
+    citationLabel?: string | undefined;
+}, {
+    atomDid: string;
+    role: AtomInputRefRole;
+    entityType?: string | undefined;
+    citationLabel?: string | undefined;
+}>>;
+/**
+ * Discriminated reasoning block. Observed atoms omit derivation fields.
+ * Derived atoms MUST carry method + at least one input ref.
+ */
+export type ReasoningChain = {
+    reasoningKind: "observed";
+} | {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: AtomInputRef[];
+};
+export declare const REASONING_CHAIN_OBSERVED_SCHEMA: z.ZodObject<{
+    reasoningKind: z.ZodLiteral<"observed">;
+}, "strip", z.ZodTypeAny, {
+    reasoningKind: "observed";
+}, {
+    reasoningKind: "observed";
+}>;
+export declare const REASONING_CHAIN_DERIVED_SCHEMA: z.ZodObject<{
+    reasoningKind: z.ZodLiteral<"derived">;
+    derivationMethod: z.ZodString;
+    inputAtomRefs: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        atomDid: z.ZodString;
+        role: z.ZodEnum<[AtomInputRefRole, ...AtomInputRefRole[]]>;
+        entityType: z.ZodOptional<z.ZodString>;
+        citationLabel: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }, {
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }>>, "many">;
+}, "strip", z.ZodTypeAny, {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: Readonly<{
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }>[];
+}, {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: Readonly<{
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }>[];
+}>;
+export declare const REASONING_CHAIN_SCHEMA: z.ZodEffects<z.ZodDiscriminatedUnion<"reasoningKind", [z.ZodObject<{
+    reasoningKind: z.ZodLiteral<"observed">;
+}, "strip", z.ZodTypeAny, {
+    reasoningKind: "observed";
+}, {
+    reasoningKind: "observed";
+}>, z.ZodObject<{
+    reasoningKind: z.ZodLiteral<"derived">;
+    derivationMethod: z.ZodString;
+    inputAtomRefs: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        atomDid: z.ZodString;
+        role: z.ZodEnum<[AtomInputRefRole, ...AtomInputRefRole[]]>;
+        entityType: z.ZodOptional<z.ZodString>;
+        citationLabel: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }, {
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }>>, "many">;
+}, "strip", z.ZodTypeAny, {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: Readonly<{
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }>[];
+}, {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: Readonly<{
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }>[];
+}>]>, {
+    reasoningKind: "observed";
+} | {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: Readonly<{
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }>[];
+}, {
+    reasoningKind: "observed";
+} | {
+    reasoningKind: "derived";
+    derivationMethod: string;
+    inputAtomRefs: Readonly<{
+        atomDid: string;
+        role: AtomInputRefRole;
+        entityType?: string | undefined;
+        citationLabel?: string | undefined;
+    }>[];
+}>;
+export declare function createReasoningChain(input: z.input<typeof REASONING_CHAIN_SCHEMA>): ReasoningChain;
+export declare function validateReasoningChain(value: unknown): ReasoningChain;
+//# sourceMappingURL=reasoning-chain.d.ts.map

package/dist/reasoning-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-chain.d.ts","sourceRoot":"","sources":["../src/reasoning-chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,sEAAsE;AACtE,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,iBAAiB,CAAC;AAE/E,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,gBAAgB,CAKhE,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,IAAI,EAAE,gBAAgB,CAAC;IACvB,yFAAyF;IACzF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;GAOrB,CAAC;AAEd;;;GAGG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,aAAa,EAAE,UAAU,CAAA;CAAE,GAC7B;IACE,aAAa,EAAE,SAAS,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,YAAY,EAAE,CAAC;CAC/B,CAAC;AAEN,eAAO,MAAM,+BAA+B;;;;;;EAE1C,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIzC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB/B,CAAC;AAEL,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,GAC5C,cAAc,CAEhB;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAErE"}

package/dist/reasoning-chain.js

@@ -0,0 +1,63 @@
+/**
+ * Core reasoning-chain primitive per Gate B §2.5.1.
+ *
+ * Generalizes the O&G production-timeseries derived idiom into an
+ * entity-type-agnostic shape for property reasoning and future compliance
+ * findings. O&G streams keep `derivesFromStreamDid`; new code uses
+ * `inputAtomRefs` as the contract-level expression of the `derives-from`
+ * semantic edge (see `./og/common.ts` link vocabulary).
+ *
+ * Composed confidence is NOT frozen on the instance — it resolves at read
+ * via calibration overlay (I-E) + asserted axes on
+ * {@link ReasoningReadContract}.
+ */
+import { z } from "zod";
+export const ATOM_INPUT_REF_ROLES = [
+    "fact",
+    "rule",
+    "derived",
+    "reference-field",
+];
+export const ATOM_INPUT_REF_SCHEMA = z
+    .object({
+    atomDid: z.string().min(1),
+    role: z.enum(ATOM_INPUT_REF_ROLES),
+    entityType: z.string().min(1).optional(),
+    citationLabel: z.string().min(1).optional(),
+})
+    .readonly();
+export const REASONING_CHAIN_OBSERVED_SCHEMA = z.object({
+    reasoningKind: z.literal("observed"),
+});
+export const REASONING_CHAIN_DERIVED_SCHEMA = z.object({
+    reasoningKind: z.literal("derived"),
+    derivationMethod: z.string().min(1),
+    inputAtomRefs: z.array(ATOM_INPUT_REF_SCHEMA).min(1),
+});
+export const REASONING_CHAIN_SCHEMA = z
+    .discriminatedUnion("reasoningKind", [
+    REASONING_CHAIN_OBSERVED_SCHEMA,
+    REASONING_CHAIN_DERIVED_SCHEMA,
+])
+    .superRefine((data, ctx) => {
+    if (data.reasoningKind !== "derived") {
+        return;
+    }
+    for (let i = 0; i < data.inputAtomRefs.length; i++) {
+        const ref = data.inputAtomRefs[i];
+        if (!ref.atomDid || ref.atomDid.trim().length === 0) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "Every inputAtomRef must have a non-empty atomDid",
+                path: ["inputAtomRefs", i, "atomDid"],
+            });
+        }
+    }
+});
+export function createReasoningChain(input) {
+    return REASONING_CHAIN_SCHEMA.parse(input);
+}
+export function validateReasoningChain(value) {
+    return REASONING_CHAIN_SCHEMA.parse(value);
+}
+//# sourceMappingURL=reasoning-chain.js.map

package/dist/reasoning-chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-chain.js","sourceRoot":"","sources":["../src/reasoning-chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,MAAM,CAAC,MAAM,oBAAoB,GAAoC;IACnE,MAAM;IACN,MAAM;IACN,SAAS;IACT,iBAAiB;CAClB,CAAC;AAsBF,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC;KACnC,MAAM,CAAC;IACN,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,oBAAiE,CAAC;IAC/E,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACxC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC5C,CAAC;KACD,QAAQ,EAAE,CAAC;AAcd,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC;IACtD,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;CACrC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAAC;IACrD,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IACnC,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACnC,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CACrD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC;KACpC,kBAAkB,CAAC,eAAe,EAAE;IACnC,+BAA+B;IAC/B,8BAA8B;CAC/B,CAAC;KACD,WAAW,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;IACzB,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;QACrC,OAAO;IACT,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnD,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAE,CAAC;QACnC,IAAI,CAAC,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACpD,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;gBAC3B,OAAO,EAAE,kDAAkD;gBAC3D,IAAI,EAAE,CAAC,eAAe,EAAE,CAAC,EAAE,SAAS,CAAC;aACtC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;AACH,CAAC,CAAC,CAAC;AAEL,MAAM,UAAU,oBAAoB,CAClC,KAA6C;IAE7C,OAAO,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAmB,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,KAAc;IACnD,OAAO,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAmB,CAAC;AAC/D,CAAC"}

package/dist/workspace/property-workspace.d.ts

@@ -23,15 +23,15 @@ export declare const PROPERTY_ADDRESS_IDENTITY_SCHEMA: z.ZodObject<{
     postalCode: z.ZodString;
     countryCode: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    line1: string;
     city: string;
+    line1: string;
     stateOrProvince: string;
     postalCode: string;
     countryCode: string;
     line2?: string | undefined;
 }, {
-    line1: string;
     city: string;
+    line1: string;
     stateOrProvince: string;
     postalCode: string;
     countryCode: string;
@@ -52,15 +52,15 @@ export declare const PROPERTY_WORKSPACE_SCHEMA: z.ZodObject<{
         postalCode: z.ZodString;
         countryCode: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        line1: string;
         city: string;
+        line1: string;
         stateOrProvince: string;
         postalCode: string;
         countryCode: string;
         line2?: string | undefined;
     }, {
-        line1: string;
         city: string;
+        line1: string;
         stateOrProvince: string;
         postalCode: string;
         countryCode: string;
@@ -100,8 +100,8 @@ export declare const PROPERTY_WORKSPACE_SCHEMA: z.ZodObject<{
     createdAt: string;
     updatedAt: string;
     address: {
-        line1: string;
         city: string;
+        line1: string;
         stateOrProvince: string;
         postalCode: string;
         countryCode: string;
@@ -125,8 +125,8 @@ export declare const PROPERTY_WORKSPACE_SCHEMA: z.ZodObject<{
     createdAt: string;
     updatedAt: string;
     address: {
-        line1: string;
         city: string;
+        line1: string;
         stateOrProvince: string;
         postalCode: string;
         countryCode: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empressaio/atom-contract",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "The typed-data substrate every Empressa atom satisfies: identity, context interface, composition declaration, and history anchoring. Peer to the Hauska SDK (`@hauska-sdk/*`); consumed directly by every product surface and MCP server.",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,6 +42,14 @@
       "types": "./dist/og/index.d.ts",
       "import": "./dist/og/index.js"
     },
+    "./reasoning": {
+      "types": "./dist/reasoning/index.d.ts",
+      "import": "./dist/reasoning/index.js"
+    },
+    "./property": {
+      "types": "./dist/property/index.d.ts",
+      "import": "./dist/property/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [