@opencode-ai/simulation 0.0.0-dev-17880

package/dist/frontend/actions.d.ts

@@ -0,0 +1,90 @@
+import type { CliRenderer } from "@opentui/core";
+import { type MockInput, type MockMouse } from "@opentui/core/testing";
+import { Effect } from "effect";
+import { SimulationProtocol } from "../protocol";
+export type Action = SimulationProtocol.Frontend.Action;
+export type Element = SimulationProtocol.Frontend.Element;
+export interface Harness {
+    readonly renderer: CliRenderer;
+    readonly mockInput: MockInput;
+    readonly mockMouse: MockMouse;
+    readonly resize: (cols: number, rows: number) => void;
+    readonly renderOnce: () => Promise<void>;
+    readonly screen: () => string;
+}
+/**
+ * Builds the harness the simulation server drives.
+ *
+ * When the renderer is the headless simulation renderer, its TestRendererSetup
+ * provides the supported testing APIs. For the visible terminal renderer the
+ * harness falls back to `requestRender` + `idle` and reading the private
+ * `currentRenderBuffer`.
+ */
+export declare function createHarness(renderer: CliRenderer): Harness;
+export declare function elements(renderer: CliRenderer): Element[];
+export declare function state(harness: Harness): {
+    focused: {
+        editor: boolean;
+        renderable?: number | undefined;
+    };
+    elements: SimulationProtocol.Frontend.Element[];
+};
+export declare function snapshot(harness: Harness): SimulationProtocol.Frontend.SemanticSnapshot;
+export declare function matches(harness: Pick<Harness, "screen">, text: string): boolean;
+export declare const capture: (harness: Harness) => Effect.Effect<{
+    cols: number;
+    rows: number;
+    cursor: readonly [0, 0];
+    lines: {
+        spans: {
+            text: string;
+            fg: [number, number, number, number];
+            bg: [number, number, number, number];
+            attributes: number;
+            width: number;
+        }[];
+    }[];
+}, import("effect/Cause").UnknownError, never>;
+export declare const execute: (harness: Harness, action: {
+    readonly type: "ui.type";
+    readonly text: string;
+} | {
+    readonly type: "ui.press";
+    readonly key: string;
+    readonly modifiers?: {
+        readonly shift?: boolean | undefined;
+        readonly ctrl?: boolean | undefined;
+        readonly meta?: boolean | undefined;
+        readonly super?: boolean | undefined;
+        readonly hyper?: boolean | undefined;
+    } | undefined;
+} | {
+    readonly type: "ui.enter";
+} | {
+    readonly type: "ui.arrow";
+    readonly direction: "up" | "down" | "left" | "right";
+} | {
+    readonly type: "ui.focus";
+    readonly target: number;
+} | {
+    readonly type: "ui.click";
+    readonly target: number;
+    readonly x: number;
+    readonly y: number;
+    readonly semantic?: {
+        readonly id: string;
+        readonly element: number;
+        readonly instance?: string | undefined;
+    } | undefined;
+} | {
+    readonly type: "ui.resize";
+    readonly cols: number;
+    readonly rows: number;
+}) => Effect.Effect<{
+    focused: {
+        editor: boolean;
+        renderable?: number | undefined;
+    };
+    elements: SimulationProtocol.Frontend.Element[];
+}, Error, never>;
+export * as SimulationActions from "./actions";

package/dist/frontend/actions.js

@@ -0,0 +1,154 @@
+import {
+  createMockKeys,
+  createMockMouse,
+  KeyCodes
+} from "@opentui/core/testing";
+import { Effect, Schema } from "effect";
+import { SimulationProtocol } from "../protocol";
+import { SimulationRenderer } from "./renderer";
+import { SimulationSemantics } from "./semantics";
+const decoder = new TextDecoder;
+function isKeyCode(key) {
+  return Object.hasOwn(KeyCodes, key);
+}
+function keyInput(key) {
+  const named = key.toUpperCase();
+  return isKeyCode(named) ? named : key;
+}
+function children(renderable) {
+  return renderable.getChildren().filter((child) => ("num" in child));
+}
+function all(renderable) {
+  return [renderable, ...children(renderable).flatMap(all)];
+}
+function mouseListeners(renderable) {
+  const general = Reflect.get(renderable, "_mouseListener"), specific = Reflect.get(renderable, "_mouseListeners");
+  return Boolean(general) || specific && typeof specific === "object" && Object.keys(specific).length > 0;
+}
+function hit(renderer, renderable) {
+  if (renderable.width <= 0 || renderable.height <= 0)
+    return !1;
+  const x = Math.floor(renderable.screenX + renderable.width / 2), y = Math.floor(renderable.screenY + renderable.height / 2), target = renderer.hitTest(x, y);
+  return all(renderable).some((item) => item.num === target);
+}
+export function createHarness(renderer) {
+  const setup = SimulationRenderer.setupFor(renderer);
+  return {
+    renderer,
+    mockInput: setup?.mockInput ?? createMockKeys(renderer),
+    mockMouse: setup?.mockMouse ?? createMockMouse(renderer),
+    resize: setup?.resize ?? ((cols, rows) => renderer.resize(cols, rows)),
+    renderOnce: setup?.renderOnce ?? (async () => {
+      renderer.requestRender();
+      await renderer.idle();
+    }),
+    screen: () => decoder.decode(Reflect.get(renderer, "currentRenderBuffer").getRealCharBytes())
+  };
+}
+export function elements(renderer) {
+  return all(renderer.root).filter((renderable) => renderable.visible && !renderable.isDestroyed).map((renderable) => {
+    const clickable = mouseListeners(renderable) && hit(renderer, renderable);
+    return {
+      id: renderable.id,
+      num: renderable.num,
+      x: renderable.screenX,
+      y: renderable.screenY,
+      width: renderable.width,
+      height: renderable.height,
+      focusable: renderable.focusable,
+      focused: renderable.focused,
+      clickable,
+      editor: renderer.currentFocusedEditor === renderable
+    };
+  }).filter((element) => element.focusable || element.clickable || element.editor);
+}
+export function state(harness) {
+  const renderable = harness.renderer.currentFocusedRenderable?.num;
+  return {
+    focused: {
+      ...renderable === void 0 ? {} : { renderable },
+      editor: Boolean(harness.renderer.currentFocusedEditor)
+    },
+    elements: elements(harness.renderer)
+  };
+}
+export function snapshot(harness) {
+  const ids = new Set, visit = (renderable, parent) => {
+    if (!renderable.visible || renderable.isDestroyed)
+      return [];
+    const definition = SimulationSemantics.read(renderable)?.();
+    if (definition && ids.has(renderable.id))
+      throw Error(`duplicate semantic UI id: ${renderable.id}`);
+    if (definition)
+      ids.add(renderable.id);
+    const node = definition ? [{ id: renderable.id, ...definition, ...parent === void 0 ? {} : { parent }, element: renderable.num }] : [], ancestor = definition ? renderable.id : parent;
+    return [...node, ...children(renderable).flatMap((child) => visit(child, ancestor))];
+  };
+  return Schema.decodeUnknownSync(SimulationProtocol.Frontend.SemanticSnapshot)({
+    format: "opencode-ui-snapshot-v1",
+    nodes: visit(harness.renderer.root)
+  });
+}
+export function matches(harness, text) {
+  return harness.screen().includes(text);
+}
+export const capture = Effect.fn("SimulationActions.capture")(function* (harness) {
+  yield* Effect.tryPromise(() => harness.renderOnce());
+  const buffer = harness.renderer.currentRenderBuffer;
+  return {
+    cols: buffer.width,
+    rows: buffer.height,
+    cursor: [0, 0],
+    lines: buffer.getSpanLines().map((line) => ({
+      spans: line.spans.map((span) => ({
+        text: span.text,
+        fg: span.fg.toInts(),
+        bg: span.bg.toInts(),
+        attributes: span.attributes,
+        width: span.width
+      }))
+    }))
+  };
+}), execute = Effect.fn("SimulationActions.execute")(function* (harness, action) {
+  switch (action.type) {
+    case "ui.type":
+      yield* Effect.tryPromise(() => harness.mockInput.typeText(action.text));
+      break;
+    case "ui.press":
+      harness.mockInput.pressKey(keyInput(action.key), action.modifiers);
+      break;
+    case "ui.enter":
+      harness.mockInput.pressEnter();
+      break;
+    case "ui.arrow":
+      harness.mockInput.pressArrow(action.direction);
+      break;
+    case "ui.focus":
+      all(harness.renderer.root).find((item) => item.num === action.target)?.focus();
+      break;
+    case "ui.click": {
+      const target = all(harness.renderer.root).find((item) => item.num === action.target);
+      if (!target || !target.visible || target.isDestroyed)
+        return yield* Effect.fail(Error(`click target is stale or unavailable: ${action.target}`));
+      if (action.semantic) {
+        const current = snapshot(harness).nodes.find((node) => node.element === action.target);
+        if (current?.id !== action.semantic.id || current.instance !== action.semantic.instance || current.element !== action.semantic.element)
+          return yield* Effect.fail(Error(`semantic click target is stale or unavailable: ${action.semantic.id}`));
+      }
+      if (!Number.isFinite(action.x) || action.x < 0 || action.x >= target.width || !Number.isFinite(action.y) || action.y < 0 || action.y >= target.height)
+        return yield* Effect.fail(Error("click position must be within the target element"));
+      yield* Effect.tryPromise(() => harness.mockMouse.click(target.screenX + action.x, target.screenY + action.y));
+      break;
+    }
+    case "ui.resize":
+      if (!Number.isSafeInteger(action.cols) || action.cols <= 0 || !Number.isSafeInteger(action.rows) || action.rows <= 0)
+        return yield* Effect.fail(Error("resize cols and rows must be positive integers"));
+      harness.resize(action.cols, action.rows);
+      SimulationRenderer.recordResize(harness.renderer, action.cols, action.rows);
+      break;
+  }
+  yield* Effect.tryPromise(() => harness.renderOnce());
+  return state(harness);
+});
+
+export * as SimulationActions from "./actions";

package/dist/frontend/renderer.d.ts

@@ -0,0 +1,18 @@
+import type { CliRenderer, CliRendererConfig } from "@opentui/core";
+import { type TestRendererSetup } from "@opentui/core/testing";
+import { Effect } from "effect";
+/**
+ * Creates a headless renderer with optional recording: a real CliRenderer
+ * backed by an in-memory screen buffer. The TestRendererSetup is kept
+ * module-side so the harness can use supported testing APIs without app
+ * code carrying it around.
+ */
+export interface Viewport {
+    readonly cols: number;
+    readonly rows: number;
+}
+export declare const create: (options: CliRendererConfig, path?: string | undefined, viewport?: Viewport | undefined) => Effect.Effect<CliRenderer, import("effect/Cause").UnknownError, import("effect/Scope").Scope>;
+export declare function recordResize(renderer: CliRenderer, cols: number, rows: number): void;
+export declare function setupFor(renderer: CliRenderer): TestRendererSetup | undefined;
+export declare function finish(renderer: CliRenderer): Effect.Effect<never, Error, never> | Effect.Effect<string, import("effect/Cause").UnknownError, never>;
+export * as SimulationRenderer from "./renderer";

package/dist/frontend/renderer.js

@@ -0,0 +1,38 @@
+import { createTestRenderer } from "@opentui/core/testing";
+import { Effect } from "effect";
+import { Timeline } from "../recording";
+const setups = new WeakMap, recordings = new WeakMap;
+export const create = Effect.fn("SimulationRenderer.create")(function* (options, path, viewport) {
+  const cols = viewport?.cols ?? 100, rows = viewport?.rows ?? 40, recording = path ? yield* Effect.acquireRelease(Effect.tryPromise(() => Timeline.create(path, cols, rows)), (recording) => Effect.tryPromise(() => recording.finish()).pipe(Effect.catch((error) => Effect.sync(() => process.stderr.write(`Failed to finish UI recording: ${error}
+`))))) : void 0, setup = yield* Effect.acquireRelease(Effect.tryPromise(() => createTestRenderer({
+    ...options,
+    width: cols,
+    height: rows,
+    kittyKeyboard: Boolean(options.useKittyKeyboard),
+    ...recording ? {
+      stdout: recording,
+      bufferedOutput: "stdout"
+    } : {}
+  })), (setup) => Effect.sync(() => {
+    if (!setup.renderer.isDestroyed)
+      setup.renderer.destroy();
+  }));
+  setups.set(setup.renderer, setup);
+  if (recording)
+    recordings.set(setup.renderer, recording);
+  return setup.renderer;
+});
+export function recordResize(renderer, cols, rows) {
+  recordings.get(renderer)?.resize(cols, rows);
+}
+export function setupFor(renderer) {
+  return setups.get(renderer);
+}
+export function finish(renderer) {
+  const recording = recordings.get(renderer);
+  if (!recording)
+    return Effect.fail(Error("UI recording is not available"));
+  return Effect.tryPromise(() => recording.finish());
+}
+
+export * as SimulationRenderer from "./renderer";

package/dist/frontend/semantics.d.ts

@@ -0,0 +1,8 @@
+import type { Renderable } from "@opentui/core";
+import type { SimulationProtocol } from "../protocol";
+export type Definition = Omit<SimulationProtocol.Frontend.SemanticNode, "id" | "element" | "parent">;
+export declare const read: (renderable: Renderable) => (() => Definition) | undefined;
+export declare const SimulationSemantics: {
+    bind: (definition: () => Definition) => (renderable: Renderable) => void;
+    read: (renderable: Renderable) => (() => Definition) | undefined;
+};

package/dist/frontend/semantics.js

@@ -0,0 +1,7 @@
+const key = Symbol.for("opencode.simulation.semantics"), bind = (definition) => (renderable) => {
+  Object.defineProperty(renderable, key, { value: definition, configurable: !0 });
+};
+export const read = (renderable) => {
+  const definition = Reflect.get(renderable, key);
+  return typeof definition === "function" ? definition : void 0;
+}, SimulationSemantics = { bind, read };

package/dist/frontend/server.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { SimulationActions } from "./actions";
+export declare const start: (harness: SimulationActions.Harness, endpoint: string, version?: any) => Effect.Effect<{
+    url: string;
+}, unknown, import("effect/Scope").Scope>;
+export * as SimulationServer from "./server";

package/dist/frontend/server.js

@@ -0,0 +1,64 @@
+import { Effect } from "effect";
+import { SimulationControlServer } from "../control-server";
+import { SimulationProtocol } from "../protocol";
+import { SimulationActions } from "./actions";
+import { SimulationRenderer } from "./renderer";
+function handle(harness, request, version) {
+  switch (request.method) {
+    case "simulation.handshake":
+      return SimulationProtocol.Handshake.dispatch({
+        role: "ui",
+        server: { name: "opencode", version },
+        capabilities: SimulationProtocol.Frontend.Capabilities
+      }, request.params);
+    case "ui.capture":
+      return SimulationActions.capture(harness);
+    case "ui.state":
+      return Effect.sync(() => SimulationActions.state(harness));
+    case "ui.snapshot":
+      return Effect.sync(() => SimulationActions.snapshot(harness));
+    case "ui.matches":
+      return Effect.sync(() => SimulationActions.matches(harness, request.params.text));
+    case "ui.recording.finish":
+      return SimulationRenderer.finish(harness.renderer);
+    case "ui.type":
+      return SimulationActions.execute(harness, { type: "ui.type", text: request.params.text });
+    case "ui.enter":
+      return SimulationActions.execute(harness, { type: "ui.enter" });
+    case "ui.press":
+      return SimulationActions.execute(harness, {
+        type: "ui.press",
+        key: request.params.key,
+        modifiers: request.params.modifiers
+      });
+    case "ui.arrow":
+      return SimulationActions.execute(harness, { type: "ui.arrow", direction: request.params.direction });
+    case "ui.focus":
+      return SimulationActions.execute(harness, { type: "ui.focus", target: request.params.target });
+    case "ui.click":
+      return SimulationActions.execute(harness, {
+        type: "ui.click",
+        target: request.params.target,
+        x: request.params.x,
+        y: request.params.y,
+        semantic: request.params.semantic
+      });
+    case "ui.resize":
+      return SimulationActions.execute(harness, {
+        type: "ui.resize",
+        cols: request.params.cols,
+        rows: request.params.rows
+      });
+  }
+}
+export const start = Effect.fn("SimulationServer.start")(function* (harness, endpoint, version = "unknown") {
+  return yield* SimulationControlServer.start({
+    endpoint,
+    label: "opencode drive ui websocket",
+    data: () => ({ drive: !0 }),
+    decode: SimulationProtocol.Frontend.decodeRequestEffect,
+    handle: (_socket, request) => handle(harness, request, version)
+  });
+});
+
+export * as SimulationServer from "./server";

package/dist/frontend/simulation.d.ts

@@ -0,0 +1,5 @@
+import { type CliRendererConfig } from "@opentui/core";
+import { Effect } from "effect";
+/** Drive-mode renderer and control-server acquisition. */
+export declare const create: (options: CliRendererConfig, version: string) => Effect.Effect<import("@opentui/core").CliRenderer, unknown, import("effect/Scope").Scope | import("effect/FileSystem").FileSystem>;
+export * as Drive from "./simulation";

package/dist/frontend/simulation.js

@@ -0,0 +1,20 @@
+import { createCliRenderer } from "@opentui/core";
+import { Config, Effect } from "effect";
+import { DriveManifest } from "../manifest";
+import { SimulationActions } from "./actions";
+import { SimulationRenderer } from "./renderer";
+import { SimulationServer } from "./server";
+export const create = Effect.fn("Drive.create")(function* (options, version) {
+  const headless = (yield* Config.string("OPENCODE_DRIVE_RENDERER").pipe(Config.withDefault("visible"))) === "headless", manifest = yield* DriveManifest.resolve(), renderer = headless ? yield* SimulationRenderer.create(options, manifest.recording?.timeline, manifest.viewport) : yield* Effect.acquireRelease(Effect.tryPromise(() => createCliRenderer(options)), (renderer) => Effect.sync(() => {
+    if (!renderer.isDestroyed)
+      renderer.destroy();
+  }));
+  if (!headless && manifest.viewport)
+    renderer.resize(manifest.viewport.cols, manifest.viewport.rows);
+  const server = yield* SimulationServer.start(SimulationActions.createHarness(renderer), manifest.endpoints.ui, version);
+  yield* Effect.sync(() => process.stderr.write(`opencode drive ui websocket: ${server.url}
+`));
+  return renderer;
+});
+
+export * as Drive from "./simulation";

package/dist/manifest.d.ts

@@ -0,0 +1,27 @@
+import { Effect, FileSystem, Schema } from "effect";
+export declare const Manifest: Schema.Struct<{
+    readonly endpoints: Schema.Struct<{
+        readonly ui: Schema.String;
+        readonly backend: Schema.String;
+    }>;
+    readonly viewport: Schema.optionalKey<Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>>;
+    readonly recording: Schema.optionalKey<Schema.Struct<{
+        readonly timeline: Schema.String;
+    }>>;
+}>;
+export interface Manifest extends Schema.Schema.Type<typeof Manifest> {
+}
+declare const ResolveError_base: Schema.Class<ResolveError, Schema.TaggedStruct<"DriveManifest.ResolveError", {
+    readonly reason: Schema.Literals<readonly ["config", "not-found", "read", "decode"]>;
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResolveError extends ResolveError_base {
+}
+export declare const defaults: Manifest;
+export declare const resolve: () => Effect.Effect<Manifest, ResolveError, FileSystem.FileSystem>;
+export * as DriveManifest from "./manifest";

package/dist/manifest.js

@@ -0,0 +1,61 @@
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { Config, Effect, FileSystem, Schema } from "effect";
+import { PositiveInt } from "@opencode-ai/core/schema";
+const InstanceName = Schema.String.check(Schema.makeFilter((value) => /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(value) ? void 0 : "a valid Drive instance name")), Endpoint = Schema.String.check(Schema.makeFilter((value) => {
+  if (!URL.canParse(value))
+    return "a loopback WebSocket endpoint with an explicit port";
+  const endpoint = new URL(value), port = Number(endpoint.port);
+  return endpoint.protocol === "ws:" && endpoint.hostname === "127.0.0.1" && Number.isInteger(port) && port >= 1 ? void 0 : "a loopback WebSocket endpoint with an explicit port";
+})), AbsolutePath = Schema.String.check(Schema.makeFilter((value) => isAbsolute(value) ? void 0 : "an absolute path"));
+export const Manifest = Schema.Struct({
+  endpoints: Schema.Struct({
+    ui: Endpoint,
+    backend: Endpoint
+  }),
+  viewport: Schema.optionalKey(Schema.Struct({
+    cols: PositiveInt,
+    rows: PositiveInt
+  })),
+  recording: Schema.optionalKey(Schema.Struct({
+    timeline: AbsolutePath
+  }))
+});
+
+export class ResolveError extends Schema.TaggedError()("DriveManifest.ResolveError", {
+  reason: Schema.Literals(["config", "not-found", "read", "decode"]),
+  path: Schema.optionalKey(Schema.String),
+  message: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+export const defaults = {
+  endpoints: {
+    ui: "ws://127.0.0.1:40900",
+    backend: "ws://127.0.0.1:40950"
+  }
+};
+const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Manifest)), configError = (cause) => new ResolveError({
+  reason: "config",
+  message: `Invalid Drive configuration: ${String(cause)}`,
+  cause
+});
+export const resolve = Effect.fn("DriveManifest.resolve")(function* () {
+  const name = yield* Config.schema(InstanceName, "OPENCODE_DRIVE").pipe(Effect.mapError(configError));
+  if (name === "1")
+    return defaults;
+  const state = yield* Config.string("XDG_STATE_HOME").pipe(Config.withDefault(join(homedir(), ".local", "state")), Effect.mapError(configError)), directory = yield* Config.string("DRIVE_REGISTRY_DIR").pipe(Config.withDefault(join(state, "opencode-drive", "instances")), Effect.mapError(configError)), file = join(directory, `${name}.json`), contents = yield* (yield* FileSystem.FileSystem).readFileString(file).pipe(Effect.mapError((cause) => new ResolveError({
+    reason: cause.reason._tag === "NotFound" ? "not-found" : "read",
+    path: file,
+    message: cause.reason._tag === "NotFound" ? `Drive manifest not found: ${file}` : `Failed to read Drive manifest: ${file}: ${cause.message}`,
+    cause
+  })));
+  return yield* decode(contents).pipe(Effect.mapError((cause) => new ResolveError({
+    reason: "decode",
+    path: file,
+    message: `Invalid Drive manifest: ${file}: ${cause.message}`,
+    cause
+  })));
+});
+
+export * as DriveManifest from "./manifest";

package/dist/protocol/index.d.ts

@@ -0,0 +1,2 @@
+export { Backend, BackendRpcs, Frontend, Handshake, JsonRpc, SimulationRequestError, UiRpcs, } from "@opencode-ai/protocol/simulation";
+export * as SimulationProtocol from "@opencode-ai/protocol/simulation";

package/dist/protocol/index.js

@@ -0,0 +1,10 @@
+export {
+  Backend,
+  BackendRpcs,
+  Frontend,
+  Handshake,
+  JsonRpc,
+  SimulationRequestError,
+  UiRpcs
+} from "@opencode-ai/protocol/simulation";
+export * as SimulationProtocol from "@opencode-ai/protocol/simulation";

package/dist/recording.d.ts

@@ -0,0 +1,65 @@
+import { Writable } from "node:stream";
+import { Schema } from "effect";
+export declare const Header: Schema.Struct<{
+    readonly type: Schema.Literal<"header">;
+    readonly version: Schema.Literal<1>;
+    readonly cols: Schema.Number;
+    readonly rows: Schema.Number;
+    readonly encoding: Schema.Literal<"base64">;
+}>;
+export interface Header extends Schema.Schema.Type<typeof Header> {
+}
+export declare const Output: Schema.Struct<{
+    readonly type: Schema.Literal<"output">;
+    readonly at_ms: Schema.Number;
+    readonly data: Schema.String;
+}>;
+export interface Output extends Schema.Schema.Type<typeof Output> {
+}
+export declare const Resize: Schema.Struct<{
+    readonly type: Schema.Literal<"resize">;
+    readonly at_ms: Schema.Number;
+    readonly cols: Schema.Number;
+    readonly rows: Schema.Number;
+}>;
+export interface Resize extends Schema.Schema.Type<typeof Resize> {
+}
+export declare const Event: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"header">;
+    readonly version: Schema.Literal<1>;
+    readonly cols: Schema.Number;
+    readonly rows: Schema.Number;
+    readonly encoding: Schema.Literal<"base64">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"output">;
+    readonly at_ms: Schema.Number;
+    readonly data: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"resize">;
+    readonly at_ms: Schema.Number;
+    readonly cols: Schema.Number;
+    readonly rows: Schema.Number;
+}>]>;
+export type Event = Schema.Schema.Type<typeof Event>;
+export declare class Timeline extends Writable {
+    readonly isTTY = true;
+    readonly path: string;
+    readonly columns: number;
+    readonly rows: number;
+    private readonly output;
+    private readonly started;
+    private readonly timestamps;
+    private done?;
+    private constructor();
+    static create(path: string, cols: number, rows: number): Promise<Timeline>;
+    getColorDepth(): number;
+    write(chunk: unknown, callback?: (error?: Error | null) => void): boolean;
+    write(chunk: unknown, encoding: BufferEncoding, callback?: (error?: Error | null) => void): boolean;
+    _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    finish(): Promise<string>;
+    resize(cols: number, rows: number): void;
+    private elapsed;
+    private writeOutput;
+}
+export * as SimulationRecording from "./recording";