graphddb 0.2.5 → 0.3.1

package/dist/{types--tdHK3vi.d.ts → types-DuJ08bgc.d.ts}

@@ -1003,7 +1003,7 @@ interface Executor {
 
 /**
  * Write middleware / hook public surface (issue #50 write path, #139). The merged
- * design is `docs/proposals/read-middleware.md`; this module implements the
+ * design is `docs/middleware.md`; this module implements the
  * **write** hook points W1–W5 and their context objects, layered on the SAME
  * registry / runtime machinery the read hooks (#138) introduced.
  *
@@ -1014,18 +1014,18 @@ interface Executor {
  * the TS↔Python bridge (#48) is unaffected. It is **unrestricted by intent**: a
  * hook may observe, mutate `ctx`, `throw` to cancel, or (on `onError`) recover by
  * returning a value. The library does NOT validate hook logic or impose semantics
- * (proposal appendix A). The internal CDC / capture mechanism (`src/capture/`,
+ * (see docs/middleware.md). The internal CDC / capture mechanism (`src/capture/`,
  * `src/cdc/`) is a SEPARATE surface — write hooks are not a substitute for it nor
- * it for them (proposal appendix C).
+ * it for them (see docs/middleware.md).
  *
- * @see docs/proposals/read-middleware.md (hook points W1–W5)
+ * @see docs/middleware.md (hook points W1–W5)
  */
 
 /**
  * The logical write kinds a {@link WriteCtx} may carry (W1 / W2 / W5). A W1 hook
  * may REWRITE this in place — the canonical case is a `delete` → `update`
  * (soft-delete-by-rewrite); derivation then runs on the rewritten op, so the
- * stored effect is the update, not the delete (proposal W1 + examples).
+ * stored effect is the update, not the delete (see docs/middleware.md).
  */
 type WriteKind = 'put' | 'update' | 'delete';
 /**
@@ -1122,9 +1122,9 @@ interface PersistCtx {
  * The write half of a registered {@link import('./types.js').Middleware}. Any
  * subset of the write hook points may be set; an unset hook is skipped. All hooks
  * are async-first — the runtime always `await`s, so sync and async hooks compose
- * uniformly (proposal "sync / async").
+ * uniformly (see docs/middleware.md).
  *
- * @see docs/proposals/read-middleware.md (hook points W1–W5)
+ * @see docs/middleware.md (hook points W1–W5)
  */
 interface WriteMiddleware {
     /** W1 — logical write, before effect derivation. May mutate `ctx.input` / `ctx.kind`; `throw` cancels (in a tx, aborts all). */
@@ -1157,7 +1157,7 @@ interface WriteMiddleware {
 
 /**
  * Read middleware / hook public surface (issue #50, implemented for the read
- * path in #138). The merged design is `docs/proposals/read-middleware.md`; this
+ * path in #138). The merged design is `docs/middleware.md`; this
  * module implements the **read** hook points R1–R5 and their context objects.
  *
  * A {@link Middleware} is a host-only, runtime-registered object (registered via
@@ -1167,9 +1167,9 @@ interface WriteMiddleware {
  * `operations.json`, so the TS↔Python bridge (#48) is unaffected. Hooks are
  * **unrestricted by intent**: a hook may observe, mutate `ctx`, `throw` to
  * cancel, or return a replacement value. The library does NOT validate hook
- * logic or impose semantics — see the proposal appendix A.
+ * logic or impose semantics — see docs/middleware.md.
  *
- * @see docs/proposals/read-middleware.md
+ * @see docs/middleware.md
  */
 
 /** A raw DynamoDB item (the shape R3 sees, per-op). */
@@ -1196,7 +1196,7 @@ interface CtxBase {
     /**
      * Scratch space shared across this op's phases (R2 → R3 → R5 for one op, or
      * R1 → R4 → R5 for the request). A fresh object per request context object;
-     * each fan-out op gets its own `state` (see proposal appendix D — siblings run
+     * each fan-out op gets its own `state` ((docs/middleware.md) — siblings run
      * concurrently, so a shared accumulator should live on a host object via
      * `context`, updated commutatively).
      */
@@ -1278,10 +1278,10 @@ interface ReadOpCtx extends CtxBase {
 /**
  * A registered read middleware object. Any subset of the read hook points may
  * be set; an unset hook is simply skipped. All hooks may be synchronous or
- * return a `Promise` — the runtime always `await`s (async-first, see proposal
+ * return a `Promise` — the runtime always `await`s (async-first, see docs/middleware.md
  * "sync / async").
  *
- * @see docs/proposals/read-middleware.md (the write hooks W1–W5 are a later phase)
+ * @see docs/middleware.md (the write hooks W1–W5 are a later phase)
  */
 interface Middleware {
     /** Optional name (for host-side debugging / ordering introspection). */
@@ -1301,7 +1301,7 @@ interface Middleware {
              * an `Item[]`: those become this op's items and the read pipeline continues
              * (the first hook that returns a value wins and short-circuits the chain).
              * Return `void` / `undefined` to decline — if no hook recovers, the original
-             * error rethrows. (See proposal R5 + appendix A — hooks are unrestricted.)
+             * error rethrows. (see docs/middleware.md — hooks are unrestricted.)
              */
             onError?(ctx: ReadOpCtx, err: unknown): void | Item[] | Promise<void | Item[]>;
         };
@@ -1343,7 +1343,7 @@ type ProjectionOf<T, Sel> = Sel extends SelectableOf<T> ? Sel : SelectOf<Sel>;
  * usages keep compiling, while the precise inference is available when the
  * constructor type is supplied (as it is from `DDBModel.asModel()`).
  */
-type AnyModelClass = abstract new (...args: any[]) => DDBModel;
+type AnyModelClass$1 = abstract new (...args: any[]) => DDBModel;
 /**
  * The accepted PK / GSI key type for `list()` / `explain()`.
  *
@@ -1353,24 +1353,24 @@ type AnyModelClass = abstract new (...args: any[]) => DDBModel;
  * {@link QueryKey}. Derived from the model class when available, otherwise
  * permissive.
  */
-type ListKey<C> = [C] extends [AnyModelClass] ? PartialQueryKeyOf<C> : Record<string, unknown>;
+type ListKey<C> = [C] extends [AnyModelClass$1] ? PartialQueryKeyOf<C> : Record<string, unknown>;
 /**
  * The accepted key type for `query()` — only keys guaranteed to return a
  * single item (PK + unique GSIs). Derived from the model class when available.
  */
-type QueryKey<C> = [C] extends [AnyModelClass] ? UniqueQueryKeyOf<C> : Record<string, unknown>;
+type QueryKey<C> = [C] extends [AnyModelClass$1] ? UniqueQueryKeyOf<C> : Record<string, unknown>;
 /**
  * The accepted key type for `delete()` (PK only). Derived from the model
  * class when available.
  */
-type DeleteKey<C> = [C] extends [AnyModelClass] ? PrimaryKeyOf<C> : Record<string, unknown>;
+type DeleteKey<C> = [C] extends [AnyModelClass$1] ? PrimaryKeyOf<C> : Record<string, unknown>;
 /**
  * The accepted *explicit* key type for `update()` — the base-table primary key
  * only. DynamoDB `UpdateItem` can target an item solely by its base-table PK
  * (GSI-based updates are impossible), so this is `PrimaryKeyOf<C>`, not
  * `UniqueQueryKeyOf<C>`. Derived from the model class when available.
  */
-type UpdateExplicitKey<C> = [C] extends [AnyModelClass] ? PrimaryKeyOf<C> : Record<string, unknown>;
+type UpdateExplicitKey<C> = [C] extends [AnyModelClass$1] ? PrimaryKeyOf<C> : Record<string, unknown>;
 /**
  * Options accepted by `list()` (third argument). The projection is supplied as
  * the separate second `select` argument, symmetric with `query()`.
@@ -1969,6 +1969,342 @@ interface DeriveEffect {
     /** The amount to add (for an increment). */
     readonly amount: number;
 }
+/**
+ * A model lifecycle event that triggers a maintenance effect, expressed as an
+ * `Entity.event` string — the source entity's class name, a dot, then one of the
+ * lifecycle events. The three events mirror {@link WriteLifecyclePhase}
+ * (`create` / `update` / `remove`) in past-tense event form, so a maintenance
+ * effect is keyed by *what happened* to the source row.
+ *
+ * The string is **branded** ({@link MaintainTrigger}) so a raw `string` is not
+ * accepted where a validated trigger is required; construct one with
+ * {@link maintainTrigger}, which rejects a malformed value.
+ *
+ * @example `'Post.created'`, `'User.updated'`, `'Comment.removed'`
+ */
+type MaintainEvent = 'created' | 'updated' | 'removed';
+/** The brand carried by a validated {@link MaintainTrigger}. */
+declare const MAINTAIN_TRIGGER_BRAND: unique symbol;
+/**
+ * A validated `Entity.event` maintenance trigger string (e.g. `'Post.created'`).
+ * Branded so it is told apart from a raw `string`; build one with
+ * {@link maintainTrigger}. The shape is `${EntityName}.${MaintainEvent}` where
+ * `EntityName` is a non-empty identifier-ish token.
+ */
+type MaintainTrigger = `${string}.${MaintainEvent}` & {
+    readonly [MAINTAIN_TRIGGER_BRAND]: true;
+};
+/**
+ * Construct a validated {@link MaintainTrigger} from an `Entity.event` string.
+ * Rejects a value that is not a non-empty entity name followed by `.created` /
+ * `.updated` / `.removed`, so an invalid trigger is refused at construction time
+ * (the AC's "invalid trigger string is rejected"). The brand is a compile-time
+ * marker only; the returned value is the input string verbatim.
+ *
+ * @throws if `value` is not a well-formed `Entity.event` trigger string.
+ */
+declare function maintainTrigger(value: string): MaintainTrigger;
+/** Runtime guard: is `value` a well-formed {@link MaintainTrigger} string? */
+declare function isMaintainTrigger(value: unknown): value is MaintainTrigger;
+/**
+ * A projection transform op (issue #120, 論点3 = 関数形): the function-form
+ * `w.transform(path, op, ...args)` is the **primary** authoring surface (there is
+ * no string DSL). The initial op set is:
+ *
+ * - `identity` — copy the source path through unchanged (no args).
+ * - `preview` — keep a length-bounded preview of the source value; `n` is the
+ *   bound (`w.transform('$.body', 'preview', 200)`).
+ *
+ * New ops extend this union (and {@link ProjectionTransform}'s `args` shape) as
+ * the maintenance graph (#124) needs them.
+ */
+type ProjectionTransformOp = 'identity' | 'preview';
+/**
+ * One entry in a maintenance projection map: a `w.transform(path, op, ...args)`
+ * IR node binding a source {@link EffectPath} to a target attribute through a
+ * {@link ProjectionTransformOp}. `args` carries the op's positional arguments
+ * (e.g. `preview`'s length bound); `identity` carries none.
+ *
+ * The function form is the only authoring surface (no string DSL); the node is a
+ * plain branded record so the maintenance graph (#124) and compile injection
+ * (#125) can read it without retaining a closure.
+ */
+interface ProjectionTransform {
+    readonly kind: 'transform';
+    /** The path-rooted source value (`$.input.*` / `$.entity.*`). */
+    readonly path: EffectPath;
+    /** The transform op applied to the source value. */
+    readonly op: ProjectionTransformOp;
+    /** The op's positional arguments (e.g. `[200]` for `preview`); empty for `identity`. */
+    readonly args: readonly unknown[];
+}
+/**
+ * A maintenance **projection map**: target attribute name → its
+ * {@link ProjectionTransform}. Generalizes the way {@link DeriveEffect} names a
+ * single derived `attribute`, to a whole projected row / collection item.
+ */
+type ProjectionMap = Readonly<Record<string, ProjectionTransform>>;
+/**
+ * Standalone authoring helper for a `preview` {@link ProjectionTransform}: keep a
+ * length-bounded preview of the source `path` (the first `n` characters). This is
+ * the recorder-free counterpart to `w.transform(path, 'preview', n)` — used where
+ * there is no {@link WriteRecorder} `w`, the relation-options decorator arguments
+ * (epic #118 §5.2 / issue #121, e.g. `projection: { textPreview: preview('body',
+ * 120) }`). It produces the **same** IR node as `w.transform` (both route through
+ * {@link makeProjectionTransform}), so the two surfaces never diverge.
+ *
+ * @param path The source value the preview is taken of (a projection source path).
+ * @param n The preview length bound (a positive integer).
+ * @throws if `n` is not a positive integer.
+ */
+declare function preview(path: EffectPath, n: number): ProjectionTransform;
+/**
+ * Standalone authoring helper for an `identity` {@link ProjectionTransform}: copy
+ * the source `path` through unchanged. The recorder-free counterpart to
+ * `w.transform(path, 'identity')`. In relation-options `projection` maps a bare
+ * `string` path is the idiomatic identity shorthand; this helper is provided for
+ * symmetry / when an explicit IR node is wanted. Routes through
+ * {@link makeProjectionTransform} so it is structurally identical to the recorder
+ * form.
+ *
+ * @param path The source value copied through unchanged.
+ */
+declare function identity(path: EffectPath): ProjectionTransform;
+/**
+ * The **path** a maintenance write travels (shared vocabulary, epic #118 A/B
+ * reconciliation — RFC §5.1 / issue #121 are the authority). `mutation` lands the
+ * maintenance write **synchronously**, in the same `TransactWriteItems` as the
+ * source mutation; `stream` defers it to the **asynchronous** Streams path. This
+ * is the path axis, NOT a write-reconciliation axis.
+ *
+ * NOTE: A(#120) previously defined `updateMode` as an *invented* write-reconcile
+ * axis (`'overwrite' | 'ifNewer'`); that axis is **removed for Phase 1** (論点2=b
+ * fixes "1 mutation × 1 target row = 1 effect", so no reconcile is needed) and the
+ * name is reclaimed for the path vocabulary above. A reconcile axis may be
+ * reintroduced later under a *different* name if a future phase needs it.
+ */
+type MaintainUpdateMode = 'mutation' | 'stream';
+/**
+ * The read/write consistency a maintenance effect is realized under (shared
+ * vocabulary, epic #118 A/B reconciliation — RFC §5.1 / issue #121 are the
+ * authority). `transactional` requires the maintenance write to land in the same
+ * transaction as the source write; `eventual` (the default the consumers assume
+ * when omitted) lets it lag. A's earlier `'strong'` value is **retired** in favor
+ * of `'transactional'`.
+ */
+type MaintainConsistency = 'transactional' | 'eventual';
+/**
+ * A **snapshot** maintenance effect (issue #120): on a {@link MaintainTrigger}
+ * the source's {@link project} is mirrored into a single target row resolved by
+ * {@link targetFactory} + {@link keys}. Generalizes {@link DeriveEffect} from a
+ * single scalar `ADD`/`SET` to a projected row. Consumed by the maintenance graph
+ * (#124) and compile injection (#125); #120 defines the type only.
+ */
+interface SnapshotEffect {
+    readonly kind: 'snapshot';
+    /** The lifecycle event of the source entity that drives the snapshot. */
+    readonly trigger: MaintainTrigger;
+    /** Resolves the target entity whose row holds the snapshot. */
+    readonly targetFactory: () => new (...args: unknown[]) => unknown;
+    /** The key binding of the target row (path-rooted values). */
+    readonly keys: Readonly<Record<string, EffectPath>>;
+    /** The projection map: target attribute → `w.transform(...)` IR. */
+    readonly project: ProjectionMap;
+    /** The path the write travels — synchronous `mutation` tx or async `stream`. */
+    readonly updateMode?: MaintainUpdateMode;
+    /** The consistency the write lands under (default `eventual`). */
+    readonly consistency?: MaintainConsistency;
+}
+/** The sort direction a maintained collection orders by (mirrors the read-side `read.order`). */
+type CollectionOrderDirection = 'ASC' | 'DESC';
+/**
+ * Options for the bounded collection a {@link CollectionEffect} maintains: the
+ * target {@link field} that holds the collection, an optional {@link maxItems}
+ * cap (oldest items are evicted past it), and an optional {@link orderBy} source
+ * path the items are ordered by (with an {@link orderDir} direction).
+ */
+interface CollectionOptions {
+    /** The target attribute that holds the maintained collection. */
+    readonly field: string;
+    /** Cap on the collection size; items past it are evicted (unbounded if omitted). */
+    readonly maxItems?: number;
+    /**
+     * A path-rooted source value the collection is ordered by (e.g. `$.entity.createdAt`).
+     * Wired from the relation's `read.order` (#130 是正2): the field is the source
+     * entity's sort-key leaf (the field the live `hasMany` read orders by via
+     * `ScanIndexForward`), so the materialized collection sorts the SAME way as the
+     * live query. The async drain ({@link import('../cdc/maintenance-drain.js')})
+     * applies the sort + trim; a single synchronous `UpdateExpression` cannot.
+     */
+    readonly orderBy?: EffectPath;
+    /**
+     * The direction {@link orderBy} sorts by — `'DESC'` (newest first, the default a
+     * bare `order: 'DESC'` declares) or `'ASC'`. Present only when {@link orderBy} is.
+     */
+    readonly orderDir?: CollectionOrderDirection;
+}
+/**
+ * A **collection** maintenance effect (issue #120): on a {@link MaintainTrigger}
+ * the source's {@link project} is appended as an item into the bounded collection
+ * named by {@link collection} on the target row resolved by {@link targetFactory}
+ * + {@link keys}. Generalizes {@link DeriveEffect} to a bounded list projection.
+ * Consumed by the maintenance graph (#124) and compile injection (#125); #120
+ * defines the type only.
+ */
+interface CollectionEffect {
+    readonly kind: 'collection';
+    /** The lifecycle event of the source entity that drives the collection write. */
+    readonly trigger: MaintainTrigger;
+    /** Resolves the target entity whose row holds the collection. */
+    readonly targetFactory: () => new (...args: unknown[]) => unknown;
+    /** The key binding of the target row (path-rooted values). */
+    readonly keys: Readonly<Record<string, EffectPath>>;
+    /** The projection map for each collection item: attribute → `w.transform(...)` IR. */
+    readonly project: ProjectionMap;
+    /** The bounded-collection options (`field` / `maxItems` / `orderBy`). */
+    readonly collection: CollectionOptions;
+    /** The path the write travels — synchronous `mutation` tx or async `stream`. */
+    readonly updateMode?: MaintainUpdateMode;
+    /** The consistency the write lands under (default `eventual`). */
+    readonly consistency?: MaintainConsistency;
+}
+/**
+ * The aggregation a {@link CounterEffect} maintains (Epic #118 §5.2 counter /
+ * latest preset; issue #141). The function-form IR `count()` / `max(field)` the
+ * `@aggregate` value helpers build, lifted into the maintenance IR:
+ *
+ * - `count` — the cardinality of the matched source rows: a `created` trigger
+ *   adds `+1`, a `removed` trigger adds `-1` (the {@link CounterEffect.delta}).
+ * - `max` — the running maximum of a named source `field`. A synchronous
+ *   transactional max cannot be expressed as a concurrency-safe single-item
+ *   `UpdateExpression` (a conditional `SET` whose guard fails would roll back the
+ *   *source* write that legitimately happened), so Phase 1 records the IR but the
+ *   compile injection (#141) rejects it for the synchronous `mutation` path —
+ *   `max` is the asynchronous stream path (#130, Phase 2). The op is kept here so
+ *   the IR is complete and the reject is precise.
+ */
+type CounterAggregate = {
+    readonly op: 'count';
+} | {
+    readonly op: 'max';
+    readonly field: string;
+};
+/**
+ * A **counter** maintenance effect (Epic #118 §5.2 counter preset; issue #141): on
+ * a {@link MaintainTrigger} a scalar aggregate on a single target row resolved by
+ * {@link targetFactory} + {@link keys} is kept in sync with the source entity's
+ * lifecycle. Where {@link SnapshotEffect} mirrors a projection and
+ * {@link CollectionEffect} appends an item, a counter applies an atomic scalar
+ * `ADD` — the maintenance-pipeline generalization of the self-lifecycle
+ * {@link DeriveEffect} (`w.increment`, #85), but driven by a CROSS-entity
+ * `maintainedOn` trigger rather than the written entity's own lifecycle.
+ *
+ * For `value.op === 'count'` the {@link delta} is the signed amount the trigger
+ * applies (`+1` on `created`, `-1` on `removed`); the maintenance graph (#124)
+ * derives it from the trigger event. Two counter effects targeting the SAME row in
+ * one mutation MERGE (the symmetric-ADD collapse #92), unlike snapshot/collection
+ * which reject a same-row collision — an `ADD` is commutative.
+ *
+ * Consumed by the maintenance graph (#124, `em.aggregates` walk) and the compile
+ * injection (#141, `DerivedMaintainWrite` of `kind: 'counter'`).
+ */
+interface CounterEffect {
+    readonly kind: 'counter';
+    /** The lifecycle event of the source entity that drives the counter. */
+    readonly trigger: MaintainTrigger;
+    /** Resolves the target entity whose row holds the counter scalar. */
+    readonly targetFactory: () => new (...args: unknown[]) => unknown;
+    /** The key binding of the target row (path-rooted values). */
+    readonly keys: Readonly<Record<string, EffectPath>>;
+    /** The target attribute the aggregate scalar is written to (e.g. `postCount`). */
+    readonly attribute: string;
+    /** The aggregation maintained (`count()` / `max(field)`). */
+    readonly value: CounterAggregate;
+    /**
+     * For `value.op === 'count'`, the signed `ADD` delta this trigger applies
+     * (`+1` created / `-1` removed). Absent for `max` (not realized synchronously).
+     */
+    readonly delta?: number;
+    /** The path the write travels — synchronous `mutation` tx or async `stream`. */
+    readonly updateMode?: MaintainUpdateMode;
+    /** The consistency the write lands under (default `eventual`). */
+    readonly consistency?: MaintainConsistency;
+}
+/**
+ * The comparison op a {@link MembershipPredicate} applies to the source value
+ * (Epic #118 pattern 6 / sparse view, issue #133). The host-side drain evaluates
+ * the predicate against the source payload to decide PUT (true) vs DELETE (false):
+ *
+ * - `truthy` / `falsy` — the source value is/ isn't truthy (no `value`);
+ * - `exists` / `notExists` — the source attribute is present / absent (no `value`);
+ * - `eq` / `ne` — the source value equals / does not equal {@link MembershipPredicate.value}.
+ */
+type MembershipPredicateOp = 'truthy' | 'falsy' | 'exists' | 'notExists' | 'eq' | 'ne';
+/**
+ * A membership predicate over the source payload (Epic #118 pattern 6 / sparse view,
+ * issue #133). When the predicate holds, the view item is PUT (projected); when it
+ * flips false the view item is DELETED. This is the "述語が flip したら view item を
+ * put/delete" maintenance — distinct from a GSI sparse index (an explicit view row,
+ * conditionally present). The `path` is a payload-rooted source value (`$.entity.*` /
+ * `$.input.*`); `value` is the comparand for `eq` / `ne` (absent for the unary ops).
+ */
+interface MembershipPredicate {
+    /** The payload-rooted source value the predicate tests (`$.entity.<field>`). */
+    readonly path: EffectPath;
+    /** The comparison op applied to the source value. */
+    readonly op: MembershipPredicateOp;
+    /** The comparand for `eq` / `ne`; absent for the unary ops. */
+    readonly value?: unknown;
+}
+/**
+ * A **membership** maintenance effect (Epic #118 pattern 6 / sparse view, issue #133):
+ * on a {@link MaintainTrigger} a {@link predicate} is evaluated over the source
+ * payload, and the view row resolved by {@link targetFactory} + {@link keys} is PUT
+ * (its {@link project}ion) when the predicate holds OR DELETED when it does not. A
+ * source `removed` event always deletes the view row (the source no longer exists).
+ *
+ * ## Why this is a NEW effect (not a snapshot/collection)
+ *
+ * A {@link SnapshotEffect} only ever `SET`s (it cannot remove a row when a predicate
+ * flips false) and a {@link CollectionEffect} only appends/splices a list field —
+ * neither expresses "the WHOLE view row appears/disappears as a predicate flips". So
+ * sparse view is a distinct effect carrying a {@link predicate} and a put-or-delete
+ * realization.
+ *
+ * ## Scope (issue #133): the asynchronous (`stream`) path
+ *
+ * The put-vs-delete branch is decided by evaluating the predicate against the source
+ * image, which the host-side CDC drain ({@link import('../cdc/maintenance-drain.js')})
+ * does naturally (it already branches snapshot SET vs collection read-modify-write). A
+ * SYNCHRONOUS membership write would need the atomic transaction to choose Put-vs-Delete
+ * from a runtime predicate (DynamoDB cannot branch an item kind on a value), which is a
+ * larger runtime change deferred as a follow-up; the compile injection rejects a
+ * `mutation`-path membership effect so it is never silently mis-realized.
+ */
+interface MembershipEffect {
+    readonly kind: 'membership';
+    /** The lifecycle event of the source entity that drives the membership write. */
+    readonly trigger: MaintainTrigger;
+    /** Resolves the target (view) entity whose row appears / disappears. */
+    readonly targetFactory: () => new (...args: unknown[]) => unknown;
+    /** The key binding of the view row (path-rooted values). */
+    readonly keys: Readonly<Record<string, EffectPath>>;
+    /** The projection PUT onto the view row when the predicate holds. */
+    readonly project: ProjectionMap;
+    /** The membership predicate (PUT when it holds, DELETE when it flips false). */
+    readonly predicate: MembershipPredicate;
+    /** The path the write travels — `stream` only for issue #133 (see header). */
+    readonly updateMode?: MaintainUpdateMode;
+    /** The consistency the write lands under (default `eventual`). */
+    readonly consistency?: MaintainConsistency;
+}
+/**
+ * The union of maintenance effects a {@link SnapshotEffect}, {@link CollectionEffect},
+ * {@link CounterEffect}, or {@link MembershipEffect} can be. The shared IR the
+ * maintenance graph (#124) and compile injection (#125 snapshot/collection, #141
+ * counter, #133 membership) consume.
+ */
+type MaintainEffect = SnapshotEffect | CollectionEffect | CounterEffect | MembershipEffect;
 /**
  * A domain event (proposal §2 `emits`): an outbox `Put` drained to Streams /
  * `src/cdc/`. Derived by #87 — stored opaquely here.
@@ -2077,6 +2413,21 @@ interface WriteRecorder {
     deleteEdge(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;
+    /**
+     * Build a projection transform IR node (issue #120, 関数形): the primary
+     * function-form authoring surface for a maintenance projection map entry. The
+     * initial ops are `identity` (no args — copy the source path through) and
+     * `preview` (one numeric arg — keep a length-bounded preview). There is no
+     * string DSL. The returned {@link ProjectionTransform} is consumed by the
+     * maintenance graph (#124) / compile injection (#125).
+     *
+     * NOTE (issue #120 scope): the escape-hatch recorders that *attach* a
+     * {@link SnapshotEffect} / {@link CollectionEffect} to a lifecycle
+     * (`w.snapshotInto` / `w.captureInto`) and the `LifecycleEffects.maintain`
+     * wiring are **Phase 2** and are intentionally NOT part of this recorder.
+     */
+    transform(path: EffectPath, op: 'identity'): ProjectionTransform;
+    transform(path: EffectPath, op: 'preview', n: number): ProjectionTransform;
     /** Declare a domain event (§2 `emits`; derived #87). */
     event(name: string, payload: Readonly<Record<string, EffectPath>>): EmitEffect;
     /** Declare an idempotency guard (§2 `idempotency`; derived #87). */
@@ -2400,6 +2751,605 @@ declare function mutation(name: string, body: MutationBody): CommandPlan;
  */
 declare const definePlan: typeof mutation;
 
+/**
+ * `defineView` / `defineProjection` — the maintained **view** and **external
+ * projection** definition DSL (Epic #118 Phase 2, issue #132 child M).
+ *
+ * ## Where this sits in the `define*` family
+ *
+ * This module extends the record-of-definitions pattern of
+ * `src/define/define.ts` (`defineQuery`/`defineList`/… grouped by
+ * `defineQueries`/`defineCommands`) with two new families that declare a single
+ * **view** node → IR:
+ *
+ * - {@link defineView} (`materializedView`) — declares an INDEPENDENT view row
+ *   maintained from the lifecycle events of one or more **source** entities. The
+ *   view row is its OWN modelled row (a `DDBModel` with its own `keys`), NOT a
+ *   field of any source entity — the "特定エンティティのフィールドでない単体行" of
+ *   RFC §5.3. RFC §5.3:
+ *   ```ts
+ *   defineView(UserThreadListModel, {
+ *     pattern: 'materializedView',
+ *     source: [{ entity: () => PostModel, maintainedOn: ['Post.created'], … }, …],
+ *     keys:   { userId: '$.entity.userId' },
+ *     fields: { … },        // per-source projection of the view row
+ *     write:  { updateMode: 'stream' },
+ *   })
+ *   ```
+ * - {@link defineProjection} (`externalProjection`) — declares a stream + idempotency
+ *   projection of a source entity into an EXTERNAL sink (BigQuery / S3 / OpenSearch
+ *   in production; the CDC emulator in dev/test). RFC §5.3:
+ *   ```ts
+ *   defineProjection('TestCaseResultBQ', {
+ *     pattern: 'externalProjection',
+ *     source: () => TestCaseResultModel,
+ *     via: 'stream',
+ *     idempotencyKey: 'resultId',
+ *   })
+ *   ```
+ *
+ * `defineViews({...})` / `defineProjections({...})` take a record of these
+ * definition nodes and return the same record (typed), forming the IR the
+ * maintenance graph (#124, extended here as the third maintenance source after
+ * relations and aggregates) and the projection sink consume — exactly the
+ * `defineQueries`/`defineCommands`样式.
+ *
+ * ## Why a view is its own definition (not a relation `@hasMany`)
+ *
+ * A relation/aggregate maintainer (#124) hangs off a MODELLED entity row — its
+ * destination is a `DDBModel` class resolved by the relation owner, and its
+ * single source is the relation's `to`. A **materialized view** is the
+ * complementary case the RFC §5.3 calls out: an independent row fed by SEVERAL
+ * foreign sources (none of which is the view itself). So it cannot be a relation
+ * decorator on a source; it is its own top-level declaration whose destination is
+ * the dedicated **view model** row. That view model is a normal `DDBModel` (so the
+ * maintenance graph / drain / rebuild resolve its key with the SAME machinery they
+ * use for a relation owner — no parallel key system), but it is the owner of NO
+ * relation: the sources point INTO it, declared here rather than on the sources.
+ *
+ * ## Scope boundary (payload-同梱; multi-source as per-source slices)
+ *
+ * Each `source` projects ONLY from its own payload (the same payload-同梱 rule
+ * the relation maintenance graph enforces — RFC §4.A.6 `requiredContext` /
+ * write-time-fetch is a deferred follow-up). A multi-source view is therefore
+ * maintained as a UNION of per-source slices on one view row: `Post.created`
+ * updates the Post-projected `fields`, `Thread.read` updates the Thread-projected
+ * `fields`, each converging the shared view row through the K (#130) stream →
+ * outbox → drain path. A field whose value must combine attributes from more than
+ * one source in a single write (a cross-source join at maintenance time) is the
+ * `requiredContext` case and is out of scope — see the module-level note and the
+ * issue report.
+ */
+
+type AnyModelClass = abstract new (...args: any[]) => DDBModel;
+/** A source-entity factory: a model class or a `ModelStatic` wrapper. */
+type SourceFactory = () => AnyModelClass | ModelStatic<DDBModel>;
+/** A bare-string identity shorthand or an explicit `w.transform(...)` IR node. */
+type ProjectionEntry = ProjectionTransform | string;
+/**
+ * Build a {@link MembershipPredicate} for a sparse view (Epic #118 pattern 6 / #133).
+ * The view row is PUT when the predicate holds and DELETED when it flips false. The
+ * `path` is normalized to a payload-rooted source value (a bare field name becomes
+ * `$.entity.<field>`).
+ *
+ * Named `whenMember` (not `when`) to avoid colliding with the transaction-condition
+ * `when` helper (`src/define/transaction.ts`).
+ *
+ * @example `whenMember('status', 'eq', 'active')` — the view row exists only while
+ *   `status === 'active'`.
+ * @example `whenMember('archived', 'falsy')` — the view row exists only while
+ *   `archived` is falsy.
+ */
+declare function whenMember(field: string, op: MembershipPredicateOp, value?: unknown): MembershipPredicate;
+/**
+ * One source contributing to a maintained view (issue #132). The source entity's
+ * lifecycle events ({@link maintainedOn}) drive the maintenance; its payload is
+ * projected into the view row's {@link fields} (payload-同梱). When the source
+ * maintains an ordered/bounded slice (a collection-shaped view) it declares
+ * {@link collection}; otherwise it maintains a single snapshot slice.
+ */
+interface ViewSource {
+    /** Resolves the source entity whose lifecycle drives this slice of the view. */
+    readonly entity: SourceFactory;
+    /**
+     * The cross-entity triggers this source fires on (`'<Entity>.<event>'`, the
+     * shared `created`/`updated`/`removed` vocabulary). The entity segment must be
+     * the source entity's logical name (the maintenance graph validates it).
+     */
+    readonly maintainedOn: readonly string[];
+    /**
+     * The view-row key binding for THIS source: view-row key field → a path-rooted
+     * source value (`$.entity.<field>` / `$.input.<field>`). Resolves which view
+     * row this source event maintains. When omitted, the view-level {@link
+     * ViewDefinitionInput.keys} is used (the common case — every source keys the
+     * view row the same way).
+     */
+    readonly keys?: Readonly<Record<string, EffectPath>>;
+    /**
+     * The projection of THIS source's payload into the view row (target attribute →
+     * identity shorthand string / `w.transform(...)`). When omitted, the view-level
+     * {@link ViewDefinitionInput.fields} is used.
+     */
+    readonly fields?: Readonly<Record<string, ProjectionEntry>>;
+    /**
+     * Declares this source maintains a bounded, ordered COLLECTION slice of the view
+     * row (e.g. "latest N posts") rather than a single snapshot. The `field` names
+     * the view-row attribute holding the list; `maxItems` / `order` shape it.
+     */
+    readonly collection?: {
+        readonly field: string;
+        readonly maxItems?: number;
+        readonly order?: 'ASC' | 'DESC';
+        /** The source path the collection orders by + trims on (e.g. `$.entity.createdAt`). */
+        readonly orderBy?: EffectPath;
+    };
+    /**
+     * Sparse-view predicate (Epic #118 pattern 6 / #133): when present, this source
+     * maintains a MEMBERSHIP slice — the view row is PUT (projected) while the predicate
+     * holds and DELETED when it flips false (and always deleted on a source `removed`).
+     * Build it with {@link whenMember} (e.g. `whenMember('status', 'eq', 'active')`). Mutually
+     * exclusive with {@link collection} (a row either appears/disappears or holds a list).
+     */
+    readonly when?: MembershipPredicate;
+}
+/** The author-facing input to {@link defineView}. */
+interface ViewDefinitionInput {
+    /** The maintenance preset — `'materializedView'` (snapshot/collection) or `'sparseView'` (membership). */
+    readonly pattern?: 'materializedView' | 'sparseView';
+    /** One or more sources whose lifecycle events maintain the view row. */
+    readonly source: ViewSource | readonly ViewSource[];
+    /**
+     * The default view-row key binding (view-row key field → path-rooted source
+     * value). A source may override it with its own `keys`. At least one of the
+     * view-level `keys` or every source's `keys` must be present.
+     */
+    readonly keys?: Readonly<Record<string, EffectPath>>;
+    /** The default per-source projection of the view row (source may override). */
+    readonly fields?: Readonly<Record<string, ProjectionEntry>>;
+    /** Maintenance-write declaration shared by the sources (`updateMode` / `consistency`). */
+    readonly write?: {
+        readonly updateMode?: MaintainUpdateMode;
+        readonly consistency?: MaintainConsistency;
+    };
+}
+/** Marks an object as a {@link ViewDefinition} IR node. */
+declare const VIEW_DEFINITION_MARKER: unique symbol;
+/**
+ * The global registry of declared {@link ViewDefinition}s (issue #132). A
+ * `defineView(...)` registers itself here so the compile-side global maintenance
+ * graph (and the linter) discovers view maintainers WITHOUT the caller threading
+ * the definitions through — the same way `@model` auto-registers an entity in
+ * `MetadataRegistry`. A {@link generation} counter (bumped on every register /
+ * clear) lets a cache keyed off it invalidate when a view is added, so a
+ * newly-declared view is never silently dropped from the compile path.
+ */
+declare class ViewRegistry {
+    private static readonly views;
+    private static gen;
+    /** Register (or replace, by view class) a declared view. Bumps the generation. */
+    static register(def: ViewDefinition): void;
+    /** Every registered view, in declaration order. */
+    static getAll(): readonly ViewDefinition[];
+    /** The monotonic generation counter (changes whenever the set of views changes). */
+    static get generation(): number;
+    /** Forget every registered view (test reset). Bumps the generation. */
+    static clear(): void;
+}
+/**
+ * The lowered per-source maintenance slice of a view — one entry per (source ×
+ * trigger), carrying the resolved source class, the validated triggers, the view
+ * row key binding, and the projection. Consumed by the maintenance graph (#124)
+ * which synthesizes the A-defined `SnapshotEffect` / `CollectionEffect` from it.
+ */
+interface ViewSourceSlice {
+    /** The resolved source model class (the lifecycle origin / projected payload). */
+    readonly sourceClass: AnyModelClass;
+    /** The validated triggers this slice fires on. */
+    readonly maintainedOn: readonly MaintainTrigger[];
+    /** The view-row key binding (view-row key field → path-rooted source value). */
+    readonly keys: Readonly<Record<string, EffectPath>>;
+    /** The projection map (target attribute → `w.transform(...)` IR). */
+    readonly project: ProjectionMap;
+    /** Bounded/ordered collection options when this slice maintains a list. */
+    readonly collection?: {
+        readonly field: string;
+        readonly maxItems?: number;
+        readonly orderBy?: EffectPath;
+        readonly orderDir?: 'ASC' | 'DESC';
+    };
+    /**
+     * Sparse-view membership predicate (Epic #118 pattern 6 / #133) when this slice
+     * maintains a put/delete membership row. The maintenance graph synthesizes a
+     * `MembershipEffect` (not a snapshot) from it.
+     */
+    readonly predicate?: MembershipPredicate;
+}
+/**
+ * The IR for one `defineView` node — an independent materialized-view row
+ * maintained from one or more source entities. The `name` is the view's logical
+ * identity; `viewClass` is the dedicated view model the row lives on (the
+ * maintenance destination); `slices` are the lowered per-source maintenance
+ * contributions the maintenance graph turns into effects.
+ */
+interface ViewDefinition {
+    readonly [VIEW_DEFINITION_MARKER]: true;
+    /** The view's logical name (e.g. `'UserThreadList'`). */
+    readonly name: string;
+    /** The dedicated view model class the maintained row lives on (the destination). */
+    readonly viewClass: AnyModelClass;
+    /** The maintenance preset (`'materializedView'` or `'sparseView'`). */
+    readonly pattern: 'materializedView' | 'sparseView';
+    /** The lowered per-source maintenance slices. */
+    readonly slices: readonly ViewSourceSlice[];
+    /** The path the maintenance writes travel (`mutation` / `stream`). */
+    readonly updateMode?: MaintainUpdateMode;
+    /** The consistency the maintenance writes land under. */
+    readonly consistency?: MaintainConsistency;
+}
+/** Runtime guard: is `value` a {@link ViewDefinition}? */
+declare function isViewDefinition(value: unknown): value is ViewDefinition;
+/**
+ * Define a single maintained **view** (`materializedView`, issue #132): an
+ * independent view row (on the dedicated `view` model) maintained from one or more
+ * source entities' lifecycle events, projecting each source's payload (payload-同梱)
+ * into the view row. The returned {@link ViewDefinition} is the IR the maintenance
+ * graph (#124) consumes as a third maintenance source (after relations /
+ * aggregates), so a view row converges through the SAME stream → outbox → drain
+ * path (K, #130).
+ *
+ * @param view The dedicated view model class the maintained row lives on (a normal
+ *   `DDBModel` with its own `keys`). Its logical name is the view's `name`.
+ * @param input The view's sources / key binding / projection / write declaration.
+ *
+ * @example
+ * ```ts
+ * const UserThreadList = defineView(UserThreadListModel, {
+ *   pattern: 'materializedView',
+ *   keys: { userId: '$.entity.userId' },
+ *   source: [
+ *     { entity: () => PostModel, maintainedOn: ['Post.created'],
+ *       fields: { lastPostId: 'postId', lastPostAt: 'createdAt' } },
+ *     { entity: () => ThreadModel, maintainedOn: ['Thread.updated'],
+ *       fields: { threadTitle: 'title' } },
+ *   ],
+ *   write: { updateMode: 'stream' },
+ * });
+ * ```
+ */
+declare function defineView(view: AnyModelClass | ModelStatic<DDBModel>, input: ViewDefinitionInput): ViewDefinition;
+/** A record of view-name → {@link ViewDefinition}. */
+type ViewDefinitionMap = Record<string, ViewDefinition>;
+/**
+ * Group a record of {@link defineView} nodes into the view IR consumed by the
+ * maintenance graph (#124). Validates that every entry is a `defineView` node —
+ * the `defineQueries`/`defineCommands` 様式.
+ */
+declare function defineViews<const D extends ViewDefinitionMap>(definitions: D): D;
+/** The author-facing input to {@link defineVersioned}. */
+interface VersionedDefinitionInput {
+    /** The maintenance preset — `'versioned'`. */
+    readonly pattern?: 'versioned';
+    /** Resolves the source entity whose lifecycle events maintain both rows. */
+    readonly source: SourceFactory;
+    /**
+     * The triggers that maintain a new version (`'<Entity>.<event>'`). Typically
+     * `['Doc.created', 'Doc.updated']` — every persisted revision advances the latest
+     * pointer and appends a history row.
+     */
+    readonly maintainedOn: readonly string[];
+    /**
+     * The LATEST-pointer row's key binding (latest-model key field → path-rooted source
+     * value). It must NOT include the version discriminator — the latest row is
+     * OVERWRITTEN on each revision (one row per source identity, e.g. `{ docId:
+     * '$.entity.docId' }`).
+     */
+    readonly latestKeys: Readonly<Record<string, EffectPath>>;
+    /**
+     * The HISTORY row's key binding (history-model key field → path-rooted source value).
+     * It MUST include the version discriminator so each revision is a NEW row (append-only
+     * history, e.g. `{ docId: '$.entity.docId', version: '$.entity.version' }`).
+     */
+    readonly historyKeys: Readonly<Record<string, EffectPath>>;
+    /** The projection of the source payload into BOTH rows (target attribute → source). */
+    readonly fields: Readonly<Record<string, ProjectionEntry>>;
+    /** Maintenance-write declaration shared by both rows (`updateMode` / `consistency`). */
+    readonly write?: {
+        readonly updateMode?: MaintainUpdateMode;
+        readonly consistency?: MaintainConsistency;
+    };
+}
+/**
+ * The pair of {@link ViewDefinition}s a {@link defineVersioned} lowers to — the
+ * latest-pointer snapshot row and the append-only history snapshot row.
+ */
+interface VersionedDefinition {
+    /** The LATEST-pointer row (a snapshot, overwritten on each revision). */
+    readonly latest: ViewDefinition;
+    /** The append-only HISTORY row (one snapshot row per version). */
+    readonly history: ViewDefinition;
+}
+/**
+ * Define a **versioned / latest-pointer** maintained access path (Epic #118 pattern 8,
+ * issue #133): from one source revision, maintain a LATEST-pointer row (overwritten in
+ * place) AND append a HISTORY row (one per version) in a single composed write.
+ *
+ * ## Lowering = composition of two snapshot effects (no new effect)
+ *
+ * Per the design hint "既存の snapshot（latest）+ 別行追記（history）の合成で表現できるか",
+ * `versioned` is **pure composition** of the existing {@link SnapshotEffect}:
+ *
+ * - the LATEST row is a snapshot keyed by the source identity WITHOUT the version
+ *   (`latestKeys`) → re-projecting the same key OVERWRITES the pointer in place;
+ * - the HISTORY row is a snapshot keyed by the source identity PLUS the version
+ *   (`historyKeys`) → each revision resolves a NEW row, so history is append-only.
+ *
+ * Both are lowered as {@link defineView} (`materializedView`) nodes — the maintenance
+ * graph synthesizes a `SnapshotEffect` per source trigger, and because the two rows
+ * resolve to DIFFERENT destination rows (distinct models / keys) the same-row collision
+ * guard is satisfied and BOTH fire from the one source mutation: the latest pointer and
+ * the history row land together (in one atomic tx for `updateMode: 'mutation'`, or
+ * converge through the stream → drain path for `'stream'`). There is NO new maintenance
+ * primitive — the existing snapshot pipeline (sync #127 / stream #130 / rebuild #131)
+ * carries both.
+ *
+ * @param latest The dedicated LATEST-pointer view model (one row per source identity).
+ * @param history The dedicated HISTORY view model (one row per version).
+ * @param input The source / triggers / key bindings / projection / write declaration.
+ *
+ * @example
+ * ```ts
+ * const DocVersioned = defineVersioned(DocLatestModel, DocVersionModel, {
+ *   pattern: 'versioned',
+ *   source: () => DocModel,
+ *   maintainedOn: ['Doc.created', 'Doc.updated'],
+ *   latestKeys: { docId: '$.entity.docId' },
+ *   historyKeys: { docId: '$.entity.docId', version: '$.entity.version' },
+ *   fields: { docId: 'docId', version: 'version', title: 'title' },
+ *   write: { updateMode: 'mutation' },
+ * });
+ * ```
+ */
+declare function defineVersioned(latest: AnyModelClass | ModelStatic<DDBModel>, history: AnyModelClass | ModelStatic<DDBModel>, input: VersionedDefinitionInput): VersionedDefinition;
+/** Marks an object as a {@link ProjectionDefinition} IR node. */
+declare const PROJECTION_DEFINITION_MARKER: unique symbol;
+/** The transport a projection travels — only `stream` (async) in this phase. */
+type ProjectionVia = 'stream';
+/** The author-facing input to {@link defineProjection}. */
+interface ProjectionDefinitionInput {
+    /** The maintenance preset — `'externalProjection'`. */
+    readonly pattern?: 'externalProjection';
+    /** Resolves the source entity whose lifecycle events are projected to the sink. */
+    readonly source: SourceFactory;
+    /** The transport (`'stream'` — async CDC; the only supported value this phase). */
+    readonly via?: ProjectionVia;
+    /**
+     * The source attribute whose value is the **idempotency key** for at-least-once
+     * de-duplication at the sink (e.g. `'resultId'`). A redelivered source event
+     * with the same key is folded to one sink upsert.
+     */
+    readonly idempotencyKey: string;
+    /**
+     * The lifecycle events projected. Defaults to every event of the source
+     * (`created` / `updated` / `removed`) when omitted.
+     */
+    readonly on?: readonly ('created' | 'updated' | 'removed')[];
+    /**
+     * Optional projection of the source payload into the sink record (target
+     * attribute → identity shorthand / transform). When omitted the whole source
+     * `newImage` is projected.
+     */
+    readonly fields?: Readonly<Record<string, ProjectionEntry>>;
+}
+/**
+ * The IR for one `defineProjection` node — a stream + idempotency projection of a
+ * source entity into an external sink. Consumed by the projection sink runtime
+ * ({@link import('../cdc/projection-sink.js')}), which subscribes to
+ * the CDC stream and upserts the projected record into the sink, folding
+ * at-least-once delivery by {@link idempotencyKey}.
+ */
+interface ProjectionDefinition {
+    readonly [PROJECTION_DEFINITION_MARKER]: true;
+    /** The projection's logical name (e.g. `'TestCaseResultBQ'`). */
+    readonly name: string;
+    /** The maintenance preset (always `'externalProjection'`). */
+    readonly pattern: 'externalProjection';
+    /** The resolved source model class whose events are projected. */
+    readonly sourceClass: AnyModelClass;
+    /** The transport (`'stream'`). */
+    readonly via: ProjectionVia;
+    /** The source attribute used as the idempotency key at the sink. */
+    readonly idempotencyKey: string;
+    /** The lifecycle events projected (defaults to all three). */
+    readonly on: readonly ('created' | 'updated' | 'removed')[];
+    /** The optional projection map (target attribute → transform IR); empty = whole image. */
+    readonly project: ProjectionMap;
+}
+/** Runtime guard: is `value` a {@link ProjectionDefinition}? */
+declare function isProjectionDefinition(value: unknown): value is ProjectionDefinition;
+/**
+ * Define a single **external projection** (`externalProjection`, issue #132): a
+ * stream + idempotency projection of a source entity into an external sink
+ * (BigQuery / S3 / OpenSearch in production; the CDC emulator + an in-process sink
+ * in dev/test). At-least-once delivery is folded to one sink upsert per genuine
+ * source event by the {@link ProjectionDefinitionInput.idempotencyKey}.
+ *
+ * @example
+ * ```ts
+ * const TestCaseResultBQ = defineProjection('TestCaseResultBQ', {
+ *   pattern: 'externalProjection',
+ *   source: () => TestCaseResultModel,
+ *   via: 'stream',
+ *   idempotencyKey: 'resultId',
+ * });
+ * ```
+ */
+declare function defineProjection(name: string, input: ProjectionDefinitionInput): ProjectionDefinition;
+/** A record of projection-name → {@link ProjectionDefinition}. */
+type ProjectionDefinitionMap = Record<string, ProjectionDefinition>;
+/**
+ * Group a record of {@link defineProjection} nodes into the projection IR consumed
+ * by the projection sink runtime. Validates every entry is a `defineProjection`
+ * node — the `defineQueries`/`defineCommands` 様式.
+ */
+declare function defineProjections<const D extends ProjectionDefinitionMap>(definitions: D): D;
+
+/**
+ * Maintenance graph builder (Epic #118 issue #124 — the RFC B-案 core).
+ *
+ * ## What this module is
+ *
+ * A relation may declare a **maintenance** side via its relation options
+ * (issue #121, the B work): `write.maintainedOn` lists the cross-entity
+ * lifecycle triggers (`"<Entity>.<event>"`, e.g. `"Post.created"`) that should
+ * keep the relation's materialized shape in sync, and `projection` declares how
+ * the source entity is projected into that shape. This module walks every
+ * registered model (`MetadataRegistry.getAll()`), reads those relation-side
+ * declarations, and builds an **index**:
+ *
+ *     trigger source entity × lifecycle event (created/updated/removed)
+ *         → list of maintenance effects to apply
+ *
+ * That index is exactly the question the compile-injection step (#125) asks of
+ * a mutation: "this mutation `created` a `Post` — what must be maintained?". This
+ * module answers *which* effect fires for *which* trigger, and validates that
+ * every declared effect is realizable (round-trips with the read side); it does
+ * **not** inject anything into the compiler — see "Scope" below.
+ *
+ * ## Input is relation-side declarations only (論点1 = c)
+ *
+ * The only input is each relation's `options.write.maintainedOn` +
+ * `options.projection` (the #121 relation options). The `entityWrites` escape
+ * hatch (`w.snapshotInto` / `w.captureInto` attached to a lifecycle) is **Phase
+ * 2** and is deliberately not read here.
+ *
+ * ## Reuses the A (#120) maintenance IR — no second definition
+ *
+ * The maintenance effect each index entry carries is the **A-defined IR** —
+ * {@link SnapshotEffect} / {@link CollectionEffect} / {@link ProjectionTransform}
+ * from `src/define/entity-writes.ts` (also re-exported from the root barrel). This
+ * module *synthesizes* those nodes from the relation-side declaration (it is the
+ * relation-options → IR lowering); it never re-defines the IR shapes.
+ *
+ * ## Round-trip validation (流用 of `assertRelationRoundTrips`)
+ *
+ * Mirroring `src/relation/edge-write.ts`'s build-time round-trip guard, the graph
+ * is verified the moment it is built, and a mis-declaration is a **loud reject**:
+ *
+ * - **Snapshot/collection target key points at a real row.** The relation's
+ *   `keyBinding` target fields must resolve to a real access pattern on the
+ *   target entity (the row that holds the snapshot/collection), via the *same*
+ *   {@link resolveKey} the read planner uses. A binding that covers no partition
+ *   would write/read an unreachable row → reject.
+ * - **Projection source attributes exist on the source payload (論点4 = payload
+ *   同梱のみ).** Every projection source path (`$.entity.<field>` /
+ *   `$.input.<field>`) must name an attribute that the *source* entity (the
+ *   trigger origin) actually carries. There is no fetch / re-projection: an
+ *   attribute that is not in the source payload is rejected, not fetched.
+ * - **Unresolved trigger.** A trigger whose entity segment names no registered
+ *   model, or whose event is not `created`/`updated`/`removed`, is rejected.
+ * - **Cycle.** A maintenance dependency cycle (entity A's event maintains a
+ *   shape on B while B's event maintains a shape on A, transitively) is detected
+ *   and rejected — an unbounded maintenance cascade.
+ *
+ * ## Scope (#124 only — NOT #125)
+ *
+ * This module builds and validates the index, and exposes enough structure for
+ * the compile-injection step (#125/#126) to consume it — including the material
+ * to detect that *two* maintainers target the **same** target row (論点2 = b,
+ * "1 mutation × 1 target row = 1 effect"). It does **not** resolve maintainers
+ * into the mutation compiler, derive `DerivedMaintainWrite`s, or emit any
+ * transaction items; `resolveMaintainers` / `deriveMaintainItems` are #125's.
+ */
+
+type ModelClass = new (...args: unknown[]) => unknown;
+/**
+ * One maintenance effect, keyed in the graph by its {@link trigger}. Synthesized
+ * from a single relation's maintenance declaration (its `write.maintainedOn` +
+ * `projection`).
+ *
+ * The role mapping follows RFC §5.1 (`relation({ from, to, maintainedOn })`):
+ *
+ * - **source** = the relation's `to` (its `targetFactory()`): the entity whose
+ *   lifecycle event fires the maintenance and whose payload is projected. The
+ *   trigger's `Entity` segment names this source.
+ * - **owner** = the relation's `from` (the model declaring the relation): the row
+ *   that *holds* the maintained snapshot / collection — the **destination** of the
+ *   maintenance write.
+ *
+ * So a `Post.created` trigger on `ThreadSummary.latestPosts → Post` maintains the
+ * `ThreadSummary` (owner) row from the `Post` (source) payload. It carries the
+ * A-defined {@link MaintainEffect} IR ({@link SnapshotEffect} /
+ * {@link CollectionEffect}) the maintenance lowers to.
+ */
+interface MaintainItem {
+    /** The validated `Entity.event` trigger that fires this effect. */
+    readonly trigger: MaintainTrigger;
+    /**
+     * The source entity name (trigger origin — the row whose lifecycle fires this
+     * and whose payload is projected). Equals the relation's target (`to`).
+     */
+    readonly sourceEntity: string;
+    /** The source model class (the relation's `targetFactory()`). */
+    readonly sourceClass: ModelClass;
+    /**
+     * The entity that *declares* the maintaining relation (the relation owner /
+     * `from`) — the row that holds the maintained snapshot / collection (the
+     * maintenance write **destination**).
+     */
+    readonly ownerEntity: string;
+    /** The owner model class (the maintenance destination). */
+    readonly ownerClass: ModelClass;
+    /** The relation property on the owner that declares this maintenance. */
+    readonly relationProperty: string;
+    /**
+     * A stable key for the **destination row** a single trigger writes (the owner
+     * row), derived from the relation's bound owner-key fields. Two
+     * {@link MaintainItem}s firing on the same trigger with the same
+     * {@link destinationRowKey} write the same row — the material #125/#126 uses to
+     * enforce 論点2 = b ("1 mutation × 1 target row = 1 effect"; multiple is a
+     * reject). Built deterministically (sorted), so it is a directly comparable
+     * string.
+     */
+    readonly destinationRowKey: string;
+    /** The A-defined maintenance IR this relation lowers to. */
+    readonly effect: MaintainEffect;
+}
+/**
+ * The maintenance graph: the trigger → effects index plus the validation surface.
+ *
+ * `byTrigger` is the core index: a `MaintainTrigger` (`"Post.created"`) maps to
+ * every {@link MaintainItem} that fires on it, in a stable order (owner entity,
+ * then relation property). Empty (no entry) for a trigger nothing maintains on.
+ */
+interface MaintenanceGraph {
+    /** Every maintenance item, flattened, in deterministic order. */
+    readonly items: readonly MaintainItem[];
+    /** The core index: trigger → the effects it fires. */
+    readonly byTrigger: ReadonlyMap<MaintainTrigger, readonly MaintainItem[]>;
+    /** Look up the effects fired by a trigger (empty array if none). */
+    effectsFor(trigger: MaintainTrigger): readonly MaintainItem[];
+    /**
+     * Items that, under the SAME trigger, write the SAME target row — grouped by
+     * `"<trigger><targetRowKey>"`. Only groups with **more than one** item are
+     * present, so an empty map means no trigger has a multi-maintainer collision.
+     * This is the detection material for 論点2 = b; #124 surfaces it, #125/#126
+     * decide the reject. (Build-time we do NOT reject here — a model may legitimately
+     * declare overlapping shapes that a later phase reconciles; #124's contract is
+     * to make the collision *detectable*.)
+     */
+    readonly multiMaintainerTargets: ReadonlyMap<string, readonly MaintainItem[]>;
+}
+/**
+ * Build the {@link MaintenanceGraph} from every registered model's relation-side
+ * maintenance declarations (`MetadataRegistry.getAll()`), validating each as it is
+ * collected (round-trip, unresolved trigger) and the whole graph (cycle) before
+ * returning. Throws a loud, actionable error on any invalid declaration.
+ *
+ * @param registry The models to scan. Defaults to `MetadataRegistry.getAll()`;
+ *   an explicit map is accepted for tests / scoped builds.
+ */
+declare function buildMaintenanceGraph(registry?: ReadonlyMap<Function, EntityMetadata>, views?: readonly ViewDefinition[]): MaintenanceGraph;
+
 /**
  * Serializable static operation specs and manifest (issue #42, Python-bridge
  * Phase 0b).
@@ -2764,6 +3714,101 @@ interface TransactionItemSpec {
      * entity / edge / counter / ConditionCheck item), so those paths are unchanged.
      */
     readonly literalKey?: boolean;
+    /**
+     * A **relation-side maintenance write** (Epic #118, issue #129 — the JSON-SSoT /
+     * Python mirror of the TS in-process `renderMaintainWriteItem`). Present ONLY on an
+     * `Update` item that materializes a maintained access path: a projected
+     * {@link DerivedMaintainWrite} of a just-written source row into a SEPARATE owner
+     * (destination) row, in the SAME atomic transaction as the source write.
+     *
+     * The item's {@link keyCondition} carries the owner row's key templates (bound from
+     * the source payload — `{sourceInputField}`), so the same key derivation / collapse
+     * signature the other `Update` items use applies unchanged. This `maintain` payload
+     * carries the projection transform IR (`identity` / `preview`) the runtimes apply
+     * IDENTICALLY when rendering the `SET … = :v` (snapshot) / `list_append(…)`
+     * (collection) `UpdateExpression`, so the maintained row is byte-consistent across
+     * TS and Python. The `changes` / `add` fields are NOT used when this is present.
+     */
+    readonly maintain?: MaintainItemSpec;
+}
+/**
+ * The transform op applied to one projected maintenance attribute (Epic #118).
+ * Mirrors `ProjectionTransformOp` from `src/define/entity-writes.ts`: `identity`
+ * copies the source value through unchanged; `preview` keeps the first `n`
+ * characters of (the string form of) the source value. The runtimes apply this
+ * IDENTICALLY so the maintained row is byte-consistent.
+ */
+type MaintainProjectionOp = 'identity' | 'preview';
+/**
+ * One projected maintenance attribute: the source value is read from the mutation
+ * input field {@link inputField} (payload 同梱 — the just-written source row image),
+ * then run through {@link op} with {@link args} (e.g. `preview`'s length bound).
+ */
+interface MaintainProjectionEntry {
+    /** The transform op applied to the source value (`identity` / `preview`). */
+    readonly op: MaintainProjectionOp;
+    /** The op's positional arguments (`[n]` for `preview`; empty for `identity`). */
+    readonly args: readonly unknown[];
+    /** The mutation-input field the source value is read from (`{inputField}`). */
+    readonly inputField: string;
+}
+/**
+ * The bounded-collection options a `collection` maintenance write carries. Phase 1
+ * is **append-only**: `maxItems` / `orderBy` are recorded for the future async trim
+ * (#130) but NOT applied synchronously — a single `UpdateExpression` cannot
+ * read-modify-write a bounded/ordered list.
+ */
+interface MaintainCollectionSpec {
+    /** The target attribute that holds the maintained collection. */
+    readonly field: string;
+    /** Cap on the collection size (recorded for #130; not trimmed in Phase 1). */
+    readonly maxItems?: number;
+    /** The mutation-input field the items are ordered by (recorded for #130). */
+    readonly orderBy?: string;
+    /** The direction `orderBy` sorts by, from the relation's `read.order` (recorded for #130). */
+    readonly orderDir?: 'ASC' | 'DESC';
+}
+/**
+ * The maintenance payload an `Update` {@link TransactionItemSpec} carries when it
+ * materializes a maintained access path (Epic #118 / #129). A `snapshot` mirrors
+ * the projection onto the owner row via `SET`; a `collection` appends the projection
+ * as an item into the bounded list named by {@link collection} via `list_append`.
+ */
+interface MaintainItemSpec {
+    /**
+     * Whether the write mirrors a single row (`snapshot`), appends a collection item
+     * (`collection`), or applies a scalar `ADD` counter (`counter`, Epic #118 / #141).
+     */
+    readonly kind: 'snapshot' | 'collection' | 'counter';
+    /** The relation property / `@aggregate` field that declared this maintenance (documentary). */
+    readonly relationProperty: string;
+    /** The trigger (`<sourceLogicalName>.<event>`) that fired this maintenance. */
+    readonly trigger: string;
+    /** target attribute → its projection transform (source field + op + args). Empty for `counter`. */
+    readonly projection: Readonly<Record<string, MaintainProjectionEntry>>;
+    /** The bounded-collection options; present only for `kind: 'collection'`. */
+    readonly collection?: MaintainCollectionSpec;
+    /**
+     * The scalar counter `ADD`; present only for `kind: 'counter'` (#141). The runtimes
+     * render `ADD #attr :delta` — an atomic, concurrency-safe increment that MERGES with
+     * a same-row counter ADD (#92), the maintenance-pipeline analogue of the
+     * self-lifecycle derived counter's `add` slot. `delta` is a numeric template string
+     * (the compile-time constant `+1` created / `-1` removed).
+     */
+    readonly counter?: MaintainCounterSpec;
+}
+/**
+ * The scalar counter a `counter` maintenance write applies (Epic #118 / #141): an
+ * atomic `ADD #attribute :delta`. `delta` is a literal numeric template string (the
+ * compile-time constant the trigger fixed — `"1"` created / `"-1"` removed); the
+ * runtimes serialize it as a number. Only `count()` is realized synchronously
+ * (`max(field)` is rejected for the synchronous path — #130 / Phase 2).
+ */
+interface MaintainCounterSpec {
+    /** The target attribute the counter increments (e.g. `postCount`). */
+    readonly attribute: string;
+    /** The signed `ADD` delta as a numeric template string (`"1"` / `"-1"`). */
+    readonly delta: string;
 }
 /** A declarative transaction definition's full execution spec. */
 interface TransactionSpec {
@@ -3058,48 +4103,6 @@ interface BridgeBundle {
     readonly operations: OperationsDocument;
 }
 
-/**
- * Single-fragment mutation → command-op compiler (issue #83, Epic #80; proposal
- * `docs/mutation-command-derivation.md` §3).
- *
- * A {@link CommandPlan} (a `mutation(...)` result) is the internal IR: a **list**
- * of write fragments to compose atomically. This module compiles the
- * **single-fragment** case end-to-end into the **same** {@link ContractMethodOp}
- * the #58 contract recorder produces, so the existing serializer
- * (`opToDefinition` → `buildCommandSpec`, `src/spec/contracts.ts` /
- * `src/spec/operations.ts`) and the existing runtimes consume it with no new
- * write substrate. The IR is already a list, so the **N-fragment atomic merge is
- * #90** — this module rejects N>1 with a clear pointer rather than half-merging.
- *
- * ## Intent → base op (proposal §3, "single fragment compile")
- *
- * | intent   | base op                                   |
- * |----------|-------------------------------------------|
- * | `create` | `PutItem` (`attribute_not_exists(PK)`)    |
- * | `update` | `UpdateItem` (key + changed fields)       |
- * | `remove` | `DeleteItem` (key)                        |
- *
- * ## `use:` resolution (the resolved fork — proposal §3, pinned spec correction)
- *
- * The fragment's **intent** selects the lifecycle; `use:` is **optional**:
- *
- * - `use:` present → adopt that {@link EntityWritesDefinition} (the **whole**
- *   `writes` set; never a single lifecycle).
- * - `use:` omitted → default to the **target model's own** `entityWrites` save
- *   contract ({@link getEntityWrites}).
- * - the resolved save contract (custom or default) has **no** entry for the
- *   intent's lifecycle, **or the target declares no `writes` at all** → the
- *   **trivial base op** for the intent (create → `Put` `attribute_not_exists(PK)`,
- *   update → `Update`, remove → `Delete`) against the plain model. So
- *   `{ create: () => PostModel, key, input }` works on a bare model.
- *
- * Either way #83 emits the **same** base op — the resolved
- * {@link LifecycleContract} only matters as the **per-fragment hook** the
- * effect-derivation issues (#84–#87) read: the resolved lifecycle's
- * {@link LifecycleContract.effects} are exposed on {@link CompiledFragment} and
- * consumed by NONE of #83 (the empty hook).
- */
-
 /**
  * A **referential-integrity assertion** derived from a `requires`
  * ({@link RequiresEffect}) effect (issue #84; proposal §2/§3). It is the
@@ -3193,6 +4196,122 @@ interface DerivedUpdate {
     /** The signed delta to add (e.g. `+1` create, `-1` remove). */
     readonly amount: number;
 }
+/**
+ * One **derived maintenance write** — the projection of a just-written source row
+ * into a *separate* target (owner) row, derived from one maintenance-graph
+ * {@link MaintainItem} (issue #125; the D/#124 → compile lowering). It generalizes
+ * {@link DerivedUpdate}: where a `derive` is one scalar `ADD`, a maintenance write
+ * mirrors a whole projection — a single-row {@link SnapshotEffect} (`kind:
+ * 'snapshot'`) or an item appended into a bounded collection ({@link
+ * CollectionEffect}, `kind: 'collection'`).
+ *
+ * The target row's key is bound from the source payload (the relation's owner-key
+ * fields, filled from `$.entity.<sourceField>` → the fragment's `<sourceField>`
+ * input param), and each projected attribute is a {@link ProjectionTransform} IR
+ * node (A/#120 関数形 — `identity` / `preview`) resolved to the input param it reads.
+ * #125 produces this structure; the runtime realization (the actual `Put` / `Update`
+ * item and its placement in the atomic `TransactWriteItems`) is #127.
+ */
+interface DerivedMaintainWrite {
+    /** The maintained (destination / owner) entity whose row holds the snapshot / collection. */
+    readonly entity: EntityRef;
+    /** The relation property on the owner that declared this maintenance (documentary). */
+    readonly relationProperty: string;
+    /** The trigger (`<sourceLogicalName>.<event>`) that fired this maintenance. */
+    readonly trigger: MaintainTrigger;
+    /**
+     * The maintenance delivery mode (Epic #118 §5.1 `updateMode`):
+     *
+     * - `'mutation'` (synchronous, the default) — the write composes into the SAME
+     *   atomic `TransactWriteItems` as the source write (#127); a snapshot `SET`,
+     *   a bounded-collection `list_append` (Phase 1 append-only), or a counter `ADD`.
+     * - `'stream'` (asynchronous, #130) — the write is NOT placed in the source tx.
+     *   Instead a **maintenance-outbox** row is emitted atomically with the source
+     *   write ({@link DerivedMaintainOutbox}) and a CDC drain
+     *   ({@link import('../cdc/maintenance-drain.js')}) applies the owner-row write
+     *   asynchronously (at-least-once, per-shard ordered). The async path realizes
+     *   the operations a single synchronous `UpdateExpression` cannot —
+     *   collection `maxItems` trim / `removed`-driven splice and a running `max`.
+     *
+     * A `stream` write is NOT composed into the synchronous maintain items; the
+     * compiler diverts it to a {@link DerivedMaintainOutbox} instead (see
+     * {@link splitMaintainByMode}). The field is carried here so a single resolved
+     * structure describes both modes (the outbox derivation reads it back).
+     */
+    readonly updateMode: 'mutation' | 'stream';
+    /**
+     * Whether the write mirrors a single row (`snapshot`), appends a collection item
+     * (`collection`), applies a scalar `ADD` counter (`counter`, #141), or puts/deletes a
+     * predicate-gated view row (`membership`, #133 sparse view — stream-only).
+     */
+    readonly kind: 'snapshot' | 'collection' | 'counter' | 'membership';
+    /**
+     * The destination row's key binding: target key field → the mutation-input param
+     * that supplies it (resolved from the effect's `$.entity.<sourceField>` paths —
+     * the source row image, payload 同梱). Every owner-key field is bound.
+     */
+    readonly keyBinding: Readonly<Record<string, string>>;
+    /**
+     * The projection: target attribute → `{ op, args, inputField }`, where `inputField`
+     * is the mutation-input param the source value is read from and `op` / `args` are
+     * the A/#120 {@link ProjectionTransform} realization (`identity` copies through,
+     * `preview` keeps the first `n` chars). Empty for a `counter` (a scalar `ADD`
+     * projects no row attributes).
+     */
+    readonly projection: Readonly<Record<string, {
+        readonly op: ProjectionTransform['op'];
+        readonly args: readonly unknown[];
+        readonly inputField: string;
+    }>>;
+    /**
+     * For a `collection` write, the bounded-collection options (the target `field`,
+     * the optional `maxItems` cap, and the optional `orderBy` input param); absent for
+     * a `snapshot` / `counter`.
+     */
+    readonly collection?: {
+        readonly field: string;
+        readonly maxItems?: number;
+        readonly orderBy?: string;
+        readonly orderDir?: 'ASC' | 'DESC';
+    };
+    /**
+     * For a `counter` write, the scalar aggregate applied to the owner attribute:
+     *
+     * - `op: 'count'` (#141) — a synchronous-capable atomic `ADD #attr :delta` (the
+     *   signed `delta` is `+1` created / `-1` removed). Commutative, so two count
+     *   writes on the SAME row MERGE (the #92 symmetric-counter collapse).
+     * - `op: 'max'` (#130 — `value: max(field)`) — a running maximum of the source
+     *   `field`. This needs a conditional `SET` (`#a = :v` guarded by
+     *   `attribute_not_exists(#a) OR #a < :v`); a failed guard would roll the SOURCE
+     *   write back if done synchronously, so a `max` counter is **stream-only** —
+     *   applied by the CDC drain ({@link import('../cdc/maintenance-drain.js')}).
+     *
+     * Absent for a `snapshot` / `collection`.
+     */
+    readonly counter?: {
+        readonly attribute: string;
+        readonly op: 'count';
+        readonly delta: number;
+    } | {
+        readonly attribute: string;
+        readonly op: 'max';
+        readonly field: string;
+    };
+    /**
+     * For a `membership` write (#133 sparse view), the predicate that gates the view row:
+     * PUT (its projection) when it holds, DELETE when it flips false. `inputField` is the
+     * mutation-input param the predicate reads the source value from (payload 同梱);
+     * `op` / `value` are the {@link import('../define/entity-writes.js').MembershipPredicate}
+     * realization. Membership is **stream-only** (the put-vs-delete branch is decided by
+     * the host-side drain), so this is only ever carried on a `stream` write. Absent for
+     * a `snapshot` / `collection` / `counter`.
+     */
+    readonly membership?: {
+        readonly op: MembershipPredicateOp;
+        readonly inputField: string;
+        readonly value?: unknown;
+    };
+}
 /**
  * A **derived uniqueness guard** — the marker-row `Put` (and, on a unique-field
  * change, the old-guard `Delete` + new-guard `Put` swap) that enforces an
@@ -3304,6 +4423,43 @@ interface DerivedIdempotencyGuard {
     /** The guard marker-row `Put` (one item; `attribute_not_exists`, `literalKey`). */
     readonly items: readonly TransactionItemSpec[];
 }
+/**
+ * A **derived maintenance-outbox event** (issue #130) — the transactional-outbox
+ * `Put` ({@link TransactionItemSpec}) that records a `updateMode: 'stream'`
+ * maintainer's intent ATOMICALLY with the source write, so the `src/cdc/` drain can
+ * apply the owner-row write asynchronously (at-least-once, per-shard ordered).
+ *
+ * ## What the row carries (dynamic values only; the drain re-derives the projection)
+ *
+ * The row's `PK`/`SK` are the deterministic `OUTBOX#MAINT#…` marker (keyed by owner
+ * entity + relation property + the SOURCE row's primary-key input fields). Its
+ * stored item carries:
+ *
+ * - the routing metadata literals — {@link MAINT_OUTBOX_OWNER_ATTR} (owner entity
+ *   name), {@link MAINT_OUTBOX_RELATION_ATTR} (the relation property), and
+ *   {@link MAINT_OUTBOX_TRIGGER_ATTR} (the `<source>.<event>` trigger) — so the drain
+ *   can look the resolved maintainer up in its own maintenance graph;
+ * - one `{inputField}` token per source value the drain needs (every projection
+ *   `inputField`, the `orderBy` field, the `max` field, and every owner-key field),
+ *   rendered from the shared method params exactly as the #87 outbox payload — so the
+ *   row's `newImage` carries the just-written SOURCE row values the drain reprojects.
+ *
+ * The projection transform IR (`identity` / `preview`) is NOT stored in the row (it
+ * would need braces the template renderer reserves for `{token}`s); the drain
+ * recovers it from its maintenance graph by `(owner, relationProperty, trigger)`.
+ * Because the row is a normal table item, real DynamoDB Streams captures it and a
+ * production consumer drains it identically — the emulator is dev/test only.
+ */
+interface DerivedMaintainOutbox {
+    /** The maintained (owner) entity whose row the drain will write (documentary). */
+    readonly ownerEntity: string;
+    /** The relation property / `@aggregate` field that declared this maintenance. */
+    readonly relationProperty: string;
+    /** The trigger (`<sourceLogicalName>.<event>`) that fired this maintenance. */
+    readonly trigger: MaintainTrigger;
+    /** The maintenance-outbox marker-row `Put` (one item; `literalKey`, `MARKER_ROW_ENTITY`). */
+    readonly items: readonly TransactionItemSpec[];
+}
 /**
  * The result of compiling one fragment: the {@link ContractMethodOp} the existing
  * serializer / runtime consume, the resolved contract Key fields (the model's
@@ -3385,6 +4541,38 @@ interface CompiledFragment {
      * guard and rolls the WHOLE transaction back — so no effect is double-applied.
      */
     readonly idempotencyGuard?: DerivedIdempotencyGuard;
+    /**
+     * The maintenance writes derived from the maintenance graph (issue #125; the
+     * D/#124 → compile lowering): one {@link DerivedMaintainWrite} per relation that
+     * declared `write.maintainedOn` for this fragment's lifecycle event (a projected
+     * snapshot / collection on a SEPARATE target row). Present (non-empty) only when
+     * the fragment's trigger fires at least one maintainer; absent otherwise (no
+     * regression — a fragment that maintains nothing compiles exactly as before).
+     *
+     * SCOPE (#125): each entry is the runtime-neutral structure the runtime (#127)
+     * realizes into the atomic `TransactWriteItems`; #125 derives it and rejects a
+     * same-target collision (論点2 = b). The cross-fragment AGGREGATION and the
+     * one-atomic-tx execution wiring are #127 — not done here.
+     *
+     * SCOPE (#130): this carries ONLY the synchronous (`updateMode: 'mutation'`)
+     * maintainers. A `updateMode: 'stream'` maintainer is diverted to
+     * {@link maintainOutbox} instead (it is applied asynchronously by the CDC drain),
+     * so it never appears here.
+     */
+    readonly maintainWrites?: readonly DerivedMaintainWrite[];
+    /**
+     * The maintenance-outbox events for this fragment's `updateMode: 'stream'`
+     * maintainers (issue #130): one {@link DerivedMaintainOutbox} per stream maintainer
+     * the fragment's trigger fires. Each is a transactional-outbox `Put` composed into
+     * the source write's atomic `TransactWriteItems` — recording the maintenance intent
+     * ATOMICALLY with the source row — which the `src/cdc/` drain
+     * ({@link import('../cdc/maintenance-drain.js')}) selects (`PK begins_with
+     * 'OUTBOX#MAINT#'`) and applies asynchronously (at-least-once, per-shard ordered).
+     * Present (non-empty) only when the fragment fires at least one stream maintainer;
+     * absent otherwise (no regression — a fragment with no stream maintainer compiles
+     * exactly as before).
+     */
+    readonly maintainOutbox?: readonly DerivedMaintainOutbox[];
 }
 /**
  * Resolve the {@link LifecycleContract} a fragment adopts for its intent:
@@ -3425,8 +4613,12 @@ type EntityRefResolver = (ref: MutationEntityRef, consumerIndex: number, consume
  * @param resolveEntityRef Resolver for a `$.entity[i].field` cross-fragment
  *   reference (multi-fragment compile), or `null` for a single-fragment compile
  *   (where such a reference is a hard error).
+ * @param maintenanceGraph The {@link MaintenanceGraph} the #125 maintain injection
+ *   queries for this fragment's trigger ({@link resolveMaintainers}). Defaults to a
+ *   lazily-built, cached graph over the global registry; an explicit graph is
+ *   accepted for scoped tests.
  */
-declare function compileFragment(fragment: MutationFragment, index?: number, resolveEntityRef?: EntityRefResolver | null): CompiledFragment;
+declare function compileFragment(fragment: MutationFragment, index?: number, resolveEntityRef?: EntityRefResolver | null, maintenanceGraph?: MaintenanceGraph): CompiledFragment;
 /**
  * Compile a single-fragment {@link CommandPlan} into its {@link CompiledFragment}.
  * The N-fragment atomic merge is **#90** ({@link compileMutationPlan}); this entry
@@ -4098,6 +5290,35 @@ interface CommandMethodSpec<TKey, TParams, TResult> {
      * the guard and rolls the WHOLE write back — no effect is double-applied.
      */
     readonly idempotencyGuard?: DerivedIdempotencyGuard;
+    /**
+     * The maintenance writes derived from the relation-side `write.maintainedOn`
+     * declarations (issue #125; D/#124 → compile lowering), flattened across every
+     * fragment in declaration order. Present (non-empty) only when a fragment's
+     * lifecycle event (`Post.created` etc.) fires at least one maintainer; absent
+     * otherwise (no regression — a maintainer-free mutation is byte-identical to its
+     * pre-#127 form). Each {@link DerivedMaintainWrite} projects the just-written
+     * source row into a SEPARATE owner (destination) row — a single-row snapshot
+     * (`kind: 'snapshot'`) or an item appended into a bounded collection (`kind:
+     * 'collection'`). Their presence (like {@link conditionChecks}) **promotes** an
+     * otherwise single-op method to a transaction: the runtime (#127) realizes each
+     * into the method's atomic `TransactWriteItems`, so the maintained row moves
+     * atomically with the source write (a failure rolls the WHOLE set back). #127 is
+     * the synchronous (`updateMode: 'mutation'`) path only; a `updateMode: 'stream'`
+     * maintainer is carried in {@link maintainOutbox} instead (it is applied
+     * asynchronously by the CDC drain), never in this synchronous slot.
+     */
+    readonly maintainWrites?: readonly DerivedMaintainWrite[];
+    /**
+     * The maintenance-outbox events for `updateMode: 'stream'` maintainers (issue
+     * #130): one {@link DerivedMaintainOutbox} per stream maintainer fired across the
+     * method's fragments. Each is a transactional-outbox `Put` the runtime composes
+     * into the method's atomic `TransactWriteItems` — recording the maintenance intent
+     * ATOMICALLY with the source write — which the `src/cdc/` drain
+     * ({@link import('../cdc/maintenance-drain.js')}) applies asynchronously
+     * (at-least-once, per-shard ordered). Present (non-empty) only when the method fires
+     * at least one stream maintainer; absent otherwise (no regression).
+     */
+    readonly maintainOutbox?: readonly DerivedMaintainOutbox[];
     /** @internal Phantom carrier retaining the formal `CommandMethod` type. */
     readonly __signature?: CommandMethod<TKey, TParams, TResult>;
 }
@@ -4698,6 +5919,34 @@ interface ExecutableCommandContract {
          * Absent on a mutation with no `idempotency` / a #64 hand-written method.
          */
         readonly idempotencyGuard?: DerivedIdempotencyGuard;
+        /**
+         * The maintenance writes derived from the relation-side `write.maintainedOn`
+         * declarations (issue #125 → #127; the D/#124 → compile lowering). When
+         * present (non-empty), a **single-key** call composes each maintenance write
+         * — a projected snapshot (`SET`) or a bounded-collection append
+         * (`SET … = list_append(…)`) on a SEPARATE owner row — into the same atomic
+         * `TransactWriteItems` as the source entity write (and every other effect),
+         * so the maintained row moves ATOMICALLY with the source: a failure on any
+         * item rolls the WHOLE transaction back (the snapshot / collection never
+         * partially persists). The owner row is upserted (a bare `UpdateItem`
+         * creates it if absent — the additive maintenance semantics). This is the
+         * synchronous (`updateMode: 'mutation'`) path only; the async stream path is
+         * #130 (loud-rejected at compile time). Absent on a mutation that fires no
+         * maintainer / a #64 hand-written method.
+         */
+        readonly maintainWrites?: readonly DerivedMaintainWrite[];
+        /**
+         * The maintenance-outbox events for `updateMode: 'stream'` maintainers (issue
+         * #130). Each is a transactional-outbox `Put` (the same `literalKey` marker
+         * mechanism as #87's outbox) composed into the method's atomic
+         * `TransactWriteItems` — recording the maintenance intent ATOMICALLY with the
+         * source write. The `src/cdc/` drain selects these (`PK begins_with
+         * 'OUTBOX#MAINT#'`) and applies the owner-row write asynchronously (so a
+         * snapshot SET / collection append+trim / counter ADD / running-max conditional
+         * SET happens off the write path, at-least-once, per-shard ordered). Absent on a
+         * mutation with no stream maintainer.
+         */
+        readonly maintainOutbox?: readonly DerivedMaintainOutbox[];
         /**
          * The return projection of a `mutation`-derived method (issue #83). When
          * present, a **single-key** call performs the write then issues a
@@ -5169,6 +6418,236 @@ declare function key<T extends Record<string, unknown>>(builder: (c: {
     readonly [K in keyof T]-?: Column<T[K], T>;
 }) => KeyStructure): KeyDefinitionMarker<T>;
 
+type DynamoType = 'S' | 'N' | 'BOOL' | 'B' | 'SS' | 'NS' | 'L' | 'M';
+interface FieldOptions {
+    format?: 'datetime' | 'date';
+    readonly?: boolean;
+    serialize?: (value: unknown) => unknown;
+    deserialize?: (value: unknown) => unknown;
+}
+interface FieldMetadata {
+    propertyName: string;
+    dynamoType: DynamoType;
+    options?: FieldOptions;
+    /**
+     * For a `@literal(...)` field — a `string`-stored field whose value is one of a
+     * known, finite set — the allowed literal values, in declaration order (issue
+     * #75). Recorded purely as model metadata so a Contract param bound into the
+     * field can recover the precise `literal` param-kind from its bind position
+     * (`src/spec/contracts.ts`), serializing as `{ type: 'literal', literals: [...] }`
+     * instead of the imprecise `'string'`. JSON-safe by construction (a non-empty
+     * array of strings). `undefined` for every other field decorator (`@string`,
+     * `@number`, …), so plain fields are byte-for-byte unchanged (backward compat).
+     */
+    literals?: readonly string[];
+}
+
+interface KeyDefinition {
+    /** The canonical structured key (PK/SK segment lists). */
+    segmented: SegmentedKey;
+    inputFieldNames: string[];
+}
+interface GsiDefinition {
+    indexName: string;
+    /** The canonical structured key (PK/SK segment lists). */
+    segmented: SegmentedKey;
+    inputFieldNames: string[];
+    unique: boolean;
+}
+interface RelationLimitOptions {
+    default: number;
+    max: number;
+}
+/**
+ * The named maintenance pattern a relation participates in (Epic #118 §5.1).
+ *
+ * `pattern` is the *preset* selector: omitting it leaves the relation a plain
+ * read-only navigation (the historical `hasMany`/`belongsTo`/`hasOne`
+ * behaviour), exactly backward compatible. When present it names the AWS
+ * design pattern the relation lowers to — the lowering itself (maintenance
+ * graph / compile injection) is out of scope for issue #121 and lands in
+ * #124/#125; here the value is recorded purely as declaration metadata.
+ *
+ * Typed as a `string` union of the known presets but kept open-ended via the
+ * `(string & {})` tail so a future preset can be authored before this union is
+ * widened, without a breaking change to callers.
+ */
+type RelationPattern = 'samePartition' | 'edge' | 'dualEdge' | 'counter' | 'embeddedSnapshot' | 'materializedView' | 'sparseView' | 'versioned' | 'externalProjection' | (string & {});
+/**
+ * Consistency boundary a maintained write is declared against (Epic #118 §4.A.7):
+ * `transactional` = same `TransactWriteItems`; `eventual` = asynchronous catch-up.
+ */
+type RelationConsistency = 'transactional' | 'eventual';
+/**
+ * How a maintained write is applied (Epic #118 §4.A.7):
+ * `mutation` = composed into the same mutation; `stream` = driven asynchronously
+ * off a stream / outbox.
+ */
+type RelationUpdateMode = 'mutation' | 'stream';
+/**
+ * Read-strategy hints for a maintained relation (Epic #118 §5.1 `read`).
+ *
+ * All fields optional — present only when a `pattern` declares a read shape
+ * (e.g. an `embeddedSnapshot` keeping the latest N items). A bare relation
+ * carries no `read` block.
+ */
+interface RelationReadOptions {
+    /** Cap on materialised items kept inline (e.g. "latest 3 posts"). */
+    maxItems?: number;
+    /** Ordering of the maintained collection. */
+    order?: 'ASC' | 'DESC';
+}
+/**
+ * Write-maintenance declaration for a relation (Epic #118 §5.1 `write`).
+ *
+ * `maintainedOn` is the cross-entity trigger list (`"<Entity>.<event>"`, e.g.
+ * `"Post.created"`) that the maintenance graph (#124/#125) will key off. Recorded
+ * here as declaration metadata only.
+ */
+interface RelationWriteOptions {
+    /**
+     * Cross-entity triggers, e.g. `['Post.created', 'Post.removed']`. The event
+     * segment is the confirmed shared lifecycle vocabulary (epic #118 A/B
+     * reconciliation): `created` / `updated` / `removed`.
+     */
+    maintainedOn?: string[];
+    consistency?: RelationConsistency;
+    updateMode?: RelationUpdateMode;
+}
+/**
+ * Snapshot / projection capture map for a maintained relation
+ * (Epic #118 §5.1 / §5.2 `projection`).
+ *
+ * Maps each captured field name on the maintaining side to **how** the source
+ * value is projected. The confirmed shared vocabulary (epic #118 A/B
+ * reconciliation) is the **function-form IR** — the same {@link
+ * ProjectionTransform} node A (#120) defines on `src/define/entity-writes.ts`,
+ * re-used here (NOT re-defined) so the two surfaces never re-diverge. Each value
+ * is either:
+ *
+ * - a {@link ProjectionTransform} (built with the standalone authoring helpers,
+ *   e.g. `preview('body', 120)` — RFC §5.2 `textPreview: preview('body', 120)`),
+ *   or
+ * - a bare `string` — the **identity shorthand**: project that source path
+ *   through unchanged (e.g. `{ postId: 'postId' }`).
+ *
+ * `Readonly` so the recorded declaration metadata is not mutated downstream.
+ * Issue #121 scopes this to the declaration shape; the maintenance graph /
+ * compile injection that consumes the IR is #124/#125.
+ *
+ * @example `{ postId: 'postId', textPreview: preview('body', 120) }`
+ */
+type RelationProjection = Readonly<Record<string, ProjectionTransform | string>>;
+interface RelationOptions {
+    limit?: RelationLimitOptions;
+    order?: 'ASC' | 'DESC';
+    /**
+     * Named maintenance preset (Epic #118). Omitted = plain read-only navigation,
+     * fully backward compatible with the historical relation decorators.
+     */
+    pattern?: RelationPattern;
+    read?: RelationReadOptions;
+    write?: RelationWriteOptions;
+    projection?: RelationProjection;
+}
+interface RelationMetadata {
+    type: 'hasMany' | 'hasOne' | 'belongsTo';
+    propertyName: string;
+    targetFactory: () => new (...args: unknown[]) => unknown;
+    keyBinding: Record<string, string>;
+    options?: RelationOptions;
+}
+/**
+ * The scalar-aggregate value an `@aggregate` field derives from its source entity
+ * (Epic #118 §5.2 counter / latest preset; issue #122). It is the function-form
+ * IR built by the {@link count} / {@link max} value helpers — the aggregation an
+ * `@aggregate(() => Source, keyBinding, { pattern, value })` field maintains:
+ *
+ * - `count` — the cardinality of source rows matched by the key binding (no
+ *   source field; e.g. `postCount!: number` ← `count()`).
+ * - `max` — the maximum value of a named source `field` (e.g. `lastPostAt!:
+ *   string` ← `max('createdAt')`).
+ *
+ * Recorded purely as declaration metadata (issue #122 scope = declaration
+ * surface): the maintenance graph (#124) / compile injection (#125) consume it;
+ * the effect itself is out of scope here. Kept open-ended via the discriminated
+ * `op` so a future aggregation (`min`, `sum`, …) extends the union without a
+ * breaking change.
+ *
+ * @example `count()` → `{ op: 'count' }`
+ * @example `max('createdAt')` → `{ op: 'max', field: 'createdAt' }`
+ */
+type AggregateValue = {
+    readonly op: 'count';
+} | {
+    readonly op: 'max';
+    readonly field: string;
+};
+/**
+ * Options for an `@aggregate` field (Epic #118 §5.2 counter / latest preset;
+ * issue #122). Mirrors the maintenance vocabulary a relation declares so the two
+ * authoring surfaces stay in lockstep:
+ *
+ * - `pattern` reuses {@link RelationPattern} (e.g. `'counter'`) — the named
+ *   maintenance preset, NOT re-defined here.
+ * - `value` is the {@link AggregateValue} the field maintains (`count()` /
+ *   `max('createdAt')`).
+ * - `write` reuses {@link RelationWriteOptions} verbatim — `maintainedOn`
+ *   triggers (`Post.created` / `Post.removed`, the confirmed shared
+ *   `created|updated|removed` event vocabulary) plus `consistency`
+ *   (`transactional|eventual`) / `updateMode` (`mutation|stream`). These are NOT
+ *   re-defined; they are the same shared types B (#121) added.
+ */
+interface AggregateOptions {
+    /** Named maintenance preset (typically `'counter'`); reuses {@link RelationPattern}. */
+    pattern?: RelationPattern;
+    /** The scalar aggregation this field maintains (`count()` / `max('createdAt')`). */
+    value: AggregateValue;
+    /** Cross-entity maintenance triggers / consistency / update-mode (reused from B). */
+    write?: RelationWriteOptions;
+}
+/**
+ * Declaration metadata recorded by an `@aggregate` field decorator (issue #122).
+ *
+ * An `@aggregate` is a **scalar** field (`postCount!: number`,
+ * `lastPostAt!: string`) whose value is derived — by aggregating rows of a source
+ * entity resolved by {@link targetFactory} + {@link keyBinding} — rather than
+ * stored directly. It is therefore recorded in its **own** metadata array
+ * (`EntityMetadata.aggregates`), distinct from both {@link FieldMetadata} (a
+ * plain stored attribute) and {@link RelationMetadata} (a navigation yielding
+ * model instances): an aggregate carries a source binding like a relation, but
+ * surfaces a scalar value like a field. The collector path mirrors relations
+ * (decorator pushes, `@model` drains).
+ *
+ * Issue #122 scope is the declaration surface + metadata pass-through only; the
+ * aggregation effect's compile / runtime (#124/#125/#127) is out of scope.
+ */
+interface AggregateMetadata {
+    /** The scalar field the aggregate value is written to. */
+    propertyName: string;
+    /** Resolves the source entity whose rows are aggregated. */
+    targetFactory: () => new (...args: unknown[]) => unknown;
+    /** The key binding selecting the source rows (target key field → source field). */
+    keyBinding: Record<string, string>;
+    /** The aggregate preset / value / maintenance-write declaration. */
+    options: AggregateOptions;
+}
+interface EmbeddedMetadata {
+    propertyName: string;
+    modelFactory: () => new (...args: unknown[]) => unknown;
+}
+interface EntityMetadata {
+    tableName: string;
+    prefix: string;
+    fields: FieldMetadata[];
+    primaryKey: KeyDefinition | null;
+    gsiDefinitions: GsiDefinition[];
+    relations: RelationMetadata[];
+    /** Scalar `@aggregate` fields (Epic #118 §5.2 counter / latest; issue #122). */
+    aggregates: AggregateMetadata[];
+    embeddedFields: EmbeddedMetadata[];
+}
+
 /**
  * CDC emulator types (issue #72). These types are **cdc-module-owned**; core
  * never references them. The {@link ChangeEvent} shape mirrors DynamoDB Streams
@@ -5282,4 +6761,4 @@ interface CdcEmulatorOptions {
 }
 type ShardId = string;
 
-export { type EntityRef as $, type ConcurrentRecomputeRef as A, type BatchGetExecInput as B, type ChangeEvent as C, type DynamoDBOperation as D, type Executor as E, type FaultSpec as F, type EventLog as G, type ReplayOptions as H, type Item as I, type ShardId as J, type TransactionItemSpec as K, type Param as L, type ModelStatic as M, type ParamDescriptor as N, type DefinitionMap as O, type PutInput as P, type OperationDefinition as Q, type ReadExecOptions as R, type SelectableOf as S, type TransactWriteExecItem as T, type UpdateInput as U, type WriteDefinitionOptions as V, type WriteExecOptions as W, type PartialQueryKeyOf as X, type StrictSelectSpec as Y, type EntityInput as Z, type UniqueQueryKeyOf as _, type ExecutorResult as a, type DerivedUpdate as a$, type ConditionInput as a0, type QueryModelContract as a1, type QueryMethodSpec as a2, type CommandModelContract as a3, type CommandMethodSpec as a4, type ContractSpec as a5, type QuerySpec as a6, type CommandSpec as a7, type ContextSpec as a8, type OperationsDocument as a9, type ComposeSpec as aA, type CondSlot as aB, type ConditionCheckInput as aC, type Connection as aD, type ContractCallSignature as aE, type ContractCardinality as aF, type ContractCommandParams as aG, type ContractCommandResult as aH, type ContractComposeNode as aI, type ContractFromRef as aJ, type ContractInputArity as aK, type ContractItem as aL, type ContractKeyFieldRef as aM, type ContractKeyInput as aN, type ContractKeyRef as aO, type ContractKeySpec as aP, type ContractKind as aQ, type ContractMethodOp as aR, type ContractParamRef as aS, type ContractQueryParams as aT, type ContractResolution as aU, type CtxBase as aV, DEFAULT_MAX_ATTEMPTS as aW, DEFAULT_RETRY_POLICY as aX, type DeleteOptions as aY, type DeriveEffect as aZ, type DerivedEdgeWrite as a_, type AnyOperationDefinition as aa, type BridgeBundle as ab, type ConditionSpec as ac, type BatchDeleteRequest as ad, type BatchGetOptions as ae, type BatchGetRequest as af, BatchGetResult as ag, type BatchPutRequest as ah, type BatchResult as ai, type BatchWriteRequest as aj, CONTRACT_RANGE_FANOUT_CONCURRENCY as ak, type CdcMode as al, type Change as am, type ChangeBatch as an, type ChangeEventName as ao, type ClockMode as ap, type Column as aq, type ColumnMap as ar, type CommandContractMethodSpec as as, type CommandInputShape as at, type CommandMethod as au, type CommandPlan as av, type CommandResolutionTarget as aw, type CommandResultKind as ax, type CommandSelectShape as ay, type CompiledFragment as az, type WriteResult as b, type ReadOpKind as b$, type DescriptorBinding as b0, ENTITY_WRITES_MARKER as b1, type EdgeEffect as b2, type EffectPath as b3, type EmitEffect as b4, type EntityWritesDefinition as b5, type EntityWritesShape as b6, type ExecutableCommandContract as b7, type ExecutableQueryContract as b8, type FilterInput as b9, type MutateParallelResult as bA, type MutateTransactionResult as bB, type MutationBody as bC, type MutationDescriptorMap as bD, type MutationFragment as bE, type MutationInputProxy as bF, type MutationInputRef as bG, type MutationIntent as bH, type NumberParam as bI, type OperationKind as bJ, type OperationSpec as bK, type ParallelOpResult as bL, type ParamKind as bM, type ParamSpec as bN, type ParamStructure as bO, type PersistCtx as bP, type PersistOrigin as bQ, type PlannedCommandMethod as bR, type PutOptions as bS, type QueryContractMethodSpec as bT, type QueryEnvelopeResult as bU, type QueryKeyOf as bV, type QueryMethod as bW, type QueryResult as bX, type RangeConditionSpec as bY, type ReadEnvelope as bZ, type ReadOpCtx as b_, type FilterSpec as ba, type FragmentInput as bb, type GsiDefinitionMarker as bc, type GsiOptions as bd, type IdempotencyEffect as be, type InProcessWriteDescriptor as bf, type InputArity as bg, type KeyDefinitionMarker as bh, type KeySegment as bi, type KeySlot as bj, type KeyStructure as bk, type KeyedResult as bl, LIFECYCLE_CONTRACT_MARKER as bm, type LifecycleContract as bn, type LifecycleEffects as bo, type LiteralParam as bp, type ManifestEntity as bq, type ManifestField as br, type ManifestFieldType as bs, type ManifestGsi as bt, type ManifestKey as bu, type ManifestRelation as bv, type ManifestTable as bw, type ModelRef as bx, type MutateMode as by, type MutateOptions as bz, type DeleteInput as c, isContractFromRef as c$, type ReadOperationType as c0, type ReadRouteDescriptor as c1, type ReadRouteOptions as c2, type ReadRouteResult as c3, type RecordedCompose as c4, type RelationBuilder as c5, type RelationSelect as c6, type RelationSpec as c7, type RequiresEffect as c8, type Resolution as c9, buildDeleteInput as cA, buildPutInput as cB, buildUpdateInput as cC, compileFragment as cD, compileMutationPlan as cE, compileSingleFragmentPlan as cF, cond as cG, contractOfMethodSpec as cH, definePlan as cI, entityWrites as cJ, executeBatchGet as cK, executeBatchWrite as cL, executeCommandMethod as cM, executeDelete as cN, executeKeyedBatchGet as cO, executePut as cP, executeQueryMethod as cQ, executeRangeFanout as cR, executeTransaction as cS, executeUpdate as cT, from as cU, getEntityWrites as cV, gsi as cW, isColumn as cX, isCommandModelContract as cY, isCommandPlan as cZ, isContractComposeNode as c_, type RetryInfo as ca, type RetryOperationKind as cb, SPEC_VERSION as cc, type SegmentSpec as cd, type SelectBuilder as ce, type SelectOf as cf, type StartingPosition as cg, type StreamViewType as ch, type StringParam as ci, TransactionContext as cj, type TransactionItemType as ck, type UniqueEffect as cl, type Updatable as cm, type UpdateOptions as cn, type WhenSpec as co, type WriteCtx as cp, type WriteDescriptor as cq, type WriteEnvelope as cr, type WriteInput as cs, type WriteKind as ct, type WriteLifecyclePhase as cu, type WriteMiddleware as cv, type WriteOperationType as cw, type WriteRecorder as cx, type WriteResultProjection as cy, attachModelClass as cz, type BatchWriteExecItem as d, isContractKeyFieldRef as d0, isContractKeyRef as d1, isContractParamRef as d2, isEntityWritesDefinition as d3, isKeySegment as d4, isLifecycleContract as d5, isMutationFragment as d6, isMutationInputRef as d7, isParam as d8, isPlannedCommandMethod as d9, isQueryModelContract as da, isRetryableError as db, isRetryableTransactionCancellation as dc, k as dd, key as de, lifecyclePhaseForIntent as df, mintContractKeyFieldRef as dg, mintContractParamRef as dh, mutation as di, param as dj, publicCommandModel as dk, publicQueryModel as dl, query as dm, resolveLifecycle as dn, wholeKeysSentinel as dp, type BatchExecOptions as e, DDBModel as f, type PrimaryKeyOf as g, type RequestContext as h, type Middleware as i, type ReadRequestKind as j, type CtxModel as k, type ReadParams as l, type ReadRequestCtx as m, type RetryPolicy as n, type ExecutionPlanSpec as o, type SegmentedKey as p, type SelectBuilderSpec as q, type RawCondition as r, type TransactionSpec as s, type Manifest as t, type RetryOverride as u, type ExecutionPlan as v, type ResolvedKey as w, type CdcEmulatorOptions as x, type ChangeHandler as y, type Unsubscribe as z };
+export { type RelationMetadata as $, type AggregateOptions as A, type BatchGetExecInput as B, type ChangeEvent as C, type DynamoDBOperation as D, type Executor as E, type FieldOptions as F, type GsiDefinition as G, type ResolvedKey as H, type Item as I, type CdcEmulatorOptions as J, type KeyDefinition as K, type ChangeHandler as L, type ModelStatic as M, type Unsubscribe as N, type FaultSpec as O, type PutInput as P, type ConcurrentRecomputeRef as Q, type ReadExecOptions as R, type SelectableOf as S, type TransactWriteExecItem as T, type UpdateInput as U, type EventLog as V, type WriteExecOptions as W, type ReplayOptions as X, type ShardId as Y, type ViewDefinition as Z, type ProjectionDefinition as _, type ExecutorResult as a, type ContractKeyFieldRef as a$, type TransactionItemSpec as a0, type MaintainEffect as a1, type Param as a2, type ParamDescriptor as a3, type DefinitionMap as a4, type OperationDefinition as a5, type WriteDefinitionOptions as a6, type PartialQueryKeyOf as a7, type StrictSelectSpec as a8, type EntityInput as a9, type ChangeBatch as aA, type ChangeEventName as aB, type ClockMode as aC, type CollectionEffect as aD, type CollectionOptions as aE, type Column as aF, type ColumnMap as aG, type CommandContractMethodSpec as aH, type CommandInputShape as aI, type CommandMethod as aJ, type CommandPlan as aK, type CommandResolutionTarget as aL, type CommandResultKind as aM, type CommandSelectShape as aN, type CompiledFragment as aO, type ComposeSpec as aP, type CondSlot as aQ, type ConditionCheckInput as aR, type Connection as aS, type ContractCallSignature as aT, type ContractCardinality as aU, type ContractCommandParams as aV, type ContractCommandResult as aW, type ContractComposeNode as aX, type ContractFromRef as aY, type ContractInputArity as aZ, type ContractItem as a_, type UniqueQueryKeyOf as aa, type EntityRef as ab, type ConditionInput as ac, type QueryModelContract as ad, type QueryMethodSpec as ae, type CommandModelContract as af, type CommandMethodSpec as ag, type ContractSpec as ah, type QuerySpec as ai, type CommandSpec as aj, type ContextSpec as ak, type OperationsDocument as al, type AnyOperationDefinition as am, type BridgeBundle as an, type ConditionSpec as ao, type AggregateMetadata as ap, type BatchDeleteRequest as aq, type BatchGetOptions as ar, type BatchGetRequest as as, BatchGetResult as at, type BatchPutRequest as au, type BatchResult as av, type BatchWriteRequest as aw, CONTRACT_RANGE_FANOUT_CONCURRENCY as ax, type CdcMode as ay, type Change as az, type WriteResult as b, type MutateParallelResult as b$, type ContractKeyInput as b0, type ContractKeyRef as b1, type ContractKeySpec as b2, type ContractKind as b3, type ContractMethodOp as b4, type ContractParamRef as b5, type ContractQueryParams as b6, type ContractResolution as b7, type CounterAggregate as b8, type CounterEffect as b9, type KeySegment as bA, type KeySlot as bB, type KeyStructure as bC, type KeyedResult as bD, LIFECYCLE_CONTRACT_MARKER as bE, type LifecycleContract as bF, type LifecycleEffects as bG, type LiteralParam as bH, type MaintainConsistency as bI, type MaintainEvent as bJ, type MaintainItem as bK, type MaintainTrigger as bL, type MaintainUpdateMode as bM, type MaintenanceGraph as bN, type ManifestEntity as bO, type ManifestField as bP, type ManifestFieldType as bQ, type ManifestGsi as bR, type ManifestKey as bS, type ManifestRelation as bT, type ManifestTable as bU, type MembershipEffect as bV, type MembershipPredicate as bW, type MembershipPredicateOp as bX, type ModelRef as bY, type MutateMode as bZ, type MutateOptions as b_, type CtxBase as ba, DEFAULT_MAX_ATTEMPTS as bb, DEFAULT_RETRY_POLICY as bc, type DeleteOptions as bd, type DeriveEffect as be, type DerivedEdgeWrite as bf, type DerivedUpdate as bg, type DescriptorBinding as bh, ENTITY_WRITES_MARKER as bi, type EdgeEffect as bj, type EffectPath as bk, type EmbeddedMetadata as bl, type EmitEffect as bm, type EntityWritesDefinition as bn, type EntityWritesShape as bo, type ExecutableCommandContract as bp, type ExecutableQueryContract as bq, type FilterInput as br, type FilterSpec as bs, type FragmentInput as bt, type GsiDefinitionMarker as bu, type GsiOptions as bv, type IdempotencyEffect as bw, type InProcessWriteDescriptor as bx, type InputArity as by, type KeyDefinitionMarker as bz, type DeleteInput as c, type UniqueEffect as c$, type MutateTransactionResult as c0, type MutationBody as c1, type MutationDescriptorMap as c2, type MutationFragment as c3, type MutationInputProxy as c4, type MutationInputRef as c5, type MutationIntent as c6, type NumberParam as c7, type OperationKind as c8, type OperationSpec as c9, type ReadRouteResult as cA, type RecordedCompose as cB, type RelationBuilder as cC, type RelationConsistency as cD, type RelationLimitOptions as cE, type RelationPattern as cF, type RelationProjection as cG, type RelationReadOptions as cH, type RelationSelect as cI, type RelationSpec as cJ, type RelationUpdateMode as cK, type RelationWriteOptions as cL, type RequiresEffect as cM, type Resolution as cN, type RetryInfo as cO, type RetryOperationKind as cP, SPEC_VERSION as cQ, type SegmentSpec as cR, type SegmentedKey as cS, type SelectBuilder as cT, type SelectOf as cU, type SnapshotEffect as cV, type StartingPosition as cW, type StreamViewType as cX, type StringParam as cY, TransactionContext as cZ, type TransactionItemType as c_, type ParallelOpResult as ca, type ParamKind as cb, type ParamSpec as cc, type ParamStructure as cd, type PersistCtx as ce, type PersistOrigin as cf, type PlannedCommandMethod as cg, type ProjectionDefinitionInput as ch, type ProjectionDefinitionMap as ci, type ProjectionMap as cj, type ProjectionTransform as ck, type ProjectionTransformOp as cl, type ProjectionVia as cm, type PutOptions as cn, type QueryContractMethodSpec as co, type QueryEnvelopeResult as cp, type QueryKeyOf as cq, type QueryMethod as cr, type QueryResult as cs, type RangeConditionSpec as ct, type ReadEnvelope as cu, type ReadOpCtx as cv, type ReadOpKind as cw, type ReadOperationType as cx, type ReadRouteDescriptor as cy, type ReadRouteOptions as cz, type BatchWriteExecItem as d, isMaintainTrigger as d$, type Updatable as d0, type UpdateOptions as d1, type VersionedDefinition as d2, type VersionedDefinitionInput as d3, type ViewDefinitionInput as d4, type ViewDefinitionMap as d5, ViewRegistry as d6, type ViewSource as d7, type ViewSourceSlice as d8, type WhenSpec as d9, defineViews as dA, entityWrites as dB, executeBatchGet as dC, executeBatchWrite as dD, executeCommandMethod as dE, executeDelete as dF, executeKeyedBatchGet as dG, executePut as dH, executeQueryMethod as dI, executeRangeFanout as dJ, executeTransaction as dK, executeUpdate as dL, from as dM, getEntityWrites as dN, gsi as dO, identity as dP, isColumn as dQ, isCommandModelContract as dR, isCommandPlan as dS, isContractComposeNode as dT, isContractFromRef as dU, isContractKeyFieldRef as dV, isContractKeyRef as dW, isContractParamRef as dX, isEntityWritesDefinition as dY, isKeySegment as dZ, isLifecycleContract as d_, type WriteCtx as da, type WriteDescriptor as db, type WriteEnvelope as dc, type WriteInput as dd, type WriteKind as de, type WriteLifecyclePhase as df, type WriteMiddleware as dg, type WriteOperationType as dh, type WriteRecorder as di, type WriteResultProjection as dj, attachModelClass as dk, buildDeleteInput as dl, buildMaintenanceGraph as dm, buildPutInput as dn, buildUpdateInput as dp, compileFragment as dq, compileMutationPlan as dr, compileSingleFragmentPlan as ds, cond as dt, contractOfMethodSpec as du, definePlan as dv, defineProjection as dw, defineProjections as dx, defineVersioned as dy, defineView as dz, type BatchExecOptions as e, isMutationFragment as e0, isMutationInputRef as e1, isParam as e2, isPlannedCommandMethod as e3, isProjectionDefinition as e4, isQueryModelContract as e5, isRetryableError as e6, isRetryableTransactionCancellation as e7, isViewDefinition as e8, k as e9, key as ea, lifecyclePhaseForIntent as eb, maintainTrigger as ec, mintContractKeyFieldRef as ed, mintContractParamRef as ee, mutation as ef, param as eg, preview as eh, publicCommandModel as ei, publicQueryModel as ej, query as ek, resolveLifecycle as el, whenMember as em, wholeKeysSentinel as en, DDBModel as f, type PrimaryKeyOf as g, type RequestContext as h, type Middleware as i, type ReadRequestKind as j, type CtxModel as k, type ReadParams as l, type ReadRequestCtx as m, type RetryPolicy as n, type ExecutionPlanSpec as o, type EntityMetadata as p, type DynamoType as q, type RelationOptions as r, type AggregateValue as s, type SelectBuilderSpec as t, type RawCondition as u, type TransactionSpec as v, type Manifest as w, type RetryOverride as x, type ExecutionPlan as y, type FieldMetadata as z };