@onesi/genesis-cli 0.0.1-stage → 0.2.0

package/dist/lifeid-native.d.ts

@@ -0,0 +1,24 @@
+export declare const LIFEID_ISSUER = "https://auth.life.one";
+export declare const GENESIS_CLI_PRODUCT = "genesis-cli";
+export declare const CALLBACK_PATH = "/lifeid/callback";
+/** Exact Auth-owned admission metadata; supplying it does not register a client. */
+export interface NativeRegistration {
+    productId: string;
+    redirectUri: string;
+    audience: string;
+}
+export interface NativeAttempt {
+    readonly browserUrl: string;
+    readonly codeVerifier: string;
+    readonly registration: NativeRegistration;
+    readonly code: Promise<string>;
+    readonly signal: AbortSignal;
+    close(): void;
+}
+export declare function validateRegistration(r: NativeRegistration): number;
+/** Bind the sole registered port before the caller opens or prints the browser URL. */
+export declare function startNativeAttempt(registration: NativeRegistration, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    organizationHint?: string;
+}): Promise<NativeAttempt>;

package/dist/lifeid-native.js

@@ -0,0 +1,113 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+export const LIFEID_ISSUER = 'https://auth.life.one';
+export const GENESIS_CLI_PRODUCT = 'genesis-cli';
+export const CALLBACK_PATH = '/lifeid/callback';
+export function validateRegistration(r) {
+    const m = /^http:\/\/127\.0\.0\.1:([1-9][0-9]{3,4})\/lifeid\/callback$/.exec(r.redirectUri);
+    const port = m ? Number(m[1]) : 0;
+    if (r.productId !== GENESIS_CLI_PRODUCT || !m || port < 1024 || port > 65535
+        || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(r.audience)) {
+        throw new Error('One account native login requires the exact admitted Genesis product, loopback callback and audience.');
+    }
+    return port;
+}
+/** Bind the sole registered port before the caller opens or prints the browser URL. */
+export async function startNativeAttempt(registration, options = {}) {
+    registration = { ...registration };
+    const port = validateRegistration(registration);
+    const timeout = options.timeoutMs ?? 300_000;
+    if (!Number.isInteger(timeout) || timeout < 1 || timeout > 300_000)
+        throw new Error('Invalid login deadline.');
+    if (options.signal?.aborted)
+        throw new Error('One account login cancelled.');
+    if (options.organizationHint && !/^o_[0-9A-HJKMNP-TV-Z]{26}$/.test(options.organizationHint)) {
+        throw new Error('Invalid One account organization hint.');
+    }
+    const verifier = randomBytes(48).toString('base64url');
+    const controller = new AbortController();
+    let settled = false;
+    let resolveCode;
+    let rejectCode;
+    const code = new Promise((resolve, reject) => { resolveCode = resolve; rejectCode = reject; });
+    // Binding/open-browser errors may happen before the caller awaits the code.
+    void code.catch(() => { });
+    const server = createServer({ maxHeaderSize: 4096 }, (req, res) => {
+        const reject = (status) => {
+            res.writeHead(status, { 'content-type': 'text/plain', 'cache-control': 'no-store', connection: 'close' });
+            res.end('Invalid One account callback.');
+        };
+        // A malformed request cannot consume a pending code. No body is read/logged.
+        if (settled || req.method !== 'GET' || req.headers.host !== `127.0.0.1:${port}`
+            || req.headers.origin !== undefined || req.headers['transfer-encoding'] !== undefined
+            || (req.headers['content-length'] !== undefined && req.headers['content-length'] !== '0')) {
+            reject(400);
+            return;
+        }
+        const m = /^\/lifeid\/callback\?life_code=([A-Za-z0-9_-]{43})$/.exec(req.url ?? '');
+        if (!m) {
+            reject(400);
+            return;
+        }
+        settled = true;
+        res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store',
+            'referrer-policy': 'no-referrer', 'content-security-policy': "default-src 'none'", connection: 'close' });
+        res.end('One account callback received. Return to Genesis CLI.');
+        server.close();
+        resolveCode(m[1]);
+    });
+    server.requestTimeout = 5000;
+    server.headersTimeout = 5000;
+    server.keepAliveTimeout = 1;
+    server.maxConnections = 4;
+    const close = () => {
+        clearTimeout(timer);
+        options.signal?.removeEventListener('abort', onAbort);
+        server.close();
+        server.closeAllConnections();
+        if (!settled) {
+            settled = true;
+            rejectCode(new Error('One account login cancelled.'));
+        }
+        controller.abort();
+    };
+    const onAbort = () => close();
+    const timer = setTimeout(() => {
+        if (!settled) {
+            settled = true;
+            rejectCode(new Error('One account login timed out. Run `genesis login` again.'));
+        }
+        close();
+    }, timeout);
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+        await new Promise((resolve, reject) => {
+            const aborted = () => { cleanup(); reject(new Error('One account login cancelled.')); };
+            const cleanup = () => { server.removeListener('error', error); controller.signal.removeEventListener('abort', aborted); };
+            const error = () => { cleanup(); reject(new Error('The registered One account callback port is unavailable. No other port was tried.')); };
+            server.once('error', error);
+            controller.signal.addEventListener('abort', aborted, { once: true });
+            if (controller.signal.aborted) {
+                aborted();
+                return;
+            }
+            server.listen({ port, host: '127.0.0.1', signal: controller.signal }, () => { cleanup(); resolve(); });
+        });
+        if (controller.signal.aborted || options.signal?.aborted)
+            throw new Error('One account login cancelled.');
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+    server.on('error', () => close());
+    const url = new URL('/v4/lifeid/start', LIFEID_ISSUER);
+    url.searchParams.set('product_id', registration.productId);
+    url.searchParams.set('return_path', '/');
+    url.searchParams.set('code_challenge', createHash('sha256').update(verifier).digest('base64url'));
+    url.searchParams.set('code_challenge_method', 'S256');
+    if (options.organizationHint)
+        url.searchParams.set('org_hint', options.organizationHint);
+    return { browserUrl: url.toString(), codeVerifier: verifier, registration: { ...registration }, code,
+        signal: controller.signal, close };
+}

package/dist/minds-owner.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import type { Genesis } from '@onesi/genesis';
+export declare function registerMindsOwner(minds: Command, client: () => Promise<Genesis>, emit: (value: unknown) => void, signal?: AbortSignal): void;

package/dist/minds-owner.js

@@ -0,0 +1,42 @@
+import { readFile, stat } from 'node:fs/promises';
+export function registerMindsOwner(minds, client, emit, signal) {
+    const intent = (command, revision = true) => {
+        command.requiredOption('--operation-id <uuid>', 'retain this non-nil UUID when reconciling the same intent');
+        if (revision)
+            command.requiredOption('--expected-version <integer>', 'current membership or attachment version; zero for first creation');
+        return command;
+    };
+    const version = (value) => {
+        if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)))
+            throw new Error('Expected version must be a nonnegative safe integer.');
+        return Number(value);
+    };
+    const body = (options) => ({ operationId: options.operationId, expectedVersion: version(options.expectedVersion) });
+    const groups = minds.command('groups').description('Canonical owner-managed groups; uses the original selected Console human session');
+    groups.command('list').action(async () => emit(await (await client()).minds.groups.list({ signal })));
+    intent(groups.command('create <name>'), false).action(async (name, options) => emit(await (await client()).minds.groups.create({ operationId: options.operationId, name }, { signal })));
+    const members = groups.command('members').description('Canonical group memberships and retained removal versions');
+    members.command('list <group_id>').action(async (group) => emit(await (await client()).minds.groups.members.list(group, { signal })));
+    intent(members.command('add <group_id> <agent_id>')).action(async (group, agent, options) => emit(await (await client()).minds.groups.members.add(group, { ...body(options), agentId: agent }, { signal })));
+    intent(members.command('remove <group_id> <agent_id>')).action(async (group, agent, options) => emit(await (await client()).minds.groups.members.remove(group, agent, body(options), { signal })));
+    const attachments = minds.command('attachments').description('Attach existing canonical agents or groups; never issues credentials');
+    attachments.command('list <mind_id>').action(async (mind) => emit(await (await client()).minds.attachments.list(mind, { signal })));
+    attachments.command('attach <mind_id>').requiredOption('--request-file <path>', 'closed JSON attachment intent with operationId, expectedVersion, subject, permissions and expiresAt')
+        .action(async (mind, options) => {
+        const metadata = await stat(options.requestFile);
+        if (!metadata.isFile() || metadata.size > 8192)
+            throw new Error('Attachment request must be at most 8 KiB.');
+        const bytes = await readFile(options.requestFile);
+        if (bytes.length > 8192)
+            throw new Error('Attachment request must be at most 8 KiB.');
+        let request;
+        try {
+            request = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        }
+        catch {
+            throw new Error('Attachment request must contain valid JSON.');
+        }
+        emit(await (await client()).minds.attachments.attach(mind, request, { signal }));
+    });
+    intent(attachments.command('detach <mind_id> <attachment_id>')).action(async (mind, attachment, options) => emit(await (await client()).minds.attachments.detach(mind, attachment, body(options), { signal })));
+}

package/dist/minds.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from 'commander';
+import { type Genesis } from '@onesi/genesis';
+export declare function registerMinds(program: Command, client: () => Promise<Genesis>, emit: (data: unknown) => void, agentClient?: () => Promise<Genesis>, signal?: AbortSignal, ownerClient?: () => Promise<Genesis>): void;

package/dist/minds.js

@@ -0,0 +1,125 @@
+import { readFile, stat } from 'node:fs/promises';
+import { registerMindsOwner } from './minds-owner.js';
+import { Option } from 'commander';
+import { mindsServices } from '@onesi/genesis';
+export function registerMinds(program, client, emit, agentClient = client, signal, ownerClient = client) {
+    // `minds engine ...` (generated, products.ts) may already have created the root.
+    const minds = (program.commands.find(c => c.name() === 'minds') ?? program.command('minds')).description('Owned Minds and persisted memory; a human Console Sandbox session, or an org API key with minds:read/minds:write/minds:manage');
+    registerMindsOwner(minds, ownerClient, emit, signal);
+    minds.command('list').option('--after <uuid>').option('--limit <number>').description('List real Minds and the current creation context fingerprint').action(async (options) => {
+        emit(await (await client()).minds.list({ ...(options.after ? { after: options.after } : {}), ...(options.limit ? { limit: Number(options.limit) } : {}) }));
+    });
+    minds.command('get <mind_id>').action(async (id) => emit(await (await client()).minds.get(id)));
+    minds.command('usage').description('Read selected-project native usage for an explicit window of at most 93 days')
+        .requiredOption('--from <timestamp>', 'RFC3339 window start')
+        .requiredOption('--to <timestamp>', 'RFC3339 window end')
+        .action(async (options) => emit(await (await client()).minds.usage({ from: options.from, to: options.to })));
+    minds.command('create <name>').description('Create a Sandbox Mind; Free/F1 by default or an admitted Pro profile; 202 means provisioning')
+        .requiredOption('--idempotency-key <uuid>', 'persist this UUID4 and retain it after an uncertain response')
+        .requiredOption('--context-sha256 <hash>', 'context_sha256 from the current minds list response')
+        .addOption(new Option('--plan <plan>', 'explicit plan; entitlement remains server-authorized').choices(['free', 'pro']))
+        .addOption(new Option('--profile-id <profile>', 'fixed native profile; Pro defaults to D1, Free accepts only F1').choices(['F1', 'D1', 'D2']))
+        .option('--services <list>', `comma-separated engine service groups (${mindsServices.join(', ')}); kv and memory always run`)
+        .action(async (name, options) => {
+        const services = options.services === undefined ? undefined : String(options.services).split(',').map((item) => item.trim()).filter(Boolean);
+        if (services && services.some(item => !mindsServices.includes(item)))
+            throw new Error(`Unknown Minds service; choose from ${mindsServices.join(', ')}.`);
+        emit(await (await client()).minds.create(name, { idempotencyKey: options.idempotencyKey, contextSha256: options.contextSha256, ...(options.plan === undefined ? {} : { plan: options.plan }), ...(options.profileId === undefined ? {} : { profileId: options.profileId }), ...(services === undefined ? {} : { services }) }));
+    });
+    minds.command('resume <mind_id>').description('Resume the same Mind and retained volume; 202 means the operation is accepted')
+        .requiredOption('--expected-generation <number>', 'desired_generation from a fresh owned Mind read')
+        .requiredOption('--idempotency-key <uuid>', 'persist this UUID4 with the original generation after an uncertain response')
+        .addOption(new Option('--wake-reason <reason>', 'reason for this resume intent').choices(['manual', 'scheduled_job', 'webhook', 'memory_consolidation', 'activity']))
+        .action(async (id, options) => emit(await (await client()).minds.resume(id, Number(options.expectedGeneration), { idempotencyKey: options.idempotencyKey, ...(options.wakeReason === undefined ? {} : { wakeReason: options.wakeReason }) })));
+    minds.command('stop <mind_id>').description('Stop the same Mind without deleting its retained volume; 202 means accepted')
+        .requiredOption('--expected-generation <number>', 'desired_generation from a fresh owned Mind read')
+        .requiredOption('--idempotency-key <uuid>', 'persist this UUID4 and original generation; no automatic retry')
+        .action(async (id, options) => emit(await (await client()).minds.stop(id, Number(options.expectedGeneration), { idempotencyKey: options.idempotencyKey })));
+    minds.command('delete <mind_id>').description('Delete the Mind (lifecycle delete; org API keys need minds:write); 202 means accepted')
+        .requiredOption('--expected-generation <number>', 'desired_generation from a fresh owned Mind read')
+        .requiredOption('--idempotency-key <uuid>', 'persist this UUID4 and original generation; no automatic retry')
+        .action(async (id, options) => emit(await (await client()).minds.delete(id, Number(options.expectedGeneration), { idempotencyKey: options.idempotencyKey })));
+    minds.command('resize <mind_id>').description('Resize to an existing Pro profile (org API keys need minds:manage); 202 means accepted')
+        .requiredOption('--expected-generation <number>', 'desired_generation from a fresh owned Mind read')
+        .addOption(new Option('--profile-id <profile>', 'existing Pro profile').choices(['F1', 'D1', 'D2']).makeOptionMandatory())
+        .requiredOption('--idempotency-key <uuid>', 'persist this UUID4 and original generation; no automatic retry')
+        .action(async (id, options) => emit(await (await client()).minds.resize(id, Number(options.expectedGeneration), options.profileId, { idempotencyKey: options.idempotencyKey })));
+    const deliveries = minds.command('webhook-deliveries').description('Durable webhook receipts for an owned Mind; a stopped-idle Mind is woken');
+    deliveries.command('create <mind_id>').description('Record one delivery; replay the same delivery_id and body to read the original receipt')
+        .requiredOption('--delivery-id <uuid>', 'caller-chosen non-nil UUID; retain it after an uncertain response')
+        .requiredOption('--event-reference <reference>', 'opaque upstream event reference ([A-Za-z0-9_.:/-], at most 200)')
+        .requiredOption('--event-sha256 <hash>', 'lowercase hex SHA-256 of the upstream event')
+        .action(async (id, options) => emit(await (await client()).minds.webhookDeliveries.create(id, { delivery_id: options.deliveryId, event_reference: options.eventReference, event_sha256: options.eventSha256 })));
+    deliveries.command('get <mind_id> <delivery_id>').description('Read a receipt this principal issued')
+        .action(async (id, delivery) => emit(await (await client()).minds.webhookDeliveries.get(id, delivery)));
+    const memory = minds.command('memory').description('Every operation selects one owned, ready Mind');
+    memory.command('insert <mind_id>').requiredOption('--event-file <path>', 'JSON event with id, content and timestamp; returned id is its storage UUID')
+        .action(async (id, options) => {
+        const metadata = await stat(options.eventFile);
+        if (!metadata.isFile() || metadata.size > 65_536)
+            throw new Error('Event file must be at most 64 KiB.');
+        const bytes = await readFile(options.eventFile);
+        if (bytes.length > 65_536)
+            throw new Error('Event file exceeds 64 KiB.');
+        const event = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        emit(await (await client()).minds.memory.insert(id, event));
+    });
+    memory.command('get <mind_id> <storage_id>').action(async (mind, storage) => emit(await (await client()).minds.memory.get(mind, storage)));
+    memory.command('update <mind_id> <storage_id>').requiredOption('--content-file <path>', 'JSON {event_id,content}; preserves stored metadata, never automatically retries')
+        .action(async (mind, storage, options) => {
+        const metadata = await stat(options.contentFile);
+        if (!metadata.isFile() || metadata.size > 65_536)
+            throw new Error('Update file must be at most 64 KiB.');
+        const bytes = await readFile(options.contentFile);
+        if (bytes.length > 65_536)
+            throw new Error('Update file exceeds 64 KiB.');
+        const body = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        emit(await (await client()).minds.memory.update(mind, storage, body));
+    });
+    memory.command('search <mind_id> <text>').option('--limit <number>', '1–100 results', '20').action(async (mind, text, options) => {
+        emit(await (await client()).minds.memory.search(mind, text, Number(options.limit)));
+    });
+    const agent = minds.command('agent').description('Use an existing agent credential; does not create an attachment or exchange a human session');
+    const createProof = async (path) => ({ signal, dpopProof: await readBounded(path, 4_096) });
+    agent.command('create <name>').description('Create a Free/F1 Sandbox Mind with an approved agent-create token; 202 means provisioning')
+        .requiredOption('--approval-id <uuid>', 'owner approval admitting this creation')
+        .requiredOption('--approval-version <number>', 'approval version')
+        .requiredOption('--operation-id <uuid>', 'persisted UUID4; also the idempotency key and the status lookup id')
+        .requiredOption('--dpop-proof-file <path>', 'fresh DPoP proof for the controller create method and URL')
+        .action(async (name, options) => emit(await (await agentClient()).minds.agent.create({ name, approvalId: options.approvalId, approvalVersion: Number(options.approvalVersion), operationId: options.operationId }, await createProof(options.dpopProofFile))));
+    agent.command('create-status <operation_id>').description('Read an agent Mind creation operation')
+        .requiredOption('--dpop-proof-file <path>', 'fresh DPoP proof for the controller status method and URL')
+        .action(async (operation, options) => emit(await (await agentClient()).minds.agent.createStatus(operation, await createProof(options.dpopProofFile))));
+    const agentMemory = agent.command('memory').description('Private or explicitly authorized group memory; requests are never automatically retried');
+    const scoped = (command) => command.option('--group <agp_id>', 'explicit canonical group; omit for private memory')
+        .option('--dpop-proof-file <path>', 'fresh DPoP proof for the controller capability method and URL');
+    const readBounded = async (path, limit) => {
+        const metadata = await stat(path);
+        if (!metadata.isFile() || metadata.size > limit)
+            throw new Error('Agent input file exceeds its byte limit.');
+        const bytes = await readFile(path);
+        if (bytes.length > limit)
+            throw new Error('Agent input file exceeds its byte limit.');
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    };
+    const agentOptions = async (options) => ({ signal,
+        ...(options.group === undefined ? {} : { group: options.group }),
+        ...(options.dpopProofFile === undefined ? {} : { dpopProof: await readBounded(options.dpopProofFile, 16_384) }),
+    });
+    scoped(agentMemory.command('insert <mind_id>').requiredOption('--event-file <path>', 'JSON event; retain the returned storage UUID'))
+        .action(async (mind, options) => {
+        const content = await readBounded(options.eventFile, 65_536);
+        let event;
+        try {
+            event = JSON.parse(content);
+        }
+        catch {
+            throw new Error('Agent event file must contain valid JSON.');
+        }
+        emit(await (await agentClient()).minds.agent.memory.insert(mind, event, await agentOptions(options)));
+    });
+    scoped(agentMemory.command('get <mind_id> <storage_id>'))
+        .action(async (mind, storage, options) => emit(await (await agentClient()).minds.agent.memory.get(mind, storage, await agentOptions(options))));
+    scoped(agentMemory.command('search <mind_id> <text>').option('--limit <number>', '1–100 results', '20'))
+        .action(async (mind, text, options) => emit(await (await agentClient()).minds.agent.memory.search(mind, text, Number(options.limit), await agentOptions(options))));
+}

package/dist/onboard/art.d.ts

@@ -0,0 +1,50 @@
+/**
+ * One's marks as drawings: the emblem (Digital One, the disc with the eye knocked out), the Ones, and the hybrid ONE
+ * logotype whose O can close to the disc, wake as the eye, hop through the Ones and open back to the ring (JR-B103's
+ * cycle, the One site's components/ui/nav-logotype.tsx). Everything is drawn into a raster.Canvas from brand.ts.
+ *
+ * Paint rules (one-system.css): the disc is One's black on light and chalk on dark, never outlined or glowing; amber
+ * is only ever light inside the eye; the Ones wear their own colours, and those colours mean nothing else.
+ */
+import { ONES, type OneShape } from './brand.js';
+import { Canvas, type Color, type Mat } from './raster.js';
+import { sample, LIGHT, type Pose } from './eye.js';
+/**
+ * The terminal's own foreground. When the probe could not learn the background we draw ink and Digital One in this
+ * colour and the encoder emits SGR 39, so the mark is always the user's own ink: black on light, chalk on dark.
+ */
+export declare const DEFAULT_INK: Color;
+export declare const isDefaultInk: (c: Color) => boolean;
+export type Tone = 'light' | 'dark' | 'unknown';
+export declare const inkFor: (tone: Tone) => Color;
+export interface Head {
+    /** null: Digital One. Otherwise one of the Ones. */
+    one: OneShape | null;
+    pose: Pose;
+    /** agent-eye's light moment, -1 (waiting below) … 0 (full) … 1 (gone above); amber, inside the eye only. */
+    light?: number;
+    /** Squash for a hop: 1 is at rest; below 1 squats onto the pivot, above stretches. */
+    squash?: number;
+    /** Vertical offset in head units (a hop's lift). */
+    hop?: number;
+}
+/** Draw a head into the -100…100 box mapped by `m`. */
+export declare function drawHead(cv: Canvas, m: Mat, head: Head, tone: Tone): void;
+export declare const LOGO_ASPECT: number;
+export interface LogoState {
+    /** 0…1: the ring draws on clockwise from twelve o'clock. */
+    ring: number;
+    /** 0 the ring … 1 the disc (its hole closes on the enter curve). */
+    fill: number;
+    /** When set, the O is a head (One's eye awake, or one of the Ones) in the O's circle. */
+    head?: Head | null;
+    /** 0…1 each: the N and the E arrive, rising into place. */
+    n: number;
+    e: number;
+}
+export declare const LOGO_REST: LogoState;
+/** The hybrid ONE, `px` tall (cap height plus the O's overshoot), its top-left at (x, y) in canvas pixels. */
+export declare function drawLogotype(cv: Canvas, x: number, y: number, px: number, s: LogoState, tone: Tone, hint?: boolean): void;
+/** Digital One, `px` across, centred at (cx, cy). */
+export declare function drawEmblem(cv: Canvas, cx: number, cy: number, px: number, head: Partial<Head>, tone: Tone): void;
+export { ONES, LIGHT, sample };

package/dist/onboard/art.js

@@ -0,0 +1,139 @@
+/**
+ * One's marks as drawings: the emblem (Digital One, the disc with the eye knocked out), the Ones, and the hybrid ONE
+ * logotype whose O can close to the disc, wake as the eye, hop through the Ones and open back to the ring (JR-B103's
+ * cycle, the One site's components/ui/nav-logotype.tsx). Everything is drawn into a raster.Canvas from brand.ts.
+ *
+ * Paint rules (one-system.css): the disc is One's black on light and chalk on dark, never outlined or glowing; amber
+ * is only ever light inside the eye; the Ones wear their own colours, and those colours mean nothing else.
+ */
+import { AMBER, DISC, INK, LOGOTYPE, NIGHT_INK, ONES } from './brand.js';
+import { circle, hex, mix, mul, parsePath, roundRect, scale, translate } from './raster.js';
+import { GEOMETRY, poseToBar, poseToMouth, sample, LIGHT, REST } from './eye.js';
+/**
+ * The terminal's own foreground. When the probe could not learn the background we draw ink and Digital One in this
+ * colour and the encoder emits SGR 39, so the mark is always the user's own ink: black on light, chalk on dark.
+ */
+export const DEFAULT_INK = { r: 1, g: 2, b: 3 };
+export const isDefaultInk = (c) => c.r === 1 && c.g === 2 && c.b === 3;
+export const inkFor = (tone) => tone === 'unknown' ? DEFAULT_INK : hex(tone === 'dark' ? NIGHT_INK : INK);
+const discFor = (tone) => tone === 'unknown' ? DEFAULT_INK : hex(tone === 'dark' ? DISC.chalk : DISC.black);
+/** Clip a convex polygon to y in [y0, y1] (Sutherland–Hodgman on two half-planes). */
+function clipY(poly, y0, y1) {
+    const pass = (p, keep, edge) => {
+        const out = [];
+        for (let i = 0; i < p.length; i++) {
+            const a = p[i], b = p[(i + 1) % p.length], ia = keep(a[1]), ib = keep(b[1]);
+            if (ia)
+                out.push(a);
+            if (ia !== ib) {
+                const t = (edge - a[1]) / (b[1] - a[1]);
+                out.push([a[0] + (b[0] - a[0]) * t, edge]);
+            }
+        }
+        return out;
+    };
+    return pass(pass(poly, (y) => y >= y0, y0), (y) => y <= y1, y1);
+}
+/** Draw a head into the -100…100 box mapped by `m`. */
+export function drawHead(cv, m, head, tone) {
+    const sq = head.squash ?? 1, lift = head.hop ?? 0;
+    const pivot = 100; // the head stands on its foot: squash about y = +100
+    const body = mul(m, mul(translate(0, pivot + lift), mul(scale(1 / Math.sqrt(sq), sq), translate(0, -pivot))));
+    const one = head.one;
+    const eyeM = one ? mul(body, mul(translate(one.eye.x, one.eye.y), scale(one.eye.scale))) : body;
+    const pose = one ? { ...head.pose, open: head.pose.open * one.eye.openScale, look: head.pose.look * one.eye.lookGain } : head.pose;
+    const bar = poseToBar(pose);
+    const r = Math.min(GEOMETRY.cornerRadius, bar.h / 2, bar.w / 2);
+    const barPoly = roundRect(bar.x, bar.y, bar.w, bar.h, r);
+    const mouth = poseToMouth(pose);
+    const mouthPoly = mouth ? roundRect(mouth.x, mouth.y, mouth.w, mouth.h, GEOMETRY.cornerRadius) : null;
+    const toBody = (p) => p.map(([x, y]) => [eyeM[0] * x + eyeM[2] * y + eyeM[4], eyeM[1] * x + eyeM[3] * y + eyeM[5]]);
+    if (!one) {
+        // Digital One: the disc with the eye (and smile) knocked out, as the still emblem's even-odd cut.
+        const disc = circle(0, 0, 100).map(([x, y]) => [body[0] * x + body[2] * y + body[4], body[1] * x + body[3] * y + body[5]]);
+        cv.fill([disc, toBody(barPoly), ...(mouthPoly ? [toBody(mouthPoly)] : [])], discFor(tone), undefined, 'evenodd');
+    }
+    else {
+        cv.fill(parsePath(one.d), hex(one.colour), body);
+        cv.fill([toBody(barPoly), ...(mouthPoly ? [toBody(mouthPoly)] : [])], hex(one.eyeColour));
+    }
+    drawLight(cv, toBody, bar, head.light ?? -1);
+}
+/**
+ * The eye fills with light: a band rises up the bar behind a pale front, holds, and leaves through the top
+ * (agent-eye's rainbow, in One's amber). Drawn as strips so the light can grade from amber at its foot to soft amber.
+ */
+function drawLight(cv, toBody, bar, light) {
+    const amount = 1 - Math.min(1, Math.abs(light));
+    if (amount <= 0.001)
+        return;
+    const top = bar.y - bar.h / 2, bottom = bar.y + bar.h / 2, H = bar.h;
+    // rising: the band's top climbs from the foot; leaving: its foot follows it out of the top.
+    const bandTop = light < 0 ? bottom - H * (1 + light) * 1.02 : top - 2;
+    const bandBottom = light < 0 ? bottom + 2 : bottom - H * light * 1.02;
+    const shape = roundRect(bar.x, bar.y, bar.w, bar.h, Math.min(GEOMETRY.cornerRadius, bar.h / 2, bar.w / 2));
+    const amber = hex(AMBER.amber), soft = hex(AMBER.soft), front = hex('#fff1d6');
+    const strips = 10;
+    for (let i = 0; i < strips; i++) {
+        const y0 = bandTop + ((bandBottom - bandTop) * i) / strips, y1 = bandTop + ((bandBottom - bandTop) * (i + 1)) / strips;
+        const part = clipY(shape, Math.max(top, y0), Math.min(bottom, y1));
+        if (part.length < 3)
+            continue;
+        const k = i / (strips - 1);
+        const c = light < 0 && i === 0 ? mix(soft, front, 0.7) : mix(soft, amber, k);
+        cv.fill([toBody(part)], c, undefined, 'nonzero', Math.min(1, amount * 1.15));
+    }
+}
+export const LOGO_ASPECT = LOGOTYPE.width / LOGOTYPE.height;
+export const LOGO_REST = { ring: 1, fill: 0, head: null, n: 1, e: 1 };
+/** The hybrid ONE, `px` tall (cap height plus the O's overshoot), its top-left at (x, y) in canvas pixels. */
+export function drawLogotype(cv, x, y, px, s, tone, hint = px <= 40) {
+    // Hinting for text cells: the scale makes a stem (11 units) a whole number of pixels, which also puts the N's second
+    // stem (99 units in) on the grid; the cap height starts on a whole pixel; and each letter moves, never more than half
+    // a pixel, so its first stem's left edge does too. Stems then read as solid columns instead of two grey halves.
+    const k = hint ? Math.max(1, Math.round((11 * px) / LOGOTYPE.height)) / 11 : px / LOGOTYPE.height;
+    // …and the cap height is a whole number of pixels too (a vertical squeeze of at most half a pixel), so the baseline
+    // is as sharp as the cap line.
+    const ky = hint ? Math.round(100 * k) / 100 : k;
+    y += hint ? (px - LOGOTYPE.height * ky) / 2 : 0;
+    const dy = hint ? Math.round(y - LOGOTYPE.top * ky) - (y - LOGOTYPE.top * ky) : 0;
+    const snapX = (ux) => hint ? (Math.round(x + ux * k) - (x + ux * k)) / k : 0;
+    const base = mul(translate(x, y + dy), mul(scale(k, ky), translate(0, -LOGOTYPE.top)));
+    const ink = inkFor(tone);
+    const { cx, cy, r, inner } = LOGOTYPE.O;
+    if (s.head) {
+        drawHead(cv, mul(base, mul(translate(cx, cy), scale(r / 100))), s.head, tone);
+    }
+    else if (s.ring > 0) {
+        const hole = inner * (1 - s.fill);
+        const sweep = Math.min(1, s.ring) * Math.PI * 2;
+        const n = 96;
+        const ring = [];
+        const steps = Math.max(2, Math.ceil((n * sweep) / (Math.PI * 2)));
+        for (let i = 0; i <= steps; i++) {
+            const a = (sweep * i) / steps;
+            ring.push([cx + r * Math.sin(a), cy - r * Math.cos(a)]);
+        }
+        if (hole > 0.05)
+            for (let i = steps; i >= 0; i--) {
+                const a = (sweep * i) / steps;
+                ring.push([cx + hole * Math.sin(a), cy - hole * Math.cos(a)]);
+            }
+        else
+            ring.push([cx, cy]);
+        cv.fill([ring], s.fill > 0.98 ? discFor(tone) : ink, base);
+    }
+    const letter = (d, ox, t) => {
+        if (t <= 0)
+            return;
+        const rise = (1 - t) * 14;
+        cv.fill(parsePath(d), ink, mul(base, translate(ox, rise)), 'nonzero', Math.min(1, t * 1.25));
+    };
+    letter(LOGOTYPE.N.d, LOGOTYPE.N.x + snapX(LOGOTYPE.N.x), s.n);
+    letter(LOGOTYPE.E.d, LOGOTYPE.E.x + snapX(LOGOTYPE.E.x), s.e);
+}
+/** Digital One, `px` across, centred at (cx, cy). */
+export function drawEmblem(cv, cx, cy, px, head, tone) {
+    drawHead(cv, mul(translate(cx, cy), scale(px / 200)), { one: null, pose: REST, ...head }, tone);
+}
+export { ONES, LIGHT, sample };

package/dist/onboard/brand.d.ts

@@ -0,0 +1,56 @@
+/**
+ * One's brand geometry and colour, for the terminal. Generated from the One site (l1felabs one-website, worktree
+ * one-ones-shapes-20261016 at cdf3a16c): components/ui/logo.tsx (EMBLEM), components/ui/logotype.ts (the hybrid ONE,
+ * JR-B103), tests/fixtures/ones-shapes/shapes.json + palette.json (the Ones, life/ones-shapes/v2) and app/one-system.css
+ * (amber, the disc, paper and night). Do not edit by hand; regenerate from those files.
+ *
+ * Rules carried over (one-system.css): amber is One's light, never the interface's; the Ones' colours belong to the
+ * characters, never to success, warning or failure; the disc is One's black on light and chalk on dark, with no glow.
+ */
+export declare const EMBLEM_PATH = "M16 0A16 16 0 1 1 16 32A16 16 0 1 1 16 0Z";
+export declare const DISC: {
+    readonly black: "#141b16";
+    readonly chalk: "#f2f1ea";
+    readonly eyeLight: "#fbfaf6";
+    readonly eyeDark: "#f2f1ea";
+};
+export declare const AMBER: {
+    readonly amber: "#c8793a";
+    readonly soft: "#e9a867";
+};
+export declare const PAPER = "#f4f2ec", NIGHT = "#0b0c0c", INK = "#191614", NIGHT_INK = "#f2f1ea";
+export declare const LOGOTYPE: {
+    readonly width: 340.5;
+    readonly height: 103;
+    readonly top: -1.5;
+    readonly O: {
+        readonly cx: 51.5;
+        readonly cy: 50;
+        readonly r: 51.5;
+        readonly inner: 39.84;
+    };
+    readonly N: {
+        readonly x: 119.5;
+        readonly d: "M0 0h11v100h-11ZM99 0h11v100h-11ZM16.1 10L31.444 10L93.9 90L78.556 90Z";
+    };
+    readonly E: {
+        readonly x: 248.5;
+        readonly d: "M0 0h11v100h-11ZM17 0h72.32v10.12h-72.32ZM0 43.94h76.816v10.12h-76.816ZM17 89.88h75v10.12h-75Z";
+    };
+};
+export interface OneShape {
+    id: string;
+    d: string;
+    eye: {
+        x: number;
+        y: number;
+        scale: number;
+        openScale: number;
+        lookGain: number;
+    };
+    colour: string;
+    eyeColour: string;
+    keyline: string | null;
+}
+/** Ones that join the parade (shapes.json parade: true), in agent-eye's -100…100 head box. */
+export declare const ONES: readonly OneShape[];