@powerhousedao/shared 6.2.3-dev.6 → 6.2.3-dev.61

package/dist/{types-CpnWmiFY.d.ts → types-DzleLgA8.d.ts}

@@ -1,26 +1,23 @@
-import { f as IAnalyticsStore } from "./types-C1in4fl3.js";
-import { ZodRawShape, z } from "zod";
+import { f as IAnalyticsStore } from "./types-Bsp8VL2y.js";
+import "./utils-BrKxCmKx.js";
+import { ZodIssue, ZodRawShape, z } from "zod";
 import { Draft } from "mutative";
-import * as cmd_ts_dist_cjs_argparser_js0 from "cmd-ts/dist/cjs/argparser.js";
+import { Kysely, QueryCreator } from "kysely";
 import { ArgParser } from "cmd-ts/dist/cjs/argparser.js";
-import * as cmd_ts_dist_cjs_helpdoc_js0 from "cmd-ts/dist/cjs/helpdoc.js";
-import * as cmd_ts_dist_cjs_runner_js0 from "cmd-ts/dist/cjs/runner.js";
 import { Agent } from "package-manager-detector";
 import { OperationWithContext } from "@powerhousedao/shared/document-model";
-import { Kysely, QueryCreator } from "kysely";
 import { IncomingMessage, ServerResponse } from "node:http";
 import { FC, ReactNode } from "react";
-
 //#region clis/args/common.d.ts
-declare const getPackageManagerCommand: Partial<cmd_ts_dist_cjs_argparser_js0.Register> & {
-  parse(context: cmd_ts_dist_cjs_argparser_js0.ParseContext): Promise<cmd_ts_dist_cjs_argparser_js0.ParsingResult<{
+declare const getPackageManagerCommand: Partial<import("cmd-ts/dist/cjs/argparser.js").Register> & {
+  parse(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<{
     packageManager: Agent | undefined;
     npm: boolean | undefined;
     pnpm: boolean | undefined;
     yarn: boolean | undefined;
     bun: boolean | undefined;
   }>>;
-} & cmd_ts_dist_cjs_helpdoc_js0.PrintHelp & cmd_ts_dist_cjs_helpdoc_js0.ProvidesHelp & cmd_ts_dist_cjs_helpdoc_js0.Named & Partial<cmd_ts_dist_cjs_helpdoc_js0.Versioned> & cmd_ts_dist_cjs_argparser_js0.Register & cmd_ts_dist_cjs_runner_js0.Handling<{
+} & import("cmd-ts/dist/cjs/helpdoc.js").PrintHelp & import("cmd-ts/dist/cjs/helpdoc.js").ProvidesHelp & import("cmd-ts/dist/cjs/helpdoc.js").Named & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned> & import("cmd-ts/dist/cjs/argparser.js").Register & import("cmd-ts/dist/cjs/runner.js").Handling<{
   packageManager: Agent | undefined;
   npm: boolean | undefined;
   pnpm: boolean | undefined;
@@ -33,14 +30,14 @@ declare const getPackageManagerCommand: Partial<cmd_ts_dist_cjs_argparser_js0.Re
   yarn: boolean | undefined;
   bun: boolean | undefined;
 }> & {
-  run(context: cmd_ts_dist_cjs_argparser_js0.ParseContext): Promise<cmd_ts_dist_cjs_argparser_js0.ParsingResult<{
+  run(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<{
     packageManager: Agent | undefined;
     npm: boolean | undefined;
     pnpm: boolean | undefined;
     yarn: boolean | undefined;
     bun: boolean | undefined;
   }>>;
-} & Partial<cmd_ts_dist_cjs_helpdoc_js0.Versioned & cmd_ts_dist_cjs_helpdoc_js0.Descriptive & cmd_ts_dist_cjs_helpdoc_js0.Aliased>;
+} & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned & import("cmd-ts/dist/cjs/helpdoc.js").Descriptive & import("cmd-ts/dist/cjs/helpdoc.js").Aliased>;
 //#endregion
 //#region processors/constants.d.ts
 declare const PROCESSOR_APPS: readonly ["connect", "switchboard"];
@@ -79,7 +76,8 @@ type PHDocumentSignatureInfo = {
   /**
    * The public key of the document creator.
    **/
-  publicKey: JsonWebKey; /** The nonce that was appended to the message to create the signature. */
+  publicKey: JsonWebKey;
+  /** The nonce that was appended to the message to create the signature. */
   nonce: string;
 };
 /** Joins a signature's params for transport. Already-joined input passes through. */
@@ -96,11 +94,200 @@ declare function deserializeSignature(signature: Signature | string): Signature;
  * Configuration for hashing document state in operations.
  */
 type HashConfig = {
-  /** The hashing algorithm to use (e.g., "sha1", "sha256") */algorithm: string; /** The encoding format for the hash output (e.g., "base64", "hex") */
-  encoding: string; /** Optional algorithm-specific parameters */
+  /** The hashing algorithm to use (e.g., "sha1", "sha256") */
+  algorithm: string;
+  /** The encoding format for the hash output (e.g., "base64", "hex") */
+  encoding: string;
+  /** Optional algorithm-specific parameters */
   params?: Record<string, unknown>;
 };
 //#endregion
+//#region document-model/operations.d.ts
+declare function setNameOperation<TDocument extends PHDocument>(document: TDocument, input: {
+  name: string;
+}): TDocument & {
+  header: {
+    name: string;
+    id: string;
+    sig: PHDocumentSignatureInfo;
+    documentType: string;
+    createdAtUtcIso: string;
+    slug: string;
+    branch: string;
+    revision: {
+      [scope: string]: number;
+    };
+    lastModifiedAtUtcIso: string;
+    protocolVersions?: {
+      [key: string]: number;
+    };
+    meta?: PHDocumentMeta;
+  };
+};
+declare function setPreferredEditorOperation<TDocument extends PHDocument>(document: TDocument, input: {
+  preferredEditor: string | null;
+}): TDocument;
+declare function undoOperation<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
+  document: TDocument;
+  action: Action;
+  skip: number;
+  reuseLastOperationIndex: boolean;
+};
+/**
+ * V2 of undoOperation for protocol version 2+.
+ * Key differences from undoOperation:
+ * - Never reuses operation index (always increments)
+ * - Always sets skip=1 (consecutive NOOPs are handled during rebuild/GC)
+ * - No complex skip calculation - simpler model where each UNDO is independent
+ */
+declare function undoOperationV2<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
+  document: TDocument;
+  action: Action;
+  skip: number;
+  reuseLastOperationIndex: false;
+};
+declare function redoOperation<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
+  document: TDocument;
+  action: Action;
+  skip: number;
+  reuseLastOperationIndex: boolean;
+};
+/**
+ * An operation that was applied to a {@link BaseDocument}.
+ *
+ * @remarks
+ * Wraps an action with an index, to be added to the operations history of a Document.
+ * The `index` field is used to keep all operations in order and enable replaying the
+ * document's history from the beginning. Note that indices and skips are relative to
+ * a specific reactor. Example below:
+ *
+ * For (index, skip, ts, action)
+ * A - [(0, 0, 1, "A0"), (1, 0, 2, "A1")]
+ * B - [(0, 0, 0, "B0"), (1, 0, 3, "B1")]
+ * ...
+ * B gets A's Operations Scenario:
+ * B' - [(0, 0, 0, "B0"), (1, 0, 3, "B1"), (2, 1, 1, "A0"), (3, 0, 2, "A1"), (4, 0, 3, "B1")]
+ * Then A needs to end up with:
+ * A' - [(0, 0, 1, "A0"), (1, 0, 2, "A1"), (2, 2, 0, "B0"), (3, 0, 1, "A0"), (4, 0, 2, "A1"), (5, 0, 3, "B1")]
+ * So that both A and B end up with the stream of actions (action):
+ * [("B0"), ("A0"), ("A1"), ("B1")]
+ *
+ * @typeParam A - The type of the action.
+ */
+type Operation = {
+  /**
+   * This is a stable id, derived from various document and action properties
+   * in deriveOperationId().
+   *
+   * It _cannot_ be an arbitrary string.
+   *
+   * It it also not unique per operation, as reshuffled operations will keep'
+   * the same id they had before they were reshuffled. This means that the
+   * IOperationStore may have multiple operations with the same operation id.
+   **/
+  id: string;
+  /** Position of the operation in the history. This is relative to a specific reactor -- they may not all agree on this value. */
+  index: number;
+  /** The number of operations skipped with this Operation. This is relative to a specific reactor -- they may not all agree on this value. */
+  skip: number;
+  /** Timestamp of when the operation was added */
+  timestampUtcMs: string;
+  /** Hash of the resulting document data after the operation */
+  hash: string;
+  /** Error message for a failed action */
+  error?: string;
+  /**
+   * If authorization rejected the action, this records the reason why.
+   */
+  deniedReason?: string;
+  /** The resulting state after the operation */
+  resultingState?: string;
+  /**
+   * The action that was applied to the document to produce this operation.
+   */
+  action: Action;
+};
+/**
+ * The operations history of the document by scope.
+ *
+ * This will be removed in a future release.
+ *
+ * TODO: Type should be Partial<Record<string, Operation[]>>,
+ * but that is a breaking change for codegen + external doc models.
+ */
+type DocumentOperations = Record<string, Operation[]>;
+/**
+ * What happened to an operation. An operation that is not `applied` still
+ * occupies its index but contributes nothing to the document's state.
+ */
+type OperationOutcome = {
+  kind: "applied";
+} | {
+  kind: "reducer-error";
+  message: string;
+} | {
+  kind: "denied";
+  reason: string;
+};
+/**
+ * Reads an operation's outcome. A denial takes precedence over a reducer
+ * error, since a denied operation never reaches its reducer.
+ */
+declare function operationOutcome(operation: Operation): OperationOutcome;
+type OperationContext = {
+  documentId: string;
+  documentType: string;
+  scope: string;
+  branch: string;
+  resultingState?: string;
+  ordinal: number;
+};
+type OperationWithContext$1 = {
+  operation: Operation;
+  context: OperationContext;
+};
+//#endregion
+//#region document-model/signature-policy.d.ts
+/** The `protocolVersions` key that fixes a document's signature requirement. */
+declare const SIGNATURE_PROTOCOL = "signature";
+/** `protocolVersions.signature` of a document that requires v2 tuples. */
+declare const SIGNATURE_PROTOCOL_V2 = 2;
+/** `v2-required`: v2 tuples only and a content-addressed id. */
+type SignaturePolicy$1 = "legacy" | "v2-required";
+/** What a new document is created as unless the caller or host says otherwise. */
+declare const DEFAULT_SIGNATURE_POLICY: SignaturePolicy$1;
+declare function isSignaturePolicy(value: unknown): value is SignaturePolicy$1;
+type ProtocolVersions = {
+  [protocol: string]: number;
+};
+/** Read from a header, a CREATE_DOCUMENT input or a bare map. */
+declare function signaturePolicyOf(source: {
+  protocolVersions?: ProtocolVersions | null;
+} | ProtocolVersions | null | undefined): SignaturePolicy$1;
+/** `protocolVersions` for a new v2-required document. */
+declare function v2RequiredProtocolVersions(base?: ProtocolVersions): ProtocolVersions;
+/**
+ * The policy a create call asks for: `signaturePolicy`, else the `signature`
+ * key of its `protocolVersions`, else `fallback`, the host's default.
+ */
+declare function requestedSignaturePolicy(request: {
+  signaturePolicy?: SignaturePolicy$1;
+  protocolVersions?: ProtocolVersions;
+} | undefined, fallback: SignaturePolicy$1): SignaturePolicy$1;
+/** `protocolVersions` for a new document under `policy`, over `base`. */
+declare function protocolVersionsFor(policy: SignaturePolicy$1, base?: ProtocolVersions): ProtocolVersions;
+/** What the id of a v2-required document is a hash of. */
+type DocumentIdParams = {
+  documentType: string;
+  createdAtUtcIso: string;
+  nonce: string;
+  protocolVersions: ProtocolVersions;
+};
+/** `base64url(sha256(canonicalJson(params)))`, unpadded. */
+declare function deriveDocumentId(params: DocumentIdParams): string;
+/** Whether `id` has the shape `deriveDocumentId` produces. */
+declare function isDerivedDocumentId(id: string): boolean;
+//#endregion
 //#region document-model/state.d.ts
 /**
  * Creates a default PHAuthState
@@ -140,11 +327,16 @@ type PHDocumentState = {
    * with the UPGRADE_DOCUMENT operation to specify the DocumentModelModule
    * version to use for reducer execution.
    */
-  version: number; /** Hash configuration for operation state verification */
-  hash: HashConfig; /** True if and only if the document has been deleted */
-  isDeleted?: boolean; /** The timestamp when the document was deleted, in UTC ISO format */
-  deletedAtUtcIso?: string; /** Optional: who deleted the document */
-  deletedBy?: string; /** Optional: reason for deletion */
+  version: number;
+  /** Hash configuration for operation state verification */
+  hash: HashConfig;
+  /** True if and only if the document has been deleted */
+  isDeleted?: boolean;
+  /** The timestamp when the document was deleted, in UTC ISO format */
+  deletedAtUtcIso?: string;
+  /** Optional: who deleted the document */
+  deletedBy?: string;
+  /** Optional: reason for deletion */
   deletionReason?: string;
 };
 /**
@@ -167,7 +359,8 @@ type PHAuthState = {
   creator?: string;
 };
 type Grant = {
-  /** Stable id. */id: string;
+  /** Stable id. */
+  id: string;
   description: string;
   effect: "allow" | "deny";
   principal: Principal;
@@ -252,7 +445,9 @@ type Operand = {
  * The base state of the document.
  */
 type PHBaseState = {
-  /** Carries authentication information. */auth: PHAuthState; /** Carries information about the document. */
+  /** Carries authentication information. */
+  auth: PHAuthState;
+  /** Carries information about the document. */
   document: PHDocumentState;
 };
 declare function defaultGlobalState(): DocumentModelGlobalState;
@@ -262,183 +457,47 @@ declare function createGlobalState(state?: Partial<DocumentModelGlobalState>): D
 declare function createLocalState(state?: Partial<DocumentModelLocalState>): DocumentModelLocalState;
 declare function createState(baseState?: Partial<PHBaseState>, globalState?: Partial<DocumentModelGlobalState>, localState?: Partial<DocumentModelLocalState>): DocumentModelPHState;
 //#endregion
-//#region document-model/operations.d.ts
-declare function setNameOperation<TDocument extends PHDocument>(document: TDocument, input: {
-  name: string;
-}): TDocument & {
-  header: {
-    name: string;
-    id: string;
-    sig: PHDocumentSignatureInfo;
-    documentType: string;
-    createdAtUtcIso: string;
-    slug: string;
-    branch: string;
-    revision: {
-      [scope: string]: number;
-    };
-    lastModifiedAtUtcIso: string;
-    protocolVersions?: {
-      [key: string]: number;
-    };
-    meta?: PHDocumentMeta;
-  };
-};
-declare function setPreferredEditorOperation<TDocument extends PHDocument>(document: TDocument, input: {
-  preferredEditor: string | null;
-}): TDocument;
-declare function undoOperation<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
-  document: TDocument;
-  action: Action;
-  skip: number;
-  reuseLastOperationIndex: boolean;
-};
-/**
- * V2 of undoOperation for protocol version 2+.
- * Key differences from undoOperation:
- * - Never reuses operation index (always increments)
- * - Always sets skip=1 (consecutive NOOPs are handled during rebuild/GC)
- * - No complex skip calculation - simpler model where each UNDO is independent
- */
-declare function undoOperationV2<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
-  document: TDocument;
-  action: Action;
-  skip: number;
-  reuseLastOperationIndex: false;
-};
-declare function redoOperation<TDocument extends PHDocument>(document: TDocument, action: Action, skip: number): {
-  document: TDocument;
-  action: Action;
-  skip: number;
-  reuseLastOperationIndex: boolean;
+//#region document-model/documents.d.ts
+/** Meta information about the document. */
+type PHDocumentMeta = {
+  /** The preferred editor for the document. */
+  preferredEditor?: string;
 };
-declare function loadStateOperation<TState extends PHBaseState>(document: PHDocument<TState>, action: LoadStateActionInput): PHDocument<TState>;
 /**
- * An operation that was applied to a {@link BaseDocument}.
- *
- * @remarks
- * Wraps an action with an index, to be added to the operations history of a Document.
- * The `index` field is used to keep all operations in order and enable replaying the
- * document's history from the beginning. Note that indices and skips are relative to
- * a specific reactor. Example below:
- *
- * For (index, skip, ts, action)
- * A - [(0, 0, 1, "A0"), (1, 0, 2, "A1")]
- * B - [(0, 0, 0, "B0"), (1, 0, 3, "B1")]
- * ...
- * B gets A's Operations Scenario:
- * B' - [(0, 0, 0, "B0"), (1, 0, 3, "B1"), (2, 1, 1, "A0"), (3, 0, 2, "A1"), (4, 0, 3, "B1")]
- * Then A needs to end up with:
- * A' - [(0, 0, 1, "A0"), (1, 0, 2, "A1"), (2, 2, 0, "B0"), (3, 0, 1, "A0"), (4, 0, 2, "A1"), (5, 0, 3, "B1")]
- * So that both A and B end up with the stream of actions (action):
- * [("B0"), ("A0"), ("A1"), ("B1")]
- *
- * @typeParam A - The type of the action.
+ * The header of a document.
  */
-type Operation = {
+type PHDocumentHeader = {
   /**
-   * This is a stable id, derived from various document and action properties
-   * in deriveOperationId().
+   * The id of the document.
    *
-   * It _cannot_ be an arbitrary string.
+   * This is a Ed25519 signature and is immutable.
+   **/
+  id: string;
+  /**
+   * Information to verify the document creator.
    *
-   * It it also not unique per operation, as reshuffled operations will keep'
-   * the same id they had before they were reshuffled. This means that the
-   * IOperationStore may have multiple operations with the same operation id.
+   * This is immutable.
    **/
-  id: string; /** Position of the operation in the history. This is relative to a specific reactor -- they may not all agree on this value. */
-  index: number; /** The number of operations skipped with this Operation. This is relative to a specific reactor -- they may not all agree on this value. */
-  skip: number; /** Timestamp of when the operation was added */
-  timestampUtcMs: string; /** Hash of the resulting document data after the operation */
-  hash: string; /** Error message for a failed action */
-  error?: string;
+  sig: PHDocumentSignatureInfo;
   /**
-   * If authorization rejected the action, this records the reason why.
-   */
-  deniedReason?: string; /** The resulting state after the operation */
-  resultingState?: string;
-  /**
-   * The action that was applied to the document to produce this operation.
-   */
-  action: Action;
-};
-/**
- * The operations history of the document by scope.
- *
- * This will be removed in a future release.
- *
- * TODO: Type should be Partial<Record<string, Operation[]>>,
- * but that is a breaking change for codegen + external doc models.
- */
-type DocumentOperations = Record<string, Operation[]>;
-/**
- * What happened to an operation. An operation that is not `applied` still
- * occupies its index but contributes nothing to the document's state.
- */
-type OperationOutcome = {
-  kind: "applied";
-} | {
-  kind: "reducer-error";
-  message: string;
-} | {
-  kind: "denied";
-  reason: string;
-};
-/**
- * Reads an operation's outcome. A denial takes precedence over a reducer
- * error, since a denied operation never reaches its reducer.
- */
-declare function operationOutcome(operation: Operation): OperationOutcome;
-type OperationContext = {
-  documentId: string;
-  documentType: string;
-  scope: string;
-  branch: string;
-  resultingState?: string;
-  ordinal: number;
-};
-type OperationWithContext$1 = {
-  operation: Operation;
-  context: OperationContext;
-};
-//#endregion
-//#region document-model/documents.d.ts
-/** Meta information about the document. */
-type PHDocumentMeta = {
-  /** The preferred editor for the document. */preferredEditor?: string;
-};
-/**
- * The header of a document.
- */
-type PHDocumentHeader = {
-  /**
-   * The id of the document.
-   *
-   * This is a Ed25519 signature and is immutable.
-   **/
-  id: string;
-  /**
-   * Information to verify the document creator.
-   *
-   * This is immutable.
-   **/
-  sig: PHDocumentSignatureInfo;
-  /**
-   * The type of the document.
-   *
-   * This is used as part of the signature payload and thus, cannot be changed
-   * after the document header has been created.
-   **/
-  documentType: string;
+   * The type of the document.
+   *
+   * This is used as part of the signature payload and thus, cannot be changed
+   * after the document header has been created.
+   **/
+  documentType: string;
   /**
    * The timestamp of the creation date of the document, in UTC ISO format.
    *
    * This is used as part of the signature payload and thus, cannot be changed
    * after the document header has been created.
    **/
-  createdAtUtcIso: string; /** The slug of the document. */
-  slug: string; /** The name of the document. */
-  name: string; /** The branch of this document. */
+  createdAtUtcIso: string;
+  /** The slug of the document. */
+  slug: string;
+  /** The name of the document. */
+  name: string;
+  /** The branch of this document. */
   branch: string;
   /**
    * The revision of each scope of the document. This object is updated every
@@ -461,7 +520,8 @@ type PHDocumentHeader = {
    */
   protocolVersions?: {
     [key: string]: number;
-  }; /** Meta information about the document. */
+  };
+  /** Meta information about the document. */
   meta?: PHDocumentMeta;
 };
 /**
@@ -473,7 +533,9 @@ type PHDocumentHeader = {
  * @typeParam TState - The type of the document state.
  */
 type PHDocument<TState extends PHBaseState = PHBaseState> = {
-  /** The header of the document. */header: PHDocumentHeader; /** The document model specific state. */
+  /** The header of the document. */
+  header: PHDocumentHeader;
+  /** The document model specific state. */
   state: TState;
   /**
    * The initial state of the document, enabling replaying operations.
@@ -504,9 +566,23 @@ declare function isUndo(action: Action): action is UndoAction;
 declare function isDocumentAction(action: Action): action is DocumentAction;
 /**
  * Creates a new document. When `documentType` is given the header is stamped
- * with it and the document-scope operations are seeded.
+ * with it and the document-scope operations are seeded. Without
+ * `protocolVersions` the document is v2-required and takes a derived id; with
+ * them it is v2-required only if they say so (see {@link protocolVersionsFor}).
+ */
+declare function baseCreateDocument<TState extends PHBaseState = PHBaseState>(createState: CreateState<TState>, initialState?: Partial<TState>, documentType?: string, protocolVersions?: ProtocolVersions): PHDocument<TState>;
+/**
+ * `document`, not yet created, under a fresh header for `policy`. A legacy
+ * header takes `id` when given; a v2-required one ignores `id` and derives its
+ * own, so a caller that needs a fixed id must ask for legacy.
+ * `protocolVersions` are merged over the document's. Name, slug, branch and
+ * meta carry over. A document already under `policy` is returned as is unless
+ * a legacy `id` or `protocolVersions` are given.
  */
-declare function baseCreateDocument<TState extends PHBaseState = PHBaseState>(createState: CreateState<TState>, initialState?: Partial<TState>, documentType?: string): PHDocument<TState>;
+declare function withSignaturePolicy<TDocument extends PHDocument>(document: TDocument, policy: SignaturePolicy$1, options?: {
+  id?: string;
+  protocolVersions?: ProtocolVersions;
+}): TDocument;
 declare function hashDocumentStateForScope(document: {
   state: {
     [key: string]: unknown;
@@ -670,31 +746,6 @@ declare const undo: (count?: number, scope?: string) => UndoAction;
  * @category Actions
  */
 declare const redo: (count?: number, scope?: string) => RedoAction;
-/**
- * Joins multiple operations into a single {@link loadState | LOAD_STATE} operation.
- *
- * @remarks
- * Useful to keep operations history smaller. Operations to prune are selected by index,
- * similar to the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | slice} method in Arrays.
- *
- * @param start - Index of the first operation to prune
- * @param end - Index of the last operation to prune
- * @category Actions
- */
-declare const prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
-/**
- * Replaces the state of the document.
- *
- * @remarks
- * This action shouldn't be used directly. It is dispatched by the {@link prune} action.
- *
- * @param state - State to be set in the document.
- * @param operations - Number of operations that were removed from the previous state.
- * @category Actions
- */
-declare const loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
-  name: string;
-}, operations: number) => LoadStateAction;
 declare const noop: (scope?: string) => NOOPAction;
 /**
  * Helper function to be used by action creators.
@@ -730,7 +781,9 @@ declare const operationWithContext: (operation: Operation, context: ActionContex
 declare const actionContext: () => ActionContext;
 declare const actionSigner: (user: UserActionSigner, app: AppActionSigner, signatures?: Signature[]) => ActionSigner;
 declare function buildOperationSignature(context: ActionSignatureContext, signMethod: ActionSigningHandler): Promise<Signature>;
+/** @deprecated Emits a legacy SHA-1 tuple; sign through `ISigner.signAction`. */
 declare function buildSignedAction<TState extends PHBaseState = PHBaseState>(action: Action, reducer: Reducer<TState>, document: PHDocument<TState>, signer: ActionSigner, signHandler: ActionSigningHandler): Promise<Operation>;
+/** @deprecated Use `verifyActionSignature` from `@powerhousedao/reactor`. */
 declare function verifyOperationSignature(signature: Signature, signer: Omit<ActionSigner, "signatures">, verifyHandler: ActionVerificationHandler): Promise<boolean>;
 /**
  * Changes the name of the document.
@@ -784,10 +837,10 @@ declare const updateOperationExample: (input: UpdateOperationExampleInput) => Up
 declare const deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
 declare const reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
 declare const operationExampleCreators: {
-  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
-  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
-  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
-  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
+  addOperationExample: typeof addOperationExample;
+  updateOperationExample: typeof updateOperationExample;
+  deleteOperationExample: typeof deleteOperationExample;
+  reorderOperationExamples: typeof reorderOperationExamples;
 };
 declare const setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
 declare const setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
@@ -801,531 +854,1115 @@ declare const deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteCh
 declare const reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
 declare const releaseNewVersion: () => ReleaseNewVersionAction;
 declare const baseActions: {
-  setName: (name: string | {
-    name: string;
-  }) => SetNameAction;
-  setPreferredEditor: (input: string | null | {
-    preferredEditor: string | null;
-  }) => SetPreferredEditorAction;
-  undo: (count?: number, scope?: string) => UndoAction;
-  redo: (count?: number, scope?: string) => RedoAction;
-  prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
-  loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
-    name: string;
-  }, operations: number) => LoadStateAction;
-  noop: (scope?: string) => NOOPAction;
+  setName: typeof setName;
+  setPreferredEditor: typeof setPreferredEditor;
+  undo: typeof undo;
+  redo: typeof redo;
+  noop: typeof noop;
 };
 declare const documentModelActions: {
-  setModelName: (input: SetModelNameInput) => SetModelNameAction;
-  setModelId: (input: SetModelIdInput) => SetModelIdAction;
-  setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
-  setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
-  setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
-  setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;
-  addModule: (input: AddModuleInput) => AddModuleAction;
-  setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
-  setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
-  deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
-  reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;
-  addOperation: (input: AddOperationInput) => AddOperationAction;
-  setOperationName: (input: SetOperationNameInput) => SetOperationNameAction;
-  setOperationScope: (input: SetOperationScopeInput) => SetOperationScopeAction;
-  setOperationSchema: (input: SetOperationSchemaInput) => SetOperationSchemaAction;
-  setOperationDescription: (input: SetOperationDescriptionInput) => SetOperationDescriptionAction;
-  setOperationTemplate: (input: SetOperationTemplateInput) => SetOperationTemplateAction;
-  setOperationReducer: (input: SetOperationReducerInput) => SetOperationReducerAction;
-  moveOperation: (input: MoveOperationInput) => MoveOperationAction;
-  deleteOperation: (input: DeleteOperationInput) => DeleteOperationAction;
-  reorderModuleOperations: (input: ReorderModuleOperationsInput) => ReorderModuleOperationsAction;
-  addOperationError: (input: AddOperationErrorInput) => AddOperationErrorAction;
-  setOperationErrorCode: (input: SetOperationErrorCodeInput) => SetOperationErrorCodeAction;
-  setOperationErrorName: (input: SetOperationErrorNameInput) => SetOperationErrorNameAction;
-  setOperationErrorDescription: (input: SetOperationErrorDescriptionInput) => SetOperationErrorDescriptionAction;
-  setOperationErrorTemplate: (input: SetOperationErrorTemplateInput) => SetOperationErrorTemplateAction;
-  deleteOperationError: (input: DeleteOperationErrorInput) => DeleteOperationErrorAction;
-  reorderOperationErrors: (input: ReorderOperationErrorsInput) => ReorderOperationErrorsAction;
-  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
-  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
-  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
-  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
-  setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
-  setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
-  addStateExample: (input: AddStateExampleInput) => AddStateExampleAction;
-  updateStateExample: (input: UpdateStateExampleInput) => UpdateStateExampleAction;
-  deleteStateExample: (input: DeleteStateExampleInput) => DeleteStateExampleAction;
-  reorderStateExamples: (input: ReorderStateExamplesInput) => ReorderStateExamplesAction;
-  addChangeLogItem: (input: AddChangeLogItemInput) => AddChangeLogItemAction;
-  updateChangeLogItem: (input: UpdateChangeLogItemInput) => UpdateChangeLogItemAction;
-  deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteChangeLogItemAction;
-  reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
-  releaseNewVersion: () => ReleaseNewVersionAction;
+  setModelName: typeof setModelName;
+  setModelId: typeof setModelId;
+  setModelExtension: typeof setModelExtension;
+  setModelDescription: typeof setModelDescription;
+  setAuthorName: typeof setAuthorName;
+  setAuthorWebsite: typeof setAuthorWebsite;
+  addModule: typeof addModule;
+  setModuleName: typeof setModuleName;
+  setModuleDescription: typeof setModuleDescription;
+  deleteModule: typeof deleteModule;
+  reorderModules: typeof reorderModules;
+  addOperation: typeof addOperation;
+  setOperationName: typeof setOperationName;
+  setOperationScope: typeof setOperationScope;
+  setOperationSchema: typeof setOperationSchema;
+  setOperationDescription: typeof setOperationDescription;
+  setOperationTemplate: typeof setOperationTemplate;
+  setOperationReducer: typeof setOperationReducer;
+  moveOperation: typeof moveOperation;
+  deleteOperation: typeof deleteOperation;
+  reorderModuleOperations: typeof reorderModuleOperations;
+  addOperationError: typeof addOperationError;
+  setOperationErrorCode: typeof setOperationErrorCode;
+  setOperationErrorName: typeof setOperationErrorName;
+  setOperationErrorDescription: typeof setOperationErrorDescription;
+  setOperationErrorTemplate: typeof setOperationErrorTemplate;
+  deleteOperationError: typeof deleteOperationError;
+  reorderOperationErrors: typeof reorderOperationErrors;
+  addOperationExample: typeof addOperationExample;
+  updateOperationExample: typeof updateOperationExample;
+  deleteOperationExample: typeof deleteOperationExample;
+  reorderOperationExamples: typeof reorderOperationExamples;
+  setStateSchema: typeof setStateSchema;
+  setInitialState: typeof setInitialState;
+  addStateExample: typeof addStateExample;
+  updateStateExample: typeof updateStateExample;
+  deleteStateExample: typeof deleteStateExample;
+  reorderStateExamples: typeof reorderStateExamples;
+  addChangeLogItem: typeof addChangeLogItem;
+  updateChangeLogItem: typeof updateChangeLogItem;
+  deleteChangeLogItem: typeof deleteChangeLogItem;
+  reorderChangeLogItems: typeof reorderChangeLogItems;
+  releaseNewVersion: typeof releaseNewVersion;
 };
 declare const actions: {
-  setModelName: (input: SetModelNameInput) => SetModelNameAction;
-  setModelId: (input: SetModelIdInput) => SetModelIdAction;
-  setModelExtension: (input: SetModelExtensionInput) => SetModelExtensionAction;
-  setModelDescription: (input: SetModelDescriptionInput) => SetModelDescriptionAction;
-  setAuthorName: (input: SetAuthorNameInput) => SetAuthorNameAction;
-  setAuthorWebsite: (input: SetAuthorWebsiteInput) => SetAuthorWebsiteAction;
-  addModule: (input: AddModuleInput) => AddModuleAction;
-  setModuleName: (input: SetModuleNameInput) => SetModuleNameAction;
-  setModuleDescription: (input: SetModuleDescriptionInput) => SetModuleDescriptionAction;
-  deleteModule: (input: DeleteModuleInput) => DeleteModuleAction;
-  reorderModules: (input: ReorderModulesInput) => ReorderModulesAction;
-  addOperation: (input: AddOperationInput) => AddOperationAction;
-  setOperationName: (input: SetOperationNameInput) => SetOperationNameAction;
-  setOperationScope: (input: SetOperationScopeInput) => SetOperationScopeAction;
-  setOperationSchema: (input: SetOperationSchemaInput) => SetOperationSchemaAction;
-  setOperationDescription: (input: SetOperationDescriptionInput) => SetOperationDescriptionAction;
-  setOperationTemplate: (input: SetOperationTemplateInput) => SetOperationTemplateAction;
-  setOperationReducer: (input: SetOperationReducerInput) => SetOperationReducerAction;
-  moveOperation: (input: MoveOperationInput) => MoveOperationAction;
-  deleteOperation: (input: DeleteOperationInput) => DeleteOperationAction;
-  reorderModuleOperations: (input: ReorderModuleOperationsInput) => ReorderModuleOperationsAction;
-  addOperationError: (input: AddOperationErrorInput) => AddOperationErrorAction;
-  setOperationErrorCode: (input: SetOperationErrorCodeInput) => SetOperationErrorCodeAction;
-  setOperationErrorName: (input: SetOperationErrorNameInput) => SetOperationErrorNameAction;
-  setOperationErrorDescription: (input: SetOperationErrorDescriptionInput) => SetOperationErrorDescriptionAction;
-  setOperationErrorTemplate: (input: SetOperationErrorTemplateInput) => SetOperationErrorTemplateAction;
-  deleteOperationError: (input: DeleteOperationErrorInput) => DeleteOperationErrorAction;
-  reorderOperationErrors: (input: ReorderOperationErrorsInput) => ReorderOperationErrorsAction;
-  addOperationExample: (input: AddOperationExampleInput) => AddOperationExampleAction;
-  updateOperationExample: (input: UpdateOperationExampleInput) => UpdateOperationExampleAction;
-  deleteOperationExample: (input: DeleteOperationExampleInput) => DeleteOperationExampleAction;
-  reorderOperationExamples: (input: ReorderOperationExamplesInput) => ReorderOperationExamplesAction;
-  setStateSchema: (input: SetStateSchemaInput) => SetStateSchemaAction;
-  setInitialState: (input: SetInitialStateInput) => SetInitialStateAction;
-  addStateExample: (input: AddStateExampleInput) => AddStateExampleAction;
-  updateStateExample: (input: UpdateStateExampleInput) => UpdateStateExampleAction;
-  deleteStateExample: (input: DeleteStateExampleInput) => DeleteStateExampleAction;
-  reorderStateExamples: (input: ReorderStateExamplesInput) => ReorderStateExamplesAction;
-  addChangeLogItem: (input: AddChangeLogItemInput) => AddChangeLogItemAction;
-  updateChangeLogItem: (input: UpdateChangeLogItemInput) => UpdateChangeLogItemAction;
-  deleteChangeLogItem: (input: DeleteChangeLogItemInput) => DeleteChangeLogItemAction;
-  reorderChangeLogItems: (input: ReorderChangeLogItemsInput) => ReorderChangeLogItemsAction;
-  releaseNewVersion: () => ReleaseNewVersionAction;
-  setName: (name: string | {
-    name: string;
-  }) => SetNameAction;
-  setPreferredEditor: (input: string | null | {
-    preferredEditor: string | null;
-  }) => SetPreferredEditorAction;
-  undo: (count?: number, scope?: string) => UndoAction;
-  redo: (count?: number, scope?: string) => RedoAction;
-  prune: (start?: number, end?: number, scope?: string) => SchemaPruneAction;
-  loadState: <TState extends PHBaseState = PHBaseState>(state: TState & {
-    name: string;
-  }, operations: number) => LoadStateAction;
-  noop: (scope?: string) => NOOPAction;
+  setName: typeof setName;
+  setPreferredEditor: typeof setPreferredEditor;
+  undo: typeof undo;
+  redo: typeof redo;
+  noop: typeof noop;
+  setModelName: typeof setModelName;
+  setModelId: typeof setModelId;
+  setModelExtension: typeof setModelExtension;
+  setModelDescription: typeof setModelDescription;
+  setAuthorName: typeof setAuthorName;
+  setAuthorWebsite: typeof setAuthorWebsite;
+  addModule: typeof addModule;
+  setModuleName: typeof setModuleName;
+  setModuleDescription: typeof setModuleDescription;
+  deleteModule: typeof deleteModule;
+  reorderModules: typeof reorderModules;
+  addOperation: typeof addOperation;
+  setOperationName: typeof setOperationName;
+  setOperationScope: typeof setOperationScope;
+  setOperationSchema: typeof setOperationSchema;
+  setOperationDescription: typeof setOperationDescription;
+  setOperationTemplate: typeof setOperationTemplate;
+  setOperationReducer: typeof setOperationReducer;
+  moveOperation: typeof moveOperation;
+  deleteOperation: typeof deleteOperation;
+  reorderModuleOperations: typeof reorderModuleOperations;
+  addOperationError: typeof addOperationError;
+  setOperationErrorCode: typeof setOperationErrorCode;
+  setOperationErrorName: typeof setOperationErrorName;
+  setOperationErrorDescription: typeof setOperationErrorDescription;
+  setOperationErrorTemplate: typeof setOperationErrorTemplate;
+  deleteOperationError: typeof deleteOperationError;
+  reorderOperationErrors: typeof reorderOperationErrors;
+  addOperationExample: typeof addOperationExample;
+  updateOperationExample: typeof updateOperationExample;
+  deleteOperationExample: typeof deleteOperationExample;
+  reorderOperationExamples: typeof reorderOperationExamples;
+  setStateSchema: typeof setStateSchema;
+  setInitialState: typeof setInitialState;
+  addStateExample: typeof addStateExample;
+  updateStateExample: typeof updateStateExample;
+  deleteStateExample: typeof deleteStateExample;
+  reorderStateExamples: typeof reorderStateExamples;
+  addChangeLogItem: typeof addChangeLogItem;
+  updateChangeLogItem: typeof updateChangeLogItem;
+  deleteChangeLogItem: typeof deleteChangeLogItem;
+  reorderChangeLogItems: typeof reorderChangeLogItems;
+  releaseNewVersion: typeof releaseNewVersion;
 };
 /**
  * The context of an action.
  */
 type ActionContext = {
-  /** The index of the previous operation, showing intended ordering. */prevOpIndex?: number; /** The hash of the previous operation, showing intended state. */
-  prevOpHash?: string; /** A nonce, to cover specific signing attacks and to prevent replay attacks from no-ops. */
-  nonce?: string; /** The signer of the action. */
+  /** The index of the previous operation, showing intended ordering. */
+  prevOpIndex?: number;
+  /** The hash of the previous operation, showing intended state. */
+  prevOpHash?: string;
+  /** A nonce, to cover specific signing attacks and to prevent replay attacks from no-ops. */
+  nonce?: string;
+  /** The signer of the action. */
   signer?: ActionSigner;
 };
 /**
  * Defines the basic structure of an action.
  */
 type Action = {
-  /** The id of the action. This is distinct from the operation id. */id: string; /** The name of the action. */
-  type: string; /** The timestamp of the action. */
-  timestampUtcMs: string; /** The payload of the action. */
-  input: unknown; /** The scope of the action */
-  scope: string; /** The context of the action. */
+  /** The id of the action. This is distinct from the operation id. */
+  id: string;
+  /** The name of the action. */
+  type: string;
+  /** The timestamp of the action. */
+  timestampUtcMs: string;
+  /** The payload of the action. */
+  input: unknown;
+  /** The scope of the action */
+  scope: string;
+  /** The context of the action. */
   context?: ActionContext;
 };
 //#endregion
-//#region processors/http.d.ts
-/** Methods a package route may bind. OPTIONS belongs to the CORS layer. */
-type RouteMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
-interface RouteUser {
-  address: string;
-  chainId: number;
-  networkId: string;
-  appKey: string;
+//#region document-model/action-signature.d.ts
+declare const ACTION_SIGNATURE_V2_PREFIX = "v2:";
+/** The log an operation is stored in, which a v2 tuple is bound to. */
+type ActionSigningTarget = {
+  documentId: string;
+  branch: string;
+};
+/** Who a v2 tuple attributes the action to; both halves are in the preimage. */
+type ActionSignerIdentity = {
+  user: UserActionSigner;
+  app: AppActionSigner;
+};
+/** A value that would not survive a JSON store round trip unchanged. */
+declare class CanonicalJsonError extends Error {
+  constructor(path: string, detail: string);
 }
-type RouteActor = {
-  user: RouteUser | undefined;
-  authEnabled: boolean;
+/** Sorted-key JSON, as the state hash encodes; drops `undefined` properties. */
+declare function canonicalJson(value: unknown, label?: string): string;
+/** Actions the reactor reduces itself, onto the document scope. */
+declare const DOCUMENT_SCOPE_ACTION_TYPES: ReadonlySet<string>;
+/** Where a document-scope action writes: `sourceId` or `documentId`. */
+declare function targetDocumentId(action: {
+  type: string;
+  input: unknown;
+}, fallback: string): string;
+/** The log an action submitted to a job on `documentId` is stored in. */
+declare function actionSigningTarget(action: {
+  type: string;
+  input: unknown;
+}, documentId: string, branch: string): ActionSigningTarget;
+/** The identity a signer writes into `context.signer`, and signs over. */
+declare function actionSignerIdentity(signer: {
+  user?: UserActionSigner;
+  app?: AppActionSigner;
+}): ActionSignerIdentity;
+/** The v2 preimage; throws `CanonicalJsonError` on an unsignable action. */
+declare function actionPreimageV2(action: Action, target: ActionSigningTarget, signer: ActionSignerIdentity): string;
+/** `"v2:" + base64url(sha256(preimage))`, unpadded. */
+declare function hashActionV2(action: Action, target: ActionSigningTarget, signer: ActionSignerIdentity): Promise<string>;
+/** Signs `action` as a v2 tuple; the message layout is the legacy one. */
+declare function signActionV2(params: {
+  action: Action;
+  target: ActionSigningTarget;
+  signer: ActionSignerIdentity;
+  sign: ActionSigningHandler;
+  previousStateHash?: string;
+}): Promise<Signature>;
+/** Element [2] carries the v2 prefix, whether or not it is well formed. */
+declare function isV2ActionHash(hash: string): boolean;
+/** The strict shape of a v2 tuple, apart from what its hash covers. */
+declare function v2TupleProblem(tuple: Signature): string | undefined;
+//#endregion
+//#region document-model/action-transport.d.ts
+/**
+ * An action's signer, as the wire declares it: signatures joined into strings,
+ * because GraphQL declares them as a list of strings rather than of lists.
+ */
+type TransportSigner = {
+  user?: {
+    address: string;
+    networkId: string;
+    chainId: number;
+  };
+  app?: {
+    name: string;
+    key: string;
+  };
+  signatures: string[];
 };
-type AuthorizerResult = {
-  authorized: true;
-} /** Refused; the scope answers with its own JSON error envelope. */ | {
-  authorized: false;
-  status: number;
-  message: string;
+/** An action's context, as the wire declares it. */
+type TransportActionContext = {
+  prevOpIndex?: number;
+  prevOpHash?: string;
+  nonce?: string;
+  signer?: TransportSigner;
+};
+/** An action projected onto exactly the fields the wire declares. */
+type TransportAction = {
+  id: string;
+  type: string;
+  timestampUtcMs: string;
+  /**
+   * Non-nullable, because the wire declares it so. An action's own type says
+   * `unknown`, which admits the absent input an action creator called without
+   * one produces - {@link toTransportAction} refuses that rather than passing
+   * it on.
+   */
+  input: NonNullable<unknown>;
+  scope: string;
+  context?: TransportActionContext;
+};
+/**
+ * Projects an action onto the fields the GraphQL `ActionInput` declares.
+ *
+ * A projection rather than a spread, because an input object rejects a field it
+ * does not declare, and that refusal takes the whole request with it. An action
+ * read back out of storage can carry fields the type no longer has - a legacy
+ * `attachments` array, or the operation fields left behind by a signing helper
+ * that returns an operation - and any one of them would sink an otherwise valid
+ * submission.
+ *
+ * Only fields the action actually carries are emitted, so an unsigned action
+ * sends no context at all rather than a context full of nulls.
+ */
+declare function toTransportAction(action: Action): TransportAction;
+//#endregion
+//#region document-model/auth.d.ts
+type InitializeAuthActionInput = {
+  version: number;
+  grants: Grant[];
+};
+type SetGrantActionInput = {
+  grant: Grant;
+};
+type RemoveGrantActionInput = {
+  id: string;
+};
+type MoveGrantActionInput = {
+  id: string;
+  /** Target index in the grant list; clamped to the valid range. */
+  index: number;
+};
+type InitializeAuthAction = Action & {
+  type: "INITIALIZE_AUTH";
+  input: InitializeAuthActionInput;
+};
+type SetGrantAction = Action & {
+  type: "SET_GRANT";
+  input: SetGrantActionInput;
+};
+type RemoveGrantAction = Action & {
+  type: "REMOVE_GRANT";
+  input: RemoveGrantActionInput;
+};
+type MoveGrantAction = Action & {
+  type: "MOVE_GRANT";
+  input: MoveGrantActionInput;
+};
+type AuthAction = InitializeAuthAction | SetGrantAction | RemoveGrantAction | MoveGrantAction;
+declare const AUTH_ACTION_TYPES: readonly ["INITIALIZE_AUTH", "SET_GRANT", "REMOVE_GRANT", "MOVE_GRANT"];
+declare function isAuthAction(action: Action): action is AuthAction;
+/** Highest known policy version; decide() fails closed above it. */
+declare const MAX_SUPPORTED_AUTH_VERSION = 1;
+declare const InitializeAuthActionInputSchema: () => z.ZodObject<{
+  version: z.ZodNumber;
+  grants: z.ZodArray<z.ZodCustom<Grant, Grant>>;
+}, z.core.$strip>;
+declare const SetGrantActionInputSchema: () => z.ZodObject<{
+  grant: z.ZodCustom<Grant, Grant>;
+}, z.core.$strip>;
+declare const RemoveGrantActionInputSchema: () => z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+declare const MoveGrantActionInputSchema: () => z.ZodObject<{
+  id: z.ZodString;
+  index: z.ZodNumber;
+}, z.core.$strip>;
+declare const initializeAuth: (input: InitializeAuthActionInput) => InitializeAuthAction;
+declare const setGrant: (input: SetGrantActionInput) => SetGrantAction;
+declare const removeGrant: (input: RemoveGrantActionInput) => RemoveGrantAction;
+declare const moveGrant: (input: MoveGrantActionInput) => MoveGrantAction;
+/**
+ * True when `signerKey` (an ActionSigner app key, a did:key) identifies the same
+ * key recorded as the document creator. Returns false
+ * when there is no creator (empty JWK) or no signer key.
+ */
+declare function isDocumentCreator(creatorKey: JsonWebKey | undefined, signerKey: string | undefined): boolean;
+/**
+ * Sets the initial policy. Valid only while the auth scope is uninitialized
+ * (version 0). The input version is the policy language version and must be an
+ * integer >= 1; 0 is reserved for the uninitialized state. On a signed-header
+ * document it must be signed by the document creator (`header.sig.publicKey`).
+ * A creator-less policy must include a grant permitting execute on the auth
+ * scope, or it would be born locked out.
+ */
+declare function applyInitializeAuthAction<TState extends PHBaseState>(document: PHDocument<TState>, action: InitializeAuthAction): PHDocument<TState>;
+/** Upserts a grant by id: replaces in place if present, otherwise appends. */
+declare function applySetGrantAction<TState extends PHBaseState>(document: PHDocument<TState>, action: SetGrantAction): PHDocument<TState>;
+/**
+ * Removes a grant by id; throws if the id is not present or if the removal
+ * would leave a creator-less policy with no auth-administration grant.
+ */
+declare function applyRemoveGrantAction<TState extends PHBaseState>(document: PHDocument<TState>, action: RemoveGrantAction): PHDocument<TState>;
+/**
+ * Moves a grant by id to a new index. Order is load-bearing (the last
+ * applicable grant wins), so the relative order of the other grants is kept.
+ * The target index is clamped to the valid range; an unknown id throws.
+ *
+ * Order alone decides which grant wins, so a move can take administration away
+ * without changing the list's contents. It carries the same retention rule as
+ * the two mutation paths.
+ */
+declare function applyMoveGrantAction<TState extends PHBaseState>(document: PHDocument<TState>, action: MoveGrantAction): PHDocument<TState>;
+/**
+ * Dispatches an auth-scope action to its handler. This is the auth scope's
+ * dedicated reducer: it is applied by the base reducer instead of the model
+ * reducer, mirroring the document-scope platform handlers. Unknown types are a
+ * no-op, matching the model-reducer default.
+ */
+declare function applyAuthAction<TState extends PHBaseState>(document: PHDocument<TState>, action: Action): PHDocument<TState>;
+/**
+ * Because only creators can initialize auth scopes, we must verify that either
+ * the document has no auth or the version and creator match.
+ */
+declare function assertAuthPreservedOnDuplicate(documentId: string, source: PHAuthState | undefined, duplicated: PHAuthState | undefined): void;
+/**
+ * The auth scope a state snapshot may install, given the policy already there.
+ *
+ * `applyAuthAction` is the validated door onto `state.auth`, but a whole-state
+ * snapshot (UPGRADE_DOCUMENT's `initialState`) replaces the scope wholesale and
+ * is authorized as a `document`-scope write. Without this, a subject holding
+ * `execute` on `document` and no auth grant at all can install a policy of its
+ * choosing, name itself `creator` (which exempts the policy from the retention
+ * rule for good), or wipe an existing policy by carrying the default
+ * uninitialized one.
+ *
+ * Three cases:
+ *
+ *   - the snapshot carries no policy, or an uninitialized one: the document
+ *     keeps the policy it has, so a default-state upgrade cannot reset it;
+ *   - the document is uninitialized and the snapshot carries a policy: the
+ *     policy is installed after the same validation genesis applies, so it
+ *     cannot be born locked out;
+ *   - both carry a policy: they must agree. A duplicate preserves its source's
+ *     policy (see {@link assertAuthPreservedOnDuplicate}), and anything else is
+ *     an attempt to replace one policy with another.
+ */
+declare function resolveSnapshotAuth(documentId: string, documentType: string, current: PHAuthState | undefined, incoming: PHAuthState | undefined): PHAuthState;
+/** UNDO and REDO are rejected on the auth scope. */
+declare function assertAuthScopeActionAllowed(action: Action): void;
+type AuthVerb = "read" | "execute";
+type AuthRequest = {
+  verb: AuthVerb;
+  scope: string;
+  /** For execute: the operation (action type) being attempted. Omitted for reads. */
+  operation?: string;
+};
+type AuthSubject = {
+  /** Verified signer address; undefined for an anonymous subject. */
+  address?: string;
+  /** The signer's app key (a did:key), used to match the document creator. */
+  key?: string;
+};
+/**
+ * What condition attr paths resolve against, beyond the subject. Supplied
+ * only while authConditions enforcement is on: with no context a grant
+ * carrying `where` or a { match } principal never applies.
+ */
+type ConditionContext = {
+  /** The executing scope's own state, for `doc.<scope>.*` paths. */
+  scopeState: unknown;
+  /** The action's input, for `action.input.*` paths. Absent for reads. */
+  actionInput?: unknown;
+};
+type AuthDecision = "allow" | "deny";
+/** Why the policy refused a request. */
+type AuthRefusal = "version-unsupported" | "no-applicable-grant" | "denied-by-grant";
+/**
+ * A decision together with why it refused. A refusal names which of the
+ * policy's rules produced it, so an operation records the reason it was refused
+ * rather than one reason standing for every refusal.
+ */
+type AuthEvaluation = {
+  decision: "allow";
 } | {
-  authorized: false;
-  response: Response;
+  decision: "deny";
+  refusal: AuthRefusal;
+  grantId?: string;
 };
-/** A route-specific gate, for policies the standard modes cannot express. */
-type RouteAuthorizer = (req: IncomingMessage) => Promise<AuthorizerResult> | AuthorizerResult;
-/** How a route authenticates. */
-type RouteAuth = /** Default. A verifiable bearer is required; a caller without one gets 401. */"renown" | "renown-optional" | "public" | RouteAuthorizer;
-/** How the request body reaches the handler. */
-type RouteBody = /** Default. Buffered, and readable through the Fetch Request. */"parsed" /** Buffered and also handed over as `ctx.rawBody`, byte for byte. */ | "raw" /** Not buffered; the Fetch Request body is the live request stream. */ | "stream" /** The body is not read at all. */ | "none";
-interface RouteOptions {
-  auth?: RouteAuth;
-  body?: RouteBody;
-  /** Refuse a body larger than this with 413. Ignored when body is `stream`. */
-  maxBodyBytes?: number;
-  /** Serve sub-paths too, not just an exact match. */
-  prefix?: boolean;
-}
-/** Where the request reached the host, resolved through any reverse proxy. */
-interface RouteTransport {
-  proto: string;
-  host: string;
-  prefix: string;
-  baseUrl: string;
-}
-interface RouteContext {
-  /** Decoded path params. */
-  params: Record<string, string>;
-  user: RouteUser | undefined;
-  authEnabled: boolean;
-  /** The exact octets received. Present only when body is `raw`. */
-  rawBody: Buffer | undefined;
-  /** Aborts when the client disconnects. */
-  signal: AbortSignal;
-  transport: RouteTransport;
-}
-type RouteHandler = (request: Request, ctx: RouteContext) => Response | Promise<Response>;
-interface RouteSpec extends RouteOptions {
-  method: RouteMethod | RouteMethod[];
-  /** Relative to the scope: "runs/:id", never "/api/@scope/pkg/runs/:id". */
-  path: string;
-  handler: RouteHandler;
+/**
+ * Evaluates the auth policy for a single request and reports why it refused.
+ * Pure and deterministic.
+ *
+ * An uninitialized policy (version 0, absent auth state, or a legacy `{}`
+ * auth scope serialized before PHAuthState had a version) leaves the document
+ * open. Once a policy exists the default is deny, and grants stack in order.
+ *
+ * Group principals match only against a supplied groups map (the groups
+ * projection, present when authGroups is on); with no map they never apply.
+ * `where` clauses and { match } principals likewise evaluate only against a
+ * supplied condition context (present when authConditions is on).
+ */
+declare function evaluate(auth: PHAuthState | undefined, subject: AuthSubject, request: AuthRequest, groups?: AuthGroups, conditions?: ConditionContext): AuthEvaluation;
+/**
+ * Evaluates the auth policy for a single request. Pure and deterministic. This
+ * is {@link evaluate} with the reason dropped.
+ */
+declare function decide(auth: PHAuthState | undefined, subject: AuthSubject, request: AuthRequest, groups?: AuthGroups, conditions?: ConditionContext): AuthDecision;
+/**
+ * The group document ids a single auth action's input names with `{ group }`
+ * principals. INITIALIZE_AUTH contributes the groups named across its grants,
+ * SET_GRANT the groups named by its one grant; REMOVE_GRANT and MOVE_GRANT
+ * contribute nothing. Total over any input shape, because references are read
+ * from the input as it arrived, including inputs later stored as errors.
+ */
+declare function mentionedGroupIds(action: Action): string[];
+//#endregion
+//#region document-model/auth-v1.d.ts
+/** Maximum number of grants in a policy. */
+declare const MAX_AUTH_GRANTS = 100;
+/** Maximum nesting depth of a condition tree. */
+declare const MAX_CONDITION_DEPTH = 10;
+/** Maximum node count (conditions plus operands) of a condition tree. */
+declare const MAX_CONDITION_NODES = 100;
+/** Maximum entries in an execute capability's operation list. */
+declare const MAX_CAPABILITY_OPERATIONS = 100;
+/**
+ * Thrown when a grant violates the v1 validation rules. The message is stored
+ * on error operations, so it must be a pure function of the input.
+ */
+declare class InvalidGrantError extends Error {
+  readonly grantId: string;
+  constructor(grantId: string, problem: string);
 }
-interface NodeRouteSpec extends Omit<RouteOptions, "body" | "maxBodyBytes"> {
-  method: RouteMethod | RouteMethod[];
-  path: string;
-  handler: (req: IncomingMessage, res: ServerResponse, ctx: Omit<RouteContext, "rawBody" | "signal">) => void | Promise<void>;
+/** Thrown for a `{ group }` principal on a group document: references never chain. */
+declare class GroupPrincipalNotAllowedError extends Error {
+  readonly grantId: string;
+  constructor(grantId: string);
 }
-interface ScopedRouteHandle {
-  /** The absolute public URL this route answers on. */
-  readonly url: string;
-  dispose(): void;
+/**
+ * Thrown when a change would leave a creator-less policy with no grant
+ * permitting execute on the auth scope. Without the creator carve-out no
+ * subject could ever administer such a policy again.
+ */
+declare class AuthAdministrationLockoutError extends Error {
+  readonly grantId: string;
+  constructor(grantId: string);
 }
-type WebhookScheme = "none" /** A shared secret presented verbatim. No digest, so no digest options. */ | "token" /** The digest of the body, alone. */ | "hmac" /** That digest behind a label, `sha256=<digest>`. */ | "hmac-prefixed" | "hmac-timestamped";
-/** Hashes a sender may compute the digest with. */
-type WebhookHashAlgorithm = "sha1" | "sha256" | "sha512";
-/** How the digest is written into the header. */
-type WebhookSignatureEncoding = "hex" | "base64";
-interface WebhookVerification {
-  scheme: WebhookScheme;
-  /** Resolved value, never a reference — the caller resolves refs. */
-  secret?: string;
-  /** Overrides the scheme's conventional header. */
-  header?: string;
-  /** Replay window for timestamped schemes. */
-  toleranceSeconds?: number;
-  algorithm?: WebhookHashAlgorithm;
-  /** Defaults to `hex`. Base64 comparison is case-sensitive; hex is not. */
-  encoding?: WebhookSignatureEncoding;
-  prefix?: string;
+/**
+ * Thrown when INITIALIZE_AUTH would create a creator-less policy with no grant
+ * permitting execute on the auth scope. Such a policy would be born with no
+ * subject able to administer it.
+ */
+declare class AuthAdministrationMissingError extends Error {
+  constructor();
 }
-type WebhookField = string | {
-  header: string;
-} /** Dot-separated path into the parsed body, e.g. `data.object.id`. */ | {
-  body: string;
-};
-interface WebhookRequest {
-  /** The caller's own key for this endpoint, e.g. a document id. */
-  key: string;
-  method: string;
-  path: string;
-  queryParams: Record<string, string>;
-  /** Lowercased, with credentials redacted. */
-  headers: Record<string, string>;
-  /** The exact bytes received. */
-  raw: Buffer;
-  /** JSON and form bodies decoded; anything else as text. */
-  body: unknown;
+declare function isPlainValue(value: unknown): value is Record<string, unknown>;
+/** Returns the first v1-rule violation, or null. Pure, total, deterministic. */
+declare function grantProblem(value: unknown): string | null;
+declare const GrantSchema: () => z.ZodCustom<Grant, Grant>;
+/** V1 shape rules plus the group-document group-principal ban. */
+declare function assertValidGrant(grant: unknown, documentType: string): void;
+/**
+ * Validates an initial grant list: the count cap, every grant, and — on a
+ * creator-less policy — that some grant keeps the auth scope administrable.
+ */
+declare function assertValidInitialGrants(grants: Grant[], documentType: string, creator: string | undefined): void;
+/**
+ * Validates a grant upsert: the grant itself, the count cap on append, and
+ * administration retention. Retention is checked on an append as well as an
+ * in-place replace, because a grant appended after the administration grant can
+ * shadow it (evaluation is last-applicable-grant-wins) and so take
+ * administration away without removing anything.
+ */
+declare function assertValidGrantUpsert(grant: Grant, existing: Grant[], documentType: string, creator: string | undefined): void;
+/**
+ * A creator-less policy must always retain a grant permitting execute on the
+ * auth scope; on a signed document the creator carve-out keeps administration
+ * reachable instead. Rejects a change that takes the last such grant away. A
+ * policy already without one is left alone: the change is not what locks it.
+ */
+declare function assertAuthAdministrationRetained(creator: string | undefined, previous: Grant[], next: Grant[], grantId: string): void;
+/**
+ * Evaluates a version-1 condition. Deterministic, total, and pure: any input
+ * shape yields a boolean and never throws, and a malformed condition is
+ * false. These are consensus semantics, versioned by `PHAuthState.version`;
+ * changing them requires a new version.
+ */
+declare function evaluateCondition(condition: Condition, subject: AuthSubject, request: AuthRequest, conditions: ConditionContext): boolean;
+/**
+ * The group document ids named by `{ group }` principals in a grant list, in
+ * order of first appearance. These are the streams the groups projection reads.
+ */
+declare function referencedGroupIds(grants: Grant[]): string[];
+/**
+ * Evaluates a v1 grant stack: default deny, last applicable grant wins, and
+ * reports which grant decided it. Group principals match only against a
+ * supplied groups map, and `where` clauses and { match } principals evaluate
+ * only against a supplied condition context; a grant that uses an unsupplied
+ * feature never applies.
+ */
+declare function evaluateGrantStack(grants: Grant[], subject: AuthSubject, request: AuthRequest, groups?: AuthGroups, conditions?: ConditionContext): AuthEvaluation;
+/**
+ * Evaluates a v1 grant stack: default deny, last applicable grant wins. This is
+ * {@link evaluateGrantStack} with the reason dropped.
+ */
+declare function evaluateGrants(grants: Grant[], subject: AuthSubject, request: AuthRequest, groups?: AuthGroups, conditions?: ConditionContext): AuthDecision;
+//#endregion
+//#region document-model/constants.d.ts
+declare const documentModelFileExtension: "phdm";
+declare const documentModelInitialLocalState: DocumentModelLocalState;
+declare const documentModelInitialGlobalState: DocumentModelGlobalState;
+declare const documentModelGlobalState: DocumentModelGlobalState;
+declare const HASH_ALGORITHM_SHA1 = "sha1";
+declare const HASH_ALGORITHM_SHA256 = "sha256";
+declare const HASH_ALGORITHM_SHA512 = "sha512";
+declare const HASH_ENCODING_BASE64 = "base64";
+declare const HASH_ENCODING_HEX = "hex";
+//#endregion
+//#region document-model/crypto.d.ts
+declare const hashBrowser: (data: string | Uint8Array | ArrayBufferView | DataView, algorithm?: string, encoding?: string, _params?: Record<string, unknown>) => string;
+declare function getUnixTimestamp(date: Date | string): string;
+declare function buildOperationSignatureParams({ documentId, signer, action, previousStateHash }: ActionSignatureContext): [string, string, string, string];
+declare function buildOperationSignatureMessage(params: [string, string, string, string]): Uint8Array;
+declare function ab2hex(ab: ArrayBuffer | ArrayBufferView): string;
+declare function hex2ab(hex: string): Uint8Array<ArrayBuffer>;
+/**
+ * Decodes a base58btc (Bitcoin/IPFS alphabet) string to bytes. Returns null on
+ * any character outside the alphabet.
+ */
+declare function base58Decode(input: string): Uint8Array | null;
+/** Encodes bytes as unpadded base64url. */
+declare function bytesToBase64Url(bytes: Uint8Array): string;
+/** Decodes a base64url string to bytes (portable across node, browsers, workers). */
+declare function base64UrlToBytes(input: string): Uint8Array;
+//#endregion
+//#region document-model/denied.d.ts
+/**
+ * True iff authorization rejected the action.
+ */
+declare function isDenied(operation: Operation): boolean;
+/**
+ * The closed set of strings persisted as `deniedReason`. Re-evaluation compares
+ * them, so they are consensus data: exact strings that embed no grant id,
+ * subject or timestamp. Changing one is history-visible.
+ */
+declare const DOCUMENT_DELETED_REASON = "document deleted";
+declare const AUTH_VERSION_UNSUPPORTED_REASON = "auth policy version unsupported";
+declare const AUTH_NO_GRANT_REASON = "no grant permits this operation";
+declare const AUTH_DENIED_BY_GRANT_REASON = "denied by grant";
+//#endregion
+//#region document-model/document-schema.d.ts
+declare const BaseDocumentHeaderSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  createdAtUtcIso: z.ZodString;
+  lastModifiedAtUtcIso: z.ZodString;
+  documentType: z.ZodString;
+}, z.core.$strip>;
+declare const BaseDocumentStateSchema: z.ZodObject<{
+  global: z.ZodUnknown;
+}, z.core.$strip>;
+/** Schema for validating the header object of a DocumentModel document */
+declare const DocumentModelHeaderSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  createdAtUtcIso: z.ZodString;
+  lastModifiedAtUtcIso: z.ZodString;
+  documentType: z.ZodLiteral<"powerhouse/document-model">;
+}, z.core.$strip>;
+/** Schema for validating the state object of a DocumentModel document */
+declare const DocumentModelPHStateSchema: z.ZodObject<{
+  global: z.ZodObject<Required<{
+    author: z.ZodType<Author, Author, z.core.$ZodTypeInternals<Author, Author>>;
+    description: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    extension: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    name: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    specifications: z.ZodType<DocumentSpecification[], DocumentSpecification[], z.core.$ZodTypeInternals<DocumentSpecification[], DocumentSpecification[]>>;
+  }>, z.core.$strip>;
+}, z.core.$strip>;
+declare const DocumentModelSchema: z.ZodObject<{
+  header: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    createdAtUtcIso: z.ZodString;
+    lastModifiedAtUtcIso: z.ZodString;
+    documentType: z.ZodLiteral<"powerhouse/document-model">;
+  }, z.core.$strip>;
+  state: z.ZodObject<{
+    global: z.ZodObject<Required<{
+      author: z.ZodType<Author, Author, z.core.$ZodTypeInternals<Author, Author>>;
+      description: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+      extension: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+      id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+      name: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+      specifications: z.ZodType<DocumentSpecification[], DocumentSpecification[], z.core.$ZodTypeInternals<DocumentSpecification[], DocumentSpecification[]>>;
+    }>, z.core.$strip>;
+  }, z.core.$strip>;
+  initialState: z.ZodObject<{
+    global: z.ZodObject<Required<{
+      author: z.ZodType<Author, Author, z.core.$ZodTypeInternals<Author, Author>>;
+      description: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+      extension: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+      id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+      name: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+      specifications: z.ZodType<DocumentSpecification[], DocumentSpecification[], z.core.$ZodTypeInternals<DocumentSpecification[], DocumentSpecification[]>>;
+    }>, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/** Simple helper function to check if a state object is a DocumentModel document state object */
+declare function isDocumentModelState(state: unknown): state is DocumentModelPHState;
+/** Simple helper function to assert that a document state object is a DocumentModel document state object */
+declare function assertIsDocumentModelState(state: unknown): asserts state is DocumentModelPHState;
+/** Simple helper function to check if a document is a DocumentModel document */
+declare function isDocumentModelDocument(document: unknown): document is DocumentModelDocument;
+/** Simple helper function to assert that a document is a DocumentModel document */
+declare function assertIsDocumentModelDocument(document: unknown): asserts document is DocumentModelDocument;
+//#endregion
+//#region document-model/document-type.d.ts
+declare const documentModelDocumentType = "powerhouse/document-model";
+declare const groupDocumentType = "powerhouse/reactor-group";
+/**
+ * The group-model action types that change membership. The groups projection
+ * filters its reads to these, so any other group operation is invisible to a
+ * decision. Kept here so the reactor never depends on the group package; a
+ * reactor-group test guards against drift.
+ */
+declare const groupMembershipActionTypes: readonly ["ADD_MEMBER", "REMOVE_MEMBER"];
+//#endregion
+//#region document-model/errors.d.ts
+declare const FileSystemError: Error;
+declare class InvalidActionInputError extends Error {
+  data: unknown;
+  constructor(data: unknown);
 }
-interface WebhookReply {
-  status: number;
-  body?: string;
-  contentType?: string;
+declare class InvalidActionInputZodError extends InvalidActionInputError {
+  issues: ZodIssue[];
+  constructor(issues: ZodIssue[]);
 }
-interface WebhookPolicy {
-  verify?: WebhookVerification;
-  /** Uppercase. Undefined accepts every method. */
-  methods?: string[];
-  dedupe?: {
-    field: WebhookField;
-    ttlSeconds?: number;
-  };
-  challengeField?: WebhookField;
-  maxBodyBytes?: number;
+/**
+ * Error thrown when attempting to downgrade a document version.
+ */
+declare class DowngradeNotSupportedError extends Error {
+  readonly documentType: string;
+  readonly fromVersion: number;
+  readonly toVersion: number;
+  constructor(documentType: string, fromVersion: number, toVersion: number);
 }
-interface WebhookSpec {
-  /** Distinguishes several endpoint families within one package. */
-  name: string;
-  defaults?: WebhookPolicy;
-  onRequest: (request: WebhookRequest) => Promise<WebhookReply> | WebhookReply;
-  policyFor?: (key: string) => Promise<WebhookPolicy | undefined> | WebhookPolicy | undefined;
+/**
+ * Thrown when INITIALIZE_AUTH is applied to an already-initialized auth scope.
+ * The genesis action is valid only at auth revision zero.
+ */
+declare class AuthAlreadyInitializedError extends Error {
+  readonly documentId: string;
+  constructor(documentId: string);
 }
-interface WebhookEndpointInfo {
-  key: string;
-  token: string;
-  url: string;
-  createdAt: string;
+/**
+ * Thrown when INITIALIZE_AUTH is not signed by the document creator (its signer
+ * does not match `header.sig.publicKey`), so it cannot set the auth policy.
+ */
+declare class AuthInitializerNotCreatorError extends Error {
+  readonly documentId: string;
+  constructor(documentId: string);
 }
-interface IWebhookEndpoints {
-  endpointFor(key: string): Promise<Omit<WebhookEndpointInfo, "key">>;
-  revoke(key: string): Promise<void>;
-  list(): Promise<WebhookEndpointInfo[]>;
+/**
+ * Thrown when INITIALIZE_AUTH carries a version below 1. Version 0 is reserved
+ * for the uninitialized auth scope.
+ */
+declare class InvalidAuthVersionError extends Error {
+  readonly documentId: string;
+  readonly version: number;
+  constructor(documentId: string, version: number);
 }
-interface IWebhookScope {
-  register(spec: WebhookSpec): Promise<IWebhookEndpoints>;
-  readonly hasPublicOrigin: boolean;
+/** Thrown when a duplicate would lose the source policy's version or creator binding. */
+declare class AuthPolicyNotPreservedError extends Error {
+  readonly documentId: string;
+  constructor(documentId: string);
 }
-interface IHttpScope {
-  readonly owner: string;
-  readonly baseUrl: string;
-  get(path: string, handler: RouteHandler): ScopedRouteHandle;
-  get(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
-  post(path: string, handler: RouteHandler): ScopedRouteHandle;
-  post(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
-  put(path: string, handler: RouteHandler): ScopedRouteHandle;
-  put(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
-  patch(path: string, handler: RouteHandler): ScopedRouteHandle;
-  patch(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
-  delete(path: string, handler: RouteHandler): ScopedRouteHandle;
-  delete(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
-  /** Registered independently of GET: a HEAD response is not a bodyless GET. */
-  head(path: string, handler: RouteHandler): ScopedRouteHandle;
-  head(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
-  route(spec: RouteSpec): ScopedRouteHandle;
-  nodeRoute(spec: NodeRouteSpec): ScopedRouteHandle;
-  readonly webhooks: IWebhookScope;
-  /** Release every route this scope registered. Called on package teardown. */
-  dispose(): void;
+/**
+ * Thrown when a grant referenced by REMOVE_GRANT or MOVE_GRANT does not exist.
+ */
+declare class GrantNotFoundError extends Error {
+  readonly grantId: string;
+  constructor(grantId: string);
 }
-//#endregion
-//#region processors/types.d.ts
-type ProcessorDispatchResult = {
-  id: string;
-  status: string;
-};
-interface IProcessorDispatch {
-  execute(docId: string, branch: string, actions: Action[], signal?: AbortSignal, meta?: Record<string, unknown>): Promise<ProcessorDispatchResult>;
+/**
+ * Thrown when a disallowed action (UNDO, REDO) targets the auth scope.
+ */
+declare class AuthActionNotAllowedError extends Error {
+  readonly actionType: string;
+  constructor(actionType: string);
 }
-interface IProcessorHostModuleBase {
-  analyticsStore: IAnalyticsStore;
-  relationalDb: IRelationalDb;
-  processorApp: ProcessorApp;
-  dispatch: IProcessorDispatch;
-  getReadModel<T>(name: string): T;
-  config?: Map<string, unknown>;
-  /**
-   * The package's slice of the HTTP surface, bound to its own namespace.
-   *
-   * Declared on the host-agnostic base rather than on each host's module so
-   * the two cannot drift: codegen types generated processors against
-   * reactor-browser's `IProcessorHostModule`, and the same source has to
-   * compile against reactor-api's.
-   *
-   * Absent whenever the host has no HTTP server — processors also run in the
-   * browser — and on the reactor when the package's name cannot be resolved to
-   * a routable namespace, so a caller must always check before using it.
-   */
-  http?: IHttpScope;
+declare class HashMismatchError extends Error {
+  protected _scope: string;
+  protected _document: PHDocument;
+  protected _operation: Operation;
+  constructor(scope: string, document: PHDocument, operation: Operation);
+  get document(): PHDocument;
+  get scope(): string;
+  get operation(): Operation;
 }
 /**
- * Filter for matching operations to processors.
- * All fields are optional arrays - when provided, operations must match at least one value in each specified field.
- * When a field is undefined or empty, it matches all values for that field.
+ * Thrown when replay or import requires a document model version that is not
+ * registered. Carries the data the UI needs to explain the mismatch.
  */
-type ProcessorFilter = {
-  documentType?: string[];
-  scope?: string[];
-  branch?: string[];
-  documentId?: string[];
+declare class UnsupportedDocumentModelVersionError extends Error {
+  readonly documentType: string;
+  readonly requiredVersion: number;
+  readonly availableVersions: number[];
+  constructor(documentType: string, requiredVersion: number, availableVersions: number[]);
+  static isError(error: unknown): error is UnsupportedDocumentModelVersionError;
+}
+//#endregion
+//#region document-model/upgrades.d.ts
+/** Upgrade reducer transforms a document from one version to another */
+type UpgradeReducer<TFrom extends PHBaseState, TTo extends PHBaseState> = (document: PHDocument<TFrom>, action: Action) => PHDocument<TTo>;
+type ModelVersion = number;
+/** Metadata about a version transition */
+type UpgradeTransition = {
+  toVersion: ModelVersion;
+  upgradeReducer: UpgradeReducer<any, any>;
+  description?: string;
+};
+type TupleMember<T extends readonly unknown[]> = T[number];
+/** Manifest declaring all supported versions and upgrade paths */
+type UpgradeManifest<TVersions extends readonly number[]> = {
+  documentType: string;
+  latestVersion: TupleMember<TVersions>;
+  supportedVersions: TVersions;
+  upgrades: { [V in Exclude<TupleMember<TVersions>, 1> as `v${V}`]: UpgradeTransition; };
 };
 /**
- * Describes an object that can process operations.
+ * Applies an UPGRADE_DOCUMENT action to a document.
+ * Handles all upgrade scenarios including initial upgrades, no-ops, and multi-step upgrades.
+ *
+ * Behavior based on fromVersion/toVersion:
+ * - fromVersion === toVersion (and fromVersion > 0): No-op - return unchanged document
+ * - fromVersion > toVersion: Throw DowngradeNotSupportedError
+ * - All other cases: Apply upgradePath transitions (if provided), then apply initialState, set version
  */
-interface IProcessor {
-  /**
-   * Processes a list of operations with context.
-   * Called when operations match this processor's filter.
-   */
-  onOperations(operations: OperationWithContext[]): Promise<void>;
-  /**
-   * Called when the processor is disconnected.
-   * Used to clean up any resources allocated during processor creation.
-   */
-  onDisconnect(): Promise<void>;
-}
+declare function applyUpgradeDocumentAction(document: PHDocument, action: UpgradeDocumentAction, upgradePath?: UpgradeTransition[]): PHDocument;
+/** CREATE_DOCUMENT fixes `protocolVersions`; this puts them back after a reducer. */
+declare function withProtocolVersions<TDocument extends PHDocument>(document: TDocument, protocolVersions: PHDocument["header"]["protocolVersions"]): TDocument;
 /**
- * Relates a processor to its filter configuration.
+ * Applies a DELETE_DOCUMENT action, or a PURGE_DOCUMENT marker, to a document.
+ * Marks the document as deleted in the document scope state.
  */
-type ProcessorRecord = {
-  processor: IProcessor;
-  filter: ProcessorFilter;
-  startFrom?: "beginning" | "current";
-  id?: string;
-};
+declare function applyDeleteDocumentAction(document: PHDocument, action: DeleteDocumentAction | PurgeDocumentAction): PHDocument;
 /**
- * A factory function that creates processor records for a given drive.
- * Called once per drive when the drive is first detected or when the factory is registered.
+ * Computes the ordered list of upgrade transitions needed to move from
+ * fromVersion to toVersion using the provided manifest.
+ * Walks keys v(fromVersion+1)..v(toVersion) and throws a descriptive Error
+ * if the manifest is absent or any step is missing.
  */
-type ProcessorFactory = (driveHeader: PHDocumentHeader, processorApp?: ProcessorApp) => Promise<ProcessorRecord[]> | ProcessorRecord[];
-/** Takes a processor host module and builds processor factories using its context. */
-type ProcessorFactoryBuilder<TModule extends IProcessorHostModuleBase = IProcessorHostModuleBase> = {
-  bivarianceHack(module: TModule): Promise<ProcessorFactory> | ProcessorFactory;
-}["bivarianceHack"];
-type ProcessorStatus = "active" | "errored";
-type TrackedProcessor = {
-  processorId: string;
-  factoryId: string;
-  driveId: string;
-  processorIndex: number;
-  record: ProcessorRecord;
-  lastOrdinal: number;
-  status: ProcessorStatus;
-  lastError: string | undefined;
-  lastErrorTimestamp: Date | undefined;
-  retry: () => Promise<void>;
+declare function computeUpgradeTransitions(manifest: UpgradeManifest<readonly number[]> | undefined, fromVersion: number, toVersion: number): UpgradeTransition[];
+//#endregion
+//#region document-model/versioned-replay.d.ts
+type VersionedReducers = Record<number, Reducer<PHBaseState>>;
+type VersionedReplayConfig = {
+  reducers: VersionedReducers;
+  upgradeManifest?: UpgradeManifest<readonly number[]>;
 };
 /**
- * Manages processor creation and destruction based on drive operations.
+ * Version-aware document replay. Replays a versioned document through per-version
+ * reducers, applying upgrade transitions at segment boundaries.
+ *
+ * Algorithm (D5):
+ *   a. Build spine from operations["document"]. Empty spine or no upgrades → legacy fallback.
+ *   b. Collect UPGRADE_DOCUMENT ops from the spine.
+ *   c. Seed state from the creation upgrade (fromVersion===0). Missing seed with validated
+ *      upgrades throws; otherwise falls back to legacy.
+ *   d. Identify validated upgrades (fromVersion > 0, version increases). Compute per-scope
+ *      boundaries using revision snapshot (preferred) or timestamp fallback.
+ *   e. Loop over version segments, replaying each scope's ops through the matching reducer,
+ *      then applying the upgrade transition before the next segment.
+ *   f. Set header.revision["document"], verify per-scope hashes against state at op-time
+ *      (not post-upgrade state) when checkHashes is false, and map timestamps from input.
+ *
+ * operations must include ALL scopes (document scope is NOT stripped).
+ * reuseOperationResultingState is ignored by this function — zip operations never carry
+ * resultingState.
  */
-interface IProcessorManager {
-  /**
-   * Registers a processor factory.
-   * Immediately creates processors for all existing drives.
-   */
-  registerFactory(identifier: string, factory: ProcessorFactory): Promise<void>;
-  /**
-   * Unregisters a processor factory and disconnects all processors it created.
-   */
-  unregisterFactory(identifier: string): Promise<void>;
-  /**
-   * Gets a tracked processor by its ID.
-   */
-  get(processorId: string): TrackedProcessor | undefined;
-  /**
-   * Gets all tracked processors.
-   */
-  getAll(): TrackedProcessor[];
-}
-type ProcessorApp = (typeof PROCESSOR_APPS)[number];
-type ProcessorApps = readonly ProcessorApp[];
+declare function replayDocumentVersioned<TState extends PHBaseState>(initialState: TState, operations: DocumentOperations, config: VersionedReplayConfig, header: PHDocumentHeader, dispatch?: SignalDispatch, options?: ReplayDocumentOptions): PHDocument<TState>;
 //#endregion
-//#region processors/relational/types.d.ts
-type IRelationalQueryMethods = "selectFrom" | "selectNoFrom" | "with" | "withRecursive";
-type IRelationalQueryBuilder<Schema = unknown> = Pick<QueryCreator<Schema>, IRelationalQueryMethods> & {
-  withSchema: (schema: string) => IRelationalQueryBuilder<Schema>;
-};
-type HashAlgorithms = "fnv1a";
-type IBaseRelationalDb<Schema = unknown> = Kysely<Schema>;
+//#region document-model/files.d.ts
+declare function createZip(document: PHDocument): Promise<Uint8Array>;
 /**
- * The standardized relational database interface for relational db processors.
- * This abstraction provides type-safe database operations while hiding the underlying
- * database framework implementation details.
- **/
-type IRelationalDb<Schema = unknown> = IBaseRelationalDb<Schema> & {
-  createNamespace<NamespaceSchema>(namespace: string): Promise<IRelationalDb<ExtractProcessorSchemaOrSelf<NamespaceSchema>>>;
-  queryNamespace<NamespaceSchema>(namespace: string): IRelationalQueryBuilder<NamespaceSchema>;
+ * Creates a minimal ZIP backup from strand data.
+ * Used when the full document is not available (e.g., in onOperations handler).
+ * Creates a ZIP with minimal header and empty operations.
+ */
+declare function createMinimalZip(data: MinimalBackupData): Promise<Uint8Array>;
+declare function baseSaveToFileHandle(document: PHDocument, input: FileSystemFileHandle): Promise<void>;
+declare function baseLoadFromInput<TState extends PHBaseState>(input: FileInput, reducer: Reducer<TState>, options?: ReplayDocumentOptions): Promise<PHDocument<TState>>;
+declare function baseLoadFromInputVersioned<TState extends PHBaseState>(input: FileInput, config: VersionedReplayConfig, options?: ReplayDocumentOptions): Promise<PHDocument<TState>>;
+type BulkArchiveEntry = {
+  /** "/"-separated zip path of a file entry (no trailing slash). */
+  path: string;
+  data: Uint8Array;
 };
-type ExtractProcessorSchemaOrSelf<TProcessor> = TProcessor extends RelationalDbProcessor<infer TSchema> ? TSchema : TProcessor;
-type RelationalDbProcessorClass<TSchema> = typeof RelationalDbProcessor<TSchema>;
-interface IRelationalDbProcessor<TDatabaseSchema = unknown> extends IProcessor {
-  namespace: string;
-  query: IRelationalQueryBuilder<TDatabaseSchema>;
-  filter: ProcessorFilter;
-  initAndUpgrade(): Promise<void>;
-}
-declare const IS_RELATIONAL_DB_PROCESSOR: unique symbol;
 /**
- * Base class for relational db processors that require a relational database storage.
- * This class abstracts database initialization, migration management, and resource cleanup,
- * allowing derived classes to focus on business logic.
+ * Whether this zip is a single Powerhouse document: the document's four JSON
+ * entries (header/state/current-state/operations) at the archive root. A
+ * bulk archive has a folder tree instead. Returns false for any input that
+ * is not a readable zip.
  */
-declare abstract class RelationalDbProcessor<TDatabaseSchema = unknown> implements IRelationalDbProcessor<TDatabaseSchema> {
-  protected _namespace: string;
-  protected _filter: ProcessorFilter;
-  protected relationalDb: IRelationalDb<TDatabaseSchema>;
-  constructor(_namespace: string, _filter: ProcessorFilter, relationalDb: IRelationalDb<TDatabaseSchema>);
-  static [IS_RELATIONAL_DB_PROCESSOR]: boolean;
-  /**
-   * Returns the namespace for a given drive id.
-   * This method can be overridden by derived classes to provide a custom namespace.
-   */
-  static getNamespace(driveId: string): string;
-  static query<Schema>(this: RelationalDbProcessorClass<Schema>, driveId: string, db: IRelationalDb<any>): IRelationalQueryBuilder<Schema>;
-  /**
-   * Processes a list of operations with context.
-   * Called when operations match this processor's filter.
-   */
-  abstract onOperations(operations: OperationWithContext[]): Promise<void>;
-  /**
-   * Returns the filter for the processor.
-   * This method can be overridden by derived classes to provide a custom filter.
-   */
-  get filter(): ProcessorFilter;
-  /**
-   * Returns the namespace used by the processor.
-   */
-  get namespace(): string;
-  get query(): IRelationalQueryBuilder<TDatabaseSchema>;
-  /**
-   * Abstract method that derived classes must implement.
-   * This method is meant to be called on subclasses to initialize and upgrade the database.
-   */
-  abstract initAndUpgrade(): Promise<void>;
-  /**
-   * Called when the processor is disconnected.
-   * This method is meant to be overridden by subclasses to clean up resources.
-   */
-  abstract onDisconnect(): Promise<void>;
-}
+declare function isDocumentZip(data: Uint8Array): Promise<boolean>;
+/**
+ * The file entries of a zip (directory entries excluded). Used for bulk
+ * archives; throws when the archive holds no files. Note this does NOT
+ * validate that the entries are document zips — pair with isDocumentZip.
+ */
+declare function parseBulkArchive(data: Uint8Array): Promise<BulkArchiveEntry[]>;
+/**
+ * Assemble a zip from raw entries. A key ending in "/" with empty data is a
+ * directory entry, so an archive's folder structure survives a round-trip.
+ */
+declare function zipEntries(entries: Record<string, Uint8Array>): Promise<Uint8Array>;
+declare const documentModelLoadFromInput: LoadFromInput<DocumentModelPHState>;
+declare const documentModelSaveToFileHandle: SaveToFileHandle;
+declare function writeFileBrowser(path: string, name: string, stream: Uint8Array): Promise<string>;
+declare function readFileBrowser(path: string): void;
+declare function fetchFileBrowser(url: string): Promise<{
+  data: Buffer;
+  mimeType?: string;
+}>;
+declare const getFileBrowser: (file: string) => Promise<void>;
 //#endregion
-//#region processors/relational/utils.d.ts
+//#region document-model/header.d.ts
 /**
- * Hashes a string to a lowercase base-26 string.
- * @param str The string to hash.
- * @param length The length of the hash. Defaults to 10.
- * @param algorithm The hashing algorithm to use. Defaults to "fnv1a".
- * @returns The hashed string.
+ * Creates a verification-only signer from a public key.
+ * This signer can only verify signatures, not sign data.
+ *
+ * @param pubKey - The public key to use for verification.
+ * @returns An ISigner that can only verify signatures.
+ */
+declare function createVerificationSigner(pubKey: JsonWebKey): Promise<ISigner>;
+/**
+ * Signs a header. Generally, this is not called directly, but rather through
+ * {@link createSignedHeader}.
+ *
+ * @param parameters - The parameters used to sign the header.
+ * @param signer - The signer of the document.
+ *
+ * @returns The signature of the header.
+ */
+declare const sign: (parameters: SigningParameters, signer: ISigner) => Promise<string>;
+/**
+ * Verifies a header signature. Generally, this is not called directly, but
+ * rather through {@link validateHeader}.
+ *
+ * @param parameters - The parameters used to sign the header.
+ * @param signature - The signature to verify.
+ * @param signer - The signer of the document.
+ */
+declare const verify: (parameters: SigningParameters, signature: string, signer: ISigner) => Promise<void>;
+/**
+ * Validates a header signature.
+ */
+declare const validateHeader: (header: PHDocumentHeader) => Promise<void>;
+/**
+ * Creates a header that has yet to be signed. This header is not valid, but
+ * can be input into {@link createSignedHeader} to create a signed header.
+ *
+ * With `protocolVersions` requiring v2 signatures the header takes a random
+ * nonce and the id {@link deriveDocumentId} gives, so `id` must be omitted.
+ *
+ * @returns An unsigned header for a document.
+ */
+declare const createPresignedHeader: (id?: string, documentType?: string, protocolVersions?: ProtocolVersions) => PHDocumentHeader;
+/**
+ * A header for a copy of a document headed `source`. A copy is v2-required
+ * when its source is or when `policy` asks for it, and then takes a derived id;
+ * otherwise it takes `id`. It keeps the source's other protocol versions.
+ */
+declare function createCopyHeader(source: Pick<PHDocumentHeader, "documentType" | "protocolVersions">, id?: string, policy?: SignaturePolicy$1): PHDocumentHeader;
+/** Whether a v2-required `header` carries the id its params derive. */
+declare function hasDerivedDocumentId(header: PHDocumentHeader): boolean;
+/**
+ * Creates a new, signed header for a document. This will replace the id of the
+ * document.
+ *
+ * @param unsignedHeader - The unsigned header to created the signed header from.
+ * @param signer - The signer of the document.
+ *
+ * @returns A new signed header for a document. Some fields are mutable and
+ * some are not. See the PHDocumentHeader type for more information.
+ */
+declare const createSignedHeader: (unsignedHeader: PHDocumentHeader, documentType: string, signer: ISigner) => Promise<PHDocumentHeader>;
+/**
+ * Creates a signed header for a document. The document header requires a signer
+ * as the document id is a cryptographic signature.
+ *
+ * @param documentType - The type of the document.
+ * @param signer - The signer of the document.
+ *
+ * @returns The signed header for a document. Some fields are mutable and
+ * some are not. See the PHDocumentHeader type for more information.
+ */
+declare const createSignedHeaderForSigner: (documentType: string, signer: ISigner) => Promise<PHDocumentHeader>;
+//#endregion
+//#region document-model/peer-agreement.d.ts
+/** The reactor feature flags a capability's support is a function of. */
+type PeerCapabilityFlags = {
+  readonly [flag: string]: boolean | undefined;
+};
+/** A document protocol, named by its `protocolVersions` key. */
+type ProtocolCapability = {
+  kind: "protocol";
+  name: string;
+  /** What a peer that announces nothing is assumed to support. */
+  baseline: readonly number[];
+  supported(flags: PeerCapabilityFlags): readonly number[];
+  /** The version new documents take when peers agree. Absent: not negotiated. */
+  preferred?(flags: PeerCapabilityFlags): number;
+  /** A header may omit the key. */
+  optional: boolean;
+};
+/** A feature that changes what a peer sends or expects on the wire. */
+type FeatureCapability = {
+  kind: "feature";
+  name: string;
+  baseline: readonly number[];
+  supported(flags: PeerCapabilityFlags): readonly number[];
+};
+type PeerCapability = ProtocolCapability | FeatureCapability;
+/** A purged document's protocol; never preferred, so creation never selects it. */
+declare const DOCUMENT_PURGE_PROTOCOL = "document-purge";
+/** A peer that takes refusals of polled purge markers on the poll. */
+declare const MARKER_REFUSAL_FEATURE = "marker-refusal";
+declare const PEER_CAPABILITIES: readonly PeerCapability[];
+/** `base` plus `extra`; an extra replaces a base entry of the same name. */
+declare function mergePeerCapabilities(base: readonly PeerCapability[], extra: readonly PeerCapability[]): PeerCapability[];
+declare const PEER_MANIFEST_FORMAT = 1;
+type Supports = {
+  protocols: {
+    [protocol: string]: readonly number[];
+  };
+  features: {
+    [feature: string]: readonly number[];
+  };
+};
+type PeerManifest = Supports & {
+  format: 1;
+  /** The signer's did:key, when configured; informational. */
+  appKey?: string;
+  /** Grows with every start of the reactor; a peer ignores an older one. */
+  sequence: number;
+  /** base64url(sha256(canonicalJson(Supports & { sequence }))) */
+  revision: string;
+};
+/** What this reactor supports, for every capability it registers. */
+declare function localSupports(capabilities: readonly PeerCapability[], flags: PeerCapabilityFlags): Supports;
+/** What a peer that announces nothing supports. */
+declare function legacySupports(capabilities: readonly PeerCapability[]): Supports;
+declare function manifestRevision(supports: Supports, sequence?: number): string;
+declare function localPeerManifest(capabilities: readonly PeerCapability[], flags: PeerCapabilityFlags, appKey?: string, sequence?: number): PeerManifest;
+/** A manifest sent before the one already held; silence carries no sequence. */
+declare function isOlderManifest(next: PeerManifest | null, held: PeerManifest | null | undefined): boolean;
+/** A peer's manifest, or the baselines for a peer that announced none. */
+declare function peerSupports(manifest: PeerManifest | null, capabilities: readonly PeerCapability[]): Supports;
+/**
+ * A manifest as received from a peer, or null when it is not one. Formats only
+ * add fields, so one of an unknown format is read as its two maps.
+ */
+declare function readPeerManifest(value: unknown): PeerManifest | null;
+/** Why a document may not go to a peer. */
+type HoldReason = {
+  protocol: string;
+  version: number;
+  peerSupports: readonly number[];
+};
+/** Only keys this reactor registers are judged; an absent key agrees. */
+declare function holdReason(peer: Supports, versions: {
+  readonly [protocol: string]: number;
+}, capabilities: readonly PeerCapability[]): HoldReason | undefined;
+/** Whether a peer runs every version this reactor does, so nothing is held. */
+declare function coversLocal(peer: Supports, local: Supports, capabilities: readonly PeerCapability[]): boolean;
+/**
+ * protocolVersions for a new document: per negotiated protocol, the highest
+ * version up to the local preference that every member supports, else the
+ * lowest local one. `requested` wins over what is selected.
+ */
+declare function selectProtocolVersions(input: {
+  capabilities: readonly PeerCapability[];
+  flags: PeerCapabilityFlags;
+  members: Iterable<Supports>;
+  requested?: {
+    readonly [protocol: string]: number;
+  };
+}): {
+  [protocol: string]: number;
+};
+//#endregion
+//#region document-model/purge.d.ts
+declare const PURGE_DOCUMENT = "PURGE_DOCUMENT";
+type PurgeMarkerOperation = Operation & {
+  action: PurgeDocumentAction;
+};
+type ActionLike = Pick<Action, "type">;
+declare function isPurgeMarker(value: Action): value is PurgeDocumentAction;
+declare function isPurgeMarker(value: Operation): value is PurgeMarkerOperation;
+declare function isPurgeMarker(value: OperationWithContext$1): value is OperationWithContext$1 & {
+  operation: PurgeMarkerOperation;
+};
+declare function isPurgeMarker(value: ActionLike | {
+  action?: ActionLike;
+} | {
+  operation: Operation;
+}): boolean;
+/** An unsigned marker; `purgedAtUtcIso` is the action's own timestamp. */
+declare function purgeDocumentAction(input: Omit<PurgeDocumentActionInput, "purgedAtUtcIso">, options?: {
+  id?: string;
+  timestampUtcMs?: string;
+}): PurgeDocumentAction;
+/** The sole row of a purged stream: document/main, index 0, skip 0, hash "". */
+declare function purgeMarkerOperation(action: PurgeDocumentAction): PurgeMarkerOperation;
+/** Protocol versions of a purged id; derived, never stored. */
+declare function purgedProtocolVersions(): {
+  [protocol: string]: number;
+};
+//#endregion
+//#region document-model/reducer.d.ts
+declare function replayOperations<TState extends PHBaseState = PHBaseState>(initialState: TState, clearedOperations: DocumentOperations, stateReducer: StateReducer<TState>, header: PHDocumentHeader, dispatch?: SignalDispatch, documentReducer?: typeof baseReducer, skipHeaderOperations?: SkipHeaderOperations, options?: ReplayDocumentOptions): PHDocument<TState>;
+/**
+ * Updates the document state based on the provided action.
+ *
+ * @param state The current state of the document.
+ * @param action The action being applied to the document.
+ * @param skip The number of operations to skip before applying the action.
+ * @param reuseLastOperationIndex Whether to reuse the last operation index (used when a an UNDO operation is performed after an existing one).
+ * @param context The operation context for deterministic ID generation.
+ * @returns The updated document state.
  */
-declare function hashNamespace(str: string, length?: number): string;
+declare function updateDocument<TDocument extends PHDocument>(document: TDocument, action: Action, reuseLastOperationIndex: boolean, skip: number, context: OperationContext, operation?: Operation, skipIndexValidation?: boolean): TDocument;
 /**
- * Creates a RelationalDb instance with namespace support.
- * @param baseDb The base RelationalDb instance to enhance.
- * @param baseOptions The default options for namespace creation. Hashes namespace by default.
- * @returns The enhanced RelationalDb instance.
+ * Processes an UNDO or REDO action.
+ *
+ * @param document The current state of the document.
+ * @param action The action being applied to the document.
+ * @param skip The number of operations to skip before applying the action.
+ * @returns The updated document, calculated skip value and transformed action (if applied).
  */
-declare function createRelationalDb<Schema>(baseDb: IBaseRelationalDb<Schema>, baseOptions?: NamespaceOptions): IRelationalDb<Schema>;
-type NamespaceOptions = {
-  hashNamespace?: boolean;
+declare function processUndoRedo<TState extends PHBaseState = PHBaseState>(document: PHDocument<TState>, action: Action, skip: number, protocolVersion?: number): {
+  document: PHDocument<TState>;
+  action: Action;
+  skip: number;
+  reuseLastOperationIndex: boolean;
 };
-declare function createNamespacedDb<Schema>(db: IBaseRelationalDb<any>, namespace: string, options?: NamespaceOptions): Promise<IRelationalDb<Schema>>;
-declare function createNamespacedQueryBuilder<Schema>(db: IBaseRelationalDb<any>, namespace: string, options?: NamespaceOptions): IRelationalQueryBuilder<Schema>;
 /**
- * Returns a query builder for a RelationalDb instance.
- * @param query The RelationalDb instance to convert.
- * @returns The IRelationalQueryBuilder instance.
+ * Base document reducer that wraps a custom document reducer and handles
+ * document-level actions such as undo, redo, and set name.
+ *
+ * @template TGlobalState - The type of the state of the custom reducer.
+ * @template TAction - The type of the actions of the custom reducer.
+ * @param state - The current state of the document.
+ * @param action - The action object to apply to the state.
+ * @param customReducer - The custom reducer that implements the application logic
+ * specific to the document's state.
+ * @returns The new state of the document.
  */
-declare function relationalDbToQueryBuilder<TSchema>(query: IBaseRelationalDb<TSchema>): IRelationalQueryBuilder<TSchema>;
+declare function baseReducer<TState extends PHBaseState = PHBaseState>(document: PHDocument<TState>, action: Action, customReducer: StateReducer<TState>, dispatch?: SignalDispatch, options?: ReducerOptions): PHDocument<TState>;
+/**
+ * Helper function to create a document model reducer.
+ *
+ * @remarks
+ * This function creates a new reducer that wraps the provided `reducer` with
+ * `documentReducer`, adding support for document actions:
+ *   - `SET_NAME`
+ *   - `UNDO`
+ *   - `REDO`
+ *
+ * It also updates the document-related attributes on every operation.
+ *
+ * @param reducer - The custom reducer to wrap.
+ * @param documentReducer - The document reducer to use.
+ *
+ * @returns The new reducer.
+ */
+declare function createReducer<TState extends PHBaseState = PHBaseState>(stateReducer: StateReducer<TState>, documentReducer?: typeof baseReducer): Reducer<TState>;
+//#endregion
+//#region document-model/reducers.d.ts
+declare const documentModelHeaderReducer: DocumentModelHeaderOperations;
+declare const documentModelModuleReducer: DocumentModelModuleOperations;
+declare const documentModelOperationErrorReducer: DocumentModelOperationErrorOperations;
+declare const documentModelOperationExampleReducer: DocumentModelOperationExampleOperations;
+declare const documentModelOperationReducer: DocumentModelOperationOperations;
+declare const documentModelStateSchemaReducer: DocumentModelStateOperations;
+declare const documentModelVersioningReducer: DocumentModelVersioningOperations;
+declare const documentModelStateReducer: StateReducer<DocumentModelPHState>;
+declare const documentModelReducer: Reducer<DocumentModelPHState>;
 //#endregion
 //#region document-model/schemas.d.ts
 type definedNonNullAny = {};
 declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
 declare const definedNonNullAnySchema: z.ZodAny & z.ZodType<definedNonNullAny, any, z.core.$ZodTypeInternals<definedNonNullAny, any>>;
-declare const Load_StateSchema: z.ZodEnum<{
-  LOAD_STATE: "LOAD_STATE";
-}>;
-declare const PruneSchema: z.ZodEnum<{
-  PRUNE: "PRUNE";
-}>;
 declare const RedoSchema: z.ZodEnum<{
   REDO: "REDO";
 }>;
@@ -1340,18 +1977,6 @@ declare const UndoSchema: z.ZodEnum<{
 }>;
 declare function OperationScopeSchema(): z.ZodString;
 declare function DocumentActionSchema(): z.ZodUnion<readonly [z.ZodObject<Required<{
-  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
-  timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
-  input: z.ZodType<LoadStateActionInput, LoadStateActionInput, z.core.$ZodTypeInternals<LoadStateActionInput, LoadStateActionInput>>;
-  type: z.ZodType<"LOAD_STATE", "LOAD_STATE", z.core.$ZodTypeInternals<"LOAD_STATE", "LOAD_STATE">>;
-  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
-}>, z.core.$strip>, z.ZodObject<Required<{
-  id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
-  timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
-  input: z.ZodType<PruneActionInput, PruneActionInput, z.core.$ZodTypeInternals<PruneActionInput, PruneActionInput>>;
-  type: z.ZodType<"PRUNE", "PRUNE", z.core.$ZodTypeInternals<"PRUNE", "PRUNE">>;
-  scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
-}>, z.core.$strip>, z.ZodObject<Required<{
   id: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
   timestampUtcMs: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
   input: z.ZodType<RedoActionInput, RedoActionInput, z.core.$ZodTypeInternals<RedoActionInput, RedoActionInput>>;
@@ -1376,11 +2001,6 @@ declare function DocumentActionSchema(): z.ZodUnion<readonly [z.ZodObject<Requir
   type: z.ZodType<"UNDO", "UNDO", z.core.$ZodTypeInternals<"UNDO", "UNDO">>;
   scope: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
 }>, z.core.$strip>]>;
-declare function LoadStateActionSchema(): z.ZodObject<Properties<SchemaLoadStateAction>>;
-declare function LoadStateActionInputSchema(): z.ZodObject<Properties<LoadStateActionInput>>;
-declare function LoadStateActionStateInputSchema(): z.ZodObject<Properties<LoadStateActionStateInput>>;
-declare function PruneActionSchema(): z.ZodObject<Properties<SchemaPruneAction>>;
-declare function PruneActionInputSchema(): z.ZodObject<Properties<PruneActionInput>>;
 declare function RedoActionInputSchema(): z.ZodObject<{
   count: z.ZodNumber;
 }, z.core.$strip>;
@@ -1397,7 +2017,7 @@ declare function UndoActionInputSchema(): z.ZodObject<{
   count: z.ZodNumber;
 }, z.core.$strip>;
 declare function UndoActionSchema(): z.ZodObject<Properties<SchemaUndoAction>>;
-type Properties<T> = Required<{ [K in keyof T]: z.ZodType<T[K], T[K]> }>;
+type Properties<T> = Required<{ [K in keyof T]: z.ZodType<T[K], T[K]>; }>;
 declare function AddChangeLogItemInputSchema(): z.ZodObject<Properties<AddChangeLogItemInput>>;
 declare function AddModuleInputSchema(): z.ZodObject<Properties<AddModuleInput>>;
 declare function AddOperationErrorInputSchema(): z.ZodObject<Properties<AddOperationErrorInput>>;
@@ -1590,6 +2210,24 @@ declare const PowerhouseModulesSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
   name: z.ZodString;
   documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>>>;
+declare const PieceModuleSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  version: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  bundle: z.ZodOptional<z.ZodString>;
+  descriptor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const PieceModulesSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  version: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  bundle: z.ZodOptional<z.ZodString>;
+  descriptor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>>;
 declare const PublisherSchema: z.ZodObject<{
   name: z.ZodOptional<z.ZodString>;
   url: z.ZodOptional<z.ZodString>;
@@ -1600,7 +2238,7 @@ declare const ConfigEntrySchema: z.ZodObject<{
   type: z.ZodUnion<readonly [z.ZodLiteral<"var">, z.ZodLiteral<"secret">]>;
   description: z.ZodOptional<z.ZodString>;
   required: z.ZodOptional<z.ZodBoolean>;
-  default: z.ZodOptional<z.ZodBoolean>;
+  default: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const PwaConfigSchema: z.ZodType<PHConnectPwa>;
 declare const ManifestSchema: z.ZodObject<{
@@ -1637,65 +2275,578 @@ declare const ManifestSchema: z.ZodObject<{
     name: z.ZodString;
     documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
   }, z.core.$strip>>>;
+  pieces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    documentTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    bundle: z.ZodOptional<z.ZodString>;
+    descriptor: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  externalDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   config: z.ZodOptional<z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     type: z.ZodUnion<readonly [z.ZodLiteral<"var">, z.ZodLiteral<"secret">]>;
     description: z.ZodOptional<z.ZodString>;
     required: z.ZodOptional<z.ZodBoolean>;
-    default: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>>;
   pwa: z.ZodOptional<z.ZodType<PHConnectPwa, unknown, z.core.$ZodTypeInternals<PHConnectPwa, unknown>>>;
 }, z.core.$strip>;
 //#endregion
-//#region document-model/upgrades.d.ts
-/** Upgrade reducer transforms a document from one version to another */
-type UpgradeReducer<TFrom extends PHBaseState, TTo extends PHBaseState> = (document: PHDocument<TFrom>, action: Action) => PHDocument<TTo>;
-type ModelVersion = number;
-/** Metadata about a version transition */
-type UpgradeTransition = {
-  toVersion: ModelVersion;
-  upgradeReducer: UpgradeReducer<any, any>;
-  description?: string;
+//#region document-model/validation.d.ts
+/**
+ * Reserved operation names from base reducer (core/actions.ts).
+ * These names cannot be used for custom operations.
+ */
+declare const RESERVED_OPERATION_NAMES: readonly ["UNDO", "REDO", "SET_NAME", "SET_PREFERRED_EDITOR", "NOOP", "PURGE_DOCUMENT"];
+type ReservedOperationName = (typeof RESERVED_OPERATION_NAMES)[number];
+/**
+ * Operation names become the literal action `type` string at runtime and the
+ * key for codegen's action union. They must be SCREAMING_SNAKE_CASE so the
+ * generated TypeScript is valid.
+ */
+declare const OPERATION_NAME_PATTERN: RegExp;
+declare function isValidOperationNameFormat(name: string): boolean;
+/**
+ * Check if name conflicts with base reducer actions (case-insensitive).
+ */
+declare function isReservedOperationName(name: string): boolean;
+/**
+ * Get all operation names from all modules in the latest specification.
+ * Returns names in uppercase for case-insensitive comparison.
+ */
+declare function getAllOperationNames(state: DocumentModelGlobalState, excludeOperationId?: string): string[];
+/**
+ * Validate operation name is not reserved or duplicate. Throws on failure.
+ *
+ * @param name - The operation name to validate
+ * @param state - The document model global state
+ * @param excludeOperationId - Optional operation ID to exclude (for rename validation)
+ * @throws Error if the name is reserved or a duplicate
+ */
+declare function validateOperationName(name: string, state: DocumentModelGlobalState, excludeOperationId?: string): void;
+declare function validateInitialState(initialState: string, allowEmptyState?: boolean): ValidationError[];
+declare function validateStateSchemaName(schema: string, documentName: string, scope?: string, allowEmptySchema?: boolean): ValidationError[];
+declare function validateModules(modules: ModuleSpecification[]): ValidationError[];
+declare function validateModule(mod: ModuleSpecification): ValidationError[];
+declare function validateModuleOperation(operation: OperationSpecification): ValidationError[];
+/**
+ * Find a module in the latest specification by id, or throw. Reducers that
+ * mutate-by-id should call this up front so an unknown id fails loudly
+ * instead of silently no-opping.
+ */
+declare function findModuleOrThrow(state: DocumentModelGlobalState, moduleId: string): ModuleSpecification;
+/**
+ * Find an operation in the latest specification by id, or throw. Same
+ * rationale as findModuleOrThrow — reducers that target an operation must
+ * fail loudly when the operation doesn't exist.
+ */
+declare function findOperationOrThrow(state: DocumentModelGlobalState, operationId: string): OperationSpecification;
+/**
+ * Find an operation error by id across all operations in the latest
+ * specification, or throw. Throws on a duplicate id too: setters act on a
+ * single error, so an ambiguous id must fail loudly rather than mutate an
+ * arbitrary match.
+ */
+declare function findOperationErrorOrThrow(state: DocumentModelGlobalState, errorId: string): OperationErrorSpecification;
+/**
+ * Find an operation example (code example) by id across all operations in the
+ * latest specification, or throw. Throws on a duplicate id for the same reason
+ * as findOperationErrorOrThrow.
+ */
+declare function findOperationExampleOrThrow(state: DocumentModelGlobalState, exampleId: string): CodeExample;
+/**
+ * Assert no module in the latest specification already uses `id`. Modules are
+ * targeted by id by the setter/delete/reorder reducers, so a duplicate id makes
+ * those operations ambiguous.
+ */
+declare function assertModuleIdUnique(state: DocumentModelGlobalState, id: string): void;
+/**
+ * Assert no operation in the latest specification already uses `id`. Operations
+ * are targeted by id across all modules, so the id must be unique document-wide.
+ */
+declare function assertOperationIdUnique(state: DocumentModelGlobalState, id: string): void;
+/**
+ * Assert no operation error in the latest specification already uses `id`.
+ * Error ids are targeted document-wide by the setter/delete reducers, so the id
+ * must be unique to keep those operations unambiguous.
+ */
+declare function assertOperationErrorIdUnique(state: DocumentModelGlobalState, id: string): void;
+/**
+ * Assert no operation example in the latest specification already uses `id`.
+ * Example ids are targeted document-wide by the update/delete reducers, so the
+ * id must be unique to keep those operations unambiguous.
+ */
+declare function assertOperationExampleIdUnique(state: DocumentModelGlobalState, id: string): void;
+declare function validateOperations(operations: DocumentOperations): ValidationError[];
+//#endregion
+//#region processors/deletion.d.ts
+/** The id a DELETE_DOCUMENT or PURGE_DOCUMENT removes; undefined otherwise. */
+declare function deletedDocumentId(op: OperationWithContext$1): string | undefined;
+//#endregion
+//#region processors/http.d.ts
+/** Methods a package route may bind. OPTIONS belongs to the CORS layer. */
+type RouteMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+interface RouteUser {
+  address: string;
+  chainId: number;
+  networkId: string;
+  appKey: string;
+}
+type RouteActor = {
+  user: RouteUser | undefined;
+  authEnabled: boolean;
+};
+type AuthorizerResult = {
+  authorized: true;
+} |
+/** Refused; the scope answers with its own JSON error envelope. */
+{
+  authorized: false;
+  status: number;
+  message: string;
+} | {
+  authorized: false;
+  response: Response;
+};
+/** A route-specific gate, for policies the standard modes cannot express. */
+type RouteAuthorizer = (req: IncomingMessage) => Promise<AuthorizerResult> | AuthorizerResult;
+/** How a route authenticates. */
+type RouteAuth =
+/** Default. A verifiable bearer is required; a caller without one gets 401. */
+"renown" | "renown-optional" | "public" | RouteAuthorizer;
+/** How the request body reaches the handler. */
+type RouteBody =
+/** Default. Buffered, and readable through the Fetch Request. */
+"parsed" |
+/** Buffered and also handed over as `ctx.rawBody`, byte for byte. */
+"raw" |
+/** Not buffered; the Fetch Request body is the live request stream. */
+"stream" |
+/** The body is not read at all. */
+"none";
+interface RouteOptions {
+  auth?: RouteAuth;
+  body?: RouteBody;
+  /** Refuse a body larger than this with 413. Ignored when body is `stream`. */
+  maxBodyBytes?: number;
+  /** Serve sub-paths too, not just an exact match. */
+  prefix?: boolean;
+}
+/** Where the request reached the host, resolved through any reverse proxy. */
+interface RouteTransport {
+  proto: string;
+  host: string;
+  prefix: string;
+  baseUrl: string;
+}
+interface RouteContext {
+  /** Decoded path params. */
+  params: Record<string, string>;
+  user: RouteUser | undefined;
+  authEnabled: boolean;
+  /** The exact octets received. Present only when body is `raw`. */
+  rawBody: Buffer | undefined;
+  /** Aborts when the client disconnects. */
+  signal: AbortSignal;
+  transport: RouteTransport;
+}
+type RouteHandler = (request: Request, ctx: RouteContext) => Response | Promise<Response>;
+interface RouteSpec extends RouteOptions {
+  method: RouteMethod | RouteMethod[];
+  /** Relative to the scope: "runs/:id", never "/api/@scope/pkg/runs/:id". */
+  path: string;
+  handler: RouteHandler;
+}
+interface NodeRouteSpec extends Omit<RouteOptions, "body" | "maxBodyBytes"> {
+  method: RouteMethod | RouteMethod[];
+  path: string;
+  handler: (req: IncomingMessage, res: ServerResponse, ctx: Omit<RouteContext, "rawBody" | "signal">) => void | Promise<void>;
+}
+interface ScopedRouteHandle {
+  /** The absolute public URL this route answers on. */
+  readonly url: string;
+  dispose(): void;
+}
+type WebhookScheme = "none" |
+/** A shared secret presented verbatim. No digest, so no digest options. */
+"token" |
+/** The digest of the body, alone. */
+"hmac" |
+/** That digest behind a label, `sha256=<digest>`. */
+"hmac-prefixed" | "hmac-timestamped";
+/** Hashes a sender may compute the digest with. */
+type WebhookHashAlgorithm = "sha1" | "sha256" | "sha512";
+/** How the digest is written into the header. */
+type WebhookSignatureEncoding = "hex" | "base64";
+interface WebhookVerification {
+  scheme: WebhookScheme;
+  /** Resolved value, never a reference — the caller resolves refs. */
+  secret?: string;
+  /** Overrides the scheme's conventional header. */
+  header?: string;
+  /** Replay window for timestamped schemes. */
+  toleranceSeconds?: number;
+  algorithm?: WebhookHashAlgorithm;
+  /** Defaults to `hex`. Base64 comparison is case-sensitive; hex is not. */
+  encoding?: WebhookSignatureEncoding;
+  prefix?: string;
+}
+type WebhookField = string | {
+  header: string;
+} |
+/** Dot-separated path into the parsed body, e.g. `data.object.id`. */
+{
+  body: string;
+};
+interface WebhookRequest {
+  /** The caller's own key for this endpoint, e.g. a document id. */
+  key: string;
+  method: string;
+  path: string;
+  queryParams: Record<string, string>;
+  /** Lowercased, with credentials redacted. */
+  headers: Record<string, string>;
+  /** The exact bytes received. */
+  raw: Buffer;
+  /** JSON and form bodies decoded; anything else as text. */
+  body: unknown;
+}
+interface WebhookReply {
+  status: number;
+  body?: string;
+  contentType?: string;
+  /** The handler did not process this delivery (its owner is shutting down),
+   * so its dedupe key is dropped and the sender's retry is delivered again.
+   * Unset, a delivery counts as seen whatever the status. */
+  unprocessed?: boolean;
+}
+interface WebhookPolicy {
+  verify?: WebhookVerification;
+  /** Uppercase. Undefined accepts every method. */
+  methods?: string[];
+  dedupe?: {
+    field: WebhookField;
+    ttlSeconds?: number;
+  };
+  challengeField?: WebhookField;
+  maxBodyBytes?: number;
+}
+interface WebhookSpec {
+  /** Distinguishes several endpoint families within one package. */
+  name: string;
+  defaults?: WebhookPolicy;
+  onRequest: (request: WebhookRequest) => Promise<WebhookReply> | WebhookReply;
+  policyFor?: (key: string) => Promise<WebhookPolicy | undefined> | WebhookPolicy | undefined;
+}
+interface WebhookEndpointInfo {
+  key: string;
+  token: string;
+  url: string;
+  createdAt: string;
+}
+interface IWebhookEndpoints {
+  endpointFor(key: string): Promise<Omit<WebhookEndpointInfo, "key">>;
+  revoke(key: string): Promise<void>;
+  list(): Promise<WebhookEndpointInfo[]>;
+}
+interface IWebhookScope {
+  register(spec: WebhookSpec): Promise<IWebhookEndpoints>;
+  readonly hasPublicOrigin: boolean;
+}
+interface IHttpScope {
+  readonly owner: string;
+  readonly baseUrl: string;
+  get(path: string, handler: RouteHandler): ScopedRouteHandle;
+  get(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
+  post(path: string, handler: RouteHandler): ScopedRouteHandle;
+  post(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
+  put(path: string, handler: RouteHandler): ScopedRouteHandle;
+  put(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
+  patch(path: string, handler: RouteHandler): ScopedRouteHandle;
+  patch(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
+  delete(path: string, handler: RouteHandler): ScopedRouteHandle;
+  delete(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
+  /** Registered independently of GET: a HEAD response is not a bodyless GET. */
+  head(path: string, handler: RouteHandler): ScopedRouteHandle;
+  head(path: string, options: RouteOptions, handler: RouteHandler): ScopedRouteHandle;
+  route(spec: RouteSpec): ScopedRouteHandle;
+  nodeRoute(spec: NodeRouteSpec): ScopedRouteHandle;
+  readonly webhooks: IWebhookScope;
+  /** Release every route this scope registered. Called on package teardown. */
+  dispose(): void;
+}
+//#endregion
+//#region processors/types.d.ts
+type ProcessorDispatchResult = {
+  id: string;
+  status: string;
+};
+interface IProcessorDispatch {
+  execute(docId: string, branch: string, actions: Action[], signal?: AbortSignal, meta?: Record<string, unknown>): Promise<ProcessorDispatchResult>;
+}
+interface IProcessorHostModuleBase {
+  analyticsStore: IAnalyticsStore;
+  relationalDb: IRelationalDb;
+  processorApp: ProcessorApp;
+  dispatch: IProcessorDispatch;
+  getReadModel<T>(name: string): T;
+  config?: Map<string, unknown>;
+  /**
+   * The package's slice of the HTTP surface, bound to its own namespace.
+   *
+   * Declared on the host-agnostic base rather than on each host's module so
+   * the two cannot drift: codegen types generated processors against
+   * reactor-browser's `IProcessorHostModule`, and the same source has to
+   * compile against reactor-api's.
+   *
+   * Absent whenever the host has no HTTP server — processors also run in the
+   * browser — and on the reactor when the package's name cannot be resolved to
+   * a routable namespace, so a caller must always check before using it.
+   */
+  http?: IHttpScope;
+}
+/**
+ * Filter for matching operations to processors.
+ * All fields are optional arrays - when provided, operations must match at least one value in each specified field.
+ * When a field is undefined or empty, it matches all values for that field.
+ */
+type ProcessorFilter = {
+  documentType?: string[];
+  scope?: string[];
+  branch?: string[];
+  documentId?: string[];
+};
+/**
+ * Describes an object that can process operations.
+ */
+interface IProcessor {
+  /**
+   * Processes a list of operations with context.
+   * Called when operations match this processor's filter.
+   *
+   * Delivery is at-least-once. Within a document's scope and branch, each
+   * call is in ordinal order, and an operation delivered late comes with
+   * every later operation of its stream this processor was already given.
+   * Across documents there is no ordering guarantee. A processor receives one
+   * `onOperations` call at a time; the next call begins after the previous
+   * resolves.
+   *
+   * A drive's processors also receive the drive's own DELETE_DOCUMENT or
+   * PURGE_DOCUMENT, whatever the filter, as the last delivery before
+   * `onDisconnect`. A purged document's operations other than its marker are
+   * not delivered. Erase a document's data on either deletion action.
+   */
+  onOperations(operations: OperationWithContext[]): Promise<void>;
+  /**
+   * Called when the processor is disconnected.
+   * Used to clean up any resources allocated during processor creation.
+   * Also runs when the factory is unregistered, so it is not a deletion signal.
+   */
+  onDisconnect(): Promise<void>;
+}
+/**
+ * Relates a processor to its filter configuration.
+ */
+type ProcessorRecord = {
+  processor: IProcessor;
+  filter: ProcessorFilter;
+  startFrom?: "beginning" | "current";
+  id?: string;
+};
+/**
+ * A factory function that creates processor records for a given drive.
+ * Called once per drive when the drive is first detected or when the factory is registered.
+ * The header is the drive's header at creation. For a purged drive it is
+ * minimal: only `id` and `documentType` are set, and `slug` and `name` are
+ * empty, so a factory that selects drives by slug or name makes no processor
+ * for it and the deletion stays owed.
+ */
+type ProcessorFactory = (driveHeader: PHDocumentHeader, processorApp?: ProcessorApp) => Promise<ProcessorRecord[]> | ProcessorRecord[];
+/** Takes a processor host module and builds processor factories using its context. */
+type ProcessorFactoryBuilder<TModule extends IProcessorHostModuleBase = IProcessorHostModuleBase> = {
+  bivarianceHack(module: TModule): Promise<ProcessorFactory> | ProcessorFactory;
+}["bivarianceHack"];
+type ProcessorStatus = "active" | "errored";
+type TrackedProcessor = {
+  processorId: string;
+  factoryId: string;
+  driveId: string;
+  processorIndex: number;
+  record: ProcessorRecord;
+  lastOrdinal: number;
+  status: ProcessorStatus;
+  lastError: string | undefined;
+  lastErrorTimestamp: Date | undefined;
+  /**
+   * Clears the error and resolves once the replay from the cursor completes.
+   * Safe from anywhere, but awaiting it from this processor's own
+   * `onOperations` waits on itself: the replay runs after that call returns.
+   * A no-op once the processor has been removed.
+   */
+  retry: () => Promise<void>;
+};
+/**
+ * Manages processor creation and destruction based on drive operations.
+ */
+interface IProcessorManager {
+  /**
+   * Registers a processor factory.
+   * Immediately creates processors for all existing drives and resolves once
+   * every factory run has completed and its processors are bound. Their
+   * backfills run afterwards, on each processor's own queue. A deleted drive
+   * whose deletion one of the factory's processors never received (it was not
+   * running, or its delivery threw) gets a processor too: it receives only the
+   * drive's `DELETE_DOCUMENT`, or its `PURGE_DOCUMENT` once purged, and is
+   * disconnected. That delivery is not awaited: it runs after this resolves,
+   * so a processor that hangs on it does not hold the registration, nor a
+   * later one: a drive whose deletion is still being delivered gets it from
+   * the new registration only if that delivery leaves it owed. If processors
+   * from an earlier registration under the same identifier are still
+   * draining, or a call of the previous factory is still in flight, the
+   * factory runs after they have settled, so awaiting a re-registration of
+   * a factory from inside that factory or one of its processors'
+   * `onOperations` waits on itself.
+   */
+  registerFactory(identifier: string, factory: ProcessorFactory): Promise<void>;
+  /**
+   * Unregisters a processor factory. Resolves once its processors receive no
+   * new deliveries and their cursors are released; each one's in-flight
+   * delivery finishes first, then `onDisconnect` runs. A released cursor no
+   * longer positions a processor: a re-registration starts each one afresh,
+   * per `startFrom`. It only records that the factory held a drive's data, so
+   * that a drive deleted before the factory registers again still gets its
+   * deletion delivered then. Safe to call from
+   * inside a processor's own `onOperations`.
+   */
+  unregisterFactory(identifier: string): Promise<void>;
+  /**
+   * Gets a tracked processor by its ID.
+   */
+  get(processorId: string): TrackedProcessor | undefined;
+  /**
+   * Gets all tracked processors, including an errored entry for each
+   * processor whose drive's deletion threw; its `retry()` delivers the
+   * deletion again.
+   */
+  getAll(): TrackedProcessor[];
+}
+type ProcessorApp = (typeof PROCESSOR_APPS)[number];
+type ProcessorApps = readonly ProcessorApp[];
+//#endregion
+//#region processors/relational/types.d.ts
+/** Columns {@link RelationalDbProcessor.deleteDocumentRows} matches. */
+declare const DOCUMENT_ID_COLUMNS: readonly ["document_id", "documentId"];
+type IRelationalQueryMethods = "selectFrom" | "selectNoFrom" | "with" | "withRecursive";
+type IRelationalQueryBuilder<Schema = unknown> = Pick<QueryCreator<Schema>, IRelationalQueryMethods> & {
+  withSchema: (schema: string) => IRelationalQueryBuilder<Schema>;
 };
-type TupleMember<T extends readonly unknown[]> = T[number];
-/** Manifest declaring all supported versions and upgrade paths */
-type UpgradeManifest<TVersions extends readonly number[]> = {
-  documentType: string;
-  latestVersion: TupleMember<TVersions>;
-  supportedVersions: TVersions;
-  upgrades: { [V in Exclude<TupleMember<TVersions>, 1> as `v${V}`]: UpgradeTransition };
+type HashAlgorithms = "fnv1a";
+type IBaseRelationalDb<Schema = unknown> = Kysely<Schema>;
+/**
+ * The standardized relational database interface for relational db processors.
+ * This abstraction provides type-safe database operations while hiding the underlying
+ * database framework implementation details.
+ **/
+type IRelationalDb<Schema = unknown> = IBaseRelationalDb<Schema> & {
+  createNamespace<NamespaceSchema>(namespace: string): Promise<IRelationalDb<ExtractProcessorSchemaOrSelf<NamespaceSchema>>>;
+  queryNamespace<NamespaceSchema>(namespace: string): IRelationalQueryBuilder<NamespaceSchema>;
 };
+type ExtractProcessorSchemaOrSelf<TProcessor> = TProcessor extends RelationalDbProcessor<infer TSchema> ? TSchema : TProcessor;
+type RelationalDbProcessorClass<TSchema> = typeof RelationalDbProcessor<TSchema>;
+interface IRelationalDbProcessor<TDatabaseSchema = unknown> extends IProcessor {
+  namespace: string;
+  query: IRelationalQueryBuilder<TDatabaseSchema>;
+  filter: ProcessorFilter;
+  initAndUpgrade(): Promise<void>;
+}
+declare const IS_RELATIONAL_DB_PROCESSOR: unique symbol;
 /**
- * Canonical document-model version normalization: documents stamped with 0
- * or nothing at all predate versioning and are treated as version 1, the
- * same version the registry assigns unversioned modules. Every consumer
- * that resolves a module or compares versions must use this rule; resolving
- * 0 to "latest" instead re-pins a legacy document's history to whichever
- * module happens to be newest.
+ * Base class for relational db processors that require a relational database storage.
+ * This class abstracts database initialization, migration management, and resource cleanup,
+ * allowing derived classes to focus on business logic.
  */
-declare function normalizeDocumentModelVersion(version: number | undefined | null): number;
+declare abstract class RelationalDbProcessor<TDatabaseSchema = unknown> implements IRelationalDbProcessor<TDatabaseSchema> {
+  protected _namespace: string;
+  protected _filter: ProcessorFilter;
+  protected relationalDb: IRelationalDb<TDatabaseSchema>;
+  /** The drive the factory created this processor for. */
+  protected _driveId?: string | undefined;
+  constructor(_namespace: string, _filter: ProcessorFilter, relationalDb: IRelationalDb<TDatabaseSchema>,
+  /** The drive the factory created this processor for. */
+  _driveId?: string | undefined);
+  static [IS_RELATIONAL_DB_PROCESSOR]: boolean;
+  /**
+   * Returns the namespace for a given drive id.
+   * This method can be overridden by derived classes to provide a custom namespace.
+   */
+  static getNamespace(driveId: string): string;
+  static query<Schema>(this: RelationalDbProcessorClass<Schema>, driveId: string, db: IRelationalDb<any>): IRelationalQueryBuilder<Schema>;
+  /**
+   * Processes a list of operations with context.
+   * Called when operations match this processor's filter.
+   */
+  abstract onOperations(operations: OperationWithContext[]): Promise<void>;
+  /**
+   * Returns the filter for the processor.
+   * This method can be overridden by derived classes to provide a custom filter.
+   */
+  get filter(): ProcessorFilter;
+  /**
+   * Returns the namespace used by the processor.
+   */
+  get namespace(): string;
+  get query(): IRelationalQueryBuilder<TDatabaseSchema>;
+  /** True for this processor's drive when its namespace is that drive's alone. */
+  protected isNamespaceDrive(documentId: string): boolean;
+  /** Deletes a document's rows from every table with a document-id column. */
+  protected deleteDocumentRows(documentId: string): Promise<void>;
+  /** Drops this processor's namespace and every table in it. */
+  protected dropNamespace(): Promise<void>;
+  private namespaceSchema;
+  /**
+   * Abstract method that derived classes must implement.
+   * This method is meant to be called on subclasses to initialize and upgrade the database.
+   */
+  abstract initAndUpgrade(): Promise<void>;
+  /**
+   * Called when the processor is disconnected.
+   * This method is meant to be overridden by subclasses to clean up resources.
+   */
+  abstract onDisconnect(): Promise<void>;
+}
+//#endregion
+//#region processors/relational/utils.d.ts
 /**
- * Applies an UPGRADE_DOCUMENT action to a document.
- * Handles all upgrade scenarios including initial upgrades, no-ops, and multi-step upgrades.
- *
- * Behavior based on fromVersion/toVersion:
- * - fromVersion === toVersion (and fromVersion > 0): No-op - return unchanged document
- * - fromVersion > toVersion: Throw DowngradeNotSupportedError
- * - All other cases: Apply upgradePath transitions (if provided), then apply initialState, set version
+ * Hashes a string to a lowercase base-26 string.
+ * @param str The string to hash.
+ * @param length The length of the hash. Defaults to 10.
+ * @param algorithm The hashing algorithm to use. Defaults to "fnv1a".
+ * @returns The hashed string.
  */
-declare function applyUpgradeDocumentAction(document: PHDocument, action: UpgradeDocumentAction, upgradePath?: UpgradeTransition[]): PHDocument;
+declare function hashNamespace(str: string, length?: number): string;
 /**
- * Applies a DELETE_DOCUMENT action to a document.
- * Marks the document as deleted in the document scope state.
+ * Creates a RelationalDb instance with namespace support.
+ * @param baseDb The base RelationalDb instance to enhance.
+ * @param baseOptions The default options for namespace creation. Hashes namespace by default.
+ * @returns The enhanced RelationalDb instance.
  */
-declare function applyDeleteDocumentAction(document: PHDocument, action: DeleteDocumentAction): PHDocument;
+declare function createRelationalDb<Schema>(baseDb: IBaseRelationalDb<Schema>, baseOptions?: NamespaceOptions): IRelationalDb<Schema>;
+type NamespaceOptions = {
+  hashNamespace?: boolean;
+};
+declare function createNamespacedDb<Schema>(db: IBaseRelationalDb<any>, namespace: string, options?: NamespaceOptions): Promise<IRelationalDb<Schema>>;
+/** The schema behind a handle from `createNamespace`; undefined otherwise. */
+declare function namespaceSchemaOf(db: object): string | undefined;
+declare function createNamespacedQueryBuilder<Schema>(db: IBaseRelationalDb<any>, namespace: string, options?: NamespaceOptions): IRelationalQueryBuilder<Schema>;
 /**
- * Computes the ordered list of upgrade transitions needed to move from
- * fromVersion to toVersion using the provided manifest.
- * Walks keys v(fromVersion+1)..v(toVersion) and throws a descriptive Error
- * if the manifest is absent or any step is missing.
+ * Returns a query builder for a RelationalDb instance.
+ * @param query The RelationalDb instance to convert.
+ * @returns The IRelationalQueryBuilder instance.
  */
-declare function computeUpgradeTransitions(manifest: UpgradeManifest<readonly number[]> | undefined, fromVersion: number, toVersion: number): UpgradeTransition[];
+declare function relationalDbToQueryBuilder<TSchema>(query: IBaseRelationalDb<TSchema>): IRelationalQueryBuilder<TSchema>;
 //#endregion
 //#region document-model/types.d.ts
 type State = {
@@ -2342,11 +3493,11 @@ interface DocumentModelVersioningOperations {
 }
 type Maybe<T> = T | null;
 type InputMaybe<T> = T | null | undefined;
-type Exact<T extends Record<string, unknown>> = { [K in keyof T]: T[K] };
-type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
-type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
-type MakeEmpty<T extends Record<string, unknown>, K extends keyof T> = { [_ in K]?: never };
-type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never };
+type Exact<T extends Record<string, unknown>> = { [K in keyof T]: T[K]; };
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]>; };
+type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]>; };
+type MakeEmpty<T extends Record<string, unknown>, K extends keyof T> = { [_ in K]?: never; };
+type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never; };
 /** All built-in and custom scalars, mapped to their actual values */
 type Scalars = {
   ID: {
@@ -2407,28 +3558,6 @@ type IOperation = {
   timestampUtcMs: Scalars["DateTime"]["output"];
   type: Scalars["String"]["output"];
 };
-type Load_State = "LOAD_STATE";
-type SchemaLoadStateAction = {
-  id: Scalars["String"]["output"];
-  timestampUtcMs: Scalars["DateTime"]["output"];
-  input: LoadStateActionInput;
-  type: Load_State;
-  scope: string;
-};
-type LoadStateActionInput = {
-  operations: Scalars["Int"]["input"];
-  state: LoadStateActionStateInput;
-};
-type LoadStateActionStateInput = {
-  data?: InputMaybe<Scalars["Unknown"]["input"]>;
-  name: Scalars["String"]["input"];
-};
-type MutationLoadStateArgs = {
-  input: SchemaLoadStateAction;
-};
-type MutationPruneArgs = {
-  input: SchemaPruneAction;
-};
 type MutationRedoArgs = {
   input: SchemaRedoAction;
 };
@@ -2438,18 +3567,6 @@ type MutationSetNameArgs = {
 type MutationUndoArgs = {
   input: SchemaUndoAction;
 };
-type Prune = "PRUNE";
-type SchemaPruneAction = {
-  id: Scalars["String"]["output"];
-  timestampUtcMs: Scalars["DateTime"]["output"];
-  input: PruneActionInput;
-  type: Prune;
-  scope: string;
-};
-type PruneActionInput = {
-  end?: InputMaybe<Scalars["Int"]["input"]>;
-  start?: InputMaybe<Scalars["Int"]["input"]>;
-};
 type Query = {
   __typename?: "Query";
   document: Maybe<IDocument>;
@@ -2521,14 +3638,6 @@ type SchemaNOOPAction = {
   timestampUtcMs: Scalars["DateTime"]["output"];
   type: "NOOP";
 };
-type LoadStateAction = Action & {
-  type: "LOAD_STATE";
-  input: LoadStateActionInput;
-};
-type PruneAction = Action & {
-  type: "PRUNE";
-  input: PruneActionInput;
-};
 type RedoAction = Action & {
   type: "REDO";
   input: SchemaRedoAction["input"];
@@ -2585,6 +3694,13 @@ type DeleteDocumentActionInput = {
   documentId: string;
   propagate?: "none" | "cascade";
 };
+type PurgeDocumentActionInput = {
+  documentId: string;
+  documentType: string;
+  /** The same instant as the action's timestampUtcMs. */
+  purgedAtUtcIso: string;
+  requestId: string;
+};
 type AddRelationshipActionInput = {
   sourceId: string;
   targetId: string;
@@ -2614,6 +3730,12 @@ type DeleteDocumentAction = Action & {
   type: "DELETE_DOCUMENT";
   input: DeleteDocumentActionInput;
 };
+/** Reserved document-scope marker; a purged document's only operation. */
+type PurgeDocumentAction = Action & {
+  type: "PURGE_DOCUMENT";
+  scope: "document";
+  input: PurgeDocumentActionInput;
+};
 type AddRelationshipAction = Action & {
   type: "ADD_RELATIONSHIP";
   input: AddRelationshipActionInput;
@@ -2626,7 +3748,7 @@ type UpdateRelationshipAction = Action & {
   type: "UPDATE_RELATIONSHIP";
   input: UpdateRelationshipActionInput;
 };
-type DocumentAction = LoadStateAction | PruneAction | RedoAction | SetNameAction | SetPreferredEditorAction | UndoAction | NOOPAction;
+type DocumentAction = RedoAction | SetNameAction | SetPreferredEditorAction | UndoAction | NOOPAction;
 interface ISignal<TType extends string, TInput> {
   type: TType;
   input: TInput;
@@ -2663,19 +3785,27 @@ type SignalResults = {
 type SignalType<T extends Signal> = T["type"];
 type FileInput = string | number[] | Uint8Array | ArrayBuffer | Blob;
 type ReducerOptions = {
-  /** The number of operations to skip before this new action is applied. This overrides the skip count in the operation. */skip?: number; /** When true the skip count is ignored and the action is applied regardless of the skip count */
-  ignoreSkipOperations?: boolean; /** if true reuses the provided action resulting state instead of replaying it */
-  reuseOperationResultingState?: boolean; /** if true checks the hashes of the operations */
-  checkHashes?: boolean; /** Options for performing a replay. */
+  /** The number of operations to skip before this new action is applied. This overrides the skip count in the operation. */
+  skip?: number;
+  /** When true the skip count is ignored and the action is applied regardless of the skip count */
+  ignoreSkipOperations?: boolean;
+  /** if true reuses the provided action resulting state instead of replaying it */
+  reuseOperationResultingState?: boolean;
+  /** if true checks the hashes of the operations */
+  checkHashes?: boolean;
+  /** Options for performing a replay. */
   replayOptions?: {
-    /** The previously created operation to verify against. */operation: Operation;
-  }; /** Optional parser for the operation resulting state, uses JSON.parse by default */
+    /** The previously created operation to verify against. */
+    operation: Operation;
+  };
+  /** Optional parser for the operation resulting state, uses JSON.parse by default */
   operationResultingStateParser?: <TState>(state: string | null | undefined) => TState;
   /**
    * When true (default), the reducer will prune operations (garbage collect) when processing a skip.
    * When false, it will recompute state for the skip but preserve the existing operations history.
    */
-  pruneOnSkip?: boolean; /** The branch being operated on. Defaults to "main". */
+  pruneOnSkip?: boolean;
+  /** The branch being operated on. Defaults to "main". */
   branch?: string;
   /**
    * Protocol version controlling undo/redo behavior.
@@ -2726,7 +3856,7 @@ type User = {
   chainId: number;
   ens?: ENSInfo;
 };
-type PartialRecord<K extends keyof any, T> = { [P in K]?: T };
+type PartialRecord<K extends keyof any, T> = { [P in K]?: T; };
 type RevisionsFilter = PartialRecord<string, number>;
 type GetDocumentOptions = ReducerOptions & {
   revisions?: RevisionsFilter;
@@ -2806,13 +3936,14 @@ interface ISigner {
    */
   verify: (data: Uint8Array, signature: Uint8Array) => Promise<void>;
   /**
-   * Signs an action (used for operation signing).
+   * Signs an action for the log it is written to.
    *
    * @param action - The action to sign.
+   * @param target - The document and branch whose log stores the action.
    * @param abortSignal - Optional abort signal to cancel the signing.
    * @returns The signature tuple.
    */
-  signAction: (action: Action, abortSignal?: AbortSignal) => Promise<Signature>;
+  signAction: (action: Action, target: ActionSigningTarget, abortSignal?: AbortSignal) => Promise<Signature>;
 }
 type IsStateOfType<TState> = (state: unknown) => state is TState;
 type AssertIsStateOfType<TState> = (state: unknown) => asserts state is TState;
@@ -2831,6 +3962,9 @@ type MinimalBackupData = {
   branch: string;
   state: PHBaseState;
   name: string;
+  protocolVersions?: {
+    [key: string]: number;
+  };
 };
 type DocumentModelUtils<TState extends PHBaseState = PHBaseState> = {
   fileExtension: string;
@@ -2870,7 +4004,8 @@ type PhAiToolDescriptor = {
   callback: (args: never) => Promise<unknown>;
 };
 type DocumentModelModule<TState extends PHBaseState = PHBaseState> = {
-  /** optional version field, should be made required */version?: number;
+  /** optional version field, should be made required */
+  version?: number;
   reducer: Reducer<TState>;
   actions: Actions;
   utils: DocumentModelUtils<TState>;
@@ -2893,6 +4028,7 @@ type DocumentModelDocumentModelModule = DocumentModelModule<DocumentModelPHState
 type ConfigEntryType = z.infer<typeof ConfigEntryTypeSchema>;
 type ConfigEntry = z.infer<typeof ConfigEntrySchema>;
 type PowerhouseModule = z.infer<typeof PowerhouseModuleSchema>;
+type PieceModule = z.infer<typeof PieceModuleSchema>;
 type Publisher = z.infer<typeof PublisherSchema>;
 type Manifest = z.infer<typeof ManifestSchema>;
 //#endregion
@@ -2929,10 +4065,13 @@ type PHConnectDefaultDriveRemote = {
   icon?: string | null;
 };
 type PHConnectDefaultDriveLocal = {
-  /** Discriminator: this entry is a local drive created on first boot. */local: true; /** Stable drive id; the drive is not re-created on later boots. */
+  /** Discriminator: this entry is a local drive created on first boot. */
+  local: true;
+  /** Stable drive id; the drive is not re-created on later boots. */
   id: string;
   name?: string | null;
-  icon?: string | null; /** Drive app (preferred editor) to open on the drive. */
+  icon?: string | null;
+  /** Drive app (preferred editor) to open on the drive. */
   app?: string;
 };
 type PHConnectDefaultDrive = PHConnectDefaultDriveRemote | PHConnectDefaultDriveLocal;
@@ -2956,21 +4095,29 @@ type PHConnectApp = {
   basePath?: string;
   offline?: boolean;
   studioMode?: boolean;
+  workflowsEnabled?: boolean;
 };
 type PHConnectAi = {
-  /** Enables the in-browser AI assistant (chat FAB + window). Off by default. */assistantEnabled?: boolean;
+  /** Enables the in-browser AI assistant (chat FAB + window). Off by default. */
+  assistantEnabled?: boolean;
 };
 type PHConnectPackages = {
-  externalEnabled?: boolean; /** Subscribe to the static-mode `/__packages` SSE channel for live reload. */
+  externalEnabled?: boolean;
+  /** Subscribe to the static-mode `/__packages` SSE channel for live reload. */
   liveReload?: boolean;
 };
 type PHRenownRainbowAdapterConfig = {
-  /** WalletConnect project id; required for the rainbow adapter to function. */walletConnectProjectId?: string; /** Optional Infura project id used to build RPC transports. */
+  /** WalletConnect project id; required for the rainbow adapter to function. */
+  walletConnectProjectId?: string;
+  /** Optional Infura project id used to build RPC transports. */
   infuraProjectId?: string;
 };
 type PHRenownPrivyAdapterConfig = {
-  /** Privy application id; required for the privy adapter to function. */appId?: string; /** Optional Privy client id. */
-  clientId?: string; /** Login methods this adapter offers; defaults per adapter when omitted. */
+  /** Privy application id; required for the privy adapter to function. */
+  appId?: string;
+  /** Optional Privy client id. */
+  clientId?: string;
+  /** Login methods this adapter offers; defaults per adapter when omitted. */
   methods?: string[];
 };
 type PHConnectRenownAdapters = {
@@ -2980,30 +4127,72 @@ type PHConnectRenownAdapters = {
 type PHConnectRenown = {
   url?: string;
   networkId?: string;
-  chainId?: number; /** Renown localStorage namespace; share it across Connects to share login. */
-  namespace?: string; /** Switchboard GraphQL URL; when set, enables in-page (no-redirect) auth. */
-  switchboardUrl?: string; /** Per-adapter wallet config; presence of a key enables that adapter. */
+  chainId?: number;
+  /** Renown localStorage namespace; share it across Connects to share login. */
+  namespace?: string;
+  /** Switchboard GraphQL URL; when set, enables in-page (no-redirect) auth. */
+  switchboardUrl?: string;
+  /** Per-adapter wallet config; presence of a key enables that adapter. */
   adapters?: PHConnectRenownAdapters;
 };
 type PHConnectSentry = {
-  /** Sentry DSN URL. `null` disables Sentry entirely. */dsn?: string | null; /** Sentry environment label. */
-  env?: string; /** Enable Sentry performance tracing. */
+  /** Sentry DSN URL. `null` disables Sentry entirely. */
+  dsn?: string | null;
+  /** Sentry environment label. */
+  env?: string;
+  /** Enable Sentry performance tracing. */
   tracing?: boolean;
 };
+type PHConnectOpenPanel = {
+  /** OpenPanel client id. Empty string (the default) disables OpenPanel. */
+  clientId?: string;
+  /** OpenPanel API URL, for self-hosted instances. */
+  apiUrl?: string;
+  /** Track UI events. */
+  trackUiEvents?: boolean;
+  /** Track document operations. */
+  trackOperations?: boolean;
+};
+/**
+ * Which reactor client Connect runs. One field selects all four shapes the
+ * multi-reactor work standardized (each a peer `IReactorClient`):
+ *  - `in-process`: the tab's own reactor on the main thread (PGlite in-tab).
+ *  - `worker`:     the tab's own reactor in a SharedWorker (PGlite in-worker).
+ *  - `remote`:     a pure client to a remote Switchboard reactor over GraphQL,
+ *                  with NO local reactor and NO PGlite download.
+ *  - `router`:     the tab's reactor (local) PLUS remote backends, routed.
+ * Derived from the host's reactor backends (see reactorClientMode): a lone
+ * remote backend -> `remote`, local+remote -> `router`, a worker backend ->
+ * `worker`, else `in-process`. When unset, Connect falls back to the legacy
+ * `reactorWorker`/`multiReactor` booleans, so existing configs are unchanged.
+ */
+type PHReactorClientMode = "in-process" | "worker" | "remote" | "router";
 type PHConnectInstance = {
   namespace: string | null;
   reactorWorker: boolean;
+  /** Routes through the in-browser reactor plus remote backends. Off by default. */
+  multiReactor?: boolean;
+  /** Explicit client selection; supersedes reactorWorker/multiReactor when set. */
+  reactorClient?: PHReactorClientMode;
 };
 /** Each flag implies its predecessors, and must match the fleet Connect syncs
  * with or the two compute different replay outcomes. */
 type PHConnectReactorFeatureFlags = {
-  /** Decide writes from the document stream instead of the meta cache. */documentDecisions?: boolean; /** Enforce the auth scope's policy at admission, replay, and read. */
-  authEnforcement?: boolean; /** Let `{ group }` principals match, via the group documents' rosters. */
-  authGroups?: boolean; /** Evaluate `where` / `match` conditions on grants. */
+  /** Decide writes from the document stream instead of the meta cache. */
+  documentDecisions?: boolean;
+  /** Enforce the auth scope's policy at admission, replay, and read. */
+  authEnforcement?: boolean;
+  /** Let `{ group }` principals match, via the group documents' rosters. */
+  authGroups?: boolean;
+  /** Evaluate `where` / `match` conditions on grants. */
   authConditions?: boolean;
 };
 type PHConnectReactor = {
   featureFlags?: PHConnectReactorFeatureFlags;
+  /** What new documents are created as; `legacy` while peers predate v2-required documents. */
+  createSignaturePolicy?: "legacy" | "v2-required";
+  /** Stored documents at protocol versions this build does not run: refuse to boot, or keep them read-only. */
+  unsupportedStoredDocuments?: "refuse" | "read-only";
 };
 /**
  * A URL-matching pattern for a service-worker runtime-caching rule, in
@@ -3052,7 +4241,9 @@ type PHConnectPwaIcon = {
  * at Connect's app root, injected at build time.
  */
 type PHConnectPwaFileHandler = {
-  /** MIME type → file extensions (each must start with "."). */accept: Record<string, string[]>; /** OS-level file-type icons. */
+  /** MIME type → file extensions (each must start with "."). */
+  accept: Record<string, string[]>;
+  /** OS-level file-type icons. */
   icons?: PHConnectPwaIcon[];
   launch_type?: "single-client" | "multiple-clients";
 };
@@ -3066,8 +4257,10 @@ type PHConnectPwaManifest = {
   display?: "fullscreen" | "standalone" | "minimal-ui" | "browser";
   start_url?: string;
   scope?: string;
-  icons?: PHConnectPwaIcon[]; /** Extra file associations, appended after Connect's built-in `.phd`/`.phdm` handler. */
-  file_handlers?: PHConnectPwaFileHandler[]; /** How the OS launches the app for handled files/links. */
+  icons?: PHConnectPwaIcon[];
+  /** Extra file associations, appended after Connect's built-in `.phd`/`.phdm` handler. */
+  file_handlers?: PHConnectPwaFileHandler[];
+  /** How the OS launches the app for handled files/links. */
   launch_handler?: {
     client_mode: "auto" | "focus-existing" | "navigate-existing" | "navigate-new";
   };
@@ -3087,14 +4280,30 @@ type PHConnectPwaManifest = {
  * Precedence: defaults < package fragments < project config.
  */
 type PHConnectPwa = {
-  manifest?: PHConnectPwaManifest; /** Extra Workbox precache globs, unioned with the built-in patterns. */
-  globPatterns?: string[]; /** Extra Workbox precache ignore globs, unioned with the built-in list. */
-  globIgnores?: string[]; /** Raise the precache file-size ceiling; the max across contributors wins. */
-  maximumFileSizeToCacheInBytes?: number; /** Additional runtime-caching rules, appended after the built-in rules. */
-  runtimeCaching?: PHConnectPwaRuntimeCaching[]; /** Extra SPA-fallback denylist patterns, unioned with the built-in list. */
+  manifest?: PHConnectPwaManifest;
+  /** Extra Workbox precache globs, unioned with the built-in patterns. */
+  globPatterns?: string[];
+  /** Extra Workbox precache ignore globs, unioned with the built-in list. */
+  globIgnores?: string[];
+  /** Raise the precache file-size ceiling; the max across contributors wins. */
+  maximumFileSizeToCacheInBytes?: number;
+  /** Additional runtime-caching rules, appended after the built-in rules. */
+  runtimeCaching?: PHConnectPwaRuntimeCaching[];
+  /** Extra SPA-fallback denylist patterns, unioned with the built-in list. */
   navigateFallbackDenylist?: PHConnectPwaUrlPattern[];
 };
+/** One entry of the host.js composition, projected into the served config as
+ * DATA (module specifier + validated config) — the browser pipeline resolves
+ * and runs them (rewire R3). Verb filtering happens at the runner. */
+type PHConnectCompositionEntry = {
+  module: string;
+  config?: Record<string, unknown>;
+};
 type PHConnectRuntimeConfig = {
+  /** The plugin composition this Connect boots with (rewire R3): present
+   * only when the host file declares runner.plugins — absent means the
+   * classic defaults. */
+  composition?: PHConnectCompositionEntry[];
   branding?: PHConnectBranding;
   app?: PHConnectApp;
   ai?: PHConnectAi;
@@ -3102,6 +4311,7 @@ type PHConnectRuntimeConfig = {
   drives?: PHConnectDrives;
   renown?: PHConnectRenown;
   sentry?: PHConnectSentry;
+  openPanel?: PHConnectOpenPanel;
   instance?: PHConnectInstance;
   reactor?: PHConnectReactor;
   pwa?: PHConnectPwa;
@@ -3110,8 +4320,10 @@ type PHConnectRuntimeConfig = {
 type PHReactorRenown = {
   /** "self" reads this reactor's own renown read model; "remote" (default)
    * queries a Renown or Switchboard instance. */
-  source?: "remote" | "self"; /** Renown base URL; also the instance this reactor's own identity uses. */
-  url?: string; /** Switchboard GraphQL endpoint to read credentials from directly. */
+  source?: "remote" | "self";
+  /** Renown base URL; also the instance this reactor's own identity uses. */
+  url?: string;
+  /** Switchboard GraphQL endpoint to read credentials from directly. */
   switchboardUrl?: string;
 };
 type PowerhouseConfig = {
@@ -3159,9 +4371,13 @@ type PowerhouseConfig = {
     driveUrl?: string;
     connectPort?: number;
   };
+  workflows?: {
+    enabled?: boolean;
+  };
   packageRegistryUrl?: string;
   connect?: PHConnectRuntimeConfig;
 };
 //#endregion
-export { AddOperationExampleAction as $, UpgradeReducer as $a, deleteOperationExample as $c, SetOperationErrorCodeAction as $i, baseCreateDocument as $l, MutationDeleteOperationErrorArgs as $n, SetAuthorWebsiteInputSchema as $o, RedoActionInput as $r, ProcessorDispatchResult as $s, DocumentModelOperationExampleOperations as $t, PHDocumentState as $u, PHReactorRenown as A, SigningParameters as Aa, WebhookSignatureEncoding as Ac, SetAuthorNameAction as Ai, setOperationErrorDescription as Al, LoadStateActionInput as An, ModuleSchema as Ao, MutationSetOperationTemplateArgs as Ar, UpdateStateExampleInputSchema as As, DeleteOperationErrorInput as At, sortMappedOperations as Au, DEFAULT_REGISTRY_URL as B, UpdateChangeLogItemAction as Ba, addModule as Bc, SetModelIdAction as Bi, undo as Bl, ModuleSpecification as Bn, PublisherSchema as Bo, OperationsByScope as Br, IBaseRelationalDb as Bs, DocumentModelGlobalState as Bt, operationOutcome as Bu, PHConnectReactor as C, Set_PreferredEditor as Ca, WebhookEndpointInfo as Cc, DEFAULT_ANALYTICS_PROCESSOR_DB_NAME as Cd, SchemaNOOPAction as Ci, setModelId as Cl, Incremental as Cn, DocumentModelInputSchema as Co, MutationSetOperationErrorCodeArgs as Cr, Set_PreferredEditorSchema as Cs, DeleteChildDocumentSignal as Ct, prepareOperations as Cu, PHConnectRuntimeConfig as D, SignalResults as Da, WebhookReply as Dc, SchemaSetPreferredEditorAction as Di, setName as Dl, LoadFromFile as Dn, LoadStateActionStateInputSchema as Do, MutationSetOperationNameArgs as Dr, UndoSchema as Ds, DeleteModuleInput as Dt, reshuffleByTimestamp as Du, PHConnectRenownAdapters as E, SignalResult as Ea, WebhookPolicy as Ec, SchemaSetNameAction as Ei, setModuleName as El, IsStateOfType as En, LoadStateActionSchema as Eo, MutationSetOperationErrorTemplateArgs as Er, UndoActionSchema as Es, DeleteModuleAction as Et, replayDocument as Eu, PathValidation as F, SubgraphModule as Fa, actionContext as Fc, SetInitialStateInput as Fi, setOperationSchema as Fl, MakeOptional as Fn, PowerhouseModuleSchema as Fo, MutationUpdateStateExampleArgs as Fr, createRelationalDb as Fs, DeleteStateExampleInput as Ft, Operation as Fu, Actions as G, UpdateRelationshipActionInput as Ga, baseActions as Gc, SetModuleDescriptionInput as Gi, IntegrityIssueSubType as Gl, MutationAddModuleArgs as Gn, ReorderChangeLogItemsInputSchema as Go, PowerhouseModule as Gr, RelationalDbProcessor as Gs, DocumentModelLocalState as Gt, undoOperationV2 as Gu, ActionSignatureContext as H, UpdateOperationExampleAction as Ha, addOperationError as Hc, SetModelNameAction as Hi, updateOperationExample as Hl, MoveOperationInput as Hn, RedoActionInputSchema as Ho, PartialState as Hr, IRelationalDbProcessor as Hs, DocumentModelHeaderOperations as Ht, setNameOperation as Hu, PowerhouseConfig as I, Undo as Ia, actionFromAction as Ic, SetModelDescriptionAction as Ii, setOperationScope as Il, Manifest as In, PowerhouseModulesSchema as Io, NOOPAction as Ir, hashNamespace as Is, DocumentAction as It, OperationContext as Iu, AddModuleAction as J, UpgradeDocumentAction as Ja, createAction as Jc, SetNameAction as Ji, PHDocumentHeader as Jl, MutationAddOperationExampleArgs as Jn, ReorderOperationErrorsInputSchema as Jo, PruneActionInput as Jr, IProcessorDispatch as Js, DocumentModelModuleOperations as Jt, Condition as Ju, AddChangeLogItemAction as K, UpdateStateExampleAction as Ka, buildOperationSignature as Kc, SetModuleNameAction as Ki, IntegrityIssueType as Kl, MutationAddOperationArgs as Kn, ReorderModuleOperationsInputSchema as Ko, Prune as Kr, RelationalDbProcessorClass as Ks, DocumentModelModule as Kt, AuthGroups as Ku, PowerhousePackage as L, UndoAction as La, actionSigner as Lc, SetModelDescriptionInput as Li, setOperationTemplate as Ll, MappedOperation as Ln, PruneActionInputSchema as Lo, OperationErrorSpecification as Lr, relationalDbToQueryBuilder as Ls, DocumentModelAction as Lt, OperationOutcome as Lu, PHRenownRainbowAdapterConfig as M, SkipHeaderOperations as Ma, WebhookVerification as Mc, SetAuthorWebsiteAction as Mi, setOperationErrorTemplate as Ml, Load_State as Mn, OperationErrorSchema as Mo, MutationUndoArgs as Mr, isDefinedNonNullAny as Ms, DeleteOperationExampleInput as Mt, split as Mu, PackageManagerArgs as N, State as Na, Action as Nc, SetAuthorWebsiteInput as Ni, setOperationName as Nl, MakeEmpty as Nn, OperationScopeSchema as No, MutationUpdateChangeLogItemInputArgs as Nr, createNamespacedDb as Ns, DeleteOperationInput as Nt, updateHeaderRevision as Nu, PHConnectSentry as O, SignalType as Oa, WebhookRequest as Oc, SchemaUndoAction as Oi, setOperationDescription as Ol, LoadFromInput as On, Load_StateSchema as Oo, MutationSetOperationReducerArgs as Or, UpdateChangeLogItemInputSchema as Os, DeleteOperationAction as Ot, reshuffleByTimestampAndIndex as Ou, ParsedCmdResult as P, StateReducer as Pa, ActionContext as Pc, SetInitialStateAction as Pi, setOperationReducer as Pl, MakeMaybe as Pn, OperationSpecificationSchema as Po, MutationUpdateOperationExampleArgs as Pr, createNamespacedQueryBuilder as Ps, DeleteStateExampleAction as Pt, DocumentOperations as Pu, AddOperationErrorInput as Q, UpgradeManifest as Qa, deleteOperationError as Qc, SetOperationDescriptionInput as Qi, attachBranch as Ql, MutationDeleteOperationArgs as Qn, SetAuthorNameInputSchema as Qo, RedoAction as Qr, ProcessorApps as Qs, DocumentModelOperationExampleAction as Qt, PHBaseState as Qu, ServiceAction as R, UndoActionInput as Ra, actions as Rc, SetModelExtensionAction as Ri, setPreferredEditor as Rl, Maybe as Rn, PruneActionSchema as Ro, OperationIndex as Rr, ExtractProcessorSchemaOrSelf as Rs, DocumentModelDocument as Rt, OperationWithContext$1 as Ru, PHConnectPwaUrlPattern as S, Set_Name as Sa, ScopedRouteHandle as Sc, serializeSignature as Sd, SchemaLoadStateAction as Si, setModelExtension as Sl, ISigner as Sn, DocumentModelGlobalStateSchema as So, MutationSetOperationDescriptionArgs as Sr, Set_NameSchema as Ss, DeleteChildDocumentInput as St, precedes as Su, PHConnectRenown as T, SignalDispatch as Ta, WebhookHashAlgorithm as Tc, PROCESSOR_APPS as Td, SchemaRedoAction as Ti, setModuleDescription as Tl, IsDocumentOfType as Tn, LoadStateActionInputSchema as To, MutationSetOperationErrorNameArgs as Tr, UndoActionInputSchema as Ts, DeleteDocumentActionInput as Tt, removeExistingOperations as Tu, ActionSigningHandler as U, UpdateOperationExampleInput as Ua, addOperationExample as Uc, SetModelNameInput as Ui, updateStateExample as Ul, Mutation as Un, RedoActionSchema as Uo, PhAiToolAnnotations as Ur, IRelationalQueryBuilder as Us, DocumentModelInput as Ut, setPreferredEditorOperation as Uu, ActionErrorCallback as V, UpdateChangeLogItemInput as Va, addOperation as Vc, SetModelIdInput as Vi, updateChangeLogItem as Vl, MoveOperationAction as Vn, PwaConfigSchema as Vo, PartialRecord as Vr, IRelationalDb as Vs, DocumentModelHeaderAction as Vt, redoOperation as Vu, ActionVerificationHandler as W, UpdateRelationshipAction as Wa, addStateExample as Wc, SetModuleDescriptionAction as Wi, verifyOperationSignature as Wl, MutationAddChangeLogItemInputArgs as Wn, RedoSchema as Wo, PhAiToolDescriptor as Wr, IRelationalQueryMethods as Ws, DocumentModelLib as Wt, undoOperation as Wu, AddOperationAction as X, User as Xa, deleteModule as Xc, SetNameOperation as Xi, addUndo as Xl, MutationDeleteChangeLogItemInputArgs as Xn, ReorderStateExamplesInputSchema as Xo, Query as Xr, IProcessorManager as Xs, DocumentModelOperationErrorAction as Xt, Operand as Xu, AddModuleInput as Y, UpgradeDocumentActionInput as Ya, deleteChangeLogItem as Yc, SetNameActionInput as Yi, PHDocumentMeta as Yl, MutationAddStateExampleArgs as Yn, ReorderOperationExamplesInputSchema as Yo, Publisher as Yr, IProcessorHostModuleBase as Ys, DocumentModelOperationAction as Yt, Grant as Yu, AddOperationErrorAction as Z, ValidationError as Za, deleteOperation as Zc, SetOperationDescriptionAction as Zi, appendWithoutApplying as Zl, MutationDeleteModuleArgs as Zn, ScopeStateSchema as Zo, Redo as Zr, ProcessorApp as Zs, DocumentModelOperationErrorOperations as Zt, PHAuthState as Zu, PHConnectPwaCacheStrategy as _, SetPreferredEditorAction as _a, RouteMethod as _c, HashConfig as _d, ReplayDocumentOptions as _i, reorderStateExamples as _l, ID as _n, DeleteOperationErrorInputSchema as _o, MutationSetModelIdArgs as _r, SetOperationScopeInputSchema as _s, CreateDocumentAction as _t, mapSkippedOperationsV2 as _u, PHConnectAi as a, SetOperationErrorTemplateAction as aa, TrackedProcessor as ac, createDocumentState as ad, ReorderChangeLogItemsAction as ai, operationExampleCreators as al, DocumentModelVersioningAction as an, AddChangeLogItemInputSchema as ao, MutationRedoArgs as ar, SetModuleDescriptionInputSchema as as, AddStateExampleInput as at, filterDuplicatedOperations as au, PHConnectPwaManifest as b, SetStateSchemaAction as ba, RouteTransport as bc, UserActionSigner as bd, SaveToFileHandle as bi, setInitialState as bl, ISignal as bn, DeleteStateExampleInputSchema as bo, MutationSetModuleNameArgs as br, SetPreferredEditorActionSchema as bs, DeleteChangeLogItemAction as bt, operationsAreEqual as bu, PHConnectDefaultDrive as c, SetOperationNameInput as ca, IWebhookEndpoints as cc, createState as cd, ReorderModuleOperationsInput as ci, operationWithContext as cl, DocumentSpecification as cn, AddOperationExampleInputSchema as co, MutationReorderModulesArgs as cr, SetNameActionSchema as cs, Author as ct, garbageCollectV2 as cu, PHConnectDriveSection as d, SetOperationSchemaAction as da, RouteActor as dc, defaultDocumentState as dd, ReorderOperationErrorsAction as di, releaseNewVersion as dl, EditorModule as dn, AuthorSchema as do, MutationReorderStateExamplesArgs as dr, SetOperationErrorDescriptionInputSchema as ds, ConfigEntryType as dt, hashDocumentStateForScope as du, SetOperationErrorCodeInput as ea, ProcessorFactory as ec, PHGroupState as ed, Reducer as ei, deleteStateExample as el, DocumentModelOperationOperations as en, UpgradeTransition as eo, MutationDeleteOperationExampleArgs as er, SetInitialStateInputSchema as es, AddOperationExampleInput as et, baseReducerVersion as eu, PHConnectDriveSections as f, SetOperationSchemaInput as fa, RouteAuth as fc, defaultGlobalState as fd, ReorderOperationErrorsInput as fi, reorderChangeLogItems as fl, EditorProps as fn, CodeExampleSchema as fo, MutationSetAuthorNameArgs as fr, SetOperationErrorNameInputSchema as fs, CopyChildDocumentInput as ft, isDocumentAction as fu, PHConnectPwa as g, SetOperationTemplateInput as ga, RouteHandler as gc, AppActionSigner as gd, ReorderStateExamplesInput as gi, reorderOperationExamples as gl, IAction as gn, DeleteModuleInputSchema as go, MutationSetModelExtensionArgs as gr, SetOperationSchemaInputSchema as gs, CreateDocument as gt, mapSkippedOperations as gu, PHConnectPackages as h, SetOperationTemplateAction as ha, RouteContext as hc, ActionSigner as hd, ReorderStateExamplesAction as hi, reorderOperationErrors as hl, GetDocumentOptions as hn, DeleteChangeLogItemInputSchema as ho, MutationSetModelDescriptionArgs as hr, SetOperationReducerInputSchema as hs, CreateChildDocumentSignal as ht, isUndoRedo as hu, LogLevels as i, SetOperationErrorNameInput as ia, ProcessorStatus as ic, createBaseState as id, RemoveRelationshipActionInput as ii, noop as il, DocumentModelUtils as in, normalizeDocumentModelVersion as io, MutationPruneArgs as ir, SetModelNameInputSchema as is, AddStateExampleAction as it, filterDocumentOperationsResultingState as iu, PHRenownPrivyAdapterConfig as j, SkipHeaderOperationIndex as ja, WebhookSpec as jc, SetAuthorNameInput as ji, setOperationErrorName as jl, LoadStateActionStateInput as jn, MoveOperationInputSchema as jo, MutationSetStateSchemaArgs as jr, definedNonNullAnySchema as js, DeleteOperationExampleAction as jt, sortOperations as ju, PHPackageProvider as k, SignatureVerificationHandler as ka, WebhookScheme as kc, ScopeState as ki, setOperationErrorCode as kl, LoadStateAction as kn, ManifestSchema as ko, MutationSetOperationSchemaArgs as kr, UpdateOperationExampleInputSchema as ks, DeleteOperationErrorAction as kt, skipHeaderOperations as ku, PHConnectDefaultDriveLocal as l, SetOperationReducerAction as la, IWebhookScope as lc, defaultAuthState as ld, ReorderModulesAction as li, prune as ll, ENSInfo as ln, AddOperationInputSchema as lo, MutationReorderOperationErrorsArgs as lr, SetOperationDescriptionInputSchema as ls, CodeExample as lt, getDocumentLastModified as lu, PHConnectInstance as m, SetOperationScopeInput as ma, RouteBody as mc, defaultPHState as md, ReorderOperationExamplesInput as mi, reorderModules as ml, FileInput as mn, ConfigEntryTypeSchema as mo, MutationSetInitialStateArgs as mr, SetOperationNameInputSchema as ms, CreateChildDocumentInput as mt, isUndo as mu, DrivePreserveStrategy as n, SetOperationErrorDescriptionInput as na, ProcessorFilter as nc, backfillAuthState as nd, ReleaseNewVersionAction as ni, loadState as nl, DocumentModelStateAction as nn, applyUpgradeDocumentAction as no, MutationLoadStateArgs as nr, SetModelExtensionInputSchema as ns, AddRelationshipAction as nt, checkOperationsIntegrity as nu, PHConnectApp as o, SetOperationErrorTemplateInput as oa, AuthorizerResult as oc, createGlobalState as od, ReorderChangeLogItemsInput as oi, operationFromAction as ol, DocumentModelVersioningOperations as on, AddModuleInputSchema as oo, MutationReorderChangeLogItemsInputArgs as or, SetModuleNameInputSchema as os, AssertIsDocumentOfType as ot, garbageCollect as ou, PHConnectDrives as p, SetOperationScopeAction as pa, RouteAuthorizer as pc, defaultLocalState as pd, ReorderOperationExamplesAction as pi, reorderModuleOperations as pl, Exact as pn, ConfigEntrySchema as po, MutationSetAuthorWebsiteArgs as pr, SetOperationErrorTemplateInputSchema as ps, CopyChildDocumentSignal as pt, isNoopOperation as pu, AddChangeLogItemInput as q, UpdateStateExampleInput as qa, buildSignedAction as qc, SetModuleNameInput as qi, PHDocument as ql, MutationAddOperationErrorArgs as qn, ReorderModulesInputSchema as qo, PruneAction as qr, IProcessor as qs, DocumentModelModuleAction as qt, Capability as qu, LogLevel as r, SetOperationErrorNameAction as ra, ProcessorRecord as rc, createAuthState as rd, RemoveRelationshipAction as ri, moveOperation as rl, DocumentModelStateOperations as rn, computeUpgradeTransitions as ro, MutationMoveOperationArgs as rr, SetModelIdInputSchema as rs, AddRelationshipActionInput as rt, diffOperations as ru, PHConnectBranding as s, SetOperationNameAction as sa, IHttpScope as sc, createLocalState as sd, ReorderModuleOperationsAction as si, operationFromOperation as sl, DocumentOperationsIgnoreMap as sn, AddOperationErrorInputSchema as so, MutationReorderModuleOperationsArgs as sr, SetNameActionInputSchema as ss, AssertIsStateOfType as st, garbageCollectDocumentOperations as su, DrivePreserveStrategies as t, SetOperationErrorDescriptionAction as ta, ProcessorFactoryBuilder as tc, Principal as td, ReducerOptions as ti, documentModelActions as tl, DocumentModelPHState as tn, applyDeleteDocumentAction as to, MutationDeleteStateExampleArgs as tr, SetModelDescriptionInputSchema as ts, AddOperationInput as tt, checkCleanedOperationsIntegrity as tu, PHConnectDefaultDriveRemote as u, SetOperationReducerInput as ua, NodeRouteSpec as uc, defaultBaseState as ud, ReorderModulesInput as ui, redo as ul, EditorDispatch as un, AddStateExampleInputSchema as uo, MutationReorderOperationExamplesArgs as ur, SetOperationErrorCodeInputSchema as us, ConfigEntry as ut, groupOperationsByScope as uu, PHConnectPwaFileHandler as v, SetPreferredEditorActionInput as va, RouteOptions as vc, PHDocumentSignatureInfo as vd, RevisionsFilter as vi, setAuthorName as vl, IDocument as vn, DeleteOperationExampleInputSchema as vo, MutationSetModelNameArgs as vr, SetOperationTemplateInputSchema as vs, CreateDocumentActionInput as vt, merge as vu, PHConnectReactorFeatureFlags as w, Signal as wa, WebhookField as wc, DEFAULT_RELATIONAL_PROCESSOR_DB_NAME as wd, SchemaPruneAction as wi, setModelName as wl, InputMaybe as wn, DocumentSpecificationSchema as wo, MutationSetOperationErrorDescriptionArgs as wr, StateSchema as ws, DeleteDocumentAction as wt, readOnly as wu, PHConnectPwaRuntimeCaching as x, SetStateSchemaInput as xa, RouteUser as xc, deserializeSignature as xd, Scalars as xi, setModelDescription as xl, ISignalResult as xn, DocumentActionSchema as xo, MutationSetNameArgs as xr, SetStateSchemaInputSchema as xs, DeleteChangeLogItemInput as xt, parseResultingState as xu, PHConnectPwaIcon as y, SetPreferredEditorOperation as ya, RouteSpec as yc, Signature as yd, SaveToFile as yi, setAuthorWebsite as yl, IOperation as yn, DeleteOperationInputSchema as yo, MutationSetModuleDescriptionArgs as yr, SetPreferredEditorActionInputSchema as ys, CreateState as yt, nextSkipNumber as yu, ServiceActions as z, UndoRedoAction as za, addChangeLogItem as zc, SetModelExtensionInput as zi, setStateSchema as zl, MinimalBackupData as zn, PruneSchema as zo, OperationSpecification as zr, HashAlgorithms as zs, DocumentModelDocumentModelModule as zt, loadStateOperation as zu };
-//# sourceMappingURL=types-CpnWmiFY.d.ts.map
+export { AddOperationAction as $, DOCUMENT_ID_COLUMNS as $a, updateDocument as $c, isDocumentCreator as $d, releaseNewVersion as $f, SetOperationErrorNameInput as $i, VersionedReplayConfig as $l, isDerivedDocumentId as $m, MutationDeleteOperationExampleArgs as $n, assertModuleIdUnique as $o, hashDocumentStateForScope as $p, ReleaseNewVersionAction as $r, ReorderModuleOperationsInputSchema as $s, DocumentModelOperationErrorAction as $t, documentModelInitialGlobalState as $u, PHConnectSentry as A, SubgraphModule as Aa, Set_PreferredEditorSchema as Ac, InitializeAuthActionInput as Ad, addModule as Af, SetInitialStateInput as Ai, createSignedHeader as Al, PHDocumentState as Am, LoadFromFile as An, RouteBody as Ao, updateOperationExample as Ap, MutationUpdateChangeLogItemInputArgs as Ar, DeleteOperationExampleInputSchema as As, DeleteModuleInput as At, isDocumentModelDocument as Au, PowerhousePackage as B, UpdateRelationshipActionInput as Ba, documentModelHeaderReducer as Bc, SetGrantActionInput as Bd, deleteModule as Bf, SetModuleDescriptionInput as Bi, baseSaveToFileHandle as Bl, defaultAuthState as Bm, MoveOperationAction as Bn, WebhookField as Bo, attachBranch as Bp, PhAiToolAnnotations as Br, OperationErrorSchema as Bs, DocumentModelAction as Bt, buildOperationSignatureMessage as Bu, PHConnectPwaRuntimeCaching as C, SignalType as Ca, SetOperationSchemaInputSchema as Cc, AuthEvaluation as Cd, Action as Cf, serializeSignature as Ch, SchemaUndoAction as Ci, manifestRevision as Cl, AuthGroups as Cm, ISignal as Cn, IHttpScope as Co, setOperationSchema as Cp, MutationSetOperationErrorTemplateArgs as Cr, AuthorSchema as Cs, DeleteChangeLogItemAction as Ct, BaseDocumentHeaderSchema as Cu, PHConnectRenown as D, SkipHeaderOperations as Da, SetPreferredEditorActionSchema as Dc, AuthVerb as Dd, actionSigner as Df, SetAuthorWebsiteAction as Di, selectProtocolVersions as Dl, Operand as Dm, InputMaybe as Dn, RouteActor as Do, setStateSchema as Dp, MutationSetOperationTemplateArgs as Dr, DeleteChangeLogItemInputSchema as Ds, DeleteDocumentAction as Dt, DocumentModelSchema as Du, PHConnectReactorFeatureFlags as E, SkipHeaderOperationIndex as Ea, SetPreferredEditorActionInputSchema as Ec, AuthSubject as Ed, actionFromAction as Ef, PROCESSOR_APPS as Eh, SetAuthorNameInput as Ei, readPeerManifest as El, Grant as Em, Incremental as En, NodeRouteSpec as Eo, setPreferredEditor as Ep, MutationSetOperationSchemaArgs as Er, ConfigEntryTypeSchema as Es, DeleteChildDocumentSignal as Et, DocumentModelPHStateSchema as Eu, PHRenownRainbowAdapterConfig as F, UpdateChangeLogItemAction as Fa, UpdateChangeLogItemInputSchema as Fc, MoveGrantActionInputSchema as Fd, baseActions as Ff, SetModelIdAction as Fi, validateHeader as Fl, createBaseState as Fm, Manifest as Fn, RouteSpec as Fo, PHDocument as Fp, OperationIndex as Fr, DocumentModelInputSchema as Fs, DeleteOperationExampleInput as Ft, DOCUMENT_DELETED_REASON as Fu, ActionSignatureContext as G, User as Ga, documentModelReducer as Gc, applyRemoveGrantAction as Gd, documentModelActions as Gf, SetNameOperation as Gi, fetchFileBrowser as Gl, defaultPHState as Gm, MutationAddOperationArgs as Gn, WebhookScheme as Go, diffOperations as Gp, PurgeDocumentAction as Gr, PowerhouseModuleSchema as Gs, DocumentModelHeaderOperations as Gt, hex2ab as Gu, ServiceActions as H, UpdateStateExampleInput as Ha, documentModelOperationErrorReducer as Hc, applyAuthAction as Hd, deleteOperationError as Hf, SetModuleNameInput as Hi, createZip as Hl, defaultDocumentState as Hm, Mutation as Hn, WebhookPolicy as Ho, baseReducerVersion as Hp, PieceModule as Hr, OperationSpecificationSchema as Hs, DocumentModelDocumentModelModule as Ht, bytesToBase64Url as Hu, PackageManagerArgs as I, UpdateChangeLogItemInput as Ia, UpdateOperationExampleInputSchema as Ic, RemoveGrantAction as Id, buildOperationSignature as If, SetModelIdInput as Ii, verify as Il, createDocumentState as Im, MappedOperation as In, RouteTransport as Io, PHDocumentHeader as Ip, OperationSpecification as Ir, DocumentSpecificationSchema as Is, DeleteOperationInput as It, isDenied as Iu, Actions as J, createNamespacedQueryBuilder as Ja, documentModelVersioningReducer as Jc, assertAuthScopeActionAllowed as Jd, operationExampleCreators as Jf, SetOperationErrorCodeAction as Ji, parseBulkArchive as Jl, ProtocolVersions as Jm, MutationAddStateExampleArgs as Jn, WebhookVerification as Jo, garbageCollect as Jp, Redo as Jr, PwaConfigSchema as Js, DocumentModelLocalState as Jt, HASH_ALGORITHM_SHA512 as Ju, ActionSigningHandler as K, ValidationError as Ka, documentModelStateReducer as Kc, applySetGrantAction as Kd, moveOperation as Kf, SetOperationDescriptionAction as Ki, getFileBrowser as Kl, DEFAULT_SIGNATURE_POLICY as Km, MutationAddOperationErrorArgs as Kn, WebhookSignatureEncoding as Ko, filterDocumentOperationsResultingState as Kp, PurgeDocumentActionInput as Kr, PowerhouseModulesSchema as Ks, DocumentModelInput as Kt, HASH_ALGORITHM_SHA1 as Ku, ParsedCmdResult as L, UpdateOperationExampleAction as La, UpdateStateExampleInputSchema as Lc, RemoveGrantActionInput as Ld, buildSignedAction as Lf, SetModelNameAction as Li, BulkArchiveEntry as Ll, createGlobalState as Lm, Maybe as Ln, RouteUser as Lo, PHDocumentMeta as Lp, OperationsByScope as Lr, ManifestSchema as Ls, DeleteStateExampleAction as Lt, ab2hex as Lu, PHReactorClientMode as M, UndoAction as Ma, UndoActionInputSchema as Mc, MAX_SUPPORTED_AUTH_VERSION as Md, addOperationError as Mf, SetModelDescriptionInput as Mi, createVerificationSigner as Ml, Principal as Mm, MakeEmpty as Mn, RouteHandler as Mo, verifyOperationSignature as Mp, MutationUpdateStateExampleArgs as Mr, DeleteStateExampleInputSchema as Ms, DeleteOperationErrorAction as Mt, AUTH_DENIED_BY_GRANT_REASON as Mu, PHReactorRenown as N, UndoActionInput as Na, UndoActionSchema as Nc, MoveGrantAction as Nd, addOperationExample as Nf, SetModelExtensionAction as Ni, hasDerivedDocumentId as Nl, backfillAuthState as Nm, MakeMaybe as Nn, RouteMethod as No, IntegrityIssueSubType as Np, NOOPAction as Nr, DocumentActionSchema as Ns, DeleteOperationErrorInput as Nt, AUTH_NO_GRANT_REASON as Nu, PHConnectRenownAdapters as O, State as Oa, SetStateSchemaInputSchema as Oc, ConditionContext as Od, actions as Of, SetAuthorWebsiteInput as Oi, createCopyHeader as Ol, PHAuthState as Om, IsDocumentOfType as On, RouteAuth as Oo, undo as Op, MutationSetStateSchemaArgs as Or, DeleteModuleInputSchema as Os, DeleteDocumentActionInput as Ot, assertIsDocumentModelDocument as Ou, PHRenownPrivyAdapterConfig as P, UndoRedoAction as Pa, UndoSchema as Pc, MoveGrantActionInput as Pd, addStateExample as Pf, SetModelExtensionInput as Pi, sign as Pl, createAuthState as Pm, MakeOptional as Pn, RouteOptions as Po, IntegrityIssueType as Pp, OperationErrorSpecification as Pr, DocumentModelGlobalStateSchema as Ps, DeleteOperationExampleAction as Pt, AUTH_VERSION_UNSUPPORTED_REASON as Pu, AddModuleInput as Q, relationalDbToQueryBuilder as Qa, replayOperations as Qc, isAuthAction as Qd, redo as Qf, SetOperationErrorNameAction as Qi, VersionedReducers as Ql, deriveDocumentId as Qm, MutationDeleteOperationErrorArgs as Qn, ReservedOperationName as Qo, groupOperationsByScope as Qp, ReducerOptions as Qr, ReorderChangeLogItemsInputSchema as Qs, DocumentModelOperationAction as Qt, documentModelGlobalState as Qu, PathValidation as R, UpdateOperationExampleInput as Ra, definedNonNullAnySchema as Rc, RemoveGrantActionInputSchema as Rd, createAction as Rf, SetModelNameInput as Ri, baseLoadFromInput as Rl, createLocalState as Rm, MinimalBackupData as Rn, ScopedRouteHandle as Ro, addUndo as Rp, PartialRecord as Rr, ModuleSchema as Rs, DeleteStateExampleInput as Rt, base58Decode as Ru, PHConnectPwaManifest as S, SignalResults as Sa, SetOperationReducerInputSchema as Sc, AuthDecision as Sd, v2TupleProblem as Sf, deserializeSignature as Sh, SchemaSetPreferredEditorAction as Si, localSupports as Sl, withSignaturePolicy as Sm, IOperation as Sn, AuthorizerResult as So, setOperationReducer as Sp, MutationSetOperationErrorNameArgs as Sr, AddStateExampleInputSchema as Ss, CreateState as St, groupMembershipActionTypes as Su, PHConnectReactor as T, SigningParameters as Ta, SetOperationTemplateInputSchema as Tc, AuthRequest as Td, actionContext as Tf, DEFAULT_RELATIONAL_PROCESSOR_DB_NAME as Th, SetAuthorNameAction as Ti, peerSupports as Tl, Condition as Tm, ISigner as Tn, IWebhookScope as To, setOperationTemplate as Tp, MutationSetOperationReducerArgs as Tr, ConfigEntrySchema as Ts, DeleteChildDocumentInput as Tt, DocumentModelHeaderSchema as Tu, DEFAULT_REGISTRY_URL as U, UpgradeDocumentAction as Ua, documentModelOperationExampleReducer as Uc, applyInitializeAuthAction as Ud, deleteOperationExample as Uf, SetNameAction as Ui, documentModelLoadFromInput as Ul, defaultGlobalState as Um, MutationAddChangeLogItemInputArgs as Un, WebhookReply as Uo, checkCleanedOperationsIntegrity as Up, PowerhouseModule as Ur, PieceModuleSchema as Us, DocumentModelGlobalState as Ut, getUnixTimestamp as Uu, ServiceAction as V, UpdateStateExampleAction as Va, documentModelModuleReducer as Vc, SetGrantActionInputSchema as Vd, deleteOperation as Vf, SetModuleNameAction as Vi, createMinimalZip as Vl, defaultBaseState as Vm, MoveOperationInput as Vn, WebhookHashAlgorithm as Vo, baseCreateDocument as Vp, PhAiToolDescriptor as Vr, OperationScopeSchema as Vs, DocumentModelDocument as Vt, buildOperationSignatureParams as Vu, ActionErrorCallback as W, UpgradeDocumentActionInput as Wa, documentModelOperationReducer as Wc, applyMoveGrantAction as Wd, deleteStateExample as Wf, SetNameActionInput as Wi, documentModelSaveToFileHandle as Wl, defaultLocalState as Wm, MutationAddModuleArgs as Wn, WebhookRequest as Wo, checkOperationsIntegrity as Wp, Publisher as Wr, PieceModulesSchema as Ws, DocumentModelHeaderAction as Wt, hashBrowser as Wu, AddChangeLogItemInput as X, hashNamespace as Xa, createReducer as Xc, evaluate as Xd, operationFromOperation as Xf, SetOperationErrorDescriptionAction as Xi, writeFileBrowser as Xl, SIGNATURE_PROTOCOL_V2 as Xm, MutationDeleteModuleArgs as Xn, OPERATION_NAME_PATTERN as Xo, garbageCollectV2 as Xp, RedoActionInput as Xr, RedoActionSchema as Xs, DocumentModelModuleAction as Xt, HASH_ENCODING_HEX as Xu, AddChangeLogItemAction as Y, createRelationalDb as Ya, baseReducer as Yc, decide as Yd, operationFromAction as Yf, SetOperationErrorCodeInput as Yi, readFileBrowser as Yl, SIGNATURE_PROTOCOL as Ym, MutationDeleteChangeLogItemInputArgs as Yn, deletedDocumentId as Yo, garbageCollectDocumentOperations as Yp, RedoAction as Yr, RedoActionInputSchema as Ys, DocumentModelModule as Yt, HASH_ENCODING_BASE64 as Yu, AddModuleAction as Z, namespaceSchemaOf as Za, processUndoRedo as Zc, initializeAuth as Zd, operationWithContext as Zf, SetOperationErrorDescriptionInput as Zi, zipEntries as Zl, SignaturePolicy$1 as Zm, MutationDeleteOperationArgs as Zn, RESERVED_OPERATION_NAMES as Zo, getDocumentLastModified as Zp, Reducer as Zr, RedoSchema as Zs, DocumentModelModuleOperations as Zt, documentModelFileExtension as Zu, PHConnectPackages as _, Set_Name as _a, SetOperationErrorCodeInputSchema as _c, grantProblem as _d, canonicalJson as _f, AppActionSigner as _h, SaveToFileHandle as _i, coversLocal as _l, skipHeaderOperations as _m, FileInput as _n, ProcessorFactoryBuilder as _o, setOperationErrorCode as _p, MutationSetModuleNameArgs as _r, AddChangeLogItemInputSchema as _s, CreateChildDocumentInput as _t, InvalidActionInputZodError as _u, PHConnectAi as a, SetOperationReducerInput as aa, SetAuthorNameInputSchema as ac, InvalidGrantError as ad, TransportAction as af, DocumentOperations as ah, ReorderModuleOperationsInput as ai, purgedProtocolVersions as al, mapSkippedOperationsV2 as am, DocumentModelStateAction as an, IRelationalQueryBuilder as ao, reorderStateExamples as ap, MutationReorderModulesArgs as ar, findOperationExampleOrThrow as as, AddRelationshipAction as at, applyUpgradeDocumentAction as au, PHConnectPwaFileHandler as b, SignalDispatch as ba, SetOperationErrorTemplateInputSchema as bc, AUTH_ACTION_TYPES as bd, signActionV2 as bf, Signature as bh, SchemaRedoAction as bi, legacySupports as bl, split as bm, ID as bn, ProcessorStatus as bo, setOperationErrorTemplate as bp, MutationSetOperationErrorCodeArgs as br, AddOperationExampleInputSchema as bs, CreateDocumentAction as bt, documentModelDocumentType as bu, PHConnectCompositionEntry as c, SetOperationScopeAction as ca, SetModelDescriptionInputSchema as cc, MAX_CONDITION_DEPTH as cd, toTransportAction as cf, OperationOutcome as ch, ReorderOperationErrorsAction as ci, HoldReason as cl, operationsAreEqual as cm, DocumentModelVersioningAction as cn, RelationalDbProcessorClass as co, setInitialState as cp, MutationReorderStateExamplesArgs as cr, isReservedOperationName as cs, AddStateExampleInput as ct, AuthActionNotAllowedError as cu, PHConnectDefaultDriveRemote as d, SetOperationTemplateInput as da, SetModelNameInputSchema as dc, assertValidGrant as dd, ActionSigningTarget as df, redoOperation as dh, ReorderOperationExamplesInput as di, PEER_MANIFEST_FORMAT as dl, prepareOperations as dm, DocumentSpecification as dn, IProcessorHostModuleBase as do, setModelId as dp, MutationSetInitialStateArgs as dr, validateModule as ds, Author as dt, AuthPolicyNotPreservedError as du, SetOperationErrorTemplateAction as ea, ReorderModulesInputSchema as ec, documentModelInitialLocalState as ed, mentionedGroupIds as ef, isSignaturePolicy as eh, RemoveRelationshipAction as ei, PURGE_DOCUMENT as el, isDocumentAction as em, DocumentModelOperationErrorOperations as en, ExtractProcessorSchemaOrSelf as eo, reorderChangeLogItems as ep, MutationDeleteStateExampleArgs as er, assertOperationErrorIdUnique as es, AddOperationErrorAction as et, replayDocumentVersioned as eu, PHConnectDriveSection as f, SetPreferredEditorAction as fa, SetModuleDescriptionInputSchema as fc, assertValidGrantUpsert as fd, CanonicalJsonError as ff, setNameOperation as fh, ReorderStateExamplesAction as fi, PeerCapability as fl, readOnly as fm, ENSInfo as fn, IProcessorManager as fo, setModelName as fp, MutationSetModelDescriptionArgs as fr, validateModuleOperation as fs, CodeExample as ft, DowngradeNotSupportedError as fu, PHConnectOpenPanel as g, SetStateSchemaInput as ga, SetOperationDescriptionInputSchema as gc, evaluateGrants as gd, actionSigningTarget as gf, ActionSigner as gh, SaveToFile as gi, Supports as gl, reshuffleByTimestampAndIndex as gm, Exact as gn, ProcessorFactory as go, setOperationDescription as gp, MutationSetModuleDescriptionArgs as gr, validateStateSchemaName as gs, CopyChildDocumentSignal as gt, InvalidActionInputError as gu, PHConnectInstance as h, SetStateSchemaAction as ha, SetNameActionSchema as hc, evaluateGrantStack as hd, actionSignerIdentity as hf, undoOperationV2 as hh, RevisionsFilter as hi, ProtocolCapability as hl, reshuffleByTimestamp as hm, EditorProps as hn, ProcessorDispatchResult as ho, setName as hp, MutationSetModelNameArgs as hr, validateOperations as hs, CopyChildDocumentInput as ht, HashMismatchError as hu, LogLevels as i, SetOperationReducerAction as ia, ScopeStateSchema as ic, GroupPrincipalNotAllowedError as id, setGrant as if, v2RequiredProtocolVersions as ih, ReorderModuleOperationsAction as ii, purgeMarkerOperation as il, mapSkippedOperations as im, DocumentModelPHState as in, IRelationalDbProcessor as io, reorderOperationExamples as ip, MutationReorderModuleOperationsArgs as ir, findOperationErrorOrThrow as is, AddOperationInput as it, applyDeleteDocumentAction as iu, PHPackageProvider as j, Undo as ja, StateSchema as jc, InitializeAuthActionInputSchema as jd, addOperation as jf, SetModelDescriptionAction as ji, createSignedHeaderForSigner as jl, PHGroupState as jm, LoadFromInput as jn, RouteContext as jo, updateStateExample as jp, MutationUpdateOperationExampleArgs as jr, DeleteOperationInputSchema as js, DeleteOperationAction as jt, isDocumentModelState as ju, PHConnectRuntimeConfig as k, StateReducer as ka, Set_NameSchema as kc, InitializeAuthAction as kd, addChangeLogItem as kf, SetInitialStateAction as ki, createPresignedHeader as kl, PHBaseState as km, IsStateOfType as kn, RouteAuthorizer as ko, updateChangeLogItem as kp, MutationUndoArgs as kr, DeleteOperationErrorInputSchema as ks, DeleteModuleAction as kt, assertIsDocumentModelState as ku, PHConnectDefaultDrive as l, SetOperationScopeInput as la, SetModelExtensionInputSchema as lc, MAX_CONDITION_NODES as ld, ACTION_SIGNATURE_V2_PREFIX as lf, OperationWithContext$1 as lh, ReorderOperationErrorsInput as li, MARKER_REFUSAL_FEATURE as ll, parseResultingState as lm, DocumentModelVersioningOperations as ln, IProcessor as lo, setModelDescription as lp, MutationSetAuthorNameArgs as lr, isValidOperationNameFormat as ls, AssertIsDocumentOfType as lt, AuthAlreadyInitializedError as lu, PHConnectDrives as m, SetPreferredEditorOperation as ma, SetNameActionInputSchema as mc, evaluateCondition as md, actionPreimageV2 as mf, undoOperation as mh, ReplayDocumentOptions as mi, PeerManifest as ml, replayDocument as mm, EditorModule as mn, ProcessorApps as mo, setModuleName as mp, MutationSetModelIdArgs as mr, validateOperationName as ms, ConfigEntryType as mt, GrantNotFoundError as mu, DrivePreserveStrategy as n, SetOperationNameAction as na, ReorderOperationExamplesInputSchema as nc, AuthAdministrationMissingError as nd, removeGrant as nf, requestedSignaturePolicy as nh, ReorderChangeLogItemsAction as ni, isPurgeMarker as nl, isUndo as nm, DocumentModelOperationExampleOperations as nn, IBaseRelationalDb as no, reorderModules as np, MutationRedoArgs as nr, assertOperationIdUnique as ns, AddOperationExampleAction as nt, UpgradeReducer as nu, PHConnectApp as o, SetOperationSchemaAction as oa, SetAuthorWebsiteInputSchema as oc, MAX_AUTH_GRANTS as od, TransportActionContext as of, Operation as oh, ReorderModulesAction as oi, DOCUMENT_PURGE_PROTOCOL as ol, merge as om, DocumentModelStateOperations as on, IRelationalQueryMethods as oo, setAuthorName as op, MutationReorderOperationErrorsArgs as or, findOperationOrThrow as os, AddRelationshipActionInput as ot, computeUpgradeTransitions as ou, PHConnectDriveSections as p, SetPreferredEditorActionInput as pa, SetModuleNameInputSchema as pc, assertValidInitialGrants as pd, DOCUMENT_SCOPE_ACTION_TYPES as pf, setPreferredEditorOperation as ph, ReorderStateExamplesInput as pi, PeerCapabilityFlags as pl, removeExistingOperations as pm, EditorDispatch as pn, ProcessorApp as po, setModuleDescription as pp, MutationSetModelExtensionArgs as pr, validateModules as ps, ConfigEntry as pt, FileSystemError as pu, ActionVerificationHandler as q, createNamespacedDb as qa, documentModelStateSchemaReducer as qc, assertAuthPreservedOnDuplicate as qd, noop as qf, SetOperationDescriptionInput as qi, isDocumentZip as ql, DocumentIdParams as qm, MutationAddOperationExampleArgs as qn, WebhookSpec as qo, filterDuplicatedOperations as qp, Query as qr, PublisherSchema as qs, DocumentModelLib as qt, HASH_ALGORITHM_SHA256 as qu, LogLevel as r, SetOperationNameInput as ra, ReorderStateExamplesInputSchema as rc, GrantSchema as rd, resolveSnapshotAuth as rf, signaturePolicyOf as rh, ReorderChangeLogItemsInput as ri, purgeDocumentAction as rl, isUndoRedo as rm, DocumentModelOperationOperations as rn, IRelationalDb as ro, reorderOperationErrors as rp, MutationReorderChangeLogItemsInputArgs as rr, findModuleOrThrow as rs, AddOperationExampleInput as rt, UpgradeTransition as ru, PHConnectBranding as s, SetOperationSchemaInput as sa, SetInitialStateInputSchema as sc, MAX_CAPABILITY_OPERATIONS as sd, TransportSigner as sf, OperationContext as sh, ReorderModulesInput as si, FeatureCapability as sl, nextSkipNumber as sm, DocumentModelUtils as sn, RelationalDbProcessor as so, setAuthorWebsite as sp, MutationReorderOperationExamplesArgs as sr, getAllOperationNames as ss, AddStateExampleAction as st, withProtocolVersions as su, DrivePreserveStrategies as t, SetOperationErrorTemplateInput as ta, ReorderOperationErrorsInputSchema as tc, AuthAdministrationLockoutError as td, moveGrant as tf, protocolVersionsFor as th, RemoveRelationshipActionInput as ti, PurgeMarkerOperation as tl, isNoopOperation as tm, DocumentModelOperationExampleAction as tn, HashAlgorithms as to, reorderModuleOperations as tp, MutationMoveOperationArgs as tr, assertOperationExampleIdUnique as ts, AddOperationErrorInput as tt, UpgradeManifest as tu, PHConnectDefaultDriveLocal as u, SetOperationTemplateAction as ua, SetModelIdInputSchema as uc, assertAuthAdministrationRetained as ud, ActionSignerIdentity as uf, operationOutcome as uh, ReorderOperationExamplesAction as ui, PEER_CAPABILITIES as ul, precedes as um, DocumentOperationsIgnoreMap as un, IProcessorDispatch as uo, setModelExtension as up, MutationSetAuthorWebsiteArgs as ur, validateInitialState as us, AssertIsStateOfType as ut, AuthInitializerNotCreatorError as uu, PHConnectPwa as v, Set_PreferredEditor as va, SetOperationErrorDescriptionInputSchema as vc, isPlainValue as vd, hashActionV2 as vf, HashConfig as vh, Scalars as vi, holdReason as vl, sortMappedOperations as vm, GetDocumentOptions as vn, ProcessorFilter as vo, setOperationErrorDescription as vp, MutationSetNameArgs as vr, AddModuleInputSchema as vs, CreateChildDocumentSignal as vt, InvalidAuthVersionError as vu, PHConnectPwaUrlPattern as w, SignatureVerificationHandler as wa, SetOperationScopeInputSchema as wc, AuthRefusal as wd, ActionContext as wf, DEFAULT_ANALYTICS_PROCESSOR_DB_NAME as wh, ScopeState as wi, mergePeerCapabilities as wl, Capability as wm, ISignalResult as wn, IWebhookEndpoints as wo, setOperationScope as wp, MutationSetOperationNameArgs as wr, CodeExampleSchema as ws, DeleteChangeLogItemInput as wt, BaseDocumentStateSchema as wu, PHConnectPwaIcon as x, SignalResult as xa, SetOperationNameInputSchema as xc, AuthAction as xd, targetDocumentId as xf, UserActionSigner as xh, SchemaSetNameAction as xi, localPeerManifest as xl, updateHeaderRevision as xm, IDocument as xn, TrackedProcessor as xo, setOperationName as xp, MutationSetOperationErrorDescriptionArgs as xr, AddOperationInputSchema as xs, CreateDocumentActionInput as xt, groupDocumentType as xu, PHConnectPwaCacheStrategy as y, Signal as ya, SetOperationErrorNameInputSchema as yc, referencedGroupIds as yd, isV2ActionHash as yf, PHDocumentSignatureInfo as yh, SchemaNOOPAction as yi, isOlderManifest as yl, sortOperations as ym, IAction as yn, ProcessorRecord as yo, setOperationErrorName as yp, MutationSetOperationDescriptionArgs as yr, AddOperationErrorInputSchema as ys, CreateDocument as yt, UnsupportedDocumentModelVersionError as yu, PowerhouseConfig as z, UpdateRelationshipAction as za, isDefinedNonNullAny as zc, SetGrantAction as zd, deleteChangeLogItem as zf, SetModuleDescriptionAction as zi, baseLoadFromInputVersioned as zl, createState as zm, ModuleSpecification as zn, WebhookEndpointInfo as zo, appendWithoutApplying as zp, PartialState as zr, MoveOperationInputSchema as zs, DocumentAction as zt, base64UrlToBytes as zu };
+export {};
+//# sourceMappingURL=types-DzleLgA8.d.ts.map