@hanzo/rooms 0.1.38 → 0.1.40

package/dist/lib/host.js

@@ -1,18 +1,20 @@
 /**
- * Which host this export is read on, and what that host keeps.
+ * Which host this export is read on, what that host keeps, and the app's
+ * addresses — the one module that writes and reads them.
  *
  * hanzo.ai is the site for a stranger and the app for a member: the web app is
- * `/` once signed in (app/page.tsx), beside /chat. hanzo.team is the
- * workspace, its own app (hanzo-apps/team) with Home at its root. This export
- * still carries the rooms, so a room asked for on the apex is sent to the same
- * room on hanzo.team, and `output: 'export'` has no server to do that, so it is
- * decided in the browser off the hostname, here.
+ * /chat and /dev once signed in, and `/` takes a member to the mode they were
+ * last in. hanzo.team is the workspace, its own app (hanzo-apps/team) with Home
+ * at its root. This export still carries the rooms, so a room asked for on the
+ * apex is sent to the same room on hanzo.team, and `output: 'export'` has no
+ * server to do that, so it is decided in the browser off the hostname, here.
  *
  * Two predicates, one per product: `apex()` for the app, `team()` for the
  * workspace. Every host that is neither (localhost, a preview) draws the whole
  * workspace and admits the way the apex does.
  */
 import APP from './rooms.json' with { type: 'json' };
+import { href, parse, path, route, SESSION, SLUG } from '@hanzo/build/route';
 import { site } from '../where.js';
 /** The workspace's own address. */
 export const WORKSPACE = 'https://hanzo.team';
@@ -32,59 +34,107 @@ export const ENTRY = `${WORKSPACE}/?signin`;
  */
 export const START = `${WORKSPACE}/start`;
 /**
- * The web app, for a signed-in reader, in two modes. Chat is the default, at
- * `/`. Dev is @hanzo/build's `<Builder>` at `/dev`, and what it shows is the
- * PATH under it, in the builder's own grammar (`route` in @hanzo/build): `/dev`
- * New, `/dev/sess_<id>` a run, `/dev/<org>/<repo>` a project,
- * `/dev/-/<screen>`, `/dev/-/settings[/<section>]`, `/dev/-/customize[/<tab>]`,
- * `/dev/<slug>` a deployed site. The export holds one page for all of them,
- * `/dev`, and the edge serves it for every path under it (hanzo.ai's
- * lib/edge.ts `APP`).
+ * THE APP'S ADDRESSES ARE PATHS, in two modes at two roots. Chat is /chat, a
+ * new conversation, and /chat/<id> one of the reader's. Dev is /dev, Dev's New,
+ * and every place of @hanzo/build's builder is a path under it, written and
+ * read by `href`/`parse` (@hanzo/build/route): /dev/run/<id>, /dev/projects,
+ * /dev/projects/<org>/<repo> a repository, /dev/projects/<slug> a deployed
+ * site, /dev/issues, /dev/artifacts, /dev/templates, /dev/automations[/<id>],
+ * /dev/machines, /dev/environments, /dev/customize[/<tab>],
+ * /dev/settings[/<section>], /dev/plans. The export holds one page per root,
+ * /chat and /dev, and the edge serves it for every path under it (hanzo.ai's
+ * lib/edge.ts `APP`), so every address reloads.
  */
+export const CHAT = '/chat';
 export const DEV = '/dev';
-/** Dev at an app address; '' is Dev's New, `/dev` itself. */
-export const app = (path) => {
-    const p = path.replace(/^\/+|\/+$/g, '');
-    return p ? `${DEV}/${p}` : DEV;
-};
-/** The app address a pathname names under `/dev`, or null for a pathname that is not Dev's. */
-export const under = (pathname) => {
-    if (!pathname)
+/** Chat on a conversation, or /chat itself for a new one. */
+export const talk = (id) => (id ? `${CHAT}/${encodeURIComponent(id)}` : CHAT);
+/** Dev at a builder address (`route` in @hanzo/build); '' is New, /dev. What is not an address is New. */
+export const app = (at) => DEV + href(route(at));
+/** /chat/shared is a page of its own, where a chat shared by link is read (lib/share.ts). */
+const SHARED = 'shared';
+/** The place a path names, or null when it names none of the app's. */
+export function place(pathname) {
+    const p = pathname.replace(/\/+$/, '') || '/';
+    if (p === CHAT)
+        return { mode: 'chat', thread: null };
+    if (p === DEV || p.startsWith(`${DEV}/`))
+        return { mode: 'dev', at: path(parse(p.slice(DEV.length))) };
+    if (!p.startsWith(`${CHAT}/`))
         return null;
-    if (pathname === DEV || pathname === `${DEV}/`)
-        return '';
-    if (!pathname.startsWith(`${DEV}/`))
+    const id = p.slice(CHAT.length + 1);
+    if (id.includes('/') || id === SHARED)
         return null;
     try {
-        return decodeURIComponent(pathname.slice(DEV.length + 1));
+        return { mode: 'chat', thread: decodeURIComponent(id) };
     }
     catch {
-        return '';
+        return null;
     }
-};
-/**
- * Chat, the app's default mode: `/` is a new conversation and `?chat=<id>` one
- * of the reader's. So the address says which mode the app is in — a path under
- * `/dev` for Dev, anything else Chat — and a reload keeps it.
- */
-export const TALK = 'chat';
-/** `/` in Chat, on a conversation, or `/` itself for a new one. */
-export const talk = (id) => (id ? `/?${TALK}=${encodeURIComponent(id)}` : '/');
-/** A run, as the platform mints its id. */
-const SESSION = /^sess_[0-9a-f]{32}$/;
-/** A deployed site, as the Sites plane slugs it. */
-const SLUG = /^[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/;
+}
+/** An address as analytics counts it: a record folded to its kind, so every conversation is one page. */
+export function page(pathname) {
+    const at = place(pathname);
+    if (!at)
+        return pathname;
+    if (at.mode === 'chat')
+        return at.thread ? `${CHAT}/:id` : CHAT;
+    const r = route(at.at);
+    if (r.kind === 'run')
+        return `${DEV}/run/:id`;
+    if (r.kind === 'repo')
+        return `${DEV}/projects/:org/:repo`;
+    if (r.kind === 'project')
+        return `${DEV}/projects/:slug`;
+    if (r.kind === 'automation' && r.id !== 'new')
+        return `${DEV}/automations/:id`;
+    return DEV + href(r);
+}
 /** A repository on the forge, `<org>/<name>`. */
 const REPO = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}\/[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 /**
- * Dev opened on one run, project or site, from anywhere: every "Try Hanzo Dev"
- * link, a room's Dev, the console's "open in the builder". It signs a stranger
- * in on the way (app/(app)/dev/_door.tsx), and is reached through `site()`:
- * here on hanzo.ai, across to hanzo.ai from hanzo.team. Only a value that is
- * exactly a session id, a repository or a site's slug is carried; anything else
- * opens /dev itself, so no caller can make this name another address.
+ * Dev opened on one run, repository or site, from anywhere: every "Try Hanzo
+ * Dev" link, a room's Dev, the console's "open in the builder". It signs a
+ * stranger in on the way (app/(app)/dev/_door.tsx), and is reached through
+ * `site()`: here on hanzo.ai, across to hanzo.ai from hanzo.team. Only a value
+ * that is exactly a session id, a repository or a site's slug is carried;
+ * anything else opens /dev itself, so no caller can make this name another
+ * address.
  */
-export const dev = (ref) => site(ref && (SESSION.test(ref) || REPO.test(ref) || SLUG.test(ref)) ? app(ref) : DEV);
+export const dev = (ref) => site(app(ref && (SESSION.test(ref) || REPO.test(ref) || SLUG.test(ref)) ? ref : ''));
+/**
+ * Move the app to an address of this page: a history entry, or in place of this
+ * one. No document load and no route change — the Next router folds a native
+ * history entry into `usePathname`, so the app follows the path it reads.
+ */
+export function go(address, replace = false) {
+    if (`${window.location.pathname}${window.location.search}` === address)
+        return;
+    if (replace)
+        window.history.replaceState(null, '', address);
+    else
+        window.history.pushState(null, '', address);
+}
+/** Where this browser keeps the mode its reader was last in. */
+const MODE = 'hanzo.app.mode';
+/** Keep the mode the reader is in, for `resume`. */
+export function remember(mode) {
+    try {
+        window.localStorage.setItem(MODE, mode);
+    }
+    catch {
+        /* no store: `/` opens Chat */
+    }
+}
+/** Where `/` takes a member: the mode they were last in, Chat when none is kept. */
+export function resume() {
+    try {
+        return window.localStorage.getItem(MODE) === 'dev' ? DEV : CHAT;
+    }
+    catch {
+        return CHAT;
+    }
+}
 /** The routes under app/(app) the apex keeps: the app — /chat, a chat shared by link, and /dev. */
 const KEPT = new Set(['/chat', '/chat/shared', '/dev']);
 /** Settings, and every page under it: the person's and the organization's, served wherever the app is. */
@@ -135,7 +185,7 @@ export const GET = 'https://hanzo.app';
  * is signed out is asked to sign in there, on hanzo.ai's own page, and lands
  * back in the chat.
  */
-export const WEB = `${SIGNIN}/chat`;
+export const WEB = `${SIGNIN}${CHAT}`;
 /**
  * Whether a host serves this export and signs nobody in: hanzo.app, whose root
  * is the page above; every `<slug>.hanzo.app` alias the Sites plane serves it

package/dist/lib/limits.d.ts

@@ -1,13 +1,5 @@
-/**
- * The plan's usage, as @hanzo/ui holds it: `GET /v1/ai/limits` read as whoever
- * holds the bearer in this browser's organization, kept current by every AI
- * call `observed` (lib/served.ts) hands to `observe`. Shares only.
- *
- * Same base URL and headers as every billing read (lib/hanzo/tier.ts): the
- * bearer is the subject and `X-Org-Id` the organization this browser works in.
- */
 import { type UseLimits } from '@hanzo/ui/product/useLimits';
-import { paidPlan } from '@hanzo/ui/product/limits';
+import { paidPlan, type LimitAction, type LimitNotice } from '@hanzo/ui/product/limits';
 /** Reads the limits as whoever holds the bearer, in this browser's organization. */
 export declare function readLimits(signal: AbortSignal): Promise<unknown>;
 /**
@@ -28,6 +20,18 @@ export declare const useLimits: (enabled?: boolean, org?: string | null, name?:
  */
 export declare const spendShown: ({ limits, answered }: Pick<UseLimits, 'limits' | 'answered'>) => boolean;
 export { paidPlan };
+/**
+ * What the banner over the composer says once the reader is turned away, and
+ * the ways on. A spent allowance is said by the plan's name and when it comes
+ * back — `Your Max 20x plan’s included premium model usage is used until 5:00
+ * PM.` — and a spent request window the same way; any other refusal in the
+ * server's own words. The ways are @hanzo/build's `ways`: continue with credits
+ * where the org holds some, else add credits; then the upgrade.
+ */
+export declare function paused(n: LimitNotice, plan: string, name?: (id: string) => string, now?: number): {
+    message: string;
+    actions: LimitAction[];
+};
 /** Whether a catalog family is one of Hanzo's chat families, Enso or Zen, whose turns carry the live web. */
 export declare const house: (family: string | undefined) => boolean;
 /**

package/dist/lib/limits.js

@@ -7,6 +7,7 @@
  * Same base URL and headers as every billing read (lib/hanzo/tier.ts): the
  * bearer is the subject and `X-Org-Id` the organization this browser works in.
  */
+import { label, said, spent, ways, when } from '@hanzo/build/plan';
 import { useLimits as useHeld } from '@hanzo/ui/product/useLimits';
 import { paidPlan } from '@hanzo/ui/product/limits';
 import { api } from './api.js';
@@ -47,6 +48,25 @@ export const useLimits = (enabled = true, org = null, name) => useHeld(enabled ?
  */
 export const spendShown = ({ limits, answered }) => answered && !paidPlan(limits);
 export { paidPlan };
+/**
+ * What the banner over the composer says once the reader is turned away, and
+ * the ways on. A spent allowance is said by the plan's name and when it comes
+ * back — `Your Max 20x plan’s included premium model usage is used until 5:00
+ * PM.` — and a spent request window the same way; any other refusal in the
+ * server's own words. The ways are @hanzo/build's `ways`: continue with credits
+ * where the org holds some, else add credits; then the upgrade.
+ */
+export function paused(n, plan, name = (id) => id, now = Date.now()) {
+    const l = label(plan);
+    const until = when(n.resets_at ?? '', now);
+    const on = n.fallback ? ` You’re chatting on ${name(n.fallback)}.` : '';
+    const message = n.reason === 'plan_allowance_used' || (!n.reason && n.classes.length > 0)
+        ? spent(l, n.classes, n.resets_at ?? '', now) + on
+        : n.reason === 'usage_cap_exceeded'
+            ? `Your ${l ? `${said(l)} plan’s` : 'plan’s'} requests are used${until ? ` until ${until}` : ''}.${on}`
+            : n.message;
+    return { message, actions: ways(n.actions) };
+}
 /** Whether a catalog family is one of Hanzo's chat families, Enso or Zen, whose turns carry the live web. */
 export const house = (family) => family === 'enso' || family === 'zen';
 /**

package/dist/lib/plans.d.ts

@@ -26,8 +26,8 @@
  * A SuperAdmin edits these rows at admin.hanzo.ai (/v1/commerce/plans/entries),
  * and every reader here follows: the build bakes the authority's answer into the
  * pricing snapshot for the first paint, and the page replaces it with the live
- * read. No price in this repo is typed; @hanzo/plans is read only for what the
- * wire does not carry — a plan's name for a slug, and the Free row's models.
+ * read. No price in this repo is typed, and no plan's name: a slug is named by
+ * @hanzo/build's `label` (`max-20x` reads Max, with 20x beside it).
  */
 /** A row exactly as GET /v1/billing/plans returns it. */
 export interface BillingPlan {
@@ -150,17 +150,6 @@ export declare function charge(plan: SubscriptionPlan, interval: Interval): numb
 export declare function quote(plan: SubscriptionPlan, interval: Interval): string | null;
 /** What a year saves against twelve months, as a whole percent: 1 − year ÷ (12 × month). Null where it saves nothing. */
 export declare function saving(plan: SubscriptionPlan): number | null;
-/**
- * The catalog's own name for a plan slug — "max-20x" reads as "Max 20x" —
- * or null where the slug is empty or the catalog does not carry it.
- *
- * Read off the published package: a plan's name does not move between a build and the next release the way
- * its price can, so the bundled copy is not a stale answer here the way it
- * would be for money. A reader of `GET /v1/billing/tier`'s `plan` field
- * needs a name and nothing else, so no live fetch is spent proving what the
- * package already states.
- */
-export declare function planName(slug: string | null | undefined): string | null;
 /**
  * A usage rate as money. A sub-dollar rate needs at least two decimals to read as
  * a price at all — 0.1 is $0.10, not $0.1 — while keeping the precision the

package/dist/lib/plans.js

@@ -26,11 +26,10 @@
  * A SuperAdmin edits these rows at admin.hanzo.ai (/v1/commerce/plans/entries),
  * and every reader here follows: the build bakes the authority's answer into the
  * pricing snapshot for the first paint, and the page replaces it with the live
- * read. No price in this repo is typed; @hanzo/plans is read only for what the
- * wire does not carry — a plan's name for a slug, and the Free row's models.
+ * read. No price in this repo is typed, and no plan's name: a slug is named by
+ * @hanzo/build's `label` (`max-20x` reads Max, with 20x beside it).
  */
 import { useEffect, useMemo, useState } from "react";
-import { subscriptionPlans } from "@hanzo/plans";
 import { where } from "../where.js";
 import { api } from "./api.js";
 import { BILLING_URL, checkoutUrl, dollars, money, payUrl } from "./pay.js";
@@ -222,22 +221,6 @@ export function saving(plan) {
         return null;
     return Math.round((1 - year / (12 * month)) * 100);
 }
-/**
- * The catalog's own name for a plan slug — "max-20x" reads as "Max 20x" —
- * or null where the slug is empty or the catalog does not carry it.
- *
- * Read off the published package: a plan's name does not move between a build and the next release the way
- * its price can, so the bundled copy is not a stale answer here the way it
- * would be for money. A reader of `GET /v1/billing/tier`'s `plan` field
- * needs a name and nothing else, so no live fetch is spent proving what the
- * package already states.
- */
-export function planName(slug) {
-    if (!slug)
-        return null;
-    const row = subscriptionPlans.find((p) => p.id === slug);
-    return row?.name ?? null;
-}
 /**
  * A usage rate as money. A sub-dollar rate needs at least two decimals to read as
  * a price at all — 0.1 is $0.10, not $0.1 — while keeping the precision the

package/dist/lib/session.d.ts

@@ -31,18 +31,15 @@ export declare function bearer(): string | null;
 export declare function live(): boolean;
 /** The attribute on `<html>` that says `/` is showing the app, not the landing. */
 export declare const APP = "data-app";
-/** Whether `search` names a place in the app. */
-export declare const place: (search: string) => boolean;
-/**
- * `live()`, and a place in the app, as the script `/` runs as the first child
- * of its landing (app/_apex.tsx `[data-landing]`), before the rest of the
- * landing is parsed (app/page.tsx). Either marks the document with `APP` and
- * takes the landing off the page at once: a signed-in reader is never shown the
- * pitch while the app loads, and a reader on their way to sign in to a place is
- * not shown it while they leave. Same keys, same test. An inline style, because
- * this is decided before any stylesheet or component has run.
- */
-export declare const BOOT: string;
+/**
+ * `live()`, as the script `/` runs as the first child of its landing
+ * (app/_apex.tsx `[data-landing]`), before the rest of the landing is parsed
+ * (app/page.tsx). A live token marks the document with `APP` and takes the
+ * landing off the page at once, so a signed-in reader is never shown the pitch
+ * on the way to the app. Same keys, same test. An inline style, because this is
+ * decided before any stylesheet or component has run.
+ */
+export declare const BOOT = "try{var t=localStorage.getItem('hanzo_iam_access_token'),e=localStorage.getItem('hanzo_iam_expires_at');if(t&&(!e||Date.now()<Number(e))){document.documentElement.setAttribute('data-app','');var l=document.currentScript&&document.currentScript.parentElement;if(l&&l.hasAttribute('data-landing'))l.style.display='none'}}catch(_){}";
 /**
  * Whether this tab may still ask: a person's browser, and not asked in this tab
  * yet. A browser that refuses storage cannot remember having asked, so it never

package/dist/lib/session.js

@@ -14,7 +14,6 @@
  * who was signed in, which reads as a permissions problem rather than a typo.
  * Two derivations of one name never agree; this is the one derivation.
  */
-import { TALK } from './host.js';
 import { api } from './api.js';
 /** The SDK's own keys, `hanzo_iam_`-prefixed. The far side of a boundary. */
 const PREFIX = 'hanzo_iam_';
@@ -59,25 +58,14 @@ export function live() {
 /** The attribute on `<html>` that says `/` is showing the app, not the landing. */
 export const APP = 'data-app';
 /**
- * An address on `/` that names a place in the app — `?chat` in Chat
- * (lib/host.ts `TALK`; Dev's places are paths under `/dev`, whose own page
- * signs a stranger in). The app is signed-in only, so a reader nobody has
- * signed in is sent to hanzo.id with it rather than shown the landing, and it
- * comes back with them.
+ * `live()`, as the script `/` runs as the first child of its landing
+ * (app/_apex.tsx `[data-landing]`), before the rest of the landing is parsed
+ * (app/page.tsx). A live token marks the document with `APP` and takes the
+ * landing off the page at once, so a signed-in reader is never shown the pitch
+ * on the way to the app. Same keys, same test. An inline style, because this is
+ * decided before any stylesheet or component has run.
  */
-const PLACE = new RegExp(`[?&]${TALK}(?:[=&]|$)`);
-/** Whether `search` names a place in the app. */
-export const place = (search) => PLACE.test(search);
-/**
- * `live()`, and a place in the app, as the script `/` runs as the first child
- * of its landing (app/_apex.tsx `[data-landing]`), before the rest of the
- * landing is parsed (app/page.tsx). Either marks the document with `APP` and
- * takes the landing off the page at once: a signed-in reader is never shown the
- * pitch while the app loads, and a reader on their way to sign in to a place is
- * not shown it while they leave. Same keys, same test. An inline style, because
- * this is decided before any stylesheet or component has run.
- */
-export const BOOT = `try{var t=localStorage.getItem('${ACCESS}'),e=localStorage.getItem('${EXPIRES}');if((t&&(!e||Date.now()<Number(e)))||${PLACE}.test(location.search)){document.documentElement.setAttribute('${APP}','');var l=document.currentScript&&document.currentScript.parentElement;if(l&&l.hasAttribute('data-landing'))l.style.display='none'}}catch(_){}`;
+export const BOOT = `try{var t=localStorage.getItem('${ACCESS}'),e=localStorage.getItem('${EXPIRES}');if(t&&(!e||Date.now()<Number(e))){document.documentElement.setAttribute('${APP}','');var l=document.currentScript&&document.currentScript.parentElement;if(l&&l.hasAttribute('data-landing'))l.style.display='none'}}catch(_){}`;
 /**
  * A RETURNING PERSON IS RECOGNISED WITHOUT GOING ANYWHERE.
  *

package/dist/lib/web.d.ts

@@ -1,48 +1,56 @@
 /**
  * THE LIVE WEB, IN A CHAT TURN.
  *
- * A turn on an Enso or Zen model is offered two tools, `websearch` and `crawl`.
- * They are the platform's own operations — POST /v1/websearch and POST
- * /v1/crawl, the two the assistant calls when it answers in Slack — run here
- * with the reader's own credential, so they are admitted, metered and refused
- * exactly as they are for every other caller.
+ * A turn on an Enso or Zen model carries the two web tools (`WEB`) as its mark
+ * that it may use the web. `researched` is the client's fetch that acts on the
+ * mark: it looks the turn up BEFORE the model is asked — POST /v1/websearch and
+ * POST /v1/crawl, the platform's own operations, run with the reader's own
+ * credential so they are admitted, metered and refused exactly as for every
+ * other caller — and then asks the model once, WITHOUT tools, with what was
+ * found in its system turn.
  *
- * `researched` is the client's fetch with the tool loop in it. A completion
- * that offers these tools is answered as ONE event stream: the model asks for a
- * lookup, the lookup runs, its result goes back, and the model is asked again —
- * each round an ordinary completion, so the plan's windows count it like any
- * other — and the reader's stream carries only what the model says. Nothing
- * above the fetch changes: `useChat` streams the answer it always streamed.
+ * Without tools because the gateway answers a request that offers tools whole,
+ * checking its calls against their schemas before the first byte, so its first
+ * word waits for its last. Asked without them, every turn streams. The model
+ * therefore never asks for a lookup of its own: the client's one lookup is the
+ * turn's web.
  *
- * A question about now — the weather, the news, a price, a score, "today",
- * "latest" — does not wait for the model to decide: it is searched before the
- * model is asked (`current`), and the search reads the best pages as well as
- * listing them, so the answer can quote a reading rather than a page's blurb.
+ * Which turns: every question about the world, in any language. The web is
+ * skipped only for a turn that plainly needs none (`needs`) — code, arithmetic,
+ * a passage supplied to work on, a greeting — and for a turn about the person's
+ * own files or picture, whose words never leave for a search engine. The test
+ * reads the shape of the text, never a list of topics. A turn that names a page
+ * reads it, and searches too when it asks something. The query is the person's
+ * own words, each address said as its host and path words, and the language narrows
+ * the search (`language`), so a question asked in Russian is searched in Russian.
  *
- * Only a turn that needs the web is offered it: a question about now, or one
- * that names a page. The gateway answers a request that offers tools whole,
- * after checking its calls against their schemas, so its first word waits for
- * its last; every other turn goes out without the tools and streams.
+ * WHERE WHAT WAS FOUND GOES: the end of the leading system turn, between two
+ * markers no page can know. Not a system turn of its own, because the gateway's
+ * text pipeline keeps only the last system turn it reads, and that would drop
+ * the room's own; not the person's turn, because the router chooses the model
+ * from the last user turn and would read the web pages as the question.
  *
- * Bounded: at most ROUNDS rounds of lookups the model asks for, CALLS lookups in
- * a round, and every lookup on its own clock. The request after the last round
- * offers no tools, so the turn ends in words; a reply of no words is asked for
- * once more.
- *
- * A page is read only when the conversation or one of this turn's searches
- * named it. Page text is written by strangers and can tell a model to fetch an
- * address carrying the conversation in its query; an address nobody named is
- * never fetched.
+ * A page is read only when the person points at it — never an address that
+ * signs in, confirms, unsubscribes or spends a token (`opened`) — or this turn's
+ * search found it. A reply of no words is asked for once more.
  */
 import { type ChatCompletionTool } from '@hanzo/ai';
-/** Rounds of lookups the model may ask for in one turn. */
-export declare const ROUNDS = 2;
-/** Lookups run in one round; the rest are answered as refused. */
-export declare const CALLS = 3;
-/** The two tools a turn is offered. */
+/** Pages a turn that names them reads. */
+export declare const PAGES = 3;
+/** The two tools that mark a turn as one that may use the web. */
 export declare const WEB: ChatCompletionTool[];
-/** Whether a question asks about now. */
-export declare const current: (text: string) => boolean;
+/**
+ * Whether a turn's words need the web. Every question about the world does, in
+ * any language; the turns that plainly do not are code, arithmetic, a passage
+ * supplied to work on, a greeting, and a turn of no words at all.
+ */
+export declare function needs(text: string): boolean;
+/**
+ * The language a question is written in, as /v1/websearch reads it ("ru",
+ * "en", "ja"), or '' when its words do not say. `spoken` is the reader's own
+ * languages, which pick among the languages a script is shared by.
+ */
+export declare function language(text: string, spoken?: readonly string[]): string;
 /**
  * The part of a page that answers, within `max` characters: the lines that
  * carry the question's words or a reading — a figure, a unit — kept in the
@@ -50,7 +58,7 @@ export declare const current: (text: string) => boolean;
  */
 export declare function excerpt(markdown: string, words: string[], max: number): string;
 /**
- * A fetch that runs the web tools a completion offers (see the head of this
- * file). Every other request passes through untouched.
+ * A fetch that looks up the turns a completion marks with the web tools (see
+ * the head of this file). Every other request passes through untouched.
  */
-export declare function researched(base: typeof fetch, clock?: () => Date): typeof fetch;
+export declare function researched(base: typeof fetch, clock?: () => Date, spoken?: () => readonly string[]): typeof fetch;