@hanzo/build 0.2.80 → 0.2.82

package/lib/api/coding.js

@@ -28,11 +28,17 @@
  * A sandbox run keeps its sandbox after it ends, so `after` continues the earlier
  * run in that same sandbox and working tree, resumed if it parked.
  */
+import { phrase } from '@hanzo/i18n';
+import { english } from '../say.js';
 import { call, headers, reason, Refusal, seg } from './call.js';
-/** Why this mode cannot run where it is sent, or '' when it can. */
-export const unhonoured = (mode, target) => (mode === 'plan' || mode === 'setup') && target?.trim()
-    ? `A ${mode} runs in the Hanzo sandbox: a machine clones and pushes with its own credential. Choose Cloud, or switch to Build.`
-    : '';
+/** Why this mode cannot run where it is sent, in the words of the `t` handed (English without one), or '' when it can. */
+export const unhonoured = (mode, target, t = english) => !target?.trim()
+    ? ''
+    : mode === 'plan'
+        ? t('A plan runs in the Hanzo sandbox: a machine clones and pushes with its own credential. Choose Cloud, or switch to Build.')
+        : mode === 'setup'
+            ? t('A setup runs in the Hanzo sandbox: a machine clones and pushes with its own credential. Choose Cloud, or switch to Build.')
+            : '';
 /**
  * The request body: only what was asked, with no empty strings sent as values.
  * A run in the sandbox asks for one with a desktop, so its Desktop tab has a
@@ -53,14 +59,14 @@ export function body(ask) {
 }
 export async function start(t, ask) {
     if (!ask.prompt.trim())
-        throw new Refusal(400, 'Say what the run should do');
+        throw new Refusal(400, phrase('Say what the run should do'));
     const why = unhonoured(ask.mode, ask.targetId);
     if (why)
         throw new Refusal(400, why);
     const r = await call(t, 'POST', '/v1/agent/coding', body(ask));
     const s = (k) => (typeof r?.[k] === 'string' ? r[k] : '');
     if (!s('sessionId'))
-        throw new Refusal(502, 'The run was admitted but named no session');
+        throw new Refusal(502, phrase('The run was admitted but named no session'));
     return {
         session: s('sessionId'),
         repo: s('repo'),
@@ -154,7 +160,7 @@ export async function artifacts(t, session) {
 export async function artifact(t, session, name) {
     const parts = name.split('/');
     if (parts.some((p) => p === '' || p === '.' || p === '..'))
-        throw new Refusal(400, 'That artifact has no name to fetch it by');
+        throw new Refusal(400, phrase('That artifact has no name to fetch it by'));
     const res = await fetch(`${t.api}/v1/agent/coding/${seg(session)}/artifacts/${parts.map(seg).join('/')}`, { headers: headers(t), cache: 'no-store' });
     if (!res.ok)
         throw new Refusal(res.status, (await reason(res)) || `The artifact answered ${res.status}`);

package/lib/api/connectors.d.ts

@@ -1,19 +1,3 @@
-/**
- * Connectors: the MCP servers an org adds, and the shelf it picks them from.
- *
- *   GET    /v1/tool/mcp/servers        {servers: [server]}
- *   POST   /v1/tool/mcp/servers        {name, url} or {listing, name?}, with {authHeader, secret} → 201 server
- *   DELETE /v1/tool/mcp/servers/{id}   204
- *   GET    /v1/tool/catalog?q=&limit=&offset=   {catalog: [listing], total, limit, offset}
- *   GET    /v1/tool/catalog/{id}       one listing in full
- *
- * A server's secret is sealed in KMS by the platform and never answered again;
- * a record says only whether it has one. Its tools are GET /v1/tool?source=mcp
- * (tools.ts), named `<server id>_<tool>`, and each is called only once it is on.
- * A listing can be added here only when it serves streamable HTTP; one that
- * ships only a package needs somewhere to run first. The fleet's own servers,
- * on for every run, are mcp.ts.
- */
 import { type Target } from './call.ts';
 export interface Server {
     /** The server's id in the org, and the prefix of every tool it brings. */
@@ -79,7 +63,7 @@ export interface Adding {
     header?: string;
     secret?: string;
 }
-/** Why a server cannot be added as it stands, or '' when it can. */
+/** Why a server cannot be added as it stands, or '' when it can. English, marked (`phrase`): a screen says it through `t`. */
 export declare function refuse(a: Adding): string;
 export declare function add(t: Target, a: Adding): Promise<Server>;
 export declare function remove(t: Target, id: string): Promise<void>;

package/lib/api/connectors.js

@@ -14,6 +14,7 @@
  * ships only a package needs somewhere to run first. The fleet's own servers,
  * on for every run, are mcp.ts.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, query, seg } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
@@ -67,16 +68,16 @@ export const owns = (s, toolName) => toolName.startsWith(`${s.id}_`);
 export async function servers(t) {
     return rows(obj(await call(t, 'GET', '/v1/tool/mcp/servers')).servers).map(server).filter((s) => s.id);
 }
-/** Why a server cannot be added as it stands, or '' when it can. */
+/** Why a server cannot be added as it stands, or '' when it can. English, marked (`phrase`): a screen says it through `t`. */
 export function refuse(a) {
     if (!a.listing) {
         if (!a.name?.trim())
-            return 'A connector needs a name';
+            return phrase('A connector needs a name');
         if (!/^https?:\/\/[^\s/]+/.test(a.url?.trim() ?? ''))
-            return 'The URL is an http(s) address';
+            return phrase('The URL is an http(s) address');
     }
     if (a.secret && !a.header?.trim())
-        return 'Name the header the secret is sent in';
+        return phrase('Name the header the secret is sent in');
     return '';
 }
 export async function add(t, a) {

package/lib/api/environment.d.ts

@@ -1,19 +1,4 @@
-/**
- * A codebase's environment: what a run does to its checkout before the agent
- * starts, and which secrets it exports.
- *
- *   GET    /v1/environment                      {data: [environment]}
- *   GET    /v1/environment/{repo}               one; a codebase with none answers state "none"
- *   PUT    /v1/environment/{repo}               save {install, start} (org admin)
- *   DELETE /v1/environment/{repo}               forget it and its secrets (org admin)
- *   PUT    /v1/environment/{repo}/secrets/{name}  set one value (org admin)
- *   DELETE /v1/environment/{repo}/secrets/{name}  remove one (org admin)
- *
- * A setup run is a coding run in mode `setup` (coding.ts): its agent explores the
- * checkout, installs and checks what it finds, and the platform keeps its answer
- * here as `proposal` until someone saves it. Secrets are names only; their values
- * are sealed in KMS and reach the run's environment, never this record.
- */
+import type { Say } from '@hanzo/i18n/react';
 import { type Target } from './call.ts';
 export type State = 'none' | 'proposed' | 'ready';
 export interface Proposal {
@@ -46,9 +31,10 @@ export declare function environment(raw: unknown, repo?: string): Environment;
 export declare const unset: (e: Environment) => boolean;
 /**
  * What a refused save or setup run says to the person who pressed it: what is
- * wrong and what to do, in the reader's words rather than the platform's.
+ * wrong and what to do, in the reader's words rather than the platform's, and
+ * in the language of the `t` handed (English without one).
  */
-export declare function plain(e: unknown, repo: string, act: 'save' | 'start' | 'run'): string;
+export declare function plain(e: unknown, repo: string, act: 'save' | 'start' | 'run', t?: Say): string;
 export declare function environments(t: Target): Promise<Environment[]>;
 export declare function read(t: Target, repo: string): Promise<Environment>;
 export declare function save(t: Target, repo: string, scripts: {
@@ -58,8 +44,8 @@ export declare function save(t: Target, repo: string, scripts: {
 export declare function forget(t: Target, repo: string): Promise<void>;
 /** An environment variable name the run can export, and not one of its own. */
 export declare const NAME: RegExp;
-/** Why a secret name cannot be set, or '' when it can. */
-export declare function refuse(name: string): string;
+/** Why a secret name cannot be set, in the words of the `t` handed, or '' when it can. */
+export declare function refuse(name: string, t?: Say): string;
 export declare function setSecret(t: Target, repo: string, name: string, value: string): Promise<Environment>;
 export declare function removeSecret(t: Target, repo: string, name: string): Promise<Environment>;
 /**

package/lib/api/environment.js

@@ -14,7 +14,9 @@
  * here as `proposal` until someone saves it. Secrets are names only; their values
  * are sealed in KMS and reach the run's environment, never this record.
  */
-import { call, Refusal, seg } from './call.js';
+import { phrase } from '@hanzo/i18n';
+import { english } from '../say.js';
+import { call, Refusal, seg, told } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const obj = (v) => (v && typeof v === 'object' ? v : {});
 const names = (v) => (Array.isArray(v) ? v.filter((n) => typeof n === 'string' && n !== '') : []);
@@ -43,34 +45,35 @@ export function environment(raw, repo = '') {
 export const unset = (e) => e.state === 'none' && !e.updated;
 /**
  * What a refused save or setup run says to the person who pressed it: what is
- * wrong and what to do, in the reader's words rather than the platform's.
+ * wrong and what to do, in the reader's words rather than the platform's, and
+ * in the language of the `t` handed (English without one).
  */
-export function plain(e, repo, act) {
+export function plain(e, repo, act, t = english) {
     // This page's own refusals (a secret's name, an empty value) are already a reader's words.
     if (e instanceof Error && !(e instanceof Refusal) && e.name === 'Error' && e.message)
-        return e.message;
+        return told(e, t);
     if (e instanceof Refusal) {
         const why = e.message;
         if (e.status === 401)
-            return 'Your session ended. Sign in again, then try again.';
+            return t('Your session ended. Sign in again, then try again.');
         if (e.status === 403 && act === 'save')
-            return 'Only an organization admin saves an environment. Start the agent instead; an admin reviews what it proposes.';
+            return t('Only an organization admin saves an environment. Start the agent instead; an admin reviews what it proposes.');
         if (e.status === 402)
-            return 'This run needs a plan with runs left. See Plans to change it.';
+            return t('This run needs a plan with runs left. See Plans to change it.');
         if (e.status === 403)
-            return `This account cannot start a run on ${repo}. Ask an organization admin for access.`;
+            return t('This account cannot start a run on {repo}. Ask an organization admin for access.', { repo });
         if (e.status === 429)
-            return 'Too many runs are going right now. Try again in a minute.';
+            return t('Too many runs are going right now. Try again in a minute.');
         if (e.status >= 500)
-            return act === 'save' ? 'The environment store is not answering right now. Try again shortly.' : 'The code workspace is not answering right now. Try again shortly.';
+            return act === 'save' ? t('The environment store is not answering right now. Try again shortly.') : t('The code workspace is not answering right now. Try again shortly.');
         if (/no repository named|not one of this organization|is not a repository/.test(why))
-            return `${repo} is not a repository this organization has on the forge. Choose one of its repositories.`;
+            return t('{repo} is not a repository this organization has on the forge. Choose one of its repositories.', { repo });
         if (/no account on the forge|verify .* first|no forge identity/.test(why))
-            return 'Your forge account is not ready yet: sign in to the forge once, then try again.';
+            return t('Your forge account is not ready yet: sign in to the forge once, then try again.');
     }
     if (act === 'save')
-        return `The environment for ${repo} could not be saved. Try again.`;
-    return act === 'start' ? `The setup run on ${repo} could not start. Try again.` : `The run on ${repo} could not start. Try again.`;
+        return t('The environment for {repo} could not be saved. Try again.', { repo });
+    return act === 'start' ? t('The setup run on {repo} could not start. Try again.', { repo }) : t('The run on {repo} could not start. Try again.', { repo });
 }
 export async function environments(t) {
     const r = await call(t, 'GET', '/v1/environment');
@@ -88,13 +91,13 @@ export async function forget(t, repo) {
 /** An environment variable name the run can export, and not one of its own. */
 export const NAME = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
 const RESERVED = ['PATH', 'HOME', 'USER', 'SHELL', 'PWD', 'HOSTNAME', 'IFS', 'ENV', 'BASH_ENV'];
-/** Why a secret name cannot be set, or '' when it can. */
-export function refuse(name) {
+/** Why a secret name cannot be set, in the words of the `t` handed, or '' when it can. */
+export function refuse(name, t = english) {
     if (!NAME.test(name))
-        return `${name || 'That'} is not an environment variable name`;
+        return name ? t('{name} is not an environment variable name', { name }) : t('That is not an environment variable name');
     const up = name.toUpperCase();
     if (up.startsWith('HANZO_') || RESERVED.includes(up))
-        return `${name} is reserved for the run itself`;
+        return t('{name} is reserved for the run itself', { name });
     return '';
 }
 export async function setSecret(t, repo, name, value) {
@@ -102,7 +105,7 @@ export async function setSecret(t, repo, name, value) {
     if (why)
         throw new Error(why);
     if (!value)
-        throw new Error('A secret needs a value');
+        throw new Error(phrase('A secret needs a value'));
     return environment(await call(t, 'PUT', `/v1/environment/${seg(repo)}/secrets/${seg(name)}`, { value }), repo);
 }
 export async function removeSecret(t, repo, name) {

package/lib/api/github.d.ts

@@ -1,25 +1,3 @@
-/**
- * GitHub, as the platform's GitHub App sees it for the signed-in person.
- *
- *   GET  /v1/provider/github/repos?q=&owner=&limit=&after=           most recently pushed first
- *   GET  /v1/provider/github/repos/{owner}/{repo}/branches?q=&limit=&after=   default first
- *   GET  /v1/provider/github/user              the person's own connection
- *   POST /v1/provider/github/user/connect      {return} → {authorizeUrl}
- *   POST /v1/provider/github/user/complete     {grant} → the connection
- *   POST /v1/provider/github/user/disconnect
- *   GET  /v1/provider/github/installations     the accounts this org has bound the App on
- *   POST /v1/provider/github/issues/backfill   {state, repo?} → mirror GitHub issues onto the board
- *
- * Paged by an opaque `after` cursor; `next` is the cursor for the page after
- * this one, or empty on the last. Rows are read defensively: a field the
- * platform left out is an empty value here, never `undefined` in a label.
- *
- * `connected` false with repositories is an org admin seeing the org's
- * installations; false with none is the cue to connect. GitHub returns a
- * connecting person to the page the connect named as its return (a Hanzo app
- * page; the console's /connectors otherwise) with `?complete=github&grant=<id>`,
- * and that page completes it (`complete`, and `landed` in ../back.ts).
- */
 import { type Target } from './call.ts';
 export interface Repo {
     owner: string;

package/lib/api/github.js

@@ -20,6 +20,7 @@
  * page; the console's /connectors otherwise) with `?complete=github&grant=<id>`,
  * and that page completes it (`complete`, and `landed` in ../back.ts).
  */
+import { phrase } from '@hanzo/i18n';
 import { call, query, seg } from './call.js';
 import { codebases } from './codebases.js';
 import { links } from './links.js';
@@ -79,7 +80,7 @@ export async function connect(t, back) {
     const raw = obj(await call(t, 'POST', '/v1/provider/github/user/connect', back ? { return: back } : undefined));
     const url = str(raw.authorizeUrl);
     if (!/^https:\/\/github\.com\//.test(url))
-        throw new Error('The platform did not name a GitHub address to connect at');
+        throw new Error(phrase('The platform did not name a GitHub address to connect at'));
     return url;
 }
 /** Finish the connect GitHub's return handed this page as `grant`. */
@@ -177,7 +178,7 @@ export async function grants(t, signal) {
 export async function bring(t, repos) {
     const names = repos.map((n) => n.trim()).filter(Boolean);
     if (names.length === 0)
-        throw new Error('Choose a repository first');
+        throw new Error(phrase('Choose a repository first'));
     const raw = obj(await call(t, 'POST', '/v1/provider/github/repos/import', { repos: names }));
     const said = Array.isArray(raw.repos) ? raw.repos : [];
     const made = Array.isArray(raw.codebases) ? raw.codebases : [];

package/lib/api/keys.d.ts

@@ -1,17 +1,3 @@
-/**
- * A person's API keys, each its own credential: as many as they like, of either
- * type — secret (sk-, it belongs on a server) or publishable (pk-, safe in a
- * page's source).
- *
- *   GET    /v1/account/keys        {keys: [{id, name, type, prefix, key?, status, limit?, created, …}]}
- *   POST   /v1/account/keys        {name, type, limit?} → the key, its secret answered once
- *   DELETE /v1/account/keys/{id}   revoke exactly that one; it stays listed as revoked
- *
- * Creating a key never touches another. A secret key is answered once and by its
- * prefix after; a publishable key is public by construction and always comes back
- * whole. A limit only narrows what a key may reach — `model:zen5`,
- * `project:acme`, `product:train`, `read:*`.
- */
 import { type Target } from './call.ts';
 export declare const KINDS: readonly ['secret', 'publishable'];
 export type Kind = (typeof KINDS)[number];

package/lib/api/keys.js

@@ -12,7 +12,8 @@
  * whole. A limit only narrows what a key may reach — `model:zen5`,
  * `project:acme`, `product:train`, `read:*`.
  */
-import { call } from './call.js';
+import { phrase } from '@hanzo/i18n';
+import { call, Sentence } from './call.js';
 export const KINDS = ['secret', 'publishable'];
 const str = (v) => (typeof v === 'string' ? v : '');
 const list = (v) => (Array.isArray(v) ? v.filter((s) => typeof s === 'string' && s !== '') : []);
@@ -49,7 +50,7 @@ export function limits(raw) {
         .filter(Boolean);
     const bad = out.find((s) => !LIMIT.test(s));
     if (bad)
-        throw new Error(`${bad} is not a limit — write it as kind:name, like model:zen5`);
+        throw new Sentence(phrase('{limit} is not a limit — write it as kind:name, like model:zen5'), { limit: bad });
     return out;
 }
 /** Create a new key beside the ones held. The answer is the only time a secret key is shown. */
@@ -62,7 +63,7 @@ export async function mint(t, type, name = '', limit = []) {
     const r = await call(t, 'POST', '/v1/account/keys', body);
     const key = str(r?.key);
     if (!key)
-        throw new Error('The platform answered no key');
+        throw new Error(phrase('The platform answered no key'));
     return { id: str(r?.id), name: str(r?.name), type: kind(r?.type) ?? type, key, limit: list(r?.limit) };
 }
 /** Revoke exactly one key, by id. Every other key keeps working. */

package/lib/api/library.d.ts

@@ -1,21 +1,7 @@
-/**
- * The Library: everything a person made, in Chat, Dev, Studio and workflows, in
- * one index.
- *
- *   GET    /v1/library            {data: [item], next}   newest first, filtered
- *   GET    /v1/library/{id}       one item, with fresh signed URLs
- *   POST   /v1/library            keep one: its bytes as base64, at most 10 MiB
- *   PATCH  /v1/library/{id}       rename, share with the org, move to a project
- *   DELETE /v1/library/{id}       its row and its bytes
- *
- * An item is its owner's; another member of the org reads it only once its owner
- * shares it, and changes it never. Its `url`, `download` and `preview` are
- * signed and stop working at `expires`: read the item again for fresh ones.
- */
 import { type Target } from './call.ts';
 export declare const KIND_IDS: readonly ['image', 'video', 'audio', 'document', 'slides', 'type', 'model', 'code', 'file'];
 export type Kind = (typeof KIND_IDS)[number];
-/** The kinds a reader narrows to, in the order the Library lists them, '' being all. */
+/** The kinds a reader narrows to, in the order the Library lists them, '' being all; each label English and marked (`phrase`), drawn through `t`. */
 export declare const KINDS: readonly {
     id: Kind | '';
     label: string;
@@ -23,7 +9,7 @@ export declare const KINDS: readonly {
 export declare const SOURCES: readonly ['chat', 'dev', 'studio', 'workflow'];
 export type Source = (typeof SOURCES)[number];
 export type Scope = 'all' | 'mine' | 'shared';
-/** A product, as a person names it. */
+/** A product, as a person names it: Chat, Dev and Studio are names, and Workflow a word, marked (`phrase`). */
 export declare const SOURCE: Record<Source, string>;
 export interface Item {
     id: string;
@@ -117,7 +103,7 @@ export declare function change(t: Target, id: string, c: Change): Promise<Item>;
 export declare function remove(t: Target, id: string): Promise<void>;
 /** A size the way a person reads it. */
 export declare function size(bytes: number): string;
-/** The day an instant falls on, as a section of the Library: Today, Yesterday, then the month. */
+/** The day an instant falls on, as a section of the Library: Today, Yesterday (English, marked), then the month. */
 export declare function day(iso: string, now?: Date): string;
 /** Items under the day each was made, in the order given (newest first). */
 export declare function days(list: Item[], now?: Date): {

package/lib/api/library.js

@@ -12,23 +12,24 @@
  * shares it, and changes it never. Its `url`, `download` and `preview` are
  * signed and stop working at `expires`: read the item again for fresh ones.
  */
-import { call, query, seg } from './call.js';
+import { phrase } from '@hanzo/i18n';
+import { call, query, seg, Sentence } from './call.js';
 export const KIND_IDS = ['image', 'video', 'audio', 'document', 'slides', 'type', 'model', 'code', 'file'];
-/** The kinds a reader narrows to, in the order the Library lists them, '' being all. */
+/** The kinds a reader narrows to, in the order the Library lists them, '' being all; each label English and marked (`phrase`), drawn through `t`. */
 export const KINDS = [
-    { id: '', label: 'All' },
-    { id: 'image', label: 'Images' },
-    { id: 'video', label: 'Videos' },
-    { id: 'audio', label: 'Audio' },
-    { id: 'document', label: 'Documents' },
-    { id: 'slides', label: 'Slides' },
-    { id: 'model', label: '3D' },
-    { id: 'code', label: 'Code' },
-    { id: 'file', label: 'Files' },
+    { id: '', label: phrase('All') },
+    { id: 'image', label: phrase('Images') },
+    { id: 'video', label: phrase('Videos') },
+    { id: 'audio', label: phrase('Audio') },
+    { id: 'document', label: phrase('Documents') },
+    { id: 'slides', label: phrase('Slides') },
+    { id: 'model', label: phrase('3D') },
+    { id: 'code', label: phrase('Code') },
+    { id: 'file', label: phrase('Files') },
 ];
 export const SOURCES = ['chat', 'dev', 'studio', 'workflow'];
-/** A product, as a person names it. */
-export const SOURCE = { chat: 'Chat', dev: 'Dev', studio: 'Studio', workflow: 'Workflow' };
+/** A product, as a person names it: Chat, Dev and Studio are names, and Workflow a word, marked (`phrase`). */
+export const SOURCE = { chat: 'Chat', dev: 'Dev', studio: 'Studio', workflow: phrase('Workflow') };
 const str = (v) => (typeof v === 'string' ? v : '');
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : 0);
 const obj = (v) => (v && typeof v === 'object' ? v : {});
@@ -91,7 +92,7 @@ export async function items(t, f = {}, init) {
 export async function get(t, id) {
     const x = item(await call(t, 'GET', `/v1/library/${seg(id)}`));
     if (!x)
-        throw new Error('The item came back without an id');
+        throw new Error(phrase('The item came back without an id'));
     return x;
 }
 /** The largest thing one upload carries. */
@@ -106,9 +107,9 @@ export function base64(bytes) {
 /** Keep a file in the Library. */
 export async function upload(t, file, made) {
     if (!file.bytes.length)
-        throw new Error(`${file.name} is empty`);
+        throw new Sentence(phrase('{name} is empty'), { name: file.name });
     if (file.bytes.length > INLINE)
-        throw new Error(`${file.name} is larger than 10 MB`);
+        throw new Sentence(phrase('{name} is larger than 10 MB'), { name: file.name });
     const x = item(await call(t, 'POST', '/v1/library', {
         name: file.name,
         mime: file.type || 'application/octet-stream',
@@ -116,13 +117,13 @@ export async function upload(t, file, made) {
         ...made,
     }));
     if (!x)
-        throw new Error('The item was kept and came back without an id');
+        throw new Error(phrase('The item was kept and came back without an id'));
     return x;
 }
 export async function change(t, id, c) {
     const x = item(await call(t, 'PATCH', `/v1/library/${seg(id)}`, c));
     if (!x)
-        throw new Error('The item was changed and came back without an id');
+        throw new Error(phrase('The item was changed and came back without an id'));
     return x;
 }
 export async function remove(t, id) {
@@ -141,17 +142,17 @@ export function size(bytes) {
     }
     return `${n < 10 ? n.toFixed(1) : Math.round(n)} ${units[u]}`;
 }
-/** The day an instant falls on, as a section of the Library: Today, Yesterday, then the month. */
+/** The day an instant falls on, as a section of the Library: Today, Yesterday (English, marked), then the month. */
 export function day(iso, now = new Date()) {
     const d = new Date(iso);
     if (Number.isNaN(d.getTime()))
-        return 'Earlier';
+        return phrase('Earlier');
     const start = (x) => new Date(x.getFullYear(), x.getMonth(), x.getDate()).getTime();
     const days = Math.round((start(now) - start(d)) / 86_400_000);
     if (days <= 0)
-        return 'Today';
+        return phrase('Today');
     if (days === 1)
-        return 'Yesterday';
+        return phrase('Yesterday');
     return d.toLocaleDateString(undefined, d.getFullYear() === now.getFullYear() ? { month: 'long' } : { month: 'long', year: 'numeric' });
 }
 /** Items under the day each was made, in the order given (newest first). */

package/lib/api/links.d.ts

@@ -12,7 +12,7 @@
  * `conflict`, `pending` (not on the forge yet) or `paused` — and is absent when
  * the forge could not be read, which is not reported as healthy.
  *
- * Every link the sync app holds is also a row of GET /v1/projects (apps/sync
+ * Every link the sync app holds is also a row of GET /v1/project (apps/sync
  * project.go), so this list is the org's linked projects and not a copy of them.
  */
 import { type Target } from './call.ts';

package/lib/api/links.js

@@ -12,7 +12,7 @@
  * `conflict`, `pending` (not on the forge yet) or `paused` — and is absent when
  * the forge could not be read, which is not reported as healthy.
  *
- * Every link the sync app holds is also a row of GET /v1/projects (apps/sync
+ * Every link the sync app holds is also a row of GET /v1/project (apps/sync
  * project.go), so this list is the org's linked projects and not a copy of them.
  */
 import { call } from './call.js';

package/lib/api/machines.d.ts

@@ -1,18 +1,3 @@
-/**
- * The org's machines: its own computers a run can be sent to, beside the sandbox.
- *
- *   GET    /v1/agent/targets            {targets: [...]}, newest first
- *   POST   /v1/agent/targets            register one by hand {label, kind, host}
- *   PATCH  /v1/agent/targets/{id}       rename it, drain it, bring it back
- *   DELETE /v1/agent/targets/{id}       deregister it
- *   POST   /v1/agent/targets/{id}/key   mint or rotate its claim key, answered once
- *
- * A machine belongs to the member who registered it. Only that member or an org
- * admin changes, removes or keys it, and the platform answers anyone else the
- * same 404 an unknown id gets — the record names no owner — so a 404 here is
- * said as that rule. `hanzo link`, run on the machine, registers it under its
- * hostname and keeps it online while it runs.
- */
 import { type Target } from './call.ts';
 export declare const KINDS: readonly ['laptop', 'gpu', 'cloud', 'cluster', 'machine'];
 export type Kind = (typeof KINDS)[number];

package/lib/api/machines.js

@@ -13,6 +13,7 @@
  * said as that rule. `hanzo link`, run on the machine, registers it under its
  * hostname and keeps it online while it runs.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, Refusal, seg } from './call.js';
 export const KINDS = ['laptop', 'gpu', 'cloud', 'cluster', 'machine'];
 const str = (v) => (typeof v === 'string' ? v : '');
@@ -142,7 +143,7 @@ async function owned(p) {
     }
     catch (e) {
         if (e instanceof Refusal && e.status === 404)
-            throw new Refusal(404, 'This machine is gone, or not yours to change: only the member who linked it, or an org admin, can.');
+            throw new Refusal(404, phrase('This machine is gone, or not yours to change: only the member who linked it, or an org admin, can.'));
         throw e;
     }
 }
@@ -154,7 +155,7 @@ export async function add(t, what) {
     const host = (what.host ?? '').trim();
     const label = what.label.trim() || host;
     if (!label)
-        throw new Error('A machine needs a name or a hostname');
+        throw new Error(phrase('A machine needs a name or a hostname'));
     const body = { label, kind: what.kind };
     if (host)
         body.host = host;
@@ -168,7 +169,7 @@ export async function add(t, what) {
  * once one has; before that it is `not seen yet`, and nothing is there to take a run.
  */
 export function state(m) {
-    return m.status === 'online' && !m.seen ? 'not seen yet' : m.status;
+    return m.status === 'online' && !m.seen ? phrase('not seen yet') : m.status;
 }
 /** Rename a machine, or drain it (`draining`) and bring it back (`online`). */
 export async function change(t, id, what) {
@@ -176,7 +177,7 @@ export async function change(t, id, what) {
     if (what.label !== undefined) {
         const label = what.label.trim();
         if (!label)
-            throw new Error('A machine needs a name');
+            throw new Error(phrase('A machine needs a name'));
         body.label = label;
     }
     if (what.status !== undefined)
@@ -201,6 +202,6 @@ export async function key(t, id) {
     const r = await owned(call(t, 'POST', `/v1/agent/targets/${seg(id)}/key`));
     const k = str(r?.claimKey);
     if (!k)
-        throw new Error('The platform answered no key');
+        throw new Error(phrase('The platform answered no key'));
     return k;
 }

package/lib/api/mcp.d.ts

@@ -1,12 +1,3 @@
-/**
- * The fleet's native MCP servers, as the MCP server itself lists them.
- *
- *   POST /v1/mcp  {"method":"tools/list"} → {result:{tools:[…]}}
- *
- * One tool is one native server. Its operations are the names in `op`. A run
- * starts a server the first time it calls it; the server stays up afterwards.
- * `describe` is how a caller reads one operation's schema, so it is not a server.
- */
 import { type Target } from './call.ts';
 export interface Native {
     name: string;

package/lib/api/mcp.js

@@ -7,6 +7,7 @@
  * starts a server the first time it calls it; the server stays up afterwards.
  * `describe` is how a caller reads one operation's schema, so it is not a server.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, Refusal } from './call.js';
 const words = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string' && x !== '') : []);
 /** The servers in one tools/list answer. A missing tool array is a refusal. */
@@ -15,12 +16,12 @@ export function nativesOf(body) {
     const err = root.error;
     if (err && typeof err === 'object') {
         const message = err.message;
-        throw new Refusal(200, typeof message === 'string' && message ? message : 'The MCP server refused the list');
+        throw new Refusal(200, typeof message === 'string' && message ? message : phrase('The MCP server refused the list'));
     }
     const result = root.result && typeof root.result === 'object' ? root.result : null;
     const tools = result && Array.isArray(result.tools) ? result.tools : null;
     if (!tools)
-        throw new Refusal(502, 'The MCP server did not list its tools');
+        throw new Refusal(502, phrase('The MCP server did not list its tools'));
     const out = [];
     for (const raw of tools) {
         if (!raw || typeof raw !== 'object')

package/lib/api/members.d.ts

@@ -1,18 +1,3 @@
-/**
- * Who is in the organization, and who has been asked to join it, as Hanzo IAM
- * holds them.
- *
- *   GET    /v1/iam/memberships?org=              the roster: {status, data: [membership], data2: count}
- *   GET    /v1/iam/invitations?owner=            {invitations, total} (org admin)
- *   POST   /v1/iam/invitations                   issue one (org admin)
- *   DELETE /v1/iam/invitations/{owner}/{name}    withdraw one (org admin)
- *   GET    /v1/iam/organizations/admin/{org}     the org's record, whose `logo` is its mark (member)
- *
- * IAM decides the scope from the credential: a member reads the roster of an org
- * they belong to, and only an admin of the org reads or writes its invitations.
- * An invitation is a code IAM redeems when someone signs up with it; IAM sends
- * no email of its own.
- */
 import { type Target } from './call.ts';
 export type Role = 'owner' | 'admin' | 'member';
 export interface Member {