graphddb 0.8.1 → 0.9.0

package/dist/spec/index.d.ts

@@ -1,11 +1,14 @@
-import { $ as AnyOperationDefinition, a0 as TransactionDefinition, b as PreparedBody } from '../key-DZtjAQDh.js';
-export { a1 as CompiledFragment, a2 as CompiledMutationPlan, a3 as DerivedConditionCheck, a4 as DerivedEdgeWrite, a5 as DerivedIdempotencyGuard, a6 as DerivedMaintainOutbox, a7 as DerivedMaintainWrite, a8 as DerivedOutboxEvent, a9 as DerivedUniqueGuard, aa as DerivedUpdate, ab as EntityRefResolver, ac as MAX_TRANSACT_COMPOSE_ITEMS, ad as assertNoCrossFragmentMaintainCollision, ae as compileFragment, af as compileMutationPlan, ag as compileSingleFragmentPlan, ah as resetMaintenanceGraphCache, ai as resolveLifecycle, aj as resolveMaintainers } from '../key-DZtjAQDh.js';
-import { M as MetadataRegistry } from '../linter-DQY7gUEk.js';
-import { C as ContractMap, e as ContextOwnershipMap, c as PreparedPlanSpec, a as PreparedPlanDocument } from '../prepared-artifact-HFealr1q.js';
-export { A as AnyModelContract, B as BuiltContracts, f as ContextOwnership, g as PREPARED_FORMAT_VERSION, h as PreparedBindMap, b as PreparedBindSpec, d as PreparedReadRouteSpec, P as PreparedWriteOpSpec, i as buildContexts, j as buildContracts, k as canonicalJson, l as entityFingerprint, p as planFingerprint } from '../prepared-artifact-HFealr1q.js';
-import { O as OperationsDocument, Q as QuerySpec, M as Manifest, C as ContractSpec, T as TransactionSpec, B as BridgeBundle, c as ConditionSpec, E as ExpressionSpec, a as CommandSpec, d as SpecVersion } from '../types-2PMXEn5x.js';
-export { e as CommandContractMethodSpec, f as CommandResolutionTarget, g as ComposeSpec, h as CompositionPlanSpec, b as ContextSpec, i as ContractCardinality, j as ContractCommandResult, k as ContractInputArity, l as ContractKeySpec, m as ContractKind, n as ContractResolution, o as EXPR_VERSION, p as ExecutionPlanSpec, q as ExpressionArrNode, r as ExpressionFloatNode, s as ExpressionIntNode, t as ExpressionNode, u as ExpressionObjNode, v as ExpressionOpNode, w as ExpressionOperator, x as ExpressionRefNode, y as ExpressionRefOptNode, z as ExpressionScalar, F as FilterSpec, A as ManifestEntity, D as ManifestField, G as ManifestFieldType, H as ManifestGsi, I as ManifestKey, J as ManifestRelation, K as ManifestTable, L as OperationSpec, P as ParamSpec, N as QueryContractMethodSpec, R as RangeConditionSpec, U as ReadOperationType, S as SPEC_VERSION, V as SPEC_VERSION_SCP, W as SPEC_VERSION_SUPPORTED, X as TransactionItemSpec, Y as TransactionItemType, Z as WhenSpec, _ as WriteOperationType } from '../types-2PMXEn5x.js';
-import '../types-DW__-Icc.js';
+import { $ as AnyOperationDefinition, a0 as TransactionDefinition, b as PreparedBody } from '../key-Dne-a20Q.js';
+export { a1 as CompiledFragment, a2 as CompiledMutationPlan, a3 as DerivedConditionCheck, a4 as DerivedEdgeWrite, a5 as DerivedIdempotencyGuard, a6 as DerivedMaintainOutbox, a7 as DerivedMaintainWrite, a8 as DerivedOutboxEvent, a9 as DerivedUniqueGuard, aa as DerivedUpdate, ab as EntityRefResolver, ac as MAX_TRANSACT_COMPOSE_ITEMS, ad as assertNoCrossFragmentMaintainCollision, ae as compileFragment, af as compileMutationPlan, ag as compileSingleFragmentPlan, ah as resetMaintenanceGraphCache, ai as resolveLifecycle, aj as resolveMaintainers } from '../key-Dne-a20Q.js';
+import { M as MetadataRegistry } from '../linter-Cr1Hnw7n.js';
+import { B as BehaviorModelContract } from '../behaviors-DDltNivc.js';
+export { a as BehaviorMethodSpec } from '../behaviors-DDltNivc.js';
+import { C as ContractMap, e as ContextOwnershipMap, c as PreparedPlanSpec, a as PreparedPlanDocument } from '../prepared-artifact-BXkARxwO.js';
+export { A as AnyModelContract, B as BuiltContracts, f as ContextOwnership, g as PREPARED_FORMAT_VERSION, h as PreparedBindMap, b as PreparedBindSpec, d as PreparedReadRouteSpec, P as PreparedWriteOpSpec, i as buildContexts, j as buildContracts, k as canonicalJson, l as entityFingerprint, p as planFingerprint } from '../prepared-artifact-BXkARxwO.js';
+import { O as OperationsDocument, Q as QuerySpec, M as Manifest, T as TransactionSpec, C as ContractSpec, B as BridgeBundle, c as ConditionSpec, E as ExpressionSpec, a as CommandSpec, d as SpecVersion } from '../types-CfxzTEFL.js';
+export { e as CommandContractMethodSpec, f as CommandResolutionTarget, g as ComposeSpec, h as CompositionPlanSpec, b as ContextSpec, i as ContractCardinality, j as ContractCommandResult, k as ContractInputArity, l as ContractKeySpec, m as ContractKind, n as ContractResolution, o as EXPR_VERSION, p as ExecutionPlanSpec, q as ExpressionArrNode, r as ExpressionFloatNode, s as ExpressionIntNode, t as ExpressionNode, u as ExpressionObjNode, v as ExpressionOpNode, w as ExpressionOperator, x as ExpressionRefNode, y as ExpressionRefOptNode, z as ExpressionScalar, F as FilterSpec, A as ManifestEntity, D as ManifestField, G as ManifestFieldType, H as ManifestGsi, I as ManifestKey, J as ManifestRelation, K as ManifestTable, L as OperationSpec, P as ParamSpec, N as QueryContractMethodSpec, R as RangeConditionSpec, U as ReadOperationType, V as SPEC_VERSION, S as SPEC_VERSION_KEY_EXPR, W as SPEC_VERSION_SCP, X as SPEC_VERSION_SUPPORTED, Y as TransactionItemSpec, Z as TransactionItemType, _ as WhenSpec, $ as WriteOperationType } from '../types-CfxzTEFL.js';
+import { Component, ComponentGraphIR } from 'behavior-contracts';
+import '../types-BnFsTZwl.js';
 
 /**
  * Static parameterized operation-spec generation (issue #42, Phase 0b).
@@ -33,6 +36,16 @@ interface ContractInputs {
     readonly contracts?: ContractMap;
     /** Context-ownership declarations (context → member models / contracts). */
     readonly contexts?: ContextOwnershipMap;
+    /**
+     * Resolved behavior contracts (`publishBehaviors` output, #297 SP3) — the
+     * shared-authoring surface registrations. ADDITIVE: each contract's bc-lowered
+     * components register into the emitted `components[]` as
+     * `<RegistrationKey>__<method>` alongside the publish* output; nothing else
+     * in the document changes, and an absent/empty map reproduces the previous
+     * bytes exactly. Their CQRS effect is purely graph-derived (there is no
+     * declared side to verify — see `assertPublishSplitMatchesDerived`).
+     */
+    readonly behaviors?: Readonly<Record<string, BehaviorModelContract>>;
 }
 /**
  * Build the operations document from grouped read (`queries`) and write
@@ -46,6 +59,10 @@ interface ContractInputs {
  * contract-free input (`contractInputs` empty / absent) reproduces the pre-#59
  * document byte-for-byte — no `contracts` / `contexts` keys appear.
  *
+ * The shared-authoring layer (#297 SP3) is likewise additive: each
+ * `contractInputs.behaviors` registration appends its bc-lowered components to
+ * `components[]` (as `<Key>__<method>`); an absent/empty map changes nothing.
+ *
  * @throws if a command carries a write condition outside the supported subset
  *   (`{ notExists }` or pure equality) — the bridge guard; or if a contract op
  *   name collides with a hand-written definition.
@@ -70,6 +87,192 @@ declare function buildOperations(queries?: Record<string, AnyOperationDefinition
  */
 declare function buildManifest(registry?: typeof MetadataRegistry): Manifest;
 
+/**
+ * Universal component-graph IR emitter (SCP IR Phase 3, issue #290 — sub-pass 1b,
+ * DUAL-EMIT, behavior-contracts vocabulary v2).
+ *
+ * This module additively lifts the graphddb-specific operation IR
+ * (`QuerySpec.operations[]` / `TransactionSpec.items[]`, wired by `resultPath` /
+ * `sourceField` / `sourceList` / `{item.*}`) into the **universal SCP
+ * component-graph** form behavior-contracts defines
+ * (`scp-ir-architecture.md` §5/§5.1, `ts/src/behavior.ts`): a `Component{ name,
+ * inputPorts, body[], output, plan }` whose `body` nodes are `componentRef` /
+ * `map` referencing the graphddb catalog (`GetItem` / `Query` / `BatchGetItem` /
+ * `PutItem` / `UpdateItem` / `DeleteItem` / `ConditionCheck`) and whose Port
+ * wiring is Expression IR.
+ *
+ * ## SP5 ownership split (#297 / bc#26)
+ *
+ * Since #297 SP5 this module EXTRACTS but does not ASSEMBLE: every derived
+ * graph (node ids, ports, map/into/batched decisions, relationKind, plan) is
+ * handed to behavior-contracts' data-registration builder
+ * (`buildComponentDefinition`, validated against `GRAPHDDB_CATALOG`), which
+ * owns the IR shape — structural/catalog/plan validation, reference-root
+ * existence, and the deterministic code-point key-sorted canonicalization of
+ * the final `Component`. graphddb's `assertComponentsInCatalog` stays as the
+ * stricter consumer-side gate on top (its dynamic-family whitelist is tighter
+ * than the builder's `additionalPorts` acceptance — belt-and-suspenders by
+ * design).
+ *
+ * ## Dual-emit (this sub-pass only)
+ *
+ * The emitted `components[]` sits ALONGSIDE the existing
+ * `queries`/`commands`/`transactions` — nothing here removes or rewrites the old
+ * wiring. The 4 spec-consumer runtimes (py/php/rust/go) keep reading the OLD path
+ * (`queries` etc.); `components[]` is a new top-level field they tolerate (they
+ * read only the keys they know, and `validateEnvelope` checks only `version`).
+ * The purpose of the additive emit is to PROVE, via behavior-contracts
+ * `assertPortableComponentGraph` + `runBehavior`, that the universal form is
+ * well-formed and semantically reproduces the query — de-risking the later
+ * sub-passes that migrate the runtimes onto it.
+ *
+ * ## Vocabulary v2 (bc#22, behaviorVersion 2) — the sub-pass-2a gap closures
+ *
+ * The 2a escalation proved 6 constructs the sub-pass-1 emission could not carry;
+ * this emitter closes them on the v2 map vocabulary:
+ *
+ * 1. **Depth-2+ relations** (`$.groups.items.group[.permissions.items]`): a
+ *    relation whose producer is a CONNECTION is emitted as a `map` over the
+ *    parent connection's `items` with `into: <relationProp>` (zip-attach onto the
+ *    per-element membership row); deeper levels CHAIN over the previous map's
+ *    augmented list (`over: {ref:[<prevMapId>]}`), reading the parent body
+ *    through the attach key (`{ref:["$el","group",…]}`). The attach is FLAT on
+ *    the element (v2 `into` semantics — the canonical bc depth-2 vector shape);
+ *    the node id carries the full `resultPath`-derived path
+ *    (`groups.items.group.permissions.items`), so re-nesting the flat key into
+ *    the old assembled placement (`item.group.permissions`) is a mechanical,
+ *    id-driven fold in the consuming runtime.
+ * 2. **Per-element transaction guards**: the legacy `when:{op,left,right}`
+ *    comparison AND the #267/#268 `guard` Expression IR both lower to `map.when`
+ *    (evaluated under the `$item` element binding; strict-bool, fail-closed).
+ * 3. **Write-condition / write-item ports completeness**: every transaction
+ *    item's `entity`, `condition` (all kinds), `literalKey` and `maintain`
+ *    payload are carried as ports, so a handler builds the exact TransactWrite
+ *    item from the evaluated ports alone (plus its injected manifest/config —
+ *    the C4 boundary; no node-identity join needed).
+ * 4. **Relation filters**: an op's `filter.declarative` tree rides in the read
+ *    ports (JSON-encoded — see below).
+ * 5. **Implicit-strip marker**: a `refs` fan-out whose driver list was projected
+ *    only implicitly (`sourceList.implicit`) emits `implicitSourceField` in its
+ *    map ports, so the post-assembly strip of the driver field from the parent
+ *    is expressible without the old `sourceList`.
+ * 6. **Batched fan-out**: fan-outs the old path serves with ONE deduped/chunked
+ *    `BatchGetItem` (a `sourceList` refs fan-out; a belongsTo child of a
+ *    connection) emit `batched: true` — the handler receives `{items:[…]}` once
+ *    and owns dedupe/chunk/retry (CONSUMER), returning a list aligned to
+ *    `items`. Per-element `GetItem`/`Query` maps stay unbatched.
+ *
+ * ## Opaque-JSON ports (declarative trees)
+ *
+ * A port VALUE is Expression IR: `assertPortableComponentGraph` walks every port
+ * value through the closed operator set, so a declarative operator tree
+ * (`filter.declarative`, `condition.declarative`, `condition.names`, `maintain`)
+ * — whose single-key nodes (`{and:…}`, `{name:…}`) would be mis-read as
+ * unknown operators — is carried as a **canonical JSON string literal**
+ * (deterministically key-sorted), which the handler parses. Caller-param leaves
+ * (`{$param}`) that such a tree binds at execution time are lifted OUT into
+ * companion `condition.params.<name>` / `condition.values.<slot>` ports whose
+ * values are `{ref:[<param>]}` — evaluated by the executor, so the handler gets
+ * the bound values without reaching into graphddb scope internals.
+ *
+ * ## Scope convention (`runBehavior`-native)
+ *
+ * The graphddb Phase-2 key wiring roots its Expression IR references at
+ * `input.<param>` / `result.<field>` (and guards at `item.<field>`). The
+ * universal `runBehavior` executor evaluates ports against a FLAT scope
+ * `{ ...input, ...nodeResultsById, [<as>]: element }`, so this emitter REMAPS
+ * the scope roots when lowering:
+ *
+ * - `["input", p]`  → `[p]`                    — a param at the top-level scope.
+ * - `["result", f]` → `[<parentNodeId>, f]`    — the parent node result, or
+ *   `["$el"(…attach segs), f]` inside a relation map, or `[<as>, f]` inside a
+ *   refs fan-out map.
+ * - `["item", f]`   → `["$item", f]`           — a forEach guard's element field.
+ *
+ * The remap is a pure rename of the reference ROOTS; the literal/`concat`
+ * structure the Phase-2 lowerer produced is reused verbatim.
+ *
+ * ## Cardinality-one root collapse
+ *
+ * A cardinality-`'one'` query whose root is a `Query` (unique-GSI lookup)
+ * assembles, on the old path, a SINGLE entity (first matched item) that child
+ * relations key off (`{result.userId}`). Expression IR has no list indexing, so
+ * the collapse is carried as a root port `cardinality: 'one'` — the catalog
+ * `Query` handler returns the first matched item (or null) instead of a
+ * connection, exactly the old runtime's root shaping.
+ */
+
+/**
+ * Lower one {@link QuerySpec} into a universal SCP {@link Component}. Each read
+ * {@link OperationSpec} becomes a body node:
+ *
+ * - the root op (`resultPath === '$'`) → a `componentRef` whose ports carry the
+ *   remapped `keyExpr` (rooted at the params) and `projection`; a
+ *   cardinality-one Query root adds the `cardinality: 'one'` collapse port;
+ * - a `refs` fan-out op (carrying `sourceList`) → a **batched** `map` node
+ *   iterating the parent list attribute (`sourceList.over`), the per-element key
+ *   bound through the `sourceList.as` element binding, with the
+ *   `implicitSourceField` strip marker when the driver list was implicit;
+ * - a relation whose producer is a CONNECTION (or a deeper link of such a
+ *   chain) → a `map` over the connection's items / the previous map's augmented
+ *   list, `into: <relationProp>` (zip-attach; `batched` when the old path served
+ *   it with one BatchGetItem);
+ * - a root-level `hasMany` / `belongsTo` relation → a `componentRef` with
+ *   `parent`, `bindField` (the source field for null-binding skip), and
+ *   `relationKind`.
+ *
+ * The component's `output` is the Φ merge: the root node result with each
+ * ROOT-LEVEL relation attached under its property; a chained connection exposes
+ * `{obj:{cursor:<connection cursor>, items:<final augmented list>}}`. The `plan`
+ * is re-derived from the emitted parent wiring (identical `{groups,
+ * concurrency}` shape; equal to the query's plan wherever chaining introduced no
+ * new dependency), or absent for a single-node read.
+ */
+declare function buildQueryComponent(name: string, query: QuerySpec): Component;
+/**
+ * Lower one {@link TransactionSpec} into a universal SCP {@link Component}. A
+ * transaction is a single-stage batched write; each item becomes a body node:
+ *
+ * - a `forEach` item (expanded once per element of the named array param) → an
+ *   SCP `map` over that array param (`over: {ref:[<source>]}`, `as: "$item"`),
+ *   its `{item.<field>}` template tokens lowered to `["$item", field]` refs and
+ *   its `when`/`guard` lowered to `map.when` (gap 2 — a falsy element is
+ *   skipped: handler not called, excluded from the result, order preserved);
+ * - a plain item with an input-scope `guard` → a MAP OF ONE with `when`
+ *   (`over: {arr:[true]}`), reproducing the old kept/skipped expansion;
+ * - a plain item → a `componentRef` against the params.
+ *
+ * The `component` name is the DynamoDB write catalog entry (`Put` → `PutItem`,
+ * `Update` → `UpdateItem`, `Delete` → `DeleteItem`, `ConditionCheck` →
+ * `ConditionCheck`). The output is the array of every item node's result (a
+ * transaction returns no per-item image, so this is descriptive of the writes).
+ */
+declare function buildTransactionComponent(name: string, tx: TransactionSpec): Component;
+/**
+ * Build the universal `components[]` for a whole operations document (dual-emit,
+ * issue #290 sub-pass 1b). Every query and every transaction is lifted into one
+ * {@link Component}; commands (single writes) are represented via the query
+ * readbacks / transactions already present, so this sub-pass lifts the two
+ * multi-node forms (queries, transactions) that exercise the universal `map` /
+ * `componentRef` / plan vocabulary. Deterministic: queries then transactions,
+ * each in sorted-name order.
+ *
+ * Every emitted component is validated against {@link GRAPHDDB_CATALOG}
+ * (#297 SP1c — names, required ports, declared-port families); a mismatch
+ * throws, so an emitter drift from the catalog is a BUILD error, never a
+ * silently-shipped document.
+ */
+declare function buildComponents(queries: Readonly<Record<string, QuerySpec>>, transactions: Readonly<Record<string, TransactionSpec>>): Component[];
+/**
+ * Wrap emitted `components[]` into the portable component-graph IR document
+ * (`{irVersion, exprVersion, components}` — scp-ir-architecture.md §5): the
+ * ONLY input shape behavior-contracts' common Generator accepts (issue #257 —
+ * `generateModule` loudly rejects the raw operations bundle / internal IR).
+ * graphddb adds no generation logic: this envelope is the entire consumer-side
+ * input contract of the upstream codegen-static endpoint (§7.3 endpoint 3).
+ */
+declare function portableIrDocument(components: readonly Component[]): ComponentGraphIR;
+
 /**
  * N+1 static checker for the CQRS Contract layer (issue #60, Epic #57; proposal
  * `docs/cqrs-contract.md`, "N+1 Safety (Static Restriction)").
@@ -394,24 +597,22 @@ declare function assertBundleSerializable(bundle: BridgeBundle): void;
  */
 declare function canonicalizeExpressionSpec(input: unknown, context: string): ExpressionSpec;
 /**
- * Does this operations-document content actually contain an SCP Expression IR
- * node — a `{ kind: 'scpExpr' }` write condition or a `guard` (transaction
- * item / contract command method)? This is the **presence scan** behind the
- * conditional stamp (issue #261): the walk visits exactly the slots the spec
- * vocabulary defines, so an SCP-free document is provably stamped `1.1` and
- * stays byte-identical.
+ * The spec version to stamp on an operations document. **SCP IR Phase 2 (#289):
+ * always `2.0`.** The read-op key wiring moved from `{param}` string templates to
+ * the portable Expression IR (`keyExpr` / `valueExpr`), a MAJOR IR serialization
+ * change — so the whole operations IR moves to `2.0` at once (migration plan §4).
+ * A pre-#289 runtime (supported `1.2`) `validateEnvelope`-rejects a `2.0`
+ * document, the intended breaking cut. The former conditional `1.1`/`1.2`
+ * presence-scan stamping (issue #261, `operationsContainScpNodes`) was removed
+ * in the final #290 sub-pass: every `2.0` document is a superset (guard/scpExpr
+ * nodes still validate under exprVersion 2), so a single unconditional `2.0`
+ * stamp is correct now that the read-op key wiring is unconditionally Expression
+ * IR.
  */
-declare function operationsContainScpNodes(doc: {
+declare function operationsSpecVersion(_doc: {
     readonly commands: Readonly<Record<string, CommandSpec>>;
-    readonly transactions?: Readonly<Record<string, TransactionSpec>>;
     readonly contracts?: Readonly<Record<string, ContractSpec>>;
-}): boolean;
-/**
- * The spec version to stamp on an operations document: `1.2` iff it actually
- * contains an SCP node ({@link operationsContainScpNodes}), else the base
- * `1.1` — so every pre-#261 bundle serializes byte-identically.
- */
-declare function operationsSpecVersion(doc: Parameters<typeof operationsContainScpNodes>[0]): SpecVersion;
+}): SpecVersion;
 
 /**
  * Static prepared-plan artifact — the **build-time** (AOT) compilation of
@@ -503,4 +704,4 @@ declare function buildPreparedPlanDocument(plans: Readonly<Record<string, Prepar
  */
 declare function buildBridgeBundle(queries?: Record<string, AnyOperationDefinition>, commands?: Record<string, AnyOperationDefinition>, registry?: typeof MetadataRegistry, transactions?: Record<string, TransactionDefinition>, contractInputs?: ContractInputs): BridgeBundle;
 
-export { BridgeBundle, CommandSpec, ConditionSpec, ContextOwnershipMap, type ContractBoundaryViolation, type ContractInputs, ContractMap, type ContractN1Violation, ContractSpec, ExpressionSpec, Manifest, OperationsDocument, PreparedPlanDocument, PreparedPlanSpec, QuerySpec, SpecVersion, TransactionSpec, assertBundleSerializable, assertContractBoundaries, assertContractN1Safe, assertJsonSerializable, assertSupportedCondition, buildBridgeBundle, buildManifest, buildOperations, buildPreparedPlanDocument, buildQuerySpec, buildTransactionSpec, buildTransactions, canonicalizeExpressionSpec, collectContractBoundaryViolations, collectContractN1Violations, compilePreparedPlan, operationsContainScpNodes, operationsSpecVersion };
+export { BehaviorModelContract, BridgeBundle, CommandSpec, ConditionSpec, ContextOwnershipMap, type ContractBoundaryViolation, type ContractInputs, ContractMap, type ContractN1Violation, ContractSpec, ExpressionSpec, Manifest, OperationsDocument, PreparedPlanDocument, PreparedPlanSpec, QuerySpec, SpecVersion, TransactionSpec, assertBundleSerializable, assertContractBoundaries, assertContractN1Safe, assertJsonSerializable, assertSupportedCondition, buildBridgeBundle, buildComponents, buildManifest, buildOperations, buildPreparedPlanDocument, buildQueryComponent, buildQuerySpec, buildTransactionComponent, buildTransactionSpec, buildTransactions, canonicalizeExpressionSpec, collectContractBoundaryViolations, collectContractN1Violations, compilePreparedPlan, operationsSpecVersion, portableIrDocument };

package/dist/spec/index.js

@@ -2,22 +2,26 @@ import {
   assertContractBoundaries,
   assertContractN1Safe,
   buildBridgeBundle,
+  buildComponents,
   buildContexts,
   buildContracts,
   buildOperations,
   buildPreparedPlanDocument,
+  buildQueryComponent,
   buildQuerySpec,
+  buildTransactionComponent,
   collectContractBoundaryViolations,
   collectContractN1Violations,
-  compilePreparedPlan
-} from "../chunk-LAT64YCZ.js";
+  compilePreparedPlan,
+  portableIrDocument
+} from "../chunk-SSVG6NQK.js";
 import {
   PREPARED_FORMAT_VERSION,
   buildManifest,
   canonicalJson,
   entityFingerprint,
   planFingerprint
-} from "../chunk-S2NI4PBW.js";
+} from "../chunk-NWTEUWJD.js";
 import {
   MAX_TRANSACT_COMPOSE_ITEMS,
   assertBundleSerializable,
@@ -32,24 +36,25 @@ import {
   resetMaintenanceGraphCache,
   resolveLifecycle,
   resolveMaintainers
-} from "../chunk-T44OB5GU.js";
-import "../chunk-HNY2EJPV.js";
+} from "../chunk-XZTA4VJH.js";
+import "../chunk-KOIJ4SNO.js";
 import {
   EXPR_VERSION,
   SPEC_VERSION,
+  SPEC_VERSION_KEY_EXPR,
   SPEC_VERSION_SCP,
   SPEC_VERSION_SUPPORTED,
   canonicalizeExpressionSpec,
-  operationsContainScpNodes,
   operationsSpecVersion
-} from "../chunk-L4QRCHRQ.js";
-import "../chunk-L2NEDS7U.js";
+} from "../chunk-WOFRHRXY.js";
+import "../chunk-ZNU7OI5I.js";
 import "../chunk-XTWXMOHD.js";
 export {
   EXPR_VERSION,
   MAX_TRANSACT_COMPOSE_ITEMS,
   PREPARED_FORMAT_VERSION,
   SPEC_VERSION,
+  SPEC_VERSION_KEY_EXPR,
   SPEC_VERSION_SCP,
   SPEC_VERSION_SUPPORTED,
   assertBundleSerializable,
@@ -59,12 +64,15 @@ export {
   assertNoCrossFragmentMaintainCollision,
   assertSupportedCondition,
   buildBridgeBundle,
+  buildComponents,
   buildContexts,
   buildContracts,
   buildManifest,
   buildOperations,
   buildPreparedPlanDocument,
+  buildQueryComponent,
   buildQuerySpec,
+  buildTransactionComponent,
   buildTransactionSpec,
   buildTransactions,
   canonicalJson,
@@ -76,9 +84,9 @@ export {
   compilePreparedPlan,
   compileSingleFragmentPlan,
   entityFingerprint,
-  operationsContainScpNodes,
   operationsSpecVersion,
   planFingerprint,
+  portableIrDocument,
   resetMaintenanceGraphCache,
   resolveLifecycle,
   resolveMaintainers

package/dist/testing/index.d.ts

@@ -1,5 +1,6 @@
-import { n as Executor, o as DynamoDBOperation, R as ReadExecOptions, p as ExecutorResult, B as BatchGetExecInput, q as PutInput, W as WriteExecOptions, r as WriteResult, U as UpdateInput, s as DeleteInput, t as BatchWriteExecItem, u as BatchExecOptions, T as TransactWriteExecItem, M as ModelStatic, D as DDBModel, v as ChangeEvent } from '../key-DZtjAQDh.js';
-import '../types-2PMXEn5x.js';
+import { n as Executor, o as DynamoDBOperation, R as ReadExecOptions, p as ExecutorResult, B as BatchGetExecInput, q as PutInput, W as WriteExecOptions, r as WriteResult, U as UpdateInput, s as DeleteInput, t as BatchWriteExecItem, u as BatchExecOptions, T as TransactWriteExecItem, M as ModelStatic, D as DDBModel, v as ChangeEvent } from '../key-Dne-a20Q.js';
+import '../types-CfxzTEFL.js';
+import 'behavior-contracts';
 
 /**
  * In-process physical store backing the GraphDDB Memory Test Adapter

package/dist/testing/index.js

@@ -1,12 +1,12 @@
 import {
   createCdcEmulator
-} from "../chunk-GS4C5VGO.js";
-import "../chunk-HNY2EJPV.js";
+} from "../chunk-YGQ2NO6J.js";
+import "../chunk-KOIJ4SNO.js";
 import {
   ClientManager,
   MetadataRegistry,
   resolveModelClass
-} from "../chunk-L2NEDS7U.js";
+} from "../chunk-ZNU7OI5I.js";
 import {
   TableMapping
 } from "../chunk-XTWXMOHD.js";

package/dist/transform/index.d.ts

@@ -1,5 +1,6 @@
 import ts from 'typescript';
-import { E as ExpressionSpec } from '../types-2PMXEn5x.js';
+import { E as ExpressionSpec } from '../types-CfxzTEFL.js';
+import 'behavior-contracts';
 
 /**
  * Compile-time hoist transform + no-runtime-capture build lint for

package/dist/transform/index.js

@@ -2,8 +2,8 @@ import {
   EXPR_VERSION,
   SCP_LOWERED_MARKER,
   canonicalizeExpressionSpec
-} from "../chunk-L4QRCHRQ.js";
-import "../chunk-L2NEDS7U.js";
+} from "../chunk-WOFRHRXY.js";
+import "../chunk-ZNU7OI5I.js";
 import "../chunk-XTWXMOHD.js";
 
 // src/transform/prepared-transform.ts

package/dist/{types-DW__-Icc.d.ts → types-BnFsTZwl.d.ts}

@@ -1,4 +1,4 @@
-import { d as SegmentedKey, e as ProjectionTransform, f as MaintainEvent, g as ProjectionMap, h as MaintainConsistency, i as MaintainUpdateMode, E as EffectPath, j as MembershipPredicate } from './key-DZtjAQDh.js';
+import { d as SegmentedKey, e as ProjectionTransform, f as MaintainEvent, g as ProjectionMap, h as MaintainConsistency, i as MaintainUpdateMode, E as EffectPath, j as MembershipPredicate } from './key-Dne-a20Q.js';
 
 type DynamoType = 'S' | 'N' | 'BOOL' | 'B' | 'SS' | 'NS' | 'L' | 'M';
 interface FieldOptions {