@cruba/crubal 0.1.0 → 0.3.0

package/dist/src/views.js

@@ -4,7 +4,10 @@
 // a view's read set decides which projection rows go stale.
 import { serialize } from "./canonical.js";
 import { evaluate, parseCondition } from "./conditions.js";
+import { facetOf, leafOf, linkStep, rowStep } from "./address.js";
+export { facetOf, leafOf } from "./address.js";
 import { splitTop } from "./lex.js";
+import { MemoryRecords } from "./records.js";
 import { Engine } from "./rules.js";
 import { CrubalError, readTree } from "./tree.js";
 const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -16,7 +19,7 @@ const rankOf = (a) => {
 };
 /** Read shapes, filters, views (with a body), roles and `shown to` rules. */
 export function readViews(source) {
-    const set = { shapes: new Map(), filters: new Map(), views: new Map(), roles: new Map(), shown: new Map() };
+    const set = { shapes: new Map(), filters: new Map(), views: new Map(), roles: new Map(), shown: new Map(), shownFor: new Map() };
     for (const n of readTree(source)) {
         if (n.kind !== "pair" || !n.key)
             continue;
@@ -81,6 +84,8 @@ export function readViews(source) {
                 indexLine: get("index")?.line ?? n.line,
                 show: get("show")?.value ?? "public",
                 fresh: get("fresh")?.value ?? "write",
+                ...(get("partition") ? { partition: get("partition")?.value.trim() } : {}),
+                ...(get("version") ? { version: get("version")?.value.trim() } : {}),
             });
         }
         else if (n.key === "role") {
@@ -96,15 +101,39 @@ export function readViews(source) {
         else if (n.key === "rule") {
             const then = get("then")?.value ?? "";
             const m = then.match(/^(\S+) shown to (\S+)$/);
-            if (m)
-                set.shown.set(m[1], m[2]);
+            if (m) {
+                const scope = get("for")?.value.trim() ?? "everywhere";
+                if (scope === "everywhere")
+                    set.shown.set(m[1], m[2]);
+                else
+                    set.shownFor.set(m[1], [...(set.shownFor.get(m[1]) ?? []), { for: scope, audience: m[2] }]);
+            }
         }
     }
     return set;
 }
-/** Can an audience see a facet? (`shown to` names the lowest audience that may.) */
-function visibleTo(set, facet, audience) {
-    const min = set.shown.get(facet.replace(/^\w+::/, ""));
+/**
+ * The lowest audience that may see a facet (12.4): a show rule whose `for` covers the record decides for it,
+ * a class over a kind or level, else the rule for everywhere; no rule, the public.
+ */
+export function shownAudience(set, facet, record, dict) {
+    const key = facet.replace(/^\w+::/, "");
+    if (record) {
+        const scoped = set.shownFor.get(key) ?? [];
+        // A record wears its kind's base class without saying so (chapter 5).
+        const base = dict?.kinds.get(record.kind)?.base;
+        const byClass = scoped.find((s) => (record.wears ?? []).includes(s.for) || s.for === base);
+        if (byClass)
+            return byClass.audience;
+        const byKind = scoped.find((s) => s.for === record.kind || s.for === record.level);
+        if (byKind)
+            return byKind.audience;
+    }
+    return set.shown.get(key);
+}
+/** Can an audience see a facet, of this record when one is given? */
+export function visibleTo(set, facet, audience, record, dict) {
+    const min = shownAudience(set, facet, record, dict);
     return !min || rankOf(audience) >= rankOf(min);
 }
 /** The keys a slot's source reads. */
@@ -116,11 +145,11 @@ function slotKeys(from) {
 }
 // ─── Publish checks (12.8) ───────────────────────────────────────────────────
 export function checkViews(set, dict) {
-    const defined = (k) => dict.facets.has(k.replace(/^\w+::/, "").replace(/^parts\[\*\]\./, ""));
+    const defined = (k) => facetOf(k, dict) !== undefined;
     for (const f of set.filters.values()) {
         if (!defined(f.facet))
             throw new CrubalError(`the filter ${f.name} reads ${f.facet}, which isn't a facet`, f.line);
-        const facet = dict.facets.get(f.facet.replace(/^\w+::/, ""));
+        const facet = facetOf(f.facet, dict);
         const seen = new Map();
         f.buckets?.forEach((b, i) => {
             for (const v of b.values ?? []) {
@@ -134,16 +163,30 @@ export function checkViews(set, dict) {
         });
     }
     for (const s of set.shapes.values()) {
-        for (const sl of s.slots)
+        for (const sl of s.slots) {
+            // A page shape's slot may hold another view (12.1), run with the page's record as its context.
+            if (sl.from.startsWith("view:")) {
+                if (!set.views.has(sl.from.slice(5)))
+                    throw new CrubalError(`the slot ${sl.to} holds the view ${sl.from.slice(5)}, which doesn't exist`, sl.line);
+                continue;
+            }
             for (const k of slotKeys(sl.from))
                 if (!sl.from.startsWith('"') || k)
                     if (!defined(k) && k !== "id")
                         throw new CrubalError(`the slot ${sl.to} reads ${k}, which isn't a facet`, sl.line);
+        }
     }
+    for (const f of set.filters.values())
+        for (const d of f.dependent)
+            if (!defined(d))
+                throw new CrubalError(`the filter ${f.name} depends on ${d}, which isn't a facet`, f.line);
     for (const v of set.views.values()) {
         for (const s of v.shapes)
-            if (s !== "crubal:portable" && !set.shapes.has(s))
+            if (!CORE_SHAPES.includes(s) && !set.shapes.has(s))
                 throw new CrubalError(`${v.name} names the shape ${s}, which doesn't exist`, v.line);
+        // A list is the whole selection (12.2): a level, classes, a condition or curation would contradict it.
+        if (v.list && (v.level || v.wears.length || v.when || v.pin.length || v.hide.length || v.order.length))
+            throw new CrubalError(`${v.name} selects a list, so it takes no level, wears, when, pin, hide or order`, v.line);
         for (const f of v.filters)
             if (!set.filters.has(f))
                 throw new CrubalError(`${v.name} names the filter ${f}, which doesn't exist`, v.line);
@@ -158,7 +201,7 @@ export function checkViews(set, dict) {
                 ...v.shapes.flatMap((s) => (set.shapes.get(s)?.slots ?? []).flatMap((sl) => slotKeys(sl.from))),
                 ...v.filters.map((f) => set.filters.get(f)?.facet ?? f),
             ];
-            const hidden = reads.find((k) => !visibleTo(set, k, "public"));
+            const hidden = reads.find((k) => !visibleTo(set, leafOf(k, dict), "public"));
             if (hidden)
                 throw new CrubalError(`the public view ${v.name} reads ${hidden}, which show rules hide from public`, v.line);
         }
@@ -172,6 +215,12 @@ export function checkViews(set, dict) {
         }
     }
 }
+/** The shapes the core defines (12.1, 12.5): the portable one, and structured data for the public. */
+export const CORE_SHAPES = ["crubal:portable", "crubal:jsonld"];
+/** A view's partition: what it declares, else `controlled` above member and `none` otherwise (12.2). */
+export function partitionOf(v) {
+    return v.partition ?? (rankOf(v.show) > rankOf("member") ? "controlled" : "none");
+}
 function plainText(v) {
     if (typeof v === "string")
         return v;
@@ -188,11 +237,14 @@ function label(key) {
 export class Views {
     dict;
     set;
-    records = new Map();
+    records = new MemoryRecords();
     engine;
-    constructor(dict, set) {
+    /** Over a record set of the caller's (a store's working set), or an empty memory set to `put` into. */
+    constructor(dict, set, records) {
         this.dict = dict;
         this.set = set;
+        if (records)
+            this.records = records;
         this.engine = new Engine(dict, []);
     }
     put(r) {
@@ -202,12 +254,50 @@ export class Views {
         const up = r.of ? this.records.get(r.of) : undefined;
         return { ...(up ? this.effective(up) : {}), ...r.values };
     }
+    /** The classes a record wears, those of the records above it included (5.5). */
+    wearsOf(r) {
+        const up = r.of ? this.records.get(r.of) : undefined;
+        return [...(up ? this.wearsOf(up) : []), ...(r.wears ?? [])];
+    }
     below(r, level) {
-        return [...this.records.values()].filter((x) => x.of === r.id && x.level === level);
+        return this.records.childrenOf(r.id, "of", level);
+    }
+    /**
+     * The records a link facet points at: shared parts, read through (1.6). A link into a vocabulary (`wd`,
+     * `gpc`) or to a url points at no record here and reads nothing.
+     */
+    linked(r, link) {
+        const f = this.dict.facets.get(link);
+        if (!f || f.type !== "link" || !f.to || !(this.dict.kinds.has(f.to) || this.dict.classes.has(f.to)))
+            return [];
+        const v = this.effective(r)[link];
+        const items = v === undefined ? [] : Array.isArray(v) ? v : [v];
+        return items.flatMap((x) => {
+            const id = isObj(x) && "$link" in x ? String(x.$link) : typeof x === "string" ? x : "";
+            const t = id ? this.records.get(id) : undefined;
+            return t && t.status?.state !== "archived" ? [t] : [];
+        });
+    }
+    /** The rows of a compound on a record, as objects. */
+    rowsOf(r, compound) {
+        const v = this.effective(r)[compound];
+        return (v === undefined ? [] : Array.isArray(v) ? v : [v]).filter(isObj);
     }
     /** The values an address reads, as a list: own values, or a lower level's (`unit::price`). */
     valuesAt(r, address) {
+        // A step through a link facet reads the linked records (shared parts, 1.6), each by the rest of the address.
+        const ls = linkStep(address, this.dict);
+        if (ls)
+            return this.linked(r, ls.link).flatMap((t) => this.valuesAt(t, ls.rest));
+        // A step into a compound's rows reads the child on every row (1.10 with the wildcard).
+        const rs = rowStep(address, this.dict);
+        if (rs)
+            return this.rowsOf(r, rs.compound).flatMap((row) => { const c = rs.child ? row[rs.child] : row; return c === undefined ? [] : Array.isArray(c) ? c : [c]; });
         const m = address.match(/^(\w+)::(.+)$/);
+        // A level prefix reads the records below at that level, or the record itself when it sits there
+        // (a standing-alone lower record answers for its own level, 1.7).
+        if (m && r.level === m[1])
+            return this.valuesAt(r, m[2]);
         if (m)
             return this.below(r, m[1]).flatMap((u) => this.valuesAt(u, m[2]));
         const v = this.effective(r)[address];
@@ -219,29 +309,30 @@ export class Views {
             return true;
         if (isObj(v) && "$empty" in v)
             return v.$empty === "n/a";
-        const f = this.dict.facets.get(key.replace(/^\w+::/, ""));
+        const f = facetOf(key, this.dict);
         if (f?.type === "choice" && typeof v === "string")
             return (f.values ?? []).some((x) => x.value === v);
         return true;
     }
-    canSee(key, audience, caller) {
-        if (!visibleTo(this.set, key, audience))
+    canSee(address, audience, caller, record) {
+        const key = leafOf(address, this.dict);
+        if (!visibleTo(this.set, key, audience, record, this.dict))
             return false;
         if (!caller || rankOf(audience) <= rankOf("member"))
             return true;
         // Above member, a person sees what members see plus what their roles grant (default deny).
-        if (visibleTo(this.set, key, "member"))
+        if (visibleTo(this.set, key, "member", record, this.dict))
             return true;
         const held = caller.values.roles;
         const names = (Array.isArray(held) ? held : held ? [held] : []).map((x) => (isObj(x) && "$link" in x ? String(x.$link) : String(x)));
         return names.some((n) => {
             const role = this.set.roles.get(n);
-            return role && role.see.includes(key.replace(/^\w+::/, "")) && rankOf(role.audience) <= rankOf(audience);
+            return role && role.see.includes(key) && rankOf(role.audience) <= rankOf(audience);
         });
     }
     slot(r, s, audience, caller) {
         const keys = slotKeys(s.from);
-        if (!keys.every((k) => this.canSee(k, audience, caller)))
+        if (!keys.every((k) => this.canSee(k, audience, caller, r)))
             return undefined;
         if (s.from.startsWith('"'))
             return this.engine.template(s.from, this.effective(r));
@@ -260,16 +351,144 @@ export class Views {
                 return sorted.at(-1);
             return items;
         }
-        const f = this.dict.facets.get(s.from.replace(/^\w+::/, ""));
-        const v = s.from.includes("::") ? this.valuesAt(r, s.from) : this.effective(r)[s.from];
-        if (v === undefined)
+        const f = facetOf(s.from, this.dict);
+        const through = s.from.includes("::") || linkStep(s.from, this.dict) !== null || rowStep(s.from, this.dict) !== null;
+        const v = through ? this.valuesAt(r, s.from) : this.effective(r)[s.from];
+        if (v === undefined || (Array.isArray(v) && !v.length))
             return undefined;
         if (Array.isArray(v)) {
             const kept = v.filter((x) => this.fit(s.from, x, audience));
-            return kept.length ? (f?.many || s.from.includes("::") ? kept : kept[0]) : undefined;
+            return kept.length ? (f?.many || through ? kept : kept[0]) : undefined;
         }
         return this.fit(s.from, v, audience) ? v : undefined;
     }
+    /**
+     * What a condition reads of a record (6.3): the envelope under `crubal:`, and bare `id` and `status`
+     * too unless a facet of that name holds a value, which then wins.
+     */
+    conditionValues(r) {
+        const status = r.status?.state ?? "active";
+        const own = this.effective(r);
+        const out = { id: r.id, status, "crubal:id": r.id, "crubal:status": status, ...own };
+        // A compound's rows, addressed `X[*].child`, as lists of the child's values.
+        const rowKeys = (vals, prefix) => {
+            const added = {};
+            for (const [key, v] of Object.entries(vals)) {
+                if (this.dict.facets.get(key)?.type !== "compound")
+                    continue;
+                for (const row of (Array.isArray(v) ? v : [v]).filter(isObj))
+                    for (const [child, cv] of Object.entries(row))
+                        (added[`${prefix}${key}[*].${child}`] ??= []).push(...(Array.isArray(cv) ? cv : [cv]));
+            }
+            return added;
+        };
+        Object.assign(out, rowKeys(own, ""));
+        // The linked records' values, addressed through the link (`works[*].genre`, `works.genre`), so a
+        // condition reads a shared part as it reads a level below (1.6); their compounds' rows likewise.
+        for (const key of Object.keys(own)) {
+            if (this.dict.facets.get(key)?.type !== "link")
+                continue;
+            const targets = this.linked(r, key);
+            if (!targets.length)
+                continue;
+            const merged = {};
+            for (const t of targets) {
+                const tv = this.effective(t);
+                for (const [k, v] of Object.entries(tv))
+                    (merged[k] ??= []).push(...(Array.isArray(v) ? v : [v]));
+                for (const [k, v] of Object.entries(rowKeys(tv, "")))
+                    (merged[k] ??= []).push(...v);
+            }
+            for (const [k, list] of Object.entries(merged)) {
+                out[`${key}[*].${k}`] = list;
+                out[`${key}.${k}`] = list.length === 1 ? list[0] : list;
+            }
+        }
+        return out;
+    }
+    /** The values of the view's order keys as text, and the pin position: what an index orders rows by (12.7). */
+    sortOf(v, r) {
+        const vals = this.effective(r);
+        const sort = v.order.map((o) => plainText((vals[o.key] ?? "")));
+        const at = v.pin.indexOf(r.id);
+        return at >= 0 ? { sort, pin: at + 1 } : { sort };
+    }
+    /** The buckets a record falls into, per filter of the view (12.6): what an index counts from. */
+    bucketsFor(v, r) {
+        const out = {};
+        for (const fname of v.filters) {
+            const f = this.set.filters.get(fname);
+            if (!f)
+                continue;
+            const names = this.bucketsOf(f).filter((b) => this.inBucket(r, f, b)).map((b) => b.name);
+            if (names.length)
+                out[fname] = names;
+            // A dependent facet (12.3): its values, one bucket each, so an index can count them inside this filter's.
+            for (const dep of f.dependent) {
+                const vals = this.valuesAt(r, dep).filter((x) => this.fit(dep, x, "public")).map(plainText);
+                if (vals.length)
+                    out[dep] = [...new Set(vals)];
+            }
+        }
+        return out;
+    }
+    /** Dependent counts (12.3) over records already narrowed by the other filters. */
+    nestedCounts(v, pool) {
+        const out = {};
+        for (const fname of v.filters) {
+            const f = this.set.filters.get(fname);
+            if (!f?.dependent.length)
+                continue;
+            const rows = pool(fname);
+            const per = {};
+            for (const b of this.bucketsOf(f)) {
+                const inB = rows.filter((r) => this.inBucket(r, f, b));
+                const byDep = {};
+                for (const dep of f.dependent) {
+                    const tally = {};
+                    for (const r of inB)
+                        for (const val of new Set(this.valuesAt(r, dep).map(plainText)))
+                            tally[val] = (tally[val] ?? 0) + 1;
+                    byDep[dep] = tally;
+                }
+                per[b.name] = byDep;
+            }
+            out[fname] = per;
+        }
+        return out;
+    }
+    /** Does a view select this record (its own tests, before curation and the shape's required slots)? */
+    selects(v, r, opts) {
+        if (v.level && r.level !== v.level)
+            return false;
+        // An archived record is left out unless the view selects on status explicitly (1.12).
+        if (r.status?.state === "archived" && !(v.when && /\bstatus\b/.test(v.when)))
+            return false;
+        if (v.wears.some((w) => !this.wearsOf(r).includes(w)))
+            return false;
+        if (v.hide.includes(r.id))
+            return false;
+        const vals = this.conditionValues(r);
+        if (v.when && evaluate(parseCondition(v.when), vals) !== true)
+            return false;
+        if (v.of) {
+            const ctx = opts.context;
+            if (!ctx)
+                return false;
+            const cvals = this.conditionValues(ctx);
+            const cond = v.of.replace(/context\.(\w+)/g, (_, k) => JSON.stringify(cvals[k] === undefined ? "" : plainText(cvals[k])));
+            if (evaluate(parseCondition(cond), vals) !== true)
+                return false;
+        }
+        return true;
+    }
+    /** The records a list holds, in its order (12.2): the links in its `crubal:items`. */
+    listed(v) {
+        const list = v.list ? this.records.get(v.list) : undefined;
+        const items = list?.values["crubal:items"];
+        const ids = (Array.isArray(items) ? items : items === undefined ? [] : [items]).map((x) => (isObj(x) && "$link" in x ? String(x.$link) : String(x)));
+        return ids.flatMap((id) => this.records.get(id) ?? []).filter((r) => r.status?.state !== "archived");
+    }
     inBucket(r, f, b) {
         return this.valuesAt(r, f.facet).some((v) => {
             const t = plainText(v);
@@ -283,36 +502,23 @@ export class Views {
     bucketsOf(f) {
         if (f.buckets)
             return f.buckets;
-        const facet = this.dict.facets.get(f.facet.replace(/^\w+::/, ""));
+        const facet = facetOf(f.facet, this.dict);
         return (facet?.values ?? []).map((v) => ({ name: v.value, values: [v.value] }));
     }
     /** The records a view selects, curated and ordered, before filters and paging. */
     select(v, opts = {}) {
         const audience = opts.audience ?? v.show;
-        let rows = [...this.records.values()].filter((r) => {
-            if (v.level && r.level !== v.level)
-                return false;
-            if (v.wears.some((w) => !(r.wears ?? []).includes(w)))
-                return false;
-            if (v.hide.includes(r.id))
-                return false;
-            const vals = { ...this.effective(r), id: r.id };
-            if (v.when && evaluate(parseCondition(v.when), vals) !== true)
-                return false;
-            if (v.of) {
-                const ctx = opts.context;
-                if (!ctx)
-                    return false;
-                const cvals = { ...this.effective(ctx), id: ctx.id };
-                const cond = v.of.replace(/context\.(\w+)/g, (_, k) => JSON.stringify(cvals[k] === undefined ? "" : plainText(cvals[k])));
-                if (evaluate(parseCondition(cond), vals) !== true)
-                    return false;
-            }
-            return true;
-        });
-        // A record whose required slot is empty is dropped from the view.
         const shape = this.set.shapes.get(v.shapes[0] ?? "");
-        rows = rows.filter((r) => (shape?.slots ?? []).every((s) => !s.required || this.slot(r, s, audience, opts.caller) !== undefined));
+        const fills = (r) => (shape?.slots ?? []).every((s) => !s.required || this.slot(r, s, audience, opts.caller) !== undefined);
+        if (v.list) {
+            // A hand-made list (12.2): its records in its order, whatever their levels; no curation applies.
+            const listed = this.listed(v).filter(fills);
+            return opts.only ? listed.filter((r) => opts.only.includes(r.id)) : listed;
+        }
+        const pool = opts.only ? opts.only.flatMap((id) => this.records.get(id) ?? []) : v.level ? this.records.atLevel(v.level) : this.records.all();
+        let rows = pool.filter((r) => this.selects(v, r, opts));
+        // A record whose required slot is empty is dropped from the view.
+        rows = rows.filter(fills);
         const cmp = (a, b) => {
             for (const o of v.order) {
                 const x = plainText((this.effective(a)[o.key] ?? ""));
@@ -325,13 +531,27 @@ export class Views {
         const pinned = v.pin.map((id) => rows.find((r) => r.id === id)).filter((r) => !!r);
         return [...pinned, ...rows.filter((r) => !v.pin.includes(r.id)).sort(cmp)];
     }
+    /** The roles whose `see` a slot needs above member (12.6 role marks): none when members may see it. */
+    marksFor(s, audience) {
+        if (rankOf(audience) <= rankOf("member"))
+            return [];
+        const keys = slotKeys(s.from);
+        if (keys.every((k) => visibleTo(this.set, k, "member")))
+            return [];
+        return [...this.set.roles.values()].filter((r) => rankOf(r.audience) <= rankOf(audience) && keys.every((k) => visibleTo(this.set, k, "member") || r.see.includes(k.replace(/^\w+::/, "")))).map((r) => r.name).sort();
+    }
     /** A view's projection for an audience (or a caller), with filter counts and a page. */
     project(name, opts = {}) {
         const v = this.set.views.get(name);
         if (!v)
             throw new Error(`no view ${name}`);
-        const audience = opts.caller ? String(opts.caller.values.audience ?? "member") : (opts.audience ?? v.show);
-        const all = this.select(v, { ...opts, audience });
+        // A caller's audience is read off their edges (14.4) when access is at hand; a stated value otherwise.
+        const audience = opts.caller ? (opts.access ? opts.access.audienceOf(opts.caller.id) : String(opts.caller.values.audience ?? "member")) : (opts.audience ?? v.show);
+        const partition = partitionOf(v);
+        let all = this.select(v, { ...opts, audience });
+        // A partitioned view serves a caller only the rows their edges match (12.6, 14.10).
+        if (partition !== "none" && opts.access && opts.caller)
+            all = all.filter((r) => opts.access.standsIn(opts.caller.id, r.id, partition));
         const picks = opts.picks ?? {};
         const passes = (r, except) => Object.entries(picks).every(([fname, chosen]) => {
             if (fname === except)
@@ -340,32 +560,169 @@ export class Views {
             return !f || this.bucketsOf(f).some((b) => chosen.includes(b.name) && this.inBucket(r, f, b));
         });
         const counts = {};
-        for (const fname of v.filters) {
-            const f = this.set.filters.get(fname);
-            if (!f)
-                continue;
-            const pool = all.filter((r) => passes(r, fname));
-            counts[fname] = Object.fromEntries(this.bucketsOf(f).map((b) => [b.name, pool.filter((r) => this.inBucket(r, f, b)).length]));
+        if (!opts.all) {
+            for (const fname of v.filters) {
+                const f = this.set.filters.get(fname);
+                if (!f)
+                    continue;
+                const pool = all.filter((r) => passes(r, fname));
+                counts[fname] = Object.fromEntries(this.bucketsOf(f).map((b) => [b.name, pool.filter((r) => this.inBucket(r, f, b)).length]));
+            }
         }
+        const nested = opts.all ? {} : this.nestedCounts(v, (fname) => all.filter((r) => passes(r, fname)));
         const chosen = all.filter((r) => passes(r));
-        const pages = Math.max(1, Math.ceil(chosen.length / v.page));
-        const page = opts.page ?? 1;
-        const onPage = chosen.slice((page - 1) * v.page, page * v.page);
+        const pages = opts.all ? 1 : Math.max(1, Math.ceil(chosen.length / v.page));
+        const page = opts.all ? 1 : (opts.page ?? 1);
+        const onPage = opts.all ? chosen : chosen.slice((page - 1) * v.page, page * v.page);
         const pickList = Object.entries(picks).filter(([, c]) => c.length);
         const indexable = page === 1 && (pickList.length === 0 || (pickList.length === 1 && v.index.includes(pickList[0]?.[0]) && pickList[0]?.[1].length === 1));
-        const shapeName = v.shapes[0] ?? "";
+        const [shapeName = "", ...more] = v.shapes;
         const rows = onPage.map((r) => {
-            if (shapeName === "crubal:portable")
-                return { record: r.id, values: this.portable(r, audience, opts.caller) };
-            const row = { record: r.id };
-            for (const s of this.set.shapes.get(shapeName)?.slots ?? []) {
-                const val = this.slot(r, s, audience, opts.caller);
-                if (val !== undefined)
-                    row[s.to] = val;
+            const row = this.shaped(r, shapeName, audience, opts);
+            // Further shapes (12.1) share the selection: their output rides under `shapes`, served on request.
+            const shapes = {};
+            for (const s of more) {
+                const out = this.shaped(r, s, audience, opts);
+                delete out.record;
+                if (Object.keys(out).length)
+                    shapes[s] = s === "crubal:jsonld" ? out.jsonld : s === "crubal:portable" ? out.values : out;
             }
+            if (Object.keys(shapes).length)
+                row.shapes = shapes;
+            // A partitioned view's row carries its record's ancestors, so an index can match edges to it.
+            if (partition !== "none" && opts.access)
+                row.ancestors = opts.access.ancestors(r.id);
             return row;
         });
-        return { rows, records: onPage.map((r) => r.id), counts, pages, indexable };
+        return { rows, records: onPage.map((r) => r.id), counts, ...(Object.keys(nested).length ? { nested } : {}), pages, indexable };
+    }
+    /** One record in one shape: a core shape's object, or the shape's slots with their role marks. */
+    shaped(r, shapeName, audience, opts) {
+        if (shapeName === "crubal:portable")
+            return { record: r.id, values: this.portable(r, audience, opts.caller) };
+        if (shapeName === "crubal:jsonld") {
+            const ld = this.jsonld(r, audience);
+            return ld ? { record: r.id, jsonld: ld } : { record: r.id };
+        }
+        const row = { record: r.id };
+        const marks = {};
+        for (const s of this.set.shapes.get(shapeName)?.slots ?? []) {
+            // A slot holding a view (12.1): that view's rows, with this record as their context.
+            if (s.from.startsWith("view:")) {
+                const inner = this.nestedRows(s.from.slice(5), r, audience, opts);
+                if (inner.length)
+                    row[s.to] = inner;
+                continue;
+            }
+            const val = this.slot(r, s, audience, opts.caller);
+            if (val !== undefined)
+                row[s.to] = val;
+            const m = opts.caller ? [] : this.marksFor(s, audience);
+            if (val !== undefined && m.length)
+                marks[s.to] = m.length === 1 ? m[0] : m;
+        }
+        if (Object.keys(marks).length)
+            row.marks = marks;
+        return row;
+    }
+    /** A nested view's rows for a page record (12.1, 12.2 `of`): every page, in the view's order. */
+    nestedRows(name, context, audience, opts) {
+        return this.project(name, { audience, context, all: true, ...(opts.caller ? { caller: opts.caller } : {}), ...(opts.access ? { access: opts.access } : {}) }).rows;
+    }
+    /**
+     * Structured data (12.5): schema.org JSON-LD for the public from the kind's type per level (11.2) and
+     * each facet's `same-as` in the schema prefix; nothing for any other audience.
+     */
+    jsonld(r, audience = "public") {
+        if (audience !== "public")
+            return undefined;
+        const out = { "@context": "https://schema.org/" };
+        const kind = this.dict.kinds.get(this.dict.levels.get(r.level) ?? "");
+        const type = typeof kind?.schema === "string" ? kind.schema : kind?.schema?.[r.level];
+        if (type)
+            out["@type"] = type.replace(/^schema:/, "");
+        for (const [key, v] of Object.entries(this.effective(r))) {
+            if (!this.canSee(key, "public", undefined, r))
+                continue;
+            const f = this.dict.facets.get(key);
+            const same = f?.sameAs.find((s) => s.startsWith("schema:"));
+            if (!same)
+                continue;
+            const vals = (Array.isArray(v) ? v : [v]).filter((x) => this.fit(key, x, "public") && !(isObj(x) && "$empty" in x));
+            if (!vals.length)
+                continue;
+            const prop = same.slice(7);
+            const plain = vals.map((x) => {
+                if (isObj(x) && "$money" in x)
+                    return { price: String(x.$money), priceCurrency: String(x.currency) };
+                if (isObj(x) && "$qty" in x)
+                    return `${x.$qty} ${x.unit}`;
+                if (isObj(x) && "$link" in x)
+                    return { "@id": String(x.$link) };
+                if (isObj(x) && "$image" in x)
+                    return String(x.$image);
+                return plainText(x);
+            });
+            out[prop] = plain.length === 1 ? plain[0] : plain;
+        }
+        return out;
+    }
+    streams = new Map();
+    /** A view's version, as its stream names it. */
+    versionOf(name) {
+        return this.set.views.get(name)?.version ?? "";
+    }
+    /** A new version of a view: its stream starts over at the next publish (12.6). */
+    revise(name, version) {
+        const v = this.set.views.get(name);
+        if (!v)
+            throw new Error(`no view ${name}`);
+        v.version = version;
+    }
+    /**
+     * The projection stream (12.6): the entries since the last publish of this view for this audience, one
+     * per row that is new or changed, and one removal per row that left. Numbered per view and audience; a
+     * new version of the view starts over at 1, its first entry marked `reset`.
+     */
+    stream(name, opts = {}) {
+        const v = this.set.views.get(name);
+        if (!v)
+            throw new Error(`no view ${name}`);
+        const audience = opts.audience ?? v.show;
+        const key = `${name}|${audience}`;
+        const version = v.version ?? "";
+        const projection = version ? `${name} /${version}` : name;
+        const had = this.streams.get(key);
+        const last = had && had.version === version ? had : { version, rows: new Map(), seq: 0, log: [], published: false };
+        const reset = !!had && had.version !== version;
+        const now = new Map();
+        for (const row of this.project(name, { ...opts, audience, all: true }).rows)
+            now.set(String(row.record), row);
+        const out = [];
+        const next = { version, rows: new Map(), seq: last.seq, log: [...last.log], published: true };
+        for (const [id, row] of now) {
+            const rec = this.records.get(id);
+            const buckets = rec ? this.bucketsFor(v, rec) : {};
+            const order = rec ? this.sortOf(v, rec) : { sort: [] };
+            const s = serialize({ row, buckets, order: order });
+            next.rows.set(id, s);
+            if (last.rows.get(id) !== s)
+                out.push({ projection, audience, seq: ++next.seq, record: id, row, ...(Object.keys(buckets).length ? { buckets } : {}), ...(order.sort.length ? { sort: order.sort } : {}), ...(order.pin ? { pin: order.pin } : {}) });
+        }
+        for (const id of last.rows.keys())
+            if (!now.has(id))
+                out.push({ projection, audience, seq: ++next.seq, record: id, removed: true });
+        if (reset && out[0])
+            out[0].reset = true;
+        next.log.push(...out);
+        this.streams.set(key, next);
+        return out;
+    }
+    /** The current version's entries after `seq`, for an index resuming from its cursor (12.6.2). */
+    entriesSince(name, seq, audience) {
+        const v = this.set.views.get(name);
+        const s = this.streams.get(`${name}|${audience ?? v?.show ?? "public"}`);
+        return (s?.log ?? []).filter((e) => e.seq > seq);
     }
     /** The portable shape (12.1): key, label, type and value for every value the audience may see. */
     portable(r, audience = "public", caller) {
@@ -387,13 +744,21 @@ export class Views {
         if (v.of)
             keys.push(...parseConditionKeys(v.of.replace(/context\.\w+/g, '""')));
         keys.push(...v.order.map((o) => o.key));
+        if (v.list)
+            keys.push("crubal:items");
         for (const s of v.shapes)
-            for (const sl of this.set.shapes.get(s)?.slots ?? [])
-                keys.push(...slotKeys(sl.from));
+            for (const sl of this.set.shapes.get(s)?.slots ?? []) {
+                if (sl.from.startsWith("view:"))
+                    keys.push(...this.readSet(sl.from.slice(5)));
+                else
+                    keys.push(...slotKeys(sl.from));
+            }
+        for (const f of v.filters)
+            keys.push(...(this.set.filters.get(f)?.dependent ?? []));
         for (const f of v.filters)
             keys.push(this.set.filters.get(f)?.facet ?? f);
         for (const k of [...keys])
-            if (this.set.shown.has(k))
+            if (this.set.shown.has(k) || this.set.shownFor.has(k))
                 keys.push(k);
         return new Set(keys.filter((k) => k !== "id"));
     }
@@ -404,17 +769,62 @@ export class Views {
             return [];
         const reads = this.readSet(name);
         const out = new Set();
+        // The envelope is in every read set (12.6): a status, wears, within or of change stales the row.
+        const was = this.records.get(write.id);
+        const envelope = ["status", "wears", "within", "of"].some((m) => serialize((write[m] ?? "")) !== serialize((was?.[m] ?? "")));
+        if (envelope)
+            out.add(write.id);
         for (const key of Object.keys(write.values)) {
             if (reads.has(key) && (!v.level || write.level === v.level))
                 out.add(write.id);
             if (reads.has(`${write.level}::${key}`) && write.of)
                 out.add(write.of);
             if (reads.has(key) && v.level && write.level !== v.level) {
-                for (const r of this.records.values())
-                    if (r.of === write.id && r.level === v.level)
-                        out.add(r.id);
+                for (const r of this.records.childrenOf(write.id, "of", v.level))
+                    out.add(r.id);
             }
         }
+        // A write to a shared part stales the rows that read it through a link (1.6, 12.6): the linking records.
+        for (const read of reads) {
+            const ls = linkStep(read, this.dict);
+            if (!ls)
+                continue;
+            // Only a write of what the link points at (its kind, or a class it wears) can be a shared part here.
+            const to = this.dict.facets.get(ls.link)?.to;
+            if (!to || !(to === write.kind || (write.wears ?? []).includes(to)))
+                continue;
+            if (!envelope && !(leafOf(ls.rest, this.dict) in write.values))
+                continue;
+            const linkers = [...this.records.byKey(ls.link, { $link: write.id }), ...this.records.byKey(ls.link, [{ $link: write.id }])];
+            for (const r of linkers)
+                if (!v.level || r.level === v.level)
+                    out.add(r.id);
+        }
+        // A write to the list's items (12.2) stales every row: those it holds now, and those it will hold.
+        if (v.list && write.id === v.list) {
+            for (const r of this.listed(v))
+                out.add(r.id);
+            const items = write.values["crubal:items"];
+            for (const x of Array.isArray(items) ? items : items === undefined ? [] : [items])
+                out.add(isObj(x) && "$link" in x ? String(x.$link) : String(x));
+            out.delete(write.id);
+        }
+        // A page whose nested view holds, or would hold, the written record is stale (12.1).
+        for (const s of v.shapes)
+            for (const sl of this.set.shapes.get(s)?.slots ?? []) {
+                if (!sl.from.startsWith("view:"))
+                    continue;
+                const inner = this.set.views.get(sl.from.slice(5));
+                if (!inner)
+                    continue;
+                for (const page of this.select(v, { audience: v.show })) {
+                    const o = { audience: v.show, context: page };
+                    const is = was ? this.selects(inner, was, o) : false;
+                    const will = this.selects(inner, write, o);
+                    if (is || will)
+                        out.add(page.id);
+                }
+            }
         return [...out];
     }
 }