@dynamicagents/plugins 0.12.0 → 0.13.0

package/dist/workspace/read.d.ts

@@ -0,0 +1,16 @@
+import type { WorkspaceClient } from "@cloudflare/computer";
+/**
+ * Does this path exist?
+ *
+ * `getWorkspace()` types `fs` as the in-process `WorkspaceFilesystem`, but the
+ * value on the far side of a Durable Object boundary is a
+ * `WorkspaceFilesystemStub`, which carries a few methods the local class does
+ * not — `exists` among them. So the fast path is asked for rather than cast to,
+ * and `stat` is the fallback for a host that hands back a local workspace.
+ *
+ * The fallback treats *any* `stat` failure as absence, which is the honest
+ * reading for a tool whose entire answer is a boolean: there is no error channel
+ * to distinguish "missing" from "unreadable", and the caller's next move — look
+ * somewhere else — is the same either way.
+ */
+export declare function pathExists(fs: WorkspaceClient["fs"], path: string): Promise<boolean>;

package/dist/workspace/read.js

@@ -0,0 +1,22 @@
+/**
+ * Does this path exist?
+ *
+ * `getWorkspace()` types `fs` as the in-process `WorkspaceFilesystem`, but the
+ * value on the far side of a Durable Object boundary is a
+ * `WorkspaceFilesystemStub`, which carries a few methods the local class does
+ * not — `exists` among them. So the fast path is asked for rather than cast to,
+ * and `stat` is the fallback for a host that hands back a local workspace.
+ *
+ * The fallback treats *any* `stat` failure as absence, which is the honest
+ * reading for a tool whose entire answer is a boolean: there is no error channel
+ * to distinguish "missing" from "unreadable", and the caller's next move — look
+ * somewhere else — is the same either way.
+ */
+export async function pathExists(fs, path) {
+    // Called as a method, never through `.call`: on an RPC stub `.call` is read as
+    // a remote method, and the stub it would pass as `this` cannot be serialised.
+    const remote = fs;
+    if (typeof remote.exists === "function")
+        return remote.exists(path);
+    return fs.stat(path).then(() => true, () => false);
+}

package/dist/{computer → workspace}/shell.d.ts

@@ -1,11 +1,11 @@
 /**
- * Run a command under {@link file://./index.ts ComputerConfig.shell} with its
+ * Run a command under {@link file://./exec.ts WorkspaceClientConfig.shell} with its
  * two output streams left as they are, or hand it back untouched when no shell
  * is configured.
  *
  * This is the variant for a caller that **reads the result in code**: `stdout` is
  * a data channel it compares or parses, and `stderr` is a separate diagnostic.
- * {@link file://./index.ts computerExec} is that caller, on behalf of
+ * {@link file://./exec.ts workspaceExec} is that caller, on behalf of
  * `@dynamicagents/plugins/repo`, which asks git questions like
  * `symbolic-ref --short refs/remotes/origin/HEAD` and `rev-list --count` and
  * needs the answer alone.
@@ -19,12 +19,12 @@
  */
 export declare function withShell(command: string, shell: string | undefined): string;
 /**
- * Run a command under {@link file://./index.ts ComputerConfig.shell} with its
+ * Run a command under {@link file://./exec.ts WorkspaceClientConfig.shell} with its
  * two output streams merged into one transcript, in the order they were
  * written.
  *
  * This is the variant for a caller whose consumer is **a model reading output**.
- * `sb_exec` is that caller. A project's check is a chain — `wrangler types &&
+ * `bash` is that caller. A project's check is a chain — `wrangler types &&
  * prettier && eslint && tsc` — and *which tool spoke last* is how you know which
  * one failed. A stdout block and a separate stderr block destroy that ordering,
  * and a model that wants it back re-runs the whole gate as
@@ -38,7 +38,7 @@ export declare function withShell(command: string, shell: string | undefined): s
  *
  * With no shell configured there is no wrapper process to redirect, so the
  * command goes to the runtime untouched and the two streams arrive separate.
- * That is not a gap: {@link file://./render.ts renderResult} renders them as a
+ * That is not a gap: {@link file://../computer/render.ts renderResult} renders them as a
  * labelled `--- stderr ---` block for exactly this case. The transcript is the
  * better answer, not the only supported one.
  */

package/dist/{computer → workspace}/shell.js

@@ -23,20 +23,20 @@ import { shellQuote } from "@cloudflare/computer";
  * truncated with both ends kept.
  *
  * Requires a shell that implements it — `bash`, `zsh`, `ksh`, not `sh`/dash. A
- * host setting {@link file://./index.ts ComputerConfig.shell} is choosing that
+ * host setting {@link file://./exec.ts WorkspaceClientConfig.shell} is choosing that
  * shell explicitly.
  */
 function wrapped(command, shell) {
     return `${shell} -o pipefail -c ${shellQuote(command)}`;
 }
 /**
- * Run a command under {@link file://./index.ts ComputerConfig.shell} with its
+ * Run a command under {@link file://./exec.ts WorkspaceClientConfig.shell} with its
  * two output streams left as they are, or hand it back untouched when no shell
  * is configured.
  *
  * This is the variant for a caller that **reads the result in code**: `stdout` is
  * a data channel it compares or parses, and `stderr` is a separate diagnostic.
- * {@link file://./index.ts computerExec} is that caller, on behalf of
+ * {@link file://./exec.ts workspaceExec} is that caller, on behalf of
  * `@dynamicagents/plugins/repo`, which asks git questions like
  * `symbolic-ref --short refs/remotes/origin/HEAD` and `rev-list --count` and
  * needs the answer alone.
@@ -52,12 +52,12 @@ export function withShell(command, shell) {
     return shell ? wrapped(command, shell) : command;
 }
 /**
- * Run a command under {@link file://./index.ts ComputerConfig.shell} with its
+ * Run a command under {@link file://./exec.ts WorkspaceClientConfig.shell} with its
  * two output streams merged into one transcript, in the order they were
  * written.
  *
  * This is the variant for a caller whose consumer is **a model reading output**.
- * `sb_exec` is that caller. A project's check is a chain — `wrangler types &&
+ * `bash` is that caller. A project's check is a chain — `wrangler types &&
  * prettier && eslint && tsc` — and *which tool spoke last* is how you know which
  * one failed. A stdout block and a separate stderr block destroy that ordering,
  * and a model that wants it back re-runs the whole gate as
@@ -71,7 +71,7 @@ export function withShell(command, shell) {
  *
  * With no shell configured there is no wrapper process to redirect, so the
  * command goes to the runtime untouched and the two streams arrive separate.
- * That is not a gap: {@link file://./render.ts renderResult} renders them as a
+ * That is not a gap: {@link file://../computer/render.ts renderResult} renders them as a
  * labelled `--- stderr ---` block for exactly this case. The transcript is the
  * better answer, not the only supported one.
  */

package/dist/{computer/host → workspace}/wake.d.ts

@@ -12,7 +12,7 @@ export type WorkspaceWakeHandlers = {
     installRun: () => Promise<void>;
     installWatch: () => Promise<void>;
     idleReclaim: () => Promise<void>;
-    /** Start a cold container before a command needs it — see `./workspace.ts`. */
+    /** Start a cold container before a command needs it — see `./object.ts`. */
     containerWarm: () => Promise<void>;
     containerIdle: (payload?: SyncDrainIntent) => Promise<void>;
     syncRetry: (payload?: SyncDrainIntent) => Promise<void>;

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@dynamicagents/plugins",
-  "version": "0.12.0",
-  "description": "Optional, composable capabilities for a Dynamic Agent: ARC-AGI-3, browser rendering, a Linux container, git and pull requests, workspace, episodic recall, and pre-turn triage. One subpath per plugin, so a bundle grows only with what it imports.",
+  "version": "0.13.0",
+  "description": "Optional, composable capabilities for a Dynamic Agent: browser rendering, a Linux container, git and pull requests, a scratchpad, and Claude Code sessions. One subpath per plugin, so a bundle grows only with what it imports.",
   "keywords": [
     "ai-agents",
     "cloudflare-workers",
     "durable-objects",
     "agents-sdk",
-    "arc-agi",
-    "vectorize",
     "browser-rendering",
     "containers",
     "git",
@@ -32,26 +30,10 @@
     "LICENSE"
   ],
   "exports": {
-    "./arc-agi": {
-      "types": "./dist/arc-agi/index.d.ts",
-      "import": "./dist/arc-agi/index.js"
-    },
     "./browser": {
       "types": "./dist/browser/index.d.ts",
       "import": "./dist/browser/index.js"
     },
-    "./workspace": {
-      "types": "./dist/workspace/index.d.ts",
-      "import": "./dist/workspace/index.js"
-    },
-    "./recall": {
-      "types": "./dist/recall/index.d.ts",
-      "import": "./dist/recall/index.js"
-    },
-    "./triage": {
-      "types": "./dist/triage/index.d.ts",
-      "import": "./dist/triage/index.js"
-    },
     "./repo": {
       "types": "./dist/repo/index.d.ts",
       "import": "./dist/repo/index.js"
@@ -64,6 +46,10 @@
       "types": "./dist/claude-code/index.d.ts",
       "import": "./dist/claude-code/index.js"
     },
+    "./workspace": {
+      "types": "./dist/workspace/index.d.ts",
+      "import": "./dist/workspace/index.js"
+    },
     "./computer": {
       "types": "./dist/computer/index.d.ts",
       "import": "./dist/computer/index.js"
@@ -80,29 +66,24 @@
     "check": "npm run verify:peer-ranges && npm run verify:references && npm run types:check && prettier --check . && eslint . && tsc && npm run build && npm run verify:exports",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:record": "RECORD=1 vitest run recorded.spec.ts",
     "verify:exports": "node scripts/verify-exports.mjs",
     "verify:references": "node scripts/verify-references.mjs",
     "verify:peer-ranges": "node scripts/verify-peer-ranges.mjs",
+    "probe:claude-code": "npm run build && node scripts/probe-claude-code.mjs",
     "prepack": "npm run build && npm run verify:exports",
     "prepublishOnly": "npm run check && npm test",
     "prepare": "husky || true && npm run build"
   },
   "peerDependencies": {
-    "@cloudflare/computer": "^0.3.1",
-    "@cloudflare/shell": "^0.4.3",
-    "@dynamicagents/core": ">=0.12.0 <0.13.0",
+    "@cloudflare/computer": "^0.4.0",
+    "@cloudflare/think": ">=0.20.0 <0.21.0",
+    "@dynamicagents/core": ">=0.13.0 <0.14.0",
     "@platformatic/vfs": "^0.4.0",
-    "agents": ">=0.24.0 <0.25.0",
+    "agents": ">=0.26.0 <0.27.0",
     "ai": "^7.0.88",
-    "drizzle-orm": ">=0.45.2",
-    "workers-ai-provider": "^4.0.0",
     "zod": "^4.4.3"
   },
   "peerDependenciesMeta": {
-    "@cloudflare/shell": {
-      "optional": true
-    },
     "@cloudflare/computer": {
       "optional": true
     },
@@ -111,15 +92,14 @@
     }
   },
   "devDependencies": {
-    "@cloudflare/computer": "^0.3.1",
-    "@cloudflare/shell": "0.4.3",
-    "@platformatic/vfs": "^0.4.0",
+    "@cloudflare/computer": "^0.4.0",
+    "@cloudflare/think": "^0.20.0",
     "@cloudflare/vitest-plugin": "^1.1.9",
-    "@dynamicagents/core": "^0.12.0",
+    "@dynamicagents/core": "^0.13.1",
+    "@platformatic/vfs": "^0.4.0",
     "@types/node": "^26.5.1",
-    "agents": "^0.24.0",
+    "agents": "^0.26.0",
     "ai": "^7.0.101",
-    "drizzle-orm": ">=0.45.2",
     "eslint": "^10.10.0",
     "husky": "^9.1.7",
     "prettier": "^3.9.6",

package/dist/arc-agi/analysis.d.ts

@@ -1,322 +0,0 @@
-/**
- * Pure grid-analysis helpers for ARC-AGI-3 frames. No I/O — every function is a
- * deterministic transform of a 64×64 grid (color values 0–15), unit-tested in
- * isolation. The tool family calls these to render compact observations for the
- * model instead of dumping raw grids into context.
- *
- * Two rendering registers, deliberately kept apart:
- *
- * - **Prose** (diffs, shapes, histogram) names its colors: `blue->white` carries
- *   structure a bare `9->0` hides, and no tool input ever takes a color, so the
- *   index is never needed as an argument.
- * - **Grids** ({@link renderGrid}, {@link renderRegion}) stay one character per
- *   cell and carry a {@link renderLegend} instead. One char per cell is the only
- *   reason a 64×64 board is legible at all; a named cell would be unreadable and
- *   cost ~50× the tokens.
- */
-/**
- * The ARC-AGI-3 16-color palette, index → name.
- *
- * Source: `agents/templates/multimodal.py` in `arcprize/ARC-AGI-3-Agents` (ARC
- * Prize's own agent template), which maps these indices to RGBA for multimodal
- * play. Taken from there rather than assumed, because **ARC-AGI-3's palette is
- * unrelated to ARC-AGI-1's**: here 0 is *white* and 1–5 are a greyscale ramp,
- * where the familiar ARC-AGI-1 mapping would say 0=black, 1=blue, 2=red. Note
- * that same repo carries a second, contradictory `COLOR_PALETTE` in
- * `langgraph_thinking/vision.py` — that one is incomplete and does not match the
- * engine; do not use it.
- *
- * The pairs matter to a player: 6/7 and 9/10 and 2/3 are related shades, which
- * the names convey and the indices do not.
- */
-export declare const COLOR_NAMES: readonly ["white", "off-white", "neutral-light", "neutral", "off-black", "black", "magenta", "magenta-light", "red", "blue", "blue-light", "yellow", "orange", "maroon", "green", "purple"];
-/** Color 0 (white) — treated as background by {@link locateComponents}. */
-export declare const BACKGROUND_COLOR = 0;
-/**
- * Name of a color index. An out-of-range value renders as `color <n>` rather
- * than throwing: a malformed frame should degrade the wording, not fail the turn.
- */
-export declare function colorName(color: number): string;
-/** The current board: the LAST grid of a frame response's grid array. */
-export declare function lastGrid(frame: number[][][]): number[][];
-/**
- * Bare hex rows, one char per cell, no labels — the round-trippable **storage**
- * form, paired with {@link parseGrid}. Deliberately distinct from
- * {@link renderGrid}, which adds a legend, rulers and row collapsing and so
- * cannot be parsed back.
- */
-export declare function serializeGrid(grid: number[][]): string;
-/** Inverse of {@link serializeGrid}. */
-export declare function parseGrid(hex: string): number[][];
-export interface CellChange {
-    row: number;
-    col: number;
-    from: number;
-    to: number;
-}
-/** The rectangle enclosing a set of cells. */
-export interface Box {
-    top: number;
-    left: number;
-    bottom: number;
-    right: number;
-}
-export interface GridDiff {
-    changed: number;
-    /** Up to `cap` changed cells (for a compact summary of a large change). */
-    cells: CellChange[];
-    /** Rectangle enclosing ALL changed cells (not just the capped ones). */
-    box: Box | null;
-}
-/** Cell-by-cell diff of two grids. `cap` bounds the returned cell list. */
-export declare function diffGrids(a: number[][] | null, b: number[][], cap?: number): GridDiff;
-/** `rows 3-5, cols 10-12` — or a single row/col rendered without the range. */
-export declare function describeBox(box: Box): string;
-/** `(3,10) blue->white` — one changed cell, colors named. */
-export declare function describeCell(cell: CellChange): string;
-/** Count of each color present, descending by count. */
-export declare function colorHistogram(grid: number[][]): Array<{
-    color: number;
-    count: number;
-}>;
-/** One 4-connected same-color region, with where it sits and how big it is. */
-export interface Component extends Box {
-    color: number;
-    size: number;
-}
-/**
- * Every 4-connected same-color region, with its bounding box, largest first.
- * Skips {@link BACKGROUND_COLOR}.
- *
- * The bounding boxes are the point: a rollup of counts alone tells the model
- * *that* there are three shapes and never *where* they are, which leaves dumping
- * the whole 64×64 grid as the only way to locate anything. The flood fill has to
- * visit every cell regardless, so tracking min/max row/col is free.
- */
-export declare function locateComponents(grid: number[][]): Component[];
-/**
- * How much of its bounding box a region actually occupies, 0–1.
- *
- * Every caller passes a {@link Component} from {@link locateComponents} or a
- * {@link unionBox} of those, and a flood fill cannot produce `bottom < top`, so
- * `area` is at least 1 and there is nothing to guard against dividing by.
- *
- * The result is deliberately **not** clamped into 0–1. An out-of-range value here
- * could only mean a caller broke that invariant, and the way to learn that is a
- * region classified absurdly, not a number quietly corrected into looking sane.
- */
-export declare function fillRatio(box: Box, size: number): number;
-/**
- * A band of consecutive rows in which one color occupies exactly the same
- * columns, and the column runs it occupies there.
- */
-export interface SpanBand extends Pick<Box, "top" | "bottom"> {
-    /** Inclusive `[first, last]` column runs, left to right. */
-    cols: Array<[number, number]>;
-    /** Runs the cap dropped, so a truncated band never reads as a complete one. */
-    hidden: number;
-}
-/**
- * Where one color sits, row band by row band — the view a bounding box cannot
- * give for a maze, a frame, or any other structure that is mostly holes.
- *
- * Keyed by **color rather than component** on purpose. A wall that a doorway
- * splits into three components is one thing to a player, and three boxes describe
- * it worse than one span list does; the flood fill's notion of connectedness is an
- * implementation detail here, not something the model should have to reassemble.
- *
- * Rows whose runs are identical collapse into one band, the same trick
- * {@link renderGrid} uses — and for the same reason, since ARC boards are banded.
- * On a real 64×64 maze it turns 64 rows into ~20 bands.
- */
-export declare function colorSpans(grid: number[][], color: number): SpanBand[];
-/**
- * Runs named per band, one line each. Both caps exist to bound the render on a
- * board this encoding suits badly — a checkerboard is 32 runs in every one of 64
- * rows — and both announce themselves, so a clipped view is never mistaken for
- * the whole of one.
- */
-export declare function renderSpans(bands: SpanBand[]): string;
-/**
- * Named regions with their positions, largest first — the locational view.
- *
- * A bounding box describes a region only when the region roughly fills it. That
- * holds for the movable pieces and fails for exactly the two things a route
- * depends on: on a real `ls20` board the maze boxes as `off-black: rows 0-63,
- * cols 0-63 (2129 cells)` and the floor as `neutral: rows 5-54, cols 9-58 (1354
- * cells)`, both a shade over half-filled. The first says nothing; the second is
- * worse, asserting a 50×50 open arena of which 46% is wall — and a play reading
- * its route off those boxes walks into walls, then spends a dozen turns
- * rebuilding the maze through 11×11 `region` peepholes.
- *
- * So a region that sprawls is rendered as {@link colorSpans} instead — every row
- * band and the columns it occupies, which is the same fact at a resolution that
- * can be acted on. Sprawl is judged per color and the whole color is then spanned
- * at once, so a wall and the doorway splitting it read as one terrain layer rather
- * than as two boxes that overlap everything.
- *
- * `cap` bounds the boxed list; anything beyond it is reported as a count so the
- * model knows the view is truncated rather than complete.
- */
-export declare function renderShapes(grid: number[][], cap?: number): string;
-/**
- * What became of one shape between two frames.
- *
- * The four cases are kept apart because only **one** of them answers the question
- * an action asks — did anything move? Folding a counter ticking down into the
- * same bucket as a step taken is exactly the mistake {@link diffGrids} cannot
- * help making: in `ls20` every action shrinks a fuel bar by four cells, so a move
- * into a wall reports "4 cells changed" and reads, to a model told that `0 cells
- * changed` means blocked, as a move that worked. It spent eleven actions on that
- * misreading. A wall is `moved: []` here, whatever else on the board ticked.
- */
-export type ShapeChange = {
-    kind: "moved";
-    /** Where it was, with its color and cell count. */
-    from: Component;
-    /** Where it is now — same color and same cell count, by construction. */
-    to: Box;
-    dRow: number;
-    dCol: number;
-}
-/** Same color, still overlapping, different cell count — a bar, a trail, a fill. */
- | {
-    kind: "resized";
-    from: Component;
-    to: Component;
-}
-/**
- * Same footprint and same cell count, a different color — a repaint in place,
- * which is what a click game does instead of moving anything.
- */
- | {
-    kind: "recolored";
-    from: Component;
-    to: Component;
-} | {
-    kind: "appeared";
-    shape: Component;
-} | {
-    kind: "gone";
-    shape: Component;
-};
-export type MovedShape = Extract<ShapeChange, {
-    kind: "moved";
-}>;
-/**
- * Two frames' shapes, matched. Split rather than one list because both consumers
- * want the split: the renderer leads with movement, and a caller summing a batch
- * accumulates only the moves.
- */
-export interface ShapeDelta {
-    /** Every shape that travelled, largest first. */
-    moved: MovedShape[];
-    /** Resized, appeared and disappeared shapes, largest first. */
-    other: ShapeChange[];
-}
-/**
- * Above this many changed shapes, a frame is a repaint (a level change, a
- * transform) rather than a board where things moved, and naming twenty shapes
- * that all "appeared" says less than the cell diff does. {@link renderShapeDelta}
- * declines, and its caller falls back.
- */
-export declare const MAX_SHAPE_CHANGES = 10;
-/**
- * Match the shapes of two frames: what moved, what changed size, what came and
- * went. Null when there is no earlier frame to compare against.
- *
- * Three passes, and the order is the whole design. Color **and** cell count
- * first, because a rigid object that travelled keeps both — that pass is what
- * finds a move, and its pairs are never reconsidered. Color alone second, over
- * what is left, which is what a bar losing cells or a trail growing looks like.
- * **Footprint** alone last, over what neither pass claimed, which is a shape that
- * changed color without moving — see {@link matchRepaints}.
- */
-export declare function diffShapes(before: number[][] | null, after: number[][]): ShapeDelta | null;
-/** {@link diffShapes} over already-located components. Exported for tests. */
-export declare function matchShapes(before: Component[], after: Component[]): ShapeDelta;
-/** `down 5, left 10` — a displacement in board directions, zero terms dropped. */
-export declare function describeShift(dRow: number, dCol: number): string;
-/**
- * One action's effect as movement: `nothing moved` when the board's objects
- * stayed put, whatever a counter did alongside them.
- *
- * That phrase is spent carefully, because the soul teaches it as the signal for
- * *blocked or refused*: it leads a step only when everything else the delta holds
- * is a {@link ShapeChange} of kind `resized`, which is a counter or a bar doing
- * its own bookkeeping. A step that repainted a block, or made one appear, changed
- * the board — no object travelled, and reporting that as `nothing moved` tells a
- * click game that twenty clicks which each toggled a 36-cell block were refused.
- *
- * Null means *this view has nothing to say* — either no shape can be paired
- * across the frames, or so many changed that they are a repaint
- * ({@link MAX_SHAPE_CHANGES}). Both leave the cell diff as the better witness, so
- * the caller renders that instead rather than printing a confident "nothing
- * moved" over a board that changed completely.
- */
-export declare function renderShapeDelta(delta: ShapeDelta, cap?: number): string | null;
-/** Where one shape ended up over a whole batch, and how many steps took it there. */
-export interface ShapeTravel {
-    shape: Component;
-    dRow: number;
-    dCol: number;
-    /** Steps in which this shape moved at all. */
-    moves: number;
-}
-/**
- * Fold one step's moves into a batch's running totals.
- *
- * Identity is *position*, not appearance. Boards carrying two identical shapes
- * are the ordinary case, not the contrived one — a pair of blocks, a player and
- * its twin — and summing them under one color-and-size key reports two shapes
- * that passed each other as one shape that never moved, which is the single
- * worst thing this line could say.
- *
- * Each entry is re-keyed to where its shape landed, which is exactly where the
- * next step's diff will find it: the frames chain, step N's board being step
- * N+1's starting board, so a position is a stable handle for as long as the
- * shape keeps its color and size. Sources are cleared before any destination is
- * written, so a shape sliding into the cell another just vacated inherits its
- * own history rather than the vacater's.
- */
-export declare function trackTravel(travels: Map<string, ShapeTravel>, moved: MovedShape[]): void;
-/**
- * A shape's net travel over a batch, counted in **moves** rather than cells.
- *
- * Cells are the misleading unit for a sequence: two presses that each slide a
- * selector five cells are not "ten cells down", they are two moves of five, and a
- * model reading the former will place itself ten cells from where it is. So the
- * per-move stride is stated whenever the total divides by the moves that produced
- * it — observed from the steps, never assumed.
- */
-export declare function renderTravel(travel: ShapeTravel): string;
-/** `0=white 9=blue b=yellow` — maps grid characters to names, present colors only. */
-export declare function renderLegend(grid: number[][]): string;
-/**
- * The full board: a legend, a column ruler, then one labeled line per row —
- * with **runs of identical rows collapsed** into a single `12-31 |` band.
- *
- * Labels exist because a model cannot reliably count to column 37 across 64
- * undelimited characters; miscounting there costs a wrong click and two more
- * turns. Collapsing exploits how banded ARC boards are without run-length
- * encoding *within* a row, which would destroy the 2-D structure that this view
- * exists to convey.
- */
-export declare function renderGrid(grid: number[][]): string;
-/**
- * A localized view: a `radius`-cell square around (centerRow, centerCol), with
- * **absolute** row and column labels. The labels are what make the view usable —
- * an unlabeled block cannot be mapped back to a coordinate to click.
- *
- * The window is **clipped** on every side, never padded, which is what makes the
- * header's `cols` anchor true: character `i` of a body line is column
- * `firstCol + i`. Padding off-grid columns with spaces instead would shift that
- * mapping by up to `radius` near the left edge.
- *
- * **The window is ruled, not just headed.** A model asked to place a cell in an
- * 11-wide window counts the characters by hand and gets them wrong, then reasons
- * on the columns it miscounted — so narrow is exactly where the ruler is needed.
- * It steps at {@link REGION_RULER_STEP} rather than {@link renderGrid}'s tens,
- * which a window this size can miss entirely.
- */
-export declare function renderRegion(grid: number[][], centerRow: number, centerCol: number, radius?: number): string;