effect-dynamodb 1.25.0 → 1.27.0

package/dist/EventStore.d.ts

@@ -15,17 +15,26 @@
  * - Stream indexes (`makeStream({ indexes })`): sub-streams ordered by a key
  *   derived from each event, on an LSI or GSI, each projecting all of the
  *   event, all but its metadata, or only its keys — `readIndex`,
- *   `query.index`, and `indexDefinitions` for the `CreateTable` fragments
+ *   `query.index`, and `indexDefinitions` for the `CreateTable` fragments.
+ *   A GSI may derive its partition too, so several streams share one
+ *   partition of it, snapshots included (#149)
  * - `fold` / `foldFrom` helpers for state reconstruction
+ * - Packed storage (`makeStream({ storedAs: { data } })`, `snapshot.storedAs`):
+ *   event data and snapshot state as one JSON string, optionally compressed —
+ *   read by the stored form, so a stream may mix native, JSON and compressed
+ *   items; `measureAppend` / `measureSnapshot` for caller-side size planning,
+ *   and `decodeStreamImage` for DynamoDB Streams records
  *
  * Built on the existing library primitives (DynamoSchema, KeyComposer, Query,
  * DynamoClient, Marshaller).
  */
 import type { AttributeDefinition, GlobalSecondaryIndex, LocalSecondaryIndex } from "@aws-sdk/client-dynamodb";
+import { type PackedConfig } from "@effect-dynamodb/schema/DynamoModel.js";
 import * as DynamoSchema from "@effect-dynamodb/schema/DynamoSchema.js";
 import { AdditionalItemConditionFailed, AppendTooLarge, type ConcurrentModification, DuplicateCommand, type OptimisticLockError, TransactionCancelled, type UniqueConstraintViolation, ValidationError, VersionConflict } from "@effect-dynamodb/schema/Errors.js";
 import { DateTime, type Duration, Effect, Option, Pipeable, Schedule, Schema } from "effect";
 import { DynamoClient, type DynamoClientError } from "./DynamoClient.js";
+import { type StreamImage } from "./internal/Packed.js";
 import { type TransactWriteOp } from "./internal/TransactWriteOps.js";
 import * as Query from "./Query.js";
 import { type Table, type TableConfig } from "./Table.js";
@@ -66,6 +75,28 @@ export interface StreamEvent<A, M = Record<string, unknown> | undefined> {
      */
     readonly timestamp: string;
 }
+/**
+ * A {@link StreamEvent} together with the event's stored `data` in its wire
+ * form — what `decodeStreamImage(image, { raw: true })` returns.
+ */
+export interface RawStreamEvent<A, M = Record<string, unknown> | undefined> extends StreamEvent<A, M> {
+    /**
+     * The event's `data` as stored, before the event schema decoded it: the
+     * parsed JSON of a packed `data` (`{ _tag, ...fields }`), or the unmarshalled
+     * map of a native one — fields the event schema does not model included. The
+     * same object the decode read, so nothing is parsed twice.
+     */
+    readonly rawData: Readonly<Record<string, unknown>>;
+}
+/** Options of `decodeStreamImage`. */
+export interface DecodeStreamImageOptions {
+    /**
+     * Also return the event's stored `data` in wire form (`rawData`, see
+     * {@link RawStreamEvent}) — for a consumer that needs fields the event
+     * schema does not model, without parsing the image a second time.
+     */
+    readonly raw?: boolean | undefined;
+}
 /**
  * Metadata type carried on {@link StreamEvent} for a stream: the decoded
  * metadata schema type when the stream declares one, an untyped record
@@ -128,7 +159,69 @@ export interface SnapshotConfig<TSchema extends Schema.Top = Schema.Top> {
     readonly schema: TSchema;
     readonly mode?: SnapshotMode | undefined;
     readonly every?: number | undefined;
+    /**
+     * How the snapshot's `state` is stored: a native map (omitted, the default)
+     * or packed — `DynamoModel.Packed({ format: "json", compression? })`, one
+     * JSON string, compressed to binary at or over the threshold when that is
+     * smaller. Packing shrinks a large state the most: an inline snapshot rides
+     * in every append's transaction, and DynamoDB's item and transaction size
+     * limits count its **stored** bytes.
+     *
+     * The state schema's encoded side must be object- or array-shaped
+     * (`[EDD-9073]`). Reads go by the stored form, so changing this setting
+     * needs no rewrite: a snapshot written before still decodes.
+     */
+    readonly storedAs?: PackedConfig | undefined;
+}
+/**
+ * How a stream stores event `data` (`makeStream({ storedAs })`). `data` is a
+ * native map by default; `DynamoModel.Packed({ format: "json", compression? })`
+ * stores it as one JSON string (`S`), compressed to binary (`B`) at or over the
+ * threshold when that is smaller. Metadata always stays a map.
+ *
+ * Reads go by each item's stored form, never by this setting, so a stream may
+ * hold a mix — events appended before packing was turned on still decode, and
+ * so do packed events after it is turned off.
+ */
+export interface StreamStorageConfig {
+    readonly data?: PackedConfig | undefined;
+}
+/** The resolved storage settings exposed on a stream (`stream.storedAs`). */
+export interface StreamStorageSettings {
+    /** Event `data` (`makeStream({ storedAs: { data } })`); `undefined` = native map. */
+    readonly data: PackedConfig | undefined;
+    /** Snapshot `state` (`snapshot.storedAs`); `undefined` = native map. */
+    readonly state: PackedConfig | undefined;
+}
+/**
+ * The bytes an {@link EventStream.append} would write, by DynamoDB's own size
+ * accounting — {@link EventStream.measureAppend}. Every number counts stored
+ * bytes: packed (and compressed) `data` and `state` as they would be sent.
+ */
+export interface AppendMeasurement {
+    /**
+     * The item size of each event `Put`, in order — what DynamoDB's 400 KB
+     * (409,600-byte) item limit measures.
+     */
+    readonly events: ReadonlyArray<number>;
+    /** The item size of the idempotency sentinel `Put`, when `idempotency` is given. */
+    readonly sentinel: number | undefined;
+    /** The item size of the inline snapshot `Put`, when `snapshot` is given. */
+    readonly snapshot: number | undefined;
+    /**
+     * What the stream's own actions (the contiguity check, the event puts, the
+     * sentinel and the inline snapshot) add to the `TransactWriteItems` request
+     * — its 4 MB (4,194,304-byte) limit counts items, keys and expressions.
+     * Caller `additionalItems` are not included: add their size yourself.
+     */
+    readonly transactionBytes: number;
 }
+/**
+ * The options {@link EventStream.measureAppend} accepts: those of
+ * {@link EventStream.append} except `additionalItems`.
+ */
+export type MeasureAppendOptions<TMetadata, TState = never> = Omit<AppendOptionsBase<TState>, "additionalItems"> & AppendMetadataOptions<TMetadata>;
+export type { LambdaAttributeValue, StreamImage } from "./internal/Packed.js";
 /**
  * How {@link commandHandler} writes snapshots.
  *
@@ -353,20 +446,27 @@ export interface LatestState<TState, TEvent, M = Record<string, unknown> | undef
     readonly events: ReadonlyArray<StreamEvent<TEvent, M>>;
     readonly version: number;
 }
+/**
+ * The stream id as a stream's index functions receive it: the value of each
+ * `streamId.composite` field, by name.
+ */
+export type StreamIndexStreamId = {
+    readonly [field: string]: string;
+};
 /**
  * Derives an event's key in a stream index from the domain event (before it is
- * encoded) and the version it is appended at.
+ * encoded), the version it is appended at — its version in the stream — and
+ * the stream id it is appended to.
  *
  * - A string is the event's sort key in the index. It is stored **raw**: no
  *   casing and no prefixing is applied, so compose it to sort the way you
  *   query (zero-pad numbers, for example).
  * - `undefined` leaves the event out of the index (a sparse index).
- * - An empty string (or any other value) fails the append with
- *   `ValidationError` before anything is written — DynamoDB rejects empty key
- *   values — as does a `key` that throws. A key over DynamoDB's 1024-byte
- *   sort-key limit is sent and rejected by DynamoDB; the append then fails
- *   with `ValidationError` naming the index and the event (#144), and nothing
- *   is written.
+ * - Any other value, or a `key` that throws, fails the append with
+ *   `ValidationError` before anything is written. An empty string or a key
+ *   over DynamoDB's 1024-byte sort-key limit is sent and rejected by
+ *   DynamoDB; the append then fails with `ValidationError` naming the index
+ *   and the event (#144), and nothing is written.
  *
  * The key is derived only when an event is appended. Events are never
  * rewritten, so changing `key` later leaves events already stored under their
@@ -376,7 +476,60 @@ export interface LatestState<TState, TEvent, M = Record<string, unknown> | undef
  * existing events is the application's decision (see `indexes` on
  * {@link makeStream}).
  */
-export type StreamIndexKey<TEvent> = (event: TEvent, version: number) => string | undefined;
+export type StreamIndexKey<TEvent, TStreamId = StreamIndexStreamId> = (event: TEvent, version: number, streamId: TStreamId) => string | undefined;
+/**
+ * Derives an event's partition in a GSI stream index (`partition` on a
+ * {@link GlobalStreamIndexConfig}, #149) from the domain event, the version it
+ * is appended at and the stream id — the arguments of the index's `key`, in
+ * the same order. Called for every appended event, with `key`.
+ *
+ * - A string is the event's partition key in the index, stored **raw** (no
+ *   casing, no prefix) in the index's `pk` attribute. Several streams may
+ *   derive the same value, so one query of the index reads a group of
+ *   streams — `ORDER#<orderId>` for an order's line, payment and shipment
+ *   streams, say.
+ * - `undefined` leaves the event out of the index, as an `undefined` `key`
+ *   does. An event is indexed only when both return a string.
+ * - Within one append, every event whose partition is a string must have the
+ *   same one, and so must the inline snapshot's entry (see
+ *   {@link StreamIndexSnapshotEntry}); otherwise the append fails with
+ *   `ValidationError` and nothing is written. Another value, or a function
+ *   that throws, fails it the same way. An empty string, or one over
+ *   DynamoDB's 2048-byte partition-key limit, is DynamoDB's to reject: the
+ *   rejection is reported as a `ValidationError` naming the index and the
+ *   event.
+ */
+export type StreamIndexPartition<TEvent, TStreamId = StreamIndexStreamId> = (event: TEvent, version: number, streamId: TStreamId) => string | undefined;
+/**
+ * Puts a stream's snapshot in a GSI stream index with a derived partition
+ * (`snapshot` on a {@link GlobalStreamIndexConfig}, #149): from the state
+ * being written (before it is encoded), the snapshot's `asOfVersion` and the
+ * stream id — in the order of the events' `key` and `partition` — the
+ * snapshot item's partition and sort key in the index —
+ * both stored **raw** — or `undefined` to leave it out.
+ *
+ * Every snapshot write derives it — `writeSnapshot`, the inline snapshot of
+ * `append` and `commandHandler` (`mode: "inline"` or `"after-append"`) — and
+ * the attributes are part of the snapshot item itself, so an inline snapshot
+ * enters the index in the append's own transaction. The snapshot `Put`
+ * replaces the whole item, so returning `undefined` takes a snapshot already
+ * in the index out of it.
+ *
+ * The inline snapshot of an append must have the partition of the append's
+ * events in the index (when they have one); a standalone `writeSnapshot` has
+ * no events to compare with. Another value than an object of two strings, or
+ * a function that throws, fails the write with `ValidationError` before
+ * anything is written.
+ *
+ * A snapshot is the state **as of** `asOfVersion`: it is current after every
+ * append only with `snapshot: { mode: "inline" }` and no `every`. A reader of
+ * the index that needs the head folds the stream's indexed events after
+ * `asOfVersion` onto it.
+ */
+export type StreamIndexSnapshotEntry<TState, TStreamId = StreamIndexStreamId> = (state: TState, asOfVersion: number, streamId: TStreamId) => {
+    readonly partition: string;
+    readonly key: string;
+} | undefined;
 /**
  * A stream index on a **local** secondary index (the default `type`). An LSI
  * shares the table's partition key (`pk`), so its items are exactly the
@@ -393,13 +546,17 @@ export type StreamIndexKey<TEvent> = (event: TEvent, version: number) => string
  * the index copies from each event is its `projection` — see
  * {@link StreamIndexProjection}.
  */
-export interface LocalStreamIndexConfig<TEvent> {
+export interface LocalStreamIndexConfig<TEvent, TStreamId = StreamIndexStreamId> {
     readonly type?: "lsi" | undefined;
     readonly index: string;
     readonly sk: string;
     /** An LSI uses the table partition key; supplying `pk` is refused (`[EDD-9063]`). */
     readonly pk?: undefined;
-    readonly key: StreamIndexKey<TEvent>;
+    readonly key: StreamIndexKey<TEvent, TStreamId>;
+    /** An LSI's partition is the stream's; supplying `partition` is refused (`[EDD-9063]`). */
+    readonly partition?: undefined;
+    /** Only a GSI with a derived `partition` indexes snapshots (`[EDD-9063]`). */
+    readonly snapshot?: undefined;
     /**
      * What the index copies from each event — see {@link StreamIndexProjection}.
      * Default `"all"`. Must match the deployed index.
@@ -407,30 +564,56 @@ export interface LocalStreamIndexConfig<TEvent> {
     readonly projection?: StreamIndexProjection | undefined;
 }
 /**
- * A stream index on a **global** secondary index. `append` writes the stream's
- * partition key value into the `pk` attribute of each indexed event, so the
- * index is scoped to the same stream: the eventually consistent equivalent of
- * an LSI, without the LSI's 10 GB item-collection cap. DynamoDB rejects a
- * strongly consistent read of it, diagnosed as a `ValidationError` naming the
- * index.
+ * A stream index on a **global** secondary index. By default `append` writes
+ * the stream's partition key value into the `pk` attribute of each indexed
+ * event, so the index is scoped to the same stream: the eventually consistent
+ * equivalent of an LSI, without the LSI's 10 GB item-collection cap. DynamoDB
+ * rejects a strongly consistent read of it, diagnosed as a `ValidationError`
+ * naming the index.
+ *
+ * With `partition` (#149), the partition is derived instead — see
+ * {@link StreamIndexPartition} — and stored raw, so several streams can write
+ * the same partition of one GSI they all declare, and one query of it reads
+ * the whole group (an order's line, payment and shipment streams under
+ * `ORDER#<orderId>`, say). {@link indexDefinitions} emits a physical index
+ * the streams declare alike once. With `snapshot` as well, each stream's
+ * snapshot item is in the index too — see {@link StreamIndexSnapshotEntry}.
+ * {@link EventStream.readIndex} then takes the partition to read, and
+ * returns the given stream's events in it.
  *
  * Unlike an LSI, the GSI itself can be added to an existing table
- * (`UpdateTable`), but that does not index the stream's existing events: the
- * index attributes are written only by `append`, so only events appended after
- * the index is declared are in it — see {@link StreamIndexKey}.
+ * (`UpdateTable`), but that does not index the stream's existing items: the
+ * index attributes are written only by `append` (and snapshot writes), so only
+ * events appended after the index is declared are in it — see
+ * {@link StreamIndexKey}.
  *
  * - `index` — the physical GSI name.
- * - `pk` — the attribute carrying the stream's partition key (the GSI's HASH key).
+ * - `pk` — the attribute carrying the partition (the GSI's HASH key): the
+ *   stream's partition key, or the derived `partition`.
  * - `sk` — the attribute carrying the derived key (the GSI's RANGE key).
  * - `key` — see {@link StreamIndexKey}.
+ * - `partition` — optional, see {@link StreamIndexPartition}.
+ * - `snapshot` — optional, requires `partition` and a stream `snapshot`
+ *   config; see {@link StreamIndexSnapshotEntry}.
  * - `projection` — see {@link StreamIndexProjection}.
+ *
+ * Write `type: "gsi"` in the entry itself. TypeScript infers the parameter
+ * types of `partition` and `snapshot` from the GSI member of the entry union,
+ * which it selects by the literal `type`: an entry whose `type` comes from an
+ * object spread (`{ ...shared, partition: (event) => … }`) gets implicit-`any`
+ * parameters there, although `key` still infers. Annotate them, or give the
+ * shared fragment a {@link GlobalStreamIndexConfig} type.
  */
-export interface GlobalStreamIndexConfig<TEvent> {
+export interface GlobalStreamIndexConfig<TEvent, TStreamId = StreamIndexStreamId, TState = unknown> {
     readonly type: "gsi";
     readonly index: string;
     readonly pk: string;
     readonly sk: string;
-    readonly key: StreamIndexKey<TEvent>;
+    readonly key: StreamIndexKey<TEvent, TStreamId>;
+    /** The derived partition — see {@link StreamIndexPartition}. */
+    readonly partition?: StreamIndexPartition<TEvent, TStreamId> | undefined;
+    /** The snapshot's entry — see {@link StreamIndexSnapshotEntry}. Requires `partition`. */
+    readonly snapshot?: StreamIndexSnapshotEntry<TState, TStreamId> | undefined;
     /**
      * What the index copies from each event — see {@link StreamIndexProjection}.
      * Default `"all"`. Must match the deployed index.
@@ -442,7 +625,7 @@ export interface GlobalStreamIndexConfig<TEvent> {
  * ordered by a key derived from each event. See {@link LocalStreamIndexConfig}
  * and {@link GlobalStreamIndexConfig}.
  */
-export type StreamIndexConfig<TEvent> = LocalStreamIndexConfig<TEvent> | GlobalStreamIndexConfig<TEvent>;
+export type StreamIndexConfig<TEvent, TStreamId = StreamIndexStreamId, TState = unknown> = LocalStreamIndexConfig<TEvent, TStreamId> | GlobalStreamIndexConfig<TEvent, TStreamId, TState>;
 /**
  * What a stream index copies from each event (`projection` on an entry of
  * `makeStream({ indexes })`). {@link indexDefinitions} emits the matching
@@ -451,7 +634,7 @@ export type StreamIndexConfig<TEvent> = LocalStreamIndexConfig<TEvent> | GlobalS
  * | Value | Emitted `Projection` | Read |
  * |---|---|---|
  * | `"all"` (default) | `ALL` | one query |
- * | `"withoutMetadata"` | `INCLUDE` of every event attribute except `metadata` | one query; `metadata` is `undefined` (and typed so) |
+ * | `"withoutMetadata"` | `INCLUDE` of every event attribute except `metadata` (plus the snapshot's `asOfVersion` and `state` when a stream indexes its snapshot in it) | one query; `metadata` is `undefined` (and typed so) |
  * | `"keys"` | `INCLUDE ["__edd_e__"]` — **not** `KEYS_ONLY` | LSI: one query with `Select: ALL_ATTRIBUTES` (DynamoDB fetches each event from the table). GSI: the query, then `BatchGetItem` for the events of each page, in index order |
  *
  * `__edd_e__` is always projected because every read filters on it, and
@@ -484,6 +667,18 @@ export interface StreamIndexSettings {
     readonly pk: string;
     readonly sk: string;
     readonly projection: StreamIndexProjection;
+    /**
+     * Where the index's partition comes from: `"stream"` — the stream's own
+     * partition key (every LSI, and a GSI without `partition`) — or
+     * `"derived"`, a GSI's `partition` function (#149). A stream always sets
+     * it; absent (a settings object built by hand) reads as `"stream"`.
+     */
+    readonly partition?: "stream" | "derived" | undefined;
+    /**
+     * Whether the stream's snapshot is in the index (a GSI's `snapshot`, #149).
+     * A stream always sets it; absent reads as `false`.
+     */
+    readonly snapshot?: boolean | undefined;
 }
 /**
  * The `metadata` type of an event read through a stream index of projection
@@ -504,6 +699,16 @@ type ProjectionOf<C> = C extends {
 export type IndexProjectionsOf<TIndexes> = {
     readonly [K in keyof TIndexes & string]: ProjectionOf<TIndexes[K]>;
 };
+/**
+ * The names of the indexes of a `makeStream({ indexes })` config that derive
+ * their partition (`partition`, #149) — those {@link EventStream.readIndex}
+ * and `query.index` read with an explicit `partition`.
+ */
+export type PartitionedIndexesOf<TIndexes> = {
+    readonly [K in keyof TIndexes & string]: TIndexes[K] extends {
+        readonly partition: (...args: ReadonlyArray<any>) => unknown;
+    } ? K : never;
+}[keyof TIndexes & string];
 /** @internal The members a stream index entry may declare. */
 type StreamIndexConfigKey = keyof LocalStreamIndexConfig<unknown> | keyof GlobalStreamIndexConfig<unknown>;
 /**
@@ -513,8 +718,8 @@ type StreamIndexConfigKey = keyof LocalStreamIndexConfig<unknown> | keyof Global
  * `TIndexes` from the entries turns off TypeScript's own excess-property check,
  * which would otherwise catch it.
  */
-export type StreamIndexesConfig<TIndexes, TEvent> = {
-    readonly [K in keyof TIndexes]: StreamIndexConfig<TEvent> & {
+export type StreamIndexesConfig<TIndexes, TEvent, TStreamId = StreamIndexStreamId, TState = unknown> = {
+    readonly [K in keyof TIndexes]: StreamIndexConfig<TEvent, TStreamId, TState> & {
         readonly [P in Exclude<keyof TIndexes[K], StreamIndexConfigKey>]: never;
     };
 };
@@ -532,6 +737,9 @@ export type StreamIndexesConfig<TIndexes, TEvent> = {
  * - `consistentRead` — strongly consistent read. DynamoDB rejects it on a
  *   GSI-backed index, which it reads only eventually consistently: the read
  *   fails with a `ValidationError` naming the index.
+ *
+ * An index that derives its partition (#149) also takes `partition` — see
+ * {@link ReadIndexArgs}.
  */
 export type ReadIndexOptions = {
     readonly reverse?: boolean | undefined;
@@ -544,9 +752,47 @@ export type ReadIndexOptions = {
     readonly between?: readonly [string, string] | undefined;
     readonly beginsWith?: undefined;
 });
+/**
+ * The options argument of {@link EventStream.readIndex} for index `N`. An
+ * index that derives its partition (`partition`, #149) is read one partition
+ * at a time, so `partition` — the value to read, as the index's `partition`
+ * function returns it — is required, and the read returns the events of the
+ * given stream in it. Any other index is scoped to the stream already: a
+ * `partition` passed for it fails the read with `ValidationError` (it stays
+ * in the type so that a stream whose indexes derive their partition remains
+ * assignable to one whose indexes do not, as every stream is to
+ * `EventStream<E, F, M, S>`).
+ */
+export type ReadIndexArgs<N extends string, TPartitionedIndexName extends string> = [
+    TPartitionedIndexName
+] extends [never] ? [
+    options?: (ReadIndexOptions & {
+        readonly partition?: string | undefined;
+    }) | undefined
+] : [N] extends [TPartitionedIndexName] ? [options: ReadIndexOptions & {
+    readonly partition: string;
+}] : [options?: (ReadIndexOptions & {
+    readonly partition?: string | undefined;
+}) | undefined];
+/**
+ * The options argument of `query.index` for index `N` — `partition`, required
+ * for an index that derives its partition, as for {@link ReadIndexArgs}; on
+ * any other index, one passed throws `[EDD-9080]`.
+ */
+export type IndexQueryArgs<N extends string, TPartitionedIndexName extends string> = [
+    TPartitionedIndexName
+] extends [never] ? [options?: {
+    readonly partition?: string | undefined;
+} | undefined] : [N] extends [TPartitionedIndexName] ? [options: {
+    readonly partition: string;
+}] : [options?: {
+    readonly partition?: string | undefined;
+} | undefined];
 type StreamIdInput<T extends ReadonlyArray<string>> = {
     readonly [K in T[number]]: string;
 };
+/** @internal The state type of a `makeStream({ snapshot })` config; `never` without one. */
+type SnapshotStateOf<TSnapshot> = TSnapshot extends SnapshotConfig<infer TStateSchema> ? Schema.Schema.Type<TStateSchema> : never;
 declare const EventStreamTypeId: unique symbol;
 export type EventStreamTypeId = typeof EventStreamTypeId;
 /**
@@ -560,12 +806,14 @@ export type EventStreamTypeId = typeof EventStreamTypeId;
  * `query.index` only accept a declared name. `TIndexProjections` is each
  * index's {@link StreamIndexProjection} by name, so an event read through a
  * `"withoutMetadata"` index has `metadata: undefined`.
+ * `TPartitionedIndexName` names the indexes that derive their partition
+ * (#149), which are read with an explicit `partition`.
  */
 export interface EventStream<TEvent, TStreamIdFields extends ReadonlyArray<string>, TMetadata, TState = never, TIndexName extends string = never, TIndexProjections extends {
     readonly [K in TIndexName]: StreamIndexProjection;
 } = {
     readonly [K in TIndexName]: "all";
-}> extends Pipeable.Pipeable {
+}, TPartitionedIndexName extends string = never> extends Pipeable.Pipeable {
     readonly [EventStreamTypeId]: EventStreamTypeId;
     readonly streamName: string;
     readonly eventSchema: Schema.Top;
@@ -584,6 +832,11 @@ export interface EventStream<TEvent, TStreamIdFields extends ReadonlyArray<strin
      * snapshots.
      */
     readonly snapshotConfig: SnapshotSettings | undefined;
+    /**
+     * How the stream stores event `data` and snapshot `state` — see
+     * {@link StreamStorageConfig} and {@link SnapshotConfig.storedAs}.
+     */
+    readonly storedAs: StreamStorageSettings;
     /**
      * Write (or overwrite) this stream's snapshot.
      *
@@ -673,8 +926,71 @@ export interface EventStream<TEvent, TStreamIdFields extends ReadonlyArray<strin
      * `metadata: undefined`, as the type says); for `"keys"`, one query with
      * `Select: ALL_ATTRIBUTES` on an LSI, or the query followed by `BatchGetItem`
      * (unprocessed keys retried, index order kept) on a GSI.
+     *
+     * An index that derives its partition (`partition`, #149) is read one
+     * partition at a time: pass the partition as `options.partition` (required
+     * by the types — see {@link ReadIndexArgs}). The read keeps the events of
+     * `streamId` in it — not the other streams sharing the partition, nor any
+     * snapshot — by filtering on the table's `pk`, which every index projects.
+     */
+    readIndex<N extends TIndexName>(name: N, streamId: StreamIdInput<TStreamIdFields>, ...options: ReadIndexArgs<N, TPartitionedIndexName>): Effect.Effect<ReadonlyArray<StreamEvent<TEvent, IndexEventMetadata<TMetadata, TIndexProjections[N]>>>, DynamoClientError | ValidationError, DynamoClient | TableConfig>;
+    /**
+     * The bytes {@link EventStream.append} would write for these arguments, by
+     * DynamoDB's own size accounting — for planning chunks against the 400 KB
+     * item and 4 MB transaction limits without re-implementing the stream's
+     * item layout or packing. The items are built by the same code `append`
+     * uses (envelope, keys, packed and compressed `data`, metadata, stream-index
+     * attributes, the sentinel, the inline snapshot), so the numbers are exact
+     * for the request `append` would send now with this runtime's compressors.
+     *
+     * Nothing is read or written, and nothing is refused for its size: this is
+     * caller-side planning, not a pre-check. `additionalItems` are not accepted
+     * — add their size yourself. Fails as `append` would on invalid options
+     * (`ValidationError`), and — with a `CompressorNotRegistered` cause — when a
+     * value crosses its compression threshold without a registered compressor.
+     */
+    measureAppend(streamId: StreamIdInput<TStreamIdFields>, events: ReadonlyArray<TEvent>, expectedVersion: number, options?: MeasureAppendOptions<TMetadata, TState> | undefined): Effect.Effect<AppendMeasurement, ValidationError, TableConfig>;
+    /**
+     * The item size, in bytes, of the snapshot {@link EventStream.writeSnapshot}
+     * (or an inline snapshot at `asOfVersion`) would write — packed `state` as
+     * stored. Caller-side planning, like {@link EventStream.measureAppend}. Dies
+     * with `[EDD-9026]` on a stream without a `snapshot` config.
+     */
+    measureSnapshot(streamId: StreamIdInput<TStreamIdFields>, state: TState, asOfVersion: number): Effect.Effect<number, ValidationError, TableConfig>;
+    /**
+     * Decode a DynamoDB Streams record image (`NewImage` / `OldImage`) of one
+     * of this stream's events into exactly the {@link StreamEvent} the read
+     * paths return — `data` decoded through the event schemas (by its stored
+     * form: native map, JSON string or compressed binary), `metadata` through
+     * the metadata schema when the stream declares one.
+     *
+     * Accepts DynamoDB JSON as Lambda and EventBridge Pipes deliver it (`B` /
+     * `BS` members as base64 text, or as bytes), or an already-unmarshalled
+     * item (a packed `data` as bytes or base64 text). `Option.none()` for an
+     * image that is not one of this stream's events — its snapshot, an
+     * idempotency sentinel, another stream's or an entity's item — so one
+     * handler can fan a table's records across decoders. The type is read off
+     * the raw image before anything is unmarshalled, so nothing in another
+     * item's image (a number the SDK cannot represent, say) fails the decode.
+     * An event image that does not decode fails with `ValidationError`.
+     *
+     * With `{ raw: true }`, each event also carries `rawData`: its `data` as
+     * stored, in wire form, unmodelled fields included (see
+     * {@link RawStreamEvent}).
+     *
+     * The compressor registry is not in the type (`R = never`): this unbound
+     * method reads the `Compression` service from the running fiber. When the
+     * stream's `storedAs.data` or `snapshot.storedAs` names a codec that
+     * registry does not hold — including no `Compression` at all, for example
+     * one lost behind `Layer.provide` — it dies with the `[EDD-9078]`
+     * configuration defect on first use, whatever the image, rather than
+     * failing with a typed error. Provide `Compression` where the handler runs,
+     * or decode through {@link EventStore.bind}, which captures it.
      */
-    readIndex<N extends TIndexName>(name: N, streamId: StreamIdInput<TStreamIdFields>, options?: ReadIndexOptions | undefined): Effect.Effect<ReadonlyArray<StreamEvent<TEvent, IndexEventMetadata<TMetadata, TIndexProjections[N]>>>, DynamoClientError | ValidationError, DynamoClient | TableConfig>;
+    decodeStreamImage(image: StreamImage, options: DecodeStreamImageOptions & {
+        readonly raw: true;
+    }): Effect.Effect<Option.Option<RawStreamEvent<TEvent, StreamMetadata<TMetadata>>>, ValidationError, never>;
+    decodeStreamImage(image: StreamImage, options?: DecodeStreamImageOptions): Effect.Effect<Option.Option<StreamEvent<TEvent, StreamMetadata<TMetadata>>>, ValidationError, never>;
     readonly query: {
         events(streamId: StreamIdInput<TStreamIdFields>): Query.Query<StreamEvent<TEvent, StreamMetadata<TMetadata>>>;
         /**
@@ -692,8 +1008,12 @@ export interface EventStream<TEvent, TStreamIdFields extends ReadonlyArray<strin
          * counts index entries and fetches nothing. On a `"keys"` or
          * `"withoutMetadata"` index, a `Query.filter` on an attribute the index
          * does not project is refused by DynamoDB — use `Query.filterBy`.
+         *
+         * An index that derives its partition (#149) takes the partition to read
+         * as `options.partition` (see {@link IndexQueryArgs}), and the query keeps
+         * `streamId`'s events in it, as {@link EventStream.readIndex} does.
          */
-        index<N extends TIndexName>(name: N, streamId: StreamIdInput<TStreamIdFields>): Query.Query<StreamEvent<TEvent, IndexEventMetadata<TMetadata, TIndexProjections[N]>>>;
+        index<N extends TIndexName>(name: N, streamId: StreamIdInput<TStreamIdFields>, ...options: IndexQueryArgs<N, TPartitionedIndexName>): Query.Query<StreamEvent<TEvent, IndexEventMetadata<TMetadata, TIndexProjections[N]>>>;
     };
 }
 /**
@@ -753,11 +1073,20 @@ export interface EventStream<TEvent, TStreamIdFields extends ReadonlyArray<strin
  * `indexes` declares sub-streams ordered by a key derived from each event
  * (#140), on a local (default) or global secondary index. `append` writes each
  * event's derived key (and, for a GSI, the stream's partition key) on the
- * event item; snapshots and idempotency sentinels never carry them, so they
- * are never in an index. Read with {@link EventStream.readIndex} or
- * `query.index`, and create the indexes with {@link indexDefinitions}. Each
- * index's `projection` (default `"all"`) sets what it copies from each event
- * and how it is read — see {@link StreamIndexProjection}.
+ * event item. Idempotency sentinels never carry them; snapshots carry an
+ * entry only in a GSI that derives its partition and declares `snapshot`.
+ * Read with {@link EventStream.readIndex} or `query.index`, and create the
+ * indexes with {@link indexDefinitions}. Each index's `projection` (default
+ * `"all"`) sets what it copies from each event and how it is read — see
+ * {@link StreamIndexProjection}.
+ *
+ * A GSI's `partition` (#149) derives the partition from the stream id and the
+ * event instead, stored raw, so several streams declaring the same GSI write
+ * one partition of it — an order's line, payment and shipment streams under
+ * `ORDER#<orderId>`, read by one query — and its `snapshot` puts each stream's
+ * snapshot item in that partition too, in the same `Put` (so an inline
+ * snapshot enters the index in the append's own transaction). See
+ * {@link GlobalStreamIndexConfig}.
  *
  * Index attributes are written only at append time and events are never
  * rewritten. Declaring an index on a stream that already holds events, or
@@ -769,6 +1098,36 @@ export interface EventStream<TEvent, TStreamIdFields extends ReadonlyArray<strin
  *
  * @example
  * ```typescript
+ * // Lines and payments of an order share `gsi1` under `ORDER#<orderId>`.
+ * const OrderLines = EventStore.makeStream({
+ *   table: EventsTable,
+ *   streamName: "OrderLine",
+ *   events: [LineAdded, LineRemoved],
+ *   streamId: { composite: ["orderId", "lineId"] },
+ *   snapshot: { schema: LineState, mode: "inline" },
+ *   indexes: {
+ *     byOrder: {
+ *       type: "gsi",
+ *       index: "gsi1",
+ *       pk: "gsi1pk",
+ *       sk: "gsi1sk",
+ *       partition: (_event, _version, streamId) => `ORDER#${streamId.orderId}`,
+ *       key: (_event, version, streamId) => `LINE#${streamId.lineId}#EVT#${pad(version)}`,
+ *       snapshot: (_state, _asOfVersion, streamId) => ({
+ *         partition: `ORDER#${streamId.orderId}`,
+ *         key: `LINE#${streamId.lineId}#STATE`,
+ *       }),
+ *     },
+ *   },
+ * })
+ *
+ * const lineEvents = yield* OrderLines.readIndex("byOrder", { orderId, lineId }, {
+ *   partition: `ORDER#${orderId}`,
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
  * const Entries = EventStore.makeStream({
  *   table: EventsTable,
  *   streamName: "Ledger",
@@ -793,10 +1152,12 @@ export interface EventStream<TEvent, TStreamIdFields extends ReadonlyArray<strin
  * @throws `[EDD-9062]` when `snapshot.mode` is neither `"after-append"` nor
  *   `"inline"`.
  * @throws `[EDD-9063]` for a malformed index: a `type` other than `"lsi"` /
- *   `"gsi"`, a `gsi` without `pk`, an `lsi` with `pk`, an empty `index` / `sk`
- *   / `pk`, a `key` that is not a function, a `projection` other than
- *   `"all"` / `"withoutMetadata"` / `"keys"`, or a member an index entry does
- *   not declare (such as a misspelled `projection`, also a type error).
+ *   `"gsi"`, a `gsi` without `pk`, an `lsi` with `pk`, `partition` or
+ *   `snapshot`, an empty `index` / `sk` / `pk`, a `key` / `partition` /
+ *   `snapshot` that is not a function, a `snapshot` without `partition` or on
+ *   a stream without a `snapshot` config, a `projection` other than `"all"` /
+ *   `"withoutMetadata"` / `"keys"`, or a member an index entry does not
+ *   declare (such as a misspelled `projection`, also a type error).
  * @throws `[EDD-9064]` when an index attribute is one the stream writes itself
  *   (`pk`, `sk`, `__edd_e__`, `streamId`, `version`, `eventType`, `data`,
  *   `metadata`, `timestamp`, `asOfVersion`, `state`, `commandId`, or the
@@ -805,10 +1166,22 @@ export interface EventStream<TEvent, TStreamIdFields extends ReadonlyArray<strin
  *   with `ValidationError`.
  * @throws `[EDD-9065]` when two indexes share a physical index name or an
  *   attribute (or a GSI's `pk` and `sk` are the same attribute).
+ * @throws `[EDD-9079]` when `storedAs` declares a key other than `data`
+ *   (metadata always stays a map), or a `storedAs.data` / `snapshot.storedAs`
+ *   value is not a `DynamoModel.Packed(...)` config.
+ * @throws `[EDD-9073]` when `snapshot.storedAs` is set and the state schema's
+ *   encoded side is not object- or array-shaped.
+ *
+ * `storedAs: { data: DynamoModel.Packed(...) }` stores event `data` packed, and
+ * `snapshot.storedAs` the snapshot `state` — see {@link StreamStorageConfig}.
+ * Register the codecs a compressed config names through the `Compression`
+ * service (`Compression.layer([...])` merged into the application layer): a
+ * bound stream refuses to bind without them, and an unbound one to run its
+ * first operation (`[EDD-9078]`).
  */
 export declare const makeStream: <const TEvents extends ReadonlyArray<Schema.Top>, TTable extends Table, const TStreamName extends string, const TStreamId extends {
     readonly composite: ReadonlyArray<string>;
-}, TMetadata extends Schema.Top | undefined = undefined, TSnapshot extends SnapshotConfig | undefined = undefined, const TIndexes extends { readonly [K in keyof TIndexes]: StreamIndexConfig<Schema.Schema.Type<TEvents[number]>>; } = {}>(config: {
+}, TMetadata extends Schema.Top | undefined = undefined, TSnapshot extends SnapshotConfig | undefined = undefined, const TIndexes extends { readonly [K in keyof TIndexes]: StreamIndexConfig<Schema.Schema.Type<TEvents[number]>, StreamIdInput<TStreamId["composite"]>, SnapshotStateOf<TSnapshot>>; } = {}>(config: {
     readonly table: TTable;
     readonly streamName: TStreamName;
     readonly events: TEvents;
@@ -816,8 +1189,10 @@ export declare const makeStream: <const TEvents extends ReadonlyArray<Schema.Top
     readonly metadata?: TMetadata;
     readonly snapshot?: TSnapshot;
     readonly casing?: DynamoSchema.Casing | undefined;
-    readonly indexes?: TIndexes & StreamIndexesConfig<TIndexes, Schema.Schema.Type<TEvents[number]>>;
-}) => EventStream<Schema.Schema.Type<TEvents[number]>, TStreamId["composite"], TMetadata extends Schema.Top ? Schema.Schema.Type<TMetadata> : undefined, TSnapshot extends SnapshotConfig<infer TStateSchema> ? Schema.Schema.Type<TStateSchema> : never, keyof TIndexes & string, IndexProjectionsOf<TIndexes>>;
+    readonly indexes?: TIndexes & StreamIndexesConfig<TIndexes, Schema.Schema.Type<TEvents[number]>, StreamIdInput<TStreamId["composite"]>, SnapshotStateOf<TSnapshot>>;
+    /** How event `data` is stored — see {@link StreamStorageConfig}. */
+    readonly storedAs?: StreamStorageConfig | undefined;
+}) => EventStream<Schema.Schema.Type<TEvents[number]>, TStreamId["composite"], TMetadata extends Schema.Top ? Schema.Schema.Type<TMetadata> : undefined, SnapshotStateOf<TSnapshot>, keyof TIndexes & string, IndexProjectionsOf<TIndexes>, PartitionedIndexesOf<TIndexes>>;
 /**
  * An EventStream whose operations have `DynamoClient` and `TableConfig` already
  * resolved, so all methods return `Effect<A, E, never>`.
@@ -842,12 +1217,14 @@ export interface BoundEventStream<TEvent, TStreamIdFields extends ReadonlyArray<
     readonly [K in TIndexName]: StreamIndexProjection;
 } = {
     readonly [K in TIndexName]: "all";
-}> extends Pipeable.Pipeable {
+}, TPartitionedIndexName extends string = never> extends Pipeable.Pipeable {
     readonly [EventStreamTypeId]: EventStreamTypeId;
     readonly streamName: string;
     readonly eventSchema: Schema.Top;
     /** See {@link EventStream.snapshotConfig}. */
     readonly snapshotConfig: SnapshotSettings | undefined;
+    /** See {@link EventStream.storedAs}. */
+    readonly storedAs: StreamStorageSettings;
     /** See {@link EventStream.indexes}. */
     readonly indexes: {
         readonly [K in TIndexName]: StreamIndexSettings;
@@ -867,15 +1244,27 @@ export interface BoundEventStream<TEvent, TStreamIdFields extends ReadonlyArray<
     /** See {@link EventStream.readLatest}. */
     readLatest(streamId: StreamIdInput<TStreamIdFields>, options?: ReadLatestOptions | undefined): Effect.Effect<LatestState<TState, TEvent, StreamMetadata<TMetadata>>, DynamoClientError | ValidationError, never>;
     /** See {@link EventStream.readIndex}. */
-    readIndex<N extends TIndexName>(name: N, streamId: StreamIdInput<TStreamIdFields>, options?: ReadIndexOptions | undefined): Effect.Effect<ReadonlyArray<StreamEvent<TEvent, IndexEventMetadata<TMetadata, TIndexProjections[N]>>>, DynamoClientError | ValidationError, never>;
+    readIndex<N extends TIndexName>(name: N, streamId: StreamIdInput<TStreamIdFields>, ...options: ReadIndexArgs<N, TPartitionedIndexName>): Effect.Effect<ReadonlyArray<StreamEvent<TEvent, IndexEventMetadata<TMetadata, TIndexProjections[N]>>>, DynamoClientError | ValidationError, never>;
+    /** See {@link EventStream.measureAppend}. */
+    measureAppend(streamId: StreamIdInput<TStreamIdFields>, events: ReadonlyArray<TEvent>, expectedVersion: number, options?: MeasureAppendOptions<TMetadata, TState> | undefined): Effect.Effect<AppendMeasurement, ValidationError, never>;
+    /** See {@link EventStream.measureSnapshot}. */
+    measureSnapshot(streamId: StreamIdInput<TStreamIdFields>, state: TState, asOfVersion: number): Effect.Effect<number, ValidationError, never>;
+    /** See {@link EventStream.decodeStreamImage}. */
+    decodeStreamImage(image: StreamImage, options: DecodeStreamImageOptions & {
+        readonly raw: true;
+    }): Effect.Effect<Option.Option<RawStreamEvent<TEvent, StreamMetadata<TMetadata>>>, ValidationError, never>;
+    decodeStreamImage(image: StreamImage, options?: DecodeStreamImageOptions): Effect.Effect<Option.Option<StreamEvent<TEvent, StreamMetadata<TMetadata>>>, ValidationError, never>;
     /**
      * The stream's query builders — unbound: run them with {@link provide}, or
-     * where `DynamoClient` and `TableConfig` are provided.
+     * where `DynamoClient` and `TableConfig` are provided. They do not use the
+     * context this bound stream captured unless run through {@link provide}:
+     * run directly, raw-row unpacking (`Query.select`) and decoding read the
+     * `Compression` registry of the caller's context, not the bound one.
      */
     readonly query: {
         events(streamId: StreamIdInput<TStreamIdFields>): Query.Query<StreamEvent<TEvent, StreamMetadata<TMetadata>>>;
         /** See `EventStream.query.index`. */
-        index<N extends TIndexName>(name: N, streamId: StreamIdInput<TStreamIdFields>): Query.Query<StreamEvent<TEvent, IndexEventMetadata<TMetadata, TIndexProjections[N]>>>;
+        index<N extends TIndexName>(name: N, streamId: StreamIdInput<TStreamIdFields>, ...options: IndexQueryArgs<N, TPartitionedIndexName>): Query.Query<StreamEvent<TEvent, IndexEventMetadata<TMetadata, TIndexProjections[N]>>>;
     };
     /** Escape hatch: provide DynamoClient | TableConfig to an arbitrary effect. */
     readonly provide: <A, E>(effect: Effect.Effect<A, E, DynamoClient | TableConfig>) => Effect.Effect<A, E, never>;
@@ -894,7 +1283,7 @@ export interface BoundEventStream<TEvent, TStreamIdFields extends ReadonlyArray<
  * yield* stream.append({ matchId: "m-1" }, [event], 0)     // R = never
  * ```
  */
-export declare const bind: <TEvent, TStreamIdFields extends ReadonlyArray<string>, TMetadata, TState, TIndexName extends string = never, TIndexProjections extends { readonly [K in TIndexName]: StreamIndexProjection; } = { readonly [K in TIndexName]: "all"; }>(stream: EventStream<TEvent, TStreamIdFields, TMetadata, TState, TIndexName, TIndexProjections>) => Effect.Effect<BoundEventStream<TEvent, TStreamIdFields, TMetadata, TState, TIndexName, TIndexProjections>, never, DynamoClient | TableConfig>;
+export declare const bind: <TEvent, TStreamIdFields extends ReadonlyArray<string>, TMetadata, TState, TIndexName extends string = never, TIndexProjections extends { readonly [K in TIndexName]: StreamIndexProjection; } = { readonly [K in TIndexName]: "all"; }, TPartitionedIndexName extends string = never>(stream: EventStream<TEvent, TStreamIdFields, TMetadata, TState, TIndexName, TIndexProjections, TPartitionedIndexName>) => Effect.Effect<BoundEventStream<TEvent, TStreamIdFields, TMetadata, TState, TIndexName, TIndexProjections, TPartitionedIndexName>, never, DynamoClient | TableConfig>;
 /**
  * `CreateTable` fragments for the stream indexes of one or more streams — see
  * {@link indexDefinitions}. The lists are absent when empty, because
@@ -920,7 +1309,7 @@ export interface StreamIndexDefinitions {
  * | `projection` | `Projection` |
  * |---|---|
  * | `"all"` (default) | `{ ProjectionType: "ALL" }` |
- * | `"withoutMetadata"` | `{ ProjectionType: "INCLUDE", NonKeyAttributes: ["__edd_e__", "data", "eventType", "streamId", "timestamp", "version"] }` |
+ * | `"withoutMetadata"` | `{ ProjectionType: "INCLUDE", NonKeyAttributes: ["__edd_e__", "data", "eventType", "streamId", "timestamp", "version"] }` — plus `"asOfVersion"` and `"state"` when a stream declaring the index puts its snapshot in it (#149) |
  * | `"keys"` | `{ ProjectionType: "INCLUDE", NonKeyAttributes: ["__edd_e__"] }` — not `KEYS_ONLY`: every read filters on `__edd_e__` |
  *
  * The deployed index must project what is declared — copy `Projection` from
@@ -931,7 +1320,12 @@ export interface StreamIndexDefinitions {
  * table over the limit).
  *
  * An index shared by several streams with the same definition is emitted
- * once. Lists are sorted by index name, attributes by attribute name.
+ * once — the way several streams write one GSI whose partition they derive
+ * (`partition`, #149): an order's line, payment and shipment streams under
+ * `ORDER#<orderId>`, say. Whether each declaration derives its partition or
+ * indexes its snapshot is not part of the definition: the index's key schema
+ * and projection kind are. Lists are sorted by index name, attributes by
+ * attribute name.
  *
  * - An LSI can only be created with the table, and caps the item collection
  *   of every partition key value in the table at 10 GB — entity partitions
@@ -959,13 +1353,19 @@ export interface StreamIndexDefinitions {
  *
  * @throws `[EDD-9067]` when two streams define the same physical index
  *   differently (another type, other key attributes, or another projection).
+ *   Whether a declaration derives its partition or indexes its snapshot is not
+ *   part of the index's definition: streams that differ only there share it.
  */
 export declare const indexDefinitions: (...streams: ReadonlyArray<{
     readonly streamName: string;
     readonly indexes: {
-        readonly [name: string]: Omit<StreamIndexSettings, "projection"> & {
+        readonly [name: string]: Omit<StreamIndexSettings, "projection" | "partition" | "snapshot"> & {
             /** Read as `"all"` when absent (a hand-built settings object). */
             readonly projection?: StreamIndexProjection | undefined;
+            /** Read as `"stream"` when absent (a hand-built settings object). */
+            readonly partition?: "stream" | "derived" | undefined;
+            /** Read as `false` when absent (a hand-built settings object). */
+            readonly snapshot?: boolean | undefined;
         };
     };
 }>) => StreamIndexDefinitions;
@@ -1326,7 +1726,7 @@ type BoundCommandHandler<State, Command, TEvent, E, TStreamIdFields extends Read
  * stream is also structurally an `EventStream`), a {@link CommandHandler}
  * otherwise.
  */
-type CommandHandlerFor<S, State, Command, TEvent, E, TConfig extends CommandHandlerOptions | undefined> = S extends BoundEventStream<any, infer TStreamIdFields, infer TMetadata, any, any> ? BoundCommandHandler<State, Command, TEvent, E, TStreamIdFields, TMetadata, TConfig> : S extends EventStream<any, infer TStreamIdFields, infer TMetadata, any, any> ? CommandHandler<State, Command, TEvent, E, TStreamIdFields, TMetadata, TConfig> : never;
+type CommandHandlerFor<S, State, Command, TEvent, E, TConfig extends CommandHandlerOptions | undefined> = S extends BoundEventStream<any, infer TStreamIdFields, infer TMetadata, any, any, any, any> ? BoundCommandHandler<State, Command, TEvent, E, TStreamIdFields, TMetadata, TConfig> : S extends EventStream<any, infer TStreamIdFields, infer TMetadata, any, any, any, any> ? CommandHandler<State, Command, TEvent, E, TStreamIdFields, TMetadata, TConfig> : never;
 /**
  * Create a command handler that reads, decides, and appends atomically.
  *
@@ -1426,13 +1826,13 @@ type CommandHandlerFor<S, State, Command, TEvent, E, TConfig extends CommandHand
  * `EventStreamTypeId` brand of the second argument.
  */
 export declare const commandHandler: {
-    <State, Command, TEvent, E, const TConfig extends CommandHandlerOptions | undefined = undefined>(decider: Decider<State, Command, TEvent, E>, options?: TConfig): <S extends BoundEventStream<TEvent, any, any, State, any, any> | EventStream<TEvent, ReadonlyArray<string>, any, State, any, any>>(stream: S) => CommandHandlerFor<S, State, Command, TEvent, E, TConfig>;
+    <State, Command, TEvent, E, const TConfig extends CommandHandlerOptions | undefined = undefined>(decider: Decider<State, Command, TEvent, E>, options?: TConfig): <S extends BoundEventStream<TEvent, any, any, State, any, any, any> | EventStream<TEvent, ReadonlyArray<string>, any, State, any, any, any>>(stream: S) => CommandHandlerFor<S, State, Command, TEvent, E, TConfig>;
     <State, Command, TEvent, E, TStreamIdFields extends ReadonlyArray<string>, TMetadata, TState extends State, TIndexName extends string, TIndexProjections extends {
         readonly [K in TIndexName]: StreamIndexProjection;
-    }, const TConfig extends CommandHandlerOptions | undefined = undefined>(decider: Decider<State, Command, TEvent, E>, stream: BoundEventStream<TEvent, TStreamIdFields, TMetadata, TState, TIndexName, TIndexProjections>, options?: TConfig): BoundCommandHandler<State, Command, TEvent, E, TStreamIdFields, TMetadata, TConfig>;
+    }, TPartitionedIndexName extends string, const TConfig extends CommandHandlerOptions | undefined = undefined>(decider: Decider<State, Command, TEvent, E>, stream: BoundEventStream<TEvent, TStreamIdFields, TMetadata, TState, TIndexName, TIndexProjections, TPartitionedIndexName>, options?: TConfig): BoundCommandHandler<State, Command, TEvent, E, TStreamIdFields, TMetadata, TConfig>;
     <State, Command, TEvent, E, TStreamIdFields extends ReadonlyArray<string>, TMetadata, TState extends State, TIndexName extends string, TIndexProjections extends {
         readonly [K in TIndexName]: StreamIndexProjection;
-    }, const TConfig extends CommandHandlerOptions | undefined = undefined>(decider: Decider<State, Command, TEvent, E>, stream: EventStream<TEvent, TStreamIdFields, TMetadata, TState, TIndexName, TIndexProjections>, options?: TConfig): CommandHandler<State, Command, TEvent, E, TStreamIdFields, TMetadata, TConfig>;
+    }, TPartitionedIndexName extends string, const TConfig extends CommandHandlerOptions | undefined = undefined>(decider: Decider<State, Command, TEvent, E>, stream: EventStream<TEvent, TStreamIdFields, TMetadata, TState, TIndexName, TIndexProjections, TPartitionedIndexName>, options?: TConfig): CommandHandler<State, Command, TEvent, E, TStreamIdFields, TMetadata, TConfig>;
 };
 /**
  * Reconstruct state from events by folding through a decider's `evolve` function.
@@ -1452,5 +1852,4 @@ export declare const foldFrom: {
     <A>(startState: unknown, events: ReadonlyArray<StreamEvent<A>>): <S, C, E>(decider: Decider<S, C, A, E>) => S;
     <S, C, A, E>(decider: Decider<S, C, A, E>, startState: S, events: ReadonlyArray<StreamEvent<A>>): S;
 };
-export {};
 //# sourceMappingURL=EventStore.d.ts.map