@empressaio/atom-contract 1.7.0

package/README.md

@@ -0,0 +1,379 @@
+# `@empressaio/atom-contract`
+
+The typed-data substrate every Empressa atom must satisfy: identity,
+context interface, composition declaration, and history anchoring.
+Peer to the Hauska SDK (`@hauska-sdk/*`); consumed directly by every product surface
+and MCP server.
+
+This package is **framework only**. It ships the contract, the runtime
+that enforces it, the schema the history layer writes into, and the
+test scaffolding consumer packages use to prove their atoms comply.
+Catalog atom registrations (the actual atom types — `engagement`,
+`code-section`, `jurisdiction-corpus`, etc.) live in consumer packages
+that depend on this one.
+
+Empressa commercial substrate, peer to `@hauska-sdk/*` and `hauska-engine`,
+per doc_repo ADR-018 (atom contract substrate layer placement). The
+package has zero `@hauska-sdk/*` dependency: an MCP server or product
+surface can depend on the contract without inheriting the commerce
+stack.
+
+## Install
+
+```bash
+npm install @empressaio/atom-contract
+# or
+pnpm add @empressaio/atom-contract
+```
+
+Requires Node 18.18+ and `drizzle-orm` (^0.30.0) if you intend to use
+`PostgresEventAnchoringService`. Atoms that don't anchor history can
+use `createInMemoryEventService()` from the `./testing` subpath.
+
+## Publishing (operators)
+
+The `hauska-sdk` npm account uses **staged publishing + Windows Hello**
+(passkey 2FA), not granular tokens. See
+[`docs/npm-publish-automation.md`](docs/npm-publish-automation.md).
+
+```powershell
+.\publish-1.4.0.ps1
+.\publish-approve-1.4.0.ps1 -StageId <uuid-from-stage-list>
+```
+
+## Public surface
+
+```ts
+import {
+  createAtomRegistry,
+  defaultScope,
+  resolveMode,
+  parseInlineReferences,
+  serializeInlineReference,
+  httpContextSummary,
+  resolveComposition,
+  PostgresEventAnchoringService,
+  wrapForStorage,
+  unwrapFromStorage,
+  type AccessPolicy,
+  type AtomRegistration,
+  type AtomMode,
+  type AtomReference,
+  type ContextSummary,
+  type Scope,
+  type AtomComposition,
+  type EventAnchoringService,
+} from "@empressaio/atom-contract";
+```
+
+Testing utilities live behind a separate subpath so production bundles
+never pull them in:
+
+```ts
+import {
+  createTestRegistry,
+  createInMemoryEventService,
+  runAtomContractTests,
+} from "@empressaio/atom-contract/testing";
+```
+
+## The four-layer contract
+
+An atom registers with one structurally-typed object:
+
+```ts
+const taskAtom: AtomRegistration<"task", ["card", "compact", "expanded"]> = {
+  // identity
+  entityType: "task",
+  domain: "sprint",
+
+  // render-mode contract (type-level)
+  supportedModes: ["card", "compact", "expanded"],
+  defaultMode: "card",
+
+  // context interface
+  contextSummary: async (entityId, scope) => ({
+    prose: `Task ${entityId}: ...`,
+    typed: { id: entityId },
+    keyMetrics: [{ label: "Status", value: "open" }],
+    relatedAtoms: [],
+    historyProvenance: { latestEventId: "evt-...", latestEventAt: "2026-..." },
+    scopeFiltered: false,
+  }),
+
+  // composition declaration (multi-child; required field)
+  composition: [
+    { childEntityType: "blocker", childMode: "compact", dataKey: "blockers" },
+  ],
+};
+
+const registry = createAtomRegistry();
+registry.register(taskAtom);
+```
+
+Compile-time guarantees:
+
+- `defaultMode` must be a member of `supportedModes`. Mismatched defaults
+  fail to typecheck.
+- `entityType` is a literal string, narrowed all the way through
+  `registry.resolve("task")` so consumers see the exact type back.
+- `domain` is required and queryable through `registry.listByDomain(...)`.
+- `composition` is required. Pass `[]` to declare no children.
+
+Five render modes ship as a literal union: `inline`, `compact`, `card`,
+`expanded`, `focus`. Render bindings (the React `<AtomShell>`, per-mode
+components, focus-store wiring) live in a separate package that
+depends on this one.
+
+## Scope at the call site
+
+`contextSummary` always takes a second `Scope` argument:
+
+```ts
+interface Scope {
+  audience: "ai" | "user" | "internal";
+  requestor?: { kind: "user" | "agent"; id: string };
+  asOf?: Date;
+  permissions?: ReadonlyArray<string>;
+}
+```
+
+Atoms that don't differentiate by scope ignore it and set
+`scopeFiltered: false`. Tests use the `defaultScope()` helper.
+
+## Composition
+
+Composition is a multi-child declarative graph. The registry consumes
+the field: `registry.validate()` walks every registration's composition
+edges and reports any that point at an unregistered child entity type.
+Use `resolveComposition(parent, parentRef, parentData, registry)` to
+turn the declaration into a typed children list ready for render-side
+iteration.
+
+**Boot-time contract:** the application bootstrap MUST call
+`registry.validate()` once after every `register()` call has run and
+fail to start when the result is `{ ok: false }`. The registry does
+not revalidate composition on each `register()` (the parent may
+legitimately register before the child) and `resolve()` does not
+recheck on lookup, so dangling cross-references would otherwise
+surface only at composition-resolution time.
+
+Composition edges may opt out of presence validation by setting
+`forwardRef: true`. Forward-ref edges are skipped by both `validate()`
+and `resolveComposition` while the child remains unregistered, so a
+parent atom can ship a declaration that names a child slated for a
+later sprint without crashing the boot.
+
+## Access policy (visibility tier)
+
+Atoms may declare an ADR-017 access tier. The contract performs no
+enforcement; downstream surfaces (MCP `list_*`, catalog APIs) gate on
+the value.
+
+```ts
+type AccessPolicy =
+  | "public-free"        // unauthenticated public catalog
+  | "public-paid"        // catalog-visible, entitlement-gated at fetch
+  | "platform-internal"  // platform staff only; never enumerated publicly
+  | "tenant-private"     // owning tenant only
+  | "tenant-shared";     // explicit cross-tenant share (ADR-017)
+```
+
+The field appears in two places:
+
+- `AtomRegistration.accessPolicy?` — atom-type default. Useful when the
+  entire type is internal (e.g. an audit atom).
+- `ContextSummary.accessPolicy?` — per-instance value. Lets a
+  mostly-public atom mark individual instances internal — for example,
+  a public `jurisdiction-corpus` catalog where partnership-pending
+  jurisdictions are tagged `"platform-internal"` until partnership
+  closes.
+
+Resolution: per-instance `ContextSummary.accessPolicy` wins when
+present, otherwise fall back to the registration's `accessPolicy`,
+otherwise treat the atom as `"public-free"`. The prompt-builder
+catalog (`registry.describeForPrompt()`) normalizes the registration
+value to `"public-free"` when undeclared so downstream filters branch
+without nullish guards.
+
+## History (`EventAnchoringService`)
+
+Every atom mutation flows through `EventAnchoringService.appendEvent`,
+which writes one row to an `atom_events` table. The shipped
+`PostgresEventAnchoringService` writes a deterministic SHA-256 chain
+hash. `prevHash` links each event to the previous event for the same
+`(entityType, entityId)` pair, producing a per-entity hash chain.
+
+**Interface-stable / implementation-evolving.** The
+`EventAnchoringService` interface is the contract. The deterministic
+SHA-256 implementation will be replaced with a real cryptographic
+anchor (Merkle root + external ledger anchor) at a later milestone
+without changing the consumer interface. Mark sites that should be
+revisited carry `TODO(M2-C):` markers.
+
+The host project owns the `atom_events` schema (table, columns,
+constraints). This library issues raw SQL against the agreed table name
+only and depends on `drizzle-orm`'s `sql` helper for SQL templating.
+
+## VDA wrapping (no-op today)
+
+`wrapForStorage(value)` returns
+`{ envelope: { version: 1, vdaApplied: false }, payload: value }` and
+`unwrapFromStorage(stored)` returns `stored.payload`. Consumers call
+these from their write paths today; the no-op becomes a real envelope
+(version chain + tombstone semantics) at a later milestone without
+consumer changes.
+
+## Inline reference syntax
+
+The chat layer embeds atoms in prose using `{{atom|type|id|label}}`:
+
+```ts
+parseInlineReferences("see {{atom|task|t1|Pick HVAC}}");
+// -> [
+//   { kind: "text", text: "see " },
+//   { kind: "atom", reference: { kind: "atom", entityType: "task", entityId: "t1", displayLabel: "Pick HVAC" }, raw: "{{atom|task|t1|Pick HVAC}}" }
+// ]
+```
+
+The delimiter is `|`. The previous shape used `:` and could not
+represent Spec 51 entityIds that themselves contain `:` (e.g.
+`parcel-briefing:{parcelId}:{intentHash}`). The old shape is no longer
+parsed: there is no dual-parse compatibility path.
+
+## Encumbrance atom types (ADR-020 / ADR-021)
+
+Private recorded land-use instruments ship as Zod-validated payloads on
+the `./encumbrances` subpath (v1.2.0+). Types are **never**
+`public-free`; schemas accept only `tenant-private` and
+`tenant-shared`.
+
+```ts
+import {
+  RECORDED_INSTRUMENT_SCHEMA,
+  RESTRICTION_CLAUSE_SCHEMA,
+  ENCUMBRANCE_RENDER_MODES,
+  SAMPLE_RECORDED_INSTRUMENT,
+} from "@empressaio/atom-contract/encumbrances";
+```
+
+## Oil & Gas atom types (ADR-025)
+
+O&G operational, land, and capital atoms ship as Zod-validated payloads on
+the `./og` subpath (v1.7.0). Covers the asset spine (well, wellbore,
+completion, zone, pad), production timeseries, equipment state, the land
+leg (mineral-lease, rrc-lease, tract, ownership-interest), and revenue
+allocation units. Obligation (core domain-neutral type) ships in the main
+module, not `./og`.
+
+```ts
+import {
+  WELL_SCHEMA,
+  MINERAL_LEASE_SCHEMA,
+  REVENUE_ALLOCATION_UNIT_SCHEMA,
+  SAMPLE_WELL,
+  OG_DEFAULT_ACCESS_POLICY,
+} from "@empressaio/atom-contract/og";
+```
+
+| `entityType` | Purpose | Recommended render modes |
+|---|---|---|
+| `recorded-instrument` | Parent instrument; wet PDF via `sourceDocumentCid` | `card`, `compact`, `expanded` |
+| `restriction-clause` | Enforceable snippet; plan-review citation target | `inline` … `focus` (**default `focus`**) |
+| `restriction-corpus` | Subdivision CC&R pack | `card`, `expanded` |
+| `administrative-rule` | Unrecorded HOA guidelines (`legalWeight: advisory`) | `inline`, `compact`, `card`, `expanded` |
+| `constraint-resolution` | Effective constraint lattice (ADR-021) | `card`, `expanded` |
+
+Engine `AtomRegistration` literals and ingest producers belong in
+`hauska-engine/packages/atoms/` (cc-agent-E); Cortex Phase 1 may
+validate uploads with these schemas before the engine registry lands.
+
+## Read-contract types (Calibrated Spine F4 / F6 / K6)
+
+Widthed, three-axis confidence returned at read time. Unwidthed,
+unsourced confidence is unrepresentable: the estimate is a branded
+nominal type constructible only through `createWidthedConfidence`.
+No derived numbers are stored in this package.
+
+```ts
+import {
+  createReadContract,
+  createWidthedConfidence,
+  READ_CONTRACT_SCHEMA,
+  SAMPLE_READ_CONTRACT,
+  type ReadContract,
+  type CalibrationProvenance,
+} from "@empressaio/atom-contract/read-contract";
+```
+
+| Export | Role |
+|---|---|
+| `WidthedConfidence` | Inseparable estimate + `n` + `intervalWidth` + provenance |
+| `ThreeAxisConfidence` | Accuracy, source-quality, and consequence axes |
+| `ReadContract` | Full read-contract object every surface must emit |
+| `ModelAttributionStamp` | Ledger deposit stamp (model, prompt, atom-set id) |
+| `CalibrationProvenance` | `asserted` \| `backtest` \| `seed` \| `live` |
+
+Propagation to MCP, cortex-api, Cortex, extension, and map is a
+consumer-side Wave 2 co-bump after pinning `^1.4.0`.
+
+## Testing utilities
+
+Consumer packages import the contract test suite to prove their
+registration is well-formed in one function call:
+
+```ts
+import { describe } from "vitest";
+import { runAtomContractTests } from "@empressaio/atom-contract/testing";
+import { taskAtom } from "./task.reg";
+
+describe("task atom contract", () => {
+  runAtomContractTests(taskAtom, {
+    withFixture: { entityId: "t1", setUp: seedTestData },
+    alsoRegister: [/* any composition children */],
+  });
+});
+```
+
+The suite asserts:
+
+1. identity is present and `entityType` is non-empty,
+2. `defaultMode` is in `supportedModes`,
+3. `contextSummary` returns a valid four-layer shape with
+   `historyProvenance` and `scopeFiltered`,
+4. every composition edge resolves against `alsoRegister + this`,
+5. inline-reference round-trips for an instance of this atom.
+
+`createInMemoryEventService()` provides an in-memory
+`EventAnchoringService` for unit tests that don't need Postgres;
+`createTestRegistry(initial)` is a convenience over
+`createAtomRegistry()`.
+
+## What this package does NOT ship
+
+- **Catalog atom registrations.** No `engagement.atom.ts`,
+  `code-section.atom.ts`, etc. Catalog atoms live in consumer packages
+  (`hauska-engine/packages/atoms/`, product api-servers, etc.) that
+  depend on this one. The line: this package owns the registration
+  *mechanism* and the contract; consumers own the per-atom *instances*.
+- **React rendering layer.** Type-level render-mode contract only. The
+  `<AtomRenderer>`, `<AtomShell>`, per-mode components, focus-store
+  wiring, and right-panel state machine all ship in a later sibling
+  package.
+- **Cryptographic anchoring of `atom_events`.** `chainHash` is
+  deterministic SHA-256 today; Merkle root + external anchor land in a
+  later milestone.
+- **Real VDA backing.** `wrapForStorage` / `unwrapFromStorage` are
+  no-ops; the real envelope, version chain, and tombstone semantics
+  land in a later milestone.
+
+## Lineage
+
+This package extracts the workspace-private `@workspace/empressa-atom`
+that lived at `legacy-design-tools/lib/empressa-atom/`. The framework
+is preserved verbatim; only the package name and the `@workspace/db`
+test-time dependency changed.
+
+## License
+
+See LICENSE.

package/dist/composition.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Declarative atom composition.
+ *
+ * An atom may declare zero or more children — each describing a child
+ * entity type, the render mode the child should be drawn in by the parent,
+ * and the key under which the parent's `data` exposes the child rows. The
+ * registry **consumes** this declaration: it validates referenced child
+ * types at registration time and again on `validate()`, and the resolver
+ * (`resolveComposition`) produces a typed children list ready for render.
+ */
+import type { AtomMode, AtomReference, AnyAtomRegistration } from "./registration.js";
+/**
+ * One edge of the composition graph.
+ */
+export interface AtomComposition {
+    /**
+     * Entity type of the child atom. Must resolve in the registry by the
+     * time {@link resolveComposition} is called; the boot-time
+     * `AtomRegistry.validate()` step also asserts the child is registered
+     * unless {@link forwardRef} is `true`.
+     */
+    childEntityType: string;
+    /** Mode the parent renders each child in (typically `"compact"`). */
+    childMode: AtomMode;
+    /**
+     * Key on the parent's `data` payload where the child rows live. The
+     * resolver looks up `parentData[dataKey]` and expects an array.
+     */
+    dataKey: string;
+    /**
+     * Opt-out of presence validation for this edge. When `true`:
+     *   - `AtomRegistry.validate()` does not require {@link childEntityType}
+     *     to be registered, so a parent can ship a composition declaration
+     *     that names a child atom slated for a later sprint without
+     *     crashing the boot.
+     *   - {@link resolveComposition} silently produces zero children for
+     *     this edge while the child remains unregistered, so the parent's
+     *     `contextSummary` keeps returning `ok: true` (instead of erroring
+     *     and forcing a hand-rolled fallback in every consumer).
+     *   - Once the child atom is registered, both checks resolve normally
+     *     and child references begin surfacing without further changes to
+     *     the parent atom's code.
+     *
+     * Use sparingly — most edges should reference an already-registered
+     * child so a typo in `childEntityType` continues to fail the boot
+     * validator (the per-edge scope of this opt-out is deliberate so a
+     * sibling forward-ref edge doesn't silently mask a typo elsewhere on
+     * the same parent).
+     */
+    forwardRef?: boolean;
+}
+/**
+ * Single resolved child returned by {@link resolveComposition}.
+ */
+export interface ResolvedChild {
+    /** The composition edge that produced this child. */
+    composition: AtomComposition;
+    /** The child registration in the registry. */
+    registration: AnyAtomRegistration;
+    /** Stable atom reference suitable for handing to a render binding. */
+    reference: AtomReference;
+    /** The raw data row from `parentData[dataKey][i]`. */
+    data: Record<string, unknown>;
+}
+/**
+ * Minimal registry surface the resolver needs. Declared structurally so
+ * `composition.ts` doesn't have to import `registry.ts` and create a
+ * circular dependency.
+ */
+export interface CompositionRegistryView {
+    resolve: (entityType: string) => {
+        ok: true;
+        registration: AnyAtomRegistration;
+    } | {
+        ok: false;
+        error: {
+            entityType: string;
+            message: string;
+        };
+    };
+}
+/**
+ * Resolve a parent registration's composition edges against `parentData`.
+ *
+ * For each declared child:
+ * - looks up the child entity type in the registry (returns an error
+ *   variant if missing — never throws),
+ * - reads `parentData[dataKey]` (must be an array; missing → empty),
+ * - synthesizes a stable {@link AtomReference} per row using `id`,
+ *   `entityId`, `slug`, or `name` (in that order), falling back to
+ *   `${parentRef.entityId}-${dataKey}-${index}`.
+ *
+ * Edges marked `forwardRef: true` whose child is still unregistered at
+ * lookup time produce zero children silently rather than contributing
+ * an error — the parent has explicitly opted in to that behavior so its
+ * declaration can ship before the child catalog atom does.
+ *
+ * @returns A list of {@link ResolvedChild} on success, or `{ ok: false,
+ *   errors }` enumerating every missing non-forward-ref child entity
+ *   type. The caller decides whether to dev-warn or hard-fail.
+ */
+export declare function resolveComposition(parentRegistration: AnyAtomRegistration, parentRef: AtomReference, parentData: Record<string, unknown>, registry: CompositionRegistryView): {
+    ok: true;
+    children: ResolvedChild[];
+} | {
+    ok: false;
+    errors: ReadonlyArray<{
+        childEntityType: string;
+        message: string;
+    }>;
+};
+//# sourceMappingURL=composition.d.ts.map

package/dist/composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../src/composition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAEtF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB,qEAAqE;IACrE,SAAS,EAAE,QAAQ,CAAC;IAEpB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,WAAW,EAAE,eAAe,CAAC;IAE7B,8CAA8C;IAC9C,YAAY,EAAE,mBAAmB,CAAC;IAElC,sEAAsE;IACtE,SAAS,EAAE,aAAa,CAAC;IAEzB,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,CACP,UAAU,EAAE,MAAM,KAEhB;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,YAAY,EAAE,mBAAmB,CAAA;KAAE,GAC/C;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE;YAAE,UAAU,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;CACnE;AASD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,kBAAkB,EAAE,mBAAmB,EACvC,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,QAAQ,EAAE,uBAAuB,GAE/B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,aAAa,EAAE,CAAA;CAAE,GACvC;IACE,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,aAAa,CAAC;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrE,CA2CJ"}

package/dist/composition.js

@@ -0,0 +1,80 @@
+/**
+ * Declarative atom composition.
+ *
+ * An atom may declare zero or more children — each describing a child
+ * entity type, the render mode the child should be drawn in by the parent,
+ * and the key under which the parent's `data` exposes the child rows. The
+ * registry **consumes** this declaration: it validates referenced child
+ * types at registration time and again on `validate()`, and the resolver
+ * (`resolveComposition`) produces a typed children list ready for render.
+ */
+function pickIdFrom(row, fallback) {
+    const candidate = row.id ?? row.entityId ?? row.slug ?? row.name;
+    if (typeof candidate === "string" && candidate.length > 0)
+        return candidate;
+    if (typeof candidate === "number")
+        return String(candidate);
+    return fallback;
+}
+/**
+ * Resolve a parent registration's composition edges against `parentData`.
+ *
+ * For each declared child:
+ * - looks up the child entity type in the registry (returns an error
+ *   variant if missing — never throws),
+ * - reads `parentData[dataKey]` (must be an array; missing → empty),
+ * - synthesizes a stable {@link AtomReference} per row using `id`,
+ *   `entityId`, `slug`, or `name` (in that order), falling back to
+ *   `${parentRef.entityId}-${dataKey}-${index}`.
+ *
+ * Edges marked `forwardRef: true` whose child is still unregistered at
+ * lookup time produce zero children silently rather than contributing
+ * an error — the parent has explicitly opted in to that behavior so its
+ * declaration can ship before the child catalog atom does.
+ *
+ * @returns A list of {@link ResolvedChild} on success, or `{ ok: false,
+ *   errors }` enumerating every missing non-forward-ref child entity
+ *   type. The caller decides whether to dev-warn or hard-fail.
+ */
+export function resolveComposition(parentRegistration, parentRef, parentData, registry) {
+    const composition = parentRegistration.composition;
+    const errors = [];
+    const children = [];
+    for (const edge of composition) {
+        const resolved = registry.resolve(edge.childEntityType);
+        if (!resolved.ok) {
+            if (edge.forwardRef) {
+                continue;
+            }
+            errors.push({
+                childEntityType: edge.childEntityType,
+                message: resolved.error.message,
+            });
+            continue;
+        }
+        const raw = parentData[edge.dataKey];
+        const rows = Array.isArray(raw)
+            ? raw
+            : [];
+        rows.forEach((row, i) => {
+            if (row === null || typeof row !== "object")
+                return;
+            const childId = pickIdFrom(row, `${parentRef.entityId}-${edge.dataKey}-${i}`);
+            children.push({
+                composition: edge,
+                registration: resolved.registration,
+                reference: {
+                    kind: "atom",
+                    entityType: edge.childEntityType,
+                    entityId: childId,
+                    mode: edge.childMode,
+                },
+                data: row,
+            });
+        });
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return { ok: true, children };
+}
+//# sourceMappingURL=composition.js.map

package/dist/composition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.js","sourceRoot":"","sources":["../src/composition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA8EH,SAAS,UAAU,CAAC,GAA4B,EAAE,QAAgB;IAChE,MAAM,SAAS,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,QAAQ,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC;IACjE,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IAC5E,IAAI,OAAO,SAAS,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC;IAC5D,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,kBAAkB,CAChC,kBAAuC,EACvC,SAAwB,EACxB,UAAmC,EACnC,QAAiC;IAOjC,MAAM,WAAW,GAAG,kBAAkB,CAAC,WAAW,CAAC;IACnD,MAAM,MAAM,GAAwD,EAAE,CAAC;IACvE,MAAM,QAAQ,GAAoB,EAAE,CAAC;IAErC,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAC/B,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACxD,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACpB,SAAS;YACX,CAAC;YACD,MAAM,CAAC,IAAI,CAAC;gBACV,eAAe,EAAE,IAAI,CAAC,eAAe;gBACrC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO;aAChC,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QACD,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrC,MAAM,IAAI,GAAmC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;YAC7D,CAAC,CAAE,GAAsC;YACzC,CAAC,CAAC,EAAE,CAAC;QACP,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;YACtB,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ;gBAAE,OAAO;YACpD,MAAM,OAAO,GAAG,UAAU,CACxB,GAAG,EACH,GAAG,SAAS,CAAC,QAAQ,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC,EAAE,CAC7C,CAAC;YACF,QAAQ,CAAC,IAAI,CAAC;gBACZ,WAAW,EAAE,IAAI;gBACjB,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,SAAS,EAAE;oBACT,IAAI,EAAE,MAAM;oBACZ,UAAU,EAAE,IAAI,CAAC,eAAe;oBAChC,QAAQ,EAAE,OAAO;oBACjB,IAAI,EAAE,IAAI,CAAC,SAAS;iBACrB;gBACD,IAAI,EAAE,GAAG;aACV,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACpD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAChC,CAAC"}

package/dist/conformance/common.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Architecture-homes conformance target constants (doc 02).
+ *
+ * Every atom family must satisfy the shape validated by
+ * {@link validateAtomConformance} against
+ * {@link ATOM_CONFORMANCE_TARGET_VERSION}.
+ */
+import { z } from "zod";
+import type { AccessPolicy } from "../registration.js";
+/**
+ * Pin every consumer co-bump to this semver when adopting the
+ * conformance target or downloadable-atom export shape.
+ */
+export declare const ATOM_CONFORMANCE_TARGET_VERSION: "1.5.0";
+export type AtomConformanceTargetVersion = typeof ATOM_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>;
+export declare const ACCESS_POLICY_VALUES: ReadonlyArray<AccessPolicy>;
+export declare const ACCESS_POLICY_SCHEMA: z.ZodEnum<["public-free", "public-paid", "platform-internal", "tenant-private", "tenant-shared"]>;
+//# sourceMappingURL=common.d.ts.map

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

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

@@ -0,0 +1,29 @@
+/**
+ * Architecture-homes conformance target constants (doc 02).
+ *
+ * Every atom family must satisfy the shape validated by
+ * {@link validateAtomConformance} against
+ * {@link ATOM_CONFORMANCE_TARGET_VERSION}.
+ */
+import { z } from "zod";
+/**
+ * Pin every consumer co-bump to this semver when adopting the
+ * conformance target or downloadable-atom export shape.
+ */
+export const ATOM_CONFORMANCE_TARGET_VERSION = "1.5.0";
+export const ATOM_TIER_VALUES = ["data", "app"];
+export const ACCESS_POLICY_VALUES = [
+    "public-free",
+    "public-paid",
+    "platform-internal",
+    "tenant-private",
+    "tenant-shared",
+];
+export const ACCESS_POLICY_SCHEMA = z.enum([
+    "public-free",
+    "public-paid",
+    "platform-internal",
+    "tenant-private",
+    "tenant-shared",
+]);
+//# sourceMappingURL=common.js.map

package/dist/conformance/common.js.map

@@ -0,0 +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;AAQhE,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/fixtures.d.ts

@@ -0,0 +1,13 @@
+import type { AtomEvent } from "../history.js";
+import type { AtomConformanceTarget } from "./validate.js";
+type ChainEventSeed = Omit<AtomEvent, "chainHash" | "prevHash"> & {
+    prevHash?: string | null;
+    chainHash?: string;
+};
+/** Build a gap-free signed chain with recomputed hashes for tests. */
+export declare function buildValidSignedEventChain(events: ReadonlyArray<ChainEventSeed>): AtomEvent[];
+export declare const SAMPLE_DATA_CONFORMANCE_EVENTS: AtomEvent[];
+export declare const SAMPLE_DATA_CONFORMANCE_TARGET: AtomConformanceTarget;
+export declare const SAMPLE_APP_CONFORMANCE_TARGET: AtomConformanceTarget;
+export {};
+//# sourceMappingURL=fixtures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/conformance/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAI/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAI3D,KAAK,cAAc,GAAG,IAAI,CAAC,SAAS,EAAE,WAAW,GAAG,UAAU,CAAC,GAAG;IAChE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,sEAAsE;AACtE,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,aAAa,CAAC,cAAc,CAAC,GACpC,SAAS,EAAE,CAmBb;AAED,eAAO,MAAM,8BAA8B,aAsBzC,CAAC;AAEH,eAAO,MAAM,8BAA8B,EAAE,qBAS5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,qBAK3C,CAAC"}