graphddb 0.5.3 → 0.6.0

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-export { a as LintResult, L as LintRule, b as Linter, M as MetadataRegistry } from './registry-BD_5Rm5C.js';
-import { aN as SelectableOf, aO as PrimaryKeyOf, aP as RequestContext, aQ as Middleware, aR as ReadRequestKind, aS as CtxModel, aT as ReadParams, aU as ReadRequestCtx, D as DynamoDBOperation, aV as Item, n as Executor, aW as RetryPolicy, am as ExecutionPlanSpec, aX as KeyDefinition, aY as GsiDefinition, aZ as ModelKind, a_ as FieldOptions, a$ as DynamoType, b0 as ProjectionTransform, b1 as MaintainEvent, b2 as MembershipPredicate, b3 as MaintainConsistency, b4 as MaintainUpdateMode, b5 as MembershipPredicateOp, b6 as RelationOptions, b7 as AggregateOptions, b8 as AggregateValue, b9 as SelectBuilderSpec, ba as RawCondition, m as EntityMetadata, N as TransactionSpec, _ as Manifest, bb as RetryOverride, bc as ExecutionPlan, bd as FieldMetadata, be 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, bf as RelationMetadata, aC as TransactionItemSpec, bg as MaintainEffect, M as ModelStatic, w as DDBModel, V as ViewDefinition, A as Param, x as ParamDescriptor, X as DefinitionMap, bh as OperationDefinition, bi as WriteDefinitionOptions, bj as PartialQueryKeyOf, bk as StrictSelectSpec, bl as ReadDefinitionOptions, bm as EntityInput, bn as UniqueQueryKeyOf } from './maintenance-view-adapter-D5t9taTE.js';
-export { bo as AggregateMetadata, Z as AnyOperationDefinition, bp as BatchDeleteRequest, bq as BatchGetOptions, br as BatchGetRequest, bs as BatchGetResult, bt as BatchPutRequest, B as BatchResult, bu as BatchWriteRequest, $ as BridgeBundle, bv as CONTRACT_RANGE_FANOUT_CONCURRENCY, C as CdcEmulatorOptions, a as CdcMode, bw as CdcModelRegistry, bx as CdcSubscribeHandlers, by as Change, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, bz as CollectionEffect, bA as CollectionOptions, bB as Column, bC as ColumnMap, a1 as CommandContractMethodSpec, bD as CommandInputShape, bE as CommandMethod, I as CommandMethodSpec, H as CommandModelContract, bF as CommandPlan, a2 as CommandResolutionTarget, bG as CommandResultKind, bH as CommandSelectShape, L as CommandSpec, a3 as CompiledFragment, a5 as ComposeSpec, g as ConcurrentRecomputeRef, bI as CondSlot, bJ as ConditionCheckInput, z as ConditionInput, a0 as ConditionSpec, bK as Connection, O as ContextSpec, bL as ContractCallSignature, a7 as ContractCardinality, bM as ContractCommandParams, a8 as ContractCommandResult, bN as ContractComposeNode, bO as ContractFromRef, a9 as ContractInputArity, bP as ContractItem, bQ as ContractKeyFieldRef, bR as ContractKeyInput, bS as ContractKeyRef, aa as ContractKeySpec, ab as ContractKind, bT as ContractMethodOp, bU as ContractParamRef, bV as ContractQueryParams, ac as ContractResolution, J as ContractSpec, bW as CounterAggregate, bX as CounterEffect, bY as CtxBase, bZ as DEFAULT_MAX_ATTEMPTS, b_ as DEFAULT_RETRY_POLICY, b$ as DeleteOptions, c0 as DeriveEffect, ae as DerivedEdgeWrite, ak as DerivedUpdate, c1 as DescriptorBinding, c2 as ENTITY_WRITES_MARKER, c3 as EdgeEffect, c4 as EffectPath, c5 as EmbeddedMetadata, c6 as EmitEffect, y as EntityRef, c7 as EntityWritesDefinition, c8 as EntityWritesShape, E as EventLog, c9 as ExecutableCommandContract, ca as ExecutableQueryContract, F as FaultSpec, cb as FilterInput, an as FilterSpec, cc as FragmentInput, cd as GsiDefinitionMarker, ce as GsiOptions, cf as IdempotencyEffect, cg as InProcessWriteDescriptor, ch as InputArity, ci as KeyDefinitionMarker, cj as KeySegment, ck as KeySlot, cl as KeyStructure, cm as KeyedResult, cn as LIFECYCLE_CONTRACT_MARKER, co as LifecycleContract, cp as LifecycleEffects, cq as LiteralParam, cr as MaintainItem, cs as MaintainTrigger, ct as MaintenanceGraph, ap as ManifestEntity, aq as ManifestField, ar as ManifestFieldType, as as ManifestGsi, at as ManifestKey, au as ManifestRelation, av as ManifestTable, cu as MembershipEffect, cv as ModelRef, cw as MutateMode, cx as MutateOptions, cy as MutateParallelResult, cz as MutateTransactionResult, cA as MutationBody, cB as MutationDescriptorMap, cC as MutationFragment, cD as MutationInputProxy, cE as MutationInputRef, cF as MutationIntent, cG as NumberParam, cH as OperationKind, aw as OperationSpec, Y as OperationsDocument, cI as ParallelOpResult, cJ as ParamKind, ax as ParamSpec, cK as ParamStructure, cL as PersistCtx, cM as PersistOrigin, cN as PlannedCommandMethod, cO as ProjectionMap, cP as ProjectionTransformOp, cQ as PutOptions, ay as QueryContractMethodSpec, cR as QueryEnvelopeResult, cS as QueryKeyOf, cT as QueryMethod, G as QueryMethodSpec, Q as QueryModelContract, cU as QueryResult, K as QuerySpec, az as RangeConditionSpec, cV as ReadEnvelope, cW as ReadOpCtx, cX as ReadOpKind, aA as ReadOperationType, cY as ReadRouteDescriptor, cZ as ReadRouteOptions, c_ as ReadRouteResult, c$ as RecordedCompose, d0 as RelationBuilder, d1 as RelationConsistency, d2 as RelationLimitOptions, d3 as RelationPattern, d4 as RelationProjection, d5 as RelationReadOptions, d6 as RelationSelect, d7 as RelationSpec, d8 as RelationUpdateMode, d9 as RelationWriteOptions, R as ReplayOptions, da as RequiresEffect, db as Resolution, dc as RetryInfo, dd as RetryOperationKind, aB as SPEC_VERSION, de as SegmentSpec, df as SegmentedKey, dg as SelectBuilder, dh as SelectOf, S as ShardId, di as SnapshotEffect, h as StartingPosition, i as StreamViewType, dj as StringParam, j as SubscribeHandler, k as SubscribeHandlers, dk as TransactionContext, aD as TransactionItemType, dl as UniqueEffect, dm as Updatable, dn as UpdateOptions, dp as ViewSourceSlice, aE as WhenSpec, dq as WriteCtx, dr as WriteDescriptor, ds as WriteEnvelope, dt as WriteInput, du as WriteKind, dv as WriteLifecyclePhase, dw as WriteMiddleware, aF as WriteOperationType, dx as WriteRecorder, dy as WriteResultProjection, dz as attachModelClass, dA as buildDeleteInput, dB as buildMaintenanceGraph, dC as buildPutInput, l as buildSubscribeHandler, dD as buildUpdateInput, dE as collectViewDefinitions, aH as compileFragment, aI as compileMutationPlan, aJ as compileSingleFragmentPlan, dF as cond, dG as contractOfMethodSpec, dH as definePlan, dI as entityWrites, dJ as executeBatchGet, dK as executeBatchWrite, dL as executeCommandMethod, dM as executeDelete, dN as executeKeyedBatchGet, dO as executePut, dP as executeQueryMethod, dQ as executeRangeFanout, dR as executeTransaction, dS as executeUpdate, dT as from, dU as getEntityWrites, dV as gsi, dW as identity, dX as isColumn, dY as isCommandModelContract, dZ as isCommandPlan, d_ as isContractComposeNode, d$ as isContractFromRef, e0 as isContractKeyFieldRef, e1 as isContractKeyRef, e2 as isContractParamRef, e3 as isEntityWritesDefinition, e4 as isKeySegment, e5 as isLifecycleContract, e6 as isMaintainTrigger, e7 as isMutationFragment, e8 as isMutationInputRef, e9 as isParam, ea as isPlannedCommandMethod, eb as isQueryModelContract, ec as isRetryableError, ed as isRetryableTransactionCancellation, ee as k, ef as key, eg as lifecyclePhaseForIntent, eh as maintainTrigger, ei as mintContractKeyFieldRef, ej as mintContractParamRef, ek as mutation, el as param, em as preview, en as publicCommandModel, eo as publicQueryModel, ep as query, aL as resolveLifecycle, eq as wholeKeysSentinel } from './maintenance-view-adapter-D5t9taTE.js';
+export { a as LintResult, L as LintRule, b as Linter, M as MetadataRegistry } from './registry-DbqmFyab.js';
+import { aN as SelectableOf, aO as PrimaryKeyOf, aP as RequestContext, aQ as Middleware, aR as ReadRequestKind, aS as CtxModel, aT as ReadParams, aU as ReadRequestCtx, D as DynamoDBOperation, aV as Item, n as Executor, aW as RetryPolicy, am as ExecutionPlanSpec, aX as KeyDefinition, aY as GsiDefinition, aZ as ModelKind, a_ as FieldOptions, a$ as DynamoType, b0 as ProjectionTransform, b1 as MaintainEvent, b2 as MembershipPredicate, b3 as MaintainConsistency, b4 as MaintainUpdateMode, b5 as MembershipPredicateOp, b6 as RelationOptions, b7 as AggregateOptions, b8 as AggregateValue, b9 as SelectBuilderSpec, ba as RawCondition, m as EntityMetadata, N as TransactionSpec, _ as Manifest, bb as RetryOverride, bc as ExecutionPlan, bd as FieldMetadata, be 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, bf as RelationMetadata, aC as TransactionItemSpec, bg as MaintainEffect, M as ModelStatic, w as DDBModel, V as ViewDefinition, A as Param, x as ParamDescriptor, X as DefinitionMap, bh as OperationDefinition, bi as WriteDefinitionOptions, bj as PartialQueryKeyOf, bk as StrictSelectSpec, bl as ReadDefinitionOptions, bm as EntityInput, bn as UniqueQueryKeyOf } from './maintenance-view-adapter-CFeasCKo.js';
+export { bo as AggregateMetadata, Z as AnyOperationDefinition, bp as BatchDeleteRequest, bq as BatchGetOptions, br as BatchGetRequest, bs as BatchGetResult, bt as BatchPutRequest, B as BatchResult, bu as BatchWriteRequest, $ as BridgeBundle, bv as CONTRACT_RANGE_FANOUT_CONCURRENCY, C as CdcEmulatorOptions, a as CdcMode, bw as CdcModelRegistry, bx as CdcSubscribeHandlers, by as Change, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, bz as CollectionEffect, bA as CollectionOptions, bB as Column, bC as ColumnMap, a1 as CommandContractMethodSpec, bD as CommandInputShape, bE as CommandMethod, I as CommandMethodSpec, H as CommandModelContract, bF as CommandPlan, a2 as CommandResolutionTarget, bG as CommandResultKind, bH as CommandSelectShape, L as CommandSpec, a3 as CompiledFragment, a5 as ComposeSpec, g as ConcurrentRecomputeRef, bI as CondSlot, bJ as ConditionCheckInput, z as ConditionInput, a0 as ConditionSpec, bK as Connection, O as ContextSpec, bL as ContractCallSignature, a7 as ContractCardinality, bM as ContractCommandParams, a8 as ContractCommandResult, bN as ContractComposeNode, bO as ContractFromRef, a9 as ContractInputArity, bP as ContractItem, bQ as ContractKeyFieldRef, bR as ContractKeyInput, bS as ContractKeyRef, aa as ContractKeySpec, ab as ContractKind, bT as ContractMethodOp, bU as ContractParamRef, bV as ContractQueryParams, ac as ContractResolution, J as ContractSpec, bW as CounterAggregate, bX as CounterEffect, bY as CtxBase, bZ as DEFAULT_MAX_ATTEMPTS, b_ as DEFAULT_RETRY_POLICY, b$ as DeleteOptions, c0 as DeriveEffect, ae as DerivedEdgeWrite, ak as DerivedUpdate, c1 as DescriptorBinding, c2 as ENTITY_WRITES_MARKER, c3 as EdgeEffect, c4 as EffectPath, c5 as EmbeddedMetadata, c6 as EmitEffect, y as EntityRef, c7 as EntityWritesDefinition, c8 as EntityWritesShape, E as EventLog, c9 as ExecutableCommandContract, ca as ExecutableQueryContract, F as FaultSpec, cb as FilterInput, an as FilterSpec, cc as FragmentInput, cd as GsiDefinitionMarker, ce as GsiOptions, cf as IdempotencyEffect, cg as InProcessWriteDescriptor, ch as InlineSnapshotSpec, ci as InputArity, cj as KeyDefinitionMarker, ck as KeySegment, cl as KeySlot, cm as KeyStructure, cn as KeyedResult, co as LIFECYCLE_CONTRACT_MARKER, cp as LifecycleContract, cq as LifecycleEffects, cr as LiteralParam, cs as MaintainItem, ct as MaintainTrigger, cu as MaintenanceGraph, ap as ManifestEntity, aq as ManifestField, ar as ManifestFieldType, as as ManifestGsi, at as ManifestKey, au as ManifestRelation, av as ManifestTable, cv as MembershipEffect, cw as ModelRef, cx as MutateMode, cy as MutateOptions, cz as MutateParallelResult, cA as MutateTransactionResult, cB as MutationBody, cC as MutationDescriptorMap, cD as MutationFragment, cE as MutationInputProxy, cF as MutationInputRef, cG as MutationIntent, cH as NumberParam, cI as OperationKind, aw as OperationSpec, Y as OperationsDocument, cJ as ParallelOpResult, cK as ParamKind, ax as ParamSpec, cL as ParamStructure, cM as PersistCtx, cN as PersistOrigin, cO as PlannedCommandMethod, cP as ProjectionMap, cQ as ProjectionTransformOp, cR as PutOptions, ay as QueryContractMethodSpec, cS as QueryEnvelopeResult, cT as QueryKeyOf, cU as QueryMethod, G as QueryMethodSpec, Q as QueryModelContract, cV as QueryResult, K as QuerySpec, az as RangeConditionSpec, cW as ReadEnvelope, cX as ReadOpCtx, cY as ReadOpKind, aA as ReadOperationType, cZ as ReadRouteDescriptor, c_ as ReadRouteOptions, c$ as ReadRouteResult, d0 as RecordedCompose, d1 as RelationBuilder, d2 as RelationConsistency, d3 as RelationLimitOptions, d4 as RelationPattern, d5 as RelationProjection, d6 as RelationReadOptions, d7 as RelationSelect, d8 as RelationSpec, d9 as RelationUpdateMode, da as RelationWriteOptions, R as ReplayOptions, db as RequiresEffect, dc as Resolution, dd as RetryInfo, de as RetryOperationKind, aB as SPEC_VERSION, df as SegmentSpec, dg as SegmentedKey, dh as SelectBuilder, di as SelectOf, S as ShardId, dj as SnapshotEffect, h as StartingPosition, i as StreamViewType, dk as StringParam, j as SubscribeHandler, k as SubscribeHandlers, dl as TransactionContext, aD as TransactionItemType, dm as UniqueEffect, dn as Updatable, dp as UpdateOptions, dq as ViewSourceSlice, aE as WhenSpec, dr as WriteCtx, ds as WriteDescriptor, dt as WriteEnvelope, du as WriteInput, dv as WriteKind, dw as WriteLifecyclePhase, dx as WriteMiddleware, aF as WriteOperationType, dy as WriteRecorder, dz as WriteResultProjection, dA as attachModelClass, dB as buildDeleteInput, dC as buildMaintenanceGraph, dD as buildPutInput, l as buildSubscribeHandler, dE as buildUpdateInput, dF as collectViewDefinitions, aH as compileFragment, aI as compileMutationPlan, aJ as compileSingleFragmentPlan, dG as cond, dH as contractOfMethodSpec, dI as definePlan, dJ as entityWrites, dK as executeBatchGet, dL as executeBatchWrite, dM as executeCommandMethod, dN as executeDelete, dO as executeKeyedBatchGet, dP as executePut, dQ as executeQueryMethod, dR as executeRangeFanout, dS as executeTransaction, dT as executeUpdate, dU as from, dV as getEntityWrites, dW as gsi, dX as identity, dY as isColumn, dZ as isCommandModelContract, d_ as isCommandPlan, d$ as isContractComposeNode, e0 as isContractFromRef, e1 as isContractKeyFieldRef, e2 as isContractKeyRef, e3 as isContractParamRef, e4 as isEntityWritesDefinition, e5 as isKeySegment, e6 as isLifecycleContract, e7 as isMaintainTrigger, e8 as isMutationFragment, e9 as isMutationInputRef, ea as isParam, eb as isPlannedCommandMethod, ec as isQueryModelContract, ed as isRetryableError, ee as isRetryableTransactionCancellation, ef as k, eg as key, eh as lifecyclePhaseForIntent, ei as maintainTrigger, ej as mintContractKeyFieldRef, ek as mintContractParamRef, el as mutation, em as param, en as preview, eo as publicCommandModel, ep as publicQueryModel, eq as query, aL as resolveLifecycle, er as wholeKeysSentinel } from './maintenance-view-adapter-CFeasCKo.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-DQK2Jm9R.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-DLkhG0xX.js';
-export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, a as ContextOwnershipMap, b as ContractBoundaryViolation, c as ContractInputs, d as ContractMap, e as ContractN1Violation, T as TransactionDefinition, f as TransactionParamShape, g as TransactionRef, h as TxConditionCheckOptions, i as TxForEachInstruction, j as TxForEachOptions, k as TxInstruction, l as TxRecorder, m as TxWriteInstruction, n as TxWriteOptions, W as WhenComparison, o as assertBundleSerializable, p as assertContractBoundaries, q as assertContractN1Safe, r as assertJsonSerializable, s as assertSupportedCondition, t as buildBridgeBundle, u as buildContexts, v as buildContracts, w as buildManifest, x as buildOperations, y as buildQuerySpec, z as buildTransactionSpec, D as buildTransactions, E as collectContractBoundaryViolations, F as collectContractN1Violations, G as defineTransaction, H as defineTransactions, I as isTransactionRef, J as when } from './index-CtDBo8Se.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-CFzBy7aU.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-0TiWr5OW.js';
+export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, a as ContextOwnershipMap, b as ContractBoundaryViolation, c as ContractInputs, d as ContractMap, e as ContractN1Violation, T as TransactionDefinition, f as TransactionParamShape, g as TransactionRef, h as TxConditionCheckOptions, i as TxForEachInstruction, j as TxForEachOptions, k as TxInstruction, l as TxRecorder, m as TxWriteInstruction, n as TxWriteOptions, W as WhenComparison, o as assertBundleSerializable, p as assertContractBoundaries, q as assertContractN1Safe, r as assertJsonSerializable, s as assertSupportedCondition, t as buildBridgeBundle, u as buildContexts, v as buildContracts, w as buildManifest, x as buildOperations, y as buildQuerySpec, z as buildTransactionSpec, D as buildTransactions, E as collectContractBoundaryViolations, F as collectContractN1Violations, G as defineTransaction, H as defineTransactions, I as isTransactionRef, J as when } from './index-CtJbTrfB.js';
 
 /**
  * Query options with conditional `consistentRead` availability.
@@ -784,6 +784,48 @@ type HasManyVersionedCallback<Self, Source> = (self: SelfProxy<Self>, source: So
 
 declare function hasMany(targetFactory: () => new (...args: unknown[]) => unknown, keyBinding: Record<string, string>, options?: RelationOptions): (value: undefined, context: ClassFieldDecoratorContext) => void;
 declare function hasMany<Self = unknown, Source = unknown>(targetFactory: () => new (...args: unknown[]) => unknown, callback: HasManyVersionedCallback<Self, Source>): (value: undefined, context: ClassFieldDecoratorContext) => void;
+/**
+ * Options for a `@refs` relation (issue #197, Pattern 2 Embedded Refs read side).
+ *
+ * A `@refs` relation resolves an **inline id-list** on the parent row into the
+ * referenced child bodies in ONE deduped `BatchGetItem`:
+ *
+ * ```ts
+ * @list tagRefs!: { tagId: string }[];            // the stored inline ref list
+ * @refs(() => PTagModel, { from: 'tagRefs', key: 'tagId' })
+ * tags!: PTagModel[];                              // resolved child bodies
+ * ```
+ *
+ * `Model.query(key, { tags: { select: { name: true } } })` then reads the parent,
+ * pulls `tagId` off each `tagRefs` element, dedupes, and hydrates the `PTag`
+ * bodies in a single BatchGet — the exact physical cost (parent read + 1
+ * BatchGet) of the manual two-call form, but declarative and typed.
+ */
+interface RefsOptions extends RelationOptions {
+    /** The parent LIST attribute holding the inline reference elements (e.g. `'tagRefs'`). */
+    from: string;
+    /** The key field to read off EACH list element (e.g. `'tagId'`). */
+    key: string;
+    /**
+     * The TARGET child key field the element key binds to. Defaults to `key` (the
+     * common case where the element field name matches the child's key field name,
+     * e.g. `tagRefs[].tagId` → `PTag.tagId`). Supply when they differ.
+     */
+    to?: string;
+}
+/**
+ * Declares a **`refs`** relation (issue #197): the parent row holds an inline
+ * id-list (`from`, a `@list` attribute) whose elements each carry a reference key
+ * (`key`); the relation resolves those references to the target child bodies in a
+ * single deduped `BatchGetItem` at read time
+ * (`Model.query(key, { <prop>: { select: {…} } })`).
+ *
+ * The decorated property must be declared as an array of the target model
+ * (`tags!: PTagModel[]`), so it selects/returns like a bounded collection
+ * (`{ items, cursor }`, `cursor` always `null` — a refs list is finite, not
+ * paged).
+ */
+declare function refs(targetFactory: () => new (...args: unknown[]) => unknown, options: RefsOptions): (_value: undefined, context: ClassFieldDecoratorContext) => void;
 declare function belongsTo(targetFactory: () => new (...args: unknown[]) => unknown, keyBinding: Record<string, string>, options?: RelationOptions): (_value: undefined, context: ClassFieldDecoratorContext) => void;
 declare function hasOne(targetFactory: () => new (...args: unknown[]) => unknown, keyBinding: Record<string, string>, options?: RelationOptions): (value: undefined, context: ClassFieldDecoratorContext) => void;
 declare function hasOne<Self = unknown, Source = unknown>(targetFactory: () => new (...args: unknown[]) => unknown, callback: HasOneVersionedCallback<Self, Source>): (value: undefined, context: ClassFieldDecoratorContext) => void;
@@ -1149,7 +1191,10 @@ interface ProjectionResult {
  *
  * Rules:
  * - scalar (`true`) → field name added to projection
- * - embedded (object without `select` property) → nested path e.g. `#p0.#p1`
+ * - inline embeddedSnapshot read (`{ inline: true }`, issue #196) → the owner-row
+ *   physical attribute is added to the projection like a scalar (the maintained
+ *   copy is read straight off the row, NOT traversed to child partitions)
+ * - embedded (object without `select`/`inline`) → nested path e.g. `#p0.#p1`
  * - relation (object with `select` property) → excluded from projection
  * - additionalFields → added to projection (for implicit key resolution)
  */
@@ -2055,4 +2100,4 @@ type WriteOnlyDefinitions<D extends DefinitionMap> = {
     [K in keyof D]: D[K] extends OperationDefinition<infer _T, infer Op, infer _K, infer _S, infer _Ch, infer _P> ? Op extends 'put' | 'update' | 'delete' ? D[K] : OperationDefinition<DDBModel, 'put' | 'update' | 'delete', unknown, unknown, unknown, Record<string, ParamDescriptor>> : never;
 };
 
-export { AggregateOptions, AggregateValue, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchExecOptions, BatchGetExecInput, BatchWriteExecItem, ClientManager, type CollectParams, type ConditionExpressionResult, CtxModel, DDBModel, DefinitionMap, DeleteInput, type DriftReport, DynamoDBOperation, DynamoExecutor, DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, EntityMetadata, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FieldMetadata, FieldOptions, type FilterExpressionResult, GsiDefinition, type HasManyVersionedCallback, type HasManyVersionedOptions, type HasOneVersionedCallback, type HasOneVersionedOptions, Item, KeyDefinition, type ListInput, type ListOptions, MAX_TRANSACT_ITEMS, MaintainConsistency, MaintainEffect, MaintainEvent, MaintainUpdateMode, type MaintainedFromCallback, type MaintainedFromOptions, type MaintenanceRebuildOptions, MaintenanceRebuilder, Manifest, MembershipPredicate, MembershipPredicateOp, Middleware, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PrimaryKeyOf, type ProjectionResult, ProjectionTransform, type ProjectionValue, PutInput, type QueryOptions$1 as QueryOptions, RawCondition, ReadExecOptions, ReadParams, ReadRequestCtx, ReadRequestKind, type RebuildResult, RelationMetadata, RelationOptions, type RelationTraversalOptions, RequestContext, ResolvedKey, RetryOverride, RetryPolicy, RetryingExecutor, SelectableOf, type SelfProxy, type SelfRef, type SourceProxy, type SourceRef, TableMapping, TransactWriteExecItem, TransactionItemSpec, TransactionSpec, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type VersionedHistoryOptions, type VersionedLatestOptions, ViewDefinition, WriteDefinitionOptions, WriteExecOptions, WriteResult, aggregate, belongsTo, binary, boolean, buildConditionExpression, buildProjection, buildUpdateExpression, cdcProjected, compileFilterExpression, count, createMaintenanceRebuilder, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, list, literal, maintainedFrom, map, max, model, number, numberSet, plan, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, ttl, validateDepth, validateGsiAmbiguity, whenMember };
+export { AggregateOptions, AggregateValue, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchExecOptions, BatchGetExecInput, BatchWriteExecItem, ClientManager, type CollectParams, type ConditionExpressionResult, CtxModel, DDBModel, DefinitionMap, DeleteInput, type DriftReport, DynamoDBOperation, DynamoExecutor, DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, EntityMetadata, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FieldMetadata, FieldOptions, type FilterExpressionResult, GsiDefinition, type HasManyVersionedCallback, type HasManyVersionedOptions, type HasOneVersionedCallback, type HasOneVersionedOptions, Item, KeyDefinition, type ListInput, type ListOptions, MAX_TRANSACT_ITEMS, MaintainConsistency, MaintainEffect, MaintainEvent, MaintainUpdateMode, type MaintainedFromCallback, type MaintainedFromOptions, type MaintenanceRebuildOptions, MaintenanceRebuilder, Manifest, MembershipPredicate, MembershipPredicateOp, Middleware, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PrimaryKeyOf, type ProjectionResult, ProjectionTransform, type ProjectionValue, PutInput, type QueryOptions$1 as QueryOptions, RawCondition, ReadExecOptions, ReadParams, ReadRequestCtx, ReadRequestKind, type RebuildResult, type RefsOptions, RelationMetadata, RelationOptions, type RelationTraversalOptions, RequestContext, ResolvedKey, RetryOverride, RetryPolicy, RetryingExecutor, SelectableOf, type SelfProxy, type SelfRef, type SourceProxy, type SourceRef, TableMapping, TransactWriteExecItem, TransactionItemSpec, TransactionSpec, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type VersionedHistoryOptions, type VersionedLatestOptions, ViewDefinition, WriteDefinitionOptions, WriteExecOptions, WriteResult, aggregate, belongsTo, binary, boolean, buildConditionExpression, buildProjection, buildUpdateExpression, cdcProjected, compileFilterExpression, count, createMaintenanceRebuilder, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, list, literal, maintainedFrom, map, max, model, number, numberSet, plan, refs, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, ttl, validateDepth, validateGsiAmbiguity, whenMember };

package/dist/index.js

@@ -39,7 +39,6 @@ import {
   deriveEdgeWriteItems,
   deriveEdgeWriteItemsFor,
   deriveModelEdgeWriteItems,
-  detectRelationFields,
   edgeWrites,
   encodeCursor,
   evaluateFilter,
@@ -53,7 +52,6 @@ import {
   executeQuery,
   from,
   getEdgeWrites,
-  getImplicitKeyFields,
   isCommandModelContract,
   isCommandPlan,
   isContractComposeNode,
@@ -80,7 +78,7 @@ import {
   validateDepth,
   when,
   wholeKeysSentinel
-} from "./chunk-Y7XV5QL2.js";
+} from "./chunk-N5NQM3SO.js";
 import {
   CdcEmulator,
   MAINT_OUTBOX_PK_PREFIX,
@@ -92,7 +90,7 @@ import {
   orderAndTrimCollection,
   pathField,
   projectFrom
-} from "./chunk-M6URQOAW.js";
+} from "./chunk-5NXNEW43.js";
 import {
   BATCH_GET_MAX_KEYS,
   BATCH_WRITE_MAX_ITEMS,
@@ -119,6 +117,7 @@ import {
   collectViewDefinitions,
   commitTransaction,
   cond,
+  detectRelationFields,
   entityWrites,
   execItemKeySignature,
   executeDelete,
@@ -126,6 +125,7 @@ import {
   executeTransaction,
   executeUpdate,
   getEntityWrites,
+  getImplicitKeyFields,
   gsi,
   hydrate,
   identity,
@@ -145,7 +145,7 @@ import {
   resolveConditionTree,
   resolveModelClass,
   serializeFieldValue
-} from "./chunk-CCIVET5K.js";
+} from "./chunk-F2DI3GTI.js";
 import {
   Linter,
   TableMapping,
@@ -512,6 +512,29 @@ function hasMany(targetFactory, keyBindingOrCallback, options) {
     });
   };
 }
+function refs(targetFactory, options) {
+  return function(_value, context) {
+    const propertyName = String(context.name);
+    assertRelationPropertyNameAllowed(propertyName);
+    if (!options || typeof options.from !== "string" || typeof options.key !== "string") {
+      throw new Error(
+        `@refs relation '${propertyName}': options must supply \`from\` (the parent list attribute, e.g. 'tagRefs') and \`key\` (the ref field on each element, e.g. 'tagId').`
+      );
+    }
+    const { from: from2, key: key2, to, ...relationOptions } = options;
+    const targetKeyField = to ?? key2;
+    collectRelation({
+      type: "refs",
+      propertyName,
+      targetFactory,
+      // Scalar keyBinding: target child key field ← element key name. Per resolved
+      // element the existing scalar key-building machinery reuses this unchanged.
+      keyBinding: { [targetKeyField]: key2 },
+      refs: { from: from2, key: key2 },
+      ...Object.keys(relationOptions).length > 0 ? { options: relationOptions } : {}
+    });
+  };
+}
 function belongsTo(targetFactory, keyBinding, options) {
   return function(_value, context) {
     const propertyName = String(context.name);
@@ -1994,6 +2017,7 @@ export {
   publicQueryModel,
   query,
   queryBoundaryRule,
+  refs,
   relationDepthRule,
   requireLimitRule,
   resolveKey,

package/dist/linter/index.d.ts

@@ -1,7 +1,7 @@
-import { L as LintRule } from '../registry-BD_5Rm5C.js';
-export { a as LintResult, b as Linter } from '../registry-BD_5Rm5C.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-DLkhG0xX.js';
-import '../maintenance-view-adapter-D5t9taTE.js';
+import { L as LintRule } from '../registry-DbqmFyab.js';
+export { a as LintResult, b as Linter } from '../registry-DbqmFyab.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-0TiWr5OW.js';
+import '../maintenance-view-adapter-CFeasCKo.js';
 import '@aws-sdk/client-dynamodb';
 
 /**

package/dist/{maintenance-view-adapter-D5t9taTE.d.ts → maintenance-view-adapter-CFeasCKo.d.ts}

@@ -668,7 +668,34 @@ type Scalar = string | number | boolean | bigint | symbol | null | undefined | D
  * - Function properties → excluded
  */
 type SelectableOf<T> = {
-    [K in keyof T as T[K] extends Function ? never : K]?: T[K] extends Array<infer E> ? [E] extends [DDBModel] ? RelationSpec<E> : true : NonNullable<T[K]> extends DDBModel ? null extends T[K] ? RelationSpec<NonNullable<T[K]>> : SelectableOf<T[K]> : T[K] extends Scalar ? true : SelectableOf<T[K]>;
+    [K in keyof T as T[K] extends Function ? never : K]?: T[K] extends Array<infer E> ? [E] extends [DDBModel] ? RelationSpec<E> | InlineSnapshotSpec : true : NonNullable<T[K]> extends DDBModel ? null extends T[K] ? RelationSpec<NonNullable<T[K]>> | InlineSnapshotSpec : SelectableOf<T[K]> : T[K] extends Scalar ? true : SelectableOf<T[K]>;
+};
+/**
+ * Inline-read spec for an **`embeddedSnapshot`** relation field (issue #196).
+ *
+ * An `embeddedSnapshot` relation (`@hasMany` collection like
+ * `ThreadSummary.latestPosts`, or a `@belongsTo`/`@hasOne` single-row mirror)
+ * keeps a *maintained projected copy* of the related data as a **physical
+ * attribute on the owner row** — docs §3 calls this "read inline off the owner
+ * row". `{ inline: true }` selects exactly that stored copy: the read projects
+ * the owner-row attribute and returns it in its declared shape, WITHOUT any
+ * child-partition traversal.
+ *
+ * It is deliberately a **distinct shape** from the traversal spec
+ * {@link RelationSpec} (`{ select: … }` / a `relation(…)` builder):
+ *
+ * - `{ latestPosts: { select: { … } } }` → **traversal** — a Query against the
+ *   relation's child partition (the real children). A different physical read.
+ * - `{ latestPosts: { inline: true } }`   → **inline read** — the maintained
+ *   copy stored on the owner row. No join.
+ *
+ * The two never overlap structurally (`inline` vs `select`), so the type layer
+ * keeps them apart, and at runtime `{ inline: true }` is rejected on any field
+ * that is not an `embeddedSnapshot` relation (a loud error), so the two paths
+ * are unambiguous in BOTH the types and the execution.
+ */
+type InlineSnapshotSpec = {
+    inline: true;
 };
 /**
  * What a relation field accepts in a `select`: either the plain
@@ -738,7 +765,7 @@ type StrictSelect<T, Sel> = {
         select: infer Nested;
     } ? K extends keyof T ? Sel[K] & {
         select: StrictSelect<RelationTargetOf<T[K]>, Nested>;
-    } : Sel[K] : Sel[K] extends object ? Sel[K] extends RelationBuilder<infer _RT, infer _RS> ? Sel[K] : K extends keyof T ? Sel[K] & StrictSelect<NonNullable<T[K]>, Sel[K]> : Sel[K] : Sel[K] : never;
+    } : Sel[K] : Sel[K] extends InlineSnapshotSpec ? Sel[K] : Sel[K] extends object ? Sel[K] extends RelationBuilder<infer _RT, infer _RS> ? Sel[K] : K extends keyof T ? Sel[K] & StrictSelect<NonNullable<T[K]>, Sel[K]> : Sel[K] : Sel[K] : never;
 };
 /**
  * Extracts the relation **target entity type** from an entity field type:
@@ -794,7 +821,7 @@ type EntityInput<T> = {
  */
 
 type QueryResult<T, S> = S extends unknown ? {
-    [K in keyof S & keyof T]: S[K] extends true ? T[K] : S[K] extends RelationBuilder<infer _RT, infer Sel> ? T[K] extends Array<infer E> ? {
+    [K in keyof S & keyof T]: S[K] extends true ? T[K] : S[K] extends InlineSnapshotSpec ? T[K] : S[K] extends RelationBuilder<infer _RT, infer Sel> ? T[K] extends Array<infer E> ? {
         items: QueryResult<E, Sel>[];
         cursor: string | null;
     } : QueryResult<NonNullable<T[K]>, Sel> | null : S[K] extends {
@@ -2129,6 +2156,21 @@ interface UniqueEffect {
  * An edge write effect (proposal §2 `edges`): create / delete the adjacency row
  * that materializes a target relation. Derived to an adjacency `Put` / `Delete`
  * by #82/#85 (the `src/relation/edge-write.ts` primitive) — stored opaquely here.
+ *
+ * ## `inverse` — dual-edge synchronization through the command IF (Epic #118 pattern 9, issue #195)
+ *
+ * A plain edge above is **one physical row** (the target relation's adjacency row),
+ * created on create and deleted on delete. A **dual edge** (pattern 9 / #133) is a
+ * bidirectional relation kept as TWO physical rows — a forward row (the target
+ * relation's adjacency) and an inverse row on its OWN partition (a SECOND adjacency
+ * model). {@link inverse}, when present, names that inverse row so the command /
+ * mutation derivation ({@link import('../spec/mutation-command.js')}) maintains BOTH
+ * rows in the SAME atomic transaction — the create `Put`s both, the delete `Delete`s
+ * both, a foreign-key change `Delete`s+`Put`s both — exactly as the low-level
+ * {@link import('../relation/edge-write.js').deriveModelEdgeWriteItems} path does. It
+ * mirrors {@link import('../relation/edge-write.js').EdgeWriteDeclaration.inverse} so
+ * the two edge-write vocabularies stay structurally identical; omit `inverse` for the
+ * historical single-row (base + inverse GSI) bidirectional edge.
  */
 interface EdgeEffect {
     readonly kind: 'putEdge' | 'deleteEdge';
@@ -2136,6 +2178,22 @@ interface EdgeEffect {
     readonly targetFactory: () => new (...args: unknown[]) => unknown;
     /** The relation property on the target that reads this edge. */
     readonly relationProperty: string;
+    /**
+     * The INVERSE edge to keep in sync (Epic #118 pattern 9 / issue #133 & #195, dual-edge).
+     * Names the second adjacency model whose own row materializes the reverse-direction
+     * relation. When present, the mutation-command derivation maintains the inverse row
+     * alongside the forward row in the SAME transaction, so a one-direction declaration
+     * driven through the command IF keeps a two-row bidirectional edge consistent. Absent
+     * = the historical single-row (base + inverse GSI) bidirectional edge.
+     */
+    readonly inverse?: {
+        /** Resolves the inverse adjacency model whose row IS the inverse edge. */
+        readonly adjacencyFactory: () => new (...args: unknown[]) => unknown;
+        /** Resolves the target model whose relation the inverse row feeds. */
+        readonly targetFactory: () => new (...args: unknown[]) => unknown;
+        /** The relation property on the inverse target that reads the inverse row. */
+        readonly relationProperty: string;
+    };
 }
 /**
  * A derived (cascading) update (proposal §2 `derive`): e.g. `User.postCount +=
@@ -2605,6 +2663,42 @@ interface WriteRecorder {
     putEdge(target: () => new (...args: unknown[]) => unknown, relationProperty: string): EdgeEffect;
     /** Declare an edge delete effect (§2 `edges`; derived #82/#85). */
     deleteEdge(target: () => new (...args: unknown[]) => unknown, relationProperty: string): EdgeEffect;
+    /**
+     * Declare a **dual edge** (Epic #118 pattern 9 / issue #133 & #195): a bidirectional
+     * edge maintained as TWO physical rows — a forward row (the `forward.target`'s
+     * `relationProperty` adjacency) and an inverse row on a SECOND adjacency model
+     * (read by `inverse.target`'s `relationProperty`). Both rows are written / deleted /
+     * moved together from this single declaration, so the command / mutation IF keeps the
+     * two directions in sync WITHOUT an inverse GSI — the same two-row maintenance the
+     * low-level {@link import('../relation/edge-write.js').edgeWrites} `w.dualEdge` performs,
+     * now reachable through `entityWrites` and thus through `executeCommandMethod` /
+     * `DDBModel.mutate`. Use this when the reverse direction lives on its own partition
+     * (a second row) rather than a GSI of the forward row.
+     *
+     * The lifecycle is chosen by the fragment intent (create → both `Put`, remove → both
+     * `Delete`, update → both `Delete(old)+Put(new)`), so the SAME declaration is placed
+     * under whichever lifecycle(s) the save contract maintains the edge on.
+     *
+     * @example
+     * ```ts
+     * static readonly writes = entityWrites<FollowEdgeModel>((w) => ({
+     *   create: w.lifecycle({
+     *     edges: [w.dualEdge(
+     *       { target: () => UserModel, relationProperty: 'following' },
+     *       { adjacency: () => FollowedByEdgeModel, target: () => UserModel, relationProperty: 'followers' },
+     *     )],
+     *   }),
+     * }));
+     * ```
+     */
+    dualEdge(forward: {
+        target: () => new (...args: unknown[]) => unknown;
+        relationProperty: string;
+    }, inverse: {
+        adjacency: () => new (...args: unknown[]) => unknown;
+        target: () => new (...args: unknown[]) => unknown;
+        relationProperty: string;
+    }): EdgeEffect;
     /** Declare a derived / cascading update (§2 `derive`; derived #85). */
     increment(target: () => new (...args: unknown[]) => unknown, keys: Readonly<Record<string, EffectPath>>, attribute: string, amount: number): DeriveEffect;
     /**
@@ -3169,11 +3263,23 @@ interface ManifestGsi extends ManifestKey {
     readonly description?: string;
 }
 interface ManifestRelation {
-    readonly type: 'hasMany' | 'hasOne' | 'belongsTo';
+    readonly type: 'hasMany' | 'hasOne' | 'belongsTo' | 'refs';
     /** Target entity (model class) name. */
     readonly target: string;
     /** target field → source field (on this entity). */
     readonly keyBinding: Readonly<Record<string, string>>;
+    /**
+     * List-valued source descriptor for a `refs` relation (issue #197). Present IFF
+     * `type === 'refs'`: `from` is the parent LIST attribute holding the inline
+     * reference elements (e.g. `'tagRefs'`), `key` the field read off each element
+     * (e.g. `'tagId'`). Absent for every scalar-keyed relation (byte-identical to
+     * the pre-#197 manifest). Carried so a manifest consumer can reconstruct where a
+     * `refs` relation's BatchGet keys come from.
+     */
+    readonly refs?: Readonly<{
+        from: string;
+        key: string;
+    }>;
     /**
      * Optional human-readable description of the relation (issue #166, follow-up of
      * #154), from `@hasMany/@belongsTo/@hasOne(..., { description })`. Pure documentation
@@ -6715,11 +6821,46 @@ interface RelationOptions {
         readonly updateMode?: MaintainUpdateMode;
     };
 }
+/**
+ * Descriptor for a `refs` relation (issue #197, Pattern 2 Embedded Refs read
+ * side). A `refs` relation resolves an **inline id-list** held on the parent row
+ * — e.g. `PPost.tagRefs: { tagId: string }[]` — into the referenced child
+ * bodies, in ONE deduped `BatchGetItem` (never per-ref `GetItem`).
+ *
+ * Unlike `hasMany`/`belongsTo`/`hasOne`, whose key is bound from a parent
+ * **scalar** field ({@link RelationMetadata.keyBinding} — `target key ← parent
+ * scalar`), a `refs` key is bound from EACH ELEMENT of a parent LIST attribute:
+ * the traversal reads `parent[from]` (a list), pulls `.key` off every element,
+ * and fans those out into a single BatchGet against the target. This descriptor
+ * captures exactly that list-valued source shape, which the scalar `keyBinding`
+ * `Record<string,string>` cannot express.
+ *
+ * `keyBinding` on a `refs` relation still records the **target child key field ←
+ * element key name** mapping (e.g. `{ tagId: 'tagId' }`), so key building /
+ * projection reuse the existing scalar machinery per resolved element; `refs`
+ * only adds *where the scalar values come from* (the parent list), not a new key
+ * grammar. That keeps `refs` byte-compatible with every scalar-keyBinding
+ * consumer (manifest, planner, dedupe) — an unknown-to-them relation kind is
+ * simply carried through with a valid scalar `keyBinding`.
+ */
+interface RefsBinding {
+    /** The parent LIST attribute holding the inline reference elements (e.g. `'tagRefs'`). */
+    from: string;
+    /** The key field to read off EACH list element (e.g. `'tagId'`). */
+    key: string;
+}
 interface RelationMetadata {
-    type: 'hasMany' | 'hasOne' | 'belongsTo';
+    type: 'hasMany' | 'hasOne' | 'belongsTo' | 'refs';
     propertyName: string;
     targetFactory: () => new (...args: unknown[]) => unknown;
     keyBinding: Record<string, string>;
+    /**
+     * List-valued source descriptor for a `refs` relation (issue #197). Present
+     * IFF `type === 'refs'`; the traversal reads the parent list `refs.from`, pulls
+     * `refs.key` off each element, and resolves the referenced child bodies in one
+     * deduped BatchGet. Absent for every scalar-keyed relation (byte-compatible).
+     */
+    refs?: RefsBinding;
     options?: RelationOptions;
 }
 /**
@@ -6931,4 +7072,4 @@ interface ViewDefinition {
  */
 declare function collectViewDefinitions(registry?: ReadonlyMap<Function, EntityMetadata>): ViewDefinition[];
 
-export { type BridgeBundle as $, type Param as A, type BatchResult as B, type CdcEmulatorOptions as C, type DynamoDBOperation as D, type EventLog as E, type FaultSpec as F, type QueryMethodSpec as G, type CommandModelContract as H, type CommandMethodSpec as I, type ContractSpec as J, type QuerySpec as K, type CommandSpec as L, type ModelStatic as M, type TransactionSpec as N, type ContextSpec as O, type PutInput as P, type QueryModelContract as Q, type ReplayOptions as R, type ShardId as S, type TransactWriteExecItem as T, type Unsubscribe as U, type ViewDefinition as V, type WriteExecOptions as W, type DefinitionMap as X, type OperationsDocument as Y, type AnyOperationDefinition as Z, type Manifest as _, type CdcMode as a, type DynamoType as a$, type ConditionSpec as a0, type CommandContractMethodSpec as a1, type CommandResolutionTarget as a2, type CompiledFragment as a3, type CompiledMutationPlan as a4, type ComposeSpec as a5, type CompositionPlanSpec as a6, type ContractCardinality as a7, type ContractCommandResult as a8, type ContractInputArity as a9, type ReadOperationType as aA, SPEC_VERSION as aB, type TransactionItemSpec as aC, type TransactionItemType as aD, type WhenSpec as aE, type WriteOperationType as aF, assertNoCrossFragmentMaintainCollision as aG, compileFragment as aH, compileMutationPlan as aI, compileSingleFragmentPlan as aJ, resetMaintenanceGraphCache as aK, resolveLifecycle as aL, resolveMaintainers as aM, type SelectableOf as aN, type PrimaryKeyOf as aO, type RequestContext as aP, type Middleware as aQ, type ReadRequestKind as aR, type CtxModel as aS, type ReadParams as aT, type ReadRequestCtx as aU, type Item as aV, type RetryPolicy as aW, type KeyDefinition as aX, type GsiDefinition as aY, type ModelKind as aZ, type FieldOptions as a_, type ContractKeySpec as aa, type ContractKind as ab, type ContractResolution as ac, type DerivedConditionCheck as ad, type DerivedEdgeWrite as ae, type DerivedIdempotencyGuard as af, type DerivedMaintainOutbox as ag, type DerivedMaintainWrite as ah, type DerivedOutboxEvent as ai, type DerivedUniqueGuard as aj, type DerivedUpdate as ak, type EntityRefResolver as al, type ExecutionPlanSpec as am, type FilterSpec as an, MAX_TRANSACT_COMPOSE_ITEMS as ao, type ManifestEntity as ap, type ManifestField as aq, type ManifestFieldType as ar, type ManifestGsi as as, type ManifestKey as at, type ManifestRelation as au, type ManifestTable as av, type OperationSpec as aw, type ParamSpec as ax, type QueryContractMethodSpec as ay, type RangeConditionSpec as az, type ChangeBatch as b, type DeleteOptions as b$, type ProjectionTransform as b0, type MaintainEvent as b1, type MembershipPredicate as b2, type MaintainConsistency as b3, type MaintainUpdateMode as b4, type MembershipPredicateOp as b5, type RelationOptions as b6, type AggregateOptions as b7, type AggregateValue as b8, type SelectBuilderSpec as b9, type CollectionOptions as bA, type Column as bB, type ColumnMap as bC, type CommandInputShape as bD, type CommandMethod as bE, type CommandPlan as bF, type CommandResultKind as bG, type CommandSelectShape as bH, type CondSlot as bI, type ConditionCheckInput as bJ, type Connection as bK, type ContractCallSignature as bL, type ContractCommandParams as bM, type ContractComposeNode as bN, type ContractFromRef as bO, type ContractItem as bP, type ContractKeyFieldRef as bQ, type ContractKeyInput as bR, type ContractKeyRef as bS, type ContractMethodOp as bT, type ContractParamRef as bU, type ContractQueryParams as bV, type CounterAggregate as bW, type CounterEffect as bX, type CtxBase as bY, DEFAULT_MAX_ATTEMPTS as bZ, DEFAULT_RETRY_POLICY as b_, type RawCondition as ba, type RetryOverride as bb, type ExecutionPlan as bc, type FieldMetadata as bd, type ResolvedKey as be, type RelationMetadata as bf, type MaintainEffect as bg, type OperationDefinition as bh, type WriteDefinitionOptions as bi, type PartialQueryKeyOf as bj, type StrictSelectSpec as bk, type ReadDefinitionOptions as bl, type EntityInput as bm, type UniqueQueryKeyOf as bn, type AggregateMetadata as bo, type BatchDeleteRequest as bp, type BatchGetOptions as bq, type BatchGetRequest as br, BatchGetResult as bs, type BatchPutRequest as bt, type BatchWriteRequest as bu, CONTRACT_RANGE_FANOUT_CONCURRENCY as bv, type CdcModelRegistry as bw, type CdcSubscribeHandlers as bx, type Change as by, type CollectionEffect as bz, type ChangeEvent as c, type RecordedCompose as c$, type DeriveEffect as c0, type DescriptorBinding as c1, ENTITY_WRITES_MARKER as c2, type EdgeEffect as c3, type EffectPath as c4, type EmbeddedMetadata as c5, type EmitEffect as c6, type EntityWritesDefinition as c7, type EntityWritesShape as c8, type ExecutableCommandContract as c9, type MutationBody as cA, type MutationDescriptorMap as cB, type MutationFragment as cC, type MutationInputProxy as cD, type MutationInputRef as cE, type MutationIntent as cF, type NumberParam as cG, type OperationKind as cH, type ParallelOpResult as cI, type ParamKind as cJ, type ParamStructure as cK, type PersistCtx as cL, type PersistOrigin as cM, type PlannedCommandMethod as cN, type ProjectionMap as cO, type ProjectionTransformOp as cP, type PutOptions as cQ, type QueryEnvelopeResult as cR, type QueryKeyOf as cS, type QueryMethod as cT, type QueryResult as cU, type ReadEnvelope as cV, type ReadOpCtx as cW, type ReadOpKind as cX, type ReadRouteDescriptor as cY, type ReadRouteOptions as cZ, type ReadRouteResult as c_, type ExecutableQueryContract as ca, type FilterInput as cb, type FragmentInput as cc, type GsiDefinitionMarker as cd, type GsiOptions as ce, type IdempotencyEffect as cf, type InProcessWriteDescriptor as cg, type InputArity as ch, type KeyDefinitionMarker as ci, type KeySegment as cj, type KeySlot as ck, type KeyStructure as cl, type KeyedResult as cm, LIFECYCLE_CONTRACT_MARKER as cn, type LifecycleContract as co, type LifecycleEffects as cp, type LiteralParam as cq, type MaintainItem as cr, type MaintainTrigger as cs, type MaintenanceGraph as ct, type MembershipEffect as cu, type ModelRef as cv, type MutateMode as cw, type MutateOptions as cx, type MutateParallelResult as cy, type MutateTransactionResult as cz, type ChangeEventName as d, isContractFromRef as d$, type RelationBuilder as d0, type RelationConsistency as d1, type RelationLimitOptions as d2, type RelationPattern as d3, type RelationProjection as d4, type RelationReadOptions as d5, type RelationSelect as d6, type RelationSpec as d7, type RelationUpdateMode as d8, type RelationWriteOptions as d9, buildDeleteInput as dA, buildMaintenanceGraph as dB, buildPutInput as dC, buildUpdateInput as dD, collectViewDefinitions as dE, cond as dF, contractOfMethodSpec as dG, definePlan as dH, entityWrites as dI, executeBatchGet as dJ, executeBatchWrite as dK, executeCommandMethod as dL, executeDelete as dM, executeKeyedBatchGet as dN, executePut as dO, executeQueryMethod as dP, executeRangeFanout as dQ, executeTransaction as dR, executeUpdate as dS, from as dT, getEntityWrites as dU, gsi as dV, identity as dW, isColumn as dX, isCommandModelContract as dY, isCommandPlan as dZ, isContractComposeNode as d_, type RequiresEffect as da, type Resolution as db, type RetryInfo as dc, type RetryOperationKind as dd, type SegmentSpec as de, type SegmentedKey as df, type SelectBuilder as dg, type SelectOf as dh, type SnapshotEffect as di, type StringParam as dj, TransactionContext as dk, type UniqueEffect as dl, type Updatable as dm, type UpdateOptions as dn, type ViewSourceSlice as dp, type WriteCtx as dq, type WriteDescriptor as dr, type WriteEnvelope as ds, type WriteInput as dt, type WriteKind as du, type WriteLifecyclePhase as dv, type WriteMiddleware as dw, type WriteRecorder as dx, type WriteResultProjection as dy, attachModelClass as dz, type ChangeHandler as e, isContractKeyFieldRef as e0, isContractKeyRef as e1, isContractParamRef as e2, isEntityWritesDefinition as e3, isKeySegment as e4, isLifecycleContract as e5, isMaintainTrigger as e6, isMutationFragment as e7, isMutationInputRef as e8, isParam as e9, isPlannedCommandMethod as ea, isQueryModelContract as eb, isRetryableError as ec, isRetryableTransactionCancellation as ed, k as ee, key as ef, lifecyclePhaseForIntent as eg, maintainTrigger as eh, mintContractKeyFieldRef as ei, mintContractParamRef as ej, mutation as ek, param as el, preview as em, publicCommandModel as en, publicQueryModel as eo, query as ep, wholeKeysSentinel as eq, type ClockMode as f, type ConcurrentRecomputeRef as g, type StartingPosition as h, type StreamViewType as i, type SubscribeHandler as j, type SubscribeHandlers as k, buildSubscribeHandler as l, type EntityMetadata as m, type Executor as n, type ReadExecOptions as o, type ExecutorResult as p, type BatchGetExecInput as q, type WriteResult as r, type UpdateInput as s, type DeleteInput as t, type BatchWriteExecItem as u, type BatchExecOptions as v, DDBModel as w, type ParamDescriptor as x, type EntityRef as y, type ConditionInput as z };
+export { type BridgeBundle as $, type Param as A, type BatchResult as B, type CdcEmulatorOptions as C, type DynamoDBOperation as D, type EventLog as E, type FaultSpec as F, type QueryMethodSpec as G, type CommandModelContract as H, type CommandMethodSpec as I, type ContractSpec as J, type QuerySpec as K, type CommandSpec as L, type ModelStatic as M, type TransactionSpec as N, type ContextSpec as O, type PutInput as P, type QueryModelContract as Q, type ReplayOptions as R, type ShardId as S, type TransactWriteExecItem as T, type Unsubscribe as U, type ViewDefinition as V, type WriteExecOptions as W, type DefinitionMap as X, type OperationsDocument as Y, type AnyOperationDefinition as Z, type Manifest as _, type CdcMode as a, type DynamoType as a$, type ConditionSpec as a0, type CommandContractMethodSpec as a1, type CommandResolutionTarget as a2, type CompiledFragment as a3, type CompiledMutationPlan as a4, type ComposeSpec as a5, type CompositionPlanSpec as a6, type ContractCardinality as a7, type ContractCommandResult as a8, type ContractInputArity as a9, type ReadOperationType as aA, SPEC_VERSION as aB, type TransactionItemSpec as aC, type TransactionItemType as aD, type WhenSpec as aE, type WriteOperationType as aF, assertNoCrossFragmentMaintainCollision as aG, compileFragment as aH, compileMutationPlan as aI, compileSingleFragmentPlan as aJ, resetMaintenanceGraphCache as aK, resolveLifecycle as aL, resolveMaintainers as aM, type SelectableOf as aN, type PrimaryKeyOf as aO, type RequestContext as aP, type Middleware as aQ, type ReadRequestKind as aR, type CtxModel as aS, type ReadParams as aT, type ReadRequestCtx as aU, type Item as aV, type RetryPolicy as aW, type KeyDefinition as aX, type GsiDefinition as aY, type ModelKind as aZ, type FieldOptions as a_, type ContractKeySpec as aa, type ContractKind as ab, type ContractResolution as ac, type DerivedConditionCheck as ad, type DerivedEdgeWrite as ae, type DerivedIdempotencyGuard as af, type DerivedMaintainOutbox as ag, type DerivedMaintainWrite as ah, type DerivedOutboxEvent as ai, type DerivedUniqueGuard as aj, type DerivedUpdate as ak, type EntityRefResolver as al, type ExecutionPlanSpec as am, type FilterSpec as an, MAX_TRANSACT_COMPOSE_ITEMS as ao, type ManifestEntity as ap, type ManifestField as aq, type ManifestFieldType as ar, type ManifestGsi as as, type ManifestKey as at, type ManifestRelation as au, type ManifestTable as av, type OperationSpec as aw, type ParamSpec as ax, type QueryContractMethodSpec as ay, type RangeConditionSpec as az, type ChangeBatch as b, type DeleteOptions as b$, type ProjectionTransform as b0, type MaintainEvent as b1, type MembershipPredicate as b2, type MaintainConsistency as b3, type MaintainUpdateMode as b4, type MembershipPredicateOp as b5, type RelationOptions as b6, type AggregateOptions as b7, type AggregateValue as b8, type SelectBuilderSpec as b9, type CollectionOptions as bA, type Column as bB, type ColumnMap as bC, type CommandInputShape as bD, type CommandMethod as bE, type CommandPlan as bF, type CommandResultKind as bG, type CommandSelectShape as bH, type CondSlot as bI, type ConditionCheckInput as bJ, type Connection as bK, type ContractCallSignature as bL, type ContractCommandParams as bM, type ContractComposeNode as bN, type ContractFromRef as bO, type ContractItem as bP, type ContractKeyFieldRef as bQ, type ContractKeyInput as bR, type ContractKeyRef as bS, type ContractMethodOp as bT, type ContractParamRef as bU, type ContractQueryParams as bV, type CounterAggregate as bW, type CounterEffect as bX, type CtxBase as bY, DEFAULT_MAX_ATTEMPTS as bZ, DEFAULT_RETRY_POLICY as b_, type RawCondition as ba, type RetryOverride as bb, type ExecutionPlan as bc, type FieldMetadata as bd, type ResolvedKey as be, type RelationMetadata as bf, type MaintainEffect as bg, type OperationDefinition as bh, type WriteDefinitionOptions as bi, type PartialQueryKeyOf as bj, type StrictSelectSpec as bk, type ReadDefinitionOptions as bl, type EntityInput as bm, type UniqueQueryKeyOf as bn, type AggregateMetadata as bo, type BatchDeleteRequest as bp, type BatchGetOptions as bq, type BatchGetRequest as br, BatchGetResult as bs, type BatchPutRequest as bt, type BatchWriteRequest as bu, CONTRACT_RANGE_FANOUT_CONCURRENCY as bv, type CdcModelRegistry as bw, type CdcSubscribeHandlers as bx, type Change as by, type CollectionEffect as bz, type ChangeEvent as c, type ReadRouteResult as c$, type DeriveEffect as c0, type DescriptorBinding as c1, ENTITY_WRITES_MARKER as c2, type EdgeEffect as c3, type EffectPath as c4, type EmbeddedMetadata as c5, type EmitEffect as c6, type EntityWritesDefinition as c7, type EntityWritesShape as c8, type ExecutableCommandContract as c9, type MutateTransactionResult as cA, type MutationBody as cB, type MutationDescriptorMap as cC, type MutationFragment as cD, type MutationInputProxy as cE, type MutationInputRef as cF, type MutationIntent as cG, type NumberParam as cH, type OperationKind as cI, type ParallelOpResult as cJ, type ParamKind as cK, type ParamStructure as cL, type PersistCtx as cM, type PersistOrigin as cN, type PlannedCommandMethod as cO, type ProjectionMap as cP, type ProjectionTransformOp as cQ, type PutOptions as cR, type QueryEnvelopeResult as cS, type QueryKeyOf as cT, type QueryMethod as cU, type QueryResult as cV, type ReadEnvelope as cW, type ReadOpCtx as cX, type ReadOpKind as cY, type ReadRouteDescriptor as cZ, type ReadRouteOptions as c_, type ExecutableQueryContract as ca, type FilterInput as cb, type FragmentInput as cc, type GsiDefinitionMarker as cd, type GsiOptions as ce, type IdempotencyEffect as cf, type InProcessWriteDescriptor as cg, type InlineSnapshotSpec as ch, type InputArity as ci, type KeyDefinitionMarker as cj, type KeySegment as ck, type KeySlot as cl, type KeyStructure as cm, type KeyedResult as cn, LIFECYCLE_CONTRACT_MARKER as co, type LifecycleContract as cp, type LifecycleEffects as cq, type LiteralParam as cr, type MaintainItem as cs, type MaintainTrigger as ct, type MaintenanceGraph as cu, type MembershipEffect as cv, type ModelRef as cw, type MutateMode as cx, type MutateOptions as cy, type MutateParallelResult as cz, type ChangeEventName as d, isContractComposeNode as d$, type RecordedCompose as d0, type RelationBuilder as d1, type RelationConsistency as d2, type RelationLimitOptions as d3, type RelationPattern as d4, type RelationProjection as d5, type RelationReadOptions as d6, type RelationSelect as d7, type RelationSpec as d8, type RelationUpdateMode as d9, attachModelClass as dA, buildDeleteInput as dB, buildMaintenanceGraph as dC, buildPutInput as dD, buildUpdateInput as dE, collectViewDefinitions as dF, cond as dG, contractOfMethodSpec as dH, definePlan as dI, entityWrites as dJ, executeBatchGet as dK, executeBatchWrite as dL, executeCommandMethod as dM, executeDelete as dN, executeKeyedBatchGet as dO, executePut as dP, executeQueryMethod as dQ, executeRangeFanout as dR, executeTransaction as dS, executeUpdate as dT, from as dU, getEntityWrites as dV, gsi as dW, identity as dX, isColumn as dY, isCommandModelContract as dZ, isCommandPlan as d_, type RelationWriteOptions as da, type RequiresEffect as db, type Resolution as dc, type RetryInfo as dd, type RetryOperationKind as de, type SegmentSpec as df, type SegmentedKey as dg, type SelectBuilder as dh, type SelectOf as di, type SnapshotEffect as dj, type StringParam as dk, TransactionContext as dl, type UniqueEffect as dm, type Updatable as dn, type UpdateOptions as dp, type ViewSourceSlice as dq, type WriteCtx as dr, type WriteDescriptor as ds, type WriteEnvelope as dt, type WriteInput as du, type WriteKind as dv, type WriteLifecyclePhase as dw, type WriteMiddleware as dx, type WriteRecorder as dy, type WriteResultProjection as dz, type ChangeHandler as e, isContractFromRef as e0, isContractKeyFieldRef as e1, isContractKeyRef as e2, isContractParamRef as e3, isEntityWritesDefinition as e4, isKeySegment as e5, isLifecycleContract as e6, isMaintainTrigger as e7, isMutationFragment as e8, isMutationInputRef as e9, isParam as ea, isPlannedCommandMethod as eb, isQueryModelContract as ec, isRetryableError as ed, isRetryableTransactionCancellation as ee, k as ef, key as eg, lifecyclePhaseForIntent as eh, maintainTrigger as ei, mintContractKeyFieldRef as ej, mintContractParamRef as ek, mutation as el, param as em, preview as en, publicCommandModel as eo, publicQueryModel as ep, query as eq, wholeKeysSentinel as er, type ClockMode as f, type ConcurrentRecomputeRef as g, type StartingPosition as h, type StreamViewType as i, type SubscribeHandler as j, type SubscribeHandlers as k, buildSubscribeHandler as l, type EntityMetadata as m, type Executor as n, type ReadExecOptions as o, type ExecutorResult as p, type BatchGetExecInput as q, type WriteResult as r, type UpdateInput as s, type DeleteInput as t, type BatchWriteExecItem as u, type BatchExecOptions as v, DDBModel as w, type ParamDescriptor as x, type EntityRef as y, type ConditionInput as z };

package/dist/{registry-BD_5Rm5C.d.ts → registry-DbqmFyab.d.ts}

@@ -1,4 +1,4 @@
-import { m as EntityMetadata } from './maintenance-view-adapter-D5t9taTE.js';
+import { m as EntityMetadata } from './maintenance-view-adapter-CFeasCKo.js';
 
 interface LintRule {
     id: string;

package/dist/{relation-depth-DLkhG0xX.d.ts → relation-depth-0TiWr5OW.d.ts}

@@ -1,4 +1,4 @@
-import { b as Linter, L as LintRule } from './registry-BD_5Rm5C.js';
+import { b as Linter, L as LintRule } from './registry-DbqmFyab.js';
 
 /**
  * Creates a Linter pre-loaded with rules safe for Entity registration.

package/dist/spec/index.d.ts

@@ -1,4 +1,4 @@
-export { $ as BridgeBundle, a1 as CommandContractMethodSpec, a2 as CommandResolutionTarget, L as CommandSpec, a3 as CompiledFragment, a4 as CompiledMutationPlan, a5 as ComposeSpec, a6 as CompositionPlanSpec, a0 as ConditionSpec, O as ContextSpec, a7 as ContractCardinality, a8 as ContractCommandResult, a9 as ContractInputArity, aa as ContractKeySpec, ab as ContractKind, ac as ContractResolution, J as ContractSpec, ad as DerivedConditionCheck, ae as DerivedEdgeWrite, af as DerivedIdempotencyGuard, ag as DerivedMaintainOutbox, ah as DerivedMaintainWrite, ai as DerivedOutboxEvent, aj as DerivedUniqueGuard, ak as DerivedUpdate, al as EntityRefResolver, am as ExecutionPlanSpec, an as FilterSpec, ao as MAX_TRANSACT_COMPOSE_ITEMS, _ as Manifest, ap as ManifestEntity, aq as ManifestField, ar as ManifestFieldType, as as ManifestGsi, at as ManifestKey, au as ManifestRelation, av as ManifestTable, aw as OperationSpec, Y as OperationsDocument, ax as ParamSpec, ay as QueryContractMethodSpec, K as QuerySpec, az as RangeConditionSpec, aA as ReadOperationType, aB as SPEC_VERSION, aC as TransactionItemSpec, aD as TransactionItemType, N as TransactionSpec, aE as WhenSpec, aF as WriteOperationType, aG as assertNoCrossFragmentMaintainCollision, aH as compileFragment, aI as compileMutationPlan, aJ as compileSingleFragmentPlan, aK as resetMaintenanceGraphCache, aL as resolveLifecycle, aM as resolveMaintainers } from '../maintenance-view-adapter-D5t9taTE.js';
-export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, a as ContextOwnershipMap, b as ContractBoundaryViolation, c as ContractInputs, d as ContractMap, e as ContractN1Violation, o as assertBundleSerializable, p as assertContractBoundaries, q as assertContractN1Safe, r as assertJsonSerializable, s as assertSupportedCondition, t as buildBridgeBundle, u as buildContexts, v as buildContracts, w as buildManifest, x as buildOperations, y as buildQuerySpec, z as buildTransactionSpec, D as buildTransactions, E as collectContractBoundaryViolations, F as collectContractN1Violations } from '../index-CtDBo8Se.js';
-import '../registry-BD_5Rm5C.js';
+export { $ as BridgeBundle, a1 as CommandContractMethodSpec, a2 as CommandResolutionTarget, L as CommandSpec, a3 as CompiledFragment, a4 as CompiledMutationPlan, a5 as ComposeSpec, a6 as CompositionPlanSpec, a0 as ConditionSpec, O as ContextSpec, a7 as ContractCardinality, a8 as ContractCommandResult, a9 as ContractInputArity, aa as ContractKeySpec, ab as ContractKind, ac as ContractResolution, J as ContractSpec, ad as DerivedConditionCheck, ae as DerivedEdgeWrite, af as DerivedIdempotencyGuard, ag as DerivedMaintainOutbox, ah as DerivedMaintainWrite, ai as DerivedOutboxEvent, aj as DerivedUniqueGuard, ak as DerivedUpdate, al as EntityRefResolver, am as ExecutionPlanSpec, an as FilterSpec, ao as MAX_TRANSACT_COMPOSE_ITEMS, _ as Manifest, ap as ManifestEntity, aq as ManifestField, ar as ManifestFieldType, as as ManifestGsi, at as ManifestKey, au as ManifestRelation, av as ManifestTable, aw as OperationSpec, Y as OperationsDocument, ax as ParamSpec, ay as QueryContractMethodSpec, K as QuerySpec, az as RangeConditionSpec, aA as ReadOperationType, aB as SPEC_VERSION, aC as TransactionItemSpec, aD as TransactionItemType, N as TransactionSpec, aE as WhenSpec, aF as WriteOperationType, aG as assertNoCrossFragmentMaintainCollision, aH as compileFragment, aI as compileMutationPlan, aJ as compileSingleFragmentPlan, aK as resetMaintenanceGraphCache, aL as resolveLifecycle, aM as resolveMaintainers } from '../maintenance-view-adapter-CFeasCKo.js';
+export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, a as ContextOwnershipMap, b as ContractBoundaryViolation, c as ContractInputs, d as ContractMap, e as ContractN1Violation, o as assertBundleSerializable, p as assertContractBoundaries, q as assertContractN1Safe, r as assertJsonSerializable, s as assertSupportedCondition, t as buildBridgeBundle, u as buildContexts, v as buildContracts, w as buildManifest, x as buildOperations, y as buildQuerySpec, z as buildTransactionSpec, D as buildTransactions, E as collectContractBoundaryViolations, F as collectContractN1Violations } from '../index-CtJbTrfB.js';
+import '../registry-DbqmFyab.js';
 import '@aws-sdk/client-dynamodb';

package/dist/spec/index.js

@@ -23,8 +23,8 @@ import {
   resetMaintenanceGraphCache,
   resolveLifecycle,
   resolveMaintainers
-} from "../chunk-Y7XV5QL2.js";
-import "../chunk-CCIVET5K.js";
+} from "../chunk-N5NQM3SO.js";
+import "../chunk-F2DI3GTI.js";
 import "../chunk-PDUVTYC5.js";
 export {
   MAX_TRANSACT_COMPOSE_ITEMS,

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { n as Executor, D as DynamoDBOperation, 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, c as ChangeEvent } from '../maintenance-view-adapter-D5t9taTE.js';
+import { n as Executor, D as DynamoDBOperation, 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, c as ChangeEvent } from '../maintenance-view-adapter-CFeasCKo.js';
 import '@aws-sdk/client-dynamodb';
 
 /**

package/dist/testing/index.js

@@ -1,11 +1,11 @@
 import {
   createCdcEmulator
-} from "../chunk-M6URQOAW.js";
+} from "../chunk-5NXNEW43.js";
 import {
   ClientManager,
   MetadataRegistry,
   resolveModelClass
-} from "../chunk-CCIVET5K.js";
+} from "../chunk-F2DI3GTI.js";
 import {
   TableMapping
 } from "../chunk-PDUVTYC5.js";