@opencode/simulation 2.0.32 → 2.1.1

package/dist/frontend/actions.d.ts

@@ -24,8 +24,8 @@ 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;
+        editor: boolean;
     };
     elements: SimulationProtocol.Frontend.Element[];
 };
@@ -53,8 +53,8 @@ export declare const execute: (harness: Harness, action: {
     readonly type: "ui.press";
     readonly key: string;
     readonly modifiers?: {
-        readonly shift?: boolean | undefined;
         readonly ctrl?: boolean | undefined;
+        readonly shift?: boolean | undefined;
         readonly meta?: boolean | undefined;
         readonly super?: boolean | undefined;
         readonly hyper?: boolean | undefined;
@@ -63,51 +63,51 @@ export declare const execute: (harness: Harness, action: {
     readonly type: "ui.enter";
 } | {
     readonly type: "ui.arrow";
-    readonly direction: "down" | "up" | "left" | "right";
+    readonly direction: "down" | "left" | "right" | "up";
 } | {
     readonly type: "ui.focus";
     readonly target: number;
 } | {
     readonly type: "ui.mouse";
     readonly params: {
-        readonly action: "move";
         readonly x: number;
         readonly y: number;
         readonly modifiers?: {
             readonly shift?: boolean | undefined;
-            readonly ctrl?: boolean | undefined;
             readonly alt?: boolean | undefined;
+            readonly ctrl?: boolean | undefined;
         } | undefined;
+        readonly action: "move";
     } | {
-        readonly action: "down" | "up";
         readonly x: number;
         readonly y: number;
         readonly modifiers?: {
             readonly shift?: boolean | undefined;
-            readonly ctrl?: boolean | undefined;
             readonly alt?: boolean | undefined;
+            readonly ctrl?: boolean | undefined;
         } | undefined;
+        readonly action: "down" | "up";
         readonly button?: "left" | "middle" | "right" | undefined;
     } | {
-        readonly action: "scroll";
         readonly x: number;
         readonly y: number;
-        readonly direction: "down" | "up" | "left" | "right";
         readonly modifiers?: {
             readonly shift?: boolean | undefined;
-            readonly ctrl?: boolean | undefined;
             readonly alt?: boolean | undefined;
+            readonly ctrl?: boolean | undefined;
         } | undefined;
+        readonly action: "scroll";
+        readonly direction: "down" | "left" | "right" | "up";
     };
 } | {
-    readonly x: number;
-    readonly y: 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;
+        readonly element: number;
     } | undefined;
 } | {
     readonly type: "ui.resize";
@@ -115,8 +115,8 @@ export declare const execute: (harness: Harness, action: {
     readonly rows: number;
 }) => Effect.Effect<{
     focused: {
-        editor: boolean;
         renderable?: number | undefined;
+        editor: boolean;
     };
     elements: SimulationProtocol.Frontend.Element[];
 }, Error, never>;

package/dist/frontend/renderer.d.ts

@@ -16,5 +16,5 @@ export declare const create: (options: CliRendererConfig, path?: string | undefi
 export declare function recordResize(renderer: CliRenderer, cols: number, rows: number): void;
 export declare function recordPointer(renderer: CliRenderer, action: Pointer["action"], x: number, y: 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 declare function finish(renderer: CliRenderer): Effect.Effect<string, import("effect/Cause").UnknownError, never> | Effect.Effect<never, Error, never>;
 export * as SimulationRenderer from "./renderer";

package/dist/frontend/renderer.js

@@ -1,4 +1,5 @@
 import { createTestRenderer } from "@opentui/core/testing";
+import { Writable } from "node:stream";
 import { Effect } from "effect";
 import { Timeline } from "../recording";
 const setups = new WeakMap, recordings = new WeakMap;
@@ -10,13 +11,19 @@ export const create = Effect.fn("SimulationRenderer.create")(function* (options,
     height: rows,
     kittyKeyboard: Boolean(options.useKittyKeyboard),
     ...recording ? {
-      stdout: recording,
+      stdout: new Writable({
+        write(chunk, encoding, callback) {
+          recording.write(chunk, encoding, callback);
+        }
+      }),
       bufferedOutput: "stdout"
     } : {}
-  })), (setup) => Effect.sync(() => {
+  })), (setup) => Effect.promise(async () => {
     if (!setup.renderer.isDestroyed)
       setup.renderer.destroy();
+    await setup.renderer.closed;
   }));
+  yield* Effect.tryPromise(() => setup.renderer.setupTerminal());
   setups.set(setup.renderer, setup);
   if (recording)
     recordings.set(setup.renderer, recording);
@@ -35,7 +42,11 @@ 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());
+  return Effect.tryPromise(async () => {
+    if (renderer.isDestroyed)
+      await renderer.closed;
+    return recording.finish();
+  });
 }
 
 export * as SimulationRenderer from "./renderer";

package/dist/frontend/semantics.d.ts

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

package/dist/frontend/server.d.ts

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

package/dist/frontend/simulation.d.ts

@@ -1,5 +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 declare const create: (options: CliRendererConfig, version: string) => Effect.Effect<import("@opentui/core").CliRenderer, unknown, import("effect/FileSystem").FileSystem | import("effect/Scope").Scope>;
 export * as Drive from "./simulation";

package/dist/frontend/simulation.js

@@ -5,9 +5,10 @@ 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(() => {
+  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.promise(async () => {
     if (!renderer.isDestroyed)
       renderer.destroy();
+    await renderer.closed;
   }));
   if (!headless && manifest.viewport)
     renderer.resize(manifest.viewport.cols, manifest.viewport.rows);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/simulation",
-  "version": "2.0.32",
+  "version": "2.1.1",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -44,15 +44,15 @@
   "scripts": {
     "build": "bun run script/build.ts",
     "test": "bun test --timeout 30000 --only-failures",
-    "typecheck": "tsgo -b"
+    "typecheck": "tsc -b"
   },
   "dependencies": {
-    "@opencode/core": "2.0.32",
-    "@opencode/ai": "2.0.32",
-    "@opencode/plugin": "2.0.32",
-    "@opencode/protocol": "2.0.32",
-    "@opencode/util": "2.0.32",
-    "@opentui/core": "0.5.17",
+    "@opencode/core": "2.1.1",
+    "@opencode/ai": "2.1.1",
+    "@opencode/plugin": "2.1.1",
+    "@opencode/protocol": "2.1.1",
+    "@opencode/util": "2.1.1",
+    "@opentui/core": "0.6.6",
     "effect": "4.0.1",
     "ws": "8.21.0"
   },
@@ -60,6 +60,6 @@
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@types/ws": "8.18.1",
-    "@typescript/native-preview": "7.0.0-dev.20251207.1"
+    "@typescript/native": "npm:typescript@7.0.2"
   }
 }