@zenera/cli 1.1.0

package/dist/commands/sandbox.js

@@ -0,0 +1,112 @@
+import { readProjectConfig } from '@zenera/neo';
+import { parse } from "../args.js";
+import { ensurePodmanReady, ownedContainers, podmanStatus, removeContainers } from "../podman.js";
+import { project as findProject } from "../resolve.js";
+import { bold, dim, green, json, note, red, usageError, write, yellow } from "../term.js";
+const USAGE = 'zen sandbox [status|up|pull|clean] [options]';
+// ---------------------------------------------------------------------------
+// The container engine, on its own
+//
+// Everything here also happens inside `zen run`, and that is the point of
+// having it: the slow, one-time, machine-wide half of a run is the half most
+// likely to fail, and debugging it should not cost a model call. `up` is what
+// you run on a new laptop; `status` is what you read when a run says the engine
+// did not answer.
+// ---------------------------------------------------------------------------
+export const sandbox = {
+    summary: 'Check and prepare the container command-line tools run in.',
+    usage: USAGE,
+    details: [
+        '  status                 What is installed, running and pulled. Changes nothing.',
+        '  up                     Install if asked, start the machine, pull the image.',
+        '  pull                   Just the image.',
+        '  clean                  Remove every container this CLI created.',
+        '',
+        '  --project <name|dir>   Which project the image comes from.',
+        '  --image <ref>          Use this image instead of the project\u2019s.',
+        '',
+        'None of this is required. A run does all of it on its own, the first',
+        'time an agent that can reach a shell is about to start one.',
+    ],
+    run: async (ctx) => {
+        const { values, positionals } = parse(ctx.args, {
+            project: { type: 'string' },
+            image: { type: 'string' },
+        }, USAGE);
+        const what = positionals[0] ?? 'status';
+        if (!['status', 'up', 'pull', 'clean'].includes(what)) {
+            throw usageError(`unknown subcommand: ${what}`, USAGE);
+        }
+        if (positionals.length > 1) {
+            throw usageError('one subcommand at a time', USAGE);
+        }
+        const image = values.image ?? (await projectImage(ctx.cwd, values));
+        switch (what) {
+            case 'status':
+                return status(image, ctx.json);
+            case 'up':
+                return up(image, ctx.json, ctx.json);
+            case 'pull':
+                return up(image, true, ctx.json);
+            case 'clean':
+                return clean(ctx.json);
+        }
+    },
+};
+/**
+ * The project's image, when there is a project to ask. `zen sandbox status`
+ * run from anywhere at all is still a useful thing, so failing to find one is
+ * not a failure — it just means there is no image to report on. Notably this
+ * does *not* go through `target`: reading a setting must not create a session.
+ */
+async function projectImage(cwd, values) {
+    try {
+        const found = await findProject({ cwd, project: values.project, yes: true });
+        return readProjectConfig(found.dir).config.sandbox?.image;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function status(image, asJson) {
+    const found = await podmanStatus({ image });
+    const containers = found.ready ? await ownedContainers(found.engine) : [];
+    if (asJson) {
+        json({ ...found, containers });
+        return;
+    }
+    const mark = (ok) => (ok ? green('ok') : red('no'));
+    write(`${bold('engine')}     ${found.engine} ${dim(found.version ?? '')} ${mark(found.installed)}`);
+    if (found.machine) {
+        const state = found.machine.starting ? yellow('starting') : mark(found.machine.running);
+        write(`${bold('machine')}    ${found.machine.name} ${state}`);
+    }
+    write(`${bold('responds')}   ${mark(found.ready)}`);
+    if (found.image) {
+        write(`${bold('image')}      ${found.image} ${mark(Boolean(found.imagePresent))}`);
+    }
+    const listed = containers.map((c) => c.state === 'running' ? `${c.name} ${green('running')}` : `${c.name} ${dim(c.state)}`);
+    write(`${bold('containers')} ${listed.length ? listed.join(', ') : dim('none')}`);
+    if (!found.installed || !found.ready) {
+        note('');
+        note(dim('run `zen sandbox up` to fix what can be fixed.'));
+    }
+}
+async function up(image, yes, asJson) {
+    await ensurePodmanReady({ image, yes });
+    if (asJson) {
+        json({ ready: true, image });
+        return;
+    }
+    write(`${green('ready')}${image ? ` ${dim(image)}` : ''}`);
+}
+async function clean(asJson) {
+    const names = (await ownedContainers()).map((c) => c.name);
+    await removeContainers(names);
+    if (asJson) {
+        json({ removed: names });
+        return;
+    }
+    write(names.length ? `removed ${names.length}: ${names.join(', ')}` : dim('nothing to remove'));
+}
+//# sourceMappingURL=sandbox.js.map

package/dist/commands/version.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from '../command.ts';
+/** A package's version, read from its manifest rather than inlined at build time. */
+export declare function versionOf(manifest: URL): Promise<string>;
+export declare const cliManifest: import("url").URL;
+export declare const version: Command;
+//# sourceMappingURL=version.d.ts.map

package/dist/commands/version.js

@@ -0,0 +1,39 @@
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dim, json, pad, write } from "../term.js";
+/** A package's version, read from its manifest rather than inlined at build time. */
+export async function versionOf(manifest) {
+    const { version } = JSON.parse(await readFile(manifest, 'utf8'));
+    return version;
+}
+export const cliManifest = new URL('../../package.json', import.meta.url);
+/**
+ * Where the library actually resolved from — the workspace symlink in
+ * development, `node_modules` once installed. Going through its `exports` map
+ * rather than a guessed path means this also fails loudly if that map is ever
+ * broken, which is the one packaging mistake nothing else catches.
+ */
+function libraryManifest() {
+    const resolve = createRequire(import.meta.url).resolve;
+    return new URL(`file://${resolve('@zenera/neo/package.json')}`);
+}
+export const version = {
+    summary: 'Print the CLI, library and Node versions.',
+    usage: 'zen version',
+    run: async (ctx) => {
+        const versions = {
+            cli: await versionOf(cliManifest),
+            '@zenera/neo': await versionOf(libraryManifest()),
+            node: process.versions.node,
+        };
+        if (ctx.json) {
+            json(versions);
+            return;
+        }
+        const width = Math.max(...Object.keys(versions).map((k) => k.length));
+        for (const [name, value] of Object.entries(versions)) {
+            write(`${dim(pad(name, width))}  ${value}`);
+        }
+    },
+};
+//# sourceMappingURL=version.js.map

package/dist/engine.d.ts

@@ -0,0 +1,49 @@
+import { AgentRunner, type AgentEvent, type AgentProject, type AgentState, type Input, type RunResult } from '@zenera/neo';
+import type { Project } from './projects.ts';
+import { type SandboxSetup } from './sandbox.ts';
+import { type Held, type RunPaths, type SessionPaths } from './session.ts';
+export interface EngineOptions {
+    project: Project;
+    session: SessionPaths;
+    readOnly?: boolean;
+    /** default model override — `--model` */
+    model?: string;
+    /** sandbox image override — `--image` */
+    image?: string;
+    /** answer the sandbox's install question without asking — `--yes` */
+    yes?: boolean;
+}
+export interface Engine {
+    project: AgentProject;
+    runner: AgentRunner;
+    name: string;
+    workspace: string;
+    session: SessionPaths;
+    /** the session's accumulated state, when it has one */
+    state?: AgentState;
+    /** the containers this session may start; present whether or not it does */
+    sandbox: SandboxSetup;
+    lock: Held;
+    close(): Promise<void>;
+}
+/**
+ * Wires the library to a session directory. Every store is file-backed and
+ * rooted inside `.data/`, so a session is self-contained: copy the directory
+ * and the whole conversation, its memory and its blobs travel with it.
+ */
+export declare function open(opts: EngineOptions): Promise<Engine>;
+export interface RunOutcome {
+    run: RunPaths;
+    result: RunResult<string>;
+    text: string;
+    durationMs: number;
+    /** where the report landed, when one could be rendered */
+    report?: string;
+}
+/**
+ * One turn. The session's state decides whether this starts a run or continues
+ * one — which is the whole of what `resume` used to be, and why it is not a
+ * command.
+ */
+export declare function run(engine: Engine, input: Input, onEvent?: (event: AgentEvent) => void, signal?: AbortSignal): Promise<RunOutcome>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.js

@@ -0,0 +1,208 @@
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { AgentRunner, FileMemoryStore, FilePayloadStore, SANDBOX_MOUNT, assertState, buildRunReport, exaTools, lastText, loadProject, readProjectConfig, renderReportHtml, sandboxTools, turns, workspaceTools, } from '@zenera/neo';
+import { auditModels, describeIssue } from "./audit.js";
+import { readJson, writeJson } from "./home.js";
+import { KeyStore, assertUsable } from "./keys.js";
+import { buildSandbox, preflight, teardown, usesSandbox } from "./sandbox.js";
+import { acquire, createRun, readSessionMeta, writeSessionMeta, } from "./session.js";
+import { CliError, EXIT, invalidError, warn } from "./term.js";
+/**
+ * Wires the library to a session directory. Every store is file-backed and
+ * rooted inside `.data/`, so a session is self-contained: copy the directory
+ * and the whole conversation, its memory and its blobs travel with it.
+ */
+export async function open(opts) {
+    const keys = await KeyStore.open();
+    keys.materialize();
+    assertUsable(keys);
+    // Said before the load, because the load stops at the first model it cannot
+    // build: one SDK's words about one model, when the useful answer is which
+    // of the project's models are reachable and which are not.
+    for (const issue of auditModels(opts.project.dir, keys)) {
+        warn(describeIssue(issue));
+    }
+    const meta = await readSessionMeta(opts.session);
+    const workspace = resolve(meta.workspace);
+    const payloads = new FilePayloadStore({ dir: opts.session.blobs, id: 'file' });
+    const memory = [new FileMemoryStore({ dir: opts.session.memory, id: 'file' })];
+    // The config is read before the project is loaded because the sandbox is
+    // configured by it and the tools have to exist before selectors can be
+    // resolved against them. They are always registered, whether or not anyone
+    // selects them: a project that names `sandbox:*` against an empty tool list
+    // fails to load with "unknown tool", which would be a lie.
+    let sandbox;
+    let project;
+    try {
+        const { config } = readProjectConfig(opts.project.dir);
+        sandbox = buildSandbox({
+            config,
+            session: opts.session,
+            workspace,
+            readOnly: opts.readOnly,
+            image: opts.image,
+        });
+        project = await loadProject(opts.project.dir, {
+            tools: [
+                // Both groups are pointed at one directory, so both are told the
+                // one name for it: whatever `run_command` prints a path as,
+                // `read_file` accepts.
+                ...workspaceTools({
+                    root: workspace,
+                    readOnly: opts.readOnly,
+                    mount: sandbox.spec.workdir ?? SANDBOX_MOUNT,
+                }),
+                ...sandboxTools(sandbox.pool),
+                // Registered whether or not a key exists: the credential is
+                // read when a tool is called, so a project that names `exa:*`
+                // loads on a machine that cannot yet search, and says so on the
+                // turn that tried.
+                ...exaTools(),
+            ],
+            payloads,
+            memory,
+        });
+    }
+    catch (err) {
+        throw invalidError(err instanceof Error ? err.message : String(err), `while loading ${opts.project.dir}`);
+    }
+    // Asked here rather than at the first `run_command`, so a host with no
+    // container engine costs an error instead of a round trip. Nothing is
+    // started: the container itself waits until something actually runs.
+    if (usesSandbox(project)) {
+        await preflight(sandbox, opts.yes);
+    }
+    // `recordRequests` is what makes the report show the exact bytes sent
+    // rather than a reconstruction. It costs state size, and a CLI run is
+    // written to disk once and inspected by a human — exactly the case the
+    // library leaves it off for by default.
+    //
+    // `--model` becomes the runner's fallback rather than an alias, so it
+    // overrides the config's `model:` without touching agents that pinned one.
+    const runner = project.runner({
+        recordRequests: true,
+        model: opts.model ? project.models.model(opts.model) : undefined,
+    });
+    const state = await loadState(opts.session);
+    const lock = acquire(opts.session);
+    return {
+        project,
+        runner,
+        name: opts.project.name,
+        workspace,
+        session: opts.session,
+        state,
+        sandbox,
+        lock,
+        close: async () => {
+            await teardown(sandbox.pool);
+            lock.release();
+        },
+    };
+}
+async function loadState(session) {
+    if (!existsSync(session.state)) {
+        return undefined;
+    }
+    const json = await readJson(session.state, undefined);
+    try {
+        return assertState(json);
+    }
+    catch {
+        throw invalidError(`${session.state} is not a usable run state`, 'start a fresh session with --new');
+    }
+}
+/**
+ * One turn. The session's state decides whether this starts a run or continues
+ * one — which is the whole of what `resume` used to be, and why it is not a
+ * command.
+ */
+export async function run(engine, input, onEvent, signal) {
+    const startedAt = new Date();
+    const stream = engine.state
+        ? engine.runner.send(engine.state, input, { signal })
+        : engine.runner.run(engine.project.entry, input, { signal });
+    if (onEvent) {
+        for await (const event of stream) {
+            onEvent(event);
+        }
+    }
+    const result = await stream.final();
+    const durationMs = Date.now() - startedAt.getTime();
+    engine.state = result.state;
+    const outcome = await record(engine, input, result, startedAt, durationMs);
+    if (result.stopReason === 'failed') {
+        throw new CliError(result.state.error ?? 'the run failed', EXIT.failed, `report: ${outcome.run.report}`);
+    }
+    return outcome;
+}
+/**
+ * Everything a finished turn leaves behind. The session state is written first:
+ * if the report fails to render, the conversation is still resumable, which is
+ * the ordering that loses least.
+ */
+async function record(engine, input, result, startedAt, durationMs) {
+    const { session } = engine;
+    writeJson(session.state, result.state, 0o644);
+    const meta = await readSessionMeta(session);
+    meta.lastRunAt = new Date().toISOString();
+    meta.title ??= title(input);
+    writeSessionMeta(session, meta);
+    const run = createRun(session);
+    const text = await lastText(result.state, engine.runner.services.payloads);
+    await writeFile(run.input, `${asText(input)}\n`, 'utf8');
+    await writeFile(run.output, `${text}\n`, 'utf8');
+    writeJson(run.state, result.state, 0o644);
+    let report;
+    try {
+        const built = await buildRunReport(result.state, engine.runner.services.payloads, {
+            title: `${engine.name} · ${run.id}`,
+            architecture: await engine.runner.describe(),
+        });
+        await writeFile(run.report, renderReportHtml(built), 'utf8');
+        report = run.report;
+    }
+    catch {
+        // A report is a convenience. Losing it must not lose the run.
+    }
+    writeJson(run.meta, {
+        version: 1,
+        id: run.id,
+        session: session.id,
+        startedAt: startedAt.toISOString(),
+        finishedAt: new Date().toISOString(),
+        durationMs,
+        agent: result.agent,
+        stopReason: result.stopReason,
+        turns: turns(result.state),
+        usage: result.usage,
+        workspace: engine.workspace,
+        error: result.state.error,
+    }, 0o644);
+    return { run, result, text, durationMs, report };
+}
+function asText(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    return input
+        .map((part) => {
+        if (typeof part === 'string') {
+            return part;
+        }
+        if ('text' in part && typeof part.text === 'string') {
+            return part.text;
+        }
+        // A media shorthand is a single key; naming it is more useful in a
+        // transcript than printing the url or the base64 behind it.
+        return `[${Object.keys(part)[0] ?? 'part'}]`;
+    })
+        .join('\n');
+}
+/** A session's label in a picker: the first thing that was ever asked of it. */
+function title(input) {
+    const text = asText(input).replace(/\s+/g, ' ').trim();
+    return text.length > 60 ? `${text.slice(0, 57)}…` : text;
+}
+//# sourceMappingURL=engine.js.map

package/dist/external.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from './command.ts';
+import type { External } from './commands/index.ts';
+/**
+ * Whether the package is installed. Resolution only — nothing is loaded, and
+ * `import.meta.resolve` is the same resolver the import below will use, so it
+ * cannot say yes to something that then fails to load.
+ */
+export declare function hasExternal(ext: External): boolean;
+export declare function loadExternal(name: string, ext: External): Promise<Command>;
+//# sourceMappingURL=external.d.ts.map

package/dist/external.js

@@ -0,0 +1,56 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { CliError, EXIT, bold } from "./term.js";
+// ---------------------------------------------------------------------------
+// Loading a command out of a sibling package
+//
+// The specifier is built rather than written, and that is the whole mechanism:
+// a literal `import('@zenera/faker/command')` would make the sibling a
+// compile-time dependency of `zen` — a project reference, a package.json entry,
+// and a cycle, since the sibling already depends on `zen`. Built, it is
+// resolved by Node at the moment the user asks for it and by nobody before.
+//
+// So `zen --help` costs nothing whether or not the package is there, and a
+// machine without it gets the same answer the SDK loader gives: the line to run.
+// ---------------------------------------------------------------------------
+const entry = (ext) => `${ext.package}/command`;
+/**
+ * Whether the package is installed. Resolution only — nothing is loaded, and
+ * `import.meta.resolve` is the same resolver the import below will use, so it
+ * cannot say yes to something that then fails to load.
+ */
+export function hasExternal(ext) {
+    try {
+        import.meta.resolve(entry(ext));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function loadExternal(name, ext) {
+    let module;
+    try {
+        module = await import(__rewriteRelativeImportExtension(entry(ext)));
+    }
+    catch (err) {
+        if (err.code === 'ERR_MODULE_NOT_FOUND') {
+            throw new CliError(`zen ${name} needs ${ext.package}`, EXIT.usage, `run ${bold(ext.install)}`);
+        }
+        throw err;
+    }
+    // A sibling built against another version of this package is a version
+    // problem, and saying so beats `undefined is not a function`.
+    const command = module.command;
+    if (typeof command?.run !== 'function') {
+        throw new CliError(`${ext.package} does not export a command`, EXIT.failed, `it may be older than this ${bold('zen')} — try ${bold(ext.install)}`);
+    }
+    return command;
+}
+//# sourceMappingURL=external.js.map

package/dist/home.d.ts

@@ -0,0 +1,31 @@
+export declare function home(): string;
+export declare const paths: {
+    home: typeof home;
+    projects: () => string;
+    keys: () => string;
+    keyDir: () => string;
+    faker: () => string;
+};
+/** Creates a directory owner-only, and leaves an existing one's mode alone. */
+export declare function ensureDir(dir: string, mode?: number): string;
+export declare function ensureHome(): string;
+/**
+ * Refuses to read a credential file that anyone else can read, the way `ssh`
+ * does. A world-readable key is not a warning-level event: warnings are
+ * ignored, and the whole point of the store is that the secret is not lying
+ * around in the open.
+ *
+ * Windows reports a mode that means nothing here, so the check is POSIX-only.
+ */
+export declare function assertPrivate(path: string): void;
+export declare function readJson<T>(path: string, fallback: T): Promise<T>;
+/**
+ * Write to a sibling and rename. A crash then leaves either the old file or the
+ * new one, never a half-written registry — which matters more here than it
+ * looks, because the alternative is a corrupt `keys.json` locking someone out
+ * of every provider at once.
+ *
+ * Synchronous on purpose: this is also called from exit paths.
+ */
+export declare function writeJson(path: string, value: unknown, mode?: number): void;
+//# sourceMappingURL=home.d.ts.map

package/dist/home.js

@@ -0,0 +1,108 @@
+import { randomUUID } from 'node:crypto';
+import { chmodSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { CliError, EXIT } from "./term.js";
+// ---------------------------------------------------------------------------
+// The home directory
+//
+// ~/.zenera/neo holds exactly two kinds of thing: credentials, which belong to
+// the machine and never to a project, and an index of where projects are, which
+// is a convenience and is allowed to be wrong.
+//
+// `ZENERA_HOME` moves the whole tree. That is what makes any of this testable
+// and what lets CI start from an empty one.
+// ---------------------------------------------------------------------------
+const DIR_MODE = 0o700;
+const FILE_MODE = 0o600;
+export function home() {
+    const override = process.env.ZENERA_HOME?.trim();
+    return override ? override : join(homedir(), '.zenera', 'neo');
+}
+export const paths = {
+    home,
+    projects: () => join(home(), 'projects.json'),
+    keys: () => join(home(), 'keys.json'),
+    keyDir: () => join(home(), 'keys'),
+    faker: () => join(home(), 'faker'),
+};
+/** Creates a directory owner-only, and leaves an existing one's mode alone. */
+export function ensureDir(dir, mode = DIR_MODE) {
+    mkdirSync(dir, { recursive: true, mode });
+    return dir;
+}
+export function ensureHome() {
+    return ensureDir(home());
+}
+// ---------------------------------------------------------------------------
+// Permissions
+// ---------------------------------------------------------------------------
+/**
+ * Refuses to read a credential file that anyone else can read, the way `ssh`
+ * does. A world-readable key is not a warning-level event: warnings are
+ * ignored, and the whole point of the store is that the secret is not lying
+ * around in the open.
+ *
+ * Windows reports a mode that means nothing here, so the check is POSIX-only.
+ */
+export function assertPrivate(path) {
+    if (process.platform === 'win32') {
+        return;
+    }
+    let mode;
+    try {
+        mode = statSync(path).mode;
+    }
+    catch {
+        return; // absent is fine; it will be created with the right mode
+    }
+    const open = mode & 0o077;
+    if (open !== 0) {
+        const octal = (mode & 0o777).toString(8).padStart(3, '0');
+        throw new CliError(`permissions ${octal} on ${path} are too open`, EXIT.credentials, `run: chmod 600 ${path}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// JSON files
+// ---------------------------------------------------------------------------
+export async function readJson(path, fallback) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return fallback;
+        }
+        throw err;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new CliError(`${path} is not valid JSON`, EXIT.invalid, 'fix or delete the file');
+    }
+}
+/**
+ * Write to a sibling and rename. A crash then leaves either the old file or the
+ * new one, never a half-written registry — which matters more here than it
+ * looks, because the alternative is a corrupt `keys.json` locking someone out
+ * of every provider at once.
+ *
+ * Synchronous on purpose: this is also called from exit paths.
+ */
+export function writeJson(path, value, mode = FILE_MODE) {
+    ensureDir(dirname(path));
+    const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode });
+        chmodSync(tmp, mode);
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        rmSync(tmp, { force: true });
+        throw err;
+    }
+}
+//# sourceMappingURL=home.js.map

package/dist/ids.d.ts

@@ -0,0 +1,12 @@
+export declare function stamp(now?: Date): string;
+/**
+ * Ids arrive from `--session` and `--run` and become path segments, so they are
+ * checked rather than trusted. The shape has no `.` and no separator, which
+ * makes traversal unrepresentable rather than merely rejected.
+ */
+export declare function isStamp(value: string): boolean;
+/** Human-readable form of a stamp: `2026-08-25 14:30:12`. */
+export declare function stampDate(id: string): string;
+/** ISO instant a stamp names, for `ago()`. Local time in, local time out. */
+export declare function stampInstant(id: string): string | undefined;
+//# sourceMappingURL=ids.d.ts.map