@powerhousedao/reactor 6.0.0-dev.23 → 6.0.0-dev.230

package/dist/index.d.ts

@@ -0,0 +1,4544 @@
+import { Action, CreateDocumentActionInput, DocumentModelModule, ISigner, Operation, OperationContext, OperationWithContext, OperationWithContext as OperationWithContext$1, PHDocument, PHDocumentState, SignatureVerificationHandler, UpgradeDocumentActionInput, UpgradeManifest, UpgradeReducer, UpgradeTransition, actions as documentActions } from "@powerhousedao/shared/document-model";
+import { DocumentDriveDocument, DriveInput, FolderNode, Node } from "@powerhousedao/shared/document-drive";
+import { ILogger } from "document-model";
+import * as kysely from "kysely";
+import { Generated, Insertable, Kysely, Transaction } from "kysely";
+import { IProcessor, IProcessorHostModule, IProcessorManager, IProcessorManager as IProcessorManager$1, IRelationalDb, ProcessorApp, ProcessorFactory, ProcessorFactory as ProcessorFactory$1, ProcessorFactoryBuilder, ProcessorFilter, ProcessorRecord, ProcessorStatus, RelationalDbProcessor, TrackedProcessor, TrackedProcessor as TrackedProcessor$1, createRelationalDb } from "@powerhousedao/shared/processors";
+
+//#region src/attachments/types.d.ts
+/**
+ * Content hash of the attachment data. This is the primary identifier.
+ * Format is algorithm-dependent, e.g. SHA-256 hex.
+ */
+type AttachmentHash = string;
+/**
+ * A reference to an attachment, used in document state and action inputs.
+ * Format: `attachment://v<version>:<hash>`
+ *
+ * The version prefix allows changing the hash algorithm, encoding, or
+ * length without leaking implementation details into the ref format.
+ * Version 1 is defined as SHA-256 hex.
+ *
+ * Using the hash as the ref makes attachments content-addressable:
+ * any peer that has the bytes for a given hash can serve the attachment.
+ */
+type AttachmentRef = `attachment://v${number}:${string}`;
+//#endregion
+//#region src/actions/index.d.ts
+/**
+ * Creates a CREATE_DOCUMENT action for document creation.
+ */
+declare function createDocumentAction(input: CreateDocumentActionInput): Action;
+/**
+ * Creates an UPGRADE_DOCUMENT action to set initial document state.
+ */
+declare function upgradeDocumentAction(input: UpgradeDocumentActionInput): Action;
+/**
+ * Creates a DELETE_DOCUMENT action for document deletion.
+ */
+declare function deleteDocumentAction(documentId: string): Action;
+/**
+ * Creates an ADD_RELATIONSHIP action to establish a parent-child relationship.
+ */
+declare function addRelationshipAction(sourceId: string, targetId: string, relationshipType?: string): Action;
+/**
+ * Creates a REMOVE_RELATIONSHIP action to remove a parent-child relationship.
+ */
+declare function removeRelationshipAction(sourceId: string, targetId: string, relationshipType?: string): Action;
+//#endregion
+//#region src/queue/types.d.ts
+type JobKind = "mutation" | "load";
+/**
+ * State of a job in the queue
+ */
+declare enum JobQueueState {
+  UNKNOWN = -1,
+  PREPROCESSING = 0,
+  PENDING = 1,
+  READY = 2,
+  RUNNING = 3,
+  RESOLVED = 4
+}
+/**
+ * Interface for a job execution handle
+ */
+interface IJobExecutionHandle {
+  readonly job: Job;
+  readonly state: JobQueueState;
+  start(): void;
+  complete(): void;
+  fail(error: ErrorInfo): void;
+  defer(): void;
+}
+/**
+ * Represents a job to be executed by the job executor
+ */
+type Job = {
+  /** Unique identifier for the job */id: string; /** Classification of the job so executors can switch behavior */
+  kind: JobKind; /** The document ID this job operates on */
+  documentId: string; /** The scope of the operations */
+  scope: string; /** The branch of the operations */
+  branch: string; /** The actions to be executed (processed sequentially) */
+  actions: Action[]; /** Pre-existing operations to import (used for load jobs) */
+  operations: Operation[]; /** Timestamp when the job was created */
+  createdAt: string; /** The hint for the queue to use for ordering the job */
+  queueHint: string[]; /** Number of retry attempts */
+  retryCount?: number; /** Maximum number of retries allowed */
+  maxRetries?: number; /** Last error if job failed */
+  lastError?: ErrorInfo; /** History of all errors from each attempt (ordered) */
+  errorHistory: ErrorInfo[]; /** Metadata that flows through the job lifecycle */
+  meta: JobMeta;
+};
+/**
+ * Event types for the queue system
+ */
+declare const QueueEventTypes: {
+  readonly JOB_AVAILABLE: 10000;
+};
+/**
+ * Event data for job available events
+ */
+type JobAvailableEvent = {
+  documentId: string;
+  scope: string;
+  branch: string;
+  jobId: string;
+};
+//#endregion
+//#region src/shared/types.d.ts
+/**
+ * Information about an error including message and stack trace.
+ */
+type ErrorInfo = {
+  message: string;
+  stack: string;
+};
+/**
+ * Describes the status of a shutdown operation.
+ */
+type ShutdownStatus = {
+  /**
+   * True if and only if the system has been shutdown.
+   *
+   * This value is meant to be polled to determine if the system has been shutdown.
+   *
+   * In the case of a browser process, the `kill` method should be able to synchronously set this to true.
+   *
+   * In the case of a server process, a graceful shutdown period should be allowed for the system to finish its work.
+   */
+  get isShutdown(): boolean;
+  /**
+   * A promise that resolves when the shutdown process is complete.
+   *
+   * For server environments, await this promise to ensure all active jobs finish
+   * before exiting the process.
+   */
+  completed: Promise<void>;
+};
+/**
+ * Enum that determines deletion propagation.
+ */
+declare enum PropagationMode {
+  None = "none",
+  Cascade = "cascade"
+}
+/**
+ * Enum that describes the type of relationship change.
+ */
+declare enum RelationshipChangeType {
+  Added = "added",
+  Removed = "removed"
+}
+/**
+ * Batch-specific metadata always present on every job.
+ * Single jobs get a unique batchId and batchJobIds of [jobId].
+ */
+type BatchMeta = {
+  batchId: string;
+  batchJobIds: string[];
+};
+/**
+ * Metadata that flows through the job lifecycle.
+ * Always includes batch fields; callers may add additional properties.
+ */
+type JobMeta = BatchMeta & Record<string, unknown>;
+/**
+ * Describes the current state of a job.
+ */
+type JobInfo = {
+  id: string;
+  status: JobStatus;
+  createdAtUtcIso: string;
+  completedAtUtcIso?: string;
+  error?: ErrorInfo;
+  errorHistory?: ErrorInfo[];
+  result?: any;
+  /**
+   * A token for coordinating reads, only valid once a job reaches COMPLETED.
+   */
+  consistencyToken: ConsistencyToken;
+  /**
+   * Metadata that flows through the job lifecycle.
+   */
+  meta: JobMeta;
+  /**
+   * The full job object, populated on failure for debugging purposes.
+   */
+  job?: Job;
+};
+/**
+ * Job execution statuses
+ */
+declare enum JobStatus {
+  /** Job is queued but not yet started */
+  PENDING = "PENDING",
+  /** Job is currently being executed */
+  RUNNING = "RUNNING",
+  /** Operations have been written to the operation store (JOB_WRITE_READY event) */
+  WRITE_READY = "WRITE_READY",
+  /** Read models have finished indexing operations (JOB_READ_READY event) */
+  READ_READY = "READ_READY",
+  /** Job failed (may be retried) */
+  FAILED = "FAILED"
+}
+/**
+ * Describe the view of a set of documents. That is, what pieces of the
+ * documents are populated.
+ */
+type ViewFilter = {
+  branch?: string;
+  scopes?: string[];
+  revision?: number;
+};
+/**
+ * Describes filter options for searching documents.
+ *
+ * Each parameter is treated as an AND condition.
+ */
+type SearchFilter = {
+  type?: string;
+  parentId?: string;
+  ids?: string[];
+  slugs?: string[];
+};
+/**
+ * Describes the options for paging.
+ */
+type PagingOptions = {
+  cursor: string;
+  limit: number;
+};
+/**
+ * The paged result.
+ */
+type PagedResults<T> = {
+  results: T[];
+  options: PagingOptions;
+  next?: () => Promise<PagedResults<T>>;
+  nextCursor?: string;
+  totalCount?: number;
+};
+/**
+ * A string key in the format `documentId:scope:branch` used to identify a consistency checkpoint.
+ */
+type ConsistencyKey = `${string}:${string}:${string}`;
+/**
+ * Describes a specific point in a document's operation history.
+ */
+type ConsistencyCoordinate = {
+  documentId: string;
+  scope: string;
+  branch: string;
+  operationIndex: number;
+};
+/**
+ * A token that captures the state of write operations at a point in time.
+ * Can be used to ensure read-after-write consistency.
+ */
+type ConsistencyToken = {
+  version: 1;
+  createdAtUtcIso: string;
+  coordinates: ConsistencyCoordinate[];
+};
+//#endregion
+//#region src/read-models/interfaces.d.ts
+/**
+ * Generic interface for any read model that can index operations.
+ * Implementations include IDocumentView, search indices, caches, etc.
+ */
+interface IReadModel {
+  /**
+   * Unique name identifying this read model, used for lookup via getReadModel.
+   */
+  readonly name: string;
+  /**
+   * Indexes a list of operations into the read model.
+   * This method is called asynchronously when operations are written to the operation store.
+   *
+   * @param operations - The operations with their context to index
+   */
+  indexOperations(operations: OperationWithContext$1[]): Promise<void>;
+}
+/**
+ * Coordinates read model synchronization with operation writes.
+ * Listens to operation events from the event bus and updates all registered read models.
+ */
+interface IReadModelCoordinator {
+  /**
+   * All registered read models (pre-ready and post-ready).
+   */
+  readonly readModels: IReadModel[];
+  /**
+   * Start listening for operation events and updating read models.
+   */
+  start(): void;
+  /**
+   * Stop listening and clean up subscriptions.
+   */
+  stop(): void;
+}
+//#endregion
+//#region src/sync/types.d.ts
+declare enum ChannelScheme {
+  CONNECT = "connect",
+  SWITCHBOARD = "switchboard"
+}
+/**
+ * Dynamic JWT token handler for generating authentication tokens per-request.
+ * Called with the target URL to enable audience-specific tokens (aud claim).
+ * Returns undefined if no authentication is available (e.g., user not logged in).
+ */
+type JwtHandler = (url: string) => Promise<string | undefined>;
+/**
+ * Controls how a remote drives its polling schedule.
+ * - `Auto` (default): the channel runs the configured interval timer in the background.
+ * - `Manual`: the channel registers and connects but never ticks on its own.
+ *   Callers must invoke ISyncManager.triggerPull(name) to fetch.
+ */
+declare enum PollBehavior {
+  Auto = "auto",
+  Manual = "manual"
+}
+type RemoteOptions = {
+  /**
+   * Stringified UTC timestamp (ms). When set and not `"0"`, outbox operations older
+   * than this value are excluded. `"0"` and `undefined` are equivalent and disable
+   * the filter, syncing from the beginning of history.
+   */
+  sinceTimestampUtcMs?: string;
+  /**
+   * Polling cadence for this remote. Defaults to `PollBehavior.Auto` when omitted.
+   */
+  pollBehavior?: PollBehavior;
+};
+type RemoteFilter = {
+  documentId: string[];
+  scope: string[];
+  branch: string;
+};
+type RemoteCursor = {
+  remoteName: string;
+  cursorType: string;
+  cursorOrdinal: number;
+  lastSyncedAtUtcMs?: number;
+};
+type ChannelMeta = {
+  id: string;
+};
+type SyncEnvelopeType = "operations" | "ack";
+type SyncEnvelope = {
+  type: SyncEnvelopeType;
+  channelMeta: ChannelMeta;
+  operations?: OperationWithContext$1[];
+  cursor?: RemoteCursor;
+  key?: string;
+  dependsOn?: string[];
+};
+declare enum SyncOperationStatus {
+  Unknown = -1,
+  TransportPending = 0,
+  ExecutionPending = 1,
+  Applied = 2,
+  Error = 3
+}
+declare enum ChannelErrorSource {
+  None = "none",
+  Channel = "channel",
+  Inbox = "inbox",
+  Outbox = "outbox"
+}
+type SyncOperationErrorType = "SIGNATURE_INVALID" | "HASH_MISMATCH" | "LIBRARY_ERROR" | "MISSING_OPERATIONS" | "EXCESSIVE_SHUFFLE" | "GRACEFUL_ABORT";
+type ChannelHealth = {
+  state: "idle" | "running" | "error";
+  lastSuccessUtcMs?: number;
+  lastFailureUtcMs?: number;
+  failureCount: number;
+};
+type ConnectionState = "connecting" | "connected" | "disconnected" | "reconnecting" | "error";
+type ConnectionStateSnapshot = {
+  state: ConnectionState;
+  failureCount: number;
+  lastSuccessUtcMs: number;
+  lastFailureUtcMs: number;
+  pushBlocked: boolean;
+  pushFailureCount: number;
+  receivingPages: boolean;
+};
+type ConnectionStateChangedEvent = {
+  remoteName: string;
+  remoteId: string;
+  previous: ConnectionState;
+  current: ConnectionState;
+  snapshot: ConnectionStateSnapshot;
+};
+type RemoteStatus = {
+  push: ChannelHealth;
+  pull: ChannelHealth;
+};
+type ChannelConfig = {
+  type: string;
+  parameters: Record<string, unknown>;
+};
+type RemoteRecord = {
+  id: string;
+  name: string;
+  collectionId: string;
+  channelConfig: ChannelConfig;
+  filter: RemoteFilter;
+  options: RemoteOptions;
+  status: RemoteStatus;
+};
+/**
+ * Event types for sync lifecycle events.
+ * These events track the sync progress of a job's operations to remotes.
+ * Uses a separate namespace (20000 range) from ReactorEventTypes (10000 range).
+ */
+declare const SyncEventTypes: {
+  readonly SYNC_PENDING: 20001;
+  readonly SYNC_SUCCEEDED: 20002;
+  readonly SYNC_FAILED: 20003;
+  readonly DEAD_LETTER_ADDED: 20004;
+  readonly CONNECTION_STATE_CHANGED: 20005;
+};
+/**
+ * Event emitted when all SyncOperations for a job are queued in outboxes.
+ */
+type SyncPendingEvent = {
+  jobId: string;
+  syncOperationCount: number;
+  remoteNames: string[];
+};
+/**
+ * Event emitted when all sync operations for a job succeed.
+ */
+type SyncSucceededEvent = {
+  jobId: string;
+  syncOperationCount: number;
+};
+/**
+ * Event emitted when at least one sync operation for a job fails.
+ */
+type SyncFailedEvent = {
+  jobId: string;
+  successCount: number;
+  failureCount: number;
+  errors: Array<{
+    remoteName: string;
+    documentId: string;
+    error: string;
+  }>;
+};
+/**
+ * Event emitted when a sync operation is moved to dead letter storage.
+ */
+type DeadLetterAddedEvent = {
+  id: string;
+  jobId: string;
+  remoteName: string;
+  documentId: string;
+  errorSource: ChannelErrorSource;
+};
+/**
+ * Status of a sync operation result.
+ */
+type SyncResultStatus = "succeeded" | "failed";
+/**
+ * Error information for a failed sync operation to a specific remote.
+ */
+type SyncResultError = {
+  remoteName: string;
+  documentId: string;
+  error: string;
+};
+/**
+ * Result of waiting for sync operations to complete for a job.
+ * Returned by ISyncManager.waitForSync().
+ */
+type SyncResult = {
+  jobId: string;
+  status: SyncResultStatus;
+  syncOperationCount: number;
+  successCount: number;
+  failureCount: number;
+  errors: SyncResultError[];
+};
+//#endregion
+//#region src/storage/interfaces.d.ts
+/**
+ * Thrown when an operation with the same identity already exists in the store.
+ */
+declare class DuplicateOperationError extends Error {
+  constructor(description: string);
+}
+/**
+ * Thrown when a concurrent write conflict is detected during an atomic apply.
+ */
+declare class OptimisticLockError extends Error {
+  constructor(message: string);
+}
+/**
+ * Thrown when the caller-provided revision does not match the current
+ * stored revision, indicating a stale read.
+ */
+declare class RevisionMismatchError extends Error {
+  constructor(expected: number, actual: number);
+}
+/**
+ * A write transaction passed to {@link IOperationStore.apply}. Accumulates
+ * operations that are committed atomically when the callback returns.
+ */
+interface AtomicTxn {
+  /** Stages one or more operations to be written as part of this transaction. */
+  addOperations(...operations: Operation[]): void;
+}
+/**
+ * Per-scope revision map for a document, used to reconstruct the header
+ * revision field and lastModified timestamp.
+ */
+type DocumentRevisions = {
+  /** Map of scope to operation index for that scope */revision: Record<string, number>; /** Latest timestamp across revisions */
+  latestTimestamp: string;
+};
+/**
+ * Append-only store for document operations. Operations are partitioned by
+ * (documentId, scope, branch) and ordered by a monotonic revision index.
+ */
+interface IOperationStore {
+  /**
+   * Atomically appends operations for a single document/scope/branch.
+   * The provided revision must match the current head; otherwise a
+   * {@link RevisionMismatchError} is thrown.
+   *
+   * @param documentId - The document id
+   * @param documentType - The document type identifier
+   * @param scope - The operation scope (e.g. "global", "local")
+   * @param branch - The branch name
+   * @param revision - Expected current revision (optimistic lock)
+   * @param fn - Callback that stages operations via {@link AtomicTxn}
+   * @param signal - Optional abort signal to cancel the request
+   */
+  apply(documentId: string, documentType: string, scope: string, branch: string, revision: number, fn: (txn: AtomicTxn) => void | Promise<void>, signal?: AbortSignal): Promise<void>;
+  /**
+   * Returns operations for a document/scope/branch whose index is greater
+   * than the given revision.
+   *
+   * @param documentId - The document id
+   * @param scope - The operation scope
+   * @param branch - The branch name
+   * @param revision - Return operations after this revision index
+   * @param filter - Optional filters (action types, timestamp range)
+   * @param paging - Optional paging options for cursor-based pagination
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getSince(documentId: string, scope: string, branch: string, revision: number, filter?: OperationFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<Operation>>;
+  /**
+   * Returns operations across all documents whose auto-increment store id
+   * is greater than the given id. Used by read models and sync to catch up
+   * on operations they may have missed.
+   *
+   * @param id - Return operations with store id greater than this value
+   * @param paging - Optional paging options for cursor-based pagination
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getSinceId(id: number, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<OperationWithContext$1>>;
+  /**
+   * Gets operations that may conflict with incoming operations during a load.
+   *
+   * @param documentId - The document id
+   * @param scope - The scope to query
+   * @param branch - The branch name
+   * @param minTimestamp - Minimum timestamp (inclusive) as ISO string
+   * @param paging - Optional paging options for cursor-based pagination
+   * @param signal - Optional abort signal to cancel the request
+   * @returns Paged results of operations that may conflict
+   */
+  getConflicting(documentId: string, scope: string, branch: string, minTimestamp: string, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<Operation>>;
+  /**
+   * Gets the latest operation index for each scope of a document, along with
+   * the latest timestamp across all scopes. This is used to efficiently reconstruct
+   * the revision map and lastModified timestamp for document headers.
+   *
+   * @param documentId - The document id
+   * @param branch - The branch name
+   * @param signal - Optional abort signal to cancel the request
+   * @returns Object containing revision map and latest timestamp
+   */
+  getRevisions(documentId: string, branch: string, signal?: AbortSignal): Promise<DocumentRevisions>;
+}
+/**
+ * Stores periodic document snapshots (keyframes) so that document state
+ * can be reconstructed without replaying the full operation history.
+ */
+interface IKeyframeStore {
+  /**
+   * Stores a document snapshot at a specific revision.
+   *
+   * @param documentId - The document id
+   * @param scope - The operation scope
+   * @param branch - The branch name
+   * @param revision - The operation index this snapshot corresponds to
+   * @param document - The full document state to persist
+   * @param signal - Optional abort signal to cancel the request
+   */
+  putKeyframe(documentId: string, scope: string, branch: string, revision: number, document: PHDocument, signal?: AbortSignal): Promise<void>;
+  /**
+   * Finds the keyframe closest to (but not exceeding) the target revision.
+   * Returns undefined if no keyframe exists for this document/scope/branch.
+   *
+   * @param documentId - The document id
+   * @param scope - The operation scope
+   * @param branch - The branch name
+   * @param targetRevision - The desired revision upper bound
+   * @param signal - Optional abort signal to cancel the request
+   */
+  findNearestKeyframe(documentId: string, scope: string, branch: string, targetRevision: number, signal?: AbortSignal): Promise<{
+    revision: number;
+    document: PHDocument;
+  } | undefined>;
+  /**
+   * Lists all keyframes for a document, optionally filtered by scope and branch.
+   *
+   * @param documentId - The document id
+   * @param scope - Optional scope filter
+   * @param branch - Optional branch filter
+   * @param signal - Optional abort signal to cancel the request
+   */
+  listKeyframes(documentId: string, scope?: string, branch?: string, signal?: AbortSignal): Promise<Array<{
+    scope: string;
+    branch: string;
+    revision: number;
+    document: PHDocument;
+  }>>;
+  /**
+   * Deletes keyframes for a document. Optionally scoped to a specific
+   * scope and/or branch.
+   *
+   * @param documentId - The document id
+   * @param scope - Optional scope filter; omit to delete across all scopes
+   * @param branch - Optional branch filter; omit to delete across all branches
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The number of keyframes deleted
+   */
+  deleteKeyframes(documentId: string, scope?: string, branch?: string, signal?: AbortSignal): Promise<number>;
+}
+/**
+ * Filters applied when reading document state from {@link IDocumentView}.
+ */
+interface ViewFilter$1 {
+  /** Branch to read from. Defaults to the main branch when omitted. */
+  branch?: string;
+  /** Scopes to include. When omitted, all scopes are included. */
+  scopes?: string[];
+  /** Exclude operations originating from this remote name. */
+  excludeSourceRemote?: string;
+}
+/**
+ * Filter options for querying operations. When multiple filters are provided,
+ * they are combined with AND logic.
+ */
+interface OperationFilter {
+  /** Filter by action types (OR logic within array) */
+  actionTypes?: string[];
+  /** Filter operations with timestamp >= this value (ISO string) */
+  timestampFrom?: string;
+  /** Filter operations with timestamp <= this value (ISO string) */
+  timestampTo?: string;
+  /** Filter operations with index >= this value */
+  sinceRevision?: number;
+}
+/**
+ * Materialised read model that maintains document snapshots. Snapshots are
+ * updated by indexing operations (which must include `resultingState`) and
+ * queried with optional consistency tokens for read-after-write guarantees.
+ */
+interface IDocumentView extends IReadModel {
+  /**
+   * Initializes the view.
+   */
+  init(): Promise<void>;
+  /**
+   * Indexes a list of operations.
+   *
+   * @param items - Operations with context. Context MUST include ephemeral
+   *                `resultingState` for optimization. IDocumentView never rebuilds
+   *                documents from operations - it always requires resultingState.
+   */
+  indexOperations(items: OperationWithContext$1[]): Promise<void>;
+  /**
+   * Blocks until the view has processed the coordinates referenced by the
+   * provided consistency token.
+   *
+   * @param token - Consistency token derived from the originating job
+   * @param timeoutMs - Optional timeout window in milliseconds
+   * @param signal - Optional abort signal to cancel the wait
+   */
+  waitForConsistency(token: ConsistencyToken, timeoutMs?: number, signal?: AbortSignal): Promise<void>;
+  /**
+   * Returns true if and only if the documents exist.
+   *
+   * @param documentIds - The list of document ids to check.
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  exists(documentIds: string[], consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<boolean[]>;
+  /**
+   * Returns the document with the given id.
+   *
+   * @param documentId - The id of the document to get.
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  get<TDocument extends PHDocument>(documentId: string, view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Returns the documents with the given ids.
+   *
+   * @param documentIds - The list of document ids to get.
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getMany<TDocument extends PHDocument>(documentIds: string[], view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument[]>;
+  /**
+   * Returns the document with the given identifier (either id or slug).
+   * Throws an error if the identifier matches both an id and a slug that refer to different documents.
+   *
+   * @param identifier - The id or slug of the document to get.
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @throws {Error} If identifier matches both an ID and slug referring to different documents
+   */
+  getByIdOrSlug<TDocument extends PHDocument>(identifier: string, view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Finds documents by their document type.
+   *
+   * @param type - The document type to search for
+   * @param view - Optional filter containing branch and scopes information
+   * @param paging - Optional paging options for cursor-based pagination
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  findByType(type: string, view?: ViewFilter$1, paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  /**
+   * Resolves a slug to a document ID.
+   *
+   * @param slug - The slug to resolve
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The document ID or undefined if the slug doesn't exist
+   */
+  resolveSlug(slug: string, view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string | undefined>;
+  /**
+   * Resolves a list of slugs to document IDs.
+   *
+   * @param slugs - The list of slugs to resolve.
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The list of document IDs
+   */
+  resolveSlugs(slugs: string[], view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[]>;
+  /**
+   * Resolves an identifier (either id or slug) to a document ID.
+   * This is a lightweight alternative to getByIdOrSlug that returns just the ID
+   * without fetching the full document.
+   *
+   * @param identifier - The id or slug to resolve
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The document ID
+   * @throws {Error} If document not found or identifier matches both an ID and slug referring to different documents
+   */
+  resolveIdOrSlug(identifier: string, view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string>;
+}
+/**
+ * A directed relationship between two documents in the document graph.
+ */
+type DocumentRelationship = {
+  sourceId: string;
+  targetId: string;
+  relationshipType: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+};
+/**
+ * A lightweight directed edge in a {@link IDocumentGraph}.
+ */
+type DocumentGraphEdge = {
+  from: string;
+  to: string;
+  type: string;
+};
+/**
+ * A subgraph of the document relationship graph, returned by traversal
+ * queries such as {@link IDocumentIndexer.findAncestors}.
+ */
+interface IDocumentGraph {
+  nodes: string[];
+  edges: DocumentGraphEdge[];
+}
+/**
+ * Read model that maintains a directed graph of document relationships.
+ * Relationships are created and removed by indexing operations containing
+ * ADD_RELATIONSHIP and REMOVE_RELATIONSHIP actions.
+ */
+interface IDocumentIndexer extends IReadModel {
+  /**
+   * Initializes the indexer and catches up on any missed operations.
+   */
+  init(): Promise<void>;
+  /**
+   * Indexes a list of operations to update the relationship graph.
+   *
+   * @param operations - Operations to index. Will process ADD_RELATIONSHIP and
+   *                     REMOVE_RELATIONSHIP operations.
+   */
+  indexOperations(operations: OperationWithContext$1[]): Promise<void>;
+  /**
+   * Blocks until the indexer has processed the coordinates referenced by the
+   * provided consistency token.
+   *
+   * @param token - Consistency token derived from the originating job
+   * @param timeoutMs - Optional timeout window in milliseconds
+   * @param signal - Optional abort signal to cancel the wait
+   */
+  waitForConsistency(token: ConsistencyToken, timeoutMs?: number, signal?: AbortSignal): Promise<void>;
+  /**
+   * Returns outgoing relationships from a document.
+   *
+   * @param documentId - The source document id
+   * @param types - Optional filter by relationship types
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getOutgoing(documentId: string, types?: string[], paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<DocumentRelationship>>;
+  /**
+   * Returns incoming relationships to a document.
+   *
+   * @param documentId - The target document id
+   * @param types - Optional filter by relationship types
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getIncoming(documentId: string, types?: string[], paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<DocumentRelationship>>;
+  /**
+   * Checks if a relationship exists between two documents.
+   *
+   * @param sourceId - The source document id
+   * @param targetId - The target document id
+   * @param types - Optional filter by relationship types
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  hasRelationship(sourceId: string, targetId: string, types?: string[], consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<boolean>;
+  /**
+   * Returns all undirected relationships between two documents.
+   *
+   * @param a - The ID of the first document
+   * @param b - The ID of the second document
+   * @param types - Optional filter by relationship types
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getUndirectedRelationships(a: string, b: string, types?: string[], paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<DocumentRelationship>>;
+  /**
+   * Returns all directed relationships between two documents.
+   *
+   * @param sourceId - The source document id
+   * @param targetId - The target document id
+   * @param types - Optional filter by relationship types
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getDirectedRelationships(sourceId: string, targetId: string, types?: string[], paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<DocumentRelationship>>;
+  /**
+   * Finds a path from source to target following directed edges.
+   *
+   * @param sourceId - The source document id
+   * @param targetId - The target document id
+   * @param types - Optional filter by relationship types
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns Array of document ids representing the path, or null if no path exists
+   */
+  findPath(sourceId: string, targetId: string, types?: string[], consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[] | null>;
+  /**
+   * Returns all ancestors of a document in the relationship graph.
+   *
+   * @param documentId - The document id
+   * @param types - Optional filter by relationship types
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  findAncestors(documentId: string, types?: string[], consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<IDocumentGraph>;
+  /**
+   * Returns children of the given parents that have no parents outside
+   * the given set. Used by cascade delete to find documents that would
+   * be orphaned if all the given parents were deleted.
+   *
+   * @param parentIds - The set of parent document ids (the deletion set)
+   * @param types - Optional filter by relationship types
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getOrphanedChildren(parentIds: string[], types?: string[], signal?: AbortSignal): Promise<string[]>;
+  /**
+   * Returns all relationship types currently in the system.
+   *
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   */
+  getRelationshipTypes(consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[]>;
+}
+/**
+ * Persistent storage for sync remote configurations. Each remote represents
+ * a connection to an external system that operations can be synced with.
+ */
+interface ISyncRemoteStorage {
+  /**
+   * Lists all remotes.
+   *
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The remotes
+   */
+  list(signal?: AbortSignal): Promise<RemoteRecord[]>;
+  /**
+   * Gets a remote by name.
+   *
+   * @param name - The name of the remote
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The remote
+   */
+  get(name: string, signal?: AbortSignal): Promise<RemoteRecord>;
+  /**
+   * Upserts a remote.
+   *
+   * @param remote - The remote to upsert
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The remote
+   */
+  upsert(remote: RemoteRecord, signal?: AbortSignal): Promise<void>;
+  /**
+   * Removes a remote by name.
+   *
+   * @param name - The name of the remote
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The remote
+   */
+  remove(name: string, signal?: AbortSignal): Promise<void>;
+}
+/**
+ * Persistent storage for sync cursors that track inbox/outbox progress
+ * per remote. Cursors allow sync to resume from where it left off.
+ */
+interface ISyncCursorStorage {
+  /**
+   * Lists all cursors for a remote.
+   *
+   * @param remoteName - The name of the remote
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The cursors
+   */
+  list(remoteName: string, signal?: AbortSignal): Promise<RemoteCursor[]>;
+  /**
+   * Gets a cursor for a remote.
+   *
+   * @param remoteName - The name of the remote
+   * @param cursorType - The type of cursor ("inbox" or "outbox")
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The cursor
+   */
+  get(remoteName: string, cursorType: "inbox" | "outbox", signal?: AbortSignal): Promise<RemoteCursor>;
+  /**
+   * Upserts a cursor.
+   *
+   * @param cursor - The cursor to upsert
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The cursor
+   */
+  upsert(cursor: RemoteCursor, signal?: AbortSignal): Promise<void>;
+  /**
+   * Removes a cursor for a remote.
+   *
+   * @param remoteName - The name of the remote
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The cursor
+   */
+  remove(remoteName: string, signal?: AbortSignal): Promise<void>;
+}
+/**
+ * Serializable snapshot of a permanently failed SyncOperation.
+ */
+type DeadLetterRecord = {
+  id: string;
+  jobId: string;
+  jobDependencies: string[];
+  remoteName: string;
+  documentId: string;
+  scopes: string[];
+  branch: string;
+  operations: OperationWithContext$1[];
+  errorSource: ChannelErrorSource;
+  errorMessage: string;
+};
+/**
+ * Persists dead-lettered sync operations so they survive reactor restarts.
+ */
+interface ISyncDeadLetterStorage {
+  /**
+   * Lists dead letters for a remote, ordered by ordinal DESC (newest first).
+   *
+   * @param remoteName - The name of the remote
+   * @param paging - Optional paging options (cursor + limit)
+   * @param signal - Optional abort signal to cancel the request
+   * @returns Paged dead letter records
+   */
+  list(remoteName: string, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<DeadLetterRecord>>;
+  /**
+   * Adds a dead letter. Duplicate ids are silently ignored.
+   *
+   * @param deadLetter - The dead letter record to persist
+   * @param signal - Optional abort signal to cancel the request
+   */
+  add(deadLetter: DeadLetterRecord, signal?: AbortSignal): Promise<void>;
+  /**
+   * Removes a single dead letter by id.
+   *
+   * @param id - The dead letter id
+   * @param signal - Optional abort signal to cancel the request
+   */
+  remove(id: string, signal?: AbortSignal): Promise<void>;
+  /**
+   * Removes all dead letters for a remote.
+   *
+   * @param remoteName - The name of the remote
+   * @param signal - Optional abort signal to cancel the request
+   */
+  removeByRemote(remoteName: string, signal?: AbortSignal): Promise<void>;
+  /**
+   * Returns distinct document IDs that have any dead letter record across all remotes.
+   * Used to populate the quarantine set on startup.
+   *
+   * @param signal - Optional abort signal to cancel the request
+   */
+  listQuarantinedDocumentIds(signal?: AbortSignal): Promise<string[]>;
+}
+//#endregion
+//#region src/cache/operation-index-types.d.ts
+type OperationIndexEntry = Operation & {
+  ordinal?: number;
+  documentId: string;
+  documentType: string;
+  branch: string;
+  scope: string;
+  sourceRemote: string;
+};
+interface IOperationIndexTxn {
+  createCollection(collectionId: string): void;
+  addToCollection(collectionId: string, documentId: string): void;
+  removeFromCollection(collectionId: string, documentId: string): void;
+  write(operations: OperationIndexEntry[]): void;
+}
+interface IOperationIndex {
+  start(): IOperationIndexTxn;
+  commit(txn: IOperationIndexTxn, signal?: AbortSignal): Promise<number[]>;
+  find(collectionId: string, cursor?: number, view?: ViewFilter$1, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<OperationIndexEntry>>;
+  /**
+   * Get all operations for a specific document, ordered by ordinal.
+   * Used for retroactive sync when a document is added to a collection.
+   */
+  get(documentId: string, view?: ViewFilter$1, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<OperationIndexEntry>>;
+  getSinceOrdinal(ordinal: number, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<OperationWithContext$1>>;
+  getLatestTimestampForCollection(collectionId: string, signal?: AbortSignal): Promise<string | null>;
+  /**
+   * Get all collection memberships for the given document IDs.
+   * Returns a map of documentId to array of collection IDs.
+   */
+  getCollectionsForDocuments(documentIds: string[]): Promise<Record<string, string[]>>;
+}
+declare function driveCollectionId(branch: string, driveId: string): string;
+//#endregion
+//#region src/cache/write/interfaces.d.ts
+/**
+ * IWriteCache is a write-side projection that optimizes document state retrieval
+ * for the job executor. This is separate from IDocumentView (read-side projection) which optimizes
+ * queries and searches.
+ */
+interface IWriteCache {
+  /**
+   * Retrieves or builds the document at the specified revision.
+   * If targetRevision is not provided, retrieves the latest state.
+   *
+   * @param documentId - The document identifier
+   * @param scope - Operation scope
+   * @param branch - Branch name
+   * @param targetRevision - The exact revision to retrieve (optional, defaults to latest)
+   * @param signal - Optional abort signal to cancel the operation
+   * @returns The complete document at the specified revision
+   *
+   * @example
+   * ```typescript
+   * // Get latest document state
+   * const doc = await cache.getState(docId, 'global', 'main');
+   *
+   * // Get document at specific revision
+   * const doc = await cache.getState(docId, 'global', 'main', 42);
+   * ```
+   */
+  getState(documentId: string, scope: string, branch: string, targetRevision?: number, signal?: AbortSignal): Promise<PHDocument>;
+  /**
+   * Stores a document snapshot in the cache at the specified revision.
+   * Implementations may truncate the stored document (e.g. strip operation
+   * history beyond the last entry per scope, clear clipboard) to bound memory
+   * and copy cost. Callers must not assume that the document returned by a
+   * subsequent getState() call will have a complete operations array; the only
+   * guaranteed invariant is that operations[scope].at(-1) holds the latest
+   * operation index for each scope present in the cached document.
+   *
+   * @param documentId - The document identifier
+   * @param scope - Operation scope
+   * @param branch - Branch name
+   * @param revision - The revision this document represents
+   * @param document - The document to cache
+   *
+   * @example
+   * ```typescript
+   * cache.putState(docId, 'global', 'main', 42, document);
+   * ```
+   */
+  putState(documentId: string, scope: string, branch: string, revision: number, document: PHDocument): void;
+  /**
+   * Invalidates (removes) cached entries for a document stream.
+   *
+   * - If only documentId is provided: invalidates all scopes and branches for that document
+   * - If documentId + scope provided: invalidates all branches for that document and scope
+   * - If all parameters provided: invalidates the specific stream
+   *
+   * @param documentId - The document identifier
+   * @param scope - Optional scope to narrow invalidation
+   * @param branch - Optional branch to narrow invalidation
+   * @returns Number of ring buffers evicted
+   *
+   * @example
+   * ```typescript
+   * // Invalidate all streams for a document
+   * cache.invalidate(docId);
+   *
+   * // Invalidate all branches for a specific scope
+   * cache.invalidate(docId, 'global');
+   *
+   * // Invalidate specific stream
+   * cache.invalidate(docId, 'global', 'main');
+   * ```
+   */
+  invalidate(documentId: string, scope?: string, branch?: string): number;
+  /**
+   * Clears all cached data from the in-memory cache.
+   */
+  clear(): void;
+  /**
+   * Performs startup initialization.
+   */
+  startup(): Promise<void>;
+  /**
+   * Performs graceful shutdown.
+   */
+  shutdown(): Promise<void>;
+}
+//#endregion
+//#region src/events/types.d.ts
+/**
+ * Describes a function to unsubscribe from an event.
+ */
+type Unsubscribe = () => void;
+/**
+ * A subscriber is a function that is called when an event is emitted.
+ *
+ * It is passed the event type and the data.
+ * It can return a promise or a value.
+ * If it returns a promise, the event bus will wait for the promise to resolve before calling the next subscriber.
+ * If it throws an error, the event bus will reject with an aggregate error of all errors.
+ *
+ * @param type - The type of event to emit.
+ * @param data - The data to pass to the subscriber.
+ */
+type Subscriber = (type: number, data: any) => void | Promise<void>;
+/**
+ * Custom error class that aggregates multiple errors from event subscribers.
+ */
+declare class EventBusAggregateError extends Error {
+  readonly errors: any[];
+  constructor(errors: unknown[]);
+}
+/**
+ * Event types for reactor lifecycle events.
+ */
+declare const ReactorEventTypes: {
+  readonly JOB_PENDING: 10001;
+  readonly JOB_RUNNING: 10002;
+  readonly JOB_WRITE_READY: 10003;
+  readonly JOB_READ_READY: 10004;
+  readonly JOB_FAILED: 10005;
+};
+/**
+ * Event emitted when a job is registered and waiting to be executed.
+ */
+type JobPendingEvent = {
+  jobId: string;
+  jobMeta: JobMeta;
+};
+/**
+ * Event emitted when a job starts executing.
+ */
+type JobRunningEvent = {
+  jobId: string;
+  jobMeta: JobMeta;
+};
+/**
+ * Event emitted when operations are written to IOperationStore.
+ * Contains the operations directly to avoid round-trip queries.
+ */
+type JobWriteReadyEvent = {
+  jobId: string;
+  operations: OperationWithContext$1[];
+  jobMeta: JobMeta;
+  /**
+   * Maps documentId to the collection IDs it belongs to.
+   * Used by SyncManager to route operations only to remotes
+   * whose collection contains the document.
+   */
+  collectionMemberships?: Record<string, string[]>;
+};
+/**
+ * Event emitted after all read models have finished processing operations.
+ * This event fires after JOB_WRITE_READY and guarantees that:
+ * - All read models (DocumentView, DocumentIndexer, etc.) have indexed the operations
+ * - All consistency trackers have been updated with the new operation indices
+ * - Queries without consistency tokens will now see the updated data
+ *
+ * This event is useful for:
+ * - Test synchronization (knowing when read models are ready)
+ * - Observability (measuring read model latency)
+ * - Event-driven workflows (triggering downstream processes)
+ */
+type JobReadReadyEvent = {
+  jobId: string;
+  operations: OperationWithContext$1[];
+};
+/**
+ * Event emitted when a job fails with an unrecoverable error.
+ * This event allows the JobAwaiter and other subscribers to react to job failures
+ * without polling.
+ */
+type JobFailedEvent$1 = {
+  jobId: string;
+  error: Error;
+  job?: Job;
+};
+//#endregion
+//#region src/events/interfaces.d.ts
+/**
+ * Describes an object that manages event subscriptions and emissions.
+ */
+interface IEventBus {
+  /**
+   * Register a new subscriber.
+   * Order is preserved by pushing to the end of the per-type array.
+   *
+   * @param type - The type of event to subscribe to.
+   * @param subscriber - The subscriber function to call when the event is emitted.
+   *
+   * @returns A function to unsubscribe from the event.
+   */
+  subscribe<K>(type: number, subscriber: (type: number, event: K) => void | Promise<void>): Unsubscribe;
+  /**
+   * Emits an event and waits until **all** subscribers finish.
+   *  - Every subscriber present at emit-start is called, in registration order.
+   *  - Calls are invoked and settled sequentially.
+   *  - If subscribers throw/reject, `emit` rejects with an aggregate error of all errors.
+   *
+   * @param type - The type of event to emit.
+   * @param data - The data to pass to the subscribers.
+   */
+  emit(type: number, data: any): Promise<void>;
+}
+//#endregion
+//#region src/shared/awaiter.d.ts
+interface IJobAwaiter {
+  /**
+   * Waits for a job to complete: turns a job into a promise.
+   *
+   * @param jobId - The job id or job object
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The result of the job
+   */
+  waitForJob(jobId: string, signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Shuts down the job awaiter. This will synchronously reject all pending jobs.
+   */
+  shutdown(): void;
+}
+/**
+ * Event-driven implementation of IJobAwaiter.
+ * Subscribes to operation events to detect job completion without polling.
+ */
+declare class JobAwaiter implements IJobAwaiter {
+  private eventBus;
+  private getJobStatus;
+  private pendingJobs;
+  private unsubscribers;
+  constructor(eventBus: IEventBus, getJobStatus: (jobId: string, signal?: AbortSignal) => Promise<JobInfo>);
+  private subscribeToEvents;
+  shutdown(): void;
+  waitForJob(jobId: string, signal?: AbortSignal): Promise<JobInfo>;
+  private handleWriteReady;
+  private handleReadReady;
+  private handleJobFailed;
+  private checkAndResolveWaiters;
+}
+//#endregion
+//#region src/subs/types.d.ts
+/**
+ * Error handler for subscription callback errors
+ */
+interface ISubscriptionErrorHandler {
+  /**
+   * Called when a subscription callback throws an error
+   * @param error - The error that was thrown
+   * @param context - Context about which subscription failed
+   */
+  handleError(error: unknown, context: SubscriptionErrorContext): void;
+}
+/**
+ * Context information about a subscription error
+ */
+interface SubscriptionErrorContext {
+  /** The type of event that was being processed */
+  eventType: "created" | "deleted" | "updated" | "relationshipChanged";
+  /** The subscription ID that failed */
+  subscriptionId: string;
+  /** Optional additional data about the event */
+  eventData?: unknown;
+}
+/**
+ * Interface for subscribing to document events in the reactor.
+ */
+interface IReactorSubscriptionManager {
+  /**
+   * Subscribes to document creation events
+   *
+   * @param callback - Function called when documents are created
+   * @param search - Optional search filter to limit which documents trigger events
+   * @param view - Optional filter containing branch and scopes information
+   * @returns A function that unsubscribes from the events
+   */
+  onDocumentCreated(callback: (result: PagedResults<string>) => void, search?: SearchFilter): () => void;
+  /**
+   * Subscribes to document deletion events
+   *
+   * @param callback - Function called when documents are deleted
+   * @param search - Optional search filter to limit which documents trigger events
+   * @returns A function that unsubscribes from the events
+   */
+  onDocumentDeleted(callback: (documentIds: string[]) => void, search?: SearchFilter): () => void;
+  /**
+   * Subscribes to document state updates
+   *
+   * @param callback - Function called when documents are updated
+   * @param search - Optional search filter to limit which documents trigger events
+   * @param view - Optional filter containing branch and scopes information
+   * @returns A function that unsubscribes from the events
+   */
+  onDocumentStateUpdated(callback: (result: PagedResults<PHDocument>) => void, search?: SearchFilter, view?: ViewFilter): () => void;
+  /**
+   * Subscribes to parent-child relationship change events
+   *
+   * @param callback - Function called when parent-child relationships change
+   * @param search - Optional search filter to limit which documents trigger events
+   * @returns A function that unsubscribes from the events
+   */
+  onRelationshipChanged(callback: (parentId: string, childId: string, changeType: RelationshipChangeType) => void, search?: SearchFilter): () => void;
+}
+//#endregion
+//#region src/client/types.d.ts
+/**
+ * Describes the types of document changes that can occur.
+ */
+declare enum DocumentChangeType {
+  Created = "created",
+  Deleted = "deleted",
+  Updated = "updated",
+  ParentAdded = "parent_added",
+  ParentRemoved = "parent_removed",
+  ChildAdded = "child_added",
+  ChildRemoved = "child_removed"
+}
+/**
+ * Represents a change event for documents.
+ */
+type DocumentChangeEvent = {
+  type: DocumentChangeType;
+  documents: PHDocument[];
+  context?: {
+    parentId?: string;
+    childId?: string;
+  };
+};
+/**
+ * Options for creating an empty document.
+ */
+type CreateDocumentOptions = {
+  /** Optional "id" or "slug" of parent document */parentIdentifier?: string; /** Optional version of the document model to use (defaults to latest) */
+  documentModelVersion?: number;
+};
+/**
+ * Drive-aware operations grouped under `client.drives`.
+ *
+ * These methods orchestrate the multi-action, multi-document choreography
+ * required to keep a drive's `state.global.nodes` array consistent with the
+ * relationship index and the underlying documents. Use the flat
+ * `IReactorClient` primitives (`get`, `execute`, `find`) for everything that
+ * is not drive-aware.
+ */
+interface IDriveClient {
+  /**
+   * Creates a new drive document and waits for completion.
+   */
+  create(input: DriveInput, signal?: AbortSignal): Promise<DocumentDriveDocument>;
+  /**
+   * Adds a document to a drive as a single batched operation.
+   *
+   * Issues CREATE_DOCUMENT, UPGRADE_DOCUMENT, ADD_RELATIONSHIP on the new
+   * document and ADD_FILE on the drive in a single dependent batch.
+   */
+  addFile<TDocument extends PHDocument = PHDocument>(driveIdentifier: string, document: PHDocument, parentFolder?: string, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Adds a folder node to a drive.
+   */
+  addFolder(driveIdentifier: string, name: string, parentFolder?: string, signal?: AbortSignal): Promise<FolderNode>;
+  /**
+   * Removes a node from a drive. Folder nodes cascade: descendant file
+   * documents are deleted first, then the folder node entry itself.
+   */
+  removeNode(driveIdentifier: string, nodeId: string, signal?: AbortSignal): Promise<void>;
+  /**
+   * Renames a node. Updates both the underlying document header and the
+   * drive's node entry.
+   */
+  renameNode(driveIdentifier: string, nodeId: string, name: string, signal?: AbortSignal): Promise<Node>;
+  /**
+   * Moves a node to a different parent folder within the same drive.
+   * Pass `undefined` to move the node to the drive root.
+   */
+  moveNode(driveIdentifier: string, srcNodeId: string, targetParentFolderId: string | undefined, signal?: AbortSignal): Promise<DocumentDriveDocument>;
+  /**
+   * Copies a node (and its subtree, if it is a folder) within a drive.
+   * Each copied file gets a new id and a duplicated document.
+   */
+  copyNode(driveIdentifier: string, srcNodeId: string, targetParentFolderId: string | undefined, signal?: AbortSignal): Promise<DocumentDriveDocument>;
+  /**
+   * Returns a single node from the drive's `state.global.nodes` array.
+   */
+  getNode(driveIdentifier: string, nodeId: string, signal?: AbortSignal): Promise<Node>;
+  /**
+   * Returns nodes in the drive, optionally filtered to a single parent
+   * folder. Pass `null` to list root-level nodes only.
+   */
+  listNodes(driveIdentifier: string, parentFolder?: string | null, signal?: AbortSignal): Promise<Node[]>;
+}
+/**
+ * The ReactorClient interface that wraps lower-level APIs to provide
+ * a simpler interface for document operations.
+ *
+ * Features:
+ * - Wraps Jobs with Promises for easier async handling
+ * - Manages signing of submitted Action objects
+ * - Provides quality-of-life functions for common tasks
+ * - Wraps subscription interface with ViewFilters
+ */
+interface IReactorClient {
+  /**
+   * Drive-aware operations. See {@link IDriveClient}.
+   */
+  readonly drives: IDriveClient;
+  /**
+   * Retrieves a list of document model modules.
+   *
+   * @param namespace - Optional namespace like "powerhouse" or "sky", defaults to ""
+   * @param paging - Optional pagination options
+   * @param signal - Optional abort signal to cancel the request
+   * @returns List of document model modules
+   */
+  getDocumentModelModules(namespace?: string, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<DocumentModelModule>>;
+  /**
+   * Retrieves a specific document model module by document type.
+   *
+   * @param documentType - The document type identifier
+   * @returns The document model module
+   */
+  getDocumentModelModule(documentType: string): Promise<DocumentModelModule<any>>;
+  /**
+   * Retrieves a specific document by identifier (either id or slug).
+   *
+   * @param identifier - Required, this is the document id or slug
+   * @param view - Optional filter containing branch and scopes information
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The up-to-date PHDocument with scopes and list of child document ids
+   */
+  get<TDocument extends PHDocument>(identifier: string, view?: ViewFilter, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Retrieves operations for a document.
+   *
+   * @param documentIdentifier - Required, this is either a document "id" field or a "slug"
+   * @param view - Optional filter containing branch and scopes information
+   * @param filter - Optional filter for actionTypes, timestamps, and revision
+   * @param paging - Optional pagination options
+   * @param signal - Optional abort signal to cancel the request
+   * @returns Paginated list of operations
+   */
+  getOperations(documentIdentifier: string, view?: ViewFilter, filter?: OperationFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<Operation>>;
+  /**
+   * Retrieves outgoing relationships of a given type from a source document.
+   *
+   * @param sourceIdentifier - Required, this is either a document "id" field or a "slug"
+   * @param relationshipType - The relationship type to filter by
+   * @param view - Optional filter containing branch and scopes information
+   * @param paging - Optional pagination options
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The target documents and paging cursor
+   */
+  getOutgoingRelationships(sourceIdentifier: string, relationshipType: string, view?: ViewFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  /**
+   * Retrieves incoming relationships of a given type to a target document.
+   *
+   * @param targetIdentifier - Required, this is either a document "id" field or a "slug"
+   * @param relationshipType - The relationship type to filter by
+   * @param view - Optional filter containing branch and scopes information
+   * @param paging - Optional pagination options
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The source documents and paging cursor
+   */
+  getIncomingRelationships(targetIdentifier: string, relationshipType: string, view?: ViewFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  /**
+   * Filters documents by criteria and returns a list of them
+   *
+   * @param search - Search filter options (type, parentId, identifiers)
+   * @param view - Optional filter containing branch and scopes information
+   * @param paging - Optional pagination options
+   * @param signal - Optional abort signal to cancel the request
+   * @returns List of documents matching criteria and pagination cursor
+   */
+  find(search: SearchFilter, view?: ViewFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  /**
+   * Creates a document and waits for completion
+   *
+   * @param document - Document with optional id, slug, parent, model type, and initial state
+   * @param parentIdentifier - Optional "id" or "slug" of parent document
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The created document
+   */
+  create<TDocument extends PHDocument = PHDocument>(document: PHDocument, parentIdentifier?: string, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Creates an empty document and waits for completion
+   *
+   * @param documentModelType - Type of document to create
+   * @param options - Optional creation options (parentIdentifier, documentModelVersion)
+   * @param signal - Optional abort signal to cancel the request
+   */
+  createEmpty<TDocument extends PHDocument>(documentModelType: string, options?: CreateDocumentOptions, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Creates an empty document in a drive as a single batched operation.
+   * This is more efficient than createEmpty + addFile as it batches all
+   * actions into dependent jobs and waits for them to complete together.
+   *
+   * @deprecated Use {@link IDriveClient.addFile} via `client.drives.addFile`
+   * instead. This method will be removed in a future release.
+   * @param driveId - The drive document id or slug
+   * @param document - The document to create
+   * @param parentFolder - Optional folder id within the drive
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The created document
+   */
+  createDocumentInDrive<TDocument extends PHDocument>(driveId: string, document: PHDocument, parentFolder?: string, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Applies a list of actions to a document and waits for completion
+   *
+   * @param documentIdentifier - Target document id or slug
+   * @param branch - Branch to apply actions to
+   * @param actions - List of actions to apply
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The updated document
+   */
+  execute<TDocument extends PHDocument>(documentIdentifier: string, branch: string, actions: Action[], signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Submits a list of actions to a document
+   *
+   * @param documentIdentifier - Target document id or slug
+   * @param branch - Branch to apply actions to
+   * @param actions - List of actions to apply
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The job
+   */
+  executeAsync(documentIdentifier: string, branch: string, actions: Action[], signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Renames a document and waits for completion
+   *
+   * @param documentIdentifier - Target document id or slug
+   * @param name - The new name of the document
+   * @param branch - Optional branch to rename the document, defaults to "main"
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The updated document.
+   */
+  rename(documentIdentifier: string, name: string, branch?: string, signal?: AbortSignal): Promise<PHDocument>;
+  /**
+   * Adds a relationship between two documents and waits for completion.
+   *
+   * @param sourceIdentifier - Source document id or slug
+   * @param targetIdentifier - Target document id or slug
+   * @param relationshipType - Relationship type identifier
+   * @param branch - Optional branch to add the relationship to, defaults to "main"
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The updated source document
+   */
+  addRelationship(sourceIdentifier: string, targetIdentifier: string, relationshipType: string, branch?: string, signal?: AbortSignal): Promise<PHDocument>;
+  /**
+   * Removes a relationship between two documents and waits for completion.
+   *
+   * @param sourceIdentifier - Source document id or slug
+   * @param targetIdentifier - Target document id or slug
+   * @param relationshipType - Relationship type identifier
+   * @param branch - Optional branch to remove the relationship from, defaults to "main"
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The updated source document
+   */
+  removeRelationship(sourceIdentifier: string, targetIdentifier: string, relationshipType: string, branch?: string, signal?: AbortSignal): Promise<PHDocument>;
+  /**
+   * Moves a relationship from one source document to another and waits for completion.
+   *
+   * @param sourceParentIdentifier - Source parent document id or slug
+   * @param targetParentIdentifier - Target parent document id or slug
+   * @param targetIdentifier - The target document id or slug
+   * @param relationshipType - Relationship type identifier
+   * @param branch - Optional branch to apply the move to, defaults to "main"
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The updated source and target documents
+   */
+  moveRelationship(sourceParentIdentifier: string, targetParentIdentifier: string, targetIdentifier: string, relationshipType: string, branch?: string, signal?: AbortSignal): Promise<{
+    source: PHDocument;
+    target: PHDocument;
+  }>;
+  /**
+   * Deletes a document and waits for completion
+   *
+   * @param identifier - Document identifier (id or slug)
+   * @param propagate - Optional mode for handling children, CASCADE deletes child documents
+   * @param signal - Optional abort signal to cancel the request
+   * @returns a promise, resolving on deletion confirmation
+   */
+  deleteDocument(identifier: string, propagate?: PropagationMode, signal?: AbortSignal): Promise<void>;
+  /**
+   * Deletes documents and waits for completion
+   *
+   * @param identifiers - Document identifiers (ids or slugs)
+   * @param propagate - Optional mode for handling children, CASCADE deletes child documents
+   * @param signal - Optional abort signal to cancel the request
+   * @returns a promise, resolving on deletion confirmation
+   */
+  deleteDocuments(identifiers: string[], propagate?: PropagationMode, signal?: AbortSignal): Promise<void>;
+  /**
+   * Loads multiple batches of pre-existing operations across documents with dependency management.
+   * Waits for all jobs to complete.
+   *
+   * @param request - Batch load request containing jobs with dependencies
+   * @param signal - Optional abort signal to cancel the request
+   * @returns Map of job keys to completed job information
+   */
+  loadBatch(request: BatchLoadRequest, signal?: AbortSignal): Promise<BatchLoadResult>;
+  /**
+   * Retrieves the status of a job
+   *
+   * @param jobId - The job id
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The job status
+   */
+  getJobStatus(jobId: string, signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Waits for a job to complete
+   *
+   * @param jobId - The job id or job object
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The result of the job
+   */
+  waitForJob(jobId: string | JobInfo, signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Subscribes to changes for documents matching specified filters
+   *
+   * @param search - Search filter options (type, parentId, identifiers)
+   * @param callback - Function called when documents change with the change event details
+   * @param view - Optional filter containing branch and scopes information
+   * @returns A function that unsubscribes from the changes
+   */
+  subscribe(search: SearchFilter, callback: (event: DocumentChangeEvent) => void, view?: ViewFilter): () => void;
+}
+//#endregion
+//#region src/client/reactor-client.d.ts
+/**
+ * ReactorClient implementation that wraps lower-level APIs to provide
+ * a simpler interface for document operations.
+ *
+ * Features:
+ * - Wraps Jobs with Promises for easier async handling
+ * - Manages signing of submitted Action objects
+ * - Provides quality-of-life functions for common tasks
+ * - Wraps subscription interface with ViewFilters
+ */
+declare class ReactorClient implements IReactorClient {
+  private logger;
+  private reactor;
+  private signer;
+  private subscriptionManager;
+  private jobAwaiter;
+  private documentIndexer;
+  private documentView;
+  readonly drives: IDriveClient;
+  constructor(logger: ILogger, reactor: IReactor, signer: ISigner, subscriptionManager: IReactorSubscriptionManager, jobAwaiter: IJobAwaiter, documentIndexer: IDocumentIndexer, documentView: IDocumentView);
+  /**
+   * Retrieves a list of document model modules.
+   */
+  getDocumentModelModules(namespace?: string, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<DocumentModelModule>>;
+  /**
+   * Retrieves a specific document model module by document type.
+   *
+   * @param documentType - The document type identifier
+   * @returns The document model module
+   */
+  getDocumentModelModule(documentType: string): Promise<DocumentModelModule<any>>;
+  /**
+   * Retrieves a specific PHDocument
+   */
+  get<TDocument extends PHDocument>(identifier: string, view?: ViewFilter, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Retrieves operations for a document
+   */
+  getOperations(documentIdentifier: string, view?: ViewFilter, filter?: OperationFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<Operation>>;
+  private getOperationsWithCompositeCursor;
+  /**
+   * Retrieves outgoing relationships of a given type from a source document.
+   */
+  getOutgoingRelationships(sourceIdentifier: string, relationshipType: string, view?: ViewFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  /**
+   * Retrieves incoming relationships of a given type to a target document.
+   */
+  getIncomingRelationships(targetIdentifier: string, relationshipType: string, view?: ViewFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  /**
+   * Filters documents by criteria and returns a list of them
+   */
+  find(search: SearchFilter, view?: ViewFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  /**
+   * Creates a document and waits for completion
+   */
+  create<TDocument extends PHDocument = PHDocument>(document: PHDocument, parentIdentifier?: string, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Creates an empty document and waits for completion
+   */
+  createEmpty<TDocument extends PHDocument>(documentModelType: string, options?: CreateDocumentOptions, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Creates an empty document in a drive as a single batched operation.
+   * Delegates to {@link IDriveClient.addFile}.
+   *
+   * @deprecated Use `client.drives.addFile` instead. This method will be
+   * removed in a future release.
+   */
+  createDocumentInDrive<TDocument extends PHDocument>(driveId: string, document: PHDocument, parentFolder?: string, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Applies a list of actions to a document and waits for completion
+   */
+  execute<TDocument extends PHDocument>(documentIdentifier: string, branch: string, actions: Action[], signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Submits a list of actions to a document
+   */
+  executeAsync(documentIdentifier: string, branch: string, actions: Action[], signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Renames a document and waits for completion
+   */
+  rename(documentIdentifier: string, name: string, branch?: string, signal?: AbortSignal): Promise<PHDocument>;
+  /**
+   * Adds multiple documents as children to another and waits for completion
+   */
+  addRelationship(sourceIdentifier: string, targetIdentifier: string, relationshipType: string, branch?: string, signal?: AbortSignal): Promise<PHDocument>;
+  /**
+   * Removes a relationship between two documents and waits for completion.
+   */
+  removeRelationship(sourceIdentifier: string, targetIdentifier: string, relationshipType: string, branch?: string, signal?: AbortSignal): Promise<PHDocument>;
+  /**
+   * Moves a relationship from one source document to another and waits for completion.
+   */
+  moveRelationship(sourceParentIdentifier: string, targetParentIdentifier: string, targetIdentifier: string, relationshipType: string, branch?: string, signal?: AbortSignal): Promise<{
+    source: PHDocument;
+    target: PHDocument;
+  }>;
+  loadBatch(request: BatchLoadRequest, signal?: AbortSignal): Promise<BatchLoadResult>;
+  /**
+   * Deletes a document and waits for completion
+   */
+  deleteDocument(identifier: string, propagate?: PropagationMode, signal?: AbortSignal): Promise<void>;
+  /**
+   * Deletes documents and waits for completion
+   */
+  deleteDocuments(identifiers: string[], propagate?: PropagationMode, signal?: AbortSignal): Promise<void>;
+  /**
+   * Retrieves the status of a job
+   */
+  getJobStatus(jobId: string, signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Waits for a job to complete
+   */
+  waitForJob(jobId: string | JobInfo, signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Subscribes to changes for documents matching specified filters
+   */
+  subscribe(search: SearchFilter, callback: (event: DocumentChangeEvent) => void, view?: ViewFilter): () => void;
+  private removeAllIncomingRelationships;
+}
+//#endregion
+//#region src/executor/types.d.ts
+/**
+ * Represents the result of a job execution
+ */
+type JobResult = {
+  /** The job that was executed */job: Job; /** Whether the job executed successfully */
+  success: boolean; /** Error if the job failed */
+  error?: Error; /** The operations generated from the actions (if successful) */
+  operations?: Operation[];
+  /**
+   * Operations with context (includes ephemeral resultingState).
+   * Used for emitting to IDocumentView via event bus.
+   */
+  operationsWithContext?: OperationWithContext$1[]; /** Timestamp when the job execution completed */
+  completedAt?: string; /** Duration of job execution in milliseconds */
+  duration?: number; /** Any additional metadata from the execution */
+  metadata?: Record<string, any>;
+};
+/**
+ * Configuration options for the job executor
+ */
+type JobExecutorConfig = {
+  /** Maximum number of conflicting operations to skip when reshuffling. */maxSkipThreshold?: number; /** Maximum number of concurrent jobs to execute */
+  maxConcurrency?: number; /** Maximum time in milliseconds a job can run before being considered timed out */
+  jobTimeoutMs?: number; /** Base delay in milliseconds for exponential backoff retries */
+  retryBaseDelayMs?: number; /** Maximum delay in milliseconds for exponential backoff retries */
+  retryMaxDelayMs?: number;
+  /** Maximum elapsed milliseconds before yielding to the main thread between actions.
+   *  Keeps the UI responsive when processing large batches. */
+  yieldDeadlineMs?: number;
+};
+/**
+ * Event types for the job executor
+ */
+declare const JobExecutorEventTypes: {
+  readonly JOB_STARTED: 20000;
+  readonly JOB_COMPLETED: 20001;
+  readonly JOB_FAILED: 20002;
+  readonly EXECUTOR_STARTED: 20003;
+  readonly EXECUTOR_STOPPED: 20004;
+};
+/**
+ * Event data for job execution events
+ */
+type JobStartedEvent = {
+  job: Job;
+  startedAt: string;
+};
+type JobCompletedEvent = {
+  job: Job;
+  result: JobResult;
+};
+type JobFailedEvent = {
+  job: Job;
+  error: string;
+  willRetry: boolean;
+  retryCount: number;
+};
+type ExecutorStartedEvent = {
+  config: JobExecutorConfig;
+  startedAt: string;
+};
+type ExecutorStoppedEvent = {
+  stoppedAt: string;
+  graceful: boolean;
+};
+/**
+ * Status information for the job executor manager
+ */
+type ExecutorManagerStatus = {
+  /** Whether the manager is currently running */isRunning: boolean; /** Number of executor instances managed */
+  numExecutors: number; /** Number of jobs currently being processed */
+  activeJobs: number; /** Total number of jobs processed since start */
+  totalJobsProcessed: number;
+};
+//#endregion
+//#region src/executor/interfaces.d.ts
+/**
+ * Simple interface for executing a job.
+ * A JobExecutor simply takes a job and executes it - nothing more.
+ */
+interface IJobExecutor {
+  /**
+   * Execute a single job.
+   * @param job - The job to execute
+   * @returns Promise that resolves to the job result
+   */
+  executeJob(job: Job, signal?: AbortSignal): Promise<JobResult>;
+}
+/**
+ * Interface for managing multiple job executors.
+ * Listens for 'jobAvailable' events from the event bus, pulls jobs from the queue,
+ * and coordinates the distribution of jobs across multiple executor instances.
+ */
+interface IJobExecutorManager {
+  /**
+   * Start the executor manager.
+   * Begins listening for 'jobAvailable' events and dispatching to executors.
+   *
+   * @param numExecutors - Number of executor instances to create
+   * @returns Promise that resolves when the manager is started
+   */
+  start(numExecutors: number): Promise<void>;
+  /**
+   * Stop the executor manager.
+   *
+   * @param graceful - Whether to wait for current jobs to complete
+   * @returns Promise that resolves when the manager is stopped
+   */
+  stop(graceful?: boolean): Promise<void>;
+  /**
+   * Get all managed executor instances.
+   *
+   * @returns Array of executor instances
+   */
+  getExecutors(): IJobExecutor[];
+  /**
+   * Get the current status of the manager.
+   *
+   * @returns The current manager status
+   */
+  getStatus(): ExecutorManagerStatus;
+}
+//#endregion
+//#region src/job-tracker/interfaces.d.ts
+/**
+ * Interface for tracking job lifecycle status.
+ * Maintains job state throughout execution: PENDING → RUNNING → COMPLETED/FAILED.
+ */
+interface IJobTracker {
+  /**
+   * Register a new job with PENDING status.
+   *
+   * @param jobInfo - The job information to register
+   */
+  registerJob(jobInfo: JobInfo): void;
+  /**
+   * Update a job's status to RUNNING.
+   *
+   * @param jobId - The job ID to mark as running
+   */
+  markRunning(jobId: string): void;
+  /**
+   * Mark a job as failed.
+   *
+   * @param jobId - The job ID to mark as failed
+   * @param error - Error information including message and stack trace
+   * @param job - Optional full job object for debugging purposes
+   */
+  markFailed(jobId: string, error: ErrorInfo, job?: Job): void;
+  /**
+   * Retrieve the current status of a job.
+   *
+   * @param jobId - The job ID to query
+   * @returns The job information, or null if the job is not found
+   */
+  getJobStatus(jobId: string): JobInfo | null;
+  /**
+   * Shutdown the job tracker and clean up resources.
+   * Unsubscribes from all event bus subscriptions.
+   */
+  shutdown(): void;
+}
+//#endregion
+//#region src/queue/interfaces.d.ts
+/**
+ * Interface for a job queue that manages write operations.
+ * Internally organizes jobs by documentId, scope, and branch to ensure proper ordering.
+ * Emits events to the event bus when new jobs are available for consumption.
+ */
+interface IQueue {
+  /**
+   * Add a new job to the queue.
+   * Jobs are automatically organized by documentId, scope, and branch internally.
+   * Emits a 'jobAvailable' event to the event bus when the job is queued.
+   * @param job - The job to add to the queue
+   * @returns Promise that resolves when the job is queued
+   */
+  enqueue(job: Job): Promise<void>;
+  /**
+   * Get the next job to execute for a specific document/scope/branch combination.
+   * @param documentId - The document ID to get jobs for
+   * @param scope - The scope to get jobs for
+   * @param branch - The branch to get jobs for
+   * @param signal - Optional abort signal to cancel the request
+   * @returns Promise that resolves to the next job execution handle or null if no jobs available
+   */
+  dequeue(documentId: string, scope: string, branch: string, signal?: AbortSignal): Promise<IJobExecutionHandle | null>;
+  /**
+   * Get the next available job from any queue.
+   * @param signal - Optional abort signal to cancel the request
+   * @returns Promise that resolves to the next job execution handle or null if no jobs available
+   */
+  dequeueNext(signal?: AbortSignal): Promise<IJobExecutionHandle | null>;
+  /**
+   * Get the current size of the queue for a specific document/scope/branch.
+   * @param documentId - The document ID
+   * @param scope - The scope
+   * @param branch - The branch
+   * @returns Promise that resolves to the number of jobs in the queue
+   */
+  size(documentId: string, scope: string, branch: string): Promise<number>;
+  /**
+   * Get the total size of all queues.
+   * @returns Promise that resolves to the total number of jobs across all queues
+   */
+  totalSize(): Promise<number>;
+  /**
+   * Remove a specific job from the queue.
+   * @param jobId - The ID of the job to remove
+   * @returns Promise that resolves to true if job was removed, false if not found
+   */
+  remove(jobId: string): Promise<boolean>;
+  /**
+   * Clear all jobs for a specific document/scope/branch combination.
+   * @param documentId - The document ID
+   * @param scope - The scope
+   * @param branch - The branch
+   * @returns Promise that resolves when the queue is cleared
+   */
+  clear(documentId: string, scope: string, branch: string): Promise<void>;
+  /**
+   * Clear all jobs from all queues.
+   * @returns Promise that resolves when all queues are cleared
+   */
+  clearAll(): Promise<void>;
+  /**
+   * Check if there are any jobs in the queue.
+   * @returns Promise that resolves to true if there are jobs, false otherwise
+   */
+  hasJobs(): Promise<boolean>;
+  /**
+   * Mark a job as completed.
+   * @param jobId - The ID of the job to mark as completed
+   * @returns Promise that resolves when the job is marked as completed
+   */
+  completeJob(jobId: string): Promise<void>;
+  /**
+   * Mark a job as failed.
+   * @param jobId - The ID of the job to mark as failed
+   * @param error - Optional error information
+   * @returns Promise that resolves when the job is marked as failed
+   */
+  failJob(jobId: string, error?: ErrorInfo): Promise<void>;
+  /**
+   * Retry a failed job.
+   * @param jobId - The ID of the job to retry
+   * @param error - Optional error information from the failure
+   * @returns Promise that resolves when the job is requeued for retry
+   */
+  retryJob(jobId: string, error?: ErrorInfo): Promise<void>;
+  /**
+   * Returns true if and only if all jobs have been resolved.
+   */
+  get isDrained(): boolean;
+  /**
+   * Blocks the queue from accepting new jobs.
+   * @param onDrained - Optional callback to call when the queue is drained
+   */
+  block(onDrained?: () => void): void;
+  /**
+   * Unblocks the queue from accepting new jobs.
+   */
+  unblock(): void;
+}
+//#endregion
+//#region src/read-models/types.d.ts
+interface ViewStateTable {
+  readModelId: string;
+  lastOrdinal: number;
+  lastOperationTimestamp: Generated<Date>;
+}
+interface DocumentSnapshotTable {
+  id: Generated<string>;
+  documentId: string;
+  slug: string | null;
+  name: string | null;
+  scope: string;
+  branch: string;
+  content: unknown;
+  documentType: string;
+  lastOperationIndex: number;
+  lastOperationHash: string;
+  lastUpdatedAt: Generated<Date>;
+  snapshotVersion: Generated<number>;
+  identifiers: unknown;
+  metadata: unknown;
+  isDeleted: Generated<boolean>;
+  deletedAt: Date | null;
+}
+interface SlugMappingTable {
+  slug: string;
+  documentId: string;
+  scope: string;
+  branch: string;
+  createdAt: Generated<Date>;
+  updatedAt: Generated<Date>;
+}
+interface ProcessorCursorTable {
+  processorId: string;
+  factoryId: string;
+  driveId: string;
+  processorIndex: number;
+  lastOrdinal: Generated<number>;
+  status: Generated<string>;
+  lastError: string | null;
+  lastErrorTimestamp: Date | null;
+  createdAt: Generated<Date>;
+  updatedAt: Generated<Date>;
+}
+interface DocumentViewDatabase {
+  ViewState: ViewStateTable;
+  DocumentSnapshot: DocumentSnapshotTable;
+  SlugMapping: SlugMappingTable;
+  ProcessorCursor: ProcessorCursorTable;
+}
+type InsertableDocumentSnapshot = Insertable<DocumentSnapshotTable>;
+//#endregion
+//#region src/registry/interfaces.d.ts
+type RegistrationResult<T> = {
+  status: "success";
+  item: T;
+} | {
+  status: "error";
+  item: T;
+  error: Error;
+};
+/**
+ * Loader that can asynchronously resolve and return a document model module
+ * for a given document type. Used by the queue to gate CREATE_DOCUMENT jobs
+ * until the required model is available in the registry.
+ */
+interface IDocumentModelLoader {
+  load(documentType: string): Promise<DocumentModelModule<any>>;
+}
+/**
+ * Registry for managing document model modules.
+ * Provides centralized access to document models' reducers, utils, and specifications.
+ * Supports version-aware module storage and upgrade manifest management.
+ */
+interface IDocumentModelRegistry {
+  /**
+   * Register multiple modules at once.
+   * Modules without a version field default to version 1.
+   * Invalid or duplicate modules are skipped without breaking registration of the remaining modules.
+   *
+   * @param modules Document model modules to register
+   * @returns Array of results, one per module, indicating success or failure
+   */
+  registerModules(...modules: DocumentModelModule<any>[]): RegistrationResult<DocumentModelModule<any>>[];
+  /**
+   * Unregister all versions of the specified document types.
+   *
+   * @param documentTypes The document types to unregister
+   * @returns true if all modules were unregistered, false if any were not found
+   */
+  unregisterModules(...documentTypes: string[]): boolean;
+  /**
+   * Get a specific document model module by document type and optional version.
+   * If version is not specified, returns the latest version.
+   *
+   * @param documentType The document type identifier
+   * @param version Optional version number to retrieve
+   * @returns The document model module
+   * @throws ModuleNotFoundError if the document type or version is not registered
+   */
+  getModule(documentType: string, version?: number): DocumentModelModule<any>;
+  /**
+   * Get all registered document model modules.
+   *
+   * @returns Array of all registered modules
+   */
+  getAllModules(): DocumentModelModule<any>[];
+  /**
+   * Clear all registered modules and upgrade manifests.
+   */
+  clear(): void;
+  /**
+   * Get all supported versions for a document type, sorted in ascending order.
+   *
+   * @param documentType The document type identifier
+   * @returns Array of version numbers sorted ascending
+   * @throws ModuleNotFoundError if no modules are registered for the document type
+   */
+  getSupportedVersions(documentType: string): number[];
+  /**
+   * Get the latest (highest) version number for a document type.
+   *
+   * @param documentType The document type identifier
+   * @returns The highest version number registered for this document type
+   * @throws ModuleNotFoundError if no modules are registered for the document type
+   */
+  getLatestVersion(documentType: string): number;
+  /**
+   * Register upgrade manifests that define upgrade paths between versions.
+   * Invalid or duplicate manifests are skipped without breaking registration of the remaining manifests.
+   *
+   * @param manifests Upgrade manifests to register
+   * @returns Array of results, one per manifest, indicating success or failure
+   */
+  registerUpgradeManifests(...manifests: UpgradeManifest<readonly number[]>[]): RegistrationResult<UpgradeManifest<readonly number[]>>[];
+  /**
+   * Unregister upgrade manifests for the specified document types.
+   * @param documentTypes The document types whose upgrade manifests should be unregistered
+   * @returns true if all modules were unregistered, false if any were not found
+   **/
+  unregisterUpgradeManifests(...documentTypes: string[]): boolean;
+  /**
+   * Get the upgrade manifest for a document type.
+   *
+   * @param documentType The document type identifier
+   * @returns The upgrade manifest
+   * @throws ManifestNotFoundError if no manifest is registered for the document type
+   */
+  getUpgradeManifest(documentType: string): UpgradeManifest<readonly number[]>;
+  /**
+   * Compute the upgrade path from one version to another.
+   * Returns the sequence of upgrade transitions needed.
+   *
+   * @param documentType The document type identifier
+   * @param fromVersion The starting version
+   * @param toVersion The target version
+   * @returns Array of upgrade transitions in order
+   * @throws DowngradeNotSupportedError if toVersion is less than fromVersion
+   * @throws ManifestNotFoundError if no upgrade manifest is registered
+   * @throws MissingUpgradeTransitionError if any transition in the path is missing
+   */
+  computeUpgradePath(documentType: string, fromVersion: number, toVersion: number): UpgradeTransition[];
+  /**
+   * Get the upgrade reducer for a single-step version transition.
+   *
+   * @param documentType The document type identifier
+   * @param fromVersion The starting version
+   * @param toVersion The target version (must be fromVersion + 1)
+   * @returns The upgrade reducer function
+   * @throws InvalidUpgradeStepError if toVersion is not fromVersion + 1
+   * @throws ManifestNotFoundError if no upgrade manifest is registered
+   * @throws MissingUpgradeTransitionError if the transition is not found
+   */
+  getUpgradeReducer(documentType: string, fromVersion: number, toVersion: number): UpgradeReducer<any, any>;
+}
+//#endregion
+//#region src/shared/consistency-tracker.d.ts
+interface IConsistencyTracker {
+  /**
+   * Updates the tracker with new operation indexes.
+   * When multiple coordinates have the same key, keeps the highest operationIndex.
+   * Resolves any pending waiters whose coordinates are now satisfied.
+   */
+  update(coordinates: ConsistencyCoordinate[]): void;
+  /**
+   * Returns the latest operation index for a given key, or undefined if not tracked.
+   */
+  getLatest(key: ConsistencyKey): number | undefined;
+  /**
+   * Returns a promise that resolves when all coordinates are satisfied.
+   * Rejects if the timeout is reached or the signal is aborted.
+   */
+  waitFor(coordinates: ConsistencyCoordinate[], timeoutMs?: number, signal?: AbortSignal): Promise<void>;
+  /**
+   * Returns a serializable snapshot of the current state.
+   */
+  serialize(): Array<[ConsistencyKey, number]>;
+  /**
+   * Restores state from a serialized snapshot.
+   */
+  hydrate(entries: Array<[ConsistencyKey, number]>): void;
+}
+/**
+ * Creates a consistency key from documentId, scope, and branch.
+ */
+declare function makeConsistencyKey(documentId: string, scope: string, branch: string): ConsistencyKey;
+/**
+ * Tracks operation indexes for documents and provides read-after-write consistency guarantees.
+ * Maintains an in-memory map of the latest operation index for each (documentId, scope, branch) tuple.
+ */
+declare class ConsistencyTracker implements IConsistencyTracker {
+  private state;
+  private waiters;
+  update(coordinates: ConsistencyCoordinate[]): void;
+  getLatest(key: ConsistencyKey): number | undefined;
+  waitFor(coordinates: ConsistencyCoordinate[], timeoutMs?: number, signal?: AbortSignal): Promise<void>;
+  serialize(): Array<[ConsistencyKey, number]>;
+  hydrate(entries: Array<[ConsistencyKey, number]>): void;
+  private deduplicateCoordinates;
+  private areCoordinatesSatisfied;
+  private checkWaiters;
+  private removeWaiter;
+}
+//#endregion
+//#region src/storage/kysely/types.d.ts
+interface OperationTable {
+  id: Generated<number>;
+  jobId: string;
+  opId: string;
+  prevOpId: string;
+  writeTimestampUtcMs: Generated<Date>;
+  documentId: string;
+  documentType: string;
+  scope: string;
+  branch: string;
+  timestampUtcMs: Date;
+  index: number;
+  action: unknown;
+  skip: number;
+  error?: string | null;
+  hash: string;
+}
+interface KeyframeTable {
+  id: Generated<number>;
+  documentId: string;
+  documentType: string;
+  scope: string;
+  branch: string;
+  revision: number;
+  document: unknown;
+  createdAt: Generated<Date>;
+}
+interface DocumentCollectionTable {
+  documentId: string;
+  collectionId: string;
+  joinedOrdinal: bigint;
+  leftOrdinal: bigint | null;
+}
+interface OperationIndexOperationTable {
+  ordinal: Generated<number>;
+  opId: string;
+  documentId: string;
+  documentType: string;
+  scope: string;
+  branch: string;
+  timestampUtcMs: string;
+  writeTimestampUtcMs: Generated<Date>;
+  index: number;
+  skip: number;
+  hash: string;
+  action: unknown;
+  sourceRemote: Generated<string>;
+}
+interface SyncRemoteTable {
+  name: string;
+  collection_id: string;
+  channel_type: string;
+  channel_id: string;
+  remote_name: string;
+  channel_parameters: unknown;
+  filter_document_ids: unknown;
+  filter_scopes: unknown;
+  filter_branch: string;
+  push_state: string;
+  push_last_success_utc_ms: string | null;
+  push_last_failure_utc_ms: string | null;
+  push_failure_count: number;
+  pull_state: string;
+  pull_last_success_utc_ms: string | null;
+  pull_last_failure_utc_ms: string | null;
+  pull_failure_count: number;
+  created_at: Generated<Date>;
+  updated_at: Generated<Date>;
+}
+interface SyncCursorTable {
+  remote_name: string;
+  cursor_type: string;
+  cursor_ordinal: bigint;
+  last_synced_at_utc_ms: string | null;
+  updated_at: Generated<Date>;
+}
+/**
+ * Kysely table definition for the `sync_dead_letters` table.
+ */
+interface SyncDeadLetterTable {
+  ordinal: Generated<number>;
+  id: string;
+  job_id: string;
+  job_dependencies: unknown;
+  remote_name: string;
+  document_id: string;
+  scopes: unknown;
+  branch: string;
+  operations: unknown;
+  error_source: string;
+  error_message: string;
+  created_at: Generated<Date>;
+}
+interface Database$1 {
+  Operation: OperationTable;
+  Keyframe: KeyframeTable;
+  document_collections: DocumentCollectionTable;
+  operation_index_operations: OperationIndexOperationTable;
+  sync_remotes: SyncRemoteTable;
+  sync_cursors: SyncCursorTable;
+  sync_dead_letters: SyncDeadLetterTable;
+}
+interface DocumentTable {
+  id: string;
+  createdAt: Generated<Date>;
+  updatedAt: Generated<Date>;
+}
+interface DocumentRelationshipTable {
+  id: Generated<string>;
+  sourceId: string;
+  targetId: string;
+  relationshipType: string;
+  metadata: unknown;
+  createdAt: Generated<Date>;
+  updatedAt: Generated<Date>;
+}
+interface IndexerStateTable {
+  id: Generated<number>;
+  lastOperationId: number;
+  lastOperationTimestamp: Generated<Date>;
+}
+interface DocumentIndexerDatabase {
+  Document: DocumentTable;
+  DocumentRelationship: DocumentRelationshipTable;
+  IndexerState: IndexerStateTable;
+}
+//#endregion
+//#region src/sync/errors.d.ts
+declare class PollingChannelError extends Error {
+  constructor(message: string);
+}
+declare class ChannelError extends Error {
+  source: ChannelErrorSource;
+  error: Error;
+  constructor(source: ChannelErrorSource, error: Error);
+}
+//#endregion
+//#region src/sync/sync-operation.d.ts
+type SyncOperationStatusCallback = (syncOp: SyncOperation, prev: SyncOperationStatus, next: SyncOperationStatus) => void;
+declare class SyncOperationAggregateError extends Error {
+  errors: Error[];
+  constructor(errors: Error[]);
+}
+declare class SyncOperation {
+  readonly id: string;
+  readonly jobId: string;
+  jobDependencies: string[];
+  readonly remoteName: string;
+  readonly documentId: string;
+  readonly scopes: string[];
+  readonly branch: string;
+  readonly operations: OperationWithContext$1[];
+  status: SyncOperationStatus;
+  error?: ChannelError;
+  callbacks: SyncOperationStatusCallback[];
+  constructor(id: string, jobId: string, jobDependencies: string[], remoteName: string, documentId: string, scopes: string[], branch: string, operations: OperationWithContext$1[]);
+  on(callback: SyncOperationStatusCallback): void;
+  started(): void;
+  transported(): void;
+  executed(): void;
+  failed(error: ChannelError): void;
+  transition(next: SyncOperationStatus): void;
+}
+//#endregion
+//#region src/sync/mailbox.d.ts
+type MailboxCallback = (items: SyncOperation[]) => void;
+/**
+ * The Mailbox interface is not intended to use any persistence. Instead, the
+ * IChannel implementation is responsible for persisting cursors or other data.
+ *
+ * This means that ackOrdinal and latestOrdinal are in memory only.
+ */
+interface IMailbox {
+  get items(): ReadonlyArray<SyncOperation>;
+  /**
+   * The latest ordinal that has been acknowledged. Because acknowledged items
+   * are removed from the mailbox, this is the last ordinal that has been removed.
+   */
+  get ackOrdinal(): number;
+  /**
+   * The latest ordinal of the items that are or have been added to the mailbox.
+   * This may be greater than the ack ordinal if items have been added but not
+   * yet acknowledged.
+   */
+  get latestOrdinal(): number;
+  init(ackOrdinal: number): void;
+  advanceOrdinal(ordinal: number): void;
+  get(id: string): SyncOperation | undefined;
+  add(...items: SyncOperation[]): void;
+  remove(...items: SyncOperation[]): void;
+  onAdded(callback: MailboxCallback): void;
+  onRemoved(callback: MailboxCallback): void;
+  pause(): void;
+  resume(): void;
+  flush(): void;
+  isPaused(): boolean;
+}
+declare class Mailbox implements IMailbox {
+  private itemsMap;
+  private addedCallbacks;
+  private removedCallbacks;
+  private paused;
+  private addedBuffer;
+  private removedBuffer;
+  private _ack;
+  private _latestOrdinal;
+  init(ackOrdinal: number): void;
+  advanceOrdinal(ordinal: number): void;
+  get items(): ReadonlyArray<SyncOperation>;
+  get ackOrdinal(): number;
+  get latestOrdinal(): number;
+  get(id: string): SyncOperation | undefined;
+  add(...items: SyncOperation[]): void;
+  remove(...items: SyncOperation[]): void;
+  onAdded(callback: MailboxCallback): void;
+  onRemoved(callback: MailboxCallback): void;
+  pause(): void;
+  resume(): void;
+  flush(): void;
+  isPaused(): boolean;
+}
+//#endregion
+//#region src/sync/sync-status-tracker.d.ts
+declare enum SyncStatus {
+  Synced = "SYNCED",
+  Outgoing = "OUTGOING",
+  Incoming = "INCOMING",
+  OutgoingAndIncoming = "OUTGOING_AND_INCOMING",
+  Error = "ERROR"
+}
+type SyncStatusChangeCallback = (documentId: string, status: SyncStatus) => void;
+interface ISyncStatusTracker {
+  getStatus(documentId: string): SyncStatus | undefined;
+  onChange(callback: SyncStatusChangeCallback): () => void;
+  trackRemote(remoteName: string, channel: IChannel): void;
+  untrackRemote(remoteName: string): void;
+  clear(): void;
+}
+declare class SyncStatusTracker implements ISyncStatusTracker {
+  private readonly remotes;
+  private readonly seen;
+  private readonly callbacks;
+  getStatus(documentId: string): SyncStatus | undefined;
+  onChange(callback: SyncStatusChangeCallback): () => void;
+  trackRemote(remoteName: string, channel: IChannel): void;
+  untrackRemote(remoteName: string): void;
+  clear(): void;
+  private handleAdded;
+  private handleRemoved;
+  private getOrCreateCounts;
+  private notifyChange;
+}
+//#endregion
+//#region src/sync/interfaces.d.ts
+/**
+ * Represents a bidirectional synchronization channel between two reactor instances.
+ *
+ * A channel manages three mailboxes:
+ * - inbox: Sync operations received from the remote that need to be applied locally
+ * - outbox: Sync operations to be sent to the remote
+ * - deadLetter: Sync operations that failed and cannot be retried
+ */
+type ConnectionStateChangeCallback = (snapshot: ConnectionStateSnapshot) => void;
+interface IChannel {
+  /**
+   * Mailbox containing sync operations received from the remote that need to be applied locally.
+   * Consumers should register callbacks via onAdded to process incoming sync operations.
+   */
+  inbox: IMailbox;
+  /**
+   * Mailbox containing sync operations that need to be sent to the remote.
+   * The channel is responsible for transporting these sync operations and handling ACKs.
+   */
+  outbox: IMailbox;
+  /**
+   * Mailbox containing sync operations that failed and cannot be retried.
+   * These sync operations require manual intervention or should be logged for debugging.
+   */
+  deadLetter: IMailbox;
+  /**
+   * Initializes the channel asynchronously.
+   * For remote channels, this typically involves registering the channel on the remote server.
+   * Must be called after construction before the channel is used.
+   */
+  init(): Promise<void>;
+  /**
+   * Shuts down the channel and prevents further operations.
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Returns the current connection state snapshot.
+   */
+  getConnectionState(): ConnectionStateSnapshot;
+  /**
+   * Registers a callback that fires when the connection state changes.
+   * Returns an unsubscribe function.
+   */
+  onConnectionStateChange(callback: ConnectionStateChangeCallback): () => void;
+  /**
+   * Fires a single pull cycle on demand. For Manual poll-behavior remotes this is the
+   * mechanism for syncing without enabling background polling. Implementations that do
+   * not poll (e.g. push-only response channels) should treat this as a no-op.
+   */
+  triggerPull(): void;
+}
+/**
+ * Factory for creating channel instances.
+ *
+ * Different channel implementations (InternalChannel, GqlChannel, etc.) will have
+ * their own factories that implement this interface.
+ */
+interface IChannelFactory {
+  /**
+   * Creates a new channel instance with the given configuration.
+   *
+   * @param remoteId - Unique identifier for the remote
+   * @param remoteName - Name of the remote
+   * @param config - Channel configuration including type and parameters
+   * @param cursorStorage - Storage for persisting synchronization cursors
+   * @param collectionId - Collection ID to synchronize
+   * @param filter - Filter to apply to operations
+   * @param operationIndex - Operation index for querying timestamps
+   * @param options - Remote-level options (e.g. pollBehavior). May be omitted; implementations should default sensibly.
+   * @returns A new channel instance
+   */
+  instance(remoteId: string, remoteName: string, config: ChannelConfig, cursorStorage: ISyncCursorStorage, collectionId: string, filter: RemoteFilter, operationIndex: IOperationIndex, options?: RemoteOptions): IChannel;
+}
+/**
+ * Represents a configured remote with an active channel.
+ *
+ * A remote defines what to synchronize (collectionId, filter) and how to synchronize it (channel).
+ * The remote name is used as a unique identifier across the system.
+ */
+type Remote = {
+  /**
+   * Unique identifier for this remote.
+   */
+  id: string;
+  /**
+   * Unique name for this remote.
+   */
+  name: string;
+  /**
+   * Collection ID to synchronize.
+   * Typically created via driveCollectionId(branch, documentId) for drive-level sync.
+   */
+  collectionId: string;
+  /**
+   * Filter to apply to operations.
+   * Can filter by documentId, scope, and branch.
+   */
+  filter: RemoteFilter;
+  /**
+   * Additional configuration options for the remote.
+   */
+  options: RemoteOptions;
+  /**
+   * Active channel for bidirectional communication with the remote.
+   */
+  channel: IChannel;
+};
+/**
+ * Orchestrates all synchronization activity for a reactor instance.
+ */
+interface ISyncManager {
+  /**
+   * Starts the synchronization manager.
+   *
+   * This recreates all remotes from storage and prepares channels for synchronization.
+   * Each remote's channel will begin processing its inbox/outbox mailboxes.
+   *
+   * @returns Promise that resolves when the manager is started
+   */
+  startup(): Promise<void>;
+  /**
+   * Shuts down the synchronization manager.
+   *
+   * This stops all channels, flushes pending operations, and releases resources.
+   * The shutdown status indicates whether the system was cleanly shut down.
+   *
+   * @returns Status object with shutdown information
+   */
+  shutdown(): ShutdownStatus;
+  /**
+   * Gets a remote by name.
+   *
+   * @param name - The name of the remote
+   * @returns The remote
+   * @throws Error if the remote does not exist
+   */
+  getByName(name: string): Remote;
+  /**
+   * Gets a remote by ID.
+   *
+   * @param id - The ID of the remote
+   * @returns The remote
+   * @throws Error if the remote does not exist
+   */
+  getById(id: string): Remote;
+  /**
+   * Adds a new remote and starts its channel.
+   *
+   * The remote configuration is persisted to storage and a channel is created
+   * using the appropriate factory. The channel begins processing immediately.
+   *
+   * @param name - Unique name for the remote
+   * @param collectionId - Collection ID to synchronize
+   * @param channelConfig - Configuration for the channel type and parameters
+   * @param filter - Optional filter for operations (defaults to no filtering)
+   * @param options - Optional remote configuration options
+   * @param id - Optional ID for the remote (generated if not provided)
+   * @returns Promise that resolves with the created remote
+   * @throws Error if a remote with this name already exists
+   */
+  add(name: string, collectionId: string, channelConfig: ChannelConfig, filter?: RemoteFilter, options?: RemoteOptions, id?: string): Promise<Remote>;
+  /**
+   * Triggers a one-shot pull for the named remote. Useful for Manual poll-behavior
+   * remotes, where the channel is registered but does not poll on a schedule.
+   *
+   * @param name - The name of the remote
+   * @throws Error if the remote does not exist
+   */
+  triggerPull(name: string): void;
+  /**
+   * Removes a remote and stops its channel.
+   *
+   * The remote configuration is removed from storage and the channel is shut down.
+   * Any pending sync operations in the channel's mailboxes will be processed before shutdown.
+   *
+   * @param name - The name of the remote to remove
+   * @returns Promise that resolves when the remote is removed
+   * @throws Error if the remote does not exist
+   */
+  remove(name: string): Promise<void>;
+  /**
+   * Lists all configured remotes.
+   *
+   * @returns Array of all remotes
+   */
+  list(): Remote[];
+  /**
+   * Waits for sync operations for a job to complete.
+   * Resolves when SYNC_SUCCEEDED is emitted.
+   * Rejects when SYNC_FAILED is emitted.
+   *
+   * @param jobId - The job id to wait for
+   * @param signal - Optional abort signal
+   * @returns The sync result
+   */
+  waitForSync(jobId: string, signal?: AbortSignal): Promise<SyncResult>;
+  /**
+   * Gets the current sync status for a document.
+   *
+   * @param documentId - The document ID to check
+   * @returns The sync status, or undefined if the document has never been tracked
+   */
+  getSyncStatus(documentId: string): SyncStatus | undefined;
+  /**
+   * Registers a callback that fires when a document's sync status changes.
+   *
+   * @param callback - Called with (documentId, newStatus) on each transition
+   * @returns Unsubscribe function
+   */
+  onSyncStatusChange(callback: SyncStatusChangeCallback): () => void;
+}
+//#endregion
+//#region src/core/types.d.ts
+/**
+ * A single mutation job within a batch request.
+ */
+type ExecutionJobPlan = {
+  key: string;
+  documentId: string;
+  scope: string;
+  branch: string;
+  actions: Action[];
+  dependsOn: string[];
+};
+/**
+ * Request for batch mutation operation.
+ */
+type BatchExecutionRequest = {
+  jobs: ExecutionJobPlan[];
+};
+/**
+ * Result from batch mutation operation.
+ */
+type BatchExecutionResult = {
+  jobs: Record<string, JobInfo>;
+};
+/**
+ * A single load job within a batch request.
+ */
+type LoadJobPlan = {
+  key: string;
+  documentId: string;
+  scope: string;
+  branch: string;
+  operations: Operation[];
+  dependsOn: string[];
+};
+/**
+ * Request for batch load operation.
+ */
+type BatchLoadRequest = {
+  jobs: LoadJobPlan[];
+};
+/**
+ * Result from batch load operation.
+ */
+type BatchLoadResult = {
+  jobs: Record<string, JobInfo>;
+};
+/**
+ * The main Reactor interface that serves as a facade for document operations.
+ * This interface provides a unified API for document management, including
+ * creation, retrieval, mutation, and deletion operations.
+ */
+interface IReactor {
+  /**
+   * Signals that the reactor should shutdown.
+   */
+  kill(): ShutdownStatus;
+  /**
+   * Retrieves a list of document model modules.
+   *
+   * @param namespace - Optional namespace like "powerhouse" or "sky", defaults to ""
+   * @param paging - Optional options for paging data in large queries.
+   * @param signal - Optional abort signal to cancel the request
+   * @returns List of document model modules
+   */
+  getDocumentModels(namespace?: string, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<DocumentModelModule>>;
+  /**
+   * Retrieves a specific PHDocument by id
+   *
+   * @param id - Required, this is the document id
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The up-to-date PHDocument
+   */
+  get<TDocument extends PHDocument>(id: string, view?: ViewFilter, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Retrieves a specific PHDocument by slug
+   *
+   * @param slug - Required, this is the document slug
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The up-to-date PHDocument with scopes and list of child document ids
+   */
+  getBySlug<TDocument extends PHDocument>(slug: string, view?: ViewFilter, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Retrieves a specific PHDocument by identifier (either id or slug).
+   * Throws an error if the identifier matches both an id and a slug that refer to different documents.
+   *
+   * @param identifier - Required, this is the document id or slug
+   * @param view - Optional filter containing branch and scopes information
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The up-to-date PHDocument with scopes and list of child document ids
+   * @throws {Error} If identifier matches both an ID and slug referring to different documents
+   */
+  getByIdOrSlug<TDocument extends PHDocument>(identifier: string, view?: ViewFilter, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  /**
+   * Retrieves outgoing relationships of a given type from a source document.
+   *
+   * @param sourceId - The source document id
+   * @param relationshipType - The relationship type to filter by
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The list of target document ids
+   */
+  getOutgoingRelationships(sourceId: string, relationshipType: string, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[]>;
+  /**
+   * Retrieves incoming relationships of a given type to a target document.
+   *
+   * @param targetId - The target document id
+   * @param relationshipType - The relationship type to filter by
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The list of source document ids
+   */
+  getIncomingRelationships(targetId: string, relationshipType: string, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[]>;
+  /**
+   * Retrieves the operations for a document
+   *
+   * @param documentId - The document id
+   * @param view - Optional filter containing branch and scopes information
+   * @param filter - Optional filter for actionTypes, timestamps, and revision
+   * @param paging - Optional pagination options
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The list of operations
+   */
+  getOperations(documentId: string, view?: ViewFilter, filter?: OperationFilter, paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<Record<string, PagedResults<Operation>>>;
+  /**
+   * Filters documents by criteria and returns a list of them
+   *
+   * @param search - Search filter options (type, parentId, identifiers)
+   * @param view - Optional filter containing branch and scopes information
+   * @param paging - Optional pagination options
+   * @param consistencyToken - Optional token for read-after-write consistency
+   * @param signal - Optional abort signal to cancel the request
+   * @returns List of documents matching criteria and pagination cursor
+   */
+  find(search: SearchFilter, view?: ViewFilter, paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  /**
+   * Creates a document
+   *
+   * @param document - Document with optional id, slug, parent, model type, and initial state
+   * @param signer - Optional signer to sign the actions
+   * @param signal - Optional abort signal to cancel the request
+   * @param meta - Optional metadata that flows through the job lifecycle
+   * @returns The job status
+   */
+  create(document: PHDocument, signer?: ISigner, signal?: AbortSignal, meta?: Record<string, unknown>): Promise<JobInfo>;
+  /**
+   * Deletes a document
+   *
+   * @param id - Document id
+   * @param signer - Optional signer to sign the actions
+   * @param signal - Optional abort signal to cancel the request
+   * @param meta - Optional metadata that flows through the job lifecycle
+   * @returns The job id and status
+   */
+  deleteDocument(id: string, signer?: ISigner, signal?: AbortSignal, meta?: Record<string, unknown>): Promise<JobInfo>;
+  /**
+   * Applies a list of actions to a document.
+   *
+   * @param docId - Document id
+   * @param branch - Branch to apply actions to
+   * @param actions - List of actions to apply
+   * @param signal - Optional abort signal to cancel the request
+   * @param meta - Optional metadata that flows through the job lifecycle
+   * @returns The job id and status
+   */
+  execute(docId: string, branch: string, actions: Action[], signal?: AbortSignal, meta?: Record<string, unknown>): Promise<JobInfo>;
+  /**
+   * Loads existing operations generated elsewhere into this reactor.
+   *
+   * @param docId - Document id
+   * @param branch - Branch to load operations to
+   * @param operations - List of operations to load
+   * @param signal - Optional abort signal to cancel the request
+   * @param meta - Optional metadata that flows through the job lifecycle
+   * @returns The job id and status
+   */
+  load(docId: string, branch: string, operations: Operation[], signal?: AbortSignal, meta?: Record<string, unknown>): Promise<JobInfo>;
+  /**
+   * Applies multiple mutations across documents with dependency management.
+   *
+   * @param request - Batch mutation request containing jobs with dependencies
+   * @param signal - Optional abort signal to cancel the request
+   * @param meta - Optional metadata that flows through the job lifecycle
+   * @returns Map of job keys to job information
+   */
+  executeBatch(request: BatchExecutionRequest, signal?: AbortSignal, meta?: Record<string, unknown>): Promise<BatchExecutionResult>;
+  /**
+   * Loads multiple batches of pre-existing operations across documents with dependency management.
+   *
+   * @param request - Batch load request containing jobs with dependencies
+   * @param signal - Optional abort signal to cancel the request
+   * @param meta - Optional metadata that flows through the job lifecycle
+   * @returns Map of job keys to job information
+   */
+  loadBatch(request: BatchLoadRequest, signal?: AbortSignal, meta?: Record<string, unknown>): Promise<BatchLoadResult>;
+  /**
+   * Adds a relationship between two documents.
+   *
+   * @param sourceId - Source document id
+   * @param targetId - Target document id
+   * @param relationshipType - Relationship type identifier
+   * @param branch - Branch to add the relationship to, defaults to "main"
+   * @param signer - Optional signer to sign the actions
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The job id and status
+   */
+  addRelationship(sourceId: string, targetId: string, relationshipType: string, branch?: string, signer?: ISigner, signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Removes a relationship between two documents.
+   *
+   * @param sourceId - Source document id
+   * @param targetId - Target document id
+   * @param relationshipType - Relationship type identifier
+   * @param branch - Branch to remove the relationship from, defaults to "main"
+   * @param signer - Optional signer to sign the actions
+   * @param signal - Optional abort signal to cancel the request
+   * @returns The job id and status
+   */
+  removeRelationship(sourceId: string, targetId: string, relationshipType: string, branch?: string, signer?: ISigner, signal?: AbortSignal): Promise<JobInfo>;
+  /**
+   * Retrieves the status of a job
+   *
+   * @param jobId - The job id
+   * @returns The job status
+   */
+  getJobStatus(jobId: string, signal?: AbortSignal): Promise<JobInfo>;
+}
+/**
+ * Feature flags for reactor configuration
+ */
+type ReactorFeatures = {
+  [key: string]: boolean;
+};
+/**
+ * Combined database type that includes all schemas
+ */
+type Database = Database$1 & DocumentViewDatabase & DocumentIndexerDatabase;
+/**
+ * Container for all sync manager dependencies created during the build process.
+ */
+interface SyncModule {
+  remoteStorage: ISyncRemoteStorage;
+  cursorStorage: ISyncCursorStorage;
+  deadLetterStorage: ISyncDeadLetterStorage;
+  channelFactory: IChannelFactory;
+  syncManager: ISyncManager;
+}
+/**
+ * Container for all reactor dependencies created during the build process.
+ * Provides direct access to internal components for advanced use cases,
+ * testing, or integration scenarios.
+ */
+interface ReactorModule {
+  eventBus: IEventBus;
+  documentModelRegistry: IDocumentModelRegistry;
+  queue: IQueue;
+  jobTracker: IJobTracker;
+  executorManager: IJobExecutorManager;
+  database: Kysely<Database>;
+  operationStore: IOperationStore;
+  keyframeStore: IKeyframeStore;
+  writeCache: IWriteCache;
+  operationIndex: IOperationIndex;
+  documentView: IDocumentView;
+  documentViewConsistencyTracker: IConsistencyTracker;
+  documentIndexer: IDocumentIndexer;
+  documentIndexerConsistencyTracker: IConsistencyTracker;
+  readModelCoordinator: IReadModelCoordinator;
+  subscriptionManager: IReactorSubscriptionManager;
+  processorManager: IProcessorManager$1;
+  processorManagerConsistencyTracker: IConsistencyTracker;
+  syncModule: SyncModule | undefined;
+  reactor: IReactor;
+}
+/**
+ * Container for all reactor client dependencies created during the build process.
+ * Provides direct access to internal components for advanced use cases,
+ * testing, or integration scenarios.
+ */
+interface ReactorClientModule {
+  client: ReactorClient;
+  reactor: IReactor;
+  eventBus: IEventBus;
+  documentIndexer: IDocumentIndexer;
+  documentView: IDocumentView;
+  signer: ISigner;
+  subscriptionManager: IReactorSubscriptionManager;
+  jobAwaiter: IJobAwaiter;
+  reactorModule: ReactorModule | undefined;
+}
+//#endregion
+//#region src/client/drive-client.d.ts
+/**
+ * Implementation of {@link IDriveClient}.
+ *
+ * Holds a back-reference to its parent {@link IReactorClient} for read and
+ * single-document write primitives, plus direct access to {@link IReactor}
+ * for batch execution. The back-reference is captured but never invoked
+ * during construction, so the partial-`this` hazard does not apply.
+ */
+declare class DriveClient implements IDriveClient {
+  private readonly client;
+  private readonly logger;
+  private readonly reactor;
+  private readonly signer;
+  constructor(client: IReactorClient, logger: ILogger, reactor: IReactor, signer: ISigner);
+  create(input: DriveInput, signal?: AbortSignal): Promise<DocumentDriveDocument>;
+  addFile<TDocument extends PHDocument = PHDocument>(driveIdentifier: string, document: PHDocument, parentFolder?: string, signal?: AbortSignal): Promise<TDocument>;
+  addFolder(driveIdentifier: string, name: string, parentFolder?: string, signal?: AbortSignal): Promise<FolderNode>;
+  removeNode(driveIdentifier: string, nodeId: string, signal?: AbortSignal): Promise<void>;
+  renameNode(driveIdentifier: string, nodeId: string, name: string, signal?: AbortSignal): Promise<Node>;
+  moveNode(driveIdentifier: string, srcNodeId: string, targetParentFolderId: string | undefined, signal?: AbortSignal): Promise<DocumentDriveDocument>;
+  copyNode(driveIdentifier: string, srcNodeId: string, targetParentFolderId: string | undefined, signal?: AbortSignal): Promise<DocumentDriveDocument>;
+  getNode(driveIdentifier: string, nodeId: string, signal?: AbortSignal): Promise<Node>;
+  listNodes(driveIdentifier: string, parentFolder?: string | null, signal?: AbortSignal): Promise<Node[]>;
+  private removeFileNode;
+}
+//#endregion
+//#region src/cache/write-cache-types.d.ts
+/**
+ * Configuration options for the write cache
+ */
+type WriteCacheConfig = {
+  /** Maximum number of document streams to cache (LRU eviction). Default: 1000 */maxDocuments: number; /** Number of snapshots to keep in each document's ring buffer. Default: 10 */
+  ringBufferSize: number; /** Persist a keyframe snapshot every N revisions. Default: 10 */
+  keyframeInterval: number;
+};
+/**
+ * Unique identifier for a document stream
+ */
+type DocumentStreamKey = {
+  /** Document identifier */documentId: string; /** Operation scope */
+  scope: string; /** Branch name */
+  branch: string;
+};
+/**
+ * A cached document snapshot at a specific revision
+ */
+type CachedSnapshot = {
+  /** The revision number of this snapshot */revision: number; /** The document state at this revision */
+  document: PHDocument;
+};
+/**
+ * Serialized keyframe snapshot for K/V store persistence
+ */
+type KeyframeSnapshot = {
+  /** The revision number of this keyframe */revision: number; /** Serialized document state */
+  document: string;
+};
+//#endregion
+//#region src/signer/types.d.ts
+/**
+ * Configuration for signing and verification.
+ */
+type SignerConfig = {
+  /**
+   * The signer used to sign actions before submission.
+   */
+  signer: ISigner;
+  /**
+   * Optional handler for verifying signatures on incoming operations.
+   * If not provided, signature verification will be skipped.
+   */
+  verifier?: SignatureVerificationHandler;
+};
+//#endregion
+//#region src/storage/migrations/types.d.ts
+type MigrationStrategy = "auto" | "manual" | "none";
+interface MigrationResult {
+  success: boolean;
+  migrationsExecuted: string[];
+  error?: Error;
+}
+//#endregion
+//#region src/sync/sync-builder.d.ts
+declare class SyncBuilder {
+  private channelFactory?;
+  private remoteStorage?;
+  private cursorStorage?;
+  private deadLetterStorage?;
+  private config;
+  withChannelFactory(factory: IChannelFactory): this;
+  withRemoteStorage(storage: ISyncRemoteStorage): this;
+  withCursorStorage(storage: ISyncCursorStorage): this;
+  withDeadLetterStorage(storage: ISyncDeadLetterStorage): this;
+  withMaxDeadLettersPerRemote(limit: number): this;
+  withMaxInboxBatchSize(limit: number): this;
+  build(reactor: IReactor, logger: ILogger, operationIndex: IOperationIndex, eventBus: IEventBus, db: Kysely<Database$1>): ISyncManager;
+  buildModule(reactor: IReactor, logger: ILogger, operationIndex: IOperationIndex, eventBus: IEventBus, db: Kysely<Database$1>): SyncModule;
+}
+//#endregion
+//#region src/core/reactor-builder.d.ts
+declare class ReactorBuilder {
+  private logger?;
+  private documentModels;
+  private upgradeManifests;
+  private features;
+  private readModels;
+  private executorManager;
+  private executorConfig;
+  private writeCacheConfig?;
+  private migrationStrategy;
+  private syncBuilder?;
+  private eventBus?;
+  private readModelCoordinator?;
+  private signatureVerifier?;
+  private kyselyInstance?;
+  private signalHandlersEnabled;
+  private queueInstance?;
+  private channelScheme?;
+  private jwtHandler?;
+  private documentModelLoader?;
+  private shutdownHooks;
+  withLogger(logger: ILogger): this;
+  withDocumentModels(models: DocumentModelModule<any>[]): this;
+  withUpgradeManifests(manifests: UpgradeManifest<readonly number[]>[]): this;
+  withFeatures(features: ReactorFeatures): this;
+  withReadModel(readModel: IReadModel): this;
+  withReadModelCoordinator(readModelCoordinator: IReadModelCoordinator): this;
+  withExecutor(executor: IJobExecutorManager): this;
+  withExecutorConfig(config: Partial<JobExecutorConfig>): this;
+  withWriteCacheConfig(config: Partial<WriteCacheConfig>): this;
+  withMigrationStrategy(strategy: MigrationStrategy): this;
+  withSync(syncBuilder: SyncBuilder): this;
+  withEventBus(eventBus: IEventBus): this;
+  withSignatureVerifier(verifier: SignatureVerificationHandler): this;
+  withKysely(kysely: Kysely<Database>): this;
+  withQueue(queue: IQueue): this;
+  withChannelScheme(scheme: ChannelScheme): this;
+  withJwtHandler(handler: JwtHandler): this;
+  withDocumentModelLoader(loader: IDocumentModelLoader): this;
+  withSignalHandlers(): this;
+  /**
+   * Register an async cleanup hook to run during graceful shutdown. Hooks fire
+   * after `reactor.kill()` resolves and before `database.destroy()`, so callers
+   * that depend on the reactor (e.g. an HTTP API layered on top) can drain
+   * cleanly before the underlying kysely instance is torn down. Hook errors are
+   * logged and otherwise ignored — one bad hook cannot strand the rest of the
+   * shutdown chain.
+   */
+  withShutdownHook(hook: () => Promise<void>): this;
+  build(): Promise<IReactor>;
+  buildModule(): Promise<ReactorModule>;
+  private attachSignalHandlers;
+}
+//#endregion
+//#region src/core/reactor-client-builder.d.ts
+/**
+ * Builder class for constructing ReactorClient instances with proper configuration
+ */
+declare class ReactorClientBuilder {
+  private logger?;
+  private reactorBuilder?;
+  private reactor?;
+  private eventBus?;
+  private documentIndexer?;
+  private documentView?;
+  private signer?;
+  private signatureVerifier?;
+  private subscriptionManager?;
+  private jobAwaiter?;
+  private documentModelLoader?;
+  /**
+   * Sets the logger for the ReactorClient.
+   * @param logger - The logger to use.
+   * @returns The ReactorClientBuilder instance.
+   */
+  withLogger(logger: ILogger): this;
+  /**
+   * Either this or withReactor must be set.
+   */
+  withReactorBuilder(reactorBuilder: ReactorBuilder): this;
+  /**
+   * Either this or withReactorBuilder must be set.
+   */
+  withReactor(reactor: IReactor, eventBus: IEventBus, documentIndexer: IDocumentIndexer, documentView: IDocumentView): this;
+  /**
+   * Sets the signer configuration for signing and verifying actions.
+   *
+   * @param config - Either an ISigner for signing only, or a SignerConfig for both signing and verification
+   */
+  withSigner(config: ISigner | SignerConfig): this;
+  withSubscriptionManager(subscriptionManager: IReactorSubscriptionManager): this;
+  withJobAwaiter(jobAwaiter: IJobAwaiter): this;
+  withDocumentModelLoader(loader: IDocumentModelLoader): this;
+  build(): Promise<ReactorClient>;
+  buildModule(): Promise<ReactorClientModule>;
+}
+//#endregion
+//#region src/core/reactor.d.ts
+/**
+ * This class implements the IReactor interface and serves as the main entry point
+ * for the new Reactor architecture.
+ */
+declare class Reactor implements IReactor {
+  private logger;
+  private documentModelRegistry;
+  private shutdownStatus;
+  private setShutdown;
+  private setCompleted;
+  private queue;
+  private jobTracker;
+  private readModelCoordinator;
+  private features;
+  private documentView;
+  private documentIndexer;
+  private operationStore;
+  private eventBus;
+  private executorManager;
+  constructor(logger: ILogger, documentModelRegistry: IDocumentModelRegistry, queue: IQueue, jobTracker: IJobTracker, readModelCoordinator: IReadModelCoordinator, features: ReactorFeatures, documentView: IDocumentView, documentIndexer: IDocumentIndexer, operationStore: IOperationStore, eventBus: IEventBus, executorManager: IJobExecutorManager);
+  kill(): ShutdownStatus;
+  getDocumentModels(namespace?: string, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<DocumentModelModule>>;
+  get<TDocument extends PHDocument>(id: string, view?: ViewFilter, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  getBySlug<TDocument extends PHDocument>(slug: string, view?: ViewFilter, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  getByIdOrSlug<TDocument extends PHDocument>(identifier: string, view?: ViewFilter, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  getOutgoingRelationships(sourceId: string, relationshipType: string, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[]>;
+  getIncomingRelationships(targetId: string, relationshipType: string, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[]>;
+  getOperations(documentId: string, view?: ViewFilter, filter?: OperationFilter, paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<Record<string, PagedResults<Operation>>>;
+  find(search: SearchFilter, view?: ViewFilter, paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  create(document: PHDocument, signer?: ISigner, signal?: AbortSignal, meta?: Record<string, unknown>): Promise<JobInfo>;
+  deleteDocument(id: string, signer?: ISigner, signal?: AbortSignal, meta?: Record<string, unknown>): Promise<JobInfo>;
+  execute(docId: string, branch: string, actions: Action[], signal?: AbortSignal, meta?: Record<string, unknown>): Promise<JobInfo>;
+  load(docId: string, branch: string, operations: Operation[], signal?: AbortSignal, meta?: Record<string, unknown>): Promise<JobInfo>;
+  executeBatch(request: BatchExecutionRequest, signal?: AbortSignal, meta?: Record<string, unknown>): Promise<BatchExecutionResult>;
+  loadBatch(request: BatchLoadRequest, signal?: AbortSignal, meta?: Record<string, unknown>): Promise<BatchLoadResult>;
+  addRelationship(sourceId: string, targetId: string, relationshipType: string, branch?: string, signer?: ISigner, signal?: AbortSignal): Promise<JobInfo>;
+  removeRelationship(sourceId: string, targetId: string, relationshipType: string, branch?: string, signer?: ISigner, signal?: AbortSignal): Promise<JobInfo>;
+  getJobStatus(jobId: string, signal?: AbortSignal): Promise<JobInfo>;
+  private findByIds;
+  private findBySlugs;
+  private findByParentId;
+  private findByType;
+  private emitJobPending;
+}
+//#endregion
+//#region src/shared/drive-url.d.ts
+interface ParsedDriveUrl {
+  url: string;
+  driveId: string;
+  graphqlEndpoint: string;
+}
+/**
+ * Parse a drive URL to extract drive ID and construct GraphQL endpoint.
+ * Preserves any subpath prefix so the result is correct when the reactor is
+ * served behind a proxy at a non-root path.
+ * e.g., "http://localhost:4001/d/abc123" -> { driveId: "abc123", graphqlEndpoint: "http://localhost:4001/graphql/r" }
+ * e.g., "https://example.com/api/reactor/d/abc123" -> { ..., graphqlEndpoint: "https://example.com/api/reactor/graphql/r" }
+ */
+declare function parseDriveUrl(url: string): ParsedDriveUrl;
+/**
+ * Extract drive ID from a drive URL.
+ */
+declare function driveIdFromUrl(url: string): string;
+//#endregion
+//#region src/shared/factories.d.ts
+/**
+ * Factory method to create a ShutdownStatus that can be updated
+ *
+ * @param initialState - Initial shutdown state (default: false)
+ * @returns A tuple of [ShutdownStatus, setShutdown function, setCompleted function]
+ */
+declare function createMutableShutdownStatus(initialState?: boolean): [ShutdownStatus, (value: boolean) => void, (completed: Promise<void>) => void];
+//#endregion
+//#region src/subs/default-error-handler.d.ts
+/**
+ * Default error handler that re-throws subscription errors.
+ * This ensures that errors are not silently swallowed.
+ */
+declare class DefaultSubscriptionErrorHandler implements ISubscriptionErrorHandler {
+  handleError(error: unknown, context: SubscriptionErrorContext): void;
+}
+//#endregion
+//#region src/subs/react-subscription-manager.d.ts
+type DocumentCreatedCallback = (result: PagedResults<string>) => void;
+type DocumentDeletedCallback = (documentIds: string[]) => void;
+type DocumentStateUpdatedCallback = (result: PagedResults<PHDocument>) => void;
+type RelationshipChangedCallback = (parentId: string, childId: string, changeType: RelationshipChangeType) => void;
+declare class ReactorSubscriptionManager implements IReactorSubscriptionManager {
+  private createdSubscriptions;
+  private deletedSubscriptions;
+  private updatedSubscriptions;
+  private relationshipSubscriptions;
+  private subscriptionCounter;
+  private errorHandler;
+  constructor(errorHandler: ISubscriptionErrorHandler);
+  onDocumentCreated(callback: DocumentCreatedCallback, search?: SearchFilter): () => void;
+  onDocumentDeleted(callback: DocumentDeletedCallback, search?: SearchFilter): () => void;
+  onDocumentStateUpdated(callback: DocumentStateUpdatedCallback, search?: SearchFilter, view?: ViewFilter): () => void;
+  onRelationshipChanged(callback: RelationshipChangedCallback, search?: SearchFilter): () => void;
+  /**
+   * Notify subscribers about created documents
+   */
+  notifyDocumentsCreated(documentIds: string[], documentTypes?: Map<string, string>, parentIds?: Map<string, string | null>): void;
+  /**
+   * Notify subscribers about deleted documents
+   */
+  notifyDocumentsDeleted(documentIds: string[], documentTypes?: Map<string, string>, parentIds?: Map<string, string | null>): void;
+  /**
+   * Notify subscribers about updated documents
+   */
+  notifyDocumentsUpdated(documents: PHDocument[]): void;
+  /**
+   * Notify subscribers about relationship changes
+   */
+  notifyRelationshipChanged(parentId: string, childId: string, changeType: RelationshipChangeType, childType?: string): void;
+  /**
+   * Clear all subscriptions
+   */
+  clearAll(): void;
+  private filterDocumentIds;
+  private filterDocuments;
+  private matchesRelationshipFilter;
+}
+//#endregion
+//#region src/events/event-bus.d.ts
+declare class EventBus implements IEventBus {
+  readonly eventTypeToSubscribers: Map<number, Subscriber[]>;
+  subscribe<K>(type: number, subscriber: (type: number, event: K) => void | Promise<void>): Unsubscribe;
+  emit(type: number, data: any): Promise<void>;
+}
+//#endregion
+//#region src/registry/document-model-resolver.d.ts
+interface IDocumentModelResolver {
+  ensureModelLoaded(documentType: string): Promise<void>;
+}
+/**
+ * No-op resolver used when no document model loader is configured.
+ * Checks the registry for the model and returns if found; throws if not.
+ * Since there is no loader, missing models cannot be recovered.
+ */
+declare class NullDocumentModelResolver implements IDocumentModelResolver {
+  private registry?;
+  constructor(registry?: IDocumentModelRegistry | undefined);
+  ensureModelLoaded(documentType: string): Promise<void>;
+}
+//#endregion
+//#region src/queue/queue.d.ts
+/**
+ * In-memory implementation of the IQueue interface.
+ * Organizes jobs by documentId, scope, and branch to ensure proper ordering.
+ * Ensures serial execution per document by tracking executing jobs.
+ * Implements dependency management through queue hints.
+ */
+declare class InMemoryQueue implements IQueue {
+  private eventBus;
+  private resolver;
+  private queues;
+  private jobIdToQueueKey;
+  private docIdToJobId;
+  private jobIdToDocId;
+  private completedJobs;
+  private jobIndex;
+  private isBlocked;
+  private onDrainedCallback?;
+  private isPausedFlag;
+  constructor(eventBus: IEventBus, resolver: IDocumentModelResolver);
+  private toErrorInfo;
+  /**
+   * Creates a unique key for a document/scope/branch combination
+   */
+  private createQueueKey;
+  /**
+   * Gets or creates a queue for the given key
+   */
+  private getQueue;
+  /**
+   * Check if a document has any jobs currently executing
+   */
+  private isDocumentExecuting;
+  /**
+   * Mark a job as executing for its document
+   */
+  private markJobExecuting;
+  /**
+   * Mark a job as no longer executing for its document
+   */
+  private markJobComplete;
+  /**
+   * Check if all dependencies for a job have been completed
+   */
+  private areDependenciesMet;
+  /**
+   * Get the next job that has all its dependencies met
+   */
+  private getNextJobWithMetDependencies;
+  private getCreateDocumentType;
+  enqueue(job: Job): Promise<void>;
+  dequeue(documentId: string, scope: string, branch: string, signal?: AbortSignal): Promise<IJobExecutionHandle | null>;
+  dequeueNext(signal?: AbortSignal): Promise<IJobExecutionHandle | null>;
+  size(documentId: string, scope: string, branch: string): Promise<number>;
+  totalSize(): Promise<number>;
+  remove(jobId: string): Promise<boolean>;
+  clear(documentId: string, scope: string, branch: string): Promise<void>;
+  clearAll(): Promise<void>;
+  hasJobs(): Promise<boolean>;
+  completeJob(jobId: string): Promise<void>;
+  failJob(jobId: string, error?: ErrorInfo): Promise<void>;
+  deferJob(jobId: string): void;
+  retryJob(jobId: string, error?: ErrorInfo): Promise<void>;
+  /**
+   * Check if the queue is drained and call the callback if it is
+   */
+  private checkDrained;
+  /**
+   * Returns true if and only if all jobs have been resolved.
+   */
+  get isDrained(): boolean;
+  /**
+   * Blocks the queue from accepting new jobs.
+   * @param onDrained - Optional callback to call when the queue is drained
+   */
+  block(onDrained?: () => void): void;
+  /**
+   * Unblocks the queue from accepting new jobs.
+   */
+  unblock(): void;
+  /**
+   * Pauses job dequeuing. Jobs can still be enqueued but dequeueNext() will return null.
+   */
+  pause(): void;
+  /**
+   * Resumes job dequeuing and emits JOB_AVAILABLE events for pending jobs to wake up executors.
+   */
+  resume(): Promise<void>;
+  /**
+   * Returns whether job dequeuing is paused.
+   */
+  get paused(): boolean;
+  /**
+   * Returns all pending jobs across all queues.
+   */
+  getPendingJobs(): Job[];
+  /**
+   * Returns a map of document IDs to sets of executing job IDs.
+   */
+  getExecutingJobIds(): Map<string, Set<string>>;
+  /**
+   * Returns a job by ID from the job index.
+   */
+  getJob(jobId: string): Job | undefined;
+}
+//#endregion
+//#region src/job-tracker/in-memory-job-tracker.d.ts
+/**
+ * In-memory implementation of IJobTracker.
+ * Maintains job status in a Map for synchronous access.
+ * Subscribes to operation events to update job states.
+ */
+declare class InMemoryJobTracker implements IJobTracker {
+  private eventBus;
+  private jobs;
+  private unsubscribers;
+  constructor(eventBus: IEventBus);
+  private subscribeToEvents;
+  private handleWriteReady;
+  private handleReadReady;
+  private handleJobFailed;
+  shutdown(): void;
+  registerJob(jobInfo: JobInfo): void;
+  markRunning(jobId: string): void;
+  markFailed(jobId: string, error: ErrorInfo, job?: Job): void;
+  getJobStatus(jobId: string): JobInfo | null;
+}
+//#endregion
+//#region src/executor/simple-job-executor-manager.d.ts
+type JobExecutorFactory = () => IJobExecutor;
+/**
+ * Manages multiple job executors and coordinates job distribution.
+ * Listens for job available events and dispatches jobs to executors.
+ */
+declare class SimpleJobExecutorManager implements IJobExecutorManager {
+  private executorFactory;
+  private eventBus;
+  private queue;
+  private jobTracker;
+  private logger;
+  private resolver;
+  private executors;
+  private isRunning;
+  private activeJobs;
+  private totalJobsProcessed;
+  private unsubscribe?;
+  private deferredJobs;
+  private jobTimeoutMs;
+  constructor(executorFactory: JobExecutorFactory, eventBus: IEventBus, queue: IQueue, jobTracker: IJobTracker, logger: ILogger, resolver: IDocumentModelResolver, jobTimeoutMs?: number);
+  start(numExecutors: number): Promise<void>;
+  stop(graceful?: boolean): Promise<void>;
+  getExecutors(): IJobExecutor[];
+  getStatus(): ExecutorManagerStatus;
+  private processNextJob;
+  private checkForMoreJobs;
+  private processExistingJobs;
+  private toErrorInfo;
+  private hasCreateDocumentAction;
+  private flushDeferredJobs;
+  private formatErrorHistory;
+}
+//#endregion
+//#region src/cache/collection-membership-cache.d.ts
+interface ICollectionMembershipCache {
+  getCollectionsForDocuments(documentIds: string[]): Promise<Record<string, string[]>>;
+  invalidate(documentId: string): void;
+}
+//#endregion
+//#region src/cache/document-meta-cache-types.d.ts
+/**
+ * Cached document metadata from the "document" scope.
+ *
+ * This lightweight structure holds essential document information needed by
+ * the job executor without fetching full scope state. It provides an explicit
+ * cross-scope contract for accessing document scope metadata.
+ */
+type CachedDocumentMeta = {
+  /**
+   * The full PHDocumentState from document.state.document.
+   * Contains version, hash, isDeleted, deletedAtUtcIso, etc.
+   */
+  state: PHDocumentState;
+  /**
+   * The document type (from header), cached for convenience.
+   */
+  documentType: string;
+  /**
+   * The revision of the document scope when this metadata was captured.
+   * Used for cache invalidation and consistency checks.
+   */
+  documentScopeRevision: number;
+};
+/**
+ * Interface for the document metadata cache.
+ *
+ * This cache provides an explicit cross-scope contract for accessing document
+ * scope metadata. It solves the problem where job execution in one scope (e.g.,
+ * "global") needs access to document scope state (version, isDeleted, etc.)
+ * which may be stale in scope-specific caches or keyframes.
+ *
+ * The cache supports:
+ * - Latest metadata retrieval with LRU caching
+ * - Historical metadata reconstruction for reshuffling scenarios
+ * - Eager updates after document scope operations
+ */
+interface IDocumentMetaCache {
+  /**
+   * Retrieves the LATEST document metadata from cache or rebuilds from operations.
+   *
+   * On cache miss, fetches all document scope operations and reconstructs the
+   * current PHDocumentState by applying UPGRADE_DOCUMENT and DELETE_DOCUMENT
+   * operations.
+   *
+   * @param documentId - The document identifier
+   * @param branch - Branch name
+   * @param signal - Optional abort signal to cancel the operation
+   * @returns The cached or rebuilt document metadata
+   * @throws {Error} "Operation aborted" if signal is aborted
+   * @throws {Error} If document not found (no CREATE_DOCUMENT operation)
+   */
+  getDocumentMeta(documentId: string, branch: string, signal?: AbortSignal): Promise<CachedDocumentMeta>;
+  /**
+   * Rebuilds document metadata at a SPECIFIC revision (always rebuilds, no caching).
+   *
+   * Used during reshuffling when operations need to be inserted at a previous
+   * revision and we need the document scope state as of that point in time.
+   *
+   * @param documentId - The document identifier
+   * @param branch - Branch name
+   * @param targetRevision - The document scope revision to reconstruct up to
+   * @param signal - Optional abort signal to cancel the operation
+   * @returns Document metadata as of the target revision
+   * @throws {Error} "Operation aborted" if signal is aborted
+   * @throws {Error} If document not found
+   */
+  rebuildAtRevision(documentId: string, branch: string, targetRevision: number, signal?: AbortSignal): Promise<CachedDocumentMeta>;
+  /**
+   * Eagerly updates cached metadata after document scope operations.
+   *
+   * Called by the job executor after CREATE_DOCUMENT, UPGRADE_DOCUMENT, or
+   * DELETE_DOCUMENT operations to keep the cache current.
+   *
+   * @param documentId - The document identifier
+   * @param branch - Branch name
+   * @param meta - The new metadata to cache
+   */
+  putDocumentMeta(documentId: string, branch: string, meta: CachedDocumentMeta): void;
+  /**
+   * Invalidates cached document metadata.
+   *
+   * Call before reshuffling operations that modify the document scope, or
+   * when document state may have changed externally.
+   *
+   * @param documentId - The document identifier
+   * @param branch - Optional branch to narrow invalidation (if omitted, all branches)
+   * @returns Number of entries invalidated
+   */
+  invalidate(documentId: string, branch?: string): number;
+  /**
+   * Clears all cached document metadata.
+   */
+  clear(): void;
+  /**
+   * Performs startup initialization.
+   */
+  startup(): Promise<void>;
+  /**
+   * Performs graceful shutdown.
+   */
+  shutdown(): Promise<void>;
+}
+//#endregion
+//#region src/cache/buffer/ring-buffer.d.ts
+/**
+ * RingBuffer is a generic circular buffer implementation that stores a fixed number
+ * of items. When the buffer is full, new items overwrite the oldest items.
+ *
+ * This implementation maintains O(1) time complexity for push operations and provides
+ * items in chronological order (oldest to newest) via getAll().
+ *
+ * @template T - The type of items stored in the buffer
+ */
+declare class RingBuffer<T> {
+  private buffer;
+  private head;
+  private size;
+  private capacity;
+  constructor(capacity: number);
+  /**
+   * Adds an item to the buffer. If the buffer is full, overwrites the oldest item.
+   *
+   * @param item - The item to add
+   */
+  push(item: T): void;
+  /**
+   * Returns all items in the buffer in chronological order (oldest to newest).
+   *
+   * @returns Array of items in insertion order
+   */
+  getAll(): T[];
+  /**
+   * Clears all items from the buffer.
+   */
+  clear(): void;
+  /**
+   * Gets the current number of items in the buffer.
+   */
+  get length(): number;
+}
+//#endregion
+//#region src/cache/kysely-write-cache.d.ts
+type DocumentStream = {
+  key: string;
+  ringBuffer: RingBuffer<CachedSnapshot>;
+};
+/**
+ * In-memory write cache with keyframe persistence for PHDocuments.
+ *
+ * Caches document snapshots in ring buffers with LRU eviction. On cache miss,
+ * rebuilds documents from nearest keyframe or full operation history.
+ *
+ * **Performance Characteristics:**
+ * - Cache hit: O(1) lookup in ring buffer
+ * - Cold miss: O(n) where n is total operation count, or O(k) where k is operations since keyframe
+ * - Warm miss: O(m) where m is operations since cached revision
+ * - Eviction: O(1) for LRU tracking and removal
+ *
+ * **Thread Safety:**
+ * Not thread-safe. Designed for single-threaded job executor environment.
+ * External synchronization required for concurrent access across multiple executors.
+ *
+ * **Example:**
+ * ```typescript
+ * const cache = new KyselyWriteCache(
+ *   keyframeStore,
+ *   operationStore,
+ *   registry,
+ *   { maxDocuments: 1000, ringBufferSize: 10, keyframeInterval: 10 }
+ * );
+ *
+ * await cache.startup();
+ *
+ * // Retrieve or rebuild document
+ * const doc = await cache.getState(docId, docType, scope, branch, revision);
+ *
+ * // Cache result after job execution
+ * cache.putState(docId, docType, scope, branch, newRevision, updatedDoc);
+ *
+ * await cache.shutdown();
+ * ```
+ */
+declare class KyselyWriteCache implements IWriteCache {
+  private streams;
+  private lruTracker;
+  private keyframeStore;
+  private operationStore;
+  private registry;
+  private config;
+  constructor(keyframeStore: IKeyframeStore, operationStore: IOperationStore, registry: IDocumentModelRegistry, config: WriteCacheConfig);
+  withScopedStores(operationStore: IOperationStore, keyframeStore: IKeyframeStore): KyselyWriteCache;
+  /**
+   * Initializes the write cache.
+   * Currently a no-op as keyframe store lifecycle is managed externally.
+   */
+  startup(): Promise<void>;
+  /**
+   * Shuts down the write cache.
+   * Currently a no-op as keyframe store lifecycle is managed externally.
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Retrieves document state at a specific revision from cache or rebuilds it.
+   *
+   * Cache hit path: Returns cached snapshot if available (O(1))
+   * Warm miss path: Rebuilds from cached base revision + incremental ops
+   * Cold miss path: Rebuilds from keyframe or from scratch using all operations
+   *
+   * @param documentId - The document identifier
+   * @param scope - The operation scope
+   * @param branch - The operation branch
+   * @param targetRevision - The target revision, or undefined for newest
+   * @param signal - Optional abort signal to cancel the operation
+   * @returns The document at the target revision
+   * @throws {Error} "Operation aborted" if signal is aborted
+   * @throws {ModuleNotFoundError} If document type not registered in registry
+   * @throws {Error} "Failed to rebuild document" if operation store fails
+   * @throws {Error} If reducer throws during operation application
+   * @throws {Error} If document serialization fails
+   */
+  getState(documentId: string, scope: string, branch: string, targetRevision?: number, signal?: AbortSignal): Promise<PHDocument>;
+  /**
+   * Stores a document snapshot in the cache at a specific revision.
+   *
+   * The cached document is a shallow copy of the input with its operation history
+   * truncated to the last operation per scope and its clipboard cleared. This keeps
+   * memory use and copy costs constant regardless of operation count. Consumers of
+   * getState() must not rely on the full operation history being present; the only
+   * guaranteed invariant is that operations[scope].at(-1) reflects the latest
+   * operation index for each scope.
+   *
+   * Updates LRU tracker and may evict least recently used stream if at capacity.
+   * Asynchronously persists keyframes at configured intervals (fire-and-forget).
+   *
+   * @param documentId - The document identifier
+   * @param scope - The operation scope
+   * @param branch - The operation branch
+   * @param revision - The revision number
+   * @param document - The document to cache
+   * @throws {Error} If document serialization fails
+   */
+  putState(documentId: string, scope: string, branch: string, revision: number, document: PHDocument): void;
+  /**
+   * Invalidates cached document streams.
+   *
+   * Supports three invalidation scopes:
+   * - Document-level: invalidate(documentId) - removes all streams for document
+   * - Scope-level: invalidate(documentId, scope) - removes all branches for scope
+   * - Stream-level: invalidate(documentId, scope, branch) - removes specific stream
+   *
+   * @param documentId - The document identifier
+   * @param scope - Optional scope to narrow invalidation
+   * @param branch - Optional branch to narrow invalidation (requires scope)
+   * @returns The number of streams evicted
+   */
+  invalidate(documentId: string, scope?: string, branch?: string): number;
+  /**
+   * Clears the entire cache, removing all cached document streams.
+   * Resets LRU tracking state. This operation always succeeds.
+   */
+  clear(): void;
+  /**
+   * Retrieves a specific stream for a document. Exposed on the implementation
+   * for testing, but not on the interface.
+   *
+   * @internal
+   */
+  getStream(documentId: string, scope: string, branch: string): DocumentStream | undefined;
+  private findNearestKeyframe;
+  private coldMissRebuild;
+  private warmMissRebuild;
+  private findNearestOlderSnapshot;
+  private makeStreamKey;
+  private getOrCreateStream;
+  private isKeyframeRevision;
+}
+//#endregion
+//#region src/storage/kysely/store.d.ts
+declare class KyselyOperationStore implements IOperationStore {
+  private db;
+  private trx?;
+  constructor(db: Kysely<Database$1>);
+  private get queryExecutor();
+  withTransaction(trx: Transaction<Database$1>): KyselyOperationStore;
+  apply(documentId: string, documentType: string, scope: string, branch: string, revision: number, fn: (txn: AtomicTxn) => void | Promise<void>, signal?: AbortSignal): Promise<void>;
+  private executeApply;
+  getSince(documentId: string, scope: string, branch: string, revision: number, filter?: OperationFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<Operation>>;
+  getSinceId(id: number, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<OperationWithContext$1>>;
+  getConflicting(documentId: string, scope: string, branch: string, minTimestamp: string, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<Operation>>;
+  getRevisions(documentId: string, branch: string, signal?: AbortSignal): Promise<DocumentRevisions>;
+  private rowToOperation;
+  private rowToOperationWithContext;
+}
+//#endregion
+//#region src/storage/kysely/keyframe-store.d.ts
+declare class KyselyKeyframeStore implements IKeyframeStore {
+  private db;
+  private trx?;
+  constructor(db: Kysely<Database$1>);
+  private get queryExecutor();
+  withTransaction(trx: Transaction<Database$1>): KyselyKeyframeStore;
+  putKeyframe(documentId: string, scope: string, branch: string, revision: number, document: PHDocument, signal?: AbortSignal): Promise<void>;
+  findNearestKeyframe(documentId: string, scope: string, branch: string, targetRevision: number, signal?: AbortSignal): Promise<{
+    revision: number;
+    document: PHDocument;
+  } | undefined>;
+  listKeyframes(documentId: string, scope?: string, branch?: string, signal?: AbortSignal): Promise<Array<{
+    scope: string;
+    branch: string;
+    revision: number;
+    document: PHDocument;
+  }>>;
+  deleteKeyframes(documentId: string, scope?: string, branch?: string, signal?: AbortSignal): Promise<number>;
+}
+//#endregion
+//#region src/executor/execution-scope.d.ts
+interface ExecutionStores {
+  operationStore: IOperationStore;
+  operationIndex: IOperationIndex;
+  writeCache: IWriteCache;
+  documentMetaCache: IDocumentMetaCache;
+  collectionMembershipCache: ICollectionMembershipCache;
+}
+interface IExecutionScope {
+  run<T>(fn: (stores: ExecutionStores) => Promise<T>, signal?: AbortSignal): Promise<T>;
+}
+//#endregion
+//#region src/executor/simple-job-executor.d.ts
+/**
+ * Simple job executor that processes a job by applying actions through document model reducers.
+ */
+declare class SimpleJobExecutor implements IJobExecutor {
+  private logger;
+  private registry;
+  private operationStore;
+  private eventBus;
+  private writeCache;
+  private operationIndex;
+  private documentMetaCache;
+  private collectionMembershipCache;
+  private config;
+  private signatureVerifierModule;
+  private documentActionHandler;
+  private executionScope;
+  constructor(logger: ILogger, registry: IDocumentModelRegistry, operationStore: IOperationStore, eventBus: IEventBus, writeCache: IWriteCache, operationIndex: IOperationIndex, documentMetaCache: IDocumentMetaCache, collectionMembershipCache: ICollectionMembershipCache, config: JobExecutorConfig, signatureVerifier?: SignatureVerificationHandler, executionScope?: IExecutionScope);
+  /**
+   * Execute a single job by applying all its actions through the appropriate reducers.
+   * Actions are processed sequentially in order.
+   */
+  executeJob(job: Job, signal?: AbortSignal): Promise<JobResult>;
+  private getCollectionMembershipsForOperations;
+  private processActions;
+  private executeRegularAction;
+  private executeLoadJob;
+  private accumulateResultOrReturnError;
+}
+//#endregion
+//#region src/registry/implementation.d.ts
+/**
+ * Error thrown when a document model module is not found in the registry.
+ */
+declare class ModuleNotFoundError extends Error {
+  readonly documentType: string;
+  readonly requestedVersion: number | undefined;
+  constructor(documentType: string, version?: number);
+  static isError(error: unknown): error is ModuleNotFoundError;
+}
+/**
+ * Error thrown when attempting to register a module that already exists.
+ */
+declare class DuplicateModuleError extends Error {
+  constructor(documentType: string, version?: number);
+  static isError(error: unknown): error is DuplicateModuleError;
+}
+/**
+ * Error thrown when a module is invalid or malformed.
+ */
+declare class InvalidModuleError extends Error {
+  constructor(message: string);
+}
+/**
+ * Error thrown when attempting to register an upgrade manifest that already exists.
+ */
+declare class DuplicateManifestError extends Error {
+  constructor(documentType: string);
+  static isError(error: unknown): error is DuplicateManifestError;
+}
+/**
+ * In-memory implementation of the IDocumentModelRegistry interface.
+ * Manages document model modules with version-aware storage and upgrade manifest support.
+ */
+declare class DocumentModelRegistry implements IDocumentModelRegistry {
+  private modules;
+  private manifests;
+  registerModules(...modules: DocumentModelModule<any>[]): RegistrationResult<DocumentModelModule<any>>[];
+  unregisterModules(...documentTypes: string[]): boolean;
+  getModule(documentType: string, version?: number): DocumentModelModule<any>;
+  getAllModules(): DocumentModelModule<any>[];
+  clear(): void;
+  getSupportedVersions(documentType: string): number[];
+  getLatestVersion(documentType: string): number;
+  registerUpgradeManifests(...manifestsToRegister: UpgradeManifest<readonly number[]>[]): RegistrationResult<UpgradeManifest<readonly number[]>>[];
+  unregisterUpgradeManifests(...documentTypes: string[]): boolean;
+  getUpgradeManifest(documentType: string): UpgradeManifest<readonly number[]>;
+  computeUpgradePath(documentType: string, fromVersion: number, toVersion: number): UpgradeTransition[];
+  getUpgradeReducer(documentType: string, fromVersion: number, toVersion: number): UpgradeReducer<any, any>;
+}
+//#endregion
+//#region src/read-models/base-read-model.d.ts
+type BaseReadModelConfig = {
+  readModelId: string;
+  rebuildStateOnInit: boolean;
+};
+/**
+ * Base class for read models that provides catch-up/rewind functionality.
+ * Handles initialization, state tracking via ViewState table, and consistency tracking.
+ * Subclasses override commitOperations() with their specific domain logic.
+ */
+declare class BaseReadModel implements IReadModel {
+  protected db: Kysely<DocumentViewDatabase>;
+  protected operationIndex: IOperationIndex;
+  protected writeCache: IWriteCache;
+  protected consistencyTracker: IConsistencyTracker;
+  protected config: BaseReadModelConfig;
+  protected lastOrdinal: number;
+  readonly name: string;
+  constructor(db: Kysely<DocumentViewDatabase>, operationIndex: IOperationIndex, writeCache: IWriteCache, consistencyTracker: IConsistencyTracker, config: BaseReadModelConfig);
+  /**
+   * Initializes the read model by loading state and catching up on missed operations.
+   */
+  init(): Promise<void>;
+  /**
+   * Template method: runs domain-specific commitOperations, then persists
+   * state and updates consistency tracking.
+   */
+  indexOperations(items: OperationWithContext$1[]): Promise<void>;
+  /**
+   * Waits for the read model to reach the specified consistency level.
+   */
+  waitForConsistency(token: ConsistencyToken, timeoutMs?: number, signal?: AbortSignal): Promise<void>;
+  protected commitOperations(items: OperationWithContext$1[]): Promise<void>;
+  /**
+   * Rebuilds document state for each operation using the write cache.
+   */
+  protected rebuildStateForOperations(operations: OperationWithContext$1[]): Promise<OperationWithContext$1[]>;
+  /**
+   * Loads the last processed ordinal from the ViewState table.
+   * Returns undefined if no state exists for this read model.
+   */
+  protected loadState(): Promise<number | undefined>;
+  /**
+   * Initializes the ViewState row for this read model.
+   */
+  protected initializeState(): Promise<void>;
+  /**
+   * Saves the last processed ordinal to the ViewState table.
+   */
+  protected saveState(trx: Transaction<DocumentViewDatabase>, items: OperationWithContext$1[]): Promise<void>;
+  /**
+   * Updates the consistency tracker with the processed operations.
+   */
+  protected updateConsistencyTracker(items: OperationWithContext$1[]): void;
+}
+//#endregion
+//#region src/storage/kysely/document-indexer.d.ts
+type IndexerDatabase = Database$1 & DocumentIndexerDatabase & DocumentViewDatabase;
+declare class KyselyDocumentIndexer extends BaseReadModel implements IDocumentIndexer {
+  private _db;
+  constructor(db: Kysely<IndexerDatabase>, operationIndex: IOperationIndex, writeCache: IWriteCache, consistencyTracker: IConsistencyTracker);
+  protected commitOperations(items: OperationWithContext$1[]): Promise<void>;
+  getOutgoing(documentId: string, types?: string[], paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<DocumentRelationship>>;
+  getIncoming(documentId: string, types?: string[], paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<DocumentRelationship>>;
+  getOrphanedChildren(parentIds: string[], types?: string[], signal?: AbortSignal): Promise<string[]>;
+  hasRelationship(sourceId: string, targetId: string, types?: string[], consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<boolean>;
+  getUndirectedRelationships(a: string, b: string, types?: string[], paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<DocumentRelationship>>;
+  getDirectedRelationships(sourceId: string, targetId: string, types?: string[], paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<DocumentRelationship>>;
+  findPath(sourceId: string, targetId: string, types?: string[], consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[] | null>;
+  findAncestors(documentId: string, types?: string[], consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<IDocumentGraph>;
+  getRelationshipTypes(consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[]>;
+  private handleAddRelationship;
+  private handleRemoveRelationship;
+}
+//#endregion
+//#region src/read-models/coordinator.d.ts
+/**
+ * Coordinates read model synchronization by listening to operation write events
+ * and updating all registered read models in parallel.
+ *
+ * This coordinator is responsible for:
+ * - Subscribing to OPERATION_WRITTEN events from the event bus
+ * - Distributing operation updates to all registered read models
+ * - Managing the lifecycle of read model subscriptions
+ *
+ * Read models are updated asynchronously and in parallel to avoid blocking
+ * the write path. Errors in read model updates are propagated through the
+ * event bus but do not affect the write operation success.
+ */
+declare class ReadModelCoordinator implements IReadModelCoordinator {
+  private eventBus;
+  readonly preReady: IReadModel[];
+  readonly postReady: IReadModel[];
+  private unsubscribe?;
+  private isRunning;
+  readonly readModels: IReadModel[];
+  constructor(eventBus: IEventBus, preReady: IReadModel[], postReady: IReadModel[]);
+  /**
+   * Start listening for operation events and updating read models.
+   * Can be called multiple times safely (subsequent calls are no-ops).
+   */
+  start(): void;
+  /**
+   * Stop listening and clean up subscriptions.
+   * Can be called multiple times safely (subsequent calls are no-ops).
+   */
+  stop(): void;
+  /**
+   * Handle write ready events by updating all read models in parallel.
+   * Errors from individual read models are collected and re-thrown as an aggregate.
+   */
+  private handleWriteReady;
+}
+//#endregion
+//#region src/read-models/document-view.d.ts
+type Database$2 = Database$1 & DocumentViewDatabase;
+declare class KyselyDocumentView extends BaseReadModel implements IDocumentView {
+  private operationStore;
+  private _db;
+  constructor(db: Kysely<Database$2>, operationStore: IOperationStore, operationIndex: IOperationIndex, writeCache: IWriteCache, consistencyTracker: IConsistencyTracker);
+  protected commitOperations(items: OperationWithContext$1[]): Promise<void>;
+  exists(documentIds: string[], consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<boolean[]>;
+  get<TDocument extends PHDocument>(documentId: string, view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  getMany<TDocument extends PHDocument>(documentIds: string[], view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument[]>;
+  getByIdOrSlug<TDocument extends PHDocument>(identifier: string, view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<TDocument>;
+  findByType(type: string, view?: ViewFilter$1, paging?: PagingOptions, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<PagedResults<PHDocument>>;
+  resolveSlug(slug: string, view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string | undefined>;
+  resolveSlugs(slugs: string[], view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string[]>;
+  resolveIdOrSlug(identifier: string, view?: ViewFilter$1, consistencyToken?: ConsistencyToken, signal?: AbortSignal): Promise<string>;
+}
+//#endregion
+//#region src/storage/migrations/migrator.d.ts
+declare const REACTOR_SCHEMA = "reactor";
+declare function runMigrations(db: Kysely<any>, schema?: string): Promise<MigrationResult>;
+declare function getMigrationStatus(db: Kysely<any>, schema?: string): Promise<readonly kysely.MigrationInfo[]>;
+//#endregion
+//#region src/storage/kysely/sync-cursor-storage.d.ts
+declare class KyselySyncCursorStorage implements ISyncCursorStorage {
+  private readonly db;
+  constructor(db: Kysely<Database$1>);
+  list(remoteName: string, signal?: AbortSignal): Promise<RemoteCursor[]>;
+  get(remoteName: string, cursorType: "inbox" | "outbox", signal?: AbortSignal): Promise<RemoteCursor>;
+  upsert(cursor: RemoteCursor, signal?: AbortSignal): Promise<void>;
+  remove(remoteName: string, signal?: AbortSignal): Promise<void>;
+}
+//#endregion
+//#region src/storage/kysely/sync-remote-storage.d.ts
+declare class KyselySyncRemoteStorage implements ISyncRemoteStorage {
+  private readonly db;
+  constructor(db: Kysely<Database$1>);
+  list(signal?: AbortSignal): Promise<RemoteRecord[]>;
+  get(name: string, signal?: AbortSignal): Promise<RemoteRecord>;
+  upsert(remote: RemoteRecord, signal?: AbortSignal): Promise<void>;
+  remove(name: string, signal?: AbortSignal): Promise<void>;
+}
+//#endregion
+//#region src/sync/channels/gql-request-channel-factory.d.ts
+/**
+ * Factory for creating GqlRequestChannel instances.
+ *
+ * Extracts GraphQL-specific configuration from ChannelConfig.parameters and
+ * instantiates GqlRequestChannel instances for network-based synchronization.
+ *
+ * The optional jwtHandler enables dynamic JWT token generation per-request,
+ * which is useful for short-lived tokens with audience-specific claims.
+ */
+declare class GqlRequestChannelFactory implements IChannelFactory {
+  private readonly logger;
+  private readonly jwtHandler?;
+  private readonly queue;
+  constructor(logger: ILogger, jwtHandler: JwtHandler | undefined, queue: IQueue);
+  /**
+   * Creates a new GqlRequestChannel instance with the given configuration.
+   * See GqlChannelConfig for the expected parameters.
+   *
+   * @param config - Channel configuration including type and parameters
+   * @param cursorStorage - Storage for persisting synchronization cursors
+   * @param operationIndex - Operation index for querying timestamps
+   * @returns A new GqlRequestChannel instance
+   */
+  instance(remoteId: string, remoteName: string, config: ChannelConfig, cursorStorage: ISyncCursorStorage, collectionId: string, filter: RemoteFilter, operationIndex: IOperationIndex, options?: RemoteOptions): IChannel;
+}
+//#endregion
+//#region src/sync/channels/gql-response-channel-factory.d.ts
+/**
+ * Factory for creating GqlResponseChannel instances.
+ */
+declare class GqlResponseChannelFactory implements IChannelFactory {
+  private readonly logger;
+  constructor(logger: ILogger);
+  instance(remoteId: string, remoteName: string, config: ChannelConfig, cursorStorage: ISyncCursorStorage): IChannel;
+}
+//#endregion
+//#region src/sync/channels/poll-timer.d.ts
+/**
+ * Timer that controls when polling occurs.
+ * GqlChannel registers a delegate; the timer invokes it when appropriate.
+ * The delegate returns a Promise; timer waits for completion before scheduling next tick.
+ */
+type IPollTimer = {
+  /** Register the delegate to be called on each tick. Returns Promise that timer awaits. */setDelegate: (delegate: () => Promise<void>) => void; /** Start the timer (begins calling delegate periodically) */
+  start: () => void; /** Stop the timer */
+  stop: () => void;
+  /**
+   * Fires the delegate exactly once without changing the running/paused state.
+   * Used by Manual polling mode to pull on demand without resuming the schedule.
+   */
+  triggerNow: () => void;
+};
+//#endregion
+//#region src/sync/channels/gql-req-channel.d.ts
+/**
+ * Configuration parameters for GqlChannel
+ */
+type GqlChannelConfig = {
+  /** The GraphQL endpoint URL */url: string; /** Dynamic JWT token handler for generating fresh tokens per-request */
+  jwtHandler?: JwtHandler; /** Custom fetch function for testing (default: global fetch) */
+  fetchFn?: typeof fetch; /** Collection ID to synchronize */
+  collectionId: string; /** Filter to apply to operations */
+  filter: RemoteFilter; /** Base delay in ms for exponential backoff on push retries */
+  retryBaseDelayMs: number; /** Maximum delay in ms for exponential backoff on push retries */
+  retryMaxDelayMs: number;
+};
+/**
+ * GraphQL-based synchronization channel for network communication between reactors.
+ */
+declare class GqlRequestChannel implements IChannel {
+  private readonly logger;
+  readonly inbox: IMailbox;
+  readonly outbox: IMailbox;
+  readonly deadLetter: IMailbox;
+  readonly config: GqlChannelConfig;
+  private readonly bufferedOutbox;
+  private readonly channelId;
+  private readonly remoteName;
+  private readonly cursorStorage;
+  private readonly operationIndex;
+  private readonly pollTimer;
+  private readonly abortController;
+  private isShutdown;
+  private failureCount;
+  private lastSuccessUtcMs?;
+  private lastFailureUtcMs?;
+  private lastPersistedInboxOrdinal;
+  private lastPersistedOutboxOrdinal;
+  private pushFailureCount;
+  private pushRetryTimer;
+  private pushBlocked;
+  private isPushing;
+  private pendingDrain;
+  private receivingPages;
+  private connectionState;
+  private readonly connectionStateCallbacks;
+  constructor(logger: ILogger, channelId: string, remoteName: string, cursorStorage: ISyncCursorStorage, config: GqlChannelConfig, operationIndex: IOperationIndex, pollTimer: IPollTimer);
+  /**
+   * Shuts down the channel and prevents further operations.
+   */
+  shutdown(): Promise<void>;
+  getConnectionState(): ConnectionStateSnapshot;
+  onConnectionStateChange(callback: ConnectionStateChangeCallback): () => void;
+  triggerPull(): void;
+  /**
+   * Initializes the channel by registering it on the remote server and starting polling.
+   */
+  init(): Promise<void>;
+  private transitionConnectionState;
+  /**
+   * Polls the remote for new sync envelopes.
+   */
+  private poll;
+  /**
+   * Handles dead letters reported by the remote server.
+   * Creates local dead letter SyncOperations so the channel quiesces.
+   */
+  private handleRemoteDeadLetters;
+  /**
+   * Handles polling errors with error classification.
+   * Returns true if the error was handled (caller should not rethrow).
+   */
+  private handlePollError;
+  /**
+   * Recovers from a "Channel not found" error by re-registering and restarting polling.
+   * Self-retries with backoff instead of restarting the poll timer on failure.
+   */
+  private recoverFromChannelNotFound;
+  /**
+   * Queries the remote GraphQL endpoint for sync envelopes.
+   */
+  private pollSyncEnvelopes;
+  /**
+   * Registers or updates this channel on the remote server via GraphQL mutation.
+   * Returns the remote's ack ordinal so the client can trim its outbox.
+   */
+  private touchRemoteChannel;
+  /**
+   * Fire-and-forget push with retry on recoverable errors.
+   * On success, clears push blocked state. On recoverable error, blocks
+   * further pushes and schedules a retry. On unrecoverable error, moves
+   * ops to deadLetter.
+   */
+  private attemptPush;
+  /**
+   * Schedules a retry of all current outbox items using exponential backoff.
+   */
+  private schedulePushRetry;
+  /**
+   * Drains pending outbox items that arrived while a push was in-flight.
+   * Server-side action.id dedup handles any overlap with the previous push.
+   */
+  private drainOutbox;
+  /**
+   * Classifies an error as recoverable or unrecoverable based on its type.
+   * Recoverable errors are transient and worth retrying (network, 5xx, parse).
+   * Unrecoverable errors will not self-heal (auth, client errors, GraphQL rejections).
+   */
+  private classifyError;
+  /**
+   * Pushes multiple sync operations to the remote via a single GraphQL mutation.
+   * Creates one SyncEnvelope per SyncOperation with key/dependsOn for batch ordering.
+   */
+  private pushSyncOperations;
+  /**
+   * Gets the authorization header value using jwtHandler.
+   */
+  private getAuthorizationHeader;
+  /**
+   * Executes a GraphQL query or mutation against the remote endpoint.
+   */
+  private executeGraphQL;
+  get poller(): IPollTimer;
+}
+//#endregion
+//#region src/sync/channels/gql-res-channel.d.ts
+/**
+ * This class is used server-side to accumulate inbox + outbox operations.
+ *
+ * In general, the resolvers are responsible for updating mailboxes.
+ */
+declare class GqlResponseChannel implements IChannel {
+  private readonly logger;
+  readonly inbox: Mailbox;
+  readonly outbox: Mailbox;
+  readonly deadLetter: Mailbox;
+  private readonly channelId;
+  private readonly remoteName;
+  private readonly cursorStorage;
+  private isShutdown;
+  private lastPersistedInboxOrdinal;
+  private lastPersistedOutboxOrdinal;
+  private connectionState;
+  private readonly connectionStateCallbacks;
+  constructor(logger: ILogger, channelId: string, remoteName: string, cursorStorage: ISyncCursorStorage);
+  shutdown(): Promise<void>;
+  getConnectionState(): ConnectionStateSnapshot;
+  onConnectionStateChange(callback: ConnectionStateChangeCallback): () => void;
+  /** Response channels are push-driven; resolvers populate mailboxes directly. */
+  triggerPull(): void;
+  private transitionConnectionState;
+  init(): Promise<void>;
+}
+//#endregion
+//#region src/sync/channels/interval-poll-timer.d.ts
+type PollTimerConfig = {
+  intervalMs: number;
+  maxQueueDepth: number;
+  backpressureCheckIntervalMs: number;
+  retryBaseDelayMs: number;
+  retryMaxDelayMs: number;
+  /**
+   * If true, start() puts the timer into a paused state — running but not ticking.
+   * Use resume() to begin scheduling ticks, or triggerNow() to fire a single tick
+   * without leaving the paused state. Defaults to false (auto-tick on start).
+   */
+  startPaused: boolean;
+};
+/**
+ * Default poll timer using setTimeout.
+ * Waits for delegate completion before scheduling next tick.
+ * Checks queue depth and defers polling when backpressure is detected.
+ */
+declare class IntervalPollTimer implements IPollTimer {
+  private delegate;
+  private timer;
+  private running;
+  private paused;
+  private consecutiveFailures;
+  private readonly queue;
+  private readonly config;
+  constructor(queue: IQueue, config?: Partial<PollTimerConfig>);
+  setDelegate(delegate: () => Promise<void>): void;
+  start(): void;
+  stop(): void;
+  private tick;
+  private scheduleNext;
+  private scheduleRetry;
+  private scheduleBackpressureRecheck;
+  pause(): void;
+  resume(): void;
+  triggerNow(): void;
+  isPaused(): boolean;
+  isRunning(): boolean;
+  getIntervalMs(): number;
+  setIntervalMs(ms: number): void;
+}
+//#endregion
+//#region src/sync/channels/utils.d.ts
+/**
+ * Converts a SyncEnvelope containing operations into multiple SyncOperations.
+ *
+ * This function batches operations by documentId, preserving cross-document ordering.
+ * For operations [a1, a2, a3, b1, b2, a4], it returns:
+ * - SyncOperation 1: [a1, a2, a3] for doc-a
+ * - SyncOperation 2: [b1, b2] for doc-b
+ * - SyncOperation 3: [a4] for doc-a
+ *
+ * This ensures operations are grouped for efficient processing while maintaining
+ * causality across documents.
+ */
+declare function envelopesToSyncOperations(envelope: SyncEnvelope, remoteName: string): SyncOperation[];
+//#endregion
+//#region src/sync/utils.d.ts
+type OperationBatch = {
+  documentId: string;
+  branch: string;
+  scope: string;
+  operations: OperationWithContext$1[];
+};
+/**
+ * Trims a mailbox using the ack ordinal.
+ */
+declare function trimMailboxFromAckOrdinal(mailbox: IMailbox, ackOrdinal: number): void;
+/**
+ * Batches consecutive operations by documentId and scope, preserving ordering.
+ *
+ * For operations [a1_doc, a1_global, a2_doc, b1_global], this returns:
+ * - Batch 1: [a1_doc] for doc-a, document scope
+ * - Batch 2: [a1_global] for doc-a, global scope
+ * - Batch 3: [a2_doc] for doc-a, document scope
+ * - Batch 4: [b1_global] for doc-b, global scope
+ *
+ * This ensures operations are grouped for efficient processing while maintaining
+ * causality across documents and scopes.
+ */
+declare function batchOperationsByDocument(operations: OperationWithContext$1[]): OperationBatch[];
+/**
+ * Merges SyncOperations that share the same (documentId, scope, branch) into
+ * a single SyncOperation per group. Within each group, operations are sorted
+ * by context.ordinal. The merged SyncOperation keeps the first group member's
+ * jobId; all other jobIds are remapped so external dependencies still resolve.
+ */
+declare function consolidateSyncOperations(syncOps: SyncOperation[]): SyncOperation[];
+//#endregion
+//#region src/admin/types.d.ts
+type KeyframeValidationIssue = {
+  scope: string;
+  branch: string;
+  revision: number;
+  keyframeHash: string;
+  replayedHash: string;
+};
+type SnapshotValidationIssue = {
+  scope: string;
+  branch: string;
+  snapshotHash: string;
+  replayedHash: string;
+};
+type ValidationResult = {
+  documentId: string;
+  isConsistent: boolean;
+  keyframeIssues: KeyframeValidationIssue[];
+  snapshotIssues: SnapshotValidationIssue[];
+};
+type RebuildResult = {
+  documentId: string;
+  keyframesDeleted: number;
+  scopesInvalidated: number;
+};
+interface IDocumentIntegrityService {
+  validateDocument(documentId: string, branch?: string, signal?: AbortSignal): Promise<ValidationResult>;
+  rebuildKeyframes(documentId: string, branch?: string, signal?: AbortSignal): Promise<RebuildResult>;
+  rebuildSnapshots(documentId: string, branch?: string, signal?: AbortSignal): Promise<RebuildResult>;
+}
+//#endregion
+//#region src/admin/document-integrity-service.d.ts
+declare class DocumentIntegrityService implements IDocumentIntegrityService {
+  private readonly keyframeStore;
+  private readonly operationStore;
+  private readonly writeCache;
+  private readonly documentView;
+  private readonly documentModelRegistry;
+  constructor(keyframeStore: IKeyframeStore, operationStore: IOperationStore, writeCache: IWriteCache, documentView: IDocumentView, documentModelRegistry: IDocumentModelRegistry);
+  validateDocument(documentId: string, branch?: string, signal?: AbortSignal): Promise<ValidationResult>;
+  rebuildKeyframes(documentId: string, branch?: string, signal?: AbortSignal): Promise<RebuildResult>;
+  rebuildSnapshots(documentId: string, branch?: string, signal?: AbortSignal): Promise<RebuildResult>;
+  private discoverScopes;
+}
+//#endregion
+//#region src/processors/processor-manager.d.ts
+/**
+ * Manages processor lifecycle based on operations.
+ * Extends BaseReadModel to receive operations from ReadModelCoordinator.
+ *
+ * Responsibilities:
+ * 1. Detect drive creation from CREATE_DOCUMENT operations
+ * 2. Create processors for each drive using registered factories
+ * 3. Route operations to matching processors based on filters
+ * 4. Clean up processors when drives are deleted or factories are unregistered
+ * 5. Track per-processor cursors for failure recovery and backfill
+ */
+declare class ProcessorManager extends BaseReadModel implements IProcessorManager$1 {
+  private factoryRegistry;
+  private processorsByDrive;
+  private factoryToProcessors;
+  private knownDriveIds;
+  private cursorCache;
+  private logger;
+  constructor(db: Kysely<DocumentViewDatabase>, operationIndex: IOperationIndex, writeCache: IWriteCache, consistencyTracker: IConsistencyTracker, logger: ILogger);
+  init(): Promise<void>;
+  protected commitOperations(items: OperationWithContext$1[]): Promise<void>;
+  registerFactory(identifier: string, factory: ProcessorFactory$1): Promise<void>;
+  unregisterFactory(identifier: string): Promise<void>;
+  get(processorId: string): TrackedProcessor$1 | undefined;
+  getAll(): TrackedProcessor$1[];
+  private allTrackedProcessors;
+  private detectAndRegisterNewDrives;
+  private detectAndCleanupDeletedDrives;
+  private discoverExistingDrives;
+  private isDeletedDocumentADrive;
+  private createProcessorsForDrive;
+  private backfillProcessor;
+  private retryProcessor;
+  private cleanupDriveProcessors;
+  private safeDisconnect;
+  private routeOperationsToProcessors;
+  private loadAllCursors;
+  private safeSaveProcessorCursor;
+  private saveProcessorCursor;
+  private deleteProcessorCursors;
+}
+//#endregion
+export { type AtomicTxn, type AttachmentHash, type AttachmentRef, BaseReadModel, type BatchLoadRequest, type BatchLoadResult, type CachedSnapshot, type ChannelConfig, ChannelError, ChannelErrorSource, type ChannelHealth, type ChannelMeta, ChannelScheme, type ConnectionState, type ConnectionStateChangeCallback, type ConnectionStateChangedEvent, type ConnectionStateSnapshot, type ConsistencyCoordinate, type ConsistencyKey, type ConsistencyToken, ConsistencyTracker, type Database, type DeadLetterAddedEvent, DefaultSubscriptionErrorHandler, type DocumentChangeEvent, DocumentChangeType, type DocumentGraphEdge, type DocumentIndexerDatabase, DocumentIntegrityService, DocumentModelRegistry, type DocumentRelationship, type DocumentRevisions, type DocumentStreamKey, type DocumentViewDatabase, DriveClient, DuplicateManifestError, DuplicateModuleError, DuplicateOperationError, EventBus, EventBusAggregateError, type ExecutorStartedEvent, type ExecutorStoppedEvent, type GqlChannelConfig, GqlRequestChannel, GqlRequestChannelFactory, GqlResponseChannel, GqlResponseChannelFactory, type IChannel, type IChannelFactory, type IConsistencyTracker, type IDocumentGraph, type IDocumentIndexer, type IDocumentIntegrityService, type IDocumentModelLoader, type IDocumentModelRegistry, type IDocumentView, type IDriveClient, type IEventBus, type IJobAwaiter, type IJobExecutor, type IJobExecutorManager, type IJobTracker, type IKeyframeStore, type IOperationIndex, type IOperationStore, type IPollTimer, type IProcessor, type IProcessorHostModule, type IProcessorManager, type IQueue, type IReactor, type IReactorClient, type IReactorSubscriptionManager, type IReadModel, type IReadModelCoordinator, type IRelationalDb, type ISubscriptionErrorHandler, type ISyncCursorStorage, type ISyncManager, type ISyncRemoteStorage, type ISyncStatusTracker, type IWriteCache, SimpleJobExecutor as InMemoryJobExecutor, SimpleJobExecutor, InMemoryJobTracker, InMemoryQueue, type InsertableDocumentSnapshot, IntervalPollTimer, InvalidModuleError, type Job, type JobAvailableEvent, JobAwaiter, type JobCompletedEvent, type JobExecutorConfig, JobExecutorEventTypes, type JobExecutorFactory, type JobFailedEvent, type JobInfo, type JobPendingEvent, type JobReadReadyEvent, type JobResult, type JobRunningEvent, type JobStartedEvent, JobStatus, type JobWriteReadyEvent, type JwtHandler, type KeyframeSnapshot, type KeyframeValidationIssue, KyselyDocumentIndexer, KyselyDocumentView, KyselyKeyframeStore, KyselyOperationStore, KyselySyncCursorStorage, KyselySyncRemoteStorage, KyselyWriteCache, type LoadJobPlan, Mailbox, ModuleNotFoundError, NullDocumentModelResolver, type OperationBatch, type OperationContext, type OperationFilter, type OperationIndexEntry, type OperationTable, type OperationWithContext, OptimisticLockError, type PagedResults, type PagingOptions, type ParsedDriveUrl, PollBehavior, PollingChannelError, type ProcessorApp, type ProcessorFactory, type ProcessorFactoryBuilder, type ProcessorFilter, ProcessorManager, type ProcessorRecord, type ProcessorStatus, PropagationMode, QueueEventTypes, REACTOR_SCHEMA, Reactor, ReactorBuilder, ReactorClient, ReactorClientBuilder, type ReactorClientModule, ReactorEventTypes, type ReactorFeatures, type JobFailedEvent$1 as ReactorJobFailedEvent, type ReactorModule, ReactorSubscriptionManager, ReadModelCoordinator, type RebuildResult, RelationalDbProcessor, RelationshipChangeType, type Remote, type RemoteCursor, type RemoteFilter, type RemoteOptions, type RemoteRecord, type RemoteStatus, RevisionMismatchError, type SearchFilter, type ShutdownStatus, type SignatureVerificationHandler, type SignerConfig, SimpleJobExecutorManager, type SnapshotValidationIssue, type Database$1 as StorageDatabase, type SubscriptionErrorContext, SyncBuilder, type SyncEnvelope, type SyncEnvelopeType, SyncEventTypes, type SyncFailedEvent, type SyncModule, SyncOperation, SyncOperationAggregateError, type SyncOperationErrorType, SyncOperationStatus, type SyncPendingEvent, SyncStatus, type SyncStatusChangeCallback, SyncStatusTracker, type SyncSucceededEvent, type TrackedProcessor, type Unsubscribe, type ValidationResult, type ViewFilter, type WriteCacheConfig, addRelationshipAction, batchOperationsByDocument, consolidateSyncOperations, createDocumentAction, createMutableShutdownStatus, createRelationalDb, deleteDocumentAction, documentActions, driveCollectionId, driveIdFromUrl, envelopesToSyncOperations, getMigrationStatus, makeConsistencyKey, parseDriveUrl, removeRelationshipAction, runMigrations, trimMailboxFromAckOrdinal, upgradeDocumentAction };
+//# sourceMappingURL=index.d.ts.map