@cruba/crubal 0.1.0 → 0.2.0

package/dist/src/bundle.js

@@ -0,0 +1,753 @@
+// bundle.ts: a package as one JSON document (docs/design/publishing.md; spec 4.6, 5.9, 6.10, 7.9, 10.6,
+// 11.6, 12.7, 14.11). Writers turn what the text readers produced into the JSON forms; the printer turns
+// the JSON forms back into the text form, so the text readers stay the one parser and a bundle is read by
+// printing it and reading the text. The hash is over the canonical form without `hash` and `sig`; the
+// signature is Ed25519 over the hash's bytes, as a log entry's is (8.5).
+import { readInstructionBlocks } from "./lifecycle.js";
+import { createPrivateKey, createPublicKey, sign as edSign, verify as edVerify } from "node:crypto";
+import { readAccess } from "./access.js";
+import { serialize } from "./canonical.js";
+import { emptyDictionary, readDefinitions } from "./defs.js";
+import { facetJson } from "./dictionary.js";
+import { readRecipes } from "./migrate.js";
+import { readPackages } from "./packages.js";
+import { readRules } from "./rules.js";
+import { readContracts, sha256, keyFor } from "./store.js";
+import { readViews } from "./views.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** Read a package's text with every reader. */
+export function parsePackage(source) {
+    const [info] = readPackages(source);
+    if (!info)
+        throw new Error("no package header");
+    const dict = readDefinitions(source);
+    const { perms, edges } = readAccess(source);
+    return { info, dict, rules: readRules(source), contracts: readContracts(source), views: readViews(source), perms, edges, recipes: readRecipes(source), instructions: readInstructionBlocks(source) };
+}
+// ─── Writers: the JSON forms ─────────────────────────────────────────────────
+const PRECISION_CODE = { year: "y", month: "ym", day: "ymd", hour: "ymdh", minute: "ymdhm", second: "ymdhms", any: "any" };
+export function kindJson(dict, k) {
+    const o = { kind: k.name, levels: [...k.levels] };
+    if (k.base)
+        o.base = k.base;
+    if (k.schema)
+        o.schema = k.schema;
+    const vary = {};
+    for (const level of k.levels) {
+        const keys = dict.vary.get(level);
+        if (keys?.size)
+            vary[level] = [...keys];
+    }
+    if (Object.keys(vary).length)
+        o.vary = vary;
+    if (k.follows)
+        o.follows = { ...k.follows };
+    const identify = {};
+    const match = {};
+    for (const level of k.levels) {
+        const i = dict.identify.get(level);
+        if (i?.length)
+            identify[level] = [...i];
+        const m = dict.match.get(level);
+        if (m?.length)
+            match[level] = m.map((g) => [...g]);
+    }
+    if (Object.keys(identify).length)
+        o.identify = identify;
+    if (Object.keys(match).length)
+        o.match = match;
+    const archive = dict.archive.get(k.name);
+    if (archive)
+        o.archive = archive;
+    return o;
+}
+export function classLineJson(l) {
+    const o = { facet: l.facet };
+    if (l.required)
+        o.required = true;
+    if (l.values)
+        o.values = [...l.values];
+    if (l.length !== undefined)
+        o.length = String(l.length);
+    if (l.pick !== undefined)
+        o.pick = l.pick;
+    if (l.range)
+        o.range = { min: l.range.min, max: l.range.max };
+    if (l.precision)
+        o.precision = l.precision;
+    if (l.level)
+        o.level = l.level;
+    if (l.when)
+        o.when = l.when;
+    if (l.frame)
+        o.frame = l.frame;
+    return o;
+}
+export function classJson(c) {
+    const o = { class: c.name };
+    if (c.label)
+        o.label = c.label;
+    if (c.describe)
+        o.describe = c.describe;
+    if (c.for.length)
+        o.for = [...c.for];
+    if (c.uses.length)
+        o.uses = [...c.uses];
+    const lines = [];
+    let section;
+    for (const l of c.lines) {
+        if (l.section !== section) {
+            section = l.section;
+            if (section)
+                lines.push({ section });
+        }
+        lines.push(classLineJson(l));
+    }
+    o.facets = lines;
+    if (c.parts.length)
+        o.parts = c.parts.map((p) => ({ slot: p.slot, wears: p.wears, pick: p.many ? "any" : "1", ...(p.fungible ? { fungible: true } : {}), ...(p.match ? { match: p.match } : {}) }));
+    if (c.state && c.state !== "active")
+        o.state = c.state;
+    if (c.version)
+        o.version = c.version;
+    return o;
+}
+export function ruleJson(r) {
+    const o = { rule: r.name };
+    if (r.for !== "everywhere")
+        o.for = r.for;
+    if (r.whenText)
+        o.when = r.whenText;
+    o.then = r.thenText;
+    o.strength = r.strength;
+    if (r.because)
+        o.because = r.because;
+    if (r.version)
+        o.version = r.version;
+    return o;
+}
+const mapJson = (m) => ({
+    ...(m.from.startsWith('"') ? { literal: JSON.parse(m.from) } : { from: m.from }),
+    to: m.to,
+    ...(m.values.length ? { values: m.values.map(([from, to]) => ({ from, to })) } : {}),
+});
+export function contractJson(c) {
+    const o = { contract: c.name, kind: c.kind };
+    for (const k of ["label", "describe", "for"])
+        if (c.parts[k] !== undefined)
+            o[k] = c.parts[k];
+    if (c.needs.length)
+        o.needs = c.needs.map(classLineJson);
+    if (c.gives.length)
+        o.gives = [...c.gives];
+    if (Object.keys(c.terms).length)
+        o.terms = { ...c.terms };
+    if (c.stores.length)
+        o.stores = c.stores.map(mapJson);
+    else {
+        if (c.writes.length)
+            o.writes = c.writes.map(mapJson);
+        if (c.reads.length)
+            o.reads = c.reads.map(mapJson);
+    }
+    if (c.stream.length)
+        o.stream = [...c.stream];
+    for (const k of ["when", "who", "from", "to", "mode", "undo", "ref", "prefix"])
+        if (c[k])
+            o[k] = c[k];
+    // origin is a part of the kinds that bring values in (7.2); the reader defaults it for the rest.
+    if (c.origin && ["receive", "form", "take"].includes(c.kind))
+        o.origin = c.origin;
+    if (c.lands !== "value")
+        o.lands = c.lands;
+    if (!c.absorb)
+        o.absorb = false;
+    if (c.ignore.length)
+        o.ignore = [...c.ignore];
+    if (c.keepRaw.length)
+        o["keep-raw"] = [...c.keepRaw];
+    for (const [k, v] of Object.entries(c.parts)) {
+        if (["label", "describe", "for", "needs", "gives", "terms", "writes", "reads", "stream", "when", "who", "from", "to", "mode", "undo", "ref", "origin", "prefix", "lands", "absorb", "ignore", "keep-raw", "kind"].includes(k))
+            continue;
+        if (k === "retry") {
+            const m = v.match(/^(\d+)\s+every\s+(\S+)$/);
+            o.retry = m ? { times: m[1], every: m[2] } : v;
+        }
+        else
+            o[k] = v;
+    }
+    return o;
+}
+export function recipeJson(r) {
+    const steps = r.steps.map((s) => {
+        const o = { facet: s.facet };
+        switch (s.verb) {
+            case "rename":
+            case "precision":
+            case "retype":
+                o[s.verb] = { from: s.from, to: s.to };
+                break;
+            case "merge":
+                o.merge = { from: [...s.from], to: s.to };
+                break;
+            case "convert":
+                o.convert = { from: s.from, to: s.to, rounding: s.rounding };
+                break;
+            case "split":
+                o.split = { value: s.value, when: s.when.map((w) => ({ if: w.cond, to: w.to })), ...(s.else !== undefined ? { else: s.else } : {}) };
+                break;
+            case "move":
+                o.move = { to: s.to };
+                break;
+            case "review":
+                o.review = s.cond;
+                break;
+            case "recompute":
+                o.recompute = true;
+                break;
+            case "fill":
+                o.fill = { value: s.value, ...(s.level ? { level: s.level } : {}), ...(s.when ? { when: s.when } : {}) };
+                break;
+        }
+        return o;
+    });
+    return { migration: { from: r.from, to: r.to }, steps };
+}
+export function shapeJson(s) {
+    return { shape: s.name, slots: s.slots.map((sl) => ({ ...(sl.from.startsWith('"') ? { template: JSON.parse(sl.from) } : { from: sl.from }), to: sl.to, ...(sl.required ? { required: true } : {}) })) };
+}
+export function filterJson(f) {
+    const o = { filter: f.name, facet: f.facet };
+    if (f.buckets)
+        o.buckets = f.buckets.map((b) => (b.range ? { name: b.name, range: { min: String(b.range[0]), max: String(b.range[1]) } } : { name: b.name, values: [...(b.values ?? [])] }));
+    if (f.dependent.length)
+        o.dependent = [...f.dependent];
+    return o;
+}
+export function viewJson(v) {
+    const select = {};
+    if (v.level)
+        select.level = v.level;
+    if (v.wears.length)
+        select.wears = [...v.wears];
+    if (v.when)
+        select.when = v.when;
+    if (v.list)
+        select.list = v.list;
+    const o = { view: v.name, select };
+    if (v.partition)
+        o.partition = v.partition;
+    if (v.of)
+        o.of = v.of;
+    if (v.pin.length)
+        o.pin = [...v.pin];
+    if (v.hide.length)
+        o.hide = [...v.hide];
+    if (v.order.length)
+        o.order = v.order.map((x) => ({ key: x.key, dir: x.dir }));
+    if (v.page !== 24)
+        o.page = String(v.page);
+    o.shape = v.shapes.length === 1 ? v.shapes[0] : [...v.shapes];
+    if (v.filters.length)
+        o.filters = [...v.filters];
+    if (v.index.length)
+        o.index = [...v.index];
+    if (v.show !== "public")
+        o.show = v.show;
+    if (v.fresh !== "write")
+        o.fresh = v.fresh;
+    if (v.version)
+        o.version = v.version;
+    return o;
+}
+/** The `role:` blocks, from the presets and menu items the access reader made of them (12.4). */
+export function rolesJson(perms) {
+    const out = [];
+    for (const p of perms.presets.values()) {
+        const own = p.items.filter((i) => i.startsWith(`${p.name}.`));
+        if (!own.length || own.length !== p.items.length)
+            continue;
+        const may = {};
+        for (const i of own) {
+            const item = perms.menu.get(i);
+            if (item)
+                for (const [verb, targets] of Object.entries(item.verbs))
+                    may[verb] = [...targets];
+        }
+        out.push({ role: p.name, audience: p.audience, may });
+    }
+    return out;
+}
+export function permissionsJson(perms) {
+    const roleItems = new Set(rolesJson(perms).flatMap((r) => Object.keys(r.may).map((v) => `${r.role}.${v}`)));
+    const menu = {};
+    for (const m of perms.menu.values())
+        if (!roleItems.has(m.name))
+            menu[m.name] = { verbs: Object.fromEntries(Object.entries(m.verbs).map(([v, t]) => [v, [...t]])), ...(m.on ? { on: m.on } : {}) };
+    const presets = {};
+    for (const p of perms.presets.values())
+        if (!roleItems.has(`${p.name}.${Object.keys(perms.menu.get(p.items[0] ?? "")?.verbs ?? {})[0]}`) && !p.items.every((i) => roleItems.has(i)))
+            presets[p.name] = { items: [...p.items], audience: p.audience };
+    const relations = {};
+    for (const [r, v] of perms.relations)
+        relations[r] = v.only ? { only: true } : {};
+    if (!perms.name && !Object.keys(menu).length && !Object.keys(relations).length)
+        return undefined;
+    return { permissions: perms.name ?? "", menu, presets, relations };
+}
+/** A utility block's JSON form (11.6). */
+export function utilityJson(u) {
+    const o = { utility: u.name, version: u.version };
+    if (u.label)
+        o.label = u.label;
+    if (u.describe)
+        o.describe = u.describe;
+    if (u.serves.length)
+        o.serves = u.serves.map((s) => ({ as: s.as, ...(s.items ? { items: [...s.items] } : {}) }));
+    if (u.needs.length)
+        o.needs = u.needs.map((n) => ({ name: n.name, ...(n.version ? { version: n.version } : {}) }));
+    if (u.setup.length)
+        o.setup = u.setup.map((s) => ("connection" in s ? { connection: s.connection } : { setting: s.setting }));
+    return o;
+}
+/** The whole package as the JSON document, without `hash` and `sig`. */
+export function bundleOf(p) {
+    const { info, dict } = p;
+    const o = { crubal: String(info.crubal), package: info.name, version: info.version, owner: info.owner, id: `${info.owner}/${info.name}` };
+    for (const k of ["label", "describe", "licence"])
+        if (info.header[k])
+            o[k] = info.header[k];
+    if (info.extends.length)
+        o.extends = info.extends.map((e) => ({ package: e.name, version: e.version }));
+    if (info.prefixes.size)
+        o.prefixes = Object.fromEntries([...info.prefixes].map(([k, v]) => [k, v.target]));
+    if (info.header.units) {
+        const [pkg = "", ver = ""] = info.header.units.split(/\s+\//).map((s) => s.trim());
+        o.units = { package: pkg, version: ver };
+    }
+    for (const k of ["confirm", "split", "recur"])
+        if (info.header[k])
+            o[k] = info.header[k];
+    if (dict.trust.length)
+        o.trust = [...dict.trust];
+    if (dict.facetTrust.size)
+        o["facet-trust"] = Object.fromEntries([...dict.facetTrust].map(([k, v]) => [k, [...v]]));
+    if (Object.keys(info.terms).length)
+        o.terms = { ...info.terms };
+    const members = {};
+    const facets = [...dict.facets.values()].filter((f) => !f.key.includes(":") || info.name === "core");
+    for (const f of facets)
+        if (f.version)
+            members[`facet:${f.key}`] = f.version;
+    for (const c of dict.classes.values())
+        if (c.version)
+            members[`class:${c.name}`] = c.version;
+    for (const r of p.rules)
+        if (r.version)
+            members[`rule:${r.name}`] = r.version;
+    for (const c of p.contracts)
+        if (c.parts.version)
+            members[`contract:${c.name}`] = c.parts.version;
+    for (const v of p.views.views.values())
+        if (v.version)
+            members[`view:${v.name}`] = v.version;
+    for (const u of info.utilities)
+        if (u.version)
+            members[`utility:${u.name}`] = u.version;
+    o.members = members;
+    if (dict.kinds.size)
+        o.kinds = [...dict.kinds.values()].map((k) => kindJson(dict, k));
+    if (facets.length)
+        o.facets = facets.map(facetJson);
+    if (dict.classes.size)
+        o.classes = [...dict.classes.values()].map(classJson);
+    if (p.rules.length)
+        o.rules = p.rules.map(ruleJson);
+    if (p.contracts.length)
+        o.contracts = p.contracts.map(contractJson);
+    if (p.views.shapes.size)
+        o.shapes = [...p.views.shapes.values()].map(shapeJson);
+    if (p.views.filters.size)
+        o.filters = [...p.views.filters.values()].map(filterJson);
+    if (p.views.views.size)
+        o.views = [...p.views.views.values()].map(viewJson);
+    const roles = rolesJson(p.perms);
+    if (roles.length)
+        o.roles = roles;
+    const perms = permissionsJson(p.perms);
+    if (perms)
+        o.permissions = perms;
+    if (p.perms.ownership.size)
+        o.ownership = Object.fromEntries([...p.perms.ownership].map(([k, v]) => [k, [...v]]));
+    if (p.perms.emergency)
+        o.emergency = { approvers: String(p.perms.emergency.approvers), longest: p.perms.emergency.longest };
+    if (p.recipes.length)
+        o.recipes = p.recipes.map(recipeJson);
+    if (p.instructions.size)
+        o.instructions = [...p.instructions].map(([issuer, list]) => ({ issuer, instructions: list.map((i) => ({ n: i.n, op: i.op, key: i.key, ...(i.to ? { to: i.to } : {}), ...(i.map.length ? { map: i.map.map(([a, b]) => ({ from: a, to: b })) } : {}) })) }));
+    if (info.utilities.length)
+        o.utilities = info.utilities.map(utilityJson);
+    return o;
+}
+// ─── Printer: the JSON forms back to the text form ───────────────────────────
+/** Quote a value when the text form would otherwise misread it (2.5). */
+export function q(s) {
+    if (s === "" || /^[&_\-\["{]|^\.\.\.$/.test(s) || /, |: | \/\/|[\n\r\t]/.test(s) || /^\s|\s$/.test(s) || /^-?\d/.test(s) && false)
+        return JSON.stringify(s);
+    return s;
+}
+const list = (xs) => (xs ?? []).map((x) => q(String(x))).join(", ");
+const str = (v) => (v === undefined ? undefined : typeof v === "string" ? v : String(v));
+function facetText(f, depth) {
+    const pad = "  ".repeat(depth);
+    const out = [`${pad}facet: ${f.facet}`];
+    const line = (k, v) => { if (v !== undefined)
+        out.push(`${pad}  ${k}: ${v}`); };
+    line("type", str(f.type));
+    for (const k of ["label", "ask", "describe"])
+        if (typeof f[k] === "string")
+            line(k, q(f[k]));
+    line("pick", str(f.pick));
+    if (f.ordered === true)
+        line("ordered", "yes");
+    line("state", str(f.state));
+    if (Array.isArray(f.qualifiers))
+        line("qualifiers", list(f.qualifiers));
+    if (Array.isArray(f.aliases))
+        line("aliases", list(f.aliases));
+    if (Array.isArray(f["same-as"]))
+        line("same-as", list(f["same-as"]));
+    line("agree-by", str(f["agree-by"]));
+    line("length", str(f.length));
+    line("unit", str(f.unit));
+    if (Array.isArray(f.accepts))
+        line("accepts", list(f.accepts));
+    if (isObj(f.range))
+        line("range", `${f.range.min}..${f.range.max}${f.range.step ? ` step ${f.range.step}` : ""}`);
+    line("places", str(f.places));
+    line("precision", str(f.precision));
+    line("zone", str(f.zone));
+    if (Array.isArray(f.words))
+        line("words", list(f.words));
+    if (Array.isArray(f.values)) {
+        const vals = f.values.map((v) => (isObj(v) ? [q(String(v.value)), ...(v.aliases ?? []).map((a) => `~${q(a)}`)].join(" ") : q(String(v))));
+        if (f.open === true)
+            vals.push("...");
+        line("values", vals.join(", "));
+    }
+    for (const k of ["fixed", "ranked", "scored", "required", "na", "unique", "transitions"])
+        if (f[k] === true)
+            line(k, "yes");
+    line("to", str(f.to));
+    if (Array.isArray(f.facets)) {
+        out.push(`${pad}  facets:`);
+        for (const c of f.facets)
+            if (isObj(c))
+                out.push(...facetText(c, depth + 2));
+    }
+    line("identity", str(f.identity));
+    if (typeof f.when === "string")
+        line("when", f.when);
+    line("combine", str(f.combine));
+    line("version", str(f.version));
+    for (const [k, v] of Object.entries(f))
+        if (k.includes(":"))
+            line(k, str(v));
+    return out;
+}
+/** A class line's text from its settings (5.3), the shorthand marks in their order (4.5). */
+export function lineText(l, type) {
+    let s = `${l.required === true ? "!" : ""}${l.level ? `${l.level}::` : ""}${l.facet}`;
+    if (Array.isArray(l.values))
+        s += `{${l.values.map((v) => q(String(v)).replace(/\|/g, "\\|")).join("|")}}`;
+    if (l.length !== undefined)
+        s += `$${l.length}`;
+    if (l.pick !== undefined)
+        s += l.pick === "any" ? "*" : `*${l.pick}`;
+    if (isObj(l.range))
+        s += ` ${l.range.min}..${l.range.max}`;
+    if (typeof l.precision === "string")
+        s += `@${type === "time" ? (l.precision === "second" ? "hms" : "hm") : (PRECISION_CODE[l.precision] ?? l.precision)}`;
+    if (typeof l.frame === "string")
+        s += ` frame: ${l.frame}`;
+    if (typeof l.when === "string")
+        s += ` when ${l.when}`;
+    return s;
+}
+const kv = (pad, k, v) => (v === undefined ? [] : [`${pad}${k}: ${Array.isArray(v) ? list(v) : q(String(v))}`]);
+function kindText(k) {
+    const out = [`kind: ${k.kind}`, ...kv("  ", "levels", k.levels), ...kv("  ", "base", k.base)];
+    if (typeof k.schema === "string")
+        out.push(`  schema: ${k.schema}`);
+    else if (isObj(k.schema))
+        out.push("  schema:", ...Object.entries(k.schema).map(([l, t]) => `    ${l}: ${t}`));
+    for (const block of ["vary", "identify"])
+        if (isObj(k[block]))
+            out.push(`  ${block}:`, ...Object.entries(k[block]).map(([l, keys]) => `    ${l}: ${keys.join(", ")}`));
+    if (isObj(k.follows))
+        out.push("  follows:", ...Object.entries(k.follows).map(([a, b]) => `    ${a}: ${b}`));
+    if (isObj(k.match))
+        out.push("  match:", ...Object.entries(k.match).map(([l, groups]) => `    ${l}: ${groups.map((g) => g.join(" + ")).join("; ")}`));
+    out.push(...kv("  ", "archive", k.archive));
+    return out;
+}
+function classText(c) {
+    const out = [`class: ${c.class}`, ...kv("  ", "label", c.label), ...kv("  ", "describe", c.describe), ...kv("  ", "for", c.for), ...kv("  ", "uses", c.uses), ...kv("  ", "state", c.state), ...kv("  ", "version", c.version)];
+    if (Array.isArray(c.facets)) {
+        out.push("  facets:");
+        for (const l of c.facets)
+            if (isObj(l))
+                out.push(typeof l.section === "string" ? `    section: ${q(l.section)}` : `    ${lineText(l)}`);
+    }
+    if (Array.isArray(c.parts)) {
+        out.push("  parts:");
+        for (const p of c.parts)
+            if (isObj(p))
+                out.push(`    ${p.slot}: ${p.wears}${p.pick === "any" ? " *" : ""}${p.fungible === true ? " fungible: yes" : ""}${p.match ? ` match: ${p.match}` : ""}`);
+    }
+    return out;
+}
+const mapText = (m) => [`    ${typeof m.literal === "string" ? JSON.stringify(m.literal) : m.from} -> ${m.to}`, ...(m.values ?? []).map((v) => `      ${q(String(v.from))} -> ${q(String(v.to))}`)];
+function contractText(c) {
+    const out = [`contract: ${c.contract}`, ...kv("  ", "kind", c.kind)];
+    for (const k of ["label", "describe", "for"])
+        out.push(...kv("  ", k, c[k]));
+    if (Array.isArray(c.needs))
+        out.push("  needs:", ...c.needs.map((l) => `    ${lineText(l)}`));
+    for (const k of ["writes", "reads", "stores"])
+        if (Array.isArray(c[k]))
+            out.push(`  ${k}:`, ...c[k].flatMap(mapText));
+    for (const k of ["gives", "stream", "when", "who", "from", "to", "mode", "undo", "ref", "origin", "prefix", "lands", "ignore", "keep-raw"])
+        out.push(...kv("  ", k, c[k]));
+    if (isObj(c.terms) && Object.keys(c.terms).length) {
+        out.push("  terms:");
+        for (const [k, v] of Object.entries(c.terms))
+            out.push(`    ${k}: ${String(v)}`);
+    }
+    if (c.absorb === false)
+        out.push("  absorb: no");
+    for (const [k, v] of Object.entries(c)) {
+        if (["contract", "kind", "label", "describe", "for", "needs", "writes", "reads", "stores", "gives", "terms", "stream", "when", "who", "from", "to", "mode", "undo", "ref", "origin", "prefix", "lands", "ignore", "keep-raw", "absorb"].includes(k))
+            continue;
+        if (k === "retry" && isObj(v))
+            out.push(`  retry: ${v.times} every ${v.every}`);
+        else
+            out.push(...kv("  ", k, v));
+    }
+    return out;
+}
+function ruleText(r) {
+    return [`rule: ${r.rule}`, ...kv("  ", "for", r.for), ...(typeof r.when === "string" ? [`  when: ${r.when}`] : []), `  then: ${r.then}`, ...kv("  ", "strength", r.strength), ...kv("  ", "because", r.because), ...kv("  ", "version", r.version)];
+}
+function instructionsText(b) {
+    const out = [`instructions: ${String(b.issuer)}`];
+    for (const i of b.instructions ?? []) {
+        out.push(`  ${String(i.n)}: ${String(i.op)}${String(i.key)}${i.to ? ` -> ${String(i.to)}` : ""}`);
+        for (const m of i.map ?? [])
+            out.push(`    ${q(String(m.from))} -> ${q(String(m.to))}`);
+    }
+    return out;
+}
+function recipeText(r) {
+    const m = r.migration;
+    const out = [`migration: ${m.from} -> ${m.to}`];
+    let facet;
+    for (const s of r.steps ?? []) {
+        if (s.facet !== facet) {
+            facet = String(s.facet);
+            out.push(`  facet: ${facet}`);
+        }
+        for (const verb of ["rename", "precision", "retype"])
+            if (isObj(s[verb]))
+                out.push(`    ${verb}: ${q(String(s[verb].from))} -> ${q(String(s[verb].to))}`);
+        if (isObj(s.merge))
+            out.push(`    merge: ${list(s.merge.from)} -> ${q(String(s.merge.to))}`);
+        if (isObj(s.convert))
+            out.push(`    convert: ${s.convert.from} -> ${s.convert.to}`, ...(s.convert.rounding && s.convert.rounding !== "nearest" ? [`    rounding: ${s.convert.rounding}`] : []));
+        if (isObj(s.split))
+            out.push(`    split: ${q(String(s.split.value))}`, ...(s.split.when ?? []).map((w) => `      when: ${w.if} -> ${q(String(w.to))}`), ...(s.split.else !== undefined ? [`      else: ${q(String(s.split.else))}`] : []));
+        if (isObj(s.move))
+            out.push(`    move: -> ${s.move.to}`);
+        if (typeof s.review === "string")
+            out.push(`    review: ${s.review}`);
+        if (s.recompute === true)
+            out.push("    recompute");
+        if (isObj(s.fill))
+            out.push(`    fill: ${q(String(s.fill.value))}`, ...(typeof s.fill.level === "string" ? [`      for: ${s.fill.level}::`] : []), ...(typeof s.fill.when === "string" ? [`      when: ${s.fill.when}`] : []));
+    }
+    return out;
+}
+const shapeText = (s) => [`shape: ${s.shape}`, "  slots:", ...(s.slots ?? []).map((sl) => `    ${sl.required === true ? "!" : ""}${typeof sl.template === "string" ? JSON.stringify(sl.template) : sl.from} -> ${sl.to}`)];
+function filterText(f) {
+    const out = [`filter: ${f.filter}`, `  facet: ${f.facet}`];
+    if (Array.isArray(f.buckets))
+        out.push("  buckets:", ...f.buckets.map((b) => { const bb = b; const name = /[\s:]/.test(String(bb.name)) ? JSON.stringify(bb.name) : String(bb.name); return isObj(bb.range) ? `    ${name}: ${bb.range.min}..${bb.range.max}` : `    ${name}: ${list(bb.values)}`; }));
+    out.push(...kv("  ", "dependent", f.dependent));
+    return out;
+}
+function viewText(v) {
+    const sel = (v.select ?? {});
+    const out = [`view: ${v.view}`, "  select:", ...kv("    ", "level", sel.level), ...kv("    ", "wears", sel.wears), ...(typeof sel.when === "string" ? [`    when: ${sel.when}`] : []), ...kv("    ", "list", sel.list)];
+    if (!Object.keys(sel).length)
+        out.pop();
+    out.push(...kv("  ", "partition", v.partition), ...(typeof v.of === "string" ? [`  of: ${v.of}`] : []), ...kv("  ", "pin", v.pin), ...kv("  ", "hide", v.hide));
+    if (Array.isArray(v.order))
+        out.push(`  order: ${v.order.map((o) => `${o.key} ${o.dir}`).join(", ")}`);
+    out.push(...kv("  ", "page", v.page), ...kv("  ", "shape", v.shape), ...kv("  ", "filters", v.filters), ...kv("  ", "index", v.index), ...kv("  ", "show", v.show), ...kv("  ", "fresh", v.fresh), ...kv("  ", "version", v.version));
+    return out;
+}
+const roleText = (r) => [`role: ${r.role}`, `  audience: ${r.audience}`, "  may:", ...Object.entries(r.may ?? {}).map(([verb, t]) => `    ${verb}: ${t.join(", ")}`)];
+function permissionsText(p) {
+    const out = [`permissions: ${p.permissions}`];
+    const menu = (p.menu ?? {});
+    if (Object.keys(menu).length)
+        out.push("  menu:", ...Object.entries(menu).map(([name, item]) => { const it = item; const verbs = Object.entries(it.verbs ?? {}).map(([v, t]) => `${v} ${t.join(" ")}`).join(", "); return `    ${name}: ${verbs}${it.on ? ` on: ${it.on}` : ""}`; }));
+    const presets = (p.presets ?? {});
+    if (Object.keys(presets).length)
+        out.push("  presets:", ...Object.entries(presets).map(([name, pr]) => `    ${name}: ${pr.items.join(", ")} audience: ${pr.audience}`));
+    const rel = (p.relations ?? {});
+    if (Object.keys(rel).length)
+        out.push(`  relations: ${Object.entries(rel).map(([r, v]) => (v.only === true ? `${r} only` : r)).join(", ")}`);
+    return out;
+}
+/** The text form of a bundle: the package header, then every member, in the long form. */
+export function printBundle(b) {
+    const out = [`package: ${b.package} /${b.version}`];
+    out.push(...kv("  ", "owner", b.owner), ...kv("  ", "label", b.label), ...kv("  ", "describe", b.describe), `  crubal: ${b.crubal ?? "2"}`, ...kv("  ", "licence", b.licence));
+    if (Array.isArray(b.extends))
+        out.push(`  extends: ${b.extends.map((e) => `${e.package} /${e.version}`).join(", ")}`);
+    if (isObj(b.prefixes))
+        out.push("  prefixes:", ...Object.entries(b.prefixes).map(([k, v]) => `    ${k}: ${v}`));
+    if (isObj(b.units))
+        out.push(`  units: ${b.units.package} /${b.units.version}`);
+    for (const k of ["confirm", "split", "recur"])
+        out.push(...kv("  ", k, b[k]));
+    if (isObj(b.terms))
+        out.push("  terms:", ...Object.entries(b.terms).map(([a, t]) => `    ${a}: ${t}`));
+    out.push("");
+    if (Array.isArray(b.trust))
+        out.push("trust:", ...b.trust.map((t) => `  ${t}`), "");
+    if (isObj(b["facet-trust"]))
+        out.push("facet-trust:", ...Object.entries(b["facet-trust"]).map(([k, v]) => `  ${k}: ${v.join(", ")}`), "");
+    const blocks = (key, fn) => { for (const x of b[key] ?? [])
+        out.push(...fn(x), ""); };
+    blocks("kinds", kindText);
+    blocks("facets", (f) => facetText(f, 0));
+    blocks("classes", classText);
+    blocks("rules", ruleText);
+    blocks("contracts", contractText);
+    blocks("recipes", recipeText);
+    blocks("instructions", instructionsText);
+    blocks("shapes", shapeText);
+    blocks("filters", filterText);
+    blocks("views", viewText);
+    blocks("roles", roleText);
+    if (isObj(b.permissions))
+        out.push(...permissionsText(b.permissions), "");
+    if (isObj(b.ownership))
+        out.push("ownership:", ...Object.entries(b.ownership).map(([k, v]) => `  ${k}: ${v.join(", ")}`), "");
+    if (isObj(b.emergency))
+        out.push("emergency:", `  approvers: ${b.emergency.approvers}`, `  longest: ${b.emergency.longest}`, "");
+    blocks("utilities", utilityText);
+    return `${out.join("\n").trimEnd()}\n`;
+}
+function utilityText(u) {
+    const out = [`utility: ${u.utility} /${u.version}`, ...kv("  ", "label", u.label), ...kv("  ", "describe", u.describe)];
+    if (Array.isArray(u.serves))
+        out.push(`  serves: ${u.serves.map((s) => `${s.as}${Array.isArray(s.items) ? `(${s.items.join(", ")})` : ""}`).join(", ")}`);
+    if (Array.isArray(u.needs))
+        out.push(`  needs: ${u.needs.map((n) => `${n.name}${n.version ? ` /${n.version}` : ""}`).join(", ")}`);
+    if (Array.isArray(u.setup))
+        out.push(`  setup: ${u.setup.map((s) => (typeof s.connection === "string" ? `connection ${s.connection}` : `setting ${s.setting}`)).join(", ")}`);
+    return out;
+}
+/** Read a bundle: print it to text and read the text, so there is one parser. */
+export function readBundle(b) {
+    const text = printBundle(b);
+    return { ...parsePackage(text), text };
+}
+/** Read a bundle's definitions into a dictionary that already holds what the package extends. */
+export function readBundleInto(b, into = emptyDictionary()) {
+    return readDefinitions(printBundle(b), into);
+}
+/** An empty Parsed to read packages onto, in order. */
+export function emptyParsed() {
+    const { perms } = readAccess("");
+    return { info: { name: "", version: "", owner: "", line: 0, crubal: 2, crubalLine: 0, extends: [], prefixes: new Map(), trust: [], dict: emptyDictionary(), contracts: [], header: {}, terms: {}, utilities: [] }, dict: emptyDictionary(), rules: [], contracts: [], views: { shapes: new Map(), filters: new Map(), views: new Map(), roles: new Map(), shown: new Map(), shownFor: new Map() }, perms, edges: [], recipes: [], instructions: new Map() };
+}
+/**
+ * Read a bundle onto what is already read (the packages it extends, or the installed packages before the
+ * owner's own definitions): the dictionary grows, and a member of the same name replaces the earlier one.
+ */
+export function readBundleOnto(bundle, base) {
+    const text = printBundle(bundle);
+    readDefinitions(text, base.dict);
+    const [info] = readPackages(text);
+    if (info)
+        base.info = { ...info, dict: base.dict, terms: Object.keys(info.terms).length ? info.terms : base.info.terms, utilities: [...base.info.utilities.filter((h) => !info.utilities.some((n) => n.name === h.name)), ...info.utilities] };
+    const byName = (have, next) => [...have.filter((h) => !next.some((n) => n.name === h.name)), ...next];
+    base.rules = byName(base.rules, readRules(text));
+    base.contracts = byName(base.contracts, readContracts(text));
+    const views = readViews(text);
+    for (const k of ["shapes", "filters", "views", "roles", "shown", "shownFor"])
+        for (const [key, val] of views[k])
+            base.views[k].set(key, val);
+    const { perms, edges } = readAccess(text);
+    if (perms.name)
+        base.perms.name = perms.name;
+    // A menu item named by more than one package (platform's `people`, every package's `people: grant …`) is
+    // one item: a later package adds its verbs and targets to what stands, never replaces them. A preset of
+    // the same name is replaced whole: it is one declaration, not an accumulation.
+    for (const [k, v] of perms.menu) {
+        const have = base.perms.menu.get(k);
+        if (!have) {
+            base.perms.menu.set(k, v);
+            continue;
+        }
+        const verbs = { ...have.verbs };
+        for (const [verb, targets] of Object.entries(v.verbs))
+            verbs[verb] = [...new Set([...(verbs[verb] ?? []), ...targets])];
+        base.perms.menu.set(k, { ...have, ...v, verbs });
+    }
+    for (const [k, v] of perms.presets)
+        base.perms.presets.set(k, v);
+    for (const [k, v] of perms.relations)
+        base.perms.relations.set(k, v);
+    for (const [k, v] of perms.ownership)
+        base.perms.ownership.set(k, v);
+    if (perms.emergency)
+        base.perms.emergency = perms.emergency;
+    base.edges.push(...edges);
+    base.recipes.push(...readRecipes(text));
+    for (const [issuer, list] of readInstructionBlocks(text))
+        base.instructions.set(issuer, [...(base.instructions.get(issuer) ?? []), ...list]);
+    return base;
+}
+// ─── Hash, sign, verify ──────────────────────────────────────────────────────
+export function bundleHash(b) {
+    const { hash: _h, sig: _s, ...rest } = b;
+    return sha256(serialize(rest));
+}
+/** Sign a bundle with the owner's Ed25519 private key (the JWK `d`, base64url); sets `hash` and `sig`. */
+export function signBundle(b, privateD, publicX) {
+    const hash = bundleHash(b);
+    const key = createPrivateKey({ key: { kty: "OKP", crv: "Ed25519", x: publicX, d: privateD }, format: "jwk" });
+    const sig = edSign(null, Buffer.from(hash, "hex"), key).toString("base64url");
+    return { ...b, hash: `sha256:${hash}`, sig };
+}
+/** Check a bundle's hash and, with the owner's published key, its signature. */
+export function verifyBundle(b, keys) {
+    const hash = bundleHash(b);
+    if (b.hash !== `sha256:${hash}`)
+        return { valid: false, reason: "hash" };
+    const owner = String(b.owner ?? "");
+    // The key in force when the version was published (11.7): a rotated key still verifies what it signed.
+    const k = keys ? keyFor(keys, owner, typeof b.version === "string" ? b.version : undefined) : undefined;
+    if (!k)
+        return keys ? { valid: false, reason: "no key" } : { valid: true };
+    if (k.alg !== "Ed25519" || typeof b.sig !== "string")
+        return { valid: false, reason: "signature" };
+    const key = createPublicKey({ key: { kty: "OKP", crv: "Ed25519", x: k.public }, format: "jwk" });
+    return edVerify(null, Buffer.from(hash, "hex"), key, Buffer.from(b.sig, "base64url")) ? { valid: true } : { valid: false, reason: "signature" };
+}
+//# sourceMappingURL=bundle.js.map