lattris 0.1.4 → 0.2.1

package/dist/render/datasets.js

@@ -0,0 +1,77 @@
+import { sanitizeForTerminal } from "./text.js";
+const LABEL = 13;
+const valueText = (value, max = 200) => typeof value === 'string'
+    ? sanitizeForTerminal(value, max)
+    : sanitizeForTerminal(JSON.stringify(value) ?? 'null', max);
+const wordsText = (words) => words.length === 0 ? '(none)' : words.map((w) => sanitizeForTerminal(w)).join(', ');
+const widest = (cells) => Math.max(0, ...cells.map((c) => c.length));
+const table = (rows) => {
+    const widths = rows[0]?.map((_, i) => widest(rows.map((r) => r[i] ?? ''))) ?? [];
+    return rows
+        .map((r) => r
+        .map((cell, i) => (i === r.length - 1 ? cell : cell.padEnd(widths[i])))
+        .join('  ')
+        .trimEnd())
+        .join('\n');
+};
+export const formatCatalogue = (entries) => entries.length === 0
+    ? 'No datasets.'
+    : table(entries.map((e) => [
+        sanitizeForTerminal(e.name),
+        sanitizeForTerminal(e.storage),
+        e.holds ? 'holds rows' : 'no rows',
+        valueText(e.earliest ?? '-'),
+        valueText(e.latest ?? '-')
+    ]));
+const boundText = (value) => Array.isArray(value) ? value.map((v) => valueText(v)).join(', ') : valueText(value);
+const fieldCells = (f) => {
+    const { name, type, required, nullable, ...bounds } = f;
+    const rest = [
+        required ? 'required' : 'optional',
+        ...(nullable ? ['nullable'] : []),
+        ...Object.entries(bounds).map(([k, v]) => `${sanitizeForTerminal(k)} ${boundText(v)}`)
+    ];
+    return [`  ${sanitizeForTerminal(name)}`, sanitizeForTerminal(type), rest.join('  ')];
+};
+export const formatDescription = (d) => {
+    const lines = [
+        `${'dataset'.padEnd(LABEL)}${sanitizeForTerminal(d.name)}  (${sanitizeForTerminal(d.storage)})`,
+        `${'identity'.padEnd(LABEL)}${wordsText(d.identity)}`,
+        `${'filters'.padEnd(LABEL)}required ${wordsText(d.filters.required)}`,
+        `${''.padEnd(LABEL)}optional ${wordsText(d.filters.optional)}`
+    ];
+    if (d.page) {
+        const limits = d.limits ? `, ${d.limits.default} rows a page, at most ${d.limits.maximum}` : '';
+        lines.push(`${'page'.padEnd(LABEL)}by ${valueText(d.page.by)} on ${valueText(d.page.field)}${limits}`);
+    }
+    lines.push('', 'fields', table(d.fields.map(fieldCells)));
+    if (d.example) {
+        lines.push('', 'example line', `  ${valueText(JSON.stringify(d.example), Infinity)}`);
+    }
+    return lines.join('\n');
+};
+export const formatRow = (row) => {
+    const width = widest(Object.keys(row)) + 2;
+    return Object.entries(row)
+        .map(([k, v]) => `${sanitizeForTerminal(k).padEnd(width)}${valueText(v, Infinity)}`)
+        .join('\n');
+};
+const formatRowLine = (row) => [
+    valueText(row.id),
+    ...Object.entries(row)
+        .filter(([k, v]) => k !== 'id' && k !== 'ownerId' && v !== null)
+        .map(([k, v]) => `${sanitizeForTerminal(k)}=${valueText(v)}`)
+].join('  ');
+export const formatRowPage = (page) => page.items.length === 0 ? 'No rows.' : page.items.map(formatRowLine).join('\n');
+export const formatCaptured = (name, c) => {
+    const lines = [
+        `Sent ${c.sent} ${c.sent === 1 ? 'line' : 'lines'} to ${sanitizeForTerminal(name)}: ` +
+            `${c.added} added, ${c.replaced} replaced, ${c.refused} refused.`,
+        ...c.refusals.map((r) => `  ${valueText(r.message ?? '', Infinity)}`)
+    ];
+    if (c.refused > c.refusals.length) {
+        lines.push(`  ${c.refused - c.refusals.length} more refused, counted and not named.`);
+    }
+    return lines.join('\n');
+};
+//# sourceMappingURL=datasets.js.map

package/dist/render/door.js

@@ -0,0 +1,39 @@
+import { renderRunHint, sanitizeForTerminal } from "./text.js";
+const EDGE_REFUSAL_EXCERPT_BYTES = 200;
+export const truncateToUtf8Bytes = (s, max) => {
+    let bytes = 0;
+    let out = '';
+    for (const ch of s) {
+        const n = Buffer.byteLength(ch, 'utf8');
+        if (bytes + n > max)
+            break;
+        bytes += n;
+        out += ch;
+    }
+    return out;
+};
+export const doorText = (commands, message, next, messageLimit = 200) => {
+    let text = `${sanitizeForTerminal(message, messageLimit)}\n`;
+    if (next?.action) {
+        const argv = next.action.trim().split(/\s+/);
+        text += commands.has(argv[0])
+            ? `Run: ${renderRunHint(argv)}\n`
+            : `The door suggests: ${sanitizeForTerminal(next.action)}\n`;
+    }
+    return text;
+};
+export const edgeText = (excerpt) => {
+    const shown = truncateToUtf8Bytes(sanitizeForTerminal(excerpt.replace(/\r/g, ''), Infinity), EDGE_REFUSAL_EXCERPT_BYTES);
+    return ('Refused at the edge before reaching Lattris (403). The words or the request shape ' +
+        "tripped the gateway's screen; nothing was written." +
+        (shown.length > 0 ? `\n${shown}` : ''));
+};
+export const answerText = (commands, answer) => {
+    if (answer.kind === 'door') {
+        return doorText(commands, answer.message, answer.next, answer.whole ? Infinity : 200);
+    }
+    if (answer.kind === 'edge')
+        return `${edgeText(answer.excerpt)}\n`;
+    return `The server answered with a web page, not the API — check the environment’s \`${answer.address}\` URL.\n`;
+};
+//# sourceMappingURL=door.js.map

package/dist/render/output.js

@@ -0,0 +1,19 @@
+import { answerText } from "./door.js";
+export const emit = (term, data, rawText, renderHuman) => {
+    if (term.stdout.isTTY) {
+        const human = renderHuman(data);
+        if (human.length > 0)
+            term.stdout.write(`${human}\n`);
+    }
+    else {
+        term.stdout.write(rawText.endsWith('\n') ? rawText : `${rawText}\n`);
+    }
+};
+export const renderRefusal = (term, refused) => {
+    if (refused.answer)
+        term.stderr.write(answerText(term.commands, refused.answer));
+    if (refused.message.length > 0)
+        term.stderr.write(refused.message);
+    term.exit(refused.exit);
+};
+//# sourceMappingURL=output.js.map

package/dist/render/prompt.js

@@ -0,0 +1,4 @@
+export const readYesNo = (answer) => answer === null ? 'interrupted' : /^y(es)?$/i.test(answer.trim()) ? 'yes' : 'no';
+export const confirmAction = async (term, prompt) => readYesNo(await term.stdin.ask(prompt));
+export const promptLine = async (term, question) => (await term.stdin.ask(question))?.trim() ?? null;
+//# sourceMappingURL=prompt.js.map

package/dist/render/rows.js

@@ -0,0 +1,82 @@
+import { renderRunHint, sanitizeForTerminal } from "./text.js";
+import { isUuidKey } from "../store/write-identity.js";
+export const formatContact = (c) => `${sanitizeForTerminal(c.displayName)} · ${c.type} · ${c.id}` +
+    `${c.claimedPersonId ? ' · linked' : ''}` +
+    `${c.email ? ` · email ${sanitizeForTerminal(c.email)}` : ''}` +
+    `${c.phone ? ` · phone ${sanitizeForTerminal(c.phone)}` : ''}` +
+    `${c.rootBlockId ? ` · root ${c.rootBlockId}` : ''}`;
+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 isGroupWord = (word) => word.trim().toLowerCase().startsWith('group:');
+export const groupsNotBuilt = (word) => `${sanitizeForTerminal(word)} names a group, and groups are not built yet. A contact called that is reached by its id.\n`;
+export const audienceOf = (r) => r.kind === 'public'
+    ? 'public'
+    : r.kind === 'all_contacts'
+        ? 'all contacts'
+        : r.kind === 'person'
+            ? `${sanitizeForTerminal(r.contactName ?? r.personId ?? '')} (website)`
+            : sanitizeForTerminal(r.contactName ?? r.contactId ?? '');
+export const formatAccessRow = (r) => `${r.effect} ${audienceOf(r)}`;
+export const waitsForNameSentence = (name) => `${sanitizeForTerminal(name)} is linked to an account, but the website share waits until you set your name (${renderRunHint(['set', 'name'])}).`;
+export const waitsForNameLines = (rows) => (rows ?? [])
+    .filter((r) => r.unpairedBecause === 'owner-has-no-name' && r.contactName)
+    .map((r) => waitsForNameSentence(r.contactName ?? ''));
+export const formatAccess = (rows) => rows.length === 0 ? '(nothing set)' : rows.map(formatAccessRow).join('; ');
+export const describeForContact = (c, asked) => c === null
+    ? `no contact holds ${sanitizeForTerminal(asked ?? 'that number')}; a stranger sees public memories only`
+    : `${sanitizeForTerminal(c.displayName)} (${c.type}${c.phone ? `, ${sanitizeForTerminal(c.phone)}` : ''})`;
+export const formatQuestion = (q) => {
+    const lines = [`id           ${q.id}`, `createdAt    ${q.createdAt}`];
+    if (q.kind === 'share') {
+        lines.push(`shared by    @${sanitizeForTerminal(q.sharerHandle ?? '(unknown)')}`, `memory       ${q.aboutBlockId ?? '(missing)'}`, `seen         ${q.seenAt ?? '(unseen)'}`);
+        return lines.join('\n');
+    }
+    if (q.aboutBlockId)
+        lines.push(`about        ${q.aboutBlockId}`);
+    lines.push(q.closedAs === null
+        ? 'closed as    (open)'
+        : `closed as    ${sanitizeForTerminal(q.closedAs)}${q.closeBlockId ? ` → ${q.closeBlockId}` : ''}${q.closedAt ? `  ${q.closedAt}` : ''}`);
+    if (q.closeNote)
+        lines.push(`note         ${sanitizeForTerminal(q.closeNote, Infinity)}`);
+    lines.push('', sanitizeForTerminal(q.body ?? '', Infinity));
+    return lines.join('\n');
+};
+export const formatQuestionList = (qs) => qs.map((q) => formatQuestion(q)).join('\n\n');
+export const formatAsked = (q) => {
+    const lines = [`Sent question ${q.id}`];
+    if (q.aboutBlockId)
+        lines.push(`  about        ${q.aboutBlockId}`);
+    lines.push(`  createdAt    ${q.createdAt}`);
+    return lines.join('\n');
+};
+export const formatClosed = (q) => `Closed question ${q.id}  (${sanitizeForTerminal(q.closedAs ?? '')})${q.closeBlockId ? ` → ${q.closeBlockId}` : ''}`;
+export const formatEdgeReceipt = (heading, e) => [
+    `${heading}  (verb: ${sanitizeForTerminal(e.verb)})`,
+    `  from    ${e.fromBlockId}  (${e.fromType})`,
+    `  to      ${e.toBlockId}  (${e.toType})`,
+    `  reason  ${sanitizeForTerminal(e.reason, Infinity)}`
+].join('\n');
+export const formatAmendedEdge = (e) => formatEdgeReceipt('Updated edge reason.', e);
+export const formatAudiences = (audiences) => audiences.length === 0 ? '(private)' : audiences.map((a) => a.kind).join(', ');
+export const ambiguousText = (body) => {
+    if (body.code !== 'memory:ambiguous-id')
+        return '';
+    const matches = body.detail?.matches;
+    if (!Array.isArray(matches))
+        return '';
+    return matches
+        .map((m) => `  ${m.id}  ${sanitizeForTerminal(m.title ?? '(untitled)')}\n`)
+        .join('');
+};
+//# sourceMappingURL=rows.js.map

package/dist/render/text.js

@@ -0,0 +1,21 @@
+import { createHash, randomBytes } from 'node:crypto';
+export const base64url = (b) => b.toString('base64url');
+export const makePkce = () => {
+    const verifier = base64url(randomBytes(32));
+    const challenge = base64url(createHash('sha256').update(verifier).digest());
+    return { verifier, challenge };
+};
+/* eslint-disable no-control-regex */
+const ESCAPE_SEQUENCES = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[PX^_][^\x1b]*\x1b\\|\x1b\[[0-9:;<=>?]*[ -/]*[@-~]|\x1b[@-Z\\^_]/g;
+const CONTROL_CHARS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f\u0080-\u009f]/g;
+/* eslint-enable no-control-regex */
+const BIDI_FORMAT_CHARS = /[\u202a-\u202e\u2066-\u2069]/g;
+export const sanitizeForTerminal = (s, maxLen = 200) => s
+    .replace(ESCAPE_SEQUENCES, '')
+    .replace(CONTROL_CHARS, '')
+    .replace(BIDI_FORMAT_CHARS, '')
+    .slice(0, maxLen);
+export const shellQuote = (token) => `'${sanitizeForTerminal(token, Infinity).replace(/'/g, `'\\''`)}'`;
+const SAFE_HINT_TOKEN = /^[A-Za-z0-9@._:/-]+$/;
+export const renderRunHint = (argv) => ['lattris', ...argv.map((t) => (SAFE_HINT_TOKEN.test(t) ? t : shellQuote(t)))].join(' ');
+//# sourceMappingURL=text.js.map

package/dist/request/access-token.js

@@ -0,0 +1,67 @@
+import { EXIT, refusal } from "../store/exit.js";
+import { RENEWAL_TIMEOUT_MS, SessionLockHeld, WAIT_AT_MOST_MS, withSessionLock } from "../store/session-lock.js";
+import { loadSession, notLoggedInWords, saveSession } from "../store/session.js";
+import { postToken, refreshBody, toSession } from "./token.js";
+const SKEW_SECONDS = 30;
+const stillValid = (session, now) => session.expiresAt > Math.floor(now / 1000) + SKEW_SECONDS;
+const renewFrom = async (io, cfg, session) => {
+    if (!session)
+        throw new Error('not-logged-in');
+    if (stillValid(session, io.store.now()))
+        return session.accessToken;
+    if (!session.refreshToken)
+        throw new Error('not-logged-in');
+    const token = await postToken(io.network, cfg, refreshBody(cfg, session.refreshToken), io.store.timeout(RENEWAL_TIMEOUT_MS));
+    const refreshed = toSession(token, io.store.now());
+    refreshed.refreshToken = refreshed.refreshToken ?? session.refreshToken;
+    refreshed.personId = session.personId;
+    refreshed.handle = session.handle;
+    saveSession(io.store, refreshed);
+    return refreshed.accessToken;
+};
+export const validAccessToken = async (io, cfg) => {
+    const session = loadSession(io.store);
+    if (!session)
+        throw new Error('not-logged-in');
+    if (stillValid(session, io.store.now()))
+        return session.accessToken;
+    if (!session.refreshToken)
+        throw new Error('not-logged-in');
+    try {
+        return await withSessionLock(io.store, () => renewFrom(io, cfg, loadSession(io.store)), () => io.stderr.write('Waiting for another lattris command to finish renewing the sign-in…\n'));
+    }
+    catch (e) {
+        if (e instanceof SessionLockHeld)
+            throw e;
+        throw new Error('not-logged-in');
+    }
+};
+export const optionalAccessToken = async (io, cfg) => {
+    try {
+        return await io.token(cfg);
+    }
+    catch {
+        return undefined;
+    }
+};
+const notLoggedIn = (io) => ({
+    message: '',
+    exit: EXIT.NOAUTH,
+    answer: {
+        kind: 'door',
+        message: notLoggedInWords(io.store),
+        next: { action: 'login' },
+        whole: true
+    }
+});
+const gaveUpWaiting = (lock) => refusal(`Gave up after ${WAIT_AT_MOST_MS / 1000} seconds waiting for another lattris command to renew the sign-in. ` +
+    `If none is running, remove ${lock} and run this again.\n`, EXIT.GENERIC);
+export const signedIn = async (io, cfg) => {
+    try {
+        return await io.token(cfg);
+    }
+    catch (e) {
+        return e instanceof SessionLockHeld ? gaveUpWaiting(e.path) : notLoggedIn(io);
+    }
+};
+//# sourceMappingURL=access-token.js.map

package/dist/request/api-fetch.js

@@ -0,0 +1,76 @@
+import { EXIT } from "../store/exit.js";
+import { classifyApiError, edgeExcerpt, parseErrorBody } from "./door.js";
+const HTTP_NO_CONTENT = 204;
+export const apiFetch = async (network, accessToken, url, init = {}, addressKind = 'api') => {
+    const { retryAnonymousOn401 = false, ...requestInit } = init;
+    const request = (token) => {
+        const headers = { ...requestInit.headers };
+        if (token !== undefined)
+            headers.Authorization = `Bearer ${token}`;
+        else if (retryAnonymousOn401)
+            delete headers.Authorization;
+        return network(url, { ...requestInit, headers });
+    };
+    let res = await request(accessToken);
+    const isRead = requestInit.method === undefined || requestInit.method.toUpperCase() === 'GET';
+    if (retryAnonymousOn401 && isRead && accessToken !== undefined && res.status === 401) {
+        await res.body?.cancel().catch(() => { });
+        res = await request(undefined);
+    }
+    if (!res.ok) {
+        const bytes = new Uint8Array(await res.arrayBuffer().catch(() => new ArrayBuffer(0)));
+        const rawText = new TextDecoder().decode(bytes);
+        const excerpt = edgeExcerpt(res.status, { contentType: res.headers.get('content-type'), via: res.headers.get('via') }, bytes);
+        if (excerpt !== null) {
+            return {
+                ok: false,
+                body: {},
+                exit: EXIT.GENERIC,
+                answer: { kind: 'edge', excerpt },
+                status: res.status,
+                rawText
+            };
+        }
+        const body = parseErrorBody(rawText);
+        const { message, next, exit } = classifyApiError(res.status, body);
+        return {
+            ok: false,
+            body,
+            exit,
+            answer: { kind: 'door', message, next },
+            status: res.status,
+            rawText
+        };
+    }
+    if (res.status === HTTP_NO_CONTENT) {
+        return { ok: true, data: undefined, rawText: '', status: res.status };
+    }
+    let rawText;
+    try {
+        rawText = await res.text();
+    }
+    catch (e) {
+        throw new TypeError('fetch failed', { cause: e });
+    }
+    let data;
+    try {
+        data = JSON.parse(rawText);
+    }
+    catch {
+        return {
+            ok: false,
+            body: {},
+            exit: EXIT.GENERIC,
+            answer: { kind: 'page', address: addressKind },
+            status: res.status,
+            rawText
+        };
+    }
+    return { ok: true, data, rawText, status: res.status };
+};
+export const refusalOf = (failed, message = '') => ({
+    message,
+    exit: failed.exit,
+    answer: failed.answer
+});
+//# sourceMappingURL=api-fetch.js.map

package/dist/request/callback.js

@@ -0,0 +1,86 @@
+import { createServer } from 'node:http';
+export const htmlEscape = (s) => s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+export class AuthorizationError extends Error {
+    error;
+    constructor(error) {
+        super(`authorization error: ${error}`);
+        this.error = error;
+    }
+}
+export const decideCallback = (params, expectedState) => {
+    const state = params.get('state');
+    if (!state || state !== expectedState)
+        return { kind: 'state-mismatch' };
+    const error = params.get('error');
+    if (error)
+        return { kind: 'error', error };
+    const code = params.get('code');
+    if (!code)
+        return { kind: 'missing-code' };
+    return { kind: 'success', code };
+};
+const callbackHtml = (ok, message) => `<!doctype html><meta charset="utf-8"><title>lattris</title>` +
+    `<body style="font:16px system-ui;padding:3rem;text-align:center">` +
+    `<h1>${ok ? '✓ Signed in' : '✗ Sign-in failed'}</h1>` +
+    `<p>${htmlEscape(message)}</p>` +
+    `<p style="color:#888">You can close this tab and return to the terminal.</p>`;
+export const waitForCode = (port, expectedState, timeoutMs = 300_000, handle) => new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? '/', `http://127.0.0.1:${port}`);
+        if (url.pathname !== '/callback') {
+            res.writeHead(404).end('Not found');
+            return;
+        }
+        const decision = decideCallback(url.searchParams, expectedState);
+        const corsHeaders = (verdict) => ({
+            'Content-Type': 'text/html',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Expose-Headers': 'X-Lattris-Login',
+            'X-Lattris-Login': verdict
+        });
+        if (decision.kind === 'state-mismatch') {
+            res.writeHead(400, corsHeaders('refused'));
+            res.end(callbackHtml(false, 'Invalid or missing state; ignoring this callback.'));
+            return;
+        }
+        const settle = (status, ok, message) => {
+            res.writeHead(status, corsHeaders(ok ? 'ok' : 'refused'));
+            res.end(callbackHtml(ok, message));
+            shutdown();
+        };
+        if (decision.kind === 'success') {
+            settle(200, true, 'Your terminal now holds your Lattris session.');
+            resolve(decision.code);
+            return;
+        }
+        if (decision.kind === 'error') {
+            settle(400, false, `Authorization server returned: ${htmlEscape(decision.error)}`);
+            reject(new AuthorizationError(decision.error));
+            return;
+        }
+        settle(400, false, 'Missing authorization code.');
+        reject(new Error('missing authorization code'));
+    });
+    const shutdown = () => {
+        server.close();
+        server.closeAllConnections();
+        server.unref();
+    };
+    server.on('error', reject);
+    server.listen(port, '127.0.0.1');
+    if (handle)
+        handle.close = shutdown;
+    setTimeout(() => {
+        shutdown();
+        reject(new Error('timed out waiting for the sign-in redirect'));
+    }, timeoutMs).unref();
+});
+export const openBrowser = (machine, url) => {
+    const [cmd, args] = machine.platform === 'darwin'
+        ? ['open', [url]]
+        : machine.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '', url]]
+            : ['xdg-open', [url]];
+    machine.detach(cmd, args);
+};
+//# sourceMappingURL=callback.js.map

package/dist/request/door.js

@@ -0,0 +1,74 @@
+import { EXIT } from "../store/exit.js";
+export const parseErrorBody = (text) => {
+    try {
+        const b = JSON.parse(text);
+        return b && typeof b === 'object' ? b : {};
+    }
+    catch {
+        return {};
+    }
+};
+export const classifyApiError = (status, body) => {
+    if (body.next?.action) {
+        return { message: body.message ?? 'Action required.', next: body.next, exit: EXIT.DOOR };
+    }
+    if (status === 401) {
+        return {
+            message: body.message ?? 'Session invalid or expired.',
+            next: { action: 'login' },
+            exit: EXIT.NOAUTH
+        };
+    }
+    if (status === 403) {
+        return {
+            message: body.message ?? 'Your session lacks a required scope.',
+            next: { action: 'login' },
+            exit: EXIT.NOAUTH
+        };
+    }
+    return {
+        message: body.message ?? `Unexpected response from lattris-api: ${status}`,
+        exit: EXIT.GENERIC
+    };
+};
+const EDGE_REFUSAL_EXCERPT_BYTES = 200;
+export const trimCutUtf8 = (bytes) => {
+    let i = bytes.length - 1;
+    let back = 0;
+    while (i >= 0 && back < 3 && (bytes[i] & 0xc0) === 0x80) {
+        i--;
+        back++;
+    }
+    if (i < 0)
+        return bytes;
+    const lead = bytes[i];
+    const need = lead >= 0xf0 ? 4 : lead >= 0xe0 ? 3 : lead >= 0xc0 ? 2 : 1;
+    const have = bytes.length - i;
+    return have < need ? bytes.subarray(0, i) : bytes;
+};
+const looksLikeHouseError = (text) => {
+    try {
+        const b = JSON.parse(text);
+        return (b !== null &&
+            typeof b === 'object' &&
+            (typeof b.code === 'string' || typeof b.message === 'string'));
+    }
+    catch {
+        return false;
+    }
+};
+export const edgeExcerpt = (status, headers, bytes) => {
+    if (status !== 403)
+        return null;
+    const text = new TextDecoder().decode(bytes);
+    if (looksLikeHouseError(text))
+        return null;
+    const contentType = (headers.contentType ?? '').toLowerCase();
+    const via = (headers.via ?? '').toLowerCase();
+    const isHtml = contentType.includes('text/html') || /^\s*<(!doctype|html)/i.test(text);
+    if (!isHtml && !via.includes('1.1 google'))
+        return null;
+    const prefix = trimCutUtf8(bytes.subarray(0, EDGE_REFUSAL_EXCERPT_BYTES));
+    return new TextDecoder().decode(prefix);
+};
+//# sourceMappingURL=door.js.map

package/dist/request/flags.js

@@ -0,0 +1,38 @@
+export const HELP_TOKENS = new Set(['--help', '-h', 'help']);
+export const parseArgs = (flagNames, args, ids = []) => {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const eq = arg.indexOf('=');
+        const name = eq === -1 ? arg : arg.slice(0, eq);
+        const key = flagNames[name];
+        if (!key)
+            return { flags, positionals, unknown: name };
+        if (eq !== -1) {
+            flags[key] = arg.slice(eq + 1);
+            continue;
+        }
+        const value = args[i + 1];
+        if (value === undefined || value.startsWith('--')) {
+            return { flags, positionals, unknown: name };
+        }
+        flags[key] = value;
+        i++;
+    }
+    const notAnId = ids
+        .map((k) => positionals[k])
+        .find((v) => v === '.' || v === '..' || v?.includes('/'));
+    return notAnId === undefined
+        ? { flags, positionals }
+        : {
+            flags,
+            positionals,
+            notAnId: `Not an id: ${notAnId} — an id is never . or .. and never holds a /.\n`
+        };
+};
+//# sourceMappingURL=flags.js.map

package/dist/request/io.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=io.js.map