@graview/core 0.1.12 → 0.1.15

package/dist/document/compile.js

@@ -1,18 +1,16 @@
-import { RuleBudgetError, withArticle, brandFromAccent, createSchema, defineInvariant, defineMutation, defineNode, SCHEMES, } from "../index.js";
-import * as z from "../schema/zod.js";
-import { refTo } from "../mutations/node-ref.js";
+import { brandFromAccent, SCHEMES } from "../index.js";
+import { ActRefusal } from "../refused.js";
 import { analyzeExpr } from "./expr/analyze.js";
-import { rememberDocument } from "./to-document.js";
-import { evaluateExpr, ExprBudgetError, ExprEvalError } from "./expr/evaluate.js";
 import { ExprSyntaxError, parseExpr } from "./expr/parse.js";
 import { error, hasErrors, warning } from "./findings.js";
 import { DocumentSpec, MAX_DOCUMENT_BYTES, } from "./schema.js";
-import { parseTemplate, renderTemplate, TemplateError } from "./template.js";
+import { parseTemplate, TemplateError } from "./template-parse.js";
 import { upgradeDocument } from "./upgrade.js";
 import { homeOf, validateViews, viewsOf } from "./views.js";
+import { farEnd } from "./far-end.js";
 import { computedOf, parsedComputed, validateComputed, workedOutAlone } from "./computed.js";
+import { build, COMPILED_FORMAT, defaultLabelField, refName, SUBJECT_ARG, } from "./compiled.js";
 const BUILTIN_REFS = new Set(["subject", "now", "today"]);
-const SUBJECT_ARG = "id";
 /** Parse and validate without compiling — the document's own sentences, before the framework's. */
 export function readDocument(raw) {
     if (typeof raw === "string") {
@@ -88,6 +86,13 @@ export function kindShapes(document) {
 export function effectsOf(act, document) {
     // Shorthands first, then any listed effects: an act may say "writes quote" and also set a status.
     const effects = [];
+    const subject = asArray(act.on);
+    // A relation joins its subject from whichever end the declaration puts it (FR-115): `owns` on a component links from the person given.
+    const link = (relation, verb) => {
+        const reversed = farEnd(document.kinds, relation, subject)?.reversed === true;
+        const [from, to] = reversed ? ["$to", "$subject"] : ["$subject", "$to"];
+        return verb === "connect" ? { connect: relation, from, to } : { sever: relation, from, to };
+    };
     if (act.creates) {
         const kind = document.kinds[act.creates];
         const set = {};
@@ -104,17 +109,22 @@ export function effectsOf(act, document) {
     // An act that makes a record already asks for each of its fields: `writes` beside `creates` (and no `on`) names some of them again, not a subject.
     if (act.writes && !(act.creates && act.on === undefined))
         effects.push({ set: Object.fromEntries(act.writes.map((f) => [f, `$${f}`])) });
-    if (act.connects)
-        effects.push({ connect: act.connects, from: "$subject", to: "$to" });
+    if (act.connects) {
+        if (act.replaces)
+            effects.push({ replace: act.replaces === true ? [act.connects] : [...act.replaces], keep: act.connects });
+        effects.push(link(act.connects, "connect"));
+    }
     if (act.severs)
-        effects.push({ sever: act.severs, from: "$subject", to: "$to" });
+        effects.push(link(act.severs, "sever"));
+    // What it sets on the record at the other end (FR-115): that record is its `$to`.
+    if (act.setsOther && (act.connects || act.severs))
+        effects.push({ set: act.setsOther, target: "$to" });
     if (act.removes)
         effects.push({ remove: "$subject" });
     if (act.effects)
         effects.push(...act.effects.filter((e) => !(act.creates && "set" in e && !("create" in e) && refName(e.target) === "new")));
     return effects;
 }
-const refName = (v) => (typeof v === "string" && /^\$[A-Za-z][A-Za-z0-9]*$/.test(v) ? v.slice(1) : undefined);
 function tryExpr(source, path, findings) {
     try {
         const expr = parseExpr(source);
@@ -336,75 +346,30 @@ function validate(document) {
     findings.push(...validateComputed(new Map(Object.entries(document.kinds).map(([kind, spec]) => [kind, { fields: new Set(Object.keys(spec.fields)), edges: new Set(Object.keys(spec.edges ?? {})), computed: computedOf(spec) }])), (kind, name) => `kinds.${kind}.computed.${name}`));
     return findings;
 }
-/*
- * A FIELD'S SCHEMA, in zod/mini (schema/zod.ts): a page that compiles a
- * document in the browser pays for the checks it calls, not for classic
- * zod whole (FR-57). The checks, their messages and their definitions are
- * the ones classic's methods make.
- */
-function fieldSchema(spec, optional) {
-    let schema;
-    switch (spec.type) {
-        case "string":
-            schema = z.string().check(z.maxLength(500));
-            break;
-        case "text":
-            schema = z.string().check(z.maxLength(20_000));
-            break;
-        case "number":
-            schema = z.number();
-            break;
-        case "integer":
-            schema = z.number().check(z.int());
-            break;
-        case "boolean":
-            schema = z.boolean();
-            break;
-        case "date":
-            schema = z.string().check(z.regex(/^\d{4}-\d{2}-\d{2}$/, "a date like 2026-10-02"));
-            break;
-        case "datetime":
-            schema = z.string().check(z.refine((s) => !Number.isNaN(Date.parse(s)), "a date and time like 2026-10-02T14:30:00Z"));
-            break;
-        case "enum":
-            schema = z.enum(spec.options);
-            break;
-        case "list":
-            schema = z.array(spec.of === "number" ? z.number() : spec.of === "date" ? z.string().check(z.regex(/^\d{4}-\d{2}-\d{2}$/)) : z.string().check(z.maxLength(500))).check(z.maxLength(200));
-            break;
-        case "url":
-            schema = z.url();
-            break;
-        case "email":
-            schema = z.email();
-            break;
-    }
-    if (spec.description)
-        schema = schema.check(z.describe(spec.description));
-    return optional ? z.optional(schema) : schema;
-}
-/** What one of these is called, when the kind says nothing: the first required word-ish field. */
-function defaultLabelField(spec) {
-    const entries = Object.entries(spec.fields);
-    return (entries.find(([, f]) => f.required && (f.type === "string" || f.type === "text"))?.[0] ??
-        entries.find(([, f]) => f.type === "string")?.[0]);
-}
 /** The arguments an act asks for: declared ones, then whatever its effects reference. */
-function argsOf(name, act, effects, document, edges) {
+function argsOf(act, effects, document, edges) {
     const args = new Map();
     const subjectKinds = asArray(act.on);
     const created = new Map();
+    /** The kinds a record argument names, by argument: what a `set` on it (a `setsOther`) is checked against. */
+    const named = new Map();
     const usesSubject = subjectKinds.length > 0 ||
         effects.some((e) => ("remove" in e && refName(e.remove) === "subject") || ("from" in e && (refName(e.from) === "subject" || refName(e.to) === "subject")) || ("set" in e && !("create" in e) && refName(e.target ?? "$subject") === "subject"));
     if (usesSubject)
-        args.set(SUBJECT_ARG, { schema: refTo(subjectKinds.length > 0 ? subjectKinds : "*"), required: true });
+        args.set(SUBJECT_ARG, { ref: subjectKinds.length > 0 ? subjectKinds : "*", required: true });
     const declared = act.args ?? {};
     const writesOnlyOne = act.writes?.length === 1;
-    const note = (arg, schema) => {
+    /*
+     * A declared argument that fills a number field and says no range of its
+     * own is asked for within the field's (FR-114): the form will not take
+     * what the record would refuse.
+     */
+    const withRangeOf = (d, fed) => fed && d.type === fed.type && d.min === undefined && d.max === undefined && d.step === undefined ? { ...d, ...(fed.min === undefined ? {} : { min: fed.min }), ...(fed.max === undefined ? {} : { max: fed.max }), ...(fed.step === undefined ? {} : { step: fed.step }) } : d;
+    const note = (arg, schema, fed) => {
         if (arg === SUBJECT_ARG || BUILTIN_REFS.has(arg) || created.has(arg) || args.has(arg))
             return;
-        const d = declared[arg];
-        args.set(arg, d ? { schema: fieldSchema(d, !d.required), required: Boolean(d.required) } : schema());
+        const d = declared[arg] ? withRangeOf(declared[arg], fed) : undefined;
+        args.set(arg, d ? { field: d, optional: !d.required, required: Boolean(d.required) } : schema());
     };
     for (const effect of effects) {
         if ("create" in effect) {
@@ -414,7 +379,7 @@ function argsOf(name, act, effects, document, edges) {
                 const spec = kind?.fields[field];
                 if (arg && spec) {
                     const required = Boolean(spec.required) && spec.default === undefined;
-                    note(arg, () => ({ schema: fieldSchema(spec, !required), required }));
+                    note(arg, () => ({ field: spec, optional: !required, required }), spec);
                 }
             }
             if (effect.as)
@@ -427,36 +392,35 @@ function argsOf(name, act, effects, document, edges) {
                 if (!arg)
                     continue;
                 const kinds = end === "to" ? edge?.to ?? "*" : edge?.from ?? "*";
-                note(arg, () => ({ schema: refTo(kinds === "*" ? "*" : kinds), required: true }));
+                if (kinds !== "*" && !named.has(arg))
+                    named.set(arg, kinds);
+                note(arg, () => ({ ref: kinds, required: true }));
             }
         }
         else if ("set" in effect) {
             const target = refName(effect.target ?? "$subject");
-            const targetKind = target === "subject" ? subjectKinds[0] : created.get(target ?? "");
+            const targetKind = target === "subject" ? subjectKinds[0] : (created.get(target ?? "") ?? named.get(target ?? "")?.[0]);
             if (target && target !== "subject" && !created.has(target))
-                note(target, () => ({ schema: refTo("*"), required: true }));
+                note(target, () => ({ ref: "*", required: true }));
             for (const [field, value] of Object.entries(effect.set)) {
                 const arg = refName(value);
                 if (!arg)
                     continue;
                 const spec = targetKind ? document.kinds[targetKind]?.fields[field] : undefined;
-                note(arg, () => (spec ? { schema: fieldSchema(spec, !writesOnlyOne), required: writesOnlyOne } : { schema: z.optional(z.unknown()), required: false }));
+                note(arg, () => (spec ? { field: spec, optional: !writesOnlyOne, required: writesOnlyOne } : { any: true, required: false }), spec);
             }
         }
         else if ("remove" in effect) {
             const arg = refName(effect.remove);
             if (arg)
-                note(arg, () => ({ schema: refTo("*"), required: true }));
+                note(arg, () => ({ ref: "*", required: true }));
         }
     }
     for (const [arg, d] of Object.entries(declared))
         if (!args.has(arg))
-            args.set(arg, { schema: fieldSchema(d, !d.required), required: Boolean(d.required) });
-    void name;
+            args.set(arg, { field: d, optional: !d.required, required: Boolean(d.required) });
     return args;
 }
-class Refused extends Error {
-}
 /**
  * A DOCUMENT COMPILED WITHOUT THE FRAMEWORK'S CHECKER: its own sentences
  * still judged, `checkApp` not asked. For a page drawing a document its host
@@ -473,71 +437,80 @@ export function compileDocumentWithoutCheck(raw, options = {}) {
     const findings = [...read.findings];
     if (options.previous)
         findings.push(...renamesFromNothing(document, options.previous));
-    const today = options.today ?? (() => new Date().toISOString().slice(0, 10));
-    const shapes = kindShapes(document);
+    const plan = planOf(document, findings);
+    if (hasErrors(plan.findings))
+        return { ok: false, findings: plan.findings };
+    return build(plan, options);
+}
+/**
+ * The first half of compiling (FR-123): what a document that has been read
+ * and judged compiles to, as data — each template and expression parsed,
+ * each act's arguments and effects said, the brand derived. `findings` is
+ * added to (a brand that cannot be read is a warning) and carried.
+ */
+function planOf(document, findings) {
     const edges = edgeIndex(document);
-    // What `{x | money}` says in a label, a sentence or a refusal: the app's currency and locale (FR-100).
-    const { accent, name: wordmark, ...money } = document.brand ?? {};
     // ── kinds ────────────────────────────────────────────────────────────────
-    const definitions = Object.entries(document.kinds).map(([kind, spec]) => {
-        const shape = {};
-        for (const [field, f] of Object.entries(spec.fields))
-            shape[field] = fieldSchema(f, !f.required);
-        const labelSource = spec.label ?? (defaultLabelField(spec) ? `{${defaultLabelField(spec)}}` : undefined);
-        const labelParts = labelSource ? parseTemplate(labelSource) : undefined;
-        const describeParts = spec.describe ? parseTemplate(spec.describe) : undefined;
-        const computed = computedOf(spec);
-        // A computed field's words are said like a field's: its label, where it has one.
-        const labels = Object.fromEntries([
-            ...Object.entries(spec.fields).filter(([, f]) => f.label).map(([n, f]) => [n, f.label]),
-            ...[...computed].filter(([, c]) => c.label).map(([n, c]) => [n, c.label]),
-        ]);
-        // Defaults stay out of the zod schema (hydration must not invent values) and ride beside it, for a repair to read.
-        const defaults = Object.fromEntries(Object.entries(spec.fields).filter(([, f]) => f.default !== undefined).map(([n, f]) => [n, f.default]));
-        const edgeDecls = Object.fromEntries(Object.entries(spec.edges ?? {}).map(([n, e]) => [
-            n,
-            {
-                to: e.to,
-                ...(e.cardinality ? { cardinality: e.cardinality } : {}),
-                ...(e.description ? { description: e.description } : {}),
-                ...(e.inverse ? { inverse: e.inverse } : {}),
-                ...(e.appendOnly ? { appendOnly: e.appendOnly } : {}),
-            },
-        ]));
-        return defineNode(kind, {
-            fields: z.object(shape),
-            edges: edgeDecls,
-            ...(spec.plural ? { plural: spec.plural } : {}),
-            ...(spec.noun ? { noun: spec.noun } : {}),
-            ...(spec.description ? { description: spec.description } : {}),
-            ...(labelParts ? { label: (node) => renderTemplate(labelParts, { node: node, kinds: shapes, today: today(), money }) || node.id } : {}),
-            ...(describeParts ? { describe: (node) => renderTemplate(describeParts, { node: node, kinds: shapes, today: today(), money }) } : {}),
-            ...(spec.lifecycle ? { lifecycle: { field: spec.lifecycle.field, retired: spec.lifecycle.retired } } : {}),
-            ...(spec.figure ? { figure: spec.figure } : {}),
-            ...(spec.computed && Object.keys(spec.computed).length > 0 ? { computed: spec.computed } : {}),
-            ...(Object.keys(labels).length > 0 || spec.glance ? { display: { ...(Object.keys(labels).length > 0 ? { labels } : {}), ...(spec.glance ? { glance: [...spec.glance] } : {}) } } : {}),
-            ...(Object.keys(defaults).length > 0 ? { defaults } : {}),
-        });
-    });
-    const schema = createSchema(definitions);
+    const kinds = {};
+    for (const [kind, spec] of Object.entries(document.kinds)) {
+        const labelField = defaultLabelField(spec);
+        const labelSource = spec.label ?? (labelField ? `{${labelField}}` : undefined);
+        const computed = parsedComputed(spec);
+        kinds[kind] = {
+            ...(labelSource ? { label: parseTemplate(labelSource) } : {}),
+            ...(spec.describe ? { describe: parseTemplate(spec.describe) } : {}),
+            ...(computed ? { computed: [...computed] } : {}),
+        };
+    }
     // ── acts ─────────────────────────────────────────────────────────────────
-    const mutations = [];
+    const acts = {};
     for (const [name, act] of Object.entries(document.acts ?? {})) {
         const effects = effectsOf(act, document);
-        const args = argsOf(name, act, effects, document, edges);
-        const shape = {};
-        for (const [arg, a] of args)
-            shape[arg] = a.schema;
-        const subjectKinds = asArray(act.on);
-        const title = act.title ?? name.replace(/-/g, " ");
-        const guard = act.allowedWhen ? parseExpr(act.allowedWhen) : undefined;
-        const refusal = act.refusal ? parseTemplate(act.refusal) : undefined;
-        const destructive = act.destructive ?? effects.some((e) => "remove" in e || "sever" in e);
+        const args = argsOf(act, effects, document, edges);
+        const destructive = act.destructive ?? effects.some((e) => "remove" in e || "sever" in e || "replace" in e);
         const creates = [...new Set(effects.flatMap((e) => ("create" in e ? [e.create] : [])))];
         const connects = [...new Set(effects.flatMap((e) => ("connect" in e ? [e.connect] : [])))];
-        const severs = [...new Set(effects.flatMap((e) => ("sever" in e ? [e.sever] : [])))];
+        // What it may sever: what it says it severs, and what it replaces (FR-115).
+        const severs = [...new Set(effects.flatMap((e) => ("sever" in e ? [e.sever] : "replace" in e ? e.replace : [])))];
         // An act WRITES only what it sets on its subject; setting fields on a record it just made is part of making it.
         const writes = [...new Set(effects.flatMap((e) => ("set" in e && !("create" in e) && (refName(e.target ?? "$subject") === "subject") ? Object.keys(e.set) : [])))];
+        /*
+         * And what it sets on the record at an end of a link it makes or breaks
+         * (FR-115's `setsOther`), by that end's kinds: not the subject's, but a
+         * field another act sets, so no derived edit offers it freely.
+         */
+        const ends = new Map();
+        for (const e of effects) {
+            if (!("connect" in e) && !("sever" in e))
+                continue;
+            const edge = edges.get("connect" in e ? e.connect : e.sever);
+            for (const [end, value] of [["from", e.from], ["to", e.to]]) {
+                const ref = refName(value);
+                const kinds = end === "to" ? edge?.to : edge?.from;
+                if (ref && ref !== "subject" && kinds && kinds !== "*")
+                    ends.set(ref, [...new Set([...(ends.get(ref) ?? []), ...kinds])]);
+            }
+        }
+        const writesOther = {};
+        for (const e of effects) {
+            if (!("set" in e) || "create" in e)
+                continue;
+            const target = refName(e.target ?? "$subject");
+            for (const kind of (target && target !== "subject" && ends.get(target)) || [])
+                writesOther[kind] = [...new Set([...(writesOther[kind] ?? []), ...Object.keys(e.set)])];
+        }
+        // What it sets on its subject to a fixed value, whatever it is told — a named step (FR-108), resolved as `apply` resolves a literal.
+        const sets = {};
+        for (const e of effects) {
+            if (!("set" in e) || "create" in e || refName(e.target ?? "$subject") !== "subject")
+                continue;
+            for (const [field, v] of Object.entries(e.set ?? {})) {
+                if ((typeof v === "string" && refName(v) === undefined) || typeof v === "number" || typeof v === "boolean")
+                    sets[field] = typeof v === "string" && v.startsWith("$$") ? v.slice(1) : v;
+                else
+                    delete sets[field];
+            }
+        }
         /*
          * Twice is once when nothing is made and every value set is given
          * (a literal or an argument), never computed from what is there.
@@ -552,227 +525,37 @@ export function compileDocumentWithoutCheck(raw, options = {}) {
                 if (v && typeof v === "object" && !Array.isArray(v) && "expr" in v)
                     exprs.set(v.expr, parseExpr(v.expr));
         }
-        mutations.push(defineMutation(name, {
-            input: z.object(shape),
-            title,
-            ...(act.description ? { description: act.description } : {}),
-            ...(act.fromTheOtherEnd ? { fromTheOtherEnd: act.fromTheOtherEnd } : {}),
-            ...(args.has(SUBJECT_ARG) ? { subject: { kinds: subjectKinds.length > 0 ? subjectKinds : "*", arg: SUBJECT_ARG } } : {}),
-            ...(destructive ? { destructive: true } : {}),
-            ...(idempotent ? { idempotent: true } : {}),
-            ...(creates.length > 0 ? { creates } : {}),
-            ...(connects.length > 0 ? { connects } : {}),
-            ...(severs.length > 0 ? { severs } : {}),
-            ...(writes.length > 0 ? { writes } : {}),
-            describe: (input, graph) => {
-                const subject = typeof input[SUBJECT_ARG] === "string" ? graph.getNode(input[SUBJECT_ARG]) : undefined;
-                const what = subject ? labelFor(subject) : Object.values(input).find((v) => typeof v === "string");
-                return what ? `${title}: ${String(what)}` : title;
-            },
-            apply(context, input) {
-                const graph = context.graph;
-                const subjectId = typeof input[SUBJECT_ARG] === "string" ? input[SUBJECT_ARG] : undefined;
-                const subject = subjectId ? graph.getNode(subjectId) : undefined;
-                if (subjectId && !subject)
-                    throw new Refused(`there is no record "${subjectId}"`);
-                if (subject && subjectKinds.length > 0 && !subjectKinds.includes(subject.kind))
-                    throw new Refused(`"${title}" acts on ${subjectKinds.join(" or ")}, not on ${withArticle(subject.kind)}`);
-                const bindings = {};
-                for (const [k, v] of Object.entries(input))
-                    if (v !== undefined)
-                        bindings[k] = v;
-                if (guard && subject) {
-                    let allowed;
-                    try {
-                        allowed = evaluateExpr(guard, { graph, subject, kinds: shapes, bindings, today: today() });
-                    }
-                    catch (e) {
-                        if (e instanceof ExprEvalError)
-                            throw new Refused(`"${title}" could not be judged: ${e.sentence}`);
-                        throw e;
-                    }
-                    if (allowed !== true) {
-                        throw new Refused(refusal ? renderTemplate(refusal, { node: subject, kinds: shapes, graph, bindings, today: today(), money }) : `"${title}" is not allowed for ${labelFor(subject)} right now`);
-                    }
-                }
-                const made = new Map();
-                const resolve = (value, current) => {
-                    if (value && typeof value === "object" && !Array.isArray(value) && "expr" in value) {
-                        try {
-                            return evaluateExpr(exprs.get(value.expr), { graph, subject: current ?? subject ?? null, kinds: shapes, bindings, today: today() });
-                        }
-                        catch (e) {
-                            if (e instanceof ExprEvalError)
-                                throw new Refused(`"${title}" could not work out a value: ${e.sentence}`);
-                            throw e;
-                        }
-                    }
-                    const ref = refName(value);
-                    if (ref === undefined)
-                        return typeof value === "string" && value.startsWith("$$") ? value.slice(1) : value;
-                    if (ref === "subject")
-                        return subjectId;
-                    if (ref === "now")
-                        return new Date().toISOString();
-                    if (ref === "today")
-                        return today();
-                    if (made.has(ref))
-                        return made.get(ref);
-                    return input[ref];
-                };
-                for (const effect of effects) {
-                    if ("create" in effect) {
-                        const kind = document.kinds[effect.create];
-                        const node = { kind: effect.create };
-                        for (const [field, f] of Object.entries(kind.fields))
-                            if (f.default !== undefined)
-                                node[field] = f.default;
-                        for (const [field, value] of Object.entries(effect.set ?? {})) {
-                            const v = resolve(value, undefined);
-                            if (v !== undefined)
-                                node[field] = v;
-                        }
-                        const labelField = defaultLabelField(kind);
-                        const id = context.freshId(String((labelField && node[labelField]) ?? effect.create), effect.create);
-                        context.addNode({ id, ...node });
-                        if (effect.as)
-                            made.set(effect.as, id);
-                    }
-                    else if ("connect" in effect || "sever" in effect) {
-                        const kind = "connect" in effect ? effect.connect : effect.sever;
-                        const from = String(resolve(effect.from, undefined) ?? "");
-                        const to = String(resolve(effect.to, undefined) ?? "");
-                        if (!graph.has(from) && ![...made.values()].includes(from))
-                            throw new Refused(`there is no record "${from}"`);
-                        if (!graph.has(to) && ![...made.values()].includes(to))
-                            throw new Refused(`there is no record "${to}"`);
-                        if ("connect" in effect) {
-                            if (edges.get(kind)?.cardinality === "one")
-                                for (const existing of graph.out(from, kind))
-                                    if (existing.id !== to)
-                                        context.removeEdge({ kind, from, to: existing.id });
-                            if (!graph.out(from, kind).some((n) => n.id === to))
-                                context.addEdge({ kind, from, to });
-                        }
-                        else {
-                            context.removeEdge({ kind, from, to });
-                        }
-                    }
-                    else if ("set" in effect) {
-                        const targetId = String(resolve(effect.target ?? "$subject", undefined) ?? "");
-                        const target = graph.getNode(targetId);
-                        if (!target && ![...made.values()].includes(targetId))
-                            throw new Refused(`there is no record "${targetId}"`);
-                        const patch = {};
-                        for (const [field, value] of Object.entries(effect.set)) {
-                            const v = resolve(value, target);
-                            if (v !== undefined)
-                                patch[field] = v;
-                        }
-                        if (Object.keys(patch).length > 0)
-                            context.patchNode(targetId, patch);
-                    }
-                    else if ("remove" in effect) {
-                        const id = String(resolve(effect.remove, undefined) ?? "");
-                        if (!graph.has(id))
-                            throw new Refused(`there is no record "${id}"`);
-                        context.removeNode(id);
-                    }
-                }
-            },
-        }));
-    }
-    function labelFor(node) {
-        const definition = schema.tryDefinition(node.kind);
-        return definition?.label?.(node) ?? node.id;
+        acts[name] = {
+            title: act.title ?? name.replace(/-/g, " "),
+            effects,
+            args: [...args],
+            ...(act.allowedWhen ? { guard: parseExpr(act.allowedWhen) } : {}),
+            ...(act.refusal ? { refusal: parseTemplate(act.refusal) } : {}),
+            exprs: [...exprs],
+            destructive,
+            idempotent,
+            creates,
+            connects,
+            severs,
+            writes,
+            writesOther,
+            sets,
+        };
     }
     // ── rules ────────────────────────────────────────────────────────────────
-    const invariants = [];
+    const rules = {};
     for (const [name, rule] of Object.entries(document.rules ?? {})) {
-        const require = parseExpr(rule.require);
-        const when = rule.when ? parseExpr(rule.when) : undefined;
-        const says = rule.says ? parseTemplate(rule.says) : undefined;
-        const title = rule.title ?? name.replace(/-/g, " ");
-        const repairs = rule.repairs ?? [];
-        const judge = (graph, subject) => {
-            const ctx = { graph, subject, kinds: shapes, today: today() };
-            let holds;
-            /*
-             * A RULE THAT CANNOT ANSWER IS THE ENGINE'S TO SAY (FR-29). Out of
-             * budget it throws RuleBudgetError, and the violation's status is
-             * `over-budget`; any other mistake (a word added to a number) is
-             * `could-not-judge`. Both name the rule and its subject, and neither
-             * is a hang or a crash that takes the other rules down.
-             */
-            try {
-                if (when && evaluateExpr(when, ctx) !== true)
-                    return [];
-                holds = evaluateExpr(require, ctx) === true;
-            }
-            catch (e) {
-                if (e instanceof ExprBudgetError)
-                    throw new RuleBudgetError(e.sentence);
-                if (e instanceof ExprEvalError)
-                    throw new Error(e.sentence);
-                throw e;
-            }
-            if (holds)
-                return [];
-            const repairList = repairs.flatMap((r) => {
-                const act = document.acts?.[r.act];
-                const args = {};
-                if (subject && (act?.on || /^(edit|remove)-/.test(r.act)))
-                    args[SUBJECT_ARG] = subject.id;
-                for (const [k, v] of Object.entries(r.args ?? {}))
-                    args[k] = refName(v) === "subject" ? subject?.id : v;
-                const declared = act ? argsOf(r.act, act, effectsOf(act, document), document, edges) : new Map();
-                const missing = [...declared].filter(([k, a]) => a.required && args[k] === undefined).map(([k]) => k);
-                return [{ mutation: r.act, label: r.label ?? act?.title ?? r.act.replace(/-/g, " "), args, ...(missing.length > 0 ? { missing } : {}) }];
-            });
-            return [
-                {
-                    invariant: name,
-                    ...(subject ? { subjectId: subject.id } : {}),
-                    label: title,
-                    message: (says ? renderTemplate(says, { node: subject, kinds: shapes, graph, today: today(), money }) : subject ? `${labelFor(subject)}: ${title}` : title),
-                    nodeIds: subject ? [subject.id] : [],
-                    repairs: repairList,
-                },
-            ];
+        rules[name] = {
+            title: rule.title ?? name.replace(/-/g, " "),
+            require: parseExpr(rule.require),
+            ...(rule.when ? { when: parseExpr(rule.when) } : {}),
+            ...(rule.says ? { says: parseTemplate(rule.says) } : {}),
         };
-        invariants.push((rule.over === "graph"
-            ? defineInvariant(name, {
-                scope: "graph",
-                label: title,
-                judgement: { require: rule.require, ...(rule.when ? { when: rule.when } : {}), ...(rule.says ? { says: rule.says } : {}) },
-                ...(rule.description ? { description: rule.description } : {}),
-                ...(repairs.length > 0 ? { repairs: repairs.map((r) => r.act) } : {}),
-                evaluate: ({ graph }) => judge(graph, null),
-            })
-            : defineInvariant(name, {
-                scope: { kind: rule.over },
-                label: title,
-                judgement: { require: rule.require, ...(rule.when ? { when: rule.when } : {}), ...(rule.says ? { says: rule.says } : {}) },
-                ...(rule.description ? { description: rule.description } : {}),
-                ...(repairs.length > 0 ? { repairs: repairs.map((r) => r.act) } : {}),
-                evaluate: ({ graph, subject }) => judge(graph, subject),
-            })));
     }
-    // ── policy, brand, the rest ──────────────────────────────────────────────
-    /*
-     * WHO SEES WHAT is the app's, in the framework's one meaning (FR-02):
-     * absent, everybody sees everything; present, a kind no sight names is
-     * seen by nobody but the system, and `own` is the principal's own records.
-     */
-    const policy = document.policy
-        ? {
-            grants: document.policy.grants,
-            ...(document.policy.sees ? { sees: document.policy.sees } : {}),
-            ...(document.roles ? { roles: document.roles } : {}),
-        }
-        : undefined;
+    // ── brand, views ─────────────────────────────────────────────────────────
     let brand;
     if (document.brand) {
+        const { accent, name: wordmark, ...money } = document.brand;
         const derived = accent ? brandFromAccent({ accent, base: SCHEMES }) : undefined;
         // A colour that cannot be read is not a reason to refuse an app: it wears the default colours and says why.
         if (derived && !derived.ok)
@@ -781,29 +564,20 @@ export function compileDocumentWithoutCheck(raw, options = {}) {
         if (!derived || derived.ok || money.currency || money.locale)
             brand = { name: wordmark ?? document.name, schemes: derived?.ok ? derived.schemes : SCHEMES, ...money };
     }
-    if (hasErrors(findings))
-        return { ok: false, findings };
-    const app = {
-        name: document.name,
-        schema,
-        mutations,
-        invariants,
-        ...(policy ? { policy } : {}),
+    const viewSpecs = viewsOf(document);
+    const home = homeOf(document);
+    return {
+        format: COMPILED_FORMAT,
+        document,
+        findings,
+        kinds,
+        edges: [...edges].map(([name, { from, to, cardinality }]) => [name, { from, to, cardinality }]),
+        acts,
+        rules,
         ...(brand ? { brand } : {}),
-        ...(document.modules ? { modules: document.modules } : {}),
-        ...(document.lenses ? { lenses: document.lenses } : {}),
-        // The arrangement is the app's (FR-80): every face reads it beside the places.
-        ...(document.pages ? { pages: document.pages } : {}),
-        ...(document.settings ? { settings: document.settings } : {}),
-        // The document's views are the declaration's view specs (FR-03): data the framework draws.
-        ...(Object.keys(viewsOf(document)).length > 0 ? { viewSpecs: viewsOf(document) } : {}),
-        // And its home view, about no one record, is the app's home (FR-81).
-        ...(homeOf(document) ? { home: homeOf(document) } : {}),
-        version: document.version ?? 1,
+        ...(Object.keys(viewSpecs).length > 0 ? { viewSpecs } : {}),
+        ...(home ? { home } : {}),
     };
-    // `toDocument(app)` gives this document back, byte for byte.
-    rememberDocument(app, document);
-    return { ok: true, app, document, findings, sights: document.policy?.sees, kinds: shapes };
 }
 /** Map a framework check's "where" (a kind, an act, a rule by name) back to a document path when we can. */
 export function frameworkPath(where, document) {
@@ -829,7 +603,7 @@ export function inDocumentWords(finding, where, document) {
     const first = Object.keys(spec.fields).filter((field) => field !== "label").slice(0, 3);
     return { ...finding, path: `kinds.${kind}.glance`, fix: `Say which: "glance": [${first.map((field) => `"${field}"`).join(", ")}] on kinds.${kind} — the facts a person compares one by, at a glance.` };
 }
-export { Refused as ActRefusal };
+export { ActRefusal };
 /** Every `renamedFrom` that names nothing in the version before: the values it was meant to carry would be lost. */
 function renamesFromNothing(document, previous) {
     const out = [];