@graview/core 0.1.0

package/dist/intelligence-bridge.js

@@ -0,0 +1,31 @@
+/**
+ * THE LOCAL DOOR'S CONTRACT — what a page and a dev server agree on.
+ *
+ * `reach: ["local"]` says a provider can be reached by a process on this
+ * machine. This is the whole of what the two sides share: one path and three
+ * message shapes. It carries no Node and no DOM, so the browser bundle and
+ * the dev-server plugin can both hold it, and neither has to import the
+ * other — which matters here, because the plugin lives a tier above the
+ * hook that probes it.
+ *
+ * Not to be confused with a model running IN the browser (`localCompletion`
+ * in `@graview/tools`, which downloads weights and runs them on WebGPU).
+ * This door is a process on the machine the dev server is running on:
+ * somebody's own CLI, already installed, already logged in, already paid
+ * for, and reachable for as long as `pnpm dev` is up.
+ */
+/** Where the bridge answers unless an app says otherwise. */
+export const LOCAL_BRIDGE_PATH = "/__graview/local";
+/* ---------------------------------------------------- the decision door */
+/**
+ * THE DOOR A DECISION PROVIDER IS REACHED BY from a browser: the dev server
+ * holds the key, the page holds the questions. Same three shapes as the
+ * local door — a probe, an ask, an answer — and the same rule about who may
+ * knock: the page this server serves, and nobody else.
+ *
+ * The key is read on the SERVER side from the environment, so it is never
+ * in a bundle, a repo or the browser's storage: the person running
+ * `pnpm dev` set it once, and the page never sees it.
+ */
+export const DECISION_BRIDGE_PATH = "/__graview/decide";
+//# sourceMappingURL=intelligence-bridge.js.map

package/dist/intelligence-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-bridge.js","sourceRoot":"","sources":["../src/intelligence-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,6DAA6D;AAC7D,MAAM,CAAC,MAAM,iBAAiB,GAAG,kBAAkB,CAAC;AAgBpD,4EAA4E;AAE5E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,mBAAmB,CAAC"}

package/dist/invariants/engine.d.ts

@@ -0,0 +1,36 @@
+import type { Graph } from "../graph/graph.js";
+import type { AnySchema, KindOfSchema, NodeOfKind } from "../schema/schema.js";
+import type { EvaluateOptions, InvariantDefinition, InvariantEvalArgs, Violation } from "./types.js";
+export declare class UnregisteredInvariantError extends Error {
+    readonly invariant: string;
+    readonly nodeId: string;
+    constructor(invariant: string, nodeId: string);
+}
+export declare function defineInvariant<S extends AnySchema, K extends KindOfSchema<S>>(name: string, spec: {
+    readonly scope: {
+        readonly kind: K;
+        readonly match?: (node: NodeOfKind<S, K>) => boolean;
+    };
+    readonly label?: string;
+    readonly description?: string;
+    readonly repairs?: readonly string[];
+    readonly judgesPast?: boolean;
+    readonly evaluate: (args: InvariantEvalArgs<S, NodeOfKind<S, K>>) => Violation[];
+}): InvariantDefinition<S>;
+export declare function defineInvariant<S extends AnySchema>(name: string, spec: {
+    readonly scope: "graph";
+    readonly label?: string;
+    readonly description?: string;
+    readonly repairs?: readonly string[];
+    readonly judgesPast?: boolean;
+    readonly evaluate: (args: InvariantEvalArgs<S, undefined>) => Violation[];
+}): InvariantDefinition<S>;
+/**
+ * Pure evaluation: same graph, context and `today` in, same violations out.
+ * The one clock read is the lifecycle horizon's date fallback when no
+ * `options.today` is pinned — pin it and the whole tier runs headlessly in CI.
+ */
+export declare function evaluate<S extends AnySchema>(graph: Graph<S>, invariants: readonly InvariantDefinition<S>[], options?: EvaluateOptions<S>): Violation[];
+/** Violations that implicate any of the given node ids. */
+export declare function violationsTouching(violations: readonly Violation[], nodeIds: readonly string[]): Violation[];
+//# sourceMappingURL=engine.d.ts.map

package/dist/invariants/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/invariants/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAgB,MAAM,qBAAqB,CAAC;AAC7F,OAAO,KAAK,EACV,eAAe,EAEf,mBAAmB,EACnB,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAC;AAEpB,qBAAa,0BAA2B,SAAQ,KAAK;IAEjD,QAAQ,CAAC,SAAS,EAAE,MAAM;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM;gBADd,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM;CAO1B;AAED,wBAAgB,eAAe,CAC7B,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,EAEzB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE;IACJ,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,OAAO,CAAA;KAAE,CAAC;IAC3F,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;CAClF,GACA,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAC1B,wBAAgB,eAAe,CAAC,CAAC,SAAS,SAAS,EACjD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE;IACJ,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,SAAS,EAAE,CAAC;CAC3E,GACA,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAe1B;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,SAAS,EAC1C,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,UAAU,EAAE,SAAS,mBAAmB,CAAC,CAAC,CAAC,EAAE,EAC7C,OAAO,GAAE,eAAe,CAAC,CAAC,CAAM,GAC/B,SAAS,EAAE,CAmEb;AAED,2DAA2D;AAC3D,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,SAAS,SAAS,EAAE,EAChC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,SAAS,EAAE,CAKb"}

package/dist/invariants/engine.js

@@ -0,0 +1,88 @@
+import { isCurrent } from "../schema/define-node.js";
+export class UnregisteredInvariantError extends Error {
+    invariant;
+    nodeId;
+    constructor(invariant, nodeId) {
+        super(`No invariant registered under "${invariant}" (required by node "${nodeId}")`);
+        this.invariant = invariant;
+        this.nodeId = nodeId;
+        this.name = "UnregisteredInvariantError";
+    }
+}
+export function defineInvariant(name, spec) {
+    return { ...spec, name };
+}
+/**
+ * Pure evaluation: same graph, context and `today` in, same violations out.
+ * The one clock read is the lifecycle horizon's date fallback when no
+ * `options.today` is pinned — pin it and the whole tier runs headlessly in CI.
+ */
+export function evaluate(graph, invariants, options = {}) {
+    const context = options.context ?? {};
+    const onUnregistered = options.onUnregistered ?? "skip";
+    const registered = new Set(invariants.map((i) => i.name));
+    const violations = [];
+    for (const invariant of invariants) {
+        if (invariant.scope !== "graph")
+            continue;
+        violations.push(...invariant.evaluate({ graph, subject: undefined, context }));
+    }
+    const scoped = invariants.filter((i) => i.scope !== "graph");
+    const byKind = new Map();
+    for (const invariant of scoped) {
+        const kind = invariant.scope.kind;
+        const list = byKind.get(kind);
+        if (list)
+            list.push(invariant);
+        else
+            byKind.set(kind, [invariant]);
+    }
+    for (const node of graph.allNodes()) {
+        const definition = graph.schema.tryDefinition(node.kind);
+        const required = definition?.requiresInvariant?.(node) ?? null;
+        if (options.subjectFilter && !options.subjectFilter(node, context))
+            continue;
+        if (required !== null && !registered.has(required)) {
+            if (onUnregistered === "throw") {
+                throw new UnregisteredInvariantError(required, node.id);
+            }
+            continue;
+        }
+        /*
+         * The horizon applies to judgement, not just display: a retired subject
+         * is only examined by invariants that opted into the past. Graph-scoped
+         * invariants read whatever they read — they have no subject to retire.
+         */
+        const retired = !isCurrent(definition, node, options.today);
+        for (const invariant of byKind.get(node.kind) ?? []) {
+            if (retired && invariant.judgesPast !== true)
+                continue;
+            const match = invariant.scope.match;
+            if (match && !match(node))
+                continue;
+            violations.push(...invariant.evaluate({ graph, subject: node, context }));
+        }
+    }
+    /*
+     * IDENTICAL claims collapse to one. Two rule nodes carrying the same spec
+     * each evaluate honestly, and every surface downstream — the standing
+     * count, the board, the inspector — would repeat the same sentence twice
+     * for what a reader rightly regards as one problem. Distinct facts always
+     * differ in message or in the nodes they implicate, so this only removes
+     * true twins.
+     */
+    const seen = new Set();
+    return violations.filter((violation) => {
+        const key = `${violation.message}|${[...violation.nodeIds].sort().join(",")}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** Violations that implicate any of the given node ids. */
+export function violationsTouching(violations, nodeIds) {
+    const wanted = new Set(nodeIds);
+    return violations.filter((v) => v.nodeIds.some((id) => wanted.has(id)) || (v.subjectId !== undefined && wanted.has(v.subjectId)));
+}
+//# sourceMappingURL=engine.js.map

package/dist/invariants/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../src/invariants/engine.ts"],"names":[],"mappings":"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"}

package/dist/invariants/types.d.ts

@@ -0,0 +1,75 @@
+import type { GraphReader } from "../graph/types.js";
+import type { AnySchema, KindOfSchema, NodeOfKind, NodeOfSchema } from "../schema/schema.js";
+/**
+ * A mutation that would resolve a violation. This field is the seam between
+ * the invariant engine and derived affordances: it is why selecting an
+ * out-of-balance set of duties can surface "rebalance" without anyone
+ * writing a rule to produce that suggestion.
+ */
+export interface Repair {
+    readonly mutation: string;
+    /** Arguments already determined by the violation. */
+    readonly args?: Readonly<Record<string, unknown>>;
+    /** Arguments the caller still has to choose. */
+    readonly missing?: readonly string[];
+    readonly label: string;
+}
+export interface Violation {
+    readonly invariant: string;
+    /** The node whose declaration produced the check, when there is one. */
+    readonly subjectId?: string;
+    readonly label: string;
+    readonly message: string;
+    /** Ids of the nodes that cause the violation, for cross-plane highlighting. */
+    readonly nodeIds: readonly string[];
+    readonly repairs: readonly Repair[];
+}
+/** Free-form evaluation context an app threads through (e.g. a week start). */
+export type InvariantContext = Readonly<Record<string, unknown>>;
+export interface InvariantScope<S extends AnySchema, K extends KindOfSchema<S>> {
+    readonly kind: K;
+    /** Narrows which nodes of the kind this invariant judges. */
+    readonly match?: (node: NodeOfKind<S, K>) => boolean;
+}
+export interface InvariantEvalArgs<S extends AnySchema, Subject> {
+    readonly graph: GraphReader<NodeOfSchema<S>>;
+    readonly subject: Subject;
+    readonly context: InvariantContext;
+}
+export interface InvariantDefinition<S extends AnySchema = AnySchema> {
+    readonly name: string;
+    readonly label?: string;
+    readonly description?: string;
+    readonly scope: {
+        readonly kind: string;
+        readonly match?: (node: never) => boolean;
+    } | "graph";
+    /**
+     * Mutation names this invariant may name as repairs. Declared statically so
+     * `graview check` can catch a repair that points at a mutation nobody
+     * registered, instead of discovering it when a violation fires.
+     */
+    readonly repairs?: readonly string[];
+    /**
+     * Judge retired subjects too. By default a scoped invariant sees only the
+     * HORIZON — nodes current under their kind's lifecycle — because a rule
+     * about last term's agreement is noise, not a violation. An invariant that
+     * genuinely audits history says so here, explicitly.
+     */
+    readonly judgesPast?: boolean;
+    readonly evaluate: (args: InvariantEvalArgs<S, never>) => Violation[];
+}
+export interface EvaluateOptions<S extends AnySchema = AnySchema> {
+    readonly context?: InvariantContext;
+    /** What to do when a node requires an invariant nobody registered. */
+    readonly onUnregistered?: "skip" | "throw";
+    /**
+     * Pins "today" for the lifecycle horizon (YYYY-MM-DD). Without it the
+     * date-retired check reads the real clock — pass this wherever determinism
+     * matters (tests, replays).
+     */
+    readonly today?: string;
+    /** Filters subject nodes before evaluation, e.g. by effectivity window. */
+    readonly subjectFilter?: (node: NodeOfSchema<S>, context: InvariantContext) => boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/invariants/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/invariants/types.ts"],"names":[],"mappings":"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"}

package/dist/invariants/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/invariants/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/invariants/types.ts"],"names":[],"mappings":""}

package/dist/modules.d.ts

@@ -0,0 +1,75 @@
+/**
+ * MODULES: named parts of a declaration a workspace can turn on and off.
+ *
+ * A deployed app needs to scope itself per workspace — one household wants
+ * Vehicles, another does not — and "comment out the import" is not a thing a
+ * hosted product can offer. A module is a declared subset of the app's
+ * surface: node kinds, mutations, invariants. The enabled set is plain
+ * serialisable config, which is what lets a platform bind it to entitlements.
+ *
+ * Two rules keep this honest. Anything no module claims is CORE and always
+ * on — an app pays for the concept only where it opts in. And disabling
+ * never deletes: nodes of a disabled kind stay in the graph and simply stop
+ * being drawn, counted or judged, so re-enabling brings a workspace back
+ * intact. "Module off" is a horizon, not a delete.
+ */
+export interface ModuleDeclaration {
+    readonly description?: string;
+    /** Node kinds this module owns. */
+    readonly kinds?: readonly string[];
+    /** Mutation names this module owns. */
+    readonly mutations?: readonly string[];
+    /** Invariant names this module owns. */
+    readonly invariants?: readonly string[];
+    /** Modules this one cannot stand without. */
+    readonly requires?: readonly string[];
+    /**
+     * A module that is never off.
+     *
+     * People are not a bolt-on for a grounds app, or a rota, or anything else
+     * several people use: an installation without people is a household of one,
+     * which is a graph with no user NODES rather than a disabled module. An app
+     * in that position had two options, both bad — drop the module, which draws
+     * the installation for everybody and loses the thing the module is for, or
+     * carry a permanent `module-edge-leak` warning for every edge the domain
+     * points at a person and hope nobody stops reading them.
+     *
+     * A warning that can only ever be acknowledged costs the checker its
+     * authority on the warnings that matter, so the declaration can say the
+     * thing that makes the question moot: this cannot be off, so no line
+     * dangles. `resolveModules` keeps it on whatever the enabled set says, and
+     * `graview check` skips the leak warning for edges reaching into it.
+     */
+    readonly required?: boolean;
+    /**
+     * Who the module's kinds are drawn for. `always` (the default) is every
+     * seat; `admin` keeps them out of the picture until a seat that may run
+     * one of the module's acts asks to see them — the installation's own
+     * users and invitations sit beside the domain for the person who keeps
+     * it, and are never a district for anyone else.
+     */
+    readonly visibility?: "always" | "admin";
+}
+export type ModuleMap = Readonly<Record<string, ModuleDeclaration>>;
+/** What an enabled set works out to, asked once and shared by every surface. */
+export interface ModuleProjection {
+    /** Module names actually on, requirements included. */
+    readonly enabled: ReadonlySet<string>;
+    readonly disabledKinds: ReadonlySet<string>;
+    readonly disabledMutations: ReadonlySet<string>;
+    readonly disabledInvariants: ReadonlySet<string>;
+    /** Enabled modules drawn only for those who administer them, by name. */
+    readonly administered: ReadonlyMap<string, ModuleDeclaration>;
+}
+/**
+ * Resolves an enabled set against the declared modules.
+ *
+ * `enabled: undefined` means everything — the default install is the whole
+ * app, and a store that never heard of modules behaves exactly as before.
+ * Enabling a module quietly enables what it `requires`, transitively: at
+ * runtime the forgiving reading is correct (an entitlement flip must not
+ * strand a workspace), and the strict reading lives in `graview check`,
+ * which reports a requirement pointing at a module nobody declared.
+ */
+export declare function resolveModules(modules: ModuleMap | undefined, enabled: readonly string[] | undefined): ModuleProjection;
+//# sourceMappingURL=modules.d.ts.map

package/dist/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,mCAAmC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,uCAAuC;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,wCAAwC;IACxC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;CAC1C;AAED,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAEpE,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChD,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACjD,yEAAyE;IACzE,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;CAC/D;AAID;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,GAAG,SAAS,EAC9B,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACrC,gBAAgB,CA0ClB"}

package/dist/modules.js

@@ -0,0 +1,87 @@
+/**
+ * MODULES: named parts of a declaration a workspace can turn on and off.
+ *
+ * A deployed app needs to scope itself per workspace — one household wants
+ * Vehicles, another does not — and "comment out the import" is not a thing a
+ * hosted product can offer. A module is a declared subset of the app's
+ * surface: node kinds, mutations, invariants. The enabled set is plain
+ * serialisable config, which is what lets a platform bind it to entitlements.
+ *
+ * Two rules keep this honest. Anything no module claims is CORE and always
+ * on — an app pays for the concept only where it opts in. And disabling
+ * never deletes: nodes of a disabled kind stay in the graph and simply stop
+ * being drawn, counted or judged, so re-enabling brings a workspace back
+ * intact. "Module off" is a horizon, not a delete.
+ */
+const NOTHING = new Set();
+/**
+ * Resolves an enabled set against the declared modules.
+ *
+ * `enabled: undefined` means everything — the default install is the whole
+ * app, and a store that never heard of modules behaves exactly as before.
+ * Enabling a module quietly enables what it `requires`, transitively: at
+ * runtime the forgiving reading is correct (an entitlement flip must not
+ * strand a workspace), and the strict reading lives in `graview check`,
+ * which reports a requirement pointing at a module nobody declared.
+ */
+export function resolveModules(modules, enabled) {
+    if (!modules || enabled === undefined) {
+        return {
+            enabled: new Set(Object.keys(modules ?? {})),
+            disabledKinds: NOTHING,
+            disabledMutations: NOTHING,
+            disabledInvariants: NOTHING,
+            administered: administeredOf(modules, new Set(Object.keys(modules ?? {}))),
+        };
+    }
+    const on = new Set();
+    const turnOn = (name) => {
+        if (on.has(name) || !(name in modules))
+            return;
+        on.add(name);
+        for (const required of modules[name]?.requires ?? [])
+            turnOn(required);
+    };
+    for (const name of enabled)
+        turnOn(name);
+    /* A module that declares itself required is on whatever the config says. */
+    for (const [name, module] of Object.entries(modules))
+        if (module.required)
+            turnOn(name);
+    const disabledKinds = new Set();
+    const disabledMutations = new Set();
+    const disabledInvariants = new Set();
+    for (const [name, module] of Object.entries(modules)) {
+        if (on.has(name))
+            continue;
+        for (const kind of module.kinds ?? [])
+            disabledKinds.add(kind);
+        for (const mutation of module.mutations ?? [])
+            disabledMutations.add(mutation);
+        for (const invariant of module.invariants ?? [])
+            disabledInvariants.add(invariant);
+    }
+    /*
+     * A kind two modules claim stays on while EITHER is enabled — ownership
+     * is a union, and the disabled set only holds what nothing enabled wants.
+     */
+    for (const name of on) {
+        const module = modules[name];
+        for (const kind of module?.kinds ?? [])
+            disabledKinds.delete(kind);
+        for (const mutation of module?.mutations ?? [])
+            disabledMutations.delete(mutation);
+        for (const invariant of module?.invariants ?? [])
+            disabledInvariants.delete(invariant);
+    }
+    return { enabled: on, disabledKinds, disabledMutations, disabledInvariants, administered: administeredOf(modules, on) };
+}
+function administeredOf(modules, on) {
+    const found = new Map();
+    for (const [name, module] of Object.entries(modules ?? {})) {
+        if (on.has(name) && module.visibility === "admin")
+            found.set(name, module);
+    }
+    return found;
+}
+//# sourceMappingURL=modules.js.map

package/dist/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"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"}

package/dist/mutations/decidable.d.ts

@@ -0,0 +1,26 @@
+import { type FormField } from "./form.js";
+/**
+ * WHAT A DECISION PROVIDER COULD NEVER SUPPLY.
+ *
+ * A decision provider answers in values the declaration already types: a
+ * Choice over named options (an enum, a node of some kind), a truth, a
+ * Score over an ordered rubric (a bounded number). It has no prose, so an
+ * act whose required arguments include free text — or a date, which is
+ * neither chosen from a set nor scored — is an act it could not possibly
+ * call, whatever the allowlist says. The checker refuses such a provider;
+ * a surface deriving questions skips such an act rather than asking one
+ * it cannot fill.
+ *
+ * Optional arguments are not counted: a decision provider leaves them
+ * unset, which is what optional means. A variant's tag is a choice; its
+ * arms' fields are judged like any other.
+ */
+export interface UndecidableArgument {
+    readonly name: string;
+    readonly control: FormField["control"];
+}
+/** The required arguments of an act that no typed answer can fill. */
+export declare function undecidableArguments(mutation: {
+    readonly input?: unknown;
+}): readonly UndecidableArgument[];
+//# sourceMappingURL=decidable.d.ts.map

package/dist/mutations/decidable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decidable.d.ts","sourceRoot":"","sources":["../../src/mutations/decidable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAEvD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CACxC;AA6BD,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,mBAAmB,EAAE,CAI3G"}

package/dist/mutations/decidable.js

@@ -0,0 +1,39 @@
+import { formFields } from "./form.js";
+const walk = (field, path, out) => {
+    if (field.optional)
+        return;
+    switch (field.control) {
+        case "choice":
+        case "node":
+        case "boolean":
+            return;
+        case "number":
+            // A Score needs an ordered rubric; an unbounded number is not one.
+            if (field.min === undefined || field.max === undefined)
+                out.push({ name: path, control: field.control });
+            return;
+        case "group":
+            for (const child of field.fields)
+                walk(child, `${path}.${child.name}`, out);
+            return;
+        case "variant":
+            // The tag is a Choice; every arm must then be decidable for the
+            // provider to be able to choose any of them.
+            for (const arm of field.options) {
+                for (const child of arm.fields)
+                    walk(child, `${path}.${child.name}`, out);
+            }
+            return;
+        default:
+            // text, date, list, opaque: nothing a typed answer can produce.
+            out.push({ name: path, control: field.control });
+    }
+};
+/** The required arguments of an act that no typed answer can fill. */
+export function undecidableArguments(mutation) {
+    const out = [];
+    for (const field of formFields(mutation.input))
+        walk(field, field.name, out);
+    return out;
+}
+//# sourceMappingURL=decidable.js.map

package/dist/mutations/decidable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decidable.js","sourceRoot":"","sources":["../../src/mutations/decidable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAkB,MAAM,WAAW,CAAC;AAuBvD,MAAM,IAAI,GAAG,CAAC,KAAgB,EAAE,IAAY,EAAE,GAA0B,EAAQ,EAAE;IAChF,IAAI,KAAK,CAAC,QAAQ;QAAE,OAAO;IAC3B,QAAQ,KAAK,CAAC,OAAO,EAAE,CAAC;QACtB,KAAK,QAAQ,CAAC;QACd,KAAK,MAAM,CAAC;QACZ,KAAK,SAAS;YACZ,OAAO;QACT,KAAK,QAAQ;YACX,mEAAmE;YACnE,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS;gBAAE,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACzG,OAAO;QACT,KAAK,OAAO;YACV,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM;gBAAE,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC;YAC5E,OAAO;QACT,KAAK,SAAS;YACZ,gEAAgE;YAChE,6CAA6C;YAC7C,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAChC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,MAAM;oBAAE,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC;YAC5E,CAAC;YACD,OAAO;QACT;YACE,gEAAgE;YAChE,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;IACrD,CAAC;AACH,CAAC,CAAC;AAEF,sEAAsE;AACtE,MAAM,UAAU,oBAAoB,CAAC,QAAsC;IACzE,MAAM,GAAG,GAA0B,EAAE,CAAC;IACtC,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC7E,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/mutations/define-mutation.d.ts

@@ -0,0 +1,32 @@
+import type { z } from "zod";
+import type { Graph } from "../graph/graph.js";
+import type { Primitive } from "../graph/primitives.js";
+import type { AnySchema } from "../schema/schema.js";
+import type { AnyMutationDefinition, MutationDefinition, MutationDefinitionSpec } from "./types.js";
+export declare function defineMutation<S extends AnySchema, const Name extends string, I extends z.ZodType>(name: Name, spec: MutationDefinitionSpec<S, I>): MutationDefinition<S, Name, I>;
+export interface CompiledMutation {
+    readonly primitives: readonly Primitive[];
+    /** Node ids the mutation looked at while computing its writes. */
+    readonly reads: readonly string[];
+    readonly writes: readonly string[];
+    readonly intent: string;
+}
+/** Whether an act takes the framework's `id` argument: it creates, and has no `id` of its own. */
+export declare function takesAnId(definition: Pick<AnyMutationDefinition, "creates" | "input">): boolean;
+/**
+ * An id from a name: the name's own letters, folded and hyphenated.
+ *
+ * It kept ASCII and dropped everything else, so "Zoë Lamarré" became
+ * `artist:zo-lamarr` — an address that is neither her name nor anybody's —
+ * and a name in any script without Latin letters became `item`. Accents are
+ * folded the way search folds them (`zoe-lamarre`, the id a person would
+ * guess), and a letter with no Latin form is kept as the letter it is.
+ */
+export declare function slug(label: string): string;
+/**
+ * Runs a mutation against the graph WITHOUT applying it, returning the
+ * primitives it would emit plus the causal read set. Applying is the op
+ * log's job — keeping the two apart is what makes preview-as-diff free.
+ */
+export declare function compileMutation<S extends AnySchema>(graph: Graph<S>, definition: AnyMutationDefinition<S>, rawArgs: unknown): CompiledMutation;
+//# sourceMappingURL=define-mutation.d.ts.map

package/dist/mutations/define-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-mutation.d.ts","sourceRoot":"","sources":["../../src/mutations/define-mutation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGxD,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EACV,qBAAqB,EAErB,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,cAAc,CAC5B,CAAC,SAAS,SAAS,EACnB,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,CAAC,SAAS,CAAC,CAAC,OAAO,EAEnB,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAEhC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,kGAAkG;AAClG,wBAAgB,SAAS,CAAC,UAAU,EAAE,IAAI,CAAC,qBAAqB,EAAE,SAAS,GAAG,OAAO,CAAC,GAAG,OAAO,CAI/F;AAiBD;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAS1C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,SAAS,EACjD,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,UAAU,EAAE,qBAAqB,CAAC,CAAC,CAAC,EACpC,OAAO,EAAE,OAAO,GACf,gBAAgB,CAwIlB"}