@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/{integration-a7rjzrqs.js → command-drn755cb.js}

@@ -1,42 +1,50 @@
 import {
-  exports_schema
-} from "./integration-m7jtgrng.js";
+  AbsolutePath2
+} from "./command-p8qxwesx.js";
 import {
-  WorktreeTable
-} from "./integration-gb1z7yet.js";
+  Service80,
+  node84
+} from "./command-mh85gtv1.js";
 import {
-  ProjectTable,
-  upsertProject
-} from "./integration-c8ya26sa.js";
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
 import {
-  exports_git
-} from "./integration-qz5gwjr7.js";
+  Service70,
+  node73
+} from "./command-mhsg1yty.js";
 import {
-  AbsolutePath
-} from "./integration-j07kk359.js";
+  ID13,
+  Current3,
+  Info27,
+  UpdateInput4,
+  Event14,
+  Vcs3
+} from "./command-dqwszdkc.js";
 import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
+  ProjectTable2,
+  upsertProject2
+} from "./command-9qm9egsn.js";
 import {
-  exports_database
-} from "./integration-3dyzk5zr.js";
+  WorktreeTable2
+} from "./command-ajtjthsy.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-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: () => Service69,
+  UpdateInput: () => UpdateInput3,
+  Vcs: () => Vcs2,
+  node: () => node72,
+  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 Service69 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(Service69, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const git = yield* exports_git.Service;
+  const git = yield* Service70;
   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(Event14.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(Event14.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 Service69.of({ list, update, resolve });
 }));
-var node = makeGlobalNode({
-  service: Service,
+var node72 = makeGlobalNode({
+  service: Service69,
   layer,
-  deps: [exports_bus.node, exports_database.node, FSUtil.node, exports_git.node, AppProcess.node]
+  deps: [node83, node84, FSUtil.node, node73, AppProcess.node]
 });
 
-export { ID, Vcs, Current, Info, UpdateInput, NotFoundError, root, Service, node, exports_project };
+export { ID12, Vcs2, Current2, Info26, UpdateInput3, NotFoundError9, root2, Service69, node72, exports_project };

package/dist/chunks/{integration-7gcyy9x5.js → command-dv0xdbpz.js}

@@ -1,50 +1,50 @@
 import {
-  exports_file_retention
-} from "./integration-p1m5qwvv.js";
+  cleanup3
+} from "./command-gd4qta3r.js";
 import {
-  exports_id
-} from "./integration-x4az4y7r.js";
+  ascending2
+} from "./command-k4bwy1x5.js";
 import {
-  exports_state
-} from "./integration-j6s3yjyb.js";
+  create3
+} from "./command-kg06axw8.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/tool-output.ts
-var exports_tool_output = {};
-__export(exports_tool_output, {
-  DIRECTORY: () => DIRECTORY,
-  MAX_BYTES: () => MAX_BYTES,
-  MAX_LINES: () => MAX_LINES,
-  RETENTION: () => RETENTION,
-  Service: () => Service,
-  ToolOutput: () => exports_tool_output,
-  node: () => node
+var exports_tool_output2 = {};
+__export(exports_tool_output2, {
+  DIRECTORY: () => DIRECTORY3,
+  MAX_BYTES: () => MAX_BYTES2,
+  MAX_LINES: () => MAX_LINES2,
+  RETENTION: () => RETENTION3,
+  Service: () => Service40,
+  ToolOutput: () => exports_tool_output2,
+  node: () => node42
 });
 import path from "path";
 import { Context, Duration, Effect, Layer, Schedule } from "effect";
 import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
-var MAX_LINES = 2000;
-var MAX_BYTES = 50 * 1024;
-var RETENTION = Duration.days(7);
-var DIRECTORY = "tool-output";
+var MAX_LINES2 = 2000;
+var MAX_BYTES2 = 50 * 1024;
+var RETENTION3 = Duration.days(7);
+var DIRECTORY3 = "tool-output";
 
-class Service extends Context.Service()("@opencode/ToolOutput") {
+class Service40 extends Context.Service()("@opencode/ToolOutput") {
 }
 var cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs, directory) {
-  const entries = yield* fs.readDirectory(directory).pipe(Effect.map((entries2) => entries2.filter((entry) => /^tool_[0-9a-f]{12}/.test(entry))), Effect.orElseSucceed(() => []));
-  yield* exports_file_retention.cleanup(fs, entries.map((entry) => path.join(directory, entry)), RETENTION);
+  const entries = yield* fs.readDirectory(directory).pipe(Effect.map((entries) => entries.filter((entry) => /^tool_[0-9a-f]{12}/.test(entry))), Effect.orElseSucceed(() => []));
+  yield* cleanup3(fs, entries.map((entry) => path.join(directory, entry)), RETENTION3);
 });
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service40, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const global = yield* Global.Service;
-  const directory = path.join(global.data, DIRECTORY);
-  const state = exports_state.create({
+  const directory = path.join(global.data, DIRECTORY3);
+  const state = create3({
     name: "tool-output",
-    initial: () => ({ maxLines: MAX_LINES, maxBytes: MAX_BYTES }),
+    initial: () => ({ maxLines: MAX_LINES2, maxBytes: MAX_BYTES2 }),
     editor: (editor) => ({
       configure: (limits) => {
         if (limits.maxLines !== undefined)
@@ -85,7 +85,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       hitBytes = true;
     const removed = hitBytes ? totalBytes - bytes : lines.length - kept.length;
     const unit = hitBytes ? removed === 1 ? "byte" : "bytes" : removed === 1 ? "line" : "lines";
-    const file = path.join(directory, exports_id.ascending("tool"));
+    const file = path.join(directory, ascending2("tool"));
     yield* fs.ensureDir(directory).pipe(Effect.orDie);
     yield* fs.writeFileString(file, text).pipe(Effect.orDie);
     const marker = `... ${removed} ${unit} truncated; full content saved to ${file} ...`;
@@ -122,7 +122,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       metadata: { ...result.metadata, truncated: true, outputPath: file }
     };
   });
-  return Service.of({
+  return Service40.of({
     transform: state.transform,
     reload: state.reload,
     truncate,
@@ -132,17 +132,17 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
 var cleanupLayer = Layer.effectDiscard(Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const global = yield* Global.Service;
-  yield* cleanup(fs, path.join(global.data, DIRECTORY)).pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped);
+  yield* cleanup(fs, path.join(global.data, DIRECTORY3)).pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped);
 }));
 var cleanupNode = makeGlobalNode({
   name: "tool-output-cleanup",
   layer: cleanupLayer,
   deps: [FSUtil.node, Global.node]
 });
-var node = makeLocationNode({
-  service: Service,
+var node42 = makeLocationNode({
+  service: Service40,
   layer,
   deps: [FSUtil.node, Global.node, cleanupNode]
 });
 
-export { MAX_LINES, MAX_BYTES, RETENTION, DIRECTORY, Service, node, exports_tool_output };
+export { MAX_LINES2, MAX_BYTES2, RETENTION3, DIRECTORY3, Service40, node42, exports_tool_output2 };

package/dist/chunks/{integration-zxfj0wec.js → command-dxvz0qx6.js}

@@ -1,37 +1,41 @@
 import {
-  exports_model_resolver
-} from "./integration-380kpb9q.js";
+  VariantUnavailableError3,
+  UnsupportedPackageError3,
+  UnresolvedProviderVariablesError3,
+  Service52,
+  node54
+} from "./command-y3kam97a.js";
 import {
-  SessionSchema
-} from "./integration-bjwj8hwv.js";
+  SessionSchema2
+} from "./command-5rw6je3s.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/session/runner/model.ts
 var exports_model = {};
 __export(exports_model, {
-  ModelNotSelectedError: () => ModelNotSelectedError,
-  ModelUnavailableError: () => ModelUnavailableError,
-  Service: () => Service,
+  ModelNotSelectedError: () => ModelNotSelectedError2,
+  ModelUnavailableError: () => ModelUnavailableError2,
+  Service: () => Service30,
   SessionRunnerModel: () => exports_model,
-  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError,
-  UnsupportedPackageError: () => UnsupportedPackageError,
-  VariantUnavailableError: () => VariantUnavailableError,
-  node: () => node,
-  resolved: () => resolved
+  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError2,
+  UnsupportedPackageError: () => UnsupportedPackageError2,
+  VariantUnavailableError: () => VariantUnavailableError2,
+  node: () => node33,
+  resolved: () => resolved2
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Model } from "@opencode-ai/schema/model";
 import { Provider } from "@opencode-ai/schema/provider";
 import { Context, Effect, Layer, Schema } from "effect";
-class ModelNotSelectedError extends Schema.TaggedError()("SessionRunnerModel.ModelNotSelectedError", { sessionID: SessionSchema.ID }) {
+class ModelNotSelectedError2 extends Schema.TaggedError()("SessionRunnerModel.ModelNotSelectedError", { sessionID: SessionSchema2.ID }) {
   get message() {
     return `No model is available for session ${this.sessionID}`;
   }
 }
 
-class ModelUnavailableError extends Schema.TaggedError()("SessionRunnerModel.ModelUnavailableError", { providerID: Provider.ID, modelID: Model.ID }) {
+class ModelUnavailableError2 extends Schema.TaggedError()("SessionRunnerModel.ModelUnavailableError", { providerID: Provider.ID, modelID: Model.ID }) {
   get message() {
     if (this.providerID === "azure-cognitive-services")
       return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use azure/${this.modelID} instead.`;
@@ -40,13 +44,13 @@ class ModelUnavailableError extends Schema.TaggedError()("SessionRunnerModel.Mod
     return `Model unavailable: ${this.providerID}/${this.modelID}`;
   }
 }
-var VariantUnavailableError = exports_model_resolver.VariantUnavailableError;
-var UnsupportedPackageError = exports_model_resolver.UnsupportedPackageError;
-var UnresolvedProviderVariablesError = exports_model_resolver.UnresolvedProviderVariablesError;
+var VariantUnavailableError2 = VariantUnavailableError3;
+var UnsupportedPackageError2 = UnsupportedPackageError3;
+var UnresolvedProviderVariablesError2 = UnresolvedProviderVariablesError3;
 
-class Service extends Context.Service()("@opencode/SessionRunnerModel") {
+class Service30 extends Context.Service()("@opencode/SessionRunnerModel") {
 }
-var resolved = (model, options) => ({
+var resolved2 = (model, options) => ({
   model,
   ref: Model.Ref.make({
     id: Model.ID.make(model.id),
@@ -57,19 +61,19 @@ var resolved = (model, options) => ({
   cost: options.cost,
   limit: options.limit
 });
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const resolver = yield* exports_model_resolver.Service;
-  return Service.of({
+var layer = Layer.effect(Service30, Effect.gen(function* () {
+  const resolver = yield* Service52;
+  return Service30.of({
     resolve: Effect.fn("SessionRunnerModel.resolve")(function* (session, available) {
       if (!session.model) {
-        const resolved2 = yield* resolver.resolve();
-        if (resolved2)
-          return resolved2;
-        return yield* new ModelNotSelectedError({ sessionID: session.id });
+        const resolved = yield* resolver.resolve();
+        if (resolved)
+          return resolved;
+        return yield* new ModelNotSelectedError2({ sessionID: session.id });
       }
       const selected = (yield* available()).find((model) => model.providerID === session.model?.providerID && model.id === session.model.id);
       if (!selected)
-        return yield* new ModelUnavailableError({
+        return yield* new ModelUnavailableError2({
           providerID: session.model.providerID,
           modelID: session.model.id
         });
@@ -77,6 +81,6 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     })
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_model_resolver.node] });
+var node33 = makeLocationNode({ service: Service30, layer, deps: [node54] });
 
-export { ModelNotSelectedError, ModelUnavailableError, VariantUnavailableError, UnsupportedPackageError, UnresolvedProviderVariablesError, Service, resolved, node, exports_model };
+export { ModelNotSelectedError2, ModelUnavailableError2, VariantUnavailableError2, UnsupportedPackageError2, UnresolvedProviderVariablesError2, Service30, resolved2, node33, exports_model };

package/dist/chunks/{integration-nec1705c.js → command-e0nkwt9z.js}

@@ -1,23 +1,22 @@
 import {
-  exports_wildcard
-} from "./integration-edxnhgvj.js";
+  ps2
+} from "./command-x0pd42vp.js";
 import {
-  lazy
-} from "./integration-8w9tzfz1.js";
+  lazy2
+} from "./command-88xbtdfr.js";
 import {
-  exports_select
-} from "./integration-xvqr7khp.js";
+  match2
+} from "./command-y1fvbwt7.js";
 import {
-  __export,
-  __require
-} from "./integration-vpjkya7h.js";
+  __export
+} from "./command-9rqn6x4v.js";
 
 // src/shell/parse.ts
 var exports_parse = {};
 __export(exports_parse, {
   ShellParse: () => exports_parse,
-  scan: () => scan,
-  scanPortable: () => scanPortable
+  scan: () => scan2,
+  scanPortable: () => scanPortable2
 });
 import { Effect } from "effect";
 import { fileURLToPath } from "url";
@@ -166,27 +165,27 @@ var ARITY = {
   "yarn run": 3
 };
 var PREFIX_LENGTH = Math.max(...Object.values(ARITY));
-var scan = Effect.fnUntraced(function* (command, shell, cwd, options) {
+var scan2 = Effect.fnUntraced(function* (command, shell, cwd, options) {
   if (options?.portable)
-    return yield* scanPortable(command, shell, cwd);
+    return yield* scanPortable2(command, shell, cwd);
   return yield* scanLegacy(command, shell, cwd);
 });
 var scanLegacy = Effect.fnUntraced(function* (command, shell, cwd) {
   const parsers = yield* Effect.promise(load);
-  const powershell = exports_select.ps(shell);
+  const powershell = ps2(shell);
   const tree = (powershell ? parsers.ps : parsers.bash).parse(command);
   if (!tree)
     return yield* Effect.fail(new Error("Failed to parse shell command"));
-  return yield* Effect.acquireUseRelease(Effect.succeed(tree), (tree2) => Effect.sync(() => tree2.rootNode.descendantsOfType("command").reduce((result, node) => {
+  return yield* Effect.acquireUseRelease(Effect.succeed(tree), (tree) => Effect.sync(() => tree.rootNode.descendantsOfType("command").reduce((result, node) => {
     if (!node)
       return result;
-    const command2 = parts(node);
-    const tokens = command2.map((part) => part.text);
+    const command = parts(node);
+    const tokens = command.map((part) => part.text);
     if (tokens.length === 0)
       return result;
     const name = powershell ? tokens[0].toLowerCase() : tokens[0];
     if (CWD.has(name)) {
-      result.directories.push(...directoryArgs(command2, powershell, cwd, shell));
+      result.directories.push(...directoryArgs(command, powershell, cwd, shell));
       return result;
     }
     result.commands.push({
@@ -194,14 +193,14 @@ var scanLegacy = Effect.fnUntraced(function* (command, shell, cwd) {
       save: `${prefix(tokens).join(" ")} *`
     });
     return result;
-  }, { commands: [], directories: [] })), (tree2) => Effect.sync(() => tree2.delete()));
+  }, { commands: [], directories: [] })), (tree) => Effect.sync(() => tree.delete()));
 });
-var scanPortable = Effect.fnUntraced(function* (command, shell, cwd) {
+var scanPortable2 = Effect.fnUntraced(function* (command, shell, cwd) {
   const { ShellScan } = yield* Effect.tryPromise({
     try: () => import("../shell/scan.js"),
     catch: (cause) => new Error(`Portable shell scanner failed to load: ${cause}`, { cause })
   });
-  const powershell = exports_select.ps(shell);
+  const powershell = ps2(shell);
   const result = powershell ? ShellScan.scanPowerShell(command) : ShellScan.scan(command);
   if (result.kind === "opaque")
     return yield* Effect.fail(new Error(`Portable shell scanner cannot analyze command: ${result.reason}`));
@@ -228,7 +227,7 @@ var scanPortable = Effect.fnUntraced(function* (command, shell, cwd) {
     const selected = prefix(words.slice(0, PREFIX_LENGTH));
     const conventional = `${selected.join(" ")} *`;
     const end = item.wordEnds?.[selected.length - 1];
-    const save = !powershell || end === undefined || exports_wildcard.match(item.resource, conventional) ? conventional : (() => {
+    const save = !powershell || end === undefined || match2(item.resource, conventional) ? conventional : (() => {
       const boundary = item.wordEnds?.find((value) => value >= end && (value >= item.resource.length || /\s/.test(item.resource[value]))) ?? end;
       const separator = /^\s+(?:`(?:\r\n|\r|\n)\s*)?/.exec(item.resource.slice(boundary))?.[0];
       return `${item.resource.slice(0, boundary)}${separator ?? " "}*`;
@@ -246,7 +245,7 @@ function parts(node) {
     if (!child)
       return [];
     if (child.type === "command_elements")
-      return Array.from({ length: child.childCount }).flatMap((_2, itemIndex) => {
+      return Array.from({ length: child.childCount }).flatMap((_, itemIndex) => {
         const item = child.child(itemIndex);
         if (!item || item.type === "command_argument_sep" || item.type === "redirection")
           return [];
@@ -264,9 +263,9 @@ function directoryArgs(command, powershell, cwd, shell) {
   let path2 = false;
   for (const part of command.slice(1)) {
     if (path2) {
-      const value2 = directoryArgument(part.text, powershell, cwd, shell);
-      if (value2)
-        directories.push(value2);
+      const value = directoryArgument(part.text, powershell, cwd, shell);
+      if (value)
+        directories.push(value);
       path2 = false;
       continue;
     }
@@ -324,7 +323,7 @@ function resolve(asset) {
     return asset;
   return fileURLToPath(new URL(asset, import.meta.url));
 }
-var load = lazy(initialize);
+var load = lazy2(initialize);
 async function initialize() {
   const { Parser, Language } = await import("web-tree-sitter");
   await Parser.init({ locateFile: () => resolve(shellParserWasm.runtime) });
@@ -339,4 +338,4 @@ async function initialize() {
   return { bash, ps };
 }
 
-export { scan, scanPortable, exports_parse };
+export { scan2, scanPortable2, exports_parse };