@hanzo/build 0.2.79 → 0.2.81

package/lib/api/call.d.ts

@@ -1,11 +1,4 @@
-/**
- * One request path to the platform.
- *
- * Every typed op below goes through `call`, so the bearer, the org scope, the
- * no-store cache rule and the reading of a refusal are decided once. The
- * platform answers a refusal as RFC 9457 problem details; older handlers still
- * answer `{error:{message}}` or `{msg}`, and all three read the same way here.
- */
+import type { Say } from '@hanzo/i18n/react';
 /** Where the platform is and who is asking. The host supplies it. */
 export interface Target {
     /** The platform origin, no trailing slash: calls are `${api}/v1/…`. */
@@ -20,6 +13,21 @@ export declare class Refusal extends Error {
     readonly status: number;
     constructor(status: number, message: string);
 }
+/**
+ * A sentence this client wrote with something of the moment in it (a file's
+ * name, an address), thrown where no `t` is at hand: its message is the
+ * English, filled, and a screen says it from its source and values.
+ */
+export declare class Sentence extends Error {
+    readonly source: string;
+    readonly values: Readonly<Record<string, string | number>>;
+    constructor(source: string, values?: Readonly<Record<string, string | number>>);
+}
+/**
+ * An error's own sentence, as the screen that caught it says it: one this
+ * client wrote, in the reader's language; the platform's, which is no key, as given.
+ */
+export declare function told(e: unknown, t?: Say): string;
 export type Query = Record<string, string | number | boolean | null | undefined>;
 /** `?a=1&b=2` from the defined, non-empty entries of `q`, or ''. */
 export declare function query(q?: Query): string;

package/lib/api/call.js

@@ -5,7 +5,15 @@
  * no-store cache rule and the reading of a refusal are decided once. The
  * platform answers a refusal as RFC 9457 problem details; older handlers still
  * answer `{error:{message}}` or `{msg}`, and all three read the same way here.
+ *
+ * A sentence this client writes is English, marked (`phrase`) for the
+ * translator: a module is not a component and asks no `t`, so a screen says
+ * what a module threw through its own (`told`), and a module that builds text
+ * takes the screen's `t` as its last argument, English (../say.ts `english`)
+ * when none is handed.
  */
+import { phrase, translate } from '@hanzo/i18n';
+import { english } from '../say.js';
 /** A refusal: the status, and the platform's own sentence for it. */
 export class Refusal extends Error {
     status;
@@ -15,6 +23,29 @@ export class Refusal extends Error {
         this.name = 'Refusal';
     }
 }
+/**
+ * A sentence this client wrote with something of the moment in it (a file's
+ * name, an address), thrown where no `t` is at hand: its message is the
+ * English, filled, and a screen says it from its source and values.
+ */
+export class Sentence extends Error {
+    source;
+    values;
+    constructor(source, values = {}) {
+        super(translate({}, source, values));
+        this.source = source;
+        this.values = values;
+    }
+}
+/**
+ * An error's own sentence, as the screen that caught it says it: one this
+ * client wrote, in the reader's language; the platform's, which is no key, as given.
+ */
+export function told(e, t = english) {
+    if (e instanceof Sentence)
+        return t(e.source, e.values);
+    return t(e instanceof Error ? e.message : String(e));
+}
 /** `?a=1&b=2` from the defined, non-empty entries of `q`, or ''. */
 export function query(q = {}) {
     const s = new URLSearchParams();
@@ -81,6 +112,6 @@ export async function call(t, method, path, body, init) {
 export function unwrap(raw) {
     const r = (raw && typeof raw === 'object' ? raw : {});
     if (r.status === 'error')
-        throw new Refusal(400, typeof r.msg === 'string' && r.msg ? r.msg : 'The platform refused that');
+        throw new Refusal(400, typeof r.msg === 'string' && r.msg ? r.msg : phrase('The platform refused that'));
     return r.data;
 }

package/lib/api/capabilities.d.ts

@@ -1,14 +1,3 @@
-/**
- * What the agent may use: every tool the org can reach, and which of them are
- * switched on.
- *
- *   GET /v1/tool → {tools: [{name, source, description, dispatchable, activated}]}
- *   PUT /v1/tool/activation  {activate: [], deactivate: []} → {enabled: []}
- *
- * Activation is per org (and project): a tool that is off is listed but
- * refused when an agent calls it. At most 256 names go in one request, so a
- * larger change is sent in turns.
- */
 import { type Target } from './call.ts';
 /** Where a tool comes from, in the order the platform ranks them. */
 export declare const SOURCES: readonly ['connector', 'function', 'zap-service', 'agent', 'skill', 'mcp'];

package/lib/api/capabilities.js

@@ -9,6 +9,7 @@
  * refused when an agent calls it. At most 256 names go in one request, so a
  * larger change is sent in turns.
  */
+import { phrase } from '@hanzo/i18n';
 import { call } from './call.js';
 /** Where a tool comes from, in the order the platform ranks them. */
 export const SOURCES = ['connector', 'function', 'zap-service', 'agent', 'skill', 'mcp'];
@@ -29,7 +30,7 @@ export async function tools(t) {
 /** Switch every tool in `names` on (or off), and answer the org's activated set. */
 export async function activate(t, names, on) {
     if (!names.length)
-        throw new Error('There is nothing to switch');
+        throw new Error(phrase('There is nothing to switch'));
     let enabled = [];
     for (let i = 0; i < names.length; i += BATCH) {
         const part = names.slice(i, i + BATCH);

package/lib/api/codebases.d.ts

@@ -1,13 +1,3 @@
-/**
- * Codebases on the forge, the org's own git.
- *
- *   GET /v1/git/repos          {data: [repo]}   most recently updated first
- *   GET /v1/git/repos/{name}   one repo, with its branch names
- *
- * A coding run addresses a repository by its name. The org is the tenant on
- * the request, so the name is the whole address — `owner/name` is a path the
- * engine refuses.
- */
 import { type Target } from './call.ts';
 export interface Codebase {
     org: string;

package/lib/api/codebases.js

@@ -8,6 +8,7 @@
  * the request, so the name is the whole address — `owner/name` is a path the
  * engine refuses.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, seg } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const obj = (v) => v && typeof v === 'object' ? v : {};
@@ -69,11 +70,11 @@ const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 export async function create(t, name, description = '') {
     const handle = name.trim().replace(/\.git$/, '');
     if (!NAME.test(handle))
-        throw new Error('A repository name starts with a letter or number, and may contain letters, numbers, dots, underscores and hyphens.');
+        throw new Error(phrase('A repository name starts with a letter or number, and may contain letters, numbers, dots, underscores and hyphens.'));
     const raw = await call(t, 'POST', '/v1/git/repos', { name: handle, description: description.trim() });
     const row = codebase(raw, t.org ?? '');
     if (!row)
-        throw new Error('The forge created a repository and did not name it');
+        throw new Error(phrase('The forge created a repository and did not name it'));
     return row;
 }
 export async function codebases(t, q = '') {

package/lib/api/coding.d.ts

@@ -1,37 +1,8 @@
-/**
- * Starting a coding run, and what it left.
- *
- *   POST /v1/agent/coding → 202 {sessionId, repo, branch, routed, targetId}
- *   GET  /v1/agent/coding/{session}/artifacts          {session, saved, artifacts}
- *   GET  /v1/agent/coding/{session}/artifacts/{name}   one stored artifact's bytes
- *
- * 202 is ADMITTED, not finished: the answer is the session the run narrates
- * itself in, and the session stream is how it is watched.
- *
- * Where it runs is one field. No `targetId` is the platform's sandbox; a target
- * id routes it to one of the org's machines, and `routed` says whether it got
- * there.
- *
- * `mode` is what the run may do: `build` edits, commits and pushes its branch;
- * `plan` reads the repository with a credential that can only read and answers
- * with a plan, as its final status. A plan runs in the platform's sandbox only —
- * a claimed machine clones and pushes with its own credential — so a plan
- * routed to one is refused, here before sending as on the platform.
- *
- * `model` and `effort` are taken by the dev harness the builder runs (and by
- * codex); the builder names no other harness, so they are always honoured.
- *
- * `setup` is a plan's shape put to one question: how this codebase is installed,
- * started and checked. Its agent may install and run things in its sandbox, and
- * its answer is kept as the codebase's proposed environment (environment.ts).
- *
- * 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 type { Say } from '@hanzo/i18n/react';
 import { type Target } from './call.ts';
 export type Mode = 'build' | 'plan' | 'setup';
-/** Why this mode cannot run where it is sent, or '' when it can. */
-export declare const unhonoured: (mode: Mode | undefined, target?: string) => string;
+/** Why this mode cannot run where it is sent, in the words of the `t` handed (English without one), or '' when it can. */
+export declare const unhonoured: (mode: Mode | undefined, target?: string, t?: Say) => string;
 export interface Ask {
     /** The task, in the words you would use with a colleague. */
     prompt: string;

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): {