@opencode-ai/core 0.0.0-beta-18684 → 0.0.0-beta-18721

package/dist/chunks/{state-g5tvq2z7.js → workspace-jv2akzxs.js}

@@ -1,9 +1,9 @@
 import {
   exports_promise
-} from "./state-5vcssjzn.js";
+} from "./workspace-5vcssjzn.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/plugin/module.ts
 var exports_module = {};
@@ -14,6 +14,7 @@ __export(exports_module, {
 import { Npm } from "@opencode-ai/util/npm";
 import { importModule } from "@opencode-ai/util/runtime-import";
 import { Effect, Schema } from "effect";
+import { readdir } from "node:fs/promises";
 import path from "path";
 import { pathToFileURL } from "url";
 var Discovery = Schema.Struct({
@@ -24,13 +25,11 @@ var Definition = Schema.Struct({
   default: Schema.Union([
     Schema.Struct({
       id: Schema.String,
-      tui: Schema.optional(Schema.Boolean),
       vcs: Schema.optional(Discovery),
       effect: Schema.declare((input) => typeof input === "function")
     }),
     Schema.Struct({
       id: Schema.String,
-      tui: Schema.optional(Schema.Boolean),
       vcs: Schema.optional(Discovery),
       setup: Schema.declare((input) => typeof input === "function")
     })
@@ -38,7 +37,9 @@ var Definition = Schema.Struct({
 });
 var load = Effect.fn("PluginModule.load")(function* (operation) {
   const npm = yield* Npm.Service;
-  const entrypoint = path.isAbsolute(operation.target) ? pathToFileURL(operation.target).href : (yield* npm.add(operation.target, { subpaths: ["server", ""] })).entrypoint;
+  const local = path.isAbsolute(operation.target);
+  const installed = local ? { entrypoint: pathToFileURL(operation.target).href } : yield* npm.add(operation.target, { subpaths: ["server", ""] });
+  const entrypoint = installed.entrypoint;
   if (!entrypoint)
     return yield* Effect.fail(new Error(`Plugin entrypoint not found: ${operation.target}`));
   const target = typeof Bun !== "undefined" ? operation.target.replaceAll("\\", "/") : entrypoint;
@@ -47,14 +48,33 @@ var load = Effect.fn("PluginModule.load")(function* (operation) {
   const mod = yield* Effect.promise(() => importModule(source));
   const value = (yield* Schema.decodeUnknownEffect(Definition)(mod)).default;
   const plugin = "effect" in value ? value : exports_promise.fromPromise(value);
+  const features = local ? yield* localFeatures(operation.target) : yield* Effect.all({
+    tui: npm.resolve(operation.target, { subpaths: ["tui"] }),
+    rpc: npm.resolve(operation.target, { subpaths: ["rpc"] })
+  }).pipe(Effect.map((resolved) => ({
+    ...resolved.tui.entrypoint ? { tui: true } : {},
+    ...resolved.rpc.entrypoint ? { rpc: true } : {}
+  })));
   return {
     id: plugin.id,
-    tui: plugin.tui,
+    features,
     vcs: plugin.vcs,
     version: JSON.stringify(operation),
     source: path.isAbsolute(operation.target) ? { type: "local", path: operation.target } : { type: "package", package: operation.target },
     effect: (host) => plugin.effect({ ...host, options: operation.options })
   };
 });
+function localFeatures(entrypoint) {
+  if (!path.basename(entrypoint).startsWith("index."))
+    return Effect.succeed({});
+  return Effect.promise(() => readdir(path.dirname(entrypoint), { withFileTypes: true })).pipe(Effect.map((entries) => {
+    const names = new Set(entries.filter((entry) => entry.isFile() || entry.isSymbolicLink()).map((entry) => entry.name));
+    const has = (name) => ["ts", "tsx", "js", "jsx", "mts", "mjs", "cts", "cjs"].some((extension) => names.has(`${name}.${extension}`));
+    return {
+      ...has("tui") ? { tui: true } : {},
+      ...has("rpc") ? { rpc: true } : {}
+    };
+  }));
+}
 
 export { load, exports_module };

package/dist/chunks/{state-m0t583rx.js → workspace-jvhgzz8q.js}

@@ -1,9 +1,9 @@
 import {
   exports_environment1 as exports_environment
-} from "./state-546qm8gr.js";
+} from "./workspace-rth9afse.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/mcp/stdio.ts
 var exports_stdio = {};
@@ -27,14 +27,12 @@ var make = Effect.fnUntraced(function* (options) {
   let startup;
   let closing;
   let trailingBytes = 0;
-  const stop = (handle) => Effect.gen(function* () {
-    const exit = yield* Effect.timeoutOption(handle.exitCode, CLOSE_GRACE);
-    if (exit._tag === "Some")
-      return;
+  const stop = Effect.fnUntraced(function* (handle) {
+    yield* Effect.timeoutOption(handle.exitCode, CLOSE_GRACE).pipe(Effect.ignore);
     const terminated = yield* Effect.timeoutOption(handle.kill({ killSignal: "SIGTERM" }), FORCE_KILL_AFTER);
     if (terminated._tag === "None")
       yield* handle.kill({ killSignal: "SIGKILL" });
-  }).pipe(Effect.ignore);
+  }, Effect.ignore());
   const close = () => closing ??= Effect.runPromise(Effect.gen(function* () {
     state.phase = "closed";
     Queue.endUnsafe(outgoing);

package/dist/chunks/{state-8ee4ayyt.js → workspace-jyhpc08g.js}

@@ -1,30 +1,30 @@
 import {
   exports_context
-} from "./state-8qrx9cj0.js";
+} from "./workspace-wfdy75zv.js";
 import {
   exports_usage
-} from "./state-sw84ckhj.js";
+} from "./workspace-sw84ckhj.js";
 import {
   llmClient
-} from "./state-393a352g.js";
+} from "./workspace-393a352g.js";
 import {
   exports_store
-} from "./state-tfd8n8cn.js";
+} from "./workspace-se07g09y.js";
 import {
   exports_history
-} from "./state-v16fefw3.js";
+} from "./workspace-9kmcw9m3.js";
 import {
   SessionEvent
-} from "./state-a83yvq99.js";
+} from "./workspace-a83yvq99.js";
 import {
   exports_bus
-} from "./state-cgy4zpa6.js";
+} from "./workspace-vkgwd1zr.js";
 import {
   exports_database
-} from "./state-vpac0x8g.js";
+} from "./workspace-gbf8gmfy.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/session/title.ts
 var exports_title = {};

package/dist/chunks/{state-6272rtjg.js → workspace-k5e6kcej.js}

@@ -1,24 +1,19 @@
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/plugin/source-directory.ts
 var exports_source_directory = {};
 __export(exports_source_directory, {
   names: () => names,
+  entrypoint: () => entrypoint,
   discover: () => discover,
   PluginSourceDirectory: () => exports_source_directory
 });
 import { FSUtil } from "@opencode-ai/util/fs-util";
-import { Effect, Option, Predicate, Schema } from "effect";
+import { Effect, Option } from "effect";
 import path from "path";
 var names = ["plugin", "plugins"];
-var Package = Schema.Struct({
-  exports: Schema.optional(Schema.Unknown),
-  module: Schema.optional(Schema.Unknown),
-  main: Schema.optional(Schema.Unknown)
-});
-var decodePackage = Schema.decodeUnknownOption(Package);
 var discover = Effect.fn("PluginSourceDirectory.discover")(function* (fs, directory) {
   const children = (yield* Effect.forEach(names, (source) => fs.readDirectoryEntries(path.join(directory, source)).pipe(Effect.orElseSucceed(() => []), Effect.map((entries) => entries.map((entry) => ({ ...entry, target: path.join(directory, source, entry.name) })))))).flat().sort((a, b) => a.target < b.target ? -1 : a.target > b.target ? 1 : 0);
   const targets = yield* Effect.forEach(children, (entry) => Effect.gen(function* () {
@@ -26,24 +21,22 @@ var discover = Effect.fn("PluginSourceDirectory.discover")(function* (fs, direct
     if (entry.type === "file" && source)
       return Option.some(entry.target);
     if (entry.type === "directory")
-      return yield* packageEntry(fs, entry.target);
+      return yield* entrypoint(fs, entry.target);
     if (entry.type !== "symlink")
       return Option.none();
     if (source && (yield* fs.isFile(entry.target)))
       return Option.some(entry.target);
     if (yield* fs.isDir(entry.target))
-      return yield* packageEntry(fs, entry.target);
+      return yield* entrypoint(fs, entry.target);
     return Option.none();
   }));
   return targets.flatMap(Option.toArray);
 });
-function packageEntry(fs, directory) {
+function entrypoint(fs, directory) {
   return Effect.gen(function* () {
     const root = yield* fs.resolve(directory);
-    const manifest = yield* fs.readJson(path.join(directory, "package.json")).pipe(Effect.map(decodePackage), Effect.orElseSucceed(Option.none));
-    const configured = Option.isSome(manifest) ? [manifest.value.exports, manifest.value.module, manifest.value.main].filter(Predicate.isString) : [];
-    return yield* Effect.findFirst([...configured, "index.ts", "index.js"].filter((entry) => !path.isAbsolute(entry)).map((entry) => path.resolve(directory, entry)).filter((entry) => FSUtil.contains(directory, entry)), (entry) => fs.isFile(entry).pipe(Effect.flatMap((exists) => exists ? fs.resolve(entry).pipe(Effect.map((resolved) => FSUtil.contains(root, resolved))) : Effect.succeed(false))));
+    return yield* Effect.findFirst(["index.ts", "index.js"].map((entry) => path.join(directory, entry)), (entry) => fs.isFile(entry).pipe(Effect.flatMap((exists) => exists ? fs.resolve(entry).pipe(Effect.map((resolved) => FSUtil.contains(root, resolved))) : Effect.succeed(false))));
   });
 }
 
-export { names, discover, exports_source_directory };
+export { names, discover, entrypoint, exports_source_directory };

package/dist/chunks/{state-k828h0dz.js → workspace-k828h0dz.js}

@@ -1,15 +1,15 @@
 import {
   exports_repository
-} from "./state-y198y2ra.js";
+} from "./workspace-y198y2ra.js";
 import {
   exports_git
-} from "./state-dyj7wa6j.js";
+} from "./workspace-dyj7wa6j.js";
 import {
   AbsolutePath
-} from "./state-j07kk359.js";
+} from "./workspace-j07kk359.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/repository-cache.ts
 var exports_repository_cache = {};

package/dist/chunks/{state-fp623900.js → workspace-kb2ag3w7.js}

@@ -1,10 +1,10 @@
 import {
   exports_state
-} from "./state-x89rah0x.js";
+} from "./workspace-x89rah0x.js";
 import {
   __export,
   __require
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/image.ts
 var exports_image = {};

package/dist/chunks/{state-kg1345f7.js → workspace-kg1345f7.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/filesystem/protected.ts
 var exports_protected = {};

package/dist/chunks/{state-a2jfr9gs.js → workspace-kn110wfv.js}

@@ -1,12 +1,12 @@
 import {
   KVTable
-} from "./state-wmxdh12w.js";
+} from "./workspace-wmxdh12w.js";
 import {
   exports_database
-} from "./state-vpac0x8g.js";
+} from "./workspace-gbf8gmfy.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/kv.ts
 var exports_kv = {};

package/dist/chunks/{state-kp1t5rcy.js → workspace-kp1t5rcy.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/config/plugin/entry-observer.ts
 var exports_entry_observer = {};

package/dist/chunks/{state-3qv8nf0b.js → workspace-kww0mg52.js}

@@ -1,6 +1,6 @@
 import {
   exports_provider
-} from "./state-krsqcmnj.js";
+} from "./workspace-fex42j86.js";
 
 // src/plugin/provider/nvidia.ts
 import { Effect } from "effect";

package/dist/chunks/{state-n7nsrdbk.js → workspace-kwy8bpa6.js}

@@ -1,12 +1,12 @@
 import {
   exports_permission
-} from "./state-6xryfvfs.js";
+} from "./workspace-ekr1z8vx.js";
 import {
   exports_agent
-} from "./state-mg2nmqys.js";
+} from "./workspace-xanq1mxd.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/plugin/agent.ts
 var exports_agent2 = {};

package/dist/chunks/workspace-kz0c7bgg.js

@@ -0,0 +1,207 @@
+import {
+  exports_location
+} from "./workspace-ngk06vjf.js";
+import {
+  optional,
+  statics
+} from "./workspace-j07kk359.js";
+import {
+  exports_bus
+} from "./workspace-vkgwd1zr.js";
+import {
+  __export
+} from "./workspace-rvfvac9x.js";
+
+// src/rpc.ts
+var exports_rpc = {};
+__export(exports_rpc, {
+  node: () => node,
+  define: () => define,
+  Service: () => Service,
+  Rpc: () => exports_rpc
+});
+import { define } from "@opencode-ai/schema/rpc";
+import { Event } from "@opencode-ai/schema/event";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, JsonSchema, Layer, Schema, SchemaRepresentation, Stream } from "effect";
+class Service extends Context.Service()("@opencode/Rpc") {
+}
+
+class DeclaredError extends Error {
+  type;
+  data;
+  constructor(type, message, data) {
+    super(message);
+    this.type = type;
+    this.data = data;
+  }
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const location = yield* exports_location.Service;
+  const ref = exports_location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID });
+  const callContext = {
+    error: (type, message, data) => new DeclaredError(type, message, data)
+  };
+  const registrations = new Map;
+  const definitions = new WeakMap;
+  const eventsFor = (definition) => {
+    const existing = definitions.get(definition);
+    if (existing)
+      return existing;
+    const events = new Map(Object.entries(definition.events).map(([name, event]) => [
+      name,
+      { event, definition: eventDefinition(definition, name) }
+    ]));
+    definitions.set(definition, events);
+    return events;
+  };
+  const register = Effect.fn("Rpc.register")(function* (definition, handlers) {
+    const entry = { definition, handlers };
+    const dispose = Effect.sync(() => {
+      const remaining = (registrations.get(definition.id) ?? []).filter((candidate) => candidate !== entry);
+      if (remaining.length === 0) {
+        registrations.delete(definition.id);
+        return;
+      }
+      registrations.set(definition.id, remaining);
+    });
+    yield* Effect.acquireRelease(Effect.sync(() => registrations.set(definition.id, [...registrations.get(definition.id) ?? [], entry])), () => dispose);
+    const events = eventsFor(definition);
+    return {
+      dispose,
+      events: {
+        emit: Effect.fn("Rpc.emit")(function* (...args) {
+          const registered = events.get(args[0]);
+          if (!registered)
+            return yield* Effect.fail(new Error(`Unknown RPC event: ${definition.id}.${args[0]}`));
+          const event = registered.event;
+          const data = yield* encode(event.schema, args[1]);
+          return yield* bus.publish(registered.definition, data, {
+            location: exports_location.Ref.make({ directory: ref.directory, workspaceID: ref.workspaceID })
+          }).pipe(Effect.asVoid);
+        })
+      }
+    };
+  });
+  const call = Effect.fn("Rpc.call")(function* (rpcID, name, input) {
+    const entry = registrations.get(rpcID)?.at(-1);
+    if (!entry)
+      return yield* Effect.fail(failure("rpc.unavailable", `RPC is unavailable: ${rpcID}`));
+    if (!Object.hasOwn(entry.definition.methods, name) || !Object.hasOwn(entry.handlers, name))
+      return yield* Effect.fail(failure("rpc.method_not_found", `Unknown RPC method: ${rpcID}.${name}`));
+    const method = entry.definition.methods[name];
+    const handler = entry.handlers[name];
+    const parsed = yield* parse(method.input, input).pipe(Effect.mapError((error) => failure("rpc.invalid_input", errorMessage(error, "Invalid RPC input"))));
+    const result = yield* Effect.suspend(() => {
+      const execution = Reflect.apply(handler, undefined, [parsed, callContext]);
+      return execution;
+    }).pipe(Effect.catch((error) => encodeError(method, error)));
+    return yield* encode(method.output, result).pipe(Effect.mapError((error) => failure("rpc.invalid_output", errorMessage(error, "Invalid RPC output"))));
+  });
+  const client = (definition) => {
+    const events = eventsFor(definition);
+    const methods = Object.fromEntries(Object.entries(definition.methods).map(([name, method]) => [
+      name,
+      (input) => call(definition.id, name, input).pipe(Effect.catch((error) => decodeError(method, error)), Effect.flatMap((value) => read(method.output, value).pipe(Effect.catch((cause) => Effect.die(cause)))))
+    ]));
+    return {
+      ...methods,
+      events: {
+        subscribe: (name) => {
+          const registered = events.get(name);
+          if (!registered)
+            return Stream.fail(new Error(`Unknown RPC event: ${definition.id}.${name}`));
+          return bus.subscribe(registered.definition).pipe(Stream.provideService(exports_location.Service, location), Stream.mapEffect((payload) => logicalEvent(definition, name, payload, ref)));
+        }
+      }
+    };
+  };
+  return Service.of({ register, call, client });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node, exports_location.node] });
+var fields = {
+  id: Event.ID,
+  created: Schema.Finite,
+  metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
+  location: optional(exports_location.Ref)
+};
+var EventData = Schema.Record(Schema.String, Schema.Unknown);
+var jsonSchemas = new WeakMap;
+function eventType(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+function eventDefinition(definition, name) {
+  const type = eventType(definition, name);
+  const data = EventData;
+  return Schema.Struct({ ...fields, type: Schema.Literal(type), data }).pipe(statics(() => ({ type, durability: "ephemeral", durable: undefined, data })));
+}
+function parse(schema, value) {
+  if (Schema.isSchema(schema))
+    return Schema.decodeUnknownEffect(schema)(value);
+  if (isStandardSchema(schema)) {
+    return Effect.gen(function* () {
+      const parsed = yield* Effect.try({ try: () => schema["~standard"].validate(value), catch: (cause) => cause });
+      const result = parsed instanceof Promise ? yield* Effect.tryPromise({ try: () => parsed, catch: (cause) => cause }) : parsed;
+      if (result.issues)
+        return yield* Effect.fail(new Error(result.issues.map((issue) => issue.message).join(`
+`)));
+      return result.value;
+    });
+  }
+  return Effect.try({
+    try: () => {
+      const existing = jsonSchemas.get(schema);
+      if (existing)
+        return existing;
+      const codec = Schema.make(SchemaRepresentation.fromJsonSchemaDocument(JsonSchema.fromSchemaDraft2020_12(schema)).ast);
+      jsonSchemas.set(schema, codec);
+      return codec;
+    },
+    catch: (cause) => cause
+  }).pipe(Effect.flatMap((codec) => Schema.decodeUnknownEffect(codec)(value)));
+}
+function encode(schema, value) {
+  return Schema.isSchema(schema) ? Schema.encodeUnknownEffect(schema)(value) : parse(schema, value);
+}
+function encodeError(method, error) {
+  if (!(error instanceof DeclaredError))
+    return Effect.die(error);
+  if (!method.errors || !Object.hasOwn(method.errors, error.type)) {
+    return Effect.die(new Error(`Undeclared RPC error: ${error.type}`));
+  }
+  return encode(method.errors[error.type], error.data).pipe(Effect.catch((cause) => Effect.die(cause)), Effect.flatMap((data) => Effect.fail(failure(error.type, error.message, data))));
+}
+function decodeError(method, error) {
+  if (!method.errors || !Object.hasOwn(method.errors, error.type))
+    return Effect.fail(error);
+  return read(method.errors[error.type], error.data).pipe(Effect.catch((cause) => Effect.die(cause)), Effect.flatMap((data) => Effect.fail(failure(error.type, error.message, data))));
+}
+function failure(type, message, data) {
+  return data === undefined ? { type, message } : { type, message, data };
+}
+function errorMessage(error, fallback) {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  return fallback;
+}
+function isStandardSchema(schema) {
+  return "~standard" in schema;
+}
+function read(schema, value) {
+  return Schema.isSchema(schema) ? Schema.decodeUnknownEffect(schema)(value) : Effect.succeed(value);
+}
+var logicalEvent = Effect.fn("Rpc.logicalEvent")(function* (definition, name, payload, ref) {
+  const event = definition.events[name];
+  const data = yield* read(event.schema, payload.data);
+  return {
+    ...payload,
+    type: eventType(definition, name),
+    data,
+    location: exports_location.Ref.make({ directory: ref.directory, workspaceID: ref.workspaceID })
+  };
+});
+
+export { Service, node, exports_rpc, define };

package/dist/chunks/{state-rrqrf7hs.js → workspace-m4a2h2aa.js}

@@ -1,30 +1,30 @@
 import {
   exports_watcher
-} from "./state-ns0sdez7.js";
-import {
-  exports_normalize
-} from "./state-qyv2f15b.js";
+} from "./workspace-ns0sdez7.js";
 import {
   exports_variable
-} from "./state-d2gk9vpf.js";
+} from "./workspace-d2gk9vpf.js";
 import {
-  exports_credential
-} from "./state-cynvptsh.js";
+  exports_normalize
+} from "./workspace-9mp6v1qd.js";
 import {
   exports_wellknown
-} from "./state-mwvdpwcp.js";
+} from "./workspace-90xaz2d8.js";
+import {
+  exports_credential
+} from "./workspace-geyszmd1.js";
 import {
   exports_location
-} from "./state-qph0wk53.js";
+} from "./workspace-ngk06vjf.js";
 import {
   AbsolutePath
-} from "./state-j07kk359.js";
+} from "./workspace-j07kk359.js";
 import {
   exports_bus
-} from "./state-cgy4zpa6.js";
+} from "./workspace-vkgwd1zr.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/config.ts
 var exports_config = {};

package/dist/chunks/{state-mf0hyk7z.js → workspace-mf0hyk7z.js}

@@ -1,6 +1,6 @@
 import {
   Timestamps
-} from "./state-sem2g21k.js";
+} from "./workspace-sem2g21k.js";
 
 // src/credential/sql.ts
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";

package/dist/chunks/{state-36dfjbwk.js → workspace-mn7qpjr2.js}

@@ -1,18 +1,18 @@
 import {
   exports_markdown
-} from "./state-7wcmqxrc.js";
+} from "./workspace-7wcmqxrc.js";
 import {
   exports_config
-} from "./state-rrqrf7hs.js";
+} from "./workspace-m4a2h2aa.js";
 import {
   exports_select
-} from "./state-bbhffenw.js";
+} from "./workspace-bbhffenw.js";
 import {
   exports_location
-} from "./state-qph0wk53.js";
+} from "./workspace-ngk06vjf.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/config/plugin/command.ts
 var exports_command = {};

package/dist/chunks/{state-mnb85w6b.js → workspace-mnb85w6b.js}

@@ -1,9 +1,9 @@
 import {
   AbsolutePath
-} from "./state-j07kk359.js";
+} from "./workspace-j07kk359.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/worktree/directory.ts
 var exports_directory = {};

package/dist/chunks/{state-27ykzq5n.js → workspace-mx9wk07j.js}

@@ -1,25 +1,25 @@
 import {
   exports_supervisor_service
-} from "./state-s33fw6zm.js";
+} from "./workspace-s33fw6zm.js";
 import {
-  exports_mime
-} from "./state-dhphtf1x.js";
+  exports_image
+} from "./workspace-kb2ag3w7.js";
 import {
   exports_skill
-} from "./state-sz7acswn.js";
-import {
-  exports_image
-} from "./state-fp623900.js";
+} from "./workspace-71he9c34.js";
 import {
   AttachmentError,
   SkillNotFoundError
-} from "./state-cgqn2mrm.js";
+} from "./workspace-cgqn2mrm.js";
+import {
+  exports_mime
+} from "./workspace-dhphtf1x.js";
 import {
   exports_hooks
-} from "./state-v2wshkax.js";
+} from "./workspace-v2wshkax.js";
 import {
   __export
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/session/prompt.ts
 var exports_prompt = {};

package/dist/chunks/{state-mxvw03gv.js → workspace-mxvw03gv.js}

@@ -1,6 +1,6 @@
 import {
   __require
-} from "./state-rvfvac9x.js";
+} from "./workspace-rvfvac9x.js";
 
 // src/plugin/provider/openai-compatible.ts
 import { Effect } from "effect";