@opencode-ai/protocol 0.0.0-dev-17471

package/dist/simulation.js

@@ -0,0 +1,460 @@
+import { Effect, Schema } from "effect";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+const JsonRpcID = Schema.Union([Schema.String, Schema.Number, Schema.Null]);
+const decodeJson = Schema.decodeUnknownSync(Schema.Json);
+export var JsonRpc;
+(function (JsonRpc) {
+    JsonRpc.RequestFields = {
+        jsonrpc: Schema.Literal("2.0"),
+        id: Schema.optional(JsonRpcID),
+    };
+    JsonRpc.Request = Schema.Struct({
+        ...JsonRpc.RequestFields,
+        method: Schema.String,
+        params: Schema.optional(Schema.Json),
+    });
+    JsonRpc.ErrorObject = Schema.Struct({
+        code: Schema.Number,
+        message: Schema.String,
+        data: Schema.optional(Schema.Json),
+    });
+    JsonRpc.Response = Schema.Union([
+        Schema.Struct({
+            jsonrpc: Schema.Literal("2.0"),
+            id: JsonRpcID,
+            result: Schema.Json,
+            error: Schema.optionalKey(Schema.Never),
+        }),
+        Schema.Struct({
+            jsonrpc: Schema.Literal("2.0"),
+            id: JsonRpcID,
+            result: Schema.optionalKey(Schema.Never),
+            error: JsonRpc.ErrorObject,
+        }),
+    ], { mode: "oneOf" });
+    JsonRpc.decodeRequest = Schema.decodeUnknownSync(JsonRpc.Request);
+    function success(id, result) {
+        if (id === undefined)
+            return undefined;
+        return { jsonrpc: "2.0", id, result: decodeJson(result) };
+    }
+    JsonRpc.success = success;
+    function failure(id, error) {
+        return {
+            jsonrpc: "2.0",
+            id: id ?? null,
+            error: {
+                code: -32000,
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+    JsonRpc.failure = failure;
+})(JsonRpc || (JsonRpc = {}));
+export class SimulationRequestError extends Schema.TaggedErrorClass()("SimulationRequestError", {
+    method: Schema.String,
+    code: Schema.Number,
+    message: Schema.String,
+    data: Schema.optionalKey(Schema.Json),
+}) {
+}
+const request = (tag, options) => Rpc.make(tag, { ...options, error: SimulationRequestError });
+export var Handshake;
+(function (Handshake) {
+    Handshake.ProtocolVersion = Schema.Literal(1);
+    Handshake.Capability = Schema.NonEmptyString;
+    Handshake.EndpointRole = Schema.Literals(["ui", "backend"]);
+    Handshake.Identity = Schema.Struct({
+        name: Schema.NonEmptyString,
+        version: Schema.NonEmptyString,
+    });
+    Handshake.Params = Schema.Struct({
+        client: Handshake.Identity,
+        expectedRole: Handshake.EndpointRole,
+        offeredVersions: Schema.Array(Schema.Int.check(Schema.isGreaterThan(0))).check(Schema.isMinLength(1), Schema.isUnique()),
+        requiredCapabilities: Schema.Array(Handshake.Capability).check(Schema.isUnique()),
+        optionalCapabilities: Schema.Array(Handshake.Capability).check(Schema.isUnique()),
+    });
+    Handshake.Response = Schema.Struct({
+        protocolVersion: Handshake.ProtocolVersion,
+        role: Handshake.EndpointRole,
+        server: Handshake.Identity,
+        capabilities: Schema.Array(Handshake.Capability).check(Schema.isUnique()),
+    });
+    Handshake.Request = Schema.Struct({
+        ...JsonRpc.RequestFields,
+        method: Schema.Literal("simulation.handshake"),
+        params: Handshake.Params,
+    });
+    class RoleMismatchError extends Schema.TaggedErrorClass()("SimulationHandshake.RoleMismatchError", {
+        expected: Handshake.EndpointRole,
+        actual: Handshake.EndpointRole,
+        message: Schema.String,
+    }) {
+    }
+    Handshake.RoleMismatchError = RoleMismatchError;
+    class UnsupportedProtocolError extends Schema.TaggedErrorClass()("SimulationHandshake.UnsupportedProtocolError", {
+        offered: Schema.Array(Schema.Number),
+        supported: Schema.Array(Handshake.ProtocolVersion),
+        message: Schema.String,
+    }) {
+    }
+    Handshake.UnsupportedProtocolError = UnsupportedProtocolError;
+    class MissingCapabilityError extends Schema.TaggedErrorClass()("SimulationHandshake.MissingCapabilityError", {
+        missing: Schema.Array(Handshake.Capability),
+        message: Schema.String,
+    }) {
+    }
+    Handshake.MissingCapabilityError = MissingCapabilityError;
+    function dispatch(action, params) {
+        return Effect.gen(function* () {
+            if (params.expectedRole !== action.role) {
+                return yield* Effect.fail(new RoleMismatchError({
+                    expected: params.expectedRole,
+                    actual: action.role,
+                    message: `Expected simulation endpoint role ${params.expectedRole}, received ${action.role}`,
+                }));
+            }
+            if (!params.offeredVersions.includes(1)) {
+                return yield* Effect.fail(new UnsupportedProtocolError({
+                    offered: params.offeredVersions,
+                    supported: [1],
+                    message: "No mutually supported simulation protocol version",
+                }));
+            }
+            const installed = new Set(action.capabilities);
+            const missing = params.requiredCapabilities.filter((capability) => !installed.has(capability));
+            if (missing.length > 0) {
+                return yield* Effect.fail(new MissingCapabilityError({
+                    missing,
+                    message: `Simulation endpoint is missing required capabilities: ${missing.join(", ")}`,
+                }));
+            }
+            return {
+                protocolVersion: 1,
+                role: action.role,
+                server: action.server,
+                capabilities: Array.from(installed),
+            };
+        });
+    }
+    Handshake.dispatch = dispatch;
+})(Handshake || (Handshake = {}));
+export var Frontend;
+(function (Frontend) {
+    Frontend.Capabilities = [
+        "ui.type",
+        "ui.press",
+        "ui.enter",
+        "ui.arrow",
+        "ui.focus",
+        "ui.click",
+        "ui.click.semantic",
+        "ui.resize",
+        "ui.matches",
+        "ui.state",
+        "ui.snapshot",
+        "ui.capture",
+        "ui.recording.finish",
+    ];
+    Frontend.KeyModifiers = Schema.Struct({
+        ctrl: Schema.optional(Schema.Boolean),
+        shift: Schema.optional(Schema.Boolean),
+        meta: Schema.optional(Schema.Boolean),
+        super: Schema.optional(Schema.Boolean),
+        hyper: Schema.optional(Schema.Boolean),
+    });
+    Frontend.SemanticClickTarget = Schema.Struct({
+        id: Schema.NonEmptyString,
+        instance: Schema.optionalKey(Schema.NonEmptyString),
+        element: Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0)),
+    });
+    Frontend.Action = Schema.Union([
+        Schema.Struct({ type: Schema.Literal("ui.type"), text: Schema.String }),
+        Schema.Struct({ type: Schema.Literal("ui.press"), key: Schema.String, modifiers: Schema.optional(Frontend.KeyModifiers) }),
+        Schema.Struct({ type: Schema.Literal("ui.enter") }),
+        Schema.Struct({ type: Schema.Literal("ui.arrow"), direction: Schema.Literals(["up", "down", "left", "right"]) }),
+        Schema.Struct({ type: Schema.Literal("ui.focus"), target: Schema.Number }),
+        Schema.Struct({
+            type: Schema.Literal("ui.click"),
+            target: Schema.Number,
+            x: Schema.Number,
+            y: Schema.Number,
+            semantic: Schema.optionalKey(Frontend.SemanticClickTarget),
+        }),
+        Schema.Struct({ type: Schema.Literal("ui.resize"), cols: Schema.Number, rows: Schema.Number }),
+    ]);
+    Frontend.Element = Schema.Struct({
+        id: Schema.String,
+        num: Schema.Number,
+        x: Schema.Number,
+        y: Schema.Number,
+        width: Schema.Number,
+        height: Schema.Number,
+        focusable: Schema.Boolean,
+        focused: Schema.Boolean,
+        clickable: Schema.Boolean,
+        editor: Schema.Boolean,
+    });
+    Frontend.State = Schema.Struct({
+        focused: Schema.Struct({
+            renderable: Schema.optional(Schema.Number),
+            editor: Schema.Boolean,
+        }),
+        elements: Schema.Array(Frontend.Element),
+    });
+    Frontend.SemanticNode = Schema.Struct({
+        id: Schema.NonEmptyString,
+        instance: Schema.optionalKey(Schema.NonEmptyString),
+        parent: Schema.optionalKey(Schema.NonEmptyString),
+        role: Schema.NonEmptyString,
+        label: Schema.optionalKey(Schema.NonEmptyString),
+        element: Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0)),
+        focused: Schema.optionalKey(Schema.Boolean),
+        selected: Schema.optionalKey(Schema.Boolean),
+        expanded: Schema.optionalKey(Schema.Boolean),
+        disabled: Schema.optionalKey(Schema.Boolean),
+    });
+    Frontend.SemanticSnapshot = Schema.Struct({
+        format: Schema.Literal("opencode-ui-snapshot-v1"),
+        nodes: Schema.Array(Frontend.SemanticNode).check(Schema.makeFilter((nodes) => {
+            const ids = new Set(nodes.map((node) => node.id));
+            if (ids.size !== nodes.length)
+                return "semantic node ids must be unique";
+            if (new Set(nodes.map((node) => node.element)).size !== nodes.length)
+                return "semantic node elements must be unique";
+            if (nodes.some((node) => node.parent !== undefined && !ids.has(node.parent)))
+                return "semantic node parents must reference another node";
+            const parents = new Map(nodes.map((node) => [node.id, node.parent]));
+            for (const node of nodes) {
+                const visited = new Set();
+                let current = node.id;
+                while (current !== undefined) {
+                    if (visited.has(current))
+                        return "semantic node hierarchy must be acyclic";
+                    visited.add(current);
+                    current = parents.get(current);
+                }
+            }
+            return undefined;
+        })),
+    });
+    Frontend.Color = Schema.Tuple([Schema.Number, Schema.Number, Schema.Number, Schema.Number]);
+    Frontend.CapturedFrame = Schema.Struct({
+        cols: Schema.Number,
+        rows: Schema.Number,
+        cursor: Schema.Tuple([Schema.Number, Schema.Number]),
+        lines: Schema.Array(Schema.Struct({
+            spans: Schema.Array(Schema.Struct({
+                text: Schema.String,
+                fg: Frontend.Color,
+                bg: Frontend.Color,
+                attributes: Schema.Number,
+                width: Schema.Number,
+            })),
+        })),
+    });
+    Frontend.RecordingFinish = Schema.String;
+    Frontend.Matches = Schema.Boolean;
+    Frontend.TypeParams = Schema.Struct({ text: Schema.String });
+    Frontend.MatchesParams = Schema.Struct({ text: Schema.String });
+    Frontend.PressParams = Schema.Struct({ key: Schema.String, modifiers: Schema.optional(Frontend.KeyModifiers) });
+    Frontend.pressParams = (key, modifiers) => ({
+        key,
+        ...(modifiers === undefined ? {} : { modifiers }),
+    });
+    Frontend.ArrowParams = Schema.Struct({ direction: Schema.Literals(["up", "down", "left", "right"]) });
+    Frontend.FocusParams = Schema.Struct({ target: Schema.Number });
+    Frontend.ClickParams = Schema.Struct({
+        target: Schema.Number,
+        x: Schema.Number,
+        y: Schema.Number,
+        semantic: Schema.optionalKey(Frontend.SemanticClickTarget),
+    });
+    Frontend.ResizeParams = Schema.Struct({ cols: Schema.Number, rows: Schema.Number });
+    Frontend.Request = Schema.Union([
+        Handshake.Request,
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.type"), params: Frontend.TypeParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.press"), params: Frontend.PressParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.arrow"), params: Frontend.ArrowParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.focus"), params: Frontend.FocusParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.click"), params: Frontend.ClickParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.resize"), params: Frontend.ResizeParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.matches"), params: Frontend.MatchesParams }),
+        Schema.Struct({
+            ...JsonRpc.RequestFields,
+            method: Schema.Literals(["ui.enter", "ui.state", "ui.snapshot", "ui.recording.finish"]),
+        }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.capture") }),
+    ]);
+    Frontend.decodeRequest = Schema.decodeUnknownSync(Frontend.Request);
+    Frontend.decodeRequestEffect = Schema.decodeUnknownEffect(Schema.fromJsonString(Frontend.Request));
+})(Frontend || (Frontend = {}));
+export var Backend;
+(function (Backend) {
+    Backend.Capabilities = [
+        "llm.attach",
+        "llm.chunk",
+        "llm.finish",
+        "llm.disconnect",
+        "llm.pending",
+        "llm.request",
+        "llm.tool-input-delta",
+        "tool.attach",
+        "tool.update",
+        "tool.finish",
+        "tool.fail",
+        "tool.invocation",
+        "tool.cancel",
+    ];
+    Backend.Item = Schema.Union([
+        Schema.Struct({ type: Schema.Literal("textDelta"), text: Schema.String }),
+        Schema.Struct({ type: Schema.Literal("reasoningDelta"), text: Schema.String }),
+        Schema.Struct({
+            type: Schema.Literal("toolInputStart"),
+            index: Schema.Number,
+            id: Schema.String,
+            name: Schema.String,
+        }),
+        Schema.Struct({
+            type: Schema.Literal("toolInputDelta"),
+            index: Schema.Number,
+            text: Schema.String,
+        }),
+        Schema.Struct({
+            type: Schema.Literal("toolCall"),
+            index: Schema.Number,
+            id: Schema.String,
+            name: Schema.String,
+            input: Schema.Json,
+        }),
+        Schema.Struct({ type: Schema.Literal("raw"), chunk: Schema.Json }),
+    ]);
+    Backend.FinishReason = Schema.Literals(["stop", "tool-calls", "length", "content-filter"]);
+    Backend.ToolContent = Schema.Union([
+        Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }),
+        Schema.Struct({
+            type: Schema.Literal("file"),
+            data: Schema.String,
+            mime: Schema.NonEmptyString,
+            name: Schema.optionalKey(Schema.String),
+        }),
+    ]);
+    const ToolName = Schema.NonEmptyString.check(Schema.makeFilter((name) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(name) ? undefined : "simulated tool names must be provider-safe"));
+    const ToolNamespace = Schema.NonEmptyString.check(Schema.makeFilter((namespace) => namespace.split(".").every((segment) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(segment))
+        ? undefined
+        : "simulated tool namespaces must contain provider-safe segments"));
+    Backend.ToolRegistration = Schema.Struct({
+        name: ToolName,
+        description: Schema.String,
+        inputSchema: Schema.Record(Schema.String, Schema.Json),
+        outputSchema: Schema.optionalKey(Schema.Record(Schema.String, Schema.Json)),
+        permission: Schema.optionalKey(Schema.NonEmptyString),
+        options: Schema.optionalKey(Schema.Struct({
+            namespace: Schema.optionalKey(ToolNamespace),
+            codemode: Schema.optionalKey(Schema.Boolean),
+        })),
+    });
+    Backend.ToolAttachParams = Schema.Struct({
+        tools: Schema.Array(Backend.ToolRegistration).check(Schema.makeFilter((tools) => {
+            const names = tools.map(exposedToolName);
+            if (names.some((name) => !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(name)))
+                return "simulated tool names including namespaces must be provider-safe";
+            if (new Set(names).size !== names.length)
+                return "simulated tool registrations must have unique exposed names";
+            if (tools.some((tool) => tool.name === "execute" && tool.options?.namespace === undefined && tool.options?.codemode === false))
+                return 'direct simulated tool name "execute" is reserved';
+            return undefined;
+        })),
+    });
+    function exposedToolName(registration) {
+        return registration.options?.namespace === undefined
+            ? registration.name
+            : `${registration.options.namespace.replaceAll(".", "_")}_${registration.name}`;
+    }
+    Backend.exposedToolName = exposedToolName;
+    Backend.ToolProgress = Schema.Record(Schema.String, Schema.Json);
+    Backend.ToolOutput = Schema.Struct({
+        structured: Schema.Json,
+        content: Schema.Array(Backend.ToolContent),
+    });
+    Backend.ToolUpdateParams = Schema.Struct({
+        id: Schema.String,
+        sequence: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+        update: Backend.ToolProgress,
+    });
+    Backend.ToolFinishParams = Schema.Struct({ id: Schema.String, output: Backend.ToolOutput });
+    Backend.ToolFailParams = Schema.Struct({ id: Schema.String, message: Schema.String });
+    Backend.ToolInvocation = Schema.Struct({
+        id: Schema.String,
+        name: Schema.String,
+        input: Schema.Json,
+        context: Schema.Struct({
+            sessionID: Schema.String,
+            agent: Schema.String,
+            messageID: Schema.String,
+            id: Schema.String,
+        }),
+    });
+    Backend.ToolCancellation = Schema.Struct({
+        id: Schema.String,
+        reason: Schema.Literal("interrupted"),
+    });
+    Backend.Attached = Schema.Struct({ attached: Schema.Literal(true) });
+    Backend.Ok = Schema.Struct({ ok: Schema.Literal(true) });
+    Backend.ChunkParams = Schema.Struct({ id: Schema.String, items: Schema.Array(Backend.Item) });
+    Backend.FinishParams = Schema.Struct({
+        id: Schema.String,
+        reason: Backend.FinishReason.pipe(Schema.withDecodingDefault(Effect.succeed("stop"))),
+    });
+    Backend.FinishPayload = Schema.Struct({
+        id: Schema.String,
+        reason: Schema.optionalKey(Backend.FinishReason),
+    });
+    Backend.DisconnectParams = Schema.Struct({ id: Schema.String });
+    Backend.Request = Schema.Union([
+        Handshake.Request,
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.chunk"), params: Backend.ChunkParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.finish"), params: Backend.FinishParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.disconnect"), params: Backend.DisconnectParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("tool.attach"), params: Backend.ToolAttachParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("tool.update"), params: Backend.ToolUpdateParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("tool.finish"), params: Backend.ToolFinishParams }),
+        Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("tool.fail"), params: Backend.ToolFailParams }),
+        Schema.Struct({
+            ...JsonRpc.RequestFields,
+            method: Schema.Literals(["llm.attach", "llm.pending"]),
+        }),
+    ]);
+    Backend.decodeRequest = Schema.decodeUnknownSync(Backend.Request);
+    Backend.decodeRequestEffect = Schema.decodeUnknownEffect(Schema.fromJsonString(Backend.Request));
+    Backend.ProviderInvocation = Schema.Struct({ id: Schema.String, url: Schema.String, body: Schema.Json });
+    Backend.Pending = Schema.Struct({ invocations: Schema.Array(Backend.ProviderInvocation) });
+    Backend.NetworkLogEntry = Schema.Struct({
+        time: Schema.Number,
+        method: Schema.String,
+        url: Schema.String,
+        matched: Schema.Boolean,
+    });
+    Backend.Notification = Schema.Union([
+        Schema.Struct({
+            jsonrpc: Schema.Literal("2.0"),
+            method: Schema.Literal("llm.request"),
+            params: Backend.ProviderInvocation,
+        }),
+        Schema.Struct({
+            jsonrpc: Schema.Literal("2.0"),
+            method: Schema.Literal("tool.invocation"),
+            params: Backend.ToolInvocation,
+        }),
+        Schema.Struct({
+            jsonrpc: Schema.Literal("2.0"),
+            method: Schema.Literal("tool.cancel"),
+            params: Backend.ToolCancellation,
+        }),
+    ]);
+    Backend.decodeNotification = Schema.decodeUnknownSync(Backend.Notification);
+    Backend.decodeNotificationEffect = Schema.decodeUnknownEffect(Schema.fromJsonString(Backend.Notification));
+})(Backend || (Backend = {}));
+export const UiRpcs = RpcGroup.make(request("simulation.handshake", { payload: Handshake.Params, success: Handshake.Response }), request("ui.state", { success: Frontend.State }), request("ui.snapshot", { success: Frontend.SemanticSnapshot }), request("ui.capture", { success: Frontend.CapturedFrame }), request("ui.matches", { payload: Frontend.MatchesParams, success: Frontend.Matches }), request("ui.recording.finish", { success: Frontend.RecordingFinish }), request("ui.type", { payload: Frontend.TypeParams, success: Frontend.State }), request("ui.press", { payload: Frontend.PressParams, success: Frontend.State }), request("ui.enter", { success: Frontend.State }), request("ui.arrow", { payload: Frontend.ArrowParams, success: Frontend.State }), request("ui.focus", { payload: Frontend.FocusParams, success: Frontend.State }), request("ui.click", { payload: Frontend.ClickParams, success: Frontend.State }), request("ui.resize", { payload: Frontend.ResizeParams, success: Frontend.State }));
+export const BackendRpcs = RpcGroup.make(request("simulation.handshake", { payload: Handshake.Params, success: Handshake.Response }), request("llm.attach", { success: Backend.Attached }), request("llm.pending", { success: Backend.Pending }), request("llm.chunk", { payload: Backend.ChunkParams, success: Backend.Ok }), request("llm.finish", { payload: Backend.FinishPayload, success: Backend.Ok }), request("llm.disconnect", { payload: Backend.DisconnectParams, success: Backend.Ok }), request("tool.attach", { payload: Backend.ToolAttachParams, success: Backend.Attached }), request("tool.update", { payload: Backend.ToolUpdateParams, success: Backend.Ok }), request("tool.finish", { payload: Backend.ToolFinishParams, success: Backend.Ok }), request("tool.fail", { payload: Backend.ToolFailParams, success: Backend.Ok }));

package/package.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/protocol",
+  "version": "0.0.0-dev-17471",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anomalyco/opencode.git",
+    "directory": "packages/protocol"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./simulation": {
+      "import": "./dist/simulation.js",
+      "types": "./dist/simulation.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build.ts",
+    "generate": "bun run script/generate-openapi.ts",
+    "check:generated": "bun run script/generate-openapi.ts --check",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@opencode-ai/schema": "0.0.0-dev-17471",
+    "effect": "4.0.0-beta.101"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.13",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1",
+    "typescript": "5.8.2"
+  }
+}