lattris 0.1.3 → 0.2.0

package/README.md

@@ -41,13 +41,13 @@ sign you up.
 ## What it does
 
 ```
-lattris capture      write a note or start a session
+lattris capture      write a note, a session or a recording, or rows of a dataset
 lattris note         a single note
 lattris session      a session and its turns
 lattris recording    a recording and its transcript
 lattris memory       read and manage blocks
 lattris link         connect two blocks
-lattris get          read a block
+lattris get          read your blocks, questions and invites, and your datasets' rows
 lattris ask          ask a question of a tree
 lattris invite       invite someone
 lattris contact      manage contacts

package/dist/build.json

@@ -1 +1,4 @@
-{"commit":"cecf7e60eb450bce092dc992155ff77002fc1379","builtAt":"2026-09-15T22:27:41Z"}
+{
+  "commit": "8b66c9fde9fb6cd5cf716c08fa0e1ed1234c0651",
+  "builtAt": "2026-09-27T23:55:25.807Z"
+}

package/dist/datasets/capture.js

@@ -0,0 +1,118 @@
+import { gzipSync } from 'node:zlib';
+import { formatCaptured } from "../render/datasets.js";
+import { emit } from "../render/output.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { signedIn } from "../request/access-token.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { parseArgs } from "../request/flags.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { LINES_PER_PIECE, NO_COUNTS, REFUSALS_NAMED, isCounts, linesOf, outcomeOf, piecesOf, withPiece } from "./pieces.js";
+const counted = (n) => new Intl.NumberFormat('en-US').format(n);
+export const CAPTURE_ROWS_HELP = `capture rows — save rows into one of your datasets.
+
+Usage:
+  lattris capture rows <name> < rows.ndjson
+  … | lattris capture rows <name>
+
+A line is one row: one JSON object on one line, its fields named as the dataset
+names them. The rows arrive on stdin, newline-delimited JSON, never as an
+argument. Blank lines are skipped, and still counted as lines.
+
+  lattris get datasets          the datasets the API takes
+  lattris get dataset <name>    GET /datasets/{name}: its fields, their types and
+                                bounds, its identity, and an example line to copy
+
+A re-send replaces. A row is known by the fields the dataset names as its
+identity: a line with the identity of a row you hold replaces that row, and
+never adds a second.
+
+The lines go out as they were read, never parsed or rewritten: gzipped, in
+pieces of at most ${counted(LINES_PER_PIECE)} lines, one request after another. One answer comes
+back for the whole input:
+
+  on a pipe      the API's capture body, summed over the pieces:
+                 {"sent":…,"added":…,"replaced":…,"refused":…,"refusals":[…]}
+  at a terminal  one summary line, then each refusal named
+
+A refusal names its line in the whole input, blank lines counted, with its code
+and its reason. The first ${counted(REFUSALS_NAMED)} are named, as the API names them; "refused"
+counts every one.
+
+Exit 0 when every line was saved, 1 when any line was refused.
+
+If a piece fails (a 5xx, a lost connection, a lost answer), the capture stops
+there, exit 1: the counts cover the pieces saved before it, and nothing after
+it is sent. Unlike a note, nothing is kept to resend and no key rides the
+request: send the same input again. Rows already saved are replaced by their
+identity, never duplicated.
+
+LATTRIS_SESSION_ID is not needed: rows are not notes.`;
+const CAPTURE_ROWS_USAGE = 'Usage: … | lattris capture rows <name>';
+const stopNote = (piece) => {
+    const them = piece.lines > 1 ? 'them' : 'it';
+    return (`Stopped at ${linesOf(piece)}: nothing confirmed ${them}, and no line after ${them} was sent. ` +
+        (piece.first > 1 ? `The counts cover lines 1–${piece.first - 1}. ` : '') +
+        'Sending the same input again is safe: rows are replaced by their identity, never duplicated.\n');
+};
+const report = (io, name, total) => emit(io, total, JSON.stringify(total), (counts) => formatCaptured(name, counts));
+const lostAnswer = (piece, why) => refusal(`The answer to ${linesOf(piece)} was lost (${why}).\n`, EXIT.GENERIC);
+export const captureRows = async (cfg, io, rest) => {
+    if (io.stdin.isTTY) {
+        io.stdout.write(`${CAPTURE_ROWS_HELP}\n`);
+        return;
+    }
+    const { positionals, unknown, notAnId } = parseArgs({}, rest, [0]);
+    if (unknown)
+        return refusal(`Unknown flag: ${unknown}\n`);
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1)
+        return refusal(`${CAPTURE_ROWS_USAGE}\n`);
+    const name = positionals[0];
+    let accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const url = `${cfg.apiUrl}/datasets/${encodeURIComponent(name)}/rows`;
+    let total = NO_COUNTS;
+    const stopped = (piece, why) => {
+        report(io, name, total);
+        return { ...why, message: `${why.message}${stopNote(piece)}` };
+    };
+    for await (const piece of piecesOf(io.stdin.stream, LINES_PER_PIECE)) {
+        if (piece.first > 1) {
+            accessToken = await signedIn(io, cfg);
+            if (typeof accessToken !== 'string')
+                return stopped(piece, accessToken);
+        }
+        let result;
+        try {
+            result = await io.api(accessToken, url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-ndjson', 'Content-Encoding': 'gzip' },
+                body: gzipSync(piece.bytes)
+            });
+        }
+        catch (e) {
+            const why = sanitizeForTerminal(e instanceof Error ? e.message : String(e));
+            return stopped(piece, lostAnswer(piece, why));
+        }
+        if (result.ok && isCounts(result.data)) {
+            total = withPiece(total, result.data, piece.first);
+            continue;
+        }
+        if (result.ok)
+            return stopped(piece, lostAnswer(piece, 'it carried no counts'));
+        const outcome = outcomeOf(result.status, result.body);
+        if (outcome === 'counts') {
+            total = withPiece(total, result.body, piece.first);
+            continue;
+        }
+        if (outcome === 'refused' && piece.first === 1)
+            return refusalOf(result);
+        return stopped(piece, refusalOf(result));
+    }
+    report(io, name, total);
+    if (total.refused > 0)
+        return refusal('', EXIT.GENERIC);
+};
+//# sourceMappingURL=capture.js.map

package/dist/datasets/page.js

@@ -0,0 +1,64 @@
+import { formatRowPage } from "../render/datasets.js";
+import { emit } from "../render/output.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+import { signedIn } from "../request/access-token.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { parseArgs } from "../request/flags.js";
+import { refusal } from "../store/exit.js";
+const GET_ROWS_USAGE = 'Usage: lattris get rows <name> [field=value …] [--from <time>] [--to <time>] [--limit <n>] [--cursor <token>]';
+const PAGE_FLAGS = {
+    '--from': 'from',
+    '--to': 'to',
+    '--limit': 'limit',
+    '--cursor': 'cursor'
+};
+export const filtersOf = (words) => {
+    const filters = [];
+    for (const word of words) {
+        const at = word.indexOf('=');
+        if (at === -1)
+            return { notAFilter: word };
+        filters.push([word.slice(0, at), word.slice(at + 1)]);
+    }
+    return filters;
+};
+export const getRows = async (cfg, io, rest) => {
+    const { flags, positionals, unknown, notAnId } = parseArgs(PAGE_FLAGS, rest, [0]);
+    if (unknown)
+        return refusal(`Unknown flag: ${unknown}\n`);
+    if (notAnId)
+        return refusal(notAnId);
+    const [name, ...words] = positionals;
+    if (name === undefined)
+        return refusal(`${GET_ROWS_USAGE}\n`);
+    const filters = filtersOf(words);
+    if (!Array.isArray(filters)) {
+        return refusal(`A filter is field=value, and ${sanitizeForTerminal(filters.notAFilter)} has no =.\n${GET_ROWS_USAGE}\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const url = new URL(`${cfg.apiUrl}/datasets/${encodeURIComponent(name)}/rows`);
+    for (const [field, value] of filters)
+        url.searchParams.append(field, value);
+    for (const key of Object.values(PAGE_FLAGS)) {
+        const value = flags[key];
+        if (value !== undefined)
+            url.searchParams.append(key, value);
+    }
+    const result = await io.api(accessToken, url);
+    if (!result.ok)
+        return refusalOf(result);
+    emit(io, result.data, result.rawText, formatRowPage);
+    const next = result.data.nextCursor;
+    if (typeof next === 'string' && io.stdout.isTTY) {
+        const again = ['get', 'rows', name, ...words];
+        for (const [flag, key] of Object.entries(PAGE_FLAGS)) {
+            const value = flags[key];
+            if (key !== 'cursor' && value !== undefined)
+                again.push(flag, value);
+        }
+        io.stderr.write(`More: ${renderRunHint([...again, '--cursor', next])}\n`);
+    }
+};
+//# sourceMappingURL=page.js.map

package/dist/datasets/pieces.js

@@ -0,0 +1,78 @@
+export const LINES_PER_PIECE = 5000;
+export const REFUSALS_NAMED = 1000;
+const NEWLINE = 0x0a;
+const bytesOf = (chunk) => typeof chunk === 'string'
+    ? Buffer.from(chunk, 'utf8')
+    : Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+export async function* piecesOf(input, size) {
+    let held = [];
+    let heldLines = 0;
+    let first = 1;
+    let yielded = false;
+    for await (const chunk of input) {
+        const bytes = bytesOf(chunk);
+        let start = 0;
+        for (let at = bytes.indexOf(NEWLINE); at !== -1; at = bytes.indexOf(NEWLINE, at + 1)) {
+            heldLines += 1;
+            if (heldLines < size)
+                continue;
+            held.push(bytes.subarray(start, at + 1));
+            yield { first, lines: heldLines, bytes: Buffer.concat(held) };
+            yielded = true;
+            first += heldLines;
+            held = [];
+            heldLines = 0;
+            start = at + 1;
+        }
+        if (start < bytes.length)
+            held.push(bytes.subarray(start));
+    }
+    const rest = Buffer.concat(held);
+    if (rest.length === 0 && yielded)
+        return;
+    const unended = rest.length > 0 && rest[rest.length - 1] !== NEWLINE ? 1 : 0;
+    yield { first, lines: heldLines + unended, bytes: rest };
+}
+export const renumbered = (refusal, first) => {
+    if (first === 1 || typeof refusal.line !== 'number')
+        return refusal;
+    const line = refusal.line + first - 1;
+    const said = `Line ${refusal.line}`;
+    const message = typeof refusal.message === 'string' &&
+        refusal.message.startsWith(said) &&
+        !/^\d/.test(refusal.message.slice(said.length))
+        ? `Line ${line}${refusal.message.slice(said.length)}`
+        : refusal.message;
+    return { ...refusal, line, message };
+};
+export const NO_COUNTS = {
+    sent: 0,
+    added: 0,
+    replaced: 0,
+    refused: 0,
+    refusals: []
+};
+export const withPiece = (total, answer, first) => ({
+    sent: total.sent + answer.sent,
+    added: total.added + answer.added,
+    replaced: total.replaced + answer.replaced,
+    refused: total.refused + answer.refused,
+    refusals: [
+        ...total.refusals,
+        ...answer.refusals
+            .slice(0, Math.max(0, REFUSALS_NAMED - total.refusals.length))
+            .map((r) => renumbered(r, first))
+    ]
+});
+export const isCounts = (body) => {
+    if (typeof body !== 'object' || body === null)
+        return false;
+    const b = body;
+    return (['sent', 'added', 'replaced', 'refused'].every((k) => typeof b[k] === 'number') &&
+        Array.isArray(b.refusals));
+};
+export const outcomeOf = (status, body) => status === 400 && isCounts(body) ? 'counts' : status >= 500 ? 'failed' : 'refused';
+export const linesOf = (piece) => piece.lines <= 1
+    ? `line ${piece.first}`
+    : `lines ${piece.first}–${piece.first + piece.lines - 1}`;
+//# sourceMappingURL=pieces.js.map

package/dist/dispatch-form.js

@@ -0,0 +1,181 @@
+import { audiencesOf } from "./nouns/index.js";
+import { emit } from "./render/output.js";
+import { confirmAction } from "./render/prompt.js";
+import { ambiguousText, formatContact } from "./render/rows.js";
+import { renderRunHint, sanitizeForTerminal } from "./render/text.js";
+import { signedIn } from "./request/access-token.js";
+import { refusalOf } from "./request/api-fetch.js";
+import { EXIT, isRefusal } from "./store/exit.js";
+import { buildBody, describeAudience, fillIn, readWords, refuse, resolveContact, urlOf } from "./dispatch-words.js";
+export const runForm = async (cfg, io, form, rest) => {
+    const typed = readWords(form, rest);
+    if (isRefusal(typed))
+        return typed;
+    const steps = form.steps ?? {};
+    const context = {
+        positionals: typed.positionals,
+        flags: typed.flags,
+        on: typed.on,
+        webUrl: cfg.webUrl
+    };
+    let selector;
+    if (steps.contact) {
+        for (const source of steps.contact.from) {
+            const value = source === 'p0' ? typed.positionals[0] : typed.flags[source.slice(5)];
+            if (value !== undefined) {
+                selector = value;
+                break;
+            }
+        }
+        if (steps.contact.required && (selector === undefined || selector.trim().length === 0)) {
+            return refuse(steps.contact.required);
+        }
+    }
+    if (steps.requireFlag && typed.flags[steps.requireFlag.key] === undefined) {
+        return refuse(steps.requireFlag.message);
+    }
+    if (steps.pipedNeedsYes && !io.stdin.isTTY && !typed.on.has('--yes')) {
+        return refuse(steps.pipedNeedsYes.message);
+    }
+    let stdin;
+    if (form.stdinBody) {
+        if (io.stdin.isTTY)
+            return refuse(form.stdinBody.atTty);
+        stdin = await io.stdin.read();
+        if (stdin.trim() === '')
+            return refuse(form.stdinBody.empty);
+    }
+    let body = buildBody(form, typed, stdin, context);
+    if (body && form.request.emptyBodyMessage && Object.keys(body).length === 0) {
+        return refuse(form.request.emptyBodyMessage);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    let missingName;
+    const wantsPublic = steps.contact?.publicWord !== undefined && selector === steps.contact.publicWord;
+    if (steps.contact && selector !== undefined && !wantsPublic) {
+        const contacts = await io.api(accessToken, `${cfg.apiUrl}/contacts`);
+        if (!contacts.ok)
+            return refusalOf(contacts);
+        const shown = sanitizeForTerminal(selector);
+        const resolution = resolveContact(contacts.data, selector.trim());
+        if (resolution.kind === 'ambiguous') {
+            const list = resolution.matches.map((c) => `  ${formatContact(c)}`).join('\n');
+            return refuse(`${shown} matches more than one of your contacts:\n${list}\nUse a contact id instead.\n`);
+        }
+        if (resolution.kind === 'missing-id' ||
+            (resolution.kind === 'missing-name' && !steps.contact.createIfMissing)) {
+            return refuse(`No contact ${shown} among yours. ${renderRunHint(['contact', 'list'])} shows them.\n`, EXIT.GENERIC);
+        }
+        if (resolution.kind === 'found') {
+            context.contact = resolution.contact;
+            if (steps.contact.mustBePerson && resolution.contact.type !== 'person') {
+                return refuse(fillIn(steps.contact.mustBePerson, {
+                    name: sanitizeForTerminal(resolution.contact.displayName)
+                }));
+            }
+            if (steps.contact.mustBeLinked &&
+                (resolution.contact.type !== 'person' || resolution.contact.claimedPersonId == null)) {
+                return refuse(steps.contact.mustBeLinked);
+            }
+        }
+        else {
+            missingName = resolution.displayName;
+        }
+    }
+    if (steps.memory === 'always' || (steps.memory === 'at-tty' && io.stdin.isTTY)) {
+        const fetched = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(typed.positionals[0])}`);
+        if (!fetched.ok)
+            return refusalOf(fetched, ambiguousText(fetched.body));
+        context.memory = fetched.data;
+    }
+    if (steps.noAudienceReport && typed.flags[steps.noAudienceReport.key] === undefined) {
+        const title = sanitizeForTerminal(context.memory?.title ?? '(untitled)');
+        return refuse(steps.noAudienceReport.first +
+            fillIn(steps.noAudienceReport.second, {
+                title,
+                'memory.id': context.memory?.id ?? '',
+                audiences: context.memory ? audiencesOf(context.memory) : ''
+            }));
+    }
+    if (steps.confirm && io.stdin.isTTY) {
+        const name = sanitizeForTerminal(context.contact?.displayName ?? missingName ?? '');
+        const question = fillIn(missingName !== undefined && steps.confirm.whenMissing
+            ? steps.confirm.whenMissing
+            : steps.confirm.question, {
+            ...Object.fromEntries(typed.positionals.map((p, i) => [`p${i}`, sanitizeForTerminal(p)])),
+            name,
+            title: sanitizeForTerminal(context.memory?.title ?? '(untitled)'),
+            'memory.id': context.memory?.id ?? '',
+            audience: context.contact?.displayName ?? describeAudience(selector ?? '')
+        });
+        const answer = await confirmAction(io, question);
+        if (answer === 'interrupted' && steps.confirm.onInterrupted) {
+            return refuse(steps.confirm.onInterrupted.text, steps.confirm.onInterrupted.exit);
+        }
+        if (answer !== 'yes') {
+            if (steps.confirm.onNo.to === 'stdout')
+                io.stdout.write(steps.confirm.onNo.text);
+            else
+                io.stderr.write(steps.confirm.onNo.text);
+            return;
+        }
+    }
+    if (missingName !== undefined) {
+        const created = await io.api(accessToken, `${cfg.apiUrl}/contacts`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ displayName: missingName, type: 'person' })
+        });
+        if (!created.ok)
+            return refusalOf(created);
+        context.contact = created.data;
+        context.createdContact = true;
+        body = buildBody(form, typed, stdin, context);
+    }
+    else if (context.contact !== undefined || wantsPublic) {
+        body = buildBody(form, typed, stdin, context);
+    }
+    const url = urlOf(cfg.apiUrl, form, typed, stdin, context);
+    const result = await io.api(accessToken, url, body === undefined
+        ? { method: form.request.method }
+        : {
+            method: form.request.method,
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        });
+    if (!result.ok) {
+        return refusalOf(result, form.ambiguousRefusal ? ambiguousText(result.body) : '');
+    }
+    const typedView = context;
+    if (form.pickFromList) {
+        const ref = typed.positionals[0].toLowerCase();
+        const rows = result.data;
+        const matches = rows.filter((c) => c.id.toLowerCase().startsWith(ref));
+        const shown = sanitizeForTerminal(typed.positionals[0]);
+        if (matches.length === 0) {
+            return refuse(fillIn(form.pickFromList.none, { typed: shown }), EXIT.GENERIC);
+        }
+        if (matches.length > 1) {
+            const list = matches.map((c) => `  ${formatContact(c)}`).join('\n');
+            return refuse(fillIn(form.pickFromList.ambiguous, { typed: shown, matches: list }));
+        }
+        emit(io, matches[0], JSON.stringify(matches[0]), (row) => form.render(row, typedView));
+        return;
+    }
+    if (form.renderTo === 'stderr') {
+        io.stderr.write(`${form.render(result.data, typedView)}\n`);
+        return;
+    }
+    if (form.renderAlways) {
+        io.stdout.write(`${form.render(result.data, typedView)}\n`);
+        return;
+    }
+    emit(io, result.data, result.rawText, (data) => form.render(data, typedView));
+    const next = form.page ? result.data[form.page.cursor] : undefined;
+    if (form.page && typeof next === 'string' && io.stdout.isTTY) {
+        io.stderr.write(`More: ${renderRunHint([...form.page.hint, '--cursor', next])}\n`);
+    }
+};
+//# sourceMappingURL=dispatch-form.js.map

package/dist/dispatch-words.js

@@ -0,0 +1,137 @@
+import { renderRunHint } from "./render/text.js";
+import { parseArgs } from "./request/flags.js";
+import { EXIT, refusal } from "./store/exit.js";
+import { isUuidKey } from "./store/write-identity.js";
+export const refuse = (message, exit = EXIT.USAGE) => refusal(message, exit);
+export const fillIn = (template, values) => template.replace(/\{([\w.]+)(?::([^}]*))?\}/g, (_m, key, arg) => key === 'hint' ? renderRunHint((arg ?? '').split(' ')) : (values[key] ?? ''));
+export const readWords = (form, rest) => {
+    const on = new Set();
+    const counts = new Map();
+    const words = rest.filter((a) => {
+        if (form.switches?.includes(a)) {
+            on.add(a);
+            counts.set(a, (counts.get(a) ?? 0) + 1);
+            return false;
+        }
+        return true;
+    });
+    const { flags, positionals, unknown, notAnId } = parseArgs(form.flags ?? {}, words, form.idPositionals);
+    if (unknown !== undefined) {
+        return refuse(form.unknownFlagIsUsage ? `${form.usage}\n` : `Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId !== undefined)
+        return refuse(notAnId);
+    const typed = { positionals, flags: flags, on };
+    const tooMany = form.positionalsAtMost ?? form.positionals;
+    if (positionals.length < form.positionals ||
+        positionals.length > tooMany ||
+        [...counts.values()].some((n) => n > 1) ||
+        (form.requiredFlags ?? []).some((k) => typed.flags[k] === undefined && !form.missingFlagsMessage) ||
+        (form.uuidPositionals ?? []).some((i) => !isUuidKey(positionals[i] ?? ''))) {
+        return refuse(`${form.usage}\n`);
+    }
+    if (form.missingFlagsMessage) {
+        const names = Object.entries(form.flags ?? {});
+        const missing = (form.requiredFlags ?? [])
+            .filter((k) => typed.flags[k] === undefined)
+            .map((k) => names.find(([, key]) => key === k)?.[0] ?? k);
+        if (missing.length > 0) {
+            return refuse(`Missing ${missing.join(', ')}.\n${form.usage}\n`);
+        }
+    }
+    for (const rule of form.uuidPositionalMessages ?? []) {
+        if (!isUuidKey(positionals[rule.index] ?? '')) {
+            return refuse(fillIn(rule.message, { value: positionals[rule.index] ?? '' }));
+        }
+    }
+    for (const rule of form.contradictions ?? []) {
+        const has = (name) => name === 'p0'
+            ? positionals.length === 1
+            : name.startsWith('--')
+                ? on.has(name)
+                : typed.flags[name] !== undefined;
+        if (has(rule.a) && has(rule.b)) {
+            return refuse(rule.message);
+        }
+    }
+    for (const rule of form.uuidFlags ?? []) {
+        const value = typed.flags[rule.key];
+        if (value !== undefined && !isUuidKey(value)) {
+            return refuse(fillIn(rule.message, { value }));
+        }
+    }
+    for (const rule of form.requireWhen ?? []) {
+        const value = typed.flags[rule.key];
+        if (value !== undefined &&
+            rule.values.includes(value) &&
+            typed.flags[rule.needs] === undefined) {
+            return refuse(fillIn(rule.message, { value }));
+        }
+    }
+    return typed;
+};
+export const valueOf = (source, typed, stdin, context) => {
+    if ('flag' in source)
+        return typed.flags[source.flag];
+    if ('positional' in source)
+        return typed.positionals[source.positional];
+    if ('stdin' in source)
+        return stdin;
+    if ('context' in source)
+        return context.contact?.id;
+    if (!('switch' in source))
+        return source.value;
+    return typed.on.has(source.switch) ? source.value : source.otherwise;
+};
+export const buildBody = (form, typed, stdin, context) => {
+    if (form.request.bodyWithPublic && context.contact === undefined) {
+        return form.request.bodyWithPublic;
+    }
+    if (!form.request.body)
+        return undefined;
+    const body = {};
+    for (const [key, sources] of Object.entries(form.request.body)) {
+        for (const source of Array.isArray(sources) ? sources : [sources]) {
+            const value = valueOf(source, typed, stdin, context);
+            if (value !== undefined)
+                body[key] = value;
+        }
+    }
+    return body;
+};
+export const pathOf = (form, typed, context) => {
+    const template = form.request.pathWithPublic && context.contact === undefined
+        ? form.request.pathWithPublic
+        : form.request.path;
+    return template
+        .replace(/\{(--[a-z-]+):([^}]*)\}/g, (_m, name, text) => typed.on.has(name) ? text : '')
+        .replace(/\{p(\d+)\}/g, (_m, i) => encodeURIComponent(typed.positionals[Number(i)] ?? ''))
+        .replace('{memory.id}', encodeURIComponent(context.memory?.id ?? typed.positionals[0] ?? ''))
+        .replace('{contact.claimedPersonId}', () => encodeURIComponent(String(context.contact?.claimedPersonId ?? '')));
+};
+export const urlOf = (apiUrl, form, typed, stdin, context) => {
+    const url = new URL(`${apiUrl}${pathOf(form, typed, context)}`);
+    for (const [key, sources] of Object.entries(form.request.query ?? {})) {
+        for (const source of Array.isArray(sources) ? sources : [sources]) {
+            const value = valueOf(source, typed, stdin, context);
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+    }
+    return url;
+};
+export const resolveContact = (contacts, selector) => {
+    if (isUuidKey(selector)) {
+        const contact = contacts.find((c) => c.id.toLowerCase() === selector.toLowerCase());
+        return contact ? { kind: 'found', contact } : { kind: 'missing-id' };
+    }
+    const folded = selector.toLowerCase();
+    const matches = contacts.filter((c) => c.displayName.toLowerCase() === folded);
+    if (matches.length === 1)
+        return { kind: 'found', contact: matches[0] };
+    if (matches.length > 1)
+        return { kind: 'ambiguous', matches };
+    return { kind: 'missing-name', displayName: selector };
+};
+export const describeAudience = (audience) => audience === 'public' ? 'public — anyone, including people without accounts' : audience;
+//# sourceMappingURL=dispatch-words.js.map

package/dist/dispatch.js

@@ -0,0 +1,67 @@
+import { VERB_ALIASES } from "./nouns/words.js";
+import { renderRefusal } from "./render/output.js";
+import { sanitizeForTerminal } from "./render/text.js";
+import { HELP_TOKENS } from "./request/flags.js";
+import { fillIn, refuse } from "./dispatch-words.js";
+import { runForm } from "./dispatch-form.js";
+const helpOf = (help, args) => typeof help === 'string' ? help : help(args);
+const runVerb = async (cfg, io, verb, rest) => {
+    const refused = 'form' in verb ? await runForm(cfg, io, verb.form, rest) : await verb.handler(cfg, io, rest);
+    if (refused)
+        renderRefusal(io, refused);
+};
+const wordsOf = (n) => [
+    n.words.singular,
+    ...(n.words.aliases ?? [])
+];
+export const dispatch = async (cfg, io, registry, argv) => {
+    const typedWord = argv[0];
+    if (typedWord === undefined)
+        return false;
+    const word = VERB_ALIASES[typedWord] ?? typedWord;
+    const rest = argv.slice(1);
+    const nounFirst = registry.nouns.find((n) => n.grammar === 'noun-first' && wordsOf(n).includes(word));
+    if (nounFirst) {
+        const first = rest[0];
+        if (first === undefined || rest.some((t) => HELP_TOKENS.has(t))) {
+            io.stdout.write(`${nounFirst.help}\n`);
+            return true;
+        }
+        const verb = nounFirst.verbs.find((v) => v.verb === first);
+        if (!verb) {
+            renderRefusal(io, refuse(fillIn(nounFirst.unknownVerb ?? nounFirst.help, { verb: sanitizeForTerminal(first) })));
+            return true;
+        }
+        await runVerb(cfg, io, verb, rest.slice(1));
+        return true;
+    }
+    const verbWord = registry.verbs[word];
+    const candidates = registry.nouns
+        .filter((n) => n.grammar !== 'noun-first')
+        .flatMap((n) => n.verbs.filter((v) => v.verb === word));
+    if (!verbWord || candidates.length === 0)
+        return false;
+    if (verbWord.help !== undefined &&
+        ((verbWord.bareIsHelp && rest.length === 0) || rest.some((t) => HELP_TOKENS.has(t)))) {
+        io.stdout.write(`${helpOf(verbWord.help, rest)}\n`);
+        return true;
+    }
+    if (!candidates.some((v) => v.nouns !== undefined)) {
+        await runVerb(cfg, io, candidates[0], rest);
+        return true;
+    }
+    const noun = rest[0];
+    const chosen = candidates.find((v) => noun !== undefined && v.nouns?.includes(noun));
+    if (!chosen) {
+        const shown = sanitizeForTerminal(noun ?? '');
+        if (verbWord.badNoun?.stdout)
+            io.stdout.write(verbWord.badNoun.stdout);
+        renderRefusal(io, refuse(fillIn(verbWord.badNoun?.stderr ?? `${helpOf(verbWord.help ?? '', rest)}\n`, {
+            noun: shown
+        })));
+        return true;
+    }
+    await runVerb(cfg, io, chosen, rest.slice(1));
+    return true;
+};
+//# sourceMappingURL=dispatch.js.map