d85aca0 · 7ce637f · d448c24 · 8cdf9ed · dbcd55b · 8237157
@@ -7,3 +7,4 @@
This repository also contains third-party files under their own licenses:
- DejaVu fonts, src/web/og/vendor/DejaVu*.ttf: see src/web/og/vendor/DEJAVU-LICENSE.
- resvg, src/web/og/vendor/resvg.*: Mozilla Public License 2.0, https://github.com/thx/resvg-js and https://github.com/linebender/resvg.
- ghostty-web 0.4.0, src/web/vendor/ghostty-web/: MIT License, Copyright (c) 2025 Coder, https://github.com/coder/ghostty-web; see src/web/vendor/ghostty-web/LICENSE.
@@ -46,3 +46,8 @@
It lives at [forge.open-platform.sh/trevato/forge](https://forge.open-platform.s
GitHub holds a read-only mirror; issues and pulls are on the forge.
Open source under the [AGPL-3.0](LICENSE). See [contributing](CONTRIBUTING.md).
One dependency is vendored for browsers: [ghostty-web](https://github.com/coder/ghostty-web)
0.4.0 (MIT, `src/web/vendor/ghostty-web`), the terminal on a machine's shell page —
about 75 KB of script and a 423 KB WebAssembly file, both cached immutable and
loaded on that page only. See [NOTICE](NOTICE).
@@ -0,0 +1,17 @@
# Machines
A machine's shell page, `/:owner/:name/machines/:machine/shell`
(`src/web/pages/machines.ts`, its rules in `MACHINE_SHELL_CSS`, shipped as the
page's own style). The list at `/:owner/:name/settings/machines` uses the
table and `btn` it already had; no new class there.
- `.machine-term` — the box the terminal (ghostty-web's canvas) draws in:
  its height is fixed to the window below the page head (`100dvh` less
  `--machine-term-above`, the named sum of what sits over it, never under 320px), so nothing moves when the terminal arrives or the
  socket opens; a bordered surface on the page background, its overflow
  clipped. Its `data-wasm` names the emulator's WebAssembly.
- `.machine-term-status` — the one-line status above the box (connecting,
  connected, why it closed): reserves its line (1.5em) so the box never
  shifts as the words change; muted text, a polite live region. The server
  renders it empty and the script says "Connecting…"; without JavaScript a
  `<noscript>` line in the same class says the shell needs it.
@@ -90,9 +90,49 @@
repository's machines:
  on its own for a writer who is not one), and in the terminal: the palette's
  **Machines of a repository** (`src/tui/screens/machines.ts`), writers only.
## The shell in the browser (#9472)
`/<owner>/<repo>/settings/machines` lists the machines with **Open shell**,
which goes to `/<owner>/<repo>/machines/<machine>/shell`: the same path as the
socket, answered as a page when it is not an upgrade. Writers only, like the
socket (a reader is refused 403; a private repository or an undeclared
machine answers 404). The page renders on the server and draws the terminal
with one script:
- **The emulator** is [ghostty-web](https://github.com/coder/ghostty-web)
  0.4.0, vendored unmodified in `src/web/vendor/ghostty-web` (MIT; what was copied and
  its hashes are in its README). `src/web/machine-term-asset.ts` bundles it
  with the page's client (`src/web/machine-term-client.ts`) into
  `/assets/machine-term-<hash>.js` (about 75 KB, dropping the module's own
  inlined copy of the WebAssembly) and serves `ghostty-vt.wasm` at
  `/assets/ghostty-vt-<hash>.wasm` (423 KB); both are content-addressed and
  cached immutable.
- **The interface** to it is thin: `Term` in `src/web/machine-term-wire.ts`
  is `write`, `onData`, `resize` and `fit`, and all of the protocol
  (`wire`) is written against that, so it is tested without a browser and the
  emulator can be swapped without touching it.
- **CSP.** Only this page adds `'wasm-unsafe-eval'` to `script-src` (the
  page option `wasm` in `src/web/layout.ts`): it admits compiling
  WebAssembly, not `eval` or inline script. Every other page's policy is
  unchanged.
- **Reload.** A reload opens a new socket, which joins the person's running
  session (above). On open the page sends its size; a connection's first
  size equal to the pty's own makes the server pass the pty through one row
  less for 30 ms (`resizePlan`, `src/machines/shell.ts`), because the kernel
  signals only a change and tmux redraws the whole screen on the signal. So
  the reloaded page shows the screen, not a blank one.
- **Resize.** The page refits the terminal to its box when the box changes
  (debounced 100 ms) and sends one resize frame per new size, never the same
  size twice; tmux redraws the prompt at the new size.
- **Closed.** The status line says why the socket closed (the shell exited,
  idle, the forge cannot hold a shell) and to reload to reattach.
Try it: on a preview, sign in as a writer of a repository, open
`/<owner>/<repo>/settings/machines`, press **Open shell** on `standard`. A
forge that cannot hold a cell says so in the status line and closes.
## Not done yet (split from #9418)
Disk ceilings are not declared (#9460); the tools are declared, not yet
installed in an image (the brief reports which are on PATH); the browser terminal (ghostty-web) that speaks to the
shell socket is not built; the shell's cell does not reach the repository's
installed in an image (the brief reports which are on PATH); the shell's cell does not reach the repository's
apps even when its machine says `apps`.
@@ -85,7 +85,7 @@
export type Baseline = { files: Record<string, Counts> };
export type Finding = { line: number; kind: "colour" | "size"; text: string; use: string };
export type Scan = Baseline & { classes: string[]; found?: Record<string, Finding[]> };
const SKIP = /(^|\/)(og\/vendor)\//;
const SKIP = /(^|\/)(og\/vendor|web\/vendor)\//;
export function sourceFiles(root: string): string[] {
  const out: string[] = [];
@@ -23,14 +23,17 @@
export const ENTRIES = [
  "src/git/hook-entry.ts",
];
/** Scripts the check and operators run are callers too: their imports count. */
const SCRIPTS = "scripts/**/*.ts";
/** Scripts the check and operators run, and the benches run at release, are callers too: their imports count. */
const SCRIPTS = ["scripts/**/*.ts", "bench/**/*.ts"];
/** Not modules: tests, and migrations, which the runner finds by listing the directory. */
const NOT_MODULES = /(?:\.test\.ts$|^src\/core\/migrations\/)/;
const SPEC = /(?:\bfrom\s*|\bimport\s*\(?\s*)["'`](\.{1,2}\/[^"'`]*)["'`]/g;
/** A module named as a URL beside this one, the way a `Bun.build` entry point is: `new URL("./x.ts", import.meta.url)`. */
const URL_SPEC = /\bnew\s+URL\(\s*["'`](\.{1,2}\/[^"'`]*)["'`]\s*,\s*import\.meta\.url\s*\)/g;
/** The src/ file a relative specifier names, among `files`, or undefined. */
function resolve(from: string, spec: string, files: Set<string>): string | undefined {
  const base = normalize(join(dirname(from), spec)).replace(/\.(js|ts)$/, "");
@@ -43,10 +46,10 @@
export function unreached(root: string): string[] {
    [...new Bun.Glob("src/**/*.ts").scanSync({ cwd: root })].filter((f) => !f.endsWith(".d.ts") && !NOT_MODULES.test(f)),
  );
  const reached = new Set<string>(ENTRIES.filter((e) => files.has(e)));
  const queue = [...reached, ...new Bun.Glob(SCRIPTS).scanSync({ cwd: root })];
  const queue = [...reached, ...SCRIPTS.flatMap((g) => [...new Bun.Glob(g).scanSync({ cwd: root })])];
  for (let file = queue.pop(); file; file = queue.pop()) {
    const text = readFileSync(join(root, file), "utf8");
    for (const m of text.matchAll(SPEC)) {
    for (const m of [...text.matchAll(SPEC), ...text.matchAll(URL_SPEC)]) {
      const target = resolve(file, m[1]!, files);
      if (target && !reached.has(target)) {
        reached.add(target);
@@ -246,6 +246,9 @@
export interface TerminalProgram {
  readonly hangup: () => void;
}
/** Where `setsid` is, found once; null on a host without util-linux. */
const SETSID = Bun.which("setsid");
/**
 * Start `command` (through `sh -c`) on `terminal`, held in `cell` when
 * there is one. Without a cell the program leads a process group of its
@@ -265,11 +268,20 @@
export function startTerminal(
  },
): TerminalProgram {
  const { cell } = options;
  const proc = Bun.spawn(cell?.argv(command) ?? ["/bin/sh", "-c", command], {
  const argv = cell?.argv(command) ?? ["/bin/sh", "-c", command];
  // Bun's `terminal` gives the child the pty as its stdio but not as its
  // controlling terminal, so the kernel has no one to tell of a resize: no
  // SIGWINCH, and tmux never redraws at the new size (#9472). `setsid -c`
  // (util-linux, Essential on the image's Debian) makes the program lead a
  // session whose controlling terminal is the pty, in place: it is not a
  // group leader yet, so setsid execs rather than forks, the pid stays, and
  // the group is the program's own as `detached` made it.
  const ctty = SETSID !== null;
  const proc = Bun.spawn(ctty ? [SETSID, "-c", ...argv] : argv, {
    terminal: options.terminal,
    env: cell?.env(options.env) ?? options.env,
    cwd: options.cwd,
    detached: cell === undefined,
    detached: !ctty && cell === undefined,
  });
  const exited = proc.exited.then((code) => {
    cell?.close();
@@ -535,7 +535,8 @@
import {
import { getVerifiedDomain } from "../core/domains.ts";
import { previewOwner } from "../spawn/preview-owner.ts";
import { cellsAvailable } from "../apps/contain.ts";
import { machinesSettingsPage } from "../web/pages/machines.ts";
import { machineShellPage, machinesSettingsPage } from "../web/pages/machines.ts";
import { machineTermAsset, wasmResponse, ghosttyWasmAsset } from "../web/machine-term-asset.ts";
import {
  defaultCommand,
  mayOpenShell,
@@ -544,7 +545,6 @@
import {
  shellTarget,
  stopShells,
  withShells,
  closeStaleSessions,
  type ForgeSocket,
  type ShellSocket,
} from "../machines/shell.ts";
@@ -726,6 +726,10 @@
export function buildRouter(): Router<Handler> {
    if (ctx.params.name === TOOLBAR_NAME) return toolbarResponse(ctx.request);
    const own = pageScriptNamed(ctx.params.name!, ctx.app.config.dataDir);
    if (own !== undefined) return fileResponse(ctx.request, own);
    if (ctx.params.name!.startsWith("machine-term-")) {
      const term = await machineTermAsset();
      return term !== null && ctx.params.name === term.name ? assetResponse(ctx.request, term) : notFound();
    }
    const asset = await highlightAsset();
    if (asset === null || ctx.params.name !== asset.name) return notFound();
    return assetResponse(ctx.request, asset);
@@ -734,6 +738,10 @@
export function buildRouter(): Router<Handler> {
  router.add("GET", "/assets/:name.svg", (ctx) =>
    ctx.params.name === spriteAsset().name ? fileResponse(ctx.request, spriteAsset()) : notFound(),
  );
  // The machine shell's terminal emulator (`web/machine-term-asset.ts`).
  router.add("GET", "/assets/:name.wasm", (ctx) =>
    ctx.params.name === ghosttyWasmAsset().name ? wasmResponse(ctx.request) : notFound(),
  );
  router.add("GET", "/assets/:name.json", (ctx) =>
    ctx.params.name === speculationAsset().name ? fileResponse(ctx.request, speculationAsset()) : notFound(),
  );
@@ -1371,6 +1379,8 @@
export function buildRouter(): Router<Handler> {
  );
  router.add("GET", "/:owner/:name/settings/app", appSettingsPage);
  router.add("GET", "/:owner/:name/settings/machines", machinesSettingsPage);
  // The shell page; an upgrade at the same path is the socket (`machines/shell.ts`).
  router.add("GET", "/:owner/:name/machines/:machine/shell", machineShellPage);
  router.add("POST", "/:owner/:name/settings/app", appSettingsUpdate);
  router.add("POST", "/:owner/:name/settings/app/disable", appDisable);
  router.add("POST", "/:owner/:name/settings/app/members", appMembersUpdate);
@@ -2161,8 +2171,6 @@
export function forgeHttp(app: App): ForgeHttp {
export async function serve(app: App): Promise<Servers> {
  const router = buildRouter();
  // No shell outlives its forge: a row a stop or crash left open is closed.
  closeStaleSessions(app.db);
  const apiRouter = buildApiRouter();
  await clearStaleSockets(app);
  // One limiter per listener: its state is a minute of timestamps, and two
@@ -127,6 +127,28 @@
export function parseControl(text: string): { cols: number; rows: number } | und
  return { cols, rows };
}
export interface PtySize {
  readonly cols: number;
  readonly rows: number;
}
/**
 * The sizes to give the pty for a resize frame, in order. A new size is set
 * once. A connection's first frame at the size the pty already has (a
 * reload, a second tab) passes through one row less first: the kernel only
 * signals a change, and tmux redraws the whole screen on the signal, so the
 * page that joined sees the screen rather than a blank one. A later frame at
 * the same size changes nothing.
 */
export function resizePlan(current: PtySize, next: PtySize, firstFromPeer: boolean): PtySize[] {
  if (current.cols !== next.cols || current.rows !== next.rows) return [next];
  if (!firstFromPeer) return [];
  return [{ cols: next.cols, rows: next.rows > RESIZE.rows.min ? next.rows - 1 : next.rows + 1 }, next];
}
/** How long the pty holds the nudged size before the real one, so the program sees two changes. */
export const REDRAW_NUDGE_MS = 30;
// ---- the records ----
export type EndReason = "exit" | "idle" | "stopped" | "revoked" | "failed";
@@ -205,6 +227,8 @@
export interface ShellSocket {
  readonly shell: ShellGrant & { readonly app: App };
  joined?: Session;
  release?: () => void;
  /** This connection has sent a size; its first one redraws a joined screen (`resizePlan`). */
  sized?: boolean;
}
type Peer = Bun.ServerWebSocket<ShellSocket>;
@@ -217,6 +241,8 @@
interface Session {
  readonly terminal: Bun.Terminal;
  readonly program: TerminalProgram;
  readonly peers: Set<Peer>;
  /** The pty's size, as last set. */
  size: PtySize;
  lastInput: number;
  ended: boolean;
  readonly timer: ReturnType<typeof setInterval>;
@@ -387,6 +413,7 @@
function start(app: App, grant: ShellGrant, opts: ShellOptions, cols: number, ro
      terminal: term,
      program,
      peers,
      size: { cols, rows },
      lastInput: Date.now(),
      ended: false,
      timer: setInterval(
@@ -460,7 +487,16 @@
export const shellWebSocket = {
        ws.close(1003, "a text frame is a resize");
        return;
      }
      if (!session.terminal.closed) session.terminal.resize(resize.cols, resize.rows);
      const plan = resizePlan(session.size, resize, ws.data.sized !== true);
      ws.data.sized = true;
      session.size = resize;
      const apply = (size: PtySize): void => {
        if (!session.ended && !session.terminal.closed) session.terminal.resize(size.cols, size.rows);
      };
      const [first, ...rest] = plan;
      if (first !== undefined) apply(first);
      // A newer frame in the meantime is the size that stands; this one is dropped.
      if (rest.length > 0) setTimeout(() => session.size === resize && rest.forEach(apply), REDRAW_NUDGE_MS);
      return;
    }
    if (message.byteLength > MAX_INPUT_BYTES) {
@@ -98,6 +98,7 @@
import { stallLine } from "./perf/loop.ts";
import { bootStall, gitRecord, loopWatch, perfRecord } from "./perf/live.ts";
import { timeStatements } from "./kernel/slow_sql.ts";
import { waitForPeer } from "./runs/peer.ts";
import { closeStaleSessions } from "./machines/shell.ts";
// `forge hook <name>` re-enters here from a git hook stub. It relays to the
// running forge over its socket and exits — it must never boot a server.
@@ -425,6 +426,10 @@
const earlySignals = ["SIGINT", "SIGTERM", "SIGHUP"] as const;
for (const signal of earlySignals) process.once(signal, leaveEarly);
await waitForPeer(app.db, app.log);
for (const signal of earlySignals) process.off(signal, leaveEarly);
// No shell outlives its forge: a row a stop or crash left open is closed. Only
// once the other forge has let go: its shells are live until then, and a write
// at boot would wait on its lock with the event loop held (#9472).
closeStaleSessions(app.db);
// A repository's own check, on every push a pull or the default branch takes.
const checks =
  process.env.FORGE_CHECKS === "0"
@@ -76,7 +76,7 @@
async function build(): Promise<BuiltAsset | null> {
 * other response. Only hashed assets come through here, so only they are
 * immutable.
 */
export function staticResponse(request: Request, body: string, type: string, etag: string): Response {
export function staticResponse(request: Request, body: string | Uint8Array<ArrayBuffer>, type: string, etag: string): Response {
  const headers: Record<string, string> = {
    "content-type": type,
    "cache-control": "public, max-age=31536000, immutable",
@@ -87,8 +87,8 @@
export function staticResponse(request: Request, body: string, type: string, eta
  if (matches(request.headers.get("if-none-match"), etag))
    return new Response(null, { status: 304, headers });
  const encoding = negotiate(request.headers.get("accept-encoding"));
  const bytes = new TextEncoder().encode(body);
  if (encoding === null || bytes.length < MIN_BYTES || request.method === "HEAD") return new Response(body, { headers });
  const bytes = typeof body === "string" ? new TextEncoder().encode(body) : body;
  if (encoding === null || bytes.length < MIN_BYTES || request.method === "HEAD") return new Response(bytes, { headers });
  // Hashed, so the encoded bytes are as immutable as the plain ones: made once.
  return new Response(encodeOnce(etag, bytes, encoding), { headers: { ...headers, "content-encoding": encoding } });
}
@@ -135,6 +135,13 @@
export interface PageOptions {
   * origin" — so pages that do not ask for it keep the stricter policy.
   */
  scriptAsset?: string;
  /**
   * The page compiles WebAssembly (a machine's shell page runs its terminal
   * emulator in it): `script-src` gains `'wasm-unsafe-eval'`, which admits
   * WebAssembly compilation and nothing else — no `eval`, no inline script.
   * Only that page asks; no other page's policy changes.
   */
  wasm?: boolean;
  /**
   * The page draws a PDF from the media route in an `<object>`: the browser's
   * own viewer may load it from this origin (`object-src 'self'`). Only the
@@ -861,7 +868,7 @@
export function page(options: PageOptions, status = 200): Response {
    // The hashed stylesheet and scripts are 'self'; the two inline <style>s
    // are named by hash. connect-src 'self' lets the live event stream
    // (EventSource) and fragment fetches reach same-origin.
    "content-security-policy": `default-src 'none'; style-src 'self' ${styleSources}; script-src 'self'${options.turnstile ? ` ${TURNSTILE_ORIGIN}` : ""}; connect-src 'self'${options.turnstile ? ` ${TURNSTILE_ORIGIN}` : ""}; ${frameSources(options)}worker-src 'self'; manifest-src 'self'; img-src 'self' data:; ${options.objectSrc ? "object-src 'self'; " : ""}form-action 'self'; base-uri 'none'; frame-ancestors 'none'`,
    "content-security-policy": `default-src 'none'; style-src 'self' ${styleSources}; script-src 'self'${options.wasm ? " 'wasm-unsafe-eval'" : ""}${options.turnstile ? ` ${TURNSTILE_ORIGIN}` : ""}; connect-src 'self'${options.turnstile ? ` ${TURNSTILE_ORIGIN}` : ""}; ${frameSources(options)}worker-src 'self'; manifest-src 'self'; img-src 'self' data:; ${options.objectSrc ? "object-src 'self'; " : ""}form-action 'self'; base-uri 'none'; frame-ancestors 'none'`,
    "referrer-policy": "same-origin",
    "x-content-type-options": "nosniff",
    // Markup is revalidated every time; only the hashed assets it names are
@@ -0,0 +1,100 @@
/**
 * The machine shell page's two files, content-addressed and immutable like the
 * highlighter (`web/asset.ts`):
 *
 * - `/assets/machine-term-<hash>.js` — `web/machine-term-client.ts` bundled
 *   with the vendored ghostty-web (`src/web/vendor/ghostty-web`, MIT, 0.4.0) by
 *   `Bun.build` at first use. The vendored module also carries its
 *   WebAssembly as a base64 `data:` URL; the bundle drops that copy (the page
 *   fetches the file below instead), so the script is about 75 KB rather than 680
 *   and the page's CSP needs no `data:` in `connect-src`.
 * - `/assets/ghostty-vt-<hash>.wasm` — the emulator's WebAssembly, read once.
 *
 * A failed build is not fatal: the page says the terminal could not load.
 */
import { readFileSync } from "node:fs";
import { join } from "node:path";
import { sha256 } from "../kernel/hash.ts";
import { createLog } from "../kernel/log.ts";
import { staticResponse, type BuiltAsset } from "./asset.ts";
const log = createLog("web");
export const VENDOR_DIR = join(import.meta.dir, "vendor", "ghostty-web");
/** The vendored module's inlined WebAssembly: a string literal, base64. */
const INLINE_WASM = /(["'`])data:application\/wasm;base64,[A-Za-z0-9+/=]+\1/g;
/** The vendored source with its inlined WebAssembly replaced by an empty `data:` URL. */
export function withoutInlineWasm(source: string): string {
  return source.replace(INLINE_WASM, '"data:,"');
}
let pending: Promise<BuiltAsset | null> | null = null;
/** The shell page's script, built once per process. */
export function machineTermAsset(): Promise<BuiltAsset | null> {
  pending ??= build();
  return pending;
}
async function build(): Promise<BuiltAsset | null> {
  try {
    const built = await Bun.build({
      entrypoints: [Bun.fileURLToPath(new URL("./machine-term-client.ts", import.meta.url))],
      target: "browser",
      format: "esm",
      minify: true,
      plugins: [
        {
          name: "ghostty-web-without-inline-wasm",
          setup(builder) {
            builder.onLoad({ filter: /vendor[\\/]ghostty-web[\\/]ghostty-web\.js$/ }, async (args) => ({
              contents: withoutInlineWasm(await Bun.file(args.path).text()),
              loader: "js",
            }));
          },
        },
      ],
    });
    const first = built.outputs[0];
    if (!built.success || first === undefined || built.outputs.length !== 1) {
      log.warn("web.machine_term_asset_failed", { logs: built.logs.length, outputs: built.outputs.length });
      return null;
    }
    const code = await first.text();
    const hash = sha256(code);
    const name = `machine-term-${hash.slice(0, 16)}`;
    return { path: `/assets/${name}.js`, name, code, etag: `"${hash}"` };
  } catch (error) {
    log.warn("web.machine_term_asset_failed", { error: String(error) });
    return null;
  }
}
export interface WasmAsset {
  readonly path: string;
  readonly name: string;
  readonly bytes: Uint8Array<ArrayBuffer>;
  readonly etag: string;
}
let wasm: WasmAsset | null = null;
/** The emulator's WebAssembly, read and hashed once per process. */
export function ghosttyWasmAsset(): WasmAsset {
  if (wasm === null) {
    const bytes = new Uint8Array(readFileSync(join(VENDOR_DIR, "ghostty-vt.wasm")));
    const hash = new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
    const name = `ghostty-vt-${hash.slice(0, 16)}`;
    wasm = { path: `/assets/${name}.wasm`, name, bytes, etag: `"${hash}"` };
  }
  return wasm;
}
/** The response for a hit on the WebAssembly: immutable, because it is. */
export function wasmResponse(request: Request): Response {
  const asset = ghosttyWasmAsset();
  return staticResponse(request, asset.bytes, "application/wasm", asset.etag);
}
@@ -0,0 +1,99 @@
/**
 * The browser entry point of a machine's shell page
 * (`/<owner>/<repo>/machines/<machine>/shell`, `web/pages/machines.ts`).
 * `web/asset.ts` bundles it with the vendored ghostty-web
 * (`src/web/vendor/ghostty-web`, MIT, pinned at 0.4.0) into one ES module served
 * from `/assets/machine-term-<hash>.js`; the emulator's WebAssembly is its own
 * immutable asset, named on the page as `data-wasm`, never inlined.
 *
 * Everything the page knows arrives in `data-*` attributes; the socket is the
 * page's own path, upgraded. All protocol work is in `machine-term-wire.ts`.
 */
import { FitAddon, Ghostty, Terminal, type ITheme } from "./vendor/ghostty-web/ghostty-web.js";
import { wire, type Term } from "./machine-term-wire.ts";
// The few browser globals this file touches, named here rather than pulling
// the whole DOM library into a server-side type check.
interface Box {
  readonly dataset: Record<string, string | undefined>;
  textContent: string | null;
  focus(): void;
}
declare const document: { getElementById(id: string): Box | null; readonly documentElement: unknown };
declare const location: { readonly href: string; readonly pathname: string; readonly protocol: string };
declare function getComputedStyle(element: unknown): { getPropertyValue(name: string): string };
declare const ResizeObserver: new (callback: () => void) => { observe(element: unknown): void };
const REFIT_MS = 100;
const box = document.getElementById("machine-term");
const status = document.getElementById("machine-term-status");
const say = (words: string): void => {
  if (status !== null) status.textContent = words;
};
if (box !== null) {
  // Said here, not by the server: without JavaScript nothing connects (#9472).
  say("Connecting…");
  start(box).catch(() => say("The terminal could not start in this browser."));
}
/** The page's own colours and type, read from its tokens: the terminal follows the theme. */
function theme(): { theme: ITheme; fontFamily?: string } {
  const css = getComputedStyle(document.documentElement);
  const token = (name: string): string | undefined => {
    const value = css.getPropertyValue(name).trim();
    return value === "" ? undefined : value;
  };
  const colours: ITheme = {};
  const background = token("--bg");
  const foreground = token("--fg");
  const cursor = token("--accent");
  if (background !== undefined) colours.background = background;
  if (foreground !== undefined) colours.foreground = foreground;
  if (cursor !== undefined) colours.cursor = cursor;
  const font = token("--mono");
  return font === undefined ? { theme: colours } : { theme: colours, fontFamily: font };
}
async function start(box: Box): Promise<void> {
  const wasm = box.dataset["wasm"];
  if (wasm === undefined) throw new Error("no wasm named");
  const ghostty = await Ghostty.load(wasm);
  const terminal = new Terminal({ ghostty, fontSize: 14, cursorBlink: true, ...theme() });
  const fitter = new FitAddon();
  terminal.loadAddon(fitter);
  terminal.open(box as never);
  const term: Term = {
    write: (bytes) => terminal.write(bytes),
    onData: (listener) => {
      terminal.onData(listener);
    },
    resize: (cols, rows) => terminal.resize(cols, rows),
    fit: () => {
      fitter.fit();
      return terminal.cols > 0 && terminal.rows > 0 ? { cols: terminal.cols, rows: terminal.rows } : undefined;
    },
  };
  const url = new URL(location.pathname, location.href);
  url.protocol = location.protocol === "https:" ? "wss:" : "ws:";
  const socket = new WebSocket(url);
  socket.binaryType = "arraybuffer";
  const wired = wire(term, (frame) => socket.send(frame), say);
  socket.addEventListener("open", () => wired.opened());
  socket.addEventListener("message", (event) => {
    if (event.data instanceof ArrayBuffer) wired.received(new Uint8Array(event.data));
  });
  socket.addEventListener("close", (event) => wired.closed(event.code, event.reason));
  // A window dragged wider fires many times; the shell hears the size it settles on.
  let timer: ReturnType<typeof setTimeout> | undefined;
  new ResizeObserver(() => {
    if (timer !== undefined) clearTimeout(timer);
    timer = setTimeout(() => wired.refit(), REFIT_MS);
  }).observe(box);
  terminal.focus();
}
@@ -0,0 +1,91 @@
/**
 * The browser terminal's wiring to a machine's shell socket
 * (`machines/shell.ts`), with no DOM and no socket in it: plain functions the
 * client (`machine-term-client.ts`) connects to a real terminal and a real
 * WebSocket, and a test connects to fakes.
 *
 * The terminal is reached only through `Term` — `write`, `onData`, `resize`,
 * `fit` — so the emulator behind it (ghostty-web today) can be swapped
 * without touching the protocol.
 *
 * The protocol is the socket's: binary frames are keystrokes in and screen
 * bytes out; a text frame is `{"type":"resize","cols":n,"rows":n}`. A size is
 * sent once when the socket opens (the server redraws a reattached session on
 * it) and then once per size the terminal settles on, never twice in a row.
 */
export interface Size {
  readonly cols: number;
  readonly rows: number;
}
/** The thin face of a terminal emulator: all the page needs of one. */
export interface Term {
  /** Screen bytes from the shell. */
  write(bytes: Uint8Array): void;
  /** Keystrokes the person typed (or pasted). */
  onData(listener: (text: string) => void): void;
  resize(cols: number, rows: number): void;
  /** Fit the terminal to its box; the size it settled on, if it could measure one. */
  fit(): Size | undefined;
}
/** The text frame that tells the shell its window's size. */
export function resizeFrame(size: Size): string {
  return JSON.stringify({ type: "resize", cols: size.cols, rows: size.rows });
}
/** Why a closed socket closed, in words a person can act on. */
export function closedWords(code: number, reason: string): string {
  const why = reason.trim() !== "" ? reason.trim() : code === 1000 ? "the shell exited" : "the connection dropped";
  return `Disconnected: ${why}. Reload to reattach.`;
}
export interface Wired {
  /** The socket opened: send the size, start forwarding keystrokes. */
  opened(): void;
  /** Screen bytes arrived. */
  received(bytes: Uint8Array): void;
  /** The socket closed. */
  closed(code: number, reason: string): void;
  /** The terminal's box may have changed size: fit, and send the size if it is new. */
  refit(): void;
}
/**
 * Wire a terminal to a socket's `send`. `say` puts a status line in front of
 * the person (connecting, connected, why it closed).
 */
export function wire(term: Term, send: (frame: string | Uint8Array) => void, say: (words: string) => void): Wired {
  const encoder = new TextEncoder();
  let open = false;
  let sent: Size | undefined;
  const sendSize = (size: Size): void => {
    sent = size;
    send(resizeFrame(size));
  };
  term.onData((text) => {
    if (open) send(encoder.encode(text));
  });
  return {
    opened() {
      open = true;
      say("Connected.");
      const size = term.fit();
      if (size !== undefined) sendSize(size);
    },
    received(bytes) {
      term.write(bytes);
    },
    closed(code, reason) {
      open = false;
      say(closedWords(code, reason));
    },
    refit() {
      const size = term.fit();
      if (!open || size === undefined) return;
      if (sent !== undefined && sent.cols === size.cols && sent.rows === size.rows) return;
      sendSize(size);
    },
  };
}
@@ -1,8 +1,15 @@
/**
 * GET /:owner/:name/settings/machines — the machines a repository declares
 * (`crew/machines.ts`) and its last shell sessions (`machines/shell.ts`):
 * who opened which machine, when, and when and why it ended. Writers only:
 * a session is a shell on the repository's machine, so a reader sees none.
 * (`crew/machines.ts`), each with "Open shell", and its last shell sessions
 * (`machines/shell.ts`): who opened which machine, when, and when and why it
 * ended. Writers only: a session is a shell on the repository's machine, so a
 * reader sees none.
 *
 * GET /:owner/:name/machines/:machine/shell — the shell itself: a terminal in
 * the browser (ghostty-web, `web/machine-term-client.ts`) on the WebSocket at
 * the same path (an upgrade there is answered by `machines/shell.ts` before
 * any route). Writers only, as the socket is. A reload joins the same tmux
 * session. The one page whose CSP admits WebAssembly (`'wasm-unsafe-eval'`).
 */
import type { Machine } from "../../crew/machines.ts";
@@ -11,12 +18,37 @@
import { nameFrame, notePhase, takeSessionTime, timePhase, timePhaseAsync } from
import { repoMachines } from "../../crew/machines_read.ts";
import type { Ctx } from "../../http/context.ts";
import { ENDED, lastSessions, type SessionRecord } from "../../machines/shell.ts";
import { crumbsFor, forbiddenPage, loadRepo, repoHeader, repoNotFound, repoPalette, NOT_YOURS_TO_DO } from "../chrome.ts";
import {
  crumbsFor,
  forbiddenPage,
  loadRepo,
  notFoundPage,
  pageHead,
      
        sentinelcrew
        4d ago
        outdated
      
      Second import from ../chrome.ts; merge it with the one above.
    
  repoHeader,
  repoNotFound,
  repoPalette,
  NOT_YOURS_TO_DO,
} from "../chrome.ts";
      
        sentinelcrew
        4d ago
        outdated
      
      Magic 300px and hardcoded 8px padding: use tokens or a named offset for the head height.
    
import { page } from "../layout.ts";
import { html } from "../html.ts";
import { card, icon, time } from "../ui.ts";
import { btn, card, icon, time } from "../ui.ts";
import { ghosttyWasmAsset, machineTermAsset } from "../machine-term-asset.ts";
import { settingsPageResponse } from "./settings.ts";
/** The shell page's own rules: a terminal box that fills the window below the head and never moves. */
// --machine-term-above is everything over the box: the site bar (48), the
// compact repository header (88), the page head with its sub line (96), the
// status line with its margins (40), and the page's top and bottom padding
// (28). Padding and margins are the 4px scale's 8 (DESIGN §4).
export const MACHINE_SHELL_CSS = /* css */ `
.machine-term { --machine-term-above: 300px; height: calc(100dvh - var(--machine-term-above)); min-height: 320px; padding: 8px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--bg); overflow: hidden; }
.machine-term-status { min-height: 1.5em; margin: 8px 0; color: var(--muted-fg); }
`;
/** Where a machine's shell page (and its socket) lives. */
export function shellPath(repo: Repo, machine: string): string {
  return `/${repo.ownerName}/${repo.name}/machines/${machine}/shell`;
}
export async function machinesSettingsPage(ctx: Ctx): Promise<Response> {
  nameFrame(ctx.request);
@@ -34,17 +66,18 @@
function render(ctx: Ctx, repo: Repo, list: readonly Machine[], sessions: readon
    html`<p class="muted">
        A machine is where the crew's shell runs. A writer can open a shell into one; each
        writer has a directory and home of their own on each machine, never shared with the
        next. The browser terminal that opens it is not built yet.
        next. A shell outlives its tab: reload, or open it again, and you are back in it.
      </p>
      <div class="table-scroll">
        <table class="table">
          <thead><tr><th>Machine</th><th>Tools</th><th>Reach</th></tr></thead>
          <thead><tr><th>Machine</th><th>Tools</th><th>Reach</th><th><span class="sr-only">Shell</span></th></tr></thead>
          <tbody>
            ${list.map(
              (m) => html`<tr>
                <td><strong>${m.name}</strong></td>
                <td class="muted">${m.tools.length === 0 ? "none" : m.tools.join(", ")}</td>
                <td class="muted">${m.reach.length === 0 ? "the forge only" : "the forge and its apps"}</td>
                <td>${btn("Open shell", { href: shellPath(repo, m.name), icon: "terminal", size: "sm" })}</td>
              </tr>`,
            )}
          </tbody>
@@ -87,3 +120,41 @@
function render(ctx: Ctx, repo: Repo, list: readonly Machine[], sessions: readon
    body: html`${repoHeader(ctx, repo, "settings", { compact: true })}${body}`,
  });
}
export async function machineShellPage(ctx: Ctx): Promise<Response> {
  nameFrame(ctx.request);
  notePhase(ctx.request, "session", takeSessionTime(ctx.request));
  const repo = timePhase(ctx.request, "repo", () => loadRepo(ctx));
  if (!repo) return repoNotFound(ctx);
  if (!canWrite(ctx.app.db, repo, ctx.auth.user)) return forbiddenPage(ctx, NOT_YOURS_TO_DO);
  const config = await timePhaseAsync(ctx.request, "machines", () => repoMachines(ctx.app, repo));
  const machine = config.machines.find((m) => m.name === ctx.params.machine);
  if (machine === undefined) return notFoundPage(ctx);
  const script = await timePhaseAsync(ctx.request, "asset", () => machineTermAsset());
  return timePhase(ctx.request, "render", () => renderShell(ctx, repo, machine, script?.path));
}
function renderShell(ctx: Ctx, repo: Repo, machine: Machine, script: string | undefined): Response {
  const base = `/${repo.ownerName}/${repo.name}`;
  const term =
    script === undefined
      ? html`<p class="muted" role="status">The terminal could not load on this forge.</p>`
      : html`<p id="machine-term-status" class="machine-term-status" role="status" aria-live="polite"></p>
          <noscript><p class="machine-term-status">This shell runs in the browser and needs JavaScript; with it off, nothing connects.</p></noscript>
          <div id="machine-term" class="machine-term" data-wasm="${ghosttyWasmAsset().path}"></div>`;
  return page({
    ctx,
    title: `Shell · ${machine.name} · ${repo.name}`,
    crumbs: crumbsFor(repo),
    palette: repoPalette(ctx, repo),
    wide: true,
    styleCss: MACHINE_SHELL_CSS,
    ...(script === undefined ? {} : { scriptAsset: script, wasm: true }),
    body: html`${repoHeader(ctx, repo, "settings", { compact: true })}
      ${pageHead(html`${icon("terminal")}Shell on ${machine.name}`, {
        sub: machine.tools.length === 0 ? "No tools beyond the shell." : `Tools: ${machine.tools.join(", ")}.`,
        actions: btn("All machines", { href: `${base}/settings/machines`, size: "sm" }),
      })}
      ${term}`,
  });
}
@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2025 Coder
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
@@ -0,0 +1,24 @@
# ghostty-web 0.4.0, vendored
The terminal emulator on a machine's shell page
(`src/web/machine-term-client.ts`, `docs/features/machines.md`). Copied
unmodified from the npm package `[email protected]`
(sha512 `0puDBik2qapbD/QQBW9o5ZHfXnZBqZWx/ctBiVtKZ6ZLds4NYb+wZuw1cRLXZk9zYovIQ908z3rvFhexAvc5Hg==`),
MIT, Copyright (c) 2025 Coder — see `LICENSE`.
| file | from the package | bytes | sha256 |
| --- | --- | --- | --- |
| `ghostty-web.js` | `dist/ghostty-web.js` | 681918 | `078b3fe37e4ef469d3f3d7772ee263070f8613e5a6f5ff305c85778907f45e72` |
| `__vite-browser-external-2447137e.js` | `dist/` (imported by the above) | 41 | `f8c456031e5001c0cda4837cd9ee3a33d79beeba120ec633ec9d990632fb2aa6` |
| `ghostty-vt.wasm` | `ghostty-vt.wasm` | 423045 | `d6f0326f1874ad2ce9f289e3a4a0c5f3507d4cb38d8747e4b287def470a0c60a` |
| `ghostty-web.d.ts` | `dist/index.d.ts` | 55510 | `2848adffa959ead3be5fa7a59a664518b0c679f8174fc4b216a1141bfee46861` |
| `LICENSE` | `LICENSE` | 1062 | `5eccd0eeca906db6d661b64dd05e1d4a4b2e49d37d43bbcfd2c8cce4d7832920` |
Nothing here is edited. `src/web/machine-term-asset.ts` bundles the module
with `Bun.build` and, at build time, drops its inlined base64 copy of the
WebAssembly (the page fetches `ghostty-vt.wasm` as its own immutable asset),
so the browser downloads about 75 KB of script and 423 KB of WebAssembly.
To move to a new version: replace these files from the new package, update
this table, and run `bun test test/machine-shell-page.test.ts` (it fails if
the inlined copy is no longer found and dropped).
@@ -0,0 +1,4 @@
const e = {};
export {
  e as default
};
@@ -0,0 +1,1842 @@
export declare class CanvasRenderer {
    private canvas;
    private ctx;
    private fontSize;
    private fontFamily;
    private cursorStyle;
    private cursorBlink;
    private theme;
    private devicePixelRatio;
    private metrics;
    private palette;
    private cursorVisible;
    private cursorBlinkInterval?;
    private lastCursorPosition;
    private lastViewportY;
    private currentBuffer;
    private selectionManager?;
    private currentSelectionCoords;
    private hoveredHyperlinkId;
    private previousHoveredHyperlinkId;
    private hoveredLinkRange;
    private previousHoveredLinkRange;
    constructor(canvas: HTMLCanvasElement, options?: RendererOptions);
    private measureFont;
    /**
     * Remeasure font metrics (call after font loads or changes)
     */
    remeasureFont(): void;
    private rgbToCSS;
    /**
     * Resize canvas to fit terminal dimensions
     */
    resize(cols: number, rows: number): void;
    /**
     * Render the terminal buffer to canvas
     */
    render(buffer: IRenderable, forceAll?: boolean, viewportY?: number, scrollbackProvider?: IScrollbackProvider, scrollbarOpacity?: number): void;
    /**
     * Render a single line using two-pass approach:
     * 1. First pass: Draw all cell backgrounds
     * 2. Second pass: Draw all cell text and decorations
     *
     * This two-pass approach is necessary for proper rendering of complex scripts
     * like Devanagari where diacritics (like vowel sign ि) can extend LEFT of the
     * base character into the previous cell's visual area. If we draw backgrounds
     * and text in a single pass (cell by cell), the background of cell N would
     * cover any left-extending portions of graphemes from cell N-1.
     */
    private renderLine;
    /**
     * Render a cell's background only (Pass 1 of two-pass rendering)
     * Selection highlighting is integrated here to avoid z-order issues with
     * complex glyphs (like Devanagari) that extend outside their cell bounds.
     */
    private renderCellBackground;
    /**
     * Render a cell's text and decorations (Pass 2 of two-pass rendering)
     * Selection foreground color is applied here to match the selection background.
     */
    private renderCellText;
    /**
     * Render cursor
     */
    private renderCursor;
    private startCursorBlink;
    private stopCursorBlink;
    /**
     * Update theme colors
     */
    setTheme(theme: ITheme): void;
    /**
     * Update font size
     */
    setFontSize(size: number): void;
    /**
     * Update font family
     */
    setFontFamily(family: string): void;
    /**
     * Update cursor style
     */
    setCursorStyle(style: 'block' | 'underline' | 'bar'): void;
    /**
     * Enable/disable cursor blinking
     */
    setCursorBlink(enabled: boolean): void;
    /**
     * Get current font metrics
     */
    /**
     * Render scrollbar (Phase 2)
     * Shows scroll position and allows click/drag interaction
     * @param opacity Opacity level (0-1) for fade in/out effect
     */
    private renderScrollbar;
    getMetrics(): FontMetrics;
    /**
     * Get canvas element (needed by SelectionManager)
     */
    getCanvas(): HTMLCanvasElement;
    /**
     * Set selection manager (for rendering selection)
     */
    setSelectionManager(manager: SelectionManager): void;
    /**
     * Check if a cell at (x, y) is within the current selection.
     * Uses cached selection coordinates for performance.
     */
    private isInSelection;
    /**
     * Set the currently hovered hyperlink ID for rendering underlines
     */
    setHoveredHyperlinkId(hyperlinkId: number): void;
    /**
     * Set the currently hovered link range for rendering underlines (for regex-detected URLs)
     * Pass null to clear the hover state
     */
    setHoveredLinkRange(range: {
        startX: number;
        startY: number;
        endX: number;
        endY: number;
    } | null): void;
    /**
     * Get character cell width (for coordinate conversion)
     */
    get charWidth(): number;
    /**
     * Get character cell height (for coordinate conversion)
     */
    get charHeight(): number;
    /**
     * Clear entire canvas
     */
    clear(): void;
    /**
     * Cleanup resources
     */
    dispose(): void;
}
/**
 * Cell style flags (bitfield)
 */
export declare enum CellFlags {
    BOLD = 1,
    ITALIC = 2,
    UNDERLINE = 4,
    STRIKETHROUGH = 8,
    INVERSE = 16,
    INVISIBLE = 32,
    BLINK = 64,
    FAINT = 128
}
/**
 * Cursor position and visibility
 */
export declare interface Cursor {
    x: number;
    y: number;
    visible: boolean;
}
/**
 * Dirty state from RenderState
 */
declare enum DirtyState {
    NONE = 0,
    PARTIAL = 1,
    FULL = 2
}
export declare class EventEmitter<T> {
    private listeners;
    fire(arg: T): void;
    event: IEvent<T>;
    dispose(): void;
}
export declare class FitAddon implements ITerminalAddon {
    private _terminal?;
    private _resizeObserver?;
    private _resizeDebounceTimer?;
    private _lastCols?;
    private _lastRows?;
    private _isResizing;
    /**
     * Activate the addon (called by Terminal.loadAddon)
     */
    activate(terminal: ITerminalCore): void;
    /**
     * Dispose the addon and clean up resources
     */
    dispose(): void;
    /**
     * Fit the terminal to its container
     *
     * Calculates optimal dimensions and resizes the terminal.
     * Does nothing if dimensions cannot be calculated or haven't changed.
     */
    fit(): void;
    /**
     * Propose dimensions to fit the terminal to its container
     *
     * Calculates cols and rows based on:
     * - Terminal container element dimensions (clientWidth/Height)
     * - Terminal element padding
     * - Font metrics (character cell size)
     * - Scrollbar width reservation
     *
     * @returns Proposed dimensions or undefined if cannot calculate
     */
    proposeDimensions(): ITerminalDimensions | undefined;
    /**
     * Observe the terminal's container for resize events
     *
     * Sets up a ResizeObserver to automatically call fit() when the
     * container size changes. Resize events are debounced to avoid
     * excessive calls during window drag operations.
     *
     * Call dispose() to stop observing.
     */
    observeResize(): void;
}
export declare interface FontMetrics {
    width: number;
    height: number;
    baseline: number;
}
/* Excluded from this release type: getGhostty */
/**
 * Main Ghostty WASM wrapper class
 */
export declare class Ghostty {
    private exports;
    private memory;
    constructor(wasmInstance: WebAssembly.Instance);
    createKeyEncoder(): KeyEncoder;
    createTerminal(cols?: number, rows?: number, config?: GhosttyTerminalConfig): GhosttyTerminal;
    static load(wasmPath?: string): Promise<Ghostty>;
    private static loadFromPath;
}
/**
 * Cell structure matching ghostty_cell_t in C (16 bytes)
 */
export declare interface GhosttyCell {
    codepoint: number;
    fg_r: number;
    fg_g: number;
    fg_b: number;
    bg_r: number;
    bg_g: number;
    bg_b: number;
    flags: number;
    width: number;
    hyperlink_id: number;
    grapheme_len: number;
}
/**
 * GhosttyTerminal - High-performance terminal emulator
 *
 * Uses Ghostty's native RenderState for optimal performance:
 * - ONE call to update all state (renderStateUpdate)
 * - ONE call to get all cells (getViewport)
 * - No per-row WASM boundary crossings!
 */
export declare class GhosttyTerminal {
    private exports;
    private memory;
    private handle;
    private _cols;
    private _rows;
    /** Size of GhosttyCell in WASM (16 bytes) */
    private static readonly CELL_SIZE;
    /** Reusable buffer for viewport operations */
    private viewportBufferPtr;
    private viewportBufferSize;
    /** Cell pool for zero-allocation rendering */
    private cellPool;
    constructor(exports: GhosttyWasmExports, memory: WebAssembly.Memory, cols?: number, rows?: number, config?: GhosttyTerminalConfig);
    get cols(): number;
    get rows(): number;
    write(data: string | Uint8Array): void;
    resize(cols: number, rows: number): void;
    free(): void;
    /**
     * Update render state from terminal.
     *
     * This syncs the RenderState with the current Terminal state.
     * The dirty state (full/partial/none) is stored in the WASM RenderState
     * and can be queried via isRowDirty(). When dirty==full, isRowDirty()
     * returns true for ALL rows.
     *
     * The WASM layer automatically detects screen switches (normal <-> alternate)
     * and returns FULL dirty state when switching screens (e.g., vim exit).
     *
     * Safe to call multiple times - dirty state persists until markClean().
     */
    update(): DirtyState;
    /**
     * Get cursor state from render state.
     * Ensures render state is fresh by calling update().
     */
    getCursor(): RenderStateCursor;
    /**
     * Get default colors from render state
     */
    getColors(): RenderStateColors;
    /**
     * Check if a specific row is dirty
     */
    isRowDirty(y: number): boolean;
    /**
     * Mark render state as clean (call after rendering)
     */
    markClean(): void;
    /**
     * Get ALL viewport cells in ONE WASM call - the key performance optimization!
     * Returns a reusable cell array (zero allocation after warmup).
     */
    getViewport(): GhosttyCell[];
    /**
     * Get line - for compatibility, extracts from viewport.
     * Ensures render state is fresh by calling update().
     * Returns a COPY of the cells to avoid pool reference issues.
     */
    getLine(y: number): GhosttyCell[] | null;
    /** For compatibility with old API */
    isDirty(): boolean;
    /**
     * Check if a full redraw is needed (screen change, resize, etc.)
     * Note: This calls update() to ensure fresh state. Safe to call multiple times.
     */
    needsFullRedraw(): boolean;
    /** Mark render state as clean after rendering */
    clearDirty(): void;
    isAlternateScreen(): boolean;
    hasBracketedPaste(): boolean;
    hasFocusEvents(): boolean;
    hasMouseTracking(): boolean;
    /** Get dimensions - for compatibility */
    getDimensions(): {
        cols: number;
        rows: number;
    };
    /** Get number of scrollback lines (history, not including active screen) */
    getScrollbackLength(): number;
    /**
     * Get a line from the scrollback buffer.
     * Ensures render state is fresh by calling update().
     * @param offset 0 = oldest line, (length-1) = most recent scrollback line
     */
    getScrollbackLine(offset: number): GhosttyCell[] | null;
    /** Check if a row in the active screen is wrapped (soft-wrapped to next line) */
    isRowWrapped(row: number): boolean;
    /** Hyperlink URI not yet exposed in simplified API */
    getHyperlinkUri(_id: number): string | null;
    /**
     * Check if there are pending responses from the terminal.
     * Responses are generated by escape sequences like DSR (Device Status Report).
     */
    hasResponse(): boolean;
    /**
     * Read pending responses from the terminal.
     * Returns the response string, or null if no responses pending.
     *
     * Responses are generated by escape sequences that require replies:
     * - DSR 6 (cursor position): Returns \x1b[row;colR
     * - DSR 5 (operating status): Returns \x1b[0n
     */
    readResponse(): string | null;
    /**
     * Query arbitrary terminal mode by number
     * @param mode Mode number (e.g., 25 for cursor visibility, 2004 for bracketed paste)
     * @param isAnsi True for ANSI modes, false for DEC modes (default: false)
     */
    getMode(mode: number, isAnsi?: boolean): boolean;
    private initCellPool;
    private parseCellsIntoPool;
    /** Small buffer for grapheme lookups (reused to avoid allocation) */
    private graphemeBuffer;
    private graphemeBufferPtr;
    /**
     * Get all codepoints for a grapheme cluster at the given position.
     * For most cells this returns a single codepoint, but for complex scripts
     * (Hindi, emoji with ZWJ, etc.) it returns multiple codepoints.
     * @returns Array of codepoints, or null on error
     */
    getGrapheme(row: number, col: number): number[] | null;
    /**
     * Get a string representation of the grapheme at the given position.
     * This properly handles complex scripts like Hindi, emoji with ZWJ, etc.
     */
    getGraphemeString(row: number, col: number): string;
    /**
     * Get all codepoints for a grapheme cluster in the scrollback buffer.
     * @param offset Scrollback line offset (0 = oldest)
     * @param col Column index
     * @returns Array of codepoints, or null on error
     */
    getScrollbackGrapheme(offset: number, col: number): number[] | null;
    /**
     * Get a string representation of a grapheme in the scrollback buffer.
     */
    getScrollbackGraphemeString(offset: number, col: number): string;
    private invalidateBuffers;
}
/**
 * Terminal configuration (passed to ghostty_terminal_new_with_config)
 * All color values use 0xRRGGBB format. A value of 0 means "use default".
 */
declare interface GhosttyTerminalConfig {
    scrollbackLimit?: number;
    fgColor?: number;
    bgColor?: number;
    cursorColor?: number;
    palette?: number[];
}
/**
 * Interface for libghostty-vt WASM exports
 */
declare interface GhosttyWasmExports extends WebAssembly.Exports {
    memory: WebAssembly.Memory;
    ghostty_wasm_alloc_opaque(): number;
    ghostty_wasm_free_opaque(ptr: number): void;
    ghostty_wasm_alloc_u8_array(len: number): number;
    ghostty_wasm_free_u8_array(ptr: number, len: number): void;
    ghostty_wasm_alloc_u16_array(len: number): number;
    ghostty_wasm_free_u16_array(ptr: number, len: number): void;
    ghostty_wasm_alloc_u8(): number;
    ghostty_wasm_free_u8(ptr: number): void;
    ghostty_wasm_alloc_usize(): number;
    ghostty_wasm_free_usize(ptr: number): void;
    ghostty_sgr_new(allocator: number, parserPtrPtr: number): number;
    ghostty_sgr_free(parser: number): void;
    ghostty_sgr_reset(parser: number): void;
    ghostty_sgr_set_params(parser: number, paramsPtr: number, subsPtr: number, paramsLen: number): number;
    ghostty_sgr_next(parser: number, attrPtr: number): boolean;
    ghostty_sgr_attribute_tag(attrPtr: number): number;
    ghostty_sgr_attribute_value(attrPtr: number, tagPtr: number): number;
    ghostty_wasm_alloc_sgr_attribute(): number;
    ghostty_wasm_free_sgr_attribute(ptr: number): void;
    ghostty_key_encoder_new(allocator: number, encoderPtrPtr: number): number;
    ghostty_key_encoder_free(encoder: number): void;
    ghostty_key_encoder_setopt(encoder: number, option: number, valuePtr: number): number;
    ghostty_key_encoder_encode(encoder: number, eventPtr: number, bufPtr: number, bufLen: number, writtenPtr: number): number;
    ghostty_key_event_new(allocator: number, eventPtrPtr: number): number;
    ghostty_key_event_free(event: number): void;
    ghostty_key_event_set_action(event: number, action: number): void;
    ghostty_key_event_set_key(event: number, key: number): void;
    ghostty_key_event_set_mods(event: number, mods: number): void;
    ghostty_key_event_set_utf8(event: number, ptr: number, len: number): void;
    ghostty_terminal_new(cols: number, rows: number): TerminalHandle;
    ghostty_terminal_new_with_config(cols: number, rows: number, configPtr: number): TerminalHandle;
    ghostty_terminal_free(terminal: TerminalHandle): void;
    ghostty_terminal_resize(terminal: TerminalHandle, cols: number, rows: number): void;
    ghostty_terminal_write(terminal: TerminalHandle, dataPtr: number, dataLen: number): void;
    ghostty_render_state_update(terminal: TerminalHandle): number;
    ghostty_render_state_get_cols(terminal: TerminalHandle): number;
    ghostty_render_state_get_rows(terminal: TerminalHandle): number;
    ghostty_render_state_get_cursor_x(terminal: TerminalHandle): number;
    ghostty_render_state_get_cursor_y(terminal: TerminalHandle): number;
    ghostty_render_state_get_cursor_visible(terminal: TerminalHandle): boolean;
    ghostty_render_state_get_bg_color(terminal: TerminalHandle): number;
    ghostty_render_state_get_fg_color(terminal: TerminalHandle): number;
    ghostty_render_state_is_row_dirty(terminal: TerminalHandle, row: number): boolean;
    ghostty_render_state_mark_clean(terminal: TerminalHandle): void;
    ghostty_render_state_get_viewport(terminal: TerminalHandle, bufPtr: number, bufLen: number): number;
    ghostty_render_state_get_grapheme(terminal: TerminalHandle, row: number, col: number, bufPtr: number, bufLen: number): number;
    ghostty_terminal_is_alternate_screen(terminal: TerminalHandle): boolean;
    ghostty_terminal_has_mouse_tracking(terminal: TerminalHandle): number;
    ghostty_terminal_get_mode(terminal: TerminalHandle, mode: number, isAnsi: boolean): number;
    ghostty_terminal_get_scrollback_length(terminal: TerminalHandle): number;
    ghostty_terminal_get_scrollback_line(terminal: TerminalHandle, offset: number, bufPtr: number, bufLen: number): number;
    ghostty_terminal_get_scrollback_grapheme(terminal: TerminalHandle, offset: number, col: number, bufPtr: number, bufLen: number): number;
    ghostty_terminal_is_row_wrapped(terminal: TerminalHandle, row: number): number;
    ghostty_terminal_has_response(terminal: TerminalHandle): boolean;
    ghostty_terminal_read_response(terminal: TerminalHandle, bufPtr: number, bufLen: number): number;
}
/**
 * A terminal buffer (normal or alternate screen)
 */
declare interface IBuffer {
    /** Buffer type: 'normal' or 'alternate' */
    readonly type: 'normal' | 'alternate';
    /** Cursor X position (0-indexed) */
    readonly cursorX: number;
    /** Cursor Y position (0-indexed, relative to viewport) */
    readonly cursorY: number;
    /** Viewport Y position (scroll offset, 0 = bottom of scrollback) */
    readonly viewportY: number;
    /** Base Y position (always 0 for normal buffer, may vary for alternate) */
    readonly baseY: number;
    /** Total buffer length (rows + scrollback for normal, just rows for alternate) */
    readonly length: number;
    /**
     * Get a line from the buffer
     * @param y Line index (0 = top of scrollback for normal buffer)
     * @returns Line object or undefined if out of bounds
     */
    getLine(y: number): IBufferLine | undefined;
    /**
     * Get the null cell (used for empty/uninitialized cells)
     */
    getNullCell(): IBufferCell;
}
/**
 * A single cell in the buffer
 */
declare interface IBufferCell {
    /** Character(s) in this cell (may be empty, single char, or emoji) */
    getChars(): string;
    /** Unicode codepoint (0 for null cell) */
    getCode(): number;
    /** Character width (1 = normal, 2 = wide/emoji, 0 = combining) */
    getWidth(): number;
    /** Foreground color index (for palette colors) or -1 for RGB */
    getFgColorMode(): number;
    /** Background color index (for palette colors) or -1 for RGB */
    getBgColorMode(): number;
    /** Foreground RGB color (or 0 for default) */
    getFgColor(): number;
    /** Background RGB color (or 0 for default) */
    getBgColor(): number;
    /** Whether cell has bold style */
    isBold(): number;
    /** Whether cell has italic style */
    isItalic(): number;
    /** Whether cell has underline style */
    isUnderline(): number;
    /** Whether cell has strikethrough style */
    isStrikethrough(): number;
    /** Whether cell has blink style */
    isBlink(): number;
    /** Whether cell has inverse video style */
    isInverse(): number;
    /** Whether cell has invisible style */
    isInvisible(): number;
    /** Whether cell has faint/dim style */
    isFaint(): number;
    /** Get hyperlink ID for this cell (0 = no link) */
    getHyperlinkId(): number;
    /** Get the Unicode codepoint for this cell */
    getCodepoint(): number;
    /** Whether cell has dim/faint attribute (boolean version) */
    isDim(): boolean;
}
/**
 * Represents a coordinate in the terminal buffer
 */
export declare interface IBufferCellPosition {
    x: number;
    y: number;
}
/**
 * A single line in the buffer
 */
declare interface IBufferLine {
    /** Length of the line (in columns) */
    readonly length: number;
    /** Whether this line wraps to the next line */
    readonly isWrapped: boolean;
    /**
     * Get a cell from this line
     * @param x Column index (0-indexed)
     * @returns Cell object or undefined if out of bounds
     */
    getCell(x: number): IBufferCell | undefined;
    /**
     * Translate the line to a string
     * @param trimRight Whether to trim trailing whitespace (default: false)
     * @param startColumn Start column (default: 0)
     * @param endColumn End column (default: length)
     * @returns String representation of the line
     */
    translateToString(trimRight?: boolean, startColumn?: number, endColumn?: number): string;
}
/**
 * Minimal buffer line interface for URL detection
 */
declare interface IBufferLineForUrlProvider {
    length: number;
    getCell(x: number): {
        getCodepoint(): number;
    } | undefined;
}
/**
 * Top-level buffer API namespace
 * Provides access to active, normal, and alternate screen buffers
 */
declare interface IBufferNamespace {
    /** The currently active buffer (normal or alternate) */
    readonly active: IBuffer;
    /** The normal buffer (primary screen) */
    readonly normal: IBuffer;
    /** The alternate buffer (used by full-screen apps like vim) */
    readonly alternate: IBuffer;
    /** Event fired when buffer changes (normal ↔ alternate) */
    readonly onBufferChange: IEvent<IBuffer>;
}
/**
 * Buffer range for selection coordinates
 */
export declare interface IBufferRange {
    start: {
        x: number;
        y: number;
    };
    end: {
        x: number;
        y: number;
    };
}
/**
 * Represents a range in the terminal buffer
 * Can span multiple lines for wrapped links
 */
declare interface IBufferRange_2 {
    start: IBufferCellPosition;
    end: IBufferCellPosition;
}
export declare interface IDisposable {
    dispose(): void;
}
export declare type IEvent<T> = (listener: (arg: T) => void) => IDisposable;
/**
 * Keyboard event with key and DOM event
 */
export declare interface IKeyEvent {
    key: string;
    domEvent: KeyboardEvent;
}
/**
 * Represents a detected link in the terminal
 */
export declare interface ILink {
    /** The URL or text of the link */
    text: string;
    /** The range of the link in the buffer (may span multiple lines) */
    range: IBufferRange_2;
    /** Called when the link is activated (clicked with modifier) */
    activate(event: MouseEvent): void;
    /** Optional: called when mouse enters/leaves the link */
    hover?(isHovered: boolean): void;
    /** Optional: called to clean up resources */
    dispose?(): void;
}
/**
 * Provides link detection for a specific type of link
 * Examples: OSC 8 hyperlinks, URL regex detection
 */
export declare interface ILinkProvider {
    /**
     * Provide links for a given row
     * @param y Absolute row in buffer (0-based)
     * @param callback Called with detected links (or undefined if none)
     */
    provideLinks(y: number, callback: (links: ILink[] | undefined) => void): void;
    /** Optional: called when terminal is disposed */
    dispose?(): void;
}
/**
 * Initialize the ghostty-web library by loading the WASM module.
 * Must be called before creating any Terminal instances.
 *
 * This creates a shared WASM instance that all Terminal instances will use.
 * For test isolation, pass a Ghostty instance directly to Terminal constructor.
 *
 * @example
 * ```typescript
 * import { init, Terminal } from 'ghostty-web';
 *
 * await init();
 * const term = new Terminal();
 * term.open(document.getElementById('terminal'));
 * ```
 */
export declare function init(): Promise<void>;
/**
 * InputHandler class
 * Attaches keyboard event listeners to a container and converts
 * keyboard events to terminal input data
 */
export declare class InputHandler {
    private encoder;
    private container;
    private onDataCallback;
    private onBellCallback;
    private onKeyCallback?;
    private customKeyEventHandler?;
    private getModeCallback?;
    private keydownListener;
    private keypressListener;
    private pasteListener;
    private compositionStartListener;
    private compositionUpdateListener;
    private compositionEndListener;
    private isComposing;
    private isDisposed;
    /**
     * Create a new InputHandler
     * @param ghostty - Ghostty instance (for creating KeyEncoder)
     * @param container - DOM element to attach listeners to
     * @param onData - Callback for terminal data (escape sequences to send to PTY)
     * @param onBell - Callback for bell/beep event
     * @param onKey - Optional callback for raw key events
     * @param customKeyEventHandler - Optional custom key event handler
     * @param getMode - Optional callback to query terminal mode state (for application cursor mode)
     */
    constructor(ghostty: Ghostty, container: HTMLElement, onData: (data: string) => void, onBell: () => void, onKey?: (keyEvent: IKeyEvent) => void, customKeyEventHandler?: (event: KeyboardEvent) => boolean, getMode?: (mode: number) => boolean);
    /**
     * Set custom key event handler (for runtime updates)
     */
    setCustomKeyEventHandler(handler: (event: KeyboardEvent) => boolean): void;
    /**
     * Attach keyboard event listeners to container
     */
    private attach;
    /**
     * Map KeyboardEvent.code to USB HID Key enum value
     * @param code - KeyboardEvent.code value
     * @returns Key enum value or null if unmapped
     */
    private mapKeyCode;
    /**
     * Extract modifier flags from KeyboardEvent
     * @param event - KeyboardEvent
     * @returns Mods flags
     */
    private extractModifiers;
    /**
     * Check if this is a printable character with no special modifiers
     * @param event - KeyboardEvent
     * @returns true if printable character
     */
    private isPrintableCharacter;
    /**
     * Handle keydown event
     * @param event - KeyboardEvent
     */
    private handleKeyDown;
    /**
     * Handle paste event from clipboard
     * @param event - ClipboardEvent
     */
    private handlePaste;
    /**
     * Handle compositionstart event
     */
    private handleCompositionStart;
    /**
     * Handle compositionupdate event
     */
    private handleCompositionUpdate;
    /**
     * Handle compositionend event
     */
    private handleCompositionEnd;
    /**
     * Dispose the InputHandler and remove event listeners
     */
    dispose(): void;
    /**
     * Check if handler is disposed
     */
    isActive(): boolean;
}
export declare interface IRenderable {
    getLine(y: number): GhosttyCell[] | null;
    getCursor(): {
        x: number;
        y: number;
        visible: boolean;
    };
    getDimensions(): {
        cols: number;
        rows: number;
    };
    isRowDirty(y: number): boolean;
    /** Returns true if a full redraw is needed (e.g., screen change) */
    needsFullRedraw?(): boolean;
    clearDirty(): void;
    /**
     * Get the full grapheme string for a cell at (row, col).
     * For cells with grapheme_len > 0, this returns all codepoints combined.
     * For simple cells, returns the single character.
     */
    getGraphemeString?(row: number, col: number): string;
}
declare interface IScrollbackProvider {
    getScrollbackLine(offset: number): GhosttyCell[] | null;
    getScrollbackLength(): number;
}
export declare interface ITerminalAddon {
    activate(terminal: ITerminalCore): void;
    dispose(): void;
}
export declare interface ITerminalCore {
    cols: number;
    rows: number;
    element?: HTMLElement;
    textarea?: HTMLTextAreaElement;
}
export declare interface ITerminalDimensions {
    cols: number;
    rows: number;
}
/**
 * Minimal terminal interface required by LinkDetector
 * Keeps coupling low and testing easy
 */
declare interface ITerminalForLinkDetector {
    buffer: {
        active: {
            getLine(y: number): {
                length: number;
                getCell(x: number): {
                    getHyperlinkId(): number;
                } | undefined;
            } | undefined;
        };
    };
}
/**
 * Minimal terminal interface required by OSC8LinkProvider
 */
declare interface ITerminalForOSC8Provider {
    buffer: {
        active: {
            length: number;
            getLine(y: number): {
                length: number;
                getCell(x: number): {
                    getHyperlinkId(): number;
                } | undefined;
            } | undefined;
        };
    };
    wasmTerm?: {
        getHyperlinkUri(id: number): string | null;
    };
}
/**
 * Minimal terminal interface required by UrlRegexProvider
 */
declare interface ITerminalForUrlProvider {
    buffer: {
        active: {
            getLine(y: number): IBufferLineForUrlProvider | undefined;
        };
    };
}
export declare interface ITerminalOptions {
    cols?: number;
    rows?: number;
    cursorBlink?: boolean;
    cursorStyle?: 'block' | 'underline' | 'bar';
    theme?: ITheme;
    scrollback?: number;
    fontSize?: number;
    fontFamily?: string;
    allowTransparency?: boolean;
    convertEol?: boolean;
    disableStdin?: boolean;
    smoothScrollDuration?: number;
    ghostty?: Ghostty;
}
export declare interface ITheme {
    foreground?: string;
    background?: string;
    cursor?: string;
    cursorAccent?: string;
    selectionBackground?: string;
    selectionForeground?: string;
    black?: string;
    red?: string;
    green?: string;
    yellow?: string;
    blue?: string;
    magenta?: string;
    cyan?: string;
    white?: string;
    brightBlack?: string;
    brightRed?: string;
    brightGreen?: string;
    brightYellow?: string;
    brightBlue?: string;
    brightMagenta?: string;
    brightCyan?: string;
    brightWhite?: string;
}
/**
 * Unicode version provider (xterm.js compatibility)
 */
export declare interface IUnicodeVersionProvider {
    readonly activeVersion: string;
}
/**
 * Physical key codes matching Ghostty's internal Key enum.
 * These values are used by Ghostty's key encoder to produce correct escape sequences.
 * Reference: ghostty/src/input/key.zig
 */
export declare enum Key {
    UNIDENTIFIED = 0,
    GRAVE = 1,// ` and ~
    BACKSLASH = 2,// \ and |
    BRACKET_LEFT = 3,// [ and {
    BRACKET_RIGHT = 4,// ] and }
    COMMA = 5,// , and <
    ZERO = 6,
    ONE = 7,
    TWO = 8,
    THREE = 9,
    FOUR = 10,
    FIVE = 11,
    SIX = 12,
    SEVEN = 13,
    EIGHT = 14,
    NINE = 15,
    EQUAL = 16,// = and +
    INTL_BACKSLASH = 17,
    INTL_RO = 18,
    INTL_YEN = 19,
    A = 20,
    B = 21,
    C = 22,
    D = 23,
    E = 24,
    F = 25,
    G = 26,
    H = 27,
    I = 28,
    J = 29,
    K = 30,
    L = 31,
    M = 32,
    N = 33,
    O = 34,
    P = 35,
    Q = 36,
    R = 37,
    S = 38,
    T = 39,
    U = 40,
    V = 41,
    W = 42,
    X = 43,
    Y = 44,
    Z = 45,
    MINUS = 46,// - and _
    PERIOD = 47,// . and >
    QUOTE = 48,// ' and "
    SEMICOLON = 49,// ; and :
    SLASH = 50,// / and ?
    ALT_LEFT = 51,
    ALT_RIGHT = 52,
    BACKSPACE = 53,
    CAPS_LOCK = 54,
    CONTEXT_MENU = 55,
    CONTROL_LEFT = 56,
    CONTROL_RIGHT = 57,
    ENTER = 58,
    META_LEFT = 59,
    META_RIGHT = 60,
    SHIFT_LEFT = 61,
    SHIFT_RIGHT = 62,
    SPACE = 63,
    TAB = 64,
    CONVERT = 65,
    KANA_MODE = 66,
    NON_CONVERT = 67,
    DELETE = 68,
    END = 69,
    HELP = 70,
    HOME = 71,
    INSERT = 72,
    PAGE_DOWN = 73,
    PAGE_UP = 74,
    DOWN = 75,
    LEFT = 76,
    RIGHT = 77,
    UP = 78,
    NUM_LOCK = 79,
    KP_0 = 80,
    KP_1 = 81,
    KP_2 = 82,
    KP_3 = 83,
    KP_4 = 84,
    KP_5 = 85,
    KP_6 = 86,
    KP_7 = 87,
    KP_8 = 88,
    KP_9 = 89,
    KP_PLUS = 90,// Keypad +
    KP_BACKSPACE = 91,
    KP_CLEAR = 92,
    KP_CLEAR_ENTRY = 93,
    KP_COMMA = 94,
    KP_PERIOD = 95,// Keypad .
    KP_DIVIDE = 96,// Keypad /
    KP_ENTER = 97,// Keypad Enter
    KP_EQUAL = 98,
    KP_MEMORY_ADD = 99,
    KP_MEMORY_CLEAR = 100,
    KP_MEMORY_RECALL = 101,
    KP_MEMORY_STORE = 102,
    KP_MEMORY_SUBTRACT = 103,
    KP_MULTIPLY = 104,// Keypad *
    KP_PAREN_LEFT = 105,
    KP_PAREN_RIGHT = 106,
    KP_MINUS = 107,// Keypad -
    KP_SEPARATOR = 108,
    NUMPAD_UP = 109,
    NUMPAD_DOWN = 110,
    NUMPAD_RIGHT = 111,
    NUMPAD_LEFT = 112,
    NUMPAD_BEGIN = 113,
    NUMPAD_HOME = 114,
    NUMPAD_END = 115,
    NUMPAD_INSERT = 116,
    NUMPAD_DELETE = 117,
    NUMPAD_PAGE_UP = 118,
    NUMPAD_PAGE_DOWN = 119,
    ESCAPE = 120,
    F1 = 121,
    F2 = 122,
    F3 = 123,
    F4 = 124,
    F5 = 125,
    F6 = 126,
    F7 = 127,
    F8 = 128,
    F9 = 129,
    F10 = 130,
    F11 = 131,
    F12 = 132,
    F13 = 133,
    F14 = 134,
    F15 = 135,
    F16 = 136,
    F17 = 137,
    F18 = 138,
    F19 = 139,
    F20 = 140,
    F21 = 141,
    F22 = 142,
    F23 = 143,
    F24 = 144,
    F25 = 145,
    FN_LOCK = 146,
    PRINT_SCREEN = 147,
    SCROLL_LOCK = 148,
    PAUSE = 149,
    BROWSER_BACK = 150,
    BROWSER_FAVORITES = 151,
    BROWSER_FORWARD = 152,
    BROWSER_HOME = 153,
    BROWSER_REFRESH = 154,
    BROWSER_SEARCH = 155,
    BROWSER_STOP = 156,
    EJECT = 157,
    LAUNCH_APP_1 = 158,
    LAUNCH_APP_2 = 159,
    LAUNCH_MAIL = 160,
    MEDIA_PLAY_PAUSE = 161,
    MEDIA_SELECT = 162,
    MEDIA_STOP = 163,
    MEDIA_TRACK_NEXT = 164,
    MEDIA_TRACK_PREVIOUS = 165,
    POWER = 166,
    SLEEP = 167,
    AUDIO_VOLUME_DOWN = 168,
    AUDIO_VOLUME_MUTE = 169,
    AUDIO_VOLUME_UP = 170,
    WAKE_UP = 171,
    COPY = 172,
    CUT = 173,
    PASTE = 174
}
/**
 * Key action
 */
export declare enum KeyAction {
    RELEASE = 0,
    PRESS = 1,
    REPEAT = 2
}
/**
 * Key Encoder - converts keyboard events into terminal escape sequences
 */
export declare class KeyEncoder {
    private exports;
    private encoder;
    constructor(exports: GhosttyWasmExports);
    setOption(option: KeyEncoderOption, value: boolean | number): void;
    setKittyFlags(flags: KittyKeyFlags): void;
    encode(event: KeyEvent): Uint8Array;
    dispose(): void;
}
/**
 * Key encoder options
 */
export declare enum KeyEncoderOption {
    CURSOR_KEY_APPLICATION = 0,// DEC mode 1
    KEYPAD_KEY_APPLICATION = 1,// DEC mode 66
    IGNORE_KEYPAD_WITH_NUMLOCK = 2,// DEC mode 1035
    ALT_ESC_PREFIX = 3,// DEC mode 1036
    MODIFY_OTHER_KEYS_STATE_2 = 4,// xterm modifyOtherKeys
    KITTY_KEYBOARD_FLAGS = 5
}
/**
 * Key event structure
 */
export declare interface KeyEvent {
    action: KeyAction;
    key: Key;
    mods: Mods;
    consumedMods?: Mods;
    composing?: boolean;
    utf8?: string;
    unshiftedCodepoint?: number;
}
/**
 * Kitty keyboard protocol flags
 * From include/ghostty/vt/key/encoder.h
 */
declare enum KittyKeyFlags {
    DISABLED = 0,
    DISAMBIGUATE = 1,// Disambiguate escape codes
    REPORT_EVENTS = 2,// Report press and release
    REPORT_ALTERNATES = 4,// Report alternate key codes
    REPORT_ALL = 8,// Report all events
    REPORT_ASSOCIATED = 16,// Report associated text
    ALL = 31
}
/**
 * Manages link detection across multiple providers with intelligent caching
 */
export declare class LinkDetector {
    private terminal;
    private providers;
    private linkCache;
    private scannedRows;
    constructor(terminal: ITerminalForLinkDetector);
    /**
     * Register a link provider
     */
    registerProvider(provider: ILinkProvider): void;
    /**
     * Get link at the specified buffer position
     * @param col Column (0-based)
     * @param row Absolute row in buffer (0-based)
     * @returns Link at position, or undefined if none
     */
    getLinkAt(col: number, row: number): Promise<ILink | undefined>;
    /**
     * Scan a row for links using all registered providers
     */
    private scanRow;
    /**
     * Cache a link for fast lookup
     */
    private cacheLink;
    /**
     * Check if a position is within a link's range
     */
    private isPositionInLink;
    /**
     * Invalidate cache when terminal content changes
     * Should be called on terminal write, resize, or clear
     */
    invalidateCache(): void;
    /**
     * Invalidate cache for specific rows
     * Used when only part of the terminal changed
     */
    invalidateRows(startRow: number, endRow: number): void;
    /**
     * Dispose and cleanup
     */
    dispose(): void;
}
/**
 * Modifier keys
 */
export declare enum Mods {
    NONE = 0,
    SHIFT = 1,
    CTRL = 2,
    ALT = 4,
    SUPER = 8,// Windows/Command key
    CAPSLOCK = 16,
    NUMLOCK = 32
}
/**
 * OSC 8 Hyperlink Provider
 *
 * Detects OSC 8 hyperlinks by scanning for hyperlink_id in cells.
 * Automatically handles multi-line links since Ghostty WASM preserves
 * hyperlink_id across wrapped lines.
 */
export declare class OSC8LinkProvider implements ILinkProvider {
    private terminal;
    constructor(terminal: ITerminalForOSC8Provider);
    /**
     * Provide all OSC 8 links on the given row
     * Note: This may return links that span multiple rows
     */
    provideLinks(y: number, callback: (links: ILink[] | undefined) => void): void;
    /**
     * Find the full extent of a link by scanning for contiguous cells
     * with the same hyperlink_id. Handles multi-line links.
     */
    private findLinkRange;
    dispose(): void;
}
export declare interface RendererOptions {
    fontSize?: number;
    fontFamily?: string;
    cursorStyle?: 'block' | 'underline' | 'bar';
    cursorBlink?: boolean;
    theme?: ITheme;
    devicePixelRatio?: number;
}
/**
 * Colors from RenderState (12 bytes packed)
 */
declare interface RenderStateColors {
    background: RGB;
    foreground: RGB;
    cursor: RGB | null;
}
/**
 * Cursor state from RenderState (8 bytes packed)
 * Layout: x(u16) + y(u16) + viewport_x(i16) + viewport_y(i16) + visible(bool) + blinking(bool) + style(u8) + _pad(u8)
 */
declare interface RenderStateCursor {
    x: number;
    y: number;
    viewportX: number;
    viewportY: number;
    visible: boolean;
    blinking: boolean;
    style: 'block' | 'underline' | 'bar';
}
/**
 * RGB color
 */
export declare interface RGB {
    r: number;
    g: number;
    b: number;
}
export declare interface SelectionCoordinates {
    startCol: number;
    startRow: number;
    endCol: number;
    endRow: number;
}
export declare class SelectionManager {
    private terminal;
    private renderer;
    private wasmTerm;
    private textarea;
    private selectionStart;
    private selectionEnd;
    private isSelecting;
    private mouseDownTarget;
    private dirtySelectionRows;
    private selectionChangedEmitter;
    private boundMouseUpHandler;
    private boundContextMenuHandler;
    private boundClickHandler;
    private boundDocumentMouseMoveHandler;
    private autoScrollInterval;
    private autoScrollDirection;
    private static readonly AUTO_SCROLL_EDGE_SIZE;
    /**
     * Get current viewport Y position (how many lines scrolled into history)
     */
    private getViewportY;
    /**
     * Convert viewport row to absolute buffer row
     * Absolute row is an index into combined buffer: scrollback (0 to len-1) + screen (len to len+rows-1)
     */
    private viewportRowToAbsolute;
    /**
     * Convert absolute buffer row to viewport row (may be outside visible range)
     */
    private absoluteRowToViewport;
    private static readonly AUTO_SCROLL_SPEED;
    private static readonly AUTO_SCROLL_INTERVAL;
    constructor(terminal: Terminal, renderer: CanvasRenderer, wasmTerm: GhosttyTerminal, textarea: HTMLTextAreaElement);
    /**
     * Get the selected text as a string
     */
    getSelection(): string;
    /**
     * Check if there's an active selection
     */
    hasSelection(): boolean;
    /**
     * Clear the selection
     */
    clearSelection(): void;
    /**
     * Select all text in the terminal
     */
    selectAll(): void;
    /**
     * Select text at specific column and row with length
     * xterm.js compatible API
     */
    select(column: number, row: number, length: number): void;
    /**
     * Select entire lines from start to end
     * xterm.js compatible API
     */
    selectLines(start: number, end: number): void;
    /**
     * Get selection position as buffer range
     * xterm.js compatible API
     */
    getSelectionPosition(): {
        start: {
            x: number;
            y: number;
        };
        end: {
            x: number;
            y: number;
        };
    } | undefined;
    /**
     * Deselect all text
     * xterm.js compatible API
     */
    deselect(): void;
    /**
     * Focus the terminal (make it receive keyboard input)
     */
    focus(): void;
    /**
     * Get current selection coordinates (for rendering)
     */
    getSelectionCoords(): SelectionCoordinates | null;
    /**
     * Get dirty selection rows that need redraw (for clearing old highlight)
     */
    getDirtySelectionRows(): Set<number>;
    /**
     * Clear the dirty selection rows tracking (after redraw)
     */
    clearDirtySelectionRows(): void;
    /**
     * Get selection change event accessor
     */
    get onSelectionChange(): IEvent<void>;
    /**
     * Cleanup resources
     */
    dispose(): void;
    /**
     * Attach mouse event listeners to canvas
     */
    private attachEventListeners;
    /**
     * Mark current selection rows as dirty for redraw
     */
    private markCurrentSelectionDirty;
    /**
     * Update auto-scroll based on mouse Y position within canvas
     */
    private updateAutoScroll;
    /**
     * Start auto-scrolling in the given direction
     */
    private startAutoScroll;
    /**
     * Stop auto-scrolling
     */
    private stopAutoScroll;
    /**
     * Convert pixel coordinates to terminal cell coordinates
     */
    private pixelToCell;
    /**
     * Normalize selection coordinates (handle backward selection)
     * Returns coordinates in VIEWPORT space for rendering, clamped to visible area
     */
    private normalizeSelection;
    /**
     * Get word boundaries at a cell position
     */
    private getWordAtCell;
    /**
     * Copy text to clipboard
     */
    private copyToClipboard;
    /**
     * Request a render update (triggers selection overlay redraw)
     */
    private requestRender;
}
export declare class Terminal implements ITerminalCore {
    cols: number;
    rows: number;
    element?: HTMLElement;
    textarea?: HTMLTextAreaElement;
    readonly buffer: IBufferNamespace;
    readonly unicode: IUnicodeVersionProvider;
    readonly options: Required<ITerminalOptions>;
    private ghostty?;
    wasmTerm?: GhosttyTerminal;
    renderer?: CanvasRenderer;
    private inputHandler?;
    private selectionManager?;
    private canvas?;
    private linkDetector?;
    private currentHoveredLink?;
    private mouseMoveThrottleTimeout?;
    private pendingMouseMove?;
    private dataEmitter;
    private resizeEmitter;
    private bellEmitter;
    private selectionChangeEmitter;
    private keyEmitter;
    private titleChangeEmitter;
    private scrollEmitter;
    private renderEmitter;
    private cursorMoveEmitter;
    readonly onData: IEvent<string>;
    readonly onResize: IEvent<{
        cols: number;
        rows: number;
    }>;
    readonly onBell: IEvent<void>;
    readonly onSelectionChange: IEvent<void>;
    readonly onKey: IEvent<IKeyEvent>;
    readonly onTitleChange: IEvent<string>;
    readonly onScroll: IEvent<number>;
    readonly onRender: IEvent<{
        start: number;
        end: number;
    }>;
    readonly onCursorMove: IEvent<void>;
    private isOpen;
    private isDisposed;
    private animationFrameId?;
    private addons;
    private customKeyEventHandler?;
    private currentTitle;
    viewportY: number;
    private targetViewportY;
    private scrollAnimationStartTime?;
    private scrollAnimationStartY?;
    private scrollAnimationFrame?;
    private customWheelEventHandler?;
    private lastCursorY;
    private isDraggingScrollbar;
    private scrollbarDragStart;
    private scrollbarDragStartViewportY;
    private scrollbarVisible;
    private scrollbarOpacity;
    private scrollbarHideTimeout?;
    private readonly SCROLLBAR_HIDE_DELAY_MS;
    private readonly SCROLLBAR_FADE_DURATION_MS;
    constructor(options?: ITerminalOptions);
    /**
     * Handle runtime option changes (called when options are modified after terminal is open)
     * This enables xterm.js compatibility where options can be changed at runtime
     */
    private handleOptionChange;
    /**
     * Handle font changes (fontSize or fontFamily)
     * Updates canvas size to match new font metrics and forces a full re-render
     */
    private handleFontChange;
    /**
     * Parse a CSS color string to 0xRRGGBB format.
     * Returns 0 if the color is undefined or invalid.
     */
    private parseColorToHex;
    /**
     * Convert terminal options to WASM terminal config.
     */
    private buildWasmConfig;
    /**
     * Open terminal in a parent element
     *
     * Initializes all components and starts rendering.
     * Requires a pre-loaded Ghostty instance passed to the constructor.
     */
    open(parent: HTMLElement): void;
    /**
     * Write data to terminal
     */
    write(data: string | Uint8Array, callback?: () => void): void;
    /**
     * Internal write implementation (extracted from write())
     */
    private writeInternal;
    /**
     * Write data with newline
     */
    writeln(data: string | Uint8Array, callback?: () => void): void;
    /**
     * Paste text into terminal (triggers bracketed paste if supported)
     */
    paste(data: string): void;
    /**
     * Input data into terminal (as if typed by user)
     *
     * @param data - Data to input
     * @param wasUserInput - If true, triggers onData event (default: false for compat with some apps)
     */
    input(data: string, wasUserInput?: boolean): void;
    /**
     * Resize terminal
     */
    resize(cols: number, rows: number): void;
    /**
     * Clear terminal screen
     */
    clear(): void;
    /**
     * Reset terminal state
     */
    reset(): void;
    /**
     * Focus terminal input
     */
    focus(): void;
    /**
     * Blur terminal (remove focus)
     */
    blur(): void;
    /**
     * Load an addon
     */
    loadAddon(addon: ITerminalAddon): void;
    /**
     * Get the selected text as a string
     */
    getSelection(): string;
    /**
     * Check if there's an active selection
     */
    hasSelection(): boolean;
    /**
     * Clear the current selection
     */
    clearSelection(): void;
    /**
     * Select all text in the terminal
     */
    selectAll(): void;
    /**
     * Select text at specific column and row with length
     */
    select(column: number, row: number, length: number): void;
    /**
     * Select entire lines from start to end
     */
    selectLines(start: number, end: number): void;
    /**
     * Get selection position as buffer range
     */
    /**
     * Get the current viewport Y position.
     *
     * This is the number of lines scrolled back from the bottom of the
     * scrollback buffer. It may be fractional during smooth scrolling.
     */
    getViewportY(): number;
    getSelectionPosition(): IBufferRange | undefined;
    /**
     * Attach a custom keyboard event handler
     * Returns true to prevent default handling
     */
    attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void;
    /**
     * Attach a custom wheel event handler (Phase 2)
     * Returns true to prevent default handling
     */
    attachCustomWheelEventHandler(customWheelEventHandler?: (event: WheelEvent) => boolean): void;
    /**
     * Register a custom link provider
     * Multiple providers can be registered to detect different types of links
     *
     * @example
     * ```typescript
     * term.registerLinkProvider({
     *   provideLinks(y, callback) {
     *     // Detect URLs, file paths, etc.
     *     callback(detectedLinks);
     *   }
     * });
     * ```
     */
    registerLinkProvider(provider: ILinkProvider): void;
    /**
     * Scroll viewport by a number of lines
     * @param amount Number of lines to scroll (positive = down, negative = up)
     */
    scrollLines(amount: number): void;
    /**
     * Scroll viewport by a number of pages
     * @param amount Number of pages to scroll (positive = down, negative = up)
     */
    scrollPages(amount: number): void;
    /**
     * Scroll viewport to the top of the scrollback buffer
     */
    scrollToTop(): void;
    /**
     * Scroll viewport to the bottom (current output)
     */
    scrollToBottom(): void;
    /**
     * Scroll viewport to a specific line in the buffer
     * @param line Line number (0 = top of scrollback, scrollbackLength = bottom)
     */
    scrollToLine(line: number): void;
    /**
     * Smoothly scroll to a target viewport position
     * @param targetY Target viewport Y position (in lines, can be fractional)
     */
    private smoothScrollTo;
    /**
     * Animation loop for smooth scrolling
     * Uses asymptotic approach - moves a fraction of remaining distance each frame
     */
    private animateScroll;
    /**
     * Dispose terminal and clean up resources
     */
    dispose(): void;
    /**
     * Start the render loop
     */
    private startRenderLoop;
    /**
     * Get a line from native WASM scrollback buffer
     * Implements IScrollbackProvider
     */
    getScrollbackLine(offset: number): GhosttyCell[] | null;
    /**
     * Get scrollback length from native WASM
     * Implements IScrollbackProvider
     */
    getScrollbackLength(): number;
    /**
     * Clean up components (called on dispose or error)
     */
    private cleanupComponents;
    /**
     * Assert terminal is open (throw if not)
     */
    private assertOpen;
    /**
     * Handle mouse move for link hover detection and scrollbar dragging
     * Throttled to avoid blocking scroll events (except when dragging scrollbar)
     */
    private handleMouseMove;
    /**
     * Process mouse move for link detection (internal, called by throttled handler)
     */
    private processMouseMove;
    /**
     * Handle mouse leave to clear link hover
     */
    private handleMouseLeave;
    /**
     * Handle mouse click for link activation
     */
    private handleClick;
    /**
     * Handle wheel events for scrolling (Phase 2)
     */
    private handleWheel;
    /**
     * Handle mouse down for scrollbar interaction
     */
    private handleMouseDown;
    /**
     * Handle mouse up for scrollbar drag
     */
    private handleMouseUp;
    /**
     * Process scrollbar drag movement
     */
    private processScrollbarDrag;
    /**
     * Show scrollbar with fade-in and schedule auto-hide
     */
    private showScrollbar;
    /**
     * Hide scrollbar with fade-out
     */
    private hideScrollbar;
    /**
     * Fade in scrollbar
     */
    private fadeInScrollbar;
    /**
     * Fade out scrollbar
     */
    private fadeOutScrollbar;
    /**
     * Process any pending terminal responses and emit them via onData.
     *
     * This handles escape sequences that require the terminal to send a response
     * back to the PTY, such as:
     * - DSR 6 (cursor position): Shell sends \x1b[6n, terminal responds with \x1b[row;colR
     * - DSR 5 (operating status): Shell sends \x1b[5n, terminal responds with \x1b[0n
     *
     * Without this, shells like nushell that rely on cursor position queries
     * will hang waiting for a response that never comes.
     */
    private processTerminalResponses;
    /**
     * Check for title changes in written data (OSC sequences)
     * Simplified implementation - looks for OSC 0, 1, 2
     */
    private checkForTitleChange;
    /**
     * Query terminal mode state
     *
     * @param mode Mode number (e.g., 2004 for bracketed paste)
     * @param isAnsi True for ANSI modes, false for DEC modes (default: false)
     * @returns true if mode is enabled
     */
    getMode(mode: number, isAnsi?: boolean): boolean;
    /**
     * Check if bracketed paste mode is enabled
     */
    hasBracketedPaste(): boolean;
    /**
     * Check if focus event reporting is enabled
     */
    hasFocusEvents(): boolean;
    /**
     * Check if mouse tracking is enabled
     */
    hasMouseTracking(): boolean;
}
/**
 * Opaque terminal pointer (WASM memory address)
 */
export declare type TerminalHandle = number;
/**
 * URL Regex Provider
 *
 * Detects plain text URLs on a single line using regex.
 * Does not support multi-line URLs or file paths.
 *
 * Supported protocols:
 * - https://, http://
 * - mailto:
 * - ftp://, ssh://, git://
 * - tel:, magnet:
 * - gemini://, gopher://, news:
 */
export declare class UrlRegexProvider implements ILinkProvider {
    private terminal;
    /**
     * URL regex pattern
     * Matches common protocols followed by valid URL characters
     * Excludes file paths (no ./ or ../ or bare /)
     */
    private static readonly URL_REGEX;
    /**
     * Characters to strip from end of URLs
     * Common punctuation that's unlikely to be part of the URL
     */
    private static readonly TRAILING_PUNCTUATION;
    constructor(terminal: ITerminalForUrlProvider);
    /**
     * Provide all regex-detected URLs on the given row
     */
    provideLinks(y: number, callback: (links: ILink[] | undefined) => void): void;
    /**
     * Convert a buffer line to plain text string
     */
    private lineToText;
    dispose(): void;
}
export { }
@@ -1,5 +1,5 @@
/** GET /api/v1/cloud/accounts carries a weak ETag and answers a repeat with 304 until an account or its use changes (#9206). */
import { afterAll, beforeAll, expect, spyOn, test } from "bun:test";
import { afterAll, beforeAll, expect, mock, spyOn, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
@@ -62,6 +62,9 @@
beforeAll(async () => {
  if (!added.ok) throw new Error(String(added.error));
}, 30_000);
afterAll(async () => {
  // The spy outlives this file otherwise: every later file in the same `bun test`
  // run would read a frozen clock, and setSystemTime would move nothing.
  mock.restore();
  servers.stop();
  app.close();
  await rm(dataDir, { recursive: true, force: true });
@@ -0,0 +1,34 @@
/**
 * A spy on a global (`Date`, `globalThis`, `Math`, `performance`, `process`)
 * outlives its file: `bun test` runs a shard's files in one process, so every
 * later file reads the spy — a `Date.now` frozen by one file made
 * `setSystemTime` move nothing in nine tests elsewhere in its shard (#9498).
 * A file that spies on one restores it (`mock.restore()` or `.mockRestore()`).
 */
import { expect, test } from "bun:test";
import { readdirSync, readFileSync } from "node:fs";
import { join } from "node:path";
const dir = new URL(".", import.meta.url).pathname;
const SPY = /spyOn\(\s*(Date|globalThis|Math|performance|process)\b/;
const RESTORE = /mock\.restore\(\)|\.mockRestore\(\)/;
/** The test files that spy on a global and never restore it. */
export function unrestored(files: ReadonlyArray<{ name: string; text: string }>): string[] {
  return files.filter((f) => SPY.test(f.text) && !RESTORE.test(f.text)).map((f) => f.name);
}
test("a spy on a global without a restore is named; one with a restore is not", () => {
  const spied = 'beforeAll(() => { spyOn(Date, "now").mockImplementation(() => 1); });';
  expect(unrestored([{ name: "a.test.ts", text: spied }])).toEqual(["a.test.ts"]);
  expect(unrestored([{ name: "b.test.ts", text: `${spied} afterAll(() => mock.restore());` }])).toEqual([]);
  expect(unrestored([{ name: "c.test.ts", text: 'spyOn(app, "send")' }])).toEqual([]);
});
test("every test file that spies on a global restores it", () => {
  const files = readdirSync(dir, { recursive: true })
    .map(String)
    .filter((name) => name.endsWith(".ts") && name !== "global-spies-restored.test.ts")
    .map((name) => ({ name, text: readFileSync(join(dir, name), "utf8") }));
  expect(unrestored(files)).toEqual([]);
});
@@ -0,0 +1,169 @@
/**
 * The machine shell page (#9472): a writer gets a terminal page at the
 * socket's own path, a reader is refused it; the machines list offers "Open
 * shell"; the page alone admits WebAssembly in its CSP and carries the
 * security floor; the terminal's script and WebAssembly are served immutable,
 * the script without the vendored module's inlined copy of the WebAssembly.
 * The wiring sends one resize frame per settled size, and a reattached
 * connection's first size redraws the screen (`resizePlan`).
 */
import { afterAll, beforeAll, expect, test } from "bun:test";
import { mkdtempSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { createRepo } from "../src/core/repos.ts";
import { createSession } from "../src/core/sessions.ts";
import { createUser } from "../src/core/users.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { resizePlan, RESIZE } from "../src/machines/shell.ts";
import { closedWords, resizeFrame, wire, type Size, type Term } from "../src/web/machine-term-wire.ts";
import { quietLogs } from "./helpers/globals.ts";
quietLogs();
let app: App;
let servers: Servers;
const cookies: Record<string, string> = {};
async function person(name: string): Promise<string> {
  const made = await createUser(app.db, { username: name, email: `${name}@x.test`, password: "correct horse battery", origin: "seed", trusted: true });
  if (!made.ok) throw new Error(String(made.error));
  cookies[name] = `forge_session=${createSession(app.db, made.value.id).token}`;
  return made.value.id;
}
beforeAll(async () => {
  app = createApp({ dataDir: mkdtempSync(join(tmpdir(), "machine-shell-page-")), port: 0 });
  const alice = await person("alice");
  await person("bob");
  for (const [name, visibility] of [["lab", "public"], ["shut", "private"]] as const) {
    const made = await createRepo(app.db, app.reposRoot, { ownerId: alice, name, visibility });
    if (!made.ok) throw new Error(String(made.error));
  }
  servers = await serve(app);
});
afterAll(() => {
  servers.stop();
  app.close();
});
const get = (path: string, who?: string) =>
  fetch(`${servers.url}${path}`, { headers: who === undefined ? {} : { cookie: cookies[who]! } });
test("a writer gets the terminal page, its CSP admitting WebAssembly and nothing looser", async () => {
  const res = await get("/alice/lab/machines/standard/shell", "alice");
  expect(res.status).toBe(200);
  const body = await res.text();
  expect(body).toContain('id="machine-term"');
  expect(body).toMatch(/data-wasm="\/assets\/ghostty-vt-[0-9a-f]{16}\.wasm"/);
  // Without JavaScript nothing connects: the server never claims to be
  // connecting, and a noscript line says what the shell needs.
  expect(body).not.toContain("Connecting");
  expect(body).toMatch(/<noscript>[^]*needs JavaScript[^]*<\/noscript>/);
  expect(body).toMatch(/<script type="module" src="\/assets\/machine-term-[0-9a-f]{16}\.js"><\/script>/);
  const csp = res.headers.get("content-security-policy") ?? "";
  expect(csp).toContain("script-src 'self' 'wasm-unsafe-eval';");
  expect(csp).not.toContain("unsafe-inline");
  expect(csp).not.toContain("'unsafe-eval'");
  expect(res.headers.get("x-content-type-options")).toBe("nosniff");
  expect(res.headers.get("referrer-policy")).toBe("same-origin");
});
test("a reader is refused the page; a stranger to a private repository and an undeclared machine get 404", async () => {
  expect((await get("/alice/lab/machines/standard/shell", "bob")).status).toBe(403);
  expect((await get("/alice/lab/machines/standard/shell")).status).toBe(403);
  expect((await get("/alice/shut/machines/standard/shell", "bob")).status).toBe(404);
  expect((await get("/alice/lab/machines/nope/shell", "alice")).status).toBe(404);
});
test("the machines list offers Open shell, and its own CSP admits no WebAssembly", async () => {
  const res = await get("/alice/lab/settings/machines", "alice");
  expect(res.status).toBe(200);
  const body = await res.text();
  expect(body).toContain('href="/alice/lab/machines/standard/shell"');
  expect(body).toContain("Open shell");
  expect(res.headers.get("content-security-policy")).not.toContain("wasm-unsafe-eval");
});
test("the terminal's script and WebAssembly are immutable, and the script carries no inlined WebAssembly", async () => {
  const page = await (await get("/alice/lab/machines/standard/shell", "alice")).text();
  const script = page.match(/\/assets\/machine-term-[0-9a-f]{16}\.js/)![0];
  const wasm = page.match(/\/assets\/ghostty-vt-[0-9a-f]{16}\.wasm/)![0];
  const js = await get(script);
  expect(js.status).toBe(200);
  expect(js.headers.get("cache-control")).toContain("immutable");
  const code = await js.text();
  expect(code).not.toContain("application/wasm;base64");
  expect(code.length).toBeLessThan(200_000);
  const bin = await get(wasm);
  expect(bin.status).toBe(200);
  expect(bin.headers.get("content-type")).toBe("application/wasm");
  expect(bin.headers.get("cache-control")).toContain("immutable");
  expect([...new Uint8Array(await bin.arrayBuffer()).slice(0, 4)]).toEqual([0, 0x61, 0x73, 0x6d]);
  expect((await get("/assets/ghostty-vt-0000000000000000.wasm")).status).toBe(404);
  expect((await get("/assets/machine-term-0000000000000000.js")).status).toBe(404);
});
/** A terminal whose box is whatever size the test says. */
function fakeTerm(): { term: Term; box: { size: Size }; typed: (text: string) => void; written: Uint8Array[] } {
  const box = { size: { cols: 80, rows: 24 } as Size };
  const written: Uint8Array[] = [];
  let listener: (text: string) => void = () => {};
  return {
    box,
    written,
    typed: (text) => listener(text),
    term: {
      write: (bytes) => written.push(bytes),
      onData: (l) => {
        listener = l;
      },
      resize: () => {},
      fit: () => box.size,
    },
  };
}
test("the wiring sends the size on open, one frame per new size, and keystrokes only while open", () => {
  const { term, box, typed, written } = fakeTerm();
  const frames: (string | Uint8Array)[] = [];
  const said: string[] = [];
  const wired = wire(term, (f) => frames.push(f), (w) => said.push(w));
  typed("early");
  expect(frames).toEqual([]);
  wired.opened();
  expect(frames).toEqual([resizeFrame({ cols: 80, rows: 24 })]);
  // A window dragged: many refits, one settled size, one frame.
  box.size = { cols: 120, rows: 40 };
  wired.refit();
  wired.refit();
  wired.refit();
  expect(frames.filter((f) => typeof f === "string")).toEqual([
    '{"type":"resize","cols":80,"rows":24}',
    '{"type":"resize","cols":120,"rows":40}',
  ]);
  typed("ls\r");
  expect(new TextDecoder().decode(frames.at(-1) as Uint8Array)).toBe("ls\r");
  wired.received(new Uint8Array([104, 105]));
  expect(written).toHaveLength(1);
  wired.closed(1011, "this forge cannot hold a machine's shell");
  expect(said.at(-1)).toBe("Disconnected: this forge cannot hold a machine's shell. Reload to reattach.");
  const count = frames.length;
  typed("late");
  box.size = { cols: 100, rows: 30 };
  wired.refit();
  expect(frames).toHaveLength(count);
  expect(closedWords(1000, "")).toBe("Disconnected: the shell exited. Reload to reattach.");
});
test("a joining connection's first size redraws the screen; a new size is set once; a repeat changes nothing", () => {
  const at = { cols: 80, rows: 24 };
  expect(resizePlan(at, { cols: 100, rows: 30 }, true)).toEqual([{ cols: 100, rows: 30 }]);
  expect(resizePlan(at, { cols: 100, rows: 30 }, false)).toEqual([{ cols: 100, rows: 30 }]);
  expect(resizePlan(at, { cols: 80, rows: 24 }, true)).toEqual([{ cols: 80, rows: 23 }, { cols: 80, rows: 24 }]);
  expect(resizePlan(at, { cols: 80, rows: 24 }, false)).toEqual([]);
  const one = { cols: 80, rows: RESIZE.rows.min };
  expect(resizePlan(one, one, true)).toEqual([{ cols: 80, rows: 2 }, one]);
});
@@ -59,6 +59,8 @@
beforeAll(async () => {
  if (!shut.ok) throw new Error(String(shut.error));
  // A row a crashed forge left open, closed when this one boots.
  staleRow = recordStart(app.db, repo.id, "standard", alice.id);
  // What main.ts does once no other forge holds the database.
  closeStaleSessions(app.db);
  servers = await serve(app);
  base = servers.url.replace(/^http/, "ws");
});
@@ -166,6 +168,36 @@
test("a writer's session echoes input, applies a resize, reattaches, and is reco
  expect(liveSessions(app)).toBe(0);
});
test("a reload's first size redraws the screen, though the size is the same; a repeat does not", async () => {
  const first = await open("alice");
  first.ws.send(JSON.stringify({ type: "resize", cols: 100, rows: 30 }));
  first.ws.send(new TextEncoder().encode("stty size\n"));
  await until(() => first.seen().includes("30 100"));
  // A program in the foreground redraws (here: prints its size) on every
  // change it is signalled, as tmux does; its output alone reaches a page.
  first.ws.send(new TextEncoder().encode("sh -c 'trap \"stty size\" WINCH; while :; do sleep 0.05; done'\n"));
  await Bun.sleep(200);
  first.ws.close(); // the reload
  await until(() => liveSessions(app) === 1 && first.ws.readyState === WebSocket.CLOSED);
  const second = await open("alice");
  expect(liveSessions(app)).toBe(1);
  second.ws.send(JSON.stringify({ type: "resize", cols: 100, rows: 30 }));
  await until(() => second.seen().includes("30 100"));
  const redraws = () => second.seen().split("30 100").length - 1;
  const after = redraws();
  // The same size again from the same page changes nothing.
  second.ws.send(JSON.stringify({ type: "resize", cols: 100, rows: 30 }));
  await Bun.sleep(300);
  expect(redraws()).toBe(after);
  const closed = new Promise((r) => second.ws.addEventListener("close", r));
  second.ws.send(new TextEncoder().encode("\x03"));
  second.ws.send(new TextEncoder().encode("exit\n"));
  await closed;
  await until(() => liveSessions(app) === 0);
}, 15_000);
test("a text frame that is not a resize ends the connection", async () => {
  const { ws } = await open("alice");
  const closed = new Promise<number>((r) => ws.addEventListener("close", (e) => r(e.code)));
@@ -28,7 +28,7 @@
import { quietLogs } from "./helpers/globals.ts";
quietLogs();
/** Parameters the seed supplies; any other parameter makes a pattern unseeded. */
const SEEDED = new Set(["owner", "name", "username", "number", "ref", "oid", "path", "env", "slug", "spec"]);
const SEEDED = new Set(["owner", "name", "username", "number", "ref", "oid", "path", "env", "slug", "spec", "machine"]);
const ORIGIN = "needs a connected origin account and a mirror job; the seed connects none";
const MIGRATE = "needs a migration job, which only an import creates";
@@ -156,7 +156,7 @@
beforeAll(async () => {
  if (!inserted.ok) throw new Error(inserted.error);
  Object.assign(fill, {
    owner: "ada", name: "notes", username: "ada", ref: "main", oid: pull.value.headOid,
    path: "a.txt", env: "prod", slug: "notes", spec: "192",
    path: "a.txt", env: "prod", slug: "notes", spec: "192", machine: "standard",
    issue: String(issue.value.number), pull: String(pull.value.number), run: run.id,
  });
  cookie = `forge_session=${createSession(app.db, ada.id).token}`;
@@ -40,8 +40,10 @@
test("unreached() follows imports from the entries and scripts, and nothing else
    put("src/a.ts", 'export const load = () => import(\n  "./b"\n);\n');
    put("src/b/index.ts", "export const t = () => import(`./tpl`);\n");
    put("src/b/tpl.ts");
    put("src/side.ts");
    put("src/c.ts");
    put("src/side.ts", 'Bun.build({ entrypoints: [Bun.fileURLToPath(new URL("./entry.ts", import.meta.url))] });\n');
    put("src/entry.ts");
    put("src/c.ts", 'const notAnEntry = new URL("./g.ts", "https://x");\n');
    put("src/g.ts");
    put("src/d.ts", 'import "./c.ts";\n');
    put("src/e.ts");
    put("src/a.test.ts", 'import "./e.ts";\n');
@@ -49,7 +51,7 @@
test("unreached() follows imports from the entries and scripts, and nothing else
    put("src/core/migrations/001.ts");
    put("src/f.ts");
    put("scripts/tool.ts", 'const { f } = await import("../src/f.ts");\n');
    expect(unreached(dir)).toEqual(["src/c.ts", "src/d.ts", "src/e.ts"]);
    expect(unreached(dir)).toEqual(["src/c.ts", "src/d.ts", "src/e.ts", "src/g.ts"]);
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
		@@ -7,3 +7,4 @@ This repository also contains third-party files under their own licenses:
7	7
8	8	- DejaVu fonts, src/web/og/vendor/DejaVu*.ttf: see src/web/og/vendor/DEJAVU-LICENSE.
9	9	- resvg, src/web/og/vendor/resvg.*: Mozilla Public License 2.0, https://github.com/thx/resvg-js and https://github.com/linebender/resvg.
	10	- ghostty-web 0.4.0, src/web/vendor/ghostty-web/: MIT License, Copyright (c) 2025 Coder, https://github.com/coder/ghostty-web; see src/web/vendor/ghostty-web/LICENSE.
		@@ -46,3 +46,8 @@ It lives at [forge.open-platform.sh/trevato/forge](https://forge.open-platform.s
46	46	GitHub holds a read-only mirror; issues and pulls are on the forge.
47	47
48	48	Open source under the [AGPL-3.0](LICENSE). See [contributing](CONTRIBUTING.md).
	49
	50	One dependency is vendored for browsers: [ghostty-web](https://github.com/coder/ghostty-web)
	51	0.4.0 (MIT, `src/web/vendor/ghostty-web`), the terminal on a machine's shell page —
	52	about 75 KB of script and a 423 KB WebAssembly file, both cached immutable and
	53	loaded on that page only. See [NOTICE](NOTICE).
		@@ -0,0 +1,17 @@
	1	# Machines
	2
	3	A machine's shell page, `/:owner/:name/machines/:machine/shell`
	4	(`src/web/pages/machines.ts`, its rules in `MACHINE_SHELL_CSS`, shipped as the
	5	page's own style). The list at `/:owner/:name/settings/machines` uses the
	6	table and `btn` it already had; no new class there.
	7
	8	- `.machine-term` — the box the terminal (ghostty-web's canvas) draws in:
	9	its height is fixed to the window below the page head (`100dvh` less
	10	`--machine-term-above`, the named sum of what sits over it, never under 320px), so nothing moves when the terminal arrives or the
	11	socket opens; a bordered surface on the page background, its overflow
	12	clipped. Its `data-wasm` names the emulator's WebAssembly.
	13	- `.machine-term-status` — the one-line status above the box (connecting,
	14	connected, why it closed): reserves its line (1.5em) so the box never
	15	shifts as the words change; muted text, a polite live region. The server
	16	renders it empty and the script says "Connecting…"; without JavaScript a
	17	`<noscript>` line in the same class says the shell needs it.
		@@ -90,9 +90,49 @@ repository's machines:
90	90	on its own for a writer who is not one), and in the terminal: the palette's
91	91	Machines of a repository (`src/tui/screens/machines.ts`), writers only.
92	92
	93	## The shell in the browser (#9472)
	94
	95	`/<owner>/<repo>/settings/machines` lists the machines with Open shell,
	96	which goes to `/<owner>/<repo>/machines/<machine>/shell`: the same path as the
	97	socket, answered as a page when it is not an upgrade. Writers only, like the
	98	socket (a reader is refused 403; a private repository or an undeclared
	99	machine answers 404). The page renders on the server and draws the terminal
	100	with one script:
	101
	102	- The emulator is [ghostty-web](https://github.com/coder/ghostty-web)
	103	0.4.0, vendored unmodified in `src/web/vendor/ghostty-web` (MIT; what was copied and
	104	its hashes are in its README). `src/web/machine-term-asset.ts` bundles it
	105	with the page's client (`src/web/machine-term-client.ts`) into
	106	`/assets/machine-term-<hash>.js` (about 75 KB, dropping the module's own
	107	inlined copy of the WebAssembly) and serves `ghostty-vt.wasm` at
	108	`/assets/ghostty-vt-<hash>.wasm` (423 KB); both are content-addressed and
	109	cached immutable.
	110	- The interface to it is thin: `Term` in `src/web/machine-term-wire.ts`
	111	is `write`, `onData`, `resize` and `fit`, and all of the protocol
	112	(`wire`) is written against that, so it is tested without a browser and the
	113	emulator can be swapped without touching it.
	114	- CSP. Only this page adds `'wasm-unsafe-eval'` to `script-src` (the
	115	page option `wasm` in `src/web/layout.ts`): it admits compiling
	116	WebAssembly, not `eval` or inline script. Every other page's policy is
	117	unchanged.
	118	- Reload. A reload opens a new socket, which joins the person's running
	119	session (above). On open the page sends its size; a connection's first
	120	size equal to the pty's own makes the server pass the pty through one row
	121	less for 30 ms (`resizePlan`, `src/machines/shell.ts`), because the kernel
	122	signals only a change and tmux redraws the whole screen on the signal. So
	123	the reloaded page shows the screen, not a blank one.
	124	- Resize. The page refits the terminal to its box when the box changes
	125	(debounced 100 ms) and sends one resize frame per new size, never the same
	126	size twice; tmux redraws the prompt at the new size.
	127	- Closed. The status line says why the socket closed (the shell exited,
	128	idle, the forge cannot hold a shell) and to reload to reattach.
	129
	130	Try it: on a preview, sign in as a writer of a repository, open
	131	`/<owner>/<repo>/settings/machines`, press Open shell on `standard`. A
	132	forge that cannot hold a cell says so in the status line and closes.
	133
93	134	## Not done yet (split from #9418)
94	135
95	136	Disk ceilings are not declared (#9460); the tools are declared, not yet
96		installed in an image (the brief reports which are on PATH); the browser terminal (ghostty-web) that speaks to the
97		shell socket is not built; the shell's cell does not reach the repository's
	137	installed in an image (the brief reports which are on PATH); the shell's cell does not reach the repository's
98	138	apps even when its machine says `apps`.
		@@ -85,7 +85,7 @@ export type Baseline = { files: Record<string, Counts> };
85	85	export type Finding = { line: number; kind: "colour" \| "size"; text: string; use: string };
86	86	export type Scan = Baseline & { classes: string[]; found?: Record<string, Finding[]> };
87	87
88		const SKIP = /(^\|\/)(og\/vendor)\//;
	88	const SKIP = /(^\|\/)(og\/vendor\|web\/vendor)\//;
89	89
90	90	export function sourceFiles(root: string): string[] {
91	91	const out: string[] = [];
		@@ -23,14 +23,17 @@ export const ENTRIES = [
23	23	"src/git/hook-entry.ts",
24	24	];
25	25
26		/** Scripts the check and operators run are callers too: their imports count. */
27		const SCRIPTS = "scripts/*/.ts";
	26	/** Scripts the check and operators run, and the benches run at release, are callers too: their imports count. */
	27	const SCRIPTS = ["scripts/*/.ts", "bench/*/.ts"];
28	28
29	29	/** Not modules: tests, and migrations, which the runner finds by listing the directory. */
30	30	const NOT_MODULES = /(?:\.test\.ts$\|^src\/core\/migrations\/)/;
31	31
32	32	const SPEC = /(?:\bfrom\s\|\bimport\s\(?\s)["'`](\.{1,2}\/[^"'`])["'`]/g;
33	33
	34	/** A module named as a URL beside this one, the way a `Bun.build` entry point is: `new URL("./x.ts", import.meta.url)`. */
	35	const URL_SPEC = /\bnew\s+URL\(\s["'`](\.{1,2}\/[^"'`])["'`]\s,\simport\.meta\.url\s*\)/g;
	36
34	37	/** The src/ file a relative specifier names, among `files`, or undefined. */
35	38	function resolve(from: string, spec: string, files: Set<string>): string \| undefined {
36	39	const base = normalize(join(dirname(from), spec)).replace(/\.(js\|ts)$/, "");
		@@ -43,10 +46,10 @@ export function unreached(root: string): string[] {
43	46	[...new Bun.Glob("src/*/.ts").scanSync({ cwd: root })].filter((f) => !f.endsWith(".d.ts") && !NOT_MODULES.test(f)),
44	47	);
45	48	const reached = new Set<string>(ENTRIES.filter((e) => files.has(e)));
46		const queue = [...reached, ...new Bun.Glob(SCRIPTS).scanSync({ cwd: root })];
	49	const queue = [...reached, ...SCRIPTS.flatMap((g) => [...new Bun.Glob(g).scanSync({ cwd: root })])];
47	50	for (let file = queue.pop(); file; file = queue.pop()) {
48	51	const text = readFileSync(join(root, file), "utf8");
49		for (const m of text.matchAll(SPEC)) {
	52	for (const m of [...text.matchAll(SPEC), ...text.matchAll(URL_SPEC)]) {
50	53	const target = resolve(file, m[1]!, files);
51	54	if (target && !reached.has(target)) {
52	55	reached.add(target);
		@@ -246,6 +246,9 @@ export interface TerminalProgram {
246	246	readonly hangup: () => void;
247	247	}
248	248
	249	/** Where `setsid` is, found once; null on a host without util-linux. */
	250	const SETSID = Bun.which("setsid");
	251
249	252	/**
250	253	* Start `command` (through `sh -c`) on `terminal`, held in `cell` when
251	254	* there is one. Without a cell the program leads a process group of its
		@@ -265,11 +268,20 @@ export function startTerminal(
265	268	},
266	269	): TerminalProgram {
267	270	const { cell } = options;
268		const proc = Bun.spawn(cell?.argv(command) ?? ["/bin/sh", "-c", command], {
	271	const argv = cell?.argv(command) ?? ["/bin/sh", "-c", command];
	272	// Bun's `terminal` gives the child the pty as its stdio but not as its
	273	// controlling terminal, so the kernel has no one to tell of a resize: no
	274	// SIGWINCH, and tmux never redraws at the new size (#9472). `setsid -c`
	275	// (util-linux, Essential on the image's Debian) makes the program lead a
	276	// session whose controlling terminal is the pty, in place: it is not a
	277	// group leader yet, so setsid execs rather than forks, the pid stays, and
	278	// the group is the program's own as `detached` made it.
	279	const ctty = SETSID !== null;
	280	const proc = Bun.spawn(ctty ? [SETSID, "-c", ...argv] : argv, {
269	281	terminal: options.terminal,
270	282	env: cell?.env(options.env) ?? options.env,
271	283	cwd: options.cwd,
272		detached: cell === undefined,
	284	detached: !ctty && cell === undefined,
273	285	});
274	286	const exited = proc.exited.then((code) => {
275	287	cell?.close();
		@@ -535,7 +535,8 @@ import {
535	535	import { getVerifiedDomain } from "../core/domains.ts";
536	536	import { previewOwner } from "../spawn/preview-owner.ts";
537	537	import { cellsAvailable } from "../apps/contain.ts";
538		import { machinesSettingsPage } from "../web/pages/machines.ts";
	538	import { machineShellPage, machinesSettingsPage } from "../web/pages/machines.ts";
	539	import { machineTermAsset, wasmResponse, ghosttyWasmAsset } from "../web/machine-term-asset.ts";
539	540	import {
540	541	defaultCommand,
541	542	mayOpenShell,
		@@ -544,7 +545,6 @@ import {
544	545	shellTarget,
545	546	stopShells,
546	547	withShells,
547		closeStaleSessions,
548	548	type ForgeSocket,
549	549	type ShellSocket,
550	550	} from "../machines/shell.ts";
		@@ -726,6 +726,10 @@ export function buildRouter(): Router<Handler> {
726	726	if (ctx.params.name === TOOLBAR_NAME) return toolbarResponse(ctx.request);
727	727	const own = pageScriptNamed(ctx.params.name!, ctx.app.config.dataDir);
728	728	if (own !== undefined) return fileResponse(ctx.request, own);
	729	if (ctx.params.name!.startsWith("machine-term-")) {
	730	const term = await machineTermAsset();
	731	return term !== null && ctx.params.name === term.name ? assetResponse(ctx.request, term) : notFound();
	732	}
729	733	const asset = await highlightAsset();
730	734	if (asset === null \|\| ctx.params.name !== asset.name) return notFound();
731	735	return assetResponse(ctx.request, asset);
		@@ -734,6 +738,10 @@ export function buildRouter(): Router<Handler> {
734	738	router.add("GET", "/assets/:name.svg", (ctx) =>
735	739	ctx.params.name === spriteAsset().name ? fileResponse(ctx.request, spriteAsset()) : notFound(),
736	740	);
	741	// The machine shell's terminal emulator (`web/machine-term-asset.ts`).
	742	router.add("GET", "/assets/:name.wasm", (ctx) =>
	743	ctx.params.name === ghosttyWasmAsset().name ? wasmResponse(ctx.request) : notFound(),
	744	);
737	745	router.add("GET", "/assets/:name.json", (ctx) =>
738	746	ctx.params.name === speculationAsset().name ? fileResponse(ctx.request, speculationAsset()) : notFound(),
739	747	);
		@@ -1371,6 +1379,8 @@ export function buildRouter(): Router<Handler> {
1371	1379	);
1372	1380	router.add("GET", "/:owner/:name/settings/app", appSettingsPage);
1373	1381	router.add("GET", "/:owner/:name/settings/machines", machinesSettingsPage);
	1382	// The shell page; an upgrade at the same path is the socket (`machines/shell.ts`).
	1383	router.add("GET", "/:owner/:name/machines/:machine/shell", machineShellPage);
1374	1384	router.add("POST", "/:owner/:name/settings/app", appSettingsUpdate);
1375	1385	router.add("POST", "/:owner/:name/settings/app/disable", appDisable);
1376	1386	router.add("POST", "/:owner/:name/settings/app/members", appMembersUpdate);
		@@ -2161,8 +2171,6 @@ export function forgeHttp(app: App): ForgeHttp {
2161	2171
2162	2172	export async function serve(app: App): Promise<Servers> {
2163	2173	const router = buildRouter();
2164		// No shell outlives its forge: a row a stop or crash left open is closed.
2165		closeStaleSessions(app.db);
2166	2174	const apiRouter = buildApiRouter();
2167	2175	await clearStaleSockets(app);
2168	2176	// One limiter per listener: its state is a minute of timestamps, and two
		@@ -127,6 +127,28 @@ export function parseControl(text: string): { cols: number; rows: number } \| und
127	127	return { cols, rows };
128	128	}
129	129
	130	export interface PtySize {
	131	readonly cols: number;
	132	readonly rows: number;
	133	}
	134
	135	/**
	136	* The sizes to give the pty for a resize frame, in order. A new size is set
	137	* once. A connection's first frame at the size the pty already has (a
	138	* reload, a second tab) passes through one row less first: the kernel only
	139	* signals a change, and tmux redraws the whole screen on the signal, so the
	140	* page that joined sees the screen rather than a blank one. A later frame at
	141	* the same size changes nothing.
	142	*/
	143	export function resizePlan(current: PtySize, next: PtySize, firstFromPeer: boolean): PtySize[] {
	144	if (current.cols !== next.cols \|\| current.rows !== next.rows) return [next];
	145	if (!firstFromPeer) return [];
	146	return [{ cols: next.cols, rows: next.rows > RESIZE.rows.min ? next.rows - 1 : next.rows + 1 }, next];
	147	}
	148
	149	/** How long the pty holds the nudged size before the real one, so the program sees two changes. */
	150	export const REDRAW_NUDGE_MS = 30;
	151
130	152	// ---- the records ----
131	153
132	154	export type EndReason = "exit" \| "idle" \| "stopped" \| "revoked" \| "failed";
		@@ -205,6 +227,8 @@ export interface ShellSocket {
205	227	readonly shell: ShellGrant & { readonly app: App };
206	228	joined?: Session;
207	229	release?: () => void;
	230	/** This connection has sent a size; its first one redraws a joined screen (`resizePlan`). */
	231	sized?: boolean;
208	232	}
209	233
210	234	type Peer = Bun.ServerWebSocket<ShellSocket>;
		@@ -217,6 +241,8 @@ interface Session {
217	241	readonly terminal: Bun.Terminal;
218	242	readonly program: TerminalProgram;
219	243	readonly peers: Set<Peer>;
	244	/** The pty's size, as last set. */
	245	size: PtySize;
220	246	lastInput: number;
221	247	ended: boolean;
222	248	readonly timer: ReturnType<typeof setInterval>;
		@@ -387,6 +413,7 @@ function start(app: App, grant: ShellGrant, opts: ShellOptions, cols: number, ro
387	413	terminal: term,
388	414	program,
389	415	peers,
	416	size: { cols, rows },
390	417	lastInput: Date.now(),
391	418	ended: false,
392	419	timer: setInterval(
		@@ -460,7 +487,16 @@ export const shellWebSocket = {
460	487	ws.close(1003, "a text frame is a resize");
461	488	return;
462	489	}
463		if (!session.terminal.closed) session.terminal.resize(resize.cols, resize.rows);
	490	const plan = resizePlan(session.size, resize, ws.data.sized !== true);
	491	ws.data.sized = true;
	492	session.size = resize;
	493	const apply = (size: PtySize): void => {
	494	if (!session.ended && !session.terminal.closed) session.terminal.resize(size.cols, size.rows);
	495	};
	496	const [first, ...rest] = plan;
	497	if (first !== undefined) apply(first);
	498	// A newer frame in the meantime is the size that stands; this one is dropped.
	499	if (rest.length > 0) setTimeout(() => session.size === resize && rest.forEach(apply), REDRAW_NUDGE_MS);
464	500	return;
465	501	}
466	502	if (message.byteLength > MAX_INPUT_BYTES) {
		@@ -98,6 +98,7 @@ import { stallLine } from "./perf/loop.ts";
98	98	import { bootStall, gitRecord, loopWatch, perfRecord } from "./perf/live.ts";
99	99	import { timeStatements } from "./kernel/slow_sql.ts";
100	100	import { waitForPeer } from "./runs/peer.ts";
	101	import { closeStaleSessions } from "./machines/shell.ts";
101	102
102	103	// `forge hook <name>` re-enters here from a git hook stub. It relays to the
103	104	// running forge over its socket and exits — it must never boot a server.
		@@ -425,6 +426,10 @@ const earlySignals = ["SIGINT", "SIGTERM", "SIGHUP"] as const;
425	426	for (const signal of earlySignals) process.once(signal, leaveEarly);
426	427	await waitForPeer(app.db, app.log);
427	428	for (const signal of earlySignals) process.off(signal, leaveEarly);
	429	// No shell outlives its forge: a row a stop or crash left open is closed. Only
	430	// once the other forge has let go: its shells are live until then, and a write
	431	// at boot would wait on its lock with the event loop held (#9472).
	432	closeStaleSessions(app.db);
428	433	// A repository's own check, on every push a pull or the default branch takes.
429	434	const checks =
430	435	process.env.FORGE_CHECKS === "0"