process-graph 1.0.5 → 1.1.0

package/dist/index-DhbvDgK4.d.ts

@@ -0,0 +1,1582 @@
+import { K as OpenIds, a as Overlay, d as Issue, g as Model } from "./index-CmZOswkx.js";
+import { z } from "zod";
+import { ContractRouterClient } from "@orpc/contract";
+import { ContractedRouter } from "@orpc/server";
+//#region ../../core/graph/store-contract/dist/contract.d.ts
+/** The `GraphStore` port: an oRPC router contract, keyed by version. */
+declare const graphStoreContract: {
+  v1: {
+    models: {
+      list: import("@orpc/contract").ProcedureContract<import("@orpc/contract").InitialInputSchema, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        revision: z.ZodInt;
+      }, z.core.$strict>>>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+      save: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        model: z.ZodReadonly<z.ZodObject<{
+          participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+              role: "role";
+              system: "system";
+              entity: "entity";
+            }>;
+          }, z.core.$strict>>>>;
+          events: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            payload: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+          }, z.core.$strict>>>>;
+          actions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+          }, z.core.$strict>>>>;
+          artefacts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            deliverable: z.ZodExactOptional<z.ZodBoolean>;
+          }, z.core.$strict>>>>;
+          elements: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"activity">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            actor: z.ZodExactOptional<z.ZodString>;
+            action: z.ZodExactOptional<z.ZodString>;
+            source: z.ZodExactOptional<z.ZodString>;
+            affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"decision">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            actor: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"state">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            parent: z.ZodExactOptional<z.ZodString>;
+            entry: z.ZodExactOptional<z.ZodString>;
+            exit: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"pseudo">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            role: z.ZodEnum<{
+              initial: "initial";
+              final: "final";
+              fork: "fork";
+              join: "join";
+              history: "history";
+            }>;
+            parent: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"message">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            mode: z.ZodEnum<{
+              sync: "sync";
+              async: "async";
+              reply: "reply";
+              create: "create";
+              destroy: "destroy";
+            }>;
+            event: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>], "kind">>>;
+          transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodString;
+            target: z.ZodString;
+            trigger: z.ZodExactOptional<z.ZodString>;
+            guard: z.ZodExactOptional<z.ZodString>;
+            condition: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+              kind: z.ZodLiteral<"not">;
+              operand: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"and">;
+              left: typeof import("trilean").PredicateNodeSchema;
+              right: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"or">;
+              left: typeof import("trilean").PredicateNodeSchema;
+              right: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"allOf">;
+              operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"anyOf">;
+              operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"compare">;
+              op: z.ZodEnum<{
+                gt: "gt";
+                gte: "gte";
+                lt: "lt";
+                lte: "lte";
+                eq: "eq";
+                neq: "neq";
+              }>;
+              left: typeof import("trilean").ExpressionNodeSchema;
+              right: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"textCompare">;
+              op: z.ZodEnum<{
+                equals: "equals";
+                notEquals: "notEquals";
+                matches: "matches";
+                notMatches: "notMatches";
+                portableMatches: "portableMatches";
+                portableNotMatches: "portableNotMatches";
+              }>;
+              left: typeof import("trilean").ExpressionNodeSchema;
+              right: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"memberOf">;
+              op: z.ZodEnum<{
+                in: "in";
+                notIn: "notIn";
+              }>;
+              operand: typeof import("trilean").ExpressionNodeSchema;
+              candidates: z.ZodArray<typeof import("trilean").ExpressionNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"exists">;
+              operand: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"some">;
+              collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+              item: typeof import("trilean").PredicateNodeSchema;
+              filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"every">;
+              collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+              item: typeof import("trilean").PredicateNodeSchema;
+              filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"treeReference">;
+              key: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+            }, z.core.$strip>], "kind">>;
+            effect: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>>>;
+          fragments: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            operator: z.ZodEnum<{
+              alt: "alt";
+              opt: "opt";
+              loop: "loop";
+              par: "par";
+              break: "break";
+            }>;
+            operands: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              guard: z.ZodExactOptional<z.ZodString>;
+              body: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>>>>;
+          projections: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            notation: z.ZodEnum<{
+              flowchart: "flowchart";
+              swimlane: "swimlane";
+            }>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            notation: z.ZodLiteral<"stateMachine">;
+            subject: z.ZodString;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            notation: z.ZodLiteral<"sequence">;
+            scenario: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+          }, z.core.$strict>>]>>>;
+          views: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodEnum<{
+            flowchart: "flowchart";
+            swimlane: "swimlane";
+            stateMachine: "stateMachine";
+            sequence: "sequence";
+          }> & z.core.$partial, z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodReadonly<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+          }, z.core.$strict>>>>>>>;
+        }, z.core.$strict>>;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodInt;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+      load: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        revision: z.ZodInt;
+        model: z.ZodReadonly<z.ZodObject<{
+          participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+              role: "role";
+              system: "system";
+              entity: "entity";
+            }>;
+          }, z.core.$strict>>>>;
+          events: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            payload: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+          }, z.core.$strict>>>>;
+          actions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+          }, z.core.$strict>>>>;
+          artefacts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            deliverable: z.ZodExactOptional<z.ZodBoolean>;
+          }, z.core.$strict>>>>;
+          elements: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"activity">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            actor: z.ZodExactOptional<z.ZodString>;
+            action: z.ZodExactOptional<z.ZodString>;
+            source: z.ZodExactOptional<z.ZodString>;
+            affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"decision">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            actor: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"state">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            parent: z.ZodExactOptional<z.ZodString>;
+            entry: z.ZodExactOptional<z.ZodString>;
+            exit: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"pseudo">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            role: z.ZodEnum<{
+              initial: "initial";
+              final: "final";
+              fork: "fork";
+              join: "join";
+              history: "history";
+            }>;
+            parent: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"message">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            mode: z.ZodEnum<{
+              sync: "sync";
+              async: "async";
+              reply: "reply";
+              create: "create";
+              destroy: "destroy";
+            }>;
+            event: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>], "kind">>>;
+          transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodString;
+            target: z.ZodString;
+            trigger: z.ZodExactOptional<z.ZodString>;
+            guard: z.ZodExactOptional<z.ZodString>;
+            condition: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+              kind: z.ZodLiteral<"not">;
+              operand: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"and">;
+              left: typeof import("trilean").PredicateNodeSchema;
+              right: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"or">;
+              left: typeof import("trilean").PredicateNodeSchema;
+              right: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"allOf">;
+              operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"anyOf">;
+              operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"compare">;
+              op: z.ZodEnum<{
+                gt: "gt";
+                gte: "gte";
+                lt: "lt";
+                lte: "lte";
+                eq: "eq";
+                neq: "neq";
+              }>;
+              left: typeof import("trilean").ExpressionNodeSchema;
+              right: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"textCompare">;
+              op: z.ZodEnum<{
+                equals: "equals";
+                notEquals: "notEquals";
+                matches: "matches";
+                notMatches: "notMatches";
+                portableMatches: "portableMatches";
+                portableNotMatches: "portableNotMatches";
+              }>;
+              left: typeof import("trilean").ExpressionNodeSchema;
+              right: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"memberOf">;
+              op: z.ZodEnum<{
+                in: "in";
+                notIn: "notIn";
+              }>;
+              operand: typeof import("trilean").ExpressionNodeSchema;
+              candidates: z.ZodArray<typeof import("trilean").ExpressionNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"exists">;
+              operand: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"some">;
+              collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+              item: typeof import("trilean").PredicateNodeSchema;
+              filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"every">;
+              collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+              item: typeof import("trilean").PredicateNodeSchema;
+              filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"treeReference">;
+              key: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+            }, z.core.$strip>], "kind">>;
+            effect: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>>>;
+          fragments: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            operator: z.ZodEnum<{
+              alt: "alt";
+              opt: "opt";
+              loop: "loop";
+              par: "par";
+              break: "break";
+            }>;
+            operands: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              guard: z.ZodExactOptional<z.ZodString>;
+              body: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>>>>;
+          projections: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            notation: z.ZodEnum<{
+              flowchart: "flowchart";
+              swimlane: "swimlane";
+            }>;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            notation: z.ZodLiteral<"stateMachine">;
+            subject: z.ZodString;
+          }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            notation: z.ZodLiteral<"sequence">;
+            scenario: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+          }, z.core.$strict>>]>>>;
+          views: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodEnum<{
+            flowchart: "flowchart";
+            swimlane: "swimlane";
+            stateMachine: "stateMachine";
+            sequence: "sequence";
+          }> & z.core.$partial, z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodReadonly<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+          }, z.core.$strict>>>>>>>;
+        }, z.core.$strict>>;
+        overlay: z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodEnum<{
+          done: "done";
+          open: "open";
+          unknown: "unknown";
+        }>>>;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+      delete: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+      }, z.core.$strict>>, z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+        deleted: z.ZodLiteral<true>;
+        revision: z.ZodInt;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        deleted: z.ZodLiteral<false>;
+      }, z.core.$strict>>]>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+    };
+    overlay: {
+      set: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        overlay: z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodEnum<{
+          done: "done";
+          open: "open";
+          unknown: "unknown";
+        }>>>;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodInt;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+    };
+    items: {
+      upsert: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        items: z.ZodReadonly<z.ZodObject<{
+          participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+              role: "role";
+              system: "system";
+              entity: "entity";
+            }>;
+          }, z.core.$strict>>>>;
+          activities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"activity">;
+            id: z.ZodString;
+            extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+            label: z.ZodString;
+            actor: z.ZodExactOptional<z.ZodString>;
+            action: z.ZodExactOptional<z.ZodString>;
+            affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            source: z.ZodString;
+          }, z.core.$strict>>>>;
+          transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodString;
+            target: z.ZodString;
+            trigger: z.ZodExactOptional<z.ZodString>;
+            guard: z.ZodExactOptional<z.ZodString>;
+            condition: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+              kind: z.ZodLiteral<"not">;
+              operand: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"and">;
+              left: typeof import("trilean").PredicateNodeSchema;
+              right: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"or">;
+              left: typeof import("trilean").PredicateNodeSchema;
+              right: typeof import("trilean").PredicateNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"allOf">;
+              operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"anyOf">;
+              operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"compare">;
+              op: z.ZodEnum<{
+                gt: "gt";
+                gte: "gte";
+                lt: "lt";
+                lte: "lte";
+                eq: "eq";
+                neq: "neq";
+              }>;
+              left: typeof import("trilean").ExpressionNodeSchema;
+              right: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"textCompare">;
+              op: z.ZodEnum<{
+                equals: "equals";
+                notEquals: "notEquals";
+                matches: "matches";
+                notMatches: "notMatches";
+                portableMatches: "portableMatches";
+                portableNotMatches: "portableNotMatches";
+              }>;
+              left: typeof import("trilean").ExpressionNodeSchema;
+              right: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"memberOf">;
+              op: z.ZodEnum<{
+                in: "in";
+                notIn: "notIn";
+              }>;
+              operand: typeof import("trilean").ExpressionNodeSchema;
+              candidates: z.ZodArray<typeof import("trilean").ExpressionNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"exists">;
+              operand: typeof import("trilean").ExpressionNodeSchema;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"some">;
+              collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+              item: typeof import("trilean").PredicateNodeSchema;
+              filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"every">;
+              collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+              item: typeof import("trilean").PredicateNodeSchema;
+              filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+              kind: z.ZodLiteral<"treeReference">;
+              key: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+            }, z.core.$strip>], "kind">>;
+            effect: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>>>>;
+          overlay: z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodEnum<{
+            done: "done";
+            open: "open";
+            unknown: "unknown";
+          }>>>;
+          relations: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodEnum<{
+              "child-of": "child-of";
+              "assigned-to": "assigned-to";
+              "part-of": "part-of";
+            }>;
+            from: z.ZodString;
+            to: z.ZodString;
+          }, z.core.$strict>>>>>;
+        }, z.core.$strict>>;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        revision: z.ZodInt;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+    };
+    relations: {
+      list: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        relations: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+          kind: z.ZodEnum<{
+            "child-of": "child-of";
+            "assigned-to": "assigned-to";
+            "part-of": "part-of";
+          }>;
+          from: z.ZodString;
+          to: z.ZodString;
+        }, z.core.$strict>>>>;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+    };
+    query: {
+      ready: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        elements: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+      blockedChain: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        element: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        chain: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+          element: z.ZodString;
+          distance: z.ZodInt;
+        }, z.core.$strict>>>>;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+      impact: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        element: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        impacted: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+          element: z.ZodString;
+          distance: z.ZodInt;
+        }, z.core.$strict>>>>;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+      children: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        element: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        children: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+      descendants: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        element: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        descendants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+          element: z.ZodString;
+          distance: z.ZodInt;
+        }, z.core.$strict>>>>;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+      ancestors: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        element: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        ancestors: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+          element: z.ZodString;
+          distance: z.ZodInt;
+        }, z.core.$strict>>>>;
+      }, z.core.$strict>>, Omit<{
+        NOT_FOUND: {
+          message: string;
+          data: z.ZodObject<{
+            modelId: z.ZodString;
+            element: z.ZodExactOptional<z.ZodString>;
+          }, z.core.$strict>;
+        };
+        UNPROCESSABLE_CONTENT: {
+          message: string;
+          data: z.ZodObject<{
+            issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+              code: z.ZodString;
+              message: z.ZodString;
+            }, z.core.$strict>>>>;
+          }, z.core.$strict>;
+        };
+      }, never> & object>;
+    };
+    changes: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+      modelId: z.ZodString;
+      since: z.ZodExactOptional<z.ZodInt>;
+    }, z.core.$strict>>, import("@orpc/contract").Schema<AsyncIteratorObject<Readonly<{
+      modelId: string;
+      kind: "overlay" | "saved" | "items" | "deleted";
+      revision: number;
+    }> | Readonly<{
+      modelId: string;
+      kind: "missed";
+    }>, unknown, void>, import("@orpc/server").AsyncIteratorClass<Readonly<{
+      modelId: string;
+      kind: "overlay" | "saved" | "items" | "deleted";
+      revision: number;
+    }> | Readonly<{
+      modelId: string;
+      kind: "missed";
+    }>, unknown, void>>, Omit<{
+      NOT_FOUND: {
+        message: string;
+        data: z.ZodObject<{
+          modelId: z.ZodString;
+          element: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strict>;
+      };
+      UNPROCESSABLE_CONTENT: {
+        message: string;
+        data: z.ZodObject<{
+          issues: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+          }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+      };
+    }, never> & object>;
+  };
+};
+/** A client for the `GraphStore` port over any transport: an in-process router client or one built on an oRPC link. */
+type GraphStoreClient = ContractRouterClient<typeof graphStoreContract>;
+//#endregion
+//#region ../../core/graph/store-contract/dist/schema.d.ts
+/** The name a store files a model under. Any non-empty string; the store gives it no structure. */
+declare const modelIdSchema: z.ZodString;
+/**
+ * A position in the store's history. Every change to any model takes the next revision from one store-wide sequence, so revisions only grow, a model's revision is the revision of its last change, and a model deleted and saved again never reuses an earlier one.
+ */
+declare const revisionSchema: z.ZodInt;
+/**
+ * An activity bound to the external record it stands for. `source` is required here, where the model leaves it optional: a bound item's identity is its source record, and the source-qualified identifier is its element id.
+ */
+declare const boundActivitySchema: z.ZodReadonly<z.ZodObject<{
+  kind: z.ZodLiteral<"activity">;
+  id: z.ZodString;
+  extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+  label: z.ZodString;
+  actor: z.ZodExactOptional<z.ZodString>;
+  action: z.ZodExactOptional<z.ZodString>;
+  affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  source: z.ZodString;
+}, z.core.$strict>>;
+/** The relation kinds a store keeps beside a model, the same kinds a source reports. */
+declare const relationKinds: readonly ["child-of", "assigned-to", "part-of"];
+/**
+ * A structural link the model has no field for, kept beside it: `child-of` from a sub-task element to its parent element, `assigned-to` from an element to a person participant, `part-of` from one participant to the participant that contains it (a repository to its organisation). A relation is identified by its kind and its two ends. Relations carry no ordering, so the structural queries never treat a parent as waiting on its children.
+ */
+declare const relationSchema: z.ZodReadonly<z.ZodObject<{
+  kind: z.ZodEnum<{
+    "child-of": "child-of";
+    "assigned-to": "assigned-to";
+    "part-of": "part-of";
+  }>;
+  from: z.ZodString;
+  to: z.ZodString;
+}, z.core.$strict>>;
+/**
+ * Items read from a source, to be merged into a stored model by identifier. Each participant, activity and transition replaces the one with the same id or is appended after the existing ones; the overlay's entries replace the run state of the elements they name; each relation not already stored is appended. Everything else in the model is left as it is.
+ */
+declare const boundItemsSchema: z.ZodReadonly<z.ZodObject<{
+  participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+      role: "role";
+      system: "system";
+      entity: "entity";
+    }>;
+  }, z.core.$strict>>>>;
+  activities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"activity">;
+    id: z.ZodString;
+    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+    label: z.ZodString;
+    actor: z.ZodExactOptional<z.ZodString>;
+    action: z.ZodExactOptional<z.ZodString>;
+    affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    source: z.ZodString;
+  }, z.core.$strict>>>>;
+  transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+    trigger: z.ZodExactOptional<z.ZodString>;
+    guard: z.ZodExactOptional<z.ZodString>;
+    condition: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"not">;
+      operand: typeof import("trilean").PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"and">;
+      left: typeof import("trilean").PredicateNodeSchema;
+      right: typeof import("trilean").PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"or">;
+      left: typeof import("trilean").PredicateNodeSchema;
+      right: typeof import("trilean").PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"allOf">;
+      operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"anyOf">;
+      operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"compare">;
+      op: z.ZodEnum<{
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        eq: "eq";
+        neq: "neq";
+      }>;
+      left: typeof import("trilean").ExpressionNodeSchema;
+      right: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"textCompare">;
+      op: z.ZodEnum<{
+        equals: "equals";
+        notEquals: "notEquals";
+        matches: "matches";
+        notMatches: "notMatches";
+        portableMatches: "portableMatches";
+        portableNotMatches: "portableNotMatches";
+      }>;
+      left: typeof import("trilean").ExpressionNodeSchema;
+      right: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"memberOf">;
+      op: z.ZodEnum<{
+        in: "in";
+        notIn: "notIn";
+      }>;
+      operand: typeof import("trilean").ExpressionNodeSchema;
+      candidates: z.ZodArray<typeof import("trilean").ExpressionNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"exists">;
+      operand: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"some">;
+      collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+      item: typeof import("trilean").PredicateNodeSchema;
+      filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"every">;
+      collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+      item: typeof import("trilean").PredicateNodeSchema;
+      filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"treeReference">;
+      key: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+    }, z.core.$strip>], "kind">>;
+    effect: z.ZodExactOptional<z.ZodString>;
+  }, z.core.$strict>>>>;
+  overlay: z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodEnum<{
+    done: "done";
+    open: "open";
+    unknown: "unknown";
+  }>>>;
+  relations: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodEnum<{
+      "child-of": "child-of";
+      "assigned-to": "assigned-to";
+      "part-of": "part-of";
+    }>;
+    from: z.ZodString;
+    to: z.ZodString;
+  }, z.core.$strict>>>>>;
+}, z.core.$strict>>;
+/** One stored model and the run state laid over it, at the revision of its last change. */
+declare const storedModelSchema: z.ZodReadonly<z.ZodObject<{
+  modelId: z.ZodString;
+  revision: z.ZodInt;
+  model: z.ZodReadonly<z.ZodObject<{
+    participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      label: z.ZodString;
+      kind: z.ZodEnum<{
+        role: "role";
+        system: "system";
+        entity: "entity";
+      }>;
+    }, z.core.$strict>>>>;
+    events: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      payload: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$strict>>>>;
+    actions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strict>>>>;
+    artefacts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      deliverable: z.ZodExactOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>>;
+    elements: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+      kind: z.ZodLiteral<"activity">;
+      id: z.ZodString;
+      extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+      label: z.ZodString;
+      actor: z.ZodExactOptional<z.ZodString>;
+      action: z.ZodExactOptional<z.ZodString>;
+      source: z.ZodExactOptional<z.ZodString>;
+      affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+      consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+      produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+      kind: z.ZodLiteral<"decision">;
+      id: z.ZodString;
+      extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+      label: z.ZodString;
+      actor: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+      kind: z.ZodLiteral<"state">;
+      id: z.ZodString;
+      extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+      label: z.ZodString;
+      parent: z.ZodExactOptional<z.ZodString>;
+      entry: z.ZodExactOptional<z.ZodString>;
+      exit: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+      kind: z.ZodLiteral<"pseudo">;
+      id: z.ZodString;
+      extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+      role: z.ZodEnum<{
+        initial: "initial";
+        final: "final";
+        fork: "fork";
+        join: "join";
+        history: "history";
+      }>;
+      parent: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+      kind: z.ZodLiteral<"message">;
+      id: z.ZodString;
+      extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+      label: z.ZodString;
+      from: z.ZodString;
+      to: z.ZodString;
+      mode: z.ZodEnum<{
+        sync: "sync";
+        async: "async";
+        reply: "reply";
+        create: "create";
+        destroy: "destroy";
+      }>;
+      event: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strict>>], "kind">>>;
+    transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      source: z.ZodString;
+      target: z.ZodString;
+      trigger: z.ZodExactOptional<z.ZodString>;
+      guard: z.ZodExactOptional<z.ZodString>;
+      condition: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"not">;
+        operand: typeof import("trilean").PredicateNodeSchema;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"and">;
+        left: typeof import("trilean").PredicateNodeSchema;
+        right: typeof import("trilean").PredicateNodeSchema;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"or">;
+        left: typeof import("trilean").PredicateNodeSchema;
+        right: typeof import("trilean").PredicateNodeSchema;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"allOf">;
+        operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"anyOf">;
+        operands: z.ZodArray<typeof import("trilean").PredicateNodeSchema>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"compare">;
+        op: z.ZodEnum<{
+          gt: "gt";
+          gte: "gte";
+          lt: "lt";
+          lte: "lte";
+          eq: "eq";
+          neq: "neq";
+        }>;
+        left: typeof import("trilean").ExpressionNodeSchema;
+        right: typeof import("trilean").ExpressionNodeSchema;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"textCompare">;
+        op: z.ZodEnum<{
+          equals: "equals";
+          notEquals: "notEquals";
+          matches: "matches";
+          notMatches: "notMatches";
+          portableMatches: "portableMatches";
+          portableNotMatches: "portableNotMatches";
+        }>;
+        left: typeof import("trilean").ExpressionNodeSchema;
+        right: typeof import("trilean").ExpressionNodeSchema;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"memberOf">;
+        op: z.ZodEnum<{
+          in: "in";
+          notIn: "notIn";
+        }>;
+        operand: typeof import("trilean").ExpressionNodeSchema;
+        candidates: z.ZodArray<typeof import("trilean").ExpressionNodeSchema>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"exists">;
+        operand: typeof import("trilean").ExpressionNodeSchema;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"some">;
+        collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+        item: typeof import("trilean").PredicateNodeSchema;
+        filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"every">;
+        collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+        item: typeof import("trilean").PredicateNodeSchema;
+        filter: z.ZodOptional<typeof import("trilean").PredicateNodeSchema>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"treeReference">;
+        key: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+      }, z.core.$strip>], "kind">>;
+      effect: z.ZodExactOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
+    fragments: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      operator: z.ZodEnum<{
+        alt: "alt";
+        opt: "opt";
+        loop: "loop";
+        par: "par";
+        break: "break";
+      }>;
+      operands: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        guard: z.ZodExactOptional<z.ZodString>;
+        body: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+      }, z.core.$strict>>>>;
+    }, z.core.$strict>>>>;
+    projections: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      notation: z.ZodEnum<{
+        flowchart: "flowchart";
+        swimlane: "swimlane";
+      }>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      notation: z.ZodLiteral<"stateMachine">;
+      subject: z.ZodString;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+      id: z.ZodString;
+      notation: z.ZodLiteral<"sequence">;
+      scenario: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>]>>>;
+    views: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodEnum<{
+      flowchart: "flowchart";
+      swimlane: "swimlane";
+      stateMachine: "stateMachine";
+      sequence: "sequence";
+    }> & z.core.$partial, z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodReadonly<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strict>>>>>>>;
+  }, z.core.$strict>>;
+  overlay: z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodEnum<{
+    done: "done";
+    open: "open";
+    unknown: "unknown";
+  }>>>;
+}, z.core.$strict>>;
+/** A stored model's name and the revision of its last change. */
+declare const modelSummarySchema: z.ZodReadonly<z.ZodObject<{
+  modelId: z.ZodString;
+  revision: z.ZodInt;
+}, z.core.$strict>>;
+/** An element reached by a traversal and its distance from the start, in transitions. */
+declare const reachSchema: z.ZodReadonly<z.ZodObject<{
+  element: z.ZodString;
+  distance: z.ZodInt;
+}, z.core.$strict>>;
+/** The kinds of change a store reports. */
+declare const changeKinds: readonly ["saved", "overlay", "items", "deleted"];
+/**
+ * A change to a model. `revision` is the revision the change took. `missed` says the subscriber missed one or more changes and should load the model again: it is sent at the start of a subscription that names a revision the model is no longer at (the model changed, or has gone), and in place of the changes a subscriber that reads too slowly has let pile up beyond its subscription's capacity.
+ */
+declare const storeChangeSchema: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+  modelId: z.ZodString;
+  kind: z.ZodEnum<{
+    overlay: "overlay";
+    saved: "saved";
+    items: "items";
+    deleted: "deleted";
+  }>;
+  revision: z.ZodInt;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+  modelId: z.ZodString;
+  kind: z.ZodLiteral<"missed">;
+}, z.core.$strict>>]>;
+/** A structural issue in a model or overlay, as `validate` and `validateOverlay` report it. */
+declare const issueSchema: z.ZodReadonly<z.ZodObject<{
+  code: z.ZodString;
+  message: z.ZodString;
+}, z.core.$strict>>;
+type ModelId = z.infer<typeof modelIdSchema>;
+type Revision = z.infer<typeof revisionSchema>;
+type BoundActivity = z.infer<typeof boundActivitySchema>;
+type BoundItems = z.infer<typeof boundItemsSchema>;
+type Relation = z.infer<typeof relationSchema>;
+type RelationKind = (typeof relationKinds)[number];
+type StoredModel = z.infer<typeof storedModelSchema>;
+type ModelSummary = z.infer<typeof modelSummarySchema>;
+type Reach = z.infer<typeof reachSchema>;
+type ChangeKind = (typeof changeKinds)[number];
+type StoreChange = z.infer<typeof storeChangeSchema>;
+//#endregion
+//#region ../../core/graph/store-contract/dist/errors.d.ts
+/** Why a store operation failed, as data. */
+type GraphStoreFailure = {
+  /** The model does not exist, or `element` is not one of its elements. */
+  readonly kind: "not-found";
+  readonly modelId: string;
+  readonly element?: string;
+} | {
+  /** The change would leave the model or its overlay invalid, as `validate` and `validateOverlay` report it; nothing was written. */
+  readonly kind: "invalid";
+  readonly issues: readonly Issue[];
+};
+/**
+ * The one error a `GraphStore` implementation throws for an expected failure. `createGraphStoreRouter` turns it into the contract's typed oRPC error, so every store reports failures the same way over every transport.
+ */
+declare class GraphStoreError extends Error {
+  /** What went wrong. */
+  readonly failure: GraphStoreFailure;
+  /**
+   * @param failure - What went wrong.
+   */
+  constructor(failure: GraphStoreFailure);
+}
+//#endregion
+//#region ../../core/graph/store-contract/dist/feed.d.ts
+/** A live subscription to one model's changes. Iterate it to receive them; `close` ends it. */
+interface ChangeSubscription extends AsyncIterable<StoreChange> {
+  /** Stops delivery and ends the iteration. Idempotent. */
+  readonly close: () => void;
+}
+/**
+ * How many undelivered changes a subscription holds by default before it collapses them into `missed`.
+ *
+ * A change tells a subscriber only that its model has moved on to a later revision, and the one thing a subscriber can do about it is read the model again. A subscriber that has not yet taken one pending change will read the model after that change, and the model it reads already reflects every later one, so a second pending change gives it nothing it could act on: one held change is all a lagging subscriber can use. A subscriber that is waiting when a change commits receives it directly and never touches the buffer, so a subscriber that keeps reading misses nothing at this capacity.
+ */
+declare const defaultSubscriptionCapacity = 1;
+/** Options for one subscription. */
+interface SubscribeOptions {
+  /** Ends the subscription when it fires. */
+  readonly signal?: AbortSignal | undefined;
+  /** Overrides the feed's capacity for this subscription; see `ChangeFeedOptions.capacity`. */
+  readonly capacity?: number;
+}
+/** Options for a feed. */
+interface ChangeFeedOptions {
+  /**
+   * The most undelivered changes a subscription holds; `defaultSubscriptionCapacity` when absent. When a change arrives and the subscription already holds this many, every held change is dropped and replaced by one `missed` event, so the buffer never grows past the capacity and the subscriber knows to load the model again. A positive integer.
+   */
+  readonly capacity?: number;
+}
+/**
+ * Fans the changes one store makes out to every subscriber of the model they touch. A store publishes after each committed write; the router reads a subscription for `changes`.
+ *
+ * A subscription is registered the moment `subscribe` returns, so a caller can subscribe first and then read the current revision without missing a change made in between. A change that arrives while the subscriber is waiting is handed straight to it; one that arrives while it is busy is held, up to the subscription's capacity. Past that, the held changes are replaced by a single `missed` event: memory stays bounded however slowly a subscriber reads, and a subscriber is never left unaware that it fell behind.
+ *
+ * A feed only sees the writes made through the store that owns it. Several processes or tabs writing to one database each need their own bridge (a `BroadcastChannel`, a database notification) that publishes the others' changes into their feed.
+ */
+declare class ChangeFeed {
+  #private;
+  /**
+   * @param options - The capacity every subscription gets unless it sets its own.
+   * @throws RangeError when the capacity is not a positive integer.
+   */
+  constructor(options?: ChangeFeedOptions);
+  /**
+   * Delivers a change to every current subscriber of its model.
+   * @param change - The change, after it is committed.
+   */
+  publish(change: StoreChange): void;
+  /**
+   * Subscribes to one model's changes from now on.
+   * @param modelId - The model to follow.
+   * @param options - The signal that ends it, and a capacity overriding the feed's.
+   * @returns The live subscription.
+   * @throws RangeError when the capacity is not a positive integer.
+   */
+  subscribe(modelId: string, options?: SubscribeOptions): ChangeSubscription;
+}
+//#endregion
+//#region ../../core/graph/store-contract/dist/store.d.ts
+/** What every store request carries: the model it is about and the caller's abort signal. */
+interface ModelRequest {
+  readonly modelId: string;
+  /** Fires when the caller gives up. A write checks it before committing, so an aborted write changes nothing. */
+  readonly signal: AbortSignal | undefined;
+}
+/** A request about one element of a model. */
+interface ElementRequest extends ModelRequest {
+  readonly element: string;
+}
+/**
+ * What a store adapter implements. `createGraphStoreRouter` builds the whole port on it, so validation, error mapping, abort handling and change subscriptions behave identically for every store.
+ *
+ * Every write is atomic: it checks the result with `checkStored` (and `relationIssues` for the relations it stores) and throws `GraphStoreError` with `invalid` before anything is visible, takes the next store-wide revision, and publishes the change to `feed` after it commits. A read or query of a model that does not exist, or of an element the model does not declare, throws `GraphStoreError` with `not-found`.
+ */
+interface GraphStore {
+  /** The feed this store publishes its committed changes to. */
+  readonly feed: ChangeFeed;
+  /**
+   * Lists the stored models.
+   * @returns Every model's id and revision, ordered by id.
+   */
+  readonly listModels: (request: {
+    readonly signal: AbortSignal | undefined;
+  }) => Promise<readonly ModelSummary[]>;
+  /**
+   * Stores a model under an id, replacing any model stored there and dropping the run state and relations of what the new model does not declare (see `relationsWithin`).
+   * @returns The revision the save took.
+   */
+  readonly saveModel: (request: ModelRequest & {
+    readonly model: Model<OpenIds>;
+  }) => Promise<Revision>;
+  /**
+   * Reads a model back exactly as saved or merged, in its declared order, with its run state.
+   * @returns The model, its overlay and its revision.
+   */
+  readonly loadModel: (request: ModelRequest) => Promise<StoredModel>;
+  /**
+   * Removes a model, its run state and its relations.
+   * @returns The revision the deletion took, or `undefined` when there was no such model and nothing changed.
+   */
+  readonly deleteModel: (request: ModelRequest) => Promise<Revision | undefined>;
+  /**
+   * Sets the run state of the elements an overlay names, leaving the others as they are.
+   * @returns The revision the change took.
+   */
+  readonly applyOverlay: (request: ModelRequest & {
+    readonly overlay: Overlay<OpenIds>;
+  }) => Promise<Revision>;
+  /**
+   * Merges items read from a source into a model by id (see `mergeBoundItems`), and adds their relations (see `mergeRelations`), creating the model from an empty one when it does not exist. Every relation stored must name what the merged model declares (`relationIssues`); otherwise nothing is written.
+   * @returns The revision the change took.
+   */
+  readonly upsertItems: (request: ModelRequest & {
+    readonly items: BoundItems;
+  }) => Promise<Revision>;
+  /**
+   * The relations kept beside a model.
+   * @returns The relations, in the order they were first stored.
+   */
+  readonly relations: (request: ModelRequest) => Promise<readonly Relation[]>;
+  /**
+   * The direct children of an element (see `childrenOf`).
+   * @returns The children, in model order.
+   */
+  readonly children: (request: ElementRequest) => Promise<readonly string[]>;
+  /**
+   * Everything beneath an element along `child-of` relations (see `descendantsOf`).
+   * @returns The descendants, by distance and then model order.
+   */
+  readonly descendants: (request: ElementRequest) => Promise<readonly Reach[]>;
+  /**
+   * Everything above an element along `child-of` relations (see `ancestorsOf`).
+   * @returns The ancestors, by distance and then model order.
+   */
+  readonly ancestors: (request: ElementRequest) => Promise<readonly Reach[]>;
+  /**
+   * The work that can start now (see `readyOf`).
+   * @returns The ready elements, in model order.
+   */
+  readonly ready: (request: ModelRequest) => Promise<readonly string[]>;
+  /**
+   * The unfinished work upstream of an element (see `blockedChainOf`).
+   * @returns The chain, by distance and then model order.
+   */
+  readonly blockedChain: (request: ElementRequest) => Promise<readonly Reach[]>;
+  /**
+   * The unfinished work downstream of an element (see `impactOf`).
+   * @returns The impacted elements, by distance and then model order.
+   */
+  readonly impact: (request: ElementRequest) => Promise<readonly Reach[]>;
+  /**
+   * The revision of a model's last change.
+   * @returns The revision, or `undefined` when there is no such model.
+   */
+  readonly revisionOf: (request: ModelRequest) => Promise<Revision | undefined>;
+}
+//#endregion
+//#region ../../core/graph/store-contract/dist/merge.d.ts
+/** A model with nothing in it, which `items.upsert` starts from when the model does not exist yet. */
+declare const emptyModel: Model<OpenIds>;
+/**
+ * Merges items read from a source into a model and its overlay: participants, activities and transitions by id, replacing a record in its place or appending a new one; overlay entries replace the run state of the elements they name. The result is not checked; see `checkStored`.
+ * @param model - The stored model.
+ * @param overlay - The stored overlay.
+ * @param items - The items to merge.
+ * @returns The merged model and overlay.
+ */
+declare const mergeBoundItems: (model: Model<OpenIds>, overlay: Overlay<OpenIds>, items: BoundItems) => {
+  readonly model: Model<OpenIds>;
+  readonly overlay: Overlay<OpenIds>;
+};
+/**
+ * Keeps only the overlay entries that name an element of the model, so replacing a model drops the run state of elements it no longer declares.
+ * @param model - The model the overlay is for.
+ * @param overlay - The overlay to narrow.
+ * @returns The entries whose key is an element of `model`.
+ */
+declare const overlayWithin: (model: Model<OpenIds>, overlay: Overlay<OpenIds>) => Overlay<OpenIds>;
+/**
+ * Checks a model and overlay a write is about to store. Every store runs this before committing, so a store never holds a model `validate` rejects or an overlay entry for an element the model does not declare.
+ * @param model - The model to store.
+ * @param overlay - The overlay to store with it.
+ * @throws GraphStoreError with `invalid` and every issue found, when there is any.
+ */
+declare const checkStored: (model: Model<OpenIds>, overlay: Overlay<OpenIds>) => void;
+//#endregion
+//#region ../../core/graph/store-contract/dist/hierarchy.d.ts
+/**
+ * Adds relations to a stored list: one already there is kept in its place, and a new one is appended in its incoming order, each distinct relation once.
+ * @param current - The stored relations.
+ * @param incoming - The relations to add.
+ * @returns The merged relations.
+ */
+declare const mergeRelations: (current: readonly Relation[], incoming: readonly Relation[]) => readonly Relation[];
+/**
+ * Keeps only the relations both of whose ends the model still declares, in the space their kind names, so replacing a model drops the relations of what it no longer has.
+ * @param model - The model the relations are for.
+ * @param relations - The relations to narrow.
+ * @returns The relations whose ends are both declared.
+ */
+declare const relationsWithin: (model: Model<OpenIds>, relations: readonly Relation[]) => readonly Relation[];
+/**
+ * The issues with a model's relations: an end that names nothing the model declares in the space its kind requires is an `unknown-reference`, as an unknown reference anywhere else in a model is.
+ * @param model - The model the relations are for.
+ * @param relations - The relations to check.
+ * @returns One issue per end that names nothing, empty when every end resolves.
+ */
+declare const relationIssues: (model: Model<OpenIds>, relations: readonly Relation[]) => readonly Issue[];
+/**
+ * The direct children of an element: every element related to it by `child-of`.
+ * @param model - The model, which declares `element`.
+ * @param relations - The model's relations.
+ * @param element - The parent.
+ * @returns The children, in model order.
+ */
+declare const childrenOf: (model: Model<OpenIds>, relations: readonly Relation[], element: string) => readonly string[];
+/**
+ * Everything beneath an element: its children, their children and so on, each with the fewest `child-of` steps between them.
+ * @param model - The model, which declares `element`.
+ * @param relations - The model's relations.
+ * @param element - The element at the top.
+ * @returns The descendants, by distance and then model order.
+ */
+declare const descendantsOf: (model: Model<OpenIds>, relations: readonly Relation[], element: string) => readonly Reach[];
+/**
+ * Everything above an element: its parents, their parents and so on, nearest first.
+ * @param model - The model, which declares `element`.
+ * @param relations - The model's relations.
+ * @param element - The element at the bottom.
+ * @returns The ancestors, by distance and then model order.
+ */
+declare const ancestorsOf: (model: Model<OpenIds>, relations: readonly Relation[], element: string) => readonly Reach[];
+//#endregion
+//#region ../../core/graph/store-contract/dist/structure.d.ts
+/**
+ * The structural view of a stored model that the store's queries read: its elements in model order, its transitions without the loop edges `graph-domain` identifies, and its run state.
+ */
+interface Structure {
+  readonly order: ReadonlyMap<string, number>;
+  readonly control: ReadonlySet<string>;
+  readonly done: ReadonlySet<string>;
+  readonly open: ReadonlySet<string>;
+  readonly upstream: ReadonlyMap<string, readonly string[]>;
+  readonly downstream: ReadonlyMap<string, readonly string[]>;
+}
+/**
+ * Builds the structural view of a model and its overlay.
+ * @param model - A valid model.
+ * @param overlay - Its run state.
+ * @returns The view the queries below read.
+ */
+declare const structureOf: (model: Model<OpenIds>, overlay: Overlay<OpenIds>) => Structure;
+/**
+ * What still stands before an element: the unfinished work upstream of it. An element that is done waits on nothing.
+ * @param structure - The structural view.
+ * @param element - An element of the model.
+ * @returns The upstream elements that are not done and are not control elements, by distance and then model order.
+ */
+declare const blockedChainOf: (structure: Structure, element: string) => readonly Reach[];
+/**
+ * What depends on an element: the unfinished work downstream of it, whatever the element's own state.
+ * @param structure - The structural view.
+ * @param element - An element of the model.
+ * @returns The downstream elements that are not done and are not control elements, by distance and then model order.
+ */
+declare const impactOf: (structure: Structure, element: string) => readonly Reach[];
+/**
+ * The work that can start now: every open element (no run state, or `open`) that is not a control element and has nothing unfinished upstream.
+ * @param structure - The structural view.
+ * @returns The ready elements, in model order.
+ */
+declare const readyOf: (structure: Structure) => readonly string[];
+//#endregion
+//#region ../../core/graph/store-contract/dist/router.d.ts
+/**
+ * Builds the `GraphStore` router over a store. Serve it over any oRPC transport, or call it in process with `createRouterClient`.
+ *
+ * `changes` subscribes to the store's feed before it reads the model's revision and before it returns, so no change is lost between the two, and a caller holding the iterator is already subscribed. When the caller names a revision `since` and the model is no longer at it, the first event is `missed`; every later change follows as it commits.
+ * @param store - The adapter.
+ * @returns The implemented router for `graphStoreContract`.
+ */
+declare const createGraphStoreRouter: (store: GraphStore) => GraphStoreRouter;
+/** The router `createGraphStoreRouter` builds: every procedure of `graphStoreContract`, needing no initial context. */
+type GraphStoreRouter = ContractedRouter<typeof graphStoreContract, object>;
+//#endregion
+//#region ../../core/graph/store-contract/dist/fake.d.ts
+/**
+ * The reference in-memory store: the behaviour every adapter's conformance run is compared with. Models are held as values and replaced on every write, so a failed check leaves the previous value in place.
+ * @returns A store with no models, revisions starting after zero.
+ */
+declare const createFakeGraphStore: () => GraphStore;
+//#endregion
+export { graphStoreContract as $, BoundItems as A, boundActivitySchema as B, ChangeFeedOptions as C, GraphStoreError as D, defaultSubscriptionCapacity as E, Relation as F, modelSummarySchema as G, changeKinds as H, RelationKind as I, relationSchema as J, reachSchema as K, Revision as L, ModelId as M, ModelSummary as N, GraphStoreFailure as O, Reach as P, GraphStoreClient as Q, StoreChange as R, ChangeFeed as S, SubscribeOptions as T, issueSchema as U, boundItemsSchema as V, modelIdSchema as W, storeChangeSchema as X, revisionSchema as Y, storedModelSchema as Z, mergeBoundItems as _, blockedChainOf as a, GraphStore as b, structureOf as c, descendantsOf as d, mergeRelations as f, emptyModel as g, checkStored as h, Structure as i, ChangeKind as j, BoundActivity as k, ancestorsOf as l, relationsWithin as m, GraphStoreRouter as n, impactOf as o, relationIssues as p, relationKinds as q, createGraphStoreRouter as r, readyOf as s, createFakeGraphStore as t, childrenOf as u, overlayWithin as v, ChangeSubscription as w, ModelRequest as x, ElementRequest as y, StoredModel as z };