@powerhousedao/shared 6.2.3-dev.5 → 6.2.3-dev.50

package/dist/{types-CpnWmiFY.d.ts → types-BRJfX8ck.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>;
+//#region document-model/files.d.ts
+declare function createZip(document: PHDocument): Promise<Uint8Array>;
+/**
+ * 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 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>;
+ * 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 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 document-model/header.d.ts
+/**
+ * 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 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;
+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;
 /**
- * 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.
+ * 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 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 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 processors/relational/utils.d.ts
+//#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>;
 /**
- * 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.
+ * 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,573 @@ 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>>>;
   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;
+}
+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 +3488,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 +3553,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 +3562,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 +3633,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 +3689,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 +3725,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 +3743,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 +3780,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 +3851,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 +3931,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 +3957,9 @@ type MinimalBackupData = {
   branch: string;
   state: PHBaseState;
   name: string;
+  protocolVersions?: {
+    [key: string]: number;
+  };
 };
 type DocumentModelUtils<TState extends PHBaseState = PHBaseState> = {
   fileExtension: string;
@@ -2870,7 +3999,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 +4023,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 +4060,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 +4090,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,16 +4122,32 @@ 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;
+};
 type PHConnectInstance = {
   namespace: string | null;
   reactorWorker: boolean;
@@ -2997,13 +4155,21 @@ type PHConnectInstance = {
 /** 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 +4218,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 +4234,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,11 +4257,16 @@ 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[];
 };
 type PHConnectRuntimeConfig = {
@@ -3102,6 +4277,7 @@ type PHConnectRuntimeConfig = {
   drives?: PHConnectDrives;
   renown?: PHConnectRenown;
   sentry?: PHConnectSentry;
+  openPanel?: PHConnectOpenPanel;
   instance?: PHConnectInstance;
   reactor?: PHConnectReactor;
   pwa?: PHConnectPwa;
@@ -3110,8 +4286,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 +4337,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 { AddOperationErrorInput as $, HashAlgorithms as $a, PurgeMarkerOperation as $c, moveGrant as $d, reorderModuleOperations as $f, SetOperationErrorTemplateInput as $i, UpgradeManifest as $l, protocolVersionsFor as $m, MutationMoveOperationArgs as $n, assertOperationExampleIdUnique as $o, isNoopOperation as $p, RemoveRelationshipActionInput as $r, ReorderOperationErrorsInputSchema as $s, DocumentModelOperationExampleAction as $t, AuthAdministrationLockoutError as $u, PHPackageProvider as A, UndoAction as Aa, UndoActionInputSchema as Ac, MAX_SUPPORTED_AUTH_VERSION as Ad, addOperationError as Af, SetModelDescriptionInput as Ai, createVerificationSigner as Al, Principal as Am, MakeEmpty as An, RouteHandler as Ao, verifyOperationSignature as Ap, MutationUpdateStateExampleArgs as Ar, DeleteStateExampleInputSchema as As, DeleteOperationErrorAction as At, AUTH_DENIED_BY_GRANT_REASON as Au, ServiceActions as B, UpdateStateExampleInput as Ba, documentModelOperationErrorReducer as Bc, applyAuthAction as Bd, deleteOperationError as Bf, SetModuleNameInput as Bi, createZip as Bl, defaultDocumentState as Bm, Mutation as Bn, WebhookPolicy as Bo, baseReducerVersion as Bp, PieceModule as Br, OperationSpecificationSchema as Bs, DocumentModelDocumentModelModule as Bt, bytesToBase64Url as Bu, PHConnectPwaUrlPattern as C, SigningParameters as Ca, SetOperationTemplateInputSchema as Cc, AuthRequest as Cd, actionContext as Cf, DEFAULT_RELATIONAL_PROCESSOR_DB_NAME as Ch, SetAuthorNameAction as Ci, peerSupports as Cl, Condition as Cm, ISigner as Cn, IWebhookScope as Co, setOperationTemplate as Cp, MutationSetOperationReducerArgs as Cr, ConfigEntrySchema as Cs, DeleteChildDocumentInput as Ct, DocumentModelHeaderSchema as Cu, PHConnectRenownAdapters as D, StateReducer as Da, Set_NameSchema as Dc, InitializeAuthAction as Dd, addChangeLogItem as Df, SetInitialStateAction as Di, createPresignedHeader as Dl, PHBaseState as Dm, IsStateOfType as Dn, RouteAuthorizer as Do, updateChangeLogItem as Dp, MutationUndoArgs as Dr, DeleteOperationErrorInputSchema as Ds, DeleteModuleAction as Dt, assertIsDocumentModelState as Du, PHConnectRenown as E, State as Ea, SetStateSchemaInputSchema as Ec, ConditionContext as Ed, actions as Ef, SetAuthorWebsiteInput as Ei, createCopyHeader as El, PHAuthState as Em, IsDocumentOfType as En, RouteAuth as Eo, undo as Ep, MutationSetStateSchemaArgs as Er, DeleteModuleInputSchema as Es, DeleteDocumentActionInput as Et, assertIsDocumentModelDocument as Eu, ParsedCmdResult as F, UpdateOperationExampleAction as Fa, UpdateStateExampleInputSchema as Fc, RemoveGrantActionInput as Fd, buildSignedAction as Ff, SetModelNameAction as Fi, BulkArchiveEntry as Fl, createGlobalState as Fm, Maybe as Fn, RouteUser as Fo, PHDocumentMeta as Fp, OperationsByScope as Fr, ManifestSchema as Fs, DeleteStateExampleAction as Ft, ab2hex as Fu, ActionVerificationHandler as G, createNamespacedDb as Ga, documentModelStateSchemaReducer as Gc, assertAuthPreservedOnDuplicate as Gd, noop as Gf, SetOperationDescriptionInput as Gi, isDocumentZip as Gl, DocumentIdParams as Gm, MutationAddOperationExampleArgs as Gn, WebhookSpec as Go, filterDuplicatedOperations as Gp, Query as Gr, PublisherSchema as Gs, DocumentModelLib as Gt, HASH_ALGORITHM_SHA256 as Gu, ActionErrorCallback as H, UpgradeDocumentActionInput as Ha, documentModelOperationReducer as Hc, applyMoveGrantAction as Hd, deleteStateExample as Hf, SetNameActionInput as Hi, documentModelSaveToFileHandle as Hl, defaultLocalState as Hm, MutationAddModuleArgs as Hn, WebhookRequest as Ho, checkOperationsIntegrity as Hp, Publisher as Hr, PieceModulesSchema as Hs, DocumentModelHeaderAction as Ht, hashBrowser as Hu, PathValidation as I, UpdateOperationExampleInput as Ia, definedNonNullAnySchema as Ic, RemoveGrantActionInputSchema as Id, createAction as If, SetModelNameInput as Ii, baseLoadFromInput as Il, createLocalState as Im, MinimalBackupData as In, ScopedRouteHandle as Io, addUndo as Ip, PartialRecord as Ir, ModuleSchema as Is, DeleteStateExampleInput as It, base58Decode as Iu, AddChangeLogItemInput as J, hashNamespace as Ja, createReducer as Jc, evaluate as Jd, operationFromOperation as Jf, SetOperationErrorDescriptionAction as Ji, writeFileBrowser as Jl, SIGNATURE_PROTOCOL_V2 as Jm, MutationDeleteModuleArgs as Jn, OPERATION_NAME_PATTERN as Jo, garbageCollectV2 as Jp, RedoActionInput as Jr, RedoActionSchema as Js, DocumentModelModuleAction as Jt, HASH_ENCODING_HEX as Ju, Actions as K, createNamespacedQueryBuilder as Ka, documentModelVersioningReducer as Kc, assertAuthScopeActionAllowed as Kd, operationExampleCreators as Kf, SetOperationErrorCodeAction as Ki, parseBulkArchive as Kl, ProtocolVersions as Km, MutationAddStateExampleArgs as Kn, WebhookVerification as Ko, garbageCollect as Kp, Redo as Kr, PwaConfigSchema as Ks, DocumentModelLocalState as Kt, HASH_ALGORITHM_SHA512 as Ku, PowerhouseConfig as L, UpdateRelationshipAction as La, isDefinedNonNullAny as Lc, SetGrantAction as Ld, deleteChangeLogItem as Lf, SetModuleDescriptionAction as Li, baseLoadFromInputVersioned as Ll, createState as Lm, ModuleSpecification as Ln, WebhookEndpointInfo as Lo, appendWithoutApplying as Lp, PartialState as Lr, MoveOperationInputSchema as Ls, DocumentAction as Lt, base64UrlToBytes as Lu, PHRenownPrivyAdapterConfig as M, UndoRedoAction as Ma, UndoSchema as Mc, MoveGrantActionInput as Md, addStateExample as Mf, SetModelExtensionInput as Mi, sign as Ml, createAuthState as Mm, MakeOptional as Mn, RouteOptions as Mo, IntegrityIssueType as Mp, OperationErrorSpecification as Mr, DocumentModelGlobalStateSchema as Ms, DeleteOperationExampleAction as Mt, AUTH_VERSION_UNSUPPORTED_REASON as Mu, PHRenownRainbowAdapterConfig as N, UpdateChangeLogItemAction as Na, UpdateChangeLogItemInputSchema as Nc, MoveGrantActionInputSchema as Nd, baseActions as Nf, SetModelIdAction as Ni, validateHeader as Nl, createBaseState as Nm, Manifest as Nn, RouteSpec as No, PHDocument as Np, OperationIndex as Nr, DocumentModelInputSchema as Ns, DeleteOperationExampleInput as Nt, DOCUMENT_DELETED_REASON as Nu, PHConnectRuntimeConfig as O, SubgraphModule as Oa, Set_PreferredEditorSchema as Oc, InitializeAuthActionInput as Od, addModule as Of, SetInitialStateInput as Oi, createSignedHeader as Ol, PHDocumentState as Om, LoadFromFile as On, RouteBody as Oo, updateOperationExample as Op, MutationUpdateChangeLogItemInputArgs as Or, DeleteOperationExampleInputSchema as Os, DeleteModuleInput as Ot, isDocumentModelDocument as Ou, PackageManagerArgs as P, UpdateChangeLogItemInput as Pa, UpdateOperationExampleInputSchema as Pc, RemoveGrantAction as Pd, buildOperationSignature as Pf, SetModelIdInput as Pi, verify as Pl, createDocumentState as Pm, MappedOperation as Pn, RouteTransport as Po, PHDocumentHeader as Pp, OperationSpecification as Pr, DocumentSpecificationSchema as Ps, DeleteOperationInput as Pt, isDenied as Pu, AddOperationErrorAction as Q, ExtractProcessorSchemaOrSelf as Qa, PURGE_DOCUMENT as Qc, mentionedGroupIds as Qd, reorderChangeLogItems as Qf, SetOperationErrorTemplateAction as Qi, replayDocumentVersioned as Ql, isSignaturePolicy as Qm, MutationDeleteStateExampleArgs as Qn, assertOperationErrorIdUnique as Qo, isDocumentAction as Qp, RemoveRelationshipAction as Qr, ReorderModulesInputSchema as Qs, DocumentModelOperationErrorOperations as Qt, documentModelInitialLocalState as Qu, PowerhousePackage as R, UpdateRelationshipActionInput as Ra, documentModelHeaderReducer as Rc, SetGrantActionInput as Rd, deleteModule as Rf, SetModuleDescriptionInput as Ri, baseSaveToFileHandle as Rl, defaultAuthState as Rm, MoveOperationAction as Rn, WebhookField as Ro, attachBranch as Rp, PhAiToolAnnotations as Rr, OperationErrorSchema as Rs, DocumentModelAction as Rt, buildOperationSignatureMessage as Ru, PHConnectPwaRuntimeCaching as S, SignatureVerificationHandler as Sa, SetOperationScopeInputSchema as Sc, AuthRefusal as Sd, ActionContext as Sf, DEFAULT_ANALYTICS_PROCESSOR_DB_NAME as Sh, ScopeState as Si, mergePeerCapabilities as Sl, Capability as Sm, ISignalResult as Sn, IWebhookEndpoints as So, setOperationScope as Sp, MutationSetOperationNameArgs as Sr, CodeExampleSchema as Ss, DeleteChangeLogItemInput as St, BaseDocumentStateSchema as Su, PHConnectReactorFeatureFlags as T, SkipHeaderOperations as Ta, SetPreferredEditorActionSchema as Tc, AuthVerb as Td, actionSigner as Tf, SetAuthorWebsiteAction as Ti, selectProtocolVersions as Tl, Operand as Tm, InputMaybe as Tn, RouteActor as To, setStateSchema as Tp, MutationSetOperationTemplateArgs as Tr, DeleteChangeLogItemInputSchema as Ts, DeleteDocumentAction as Tt, DocumentModelSchema as Tu, ActionSignatureContext as U, User as Ua, documentModelReducer as Uc, applyRemoveGrantAction as Ud, documentModelActions as Uf, SetNameOperation as Ui, fetchFileBrowser as Ul, defaultPHState as Um, MutationAddOperationArgs as Un, WebhookScheme as Uo, diffOperations as Up, PurgeDocumentAction as Ur, PowerhouseModuleSchema as Us, DocumentModelHeaderOperations as Ut, hex2ab as Uu, DEFAULT_REGISTRY_URL as V, UpgradeDocumentAction as Va, documentModelOperationExampleReducer as Vc, applyInitializeAuthAction as Vd, deleteOperationExample as Vf, SetNameAction as Vi, documentModelLoadFromInput as Vl, defaultGlobalState as Vm, MutationAddChangeLogItemInputArgs as Vn, WebhookReply as Vo, checkCleanedOperationsIntegrity as Vp, PowerhouseModule as Vr, PieceModuleSchema as Vs, DocumentModelGlobalState as Vt, getUnixTimestamp as Vu, ActionSigningHandler as W, ValidationError as Wa, documentModelStateReducer as Wc, applySetGrantAction as Wd, moveOperation as Wf, SetOperationDescriptionAction as Wi, getFileBrowser as Wl, DEFAULT_SIGNATURE_POLICY as Wm, MutationAddOperationErrorArgs as Wn, WebhookSignatureEncoding as Wo, filterDocumentOperationsResultingState as Wp, PurgeDocumentActionInput as Wr, PowerhouseModulesSchema as Ws, DocumentModelInput as Wt, HASH_ALGORITHM_SHA1 as Wu, AddModuleInput as X, relationalDbToQueryBuilder as Xa, replayOperations as Xc, isAuthAction as Xd, redo as Xf, SetOperationErrorNameAction as Xi, VersionedReducers as Xl, deriveDocumentId as Xm, MutationDeleteOperationErrorArgs as Xn, ReservedOperationName as Xo, groupOperationsByScope as Xp, ReducerOptions as Xr, ReorderChangeLogItemsInputSchema as Xs, DocumentModelOperationAction as Xt, documentModelGlobalState as Xu, AddModuleAction as Y, namespaceSchemaOf as Ya, processUndoRedo as Yc, initializeAuth as Yd, operationWithContext as Yf, SetOperationErrorDescriptionInput as Yi, zipEntries as Yl, SignaturePolicy$1 as Ym, MutationDeleteOperationArgs as Yn, RESERVED_OPERATION_NAMES as Yo, getDocumentLastModified as Yp, Reducer as Yr, RedoSchema as Ys, DocumentModelModuleOperations as Yt, documentModelFileExtension as Yu, AddOperationAction as Z, DOCUMENT_ID_COLUMNS as Za, updateDocument as Zc, isDocumentCreator as Zd, releaseNewVersion as Zf, SetOperationErrorNameInput as Zi, VersionedReplayConfig as Zl, isDerivedDocumentId as Zm, MutationDeleteOperationExampleArgs as Zn, assertModuleIdUnique as Zo, hashDocumentStateForScope as Zp, ReleaseNewVersionAction as Zr, ReorderModuleOperationsInputSchema as Zs, DocumentModelOperationErrorAction as Zt, documentModelInitialGlobalState as Zu, PHConnectPwa as _, Signal as _a, SetOperationErrorNameInputSchema as _c, referencedGroupIds as _d, isV2ActionHash as _f, PHDocumentSignatureInfo as _h, SchemaNOOPAction as _i, isOlderManifest as _l, sortOperations as _m, IAction as _n, ProcessorRecord as _o, setOperationErrorName as _p, MutationSetOperationDescriptionArgs as _r, AddOperationErrorInputSchema as _s, CreateDocument as _t, UnsupportedDocumentModelVersionError as _u, PHConnectAi as a, SetOperationSchemaInput as aa, SetInitialStateInputSchema as ac, MAX_CAPABILITY_OPERATIONS as ad, TransportSigner as af, OperationContext as ah, ReorderModulesInput as ai, FeatureCapability as al, nextSkipNumber as am, DocumentModelUtils as an, RelationalDbProcessor as ao, setAuthorWebsite as ap, MutationReorderOperationExamplesArgs as ar, getAllOperationNames as as, AddStateExampleAction as at, withProtocolVersions as au, PHConnectPwaIcon as b, SignalResults as ba, SetOperationReducerInputSchema as bc, AuthDecision as bd, v2TupleProblem as bf, deserializeSignature as bh, SchemaSetPreferredEditorAction as bi, localSupports as bl, withSignaturePolicy as bm, IOperation as bn, AuthorizerResult as bo, setOperationReducer as bp, MutationSetOperationErrorNameArgs as br, AddStateExampleInputSchema as bs, CreateState as bt, groupMembershipActionTypes as bu, PHConnectDefaultDrive as c, SetOperationTemplateAction as ca, SetModelIdInputSchema as cc, assertAuthAdministrationRetained as cd, ActionSignerIdentity as cf, operationOutcome as ch, ReorderOperationExamplesAction as ci, PEER_CAPABILITIES as cl, precedes as cm, DocumentOperationsIgnoreMap as cn, IProcessorDispatch as co, setModelExtension as cp, MutationSetAuthorWebsiteArgs as cr, validateInitialState as cs, AssertIsStateOfType as ct, AuthInitializerNotCreatorError as cu, PHConnectDriveSection as d, SetPreferredEditorActionInput as da, SetModuleNameInputSchema as dc, assertValidInitialGrants as dd, DOCUMENT_SCOPE_ACTION_TYPES as df, setPreferredEditorOperation as dh, ReorderStateExamplesInput as di, PeerCapabilityFlags as dl, removeExistingOperations as dm, EditorDispatch as dn, ProcessorApp as do, setModuleDescription as dp, MutationSetModelExtensionArgs as dr, validateModules as ds, ConfigEntry as dt, FileSystemError as du, SetOperationNameAction as ea, ReorderOperationExamplesInputSchema as ec, AuthAdministrationMissingError as ed, removeGrant as ef, requestedSignaturePolicy as eh, ReorderChangeLogItemsAction as ei, isPurgeMarker as el, isUndo as em, DocumentModelOperationExampleOperations as en, IBaseRelationalDb as eo, reorderModules as ep, MutationRedoArgs as er, assertOperationIdUnique as es, AddOperationExampleAction as et, UpgradeReducer as eu, PHConnectDriveSections as f, SetPreferredEditorOperation as fa, SetNameActionInputSchema as fc, evaluateCondition as fd, actionPreimageV2 as ff, undoOperation as fh, ReplayDocumentOptions as fi, PeerManifest as fl, replayDocument as fm, EditorModule as fn, ProcessorApps as fo, setModuleName as fp, MutationSetModelIdArgs as fr, validateOperationName as fs, ConfigEntryType as ft, GrantNotFoundError as fu, PHConnectPackages as g, Set_PreferredEditor as ga, SetOperationErrorDescriptionInputSchema as gc, isPlainValue as gd, hashActionV2 as gf, HashConfig as gh, Scalars as gi, holdReason as gl, sortMappedOperations as gm, GetDocumentOptions as gn, ProcessorFilter as go, setOperationErrorDescription as gp, MutationSetNameArgs as gr, AddModuleInputSchema as gs, CreateChildDocumentSignal as gt, InvalidAuthVersionError as gu, PHConnectOpenPanel as h, Set_Name as ha, SetOperationErrorCodeInputSchema as hc, grantProblem as hd, canonicalJson as hf, AppActionSigner as hh, SaveToFileHandle as hi, coversLocal as hl, skipHeaderOperations as hm, FileInput as hn, ProcessorFactoryBuilder as ho, setOperationErrorCode as hp, MutationSetModuleNameArgs as hr, AddChangeLogItemInputSchema as hs, CreateChildDocumentInput as ht, InvalidActionInputZodError as hu, LogLevels as i, SetOperationSchemaAction as ia, SetAuthorWebsiteInputSchema as ic, MAX_AUTH_GRANTS as id, TransportActionContext as if, Operation as ih, ReorderModulesAction as ii, DOCUMENT_PURGE_PROTOCOL as il, merge as im, DocumentModelStateOperations as in, IRelationalQueryMethods as io, setAuthorName as ip, MutationReorderOperationErrorsArgs as ir, findOperationOrThrow as is, AddRelationshipActionInput as it, computeUpgradeTransitions as iu, PHReactorRenown as j, UndoActionInput as ja, UndoActionSchema as jc, MoveGrantAction as jd, addOperationExample as jf, SetModelExtensionAction as ji, hasDerivedDocumentId as jl, backfillAuthState as jm, MakeMaybe as jn, RouteMethod as jo, IntegrityIssueSubType as jp, NOOPAction as jr, DocumentActionSchema as js, DeleteOperationErrorInput as jt, AUTH_NO_GRANT_REASON as ju, PHConnectSentry as k, Undo as ka, StateSchema as kc, InitializeAuthActionInputSchema as kd, addOperation as kf, SetModelDescriptionAction as ki, createSignedHeaderForSigner as kl, PHGroupState as km, LoadFromInput as kn, RouteContext as ko, updateStateExample as kp, MutationUpdateOperationExampleArgs as kr, DeleteOperationInputSchema as ks, DeleteOperationAction as kt, isDocumentModelState as ku, PHConnectDefaultDriveLocal as l, SetOperationTemplateInput as la, SetModelNameInputSchema as lc, assertValidGrant as ld, ActionSigningTarget as lf, redoOperation as lh, ReorderOperationExamplesInput as li, PEER_MANIFEST_FORMAT as ll, prepareOperations as lm, DocumentSpecification as ln, IProcessorHostModuleBase as lo, setModelId as lp, MutationSetInitialStateArgs as lr, validateModule as ls, Author as lt, AuthPolicyNotPreservedError as lu, PHConnectInstance as m, SetStateSchemaInput as ma, SetOperationDescriptionInputSchema as mc, evaluateGrants as md, actionSigningTarget as mf, ActionSigner as mh, SaveToFile as mi, Supports as ml, reshuffleByTimestampAndIndex as mm, Exact as mn, ProcessorFactory as mo, setOperationDescription as mp, MutationSetModuleDescriptionArgs as mr, validateStateSchemaName as ms, CopyChildDocumentSignal as mt, InvalidActionInputError as mu, DrivePreserveStrategy as n, SetOperationReducerAction as na, ScopeStateSchema as nc, GroupPrincipalNotAllowedError as nd, setGrant as nf, v2RequiredProtocolVersions as nh, ReorderModuleOperationsAction as ni, purgeMarkerOperation as nl, mapSkippedOperations as nm, DocumentModelPHState as nn, IRelationalDbProcessor as no, reorderOperationExamples as np, MutationReorderModuleOperationsArgs as nr, findOperationErrorOrThrow as ns, AddOperationInput as nt, applyDeleteDocumentAction as nu, PHConnectApp as o, SetOperationScopeAction as oa, SetModelDescriptionInputSchema as oc, MAX_CONDITION_DEPTH as od, toTransportAction as of, OperationOutcome as oh, ReorderOperationErrorsAction as oi, HoldReason as ol, operationsAreEqual as om, DocumentModelVersioningAction as on, RelationalDbProcessorClass as oo, setInitialState as op, MutationReorderStateExamplesArgs as or, isReservedOperationName as os, AddStateExampleInput as ot, AuthActionNotAllowedError as ou, PHConnectDrives as p, SetStateSchemaAction as pa, SetNameActionSchema as pc, evaluateGrantStack as pd, actionSignerIdentity as pf, undoOperationV2 as ph, RevisionsFilter as pi, ProtocolCapability as pl, reshuffleByTimestamp as pm, EditorProps as pn, ProcessorDispatchResult as po, setName as pp, MutationSetModelNameArgs as pr, validateOperations as ps, CopyChildDocumentInput as pt, HashMismatchError as pu, AddChangeLogItemAction as q, createRelationalDb as qa, baseReducer as qc, decide as qd, operationFromAction as qf, SetOperationErrorCodeInput as qi, readFileBrowser as ql, SIGNATURE_PROTOCOL as qm, MutationDeleteChangeLogItemInputArgs as qn, deletedDocumentId as qo, garbageCollectDocumentOperations as qp, RedoAction as qr, RedoActionInputSchema as qs, DocumentModelModule as qt, HASH_ENCODING_BASE64 as qu, LogLevel as r, SetOperationReducerInput as ra, SetAuthorNameInputSchema as rc, InvalidGrantError as rd, TransportAction as rf, DocumentOperations as rh, ReorderModuleOperationsInput as ri, purgedProtocolVersions as rl, mapSkippedOperationsV2 as rm, DocumentModelStateAction as rn, IRelationalQueryBuilder as ro, reorderStateExamples as rp, MutationReorderModulesArgs as rr, findOperationExampleOrThrow as rs, AddRelationshipAction as rt, applyUpgradeDocumentAction as ru, PHConnectBranding as s, SetOperationScopeInput as sa, SetModelExtensionInputSchema as sc, MAX_CONDITION_NODES as sd, ACTION_SIGNATURE_V2_PREFIX as sf, OperationWithContext$1 as sh, ReorderOperationErrorsInput as si, MARKER_REFUSAL_FEATURE as sl, parseResultingState as sm, DocumentModelVersioningOperations as sn, IProcessor as so, setModelDescription as sp, MutationSetAuthorNameArgs as sr, isValidOperationNameFormat as ss, AssertIsDocumentOfType as st, AuthAlreadyInitializedError as su, DrivePreserveStrategies as t, SetOperationNameInput as ta, ReorderStateExamplesInputSchema as tc, GrantSchema as td, resolveSnapshotAuth as tf, signaturePolicyOf as th, ReorderChangeLogItemsInput as ti, purgeDocumentAction as tl, isUndoRedo as tm, DocumentModelOperationOperations as tn, IRelationalDb as to, reorderOperationErrors as tp, MutationReorderChangeLogItemsInputArgs as tr, findModuleOrThrow as ts, AddOperationExampleInput as tt, UpgradeTransition as tu, PHConnectDefaultDriveRemote as u, SetPreferredEditorAction as ua, SetModuleDescriptionInputSchema as uc, assertValidGrantUpsert as ud, CanonicalJsonError as uf, setNameOperation as uh, ReorderStateExamplesAction as ui, PeerCapability as ul, readOnly as um, ENSInfo as un, IProcessorManager as uo, setModelName as up, MutationSetModelDescriptionArgs as ur, validateModuleOperation as us, CodeExample as ut, DowngradeNotSupportedError as uu, PHConnectPwaCacheStrategy as v, SignalDispatch as va, SetOperationErrorTemplateInputSchema as vc, AUTH_ACTION_TYPES as vd, signActionV2 as vf, Signature as vh, SchemaRedoAction as vi, legacySupports as vl, split as vm, ID as vn, ProcessorStatus as vo, setOperationErrorTemplate as vp, MutationSetOperationErrorCodeArgs as vr, AddOperationExampleInputSchema as vs, CreateDocumentAction as vt, documentModelDocumentType as vu, PHConnectReactor as w, SkipHeaderOperationIndex as wa, SetPreferredEditorActionInputSchema as wc, AuthSubject as wd, actionFromAction as wf, PROCESSOR_APPS as wh, SetAuthorNameInput as wi, readPeerManifest as wl, Grant as wm, Incremental as wn, NodeRouteSpec as wo, setPreferredEditor as wp, MutationSetOperationSchemaArgs as wr, ConfigEntryTypeSchema as ws, DeleteChildDocumentSignal as wt, DocumentModelPHStateSchema as wu, PHConnectPwaManifest as x, SignalType as xa, SetOperationSchemaInputSchema as xc, AuthEvaluation as xd, Action as xf, serializeSignature as xh, SchemaUndoAction as xi, manifestRevision as xl, AuthGroups as xm, ISignal as xn, IHttpScope as xo, setOperationSchema as xp, MutationSetOperationErrorTemplateArgs as xr, AuthorSchema as xs, DeleteChangeLogItemAction as xt, BaseDocumentHeaderSchema as xu, PHConnectPwaFileHandler as y, SignalResult as ya, SetOperationNameInputSchema as yc, AuthAction as yd, targetDocumentId as yf, UserActionSigner as yh, SchemaSetNameAction as yi, localPeerManifest as yl, updateHeaderRevision as ym, IDocument as yn, TrackedProcessor as yo, setOperationName as yp, MutationSetOperationErrorDescriptionArgs as yr, AddOperationInputSchema as ys, CreateDocumentActionInput as yt, groupDocumentType as yu, ServiceAction as z, UpdateStateExampleAction as za, documentModelModuleReducer as zc, SetGrantActionInputSchema as zd, deleteOperation as zf, SetModuleNameAction as zi, createMinimalZip as zl, defaultBaseState as zm, MoveOperationInput as zn, WebhookHashAlgorithm as zo, baseCreateDocument as zp, PhAiToolDescriptor as zr, OperationScopeSchema as zs, DocumentModelDocument as zt, buildOperationSignatureParams as zu };
+export {};
+//# sourceMappingURL=types-BRJfX8ck.d.ts.map