@powerhousedao/reactor-api 6.2.3-dev.5 → 6.2.3-dev.51

package/dist/index.d.mts

@@ -1,18 +1,18 @@
-import { i as IPackageManagerOptions, n as IPackageLoaderOptions, r as IPackageManager, s as PackageManagerResult, t as IPackageLoader } from "./types-DcYyNcHJ.mjs";
+import { a as IPackagePieceSource, c as PackageManagerResult, i as IPackageManagerOptions, l as PackagePiece, n as IPackageLoaderOptions, r as IPackageManager, t as IPackageLoader, u as PackagePieceEntry } from "./types-DlTiz6AA.mjs";
 import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
 import { AnalyticsModel } from "@powerhousedao/analytics-engine-graphql";
-import * as graphql from "graphql";
-import { DocumentNode, GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig, GraphQLSchema } from "graphql";
-import { AttachmentRef, IDocumentModelLoader, IDocumentModelRegistry, IDriveClient, IReactorClient, IReactorProcessorHostModuleBase, IRelationalDb, ISyncManager, InProcessReactorClientModule, ParsedDriveUrl, ProcessorFactoryBuilder as ProcessorFactoryBuilder$1, SyncScopeGate, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
+import { DocumentNode, GraphQLError, GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig, GraphQLSchema } from "graphql";
+import { AttachmentRef, DocumentModelSource, IDocumentModelLoader, IDocumentModelRegistry, IDriveClient, IInspectableAttachmentStore, IInspector, IInspectorStorageHealthProvider, INSPECTOR_OPS, IReactorClient, IReactorFactsSink, IReactorProcessorHostModuleBase, IRelationalDb, ISyncInspector, ISyncManager, InProcessReactorClientModule, InProcessReactorModule, InspectorDocumentReader, InspectorReadOpKey, PagedResults, ParsedDriveUrl, ProcessorFactoryBuilder as ProcessorFactoryBuilder$1, Remote, SYNC_INSPECTION_OPS, SearchFilter, SyncInspectionReadOpKey, SyncScopeGate, ViewFilter, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
+import { AuthSubject, DocumentModelGlobalState as DocumentModelGlobalState$1, DocumentModelModule, Operation, PHDocument, UpgradeManifest } from "@powerhousedao/shared/document-model";
 import { ILogger } from "document-model";
 import { GraphQLResolverMap, GraphQLSchemaModule } from "@apollo/subgraph";
-import { AuthSubject, DocumentModelGlobalState as DocumentModelGlobalState$1, DocumentModelModule, Operation, PHDocument, UpgradeManifest } from "@powerhousedao/shared/document-model";
 import * as z$1 from "zod";
 import { DocumentDriveDocument, DocumentDriveGlobalState } from "@powerhousedao/shared/document-drive";
-import { AttachmentBuildResult, AttachmentReferenceIndexBuildResult, IAttachmentReferenceReader, IAttachmentReferenceWriter } from "@powerhousedao/reactor-attachments";
+import { AttachmentBuildResult, AttachmentDownloadOptions, AttachmentDownloadTarget, AttachmentDownloadTargetOptions, AttachmentHeader, AttachmentReferenceIndexBuildResult, AttachmentResponse, AttachmentStatOptions, IAttachmentReferenceReader, IAttachmentReferenceWriter, IAttachmentService, IAttachmentUpload, ReserveAttachmentOptions } from "@powerhousedao/reactor-attachments";
 import { IAttachmentClient } from "@powerhousedao/reactor-attachments/client";
 import { WebSocketServer } from "ws";
 import { AuthorizerResult, IHttpScope, IRelationalDb as IRelationalDb$1, IWebhookEndpoints, IWebhookScope, NodeRouteSpec, ProcessorApp, ProcessorFactory, RouteActor, RouteAuth, RouteAuthorizer, RouteBody, RouteContext, RouteHandler, RouteMethod, RouteOptions, RouteSpec, RouteTransport, RouteUser, RouteUser as RouteUser$1, ScopedRouteHandle, WebhookEndpointInfo, WebhookField, WebhookHashAlgorithm, WebhookPolicy, WebhookReply, WebhookRequest, WebhookScheme, WebhookSignatureEncoding, WebhookSpec, WebhookVerification } from "@powerhousedao/shared/processors";
+import { AttachmentReadGate, IDocumentScopeGate } from "@powerhousedao/reactor-attachments/replication";
 import { Generated, Kysely } from "kysely";
 import { PGlite } from "@electric-sql/pglite";
 import { Knex } from "knex";
@@ -22,7 +22,6 @@ import { Context as Context$1, GqlDocument as GqlDocument$1, GqlDriveDocument as
 import { IncomingHttpHeaders } from "http";
 import { Pool } from "pg";
 import { PHReactorRenown } from "@powerhousedao/shared/clis";
-
 //#region src/utils/db.d.ts
 /**
  * Permission levels for documents:
@@ -30,23 +29,23 @@ import { PHReactorRenown } from "@powerhousedao/shared/clis";
  * - WRITE: Can push updates and modify the document
  * - ADMIN: Can manage document permissions and settings
  */
-type DocumentPermissionLevel = "READ" | "WRITE" | "ADMIN";
+export type DocumentPermissionLevel = "READ" | "WRITE" | "ADMIN";
 /**
  * Database schema for document permissions
  */
-interface DocumentProtectionTable {
+export interface DocumentProtectionTable {
   documentId: string;
   protected: boolean;
   ownerAddress: string | null;
   createdAt: Date;
   updatedAt: Date;
 }
-interface DocumentPermissionDatabase {
+export interface DocumentPermissionDatabase {
   DocumentPermission: DocumentPermissionTable;
   OperationUserPermission: OperationUserPermissionTable;
   DocumentProtection: DocumentProtectionTable;
 }
-interface DocumentPermissionTable {
+export interface DocumentPermissionTable {
   id: Generated<number>;
   documentId: string;
   userAddress: string;
@@ -55,7 +54,7 @@ interface DocumentPermissionTable {
   createdAt: Date;
   updatedAt: Date;
 }
-interface OperationUserPermissionTable {
+export interface OperationUserPermissionTable {
   id: Generated<number>;
   documentId: string;
   operationType: string;
@@ -64,26 +63,27 @@ interface OperationUserPermissionTable {
   createdAt: Date;
 }
 type Db = Kysely<any>;
-declare const PGLITE_UTC_PARSERS: {
+export declare const PGLITE_UTC_PARSERS: {
   readonly 1114: (value: string) => Date;
 };
+export declare function isPostgresConnectionString(connectionString: string): boolean;
 /**
  * Optional factory used by callers (e.g. Switchboard) to inject a
  * version-specific PGLite instance — e.g. `pglite-legacy-02` when an existing
  * data dir was created with an older PG major. Wire-compatible with the
  * current PGLite class for the surface knex-pglite uses.
  */
-type PgliteFactory = (connectionString: string | undefined) => PGlite;
-interface DbClient {
+export type PgliteFactory = (connectionString: string | undefined) => PGlite;
+export interface DbClient {
   db: Db;
   knex: Knex;
   pglite: PGlite | undefined;
 }
-declare function getDbClient(connectionString?: string | undefined, pgliteFactory?: PgliteFactory): DbClient;
-declare const initAnalyticsStoreSql: string[];
+export declare function getDbClient(connectionString?: string | undefined, pgliteFactory?: PgliteFactory): DbClient;
+export declare const initAnalyticsStoreSql: string[];
 //#endregion
 //#region src/services/document-permission.service.d.ts
-interface DocumentPermissionEntry {
+export interface DocumentPermissionEntry {
   documentId: string;
   userAddress: string;
   permission: DocumentPermissionLevel;
@@ -91,7 +91,7 @@ interface DocumentPermissionEntry {
   createdAt: Date;
   updatedAt: Date;
 }
-interface OperationUserPermissionEntry {
+export interface OperationUserPermissionEntry {
   documentId: string;
   operationType: string;
   userAddress: string;
@@ -102,11 +102,11 @@ interface OperationUserPermissionEntry {
  * Function type for getting parent document IDs
  * This is injected to avoid circular dependencies with the reactor client
  */
-type GetParentIdsFn = (documentId: string) => Promise<string[]>;
+export type GetParentIdsFn = (documentId: string) => Promise<string[]>;
 /**
  * Configuration for the DocumentPermissionService
  */
-interface DocumentPermissionConfig {
+export interface DocumentPermissionConfig {
   defaultProtection: boolean;
 }
 /**
@@ -120,7 +120,7 @@ interface DocumentPermissionConfig {
  * Operation permissions:
  * - Users can be granted permission to execute specific operations
  */
-declare class DocumentPermissionService {
+export declare class DocumentPermissionService {
   private readonly db;
   readonly config: DocumentPermissionConfig;
   constructor(db: Kysely<DocumentPermissionDatabase>, config?: DocumentPermissionConfig);
@@ -148,7 +148,18 @@ declare class DocumentPermissionService {
   /**
    * Delete all permissions for a document (used when deleting a document)
    */
-  deleteAllDocumentPermissions(documentId: string): Promise<void>;
+  deleteAllDocumentPermissions(documentId: string): Promise<{
+    DocumentPermission: number;
+    OperationUserPermission: number;
+  }>;
+  /** Delete a document's protection row, which names its owner. */
+  deleteDocumentProtection(documentId: string): Promise<number>;
+  /** Every row that names the address, for a subject access request. */
+  rowsForAddress(address: string): Promise<{
+    permissions: DocumentPermissionEntry[];
+    operationPermissions: OperationUserPermissionEntry[];
+    ownedDocumentIds: string[];
+  }>;
   /**
    * Grant a user permission to execute an operation on a document
    */
@@ -230,7 +241,7 @@ type CanonicalDocumentId = string & {
  * always safe for the data fetch: the canonical id when resolved, or the raw
  * identifier when the check was skipped for a policy-wide caller.
  */
-declare class AuthorizedDocumentHandle {
+export declare class AuthorizedDocumentHandle {
   readonly fetchIdentifier: string;
   readonly isResolved: boolean;
   private constructor();
@@ -239,12 +250,12 @@ declare class AuthorizedDocumentHandle {
   /** The verified canonical id; throws when resolution was skipped. */
   canonicalId(): CanonicalDocumentId;
 }
-declare const AuthorizationPolicy: {
+export declare const AuthorizationPolicy: {
   readonly OPEN: "OPEN";
   readonly ADMIN_ONLY: "ADMIN_ONLY";
   readonly DOCUMENT_PERMISSIONS: "DOCUMENT_PERMISSIONS";
 };
-type AuthorizationPolicy = (typeof AuthorizationPolicy)[keyof typeof AuthorizationPolicy];
+export type AuthorizationPolicy = (typeof AuthorizationPolicy)[keyof typeof AuthorizationPolicy];
 interface AuthorizationConfig {
   admins: string[];
   defaultProtection: boolean;
@@ -288,32 +299,32 @@ interface IAuthorizationService {
 }
 //#endregion
 //#region src/graphql/gateway/types.d.ts
-type TlsOptions = {
+export type TlsOptions = {
   keyPath: string;
   certPath: string;
 } | {
   cert: Buffer | string;
   key: Buffer | string;
 } | true;
-type GatewayContextFactory<TContext = unknown> = (request: Request) => Promise<TContext>;
+export type GatewayContextFactory<TContext = unknown> = (request: Request) => Promise<TContext>;
 /** Under graphql-ws this is `ctx.extra`, created once per socket. */
-type WsConnection = object;
-type WsContextFactory<TContext = unknown> = (connectionParams: Record<string, unknown>, connection: WsConnection) => Promise<TContext>;
-type WsConnectHandler = (connectionParams: Record<string, unknown>, connection: WsConnection) => Promise<boolean>;
-type WsHandlers<TContext = unknown> = {
+export type WsConnection = object;
+export type WsContextFactory<TContext = unknown> = (connectionParams: Record<string, unknown>, connection: WsConnection) => Promise<TContext>;
+export type WsConnectHandler = (connectionParams: Record<string, unknown>, connection: WsConnection) => Promise<boolean>;
+export type WsHandlers<TContext = unknown> = {
   onConnect: WsConnectHandler;
   context: WsContextFactory<TContext>;
 };
 /** No authenticated caller resolved, and REQUIRE_AUTHENTICATED_CALLER wants one. */
-declare const WS_CLOSE_REASON_AUTHENTICATION_REQUIRED = "authentication-required";
+export declare const WS_CLOSE_REASON_AUTHENTICATION_REQUIRED = "authentication-required";
 /** A bearer was sent and could not be verified. */
-declare const WS_CLOSE_REASON_BEARER_REJECTED = "bearer-rejected";
+export declare const WS_CLOSE_REASON_BEARER_REJECTED = "bearer-rejected";
 /** Every reason a refusal closes with, for a client matching on the set. */
-declare const WS_AUTH_CLOSE_REASONS: readonly ["authentication-required", "bearer-rejected"];
-type WsDisposer = {
+export declare const WS_AUTH_CLOSE_REASONS: readonly ["authentication-required", "bearer-rejected"];
+export type WsDisposer = {
   dispose: () => void | Promise<void>;
 };
-type FetchHandler = (request: Request) => Promise<Response>;
+export type FetchHandler = (request: Request) => Promise<Response>;
 /**
  * Handle to a route registered directly on the adapter. Packages hot-reload,
  * so every registration is reversible; disposing a route that is already gone
@@ -329,7 +340,7 @@ type FetchHandler = (request: Request) => Promise<Response>;
  * which also carries the public URL the route answers on — at this layer there
  * is no namespace to build one from and no knowledge of the host's origin.
  */
-interface AdapterRouteHandle {
+export interface AdapterRouteHandle {
   dispose(): void;
 }
 /**
@@ -338,7 +349,7 @@ interface AdapterRouteHandle {
  * federation adapters treat it as a service to call over HTTP, while the
  * stitching adapter merges its typeDefs and resolvers in-process.
  */
-type SubgraphDefinition = {
+export type SubgraphDefinition = {
   name: string;
   typeDefs: DocumentNode;
   url: string;
@@ -351,7 +362,7 @@ type SubgraphDefinition = {
    */
   resolvers?: Record<string, unknown>;
 };
-interface IGatewayAdapter<TContext = unknown> {
+export interface IGatewayAdapter<TContext = unknown> {
   /** One-time startup. */
   start(httpServer: http.Server): Promise<void>;
   /**
@@ -381,8 +392,8 @@ interface IGatewayAdapter<TContext = unknown> {
  * Methods a node route may bind. OPTIONS is excluded: the framework's CORS
  * plugin owns preflight, and a duplicate registration conflicts at startup.
  */
-type HttpMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
-interface NodeRouteOptions {
+export type HttpMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+export interface NodeRouteOptions {
   /** Serve sub-paths too, not just an exact path match. */
   prefix?: boolean;
   /**
@@ -398,7 +409,7 @@ interface NodeRouteOptions {
    */
   rawBody?: boolean;
 }
-interface IHttpAdapter {
+export interface IHttpAdapter {
   /** Set up CORS and body-parser equivalent middleware. */
   setupMiddleware(config: {
     corsOptions?: CorsOptions;
@@ -413,7 +424,8 @@ interface IHttpAdapter {
    * replaces the previous one (last write wins).
    */
   mount(path: string, handler: FetchHandler, options?: {
-    prefix?: boolean; /** @deprecated Misleading name: this always meant *prefix*, not exact. */
+    prefix?: boolean;
+    /** @deprecated Misleading name: this always meant *prefix*, not exact. */
     exact?: boolean;
   }): AdapterRouteHandle;
   /**
@@ -423,9 +435,10 @@ interface IHttpAdapter {
   getRoute(path: string, handler: (request: Request) => Response | Promise<Response>): AdapterRouteHandle;
   /**
    * Start listening on the given port. Returns the underlying http.Server
-   * so callers can attach WebSocket servers.
+   * so callers can attach WebSocket servers. Without `host` it binds the
+   * wildcard address.
    */
-  listen(port: number, tls?: TlsOptions): Promise<http.Server>;
+  listen(port: number, tls?: TlsOptions, host?: string): Promise<http.Server>;
   /**
    * Mount a raw Connect/Express-compatible middleware function (e.g. Vite dev
    * server middleware). The implementation is adapter-specific; for Express this
@@ -454,12 +467,12 @@ interface IHttpAdapter {
 }
 //#endregion
 //#region src/services/auth.service.d.ts
-type CredentialVerifier = (params: {
+export type CredentialVerifier = (params: {
   address: string;
   chainId: number;
   appId: string;
 }) => Promise<boolean>;
-interface AuthConfig {
+export interface AuthConfig {
   /**
    * Whether the authorization policy enforces anything: it selects `ADMIN_ONLY`
    * over `OPEN`, and it is what `AuthContext.auth_enabled` reports to callers
@@ -492,13 +505,13 @@ interface AuthConfig {
  * `@powerhousedao/shared/processors` as `RouteUser`, so a route handler and a
  * resolver agree on it without either package redeclaring it.
  */
-type User = RouteUser$1;
-interface AuthContext {
+export type User = RouteUser$1;
+export interface AuthContext {
   user?: User;
   admins: string[];
   auth_enabled: boolean;
 }
-declare class AuthService {
+export declare class AuthService {
   private readonly config;
   private readonly credentialCache;
   constructor(config: AuthConfig);
@@ -575,11 +588,13 @@ interface IWebhookStore {
   revoke(namespace: string, endpoint: string, ownerKey: string): Promise<void>;
   /** True when this delivery has been seen before, within the TTL. */
   seen(token: string, key: string, ttlSeconds: number): Promise<boolean>;
+  /** Drops a delivery recorded by seen(), so a retry of it is delivered. */
+  forget(token: string, key: string): Promise<void>;
 }
 /** Opaque and unguessable: the URL is a bearer capability held by a third party. */
-declare function newWebhookToken(): string;
+export declare function newWebhookToken(): string;
 /** Relational implementation, over the reactor's own database. */
-declare class RelationalWebhookStore implements IWebhookStore {
+export declare class RelationalWebhookStore implements IWebhookStore {
   #private;
   private readonly relationalDb;
   constructor(relationalDb: IRelationalDb$1);
@@ -588,14 +603,16 @@ declare class RelationalWebhookStore implements IWebhookStore {
   find(token: string): Promise<WebhookEndpointRow | undefined>;
   list(namespace: string, endpoint?: string): Promise<WebhookEndpointRow[]>;
   revoke(namespace: string, endpoint: string, ownerKey: string): Promise<void>;
+  forget(token: string, key: string): Promise<void>;
   seen(token: string, key: string, ttlSeconds: number): Promise<boolean>;
 }
 /** In-memory store, for hosts with no relational database and for tests. */
-declare class MemoryWebhookStore implements IWebhookStore {
+export declare class MemoryWebhookStore implements IWebhookStore {
   #private;
   init(): Promise<void>;
   ensure(namespace: string, endpoint: string, ownerKey: string): Promise<WebhookEndpointRow>;
   find(token: string): Promise<WebhookEndpointRow | undefined>;
+  forget(token: string, key: string): Promise<void>;
   list(namespace: string, endpoint?: string): Promise<WebhookEndpointRow[]>;
   revoke(namespace: string, endpoint: string, ownerKey: string): Promise<void>;
   seen(token: string, key: string, ttlSeconds: number): Promise<boolean>;
@@ -603,7 +620,7 @@ declare class MemoryWebhookStore implements IWebhookStore {
 //#endregion
 //#region src/http/webhook-service.d.ts
 /** The flat, token-addressed path family. */
-declare const WEBHOOK_SEGMENT = "webhooks";
+export declare const WEBHOOK_SEGMENT = "webhooks";
 interface WebhookServiceOptions {
   store: IWebhookStore;
   basePath?: string;
@@ -612,13 +629,9 @@ interface WebhookServiceOptions {
 }
 /** One host route for `/webhooks/:token`, dispatching by token. The flat path leaks
  * neither package nor document; the namespace lives in the token record, which is also what stops one package's token reaching another's handler. */
-declare class WebhookService {
+export declare class WebhookService {
   #private;
-  constructor({
-    store,
-    basePath,
-    publicUrl
-  }: WebhookServiceOptions);
+  constructor({ store, basePath, publicUrl }: WebhookServiceOptions);
   /** The scope the endpoint family serves from, handed over once the route service exists;
    * separate from the constructor only because that service takes this one as an option. */
   attach(scope: IHttpScope): void;
@@ -637,9 +650,9 @@ declare class WebhookService {
 //#endregion
 //#region src/http/route-service.d.ts
 /** The segment package routes live under, inside the host's base path. */
-declare const PACKAGE_ROUTE_SEGMENT = "api";
+export declare const PACKAGE_ROUTE_SEGMENT = "api";
 /** The namespace core's own subgraphs and services register under. */
-declare const CORE_PACKAGE_NAME = "@powerhousedao/reactor-api";
+export declare const CORE_PACKAGE_NAME = "@powerhousedao/reactor-api";
 interface HttpRouteServiceOptions {
   httpAdapter: IHttpAdapter;
   /** Absent on a host with no webhook store; `scope.webhooks` then refuses. */
@@ -656,16 +669,9 @@ interface HttpRouteServiceOptions {
 }
 /** Owns the URL space packages serve from, handing each a scope bound to its own namespace. The prefix nests inside
  * the host's base path (`<basePath>/api`), so core collisions are prevented by URL shape, not a reserved-name list. */
-declare class HttpRouteService {
+export declare class HttpRouteService {
   #private;
-  constructor({
-    httpAdapter,
-    basePath,
-    authService,
-    webhooks,
-    publicUrl,
-    trustProxy
-  }: HttpRouteServiceOptions);
+  constructor({ httpAdapter, basePath, authService, webhooks, publicUrl, trustProxy }: HttpRouteServiceOptions);
   /** The absolute path packages are mounted under. */
   get prefix(): string;
   /** The scope for a package; idempotent per name, so a reload cannot accumulate namespaces. Throws when two packages
@@ -683,18 +689,18 @@ declare class HttpRouteService {
 }
 //#endregion
 //#region src/http/namespace.d.ts
-declare class InvalidNamespaceError extends Error {}
+export declare class InvalidNamespaceError extends Error {}
 /**
  * Turns a package name into the path segments it occupies.
  * `@powerhousedao/workflow` → ["@powerhousedao", "workflow"]
  * `document-model`          → ["document-model"]
  */
-declare function namespaceSegments(packageName: string): string[];
+export declare function namespaceSegments(packageName: string): string[];
 /**
  * The path a package's routes hang off, relative to the package prefix.
  * Scoped names occupy two segments — the addressing unpkg and jsdelivr use.
  */
-declare function namespacePath(packageName: string): string;
+export declare function namespacePath(packageName: string): string;
 /**
  * Resolves the npm name a package is routed under from the key the package
  * manager holds it by. That key is the specifier as configured, which is not
@@ -707,7 +713,7 @@ declare function namespacePath(packageName: string): string;
  * Deriving a URL segment straight from the key would give a developer's home
  * directory a route namespace, so the path form is resolved rather than slugged.
  */
-declare function resolvePackageName(key: string, readPackageJsonName?: (dir: string) => string | undefined): string;
+export declare function resolvePackageName(key: string, readPackageJsonName?: (dir: string) => string | undefined): string;
 /**
  * A mount path the host named for one of its own route groups.
  *
@@ -722,7 +728,7 @@ declare function resolvePackageName(key: string, readPackageJsonName?: (dir: str
  * routes unpredictable relative to each other. Returns the normalized path,
  * with a leading and no trailing slash.
  */
-declare function assertHostMountPath(path: string): string;
+export declare function assertHostMountPath(path: string): string;
 //#endregion
 //#region src/http/webhook-verify.d.ts
 type VerifyResult = {
@@ -733,20 +739,210 @@ type VerifyResult = {
 };
 /** Verifies a delivery against the configured scheme; `raw` must be the exact bytes
  * received. The reason is for the log only: callers answer a fixed 401, so a probing sender learns nothing from the body. */
-declare function verifyWebhook(options: {
+export declare function verifyWebhook(options: {
   verification: WebhookVerification;
   headers: Record<string, string>;
   raw: Buffer;
   now?: Date;
 }): VerifyResult;
-declare function redactHeaders(headers: Record<string, string>, extra?: string): Record<string, string>;
+export declare function redactHeaders(headers: Record<string, string>, extra?: string): Record<string, string>;
 /** JSON and form bodies become objects; anything else stays decoded text, so a verified
  * XML or CSV payload is still reachable downstream. */
-declare function parseWebhookBody(raw: Buffer, contentType?: string): unknown;
+export declare function parseWebhookBody(raw: Buffer, contentType?: string): unknown;
+//#endregion
+//#region src/services/canonical-document-id.d.ts
+/**
+ * Raised when a caller-supplied identifier cannot be resolved to a canonical
+ * document id. Carries no detail on purpose: resolution failures must not act
+ * as a document-existence oracle, so consumers map this to their generic
+ * fail-closed response.
+ */
+export declare class CanonicalDocumentIdResolutionError extends Error {
+  constructor();
+}
+export type CanonicalDocumentIdResolver = (identifier: string) => Promise<CanonicalDocumentId>;
+/**
+ * The sanctioned string-to-CanonicalDocumentId cast: both the GraphQL layer
+ * and server routes must resolve caller identifiers through this helper so
+ * decision and data layers always agree on the subject document.
+ */
+export declare function createCanonicalDocumentIdResolver(client: Pick<IReactorClient, "resolveIdOrSlug">): CanonicalDocumentIdResolver;
+//#endregion
+//#region src/services/attachment-access.service.d.ts
+/**
+ * Whether the active Reactor composition hosts the attachment-reference
+ * projection. Reported by the client initializer: the built-in stack always
+ * registers it, while a caller-provided Reactor may lack the live
+ * registration capability. Consumers of reference evidence must fail closed
+ * when it is unavailable.
+ */
+export type AttachmentReferenceProjectionCapability = {
+  status: "available";
+} | {
+  status: "unavailable";
+  reason: "live-read-model-registration-unsupported" | "in-process-reactor-module-unavailable" | "initializer-did-not-report";
+};
+/**
+ * Outcome of an attachment read authorization. `denied` intentionally covers
+ * both an unreadable document and an absent document/ref relationship so the
+ * route layer cannot leak which check failed. `projection-unavailable` means
+ * the reference index is not being maintained in this composition; it is
+ * returned before any document-authorization or reference lookup runs.
+ */
+export type AttachmentAccessResult = {
+  kind: "allowed";
+  documentId: CanonicalDocumentId;
+  ref: AttachmentRef;
+} | {
+  kind: "denied";
+} | {
+  kind: "projection-unavailable";
+};
+export interface AttachmentAccessRequest {
+  documentId: string;
+  attachmentRef: string;
+  userAddress?: string;
+  /**
+   * The `did:key` of the app instance whose token authenticated the caller.
+   * A policy subject is an address AND a key — a grant can name either, and a
+   * document's creator is recorded by key — so a decision made from the address
+   * alone answers a narrower question than the one being asked.
+   */
+  appKey?: string;
+}
+export type AttachmentCallerResult = {
+  kind: "admitted";
+} | {
+  kind: "unauthenticated";
+};
+export interface AttachmentCallerRequest {
+  intent: "read" | "write";
+  userAddress?: string;
+  appKey?: string;
+}
+export interface IAttachmentAccessService {
+  canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
+  /** Whether this caller may use attachments at all, before any document decides. */
+  admitCaller(request: AttachmentCallerRequest): Promise<AttachmentCallerResult>;
+}
+export interface AttachmentAccessServiceOptions {
+  /** Refuse writes from a caller with no address. Default `true`. */
+  refuseAnonymousWrites?: boolean;
+  /** Refuse reads from a caller with no address. Default `false`. */
+  refuseAnonymousReads?: boolean;
+}
+/**
+ * Composes document authorization with the projected document/ref
+ * relationship. Order is fixed: validate ref, resolve the canonical document
+ * id, decide the read, check the reactor's read gate serves the document, then
+ * check the reference index and that the subject may read a scope whose
+ * operations reference the attachment. A denied document never reaches the
+ * reference reader, and the facade never touches attachment metadata, storage
+ * backends, or presigners.
+ *
+ * The named document decides alone: an attachment several documents reference
+ * is readable through each of them on that document's own terms.
+ *
+ * The read is decided by the document's own policy when this composition has a
+ * model to enforce it with, and by the host's permission tables when it does
+ * not. That is not a preference between two equivalent answers: a host running
+ * document policies keeps no rows in the permission tables, so asking them
+ * about such a document returns whatever the host-wide policy says — under
+ * `OPEN`, `true`, for everyone. Serving bytes on that answer hands the file to
+ * anyone who learns its hash, which the document's own state may well have told
+ * them. Both are kept because they are the two halves of one rule: an
+ * attachment is readable by whoever may read the document that references it,
+ * and each composition can only express that in its own terms. The caller
+ * decision mirrors the routes' `requireAuth`.
+ */
+export declare class AttachmentAccessService implements IAttachmentAccessService {
+  private readonly resolveCanonicalId;
+  private readonly authorization;
+  private readonly references;
+  private readonly projection;
+  private readonly readGate;
+  /**
+   * Absent below auth enforcement, where there is no policy model to
+   * evaluate; the host's permission tables decide alone, exactly as before.
+   */
+  private readonly scopeGate?;
+  private readonly options;
+  constructor(resolveCanonicalId: CanonicalDocumentIdResolver, authorization: IAuthorizationService, references: IAttachmentReferenceReader, projection: AttachmentReferenceProjectionCapability, readGate: AttachmentReadGate,
+  /**
+   * Absent below auth enforcement, where there is no policy model to
+   * evaluate; the host's permission tables decide alone, exactly as before.
+   */
+  scopeGate?: IDocumentScopeGate | undefined, options?: AttachmentAccessServiceOptions);
+  admitCaller(request: AttachmentCallerRequest): Promise<AttachmentCallerResult>;
+  canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
+  /**
+   * Whether the caller may read the state the reference lives in.
+   *
+   * A failure here is rethrown rather than turned into a denial. A read side
+   * that is down must not read as a policy: a denial nobody can distinguish
+   * from a refusal is one nobody investigates, and the route answers 500 for a
+   * reason.
+   */
+  private canReadDocument;
+}
+//#endregion
+//#region src/services/authorized-attachment.service.d.ts
+/** The reference index is not maintained in this composition. */
+export declare class AttachmentAccessUnavailable extends Error {
+  constructor();
+}
+/** The access decision itself failed; the cause is logged, not surfaced. */
+export declare class AttachmentAccessFailed extends Error {
+  constructor(cause: unknown);
+}
+/** An `IAttachmentService` whose reads and writes are decided for one subject. */
+export declare class AuthorizedAttachmentService implements IAttachmentService {
+  private readonly inner;
+  private readonly access;
+  private readonly subject;
+  private readonly logger;
+  constructor(inner: IAttachmentService, access: IAttachmentAccessService, subject: AuthSubject, logger: ILogger);
+  /** Hash-first only: an upload-first handle can send after it expires. */
+  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
+  stat(ref: AttachmentRef, options?: AttachmentStatOptions): Promise<AttachmentHeader>;
+  get(ref: AttachmentRef, options?: AbortSignal | AttachmentDownloadOptions): Promise<AttachmentResponse>;
+  getDownloadTarget(ref: AttachmentRef, options: AttachmentDownloadTargetOptions): Promise<AttachmentDownloadTarget>;
+  private decideRead;
+  private admit;
+  private accessFailed;
+}
+export interface IAttachmentClientProvider {
+  forSubject(subject: AuthSubject): IAttachmentClient;
+}
+export declare class AttachmentClientProvider implements IAttachmentClientProvider {
+  private readonly service;
+  private readonly access;
+  private readonly logger;
+  constructor(service: IAttachmentService, access: IAttachmentAccessService, logger: ILogger);
+  forSubject(subject: AuthSubject): IAttachmentClient;
+}
+//#endregion
+//#region src/graphql/inspection/source.d.ts
+/** What the inspection subgraph serves. Only reads cross GraphQL. */
+interface IReactorInspectionSource {
+  /** Reads as the host; drive and document reads are re-made as the caller. */
+  readonly inspector: IInspector;
+  readonly syncInspector: ISyncInspector | undefined;
+  readonly documentModelRegistry: IDocumentModelRegistry;
+  /** Facts the host learns after boot, e.g. a composed workflow runtime. */
+  readonly facts: IReactorFactsSink;
+}
+type ReactorInspectionOptions = {
+  /** Absent: a group-commit store's own health, else `tracked: false`. */
+  storageHealth?: IInspectorStorageHealthProvider;
+  attachmentStore?: IInspectableAttachmentStore;
+  workflows?: boolean;
+};
+export declare function createReactorInspectionSource(module: InProcessReactorModule, options?: ReactorInspectionOptions): IReactorInspectionSource;
 //#endregion
 //#region src/graphql/types.d.ts
-type SubgraphClass = typeof BaseSubgraph;
-type Context = {
+export type SubgraphClass = typeof BaseSubgraph;
+export type Context = {
   driveId?: string;
   document?: PHDocument;
   headers: IncomingHttpHeaders;
@@ -754,11 +950,12 @@ type Context = {
   user?: {
     address: string;
     chainId: number;
-    networkId: string; /** The did:key of the app instance that issued this request's token. */
+    networkId: string;
+    /** The did:key of the app instance that issued this request's token. */
     appKey: string;
   };
 };
-type ISubgraph = {
+export type ISubgraph = {
   name: string;
   /**
    * @deprecated The GraphQL manager mounts every subgraph under its own base
@@ -776,7 +973,7 @@ type ISubgraph = {
   onSetup?: () => Promise<void>;
   onDisconnect?: () => Promise<void>;
 };
-type SubgraphArgs = {
+export type SubgraphArgs = {
   reactorClient: IReactorClient;
   /**
    * The subgraph's package's slice of the HTTP surface, for serving REST
@@ -796,6 +993,13 @@ type SubgraphArgs = {
    * to the host's permission tables alone.
    */
   syncServingGate?: SyncScopeGate;
+  /**
+   * Attachments as the request's caller may use them. Bind per request with
+   * `BaseSubgraph.attachmentsFor(ctx)`.
+   */
+  attachments?: IAttachmentClientProvider;
+  /** Read only by `InspectionSubgraph`, registered only when this is set. */
+  inspection?: IReactorInspectionSource;
   /**
    * The host's base path, injected by the GraphQL manager when it constructs
    * a subgraph. Subgraph code may read it, but routing ignores it: every
@@ -803,7 +1007,7 @@ type SubgraphArgs = {
    */
   path?: string;
 };
-type GqlSigner = {
+export type GqlSigner = {
   user: {
     address: string;
     networkId: string;
@@ -815,19 +1019,19 @@ type GqlSigner = {
   };
   signatures: string[];
 };
-type GqlOperationContext = {
+export type GqlOperationContext = {
   signer: GqlSigner | undefined;
 };
-type GqlSignerUser = {
+export type GqlSignerUser = {
   address: string;
   networkId: string;
   chainId: number;
 };
-type GqlSignerApp = {
+export type GqlSignerApp = {
   name: string;
   key: string;
 };
-type GqlOperation = {
+export type GqlOperation = {
   id: string;
   type: string;
   index: number;
@@ -838,7 +1042,7 @@ type GqlOperation = {
   error: string | undefined;
   context: GqlOperationContext;
 };
-type GqlDocument = {
+export type GqlDocument = {
   __typename?: string;
   id: string;
   name: string;
@@ -851,7 +1055,7 @@ type GqlDocument = {
   state: unknown;
   initialState: unknown;
 };
-type GqlDriveDocument = GqlDocument & {
+export type GqlDriveDocument = GqlDocument & {
   meta: {
     preferredEditor?: string;
   };
@@ -861,7 +1065,12 @@ type GqlDriveDocument = GqlDocument & {
 };
 //#endregion
 //#region src/graphql/base-subgraph.d.ts
-declare class BaseSubgraph implements ISubgraph$1 {
+/**
+ * The subject a request reads as: its address and the app key its token
+ * carries. Anonymous is an empty subject, never the host's signer.
+ */
+export declare function callerSubject(user: Context["user"]): AuthSubject;
+export declare class BaseSubgraph implements ISubgraph$1 {
   #private;
   name: string;
   path: string;
@@ -877,6 +1086,12 @@ declare class BaseSubgraph implements ISubgraph$1 {
   authorizationService: IAuthorizationService;
   syncServingGate?: SyncScopeGate;
   constructor(args: SubgraphArgs$1);
+  /**
+   * An attachment client bound to this request's caller, memoized per request.
+   *
+   * @throws Error when the host provides no attachment client to subgraphs.
+   */
+  attachmentsFor(ctx: Context): IAttachmentClient;
   onSetup(): Promise<void>;
   onDisconnect(): Promise<void>;
   /**
@@ -902,6 +1117,10 @@ declare class BaseSubgraph implements ISubgraph$1 {
    * layer, such as a fetched document's id). Performs no slug resolution.
    */
   canReadDocument(documentId: CanonicalDocumentId, ctx: Context): Promise<boolean>;
+  /** Drops the items the host's own ACL refuses the caller. */
+  readableByHost<T extends {
+    id: string;
+  }>(items: readonly T[], ctx: Context): Promise<T[]>;
   /**
    * The principal a request decides as: the authenticated caller's address, and
    * the did:key of the app instance whose token authenticated it.
@@ -913,6 +1132,16 @@ declare class BaseSubgraph implements ISubgraph$1 {
    * carries the same key. Anonymous callers supply neither.
    */
   protected viewSubject(ctx: Context): AuthSubject;
+  /** Whether a listing would serve the document to the caller; fails closed. */
+  protected servesDocument(documentId: string, ctx: Context): Promise<boolean>;
+  /** {@link servesDocument}, but a reactor that cannot answer throws. */
+  protected servesDocumentOrThrows(identifier: string, ctx: Context, view?: Pick<ViewFilter, "branch" | "scopes">): Promise<boolean>;
+  /**
+   * Whether a listing would serve the document to the caller: the reactor read
+   * gate, then the host's legacy layer, as `findDocuments` applies them. Absent
+   * or withheld is `false`; a failure to decide throws.
+   */
+  protected listsDocument(identifier: string, ctx: Context, view?: Pick<ViewFilter, "branch" | "scopes">): Promise<boolean>;
   /**
    * Asserts read access, resolving a slug first. Returns a handle whose
    * `fetchIdentifier` the caller reuses for the data fetch; a denial throws.
@@ -931,16 +1160,24 @@ declare class BaseSubgraph implements ISubgraph$1 {
 }
 //#endregion
 //#region src/graphql/analytics-subgraph.d.ts
-declare class AnalyticsSubgraph extends BaseSubgraph {
+export declare class AnalyticsSubgraph extends BaseSubgraph {
+  #private;
   analyticsStore: IAnalyticsStore;
   analyticsModel: AnalyticsModel;
   name: string;
-  typeDefs: graphql.DocumentNode;
+  typeDefs: import("graphql").DocumentNode;
+  /**
+   * Every analytics field hangs off `Query.analytics`, so gating it gates them
+   * all. Series are aggregates a processor built from many documents and carry
+   * no document to decide on, so only a caller with policy-wide read (anyone
+   * under OPEN, an admin otherwise) may read them.
+   */
   resolvers: GraphQLResolverMap<Context$1>;
   constructor(args: SubgraphArgs$1);
 }
-//#endregion
-//#region src/graphql/auth/resolvers.d.ts
+declare namespace resolvers_d_exports {
+  export { DocumentAccessInfo, DocumentProtectionInfo, OperationPermissionsInfo, OperationUserPermission, canExecuteOperation, documentAccess, documentProtection, grantDocumentPermission, grantOperationPermission, operationPermissions, revokeDocumentPermission, revokeOperationPermission, setDocumentProtection, transferDocumentOwnership, userDocumentPermissions };
+}
 type DocumentAccessInfo = {
   documentId: string;
   permissions: Array<{
@@ -952,6 +1189,33 @@ type DocumentAccessInfo = {
     updatedAt: Date;
   }>;
 };
+declare function documentAccess(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+}, userAddress: string | undefined): Promise<DocumentAccessInfo>;
+declare function userDocumentPermissions(service: DocumentPermissionService, userAddress: string): Promise<Array<{
+  documentId: string;
+  userAddress: string;
+  permission: DocumentPermissionLevel;
+  grantedBy: string;
+  createdAt: Date;
+  updatedAt: Date;
+}>>;
+declare function grantDocumentPermission(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+  userAddress: string;
+  permission: DocumentPermissionLevel;
+}, grantedByAddress: string | undefined): Promise<{
+  documentId: string;
+  userAddress: string;
+  permission: DocumentPermissionLevel;
+  grantedBy: string;
+  createdAt: Date;
+  updatedAt: Date;
+}>;
+declare function revokeDocumentPermission(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+  userAddress: string;
+}, revokedByAddress: string | undefined): Promise<boolean>;
 type OperationUserPermission = {
   documentId: string;
   operationType: string;
@@ -964,13 +1228,46 @@ type OperationPermissionsInfo = {
   operationType: string;
   userPermissions: OperationUserPermission[];
 };
+declare function operationPermissions(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+  operationType: string;
+}, userAddress: string | undefined): Promise<OperationPermissionsInfo>;
+declare function canExecuteOperation(authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+  operationType: string;
+}, userAddress: string | undefined): Promise<boolean>;
+declare function grantOperationPermission(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+  operationType: string;
+  userAddress: string;
+}, grantedByAddress: string | undefined): Promise<OperationUserPermission>;
+declare function revokeOperationPermission(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+  operationType: string;
+  userAddress: string;
+}, revokedByAddress: string | undefined): Promise<boolean>;
 type DocumentProtectionInfo = {
   documentId: string;
   protected: boolean;
   ownerAddress: string | null;
 };
+declare function documentProtection(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+}, userAddress: string | undefined): Promise<DocumentProtectionInfo>;
+declare function setDocumentProtection(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+  protected: boolean;
+}, userAddress: string | undefined): Promise<DocumentProtectionInfo>;
+declare function transferDocumentOwnership(service: DocumentPermissionService, authorizationService: IAuthorizationService, args: {
+  documentId: CanonicalDocumentId;
+  newOwnerAddress: string;
+}, userAddress: string | undefined): Promise<DocumentProtectionInfo>;
 //#endregion
 //#region src/graphql/auth/subgraph.d.ts
+type DocumentArgs = {
+  documentIdOrSlug?: string | null;
+  documentId?: string | null;
+};
 /**
  * Auth Subgraph - handles all document permission and authorization operations
  *
@@ -980,17 +1277,16 @@ type DocumentProtectionInfo = {
  * - Document protection and ownership
  * - Operation-level permissions (fine-grained operation control)
  */
-declare class AuthSubgraph extends BaseSubgraph {
+export declare class AuthSubgraph extends BaseSubgraph {
+  #private;
   private logger;
   constructor(args: SubgraphArgs);
   name: string;
   hasSubscriptions: boolean;
-  typeDefs: graphql.DocumentNode;
+  typeDefs: import("graphql").DocumentNode;
   resolvers: {
     Query: {
-      documentAccess: (_parent: unknown, args: {
-        documentId: string;
-      }, ctx: {
+      documentAccess: (_parent: unknown, args: DocumentArgs, ctx: {
         user?: {
           address: string;
         };
@@ -1007,49 +1303,42 @@ declare class AuthSubgraph extends BaseSubgraph {
         createdAt: Date;
         updatedAt: Date;
       }[]>;
-      operationPermissions: (_parent: unknown, args: {
-        documentId: string;
+      operationPermissions: (_parent: unknown, args: DocumentArgs & {
         operationType: string;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<OperationPermissionsInfo>;
-      canExecuteOperation: (_parent: unknown, args: {
-        documentId: string;
+      canExecuteOperation: (_parent: unknown, args: DocumentArgs & {
         operationType: string;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<boolean>;
-      documentProtection: (_parent: unknown, args: {
-        documentId: string;
-      }, ctx: {
+      documentProtection: (_parent: unknown, args: DocumentArgs, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<DocumentProtectionInfo>;
     };
     Mutation: {
-      setDocumentProtection: (_parent: unknown, args: {
-        documentId: string;
+      setDocumentProtection: (_parent: unknown, args: DocumentArgs & {
         protected: boolean;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<DocumentProtectionInfo>;
-      transferDocumentOwnership: (_parent: unknown, args: {
-        documentId: string;
+      transferDocumentOwnership: (_parent: unknown, args: DocumentArgs & {
         newOwnerAddress: string;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<DocumentProtectionInfo>;
-      grantDocumentPermission: (_parent: unknown, args: {
-        documentId: string;
+      grantDocumentPermission: (_parent: unknown, args: DocumentArgs & {
         userAddress: string;
         permission: string;
       }, ctx: {
@@ -1064,16 +1353,14 @@ declare class AuthSubgraph extends BaseSubgraph {
         createdAt: Date;
         updatedAt: Date;
       }>;
-      revokeDocumentPermission: (_parent: unknown, args: {
-        documentId: string;
+      revokeDocumentPermission: (_parent: unknown, args: DocumentArgs & {
         userAddress: string;
       }, ctx: {
         user?: {
           address: string;
         };
       }) => Promise<boolean>;
-      grantOperationPermission: (_parent: unknown, args: {
-        documentId: string;
+      grantOperationPermission: (_parent: unknown, args: DocumentArgs & {
         operationType: string;
         userAddress: string;
       }, ctx: {
@@ -1081,8 +1368,7 @@ declare class AuthSubgraph extends BaseSubgraph {
           address: string;
         };
       }) => Promise<OperationUserPermission>;
-      revokeOperationPermission: (_parent: unknown, args: {
-        documentId: string;
+      revokeOperationPermission: (_parent: unknown, args: DocumentArgs & {
         operationType: string;
         userAddress: string;
       }, ctx: {
@@ -1096,21 +1382,29 @@ declare class AuthSubgraph extends BaseSubgraph {
 }
 //#endregion
 //#region src/graphql/gateway/auth-middleware.d.ts
-type AuthFetchMiddleware = (handler: FetchHandler) => FetchHandler;
+export type AuthFetchMiddleware = (handler: FetchHandler) => FetchHandler;
 /** Internal — only `graphql-manager.ts` should call this. */
-declare function getAuthContext(request: globalThis.Request): AuthContext | undefined;
-declare function createAuthFetchMiddleware(authService: AuthService): AuthFetchMiddleware;
+export declare function getAuthContext(request: globalThis.Request): AuthContext | undefined;
+export declare function createAuthFetchMiddleware(authService: AuthService): AuthFetchMiddleware;
 //#endregion
 //#region src/graphql/gateway/factory.d.ts
-type GatewayAdapterType = "apollo" | "mercurius" | "stitching";
-type HttpAdapterType = "express" | "fastify";
-declare function createGatewayAdapter(type: GatewayAdapterType, logger: ILogger): Promise<IGatewayAdapter<Context>>;
-type HttpAdapterSetup = {
+export type GatewayAdapterType = "apollo" | "mercurius" | "stitching";
+export type HttpAdapterType = "express" | "fastify";
+export declare function createGatewayAdapter(type: GatewayAdapterType, logger: ILogger): Promise<IGatewayAdapter<Context>>;
+export type HttpAdapterSetup = {
   adapter: IHttpAdapter;
 };
-declare function createHttpAdapter(type: HttpAdapterType): Promise<HttpAdapterSetup>;
+export declare function createHttpAdapter(type: HttpAdapterType): Promise<HttpAdapterSetup>;
 //#endregion
 //#region src/graphql/gateway/drive-ownership-cache.d.ts
+/**
+ * Where drives are looked up: the raw reactor, past the read gate. Ownership
+ * is a storage fact that serves no content, so a policy that withholds a drive
+ * from the host's key must not make the host deny holding it.
+ */
+type DriveStore = {
+  find(search: SearchFilter): Promise<PagedResults<PHDocument>>;
+};
 /**
  * In-memory record of which drives this switchboard instance owns.
  *
@@ -1122,11 +1416,17 @@ declare function createHttpAdapter(type: HttpAdapterType): Promise<HttpAdapterSe
  * 421 response.
  */
 declare class DriveOwnershipCache {
-  private readonly reactorClient;
+  private readonly store;
   private readonly drives;
-  constructor(reactorClient: IReactorClient);
+  constructor(store: DriveStore);
   init(): Promise<void>;
   has(driveId: string): boolean;
+  /**
+   * Whether this host holds the drive, asking the reactor on a miss: drives
+   * also arrive by sync and by writes that bypass the create resolvers. A
+   * positive answer is cached; a failure to ask throws.
+   */
+  holds(driveId: string): Promise<boolean>;
   add(driveId: string): void;
   remove(driveId: string): void;
   size(): number;
@@ -1136,33 +1436,49 @@ declare class DriveOwnershipCache {
 type RequireAuthFetchMiddleware = (handler: FetchHandler) => FetchHandler;
 //#endregion
 //#region src/graphql/graphql-manager.d.ts
-type GraphqlManagerFeatureFlags = {
+export type GraphqlManagerFeatureFlags = {
   enableDocumentModelSubgraphs?: boolean;
 };
-declare function createWsAuthHandlers(opts: {
-  authService?: AuthService; /** Whether anonymous callers are refused; read at call time, not at build time. */
+/** Dependencies and settings for a {@link GraphQLManager}. */
+export type GraphQLManagerOptions = {
+  path: string;
+  httpServer: http.Server;
+  wsServer: WebSocketServer;
+  reactorClient: IReactorClient;
+  relationalDb: IRelationalDb;
+  analyticsStore: IAnalyticsStore;
+  syncManager: ISyncManager;
+  logger: ILogger;
+  httpAdapter: IHttpAdapter;
+  gatewayAdapter: IGatewayAdapter<Context$1>;
+  authService?: AuthService;
+  documentPermissionService?: DocumentPermissionService;
+  /** Defaults to every flag on. */
+  featureFlags?: GraphqlManagerFeatureFlags;
+  /** Defaults to 4001. */
+  port?: number;
+  authorizationService: IAuthorizationService;
+  /** Resolvers dispatch to it for reactor-drive parents. */
+  reactorDriveClient?: IDriveClient;
+  syncServingGate?: SyncScopeGate;
+  httpRoutes?: HttpRouteService;
+  attachments?: IAttachmentClientProvider;
+  inspection?: IReactorInspectionSource;
+  /**
+   * Where drive ownership is looked up, past the read gate. Defaults to the
+   * reactor client, which withholds a drive the host's own key may not read.
+   */
+  driveStore?: DriveStore;
+};
+export declare function createWsAuthHandlers(opts: {
+  authService?: AuthService;
+  /** Whether anonymous callers are refused; read at call time, not at build time. */
   requireAuthenticatedCaller: () => boolean;
   logger: ILogger;
   buildContext: (connectionParams: Record<string, unknown>, user?: User) => Context$1;
 }): WsHandlers<Context$1>;
-declare class GraphQLManager {
+export declare class GraphQLManager {
   #private;
-  private readonly path;
-  private readonly httpServer;
-  private readonly wsServer;
-  private readonly reactorClient;
-  private readonly relationalDb;
-  private readonly analyticsStore;
-  private readonly syncManager;
-  private readonly logger;
-  private readonly httpAdapter;
-  private readonly gatewayAdapter;
-  private readonly authService?;
-  private readonly documentPermissionService?;
-  private readonly featureFlags;
-  private readonly port;
-  private readonly syncServingGate?;
-  private readonly httpRoutes?;
   private initialized;
   private coreSubgraphsMap;
   private contextFields;
@@ -1174,8 +1490,8 @@ declare class GraphQLManager {
   private readonly subgraphHandlerCache;
   /** subgraphPath → the http adapter handle of its mounted route. */
   private readonly subgraphRouteHandles;
-  /** Handle of the currently mounted supergraph SSE route, if any. */
-  private sseRouteHandle;
+  /** Mounted SSE routes, keyed by path: the supergraph's and each subgraph's. */
+  private readonly sseRouteHandles;
   /**
    * Package name → the subgraph instances registered from it, keyed by
    * subgraph name. Tracks the package association so that removed packages
@@ -1189,7 +1505,25 @@ declare class GraphQLManager {
    */
   readonly reactorDriveClient?: IDriveClient;
   private readonly authorizationService;
-  constructor(path: string, httpServer: http.Server, wsServer: WebSocketServer, reactorClient: IReactorClient, relationalDb: IRelationalDb, analyticsStore: IAnalyticsStore, syncManager: ISyncManager, logger: ILogger, httpAdapter: IHttpAdapter, gatewayAdapter: IGatewayAdapter<Context$1>, authService?: AuthService | undefined, documentPermissionService?: DocumentPermissionService | undefined, featureFlags?: GraphqlManagerFeatureFlags, port?: number, authorizationService?: IAuthorizationService, reactorDriveClient?: IDriveClient, syncServingGate?: SyncScopeGate | undefined, httpRoutes?: HttpRouteService | undefined);
+  private readonly path;
+  private readonly httpServer;
+  private readonly wsServer;
+  private readonly reactorClient;
+  private readonly relationalDb;
+  private readonly analyticsStore;
+  private readonly syncManager;
+  private readonly logger;
+  private readonly httpAdapter;
+  private readonly gatewayAdapter;
+  private readonly authService?;
+  private readonly documentPermissionService?;
+  private readonly featureFlags;
+  private readonly port;
+  private readonly syncServingGate?;
+  private readonly httpRoutes?;
+  private readonly attachments?;
+  private readonly inspection?;
+  constructor(options: GraphQLManagerOptions);
   init(coreSubgraphs: SubgraphClass$1[], authMiddleware?: AuthFetchMiddleware, requireAuthMiddleware?: RequireAuthFetchMiddleware): Promise<void>;
   /**
    * Regenerate document model subgraphs when models are dynamically loaded.
@@ -1255,100 +1589,72 @@ declare class GraphQLManager {
   shutdown(): Promise<void>;
 }
 //#endregion
+//#region src/graphql/inspection/resolvers.d.ts
+/** How the subgraph decides for one request's caller. */
+interface InspectionCallerGate {
+  /** One of the host's listed admins, whatever the policy. */
+  isOperator(ctx: Context): boolean;
+  /** The reactor client, reading as the caller. */
+  readerFor(ctx: Context): InspectorDocumentReader;
+  /** The host's own read check on one document; throws when refused. */
+  assertCanRead(identifier: string, ctx: Context): Promise<string>;
+  /** The host's own read check over a listing. */
+  readableIds(ids: readonly string[], ctx: Context): Promise<Set<string>>;
+  /** The document's id and the scopes the caller is served, or undefined. */
+  servedDocument(identifier: string, branch: string | undefined, ctx: Context): Promise<{
+    id: string;
+    scopes: ReadonlySet<string>;
+  } | undefined>;
+}
+type GqlOf<T, K extends keyof T> = T[K] extends {
+  readonly gql: infer G extends string;
+} ? G : never;
+/** Exactly the GraphQL fields of the read rows of both op tables. */
+type InspectionReadField = GqlOf<typeof INSPECTOR_OPS, InspectorReadOpKey> | GqlOf<typeof SYNC_INSPECTION_OPS, SyncInspectionReadOpKey>;
+/** The read half of the inspection surface; no lever has a field here. */
+export declare function createInspectionResolvers(source: IReactorInspectionSource, sync: {
+  list(): Remote[];
+}, gate: InspectionCallerGate): Record<string, unknown>;
+//#endregion
+//#region src/graphql/inspection/schema.d.ts
+export declare const inspectionTypeDefs: import("graphql").DocumentNode;
+//#endregion
+//#region src/graphql/inspection/subgraph.d.ts
+export declare function isListedAdmin(config: AuthorizationConfig, address: string | undefined): boolean;
+/** The read half of the reactor's inspection surface. */
+export declare class InspectionSubgraph extends BaseSubgraph {
+  name: string;
+  hasSubscriptions: boolean;
+  typeDefs: DocumentNode;
+  resolvers: Record<string, any>;
+  constructor(args: SubgraphArgs);
+  private callerGate;
+  private readerFor;
+  private servedDocument;
+}
+//#endregion
 //#region src/services/package-storage.d.ts
-interface InstalledPackageInfo {
+export interface InstalledPackageInfo {
   name: string;
   version?: string;
   registryUrl: string;
   installedAt: Date;
   documentTypes: string[];
 }
-interface IPackageStorage {
-  get(name: string): Promise<InstalledPackageInfo | undefined>;
-  getAll(): Promise<InstalledPackageInfo[]>;
-  set(name: string, info: InstalledPackageInfo): Promise<void>;
-  delete(name: string): Promise<boolean>;
-  has(name: string): Promise<boolean>;
-}
-declare class InMemoryPackageStorage implements IPackageStorage {
-  private packages;
-  get(name: string): Promise<InstalledPackageInfo | undefined>;
-  getAll(): Promise<InstalledPackageInfo[]>;
-  set(name: string, info: InstalledPackageInfo): Promise<void>;
-  delete(name: string): Promise<boolean>;
-  has(name: string): Promise<boolean>;
-}
-//#endregion
-//#region src/services/canonical-document-id.d.ts
-/**
- * Raised when a caller-supplied identifier cannot be resolved to a canonical
- * document id. Carries no detail on purpose: resolution failures must not act
- * as a document-existence oracle, so consumers map this to their generic
- * fail-closed response.
- */
-declare class CanonicalDocumentIdResolutionError extends Error {
-  constructor();
-}
-type CanonicalDocumentIdResolver = (identifier: string) => Promise<CanonicalDocumentId>;
-/**
- * The sanctioned string-to-CanonicalDocumentId cast: both the GraphQL layer
- * and server routes must resolve caller identifiers through this helper so
- * decision and data layers always agree on the subject document.
- */
-declare function createCanonicalDocumentIdResolver(client: Pick<IReactorClient, "resolveIdOrSlug">): CanonicalDocumentIdResolver;
-//#endregion
-//#region src/services/attachment-access.service.d.ts
-/**
- * Whether the active Reactor composition hosts the attachment-reference
- * projection. Reported by the client initializer: the built-in stack always
- * registers it, while a caller-provided Reactor may lack the live
- * registration capability. Consumers of reference evidence must fail closed
- * when it is unavailable.
- */
-type AttachmentReferenceProjectionCapability = {
-  status: "available";
-} | {
-  status: "unavailable";
-  reason: "live-read-model-registration-unsupported" | "in-process-reactor-module-unavailable" | "initializer-did-not-report";
-};
-/**
- * Outcome of an attachment read authorization. `denied` intentionally covers
- * both an unreadable document and an absent document/ref relationship so the
- * route layer cannot leak which check failed. `projection-unavailable` means
- * the reference index is not being maintained in this composition; it is
- * returned before any document-authorization or reference lookup runs.
- */
-type AttachmentAccessResult = {
-  kind: "allowed";
-  documentId: CanonicalDocumentId;
-  ref: AttachmentRef;
-} | {
-  kind: "denied";
-} | {
-  kind: "projection-unavailable";
-};
-interface AttachmentAccessRequest {
-  documentId: string;
-  attachmentRef: string;
-  userAddress?: string;
-}
-interface IAttachmentAccessService {
-  canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
-}
-/**
- * Composes document authorization with the projected document/ref
- * relationship. Order is fixed: validate ref, resolve the canonical document
- * id, check `canRead`, then check the reference index. A denied document
- * never reaches the reference reader, and the facade never touches
- * attachment metadata, storage backends, or presigners.
- */
-declare class AttachmentAccessService implements IAttachmentAccessService {
-  private readonly resolveCanonicalId;
-  private readonly authorization;
-  private readonly references;
-  private readonly projection;
-  constructor(resolveCanonicalId: CanonicalDocumentIdResolver, authorization: IAuthorizationService, references: IAttachmentReferenceReader, projection: AttachmentReferenceProjectionCapability);
-  canReadAttachment(request: AttachmentAccessRequest): Promise<AttachmentAccessResult>;
+export interface IPackageStorage {
+  get(name: string): Promise<InstalledPackageInfo | undefined>;
+  getAll(): Promise<InstalledPackageInfo[]>;
+  set(name: string, info: InstalledPackageInfo): Promise<void>;
+  delete(name: string): Promise<boolean>;
+  has(name: string): Promise<boolean>;
+}
+export declare class InMemoryPackageStorage implements IPackageStorage {
+  private packages;
+  get(name: string): Promise<InstalledPackageInfo | undefined>;
+  getAll(): Promise<InstalledPackageInfo[]>;
+  set(name: string, info: InstalledPackageInfo): Promise<void>;
+  delete(name: string): Promise<boolean>;
+  has(name: string): Promise<boolean>;
 }
 //#endregion
 //#region src/types.d.ts
@@ -1356,24 +1662,45 @@ declare class AttachmentAccessService implements IAttachmentAccessService {
  * Module hosts pass to processor factories: the reactor-level module plus the
  * attachment client, which shared and reactor cannot name.
  */
-interface IProcessorHostModule extends IReactorProcessorHostModuleBase {
+export interface IProcessorHostModule extends IReactorProcessorHostModuleBase {
   attachments: IAttachmentClient;
 }
 /** @deprecated Use `IProcessorHostModule`. */
-type IReactorProcessorHostModule = IProcessorHostModule;
-type ReadinessGate = {
+export type IReactorProcessorHostModule = IProcessorHostModule;
+export type ReadinessGate = {
   isReady: () => boolean;
   markReady: () => void;
 };
-type API = {
-  httpAdapter: IHttpAdapter; /** Hands each package a namespaced slice of the HTTP surface. */
+export type API = {
+  httpAdapter: IHttpAdapter;
+  /** Hands each package a namespaced slice of the HTTP surface. */
   httpRoutes: HttpRouteService;
   graphqlManager: GraphQLManager$1;
   packages: IPackageManager;
   attachments: AttachmentBuildResult;
-  attachmentReferenceIndex: AttachmentReferenceIndexBuildResult; /** Document-authorized attachment read decisions; see AttachmentAccessService. */
+  attachmentReferenceIndex: AttachmentReferenceIndexBuildResult;
+  /** Document-authorized attachment read decisions; see AttachmentAccessService. */
   attachmentAccess: IAttachmentAccessService;
+  /** Caller-bound attachment clients for subgraphs the host constructs itself. */
+  attachmentClientProvider: IAttachmentClientProvider;
   authService: AuthService | undefined;
+  /**
+   * Whether this deployment refuses anonymous callers
+   * (`REQUIRE_AUTHENTICATED_CALLER`). Carried here because routes mounted
+   * straight on the HTTP adapter never pass the GraphQL fetch chain, so its
+   * require-auth middleware cannot reach them: a host-composed route reads the
+   * resolved value from the API rather than the environment, so one variable
+   * cannot end up half applied.
+   */
+  requireAuthenticatedCaller: boolean;
+  /** The service the subgraphs decide with, for a component the host composes
+   * after boot: it must authorize with this one, not one of its own. */
+  authorizationService: IAuthorizationService;
+  /** The read-model relational store, for the same host-composed component:
+   * its tables belong in this database and nothing else hands one over. */
+  relationalDb: IRelationalDb$1;
+  /** Present when the host serves inspection; `facts` takes late-bound facts. */
+  inspection?: IReactorInspectionSource;
   /**
    * Releases resources owned by the API: shuts down the GraphQL gateway,
    * closes WebSocket and HTTP servers, destroys knex pools, and closes any
@@ -1383,25 +1710,82 @@ type API = {
    */
   dispose: () => Promise<void>;
 };
-type ReactorModule = {
+export type ReactorModule = {
   analyticsStore: IAnalyticsStore;
   relationalDb: IRelationalDb$1;
 };
 /** @deprecated Use `ProcessorFactory`. */
-type ProcessorDriveFactory = ProcessorFactory;
+export type ProcessorDriveFactory = ProcessorFactory;
 /** Builds a per-drive factory from the host module (e.g. vetra `processorFactory`). */
-type ProcessorFactoryBuilder = ProcessorFactoryBuilder$1<IProcessorHostModule>;
+export type ProcessorFactoryBuilder = ProcessorFactoryBuilder$1<IProcessorHostModule>;
 /** Multiple initializers per package name (e.g. Switchboard `processors` option). */
-type Processor = ProcessorFactoryBuilder[];
+export type Processor = ProcessorFactoryBuilder[];
+//#endregion
+//#region src/packages/registry-cache.d.ts
+/** Entry files a registry package's node build is served from, CDN-relative. */
+declare const PACKAGE_ENTRIES: {
+  readonly documentModels: "node/document-models/index.mjs";
+  readonly subgraphs: "node/subgraphs/index.mjs";
+  readonly processors: "node/processors/index.mjs";
+};
+type PackageEntryKind = keyof typeof PACKAGE_ENTRIES;
+type CachedRegistryPackage = {
+  name: string;
+  version: string;
+  dir: string;
+  /** Absolute entry files inside `dir`, for the entries the package serves. */
+  entries: Partial<Record<PackageEntryKind, string>>;
+  source: "cache" | "download";
+  /** External packages the package manifest lists, name -> version. */
+  externalDependencies: Record<string, string>;
+  /** The external packages that resolve from neither the project nor reactor-api. */
+  missingExternalDependencies: string[];
+};
+type RegistryPackageCacheOptions = {
+  registryUrl: string;
+  cacheDir?: string;
+  logger?: ILogger;
+  fetchTimeoutMs?: number;
+};
+declare class RegistryPackageCache {
+  readonly cacheDir: string;
+  private readonly registryUrl;
+  private readonly logger;
+  private readonly fetchTimeoutMs;
+  private readonly inFlight;
+  private readonly verified;
+  constructor(options: RegistryPackageCacheOptions);
+  /** Base URL every file of `name@version` is fetched under. */
+  baseUrl(name: string, version: string): string;
+  entryDir(name: string, version: string): string;
+  /** Complete cached versions of `name`, newest-agnostic. */
+  cachedVersions(name: string): Promise<string[]>;
+  ensurePackage(name: string, version: string): Promise<CachedRegistryPackage>;
+  private resolveEntry;
+  /** The manifest when every listed file is present and hashes to it. */
+  private verify;
+  private discard;
+  private fill;
+  private download;
+  private dependenciesOf;
+  private fetchBounded;
+  private outsideUrl;
+  /** Whether `specifier` resolves from the project or from reactor-api. */
+  resolvesForCachedPackages(specifier: string, pkg: string): boolean;
+  private linkBareImports;
+}
 //#endregion
 //#region src/packages/http-loader.d.ts
-interface HttpPackageLoaderOptions {
+export interface HttpPackageLoaderOptions {
   registryUrl: string;
+  /** Where document-model graphs are cached; `<cwd>/.ph/registry-packages` by default. */
+  cacheDir?: string;
 }
-interface HttpPackageLoaderLogger {
+export interface HttpPackageLoaderLogger {
   info: (msg: string) => void;
   error: (msg: string, err: unknown) => void;
 }
+export declare function piecesBaseUrl(registryUrl: string, packageName: string, version: string): string;
 type SubgraphsExport = Record<string, SubgraphClass$1>;
 /**
  * Extract subgraph classes from the imported subgraphs/index.mjs module shape.
@@ -1409,11 +1793,13 @@ type SubgraphsExport = Record<string, SubgraphClass$1>;
  * The published bundle uses `export * as Foo from "./file"`, which Node turns
  * into `{ Foo: <namespace>, … }`. The inner namespace's keys come from the
  * source file's named exports — typically `Subgraph` / `default` / the class
- * name itself — so the shape varies. Flatten one level and keep callables.
+ * name itself — so the shape varies.
  *
- * Exported for direct unit testing against synthetic module shapes.
+ * Delegates to the unified acceptance rule every package loader shares
+ * (`extractSubgraphs`), kept as an export because it is part of the package's
+ * public API and is unit-tested directly against synthetic module shapes.
  */
-declare function extractSubgraphsFromModule(module: Record<string, SubgraphsExport>): SubgraphClass$1[];
+export declare function extractSubgraphsFromModule(module: Record<string, SubgraphsExport>): SubgraphClass$1[];
 /**
  * Loads document models, subgraphs, and processors from an HTTP registry.
  * Uses Node.js module loader hooks to import directly from HTTP URLs.
@@ -1422,11 +1808,14 @@ declare function extractSubgraphsFromModule(module: Record<string, SubgraphsExpo
  *   import { register } from "node:module";
  *   register("@powerhousedao/reactor-api/https-hooks", import.meta.url);
  */
-declare class HttpPackageLoader implements IPackageLoader {
+export declare class HttpPackageLoader implements IPackageLoader {
   private readonly registryUrl;
   private readonly logger;
   readonly name = "HttpPackageLoader";
   readonly documentModelLoader: HttpDocumentModelLoader;
+  readonly cache: RegistryPackageCache;
+  private readonly versions;
+  private readonly reportedExternal;
   constructor(options: HttpPackageLoaderOptions);
   /**
    * Load document models from a package in the HTTP registry.
@@ -1436,33 +1825,43 @@ declare class HttpPackageLoader implements IPackageLoader {
    * Parse a package specifier like "@scope/pkg@tag" into name and optional tag.
    */
   private parsePackageSpec;
+  resolveVersion(packageSpec: string): Promise<string | undefined>;
+  private lookUpVersion;
+  /** Caches the pinned version of `packageSpec` on disk. */
+  cachePackage(packageSpec: string): Promise<CachedRegistryPackage>;
+  /** One entry module of the package, plus the cached file it came from. */
+  importEntry(packageSpec: string, kind: PackageEntryKind): Promise<{
+    module: Record<string, unknown>;
+    filePath?: string;
+  }>;
+  private assertExternalDependencies;
+  importDocumentModels(packageSpec: string): Promise<{
+    module: Record<string, unknown>;
+    filePath?: string;
+  }>;
   loadDocumentModels(packageSpec: string): Promise<DocumentModelModule[]>;
   loadUpgradeManifests(packageSpec: string): Promise<UpgradeManifest<readonly number[]>[]>;
   loadSubgraphs(packageSpec: string): Promise<SubgraphClass$1[]>;
   loadProcessors(packageSpec: string): Promise<ProcessorFactoryBuilder | null>;
+  loadPieces(packageSpec: string): Promise<PackagePieceEntry[]>;
   /**
    * Load document models from multiple packages.
    * Continues loading even if some packages fail.
    */
   loadPackages(packageNames: string[], logger?: HttpPackageLoaderLogger): Promise<DocumentModelModule[]>;
-  private isValidPackageName;
+  packageVersion(packageSpec: string): Promise<string | undefined>;
 }
-/**
- * Returns live modules (host-only sources): dynamically loaded models are
- * registered on the host registry but never reach executor worker threads.
- * Making them worker-executable means returning an importable source here
- * (the CDN URL as a package specifier, given process-wide https hooks).
- */
-declare class HttpDocumentModelLoader implements IDocumentModelLoader {
+export declare class HttpDocumentModelLoader implements IDocumentModelLoader {
   private readonly loader;
   private readonly logger;
   private readonly documentTypeCache;
   private readonly packageModulesCache;
+  private readonly packageFileCache;
   private onModelLoaded?;
   constructor(loader: HttpPackageLoader);
   setOnModelLoaded(callback: (model: DocumentModelModule) => void): void;
   clearCache(): void;
-  load(documentType: string): Promise<DocumentModelModule>;
+  load(documentType: string): Promise<DocumentModelSource>;
   private findPackageByDocumentType;
   getLoadedPackages(): string[];
   getPackageModules(packageName: string): DocumentModelModule[] | undefined;
@@ -1470,18 +1869,18 @@ declare class HttpDocumentModelLoader implements IDocumentModelLoader {
 }
 //#endregion
 //#region src/services/package-management.service.d.ts
-interface InstallPackageResult {
+export interface InstallPackageResult {
   package: InstalledPackageInfo;
   documentModelsLoaded: number;
 }
-interface PackageManagementServiceOptions {
+export interface PackageManagementServiceOptions {
   storage?: IPackageStorage;
   defaultRegistryUrl?: string;
   httpLoader?: HttpPackageLoader;
   documentModelRegistry?: IDocumentModelRegistry;
   packageManager?: IPackageManager;
 }
-declare class PackageManagementService {
+export declare class PackageManagementService {
   private readonly storage;
   private readonly defaultRegistryUrl?;
   private readonly httpLoader?;
@@ -1504,13 +1903,13 @@ declare class PackageManagementService {
 interface PackagesSubgraphArgs extends SubgraphArgs {
   packageManagementService: PackageManagementService;
 }
-declare class PackagesSubgraph extends BaseSubgraph {
+export declare class PackagesSubgraph extends BaseSubgraph {
   private logger;
   private packageManagementService;
   constructor(args: PackagesSubgraphArgs);
   name: string;
   hasSubscriptions: boolean;
-  typeDefs: graphql.DocumentNode;
+  typeDefs: import("graphql").DocumentNode;
   resolvers: {
     Query: {
       Packages: () => {};
@@ -1566,7 +1965,7 @@ declare class PackagesSubgraph extends BaseSubgraph {
  * `{ document, variables, headers? }` with `variables` and `headers`
  * already JSON-stringified.
  */
-interface ExplorerUrlState {
+export interface ExplorerUrlState {
   /** The GraphQL query to prefill in GraphiQL. */
   query: string;
   /** JSON-stringified variables, as stored in the payload. */
@@ -1578,24 +1977,24 @@ interface ExplorerUrlState {
  * Decodes an `explorerURLState` URL parameter. Returns `null` for anything
  * that is not a valid lz-compressed payload with a non-empty `document`.
  */
-declare function decodeExplorerUrlState(encoded: string): ExplorerUrlState | null;
-declare function renderGraphqlPlayground(url: string, query?: string, headers?: Record<string, string>, variables?: string): string;
+export declare function decodeExplorerUrlState(encoded: string): ExplorerUrlState | null;
+export declare function renderGraphqlPlayground(url: string, query?: string, headers?: Record<string, string>, variables?: string): string;
 //#endregion
 //#region src/graphql/reactor/gen/graphql.d.ts
-type Maybe<T> = T | null | undefined;
-type InputMaybe<T> = T | null | undefined;
-type Exact<T extends {
+export type Maybe<T> = T | null | undefined;
+export type InputMaybe<T> = T | null | undefined;
+export type Exact<T extends {
   [key: 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 {
+}> = { [K in keyof T]: T[K]; };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]>; };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]>; };
+export type MakeEmpty<T extends {
   [key: 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 RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
+}, K extends keyof T> = { [_ in K]?: never; };
+export type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never; };
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]>; };
 /** All built-in and custom scalars, mapped to their actual values */
-type Scalars = {
+export type Scalars = {
   ID: {
     input: string;
     output: string;
@@ -1625,7 +2024,7 @@ type Scalars = {
     output: NonNullable<unknown>;
   };
 };
-type Action = {
+export type Action = {
   readonly context?: Maybe<ActionContext>;
   readonly id: Scalars["String"]["output"];
   readonly input: Scalars["JSONObject"]["output"];
@@ -1640,12 +2039,12 @@ type Action = {
  * filled-in form carries that form's input. Omitting it predicts the verdict an
  * empty input earns, not the verdict the filled-in form will get.
  */
-type ActionCandidateInput = {
+export type ActionCandidateInput = {
   readonly input?: InputMaybe<Scalars["JSONObject"]["input"]>;
   readonly scope: Scalars["String"]["input"];
   readonly type: Scalars["String"]["input"];
 };
-type ActionContext = {
+export type ActionContext = {
   readonly signer?: Maybe<ReactorSigner>;
 };
 /**
@@ -1660,9 +2059,12 @@ type ActionContext = {
  * against. They are recorded rather than enforced; a signature is verified from
  * the params carried in its own tuple, which do not include them.
  */
-type ActionContextInput = {
-  /** Covers replay of an operation that would otherwise be a no-op. */readonly nonce?: InputMaybe<Scalars["String"]["input"]>; /** The hash of the state the action applies to. */
-  readonly prevOpHash?: InputMaybe<Scalars["String"]["input"]>; /** The index of the last operation in the scope the action applies to. */
+export type ActionContextInput = {
+  /** Covers replay of an operation that would otherwise be a no-op. */
+  readonly nonce?: InputMaybe<Scalars["String"]["input"]>;
+  /** The hash of the state the action applies to. */
+  readonly prevOpHash?: InputMaybe<Scalars["String"]["input"]>;
+  /** The index of the last operation in the scope the action applies to. */
   readonly prevOpIndex?: InputMaybe<Scalars["Int"]["input"]>;
   readonly signer?: InputMaybe<ReactorSignerInput>;
 };
@@ -1670,7 +2072,7 @@ type ActionContextInput = {
  * One candidate's predicted verdict. `reason` carries the refusal a DENY is
  * recorded with, and is null on an ALLOW.
  */
-type ActionEvaluation = {
+export type ActionEvaluation = {
   readonly decision: AuthDecision;
   readonly reason?: Maybe<Scalars["String"]["output"]>;
 };
@@ -1683,14 +2085,14 @@ type ActionEvaluation = {
  * another. Over no candidates every aggregate is false: nothing is allowed and
  * nothing is denied.
  */
-type ActionEvaluations = {
+export type ActionEvaluations = {
   readonly allAllowed: Scalars["Boolean"]["output"];
   readonly allDenied: Scalars["Boolean"]["output"];
   readonly anyAllowed: Scalars["Boolean"]["output"];
   readonly anyDenied: Scalars["Boolean"]["output"];
   readonly evaluations: ReadonlyArray<ActionEvaluation>;
 };
-type ActionInput = {
+export type ActionInput = {
   readonly context?: InputMaybe<ActionContextInput>;
   readonly id: Scalars["String"]["input"];
   readonly input: Scalars["JSONObject"]["input"];
@@ -1698,17 +2100,56 @@ type ActionInput = {
   readonly timestampUtcMs: Scalars["String"]["input"];
   readonly type: Scalars["String"]["input"];
 };
-declare enum AuthDecision {
+export declare enum AuthDecision {
   Allow = "ALLOW",
   Deny = "DENY"
 }
-type ChannelMeta = {
+/**
+ * The outcome of a batch mutation, one entry per job the request named. The wire
+ * shape of `BatchExecutionResult` (`{ jobs }`), keyed on each entry by the plan
+ * key rather than by position so the client can rebuild the record. The batch is
+ * not atomic: each job commits on its own and a failed job releases its
+ * dependents, so each entry's status says what happened to that job, and
+ * re-submitting re-applies the jobs that succeeded.
+ */
+export type BatchExecutionResult = {
+  readonly jobs: ReadonlyArray<BatchJobResult>;
+};
+/**
+ * One job's outcome within a batch, pairing the plan key the caller gave with the
+ * job that applied it. Mirrors one entry of the `Record<string, JobInfo>` that
+ * `IReactor.executeBatch` returns (packages/reactor/src/core/types.ts).
+ */
+export type BatchJobResult = {
+  readonly job: JobInfo;
+  readonly key: Scalars["String"]["output"];
+};
+export type ChannelMeta = {
   readonly id: Scalars["String"]["output"];
 };
-type ChannelMetaInput = {
+export type ChannelMetaInput = {
   readonly id: Scalars["String"]["input"];
 };
-type DeadLetterInfo = {
+export type ConsistencyCoordinate = {
+  readonly branch: Scalars["String"]["output"];
+  readonly documentId: Scalars["String"]["output"];
+  readonly operationIndex: Scalars["Int"]["output"];
+  readonly scope: Scalars["String"]["output"];
+};
+/**
+ * The write positions a job reached, for read-after-write. Only meaningful once
+ * the job has completed.
+ */
+export type ConsistencyToken = {
+  readonly coordinates: ReadonlyArray<ConsistencyCoordinate>;
+  readonly createdAtUtcIso: Scalars["String"]["output"];
+  readonly version: Scalars["Int"]["output"];
+};
+export type CreateDefaults = {
+  readonly protocolVersions: Scalars["JSONObject"]["output"];
+  readonly signaturePolicy: Scalars["String"]["output"];
+};
+export type DeadLetterInfo = {
   readonly branch: Scalars["String"]["output"];
   readonly documentId: Scalars["String"]["output"];
   readonly error: Scalars["String"]["output"];
@@ -1722,16 +2163,16 @@ type DeadLetterInfo = {
   readonly operationCount: Scalars["Int"]["output"];
   readonly scopes: ReadonlyArray<Scalars["String"]["output"]>;
 };
-type DocumentChangeContext = {
+export type DocumentChangeContext = {
   readonly childId?: Maybe<Scalars["String"]["output"]>;
   readonly parentId?: Maybe<Scalars["String"]["output"]>;
 };
-type DocumentChangeEvent = {
+export type DocumentChangeEvent = {
   readonly context?: Maybe<DocumentChangeContext>;
   readonly documents: ReadonlyArray<PhDocument>;
   readonly type: DocumentChangeType;
 };
-declare enum DocumentChangeType {
+export declare enum DocumentChangeType {
   ChildAdded = "CHILD_ADDED",
   ChildRemoved = "CHILD_REMOVED",
   Created = "CREATED",
@@ -1740,21 +2181,20 @@ declare enum DocumentChangeType {
   ParentRemoved = "PARENT_REMOVED",
   Updated = "UPDATED"
 }
-type DocumentModelGlobalState = {
+export type DocumentModelGlobalState = {
   readonly id: Scalars["String"]["output"];
   readonly name: Scalars["String"]["output"];
   readonly namespace?: Maybe<Scalars["String"]["output"]>;
   readonly specification: Scalars["JSONObject"]["output"];
   readonly version?: Maybe<Scalars["String"]["output"]>;
 };
-type DocumentModelResultPage = {
+export type DocumentModelResultPage = {
   readonly cursor?: Maybe<Scalars["String"]["output"]>;
   readonly hasNextPage: Scalars["Boolean"]["output"];
   readonly hasPreviousPage: Scalars["Boolean"]["output"];
   readonly items: ReadonlyArray<DocumentModelGlobalState>;
-  readonly totalCount: Scalars["Int"]["output"];
 };
-type DocumentOperationsFilterInput = {
+export type DocumentOperationsFilterInput = {
   readonly actionTypes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   readonly branch?: InputMaybe<Scalars["String"]["input"]>;
   readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
@@ -1762,21 +2202,75 @@ type DocumentOperationsFilterInput = {
   readonly timestampFrom?: InputMaybe<Scalars["String"]["input"]>;
   readonly timestampTo?: InputMaybe<Scalars["String"]["input"]>;
 };
-type DocumentWithChildren = {
+export type DocumentRelationship = {
+  readonly createdAt: Scalars["DateTime"]["output"];
+  readonly metadata?: Maybe<Scalars["JSONObject"]["output"]>;
+  readonly relationshipType: Scalars["String"]["output"];
+  readonly sourceId: Scalars["String"]["output"];
+  readonly targetId: Scalars["String"]["output"];
+  readonly updatedAt: Scalars["DateTime"]["output"];
+};
+export type DocumentRelationshipResultPage = {
+  readonly cursor?: Maybe<Scalars["String"]["output"]>;
+  readonly hasNextPage: Scalars["Boolean"]["output"];
+  readonly hasPreviousPage: Scalars["Boolean"]["output"];
+  readonly items: ReadonlyArray<DocumentRelationship>;
+};
+export type DocumentWithChildren = {
   readonly childIds: ReadonlyArray<Scalars["String"]["output"]>;
   readonly document: PhDocument;
 };
-type JobChangeEvent = {
+/**
+ * One mutation job of a batch, mirroring the reactor's `ExecutionJobPlan`
+ * (packages/reactor/src/core/types.ts). The batch runs its jobs in dependency
+ * order only, not atomically: each job commits on its own with no batch rollback,
+ * and a failed job still releases its dependents.
+ *
+ * `documentIdOrSlug` is the document the job's actions apply to -- an id that does
+ * not yet exist when the job's actions create it. `actions` are coerced against
+ * `ActionInput` and passed through exactly as `execute` does, so a client-signed
+ * action keeps its signature. `scope` is the single scope every action in the job
+ * shares, and `dependsOn` names the plan keys this job is ordered after. `branch`
+ * defaults to `main`.
+ */
+export type ExecutionJobInput = {
+  readonly actions: ReadonlyArray<ActionInput>;
+  readonly branch?: InputMaybe<Scalars["String"]["input"]>;
+  readonly dependsOn: ReadonlyArray<Scalars["String"]["input"]>;
+  readonly documentIdOrSlug: Scalars["String"]["input"];
+  readonly key: Scalars["String"]["input"];
+  readonly scope: Scalars["String"]["input"];
+};
+/** The batch a job was submitted in. */
+export type JobBatchMeta = {
+  readonly batchId: Scalars["String"]["output"];
+  readonly batchJobIds: ReadonlyArray<Scalars["String"]["output"]>;
+};
+export type JobChangeEvent = {
   readonly error?: Maybe<Scalars["String"]["output"]>;
   readonly jobId: Scalars["String"]["output"];
-  readonly result: Scalars["JSONObject"]["output"];
+  /**
+   * What the job produced, once it has produced anything. Nullable for the same
+   * reason as `JobInfo.result`: a job that has not written yet has produced
+   * nothing, and an empty object would claim otherwise.
+   */
+  readonly result?: Maybe<Scalars["JSONObject"]["output"]>;
   readonly status: Scalars["String"]["output"];
 };
-type JobInfo = {
+export type JobInfo = {
   readonly completedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  readonly consistencyToken: ConsistencyToken;
   readonly createdAt: Scalars["DateTime"]["output"];
+  /**
+   * The document the job operates on. Empty for a job this server does not know,
+   * which then comes back FAILED with "Job not found".
+   */
+  readonly documentId: Scalars["String"]["output"];
   readonly error?: Maybe<Scalars["String"]["output"]>;
+  /** The error's class name, such as `DocumentAlreadyExistsError`, when it failed. */
+  readonly errorName?: Maybe<Scalars["String"]["output"]>;
   readonly id: Scalars["String"]["output"];
+  readonly meta: JobBatchMeta;
   /**
    * What the job produced, once it has produced anything. Null until then, which
    * is the state every job is in when it is handed back from a submission.
@@ -1784,11 +2278,11 @@ type JobInfo = {
   readonly result?: Maybe<Scalars["JSONObject"]["output"]>;
   readonly status: Scalars["String"]["output"];
 };
-type MoveRelationshipResult = {
+export type MoveRelationshipResult = {
   readonly source: PhDocument;
   readonly target: PhDocument;
 };
-type Mutation = {
+export type Mutation = {
   readonly addRelationship: PhDocument;
   readonly createDocument: PhDocument;
   readonly createEmptyDocument: PhDocument;
@@ -1816,101 +2310,154 @@ type Mutation = {
    * ask for; `result` is null until the job produces one.
    */
   readonly executeAsync: JobInfo;
-  readonly moveRelationship: MoveRelationshipResult; /** @deprecated Use execute. Actions here are untyped, so a malformed one is refused by a hand-written check rather than by the schema, and `view.scopes` is accepted but ignored. */
-  readonly mutateDocument: PhDocument; /** @deprecated Use executeAsync, which is typed and returns the job rather than only its id. */
+  /**
+   * Applies multiple mutation jobs in dependency order and waits for all of them,
+   * the wire form of `IReactorClient.executeBatch`. Each job's actions are coerced
+   * against `ActionInput` exactly as `execute` is, so client-signed actions pass
+   * through unchanged, and `dependsOn` orders the jobs. It is synchronous: the jobs
+   * are applied and awaited before the result returns, so every returned `JobInfo`
+   * is a completed one rather than the pending receipt the in-process reactor hands
+   * back. A batch is ordering, not a transaction: each job commits on its own, and
+   * a failed job still releases the jobs that depend on it, so any job, before or
+   * after a failure, may have committed. A failed job is therefore returned as a
+   * FAILED entry with its `error` and `errorName`, beside the final state of every
+   * other job, rather than failing the mutation. The mutation itself fails only
+   * when no job state can be reported.
+   *
+   * A job carrying `CREATE_DOCUMENT` must be the batch's only job, with the create
+   * as its first action naming the job's document. Its other actions may only be
+   * an `UPGRADE_DOCUMENT` of the new document and `ADD_RELATIONSHIP`s targeting
+   * it. It is authorized like `createDocument`: write on every source of those
+   * relationships, or the right to create when there is none.
+   */
+  readonly executeBatch: BatchExecutionResult;
+  readonly moveRelationship: MoveRelationshipResult;
+  /** @deprecated Use execute. Actions here are untyped, so a malformed one is refused by a hand-written check rather than by the schema, and `view.scopes` is accepted but ignored. */
+  readonly mutateDocument: PhDocument;
+  /** @deprecated Use executeAsync, which is typed and returns the job rather than only its id. */
   readonly mutateDocumentAsync: Scalars["String"]["output"];
   readonly pushSyncEnvelopes: Scalars["Boolean"]["output"];
   readonly removeRelationship: PhDocument;
   readonly renameDocument: PhDocument;
   readonly setPreferredEditor: PhDocument;
   readonly touchChannel: TouchChannelResult;
+  readonly updateRelationship: PhDocument;
 };
-type MutationAddRelationshipArgs = {
+export type MutationAddRelationshipArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
+  metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
   relationshipType: Scalars["String"]["input"];
-  sourceIdentifier: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
-type MutationCreateDocumentArgs = {
+export type MutationCreateDocumentArgs = {
   document: Scalars["JSONObject"]["input"];
+  parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
   parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
-type MutationCreateEmptyDocumentArgs = {
+export type MutationCreateEmptyDocumentArgs = {
   documentType: Scalars["String"]["input"];
+  parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
   parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
-type MutationDeleteDocumentArgs = {
-  identifier: Scalars["String"]["input"];
+export type MutationDeleteDocumentArgs = {
+  idOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  identifier?: InputMaybe<Scalars["String"]["input"]>;
   propagate?: InputMaybe<PropagationMode>;
 };
-type MutationDeleteDocumentsArgs = {
-  identifiers: ReadonlyArray<Scalars["String"]["input"]>;
+export type MutationDeleteDocumentsArgs = {
+  identifiers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
+  idsOrSlugs?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   propagate?: InputMaybe<PropagationMode>;
 };
-type MutationExecuteArgs = {
+export type MutationExecuteArgs = {
   actions: ReadonlyArray<ActionInput>;
   branch?: InputMaybe<Scalars["String"]["input"]>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
-type MutationExecuteAsyncArgs = {
+export type MutationExecuteAsyncArgs = {
   actions: ReadonlyArray<ActionInput>;
   branch?: InputMaybe<Scalars["String"]["input"]>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type MutationExecuteBatchArgs = {
+  jobs: ReadonlyArray<ExecutionJobInput>;
 };
-type MutationMoveRelationshipArgs = {
+export type MutationMoveRelationshipArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
   relationshipType: Scalars["String"]["input"];
-  sourceParentIdentifier: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
-  targetParentIdentifier: Scalars["String"]["input"];
-};
-type MutationMutateDocumentArgs = {
+  sourceParentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceParentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetParentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetParentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type MutationMutateDocumentArgs = {
   actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
   documentIdentifier: Scalars["String"]["input"];
   view?: InputMaybe<ViewFilterInput>;
 };
-type MutationMutateDocumentAsyncArgs = {
+export type MutationMutateDocumentAsyncArgs = {
   actions: ReadonlyArray<Scalars["JSONObject"]["input"]>;
   documentIdentifier: Scalars["String"]["input"];
   view?: InputMaybe<ViewFilterInput>;
 };
-type MutationPushSyncEnvelopesArgs = {
+export type MutationPushSyncEnvelopesArgs = {
   envelopes: ReadonlyArray<SyncEnvelopeInput>;
+  peerManifestRevision?: InputMaybe<Scalars["String"]["input"]>;
 };
-type MutationRemoveRelationshipArgs = {
+export type MutationRemoveRelationshipArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
   relationshipType: Scalars["String"]["input"];
-  sourceIdentifier: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
-type MutationRenameDocumentArgs = {
+export type MutationRenameDocumentArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   name: Scalars["String"]["input"];
 };
-type MutationSetPreferredEditorArgs = {
+export type MutationSetPreferredEditorArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   preferredEditor?: InputMaybe<Scalars["String"]["input"]>;
 };
-type MutationTouchChannelArgs = {
+export type MutationTouchChannelArgs = {
   input: TouchChannelInput;
 };
-type OperationContext = {
+export type MutationUpdateRelationshipArgs = {
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+  metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
+  relationshipType: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type OperationContext = {
   readonly branch: Scalars["String"]["output"];
   readonly documentId: Scalars["String"]["output"];
   readonly documentType: Scalars["String"]["output"];
   readonly ordinal: Scalars["Int"]["output"];
   readonly scope: Scalars["String"]["output"];
 };
-type OperationContextInput = {
+export type OperationContextInput = {
   readonly branch: Scalars["String"]["input"];
   readonly documentId: Scalars["String"]["input"];
   readonly documentType: Scalars["String"]["input"];
   readonly ordinal: Scalars["Int"]["input"];
   readonly scope: Scalars["String"]["input"];
 };
-type OperationInput = {
+export type OperationInput = {
   readonly action: ActionInput;
   readonly deniedReason?: InputMaybe<Scalars["String"]["input"]>;
   readonly error?: InputMaybe<Scalars["String"]["input"]>;
@@ -1920,67 +2467,92 @@ type OperationInput = {
   readonly skip: Scalars["Int"]["input"];
   readonly timestampUtcMs: Scalars["String"]["input"];
 };
-type OperationWithContext = {
+export type OperationWithContext = {
   readonly context: OperationContext;
   readonly operation: ReactorOperation;
 };
-type OperationWithContextInput = {
+export type OperationWithContextInput = {
   readonly context: OperationContextInput;
   readonly operation: OperationInput;
 };
-type OperationsFilterInput = {
+export type OperationsFilterInput = {
   readonly actionTypes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   readonly branch?: InputMaybe<Scalars["String"]["input"]>;
-  readonly documentId: Scalars["String"]["input"];
+  /** @deprecated Use documentIdOrSlug. */
+  readonly documentId?: InputMaybe<Scalars["String"]["input"]>;
+  readonly documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
   readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   readonly sinceRevision?: InputMaybe<Scalars["Int"]["input"]>;
   readonly timestampFrom?: InputMaybe<Scalars["String"]["input"]>;
   readonly timestampTo?: InputMaybe<Scalars["String"]["input"]>;
 };
-type PhDocument = {
+export type PhDocument = {
   readonly createdAtUtcIso: Scalars["DateTime"]["output"];
   readonly documentType: Scalars["String"]["output"];
   readonly id: Scalars["String"]["output"];
   readonly lastModifiedAtUtcIso: Scalars["DateTime"]["output"];
+  readonly meta?: Maybe<Scalars["JSONObject"]["output"]>;
   readonly name: Scalars["String"]["output"];
   readonly operations?: Maybe<ReactorOperationResultPage>;
   readonly preferredEditor?: Maybe<Scalars["String"]["output"]>;
+  readonly protocolVersions?: Maybe<Scalars["JSONObject"]["output"]>;
   readonly revisionsList: ReadonlyArray<Revision>;
   readonly slug?: Maybe<Scalars["String"]["output"]>;
   readonly state: Scalars["JSONObject"]["output"];
 };
-type PhDocumentOperationsArgs = {
+export type PhDocumentOperationsArgs = {
   filter?: InputMaybe<DocumentOperationsFilterInput>;
   paging?: InputMaybe<PagingInput>;
 };
-type PhDocumentResultPage = {
+export type PhDocumentResultPage = {
   readonly cursor?: Maybe<Scalars["String"]["output"]>;
   readonly hasNextPage: Scalars["Boolean"]["output"];
   readonly hasPreviousPage: Scalars["Boolean"]["output"];
   readonly items: ReadonlyArray<PhDocument>;
-  readonly totalCount: Scalars["Int"]["output"];
 };
-type PagingInput = {
+export type PagingInput = {
   readonly cursor?: InputMaybe<Scalars["String"]["input"]>;
   readonly limit?: InputMaybe<Scalars["Int"]["input"]>;
   readonly offset?: InputMaybe<Scalars["Int"]["input"]>;
 };
-type PollSyncEnvelopesResult = {
+export type PeerAgreement = {
+  readonly collectionId: Scalars["String"]["output"];
+  readonly limitedBy: ReadonlyArray<PeerAgreementLimit>;
+  readonly local: Scalars["JSONObject"]["output"];
+  readonly members: ReadonlyArray<PeerAgreementMember>;
+};
+export type PeerAgreementLimit = {
+  readonly protocol: Scalars["String"]["output"];
+  readonly remoteNames: ReadonlyArray<Scalars["String"]["output"]>;
+};
+export type PeerAgreementMember = {
+  readonly announced: Scalars["Boolean"]["output"];
+  readonly features: Scalars["JSONObject"]["output"];
+  readonly protocols: Scalars["JSONObject"]["output"];
+  readonly remoteName: Scalars["String"]["output"];
+};
+export type PollSyncEnvelopesResult = {
   readonly ackOrdinal: Scalars["Int"]["output"];
   readonly deadLetters: ReadonlyArray<DeadLetterInfo>;
   readonly envelopes: ReadonlyArray<SyncEnvelope>;
   readonly hasMore: Scalars["Boolean"]["output"];
+  readonly manifestRevision?: Maybe<Scalars["String"]["output"]>;
+  readonly peerManifestRevision?: Maybe<Scalars["String"]["output"]>;
 };
-declare enum PropagationMode {
+export declare enum PropagationMode {
   Cascade = "CASCADE",
   Orphan = "ORPHAN"
 }
-type Query = {
+export type Query = {
+  readonly createDefaults: CreateDefaults;
   readonly document?: Maybe<DocumentWithChildren>;
+  readonly documentIncomingRelationshipEdges: DocumentRelationshipResultPage;
   readonly documentIncomingRelationships: PhDocumentResultPage;
   readonly documentModels: DocumentModelResultPage;
   readonly documentOperations: ReactorOperationResultPage;
+  readonly documentOutgoingRelationshipEdges: DocumentRelationshipResultPage;
   readonly documentOutgoingRelationships: PhDocumentResultPage;
+  readonly documentServed: Scalars["Boolean"]["output"];
   /**
    * Predicts whether the calling subject would be admitted to execute each of a
    * set of candidate operations, without submitting any of them. A UI asks this to
@@ -2011,6 +2583,7 @@ type Query = {
   readonly evaluateActions: ActionEvaluations;
   readonly findDocuments: PhDocumentResultPage;
   readonly jobStatus?: Maybe<JobInfo>;
+  readonly peerAgreement: PeerAgreement;
   /**
    * Polls for sync envelopes from a channel.
    *
@@ -2023,50 +2596,85 @@ type Query = {
    * would stop receiving those too.
    */
   readonly pollSyncEnvelopes: PollSyncEnvelopesResult;
+  readonly syncHolds: ReadonlyArray<SyncHold>;
 };
-type QueryDocumentArgs = {
-  identifier: Scalars["String"]["input"];
+export type QueryCreateDefaultsArgs = {
+  parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type QueryDocumentArgs = {
+  idOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  identifier?: InputMaybe<Scalars["String"]["input"]>;
   view?: InputMaybe<ViewFilterInput>;
 };
-type QueryDocumentIncomingRelationshipsArgs = {
+export type QueryDocumentIncomingRelationshipEdgesArgs = {
+  paging?: InputMaybe<PagingInput>;
+  relationshipType?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  view?: InputMaybe<ViewFilterInput>;
+};
+export type QueryDocumentIncomingRelationshipsArgs = {
   paging?: InputMaybe<PagingInput>;
   relationshipType: Scalars["String"]["input"];
-  targetIdentifier: Scalars["String"]["input"];
+  targetIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  targetIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   view?: InputMaybe<ViewFilterInput>;
 };
-type QueryDocumentModelsArgs = {
+export type QueryDocumentModelsArgs = {
   namespace?: InputMaybe<Scalars["String"]["input"]>;
   paging?: InputMaybe<PagingInput>;
 };
-type QueryDocumentOperationsArgs = {
+export type QueryDocumentOperationsArgs = {
   filter: OperationsFilterInput;
   paging?: InputMaybe<PagingInput>;
 };
-type QueryDocumentOutgoingRelationshipsArgs = {
+export type QueryDocumentOutgoingRelationshipEdgesArgs = {
+  paging?: InputMaybe<PagingInput>;
+  relationshipType?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
+  view?: InputMaybe<ViewFilterInput>;
+};
+export type QueryDocumentOutgoingRelationshipsArgs = {
   paging?: InputMaybe<PagingInput>;
   relationshipType: Scalars["String"]["input"];
-  sourceIdentifier: Scalars["String"]["input"];
+  sourceIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  sourceIdentifier?: InputMaybe<Scalars["String"]["input"]>;
   view?: InputMaybe<ViewFilterInput>;
 };
-type QueryEvaluateActionsArgs = {
+export type QueryDocumentServedArgs = {
+  idOrSlug: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+};
+export type QueryEvaluateActionsArgs = {
   branch?: InputMaybe<Scalars["String"]["input"]>;
   candidates: ReadonlyArray<ActionCandidateInput>;
-  documentIdentifier: Scalars["String"]["input"];
+  documentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  documentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 };
-type QueryFindDocumentsArgs = {
+export type QueryFindDocumentsArgs = {
   paging?: InputMaybe<PagingInput>;
   search?: InputMaybe<SearchFilterInput>;
   view?: InputMaybe<ViewFilterInput>;
 };
-type QueryJobStatusArgs = {
+export type QueryJobStatusArgs = {
   jobId: Scalars["String"]["input"];
 };
-type QueryPollSyncEnvelopesArgs = {
+export type QueryPeerAgreementArgs = {
+  collectionId: Scalars["String"]["input"];
+};
+export type QueryPollSyncEnvelopesArgs = {
   channelId: Scalars["String"]["input"];
+  manifestRevision?: InputMaybe<Scalars["String"]["input"]>;
   outboxAck: Scalars["Int"]["input"];
   outboxLatest: Scalars["Int"]["input"];
+  refusals?: InputMaybe<ReadonlyArray<SyncRefusalInput>>;
 };
-type ReactorOperation = {
+export type QuerySyncHoldsArgs = {
+  documentId?: InputMaybe<Scalars["String"]["input"]>;
+  remoteName?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type ReactorOperation = {
   readonly action: Action;
   readonly deniedReason?: Maybe<Scalars["String"]["output"]>;
   readonly error?: Maybe<Scalars["String"]["output"]>;
@@ -2076,77 +2684,77 @@ type ReactorOperation = {
   readonly skip: Scalars["Int"]["output"];
   readonly timestampUtcMs: Scalars["String"]["output"];
 };
-type ReactorOperationResultPage = {
+export type ReactorOperationResultPage = {
   readonly cursor?: Maybe<Scalars["String"]["output"]>;
   readonly hasNextPage: Scalars["Boolean"]["output"];
   readonly hasPreviousPage: Scalars["Boolean"]["output"];
   readonly items: ReadonlyArray<ReactorOperation>;
-  readonly totalCount: Scalars["Int"]["output"];
 };
-type ReactorSigner = {
+export type ReactorSigner = {
   readonly app?: Maybe<ReactorSignerApp>;
   readonly signatures: ReadonlyArray<Scalars["String"]["output"]>;
   readonly user?: Maybe<ReactorSignerUser>;
 };
-type ReactorSignerApp = {
+export type ReactorSignerApp = {
   readonly key: Scalars["String"]["output"];
   readonly name: Scalars["String"]["output"];
 };
-type ReactorSignerAppInput = {
+export type ReactorSignerAppInput = {
   readonly key: Scalars["String"]["input"];
   readonly name: Scalars["String"]["input"];
 };
-type ReactorSignerInput = {
+export type ReactorSignerInput = {
   readonly app?: InputMaybe<ReactorSignerAppInput>;
   readonly signatures: ReadonlyArray<Scalars["String"]["input"]>;
   readonly user?: InputMaybe<ReactorSignerUserInput>;
 };
-type ReactorSignerUser = {
+export type ReactorSignerUser = {
   readonly address: Scalars["String"]["output"];
   readonly chainId: Scalars["Int"]["output"];
   readonly networkId: Scalars["String"]["output"];
 };
-type ReactorSignerUserInput = {
+export type ReactorSignerUserInput = {
   readonly address: Scalars["String"]["input"];
   readonly chainId: Scalars["Int"]["input"];
   readonly networkId: Scalars["String"]["input"];
 };
-type RemoteCursor = {
+export type RemoteCursor = {
   readonly cursorOrdinal: Scalars["Int"]["output"];
   readonly lastSyncedAtUtcMs?: Maybe<Scalars["String"]["output"]>;
   readonly remoteName: Scalars["String"]["output"];
 };
-type RemoteCursorInput = {
+export type RemoteCursorInput = {
   readonly cursorOrdinal: Scalars["Int"]["input"];
   readonly lastSyncedAtUtcMs?: InputMaybe<Scalars["String"]["input"]>;
   readonly remoteName: Scalars["String"]["input"];
 };
-type RemoteFilterInput = {
+export type RemoteFilterInput = {
   readonly branch: Scalars["String"]["input"];
   readonly documentId: ReadonlyArray<Scalars["String"]["input"]>;
   readonly scope: ReadonlyArray<Scalars["String"]["input"]>;
 };
-type Revision = {
+export type Revision = {
   readonly revision: Scalars["Int"]["output"];
   readonly scope: Scalars["String"]["output"];
 };
-type SearchFilterInput = {
+export type SearchFilterInput = {
+  /** @deprecated Ignored. Filter by type or parentId. */
   readonly identifiers?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
   readonly parentId?: InputMaybe<Scalars["String"]["input"]>;
   readonly type?: InputMaybe<Scalars["String"]["input"]>;
 };
-type Subscription = {
+export type Subscription = {
   readonly documentChanges: DocumentChangeEvent;
   readonly jobChanges: JobChangeEvent;
 };
-type SubscriptionDocumentChangesArgs = {
+export type SubscriptionDocumentChangesArgs = {
   search?: InputMaybe<SearchFilterInput>;
   view?: InputMaybe<ViewFilterInput>;
 };
-type SubscriptionJobChangesArgs = {
+export type SubscriptionJobChangesArgs = {
   jobId: Scalars["String"]["input"];
 };
-type SyncEnvelope = {
+export type SyncEnvelope = {
   readonly channelMeta: ChannelMeta;
   readonly cursor?: Maybe<RemoteCursor>;
   readonly dependsOn?: Maybe<ReadonlyArray<Scalars["String"]["output"]>>;
@@ -2154,7 +2762,7 @@ type SyncEnvelope = {
   readonly operations?: Maybe<ReadonlyArray<OperationWithContext>>;
   readonly type: SyncEnvelopeType;
 };
-type SyncEnvelopeInput = {
+export type SyncEnvelopeInput = {
   readonly channelMeta: ChannelMetaInput;
   readonly cursor?: InputMaybe<RemoteCursorInput>;
   readonly dependsOn?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
@@ -2162,30 +2770,51 @@ type SyncEnvelopeInput = {
   readonly operations?: InputMaybe<ReadonlyArray<OperationWithContextInput>>;
   readonly type: SyncEnvelopeType;
 };
-declare enum SyncEnvelopeType {
+export declare enum SyncEnvelopeType {
   Ack = "ACK",
   Operations = "OPERATIONS"
 }
-type TouchChannelInput = {
+export type SyncHold = {
+  readonly branch: Scalars["String"]["output"];
+  readonly documentId: Scalars["String"]["output"];
+  readonly heldAtUtcMs: Scalars["String"]["output"];
+  readonly reason: SyncHoldReason;
+  readonly remoteName: Scalars["String"]["output"];
+};
+export type SyncHoldReason = {
+  readonly peerSupports: ReadonlyArray<Scalars["Int"]["output"]>;
+  readonly protocol: Scalars["String"]["output"];
+  readonly version: Scalars["Int"]["output"];
+};
+export type SyncRefusalInput = {
+  readonly branch: Scalars["String"]["input"];
+  readonly documentId: Scalars["String"]["input"];
+  readonly kind?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type TouchChannelInput = {
   readonly collectionId: Scalars["String"]["input"];
   readonly filter: RemoteFilterInput;
   readonly id: Scalars["String"]["input"];
+  readonly manifest?: InputMaybe<Scalars["JSONObject"]["input"]>;
   readonly name: Scalars["String"]["input"];
   readonly sinceTimestampUtcMs: Scalars["String"]["input"];
 };
-type TouchChannelResult = {
+export type TouchChannelResult = {
   readonly ackOrdinal: Scalars["Int"]["output"];
+  readonly manifest?: Maybe<Scalars["JSONObject"]["output"]>;
   readonly success: Scalars["Boolean"]["output"];
 };
-type ViewFilterInput = {
+export type ViewFilterInput = {
   readonly branch?: InputMaybe<Scalars["String"]["input"]>;
   readonly scopes?: InputMaybe<ReadonlyArray<Scalars["String"]["input"]>>;
 };
-type PhDocumentFieldsFragment = {
+export type PhDocumentFieldsFragment = {
   readonly id: string;
   readonly slug?: string | null | undefined;
   readonly name: string;
   readonly documentType: string;
+  readonly meta?: NonNullable<unknown> | null | undefined;
+  readonly protocolVersions?: NonNullable<unknown> | null | undefined;
   readonly state: NonNullable<unknown>;
   readonly createdAtUtcIso: string | Date;
   readonly lastModifiedAtUtcIso: string | Date;
@@ -2194,13 +2823,20 @@ type PhDocumentFieldsFragment = {
     readonly revision: number;
   }>;
 };
-type GetDocumentModelsQueryVariables = Exact<{
+export type DocumentRelationshipFieldsFragment = {
+  readonly sourceId: string;
+  readonly targetId: string;
+  readonly relationshipType: string;
+  readonly metadata?: NonNullable<unknown> | null | undefined;
+  readonly createdAt: string | Date;
+  readonly updatedAt: string | Date;
+};
+export type GetDocumentModelsQueryVariables = Exact<{
   namespace?: InputMaybe<Scalars["String"]["input"]>;
   paging?: InputMaybe<PagingInput>;
 }>;
-type GetDocumentModelsQuery = {
+export type GetDocumentModelsQuery = {
   readonly documentModels: {
-    readonly totalCount: number;
     readonly hasNextPage: boolean;
     readonly hasPreviousPage: boolean;
     readonly cursor?: string | null | undefined;
@@ -2213,11 +2849,11 @@ type GetDocumentModelsQuery = {
     }>;
   };
 };
-type GetDocumentQueryVariables = Exact<{
+export type GetDocumentQueryVariables = Exact<{
   identifier: Scalars["String"]["input"];
   view?: InputMaybe<ViewFilterInput>;
 }>;
-type GetDocumentQuery = {
+export type GetDocumentQuery = {
   readonly document?: {
     readonly childIds: ReadonlyArray<string>;
     readonly document: {
@@ -2225,6 +2861,8 @@ type GetDocumentQuery = {
       readonly slug?: string | null | undefined;
       readonly name: string;
       readonly documentType: string;
+      readonly meta?: NonNullable<unknown> | null | undefined;
+      readonly protocolVersions?: NonNullable<unknown> | null | undefined;
       readonly state: NonNullable<unknown>;
       readonly createdAtUtcIso: string | Date;
       readonly lastModifiedAtUtcIso: string | Date;
@@ -2235,13 +2873,13 @@ type GetDocumentQuery = {
     };
   } | null | undefined;
 };
-type GetDocumentWithOperationsQueryVariables = Exact<{
+export type GetDocumentWithOperationsQueryVariables = Exact<{
   identifier: Scalars["String"]["input"];
   view?: InputMaybe<ViewFilterInput>;
   operationsFilter?: InputMaybe<DocumentOperationsFilterInput>;
   operationsPaging?: InputMaybe<PagingInput>;
 }>;
-type GetDocumentWithOperationsQuery = {
+export type GetDocumentWithOperationsQuery = {
   readonly document?: {
     readonly childIds: ReadonlyArray<string>;
     readonly document: {
@@ -2249,11 +2887,12 @@ type GetDocumentWithOperationsQuery = {
       readonly slug?: string | null | undefined;
       readonly name: string;
       readonly documentType: string;
+      readonly meta?: NonNullable<unknown> | null | undefined;
+      readonly protocolVersions?: NonNullable<unknown> | null | undefined;
       readonly state: NonNullable<unknown>;
       readonly createdAtUtcIso: string | Date;
       readonly lastModifiedAtUtcIso: string | Date;
       readonly operations?: {
-        readonly totalCount: number;
         readonly hasNextPage: boolean;
         readonly hasPreviousPage: boolean;
         readonly cursor?: string | null | undefined;
@@ -2295,15 +2934,14 @@ type GetDocumentWithOperationsQuery = {
     };
   } | null | undefined;
 };
-type GetDocumentOutgoingRelationshipsQueryVariables = Exact<{
+export type GetDocumentOutgoingRelationshipsQueryVariables = Exact<{
   sourceIdentifier: Scalars["String"]["input"];
   relationshipType: Scalars["String"]["input"];
   view?: InputMaybe<ViewFilterInput>;
   paging?: InputMaybe<PagingInput>;
 }>;
-type GetDocumentOutgoingRelationshipsQuery = {
+export type GetDocumentOutgoingRelationshipsQuery = {
   readonly documentOutgoingRelationships: {
-    readonly totalCount: number;
     readonly hasNextPage: boolean;
     readonly hasPreviousPage: boolean;
     readonly cursor?: string | null | undefined;
@@ -2312,6 +2950,8 @@ type GetDocumentOutgoingRelationshipsQuery = {
       readonly slug?: string | null | undefined;
       readonly name: string;
       readonly documentType: string;
+      readonly meta?: NonNullable<unknown> | null | undefined;
+      readonly protocolVersions?: NonNullable<unknown> | null | undefined;
       readonly state: NonNullable<unknown>;
       readonly createdAtUtcIso: string | Date;
       readonly lastModifiedAtUtcIso: string | Date;
@@ -2322,15 +2962,14 @@ type GetDocumentOutgoingRelationshipsQuery = {
     }>;
   };
 };
-type GetDocumentIncomingRelationshipsQueryVariables = Exact<{
+export type GetDocumentIncomingRelationshipsQueryVariables = Exact<{
   targetIdentifier: Scalars["String"]["input"];
   relationshipType: Scalars["String"]["input"];
   view?: InputMaybe<ViewFilterInput>;
   paging?: InputMaybe<PagingInput>;
 }>;
-type GetDocumentIncomingRelationshipsQuery = {
+export type GetDocumentIncomingRelationshipsQuery = {
   readonly documentIncomingRelationships: {
-    readonly totalCount: number;
     readonly hasNextPage: boolean;
     readonly hasPreviousPage: boolean;
     readonly cursor?: string | null | undefined;
@@ -2339,6 +2978,8 @@ type GetDocumentIncomingRelationshipsQuery = {
       readonly slug?: string | null | undefined;
       readonly name: string;
       readonly documentType: string;
+      readonly meta?: NonNullable<unknown> | null | undefined;
+      readonly protocolVersions?: NonNullable<unknown> | null | undefined;
       readonly state: NonNullable<unknown>;
       readonly createdAtUtcIso: string | Date;
       readonly lastModifiedAtUtcIso: string | Date;
@@ -2349,14 +2990,55 @@ type GetDocumentIncomingRelationshipsQuery = {
     }>;
   };
 };
-type FindDocumentsQueryVariables = Exact<{
+export type GetDocumentOutgoingRelationshipEdgesQueryVariables = Exact<{
+  sourceIdentifier: Scalars["String"]["input"];
+  relationshipType?: InputMaybe<Scalars["String"]["input"]>;
+  view?: InputMaybe<ViewFilterInput>;
+  paging?: InputMaybe<PagingInput>;
+}>;
+export type GetDocumentOutgoingRelationshipEdgesQuery = {
+  readonly documentOutgoingRelationshipEdges: {
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly cursor?: string | null | undefined;
+    readonly items: ReadonlyArray<{
+      readonly sourceId: string;
+      readonly targetId: string;
+      readonly relationshipType: string;
+      readonly metadata?: NonNullable<unknown> | null | undefined;
+      readonly createdAt: string | Date;
+      readonly updatedAt: string | Date;
+    }>;
+  };
+};
+export type GetDocumentIncomingRelationshipEdgesQueryVariables = Exact<{
+  targetIdentifier: Scalars["String"]["input"];
+  relationshipType?: InputMaybe<Scalars["String"]["input"]>;
+  view?: InputMaybe<ViewFilterInput>;
+  paging?: InputMaybe<PagingInput>;
+}>;
+export type GetDocumentIncomingRelationshipEdgesQuery = {
+  readonly documentIncomingRelationshipEdges: {
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly cursor?: string | null | undefined;
+    readonly items: ReadonlyArray<{
+      readonly sourceId: string;
+      readonly targetId: string;
+      readonly relationshipType: string;
+      readonly metadata?: NonNullable<unknown> | null | undefined;
+      readonly createdAt: string | Date;
+      readonly updatedAt: string | Date;
+    }>;
+  };
+};
+export type FindDocumentsQueryVariables = Exact<{
   search?: InputMaybe<SearchFilterInput>;
   view?: InputMaybe<ViewFilterInput>;
   paging?: InputMaybe<PagingInput>;
 }>;
-type FindDocumentsQuery = {
+export type FindDocumentsQuery = {
   readonly findDocuments: {
-    readonly totalCount: number;
     readonly hasNextPage: boolean;
     readonly hasPreviousPage: boolean;
     readonly cursor?: string | null | undefined;
@@ -2365,6 +3047,8 @@ type FindDocumentsQuery = {
       readonly slug?: string | null | undefined;
       readonly name: string;
       readonly documentType: string;
+      readonly meta?: NonNullable<unknown> | null | undefined;
+      readonly protocolVersions?: NonNullable<unknown> | null | undefined;
       readonly state: NonNullable<unknown>;
       readonly createdAtUtcIso: string | Date;
       readonly lastModifiedAtUtcIso: string | Date;
@@ -2375,13 +3059,12 @@ type FindDocumentsQuery = {
     }>;
   };
 };
-type GetDocumentOperationsQueryVariables = Exact<{
+export type GetDocumentOperationsQueryVariables = Exact<{
   filter: OperationsFilterInput;
   paging?: InputMaybe<PagingInput>;
 }>;
-type GetDocumentOperationsQuery = {
+export type GetDocumentOperationsQuery = {
   readonly documentOperations: {
-    readonly totalCount: number;
     readonly hasNextPage: boolean;
     readonly hasPreviousPage: boolean;
     readonly cursor?: string | null | undefined;
@@ -2417,25 +3100,81 @@ type GetDocumentOperationsQuery = {
     }>;
   };
 };
-type GetJobStatusQueryVariables = Exact<{
+export type JobInfoFieldsFragment = {
+  readonly id: string;
+  readonly documentId: string;
+  readonly status: string;
+  readonly result?: NonNullable<unknown> | null | undefined;
+  readonly error?: string | null | undefined;
+  readonly errorName?: string | null | undefined;
+  readonly createdAt: string | Date;
+  readonly completedAt?: string | Date | null | undefined;
+  readonly consistencyToken: {
+    readonly version: number;
+    readonly createdAtUtcIso: string;
+    readonly coordinates: ReadonlyArray<{
+      readonly documentId: string;
+      readonly scope: string;
+      readonly branch: string;
+      readonly operationIndex: number;
+    }>;
+  };
+  readonly meta: {
+    readonly batchId: string;
+    readonly batchJobIds: ReadonlyArray<string>;
+  };
+};
+export type GetJobStatusQueryVariables = Exact<{
   jobId: Scalars["String"]["input"];
 }>;
-type GetJobStatusQuery = {
+export type GetJobStatusQuery = {
   readonly jobStatus?: {
     readonly id: string;
+    readonly documentId: string;
     readonly status: string;
     readonly result?: NonNullable<unknown> | null | undefined;
     readonly error?: string | null | undefined;
+    readonly errorName?: string | null | undefined;
     readonly createdAt: string | Date;
     readonly completedAt?: string | Date | null | undefined;
+    readonly consistencyToken: {
+      readonly version: number;
+      readonly createdAtUtcIso: string;
+      readonly coordinates: ReadonlyArray<{
+        readonly documentId: string;
+        readonly scope: string;
+        readonly branch: string;
+        readonly operationIndex: number;
+      }>;
+    };
+    readonly meta: {
+      readonly batchId: string;
+      readonly batchJobIds: ReadonlyArray<string>;
+    };
   } | null | undefined;
 };
-type EvaluateActionsQueryVariables = Exact<{
+export type GetDocumentServedQueryVariables = Exact<{
+  idOrSlug: Scalars["String"]["input"];
+  view?: InputMaybe<ViewFilterInput>;
+}>;
+export type GetDocumentServedQuery = {
+  readonly documentServed: boolean;
+};
+export type GetCreateDefaultsQueryVariables = Exact<{
+  parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+export type GetCreateDefaultsQuery = {
+  readonly createDefaults: {
+    readonly signaturePolicy: string;
+    readonly protocolVersions: NonNullable<unknown>;
+  };
+};
+export type EvaluateActionsQueryVariables = Exact<{
   documentIdentifier: Scalars["String"]["input"];
   branch?: InputMaybe<Scalars["String"]["input"]>;
   candidates: ReadonlyArray<ActionCandidateInput>;
 }>;
-type EvaluateActionsQuery = {
+export type EvaluateActionsQuery = {
   readonly evaluateActions: {
     readonly allAllowed: boolean;
     readonly anyAllowed: boolean;
@@ -2447,16 +3186,18 @@ type EvaluateActionsQuery = {
     }>;
   };
 };
-type CreateDocumentMutationVariables = Exact<{
+export type CreateDocumentMutationVariables = Exact<{
   document: Scalars["JSONObject"]["input"];
   parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type CreateDocumentMutation = {
+export type CreateDocumentMutation = {
   readonly createDocument: {
     readonly id: string;
     readonly slug?: string | null | undefined;
     readonly name: string;
     readonly documentType: string;
+    readonly meta?: NonNullable<unknown> | null | undefined;
+    readonly protocolVersions?: NonNullable<unknown> | null | undefined;
     readonly state: NonNullable<unknown>;
     readonly createdAtUtcIso: string | Date;
     readonly lastModifiedAtUtcIso: string | Date;
@@ -2466,16 +3207,18 @@ type CreateDocumentMutation = {
     }>;
   };
 };
-type CreateEmptyDocumentMutationVariables = Exact<{
+export type CreateEmptyDocumentMutationVariables = Exact<{
   documentType: Scalars["String"]["input"];
   parentIdentifier?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type CreateEmptyDocumentMutation = {
+export type CreateEmptyDocumentMutation = {
   readonly createEmptyDocument: {
     readonly id: string;
     readonly slug?: string | null | undefined;
     readonly name: string;
     readonly documentType: string;
+    readonly meta?: NonNullable<unknown> | null | undefined;
+    readonly protocolVersions?: NonNullable<unknown> | null | undefined;
     readonly state: NonNullable<unknown>;
     readonly createdAtUtcIso: string | Date;
     readonly lastModifiedAtUtcIso: string | Date;
@@ -2485,17 +3228,19 @@ type CreateEmptyDocumentMutation = {
     }>;
   };
 };
-type MutateDocumentMutationVariables = Exact<{
+export type MutateDocumentMutationVariables = Exact<{
   documentIdentifier: Scalars["String"]["input"];
   actions: ReadonlyArray<ActionInput>;
   branch?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type MutateDocumentMutation = {
+export type MutateDocumentMutation = {
   readonly mutateDocument: {
     readonly id: string;
     readonly slug?: string | null | undefined;
     readonly name: string;
     readonly documentType: string;
+    readonly meta?: NonNullable<unknown> | null | undefined;
+    readonly protocolVersions?: NonNullable<unknown> | null | undefined;
     readonly state: NonNullable<unknown>;
     readonly createdAtUtcIso: string | Date;
     readonly lastModifiedAtUtcIso: string | Date;
@@ -2505,32 +3250,84 @@ type MutateDocumentMutation = {
     }>;
   };
 };
-type MutateDocumentAsyncMutationVariables = Exact<{
+export type MutateDocumentAsyncMutationVariables = Exact<{
   documentIdentifier: Scalars["String"]["input"];
   actions: ReadonlyArray<ActionInput>;
   branch?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type MutateDocumentAsyncMutation = {
+export type MutateDocumentAsyncMutation = {
   readonly mutateDocumentAsync: {
     readonly id: string;
+    readonly documentId: string;
     readonly status: string;
     readonly result?: NonNullable<unknown> | null | undefined;
     readonly error?: string | null | undefined;
+    readonly errorName?: string | null | undefined;
     readonly createdAt: string | Date;
     readonly completedAt?: string | Date | null | undefined;
+    readonly consistencyToken: {
+      readonly version: number;
+      readonly createdAtUtcIso: string;
+      readonly coordinates: ReadonlyArray<{
+        readonly documentId: string;
+        readonly scope: string;
+        readonly branch: string;
+        readonly operationIndex: number;
+      }>;
+    };
+    readonly meta: {
+      readonly batchId: string;
+      readonly batchJobIds: ReadonlyArray<string>;
+    };
+  };
+};
+export type ExecuteBatchMutationVariables = Exact<{
+  jobs: ReadonlyArray<ExecutionJobInput>;
+}>;
+export type ExecuteBatchMutation = {
+  readonly executeBatch: {
+    readonly jobs: ReadonlyArray<{
+      readonly key: string;
+      readonly job: {
+        readonly id: string;
+        readonly documentId: string;
+        readonly status: string;
+        readonly result?: NonNullable<unknown> | null | undefined;
+        readonly error?: string | null | undefined;
+        readonly errorName?: string | null | undefined;
+        readonly createdAt: string | Date;
+        readonly completedAt?: string | Date | null | undefined;
+        readonly consistencyToken: {
+          readonly version: number;
+          readonly createdAtUtcIso: string;
+          readonly coordinates: ReadonlyArray<{
+            readonly documentId: string;
+            readonly scope: string;
+            readonly branch: string;
+            readonly operationIndex: number;
+          }>;
+        };
+        readonly meta: {
+          readonly batchId: string;
+          readonly batchJobIds: ReadonlyArray<string>;
+        };
+      };
+    }>;
   };
 };
-type RenameDocumentMutationVariables = Exact<{
+export type RenameDocumentMutationVariables = Exact<{
   documentIdentifier: Scalars["String"]["input"];
   name: Scalars["String"]["input"];
   branch?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type RenameDocumentMutation = {
+export type RenameDocumentMutation = {
   readonly renameDocument: {
     readonly id: string;
     readonly slug?: string | null | undefined;
     readonly name: string;
     readonly documentType: string;
+    readonly meta?: NonNullable<unknown> | null | undefined;
+    readonly protocolVersions?: NonNullable<unknown> | null | undefined;
     readonly state: NonNullable<unknown>;
     readonly createdAtUtcIso: string | Date;
     readonly lastModifiedAtUtcIso: string | Date;
@@ -2540,17 +3337,19 @@ type RenameDocumentMutation = {
     }>;
   };
 };
-type SetPreferredEditorMutationVariables = Exact<{
+export type SetPreferredEditorMutationVariables = Exact<{
   documentIdentifier: Scalars["String"]["input"];
   preferredEditor?: InputMaybe<Scalars["String"]["input"]>;
   branch?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type SetPreferredEditorMutation = {
+export type SetPreferredEditorMutation = {
   readonly setPreferredEditor: {
     readonly id: string;
     readonly slug?: string | null | undefined;
     readonly name: string;
     readonly documentType: string;
+    readonly meta?: NonNullable<unknown> | null | undefined;
+    readonly protocolVersions?: NonNullable<unknown> | null | undefined;
     readonly state: NonNullable<unknown>;
     readonly createdAtUtcIso: string | Date;
     readonly lastModifiedAtUtcIso: string | Date;
@@ -2560,18 +3359,45 @@ type SetPreferredEditorMutation = {
     }>;
   };
 };
-type AddRelationshipMutationVariables = Exact<{
+export type AddRelationshipMutationVariables = Exact<{
   sourceIdentifier: Scalars["String"]["input"];
   targetIdentifier: Scalars["String"]["input"];
   relationshipType: Scalars["String"]["input"];
+  metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
   branch?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type AddRelationshipMutation = {
+export type AddRelationshipMutation = {
   readonly addRelationship: {
     readonly id: string;
     readonly slug?: string | null | undefined;
     readonly name: string;
     readonly documentType: string;
+    readonly meta?: NonNullable<unknown> | null | undefined;
+    readonly protocolVersions?: NonNullable<unknown> | null | undefined;
+    readonly state: NonNullable<unknown>;
+    readonly createdAtUtcIso: string | Date;
+    readonly lastModifiedAtUtcIso: string | Date;
+    readonly revisionsList: ReadonlyArray<{
+      readonly scope: string;
+      readonly revision: number;
+    }>;
+  };
+};
+export type UpdateRelationshipMutationVariables = Exact<{
+  sourceIdentifier: Scalars["String"]["input"];
+  targetIdentifier: Scalars["String"]["input"];
+  relationshipType: Scalars["String"]["input"];
+  metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
+  branch?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+export type UpdateRelationshipMutation = {
+  readonly updateRelationship: {
+    readonly id: string;
+    readonly slug?: string | null | undefined;
+    readonly name: string;
+    readonly documentType: string;
+    readonly meta?: NonNullable<unknown> | null | undefined;
+    readonly protocolVersions?: NonNullable<unknown> | null | undefined;
     readonly state: NonNullable<unknown>;
     readonly createdAtUtcIso: string | Date;
     readonly lastModifiedAtUtcIso: string | Date;
@@ -2581,18 +3407,20 @@ type AddRelationshipMutation = {
     }>;
   };
 };
-type RemoveRelationshipMutationVariables = Exact<{
+export type RemoveRelationshipMutationVariables = Exact<{
   sourceIdentifier: Scalars["String"]["input"];
   targetIdentifier: Scalars["String"]["input"];
   relationshipType: Scalars["String"]["input"];
   branch?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type RemoveRelationshipMutation = {
+export type RemoveRelationshipMutation = {
   readonly removeRelationship: {
     readonly id: string;
     readonly slug?: string | null | undefined;
     readonly name: string;
     readonly documentType: string;
+    readonly meta?: NonNullable<unknown> | null | undefined;
+    readonly protocolVersions?: NonNullable<unknown> | null | undefined;
     readonly state: NonNullable<unknown>;
     readonly createdAtUtcIso: string | Date;
     readonly lastModifiedAtUtcIso: string | Date;
@@ -2602,20 +3430,22 @@ type RemoveRelationshipMutation = {
     }>;
   };
 };
-type MoveRelationshipMutationVariables = Exact<{
+export type MoveRelationshipMutationVariables = Exact<{
   sourceParentIdentifier: Scalars["String"]["input"];
   targetParentIdentifier: Scalars["String"]["input"];
   targetIdentifier: Scalars["String"]["input"];
   relationshipType: Scalars["String"]["input"];
   branch?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type MoveRelationshipMutation = {
+export type MoveRelationshipMutation = {
   readonly moveRelationship: {
     readonly source: {
       readonly id: string;
       readonly slug?: string | null | undefined;
       readonly name: string;
       readonly documentType: string;
+      readonly meta?: NonNullable<unknown> | null | undefined;
+      readonly protocolVersions?: NonNullable<unknown> | null | undefined;
       readonly state: NonNullable<unknown>;
       readonly createdAtUtcIso: string | Date;
       readonly lastModifiedAtUtcIso: string | Date;
@@ -2629,6 +3459,8 @@ type MoveRelationshipMutation = {
       readonly slug?: string | null | undefined;
       readonly name: string;
       readonly documentType: string;
+      readonly meta?: NonNullable<unknown> | null | undefined;
+      readonly protocolVersions?: NonNullable<unknown> | null | undefined;
       readonly state: NonNullable<unknown>;
       readonly createdAtUtcIso: string | Date;
       readonly lastModifiedAtUtcIso: string | Date;
@@ -2639,25 +3471,25 @@ type MoveRelationshipMutation = {
     };
   };
 };
-type DeleteDocumentMutationVariables = Exact<{
+export type DeleteDocumentMutationVariables = Exact<{
   identifier: Scalars["String"]["input"];
   propagate?: InputMaybe<PropagationMode>;
 }>;
-type DeleteDocumentMutation = {
+export type DeleteDocumentMutation = {
   readonly deleteDocument: boolean;
 };
-type DeleteDocumentsMutationVariables = Exact<{
+export type DeleteDocumentsMutationVariables = Exact<{
   identifiers: ReadonlyArray<Scalars["String"]["input"]>;
   propagate?: InputMaybe<PropagationMode>;
 }>;
-type DeleteDocumentsMutation = {
+export type DeleteDocumentsMutation = {
   readonly deleteDocuments: boolean;
 };
-type DocumentChangesSubscriptionVariables = Exact<{
+export type DocumentChangesSubscriptionVariables = Exact<{
   search?: InputMaybe<SearchFilterInput>;
   view?: InputMaybe<ViewFilterInput>;
 }>;
-type DocumentChangesSubscription = {
+export type DocumentChangesSubscription = {
   readonly documentChanges: {
     readonly type: DocumentChangeType;
     readonly documents: ReadonlyArray<{
@@ -2665,6 +3497,8 @@ type DocumentChangesSubscription = {
       readonly slug?: string | null | undefined;
       readonly name: string;
       readonly documentType: string;
+      readonly meta?: NonNullable<unknown> | null | undefined;
+      readonly protocolVersions?: NonNullable<unknown> | null | undefined;
       readonly state: NonNullable<unknown>;
       readonly createdAtUtcIso: string | Date;
       readonly lastModifiedAtUtcIso: string | Date;
@@ -2679,26 +3513,30 @@ type DocumentChangesSubscription = {
     } | null | undefined;
   };
 };
-type JobChangesSubscriptionVariables = Exact<{
+export type JobChangesSubscriptionVariables = Exact<{
   jobId: Scalars["String"]["input"];
 }>;
-type JobChangesSubscription = {
+export type JobChangesSubscription = {
   readonly jobChanges: {
     readonly jobId: string;
     readonly status: string;
-    readonly result: NonNullable<unknown>;
+    readonly result?: NonNullable<unknown> | null | undefined;
     readonly error?: string | null | undefined;
   };
 };
-type PollSyncEnvelopesQueryVariables = Exact<{
+export type PollSyncEnvelopesQueryVariables = Exact<{
   channelId: Scalars["String"]["input"];
   outboxAck: Scalars["Int"]["input"];
   outboxLatest: Scalars["Int"]["input"];
+  manifestRevision?: InputMaybe<Scalars["String"]["input"]>;
+  refusals?: InputMaybe<ReadonlyArray<SyncRefusalInput>>;
 }>;
-type PollSyncEnvelopesQuery = {
+export type PollSyncEnvelopesQuery = {
   readonly pollSyncEnvelopes: {
     readonly ackOrdinal: number;
     readonly hasMore: boolean;
+    readonly manifestRevision?: string | null | undefined;
+    readonly peerManifestRevision?: string | null | undefined;
     readonly envelopes: ReadonlyArray<{
       readonly type: SyncEnvelopeType;
       readonly key?: string | null | undefined;
@@ -2757,47 +3595,49 @@ type PollSyncEnvelopesQuery = {
     }>;
   };
 };
-type TouchChannelMutationVariables = Exact<{
+export type TouchChannelMutationVariables = Exact<{
   input: TouchChannelInput;
 }>;
-type TouchChannelMutation = {
+export type TouchChannelMutation = {
   readonly touchChannel: {
     readonly success: boolean;
     readonly ackOrdinal: number;
+    readonly manifest?: NonNullable<unknown> | null | undefined;
   };
 };
-type PushSyncEnvelopesMutationVariables = Exact<{
+export type PushSyncEnvelopesMutationVariables = Exact<{
   envelopes: ReadonlyArray<SyncEnvelopeInput>;
+  peerManifestRevision?: InputMaybe<Scalars["String"]["input"]>;
 }>;
-type PushSyncEnvelopesMutation = {
+export type PushSyncEnvelopesMutation = {
   readonly pushSyncEnvelopes: boolean;
 };
-type WithIndex<TObject> = TObject & Record<string, any>;
-type ResolversObject<TObject> = WithIndex<TObject>;
-type ResolverTypeWrapper<T> = Promise<T> | T;
-type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+export type WithIndex<TObject> = TObject & Record<string, any>;
+export type ResolversObject<TObject> = WithIndex<TObject>;
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
   resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
 };
-type Resolver<TResult, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
-type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
-type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
-type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
-interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
-  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
-  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
+export type Resolver<TResult, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult; }, TParent, TContext, TArgs>;
+  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult; }, TContext, TArgs>;
 }
-interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
   subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
   resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
 }
-type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
-type SubscriptionResolver<TResult, TKey extends string, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
-type TypeResolveFn<TTypes, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
-type IsTypeOfResolverFn<T = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
-type NextResolverFn<T> = () => Promise<T>;
-type DirectiveResolverFn<TResult = Record<PropertyKey, never>, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+export type SubscriptionResolver<TResult, TKey extends string, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+export type TypeResolveFn<TTypes, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+export type IsTypeOfResolverFn<T = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export type NextResolverFn<T> = () => Promise<T>;
+export type DirectiveResolverFn<TResult = Record<PropertyKey, never>, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
 /** Mapping between all available schema types and the resolvers types */
-type ResolversTypes = ResolversObject<{
+export type ResolversTypes = ResolversObject<{
   Action: ResolverTypeWrapper<Action>;
   ActionCandidateInput: ActionCandidateInput;
   ActionContext: ResolverTypeWrapper<ActionContext>;
@@ -2806,9 +3646,14 @@ type ResolversTypes = ResolversObject<{
   ActionEvaluations: ResolverTypeWrapper<ActionEvaluations>;
   ActionInput: ActionInput;
   AuthDecision: AuthDecision;
+  BatchExecutionResult: ResolverTypeWrapper<BatchExecutionResult>;
+  BatchJobResult: ResolverTypeWrapper<BatchJobResult>;
   Boolean: ResolverTypeWrapper<Scalars["Boolean"]["output"]>;
   ChannelMeta: ResolverTypeWrapper<ChannelMeta>;
   ChannelMetaInput: ChannelMetaInput;
+  ConsistencyCoordinate: ResolverTypeWrapper<ConsistencyCoordinate>;
+  ConsistencyToken: ResolverTypeWrapper<ConsistencyToken>;
+  CreateDefaults: ResolverTypeWrapper<CreateDefaults>;
   DateTime: ResolverTypeWrapper<Scalars["DateTime"]["output"]>;
   DeadLetterInfo: ResolverTypeWrapper<DeadLetterInfo>;
   DocumentChangeContext: ResolverTypeWrapper<DocumentChangeContext>;
@@ -2817,9 +3662,13 @@ type ResolversTypes = ResolversObject<{
   DocumentModelGlobalState: ResolverTypeWrapper<DocumentModelGlobalState>;
   DocumentModelResultPage: ResolverTypeWrapper<DocumentModelResultPage>;
   DocumentOperationsFilterInput: DocumentOperationsFilterInput;
+  DocumentRelationship: ResolverTypeWrapper<DocumentRelationship>;
+  DocumentRelationshipResultPage: ResolverTypeWrapper<DocumentRelationshipResultPage>;
   DocumentWithChildren: ResolverTypeWrapper<DocumentWithChildren>;
+  ExecutionJobInput: ExecutionJobInput;
   Int: ResolverTypeWrapper<Scalars["Int"]["output"]>;
   JSONObject: ResolverTypeWrapper<Scalars["JSONObject"]["output"]>;
+  JobBatchMeta: ResolverTypeWrapper<JobBatchMeta>;
   JobChangeEvent: ResolverTypeWrapper<JobChangeEvent>;
   JobInfo: ResolverTypeWrapper<JobInfo>;
   MoveRelationshipResult: ResolverTypeWrapper<MoveRelationshipResult>;
@@ -2833,6 +3682,9 @@ type ResolversTypes = ResolversObject<{
   PHDocument: ResolverTypeWrapper<PhDocument>;
   PHDocumentResultPage: ResolverTypeWrapper<PhDocumentResultPage>;
   PagingInput: PagingInput;
+  PeerAgreement: ResolverTypeWrapper<PeerAgreement>;
+  PeerAgreementLimit: ResolverTypeWrapper<PeerAgreementLimit>;
+  PeerAgreementMember: ResolverTypeWrapper<PeerAgreementMember>;
   PollSyncEnvelopesResult: ResolverTypeWrapper<PollSyncEnvelopesResult>;
   PropagationMode: PropagationMode;
   Query: ResolverTypeWrapper<Record<PropertyKey, never>>;
@@ -2854,12 +3706,15 @@ type ResolversTypes = ResolversObject<{
   SyncEnvelope: ResolverTypeWrapper<SyncEnvelope>;
   SyncEnvelopeInput: SyncEnvelopeInput;
   SyncEnvelopeType: SyncEnvelopeType;
+  SyncHold: ResolverTypeWrapper<SyncHold>;
+  SyncHoldReason: ResolverTypeWrapper<SyncHoldReason>;
+  SyncRefusalInput: SyncRefusalInput;
   TouchChannelInput: TouchChannelInput;
   TouchChannelResult: ResolverTypeWrapper<TouchChannelResult>;
   ViewFilterInput: ViewFilterInput;
 }>;
 /** Mapping between all available schema types and the resolvers parents */
-type ResolversParentTypes = ResolversObject<{
+export type ResolversParentTypes = ResolversObject<{
   Action: Action;
   ActionCandidateInput: ActionCandidateInput;
   ActionContext: ActionContext;
@@ -2867,9 +3722,14 @@ type ResolversParentTypes = ResolversObject<{
   ActionEvaluation: ActionEvaluation;
   ActionEvaluations: ActionEvaluations;
   ActionInput: ActionInput;
+  BatchExecutionResult: BatchExecutionResult;
+  BatchJobResult: BatchJobResult;
   Boolean: Scalars["Boolean"]["output"];
   ChannelMeta: ChannelMeta;
   ChannelMetaInput: ChannelMetaInput;
+  ConsistencyCoordinate: ConsistencyCoordinate;
+  ConsistencyToken: ConsistencyToken;
+  CreateDefaults: CreateDefaults;
   DateTime: Scalars["DateTime"]["output"];
   DeadLetterInfo: DeadLetterInfo;
   DocumentChangeContext: DocumentChangeContext;
@@ -2877,9 +3737,13 @@ type ResolversParentTypes = ResolversObject<{
   DocumentModelGlobalState: DocumentModelGlobalState;
   DocumentModelResultPage: DocumentModelResultPage;
   DocumentOperationsFilterInput: DocumentOperationsFilterInput;
+  DocumentRelationship: DocumentRelationship;
+  DocumentRelationshipResultPage: DocumentRelationshipResultPage;
   DocumentWithChildren: DocumentWithChildren;
+  ExecutionJobInput: ExecutionJobInput;
   Int: Scalars["Int"]["output"];
   JSONObject: Scalars["JSONObject"]["output"];
+  JobBatchMeta: JobBatchMeta;
   JobChangeEvent: JobChangeEvent;
   JobInfo: JobInfo;
   MoveRelationshipResult: MoveRelationshipResult;
@@ -2893,6 +3757,9 @@ type ResolversParentTypes = ResolversObject<{
   PHDocument: PhDocument;
   PHDocumentResultPage: PhDocumentResultPage;
   PagingInput: PagingInput;
+  PeerAgreement: PeerAgreement;
+  PeerAgreementLimit: PeerAgreementLimit;
+  PeerAgreementMember: PeerAgreementMember;
   PollSyncEnvelopesResult: PollSyncEnvelopesResult;
   Query: Record<PropertyKey, never>;
   ReactorOperation: ReactorOperation;
@@ -2912,11 +3779,14 @@ type ResolversParentTypes = ResolversObject<{
   Subscription: Record<PropertyKey, never>;
   SyncEnvelope: SyncEnvelope;
   SyncEnvelopeInput: SyncEnvelopeInput;
+  SyncHold: SyncHold;
+  SyncHoldReason: SyncHoldReason;
+  SyncRefusalInput: SyncRefusalInput;
   TouchChannelInput: TouchChannelInput;
   TouchChannelResult: TouchChannelResult;
   ViewFilterInput: ViewFilterInput;
 }>;
-type ActionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Action"] = ResolversParentTypes["Action"]> = ResolversObject<{
+export type ActionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Action"] = ResolversParentTypes["Action"]> = ResolversObject<{
   context?: Resolver<Maybe<ResolversTypes["ActionContext"]>, ParentType, ContextType>;
   id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   input?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
@@ -2924,27 +3794,49 @@ type ActionResolvers<ContextType = Context, ParentType extends ResolversParentTy
   timestampUtcMs?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   type?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type ActionContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionContext"] = ResolversParentTypes["ActionContext"]> = ResolversObject<{
+export type ActionContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionContext"] = ResolversParentTypes["ActionContext"]> = ResolversObject<{
   signer?: Resolver<Maybe<ResolversTypes["ReactorSigner"]>, ParentType, ContextType>;
 }>;
-type ActionEvaluationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionEvaluation"] = ResolversParentTypes["ActionEvaluation"]> = ResolversObject<{
+export type ActionEvaluationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionEvaluation"] = ResolversParentTypes["ActionEvaluation"]> = ResolversObject<{
   decision?: Resolver<ResolversTypes["AuthDecision"], ParentType, ContextType>;
   reason?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
 }>;
-type ActionEvaluationsResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionEvaluations"] = ResolversParentTypes["ActionEvaluations"]> = ResolversObject<{
+export type ActionEvaluationsResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ActionEvaluations"] = ResolversParentTypes["ActionEvaluations"]> = ResolversObject<{
   allAllowed?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   allDenied?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   anyAllowed?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   anyDenied?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   evaluations?: Resolver<ReadonlyArray<ResolversTypes["ActionEvaluation"]>, ParentType, ContextType>;
 }>;
-type ChannelMetaResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ChannelMeta"] = ResolversParentTypes["ChannelMeta"]> = ResolversObject<{
+export type BatchExecutionResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["BatchExecutionResult"] = ResolversParentTypes["BatchExecutionResult"]> = ResolversObject<{
+  jobs?: Resolver<ReadonlyArray<ResolversTypes["BatchJobResult"]>, ParentType, ContextType>;
+}>;
+export type BatchJobResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["BatchJobResult"] = ResolversParentTypes["BatchJobResult"]> = ResolversObject<{
+  job?: Resolver<ResolversTypes["JobInfo"], ParentType, ContextType>;
+  key?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+export type ChannelMetaResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ChannelMeta"] = ResolversParentTypes["ChannelMeta"]> = ResolversObject<{
   id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["DateTime"], any> {
+export type ConsistencyCoordinateResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ConsistencyCoordinate"] = ResolversParentTypes["ConsistencyCoordinate"]> = ResolversObject<{
+  branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  operationIndex?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+export type ConsistencyTokenResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ConsistencyToken"] = ResolversParentTypes["ConsistencyToken"]> = ResolversObject<{
+  coordinates?: Resolver<ReadonlyArray<ResolversTypes["ConsistencyCoordinate"]>, ParentType, ContextType>;
+  createdAtUtcIso?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  version?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+}>;
+export type CreateDefaultsResolvers<ContextType = Context, ParentType extends ResolversParentTypes["CreateDefaults"] = ResolversParentTypes["CreateDefaults"]> = ResolversObject<{
+  protocolVersions?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  signaturePolicy?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["DateTime"], any> {
   name: "DateTime";
 }
-type DeadLetterInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DeadLetterInfo"] = ResolversParentTypes["DeadLetterInfo"]> = ResolversObject<{
+export type DeadLetterInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DeadLetterInfo"] = ResolversParentTypes["DeadLetterInfo"]> = ResolversObject<{
   branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   error?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
@@ -2953,119 +3845,167 @@ type DeadLetterInfoResolvers<ContextType = Context, ParentType extends Resolvers
   operationCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
   scopes?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
 }>;
-type DocumentChangeContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeContext"] = ResolversParentTypes["DocumentChangeContext"]> = ResolversObject<{
+export type DocumentChangeContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeContext"] = ResolversParentTypes["DocumentChangeContext"]> = ResolversObject<{
   childId?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   parentId?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
 }>;
-type DocumentChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeEvent"] = ResolversParentTypes["DocumentChangeEvent"]> = ResolversObject<{
+export type DocumentChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentChangeEvent"] = ResolversParentTypes["DocumentChangeEvent"]> = ResolversObject<{
   context?: Resolver<Maybe<ResolversTypes["DocumentChangeContext"]>, ParentType, ContextType>;
   documents?: Resolver<ReadonlyArray<ResolversTypes["PHDocument"]>, ParentType, ContextType>;
   type?: Resolver<ResolversTypes["DocumentChangeType"], ParentType, ContextType>;
 }>;
-type DocumentModelGlobalStateResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelGlobalState"] = ResolversParentTypes["DocumentModelGlobalState"]> = ResolversObject<{
+export type DocumentModelGlobalStateResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelGlobalState"] = ResolversParentTypes["DocumentModelGlobalState"]> = ResolversObject<{
   id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   namespace?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   specification?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
   version?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
 }>;
-type DocumentModelResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelResultPage"] = ResolversParentTypes["DocumentModelResultPage"]> = ResolversObject<{
+export type DocumentModelResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentModelResultPage"] = ResolversParentTypes["DocumentModelResultPage"]> = ResolversObject<{
   cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   items?: Resolver<ReadonlyArray<ResolversTypes["DocumentModelGlobalState"]>, ParentType, ContextType>;
-  totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
 }>;
-type DocumentWithChildrenResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentWithChildren"] = ResolversParentTypes["DocumentWithChildren"]> = ResolversObject<{
+export type DocumentRelationshipResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentRelationship"] = ResolversParentTypes["DocumentRelationship"]> = ResolversObject<{
+  createdAt?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
+  metadata?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
+  relationshipType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  sourceId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  targetId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  updatedAt?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
+}>;
+export type DocumentRelationshipResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentRelationshipResultPage"] = ResolversParentTypes["DocumentRelationshipResultPage"]> = ResolversObject<{
+  cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  items?: Resolver<ReadonlyArray<ResolversTypes["DocumentRelationship"]>, ParentType, ContextType>;
+}>;
+export type DocumentWithChildrenResolvers<ContextType = Context, ParentType extends ResolversParentTypes["DocumentWithChildren"] = ResolversParentTypes["DocumentWithChildren"]> = ResolversObject<{
   childIds?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
   document?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
 }>;
-interface JsonObjectScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["JSONObject"], any> {
+export interface JsonObjectScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes["JSONObject"], any> {
   name: "JSONObject";
 }
-type JobChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobChangeEvent"] = ResolversParentTypes["JobChangeEvent"]> = ResolversObject<{
+export type JobBatchMetaResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobBatchMeta"] = ResolversParentTypes["JobBatchMeta"]> = ResolversObject<{
+  batchId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  batchJobIds?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
+}>;
+export type JobChangeEventResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobChangeEvent"] = ResolversParentTypes["JobChangeEvent"]> = ResolversObject<{
   error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   jobId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
-  result?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  result?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
   status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type JobInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobInfo"] = ResolversParentTypes["JobInfo"]> = ResolversObject<{
+export type JobInfoResolvers<ContextType = Context, ParentType extends ResolversParentTypes["JobInfo"] = ResolversParentTypes["JobInfo"]> = ResolversObject<{
   completedAt?: Resolver<Maybe<ResolversTypes["DateTime"]>, ParentType, ContextType>;
+  consistencyToken?: Resolver<ResolversTypes["ConsistencyToken"], ParentType, ContextType>;
   createdAt?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
+  documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  errorName?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  meta?: Resolver<ResolversTypes["JobBatchMeta"], ParentType, ContextType>;
   result?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
   status?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type MoveRelationshipResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["MoveRelationshipResult"] = ResolversParentTypes["MoveRelationshipResult"]> = ResolversObject<{
+export type MoveRelationshipResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["MoveRelationshipResult"] = ResolversParentTypes["MoveRelationshipResult"]> = ResolversObject<{
   source?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
   target?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType>;
 }>;
-type MutationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Mutation"] = ResolversParentTypes["Mutation"]> = ResolversObject<{
-  addRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationAddRelationshipArgs, "relationshipType" | "sourceIdentifier" | "targetIdentifier">>;
+export type MutationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Mutation"] = ResolversParentTypes["Mutation"]> = ResolversObject<{
+  addRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationAddRelationshipArgs, "relationshipType">>;
   createDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationCreateDocumentArgs, "document">>;
   createEmptyDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationCreateEmptyDocumentArgs, "documentType">>;
-  deleteDocument?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationDeleteDocumentArgs, "identifier">>;
-  deleteDocuments?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationDeleteDocumentsArgs, "identifiers">>;
-  execute?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationExecuteArgs, "actions" | "documentIdentifier">>;
-  executeAsync?: Resolver<ResolversTypes["JobInfo"], ParentType, ContextType, RequireFields<MutationExecuteAsyncArgs, "actions" | "documentIdentifier">>;
-  moveRelationship?: Resolver<ResolversTypes["MoveRelationshipResult"], ParentType, ContextType, RequireFields<MutationMoveRelationshipArgs, "relationshipType" | "sourceParentIdentifier" | "targetIdentifier" | "targetParentIdentifier">>;
+  deleteDocument?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, Partial<MutationDeleteDocumentArgs>>;
+  deleteDocuments?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, Partial<MutationDeleteDocumentsArgs>>;
+  execute?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationExecuteArgs, "actions">>;
+  executeAsync?: Resolver<ResolversTypes["JobInfo"], ParentType, ContextType, RequireFields<MutationExecuteAsyncArgs, "actions">>;
+  executeBatch?: Resolver<ResolversTypes["BatchExecutionResult"], ParentType, ContextType, RequireFields<MutationExecuteBatchArgs, "jobs">>;
+  moveRelationship?: Resolver<ResolversTypes["MoveRelationshipResult"], ParentType, ContextType, RequireFields<MutationMoveRelationshipArgs, "relationshipType">>;
   mutateDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationMutateDocumentArgs, "actions" | "documentIdentifier">>;
   mutateDocumentAsync?: Resolver<ResolversTypes["String"], ParentType, ContextType, RequireFields<MutationMutateDocumentAsyncArgs, "actions" | "documentIdentifier">>;
   pushSyncEnvelopes?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<MutationPushSyncEnvelopesArgs, "envelopes">>;
-  removeRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRemoveRelationshipArgs, "relationshipType" | "sourceIdentifier" | "targetIdentifier">>;
-  renameDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRenameDocumentArgs, "documentIdentifier" | "name">>;
-  setPreferredEditor?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationSetPreferredEditorArgs, "documentIdentifier">>;
+  removeRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRemoveRelationshipArgs, "relationshipType">>;
+  renameDocument?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationRenameDocumentArgs, "name">>;
+  setPreferredEditor?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, Partial<MutationSetPreferredEditorArgs>>;
   touchChannel?: Resolver<ResolversTypes["TouchChannelResult"], ParentType, ContextType, RequireFields<MutationTouchChannelArgs, "input">>;
+  updateRelationship?: Resolver<ResolversTypes["PHDocument"], ParentType, ContextType, RequireFields<MutationUpdateRelationshipArgs, "relationshipType">>;
 }>;
-type OperationContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationContext"] = ResolversParentTypes["OperationContext"]> = ResolversObject<{
+export type OperationContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationContext"] = ResolversParentTypes["OperationContext"]> = ResolversObject<{
   branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   documentType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   ordinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
   scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type OperationWithContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationWithContext"] = ResolversParentTypes["OperationWithContext"]> = ResolversObject<{
+export type OperationWithContextResolvers<ContextType = Context, ParentType extends ResolversParentTypes["OperationWithContext"] = ResolversParentTypes["OperationWithContext"]> = ResolversObject<{
   context?: Resolver<ResolversTypes["OperationContext"], ParentType, ContextType>;
   operation?: Resolver<ResolversTypes["ReactorOperation"], ParentType, ContextType>;
 }>;
-type PhDocumentResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocument"] = ResolversParentTypes["PHDocument"]> = ResolversObject<{
+export type PhDocumentResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocument"] = ResolversParentTypes["PHDocument"]> = ResolversObject<{
   createdAtUtcIso?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
   documentType?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   id?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   lastModifiedAtUtcIso?: Resolver<ResolversTypes["DateTime"], ParentType, ContextType>;
+  meta?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
   name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   operations?: Resolver<Maybe<ResolversTypes["ReactorOperationResultPage"]>, ParentType, ContextType, Partial<PhDocumentOperationsArgs>>;
   preferredEditor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  protocolVersions?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
   revisionsList?: Resolver<ReadonlyArray<ResolversTypes["Revision"]>, ParentType, ContextType>;
   slug?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   state?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
 }>;
-type PhDocumentResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocumentResultPage"] = ResolversParentTypes["PHDocumentResultPage"]> = ResolversObject<{
+export type PhDocumentResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PHDocumentResultPage"] = ResolversParentTypes["PHDocumentResultPage"]> = ResolversObject<{
   cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   items?: Resolver<ReadonlyArray<ResolversTypes["PHDocument"]>, ParentType, ContextType>;
-  totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
 }>;
-type PollSyncEnvelopesResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PollSyncEnvelopesResult"] = ResolversParentTypes["PollSyncEnvelopesResult"]> = ResolversObject<{
+export type PeerAgreementResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PeerAgreement"] = ResolversParentTypes["PeerAgreement"]> = ResolversObject<{
+  collectionId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  limitedBy?: Resolver<ReadonlyArray<ResolversTypes["PeerAgreementLimit"]>, ParentType, ContextType>;
+  local?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  members?: Resolver<ReadonlyArray<ResolversTypes["PeerAgreementMember"]>, ParentType, ContextType>;
+}>;
+export type PeerAgreementLimitResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PeerAgreementLimit"] = ResolversParentTypes["PeerAgreementLimit"]> = ResolversObject<{
+  protocol?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  remoteNames?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
+}>;
+export type PeerAgreementMemberResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PeerAgreementMember"] = ResolversParentTypes["PeerAgreementMember"]> = ResolversObject<{
+  announced?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  features?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  protocols?: Resolver<ResolversTypes["JSONObject"], ParentType, ContextType>;
+  remoteName?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+export type PollSyncEnvelopesResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["PollSyncEnvelopesResult"] = ResolversParentTypes["PollSyncEnvelopesResult"]> = ResolversObject<{
   ackOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
   deadLetters?: Resolver<ReadonlyArray<ResolversTypes["DeadLetterInfo"]>, ParentType, ContextType>;
   envelopes?: Resolver<ReadonlyArray<ResolversTypes["SyncEnvelope"]>, ParentType, ContextType>;
   hasMore?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
+  manifestRevision?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
+  peerManifestRevision?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
 }>;
-type QueryResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Query"] = ResolversParentTypes["Query"]> = ResolversObject<{
-  document?: Resolver<Maybe<ResolversTypes["DocumentWithChildren"]>, ParentType, ContextType, RequireFields<QueryDocumentArgs, "identifier">>;
-  documentIncomingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentIncomingRelationshipsArgs, "relationshipType" | "targetIdentifier">>;
+export type QueryResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Query"] = ResolversParentTypes["Query"]> = ResolversObject<{
+  createDefaults?: Resolver<ResolversTypes["CreateDefaults"], ParentType, ContextType, Partial<QueryCreateDefaultsArgs>>;
+  document?: Resolver<Maybe<ResolversTypes["DocumentWithChildren"]>, ParentType, ContextType, Partial<QueryDocumentArgs>>;
+  documentIncomingRelationshipEdges?: Resolver<ResolversTypes["DocumentRelationshipResultPage"], ParentType, ContextType, Partial<QueryDocumentIncomingRelationshipEdgesArgs>>;
+  documentIncomingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentIncomingRelationshipsArgs, "relationshipType">>;
   documentModels?: Resolver<ResolversTypes["DocumentModelResultPage"], ParentType, ContextType, Partial<QueryDocumentModelsArgs>>;
   documentOperations?: Resolver<ResolversTypes["ReactorOperationResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOperationsArgs, "filter">>;
-  documentOutgoingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOutgoingRelationshipsArgs, "relationshipType" | "sourceIdentifier">>;
-  evaluateActions?: Resolver<ResolversTypes["ActionEvaluations"], ParentType, ContextType, RequireFields<QueryEvaluateActionsArgs, "candidates" | "documentIdentifier">>;
+  documentOutgoingRelationshipEdges?: Resolver<ResolversTypes["DocumentRelationshipResultPage"], ParentType, ContextType, Partial<QueryDocumentOutgoingRelationshipEdgesArgs>>;
+  documentOutgoingRelationships?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, RequireFields<QueryDocumentOutgoingRelationshipsArgs, "relationshipType">>;
+  documentServed?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType, RequireFields<QueryDocumentServedArgs, "idOrSlug">>;
+  evaluateActions?: Resolver<ResolversTypes["ActionEvaluations"], ParentType, ContextType, RequireFields<QueryEvaluateActionsArgs, "candidates">>;
   findDocuments?: Resolver<ResolversTypes["PHDocumentResultPage"], ParentType, ContextType, Partial<QueryFindDocumentsArgs>>;
   jobStatus?: Resolver<Maybe<ResolversTypes["JobInfo"]>, ParentType, ContextType, RequireFields<QueryJobStatusArgs, "jobId">>;
+  peerAgreement?: Resolver<ResolversTypes["PeerAgreement"], ParentType, ContextType, RequireFields<QueryPeerAgreementArgs, "collectionId">>;
   pollSyncEnvelopes?: Resolver<ResolversTypes["PollSyncEnvelopesResult"], ParentType, ContextType, RequireFields<QueryPollSyncEnvelopesArgs, "channelId" | "outboxAck" | "outboxLatest">>;
+  syncHolds?: Resolver<ReadonlyArray<ResolversTypes["SyncHold"]>, ParentType, ContextType, Partial<QuerySyncHoldsArgs>>;
 }>;
-type ReactorOperationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperation"] = ResolversParentTypes["ReactorOperation"]> = ResolversObject<{
+export type ReactorOperationResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperation"] = ResolversParentTypes["ReactorOperation"]> = ResolversObject<{
   action?: Resolver<ResolversTypes["Action"], ParentType, ContextType>;
   deniedReason?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   error?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
@@ -3075,41 +4015,40 @@ type ReactorOperationResolvers<ContextType = Context, ParentType extends Resolve
   skip?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
   timestampUtcMs?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type ReactorOperationResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperationResultPage"] = ResolversParentTypes["ReactorOperationResultPage"]> = ResolversObject<{
+export type ReactorOperationResultPageResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorOperationResultPage"] = ResolversParentTypes["ReactorOperationResultPage"]> = ResolversObject<{
   cursor?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   hasNextPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   hasPreviousPage?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
   items?: Resolver<ReadonlyArray<ResolversTypes["ReactorOperation"]>, ParentType, ContextType>;
-  totalCount?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
 }>;
-type ReactorSignerResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSigner"] = ResolversParentTypes["ReactorSigner"]> = ResolversObject<{
+export type ReactorSignerResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSigner"] = ResolversParentTypes["ReactorSigner"]> = ResolversObject<{
   app?: Resolver<Maybe<ResolversTypes["ReactorSignerApp"]>, ParentType, ContextType>;
   signatures?: Resolver<ReadonlyArray<ResolversTypes["String"]>, ParentType, ContextType>;
   user?: Resolver<Maybe<ResolversTypes["ReactorSignerUser"]>, ParentType, ContextType>;
 }>;
-type ReactorSignerAppResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerApp"] = ResolversParentTypes["ReactorSignerApp"]> = ResolversObject<{
+export type ReactorSignerAppResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerApp"] = ResolversParentTypes["ReactorSignerApp"]> = ResolversObject<{
   key?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   name?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type ReactorSignerUserResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerUser"] = ResolversParentTypes["ReactorSignerUser"]> = ResolversObject<{
+export type ReactorSignerUserResolvers<ContextType = Context, ParentType extends ResolversParentTypes["ReactorSignerUser"] = ResolversParentTypes["ReactorSignerUser"]> = ResolversObject<{
   address?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
   chainId?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
   networkId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type RemoteCursorResolvers<ContextType = Context, ParentType extends ResolversParentTypes["RemoteCursor"] = ResolversParentTypes["RemoteCursor"]> = ResolversObject<{
+export type RemoteCursorResolvers<ContextType = Context, ParentType extends ResolversParentTypes["RemoteCursor"] = ResolversParentTypes["RemoteCursor"]> = ResolversObject<{
   cursorOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
   lastSyncedAtUtcMs?: Resolver<Maybe<ResolversTypes["String"]>, ParentType, ContextType>;
   remoteName?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type RevisionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Revision"] = ResolversParentTypes["Revision"]> = ResolversObject<{
+export type RevisionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Revision"] = ResolversParentTypes["Revision"]> = ResolversObject<{
   revision?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
   scope?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
 }>;
-type SubscriptionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Subscription"] = ResolversParentTypes["Subscription"]> = ResolversObject<{
+export type SubscriptionResolvers<ContextType = Context, ParentType extends ResolversParentTypes["Subscription"] = ResolversParentTypes["Subscription"]> = ResolversObject<{
   documentChanges?: SubscriptionResolver<ResolversTypes["DocumentChangeEvent"], "documentChanges", ParentType, ContextType, Partial<SubscriptionDocumentChangesArgs>>;
   jobChanges?: SubscriptionResolver<ResolversTypes["JobChangeEvent"], "jobChanges", ParentType, ContextType, RequireFields<SubscriptionJobChangesArgs, "jobId">>;
 }>;
-type SyncEnvelopeResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncEnvelope"] = ResolversParentTypes["SyncEnvelope"]> = ResolversObject<{
+export type SyncEnvelopeResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncEnvelope"] = ResolversParentTypes["SyncEnvelope"]> = ResolversObject<{
   channelMeta?: Resolver<ResolversTypes["ChannelMeta"], ParentType, ContextType>;
   cursor?: Resolver<Maybe<ResolversTypes["RemoteCursor"]>, ParentType, ContextType>;
   dependsOn?: Resolver<Maybe<ReadonlyArray<ResolversTypes["String"]>>, ParentType, ContextType>;
@@ -3117,24 +4056,45 @@ type SyncEnvelopeResolvers<ContextType = Context, ParentType extends ResolversPa
   operations?: Resolver<Maybe<ReadonlyArray<ResolversTypes["OperationWithContext"]>>, ParentType, ContextType>;
   type?: Resolver<ResolversTypes["SyncEnvelopeType"], ParentType, ContextType>;
 }>;
-type TouchChannelResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["TouchChannelResult"] = ResolversParentTypes["TouchChannelResult"]> = ResolversObject<{
+export type SyncHoldResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncHold"] = ResolversParentTypes["SyncHold"]> = ResolversObject<{
+  branch?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  documentId?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  heldAtUtcMs?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  reason?: Resolver<ResolversTypes["SyncHoldReason"], ParentType, ContextType>;
+  remoteName?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+}>;
+export type SyncHoldReasonResolvers<ContextType = Context, ParentType extends ResolversParentTypes["SyncHoldReason"] = ResolversParentTypes["SyncHoldReason"]> = ResolversObject<{
+  peerSupports?: Resolver<ReadonlyArray<ResolversTypes["Int"]>, ParentType, ContextType>;
+  protocol?: Resolver<ResolversTypes["String"], ParentType, ContextType>;
+  version?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+}>;
+export type TouchChannelResultResolvers<ContextType = Context, ParentType extends ResolversParentTypes["TouchChannelResult"] = ResolversParentTypes["TouchChannelResult"]> = ResolversObject<{
   ackOrdinal?: Resolver<ResolversTypes["Int"], ParentType, ContextType>;
+  manifest?: Resolver<Maybe<ResolversTypes["JSONObject"]>, ParentType, ContextType>;
   success?: Resolver<ResolversTypes["Boolean"], ParentType, ContextType>;
 }>;
-type Resolvers<ContextType = Context> = ResolversObject<{
+export type Resolvers<ContextType = Context> = ResolversObject<{
   Action?: ActionResolvers<ContextType>;
   ActionContext?: ActionContextResolvers<ContextType>;
   ActionEvaluation?: ActionEvaluationResolvers<ContextType>;
   ActionEvaluations?: ActionEvaluationsResolvers<ContextType>;
+  BatchExecutionResult?: BatchExecutionResultResolvers<ContextType>;
+  BatchJobResult?: BatchJobResultResolvers<ContextType>;
   ChannelMeta?: ChannelMetaResolvers<ContextType>;
+  ConsistencyCoordinate?: ConsistencyCoordinateResolvers<ContextType>;
+  ConsistencyToken?: ConsistencyTokenResolvers<ContextType>;
+  CreateDefaults?: CreateDefaultsResolvers<ContextType>;
   DateTime?: GraphQLScalarType;
   DeadLetterInfo?: DeadLetterInfoResolvers<ContextType>;
   DocumentChangeContext?: DocumentChangeContextResolvers<ContextType>;
   DocumentChangeEvent?: DocumentChangeEventResolvers<ContextType>;
   DocumentModelGlobalState?: DocumentModelGlobalStateResolvers<ContextType>;
   DocumentModelResultPage?: DocumentModelResultPageResolvers<ContextType>;
+  DocumentRelationship?: DocumentRelationshipResolvers<ContextType>;
+  DocumentRelationshipResultPage?: DocumentRelationshipResultPageResolvers<ContextType>;
   DocumentWithChildren?: DocumentWithChildrenResolvers<ContextType>;
   JSONObject?: GraphQLScalarType;
+  JobBatchMeta?: JobBatchMetaResolvers<ContextType>;
   JobChangeEvent?: JobChangeEventResolvers<ContextType>;
   JobInfo?: JobInfoResolvers<ContextType>;
   MoveRelationshipResult?: MoveRelationshipResultResolvers<ContextType>;
@@ -3143,6 +4103,9 @@ type Resolvers<ContextType = Context> = ResolversObject<{
   OperationWithContext?: OperationWithContextResolvers<ContextType>;
   PHDocument?: PhDocumentResolvers<ContextType>;
   PHDocumentResultPage?: PhDocumentResultPageResolvers<ContextType>;
+  PeerAgreement?: PeerAgreementResolvers<ContextType>;
+  PeerAgreementLimit?: PeerAgreementLimitResolvers<ContextType>;
+  PeerAgreementMember?: PeerAgreementMemberResolvers<ContextType>;
   PollSyncEnvelopesResult?: PollSyncEnvelopesResultResolvers<ContextType>;
   Query?: QueryResolvers<ContextType>;
   ReactorOperation?: ReactorOperationResolvers<ContextType>;
@@ -3154,79 +4117,97 @@ type Resolvers<ContextType = Context> = ResolversObject<{
   Revision?: RevisionResolvers<ContextType>;
   Subscription?: SubscriptionResolvers<ContextType>;
   SyncEnvelope?: SyncEnvelopeResolvers<ContextType>;
+  SyncHold?: SyncHoldResolvers<ContextType>;
+  SyncHoldReason?: SyncHoldReasonResolvers<ContextType>;
   TouchChannelResult?: TouchChannelResultResolvers<ContextType>;
 }>;
-type Properties<T> = Required<{ [K in keyof T]: z$1.ZodType<T[K]> }>;
+type Properties<T> = Required<{ [K in keyof T]: z$1.ZodType<T[K]>; }>;
 type definedNonNullAny = {};
-declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
-declare const definedNonNullAnySchema: z$1.ZodAny & z$1.ZodType<definedNonNullAny, any, z$1.core.$ZodTypeInternals<definedNonNullAny, any>>;
-declare const AuthDecisionSchema: z$1.ZodEnum<typeof AuthDecision>;
-declare const DocumentChangeTypeSchema: z$1.ZodEnum<typeof DocumentChangeType>;
-declare const PropagationModeSchema: z$1.ZodEnum<typeof PropagationMode>;
-declare const SyncEnvelopeTypeSchema: z$1.ZodEnum<typeof SyncEnvelopeType>;
-declare function ActionCandidateInputSchema(): z$1.ZodObject<Properties<ActionCandidateInput>>;
-declare function ActionContextInputSchema(): z$1.ZodObject<Properties<ActionContextInput>>;
-declare function ActionInputSchema(): z$1.ZodObject<Properties<ActionInput>>;
-declare function ChannelMetaInputSchema(): z$1.ZodObject<Properties<ChannelMetaInput>>;
-declare function DocumentOperationsFilterInputSchema(): z$1.ZodObject<Properties<DocumentOperationsFilterInput>>;
-declare function OperationContextInputSchema(): z$1.ZodObject<Properties<OperationContextInput>>;
-declare function OperationInputSchema(): z$1.ZodObject<Properties<OperationInput>>;
-declare function OperationWithContextInputSchema(): z$1.ZodObject<Properties<OperationWithContextInput>>;
-declare function OperationsFilterInputSchema(): z$1.ZodObject<Properties<OperationsFilterInput>>;
-declare function PagingInputSchema(): z$1.ZodObject<Properties<PagingInput>>;
-declare function ReactorSignerAppInputSchema(): z$1.ZodObject<Properties<ReactorSignerAppInput>>;
-declare function ReactorSignerInputSchema(): z$1.ZodObject<Properties<ReactorSignerInput>>;
-declare function ReactorSignerUserInputSchema(): z$1.ZodObject<Properties<ReactorSignerUserInput>>;
-declare function RemoteCursorInputSchema(): z$1.ZodObject<Properties<RemoteCursorInput>>;
-declare function RemoteFilterInputSchema(): z$1.ZodObject<Properties<RemoteFilterInput>>;
-declare function SearchFilterInputSchema(): z$1.ZodObject<Properties<SearchFilterInput>>;
-declare function SyncEnvelopeInputSchema(): z$1.ZodObject<Properties<SyncEnvelopeInput>>;
-declare function TouchChannelInputSchema(): z$1.ZodObject<Properties<TouchChannelInput>>;
-declare function ViewFilterInputSchema(): z$1.ZodObject<Properties<ViewFilterInput>>;
-declare const PhDocumentFieldsFragmentDoc: DocumentNode;
-declare const GetDocumentModelsDocument: DocumentNode;
-declare const GetDocumentDocument: DocumentNode;
-declare const GetDocumentWithOperationsDocument: DocumentNode;
-declare const GetDocumentOutgoingRelationshipsDocument: DocumentNode;
-declare const GetDocumentIncomingRelationshipsDocument: DocumentNode;
-declare const FindDocumentsDocument: DocumentNode;
-declare const GetDocumentOperationsDocument: DocumentNode;
-declare const GetJobStatusDocument: DocumentNode;
-declare const EvaluateActionsDocument: DocumentNode;
-declare const CreateDocumentDocument: DocumentNode;
-declare const CreateEmptyDocumentDocument: DocumentNode;
-declare const MutateDocumentDocument: DocumentNode;
-declare const MutateDocumentAsyncDocument: DocumentNode;
-declare const RenameDocumentDocument: DocumentNode;
-declare const SetPreferredEditorDocument: DocumentNode;
-declare const AddRelationshipDocument: DocumentNode;
-declare const RemoveRelationshipDocument: DocumentNode;
-declare const MoveRelationshipDocument: DocumentNode;
-declare const DeleteDocumentDocument: DocumentNode;
-declare const DeleteDocumentsDocument: DocumentNode;
-declare const DocumentChangesDocument: DocumentNode;
-declare const JobChangesDocument: DocumentNode;
-declare const PollSyncEnvelopesDocument: DocumentNode;
-declare const TouchChannelDocument: DocumentNode;
-declare const PushSyncEnvelopesDocument: DocumentNode;
-type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
-declare function getSdk<C>(requester: Requester<C>): {
+export declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
+export declare const definedNonNullAnySchema: z$1.ZodAny & z$1.ZodType<definedNonNullAny, any, z$1.core.$ZodTypeInternals<definedNonNullAny, any>>;
+export declare const AuthDecisionSchema: z$1.ZodEnum<typeof AuthDecision>;
+export declare const DocumentChangeTypeSchema: z$1.ZodEnum<typeof DocumentChangeType>;
+export declare const PropagationModeSchema: z$1.ZodEnum<typeof PropagationMode>;
+export declare const SyncEnvelopeTypeSchema: z$1.ZodEnum<typeof SyncEnvelopeType>;
+export declare function ActionCandidateInputSchema(): z$1.ZodObject<Properties<ActionCandidateInput>>;
+export declare function ActionContextInputSchema(): z$1.ZodObject<Properties<ActionContextInput>>;
+export declare function ActionInputSchema(): z$1.ZodObject<Properties<ActionInput>>;
+export declare function ChannelMetaInputSchema(): z$1.ZodObject<Properties<ChannelMetaInput>>;
+export declare function DocumentOperationsFilterInputSchema(): z$1.ZodObject<Properties<DocumentOperationsFilterInput>>;
+export declare function ExecutionJobInputSchema(): z$1.ZodObject<Properties<ExecutionJobInput>>;
+export declare function OperationContextInputSchema(): z$1.ZodObject<Properties<OperationContextInput>>;
+export declare function OperationInputSchema(): z$1.ZodObject<Properties<OperationInput>>;
+export declare function OperationWithContextInputSchema(): z$1.ZodObject<Properties<OperationWithContextInput>>;
+export declare function OperationsFilterInputSchema(): z$1.ZodObject<Properties<OperationsFilterInput>>;
+export declare function PagingInputSchema(): z$1.ZodObject<Properties<PagingInput>>;
+export declare function ReactorSignerAppInputSchema(): z$1.ZodObject<Properties<ReactorSignerAppInput>>;
+export declare function ReactorSignerInputSchema(): z$1.ZodObject<Properties<ReactorSignerInput>>;
+export declare function ReactorSignerUserInputSchema(): z$1.ZodObject<Properties<ReactorSignerUserInput>>;
+export declare function RemoteCursorInputSchema(): z$1.ZodObject<Properties<RemoteCursorInput>>;
+export declare function RemoteFilterInputSchema(): z$1.ZodObject<Properties<RemoteFilterInput>>;
+export declare function SearchFilterInputSchema(): z$1.ZodObject<Properties<SearchFilterInput>>;
+export declare function SyncEnvelopeInputSchema(): z$1.ZodObject<Properties<SyncEnvelopeInput>>;
+export declare function SyncRefusalInputSchema(): z$1.ZodObject<Properties<SyncRefusalInput>>;
+export declare function TouchChannelInputSchema(): z$1.ZodObject<Properties<TouchChannelInput>>;
+export declare function ViewFilterInputSchema(): z$1.ZodObject<Properties<ViewFilterInput>>;
+export declare const PhDocumentFieldsFragmentDoc: DocumentNode;
+export declare const DocumentRelationshipFieldsFragmentDoc: DocumentNode;
+export declare const JobInfoFieldsFragmentDoc: DocumentNode;
+export declare const GetDocumentModelsDocument: DocumentNode;
+export declare const GetDocumentDocument: DocumentNode;
+export declare const GetDocumentWithOperationsDocument: DocumentNode;
+export declare const GetDocumentOutgoingRelationshipsDocument: DocumentNode;
+export declare const GetDocumentIncomingRelationshipsDocument: DocumentNode;
+export declare const GetDocumentOutgoingRelationshipEdgesDocument: DocumentNode;
+export declare const GetDocumentIncomingRelationshipEdgesDocument: DocumentNode;
+export declare const FindDocumentsDocument: DocumentNode;
+export declare const GetDocumentOperationsDocument: DocumentNode;
+export declare const GetJobStatusDocument: DocumentNode;
+export declare const GetDocumentServedDocument: DocumentNode;
+export declare const GetCreateDefaultsDocument: DocumentNode;
+export declare const EvaluateActionsDocument: DocumentNode;
+export declare const CreateDocumentDocument: DocumentNode;
+export declare const CreateEmptyDocumentDocument: DocumentNode;
+export declare const MutateDocumentDocument: DocumentNode;
+export declare const MutateDocumentAsyncDocument: DocumentNode;
+export declare const ExecuteBatchDocument: DocumentNode;
+export declare const RenameDocumentDocument: DocumentNode;
+export declare const SetPreferredEditorDocument: DocumentNode;
+export declare const AddRelationshipDocument: DocumentNode;
+export declare const UpdateRelationshipDocument: DocumentNode;
+export declare const RemoveRelationshipDocument: DocumentNode;
+export declare const MoveRelationshipDocument: DocumentNode;
+export declare const DeleteDocumentDocument: DocumentNode;
+export declare const DeleteDocumentsDocument: DocumentNode;
+export declare const DocumentChangesDocument: DocumentNode;
+export declare const JobChangesDocument: DocumentNode;
+export declare const PollSyncEnvelopesDocument: DocumentNode;
+export declare const TouchChannelDocument: DocumentNode;
+export declare const PushSyncEnvelopesDocument: DocumentNode;
+export type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
+export declare function getSdk<C>(requester: Requester<C>): {
   GetDocumentModels(variables?: GetDocumentModelsQueryVariables, options?: C): Promise<GetDocumentModelsQuery>;
   GetDocument(variables: GetDocumentQueryVariables, options?: C): Promise<GetDocumentQuery>;
   GetDocumentWithOperations(variables: GetDocumentWithOperationsQueryVariables, options?: C): Promise<GetDocumentWithOperationsQuery>;
   GetDocumentOutgoingRelationships(variables: GetDocumentOutgoingRelationshipsQueryVariables, options?: C): Promise<GetDocumentOutgoingRelationshipsQuery>;
   GetDocumentIncomingRelationships(variables: GetDocumentIncomingRelationshipsQueryVariables, options?: C): Promise<GetDocumentIncomingRelationshipsQuery>;
+  GetDocumentOutgoingRelationshipEdges(variables: GetDocumentOutgoingRelationshipEdgesQueryVariables, options?: C): Promise<GetDocumentOutgoingRelationshipEdgesQuery>;
+  GetDocumentIncomingRelationshipEdges(variables: GetDocumentIncomingRelationshipEdgesQueryVariables, options?: C): Promise<GetDocumentIncomingRelationshipEdgesQuery>;
   FindDocuments(variables?: FindDocumentsQueryVariables, options?: C): Promise<FindDocumentsQuery>;
   GetDocumentOperations(variables: GetDocumentOperationsQueryVariables, options?: C): Promise<GetDocumentOperationsQuery>;
   GetJobStatus(variables: GetJobStatusQueryVariables, options?: C): Promise<GetJobStatusQuery>;
+  GetDocumentServed(variables: GetDocumentServedQueryVariables, options?: C): Promise<GetDocumentServedQuery>;
+  GetCreateDefaults(variables?: GetCreateDefaultsQueryVariables, options?: C): Promise<GetCreateDefaultsQuery>;
   EvaluateActions(variables: EvaluateActionsQueryVariables, options?: C): Promise<EvaluateActionsQuery>;
   CreateDocument(variables: CreateDocumentMutationVariables, options?: C): Promise<CreateDocumentMutation>;
   CreateEmptyDocument(variables: CreateEmptyDocumentMutationVariables, options?: C): Promise<CreateEmptyDocumentMutation>;
   MutateDocument(variables: MutateDocumentMutationVariables, options?: C): Promise<MutateDocumentMutation>;
   MutateDocumentAsync(variables: MutateDocumentAsyncMutationVariables, options?: C): Promise<MutateDocumentAsyncMutation>;
+  ExecuteBatch(variables: ExecuteBatchMutationVariables, options?: C): Promise<ExecuteBatchMutation>;
   RenameDocument(variables: RenameDocumentMutationVariables, options?: C): Promise<RenameDocumentMutation>;
   SetPreferredEditor(variables: SetPreferredEditorMutationVariables, options?: C): Promise<SetPreferredEditorMutation>;
   AddRelationship(variables: AddRelationshipMutationVariables, options?: C): Promise<AddRelationshipMutation>;
+  UpdateRelationship(variables: UpdateRelationshipMutationVariables, options?: C): Promise<UpdateRelationshipMutation>;
   RemoveRelationship(variables: RemoveRelationshipMutationVariables, options?: C): Promise<RemoveRelationshipMutation>;
   MoveRelationship(variables: MoveRelationshipMutationVariables, options?: C): Promise<MoveRelationshipMutation>;
   DeleteDocument(variables: DeleteDocumentMutationVariables, options?: C): Promise<DeleteDocumentMutation>;
@@ -3237,13 +4218,13 @@ declare function getSdk<C>(requester: Requester<C>): {
   TouchChannel(variables: TouchChannelMutationVariables, options?: C): Promise<TouchChannelMutation>;
   PushSyncEnvelopes(variables: PushSyncEnvelopesMutationVariables, options?: C): Promise<PushSyncEnvelopesMutation>;
 };
-type Sdk = ReturnType<typeof getSdk>;
+export type Sdk = ReturnType<typeof getSdk>;
 //#endregion
 //#region src/graphql/reactor/requester.d.ts
 type FetchLike = (input: URL | string, init: RequestInit) => Promise<Response>;
 //#endregion
 //#region src/graphql/reactor/factory.d.ts
-declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike, headers?: Record<string, string>): {
+export declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike, headers?: Record<string, string>): {
   GetDocumentModels(variables?: Exact<{
     namespace?: InputMaybe<Scalars["String"]["input"]>;
     paging?: InputMaybe<PagingInput>;
@@ -3270,6 +4251,18 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
     view?: InputMaybe<ViewFilterInput>;
     paging?: InputMaybe<PagingInput>;
   }>, options?: {} | undefined): Promise<GetDocumentIncomingRelationshipsQuery>;
+  GetDocumentOutgoingRelationshipEdges(variables: Exact<{
+    sourceIdentifier: Scalars["String"]["input"];
+    relationshipType?: InputMaybe<Scalars["String"]["input"]>;
+    view?: InputMaybe<ViewFilterInput>;
+    paging?: InputMaybe<PagingInput>;
+  }>, options?: {} | undefined): Promise<GetDocumentOutgoingRelationshipEdgesQuery>;
+  GetDocumentIncomingRelationshipEdges(variables: Exact<{
+    targetIdentifier: Scalars["String"]["input"];
+    relationshipType?: InputMaybe<Scalars["String"]["input"]>;
+    view?: InputMaybe<ViewFilterInput>;
+    paging?: InputMaybe<PagingInput>;
+  }>, options?: {} | undefined): Promise<GetDocumentIncomingRelationshipEdgesQuery>;
   FindDocuments(variables?: Exact<{
     search?: InputMaybe<SearchFilterInput>;
     view?: InputMaybe<ViewFilterInput>;
@@ -3282,6 +4275,13 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
   GetJobStatus(variables: Exact<{
     jobId: Scalars["String"]["input"];
   }>, options?: {} | undefined): Promise<GetJobStatusQuery>;
+  GetDocumentServed(variables: Exact<{
+    idOrSlug: Scalars["String"]["input"];
+    view?: InputMaybe<ViewFilterInput>;
+  }>, options?: {} | undefined): Promise<GetDocumentServedQuery>;
+  GetCreateDefaults(variables?: Exact<{
+    parentIdOrSlug?: InputMaybe<Scalars["String"]["input"]>;
+  }> | undefined, options?: {} | undefined): Promise<GetCreateDefaultsQuery>;
   EvaluateActions(variables: Exact<{
     documentIdentifier: Scalars["String"]["input"];
     branch?: InputMaybe<Scalars["String"]["input"]>;
@@ -3305,6 +4305,9 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
     actions: ReadonlyArray<ActionInput>;
     branch?: InputMaybe<Scalars["String"]["input"]>;
   }>, options?: {} | undefined): Promise<MutateDocumentAsyncMutation>;
+  ExecuteBatch(variables: Exact<{
+    jobs: ReadonlyArray<ExecutionJobInput>;
+  }>, options?: {} | undefined): Promise<ExecuteBatchMutation>;
   RenameDocument(variables: Exact<{
     documentIdentifier: Scalars["String"]["input"];
     name: Scalars["String"]["input"];
@@ -3319,8 +4322,16 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
     sourceIdentifier: Scalars["String"]["input"];
     targetIdentifier: Scalars["String"]["input"];
     relationshipType: Scalars["String"]["input"];
+    metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
     branch?: InputMaybe<Scalars["String"]["input"]>;
   }>, options?: {} | undefined): Promise<AddRelationshipMutation>;
+  UpdateRelationship(variables: Exact<{
+    sourceIdentifier: Scalars["String"]["input"];
+    targetIdentifier: Scalars["String"]["input"];
+    relationshipType: Scalars["String"]["input"];
+    metadata?: InputMaybe<Scalars["JSONObject"]["input"]>;
+    branch?: InputMaybe<Scalars["String"]["input"]>;
+  }>, options?: {} | undefined): Promise<UpdateRelationshipMutation>;
   RemoveRelationship(variables: Exact<{
     sourceIdentifier: Scalars["String"]["input"];
     targetIdentifier: Scalars["String"]["input"];
@@ -3353,40 +4364,59 @@ declare function createReactorGraphQLClient(url: string, fetchImpl?: FetchLike,
     channelId: Scalars["String"]["input"];
     outboxAck: Scalars["Int"]["input"];
     outboxLatest: Scalars["Int"]["input"];
+    manifestRevision?: InputMaybe<Scalars["String"]["input"]>;
+    refusals?: InputMaybe<ReadonlyArray<SyncRefusalInput>>;
   }>, options?: {} | undefined): Promise<PollSyncEnvelopesQuery>;
   TouchChannel(variables: Exact<{
     input: TouchChannelInput;
   }>, options?: {} | undefined): Promise<TouchChannelMutation>;
   PushSyncEnvelopes(variables: Exact<{
     envelopes: ReadonlyArray<SyncEnvelopeInput>;
+    peerManifestRevision?: InputMaybe<Scalars["String"]["input"]>;
   }>, options?: {} | undefined): Promise<PushSyncEnvelopesMutation>;
 };
 //#endregion
 //#region src/graphql/reactor/subgraph.d.ts
-declare class ReactorSubgraph extends BaseSubgraph {
+export declare class ReactorSubgraph extends BaseSubgraph {
   #private;
   private logger;
   constructor(args: SubgraphArgs);
   name: string;
   hasSubscriptions: boolean;
+  private get documentChanges();
   /**
    * Check operation-level permissions for an array of actions.
    * Delegates to base assertCanExecuteOperation for each action.
    */
   private assertCanExecuteOperations;
-  typeDefs: graphql.DocumentNode;
+  /**
+   * Drops the relationship edges whose far-end document the caller cannot read.
+   *
+   * An edge names two documents, so returning it discloses the far end's id. The
+   * document-shaped relationship queries already withhold far-end documents the
+   * caller cannot read; the edge-shaped queries have to withhold the same ones,
+   * or they become a way to enumerate around that check. Supreme admins read
+   * everything, so the per-edge check is skipped for them.
+   *
+   * The cursor describes where to resume in the underlying unfiltered stream,
+   * so it is left as it came. A filtered page is therefore often shorter than
+   * the requested limit, and that is the stream continuing rather than a sign
+   * it ended.
+   */
+  private filterRelationshipEdges;
+  typeDefs: import("graphql").DocumentNode;
   resolvers: Resolvers;
   onSetup(): Promise<void>;
 }
 //#endregion
 //#region src/graphql/system/env/index.d.ts
-declare const ADMIN_USERS: string[];
+export declare const ADMIN_USERS: string[];
 //#endregion
 //#region src/graphql/system/subgraph.d.ts
-declare class SystemSubgraph extends BaseSubgraph {
+export declare class SystemSubgraph extends BaseSubgraph {
   name: string;
   hasSubscriptions: boolean;
-  typeDefs: graphql.DocumentNode;
+  typeDefs: import("graphql").DocumentNode;
   resolvers: {
     Query: {
       system: () => {
@@ -3399,28 +4429,85 @@ declare class SystemSubgraph extends BaseSubgraph {
 }
 //#endregion
 //#region src/graphql/system/version.d.ts
-declare function getVersion(): string;
-declare function getGitHash(): string;
-declare function getGitUrl(): string | null;
+export declare function getVersion(): string;
+export declare function getGitHash(): string;
+export declare function getGitUrl(): string | null;
 //#endregion
 //#region src/graphql/utils.d.ts
-declare function isSubgraphClass(candidate: unknown): candidate is SubgraphClass$1;
-declare function buildGraphqlOperations(operations: Operation[], skip: number, first: number): GqlOperation$1[];
-declare function buildGraphqlOperation(operation: Operation): GqlOperation$1;
-declare function buildGraphQlDocument(doc: PHDocument): GqlDocument$1;
-declare function buildGraphQlDriveDocument(doc: DocumentDriveDocument): GqlDriveDocument$1;
+export declare function isSubgraphClass(candidate: unknown): candidate is SubgraphClass$1;
+export declare function buildGraphqlOperations(operations: Operation[], skip: number, first: number): GqlOperation$1[];
+export declare function buildGraphqlOperation(operation: Operation): GqlOperation$1;
+export declare function buildGraphQlDocument(doc: PHDocument): GqlDocument$1;
+export declare function buildGraphQlDriveDocument(doc: DocumentDriveDocument): GqlDriveDocument$1;
+//#endregion
+//#region src/graphql/errors.d.ts
+/** Caller (authenticated or anonymous) lacks permission for the document. */
+export declare class ForbiddenError extends GraphQLError {
+  constructor(detail?: string);
+}
+/** Anonymous caller on an action that requires logging in. */
+export declare class AuthenticationRequiredError extends GraphQLError {
+  constructor(detail?: string);
+}
+/**
+ * The reactor holds no decision model, so no authorization preflight can be
+ * answered.
+ *
+ * Distinct from a denial, and deliberately so: a caller that cannot get a
+ * prediction should render its controls as it did before it asked and let the
+ * submit path refuse. Reading this as a denial would disable every control on a
+ * switchboard running without authEnforcement. The code is what a client
+ * branches on, since the message is not a contract.
+ */
+export declare class AuthEvaluationUnsupportedError extends GraphQLError {
+  constructor();
+}
+/**
+ * A stored operation cannot be represented in the schema, so it is reported
+ * rather than served.
+ *
+ * The schema declares an action's id, type, timestamp, input and scope
+ * non-null; an operation written before the API rejected an action without an
+ * id violates that. Left to the executor, the missing value nullifies the
+ * action, which bubbles up through the non-null chain until it nullifies the
+ * envelope's whole operation list, and the caller receives a partial response
+ * beside "Cannot return null for non-nullable field Action.id" - which says
+ * nothing about which operation, and which a sync client can only read as a
+ * permanent GraphQL rejection, stopping its poll timer for good.
+ *
+ * Thrown instead, with a code that says the failure is worth polling through:
+ * the document holding the operation needs repairing, but the channel serves
+ * every other document, and a peer that stopped polling would stop receiving
+ * those too. The code is what a client branches on, since the message is not a
+ * contract.
+ */
+export declare class MalformedStoredOperationError extends GraphQLError {
+  constructor(detail: string);
+}
+/**
+ * The marker refusals a poll carried were not recorded, so the poll fails.
+ * The code is recoverable: the client keeps polling and reports them again.
+ */
+export declare class RefusalNotRecordedError extends GraphQLError {
+  constructor(cause: unknown);
+}
 //#endregion
 //#region src/packages/import-loader.d.ts
 /**
  * This class is used to load packages using the import keyword.
  */
-declare class ImportPackageLoader implements IPackageLoader {
+export declare class ImportPackageLoader implements IPackageLoader {
+  private readonly hostDir;
   private readonly logger;
   readonly name = "ImportPackageLoader";
+  constructor(hostDir?: string);
+  private readonly reportedUnbuilt;
   loadDocumentModels(identifier: string): Promise<DocumentModelModule[]>;
   loadUpgradeManifests(identifier: string): Promise<UpgradeManifest<readonly number[]>[]>;
   loadSubgraphs(identifier: string): Promise<SubgraphClass$1[]>;
   loadProcessors(identifier: string): Promise<ProcessorFactoryBuilder | null>;
+  loadPieces(identifier: string): Promise<PackagePieceEntry[]>;
+  private reportUnbuilt;
 }
 //#endregion
 //#region src/packages/package-manager.d.ts
@@ -3436,10 +4523,10 @@ declare class ImportPackageLoader implements IPackageLoader {
  * either bare (`'pkg'`) or as a subpath (`'pkg/subgraphs'`), since loaders
  * import sub-entries like `${pkg}/subgraphs` / `${pkg}/document-models`.
  */
-declare function isExpectedLoaderMiss(error: unknown, pkg: string): boolean;
-declare function getUniqueDocumentModels(...documentModels: readonly (readonly DocumentModelModule<any>[])[]): DocumentModelModule[];
-declare function getUniqueUpgradeManifests(...upgradeManifests: readonly (readonly UpgradeManifest<readonly number[]>[])[]): UpgradeManifest<readonly number[]>[];
-declare class PackageManager implements IPackageManager {
+export declare function isExpectedLoaderMiss(error: unknown, pkg: string, subPath?: string): boolean;
+export declare function getUniqueDocumentModels(...documentModels: readonly (readonly DocumentModelModule<any>[])[]): DocumentModelModule[];
+export declare function getUniqueUpgradeManifests(...upgradeManifests: readonly (readonly UpgradeManifest<readonly number[]>[])[]): UpgradeManifest<readonly number[]>[];
+export declare class PackageManager implements IPackageManager {
   protected options: IPackageManagerOptions;
   private readonly logger;
   private loaders;
@@ -3447,6 +4534,7 @@ declare class PackageManager implements IPackageManager {
   private upgradeManifestsMap;
   private subgraphsMap;
   private processorMap;
+  private piecesMap;
   private configWatcher;
   private debouncedUpdateCallbacks;
   private eventEmitter;
@@ -3459,10 +4547,12 @@ declare class PackageManager implements IPackageManager {
   private loadUpgradeManifests;
   private loadSubgraphs;
   private loadProcessors;
+  private loadPieces;
   private maybeWarnAllLoadersFailed;
   private updateDocumentModelsForPackage;
   private updateSubgraphsForPackage;
   private updateProcessorsForPackage;
+  private updatePiecesForPackage;
   /** Debounced per key so repeated subscribePackages calls reuse one timer. */
   private getDebouncedUpdateCallback;
   private subscribePackages;
@@ -3472,6 +4562,9 @@ declare class PackageManager implements IPackageManager {
   private updatePackagesMap;
   private updateSubgraphsMap;
   private updateProcessorsMap;
+  private updatePiecesMap;
+  /** The pieces every loaded package ships, keyed by the package. */
+  getPieces(): Map<string, PackagePieceEntry[]>;
   /**
    * Remove `pkg` from all package maps and emit the change events, tearing
    * down everything the package registered (subgraphs, processors, document
@@ -3482,28 +4575,57 @@ declare class PackageManager implements IPackageManager {
   onDocumentModelsChange(handler: (documentModels: Record<string, DocumentModelModule[]>) => void): void;
   onSubgraphsChange(handler: (subgraphs: Map<string, SubgraphClass$1[]>) => void): void;
   onProcessorsChange(handler: (processors: Map<string, Processor$1>) => void): void;
+  onPiecesChange(handler: (pieces: Map<string, PackagePieceEntry[]>) => void): void;
 }
 //#endregion
+//#region src/packages/subgraph-extraction.d.ts
+/**
+ * The one acceptance rule for a package's `subgraphs` module.
+ *
+ * All three package loaders (vite, import, http) consume the same generated
+ * `subgraphs/index` file, and each used to apply its own rule — the vite
+ * loader required a namespace whose alias equalled the class name inside it,
+ * the http loader took any function one level deep, and the import loader
+ * took every nested value. An export that registered under one loader could
+ * silently vanish under another (the codegen-does-not-register-subgraphs
+ * report). This is now the single rule they all share:
+ *
+ * - an export that is itself a subgraph class is accepted (named or default
+ *   export of the class);
+ * - any subgraph class among the values of an exported object is accepted
+ *   (a `export * as Alias from ...` namespace under any alias, or a
+ *   default-exported object of classes);
+ * - everything else — constants, configs, functions and classes that do not
+ *   extend BaseSubgraph — is dropped.
+ *
+ * Codegen emits `export * as <ClassName> from "./<dir>/index.js"`
+ * (makeSubgraphsIndexFile in packages/codegen), which the namespace branch
+ * accepts regardless of the alias; hand-written packages may re-export a
+ * class directly, which the direct branch accepts. A class reached through
+ * both branches is returned once.
+ */
+export declare function extractSubgraphs(namespace: Record<string, unknown>): SubgraphClass$1[];
+//#endregion
 //#region src/services/renown-config.d.ts
 /** Where the credential check reads from: a remote Renown or Switchboard
  * instance, or this switchboard's own renown read model. */
-type RenownSource = NonNullable<PHReactorRenown["source"]>;
+export type RenownSource = NonNullable<PHReactorRenown["source"]>;
 /** The `auth.renown` config block: which Renown instance to authenticate
  * against, before env overrides are applied. */
-type RenownConfig = PHReactorRenown;
+export type RenownConfig = PHReactorRenown;
 /** Resolved renown coordinates. `url` also drives this reactor's own identity,
  * so it stays meaningful when `source` is "self". */
-type ResolvedRenownConfig = {
+export type ResolvedRenownConfig = {
   source: RenownSource;
   url: string | undefined;
   switchboardUrl: string | undefined;
 };
 /** Reading credentials from this reactor's own read model needs a host-supplied
  * verifier: core has no idea which subgraph serves that read model. */
-declare function assertCredentialVerifierForSource(source: RenownSource, hasVerifier: boolean): void;
+export declare function assertCredentialVerifierForSource(source: RenownSource, hasVerifier: boolean): void;
 /** Resolve `auth.renown`; RENOWN_SOURCE / RENOWN_URL / SWITCHBOARD_URL win
  * over the config file, which wins over the SDK defaults. */
-declare function resolveRenownConfig(configured: RenownConfig | undefined, env: NodeJS.ProcessEnv, logger: ILogger): ResolvedRenownConfig;
+export declare function resolveRenownConfig(configured: RenownConfig | undefined, env: NodeJS.ProcessEnv, logger: ILogger): ResolvedRenownConfig;
 //#endregion
 //#region src/server.d.ts
 type Options = {
@@ -3529,6 +4651,19 @@ type Options = {
      *  request. Off by default; `REQUIRE_AUTHENTICATED_CALLER` overrides.
      *  Requires identity resolution to be on — refused at boot without it. */
     requireAuthenticatedCaller?: boolean;
+    /** Mounted paths that stay reachable anonymously while
+     *  `requireAuthenticatedCaller` is on, for a flow that runs before
+     *  sign-in. Matched against the request's pathname in full, never as a
+     *  prefix. `REQUIRE_AUTHENTICATED_CALLER_EXEMPT_PATHS` overrides, as a
+     *  comma-separated list. Each entry is a hole in the floor: only ever name
+     *  a path serving operations that are safe without a caller. */
+    requireAuthenticatedCallerExemptPaths?: string[];
+    /** Decide an attachment read with the referencing document's own policy
+     *  instead of the host permission tables. Off by default;
+     *  `ATTACHMENT_READS_FOLLOW_DOCUMENT_POLICY` overrides. Requires auth
+     *  enforcement, which is what supplies the model — refused at boot
+     *  without it. */
+    attachmentReadsFollowDocumentPolicy?: boolean;
   };
   /** Renown coordinates the host already resolved, used verbatim instead of
    * resolving `auth.renown` and the env again (which would warn twice). */
@@ -3560,19 +4695,21 @@ type Options = {
    * or os.tmpdir() for in-memory DB deployments.
    */
   attachmentStoragePath?: string;
+  /** Storage health and workflow facts for the inspection subgraph. */
+  inspection?: ReactorInspectionOptions;
 };
 type ProcessorInitializer = ProcessorFactoryBuilder;
 /**
  * Doc-perms require auth: with auth off no `user` is ever resolved, so every
  * authorization check fails closed. Refuse to boot rather than run broken.
  */
-declare function assertAuthRequiredForDocumentPermissions(authEnabled: boolean, documentPermissionsRequested: boolean): void;
+export declare function assertAuthRequiredForDocumentPermissions(authEnabled: boolean, documentPermissionsRequested: boolean): void;
 /**
  * Refuses SKIP_CREDENTIAL_VERIFICATION at boot outside tests or an explicit
  * opt-in: it removes the only binding between a token's claimed address and its
  * signing key. Fail-closed — unset NODE_ENV counts as production.
  */
-declare function assertSkipCredentialVerificationAllowed(resolvesCallerIdentity: boolean, skipCredentialVerification: boolean, env: NodeJS.ProcessEnv): void;
+export declare function assertSkipCredentialVerificationAllowed(resolvesCallerIdentity: boolean, skipCredentialVerification: boolean, env: NodeJS.ProcessEnv): void;
 /**
  * Requiring an authenticated caller requires identity resolution to exist at
  * all: with neither AUTH_ENABLED nor RESOLVE_CALLER_IDENTITY the middleware
@@ -3580,14 +4717,22 @@ declare function assertSkipCredentialVerificationAllowed(resolvesCallerIdentity:
  * require-authenticated-caller middleware would reject every caller —
  * authenticated ones included. Refuse to boot rather than run broken.
  */
-declare function assertRequireAuthenticatedCallerAllowed(requireAuthenticatedCaller: boolean, resolvesCallerIdentity: boolean): void;
+export declare function assertRequireAuthenticatedCallerAllowed(requireAuthenticatedCaller: boolean, resolvesCallerIdentity: boolean, exemptPaths?: readonly string[]): void;
+/**
+ * Deciding an attachment read by the document's policy needs a policy model to
+ * decide with, and that is what auth enforcement supplies. Without one there is
+ * nothing to consult, so the setting would silently leave the permission tables
+ * in charge — configuration that describes a protection the server is not
+ * applying, which is worse than no configuration at all. Refuse instead.
+ */
+export declare function assertAttachmentPolicyReadsAllowed(attachmentReadsFollowDocumentPolicy: boolean, hasDecisionModel: boolean): void;
 /**
  * The GraphiQL explorer page's mount prefix. `path.posix.join` normalizes the
  * join with `basePath` — a naive template literal would produce `//explorer`
  * for the default `/` basePath, which express compiles into a route that only
  * matches `//explorer`, leaving `GET /explorer` a 404.
  */
-declare function getExplorerPrefix(basePath: string): string;
+export declare function getExplorerPrefix(basePath: string): string;
 /**
  * Initializes and starts the API server using an initializer function.
  * This function first loads packages to get document models, then calls the initializer function
@@ -3603,47 +4748,68 @@ declare function getExplorerPrefix(basePath: string): string;
  * alongside the reactor module so resolvers can dispatch reactor-drive parent
  * ops to it; legacy switchboards omit it.
  */
-interface ClientInitializerResult {
+export interface ClientInitializerResult {
   module: InProcessReactorClientModule;
   reactorDriveClient?: IDriveClient;
   attachmentReferenceProjection?: AttachmentReferenceProjectionCapability;
 }
-interface ClientInitializerDependencies {
+export interface ClientInitializerDependencies {
   attachmentReferenceWriter: IAttachmentReferenceWriter;
   /** Upgrade manifests exported by the loaded packages, one per type. */
   upgradeManifests: UpgradeManifest<readonly number[]>[];
 }
-declare function initializeAndStartAPI(clientInitializer: (documentModels: DocumentModelModule[], dependencies: ClientInitializerDependencies) => Promise<ClientInitializerResult>, options: Options, processorApp: ProcessorApp): Promise<API & {
+export declare function initializeAndStartAPI(clientInitializer: (documentModels: DocumentModelModule[], dependencies: ClientInitializerDependencies) => Promise<ClientInitializerResult>, options: Options, processorApp: ProcessorApp): Promise<API & {
   client: IReactorClient;
   syncManager: ISyncManager;
   documentModelRegistry: IDocumentModelRegistry;
   readiness: ReadinessGate;
   attachmentReferenceProjection: AttachmentReferenceProjectionCapability;
   packageManager: PackageManager;
+  /** Set under DOCUMENT_PERMISSIONS; the privacy add-on erases through it. */
+  documentPermissionService: DocumentPermissionService | undefined;
 }>;
 //#endregion
 //#region src/services/renown-credential-verifier.d.ts
-interface RenownCredentialVerifierConfig {
+export interface RenownCredentialVerifierConfig {
   renownUrl?: string;
   switchboardUrl?: string;
 }
-declare function createRenownCredentialVerifier(config?: RenownCredentialVerifierConfig): Promise<CredentialVerifier>;
+export declare function createRenownCredentialVerifier(config?: RenownCredentialVerifierConfig): Promise<CredentialVerifier>;
+//#endregion
+//#region src/services/privacy-permissions.d.ts
+/** One permission row naming an address, as reactor-privacy discloses it. */
+export type PrivacyPermissionRow = {
+  table: string;
+  column: string;
+  documentId: string | null;
+  detail?: Record<string, unknown>;
+};
+/**
+ * reactor-privacy's permission lookup and eraser, over this host's
+ * DocumentPermissionService. Typed structurally on the privacy side.
+ */
+export declare class PrivacyPermissionAdapter {
+  private readonly service;
+  constructor(service: DocumentPermissionService);
+  rowsForAddress(address: string): Promise<PrivacyPermissionRow[]>;
+  erasePermissions(documentId: string): Promise<Record<string, number>>;
+}
 //#endregion
 //#region src/utils/create-schema.d.ts
-declare const buildSubgraphSchemaModule: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => GraphQLSchemaModule;
-declare const createSchema: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => graphql.GraphQLSchema;
+export declare const buildSubgraphSchemaModule: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => GraphQLSchemaModule;
+export declare const createSchema: (documentModels: DocumentModelModule[], resolvers: GraphQLResolverMap<Context$1>, typeDefs: DocumentNode) => import("graphql").GraphQLSchema;
 /**
  * Create a merged GraphQL schema from multiple subgraph modules.
  * Uses buildSubgraphSchema's array overload to combine type definitions
  * and resolvers from multiple subgraphs into a single executable schema.
  */
-declare const createMergedSchema: (modules: GraphQLSchemaModule[]) => graphql.GraphQLSchema;
-declare function getDocumentModelSchemaName(documentModel: DocumentModelGlobalState$1): string;
-declare const getDocumentModelTypeDefs: (documentModels: DocumentModelModule[], typeDefs: DocumentNode) => DocumentNode;
+export declare const createMergedSchema: (modules: GraphQLSchemaModule[]) => import("graphql").GraphQLSchema;
+export declare function getDocumentModelSchemaName(documentModel: DocumentModelGlobalState$1): string;
+export declare const getDocumentModelTypeDefs: (documentModels: DocumentModelModule[], typeDefs: DocumentNode) => DocumentNode;
 /**
  * Options for generating document model GraphQL schemas.
  */
-interface DocumentModelSchemaOptions {
+export interface DocumentModelSchemaOptions {
   /**
    * When true, generates new API patterns:
    * - Mutations return full document objects (MutationResult type)
@@ -3660,7 +4826,8 @@ interface DocumentModelSchemaOptions {
  * @param options - Schema generation options
  * @returns GraphQL DocumentNode
  */
-declare function generateDocumentModelSchema(documentModel: DocumentModelGlobalState$1, options?: DocumentModelSchemaOptions): DocumentNode;
+export declare function generateDocumentModelSchema(documentModel: DocumentModelGlobalState$1, options?: DocumentModelSchemaOptions): DocumentNode;
 //#endregion
-export { ADMIN_USERS, API, Action, ActionCandidateInput, ActionCandidateInputSchema, ActionContext, ActionContextInput, ActionContextInputSchema, ActionContextResolvers, ActionEvaluation, ActionEvaluationResolvers, ActionEvaluations, ActionEvaluationsResolvers, ActionInput, ActionInputSchema, ActionResolvers, AdapterRouteHandle, AddRelationshipDocument, AddRelationshipMutation, AddRelationshipMutationVariables, AnalyticsSubgraph, AttachmentAccessRequest, AttachmentAccessResult, AttachmentAccessService, type AttachmentReferenceProjectionCapability, AuthConfig, AuthContext, AuthDecision, AuthDecisionSchema, AuthFetchMiddleware, AuthService, AuthSubgraph, type AuthorizationConfig, AuthorizationPolicy, AuthorizedDocumentHandle, type AuthorizerResult, BaseSubgraph, CORE_PACKAGE_NAME, type CanonicalDocumentId, CanonicalDocumentIdResolutionError, CanonicalDocumentIdResolver, ChannelMeta, ChannelMetaInput, ChannelMetaInputSchema, ChannelMetaResolvers, ClientInitializerDependencies, ClientInitializerResult, Context, CreateDocumentDocument, CreateDocumentMutation, CreateDocumentMutationVariables, CreateEmptyDocumentDocument, CreateEmptyDocumentMutation, CreateEmptyDocumentMutationVariables, CredentialVerifier, DateTimeScalarConfig, DbClient, DeadLetterInfo, DeadLetterInfoResolvers, DeleteDocumentDocument, DeleteDocumentMutation, DeleteDocumentMutationVariables, DeleteDocumentsDocument, DeleteDocumentsMutation, DeleteDocumentsMutationVariables, DirectiveResolverFn, DocumentChangeContext, DocumentChangeContextResolvers, DocumentChangeEvent, DocumentChangeEventResolvers, DocumentChangeType, DocumentChangeTypeSchema, DocumentChangesDocument, DocumentChangesSubscription, DocumentChangesSubscriptionVariables, DocumentModelGlobalState, DocumentModelGlobalStateResolvers, DocumentModelResultPage, DocumentModelResultPageResolvers, DocumentModelSchemaOptions, DocumentOperationsFilterInput, DocumentOperationsFilterInputSchema, DocumentPermissionConfig, DocumentPermissionDatabase, DocumentPermissionEntry, DocumentPermissionLevel, DocumentPermissionService, DocumentPermissionTable, DocumentProtectionTable, DocumentWithChildren, DocumentWithChildrenResolvers, EvaluateActionsDocument, EvaluateActionsQuery, EvaluateActionsQueryVariables, Exact, ExplorerUrlState, FetchHandler, FindDocumentsDocument, FindDocumentsQuery, FindDocumentsQueryVariables, GatewayAdapterType, GatewayContextFactory, GetDocumentDocument, GetDocumentIncomingRelationshipsDocument, GetDocumentIncomingRelationshipsQuery, GetDocumentIncomingRelationshipsQueryVariables, GetDocumentModelsDocument, GetDocumentModelsQuery, GetDocumentModelsQueryVariables, GetDocumentOperationsDocument, GetDocumentOperationsQuery, GetDocumentOperationsQueryVariables, GetDocumentOutgoingRelationshipsDocument, GetDocumentOutgoingRelationshipsQuery, GetDocumentOutgoingRelationshipsQueryVariables, GetDocumentQuery, GetDocumentQueryVariables, GetDocumentWithOperationsDocument, GetDocumentWithOperationsQuery, GetDocumentWithOperationsQueryVariables, GetJobStatusDocument, GetJobStatusQuery, GetJobStatusQueryVariables, GetParentIdsFn, GqlDocument, GqlDriveDocument, GqlOperation, GqlOperationContext, GqlSigner, GqlSignerApp, GqlSignerUser, GraphQLManager, GraphqlManagerFeatureFlags, HttpAdapterSetup, HttpAdapterType, HttpDocumentModelLoader, HttpMethod, HttpPackageLoader, HttpPackageLoaderLogger, HttpPackageLoaderOptions, HttpRouteService, type HttpRouteServiceOptions, IAttachmentAccessService, type IAuthorizationService, IGatewayAdapter, IHttpAdapter, type IHttpScope, type IPackageLoader, type IPackageLoaderOptions, IPackageStorage, IProcessorHostModule, IReactorProcessorHostModule, ISubgraph, type IWebhookEndpoints, type IWebhookScope, type IWebhookStore, ImportPackageLoader, InMemoryPackageStorage, Incremental, InputMaybe, InstallPackageResult, InstalledPackageInfo, InvalidNamespaceError, IsTypeOfResolverFn, JobChangeEvent, JobChangeEventResolvers, JobChangesDocument, JobChangesSubscription, JobChangesSubscriptionVariables, JobInfo, JobInfoResolvers, JsonObjectScalarConfig, MakeEmpty, MakeMaybe, MakeOptional, Maybe, MemoryWebhookStore, MoveRelationshipDocument, MoveRelationshipMutation, MoveRelationshipMutationVariables, MoveRelationshipResult, MoveRelationshipResultResolvers, MutateDocumentAsyncDocument, MutateDocumentAsyncMutation, MutateDocumentAsyncMutationVariables, MutateDocumentDocument, MutateDocumentMutation, MutateDocumentMutationVariables, Mutation, MutationAddRelationshipArgs, MutationCreateDocumentArgs, MutationCreateEmptyDocumentArgs, MutationDeleteDocumentArgs, MutationDeleteDocumentsArgs, MutationExecuteArgs, MutationExecuteAsyncArgs, MutationMoveRelationshipArgs, MutationMutateDocumentArgs, MutationMutateDocumentAsyncArgs, MutationPushSyncEnvelopesArgs, MutationRemoveRelationshipArgs, MutationRenameDocumentArgs, MutationResolvers, MutationSetPreferredEditorArgs, MutationTouchChannelArgs, NextResolverFn, NodeRouteOptions, type NodeRouteSpec, OperationContext, OperationContextInput, OperationContextInputSchema, OperationContextResolvers, OperationInput, OperationInputSchema, OperationUserPermissionEntry, OperationUserPermissionTable, OperationWithContext, OperationWithContextInput, OperationWithContextInputSchema, OperationWithContextResolvers, OperationsFilterInput, OperationsFilterInputSchema, PACKAGE_ROUTE_SEGMENT, PGLITE_UTC_PARSERS, PackageManagementService, PackageManagementServiceOptions, PackageManager, PackagesSubgraph, type PackagesSubgraphArgs, PagingInput, PagingInputSchema, type ParsedDriveUrl, PgliteFactory, PhDocument, PhDocumentFieldsFragment, PhDocumentFieldsFragmentDoc, PhDocumentOperationsArgs, PhDocumentResolvers, PhDocumentResultPage, PhDocumentResultPageResolvers, PollSyncEnvelopesDocument, PollSyncEnvelopesQuery, PollSyncEnvelopesQueryVariables, PollSyncEnvelopesResult, PollSyncEnvelopesResultResolvers, Processor, ProcessorDriveFactory, ProcessorFactoryBuilder, PropagationMode, PropagationModeSchema, PushSyncEnvelopesDocument, PushSyncEnvelopesMutation, PushSyncEnvelopesMutationVariables, Query, QueryDocumentArgs, QueryDocumentIncomingRelationshipsArgs, QueryDocumentModelsArgs, QueryDocumentOperationsArgs, QueryDocumentOutgoingRelationshipsArgs, QueryEvaluateActionsArgs, QueryFindDocumentsArgs, QueryJobStatusArgs, QueryPollSyncEnvelopesArgs, QueryResolvers, ReactorModule, ReactorOperation, ReactorOperationResolvers, ReactorOperationResultPage, ReactorOperationResultPageResolvers, ReactorSigner, ReactorSignerApp, ReactorSignerAppInput, ReactorSignerAppInputSchema, ReactorSignerAppResolvers, ReactorSignerInput, ReactorSignerInputSchema, ReactorSignerResolvers, ReactorSignerUser, ReactorSignerUserInput, ReactorSignerUserInputSchema, ReactorSignerUserResolvers, ReactorSubgraph, ReadinessGate, RelationalWebhookStore, RemoteCursor, RemoteCursorInput, RemoteCursorInputSchema, RemoteCursorResolvers, RemoteFilterInput, RemoteFilterInputSchema, RemoveRelationshipDocument, RemoveRelationshipMutation, RemoveRelationshipMutationVariables, RenameDocumentDocument, RenameDocumentMutation, RenameDocumentMutationVariables, RenownConfig, RenownCredentialVerifierConfig, RenownSource, Requester, RequireFields, ResolvedRenownConfig, Resolver, ResolverFn, ResolverTypeWrapper, ResolverWithResolve, Resolvers, ResolversObject, ResolversParentTypes, ResolversTypes, Revision, RevisionResolvers, type RouteActor, type RouteAuth, type RouteAuthorizer, type RouteBody, type RouteContext, type RouteHandler, type RouteMethod, type RouteOptions, type RouteSpec, type RouteTransport, type RouteUser, Scalars, type ScopedRouteHandle, Sdk, SearchFilterInput, SearchFilterInputSchema, SetPreferredEditorDocument, SetPreferredEditorMutation, SetPreferredEditorMutationVariables, SubgraphArgs, SubgraphClass, SubgraphDefinition, Subscription, SubscriptionDocumentChangesArgs, SubscriptionJobChangesArgs, SubscriptionObject, SubscriptionResolveFn, SubscriptionResolver, SubscriptionResolverObject, SubscriptionResolvers, SubscriptionSubscribeFn, SubscriptionSubscriberObject, SyncEnvelope, SyncEnvelopeInput, SyncEnvelopeInputSchema, SyncEnvelopeResolvers, SyncEnvelopeType, SyncEnvelopeTypeSchema, SystemSubgraph, TlsOptions, TouchChannelDocument, TouchChannelInput, TouchChannelInputSchema, TouchChannelMutation, TouchChannelMutationVariables, TouchChannelResult, TouchChannelResultResolvers, TypeResolveFn, User, ViewFilterInput, ViewFilterInputSchema, WEBHOOK_SEGMENT, WS_AUTH_CLOSE_REASONS, WS_CLOSE_REASON_AUTHENTICATION_REQUIRED, WS_CLOSE_REASON_BEARER_REJECTED, type WebhookEndpointInfo, type WebhookEndpointRow, type WebhookField, type WebhookHashAlgorithm, type WebhookPolicy, type WebhookReply, type WebhookRequest, type WebhookScheme, WebhookService, type WebhookSignatureEncoding, type WebhookSpec, type WebhookVerification, WithIndex, WsConnectHandler, WsConnection, WsContextFactory, WsDisposer, WsHandlers, assertAuthRequiredForDocumentPermissions, assertCredentialVerifierForSource, assertHostMountPath, assertRequireAuthenticatedCallerAllowed, assertSkipCredentialVerificationAllowed, buildGraphQlDocument, buildGraphQlDriveDocument, buildGraphqlOperation, buildGraphqlOperations, buildSubgraphSchemaModule, createAuthFetchMiddleware, createCanonicalDocumentIdResolver, createGatewayAdapter, createHttpAdapter, createMergedSchema, createReactorGraphQLClient, createRenownCredentialVerifier, createSchema, createWsAuthHandlers, decodeExplorerUrlState, definedNonNullAnySchema, driveIdFromUrl, extractSubgraphsFromModule, generateDocumentModelSchema, getAuthContext, getDbClient, getDocumentModelSchemaName, getDocumentModelTypeDefs, getExplorerPrefix, getGitHash, getGitUrl, getSdk, getUniqueDocumentModels, getUniqueUpgradeManifests, getVersion, initAnalyticsStoreSql, initializeAndStartAPI, isDefinedNonNullAny, isExpectedLoaderMiss, isSubgraphClass, namespacePath, namespaceSegments, newWebhookToken, parseDriveUrl, parseWebhookBody, redactHeaders, renderGraphqlPlayground, resolvePackageName, resolveRenownConfig, verifyWebhook };
+export { type AttachmentReadGate, type AuthorizationConfig, type AuthorizerResult, type CanonicalDocumentId, type HttpRouteServiceOptions, type IAuthorizationService, type IDocumentScopeGate, type IHttpScope, type IPackageLoader, type IPackageLoaderOptions, type IPackagePieceSource, type IReactorInspectionSource, type IWebhookEndpoints, type IWebhookScope, type IWebhookStore, type InspectionCallerGate, type InspectionReadField, type NodeRouteSpec, type PackagePiece, type PackagePieceEntry, type PackagesSubgraphArgs, type ParsedDriveUrl, type ReactorInspectionOptions, type RouteActor, type RouteAuth, type RouteAuthorizer, type RouteBody, type RouteContext, type RouteHandler, type RouteMethod, type RouteOptions, type RouteSpec, type RouteTransport, type RouteUser, type ScopedRouteHandle, type WebhookEndpointInfo, type WebhookEndpointRow, type WebhookField, type WebhookHashAlgorithm, type WebhookPolicy, type WebhookReply, type WebhookRequest, type WebhookScheme, type WebhookSignatureEncoding, type WebhookSpec, type WebhookVerification, driveIdFromUrl, parseDriveUrl };
+export {};
 //# sourceMappingURL=index.d.mts.map