graphddb 0.7.7 → 0.7.9

package/dist/{from-change-D2zFApzb.d.ts → from-change-DanwjE5b.d.ts}

@@ -1,4 +1,4 @@
-import { C as CdcEmulatorOptions, e as ChangeHandler, U as Unsubscribe, F as FaultSpec, g as ConcurrentRecomputeRef, c as ChangeEvent, E as EventLog, R as ReplayOptions, S as ShardId, V as ViewDefinition, m as EntityMetadata } from './maintenance-view-adapter-C1HaBX4y.js';
+import { C as CdcEmulatorOptions, e as ChangeHandler, U as Unsubscribe, F as FaultSpec, g as ConcurrentRecomputeRef, c as ChangeEvent, E as EventLog, R as ReplayOptions, S as ShardId, V as ViewDefinition, m as EntityMetadata } from './maintenance-view-adapter-BATUh_I8.js';
 
 /**
  * CDC emulator (issue #72). Subscribes to the core write-capture seam

package/dist/{index-BnTZQ_IG.d.ts → index-CtPJSMrc.d.ts}

@@ -1,5 +1,5 @@
-import { Q as QueryModelContract, x as QueryMethodSpec, y as CommandModelContract, z as CommandMethodSpec, A as ContractSpec, G as QuerySpec, H as CommandSpec, I as TransactionSpec, J as ContextSpec, K as SPEC_VERSION, L as ParamSpec, m as EntityMetadata, N as ParamDescriptor, O as EntityRef, X as ConditionInput, Y as Param, M as ModelStatic, w as DDBModel, Z as DefinitionMap, _ as OperationsDocument, $ as AnyOperationDefinition, a0 as Manifest, a1 as BridgeBundle, a2 as ConditionSpec, a3 as PreparedBody } from './maintenance-view-adapter-C1HaBX4y.js';
-import { M as MetadataRegistry } from './registry-DWhq5wiA.js';
+import { Q as QueryModelContract, x as QueryMethodSpec, y as CommandModelContract, z as CommandMethodSpec, A as ContractSpec, G as QuerySpec, H as CommandSpec, I as TransactionSpec, J as ContextSpec, K as SPEC_VERSION, L as ParamSpec, m as EntityMetadata, N as ParamDescriptor, O as EntityRef, X as ConditionInput, Y as Param, M as ModelStatic, w as DDBModel, Z as DefinitionMap, _ as OperationsDocument, $ as AnyOperationDefinition, a0 as Manifest, a1 as BridgeBundle, a2 as ConditionSpec, a3 as PreparedBody } from './maintenance-view-adapter-BATUh_I8.js';
+import { M as MetadataRegistry } from './registry-CXhP4TaE.js';
 
 /**
  * Contract-layer serialization (issue #59, CQRS Contract layer, Epic #57;
@@ -401,8 +401,13 @@ interface TxWriteInstruction {
     /**
      * The write / assertion condition (subset). Optional on `put` / `update` /
      * `delete`; **required** on a `conditionCheck` (the assertion it makes).
+     *
+     * A tx condition operand may be a `p.*` field reference ({@link
+     * TransactionRef}) — the serializer renders it to a `{ $param }` marker — so
+     * the recorded leaf type is widened with `TransactionRef` in the tx context
+     * (#246), matching what the recorder captures from {@link TxWriteOptions}.
      */
-    readonly condition?: ConditionInput;
+    readonly condition?: ConditionInput<TransactionRef>;
     /** Optional declarative guard (skip this item when it does not hold). */
     readonly when?: WhenComparison;
 }
@@ -419,7 +424,7 @@ interface TxForEachInstruction {
 type TxInstruction = TxWriteInstruction | TxForEachInstruction;
 /** Options accepted by `tx.put/update/delete`. */
 interface TxWriteOptions {
-    readonly condition?: ConditionInput;
+    readonly condition?: ConditionInput<TransactionRef>;
     readonly when?: WhenComparison;
 }
 /**
@@ -429,7 +434,7 @@ interface TxWriteOptions {
  * the check entirely when the guard does not hold.
  */
 interface TxConditionCheckOptions {
-    readonly condition: ConditionInput;
+    readonly condition: ConditionInput<TransactionRef>;
     readonly when?: WhenComparison;
 }
 /** Options accepted by `tx.forEach`. */

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-export { a as LintResult, L as LintRule, b as Linter, M as MetadataRegistry } from './registry-DWhq5wiA.js';
-import { aO as SelectableOf, aP as PrimaryKeyOf, aQ as RequestContext, aR as Middleware, aS as ReadRequestKind, aT as CtxModel, aU as ReadParams, aV as ReadRequestCtx, D as DynamoDBOperation, aW as Item, n as Executor, aX as RetryPolicy, ap as ExecutionPlanSpec, aY as KeyDefinition, aZ as GsiDefinition, a_ as ModelKind, a$ as FieldOptions, b0 as DynamoType, b1 as ProjectionTransform, b2 as MaintainEvent, b3 as MembershipPredicate, b4 as MaintainConsistency, b5 as MaintainUpdateMode, b6 as MembershipPredicateOp, b7 as RelationOptions, b8 as AggregateOptions, b9 as AggregateValue, ba as SelectBuilderSpec, bb as RawCondition, m as EntityMetadata, I as TransactionSpec, a0 as Manifest, bc as RetryOverride, bd as ExecutionPlan, be as FieldMetadata, bf as ResolvedKey, o as ReadExecOptions, p as ExecutorResult, q as BatchGetExecInput, P as PutInput, W as WriteExecOptions, r as WriteResult, s as UpdateInput, t as DeleteInput, u as BatchWriteExecItem, v as BatchExecOptions, T as TransactWriteExecItem, M as ModelStatic, w as DDBModel, bg as Slot, bh as PreparedWriteExecOptions, bi as CommandReturn, bj as ParallelOpResult, a3 as PreparedBody, bk as PreparedStatement, bl as RelationMetadata, aD as TransactionItemSpec, bm as MaintainEffect, V as ViewDefinition, Y as Param, N as ParamDescriptor, Z as DefinitionMap, bn as OperationDefinition, bo as WriteDefinitionOptions, bp as PartialQueryKeyOf, bq as StrictSelectSpec, br as ReadDefinitionOptions, bs as EntityInput, bt as UniqueQueryKeyOf } from './maintenance-view-adapter-C1HaBX4y.js';
-export { bu as AggregateMetadata, $ as AnyOperationDefinition, bv as BatchDeleteRequest, bw as BatchGetOptions, bx as BatchGetRequest, by as BatchGetResult, bz as BatchPutRequest, B as BatchResult, bA as BatchWriteRequest, a1 as BridgeBundle, bB as CONTRACT_RANGE_FANOUT_CONCURRENCY, C as CdcEmulatorOptions, a as CdcMode, bC as CdcModelRegistry, bD as CdcSubscribeHandlers, bE as Change, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, bF as CollectionEffect, bG as CollectionOptions, bH as Column, bI as ColumnMap, a4 as CommandContractMethodSpec, bJ as CommandInputShape, bK as CommandMethod, z as CommandMethodSpec, y as CommandModelContract, bL as CommandPlan, a5 as CommandResolutionTarget, bM as CommandResultKind, bN as CommandSelectShape, H as CommandSpec, a6 as CompiledFragment, a8 as ComposeSpec, g as ConcurrentRecomputeRef, bO as CondSlot, bP as ConditionCheckInput, X as ConditionInput, a2 as ConditionSpec, bQ as Connection, J as ContextSpec, bR as ContractCallSignature, aa as ContractCardinality, bS as ContractCommandParams, ab as ContractCommandResult, bT as ContractComposeNode, bU as ContractFromRef, ac as ContractInputArity, bV as ContractItem, bW as ContractKeyFieldRef, bX as ContractKeyInput, bY as ContractKeyRef, ad as ContractKeySpec, ae as ContractKind, bZ as ContractMethodOp, b_ as ContractParamRef, b$ as ContractQueryParams, af as ContractResolution, A as ContractSpec, c0 as CounterAggregate, c1 as CounterEffect, c2 as CtxBase, c3 as DEFAULT_MAX_ATTEMPTS, c4 as DEFAULT_RETRY_POLICY, c5 as DeleteOptions, c6 as DeriveEffect, ah as DerivedEdgeWrite, an as DerivedUpdate, c7 as DescriptorBinding, c8 as ENTITY_WRITES_MARKER, c9 as EdgeEffect, ca as EffectPath, cb as EmbeddedMetadata, cc as EmitEffect, O as EntityRef, cd as EntityWritesDefinition, ce as EntityWritesShape, E as EventLog, cf as ExecutableCommandContract, cg as ExecutableQueryContract, F as FaultSpec, ch as FilterInput, aq as FilterSpec, ci as FragmentInput, cj as GsiDefinitionMarker, ck as GsiOptions, cl as IdempotencyEffect, cm as InProcessWriteDescriptor, cn as InlineSnapshotSpec, co as InputArity, cp as KeyDefinitionMarker, cq as KeySegment, cr as KeySlot, cs as KeyStructure, ct as KeyedResult, cu as LIFECYCLE_CONTRACT_MARKER, cv as LifecycleContract, cw as LifecycleEffects, cx as LiteralParam, cy as MaintainItem, cz as MaintainTrigger, cA as MaintenanceGraph, as as ManifestEntity, at as ManifestField, au as ManifestFieldType, av as ManifestGsi, aw as ManifestKey, ax as ManifestRelation, ay as ManifestTable, cB as MembershipEffect, cC as ModelRef, cD as MutateMode, cE as MutateOptions, cF as MutateParallelResult, cG as MutateTransactionResult, cH as MutationBody, cI as MutationDescriptorMap, cJ as MutationFragment, cK as MutationInputProxy, cL as MutationInputRef, cM as MutationIntent, cN as NumberParam, cO as OperationKind, az as OperationSpec, _ as OperationsDocument, cP as PREPARE_CACHE_MAX, cQ as ParamKind, L as ParamSpec, cR as ParamStructure, cS as PersistCtx, cT as PersistOrigin, cU as PlannedCommandMethod, cV as PreparedInputProxy, cW as PreparedParamRef, cX as PreparedReadExecOptions, cY as PreparedReadRoute, cZ as PreparedReadStatement, c_ as PreparedWriteRoute, c$ as PreparedWriteStatement, d0 as ProjectionMap, d1 as ProjectionTransformOp, d2 as PutOptions, aA as QueryContractMethodSpec, d3 as QueryEnvelopeResult, d4 as QueryKeyOf, d5 as QueryMethod, x as QueryMethodSpec, Q as QueryModelContract, d6 as QueryResult, G as QuerySpec, aB as RangeConditionSpec, d7 as ReadEnvelope, d8 as ReadOpCtx, d9 as ReadOpKind, aC as ReadOperationType, da as ReadRouteDescriptor, db as ReadRouteOptions, dc as ReadRouteResult, dd as RecordedCompose, de as RelationBuilder, df as RelationConsistency, dg as RelationLimitOptions, dh as RelationPattern, di as RelationProjection, dj as RelationReadOptions, dk as RelationSelect, dl as RelationSpec, dm as RelationUpdateMode, dn as RelationWriteOptions, R as ReplayOptions, dp as RequiresEffect, dq as Resolution, dr as RetryInfo, ds as RetryOperationKind, K as SPEC_VERSION, dt as SegmentSpec, du as SegmentedKey, dv as SelectBuilder, dw as SelectOf, S as ShardId, dx as SnapshotEffect, h as StartingPosition, i as StreamViewType, dy as StringParam, j as SubscribeHandler, k as SubscribeHandlers, dz as TransactionContext, aE as TransactionItemType, dA as UniqueEffect, dB as Updatable, dC as UpdateOptions, dD as ViewSourceSlice, aF as WhenSpec, dE as WriteCtx, dF as WriteDescriptor, dG as WriteEnvelope, dH as WriteInput, dI as WriteKind, dJ as WriteLifecyclePhase, dK as WriteMiddleware, aG as WriteOperationType, dL as WriteRecorder, dM as WriteResultProjection, dN as attachModelClass, dO as buildDeleteInput, dP as buildMaintenanceGraph, dQ as buildPutInput, l as buildSubscribeHandler, dR as buildUpdateInput, dS as collectViewDefinitions, aI as compileFragment, aJ as compileMutationPlan, aK as compileSingleFragmentPlan, dT as cond, dU as contractOfMethodSpec, dV as definePlan, dW as entityWrites, dX as executeBatchGet, dY as executeBatchWrite, dZ as executeCommandMethod, d_ as executeDelete, d$ as executeKeyedBatchGet, e0 as executePut, e1 as executeQueryMethod, e2 as executeRangeFanout, e3 as executeTransaction, e4 as executeUpdate, e5 as from, e6 as getEntityWrites, e7 as gsi, e8 as identity, e9 as isColumn, ea as isCommandModelContract, eb as isCommandPlan, ec as isContractComposeNode, ed as isContractFromRef, ee as isContractKeyFieldRef, ef as isContractKeyRef, eg as isContractParamRef, eh as isEntityWritesDefinition, ei as isKeySegment, ej as isLifecycleContract, ek as isMaintainTrigger, el as isMutationFragment, em as isMutationInputRef, en as isParam, eo as isPlannedCommandMethod, ep as isPreparedParamRef, eq as isQueryModelContract, er as isRetryableError, es as isRetryableTransactionCancellation, et as k, eu as key, ev as lifecyclePhaseForIntent, ew as maintainTrigger, ex as mintContractKeyFieldRef, ey as mintContractParamRef, ez as mutation, eA as param, eB as prepare, eC as preview, eD as publicCommandModel, eE as publicQueryModel, eF as query, aM as resolveLifecycle, eG as wholeKeysSentinel } from './maintenance-view-adapter-C1HaBX4y.js';
+export { a as LintResult, L as LintRule, b as Linter, M as MetadataRegistry } from './registry-CXhP4TaE.js';
+import { aO as SelectableOf, aP as PrimaryKeyOf, aQ as RequestContext, aR as Middleware, aS as ReadRequestKind, aT as CtxModel, aU as ReadParams, aV as ReadRequestCtx, D as DynamoDBOperation, aW as Item, n as Executor, aX as RetryPolicy, ap as ExecutionPlanSpec, aY as RetryOverride, aZ as KeyDefinition, a_ as GsiDefinition, a$ as ModelKind, b0 as FieldOptions, b1 as DynamoType, b2 as ProjectionTransform, b3 as MaintainEvent, b4 as MembershipPredicate, b5 as MaintainConsistency, b6 as MaintainUpdateMode, b7 as MembershipPredicateOp, b8 as RelationOptions, b9 as AggregateOptions, ba as AggregateValue, bb as SelectBuilderSpec, bc as RawCondition, m as EntityMetadata, I as TransactionSpec, a0 as Manifest, bd as ExecutionPlan, be as FieldMetadata, bf as ResolvedKey, o as ReadExecOptions, p as ExecutorResult, q as BatchGetExecInput, P as PutInput, W as WriteExecOptions, r as WriteResult, s as UpdateInput, t as DeleteInput, u as BatchWriteExecItem, v as BatchExecOptions, T as TransactWriteExecItem, M as ModelStatic, w as DDBModel, bg as Slot, bh as PreparedWriteExecOptions, bi as CommandReturn, bj as ParallelOpResult, a3 as PreparedBody, bk as PreparedStatement, bl as RelationMetadata, aD as TransactionItemSpec, bm as MaintainEffect, V as ViewDefinition, Y as Param, N as ParamDescriptor, Z as DefinitionMap, bn as OperationDefinition, bo as WriteDefinitionOptions, bp as PartialQueryKeyOf, bq as StrictSelectSpec, br as ReadDefinitionOptions, bs as EntityInput, bt as UniqueQueryKeyOf } from './maintenance-view-adapter-BATUh_I8.js';
+export { bu as AggregateMetadata, $ as AnyOperationDefinition, bv as BatchDeleteRequest, bw as BatchGetOptions, bx as BatchGetRequest, by as BatchGetResult, bz as BatchPutRequest, B as BatchResult, bA as BatchWriteRequest, a1 as BridgeBundle, bB as CONTRACT_RANGE_FANOUT_CONCURRENCY, C as CdcEmulatorOptions, a as CdcMode, bC as CdcModelRegistry, bD as CdcSubscribeHandlers, bE as Change, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, bF as CollectionEffect, bG as CollectionOptions, bH as Column, bI as ColumnMap, a4 as CommandContractMethodSpec, bJ as CommandInputShape, bK as CommandMethod, z as CommandMethodSpec, y as CommandModelContract, bL as CommandPlan, a5 as CommandResolutionTarget, bM as CommandResultKind, bN as CommandSelectShape, H as CommandSpec, a6 as CompiledFragment, a8 as ComposeSpec, g as ConcurrentRecomputeRef, bO as CondSlot, bP as ConditionCheckInput, X as ConditionInput, a2 as ConditionSpec, bQ as Connection, J as ContextSpec, bR as ContractCallSignature, aa as ContractCardinality, bS as ContractCommandParams, ab as ContractCommandResult, bT as ContractComposeNode, bU as ContractFromRef, ac as ContractInputArity, bV as ContractItem, bW as ContractKeyFieldRef, bX as ContractKeyInput, bY as ContractKeyRef, ad as ContractKeySpec, ae as ContractKind, bZ as ContractMethodOp, b_ as ContractParamRef, b$ as ContractQueryParams, af as ContractResolution, A as ContractSpec, c0 as CounterAggregate, c1 as CounterEffect, c2 as CtxBase, c3 as DEFAULT_MAX_ATTEMPTS, c4 as DEFAULT_RETRY_POLICY, c5 as DeleteOptions, c6 as DeriveEffect, ah as DerivedEdgeWrite, an as DerivedUpdate, c7 as DescriptorBinding, c8 as ENTITY_WRITES_MARKER, c9 as EdgeEffect, ca as EffectPath, cb as EmbeddedMetadata, cc as EmitEffect, O as EntityRef, cd as EntityWritesDefinition, ce as EntityWritesShape, E as EventLog, cf as ExecutableCommandContract, cg as ExecutableQueryContract, F as FaultSpec, ch as FilterInput, aq as FilterSpec, ci as FragmentCondition, cj as FragmentConditionOperatorObject, ck as FragmentInput, cl as GsiDefinitionMarker, cm as GsiOptions, cn as IdempotencyEffect, co as InProcessWriteDescriptor, cp as InlineSnapshotSpec, cq as InputArity, cr as KeyDefinitionMarker, cs as KeySegment, ct as KeySlot, cu as KeyStructure, cv as KeyedResult, cw as LIFECYCLE_CONTRACT_MARKER, cx as LifecycleContract, cy as LifecycleEffects, cz as LiteralParam, cA as MaintainItem, cB as MaintainTrigger, cC as MaintenanceGraph, as as ManifestEntity, at as ManifestField, au as ManifestFieldType, av as ManifestGsi, aw as ManifestKey, ax as ManifestRelation, ay as ManifestTable, cD as MembershipEffect, cE as ModelRef, cF as MutateMode, cG as MutateOptions, cH as MutateParallelResult, cI as MutateTransactionResult, cJ as MutationBody, cK as MutationDescriptorMap, cL as MutationFragment, cM as MutationInputProxy, cN as MutationInputRef, cO as MutationIntent, cP as NumberParam, cQ as OperationKind, az as OperationSpec, _ as OperationsDocument, cR as PREPARE_CACHE_MAX, cS as ParamKind, L as ParamSpec, cT as ParamStructure, cU as PersistCtx, cV as PersistOrigin, cW as PlannedCommandMethod, cX as PreparedInputProxy, cY as PreparedParamRef, cZ as PreparedReadExecOptions, c_ as PreparedReadRoute, c$ as PreparedReadStatement, d0 as PreparedWriteRoute, d1 as PreparedWriteStatement, d2 as ProjectionMap, d3 as ProjectionTransformOp, d4 as PutOptions, aA as QueryContractMethodSpec, d5 as QueryEnvelopeResult, d6 as QueryKeyOf, d7 as QueryMethod, x as QueryMethodSpec, Q as QueryModelContract, d8 as QueryResult, G as QuerySpec, aB as RangeConditionSpec, d9 as ReadEnvelope, da as ReadOpCtx, db as ReadOpKind, aC as ReadOperationType, dc as ReadRouteDescriptor, dd as ReadRouteOptions, de as ReadRouteResult, df as RecordedCompose, dg as RelationBuilder, dh as RelationConsistency, di as RelationLimitOptions, dj as RelationPattern, dk as RelationProjection, dl as RelationReadOptions, dm as RelationSelect, dn as RelationSpec, dp as RelationUpdateMode, dq as RelationWriteOptions, R as ReplayOptions, dr as RequiresEffect, ds as Resolution, dt as RetryInfo, du as RetryOperationKind, K as SPEC_VERSION, dv as SegmentSpec, dw as SegmentedKey, dx as SelectBuilder, dy as SelectOf, S as ShardId, dz as SnapshotEffect, h as StartingPosition, i as StreamViewType, dA as StringParam, j as SubscribeHandler, k as SubscribeHandlers, dB as TransactionContext, aE as TransactionItemType, dC as UniqueEffect, dD as Updatable, dE as UpdateOptions, dF as ViewSourceSlice, aF as WhenSpec, dG as WriteCtx, dH as WriteDescriptor, dI as WriteEnvelope, dJ as WriteInput, dK as WriteKind, dL as WriteLifecyclePhase, dM as WriteMiddleware, aG as WriteOperationType, dN as WriteRecorder, dO as WriteResultProjection, dP as attachModelClass, dQ as buildDeleteInput, dR as buildMaintenanceGraph, dS as buildPutInput, l as buildSubscribeHandler, dT as buildUpdateInput, dU as collectViewDefinitions, aI as compileFragment, aJ as compileMutationPlan, aK as compileSingleFragmentPlan, dV as cond, dW as contractOfMethodSpec, dX as definePlan, dY as entityWrites, dZ as executeBatchGet, d_ as executeBatchWrite, d$ as executeCommandMethod, e0 as executeDelete, e1 as executeKeyedBatchGet, e2 as executePut, e3 as executeQueryMethod, e4 as executeRangeFanout, e5 as executeTransaction, e6 as executeUpdate, e7 as from, e8 as getEntityWrites, e9 as gsi, ea as identity, eb as isColumn, ec as isCommandModelContract, ed as isCommandPlan, ee as isContractComposeNode, ef as isContractFromRef, eg as isContractKeyFieldRef, eh as isContractKeyRef, ei as isContractParamRef, ej as isEntityWritesDefinition, ek as isKeySegment, el as isLifecycleContract, em as isMaintainTrigger, en as isMutationFragment, eo as isMutationInputRef, ep as isParam, eq as isPlannedCommandMethod, er as isPreparedParamRef, es as isQueryModelContract, et as isRetryableError, eu as isRetryableTransactionCancellation, ev as k, ew as key, ex as lifecyclePhaseForIntent, ey as maintainTrigger, ez as mintContractKeyFieldRef, eA as mintContractParamRef, eB as mutation, eC as param, eD as prepare, eE as preview, eF as publicCommandModel, eG as publicQueryModel, eH as query, aM as resolveLifecycle, eI as wholeKeysSentinel } from './maintenance-view-adapter-BATUh_I8.js';
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-export { C as CdcEmulator, M as MAINT_OUTBOX_PK_PREFIX, a as MaintenanceDrain, b as MaintenanceDrainOptions, c as createCdcEmulator, d as createMaintenanceDrain, e as createMaintenanceDrainHandler, p as parseChange } from './from-change-D2zFApzb.js';
-import { P as PreparedWriteOpSpec, a as PreparedPlanDocument } from './index-BnTZQ_IG.js';
-export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, b as ContextOwnershipMap, c as ContractBoundaryViolation, d as ContractInputs, e as ContractMap, f as ContractN1Violation, g as PreparedBindSpec, h as PreparedPlanSpec, i as PreparedReadRouteSpec, T as TransactionDefinition, j as TransactionParamShape, k as TransactionRef, l as TxConditionCheckOptions, m as TxForEachInstruction, n as TxForEachOptions, o as TxInstruction, p as TxRecorder, q as TxWriteInstruction, r as TxWriteOptions, W as WhenComparison, s as assertBundleSerializable, t as assertContractBoundaries, u as assertContractN1Safe, v as assertJsonSerializable, w as assertSupportedCondition, x as buildBridgeBundle, y as buildContexts, z as buildContracts, D as buildManifest, E as buildOperations, F as buildQuerySpec, G as buildTransactionSpec, H as buildTransactions, I as collectContractBoundaryViolations, J as collectContractN1Violations, K as defineTransaction, L as defineTransactions, M as isTransactionRef, N as when } from './index-BnTZQ_IG.js';
-export { c as createDefaultLinter, g as gsiAmbiguityRule, m as missingGsiRule, n as noScanRule, q as queryBoundaryRule, r as relationDepthRule, a as requireLimitRule } from './relation-depth-BnqfKkZB.js';
+export { C as CdcEmulator, M as MAINT_OUTBOX_PK_PREFIX, a as MaintenanceDrain, b as MaintenanceDrainOptions, c as createCdcEmulator, d as createMaintenanceDrain, e as createMaintenanceDrainHandler, p as parseChange } from './from-change-DanwjE5b.js';
+import { P as PreparedWriteOpSpec, a as PreparedPlanDocument } from './index-CtPJSMrc.js';
+export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, b as ContextOwnershipMap, c as ContractBoundaryViolation, d as ContractInputs, e as ContractMap, f as ContractN1Violation, g as PreparedBindSpec, h as PreparedPlanSpec, i as PreparedReadRouteSpec, T as TransactionDefinition, j as TransactionParamShape, k as TransactionRef, l as TxConditionCheckOptions, m as TxForEachInstruction, n as TxForEachOptions, o as TxInstruction, p as TxRecorder, q as TxWriteInstruction, r as TxWriteOptions, W as WhenComparison, s as assertBundleSerializable, t as assertContractBoundaries, u as assertContractN1Safe, v as assertJsonSerializable, w as assertSupportedCondition, x as buildBridgeBundle, y as buildContexts, z as buildContracts, D as buildManifest, E as buildOperations, F as buildQuerySpec, G as buildTransactionSpec, H as buildTransactions, I as collectContractBoundaryViolations, J as collectContractN1Violations, K as defineTransaction, L as defineTransactions, M as isTransactionRef, N as when } from './index-CtPJSMrc.js';
+export { c as createDefaultLinter, g as gsiAmbiguityRule, m as missingGsiRule, n as noScanRule, q as queryBoundaryRule, r as relationDepthRule, a as requireLimitRule } from './relation-depth-Dg3yhl7S.js';
 
 /**
  * Query options with conditional `consistentRead` availability.
@@ -318,6 +318,113 @@ interface RelationExecutionPlan {
     readonly resultPaths: readonly string[];
 }
 
+interface QueryOptions {
+    consistentRead?: boolean;
+    maxDepth?: number;
+    /**
+     * Per-call throttle / transient-error retry override (issue #111), applied to the
+     * parent read AND to every relation-fan-out send under it. A {@link RetryPolicy}
+     * replaces the global policy for this call; `false` disables retry. Omit to use
+     * the configured (or built-in default) policy.
+     */
+    retry?: RetryOverride;
+    /**
+     * When `true`, the returned item carries its resolved base-table key as a
+     * non-enumerable Symbol property so it can be passed back to `update()`
+     * directly — even for a partial `select` or a GSI-based query. Host-side
+     * runtime behaviour only; not part of the serialized query.
+     */
+    updatable?: boolean;
+    /**
+     * Opt-in class / domain-object hydration (issue #53). When provided, the
+     * factory is applied as the **final after-fetch step** to the fully-built
+     * plain object (after projection, relation resolution, and any `updatable`
+     * hidden-key attachment) and its return value is what the read resolves to —
+     * the return type propagates from the factory (see `ModelStatic.query`).
+     *
+     * Semantics:
+     * - applied to a **present** item only; a `null` read stays `null` and the
+     *   factory is NOT invoked, so the factory need not be null-tolerant;
+     * - a throw from the factory propagates verbatim as the read's rejection
+     *   (the fetch already succeeded; the failure is purely in caller code);
+     * - synchronous by design — an async transform is a caller-side `await` on
+     *   the plain result, intentionally out of scope here.
+     *
+     * Host-side runtime behaviour ONLY: like `updatable` / `consistentRead`, the
+     * factory is a host-language closure that is NEVER serialized into the SSoT /
+     * `operations.json`, so it does not impede the multi-language bridge (#48).
+     * "What to fetch" stays declarative; "what object to load it onto" is host-side.
+     */
+    hydrate?: (raw: Record<string, unknown> | null) => unknown;
+    /**
+     * Host-injected per-call read context (issue #50 / #138) — exposed to every
+     * read hook (R1–R5) as `ctx.context`, and threaded UNCHANGED to every relation
+     * fan-out op so a hook (e.g. a tenant-scope R2 filter) applies across the root
+     * read AND the fan-out fetches. A host-language value, NEVER serialized into the
+     * SSoT / `operations.json` (the bridge #48 is unaffected). Absent ⇒ `{}`.
+     */
+    context?: RequestContext;
+}
+declare function executeQuery(modelClass: Function, key: Record<string, unknown>, selectSpec: Record<string, unknown>, options?: QueryOptions): Promise<Record<string, unknown> | null>;
+
+interface ListInput {
+    limit?: number;
+    after?: string;
+    order?: 'ASC' | 'DESC';
+    /** Declarative server-side DynamoDB FilterExpression input. */
+    filter?: Record<string, unknown>;
+    /**
+     * When `true`, each returned item carries its resolved base-table key as a
+     * non-enumerable Symbol property so it can be passed back to `update()`
+     * directly. Host-side runtime behaviour only; not part of the serialized
+     * query.
+     */
+    updatable?: boolean;
+    /**
+     * Per-call throttle / transient-error retry override (issue #111). A
+     * {@link RetryPolicy} replaces the global policy for this read; `false` disables
+     * retry. Omit to use the configured (or built-in default) policy.
+     */
+    retry?: RetryOverride;
+    /**
+     * Host-injected per-call read context (issue #50 / #138) — exposed to every
+     * read hook as `ctx.context`. Used only when this `list` is the read ENTRY
+     * point (the public `DDBModel.list` / a `list` envelope route): a fresh
+     * {@link MiddlewareRuntime} is built from it. Ignored when a relation fan-out
+     * threads an already-built {@link mw} (the runtime then carries the root read's
+     * context). Absent ⇒ `{}`.
+     */
+    context?: RequestContext;
+    /**
+     * @internal The per-read middleware runtime, threaded UNCHANGED from a relation
+     * fan-out (issue #138) so the hasMany Query's op-level hooks (R2/R3/R5) fire
+     * with the root read's context + the fan-out's {@link relationPath}. When absent
+     * at the entry point, one is built from {@link context}.
+     */
+    mw?: MiddlewareRuntime;
+    /**
+     * @internal The relation path to THIS list read — `[]` (or absent) for a
+     * top-level `list`; the fan-out leg (e.g. `['orders']`) for a hasMany Query.
+     * Populates the op-level ctx's `relationPath` (issue #138).
+     */
+    relationPath?: readonly string[];
+}
+/**
+ * Public list result returned by `DDBModel.list()`. Contains exactly the
+ * `items` and `cursor` keys — no `rawItems` leak.
+ */
+interface ListResult {
+    items: Record<string, unknown>[];
+    cursor: string | null;
+}
+/**
+ * Public list execution backing `DDBModel.list()`. Delegates to
+ * {@link executeListInternal} and constructs a fresh result object exposing
+ * only `{ items, cursor }`, so internal-only fields such as `rawItems` never
+ * cross the public API boundary (no reliance on `as` type narrowing).
+ */
+declare function executeList(modelClass: Function, key: Record<string, unknown>, selectSpec: Record<string, unknown>, options?: ListInput): Promise<ListResult>;
+
 declare function derivePrefix(customPrefix: string | undefined, className: string | undefined): string;
 
 /**
@@ -1062,113 +1169,6 @@ declare function expandTransaction(spec: TransactionSpec, manifest: Manifest, pa
  */
 declare function executeDeclarativeTransaction(spec: TransactionSpec, manifest: Manifest, params: Record<string, unknown>): Promise<void>;
 
-interface QueryOptions {
-    consistentRead?: boolean;
-    maxDepth?: number;
-    /**
-     * Per-call throttle / transient-error retry override (issue #111), applied to the
-     * parent read AND to every relation-fan-out send under it. A {@link RetryPolicy}
-     * replaces the global policy for this call; `false` disables retry. Omit to use
-     * the configured (or built-in default) policy.
-     */
-    retry?: RetryOverride;
-    /**
-     * When `true`, the returned item carries its resolved base-table key as a
-     * non-enumerable Symbol property so it can be passed back to `update()`
-     * directly — even for a partial `select` or a GSI-based query. Host-side
-     * runtime behaviour only; not part of the serialized query.
-     */
-    updatable?: boolean;
-    /**
-     * Opt-in class / domain-object hydration (issue #53). When provided, the
-     * factory is applied as the **final after-fetch step** to the fully-built
-     * plain object (after projection, relation resolution, and any `updatable`
-     * hidden-key attachment) and its return value is what the read resolves to —
-     * the return type propagates from the factory (see `ModelStatic.query`).
-     *
-     * Semantics:
-     * - applied to a **present** item only; a `null` read stays `null` and the
-     *   factory is NOT invoked, so the factory need not be null-tolerant;
-     * - a throw from the factory propagates verbatim as the read's rejection
-     *   (the fetch already succeeded; the failure is purely in caller code);
-     * - synchronous by design — an async transform is a caller-side `await` on
-     *   the plain result, intentionally out of scope here.
-     *
-     * Host-side runtime behaviour ONLY: like `updatable` / `consistentRead`, the
-     * factory is a host-language closure that is NEVER serialized into the SSoT /
-     * `operations.json`, so it does not impede the multi-language bridge (#48).
-     * "What to fetch" stays declarative; "what object to load it onto" is host-side.
-     */
-    hydrate?: (raw: Record<string, unknown> | null) => unknown;
-    /**
-     * Host-injected per-call read context (issue #50 / #138) — exposed to every
-     * read hook (R1–R5) as `ctx.context`, and threaded UNCHANGED to every relation
-     * fan-out op so a hook (e.g. a tenant-scope R2 filter) applies across the root
-     * read AND the fan-out fetches. A host-language value, NEVER serialized into the
-     * SSoT / `operations.json` (the bridge #48 is unaffected). Absent ⇒ `{}`.
-     */
-    context?: RequestContext;
-}
-declare function executeQuery(modelClass: Function, key: Record<string, unknown>, selectSpec: Record<string, unknown>, options?: QueryOptions): Promise<Record<string, unknown> | null>;
-
-interface ListInput {
-    limit?: number;
-    after?: string;
-    order?: 'ASC' | 'DESC';
-    /** Declarative server-side DynamoDB FilterExpression input. */
-    filter?: Record<string, unknown>;
-    /**
-     * When `true`, each returned item carries its resolved base-table key as a
-     * non-enumerable Symbol property so it can be passed back to `update()`
-     * directly. Host-side runtime behaviour only; not part of the serialized
-     * query.
-     */
-    updatable?: boolean;
-    /**
-     * Per-call throttle / transient-error retry override (issue #111). A
-     * {@link RetryPolicy} replaces the global policy for this read; `false` disables
-     * retry. Omit to use the configured (or built-in default) policy.
-     */
-    retry?: RetryOverride;
-    /**
-     * Host-injected per-call read context (issue #50 / #138) — exposed to every
-     * read hook as `ctx.context`. Used only when this `list` is the read ENTRY
-     * point (the public `DDBModel.list` / a `list` envelope route): a fresh
-     * {@link MiddlewareRuntime} is built from it. Ignored when a relation fan-out
-     * threads an already-built {@link mw} (the runtime then carries the root read's
-     * context). Absent ⇒ `{}`.
-     */
-    context?: RequestContext;
-    /**
-     * @internal The per-read middleware runtime, threaded UNCHANGED from a relation
-     * fan-out (issue #138) so the hasMany Query's op-level hooks (R2/R3/R5) fire
-     * with the root read's context + the fan-out's {@link relationPath}. When absent
-     * at the entry point, one is built from {@link context}.
-     */
-    mw?: MiddlewareRuntime;
-    /**
-     * @internal The relation path to THIS list read — `[]` (or absent) for a
-     * top-level `list`; the fan-out leg (e.g. `['orders']`) for a hasMany Query.
-     * Populates the op-level ctx's `relationPath` (issue #138).
-     */
-    relationPath?: readonly string[];
-}
-/**
- * Public list result returned by `DDBModel.list()`. Contains exactly the
- * `items` and `cursor` keys — no `rawItems` leak.
- */
-interface ListResult {
-    items: Record<string, unknown>[];
-    cursor: string | null;
-}
-/**
- * Public list execution backing `DDBModel.list()`. Delegates to
- * {@link executeListInternal} and constructs a fresh result object exposing
- * only `{ items, cursor }`, so internal-only fields such as `rawItems` never
- * cross the public API boundary (no reliance on `as` type narrowing).
- */
-declare function executeList(modelClass: Function, key: Record<string, unknown>, selectSpec: Record<string, unknown>, options?: ListInput): Promise<ListResult>;
-
 interface ExplainInput {
     select?: Record<string, unknown>;
     limit?: number;
@@ -1375,10 +1375,20 @@ interface PerKeyCursorEnvelope {
 /**
  * Canonical, cross-runtime-stable string identity of a contract key. Object
  * fields are sorted by name so `{ a, b }` and `{ b, a }` serialize identically;
- * values are emitted via `JSON.stringify`, matching the Python runtime's
+ * values are emitted as compact JSON, matching the Python runtime's
  * `serialize_contract_key` (sorted items, compact separators). This is the
  * identity used to key a batch result map and to bind a per-key cursor.
  *
+ * **#253 adapter (behavior-contracts)**: this is the shared COMMON
+ * `canonicalValue` primitive (runtime-boundary.md §2.1 →
+ * canonical-serialization.md §2: key identity = top-level key sort + compact
+ * JSON), the same delegation the Python / Rust / Go runtimes adopted in #255.
+ * graphddb's former field-sorted `JSON.stringify` is deleted; plain JS key
+ * values cross the boundary through {@link toSharedValue} (integral `number` →
+ * shared int, `Date` → ISO string, `undefined` fields dropped — the exact
+ * `JSON.stringify` semantics the old implementation had). Byte identity of the
+ * output is locked by the frozen #253 conformance golden.
+ *
  * @param key A plain contract-key object (e.g. `{ categoryId: 'tech' }`).
  * @returns A deterministic JSON string, e.g. `{"categoryId":"tech"}`.
  */
@@ -2011,6 +2021,8 @@ declare function createMaintenanceRebuilder(opts?: MaintenanceRebuildOptions): M
 
 /** Scalar leaf types that may be replaced by a {@link Param} placeholder. */
 type Replaceable = string | number;
+/** `null` / `undefined` — peeled off an optional leaf before the scalar test. */
+type Nullish = null | undefined;
 /**
  * Relaxes an input type `K` so each scalar leaf additionally accepts a
  * {@link Param} standing in for that leaf's value type. Non-scalar leaves and
@@ -2019,8 +2031,25 @@ type Replaceable = string | number;
  *
  * A leaf of type `V` becomes `V | Param<V>`; a `string` literal field that is a
  * fixed discriminator (no param) is still assignable as its literal.
- */
-type Parameterize<K> = K extends Replaceable ? K | Param<K> : K extends object ? {
+ *
+ * The scalar test is written with a **tuple wrap** (`[…] extends […]`) so it does
+ * **not** distribute over a literal-union leaf. A field typed `'a' | 'b'`
+ * therefore yields the whole-union placeholder `Param<'a' | 'b'>` (what
+ * `param.literal('a','b')` produces) rather than the distributed
+ * `Param<'a'> | Param<'b'>`, which rejected the multi-value literal param (#246).
+ * Because `Param` is covariant in its value type, a single-member placeholder
+ * (`param.literal('a')` → `Param<'a'>`) still fits, while a placeholder carrying a
+ * value **outside** the union (`Param<'a' | 'x'>`), a wider-typed placeholder
+ * (`Param<string>` / `Param<number>` on a literal field), or a plain literal not
+ * in the union stays a type error.
+ *
+ * `null` / `undefined` are peeled off first (via `Exclude`/`Extract`) and carried
+ * through verbatim, so an **optional** leaf (`Partial<EntityInput>` in
+ * `defineUpdate` changes) keeps accepting its placeholder — the tuple wrap alone
+ * would otherwise send `string | undefined` down the object arm and drop the
+ * placeholder.
+ */
+type Parameterize<K> = [Exclude<K, Nullish>] extends [Replaceable] ? [Exclude<K, Nullish>] extends [never] ? K : Exclude<K, Nullish> | Param<Exclude<K, Nullish>> | Extract<K, Nullish> : K extends object ? {
     [P in keyof K]: Parameterize<K[P]>;
 } : K;
 /**

package/dist/index.js

@@ -90,7 +90,7 @@ import {
   validateDepth,
   when,
   wholeKeysSentinel
-} from "./chunk-WPABX7WG.js";
+} from "./chunk-NYM7K2ST.js";
 import {
   CdcEmulator,
   MAINT_OUTBOX_PK_PREFIX,
@@ -102,7 +102,7 @@ import {
   orderAndTrimCollection,
   pathField,
   projectFrom
-} from "./chunk-5NXNEW43.js";
+} from "./chunk-ZPNRLOKA.js";
 import {
   BATCH_GET_MAX_KEYS,
   BATCH_WRITE_MAX_ITEMS,
@@ -157,7 +157,7 @@ import {
   resolveConditionTree,
   resolveModelClass,
   serializeFieldValue
-} from "./chunk-F2DI3GTI.js";
+} from "./chunk-PFFPLD4B.js";
 import {
   Linter,
   TableMapping,
@@ -742,32 +742,86 @@ function cdcProjected() {
   };
 }
 
+// src/operations/declarative-transaction.ts
+import { renderTemplate, TemplateFailure } from "behavior-contracts";
+
+// src/runtime/behavior-contracts-adapter.ts
+function toSharedValue(v) {
+  if (v === null || v === void 0) return null;
+  switch (typeof v) {
+    case "string":
+    case "boolean":
+    case "bigint":
+      return v;
+    case "number":
+      return Number.isInteger(v) ? BigInt(v) : v;
+    default:
+      break;
+  }
+  if (v instanceof Date) return v.toJSON();
+  if (Array.isArray(v)) return v.map((e) => toSharedValue(e));
+  if (typeof v === "object") {
+    const out = {};
+    for (const [k2, field2] of Object.entries(v)) {
+      if (field2 === void 0) continue;
+      out[k2] = toSharedValue(field2);
+    }
+    return out;
+  }
+  return v;
+}
+function toSharedParams(params) {
+  const out = {};
+  for (const [name, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    out[name] = toSharedValue(value);
+  }
+  return out;
+}
+
 // src/operations/declarative-transaction.ts
 var PLACEHOLDER_RE = /\{[^{}]+\}/g;
+function hasNonCoreScope(template) {
+  return (template.match(PLACEHOLDER_RE) ?? []).some((m) => {
+    const name = m.slice(1, -1);
+    return name.startsWith("item.") || name.startsWith("result.");
+  });
+}
 function resolveTemplate(template, params, element) {
-  return template.replace(PLACEHOLDER_RE, (match) => {
-    const name = match.slice(1, -1);
-    if (name.startsWith("item.")) {
-      const field2 = name.slice("item.".length);
-      if (!element || !(field2 in element)) {
+  if (hasNonCoreScope(template)) {
+    return template.replace(PLACEHOLDER_RE, (match) => {
+      const name = match.slice(1, -1);
+      if (name.startsWith("item.")) {
+        const field2 = name.slice("item.".length);
+        if (!element || !(field2 in element)) {
+          throw new Error(
+            `declarative transaction: element field '${field2}' is not bound; template '${template}' is only valid inside a forEach over the array param that supplies '${field2}'.`
+          );
+        }
+        return String(element[field2]);
+      }
+      if (!(name in params) || params[name] === void 0 || params[name] === null) {
         throw new Error(
-          `declarative transaction: element field '${field2}' is not bound; template '${template}' is only valid inside a forEach over the array param that supplies '${field2}'.`
+          `declarative transaction: template '${template}' references unbound parameter '${name}'.`
         );
       }
-      return String(element[field2]);
-    }
-    if (!(name in params) || params[name] === void 0 || params[name] === null) {
-      throw new Error(
-        `declarative transaction: template '${template}' references unbound parameter '${name}'.`
-      );
+      return String(params[name]);
+    });
+  }
+  try {
+    return renderTemplate(template, toSharedParams(params));
+  } catch (exc) {
+    if (exc instanceof TemplateFailure && exc.code === "UNBOUND_PARAM") {
+      throw new Error(`declarative transaction: ${exc.message}.`);
     }
-    return String(params[name]);
-  });
+    throw exc;
+  }
 }
 function isWholePlaceholder(template) {
   return /^\{[^{}]+\}$/.test(template);
 }
 function resolveValue(template, params, element) {
+  if (typeof template !== "string") return template;
   if (isWholePlaceholder(template)) {
     const name = template.slice(1, -1);
     if (name.startsWith("item.")) {
@@ -1079,9 +1133,9 @@ async function executeDeclarativeTransaction(spec, manifest, params) {
 }
 
 // src/runtime/per-key-cursor.ts
+import { canonicalValue } from "behavior-contracts";
 function serializeContractKey(key2) {
-  const sortedEntries = Object.keys(key2).sort().map((field2) => [field2, key2[field2]]);
-  return JSON.stringify(Object.fromEntries(sortedEntries));
+  return canonicalValue(toSharedValue(key2));
 }
 function encodePerKeyCursor(key2, inner) {
   if (inner === null) return null;
@@ -1290,6 +1344,7 @@ async function executeRangeFanout(op, keys, params = {}) {
 }
 
 // src/runtime/prepared-loader.ts
+import { validateEnvelope, EnvelopeFailure } from "behavior-contracts";
 var LOAD_LABEL = "graphddb.loadPreparedPlan";
 function slotOfBind(bind) {
   if ("param" in bind) return { kind: "param", name: bind.param };
@@ -1489,10 +1544,15 @@ function bindPlan(doc, planId) {
       `${LOAD_LABEL}: unsupported artifact format version '${String(doc.formatVersion)}' (this runtime supports '${PREPARED_FORMAT_VERSION}'). Regenerate the artifact: \`graphddb transform prepared --aot <artifact> --write\`.`
     );
   }
-  if (doc.specVersion !== SPEC_VERSION) {
-    throw new Error(
-      `${LOAD_LABEL}: the artifact was compiled against operation-IR version '${String(doc.specVersion)}' but this runtime speaks '${SPEC_VERSION}'. A version-skewed static plan never executes \u2014 regenerate the artifact.`
-    );
+  try {
+    validateEnvelope(doc, SPEC_VERSION, { field: "specVersion", label: LOAD_LABEL });
+  } catch (exc) {
+    if (exc instanceof EnvelopeFailure) {
+      throw new Error(
+        `${LOAD_LABEL}: the artifact was compiled against operation-IR version '${String(doc.specVersion)}' but this runtime speaks '${SPEC_VERSION}'. A version-skewed static plan never executes \u2014 regenerate the artifact.`
+      );
+    }
+    throw exc;
   }
   const plan2 = doc.plans[planId];
   if (plan2 === void 0) {

package/dist/linter/index.d.ts

@@ -1,7 +1,7 @@
-import { L as LintRule } from '../registry-DWhq5wiA.js';
-export { a as LintResult, b as Linter } from '../registry-DWhq5wiA.js';
-export { c as createDefaultLinter, g as gsiAmbiguityRule, m as missingGsiRule, n as noScanRule, q as queryBoundaryRule, r as relationDepthRule, a as requireLimitRule } from '../relation-depth-BnqfKkZB.js';
-import '../maintenance-view-adapter-C1HaBX4y.js';
+import { L as LintRule } from '../registry-CXhP4TaE.js';
+export { a as LintResult, b as Linter } from '../registry-CXhP4TaE.js';
+export { c as createDefaultLinter, g as gsiAmbiguityRule, m as missingGsiRule, n as noScanRule, q as queryBoundaryRule, r as relationDepthRule, a as requireLimitRule } from '../relation-depth-Dg3yhl7S.js';
+import '../maintenance-view-adapter-BATUh_I8.js';
 import '@aws-sdk/client-dynamodb';
 
 /**