@photon-grove/evt 0.1.0 → 0.1.1

package/src/dynamodb/requests.ts

@@ -0,0 +1,256 @@
+// The `TransactWriteItems` actions of a commit and of a snapshot write, built from the storage
+// format alone (storage format, "Writes"). Every commit opens with the two control checks, the
+// feature marker's and the rebuild lock's, then writes the stream: its head update, its event
+// puts, and its snapshot put when it has one.
+
+import type {SerializedEvent, SerializedSnapshot} from '../event.js'
+import {int64Argument, safeIntegerArgument} from '../fields.js'
+import type {Commit} from '../repository.js'
+import type {TransactItem} from './client.js'
+import {type HeadAction, headUpdate} from './head.js'
+import {HEAD_SORT_KEY, type Item, SNAPSHOT_SORT_KEY, eventItem, snapshotItem} from './item.js'
+import {FEATURES_PK, REBUILD_LOCK_PK} from './marker.js'
+
+/** The marker check of a writer that validated the manifest at version `:v`. */
+export const MARKER_CHECK_CONDITION = 'attribute_not_exists(pk) OR version = :v'
+
+/** The rebuild-lock check: no lock row, so the rebuild generation is settled. */
+export const REBUILD_LOCK_CONDITION = 'attribute_not_exists(pk)'
+
+/** The condition of an event put: the sequence is new. */
+export const EVENT_PUT_CONDITION = 'attribute_not_exists(sk)'
+
+/** The condition of a commit's first snapshot of a stream. */
+export const FIRST_SNAPSHOT_CONDITION = 'attribute_not_exists(seq)'
+
+/** The condition of a commit's later snapshot: the stored one is the one before it. */
+export const NEXT_SNAPSHOT_CONDITION = 'seq = :seq'
+
+/** A snapshot write's head guard: the head covers the snapshot. */
+export const SNAPSHOT_GUARD_CONDITION = 'head >= :new'
+
+/** The guard of a snapshot of an empty stream (event sequence 0), which needs no head. */
+export const SNAPSHOT_GUARD_EMPTY_CONDITION = 'attribute_not_exists(head) OR head >= :new'
+
+/** The update expression of a retained stream's snapshot guard: it refreshes the head's `ttl`. */
+export const SNAPSHOT_GUARD_RETAINED_UPDATE = 'SET #ttl = :t'
+
+/** {@link SNAPSHOT_GUARD_CONDITION} with retention: the head's `ttl` is raised, never lowered. */
+export const SNAPSHOT_GUARD_RETAINED_CONDITION =
+  'head >= :new AND (attribute_not_exists(#ttl) OR #ttl <= :t)'
+
+/** A snapshot write's put: it never lowers the stored snapshot's event sequence. */
+export const SNAPSHOT_WRITE_CONDITION = 'attribute_not_exists(eventSeq) OR eventSeq <= :new'
+
+/** The key of a control row, or of a stream's snapshot. */
+export function controlKey(pk: string): Item {
+  return {pk: {S: pk}, sk: {N: SNAPSHOT_SORT_KEY.toString()}}
+}
+
+/** The key of a stream's head item. */
+export function headKey(entityId: string): Item {
+  return {pk: {S: entityId}, sk: {N: HEAD_SORT_KEY.toString()}}
+}
+
+/** The marker check of a writer that validated the manifest at `version`. */
+export function markerCheck(table: string, version: bigint): TransactItem {
+  return {
+    ConditionCheck: {
+      TableName: table,
+      Key: controlKey(FEATURES_PK),
+      ConditionExpression: MARKER_CHECK_CONDITION,
+      ExpressionAttributeValues: {':v': number(version)},
+    },
+  }
+}
+
+/** The rebuild-lock check every commit carries second. */
+export function rebuildLockCheck(table: string): TransactItem {
+  return {
+    ConditionCheck: {
+      TableName: table,
+      Key: controlKey(REBUILD_LOCK_PK),
+      ConditionExpression: REBUILD_LOCK_CONDITION,
+    },
+  }
+}
+
+/** The `ttl`s of a commit to a stream with retention, in Unix seconds. */
+export interface CommitTtl {
+  /** The commit's own `ttl`, which its event and snapshot items carry. */
+  items: number
+  /**
+   * The head item's: the commit's own `ttl` on a create, and on an append the larger of it and
+   * the largest `ttl` the writer loaded for the stream, because the head's is never lowered.
+   */
+  head: number
+}
+
+/** The `ttl` of a snapshot written outside a commit, to a stream with retention. */
+export interface SnapshotTtl {
+  /** The snapshot's `ttl`, in Unix seconds, stamped when it's written. */
+  ttl: number
+  /**
+   * Whether the head guard refreshes the head's `ttl` to at least the snapshot's. True unless the
+   * stored head's `ttl` is known to cover it already.
+   */
+  refresh: boolean
+}
+
+/**
+ * The actions of a commit with at least one event, in order, by a writer that validated the
+ * feature manifest at `markerVersion`. `ttl` is given only for a stream with retention. Exported
+ * for the compatibility fixtures: its signature changes when commits span streams.
+ */
+export function commitTransaction(
+  table: string,
+  commit: Commit,
+  markerVersion: bigint,
+  ttl?: CommitTtl,
+): TransactItem[] {
+  const first = commit.events[0]
+  const last = commit.events.at(-1)
+  if (first === undefined || last === undefined) {
+    throw new RangeError('a commit transaction needs at least one event')
+  }
+
+  const items = [markerCheck(table, markerVersion), rebuildLockCheck(table)]
+  const head = headUpdate(commit.entityId, first.sequence, last.sequence, ttl?.head)
+  items.push(headUpdateItem(table, head))
+  for (const event of commit.events) {
+    items.push(eventPut(table, event, ttl?.items))
+  }
+
+  const snapshot = commit.snapshot
+  if (snapshot) {
+    const stored: SerializedSnapshot = {
+      entityType: snapshot.entityType,
+      entityId: commit.entityId,
+      sequence: snapshot.sequence,
+      eventSequence: last.sequence,
+      payload: snapshot.payload,
+    }
+    items.push(commitSnapshotPut(table, stored, ttl?.items))
+  }
+
+  return items
+}
+
+/**
+ * The actions of a snapshot written outside a commit: the marker check, the head guard, and the
+ * put, which never lowers the stored snapshot. It carries no rebuild-lock check. `ttl` is given
+ * only for a stream with retention. Exported for the compatibility fixtures.
+ */
+export function snapshotTransaction(
+  table: string,
+  snapshot: SerializedSnapshot,
+  markerVersion: bigint,
+  ttl?: SnapshotTtl,
+): TransactItem[] {
+  const eventSequence = int64Argument(snapshot.eventSequence, 'snapshot.eventSequence')
+
+  return [
+    markerCheck(table, markerVersion),
+    snapshotGuard(table, snapshot.entityId, eventSequence, ttl),
+    {
+      Put: {
+        TableName: table,
+        Item: snapshotItem(snapshot, ttl?.ttl),
+        ConditionExpression: SNAPSHOT_WRITE_CONDITION,
+        ExpressionAttributeValues: {':new': number(eventSequence)},
+      },
+    },
+  ]
+}
+
+// The head item's action in a snapshot write: a check that the head covers the snapshot, or, for a
+// stream with retention, an update that also keeps the head's `ttl` at least the snapshot's. A
+// snapshot of an empty stream may have no head item, so it's always a check: an update would
+// create a head item without a head.
+function snapshotGuard(
+  table: string,
+  entityId: string,
+  eventSequence: bigint,
+  ttl: SnapshotTtl | undefined,
+): TransactItem {
+  const values: Record<string, {N: string}> = {':new': number(eventSequence)}
+  if (eventSequence === 0n || ttl === undefined || !ttl.refresh) {
+    return {
+      ConditionCheck: {
+        TableName: table,
+        Key: headKey(entityId),
+        ConditionExpression:
+          eventSequence === 0n ? SNAPSHOT_GUARD_EMPTY_CONDITION : SNAPSHOT_GUARD_CONDITION,
+        ExpressionAttributeValues: values,
+      },
+    }
+  }
+
+  values[':t'] = number(BigInt(safeIntegerArgument(ttl.ttl, 'ttl')))
+
+  return {
+    Update: {
+      TableName: table,
+      Key: headKey(entityId),
+      UpdateExpression: SNAPSHOT_GUARD_RETAINED_UPDATE,
+      ConditionExpression: SNAPSHOT_GUARD_RETAINED_CONDITION,
+      ExpressionAttributeNames: {'#ttl': 'ttl'},
+      ExpressionAttributeValues: values,
+    },
+  }
+}
+
+function headUpdateItem(table: string, action: HeadAction): TransactItem {
+  const update: NonNullable<TransactItem['Update']> = {
+    TableName: table,
+    Key: headKey(action.entityId),
+    UpdateExpression: action.updateExpression ?? '',
+    ConditionExpression: action.conditionExpression,
+    ExpressionAttributeValues: Object.fromEntries(
+      action.values.map(([placeholder, value]) => [placeholder, number(value)]),
+    ),
+  }
+  if (action.names.length > 0) {
+    update.ExpressionAttributeNames = Object.fromEntries(action.names)
+  }
+
+  return {Update: update}
+}
+
+function eventPut(table: string, event: SerializedEvent, ttl: number | undefined): TransactItem {
+  return {
+    Put: {TableName: table, Item: eventItem(event, ttl), ConditionExpression: EVENT_PUT_CONDITION},
+  }
+}
+
+// A commit's snapshot follows the stored one: sequence 1 needs none, and a later one needs the
+// one before it.
+function commitSnapshotPut(
+  table: string,
+  snapshot: SerializedSnapshot,
+  ttl: number | undefined,
+): TransactItem {
+  const sequence = int64Argument(snapshot.sequence, 'snapshot.sequence')
+  if (sequence <= 1n) {
+    return {
+      Put: {
+        TableName: table,
+        Item: snapshotItem(snapshot, ttl),
+        ConditionExpression: FIRST_SNAPSHOT_CONDITION,
+      },
+    }
+  }
+
+  return {
+    Put: {
+      TableName: table,
+      Item: snapshotItem(snapshot, ttl),
+      ConditionExpression: NEXT_SNAPSHOT_CONDITION,
+      ExpressionAttributeValues: {':seq': number(sequence - 1n)},
+    },
+  }
+}
+
+function number(value: bigint): {N: string} {
+  return {N: value.toString()}
+}

package/src/errors.ts

@@ -19,6 +19,17 @@
  * - `commitTooLarge`: the commit is over the transaction budget. Nothing was written.
  * - `compactionUncovered`: no snapshot covers the events compaction was asked to delete.
  * - `reservedEntityId`: a write to an entity ID in a namespace only the engine writes.
+ * - `unsupportedFeature`: the store declares a feature this package doesn't model. Nothing was
+ *   written.
+ * - `streamHeadsNotMigrated`: the store holds data but doesn't declare stream-heads. Nothing was
+ *   written.
+ * - `storeNotInitialized`: the store doesn't declare stream-heads, and the writer doesn't
+ *   initialize a store itself. Nothing was written.
+ * - `featureManifestChanged`: another writer changed the store's feature manifest since this one
+ *   validated it. Retryable: the writer validates it again.
+ * - `transient`: the backend throttled the write. Retryable. Nothing was written.
+ * - `rebuildInProgress`: a projection rebuild holds the store, so commits wait. Retryable.
+ * - `historyDependentProjection`: compaction was refused for a history-dependent entity type.
  * - `replay`: a stored event failed to upcast or decode while an aggregate loaded.
  * - `snapshot`: a stored snapshot failed to decode while an aggregate loaded.
  */
@@ -33,6 +44,13 @@ export type EvtErrorCode =
   | 'commitTooLarge'
   | 'compactionUncovered'
   | 'reservedEntityId'
+  | 'unsupportedFeature'
+  | 'streamHeadsNotMigrated'
+  | 'storeNotInitialized'
+  | 'featureManifestChanged'
+  | 'transient'
+  | 'rebuildInProgress'
+  | 'historyDependentProjection'
   | 'replay'
   | 'snapshot'
 
@@ -162,6 +180,127 @@ export class ReservedEntityIdError extends EvtError {
   }
 }
 
+/** A feature and one of its stored-format versions. */
+export interface FeaturePair {
+  readonly name: string
+  readonly version: number
+}
+
+/**
+ * The store's feature manifest declares pairs this package doesn't model, so it refuses to write:
+ * a commit, a snapshot write, compaction or initialization. Nothing was written.
+ */
+export class UnsupportedFeatureError extends EvtError {
+  override readonly name = 'UnsupportedFeatureError'
+  override readonly code = 'unsupportedFeature'
+  /** Every unsupported pair, sorted by name. */
+  readonly unsupported: readonly FeaturePair[]
+
+  constructor(unsupported: readonly FeaturePair[]) {
+    const pairs = unsupported.map((pair) => `${pair.name}@${pair.version}`).join(', ')
+    super('unsupportedFeature', `store declares unsupported features (${pairs}); refusing to write`)
+    this.unsupported = unsupported
+  }
+}
+
+/**
+ * The store holds data but its feature manifest doesn't declare stream-heads: its streams may have
+ * no head items, so a head-aware write could fail every stream. Migrate the store with every older
+ * writer stopped. Nothing was written.
+ */
+export class StreamHeadsNotMigratedError extends EvtError {
+  override readonly name = 'StreamHeadsNotMigratedError'
+  override readonly code = 'streamHeadsNotMigrated'
+
+  constructor() {
+    super(
+      'streamHeadsNotMigrated',
+      'store does not declare the stream-heads feature and holds data without per-stream head ' +
+        'items; migrate it before writing',
+    )
+  }
+}
+
+/**
+ * The store's feature manifest doesn't declare stream-heads, and this writer doesn't initialize a
+ * store itself (the DynamoDB default), so it refuses rather than scan the table to learn whether
+ * it's fresh. Initialize a fresh store once, at deploy time, or migrate one written before stream
+ * heads. Nothing was written.
+ */
+export class StoreNotInitializedError extends EvtError {
+  override readonly name = 'StoreNotInitializedError'
+  override readonly code = 'storeNotInitialized'
+
+  constructor() {
+    super(
+      'storeNotInitialized',
+      'store is not initialized: the feature manifest does not declare stream-heads; initialize ' +
+        'a fresh store, or migrate one written before stream heads, before writing',
+    )
+  }
+}
+
+/**
+ * Another writer changed the store's feature manifest after this one validated it, so the commit's
+ * marker check failed. The writer has validated the new manifest, which it supports. Retryable.
+ * Nothing was written.
+ */
+export class FeatureManifestChangedError extends EvtError {
+  override readonly name = 'FeatureManifestChangedError'
+  override readonly code = 'featureManifestChanged'
+
+  constructor(options?: {cause?: unknown}) {
+    super('featureManifestChanged', 'feature manifest changed under this writer', options)
+  }
+}
+
+/**
+ * The backend refused the write for now, such as a DynamoDB transaction cancelled for throttling.
+ * Retryable, after a backoff. Nothing was written. The backend's error is its cause.
+ */
+export class TransientError extends EvtError {
+  override readonly name = 'TransientError'
+  override readonly code = 'transient'
+
+  constructor(detail: string, options?: {cause?: unknown}) {
+    super('transient', `transient failure: ${detail}`, options)
+  }
+}
+
+/**
+ * A projection rebuild holds the store, or one was force-released and no rebuild has finished
+ * since, so every commit is refused. Retryable: the command can run again once the rebuild ends.
+ */
+export class RebuildInProgressError extends EvtError {
+  override readonly name = 'RebuildInProgressError'
+  override readonly code = 'rebuildInProgress'
+
+  constructor() {
+    super('rebuildInProgress', 'a projection rebuild is in progress')
+  }
+}
+
+/**
+ * Compaction was refused because the store declares the entity's type history-dependent: its
+ * projectors' rebuild replays the events compaction would delete. Nothing was deleted.
+ */
+export class HistoryDependentProjectionError extends EvtError {
+  override readonly name = 'HistoryDependentProjectionError'
+  override readonly code = 'historyDependentProjection'
+  readonly entityType: string
+  readonly entityId: string
+
+  constructor(entityType: string, entityId: string) {
+    super(
+      'historyDependentProjection',
+      `entity type ${entityType} is declared history-dependent; compaction would delete the ` +
+        `commits its rebuild replays (entity ${entityId})`,
+    )
+    this.entityType = entityType
+    this.entityId = entityId
+  }
+}
+
 /** A load failed closed on a stored event: an upcaster threw, or the payload didn't decode. */
 export class ReplayError extends EvtError {
   override readonly name = 'ReplayError'
@@ -203,9 +342,21 @@ export function isConflict(error: unknown): boolean {
   return error instanceof EvtError && (error.code === 'conflict' || error.code === 'sequenceGap')
 }
 
-/** Whether reloading and running the command again may succeed. So far, only after a conflict. */
+/**
+ * Whether reloading and running the command again may succeed: after a conflict, while a rebuild
+ * holds the store, after the feature manifest changed under the writer, or after throttling.
+ */
 export function isRetryable(error: unknown): boolean {
-  return isConflict(error)
+  if (isConflict(error)) {
+    return true
+  }
+
+  return (
+    error instanceof EvtError &&
+    (error.code === 'rebuildInProgress' ||
+      error.code === 'featureManifestChanged' ||
+      error.code === 'transient')
+  )
 }
 
 /** An error's message, or the value itself as text. */

package/src/features.ts

@@ -0,0 +1,175 @@
+// The feature manifest a store keeps on its SYSTEM#FEATURES marker row (storage format, "Feature
+// marker"): the extensions it declares, each at a stored-format version, and the entity types
+// declared history-dependent or retained. A writer refuses a store that declares a pair it doesn't
+// model, and every writer requires stream-heads.
+
+import {
+  EvtError,
+  type FeaturePair,
+  StreamHeadsNotMigratedError,
+  UnsupportedFeatureError,
+} from './errors.js'
+import {DOCUMENT, int64, invalid} from './fields.js'
+import {type JsonValue, parseJson, stringifyJson} from './json.js'
+import {compareUtf8} from './utf8.js'
+
+/** The feature every writer models and requires: per-stream head items (ADR 0007). */
+export const STREAM_HEADS_FEATURE = 'stream-heads'
+
+/** The stored-format version of {@link STREAM_HEADS_FEATURE} this package reads and writes. */
+export const STREAM_HEADS_VERSION = 1
+
+/**
+ * The `(feature, stored-format version)` pairs this package models. The other features the
+ * storage format defines (`journal`, `journal-compaction`, `postgres-views`) are Rust-first, so a
+ * store that declares any of them is refused.
+ */
+export const SUPPORTED_FEATURES: readonly FeaturePair[] = Object.freeze([
+  Object.freeze({name: STREAM_HEADS_FEATURE, version: STREAM_HEADS_VERSION}),
+])
+
+// What validation reads. Private, so no caller can add a pair to it.
+const supported = new Map(SUPPORTED_FEATURES.map((pair) => [pair.name, pair.version]))
+
+/** The parsed marker row. A store with no marker row has no manifest. */
+export interface FeatureManifest {
+  /** Bumped by exactly one on every declaration. */
+  readonly version: bigint
+  /** Each declared feature's stored-format version. */
+  readonly features: ReadonlyMap<string, number>
+  /** The entity types whose commit-wide projectors are history-dependent: never compacted. */
+  readonly historyDependent: readonly string[]
+  /** The entity types configured with retention: never fenced. */
+  readonly retention: readonly string[]
+}
+
+/**
+ * Refuses a manifest that declares a pair this package doesn't model, listing every such pair,
+ * with an {@link UnsupportedFeatureError}.
+ */
+export function checkSupported(manifest: FeatureManifest | null): void {
+  const unsupported: FeaturePair[] = []
+  for (const [name, version] of sortedFeatures(manifest?.features ?? new Map())) {
+    if (supported.get(name) !== version) {
+      unsupported.push({name, version})
+    }
+  }
+
+  if (unsupported.length > 0) {
+    throw new UnsupportedFeatureError(unsupported)
+  }
+}
+
+/** Whether the manifest declares stream-heads at the version this package models. */
+export function declaresStreamHeads(manifest: FeatureManifest | null): boolean {
+  return manifest?.features.get(STREAM_HEADS_FEATURE) === STREAM_HEADS_VERSION
+}
+
+/**
+ * Refuses a write to a store whose manifest declares an unsupported pair, or doesn't declare
+ * stream-heads, without declaring anything.
+ */
+export function checkWritable(manifest: FeatureManifest | null): void {
+  checkSupported(manifest)
+  if (!declaresStreamHeads(manifest)) {
+    throw new StreamHeadsNotMigratedError()
+  }
+}
+
+/** The manifest with stream-heads declared and its version bumped: a first writer's declaration. */
+export function withStreamHeads(manifest: FeatureManifest | null): FeatureManifest {
+  const features = new Map(manifest?.features)
+  features.set(STREAM_HEADS_FEATURE, STREAM_HEADS_VERSION)
+
+  return {
+    version: (manifest?.version ?? 0n) + 1n,
+    features,
+    historyDependent: manifest?.historyDependent ?? [],
+    retention: manifest?.retention ?? [],
+  }
+}
+
+/** A manifest's stored JSON texts, as the marker row holds them. */
+export interface ManifestTexts {
+  /** A JSON object, feature name to stored-format version, keys sorted. `{}` when empty. */
+  features: string
+  /** A JSON array of entity types, sorted by UTF-8 bytes and deduplicated. `[]` when empty. */
+  historyDependent: string
+  /** Like `historyDependent`. */
+  retention: string
+}
+
+/** Encodes a manifest's declarable parts as the marker row stores them. */
+export function encodeManifest(manifest: FeatureManifest): ManifestTexts {
+  return {
+    features: stringifyJson(new Map(manifest.features)),
+    historyDependent: stringifyJson(entityTypeSet(manifest.historyDependent)),
+    retention: stringifyJson(entityTypeSet(manifest.retention)),
+  }
+}
+
+/**
+ * Decodes a marker row's stored texts. An empty text is an empty map or set, as an absent
+ * attribute is.
+ */
+export function decodeManifest(version: bigint, texts: ManifestTexts): FeatureManifest {
+  return {
+    version,
+    features: texts.features === '' ? new Map() : parseFeatures(texts.features),
+    historyDependent: parseEntityTypes(texts.historyDependent, 'historyDependent'),
+    retention: parseEntityTypes(texts.retention, 'retention'),
+  }
+}
+
+/** An entity-type set in its stored order: sorted by UTF-8 bytes and deduplicated. */
+export function entityTypeSet(types: readonly string[]): string[] {
+  // A fresh array, sorted in place: ES2022 has no toSorted.
+  const set = Array.from(new Set(types))
+  set.sort(compareUtf8)
+
+  return set
+}
+
+function parseFeatures(text: string): Map<string, number> {
+  const parsed = parseStored(text, 'features')
+  if (!(parsed instanceof Map)) {
+    throw invalid('the feature manifest is not a JSON object')
+  }
+
+  // Go and Rust read a version as an int64. One past the safe integers is no version this
+  // package models, so rounding it changes only the refusal's text.
+  const features = new Map<string, number>()
+  for (const [name, version] of parsed) {
+    features.set(name, Number(int64(version, `the feature manifest's ${name} version`)))
+  }
+
+  return features
+}
+
+function parseEntityTypes(text: string, what: string): string[] {
+  if (text.trim() === '') {
+    return []
+  }
+
+  const parsed = parseStored(text, what)
+  if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== 'string')) {
+    throw invalid(`the ${what} set is not a JSON array of strings`)
+  }
+
+  return entityTypeSet(parsed as string[])
+}
+
+function parseStored(text: string, what: string): JsonValue {
+  try {
+    return parseJson(text, DOCUMENT)
+  } catch (error) {
+    throw new EvtError('invalidRecord', `the stored ${what} is not JSON`, {cause: error})
+  }
+}
+
+function sortedFeatures(features: ReadonlyMap<string, number>): [string, number][] {
+  const sorted = Array.from(features)
+  sorted.sort(([a], [b]) => compareUtf8(a, b))
+
+  return sorted
+}

package/src/index.ts

@@ -30,11 +30,19 @@ export {
   ConflictError,
   EvtError,
   type EvtErrorCode,
+  FeatureManifestChangedError,
+  HistoryDependentProjectionError,
+  RebuildInProgressError,
   ReplayError,
   ReservedEntityIdError,
   SequenceGapError,
   SnapshotError,
+  StoreNotInitializedError,
   StreamHeadDriftError,
+  StreamHeadsNotMigratedError,
+  TransientError,
+  UnsupportedFeatureError,
+  type FeaturePair,
   isConflict,
   isRetryable,
 } from './errors.js'
@@ -47,6 +55,15 @@ export {
   encodeSnapshot,
   eventId,
 } from './event.js'
+export {
+  type FeatureManifest,
+  type ManifestTexts,
+  STREAM_HEADS_FEATURE,
+  STREAM_HEADS_VERSION,
+  SUPPORTED_FEATURES,
+  decodeManifest,
+  encodeManifest,
+} from './features.js'
 export {JsonNumber, type JsonValue, parseJson, stringifyJson} from './json.js'
 export {
   type Metadata,
@@ -56,7 +73,13 @@ export {
   emptyMetadata,
   encodeMetadata,
 } from './metadata.js'
-export type {CallOptions, Commit, NewSnapshot, Repository} from './repository.js'
+export type {
+  CallOptions,
+  Commit,
+  NewSnapshot,
+  Repository,
+  StoreInitializer,
+} from './repository.js'
 export {
   DEFAULT_RETRY_POLICY,
   type RetryPolicy,

package/src/memory/index.ts

@@ -1,3 +1,11 @@
 // @photon-grove/evt/memory: the in-memory repository, for tests and local development.
 
-export {type HeadFixtures, MemRepository, headFixtures} from './repository.js'
+export {
+  type ControlFixtures,
+  type HeadFixtures,
+  type ManifestDraft,
+  MemRepository,
+  type RebuildState,
+  controlFixtures,
+  headFixtures,
+} from './repository.js'