@hanzo/rooms 0.1.38 → 0.1.39

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/pane.d.ts

@@ -1,19 +1,10 @@
 import { type Api, type WorkFile } from './lib/files.js';
-/** One open tab in the pane's browser. */
-export interface Leaf {
-    id: string;
-    url: string;
-    /** What the strip shows: host and path, which is all we can read across an
-     *  origin we do not own. A frame's real title is not ours to ask for. */
-    title: string;
-}
 /**
  * A file put into this conversation, on its way to the workspace or already
  * there, waiting to go with the next message.
  *
- * `href` is an object URL and is the reason this is never written down — see
- * the note at the top. A name and a size are the file system's, or the
- * workspace file's, never a guess.
+ * `href` is an object URL and is the reason this is never written down. A name
+ * and a size are the file system's, or the workspace file's, never a guess.
  */
 export interface Held {
     id: string;
@@ -37,13 +28,8 @@ export interface Via {
     api: Api;
     org: string | null;
 }
-/** Everything the column beside one conversation is holding. */
+/** What one conversation holds for its next message. */
 export interface Pane {
-    tabs: Leaf[];
-    /** The chosen tab, or null when this conversation has opened none. */
-    at: string | null;
-    /** Whether the summary column stands beside the browser. */
-    pinned: boolean;
     held: Held[];
     /** Why the last files offered were refused, in the reader's words, or null. */
     refused: string | null;
@@ -55,52 +41,13 @@ export interface Pane {
  * an inbox room arrives over a transport and is keyed by it, a thread is a
  * conversation the org has recorded, and an agent is who you are talking to
  * before a thread exists. Prefixed so a room called `x` and a thread called `x`
- * cannot land on one entry.
- *
- * `new` is a real answer and not a fallback: a room nobody has spoken in yet is
- * somewhere a reader can open tabs, and they should still be there when the
- * first turn mints a thread. It is the ONE key that several conversations pass
- * through, which is the honest cost of not having an id to key on yet.
+ * cannot land on one entry. `new` is a room nobody has spoken in yet.
  */
 export declare function channel(open: {
     room: string | null;
     thread: string | null;
     agent: string | null;
 }): string;
-/** The host and path of an address, which is as much as a title can honestly be. */
-export declare function name(url: string): string;
-/**
- * An address as typed, made into one that can be opened.
- *
- * A bare host is `https`, because that is the web now; a loopback name is
- * `http`, because nothing is listening on 443 of a laptop and offering a
- * reader a URL that cannot connect is worse than guessing.
- */
-export declare function address(typed: string): string;
-/**
- * Opens an address in this conversation, and chooses it.
- *
- * `called` is for the things that HAVE a name of their own — an answer's
- * `index.html`, a file off the reader's disk — because their address is a blob
- * and `name()` can read nothing useful out of one. Without it the host and path
- * are the honest title.
- */
-export declare function openTab(key: string, url: string, called?: string): void;
-/** Points an already-open tab somewhere else. */
-export declare function goTab(key: string, id: string, url: string): void;
-/** Chooses an open tab. */
-export declare function pickTab(key: string, id: string): void;
-/**
- * Shuts a tab.
- *
- * THE NEIGHBOUR IS THE ONE TO ITS RIGHT, falling back to its left — what every
- * browser does, and the only choice that does not send the reader somewhere
- * they were not looking. Closing the last tab leaves none chosen rather than
- * refusing, because a pane with no tabs is a state this panel draws.
- */
-export declare function shutTab(key: string, id: string): void;
-/** Shows or hides the summary column beside this conversation's browser. */
-export declare function pin(key: string, on: boolean): void;
 /** The workspace file `id` as the index last said, or undefined until it has. */
 export declare function useWorkFile(id: string | undefined): WorkFile | undefined;
 /** The object URL over workspace file `id`'s bytes on this machine, or '' where this document never held them. */