@hanzo/build 0.2.79 → 0.2.81

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/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 {

package/lib/api/members.js

@@ -13,7 +13,8 @@
  * An invitation is a code IAM redeems when someone signs up with it; IAM sends
  * no email of its own.
  */
-import { call, query, seg } from './call.js';
+import { phrase } from '@hanzo/i18n';
+import { call, query, seg, Sentence } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
 const obj = (v) => (v && typeof v === 'object' ? v : {});
@@ -34,7 +35,7 @@ export function member(raw) {
 export async function roster(t, org) {
     const raw = obj(await call(t, 'GET', `/v1/iam/memberships${query({ org })}`));
     if (raw.status === 'error')
-        throw new Error(str(raw.msg) || 'IAM refused the roster');
+        throw new Error(str(raw.msg) || phrase('IAM refused the roster'));
     const rank = (r) => ROLES.indexOf(r);
     return arr(raw.data)
         .map(obj)
@@ -71,7 +72,7 @@ function hex(bytes) {
 export async function invite(t, org, email) {
     const address = email.trim().toLowerCase();
     if (!EMAIL.test(address))
-        throw new Error(`${email.trim() || 'That'} is not an email address`);
+        throw email.trim() ? new Sentence(phrase('{email} is not an email address'), { email: email.trim() }) : new Error(phrase('That is not an email address'));
     const local = address.slice(0, address.indexOf('@')).replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24);
     return invitation(await call(t, 'POST', '/v1/iam/invitations', {
         owner: org,

package/lib/api/memory.d.ts

@@ -1,14 +1,3 @@
-/**
- * What Hanzo remembers about the signed-in person, in the org they act in.
- *
- *   GET  /v1/ai/memory/list?limit=  {status, data: [memory]}, newest first
- *   POST /v1/ai/memory/remember     {content} → {status, data: memory}
- *   POST /v1/ai/memory/delete       {id: "<owner>/<name>"}
- *
- * The platform keys every memory on the validated caller and org, never on the
- * request, so these read and change the caller's own and nobody else's. A
- * refusal arrives in the envelope, usually under a 200.
- */
 import { type Target } from './call.ts';
 export interface Memory {
     /** `<owner>/<name>`, what a delete names. */

package/lib/api/memory.js

@@ -9,6 +9,7 @@
  * request, so these read and change the caller's own and nobody else's. A
  * refusal arrives in the envelope, usually under a 200.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, query, unwrap } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 export function memoryOf(raw) {
@@ -26,7 +27,7 @@ export async function memories(t, limit = 100) {
 export async function remember(t, content) {
     const said = content.trim();
     if (!said)
-        throw new Error('Say what Hanzo should remember');
+        throw new Error(phrase('Say what Hanzo should remember'));
     return memoryOf(unwrap(await call(t, 'POST', '/v1/ai/memory/remember', { content: said })));
 }
 export async function forget(t, id) {

package/lib/api/places.d.ts

@@ -1,12 +1,3 @@
-/**
- * Where a run can run: the platform's sandbox, or one of the org's machines.
- *
- *   GET /v1/agent/targets → {targets: [...]}, newest first (machines.ts)
- *
- * The sandbox is not a row the platform lists — it is what a run gets when it
- * names no target — so it is the first place here and carries no id. A machine
- * can take a run only while it is online.
- */
 import type { Target } from './call.ts';
 export interface Place {
     /** `tgt_…`, or '' for the sandbox. */
@@ -19,6 +10,7 @@ export interface Place {
     /** "10 vCPU / 122G / 1× GB10", when the machine reported one. */
     capacity: string;
 }
+/** The sandbox, named in English and marked (`phrase`): a screen draws its label through `t`. */
 export declare const SANDBOX: Place;
 export declare function places(t: Target): Promise<Place[]>;
 /** Whether a run sent here now would be taken. */

package/lib/api/places.js

@@ -1,5 +1,16 @@
+/**
+ * Where a run can run: the platform's sandbox, or one of the org's machines.
+ *
+ *   GET /v1/agent/targets → {targets: [...]}, newest first (machines.ts)
+ *
+ * The sandbox is not a row the platform lists — it is what a run gets when it
+ * names no target — so it is the first place here and carries no id. A machine
+ * can take a run only while it is online.
+ */
+import { phrase } from '@hanzo/i18n';
 import { machines, state } from './machines.js';
-export const SANDBOX = { id: '', label: 'Hanzo sandbox', kind: 'sandbox', status: 'online', capacity: '' };
+/** The sandbox, named in English and marked (`phrase`): a screen draws its label through `t`. */
+export const SANDBOX = { id: '', label: phrase('Hanzo sandbox'), kind: 'sandbox', status: 'online', capacity: '' };
 export async function places(t) {
     const list = await machines(t);
     return [SANDBOX, ...list.map((m) => ({ id: m.id, label: m.label, kind: m.kind, status: state(m), capacity: m.capacity }))];

package/lib/api/plugins.d.ts

@@ -1,18 +1,3 @@
-/**
- * Plugins: TypeScript connectors an org builds, and what this deployment mounts.
- *
- *   GET    /v1/tool/plugins/authored        {plugins: [plugin]}, newest first, each with its source
- *   POST   /v1/tool/plugins/build           {name, provider?, source | spec} → 201 {bytes, generated, plugin}
- *   DELETE /v1/tool/plugins/authored/{id}   {deleted}
- *   GET    /v1/tool/plugins                 {plugins: [{name, enabled, prefixes}]}
- *
- * Building is the gate: the platform bundles the source and compiles it in the
- * runtime that will run it, and keeps it only if both succeed — a failure is a
- * 422 whose reason is the bundler's. A spec (an OpenAPI document or prose) has a
- * model write the source, which comes back to be read. A plugin never carries a
- * credential: it names the connectors provider whose credential it reads when it
- * runs. The mounted list is the deployment's own subsystems, read-only.
- */
 import { type Target } from './call.ts';
 export interface Plugin {
     /** What a delete addresses. */
@@ -49,7 +34,7 @@ export interface Build {
     source: string;
     spec: string;
 }
-/** Why a plugin cannot be built as it stands, or '' when it can. */
+/** Why a plugin cannot be built as it stands, or '' when it can. English, marked (`phrase`): a screen says it through `t`. */
 export declare function refuse(b: Build): string;
 export declare function build(t: Target, b: Build): Promise<Built>;
 export declare function remove(t: Target, id: string): Promise<void>;

package/lib/api/plugins.js

@@ -13,6 +13,7 @@
  * credential: it names the connectors provider whose credential it reads when it
  * runs. The mounted list is the deployment's own subsystems, read-only.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, seg } from './call.js';
 /** A plugin's name: one lowercase path segment, the id it runs by. */
 export const NAME = /^[a-z0-9][a-z0-9_-]{0,63}$/;
@@ -35,12 +36,12 @@ export async function mounted(t) {
     })
         .filter((m) => m.name);
 }
-/** Why a plugin cannot be built as it stands, or '' when it can. */
+/** Why a plugin cannot be built as it stands, or '' when it can. English, marked (`phrase`): a screen says it through `t`. */
 export function refuse(b) {
     if (!NAME.test(b.name))
-        return 'A name is one lowercase word: letters, digits, _ or -';
+        return phrase('A name is one lowercase word: letters, digits, _ or -');
     if (!b.source.trim() === !b.spec.trim())
-        return 'Give the TypeScript or the API it calls, one of the two';
+        return phrase('Give the TypeScript or the API it calls, one of the two');
     return '';
 }
 export async function build(t, b) {

package/lib/api/profile.d.ts

@@ -1,13 +1,3 @@
-/**
- * The signed-in person's own profile on Hanzo IAM: the name they are shown by
- * and their photo.
- *
- *   PUT  /v1/iam/account  {displayName} → {status, data: {owner, name, displayName, avatar, …}}
- *   POST /v1/account/avatar  multipart `file` → {avatar}   the photo, also written to IAM
- *
- * Both act on the caller alone: neither request names a person. The email is a
- * sign-in identifier and changes only through IAM's verification, never here.
- */
 import { type Target } from './call.ts';
 export interface Profile {
     displayName: string;

package/lib/api/profile.js

@@ -8,6 +8,7 @@
  * Both act on the caller alone: neither request names a person. The email is a
  * sign-in identifier and changes only through IAM's verification, never here.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, headers, reason, Refusal, unwrap } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const obj = (v) => (v && typeof v === 'object' ? v : {});
@@ -15,7 +16,7 @@ const obj = (v) => (v && typeof v === 'object' ? v : {});
 export async function rename(t, name) {
     const displayName = name.trim();
     if (!displayName)
-        throw new Error('A name cannot be empty');
+        throw new Error(phrase('A name cannot be empty'));
     const p = obj(unwrap(await call(t, 'PUT', '/v1/iam/account', { displayName })));
     return { displayName: str(p.displayName), avatar: str(p.avatar) };
 }
@@ -25,9 +26,9 @@ const LIMIT = 8 << 20;
 /** Store a new photo and answer its address. */
 export async function photo(t, file) {
     if (!file.size)
-        throw new Error('That file is empty');
+        throw new Error(phrase('That file is empty'));
     if (file.size > LIMIT)
-        throw new Error('A photo is at most 8 MB');
+        throw new Error(phrase('A photo is at most 8 MB'));
     const form = new FormData();
     form.append('file', file);
     const res = await fetch(`${t.api}/v1/account/avatar`, { method: 'POST', headers: headers(t), body: form, cache: 'no-store' });
@@ -35,6 +36,6 @@ export async function photo(t, file) {
         throw new Refusal(res.status, (await reason(res)) || `POST /v1/account/avatar answered ${res.status}`);
     const url = str(obj(await res.json()).avatar);
     if (!url.startsWith('https://'))
-        throw new Refusal(502, 'The photo was stored without an address this page can show');
+        throw new Refusal(502, phrase('The photo was stored without an address this page can show'));
     return url;
 }

package/lib/api/projects.d.ts

@@ -1,17 +1,3 @@
-/**
- * The org's projects: what it has built, and where each one is served.
- *
- *   GET    /v1/projects                     → Project[]
- *   PATCH  /v1/projects/{slug}              rename it, or make it public or private
- *   DELETE /v1/projects/{slug}              delete it and take its site down
- *   GET    /v1/projects/{slug}/deployments  → Deployment[], newest first
- *
- * `slug` is the one key every surface shares — the address under /dev, the
- * site's name, the `project` a run is tagged with. A project belongs to the org,
- * not to a person: the record names no author, so any member lists, changes and
- * deletes it. Private is paid, and an unfunded org is refused rather than left
- * public without being told.
- */
 import { type Target } from './call.ts';
 export interface Project {
     slug: string;

package/lib/api/projects.js

@@ -12,6 +12,7 @@
  * deletes it. Private is paid, and an unfunded org is refused rather than left
  * public without being told.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, seg } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
@@ -64,7 +65,7 @@ export async function change(t, slug, what) {
     if (what.name !== undefined) {
         const n = what.name.trim();
         if (!n)
-            throw new Error('A project needs a name');
+            throw new Error(phrase('A project needs a name'));
         body.name = n;
     }
     if (what.visibility !== undefined)

package/lib/api/provider.d.ts

@@ -1,16 +1,3 @@
-/**
- * The organization's connectors: a Slack workspace, the GitHub accounts the
- * platform's GitHub App is installed on, and the social accounts automations
- * post to.
- *
- *   GET  /v1/provider/{id}              one connector and this org's connection to it
- *   POST /v1/provider/{id}/connect      {return} → {authorizeUrl}: the provider's own consent page (org admin)
- *   POST /v1/provider/{id}/disconnect   forget the org's connection (org admin)
- *   GET  /v1/provider/slack/channels    the connected workspace's channels, a page at a time
- *
- * Connecting leaves this page once, for the provider's consent screen, and only
- * for that provider's own host.
- */
 import { type Target } from './call.ts';
 export interface Connector {
     id: string;
@@ -30,7 +17,8 @@ export declare function read(t: Target, id: string): Promise<Connector>;
  * The social accounts an organization connects. An automation posts text to
  * the ones that take it; Instagram and TikTok take only images and video, and
  * say so. `needs` is what connecting waits on while Hanzo's app with the
- * platform is not set up.
+ * platform is not set up. Its sentences are English and marked (`phrase`):
+ * a screen draws them through `t`.
  */
 export declare const SOCIAL: readonly {
     id: string;

package/lib/api/provider.js

@@ -11,7 +11,8 @@
  * Connecting leaves this page once, for the provider's consent screen, and only
  * for that provider's own host.
  */
-import { call, query, seg } from './call.js';
+import { phrase } from '@hanzo/i18n';
+import { call, query, seg, Sentence } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
 const obj = (v) => (v && typeof v === 'object' ? v : {});
 const arr = (v) => (Array.isArray(v) ? v : []);
@@ -45,25 +46,26 @@ const CONSENT = {
  * The social accounts an organization connects. An automation posts text to
  * the ones that take it; Instagram and TikTok take only images and video, and
  * say so. `needs` is what connecting waits on while Hanzo's app with the
- * platform is not set up.
+ * platform is not set up. Its sentences are English and marked (`phrase`):
+ * a screen draws them through `t`.
  */
 export const SOCIAL = [
-    { id: 'x', name: 'X', posts: true, needs: 'X posting needs Hanzo’s X developer app with paid API access; it is not set up yet.' },
-    { id: 'linkedin', name: 'LinkedIn', posts: true, needs: 'LinkedIn posting needs Hanzo’s LinkedIn app with Share on LinkedIn; it is not set up yet.' },
-    { id: 'facebook', name: 'Facebook', posts: true, needs: 'Facebook Page posting needs Hanzo’s Meta app, approved by Meta App Review to publish to Pages; it is not set up yet.' },
+    { id: 'x', name: 'X', posts: true, needs: phrase('X posting needs Hanzo’s X developer app with paid API access; it is not set up yet.') },
+    { id: 'linkedin', name: 'LinkedIn', posts: true, needs: phrase('LinkedIn posting needs Hanzo’s LinkedIn app with Share on LinkedIn; it is not set up yet.') },
+    { id: 'facebook', name: 'Facebook', posts: true, needs: phrase('Facebook Page posting needs Hanzo’s Meta app, approved by Meta App Review to publish to Pages; it is not set up yet.') },
     {
         id: 'instagram',
         name: 'Instagram',
         posts: false,
-        needs: 'Instagram posting needs Hanzo’s Meta app, approved by Meta App Review; it is not set up yet.',
-        takes: 'Instagram takes photos and reels, not text, so automations do not post to it.',
+        needs: phrase('Instagram posting needs Hanzo’s Meta app, approved by Meta App Review; it is not set up yet.'),
+        takes: phrase('Instagram takes photos and reels, not text, so automations do not post to it.'),
     },
     {
         id: 'tiktok',
         name: 'TikTok',
         posts: false,
-        needs: 'TikTok posting needs TikTok’s audit of Hanzo’s app; it is not set up yet.',
-        takes: 'TikTok takes videos and photos, not text, so automations do not post to it.',
+        needs: phrase('TikTok posting needs TikTok’s audit of Hanzo’s app; it is not set up yet.'),
+        takes: phrase('TikTok takes videos and photos, not text, so automations do not post to it.'),
     },
 ];
 /** The provider's consent page for this org; its return lands on `back` when that is a Hanzo app page. */
@@ -71,7 +73,7 @@ export async function authorize(t, id, back) {
     const url = str(obj(await call(t, 'POST', `/v1/provider/${seg(id)}/connect`, back ? { return: back } : {})).authorizeUrl);
     const host = CONSENT[id];
     if (!host || !host.test(url))
-        throw new Error(`The platform did not name a ${id} address to connect at`);
+        throw new Sentence(phrase('The platform did not name a {provider} address to connect at'), { provider: id });
     return url;
 }
 export async function disconnect(t, id) {

package/lib/api/sandbox.d.ts

@@ -1,20 +1,3 @@
-/**
- * A run's sandbox. It outlives the run: kept after the run ends, parked (its pod
- * stopped, its disk and working tree kept) while nobody watches, and retired a
- * day after it parks; a free plan's sandbox is not parked, and ends within the
- * hour. Resume gives a parked one a pod again under the same id and tree.
- *
- *   GET  /v1/sandbox/{id}                              its status and when its lease ends
- *   POST /v1/sandbox/{id}/pause                        park it: stop the pod, keep the disk
- *   POST /v1/sandbox/{id}/resume                       a pod again, same id and /work
- *   POST /v1/sandbox/{id}/{screen|terminal}/ticket     one ticket, spent when the page's socket opens (30 s)
- *   GET  /v1/sandbox/{id}/ports                        what listens in it, each with its preview host
- *   POST /v1/sandbox/{id}/preview {port}               an address that opens that port in a browser
- *   POST /v1/sandbox/read {id, path}                   a directory's names, or a file's bytes
- *
- * A door or a preview asked of a sandbox that stopped as it was asked is 409: it
- * is resumed, and asked again once.
- */
 import { type Target } from './call.ts';
 export type Door = 'screen' | 'terminal';
 /** Where a sandbox is in its life. */

package/lib/api/sandbox.js

@@ -15,6 +15,7 @@
  * A door or a preview asked of a sandbox that stopped as it was asked is 409: it
  * is resumed, and asked again once.
  */
+import { phrase } from '@hanzo/i18n';
 import { call, Refusal, seg } from './call.js';
 const STATES = ['pending', 'running', 'parked', 'error'];
 function box(raw, id) {
@@ -54,7 +55,7 @@ async function up(t, id) {
         b = await sandbox(t, id);
     }
     if (b.state !== 'running')
-        throw new Refusal(503, b.error || 'The sandbox did not start again. Try again.');
+        throw new Refusal(503, b.error || phrase('The sandbox did not start again. Try again.'));
 }
 /** Asks what needs a running sandbox; a parked one is resumed first. */
 async function running(t, id, ask) {
@@ -75,7 +76,7 @@ export async function door(t, id, which, session = '') {
     const r = await running(t, id, () => call(t, 'POST', `/v1/sandbox/${seg(id)}/${which}/ticket`));
     const path = typeof r?.url === 'string' ? r.url : '';
     if (!path.startsWith('/v1/'))
-        throw new Refusal(502, 'The sandbox answered with no address to open');
+        throw new Refusal(502, phrase('The sandbox answered with no address to open'));
     const arg = which === 'terminal' && NAME.test(session) ? `&arg=${session}` : '';
     return `${t.api}${path}${arg}`;
 }
@@ -104,10 +105,10 @@ export async function preview(t, id, port) {
         url = new URL(typeof r?.url === 'string' ? r.url : '');
     }
     catch {
-        throw new Refusal(502, 'The sandbox answered with no address to open');
+        throw new Refusal(502, phrase('The sandbox answered with no address to open'));
     }
     if (url.protocol !== 'https:')
-        throw new Refusal(502, 'The sandbox answered with no address to open');
+        throw new Refusal(502, phrase('The sandbox answered with no address to open'));
     return url.href;
 }
 /** What a file shows at most. */

package/lib/api/sessions.d.ts

@@ -1,20 +1,3 @@
-/**
- * Runs, as the platform records them: one session per run.
- *
- *   GET   /v1/agent/sessions?kind=&project=&status=&limit=&after=   newest first, {sessions, next}
- *   GET   /v1/agent/sessions/{id}                            + the 50 most recent events
- *   PATCH /v1/agent/sessions/{id}         {title}|{published} rename it; open its story to the public build route
- *   POST  /v1/agent/sessions/{id}/message {message}           steer a running run
- *   POST  /v1/agent/sessions/{id}/pause                       pause it; a sandbox run keeps its work on its branch
- *   POST  /v1/agent/sessions/{id}/resume                      ask a paused run to go on
- *   POST  /v1/agent/sessions/{id}/stop    {message}           end it, work kept
- *   GET  /v1/agent/sessions/stream?root={id}                 SSE: `session` and `event` frames,
- *                                                            each wrapped: {"session":{…}}, {"event":{…}}
- *
- * The stream is best-effort by the platform's own statement: a subscriber that
- * falls 256 frames behind is dropped. So `watch` reconnects, and every
- * reconnect is reported, which is the caller's cue to re-read the detail.
- */
 import { type Target } from './call.ts';
 export type Status = 'running' | 'paused' | 'done' | 'error' | 'stopped' | string;
 export interface Session {