@idleware/ringi 0.4.0 → 0.6.0

package/target/esm/{app → core/hub/usecases}/view.js

@@ -1,44 +1,44 @@
 // view: how messages, work, proposals and grants are shown: as text framed for people and models, and as the JSON
 // shapes every interface (the CLI's --json, a control panel) returns.
-import { bytes, when } from '../lib/index.js';
+import { bytes, when } from '../../../lib/index.js';
 import { KNOWN } from '../protocol/index.js';
 const id12 = (x) => x.slice(0, 12);
 // Trailers a store writes about its own records (the git store's list of attached paths): shown as `Files:`, not again.
 const STORED = new Set(['ringi-files']);
-// Frames a message for a model: sender and how it is known, id, addressing, hop; the body is the peer's content.
-export const render = (all, m, { max = 0, files = () => m.files } = {}) => {
-    const lines = [`=== ${id12(m.id)} · ${m.from} (${m.trust}) → ${m.to.join(', ') || '(nobody)'} · ${when(m.time)}`];
-    if (m.re || m.trailers.re) {
-        const p = m.reId ? all.get(m.reId) : undefined;
-        lines.push(`Re: ${id12(m.reId ?? m.re ?? m.trailers.re[0])}${p ? ` (${p.from}) ${p.subject}` : ' (not available)'}`);
-    }
-    if (m.bad)
-        lines.push(`Malformed: ${m.bad} (not delivered, not part of tasks)`);
-    if (m.kind)
-        lines.push(`Kind: ${m.kind}`);
-    if (m.state)
-        lines.push(`State: ${m.state}`);
-    if (m.assign)
-        lines.push(`Assign: ${m.assign.join(', ')}`);
-    if (m.roles)
-        lines.push(`Roles: ${Object.entries(m.roles).map(([k, v]) => `${k}=${v}`).join(', ')}`);
-    if (m.hopEff)
-        lines.push(`Hop: ${m.hop}${m.hopEff !== m.hop ? ` (effective ${m.hopEff})` : ''}`);
-    for (const [k, v] of Object.entries(m.trailers))
-        if (!KNOWN.has(k) && !STORED.has(k))
-            lines.push(`${k[0].toUpperCase()}${k.slice(1)}: ${v.join(', ')}`);
-    const fl = files();
-    if (fl.length)
-        lines.push(`Files: ${fl.map(f => `${f.path} (${bytes(f.size ?? 0)})`).join(', ')}`);
-    if (m.refused.length)
-        lines.push(`Refused: ${m.refused.map(f => `${f.path} (${f.why ?? `mode ${f.mode}`})`).join(', ')}`);
-    lines.push(`Subject: ${m.subject}`);
+const reLines = (all, m) => {
+    if (!m.re && !m.trailers.re)
+        return [];
+    const p = m.reId ? all.get(m.reId) : undefined;
+    return [`Re: ${id12(m.reId ?? m.re ?? m.trailers.re[0])}${p ? ` (${p.from}) ${p.subject}` : ' (not available)'}`];
+};
+// What the message sets, in a fixed order, then the trailers ringi does not know, as written.
+const trailerLines = (m) => {
+    const known = [
+        ['Malformed', m.bad ? `${m.bad} (not delivered, not part of tasks)` : null],
+        ['Kind', m.kind || null], ['State', m.state || null], ['Assign', m.assign ? m.assign.join(', ') : null],
+        ['Roles', m.roles ? Object.entries(m.roles).map(([k, v]) => `${k}=${v}`).join(', ') : null],
+        ['Hop', m.hopEff ? `${m.hop}${m.hopEff !== m.hop ? ` (effective ${m.hopEff})` : ''}` : null],
+    ];
+    const other = Object.entries(m.trailers).filter(([k]) => !KNOWN.has(k) && !STORED.has(k))
+        .map(([k, v]) => [`${k[0].toUpperCase()}${k.slice(1)}`, v.join(', ')]);
+    return [...known, ...other].flatMap(([k, v]) => v === null ? [] : [`${k}: ${v}`]);
+};
+const fileLines = (m, fl) => [
+    ...fl.length ? [`Files: ${fl.map(f => `${f.path} (${bytes(f.size ?? 0)})`).join(', ')}`] : [],
+    ...m.refused.length ? [`Refused: ${m.refused.map(f => `${f.path} (${f.why ?? `mode ${f.mode}`})`).join(', ')}`] : [],
+];
+// The body, cut at `max` characters with a pointer to the whole.
+const bodyLines = (m, max) => {
     const body = max && m.body.length > max ? `${m.body.slice(0, max)}\n[… ${m.body.length - max} more chars: read ${id12(m.id)}]` : m.body;
-    if (body)
-        lines.push('', body);
-    lines.push(`=== end ${id12(m.id)}`);
-    return lines.join('\n');
+    return body ? ['', body] : [];
 };
+// Frames a message for a model: sender and how it is known, id, addressing, hop; the body is the peer's content.
+export const render = (all, m, { max = 0, files = () => m.files } = {}) => [
+    `=== ${id12(m.id)} · ${m.from} (${m.trust}) → ${m.to.join(', ') || '(nobody)'} · ${when(m.time)}`,
+    ...reLines(all, m), ...trailerLines(m), ...fileLines(m, files()),
+    `Subject: ${m.subject}`, ...bodyLines(m, max),
+    `=== end ${id12(m.id)}`,
+].join('\n');
 export const oneLine = (m) => `${id12(m.id)}  ${when(m.time).slice(5)}  ${m.from} → ${m.to.join(',') || '-'}  ${[m.kind, m.state].filter(Boolean).map(x => `[${x}] `).join('')}${m.subject}`;
 export const asJson = (m) => ({ id: m.id, from: m.from, trust: m.trust, to: m.to, re: m.re, kind: m.kind, state: m.state,
     assign: m.assign, roles: m.roles, hop: m.hop, hopEff: m.hopEff, bad: m.bad, time: new Date(m.time * 1000).toISOString(), subject: m.subject,

package/target/esm/core/hub/work/index.js

@@ -0,0 +1,13 @@
+// profile: what a task is, as data. ringi is a point of coordination, not a methodology: the states of a piece of
+// work, which of them end it, and who may move it, assign it or label people in it are declared by a profile
+// that lives in the hub (`profiles/<name>.json` on main) and is chosen per room. The A2A task model is one such
+// profile (resources/profiles/a2a-1.json); a team or a framework brings its own (architect, reviewer, tester, …).
+// This file interprets any profile; it knows no state, role or rule by name.
+export const PROFILE_SCHEMA = 'ringi-profile/1';
+export const DEFAULT_PROFILE = 'a2a-1';
+// A hub whose rooms may follow profiles other than the built-in A2A rules declares this capability, so that an older
+// client, which knows only those rules, refuses it instead of misreading it.
+export const PROFILES_CAPABILITY = 'profiles/1';
+export * from './parse.js';
+export * from './task.js';
+//# sourceMappingURL=index.js.map

package/target/esm/core/hub/work/parse.js

@@ -0,0 +1,37 @@
+// parse: a profile is refused, not guessed at, when it is not exactly what its schema describes.
+import { ID_RE, TOKEN_RE } from '../protocol/index.js';
+import { fail, strictJson } from '../../../lib/index.js';
+import { PROFILE_SCHEMA } from './index.js';
+const PRINCIPAL_RE = /^(?:requester|assignee|member|role:[a-z][a-z0-9-]*|agent:[a-z0-9]+(?:[._-][a-z0-9]+)*)$/;
+const RULE_RE = /^(?:assign|roles|grant|state:(?:\*|[a-z][a-z0-9-]*))$/;
+const distinctTokens = (xs) => Array.isArray(xs) && xs.length > 0 && xs.every(s => TOKEN_RE.test(s)) && new Set(xs).size === xs.length;
+const principals = (v) => Array.isArray(v) && v.length <= 64 && v.every(x => PRINCIPAL_RE.test(x));
+const waitingOk = (p) => p.waiting === undefined || (p.states.includes(p.waiting) && !p.terminal.includes(p.waiting));
+// The profile's shape, checked in order: each check may rely on the ones before it.
+const SHAPE = [
+    [p => p.schema === PROFILE_SCHEMA, p => `schema ${String(p.schema)} is not ${PROFILE_SCHEMA}; upgrade ringi or fix the profile`],
+    [p => ID_RE.test(p.name ?? ''), () => 'a profile needs a name like team-flow-1'],
+    [p => TOKEN_RE.test(p.opens ?? ''), () => '`opens` names the Kind that opens a piece of work'],
+    [p => distinctTokens(p.states), () => '`states` must be distinct tokens'],
+    [p => p.states.includes(p.initial), () => '`initial` must be one of the states'],
+    [p => Array.isArray(p.terminal) && p.terminal.every(s => p.states.includes(s)), () => '`terminal` must list states'],
+    [waitingOk, () => '`waiting` must be a state that does not end the work'],
+    [p => !!p.rules && typeof p.rules === 'object', () => '`rules` is required'],
+];
+// Why one rule is wrong, or null.
+const ruleProblem = (p, k, v) => {
+    if (!RULE_RE.test(k))
+        return `unknown rule ${k}`;
+    if (k.startsWith('state:') && k !== 'state:*' && !p.states.includes(k.slice(6)))
+        return `rule ${k} names an unknown state`;
+    return principals(v) ? null : `rule ${k} must list principals: requester, assignee, member, role:<label>, agent:<id>`;
+};
+export const parseProfile = (text, label) => {
+    const p = strictJson(text, label);
+    const wrong = SHAPE.find(([ok]) => !ok(p));
+    const why = wrong ? wrong[1](p) : Object.entries(p.rules).map(([k, v]) => ruleProblem(p, k, v)).find(x => x);
+    if (why)
+        fail(`${label}: ${why}`);
+    return p;
+};
+//# sourceMappingURL=parse.js.map

package/target/esm/core/hub/work/task.js

@@ -0,0 +1,68 @@
+// task: a piece of work folded over its messages in thread order, by the room's profile.
+import { HEARTBEATS, one, ordered } from '../protocol/index.js';
+// Who a principal of a rule is in a piece of work.
+const PRINCIPALS = {
+    requester: (who, t) => who === t.requester,
+    assignee: (who, t) => t.assignees.includes(who),
+    member: () => true,
+};
+const holds = (p, who, t) => PRINCIPALS[p]?.(who, t) ?? (p.startsWith('role:') ? t.roles[who] === p.slice(5) : p === `agent:${who}`);
+const allows = (rule, who, t) => !!rule?.some(p => holds(p, who, t));
+const ruleFor = (profile, state) => profile.rules[`state:${state}`] ?? profile.rules['state:*'];
+// A message belongs to the nearest work item on its Re chain, itself included.
+export const taskFor = (all, m, profile) => {
+    for (let x = m, i = 0; x && i < 100000; x = x.reId ? all.get(x.reId) : undefined, i++)
+        if (x.kind === profile.opens && !x.bad)
+            return x;
+    return null;
+};
+const grant = (profile, t, b, m) => {
+    if (!one(m, 'grant') || !allows(profile.rules.grant, m.from, b))
+        return null;
+    t.grant = one(m, 'grant');
+    return 'grant';
+};
+const roles = (profile, t, b, m) => {
+    if (!m.roles || !allows(profile.rules.roles, m.from, b))
+        return null;
+    for (const [id, label] of Object.entries(m.roles))
+        label === 'none' ? delete t.roles[id] : t.roles[id] = label;
+    return 'roles';
+};
+const assign = (profile, t, b, m) => {
+    if (!m.assign || !allows(profile.rules.assign, m.from, b))
+        return null;
+    t.assignees = m.assign;
+    return 'assigned';
+};
+// The first terminal state is final.
+const movable = (profile, t, s) => !!s && !profile.terminal.includes(t.state) && profile.states.includes(s);
+const state = (profile, t, b, m) => {
+    if (!movable(profile, t, m.state) || !allows(ruleFor(profile, m.state), m.from, b))
+        return null;
+    Object.assign(t, { state: m.state, by: m.from, at: m.time });
+    return `state.${m.state}`;
+};
+const STEPS = [grant, roles, assign, state];
+const opening = (root, profile, msgs) => ({ root, msgs, state: profile.initial, by: root.from, at: root.time,
+    requester: root.from, roles: { ...root.roles }, assignees: root.assign ?? (root.to.includes('*') ? [] : root.to.filter(x => x !== root.from)),
+    grant: one(root, 'grant'), effects: new Map([[root.id, ['opened', ...(root.assign ? ['assigned'] : [])]]]) });
+// Heartbeats never take part in work (§6), whatever trailers they carry.
+const partOf = (all, m, root, profile) => !m.bad && !(m.kind && HEARTBEATS.has(m.kind)) && taskFor(all, m, profile) === root;
+// A work item folds over its messages in thread order. Every right is judged on the work as it was before the
+// message, so a label given in a message authorizes nothing in that same message, while its holder may still hand it
+// over and reassign in one reply. Opening sets the initial state and assignees (Assign, else To minus the opener; none
+// for To: *). The first terminal state is final; assignment and labels may still change after it.
+export const taskOf = (all, root, profile) => {
+    const t = opening(root, profile, ordered([...all.values()].filter(m => partOf(all, m, root, profile))));
+    for (const m of t.msgs.filter(m => m !== root)) {
+        const before = { ...t, roles: { ...t.roles }, assignees: [...t.assignees] };
+        const fx = STEPS.map(step => step(profile, t, before, m)).filter((x) => !!x);
+        if (fx.length)
+            t.effects.set(m.id, fx);
+    }
+    return t;
+};
+export const tasksIn = (all, profile) => [...all.values()].filter(m => m.kind === profile.opens && !m.bad).map(r => taskOf(all, r, profile));
+export const isOpen = (t, profile) => !profile.terminal.includes(t.state);
+//# sourceMappingURL=task.js.map

package/target/esm/core/signing/index.js

@@ -0,0 +1,4 @@
+// signer: custody of a local key, independent of its storage, transport and object format. The resolver selects a
+// key for a hub/principal; the signer sees exact bytes and an explicit interaction policy, never Git arguments.
+export {};
+//# sourceMappingURL=index.js.map

package/target/esm/index.js

@@ -1,9 +1,10 @@
 // The library: the message protocol, profiles, decisions, signals and the Store port, for programs that coordinate
 // through ringi without its command line (a framework's own runner, another store, another client).
-export * from './protocol/index.js';
-export * from './domain/profiles.js';
-export * as decide from './domain/decisions.js';
-export * as signals from './domain/signals.js';
-export { STORES } from './store/index.js';
-export { openHub, openRoom, createHub, contractAt } from './hub/index.js';
+// Importing it wires this machine's defaults (composition/); a program that brings its own adapters calls wire().
+import './composition/index.js';
+export * from './core/hub/protocol/index.js';
+export * from './core/hub/work/index.js';
+export * as decide from './core/hub/decisions/index.js';
+export * as signals from './core/hub/signals/index.js';
+export { openHub, openRoom, createHub, contractAt } from './core/hub/rooms/index.js';
 //# sourceMappingURL=index.js.map

package/target/esm/lib/fail.js

@@ -0,0 +1,18 @@
+// fail: a refusal ringi explains (Fail, shown as its message), apart from a bug (any other error, shown with its stack).
+export class Fail extends Error {
+}
+export const fail = (msg) => { throw new Fail(msg); };
+export const errno = (e) => e?.code;
+// A write the host refused: what to do is the same for every host; a tool's own way (its sandbox settings) is added
+// by the interface that knows the tools (cli.ts).
+export class WriteDenied extends Fail {
+    where;
+    constructor(where, detail) {
+        super(`cannot write ${where}: ${detail}
+  An agent in a sandbox: re-run this same command with your host's sandbox escalation; the operator approves it.
+  The operator can instead add ${where} to the host's writable roots or point RINGI_HOME at a location the host
+  already allows.`);
+        this.where = where;
+    }
+}
+//# sourceMappingURL=fail.js.map

package/target/esm/lib/index.js

@@ -1,202 +1,27 @@
-// lib: helpers that know nothing of ringi: failing, notes, formatting, strict JSON, atomic files, the inter-process
-// lock.
-import fs from 'node:fs';
-export class Fail extends Error {
-}
-export const fail = (msg) => { throw new Fail(msg); };
-export const note = (s) => { process.stderr.write(`ringi: ${s}\n`); };
+// lib: helpers that know nothing of ringi and touch no host: failing (fail.ts), notes, formatting, strict JSON
+// (json.ts). Files and locks are the adapters' (adapters/fs).
+// Notes and alarms go where the program sends them (composition/: stderr). Those written before it says where wait
+// for it, so none is lost to the order modules load in.
+const notes = [];
+let sink = null;
+export const notesTo = (fn) => {
+    sink = fn;
+    for (const line of notes.splice(0))
+        fn(line);
+};
+export const note = (s) => {
+    const line = `ringi: ${s}\n`;
+    if (sink)
+        sink(line);
+    else
+        notes.push(line);
+};
 export const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 export const when = (t) => `${new Date(t * 1000).toISOString().slice(0, 16).replace('T', ' ')}Z`;
 export const bytes = (n) => n < 1024 ? `${n} B` : n < 1 << 20 ? `${(n / 1024).toFixed(1)} KB` : `${(n / (1 << 20)).toFixed(1)} MB`;
 export const short = (id) => id.slice(0, 12);
 export const stamp = () => new Date().toISOString().slice(0, 19) + 'Z';
 export const words = (v) => v ? String(v).split(/[\s,]+/).filter(Boolean) : [];
-export const errno = (e) => e?.code;
-// --- JSON files ---
-export const writeJsonAtomic = (file, v) => {
-    const tmp = `${file}.${process.pid}`;
-    fs.writeFileSync(tmp, JSON.stringify(v, null, 2));
-    fs.renameSync(tmp, file);
-};
-// JSON.parse silently keeps the last of duplicate fields; for contracts and authority that hides a second value.
-// This parser validates the structure first and refuses duplicates.
-export const strictJson = (text, label = 'JSON') => {
-    let at = 0;
-    const ws = () => { while (at < text.length && /\s/.test(text[at]))
-        at++; };
-    const bad = () => fail(`${label}: malformed or duplicate JSON field at ${at}`);
-    const str = () => {
-        const start = at++;
-        while (at < text.length && text[at] !== '"')
-            at += text[at] === '\\' ? 2 : 1;
-        if (text[at++] !== '"')
-            bad();
-        try {
-            return JSON.parse(text.slice(start, at));
-        }
-        catch {
-            return bad();
-        }
-    };
-    const value = () => {
-        ws();
-        const c = text[at];
-        if (c === '{') {
-            at++;
-            ws();
-            const keys = new Set();
-            if (text[at] === '}') {
-                at++;
-                return;
-            }
-            for (;;) {
-                ws();
-                if (text[at] !== '"')
-                    bad();
-                const k = str();
-                if (keys.has(k))
-                    bad();
-                keys.add(k);
-                ws();
-                if (text[at++] !== ':')
-                    bad();
-                value();
-                ws();
-                const n = text[at++];
-                if (n === '}')
-                    return;
-                if (n !== ',')
-                    bad();
-            }
-        }
-        if (c === '[') {
-            at++;
-            ws();
-            if (text[at] === ']') {
-                at++;
-                return;
-            }
-            for (;;) {
-                value();
-                ws();
-                const n = text[at++];
-                if (n === ']')
-                    return;
-                if (n !== ',')
-                    bad();
-            }
-        }
-        if (c === '"') {
-            str();
-            return;
-        }
-        const m = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(text.slice(at));
-        if (!m)
-            bad();
-        at += m[0].length;
-    };
-    value();
-    ws();
-    if (at !== text.length)
-        bad();
-    return JSON.parse(text);
-};
-// --- the lock ---
-// A lock is a file holding its owner (pid and a random token), created by hard-linking a file already written: it
-// never exists without its owner and never replaces another lock. All acquisitions and the recovery of a dead
-// owner's lock pass one gate, so two contenders cannot both clear a lock just taken by a third. A lock is taken from
-// someone else only when that owner's process is gone, never by age; an unreadable owner is never taken over; only
-// the owner releases it. A gate abandoned by a dead process needs the operator: recovering the recoverer would need
-// yet another gate.
-const ownerAlive = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (e) {
-        return errno(e) !== 'ESRCH';
-    }
-};
-const ownerOf = (f) => {
-    try {
-        return fs.readFileSync(f, 'utf8');
-    }
-    catch {
-        return null;
-    }
-};
-const deadOwner = (t) => {
-    const pid = Number(String(t ?? '').split('.')[0]);
-    return Number.isInteger(pid) && pid > 0 && !ownerAlive(pid);
-};
-const claim = (f, token) => {
-    const tmp = `${f}.${token}.tmp`;
-    fs.writeFileSync(tmp, token, { flag: 'wx', mode: 0o600 });
-    try {
-        fs.linkSync(tmp, f);
-        return true;
-    }
-    catch (e) {
-        if (errno(e) === 'EEXIST')
-            return false;
-        throw e;
-    }
-    finally {
-        fs.rmSync(tmp, { force: true });
-    }
-};
-const release = (f, token) => {
-    if (ownerOf(f) === token)
-        fs.rmSync(f, { force: true });
-};
-const lockWait = new Int32Array(new SharedArrayBuffer(4));
-export const locked = (file, fn, timeout = 120000) => {
-    const token = `${process.pid}.${Math.random().toString(36).slice(2)}`;
-    const gate = `${file}.recover`;
-    const until = Date.now() + timeout;
-    for (;;) {
-        if (claim(gate, token)) {
-            try {
-                if (deadOwner(ownerOf(file)))
-                    fs.rmSync(file, { force: true });
-                if (claim(file, token))
-                    break;
-            }
-            finally {
-                release(gate, token);
-            }
-        }
-        else if (deadOwner(ownerOf(gate))) {
-            fail(`${gate} was abandoned; if no ringi process runs, remove it`);
-        }
-        if (Date.now() >= until)
-            fail(`${file} is held by another process or an unknown owner; if no ringi process runs, remove it`);
-        Atomics.wait(lockWait, 0, 0, 25);
-    }
-    try {
-        return fn();
-    }
-    finally {
-        release(file, token);
-    }
-};
-// --- writing where a sandbox may refuse ---
-export const SANDBOX = /Operation not permitted|Permission denied|Read-only file system|EPERM|EACCES|EROFS/;
-export const cannotWrite = (where, detail) => fail(`cannot write ${where}: ${detail}
-  An agent in a sandbox: re-run this same command with your host's sandbox escalation; the operator approves it.
-  The operator can instead add ${where} to the host's writable roots (Codex: [sandbox_workspace_write] writable_roots
-  in ~/.codex/config.toml) or point RINGI_HOME at a location the host already allows.`);
-export const guardWrite = (where, fn) => {
-    try {
-        return fn();
-    }
-    catch (e) {
-        if (e instanceof Fail)
-            throw e;
-        if (['EPERM', 'EACCES', 'EROFS'].includes(errno(e) ?? ''))
-            cannotWrite(where, `${errno(e)} on ${e.path ?? 'a file'}`);
-        throw e;
-    }
-};
-export const mkdirIn = (where, d) => { guardWrite(where, () => fs.mkdirSync(d, { recursive: true, mode: 0o700 })); };
+export * from './fail.js';
+export * from './json.js';
 //# sourceMappingURL=index.js.map

package/target/esm/lib/json.js

@@ -0,0 +1,81 @@
+// json: JSON read strictly. JSON.parse silently keeps the last of duplicate
+// fields; for contracts and authority that hides a second value, so the structure is checked first and a duplicate
+// field is refused.
+import { fail } from './fail.js';
+const LITERAL = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/;
+// A recursive-descent check of JSON's structure: each kind of value is one small method.
+class Strict {
+    at = 0;
+    text;
+    label;
+    constructor(text, label) { this.text = text; this.label = label; }
+    bad() { return fail(`${this.label}: malformed or duplicate JSON field at ${this.at}`); }
+    ws() { while (this.at < this.text.length && /\s/.test(this.text[this.at]))
+        this.at++; }
+    peek() { this.ws(); return this.text[this.at]; }
+    take(c) { if (this.text[this.at++] !== c)
+        this.bad(); }
+    str() {
+        const start = this.at++;
+        while (this.at < this.text.length && this.text[this.at] !== '"')
+            this.at += this.text[this.at] === '\\' ? 2 : 1;
+        this.take('"');
+        try {
+            return JSON.parse(this.text.slice(start, this.at));
+        }
+        catch {
+            return this.bad();
+        }
+    }
+    // The character after the next item: a comma, or the closing bracket.
+    next() { this.ws(); return this.text[this.at++]; }
+    // Items between an opening bracket and `close`, separated by commas.
+    items(close, item) {
+        this.at++;
+        if (this.peek() === close) {
+            this.at++;
+            return;
+        }
+        do
+            item();
+        while (this.next() === ',');
+        if (this.text[this.at - 1] !== close)
+            this.bad();
+    }
+    object() {
+        const keys = new Set();
+        this.items('}', () => this.member(keys));
+    }
+    member(keys) {
+        if (this.peek() !== '"')
+            this.bad();
+        const k = this.str();
+        if (keys.has(k))
+            this.bad();
+        keys.add(k);
+        this.ws();
+        this.take(':');
+        this.value();
+    }
+    literal() { this.at += (LITERAL.exec(this.text.slice(this.at)) ?? this.bad())[0].length; }
+    value() {
+        const c = this.peek();
+        if (c === '{')
+            this.object();
+        else if (c === '[')
+            this.items(']', () => this.value());
+        else if (c === '"')
+            this.str();
+        else
+            this.literal();
+    }
+}
+export const strictJson = (text, label = 'JSON') => {
+    const s = new Strict(text, label);
+    s.value();
+    s.ws();
+    if (s.at !== text.length)
+        s.bad();
+    return JSON.parse(text);
+};
+//# sourceMappingURL=json.js.map

package/target/dts/app/agent.d.ts

@@ -1,109 +0,0 @@
-import type { Session } from '../runtime/session.ts';
-import type { Actor } from './room.ts';
-export { bound } from '../runtime/session.ts';
-export { watch } from '../runtime/watch.ts';
-export type { WatchOptions } from '../runtime/watch.ts';
-export type InboxOptions = {
-    peek?: boolean;
-    limit?: number;
-};
-export declare const started: ({ R }: Actor) => {
-    quorum: number | null;
-    agents: number;
-    started: boolean;
-};
-export declare const inbox: ({ R, me }: Actor, { peek, limit }?: InboxOptions) => {
-    rest: number;
-    cursors: {
-        [x: string]: string;
-    };
-    all: import("../protocol/index.ts").All;
-    msgs: {
-        id: string;
-        from: string;
-        trust: 'asserted' | 'verified';
-        time: number;
-        seq: number;
-        invalid: string | null;
-        subject: string;
-        body: string;
-        to: string[];
-        re: string | null;
-        kind: string | null;
-        state: string | null;
-        assign: string[] | null;
-        roles: Record<string, string> | null;
-        hop: number;
-        bad: string | null;
-        trailers: import("../protocol/index.ts").Trailers;
-        refused: import("../protocol/index.ts").Refused[];
-        reId: string | null;
-        hopEff: number;
-        files: import("../protocol/index.ts").FileRef[];
-    }[];
-};
-export type Inbox = ReturnType<typeof inbox>;
-export declare const take: ({ R, me }: Actor, ref: string) => {
-    m: import("../protocol/index.ts").Message;
-    made: boolean;
-};
-export declare const whoami: ({ s, R }: Actor & {
-    s?: Session;
-}) => {
-    session: Session;
-    profile: string;
-    members: string[];
-};
-export declare const card: ({ R, me }: Actor, text: string) => string;
-export type PingInput = {
-    to: string;
-    text?: string;
-    next?: number;
-    re?: string;
-};
-export declare const ping: ({ R, me }: Actor, { to, text, next, re }: PingInput) => {
-    id: string;
-    to: string;
-    previous: {
-        id: string;
-        answeredAt: number | null;
-    } | null;
-};
-export declare const wait: (a: Actor, { max, ...options }?: InboxOptions & {
-    max?: number;
-}) => Promise<{
-    inbox: {
-        rest: number;
-        cursors: {
-            [x: string]: string;
-        };
-        all: import("../protocol/index.ts").All;
-        msgs: {
-            id: string;
-            from: string;
-            trust: 'asserted' | 'verified';
-            time: number;
-            seq: number;
-            invalid: string | null;
-            subject: string;
-            body: string;
-            to: string[];
-            re: string | null;
-            kind: string | null;
-            state: string | null;
-            assign: string[] | null;
-            roles: Record<string, string> | null;
-            hop: number;
-            bad: string | null;
-            trailers: import("../protocol/index.ts").Trailers;
-            refused: import("../protocol/index.ts").Refused[];
-            reId: string | null;
-            hopEff: number;
-            files: import("../protocol/index.ts").FileRef[];
-        }[];
-    };
-    seconds: number;
-} | {
-    inbox: null;
-    seconds: number;
-}>;