process-graph 1.1.0 → 1.2.0

package/dist/{index-CCfe0csl.d.ts → index-BH1aFqkJ.d.ts}

@@ -1,5 +1,5 @@
 import { G as IdSpace, a as Overlay, g as Model } from "./index-CmZOswkx.js";
-import { JsonValue, Resolution } from "trilean";
+import { ComputedValue, ExpressionNode, JsonValue, PredicateNode, Resolution } from "trilean";
 //#region ../../core/graph/domain/dist/status.d.ts
 /** The derived states of an element, in the order the derivation considers them. */
 declare const statuses: readonly ["done", "unknown", "skipped", "ready", "blocked"];
@@ -41,6 +41,37 @@ declare const elementStatusKey: (id: string) => JsonValue;
  * @returns The key the port is asked.
  */
 declare const artefactKey: (id: string) => JsonValue;
+/**
+ * What is known from outside the process about one run, as plain data a store can keep: which artefacts are provided, and the values of named facts that conditions read.
+ *
+ * Each part is three-valued by presence. An artefact mapped to `true` is provided and one mapped to `false` is known not to be; an artefact the record does not name is unknown, which `isProvided` treats as not provided but a condition reading `artefactKey` sees as indeterminate. A named fact holds a trilean value; a name the record does not hold is unknown, so a condition reading it is indeterminate.
+ */
+interface FactRecord {
+  /** The artefacts whose provision is known, by artefact id. */
+  readonly artefacts: Readonly<Record<string, boolean>>;
+  /** The values of named facts, by the name a condition's `reference` node gives as its key. */
+  readonly values: Readonly<Record<string, ComputedValue>>;
+}
+/** A record that knows nothing: no artefact is provided and every named fact is unknown. */
+declare const emptyFactRecord: FactRecord;
+/**
+ * Adapts a fact record to the `Facts` port. A string key is a named fact, answered with its value when the record holds it; a key built by `artefactKey` is answered with the boolean the record holds for that artefact; every other key, and any name or artefact the record does not hold, is not found.
+ * @param record - What is known.
+ * @returns A `Facts` port reading the record.
+ */
+declare const factsFrom: (record: FactRecord) => Facts;
+/**
+ * The named facts a condition reads: the string key of every `reference` node in it, each once, in the order first met walking the tree depth first. Reserved keys and other non-string keys are not names, so they are left out, and a reference's own key is never searched for further references.
+ * @param condition - A trilean predicate or expression, such as a transition's `condition`.
+ * @returns The names, each once.
+ */
+declare const factNamesIn: (condition: PredicateNode | ExpressionNode) => readonly string[];
+/**
+ * Layers facts ports: each key is answered by the first port that finds it, so an earlier port overrides a later one only where it knows the answer.
+ * @param ports - The ports, most authoritative first.
+ * @returns A `Facts` port that is not found only when no port finds the key.
+ */
+declare const layeredFacts: (...ports: readonly Facts[]) => Facts;
 /**
  * Thrown when a condition uses a node whose evaluation needs a table or a collection from the facts port, which answers single keys only.
  */
@@ -350,4 +381,4 @@ interface UnmetOutput<I extends IdSpace> {
  */
 declare const unmetOutputs: <I extends IdSpace>(model: Model<I>, overlay: Readonly<Overlay<I>>, facts: Facts) => readonly UnmetOutput<I>[];
 //#endregion
-export { UnsupportedConditionError as A, CriticalPath as C, UnknownReference as D, NodeId as E, Status as F, statuses as I, elementStatusKey as M, evaluateBranches as N, buildDag as O, Branch as P, loopTransitions as S, Dag as T, StatusRule as _, criticalPath as a, controlDag as b, unmetOutputs as c, StatusExplanation as d, explainStatus as f, StatusBasis as g, ProducerBasis as h, blockedBy as i, artefactKey as j, Facts as k, whatIfDone as l, IncomingBasis as m, UnmetOutput as n, impact as o, ArtefactBasis as p, WhatIf as r, readySet as s, StatusChange as t, ChainLink as u, deriveStatuses as v, criticalPath$1 as w, illegalCycles as x, statusRules as y };
+export { Facts as A, Status as B, CriticalPath as C, UnknownReference as D, NodeId as E, evaluateBranches as F, factNamesIn as I, factsFrom as L, artefactKey as M, elementStatusKey as N, buildDag as O, emptyFactRecord as P, layeredFacts as R, loopTransitions as S, Dag as T, statuses as V, StatusRule as _, criticalPath as a, controlDag as b, unmetOutputs as c, StatusExplanation as d, explainStatus as f, StatusBasis as g, ProducerBasis as h, blockedBy as i, UnsupportedConditionError as j, FactRecord as k, whatIfDone as l, IncomingBasis as m, UnmetOutput as n, impact as o, ArtefactBasis as p, WhatIf as r, readySet as s, StatusChange as t, ChainLink as u, deriveStatuses as v, criticalPath$1 as w, illegalCycles as x, statusRules as y, Branch as z };

package/dist/{index-DricKcyl.d.ts → index-BUheRLdG.d.ts}

@@ -1,6 +1,6 @@
-import { C as CriticalPath, F as Status, _ as StatusRule, d as StatusExplanation, k as Facts, u as ChainLink } from "./index-CCfe0csl.js";
+import { A as Facts, B as Status, C as CriticalPath, _ as StatusRule, d as StatusExplanation, u as ChainLink } from "./index-BH1aFqkJ.js";
 import { G as IdSpace, O as Projection, a as Overlay, g as Model, x as Element } from "./index-CmZOswkx.js";
-import { Q as GraphStoreClient, z as StoredModel } from "./index-DhbvDgK4.js";
+import { K as StoredModel, ut as GraphStoreClient } from "./index-DxWOY8f9.js";
 import { A as Flowchart, E as Swimlane, g as SequenceDiagram, x as StateMachine } from "./index-CoA6vXqe.js";
 import { KeyboardEvent, ReactElement, ReactNode, RefCallback } from "react";
 //#region ../../ui/graph/react/dist/run.d.ts

package/dist/{index-DhbvDgK4.d.ts → index-DxWOY8f9.d.ts}

@@ -1,3 +1,4 @@
+import { k as FactRecord } from "./index-BH1aFqkJ.js";
 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";
@@ -440,6 +441,38 @@ declare const graphStoreContract: {
           open: "open";
           unknown: "unknown";
         }>>>;
+        facts: z.ZodReadonly<z.ZodObject<{
+          artefacts: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+          values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"number">;
+            value: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            value: z.ZodString;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"boolean">;
+            value: z.ZodBoolean;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"instant">;
+            value: z.ZodString;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"duration">;
+            value: z.ZodNumber;
+            unit: z.ZodEnum<{
+              ms: "ms";
+              s: "s";
+              min: "min";
+              h: "h";
+              d: "d";
+            }>;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"complex">;
+            re: z.ZodNumber;
+            im: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+          }, z.core.$strip>], "kind">>>;
+        }, z.core.$strict>>;
       }, z.core.$strict>>, Omit<{
         NOT_FOUND: {
           message: string;
@@ -513,6 +546,145 @@ declare const graphStoreContract: {
         };
       }, never> & object>;
     };
+    facts: {
+      read: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+      }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        revision: z.ZodInt;
+        facts: z.ZodReadonly<z.ZodObject<{
+          artefacts: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+          values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"number">;
+            value: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            value: z.ZodString;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"boolean">;
+            value: z.ZodBoolean;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"instant">;
+            value: z.ZodString;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"duration">;
+            value: z.ZodNumber;
+            unit: z.ZodEnum<{
+              ms: "ms";
+              s: "s";
+              min: "min";
+              h: "h";
+              d: "d";
+            }>;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"complex">;
+            re: z.ZodNumber;
+            im: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+          }, z.core.$strip>], "kind">>>;
+        }, 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>;
+      set: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        facts: z.ZodReadonly<z.ZodObject<{
+          artefacts: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodBoolean>>>;
+          values: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"number">;
+            value: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+            value: z.ZodString;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"boolean">;
+            value: z.ZodBoolean;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"instant">;
+            value: z.ZodString;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"duration">;
+            value: z.ZodNumber;
+            unit: z.ZodEnum<{
+              ms: "ms";
+              s: "s";
+              min: "min";
+              h: "h";
+              d: "d";
+            }>;
+          }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"complex">;
+            re: z.ZodNumber;
+            im: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+          }, z.core.$strip>], "kind">>>>;
+        }, 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>;
+      clear: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
+        modelId: z.ZodString;
+        facts: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+          artefacts: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+          values: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+          all: z.ZodLiteral<true>;
+        }, 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>;
+    };
     items: {
       upsert: import("@orpc/contract").ProcedureContract<z.ZodReadonly<z.ZodObject<{
         modelId: z.ZodString;
@@ -836,14 +1008,14 @@ declare const graphStoreContract: {
       since: z.ZodExactOptional<z.ZodInt>;
     }, z.core.$strict>>, import("@orpc/contract").Schema<AsyncIteratorObject<Readonly<{
       modelId: string;
-      kind: "overlay" | "saved" | "items" | "deleted";
+      kind: "overlay" | "facts" | "saved" | "items" | "deleted";
       revision: number;
     }> | Readonly<{
       modelId: string;
       kind: "missed";
     }>, unknown, void>, import("@orpc/server").AsyncIteratorClass<Readonly<{
       modelId: string;
-      kind: "overlay" | "saved" | "items" | "deleted";
+      kind: "overlay" | "facts" | "saved" | "items" | "deleted";
       revision: number;
     }> | Readonly<{
       modelId: string;
@@ -1021,7 +1193,44 @@ declare const boundItemsSchema: z.ZodReadonly<z.ZodObject<{
     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. */
+/** The name of a fact a condition reads: the string key of its `reference` node. */
+declare const factNameSchema: z.ZodString;
+/**
+ * What is known from outside the process about one model's run, kept beside its overlay: which artefacts are provided (`true`) or known not to be (`false`), by artefact id, and the trilean value of each named fact, by name. What the record does not name is unknown. It is graph-domain's `FactRecord`, which `factsFrom` adapts to the `Facts` port the reasoning reads.
+ */
+declare const factRecordSchema: z.ZodReadonly<z.ZodObject<{
+  artefacts: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+  values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"number">;
+    value: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"boolean">;
+    value: z.ZodBoolean;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"instant">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"duration">;
+    value: z.ZodNumber;
+    unit: z.ZodEnum<{
+      ms: "ms";
+      s: "s";
+      min: "min";
+      h: "h";
+      d: "d";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"complex">;
+    re: z.ZodNumber;
+    im: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+  }, z.core.$strip>], "kind">>>;
+}, z.core.$strict>>;
+/** One stored model, the run state laid over it and the facts known about its run, at the revision of its last change. */
 declare const storedModelSchema: z.ZodReadonly<z.ZodObject<{
   modelId: z.ZodString;
   revision: z.ZodInt;
@@ -1220,7 +1429,120 @@ declare const storedModelSchema: z.ZodReadonly<z.ZodObject<{
     open: "open";
     unknown: "unknown";
   }>>>;
+  facts: z.ZodReadonly<z.ZodObject<{
+    artefacts: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"number">;
+      value: z.ZodNumber;
+      unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"text">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"boolean">;
+      value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"instant">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"duration">;
+      value: z.ZodNumber;
+      unit: z.ZodEnum<{
+        ms: "ms";
+        s: "s";
+        min: "min";
+        h: "h";
+        d: "d";
+      }>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"complex">;
+      re: z.ZodNumber;
+      im: z.ZodNumber;
+      unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>], "kind">>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>>;
+/** A model's fact record at the revision of the model's last change. */
+declare const storedFactsSchema: z.ZodReadonly<z.ZodObject<{
+  modelId: z.ZodString;
+  revision: z.ZodInt;
+  facts: z.ZodReadonly<z.ZodObject<{
+    artefacts: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    values: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"number">;
+      value: z.ZodNumber;
+      unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"text">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"boolean">;
+      value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"instant">;
+      value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"duration">;
+      value: z.ZodNumber;
+      unit: z.ZodEnum<{
+        ms: "ms";
+        s: "s";
+        min: "min";
+        h: "h";
+        d: "d";
+      }>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"complex">;
+      re: z.ZodNumber;
+      im: z.ZodNumber;
+      unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>], "kind">>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>>;
+/**
+ * Facts to record for a model: each artefact's provision and each named fact's value replaces what the record held for it, and everything the change does not name is kept. Every artefact must be one the model declares.
+ */
+declare const factChangeSchema: z.ZodReadonly<z.ZodObject<{
+  artefacts: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodBoolean>>>;
+  values: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"number">;
+    value: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"boolean">;
+    value: z.ZodBoolean;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"instant">;
+    value: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"duration">;
+    value: z.ZodNumber;
+    unit: z.ZodEnum<{
+      ms: "ms";
+      s: "s";
+      min: "min";
+      h: "h";
+      d: "d";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"complex">;
+    re: z.ZodNumber;
+    im: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+  }, z.core.$strip>], "kind">>>>;
 }, z.core.$strict>>;
+/**
+ * Facts to forget, so they are unknown again: either the named artefacts and named facts, or, with `all`, the whole record. A name the record does not hold is ignored.
+ */
+declare const factClearingSchema: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+  artefacts: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  values: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+  all: z.ZodLiteral<true>;
+}, 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;
@@ -1232,7 +1554,7 @@ declare const reachSchema: z.ZodReadonly<z.ZodObject<{
   distance: z.ZodInt;
 }, z.core.$strict>>;
 /** The kinds of change a store reports. */
-declare const changeKinds: readonly ["saved", "overlay", "items", "deleted"];
+declare const changeKinds: readonly ["saved", "overlay", "items", "facts", "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.
  */
@@ -1240,6 +1562,7 @@ declare const storeChangeSchema: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<
   modelId: z.ZodString;
   kind: z.ZodEnum<{
     overlay: "overlay";
+    facts: "facts";
     saved: "saved";
     items: "items";
     deleted: "deleted";
@@ -1261,6 +1584,9 @@ type BoundItems = z.infer<typeof boundItemsSchema>;
 type Relation = z.infer<typeof relationSchema>;
 type RelationKind = (typeof relationKinds)[number];
 type StoredModel = z.infer<typeof storedModelSchema>;
+type StoredFacts = z.infer<typeof storedFactsSchema>;
+type FactChange = z.infer<typeof factChangeSchema>;
+type FactClearing = z.infer<typeof factClearingSchema>;
 type ModelSummary = z.infer<typeof modelSummarySchema>;
 type Reach = z.infer<typeof reachSchema>;
 type ChangeKind = (typeof changeKinds)[number];
@@ -1372,19 +1698,19 @@ interface GraphStore {
     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`).
+   * Stores a model under an id, replacing any model stored there and dropping the run state, relations and artefact facts of what the new model does not declare (see `overlayWithin`, `relationsWithin` and `factsWithin`).
    * @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.
+   * Reads a model back exactly as saved or merged, in its declared order, with its run state and its fact record.
+   * @returns The model, its overlay, its facts and its revision.
    */
   readonly loadModel: (request: ModelRequest) => Promise<StoredModel>;
   /**
-   * Removes a model, its run state and its relations.
+   * Removes a model, its run state, its relations and its facts.
    * @returns The revision the deletion took, or `undefined` when there was no such model and nothing changed.
    */
   readonly deleteModel: (request: ModelRequest) => Promise<Revision | undefined>;
@@ -1395,6 +1721,25 @@ interface GraphStore {
   readonly applyOverlay: (request: ModelRequest & {
     readonly overlay: Overlay<OpenIds>;
   }) => Promise<Revision>;
+  /**
+   * A model's fact record.
+   * @returns The record and the model's revision.
+   */
+  readonly readFacts: (request: ModelRequest) => Promise<StoredFacts>;
+  /**
+   * Records facts about a model's run (see `mergeFacts`). Every artefact named must be one the model declares (`factIssues`); otherwise nothing is written.
+   * @returns The revision the change took.
+   */
+  readonly setFacts: (request: ModelRequest & {
+    readonly facts: FactChange;
+  }) => Promise<Revision>;
+  /**
+   * Forgets facts about a model's run, so what they named is unknown again (see `withoutFacts`).
+   * @returns The revision the change took.
+   */
+  readonly clearFacts: (request: ModelRequest & {
+    readonly facts: FactClearing;
+  }) => 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.
@@ -1473,6 +1818,36 @@ declare const overlayWithin: (model: Model<OpenIds>, overlay: Overlay<OpenIds>)
  */
 declare const checkStored: (model: Model<OpenIds>, overlay: Overlay<OpenIds>) => void;
 //#endregion
+//#region ../../core/graph/store-contract/dist/facts.d.ts
+/**
+ * Keeps only the artefact entries of a record that name an artefact the model declares, so replacing a model drops what was known about artefacts it no longer has. Named facts belong to the run rather than to any record of the model, so they are all kept.
+ * @param model - The model the record is for.
+ * @param facts - The record to narrow.
+ * @returns The record with its artefacts narrowed to the model's.
+ */
+declare const factsWithin: (model: Model<OpenIds>, facts: FactRecord) => FactRecord;
+/**
+ * Applies a change to a record: each artefact and named fact the change gives replaces what the record held for it, and the rest is kept. The result is not checked; see `factIssues`.
+ * @param facts - The stored record.
+ * @param change - The facts to record.
+ * @returns The merged record.
+ */
+declare const mergeFacts: (facts: FactRecord, change: FactChange) => FactRecord;
+/**
+ * Forgets facts, so what they named is unknown again: the whole record with `all`, otherwise the named artefacts and named facts. A name the record does not hold is ignored.
+ * @param facts - The stored record.
+ * @param clearing - What to forget.
+ * @returns The record without what was forgotten.
+ */
+declare const withoutFacts: (facts: FactRecord, clearing: FactClearing) => FactRecord;
+/**
+ * The issues with a change to a model's facts: an artefact the model does not declare is an `unknown-reference`, as an unknown reference anywhere else in a model is. Named facts are free names, since any `reference` key in a condition may read one.
+ * @param model - The model the facts are for.
+ * @param change - The facts to record.
+ * @returns One issue per undeclared artefact, empty when every artefact resolves.
+ */
+declare const factIssues: (model: Model<OpenIds>, change: FactChange) => readonly Issue[];
+//#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.
@@ -1579,4 +1954,4 @@ type GraphStoreRouter = ContractedRouter<typeof graphStoreContract, object>;
  */
 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 };
+export { factRecordSchema as $, defaultSubscriptionCapacity as A, Reach as B, ElementRequest as C, ChangeFeedOptions as D, ChangeFeed as E, ChangeKind as F, StoredFacts as G, RelationKind as H, FactChange as I, boundItemsSchema as J, StoredModel as K, FactClearing as L, GraphStoreFailure as M, BoundActivity as N, ChangeSubscription as O, BoundItems as P, factNameSchema as Q, ModelId as R, overlayWithin as S, ModelRequest as T, Revision as U, Relation as V, StoreChange as W, factChangeSchema as X, changeKinds as Y, factClearingSchema as Z, mergeFacts as _, blockedChainOf as a, relationSchema as at, emptyModel as b, structureOf as c, storedFactsSchema as ct, descendantsOf as d, graphStoreContract as dt, issueSchema as et, mergeRelations as f, factsWithin as g, factIssues as h, Structure as i, relationKinds as it, GraphStoreError as j, SubscribeOptions as k, ancestorsOf as l, storedModelSchema as lt, relationsWithin as m, GraphStoreRouter as n, modelSummarySchema as nt, impactOf as o, revisionSchema as ot, relationIssues as p, boundActivitySchema as q, createGraphStoreRouter as r, reachSchema as rt, readyOf as s, storeChangeSchema as st, createFakeGraphStore as t, modelIdSchema as tt, childrenOf as u, GraphStoreClient as ut, withoutFacts as v, GraphStore as w, mergeBoundItems as x, checkStored as y, ModelSummary as z };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { A as UnsupportedConditionError, C as CriticalPath, D as UnknownReference, E as NodeId, F as Status, I as statuses, M as elementStatusKey, N as evaluateBranches, O as buildDag, P as Branch, S as loopTransitions, T as Dag, _ as StatusRule, a as criticalPath, b as controlDag, c as unmetOutputs, d as StatusExplanation, f as explainStatus, g as StatusBasis, h as ProducerBasis, i as blockedBy, j as artefactKey, k as Facts, l as whatIfDone, m as IncomingBasis, n as UnmetOutput, o as impact, p as ArtefactBasis, r as WhatIf, s as readySet, t as StatusChange, u as ChainLink, v as deriveStatuses, w as criticalPath$1, x as illegalCycles, y as statusRules } from "./index-CCfe0csl.js";
+import { A as Facts, B as Status, C as CriticalPath, D as UnknownReference, E as NodeId, F as evaluateBranches, I as factNamesIn, L as factsFrom, M as artefactKey, N as elementStatusKey, O as buildDag, P as emptyFactRecord, R as layeredFacts, S as loopTransitions, T as Dag, V as statuses, _ as StatusRule, a as criticalPath, b as controlDag, c as unmetOutputs, d as StatusExplanation, f as explainStatus, g as StatusBasis, h as ProducerBasis, i as blockedBy, j as UnsupportedConditionError, k as FactRecord, l as whatIfDone, m as IncomingBasis, n as UnmetOutput, o as impact, p as ArtefactBasis, r as WhatIf, s as readySet, t as StatusChange, u as ChainLink, v as deriveStatuses, w as criticalPath$1, x as illegalCycles, y as statusRules, z as Branch } from "./index-BH1aFqkJ.js";
 import { A as Views, B as messageModes, C as Extensions, D as Point, E as Participant, F as OverlayStatus, G as IdSpace, H as overlayStatuses, I as ParticipantKind, K as OpenIds, L as PseudoRole, M as FragmentOperator, N as MessageMode, O as Projection, P as Notation, R as elementKinds, S as EventDef, T as FragmentOperand, U as participantKinds, V as notations, W as pseudoRoles, _ as ModelParts, a as Overlay, b as ArtefactDef, c as overlaySchema, d as Issue, f as IssueCode, g as Model, h as outputsOf, i as modelSchema, j as ElementKind, k as Transition, l as parseOverlay, m as inputsOf, n as ModelParseError, o as OverlayIssue, p as validate, r as parseModel, s as OverlayParseError, t as ModelIssue, u as validateOverlay, v as defineModel, w as Fragment, x as Element, y as ActionDef, z as fragmentOperators } from "./index-CmZOswkx.js";
 import { A as Flowchart, C as StateMachineTransition, D as toSwimlane, E as Swimlane, F as UnrepresentedElement, I as UnrepresentedKind, M as Handoff, N as handoffs, O as FlowEdge, P as Loss, S as StateMachineState, T as Lane, _ as SequenceItem, a as Addressing, b as toSequence, c as Ends, d as TransitionChange, f as TransitionFieldChange, g as SequenceDiagram, h as confirmChanges, i as diffSwimlane, j as toFlowchart, k as FlowNode, l as EventChange, m as applyModelDiff, n as diffStateMachine, o as Change, p as UnconfirmedChangeError, r as diffFlowchart, s as ElementChange, t as diffSequence, u as ModelDiff, v as SequenceMessage, w as toStateMachine, x as StateMachine, y as SequenceOperand } from "./index-CoA6vXqe.js";
 //#region ../../core/graph/dag/dist/errors.d.ts
@@ -108,4 +108,4 @@ declare namespace index_d_exports {
   export { CriticalPath, CycleError, Dag, NodeId, TopologicalLayers, UnknownNodeError, UnknownReference, ancestorsOf, buildDag, criticalPath$1 as criticalPath, descendantsOf, findCycles, immediateDominators, stronglyConnectedComponents, topologicalLayers, transitiveReduction };
 }
 //#endregion
-export { type ActionDef, type Addressing, type ArtefactBasis, type ArtefactDef, type Branch, type ChainLink, type Change, type Element, type ElementChange, type ElementKind, type Ends, type EventChange, type EventDef, type Extensions, type Facts, type FlowEdge, type FlowNode, type Flowchart, type Fragment, type FragmentOperand, type FragmentOperator, type Handoff, type IdSpace, type IncomingBasis, type Issue, type IssueCode, type Lane, type Loss, type MessageMode, type Model, type ModelDiff, type ModelIssue, ModelParseError, type ModelParts, type Notation, type OpenIds, type Overlay, type OverlayIssue, OverlayParseError, type OverlayStatus, type Participant, type ParticipantKind, type Point, type ProducerBasis, type Projection, type PseudoRole, type SequenceDiagram, type SequenceItem, type SequenceMessage, type SequenceOperand, type StateMachine, type StateMachineState, type StateMachineTransition, type Status, type StatusBasis, type StatusChange, type StatusExplanation, type StatusRule, type Swimlane, type Transition, type TransitionChange, type TransitionFieldChange, UnconfirmedChangeError, type UnmetOutput, type UnrepresentedElement, type UnrepresentedKind, UnsupportedConditionError, type Views, type WhatIf, applyModelDiff, artefactKey, blockedBy, confirmChanges, controlDag, criticalPath, index_d_exports as dag, defineModel, deriveStatuses, diffFlowchart, diffSequence, diffStateMachine, diffSwimlane, elementKinds, elementStatusKey, evaluateBranches, explainStatus, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, pseudoRoles, readySet, statusRules, statuses, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, whatIfDone };
+export { type ActionDef, type Addressing, type ArtefactBasis, type ArtefactDef, type Branch, type ChainLink, type Change, type Element, type ElementChange, type ElementKind, type Ends, type EventChange, type EventDef, type Extensions, type FactRecord, type Facts, type FlowEdge, type FlowNode, type Flowchart, type Fragment, type FragmentOperand, type FragmentOperator, type Handoff, type IdSpace, type IncomingBasis, type Issue, type IssueCode, type Lane, type Loss, type MessageMode, type Model, type ModelDiff, type ModelIssue, ModelParseError, type ModelParts, type Notation, type OpenIds, type Overlay, type OverlayIssue, OverlayParseError, type OverlayStatus, type Participant, type ParticipantKind, type Point, type ProducerBasis, type Projection, type PseudoRole, type SequenceDiagram, type SequenceItem, type SequenceMessage, type SequenceOperand, type StateMachine, type StateMachineState, type StateMachineTransition, type Status, type StatusBasis, type StatusChange, type StatusExplanation, type StatusRule, type Swimlane, type Transition, type TransitionChange, type TransitionFieldChange, UnconfirmedChangeError, type UnmetOutput, type UnrepresentedElement, type UnrepresentedKind, UnsupportedConditionError, type Views, type WhatIf, applyModelDiff, artefactKey, blockedBy, confirmChanges, controlDag, criticalPath, index_d_exports as dag, defineModel, deriveStatuses, diffFlowchart, diffSequence, diffStateMachine, diffSwimlane, elementKinds, elementStatusKey, emptyFactRecord, evaluateBranches, explainStatus, factNamesIn, factsFrom, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, layeredFacts, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, pseudoRoles, readySet, statusRules, statuses, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, whatIfDone };

package/dist/index.js

@@ -2,8 +2,8 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { a as validateOverlay, c as fragmentOperators, d as overlayStatuses, f as participantKinds, i as parseOverlay, l as messageModes, n as OverlayParseError, p as pseudoRoles, r as overlaySchema, s as elementKinds, t as modelSchema, u as notations } from "./schema-CVnS6HiX.js";
 import { t as validate } from "./validate-DF3mQZww.js";
 import { n as parseModel, t as ModelParseError } from "./parse-CuipC_2K.js";
-import { C as topologicalLayers, S as immediateDominators, _ as toSwimlane, a as unmetOutputs, b as handoffs, c as deriveStatuses, d as artefactKey, f as elementStatusKey, g as toStateMachine, h as stateMachineParts, i as readySet, l as statusRules, m as toSequence, n as criticalPath, o as whatIfDone, p as evaluateBranches, r as impact, s as explainStatus, t as blockedBy, u as UnsupportedConditionError, v as flowchartParts, w as actorMap, x as criticalPath$1, y as toFlowchart } from "./queries-CCexJAE2.js";
-import { a as findCycles, c as descendantsOf, d as lookup, f as CycleError, i as assertAcyclic, l as assembleDag, n as illegalCycles, o as stronglyConnectedComponents, p as UnknownNodeError, r as loopTransitions, s as ancestorsOf, t as controlDag, u as buildDag } from "./control-aDk9560d.js";
+import { _ as criticalPath$1, a as unmetOutputs, b as actorMap, c as deriveStatuses, d as stateMachineParts, f as toStateMachine, g as handoffs, h as toFlowchart, i as readySet, l as statusRules, m as flowchartParts, n as criticalPath, o as whatIfDone, p as toSwimlane, r as impact, s as explainStatus, t as blockedBy, u as toSequence, v as immediateDominators, y as topologicalLayers } from "./queries-C8kIDRiY.js";
+import { S as UnknownNodeError, _ as descendantsOf, a as artefactKey, b as lookup, c as evaluateBranches, f as layeredFacts, g as ancestorsOf, h as stronglyConnectedComponents, i as UnsupportedConditionError, l as factNamesIn, m as findCycles, n as illegalCycles, o as elementStatusKey, p as assertAcyclic, r as loopTransitions, s as emptyFactRecord, t as controlDag, u as factsFrom, v as assembleDag, x as CycleError, y as buildDag } from "./control-DiygoEhm.js";
 import { t as statuses } from "./status-Bm1CGu9C.js";
 //#region ../../core/graph/schema/dist/artefacts.js
 /**
@@ -926,4 +926,4 @@ const diffSequence = (model, scenario, edited) => {
 	};
 };
 //#endregion
-export { ModelParseError, OverlayParseError, UnconfirmedChangeError, UnsupportedConditionError, applyModelDiff, artefactKey, blockedBy, confirmChanges, controlDag, criticalPath, dist_exports as dag, defineModel, deriveStatuses, diffFlowchart, diffSequence, diffStateMachine, diffSwimlane, elementKinds, elementStatusKey, evaluateBranches, explainStatus, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, pseudoRoles, readySet, statusRules, statuses, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, whatIfDone };
+export { ModelParseError, OverlayParseError, UnconfirmedChangeError, UnsupportedConditionError, applyModelDiff, artefactKey, blockedBy, confirmChanges, controlDag, criticalPath, dist_exports as dag, defineModel, deriveStatuses, diffFlowchart, diffSequence, diffStateMachine, diffSwimlane, elementKinds, elementStatusKey, emptyFactRecord, evaluateBranches, explainStatus, factNamesIn, factsFrom, fragmentOperators, handoffs, illegalCycles, impact, inputsOf, layeredFacts, loopTransitions, messageModes, modelSchema, notations, outputsOf, overlaySchema, overlayStatuses, parseModel, parseOverlay, participantKinds, pseudoRoles, readySet, statusRules, statuses, toFlowchart, toSequence, toStateMachine, toSwimlane, unmetOutputs, validate, validateOverlay, whatIfDone };

package/dist/{open-CyRXJ4bt.js → open-BF-UHqeW.js}

@@ -1,4 +1,4 @@
-import { t as createSqliteGraphStore } from "./store-BcR70CaO.js";
+import { t as createSqliteGraphStore } from "./store-BJILV4JS.js";
 import { sql } from "drizzle-orm";
 import { DatabaseSync } from "node:sqlite";
 import { drizzle } from "drizzle-orm/node-sqlite";