@opencode-ai/core 0.0.0-dev-19087 → 0.0.0-dev-19093

package/dist/chunks/{instance-wbkt8qpj.js → kv-wd87259q.js}

@@ -1,7 +1,7 @@
 import {
-  getViewSelectedFieldsRuntime,
-  orderSelectedFields
-} from "./instance-k8b45nas.js";
+  getViewSelectedFieldsRuntime2,
+  orderSelectedFields2
+} from "./kv-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/select.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
@@ -11,7 +11,7 @@ import { SQLiteSelectBase } from "drizzle-orm/sqlite-core/query-builders/select"
 import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
 import { Subquery } from "drizzle-orm/subquery";
 import { getTableColumns } from "drizzle-orm/utils";
-class SQLiteEffectSelectBuilder {
+class SQLiteEffectSelectBuilder2 {
   static [entityKind] = "SQLiteEffectSelectBuilder";
   fields;
   session;
@@ -36,13 +36,13 @@ class SQLiteEffectSelectBuilder {
         source[key]
       ]));
     } else if (is(source, SQLiteViewBase)) {
-      fields = getViewSelectedFieldsRuntime(source).selectedFields;
+      fields = getViewSelectedFieldsRuntime2(source).selectedFields;
     } else if (is(source, SQL)) {
       fields = {};
     } else {
       fields = getTableColumns(source);
     }
-    return new SQLiteEffectSelectBase({
+    return new SQLiteEffectSelectBase2({
       table: source,
       fields,
       isPartialSelect,
@@ -54,7 +54,7 @@ class SQLiteEffectSelectBuilder {
   }
 }
 
-class SQLiteEffectSelectBase extends SQLiteSelectBase {
+class SQLiteEffectSelectBase2 extends SQLiteSelectBase {
   static [entityKind] = "SQLiteEffectSelect";
   get effectConfig() {
     return this.config;
@@ -67,7 +67,7 @@ class SQLiteEffectSelectBase extends SQLiteSelectBase {
       throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
     }
     const session = this.session;
-    const query = session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), orderSelectedFields(this.effectConfig.fields), "all", undefined, {
+    const query = session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), orderSelectedFields2(this.effectConfig.fields), "all", undefined, {
       type: "select",
       tables: [...this.usedTables]
     }, this.cacheConfig);
@@ -97,6 +97,6 @@ class SQLiteEffectSelectBase extends SQLiteSelectBase {
     return this._prepare().execute(placeholderValues);
   };
 }
-applyEffectWrapper(SQLiteEffectSelectBase);
+applyEffectWrapper(SQLiteEffectSelectBase2);
 
-export { SQLiteEffectSelectBuilder, SQLiteEffectSelectBase };
+export { SQLiteEffectSelectBuilder2, SQLiteEffectSelectBase2 };

package/dist/chunks/{instance-qjv6na9g.js → kv-we11dx6z.js}

@@ -1,30 +1,30 @@
 import {
-  exports_form
-} from "./instance-b3ba60js.js";
+  Service78
+} from "./kv-jnv71sbj.js";
 import {
-  exports_permission
-} from "./instance-enjmckgs.js";
+  Service53
+} from "./kv-nsdz1sxb.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/tool/plugin/question.ts
 var exports_question = {};
 __export(exports_question, {
-  CancelledError: () => CancelledError,
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
+  CancelledError: () => CancelledError2,
+  Input: () => Input14,
+  Output: () => Output9,
+  Plugin: () => Plugin44,
   QuestionTool: () => exports_question,
-  description: () => description,
-  name: () => name,
-  toModelContent: () => toModelContent
+  description: () => description6,
+  name: () => name14,
+  toModelContent: () => toModelContent7
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import { Question } from "@opencode-ai/schema/question";
-var name = "question";
-var description = `Use this tool when you need to ask the user questions during execution. This allows you to:
+var name14 = "question";
+var description6 = `Use this tool when you need to ask the user questions during execution. This allows you to:
 1. Gather user preferences or requirements
 2. Clarify ambiguous instructions
 3. Get decisions on implementation choices as you work
@@ -34,33 +34,33 @@ Usage notes:
 - A "Type your own answer" option is added automatically; don't include a separate option for free form answers
 - Set \`multiple: true\` to allow selecting more than one option
 - If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`;
-var Input = Schema.Struct({
+var Input14 = Schema.Struct({
   questions: Schema.Array(Question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" })
 });
-var Output = Schema.Struct({
+var Output9 = Schema.Struct({
   answers: Schema.Array(Question.Answer)
 });
 
-class CancelledError extends Schema.TaggedError()("QuestionTool.CancelledError", {}) {
+class CancelledError2 extends Schema.TaggedError()("QuestionTool.CancelledError", {}) {
   get message() {
     return "The user dismissed this question";
   }
 }
-var toModelContent = (questions, answers) => {
+var toModelContent7 = (questions, answers) => {
   const formatted = questions.map((question, index) => `"${question.question}"="${answers[index]?.length ? answers[index].join(", ") : "Unanswered"}"`).join(", ");
   return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`;
 };
-var Plugin = {
+var Plugin44 = {
   id: "opencode.tool.question",
   effect: Effect.fn("QuestionTool.Plugin")(function* (ctx) {
-    const forms = yield* exports_form.Service;
-    const permission = yield* exports_permission.Service;
+    const forms = yield* Service78;
+    const permission = yield* Service53;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name14,
       options: { codemode: false },
-      description,
-      input: Input,
-      output: Output,
+      description: description6,
+      input: Input14,
+      output: Output9,
       execute: (input, context) => permission.assert({
         action: "question",
         resources: ["*"],
@@ -80,7 +80,7 @@ var Plugin = {
         ]
       }).pipe(Effect.orDie)), Effect.flatMap((state) => {
         if (state.status === "cancelled")
-          return Effect.die(new CancelledError);
+          return Effect.die(new CancelledError2);
         const output = {
           answers: input.questions.map((_, index) => {
             const value = state.answer[`q${index}`];
@@ -93,7 +93,7 @@ var Plugin = {
         };
         return Effect.succeed({
           output,
-          content: toModelContent(input.questions, output.answers),
+          content: toModelContent7(input.questions, output.answers),
           metadata: { answers: output.answers }
         });
       }))
@@ -115,4 +115,4 @@ function toField(question, index) {
   };
 }
 
-export { name, description, Input, Output, CancelledError, toModelContent, Plugin, exports_question };
+export { name14, description6, Input14, Output9, CancelledError2, toModelContent7, Plugin44, exports_question };

package/dist/chunks/{instance-njsjmnxj.js → kv-wh6ksyj4.js}

@@ -1,32 +1,35 @@
 import {
-  exports_instructions
-} from "./instance-c54e84vp.js";
+  Service70,
+  node74
+} from "./kv-c7r09442.js";
 import {
-  exports_location
-} from "./instance-0xgrsc61.js";
+  Key3,
+  make19,
+  combine2
+} from "./kv-6e958v7x.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/instructions/builtins.ts
 var exports_builtins = {};
 __export(exports_builtins, {
   InstructionBuiltIns: () => exports_builtins,
-  Service: () => Service,
-  node: () => node
+  Service: () => Service34,
+  node: () => node37
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, DateTime, Effect, Layer, Schema } from "effect";
 import { Global } from "@opencode-ai/util/global";
-class Service extends Context.Service()("@opencode/InstructionBuiltIns") {
+class Service34 extends Context.Service()("@opencode/InstructionBuiltIns") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service34, Effect.gen(function* () {
   const global = yield* Global.Service;
-  const location = yield* exports_location.Service;
-  return Service.of({
-    load: (sessionID) => Effect.succeed(exports_instructions.combine([
-      exports_instructions.make({
-        key: exports_instructions.Key.make("core/environment"),
+  const location = yield* Service70;
+  return Service34.of({
+    load: (sessionID) => Effect.succeed(combine2([
+      make19({
+        key: Key3.make("core/environment"),
         codec: Schema.toCodecJson(Schema.String),
         read: Effect.sync(() => [
           "<env>",
@@ -46,8 +49,8 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
 `)
         }
       }),
-      exports_instructions.make({
-        key: exports_instructions.Key.make("core/date"),
+      make19({
+        key: Key3.make("core/date"),
         codec: Schema.toCodecJson(Schema.String),
         read: DateTime.nowAsDate.pipe(Effect.map((date) => date.toDateString())),
         render: {
@@ -58,6 +61,6 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     ]))
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [Global.node, exports_location.node] });
+var node37 = makeLocationNode({ service: Service34, layer, deps: [Global.node, node74] });
 
-export { Service, node, exports_builtins };
+export { Service34, node37, exports_builtins };

package/dist/chunks/kv-wsfy2223.js

@@ -0,0 +1,18 @@
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/session/runner/index.ts
+var exports_runner = {};
+__export(exports_runner, {
+  DrainResult: () => DrainResult2,
+  Service: () => Service24,
+  SessionRunner: () => exports_runner
+});
+import { Context, Data } from "effect";
+var DrainResult2 = Data.taggedEnum();
+
+class Service24 extends Context.Service()("@opencode/SessionRunner") {
+}
+
+export { DrainResult2, Service24, exports_runner };

package/dist/chunks/{instance-z361wxjg.js → kv-wtmp9133.js}

@@ -1,25 +1,28 @@
 import {
-  exports_store
-} from "./instance-4sxm9wb7.js";
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
-  SessionEvent
-} from "./instance-a83yvq99.js";
+  Service70,
+  node74
+} from "./kv-c7r09442.js";
 import {
-  exports_location
-} from "./instance-0xgrsc61.js";
+  SessionEvent2
+} from "./kv-mntxs535.js";
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  Service55,
+  node58
+} from "./kv-0c2smd8y.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/session/instructions.ts
 var exports_instructions = {};
 __export(exports_instructions, {
-  Service: () => Service,
+  Service: () => Service6,
   SessionInstructions: () => exports_instructions,
-  node: () => node
+  node: () => node8
 });
 import { relative } from "path";
 import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
@@ -29,13 +32,13 @@ var InjectedMetadata = Schema.Struct({
   instruction: Schema.Struct({ paths: Schema.Array(Schema.String) })
 });
 
-class Service extends Context.Service()("@opencode/SessionInstructions") {
+class Service6 extends Context.Service()("@opencode/SessionInstructions") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
+var layer = Layer.effect(Service6, Effect.gen(function* () {
+  const bus = yield* Service79;
   const fs = yield* FSUtil.Service;
-  const store = yield* exports_store.Service;
-  const location = yield* exports_location.Service;
+  const store = yield* Service55;
+  const location = yield* Service70;
   const root = yield* fs.resolve(location.project.directory);
   const inFlight = yield* Ref.make(new Map);
   const load = Effect.fn("SessionInstructions.load")(function* (input) {
@@ -59,7 +62,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const readable = files.filter((file) => file !== undefined);
       if (readable.length === 0)
         return;
-      yield* bus.publish(SessionEvent.Synthetic, {
+      yield* bus.publish(SessionEvent2.Synthetic, {
         sessionID: input.sessionID,
         text: readable.map((file) => `Instructions from: ${file.path}
 ${file.content}`).join(`
@@ -81,7 +84,7 @@ ${file.content}`).join(`
       return next;
     })));
   });
-  return Service.of({ load });
+  return Service6.of({ load });
 }));
 function previouslyInjected(store, sessionID) {
   return Effect.gen(function* () {
@@ -92,10 +95,10 @@ function previouslyInjected(store, sessionID) {
 function describePath(root, path) {
   return FSUtil.contains(root, path) ? relative(root, path) : path;
 }
-var node = makeLocationNode({
+var node8 = makeLocationNode({
   name: "session-instructions",
   layer,
-  deps: [exports_bus.node, FSUtil.node, exports_location.node, exports_store.node]
+  deps: [node83, FSUtil.node, node74, node58]
 });
 
-export { Service, node, exports_instructions };
+export { Service6, node8, exports_instructions };

package/dist/chunks/{instance-rneafqj3.js → kv-wywtm3b4.js}

@@ -1,42 +1,50 @@
 import {
-  WorktreeTable
-} from "./instance-gb1z7yet.js";
+  AbsolutePath2
+} from "./kv-p8qxwesx.js";
 import {
-  exports_schema
-} from "./instance-m7jtgrng.js";
+  Service80,
+  node84
+} from "./kv-3rps85z5.js";
 import {
-  ProjectTable,
-  upsertProject
-} from "./instance-c8ya26sa.js";
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
-  exports_git
-} from "./instance-qz5gwjr7.js";
+  Service72,
+  node76
+} from "./kv-fw8cvjkv.js";
 import {
-  AbsolutePath
-} from "./instance-j07kk359.js";
+  ID13,
+  Current3,
+  Info27,
+  UpdateInput4,
+  Event16,
+  Vcs3
+} from "./kv-wb29ggtc.js";
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  ProjectTable2,
+  upsertProject2
+} from "./kv-9qm9egsn.js";
 import {
-  exports_database
-} from "./instance-5ez4e7fn.js";
+  WorktreeTable2
+} from "./kv-ajtjthsy.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/project.ts
 var exports_project = {};
 __export(exports_project, {
-  Current: () => Current,
-  ID: () => ID,
-  Info: () => Info,
-  NotFoundError: () => NotFoundError,
+  Current: () => Current2,
+  ID: () => ID12,
+  Info: () => Info26,
+  NotFoundError: () => NotFoundError9,
   Project: () => exports_project,
-  Service: () => Service,
-  UpdateInput: () => UpdateInput,
-  Vcs: () => Vcs,
-  node: () => node,
-  root: () => root
+  Service: () => Service71,
+  UpdateInput: () => UpdateInput3,
+  Vcs: () => Vcs2,
+  node: () => node75,
+  root: () => root2
 });
 import { Context, Effect, Layer, Schema } from "effect";
 import { ChildProcess } from "effect/unstable/process";
@@ -47,23 +55,23 @@ import { FSUtil } from "@opencode-ai/util/fs-util";
 import { AppProcess } from "@opencode-ai/util/process";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 import { Hash } from "@opencode-ai/util/hash";
-var ID = exports_schema.ID;
-var Vcs = exports_schema.Vcs;
-var Current = exports_schema.Current;
-var Info = exports_schema.Info;
-var UpdateInput = exports_schema.UpdateInput;
+var ID12 = ID13;
+var Vcs2 = Vcs3;
+var Current2 = Current3;
+var Info26 = Info27;
+var UpdateInput3 = UpdateInput4;
 
-class NotFoundError extends Schema.TaggedError()("Project.NotFoundError", {
-  projectID: ID
+class NotFoundError9 extends Schema.TaggedError()("Project.NotFoundError", {
+  projectID: ID12
 }) {
 }
-var root = Effect.fn("Project.root")(function* (fs, input, markers = [".git", ".hg"]) {
-  return yield* fs.up({ targets: [...markers], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0] ? AbsolutePath.make(path.dirname(matches[0])) : undefined), Effect.orElseSucceed(() => {
+var root2 = Effect.fn("Project.root")(function* (fs, input, markers = [".git", ".hg"]) {
+  return yield* fs.up({ targets: [...markers], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0] ? AbsolutePath2.make(path.dirname(matches[0])) : undefined), Effect.orElseSucceed(() => {
     return;
   }));
 });
 
-class Service extends Context.Service()("@opencode/Project") {
+class Service71 extends Context.Service()("@opencode/Project") {
 }
 function fromRow(row) {
   const icon = row.icon_url || row.icon_url_override || row.icon_color ? {
@@ -86,20 +94,20 @@ function fromRow(row) {
     sandboxes: row.sandboxes
   };
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service71, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* exports_git.Service;
+  const git = yield* Service72;
   const proc = yield* AppProcess.Service;
-  const bus = yield* exports_bus.Service;
-  const db = (yield* exports_database.Service).db;
+  const bus = yield* Service79;
+  const db = (yield* Service80).db;
   const announcing = new Set;
   const persist = Effect.fnUntraced(function* (project) {
-    const previous = yield* db.select({ canonical: ProjectTable.worktree }).from(ProjectTable).where(eq(ProjectTable.id, project.id)).get().pipe(Effect.orDie);
-    yield* upsertProject(db, project).pipe(Effect.orDie);
+    const previous = yield* db.select({ canonical: ProjectTable2.worktree }).from(ProjectTable2).where(eq(ProjectTable2.id, project.id)).get().pipe(Effect.orDie);
+    yield* upsertProject2(db, project).pipe(Effect.orDie);
     if (previous && previous.canonical !== project.canonical && !(yield* fs.exists(previous.canonical).pipe(Effect.orElseSucceed(() => true)))) {
-      const row = yield* db.update(ProjectTable).set({ worktree: project.canonical }).where(eq(ProjectTable.id, project.id)).returning().get().pipe(Effect.orDie);
+      const row = yield* db.update(ProjectTable2).set({ worktree: project.canonical }).where(eq(ProjectTable2.id, project.id)).returning().get().pipe(Effect.orDie);
       if (row)
-        yield* bus.publish(exports_schema.Event.Updated, fromRow(row));
+        yield* bus.publish(Event16.Updated, fromRow(row));
     }
     if (!project.vcs)
       return project;
@@ -118,11 +126,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         continue;
       announcing.add(key);
       yield* Effect.gen(function* () {
-        const stored = yield* db.select({ directory: WorktreeTable.directory }).from(WorktreeTable).where(and(eq(WorktreeTable.project_id, item.projectID), eq(WorktreeTable.directory, item.directory))).get().pipe(Effect.orDie);
+        const stored = yield* db.select({ directory: WorktreeTable2.directory }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, item.projectID), eq(WorktreeTable2.directory, item.directory))).get().pipe(Effect.orDie);
         if (stored)
           return;
-        const directory = AbsolutePath.make(yield* fs.resolve(item.directory));
-        const markerless = yield* db.select({ id: ProjectTable.id, directory: ProjectTable.worktree }).from(ProjectTable).where(and(isNull(ProjectTable.vcs), gte(ProjectTable.worktree, directory), lte(ProjectTable.worktree, AbsolutePath.make(directory + "￿")))).all().pipe(Effect.orDie);
+        const directory = AbsolutePath2.make(yield* fs.resolve(item.directory));
+        const markerless = yield* db.select({ id: ProjectTable2.id, directory: ProjectTable2.worktree }).from(ProjectTable2).where(and(isNull(ProjectTable2.vcs), gte(ProjectTable2.worktree, directory), lte(ProjectTable2.worktree, AbsolutePath2.make(directory + "￿")))).all().pipe(Effect.orDie);
         const adopted = yield* Effect.filter(markerless, (candidate) => Effect.gen(function* () {
           if (candidate.id === item.projectID)
             return false;
@@ -136,35 +144,35 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         yield* bus.publish(Worktree.Event.Resolved, {
           projectID: item.projectID,
           directory: item.directory,
-          previous: project.previous ?? ID.global,
+          previous: project.previous ?? ID12.global,
           ...adopted.length ? { adopted: adopted.map((candidate) => candidate.id) } : {}
         }, {
-          commit: () => db.insert(WorktreeTable).values({ project_id: item.projectID, directory: item.directory, strategy: item.strategy }).onConflictDoNothing().run().pipe(Effect.orDie, Effect.asVoid)
+          commit: () => db.insert(WorktreeTable2).values({ project_id: item.projectID, directory: item.directory, strategy: item.strategy }).onConflictDoNothing().run().pipe(Effect.orDie, Effect.asVoid)
         });
       }).pipe(Effect.ensuring(Effect.sync(() => announcing.delete(key))));
     }
     return project;
   });
   const list = Effect.fn("Project.list")(function* () {
-    const rows = yield* db.select().from(ProjectTable).orderBy(desc(ProjectTable.time_updated), asc(ProjectTable.id)).all().pipe(Effect.orDie);
+    const rows = yield* db.select().from(ProjectTable2).orderBy(desc(ProjectTable2.time_updated), asc(ProjectTable2.id)).all().pipe(Effect.orDie);
     return rows.map(fromRow);
   });
   const update = Effect.fn("Project.update")(function* (input) {
-    const row = yield* db.update(ProjectTable).set({
+    const row = yield* db.update(ProjectTable2).set({
       name: input.name === undefined ? undefined : input.name || null,
       icon_url_override: input.icon?.override === undefined ? undefined : input.icon.override || null,
       icon_color: input.icon?.color === undefined ? undefined : input.icon.color || null,
       commands: input.commands?.start === undefined ? undefined : input.commands.start ? { start: input.commands.start } : null,
       time_updated: Date.now()
-    }).where(eq(ProjectTable.id, input.projectID)).returning().get().pipe(Effect.orDie);
+    }).where(eq(ProjectTable2.id, input.projectID)).returning().get().pipe(Effect.orDie);
     if (!row)
-      return yield* new NotFoundError({ projectID: input.projectID });
+      return yield* new NotFoundError9({ projectID: input.projectID });
     const project = fromRow(row);
-    yield* bus.publish(exports_schema.Event.Updated, project);
+    yield* bus.publish(Event16.Updated, project);
     return project;
   });
   const cached = Effect.fnUntraced(function* (dir) {
-    return yield* fs.readFileString(path.join(dir, "opencode")).pipe(Effect.map((value) => value.trim()), Effect.map((value) => value ? ID.make(value) : undefined), Effect.orElseSucceed(() => {
+    return yield* fs.readFileString(path.join(dir, "opencode")).pipe(Effect.map((value) => value.trim()), Effect.map((value) => value ? ID12.make(value) : undefined), Effect.orElseSucceed(() => {
       return;
     }));
   });
@@ -175,7 +183,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const normalized = url(origin);
     if (!normalized)
       return;
-    return ID.make(Hash.fast(`git-remote:${normalized}`));
+    return ID12.make(Hash.fast(`git-remote:${normalized}`));
   });
   function url(input) {
     const value = input.trim();
@@ -199,8 +207,8 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     return `${host.toLowerCase()}/${pathname}`;
   }
   const rootCommit = Effect.fnUntraced(function* (repo) {
-    const root2 = (yield* git.history.rootCommits(repo))[0];
-    return root2 ? ID.make(root2) : undefined;
+    const root = (yield* git.history.rootCommits(repo))[0];
+    return root ? ID12.make(root) : undefined;
   });
   const hgRoot = Effect.fnUntraced(function* (worktree) {
     const result = yield* proc.run(ChildProcess.make("hg", ["log", "-r", "roots(all())", "-T", `{node}
@@ -216,39 +224,39 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return;
     const node = result.stdout.toString("utf8").split(`
 `).map((item) => item.trim()).filter(Boolean).toSorted()[0];
-    return node ? ID.make(node) : undefined;
+    return node ? ID12.make(node) : undefined;
   });
   const hgDiscover = Effect.fnUntraced(function* (dotHg) {
-    const worktree = AbsolutePath.make(path.dirname(dotHg));
-    const store = AbsolutePath.make(dotHg);
+    const worktree = AbsolutePath2.make(path.dirname(dotHg));
+    const store = AbsolutePath2.make(dotHg);
     const previous = yield* cached(store);
     const id = previous ?? (yield* hgRoot(worktree));
     return {
       previous,
-      id: id ?? ID.global,
+      id: id ?? ID12.global,
       directory: worktree,
       vcs: { type: "hg", store }
     };
   });
   const resolve = Effect.fn("Project.resolve")(function* (input, _options) {
-    const directory = AbsolutePath.make(yield* fs.resolve(input));
+    const directory = AbsolutePath2.make(yield* fs.resolve(input));
     const native = yield* fs.up({ targets: [".git", ".hg"], start: directory, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.orElseSucceed(() => {
       return;
     }));
-    const repo = native && path.basename(native) === ".git" ? yield* git.repo.discover(AbsolutePath.make(path.dirname(native))) : undefined;
+    const repo = native && path.basename(native) === ".git" ? yield* git.repo.discover(AbsolutePath2.make(path.dirname(native))) : undefined;
     if (repo) {
       const previous = yield* cached(repo.commonDirectory);
       const id = (yield* remote(repo)) ?? previous ?? (yield* rootCommit(repo));
       const canonical = repo.gitDirectory === repo.commonDirectory ? repo.worktree : yield* git.worktree.list(repo).pipe(Effect.map((items) => items.find((item) => item.kind === "main")?.directory ?? repo.worktree), Effect.orElseSucceed(() => repo.worktree));
       return yield* persist({
         previous,
-        id: id ?? ID.global,
+        id: id ?? ID12.global,
         directory: repo.worktree,
         canonical,
         vcs: { type: "git", store: repo.commonDirectory }
       });
     }
-    const hg = native && path.basename(native) === ".hg" ? yield* hgDiscover(AbsolutePath.make(native)) : undefined;
+    const hg = native && path.basename(native) === ".hg" ? yield* hgDiscover(AbsolutePath2.make(native)) : undefined;
     if (hg) {
       return yield* persist({
         ...hg,
@@ -256,18 +264,18 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       });
     }
     return yield* persist({
-      id: ID.make(Hash.fast(`directory:${directory}`)),
+      id: ID12.make(Hash.fast(`directory:${directory}`)),
       directory,
       canonical: directory,
       vcs: undefined
     });
   });
-  return Service.of({ list, update, resolve });
+  return Service71.of({ list, update, resolve });
 }));
-var node = makeGlobalNode({
-  service: Service,
+var node75 = makeGlobalNode({
+  service: Service71,
   layer,
-  deps: [exports_bus.node, exports_database.node, FSUtil.node, exports_git.node, AppProcess.node]
+  deps: [node83, node84, FSUtil.node, node76, AppProcess.node]
 });
 
-export { ID, Vcs, Current, Info, UpdateInput, NotFoundError, root, Service, node, exports_project };
+export { ID12, Vcs2, Current2, Info26, UpdateInput3, NotFoundError9, root2, Service71, node75, exports_project };

package/dist/chunks/{instance-ezs3tagn.js → kv-x0ckcb58.js}

@@ -1,6 +1,6 @@
 // src/github-copilot/chat/openai-compatible-prepare-tools.ts
 import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
-function prepareTools({
+function prepareTools2({
   tools,
   toolChoice
 }) {
@@ -51,4 +51,4 @@ function prepareTools({
   }
 }
 
-export { prepareTools };
+export { prepareTools2 };