@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/event-logger-9s6t48vc.js

@@ -0,0 +1,184 @@
+import {
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
+import {
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
+import {
+  Service33,
+  node36
+} from "./event-logger-yhtqjkzd.js";
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./event-logger-p8qxwesx.js";
+import {
+  Service76,
+  node81
+} from "./event-logger-kfyw9f0s.js";
+import {
+  Ref4
+} from "./event-logger-00s3pqt3.js";
+import {
+  Service50,
+  node53
+} from "./event-logger-5jayeb3j.js";
+import {
+  SessionMessage2
+} from "./event-logger-982e01ww.js";
+import {
+  NotFoundError9
+} from "./event-logger-n6wnzfnt.js";
+import {
+  SessionEvent2
+} from "./event-logger-mntxs535.js";
+import {
+  Service28
+} from "./event-logger-xw0r27ex.js";
+import {
+  Service72,
+  node77
+} from "./event-logger-xf2wyvfy.js";
+import {
+  Item2,
+  serialized2,
+  Service29,
+  node33,
+  moveIDs2
+} from "./event-logger-aymbgepw.js";
+import {
+  Service27,
+  node32
+} from "./event-logger-65rxya3j.js";
+import {
+  node29
+} from "./event-logger-df0c2mh7.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/session/move.ts
+var exports_move = {};
+__export(exports_move, {
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  Service: () => Service24,
+  SessionMove: () => exports_move,
+  node: () => node28
+});
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { Cause, Context, Effect, Layer, Schema } from "effect";
+import path from "path";
+class DestinationNotFoundError2 extends Schema.TaggedError()("Session.DestinationNotFoundError", { directory: AbsolutePath2 }) {
+}
+
+class DestinationNotDirectoryError2 extends Schema.TaggedError()("Session.DestinationNotDirectoryError", { directory: AbsolutePath2 }) {
+}
+
+class DestinationUnavailableError2 extends Schema.TaggedError()("Session.DestinationUnavailableError", { directory: AbsolutePath2 }) {
+}
+
+class Service24 extends Context.Service()("@opencode/SessionMove") {
+}
+var layer = Layer.effect(Service24, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const projects = yield* Service76;
+  const locations = yield* Service50;
+  const store = yield* Service72;
+  const execution = yield* Service27;
+  const instances = yield* Service33;
+  const admission = yield* Service29;
+  const database = yield* Service80;
+  const bus = yield* Service79;
+  const get = Effect.fn("SessionMove.get")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError9({ sessionID });
+    return session;
+  });
+  const resolveDestination = Effect.fn("SessionMove.resolveDestination")(function* (session, input) {
+    const value = input.directory.trim();
+    const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value;
+    const directory = AbsolutePath2.make(path.resolve(session.location.directory, expanded));
+    const info = yield* fs.stat(directory).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    if (!info)
+      return yield* new DestinationNotFoundError2({ directory });
+    if (info.type !== "Directory")
+      return yield* new DestinationNotDirectoryError2({ directory });
+    const project = yield* projects.resolve(directory);
+    const destination = {
+      location: Ref4.make({ directory, workspaceID: input.workspaceID }),
+      projectID: project.id,
+      subpath: RelativePath2.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
+    };
+    yield* locations.contextEffect(destination.location).pipe(Effect.scoped, Effect.catchCause((cause) => {
+      if (Cause.hasInterruptsOnly(cause))
+        return Effect.failCause(cause);
+      return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(Effect.andThen(Effect.fail(new DestinationUnavailableError2({ directory }))));
+    }));
+    return destination;
+  });
+  const sourceUnavailable = Effect.fn("SessionMove.sourceUnavailable")(function* (session) {
+    if (yield* execution.isActive(session.id))
+      return false;
+    if (!(yield* fs.isDir(session.location.directory)))
+      return true;
+    return yield* Service28.pipe(instances.provide(session), Effect.as(false), Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.succeed(true)));
+  });
+  return Service24.of({
+    move: Effect.fn("SessionMove.move")(function* (input) {
+      const session = yield* get(input.sessionID);
+      const destination = yield* resolveDestination(session, input);
+      const unavailable = yield* sourceUnavailable(session);
+      const item = Item2.make({
+        type: "move",
+        payload: destination,
+        delivery: input.delivery ?? "steer"
+      });
+      yield* serialized2(input.sessionID, Effect.gen(function* () {
+        const latest = yield* get(input.sessionID);
+        if (unavailable && latest.location.directory === session.location.directory && latest.location.workspaceID === session.location.workspaceID && !(yield* execution.isActive(input.sessionID))) {
+          const cancellations = (yield* moveIDs2(database.db, input.sessionID)).map((item) => [SessionEvent2.InboxCancelled, { sessionID: input.sessionID, inboxID: item.id }]);
+          const moved = [SessionEvent2.Moved, { sessionID: input.sessionID, ...destination }];
+          const first = cancellations[0];
+          if (!first)
+            return yield* bus.publish(...moved).pipe(Effect.asVoid);
+          return yield* bus.publishAll([first, ...cancellations.slice(1), moved]);
+        }
+        yield* admission.admit({
+          id: SessionMessage2.ID.create(),
+          sessionID: input.sessionID,
+          item
+        }).pipe(Effect.orDie);
+      }));
+      yield* execution.wake(input.sessionID);
+    })
+  });
+}));
+var node28 = makeGlobalNode({
+  service: Service24,
+  layer,
+  deps: [
+    FSUtil.node,
+    Global.node,
+    node81,
+    node53,
+    node77,
+    node32,
+    node36,
+    node33,
+    node85,
+    node84,
+    node29
+  ]
+});
+
+export { DestinationNotFoundError2, DestinationNotDirectoryError2, DestinationUnavailableError2, Service24, node28, exports_move };

package/dist/chunks/{schema-qpxzqy01.js → event-logger-9xvrg3b1.js}

@@ -1,16 +1,16 @@
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  packageName2
+} from "./event-logger-rwbhhn1p.js";
 
 // src/plugin/provider/cerebras.ts
 import { Effect } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
-var CerebrasPlugin = define({
+var CerebrasPlugin2 = define({
   id: "opencode.provider.cerebras",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
-        const name = exports_provider.packageName(item.provider.package);
+        const name = packageName2(item.provider.package);
         if (name !== "@ai-sdk/cerebras" && name !== "@opencode-ai/ai/providers/cerebras")
           continue;
         evt.provider.update(item.provider.id, (provider) => {
@@ -21,4 +21,4 @@ var CerebrasPlugin = define({
   })
 });
 
-export { CerebrasPlugin };
+export { CerebrasPlugin2 };

package/dist/chunks/{schema-5j084t57.js → event-logger-9xybsmp2.js}

@@ -1,46 +1,47 @@
 import {
-  PermissionTable
-} from "./schema-d4h7vwhh.js";
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
 import {
-  exports_database
-} from "./schema-8scqw7rh.js";
+  PermissionTable2
+} from "./event-logger-d72308c8.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/permission/saved.ts
 var exports_saved = {};
 __export(exports_saved, {
-  AddInput: () => AddInput,
-  ID: () => ID,
-  Info: () => Info,
-  ListInput: () => ListInput,
+  AddInput: () => AddInput2,
+  ID: () => ID14,
+  Info: () => Info27,
+  ListInput: () => ListInput5,
   PermissionSaved: () => exports_saved,
-  Service: () => Service,
-  node: () => node
+  Service: () => Service73,
+  node: () => node78
 });
 import { eq } from "drizzle-orm";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Project } from "@opencode-ai/schema/project";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 import { PermissionSaved } from "@opencode-ai/schema/permission-saved";
-var ID = PermissionSaved.ID;
-var Info = PermissionSaved.Info;
-var ListInput = Schema.Struct({
+var ID14 = PermissionSaved.ID;
+var Info27 = PermissionSaved.Info;
+var ListInput5 = Schema.Struct({
   projectID: Project.ID.pipe(Schema.optional)
 }).annotate({ identifier: "PermissionSaved.ListInput" });
-var AddInput = Schema.Struct({
+var AddInput2 = Schema.Struct({
   projectID: Project.ID,
   action: Schema.String,
   resources: Schema.Array(Schema.String)
 }).annotate({ identifier: "PermissionSaved.AddInput" });
 
-class Service extends Context.Service()("@opencode/PermissionSaved") {
+class Service73 extends Context.Service()("@opencode/PermissionSaved") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const db = (yield* exports_database.Service).db;
+var layer = Layer.effect(Service73, Effect.gen(function* () {
+  const db = (yield* Service80).db;
   const list = Effect.fnUntraced(function* (input) {
-    const rows = yield* db.select().from(PermissionTable).where(input?.projectID ? eq(PermissionTable.project_id, input.projectID) : undefined).all().pipe(Effect.orDie);
+    const rows = yield* db.select().from(PermissionTable2).where(input?.projectID ? eq(PermissionTable2.project_id, input.projectID) : undefined).all().pipe(Effect.orDie);
     return rows.map((row) => ({
       id: row.id,
       projectID: row.project_id,
@@ -51,18 +52,18 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const add = Effect.fn("PermissionSaved.add")(function* (input) {
     if (!input.resources.length)
       return;
-    yield* db.insert(PermissionTable).values(input.resources.map((resource) => ({
-      id: ID.create(),
+    yield* db.insert(PermissionTable2).values(input.resources.map((resource) => ({
+      id: ID14.create(),
       project_id: input.projectID,
       action: input.action,
       resource
     }))).onConflictDoNothing().run().pipe(Effect.orDie);
   });
   const remove = Effect.fn("PermissionSaved.remove")(function* (id) {
-    yield* db.delete(PermissionTable).where(eq(PermissionTable.id, id)).run().pipe(Effect.orDie);
+    yield* db.delete(PermissionTable2).where(eq(PermissionTable2.id, id)).run().pipe(Effect.orDie);
   });
-  return Service.of({ list, add, remove });
+  return Service73.of({ list, add, remove });
 }));
-var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+var node78 = makeGlobalNode({ service: Service73, layer, deps: [node85] });
 
-export { ID, Info, ListInput, AddInput, Service, node, exports_saved };
+export { ID14, Info27, ListInput5, AddInput2, Service73, node78, exports_saved };

package/dist/chunks/event-logger-9zdhvgqs.js

@@ -0,0 +1,18 @@
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/plugin/service.ts
+var exports_service = {};
+__export(exports_service, {
+  Plugin: () => exports_service,
+  Service: () => Service30,
+  awaitActivation: () => awaitActivation2
+});
+import { Context } from "effect";
+
+class Service30 extends Context.Service()("@opencode/Plugin") {
+}
+var awaitActivation2 = Service30.use((plugins) => plugins.awaitActivation);
+
+export { Service30, awaitActivation2, exports_service };

package/dist/chunks/{schema-qqxqwwkk.js → event-logger-a089b8en.js}

@@ -1,21 +1,22 @@
 import {
-  exports_mcp
-} from "./schema-kwh3ary7.js";
+  Service79
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  Service75
+} from "./event-logger-00s3pqt3.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  PromptsChanged2,
+  Service40
+} from "./event-logger-2mqy9ydc.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/command.ts
 var exports_command = {};
 __export(exports_command, {
   CommandPlugin: () => exports_command,
-  Plugin: () => Plugin
+  Plugin: () => Plugin8
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Stream } from "effect";
@@ -192,14 +193,14 @@ If you're uncertain about something and can't verify it with these tools, say "I
 `;
 
 // src/plugin/command.ts
-var Plugin = define({
+var Plugin8 = define({
   id: "opencode.command",
   effect: Effect.fn(function* (ctx) {
-    const location = yield* exports_location.Service;
-    const mcp = yield* exports_mcp.Service;
-    const bus = yield* exports_bus.Service;
+    const location = yield* Service75;
+    const mcp = yield* Service40;
+    const bus = yield* Service79;
     const loaded = { prompts: [] };
-    yield* bus.subscribe(exports_mcp.PromptsChanged).pipe(Stream.runForEach(() => mcp.prompts().pipe(Effect.tap((prompts) => Effect.sync(() => loaded.prompts = prompts)), Effect.andThen(ctx.command.reload()))), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(PromptsChanged2).pipe(Stream.runForEach(() => mcp.prompts().pipe(Effect.tap((prompts) => Effect.sync(() => loaded.prompts = prompts)), Effect.andThen(ctx.command.reload()))), Effect.forkScoped({ startImmediately: true }));
     loaded.prompts = yield* mcp.prompts();
     yield* ctx.command.transform((editor) => {
       editor.add({
@@ -279,4 +280,4 @@ function sanitize(value) {
 var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
 var quoteTrimRegex = /^["']|["']$/g;
 
-export { Plugin, exports_command };
+export { Plugin8, exports_command };

package/dist/chunks/{schema-bybkghrn.js → event-logger-a1tpkmh4.js}

@@ -21,9 +21,9 @@ var blocks = new Set([
   "section",
   "summary"
 ]);
-var MAX_MARKDOWN_BYTES = 5 * 1024 * 1024;
-var CONTENT_BYTES = MAX_MARKDOWN_BYTES - 64 * 1024;
-function convertHTMLToMarkdown(html) {
+var MAX_MARKDOWN_BYTES2 = 5 * 1024 * 1024;
+var CONTENT_BYTES = MAX_MARKDOWN_BYTES2 - 64 * 1024;
+function convertHTMLToMarkdown2(html) {
   const output = [];
   const stack = [];
   const encoder = new TextEncoder;
@@ -64,7 +64,7 @@ function convertHTMLToMarkdown(html) {
     return characters.slice(0, low).join("");
   };
   const append = (value, content = false) => {
-    const limit = content ? CONTENT_BYTES : MAX_MARKDOWN_BYTES;
+    const limit = content ? CONTENT_BYTES : MAX_MARKDOWN_BYTES2;
     if (!value || outputBytes >= limit)
       return;
     const bytes = encoder.encode(value);
@@ -198,12 +198,12 @@ function convertHTMLToMarkdown(html) {
       tildes = Math.max(tildes, currentTildes);
     }
     if (code.inline) {
-      const fence2 = "`".repeat(Math.max(1, backticks + 1));
+      const fence = "`".repeat(Math.max(1, backticks + 1));
       const padding = /^ | $/.test(code.text) && !/^ +$/.test(code.text) ? " " : "";
       flushSpace();
       prefixQuote();
-      const wrapper = encoder.encode(`${fence2}${padding}${padding}${fence2}`).byteLength;
-      appendRaw(`${fence2}${padding}${sliceBytes(code.text, Math.max(0, CONTENT_BYTES - outputBytes - wrapper))}${padding}${fence2}`);
+      const wrapper = encoder.encode(`${fence}${padding}${padding}${fence}`).byteLength;
+      appendRaw(`${fence}${padding}${sliceBytes(code.text, Math.max(0, CONTENT_BYTES - outputBytes - wrapper))}${padding}${fence}`);
       return;
     }
     if (activeCell) {
@@ -238,7 +238,7 @@ function convertHTMLToMarkdown(html) {
       depth++;
       if (depth > 1e4) {
         if (stack.at(-1)?.suppressed) {
-          const visibleParent = stack.findLastIndex((frame2) => !frame2.suppressed);
+          const visibleParent = stack.findLastIndex((frame) => !frame.suppressed);
           fallbackSuppressedDepth = visibleParent + 2;
         }
         activeCode = undefined;
@@ -395,8 +395,8 @@ function convertHTMLToMarkdown(html) {
         const value = Number.parseInt(attributes.value ?? "");
         if (activeList?.ordered && !Number.isNaN(value))
           activeList.next = value;
-        const marker2 = activeList?.ordered ? `${activeList.next++}.` : "-";
-        const prefix = `${(activeItem?.indent ?? "").slice(0, 24)}${marker2} `;
+        const marker = activeList?.ordered ? `${activeList.next++}.` : "-";
+        const prefix = `${(activeItem?.indent ?? "").slice(0, 24)}${marker} `;
         frame.item = { indent: " ".repeat(prefix.length), previous: activeItem };
         activeItem = frame.item;
         pendingIndent = "";
@@ -662,7 +662,7 @@ ${prefix}| ${row.join(" | ")} |`);
     pendingText += chunk;
   }
   flushText();
-  return sliceBytes(normalized.join("").trim(), MAX_MARKDOWN_BYTES);
+  return sliceBytes(normalized.join("").trim(), MAX_MARKDOWN_BYTES2);
 }
 
-export { MAX_MARKDOWN_BYTES, convertHTMLToMarkdown };
+export { MAX_MARKDOWN_BYTES2, convertHTMLToMarkdown2 };

package/dist/chunks/{schema-8ahgknnv.js → event-logger-aae7qk0j.js}

@@ -1,27 +1,27 @@
 import {
-  DiffError
-} from "./schema-d26zqcqt.js";
+  Service75
+} from "./event-logger-00s3pqt3.js";
 import {
-  MAX_PATCH_BYTES,
-  MAX_TOTAL_PATCH_BYTES,
-  PATCH_CONTEXT_LINES,
-  addPatch,
-  chunksByFile,
-  countPatch,
-  deletePatch,
-  emptyPatch
-} from "./schema-3chx3ng6.js";
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  addPatch2,
+  deletePatch2,
+  countPatch2,
+  chunksByFile2
+} from "./event-logger-tazgh4e4.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  DiffError2
+} from "./event-logger-vwbmxwbe.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/vcs/hg.ts
 var exports_hg = {};
 __export(exports_hg, {
-  Plugin: () => Plugin,
+  Plugin: () => Plugin2,
   VcsHgPlugin: () => exports_hg
 });
 import path from "path";
@@ -30,10 +30,10 @@ import { ChildProcess } from "effect/unstable/process";
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { AppProcess } from "@opencode-ai/util/process";
-var Plugin = define({
+var Plugin2 = define({
   id: "opencode.vcs.hg",
   effect: Effect.fn("VcsHgPlugin")(function* (ctx) {
-    const location = yield* exports_location.Service;
+    const location = yield* Service75;
     if (location.vcs?.type !== "hg")
       return;
     const processes = yield* AppProcess.Service;
@@ -64,27 +64,27 @@ function make(proc, fs, input) {
       const content = yield* fs.readFileString(path.join(input.worktree, item.file)).pipe(Effect.orElseSucceed(() => {
         return;
       }));
-      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES)
-        return emptyPatch(item.file);
-      return addPatch(item.file, content);
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES2)
+        return emptyPatch2(item.file);
+      return addPatch2(item.file, content);
     }
     if (item.code === "!") {
       const content = yield* hg.cat(rev ?? ".", item.file);
-      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES)
-        return emptyPatch(item.file);
-      return deletePatch(item.file, content);
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES2)
+        return emptyPatch2(item.file);
+      return deletePatch2(item.file, content);
     }
-    return emptyPatch(item.file);
+    return emptyPatch2(item.file);
   });
   const diffAgainst = Effect.fnUntraced(function* (rev, options) {
-    const [items, batch] = yield* Effect.all([hg.status(rev, scope), hg.diff(rev, scope, { context: options?.context ?? PATCH_CONTEXT_LINES })], { concurrency: 2 });
-    const chunks = chunksByFile(batch, () => {
+    const [items, batch] = yield* Effect.all([hg.status(rev, scope), hg.diff(rev, scope, { context: options?.context ?? PATCH_CONTEXT_LINES2 })], { concurrency: 2 });
+    const chunks = chunksByFile2(batch, () => {
       return;
     });
     const list = [];
     for (const item of items.toSorted((a, b) => a.file.localeCompare(b.file))) {
       const patch = yield* patchFor(item, rev, chunks.get(item.file));
-      const counts = countPatch(patch);
+      const counts = countPatch2(patch);
       list.push({
         file: item.file,
         patch,
@@ -114,7 +114,7 @@ function make(proc, fs, input) {
       if (mode === "working")
         return yield* diffAgainst(undefined, options);
       if (mode === "committed" || options?.base !== undefined) {
-        return yield* new DiffError({
+        return yield* new DiffError2({
           message: "The Mercurial provider does not support committed reviews or explicit bases"
         });
       }
@@ -162,7 +162,7 @@ function makeHg(proc, worktree) {
     });
   });
   const diff = Effect.fn("VcsHg.diffPatch")(function* (rev, scope, options) {
-    const result = yield* run(["diff", "--git", "--unified", String(options.context), ...rev ? ["-r", rev] : [], scope], { maxOutputBytes: MAX_TOTAL_PATCH_BYTES });
+    const result = yield* run(["diff", "--git", "--unified", String(options.context), ...rev ? ["-r", rev] : [], scope], { maxOutputBytes: MAX_TOTAL_PATCH_BYTES2 });
     if (result.exitCode !== 0)
       return { text: "", truncated: false };
     return { text: result.text(), truncated: result.truncated };
@@ -180,7 +180,7 @@ function makeHg(proc, worktree) {
     return result.text().trim() || undefined;
   });
   const cat = Effect.fn("VcsHg.cat")(function* (rev, file) {
-    const result = yield* run(["cat", "-r", rev, "--", file], { maxOutputBytes: MAX_PATCH_BYTES });
+    const result = yield* run(["cat", "-r", rev, "--", file], { maxOutputBytes: MAX_PATCH_BYTES2 });
     if (result.exitCode !== 0 || result.truncated)
       return;
     return result.text();
@@ -188,4 +188,4 @@ function makeHg(proc, worktree) {
   return { status, diff, branch, ancestor, cat };
 }
 
-export { Plugin, exports_hg };
+export { Plugin2, exports_hg };

package/dist/chunks/{schema-jqhp3fpz.js → event-logger-aaet6srn.js}

@@ -1,22 +1,22 @@
 import {
-  Failed,
-  NotFound,
-  WrongKind
-} from "./schema-vynk8zbr.js";
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./event-logger-2a5m3afh.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/environment/memory.ts
 var exports_memory = {};
 __export(exports_memory, {
   EnvironmentMemory: () => exports_memory,
-  makeMemoryDriver: () => makeMemoryDriver
+  makeMemoryDriver: () => makeMemoryDriver2
 });
 import path from "node:path";
 import { Effect, PlatformError } from "effect";
 import { make } from "effect/unstable/process/ChildProcessSpawner";
-var makeMemoryDriver = () => {
+var makeMemoryDriver2 = () => {
   const nodes = new Map([["/", { type: "directory", mtimeMs: Date.now() }]]);
   const key = (value) => path.posix.resolve("/", value);
   const info = (node) => ({
@@ -65,24 +65,24 @@ var makeMemoryDriver = () => {
       mkdirSync(parent);
     nodes.set(target, { type: "directory", mtimeMs: Date.now() });
   };
-  const failed = (value, cause) => new Failed({ path: value, cause });
+  const failed = (value, cause) => new Failed2({ path: value, cause });
   const overrides = {
     stat: (value) => Effect.suspend(() => {
       const node = lookup(value);
-      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }));
+      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound2({ path: value }));
     }),
     read: (value, range) => Effect.gen(function* () {
       const original = lookup(value);
       if (!original)
-        return yield* new NotFound({ path: value });
+        return yield* new NotFound2({ path: value });
       if (original.type === "directory")
-        return yield* new WrongKind({ path: value, actual: "directory" });
+        return yield* new WrongKind2({ path: value, actual: "directory" });
       const resolved = resolveKey(value, true);
       const node = resolved === undefined ? undefined : nodes.get(resolved);
       if (!node)
-        return yield* new NotFound({ path: value });
+        return yield* new NotFound2({ path: value });
       if (node.type !== "file")
-        return yield* new WrongKind({ path: value, actual: node.type });
+        return yield* new WrongKind2({ path: value, actual: node.type });
       const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length);
       return { info: info(node), bytes: bytes.slice() };
     }),
@@ -104,9 +104,9 @@ var makeMemoryDriver = () => {
       const target = resolveKey(value, true) ?? key(value);
       const node = nodes.get(target);
       if (!node)
-        return yield* new NotFound({ path: value });
+        return yield* new NotFound2({ path: value });
       if (node.type !== "directory")
-        return yield* new WrongKind({ path: value, actual: node.type });
+        return yield* new WrongKind2({ path: value, actual: node.type });
       return [...nodes.entries()].filter(([entry]) => entry !== target && path.posix.dirname(entry) === target).map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type })).sort((a, b) => a.name.localeCompare(b.name));
     }),
     remove: (value) => Effect.sync(() => {
@@ -120,7 +120,7 @@ var makeMemoryDriver = () => {
       const source = resolveKey(from, false) ?? key(from);
       const node = nodes.get(source);
       if (!node)
-        return yield* new NotFound({ path: from });
+        return yield* new NotFound2({ path: from });
       yield* Effect.try({
         try: () => {
           const requested = resolveKey(to, false) ?? key(to);
@@ -167,4 +167,4 @@ var makeMemoryDriver = () => {
   };
 };
 
-export { makeMemoryDriver, exports_memory };
+export { makeMemoryDriver2, exports_memory };