@opencode-ai/core 0.0.0-next-17428 → 0.0.0-next-17444

package/dist/chunks/{wellknown-jhdzjt2r.js → catalog-kztt8qk9.js}

@@ -1,142 +1,142 @@
-import {
-  exports_copy
-} from "./wellknown-g70fvz2n.js";
 import {
   exports_llm
-} from "./wellknown-wt1vmgpp.js";
+} from "./catalog-hj2tb0pc.js";
 import {
   exports_compaction
-} from "./wellknown-4e4pa5kh.js";
-import {
-  exports_title
-} from "./wellknown-8mwggd1z.js";
+} from "./catalog-zh02cvbf.js";
 import {
   exports_generate_node
-} from "./wellknown-akkksjcs.js";
+} from "./catalog-br9bzwn4.js";
 import {
-  exports_instructions as exports_instructions2
-} from "./wellknown-r7cbhthp.js";
+  exports_title
+} from "./catalog-rh7vxbnf.js";
 import {
   exports_instructions as exports_instructions3
-} from "./wellknown-2jtfzwaa.js";
-import {
-  exports_builtins
-} from "./wellknown-71dk037r.js";
+} from "./catalog-y23acc5q.js";
 import {
   exports_instruction_entry
-} from "./wellknown-q16dfqy6.js";
+} from "./catalog-ev1a59wp.js";
 import {
   exports_mcp as exports_mcp2
-} from "./wellknown-ww5x4bmh.js";
+} from "./catalog-9vj26axg.js";
 import {
   exports_supervisor
-} from "./wellknown-s99aagmk.js";
+} from "./catalog-af5dwr8b.js";
 import {
   exports_instructions
-} from "./wellknown-n7fgxfv6.js";
+} from "./catalog-bwkeshyk.js";
 import {
   exports_read_filesystem
-} from "./wellknown-scpmsk9g.js";
+} from "./catalog-3z9y63bn.js";
 import {
   exports_location_watcher
-} from "./wellknown-45af57yr.js";
+} from "./catalog-5wyssej8.js";
 import {
-  exports_formatter
-} from "./wellknown-6f3c0gvx.js";
+  exports_instructions as exports_instructions2
+} from "./catalog-9a767y7b.js";
 import {
-  exports_generate
-} from "./wellknown-2m1cqesy.js";
+  exports_builtins
+} from "./catalog-6e2p349p.js";
 import {
-  exports_instruction_discovery
-} from "./wellknown-p3e59vfk.js";
+  exports_tool_output
+} from "./catalog-agh3hf73.js";
 import {
   exports_location_mutation
-} from "./wellknown-1ne78j78.js";
+} from "./catalog-pcj6jaw5.js";
+import {
+  exports_plugin
+} from "./catalog-qk1q6gpy.js";
+import {
+  exports_websearch
+} from "./catalog-3qccyarx.js";
+import {
+  exports_tool
+} from "./catalog-6t8191pv.js";
 import {
   exports_file_mutation
-} from "./wellknown-25552m23.js";
+} from "./catalog-n6djjn6b.js";
 import {
-  exports_tool_output
-} from "./wellknown-bfh4wnyx.js";
+  exports_worktree
+} from "./catalog-mhmd8pwt.js";
 import {
-  exports_vcs
-} from "./wellknown-9e8aeag2.js";
+  exports_reference
+} from "./catalog-h65hz4jm.js";
+import {
+  exports_formatter
+} from "./catalog-w7cys7gf.js";
 import {
   exports_pty
-} from "./wellknown-xdyax1v4.js";
+} from "./catalog-j3mnn31z.js";
 import {
-  exports_plugin
-} from "./wellknown-0rnmdg6p.js";
+  exports_vcs
+} from "./catalog-yc1386c7.js";
 import {
-  exports_tool
-} from "./wellknown-68kcdzx8.js";
+  exports_instruction_discovery
+} from "./catalog-hbb01ekb.js";
 import {
-  exports_websearch
-} from "./wellknown-ptr7bqe1.js";
+  exports_generate
+} from "./catalog-5fmasw9x.js";
 import {
   exports_model
-} from "./wellknown-6y9cy4ak.js";
+} from "./catalog-keysyqq7.js";
 import {
-  exports_command
-} from "./wellknown-30nzded7.js";
+  exports_question
+} from "./catalog-vcem8grb.js";
 import {
-  exports_mcp
-} from "./wellknown-w6055s4r.js";
+  exports_snapshot
+} from "./catalog-v75zhgpj.js";
 import {
-  exports_model_resolver
-} from "./wellknown-g2ddtk1s.js";
+  exports_location_service_map
+} from "./catalog-zdkg1k91.js";
 import {
-  exports_image
-} from "./wellknown-6t3tjp1t.js";
+  exports_shell
+} from "./catalog-fxmgvssp.js";
 import {
   exports_skill
-} from "./wellknown-9qang0mx.js";
-import {
-  exports_permission
-} from "./wellknown-bt7xmf0d.js";
+} from "./catalog-01ebynez.js";
 import {
-  exports_location_service_map
-} from "./wellknown-zdkg1k91.js";
+  exports_image
+} from "./catalog-jzepdhcr.js";
 import {
   exports_filesystem,
   exports_search
-} from "./wellknown-20mhz48y.js";
+} from "./catalog-xk5wr58k.js";
 import {
-  exports_snapshot
-} from "./wellknown-wr3k63ve.js";
+  exports_model_resolver
+} from "./catalog-sv2h4wvj.js";
+import {
+  exports_aisdk
+} from "./catalog-d076mabj.js";
 import {
   exports_catalog
-} from "./wellknown-qb3ddt1e.js";
+} from "./catalog-0rbs31my.js";
 import {
-  exports_integration
-} from "./wellknown-njsy6pae.js";
+  exports_command
+} from "./catalog-e5j5xapc.js";
 import {
-  exports_form
-} from "./wellknown-1swmyd9s.js";
+  exports_mcp
+} from "./catalog-wady9nrb.js";
 import {
-  exports_aisdk
-} from "./wellknown-d076mabj.js";
+  exports_environment1 as exports_environment
+} from "./catalog-jyscbp9m.js";
 import {
-  exports_question
-} from "./wellknown-fzc1wfxm.js";
+  exports_config
+} from "./catalog-s8qevcta.js";
 import {
-  exports_agent
-} from "./wellknown-y2kycdcv.js";
+  exports_integration
+} from "./catalog-gr504th9.js";
 import {
-  exports_shell
-} from "./wellknown-4hxh2c3r.js";
+  exports_form
+} from "./catalog-6m63e6rk.js";
 import {
-  exports_environment1 as exports_environment
-} from "./wellknown-jq70kwhh.js";
+  exports_permission
+} from "./catalog-xc67d6rc.js";
 import {
-  exports_config
-} from "./wellknown-z5wnp00d.js";
+  exports_agent
+} from "./catalog-j9v2c738.js";
 import {
   exports_location
-} from "./wellknown-wkc2sg7c.js";
-import {
-  exports_reference
-} from "./wellknown-at7d33az.js";
+} from "./catalog-m712gcsw.js";
 
 // src/location-services.ts
 import { Effect, Layer, LayerMap } from "effect";
@@ -156,8 +156,7 @@ var locationServiceNodes = [
   exports_aisdk.node,
   exports_plugin.node,
   exports_supervisor.node,
-  exports_copy.node,
-  exports_copy.refreshNode,
+  exports_worktree.refreshNode,
   exports_search.node,
   exports_filesystem.node,
   exports_pty.node,

package/dist/chunks/{wellknown-m01ryvbe.js → catalog-m01ryvbe.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./wellknown-rvfvac9x.js";
+} from "./catalog-rvfvac9x.js";
 
 // src/effect/app-node-platform.ts
 var exports_app_node_platform = {};

package/dist/chunks/{wellknown-wkc2sg7c.js → catalog-m712gcsw.js}

@@ -1,9 +1,9 @@
 import {
   exports_project
-} from "./wellknown-ppcrn5r0.js";
+} from "./catalog-sqrt138j.js";
 import {
   __export
-} from "./wellknown-rvfvac9x.js";
+} from "./catalog-rvfvac9x.js";
 
 // src/location.ts
 var exports_location = {};

package/dist/chunks/{wellknown-9zy456m4.js → catalog-me6kx06r.js}

@@ -1,9 +1,9 @@
 import {
   exports_integration
-} from "./wellknown-njsy6pae.js";
+} from "./catalog-gr504th9.js";
 import {
   exports_provider
-} from "./wellknown-d6vvk673.js";
+} from "./catalog-d6vvk673.js";
 
 // src/plugin/provider/llmgateway.ts
 import { Effect } from "effect";

package/dist/chunks/{wellknown-mf0hyk7z.js → catalog-mf0hyk7z.js}

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

package/dist/chunks/catalog-mh28new4.js

@@ -0,0 +1,17 @@
+import {
+  ProjectTable
+} from "./catalog-88jbfw8z.js";
+import {
+  absoluteColumn
+} from "./catalog-zbqqnp0n.js";
+
+// src/worktree/sql.ts
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var WorktreeTable = sqliteTable("worktree", {
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  directory: absoluteColumn().notNull(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+
+export { WorktreeTable };

package/dist/chunks/catalog-mhmd8pwt.js

@@ -0,0 +1,252 @@
+import {
+  exports_git as exports_git2
+} from "./catalog-0brv01ad.js";
+import {
+  DirectoryUnavailableError,
+  canonical
+} from "./catalog-8vhzxx5g.js";
+import {
+  Slug
+} from "./catalog-df3v2q6j.js";
+import {
+  exports_location
+} from "./catalog-m712gcsw.js";
+import {
+  exports_schema
+} from "./catalog-8v47shgf.js";
+import {
+  WorktreeTable
+} from "./catalog-mh28new4.js";
+import {
+  ProjectTable
+} from "./catalog-88jbfw8z.js";
+import {
+  exports_git
+} from "./catalog-kcwh27nh.js";
+import {
+  AbsolutePath
+} from "./catalog-j07kk359.js";
+import {
+  exports_bus
+} from "./catalog-dktf68zy.js";
+import {
+  exports_database
+} from "./catalog-sxkhxd81.js";
+import {
+  __export
+} from "./catalog-rvfvac9x.js";
+
+// src/worktree.ts
+var exports_worktree = {};
+__export(exports_worktree, {
+  refreshNode: () => refreshNode,
+  refreshAfterBoot: () => refreshAfterBoot,
+  node: () => node,
+  Worktree: () => exports_worktree,
+  StrategyUnavailableError: () => StrategyUnavailableError,
+  StrategyID: () => StrategyID,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError,
+  Service: () => Service,
+  RemoveInput: () => RemoveInput,
+  RefreshResult: () => RefreshResult,
+  RefreshInput: () => RefreshInput,
+  ListInput: () => ListInput,
+  ListEntry: () => ListEntry,
+  List: () => List,
+  InvalidDirectoryError: () => InvalidDirectoryError,
+  Info: () => Info,
+  Event: () => Event,
+  DuplicateStrategyError: () => DuplicateStrategyError,
+  DirectoryUnavailableError: () => DirectoryUnavailableError,
+  DestinationExistsError: () => DestinationExistsError,
+  CreateInput: () => CreateInput
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { and, asc, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Worktree } from "@opencode-ai/schema/worktree";
+var StrategyID = Worktree.StrategyID;
+var CreateInput = Worktree.CreateInput;
+var RemoveInput = Worktree.RemoveInput;
+var RefreshInput = Schema.Struct({
+  projectID: exports_schema.ID
+}).annotate({ identifier: "Worktree.RefreshInput" });
+var RefreshResult = Schema.Struct({
+  updated: Schema.Array(AbsolutePath),
+  removed: Schema.Array(AbsolutePath)
+}).annotate({ identifier: "Worktree.RefreshResult" });
+var Info = Worktree.Info;
+var ListInput = Worktree.ListInput;
+var List = Worktree.List;
+var ListEntry = Schema.Struct({
+  directory: AbsolutePath,
+  type: Schema.Literals(["root", "worktree"])
+}).annotate({ identifier: "Worktree.ListEntry" });
+
+class SourceDirectoryNotFoundError extends Schema.TaggedErrorClass()("Worktree.SourceDirectoryNotFoundError", { projectID: exports_schema.ID, directory: Schema.optional(AbsolutePath) }) {
+}
+
+class DestinationExistsError extends Schema.TaggedErrorClass()("Worktree.DestinationExistsError", { directory: AbsolutePath }) {
+}
+
+class InvalidDirectoryError extends Schema.TaggedErrorClass()("Worktree.InvalidDirectoryError", { directory: AbsolutePath }) {
+}
+
+class StrategyUnavailableError extends Schema.TaggedErrorClass()("Worktree.StrategyUnavailableError", { strategy: StrategyID }) {
+}
+
+class DuplicateStrategyError extends Schema.TaggedErrorClass()("Worktree.DuplicateStrategyError", { strategy: StrategyID }) {
+}
+var Event = Worktree.Event;
+
+class Service extends Context.Service()("@opencode/v2/Worktree") {
+}
+var refreshAfterBoot = Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  const worktrees = yield* Service;
+  yield* Effect.gen(function* () {
+    yield* Effect.logInfo("worktree refresh started", { projectID: location.project.id });
+    const result = yield* worktrees.refresh({ projectID: location.project.id });
+    yield* Effect.logInfo("worktree refresh done", {
+      projectID: location.project.id,
+      updated: result.updated,
+      removed: result.removed
+    });
+  }).pipe(Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped, Effect.asVoid);
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const db = (yield* exports_database.Service).db;
+  const bus = yield* exports_bus.Service;
+  const changed = Effect.fnUntraced(function* (projectID, update) {
+    if (update)
+      yield* bus.publish(Event.Updated, { projectID });
+  });
+  const ops = {
+    list: Effect.fn("Worktree.list")(function* (projectID) {
+      const rows = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(eq(WorktreeTable.project_id, projectID)).orderBy(desc(WorktreeTable.time_created), asc(WorktreeTable.directory)).all().pipe(Effect.orDie);
+      return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
+    }),
+    find: Effect.fnUntraced(function* (projectID, directory) {
+      const row = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).get().pipe(Effect.orDie);
+      return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
+    }),
+    primary: Effect.fnUntraced(function* (projectID) {
+      return yield* db.select({ directory: ProjectTable.worktree }).from(ProjectTable).where(eq(ProjectTable.id, projectID)).get().pipe(Effect.orDie);
+    }),
+    create: Effect.fnUntraced(function* (input, tx) {
+      return (yield* (tx ?? db).insert(WorktreeTable).values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy }).onConflictDoUpdate({
+        target: [WorktreeTable.project_id, WorktreeTable.directory],
+        set: { strategy: input.strategy ?? null },
+        setWhere: input.strategy ? or(isNull(WorktreeTable.strategy), ne(WorktreeTable.strategy, input.strategy)) : isNotNull(WorktreeTable.strategy)
+      }).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie)) !== undefined;
+    }),
+    remove: Effect.fnUntraced(function* (projectID, directory, tx) {
+      return (yield* (tx ?? db).delete(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie)) !== undefined;
+    })
+  };
+  const registry = new Map;
+  const register = Effect.fn("Worktree.register")(function* (strategy) {
+    if (registry.has(strategy.id))
+      return yield* new DuplicateStrategyError({ strategy: strategy.id });
+    registry.set(strategy.id, strategy);
+  });
+  const gitStrategy = yield* exports_git2.make;
+  yield* register(gitStrategy).pipe(Effect.orDie);
+  const strategies = () => Array.from(registry.values());
+  const source = Effect.fnUntraced(function* (input, projectID) {
+    const sourceDirectory = input ?? (yield* ops.primary(projectID))?.directory;
+    if (!sourceDirectory)
+      return yield* new SourceDirectoryNotFoundError({ projectID });
+    const resolved = yield* canonical(fs, sourceDirectory);
+    if ((yield* ops.find(projectID, resolved)) === undefined)
+      return yield* new SourceDirectoryNotFoundError({ projectID, directory: resolved });
+    return resolved;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id) {
+    const found = registry.get(id);
+    if (!found)
+      return yield* new StrategyUnavailableError({ strategy: id });
+    return found;
+  });
+  const create = Effect.fn("Worktree.create")(function* (input) {
+    const selected = yield* getStrategy(input.strategy);
+    const sourceDirectory = yield* source(input.from, input.projectID);
+    yield* fs.makeDirectory(input.directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug.create();
+    let suffix = 1;
+    let worktreeDirectory = AbsolutePath.make(path.join(input.directory, name));
+    while (yield* fs.existsSafe(worktreeDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath.make(path.join(input.directory, `${name}-${suffix}`));
+    }
+    const result = yield* selected.create({
+      directory: worktreeDirectory,
+      sourceDirectory
+    });
+    yield* changed(input.projectID, yield* ops.create({
+      projectID: input.projectID,
+      directory: result.directory,
+      strategy: input.strategy
+    }));
+    return result;
+  });
+  const remove = Effect.fn("Worktree.remove")(function* (input) {
+    const worktreeDirectory = yield* canonical(fs, input.directory);
+    const stored = yield* ops.find(input.projectID, worktreeDirectory);
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError({ directory: worktreeDirectory });
+    yield* (yield* getStrategy(StrategyID.make(stored.strategy))).remove({
+      directory: worktreeDirectory,
+      force: input.force
+    });
+    yield* changed(input.projectID, yield* ops.remove(input.projectID, worktreeDirectory));
+  });
+  const refresh = Effect.fn("Worktree.refresh")(function* (input) {
+    const stored = yield* ops.list(input.projectID);
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const sourceDirectories = checked.filter((item) => item.strategy === undefined && item.exists).map((item) => item.directory);
+    const discovered = yield* Effect.forEach(sourceDirectories, (sourceDirectory) => Effect.forEach(strategies(), (strategy) => strategy.list(sourceDirectory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])), Effect.map((items) => items.map((item) => ({
+      directory: item.directory,
+      strategy: item.type === "worktree" ? strategy.id : undefined
+    }))))), { concurrency: "unbounded" }).pipe(Effect.map((sets) => new Map(sets.flat(2).map((item) => [item.directory, item])).values().toArray()));
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const result = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.forEach(discovered, (item) => ops.create({
+        projectID: input.projectID,
+        directory: item.directory,
+        strategy: item.strategy
+      }, tx)),
+      removed: Effect.forEach(removed, (directory) => ops.remove(input.projectID, directory, tx))
+    })).pipe(Effect.orDie);
+    const changes = {
+      updated: discovered.filter((_, index) => result.updated[index]).map((item) => item.directory),
+      removed: removed.filter((_, index) => result.removed[index])
+    };
+    yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service.of({
+    register,
+    list: ops.list,
+    create,
+    remove,
+    refresh
+  });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, exports_git.node, exports_bus.node, exports_database.node]
+});
+var refreshNode = makeLocationNode({
+  name: "worktree-refresh",
+  layer: Layer.effectDiscard(refreshAfterBoot),
+  deps: [node, exports_location.node]
+});
+
+export { StrategyID, CreateInput, RemoveInput, RefreshInput, RefreshResult, Info, ListInput, List, ListEntry, SourceDirectoryNotFoundError, DestinationExistsError, InvalidDirectoryError, StrategyUnavailableError, DuplicateStrategyError, Event, Service, refreshAfterBoot, node, refreshNode, exports_worktree };

package/dist/chunks/{wellknown-mwceq5am.js → catalog-mwceq5am.js}

@@ -1,7 +1,7 @@
 import {
   getViewSelectedFieldsRuntime,
   orderSelectedFields
-} from "./wellknown-ma07p6tt.js";
+} from "./catalog-ma07p6tt.js";
 
 // src/database/drizzle/sqlite-core/effect/select.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";

package/dist/chunks/{wellknown-25552m23.js → catalog-n6djjn6b.js}

@@ -1,12 +1,12 @@
 import {
   exports_environment1 as exports_environment
-} from "./wellknown-jq70kwhh.js";
+} from "./catalog-jyscbp9m.js";
 import {
   exports_keyed_mutex
-} from "./wellknown-0kvmztkf.js";
+} from "./catalog-0kvmztkf.js";
 import {
   __export
-} from "./wellknown-rvfvac9x.js";
+} from "./catalog-rvfvac9x.js";
 
 // src/file-mutation.ts
 var exports_file_mutation = {};

package/dist/chunks/{wellknown-nesb2rcz.js → catalog-nesb2rcz.js}

@@ -1,9 +1,9 @@
 import {
   ProjectTable
-} from "./wellknown-88jbfw8z.js";
+} from "./catalog-88jbfw8z.js";
 import {
   Timestamps
-} from "./wellknown-sem2g21k.js";
+} from "./catalog-sem2g21k.js";
 
 // src/permission/sql.ts
 import { sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";

package/dist/chunks/{wellknown-nr76rjj3.js → catalog-nr76rjj3.js}

@@ -1,9 +1,9 @@
 import {
   NamedError
-} from "./wellknown-hzeg9cfr.js";
+} from "./catalog-hzeg9cfr.js";
 import {
   __export
-} from "./wellknown-rvfvac9x.js";
+} from "./catalog-rvfvac9x.js";
 
 // src/v1/config/error.ts
 var exports_error = {};

package/dist/chunks/{wellknown-nzrjycs5.js → catalog-nzrjycs5.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./wellknown-rvfvac9x.js";
+} from "./catalog-rvfvac9x.js";
 
 // src/v1/config/skills.ts
 var exports_skills = {};

package/dist/chunks/{wellknown-s8da7qpe.js → catalog-p14gxk1c.js}

@@ -1,42 +1,42 @@
 import {
   MAX_STEPS_PROMPT
-} from "./wellknown-qaarhjrp.js";
-import {
-  exports_model_http
-} from "./wellknown-93qdgxxd.js";
+} from "./catalog-qaarhjrp.js";
 import {
   exports_prompt_cache_diagnostics
-} from "./wellknown-wd268jeg.js";
+} from "./catalog-wd268jeg.js";
 import {
   base_default
-} from "./wellknown-8m0qaa0v.js";
+} from "./catalog-8m0qaa0v.js";
 import {
   toLLMMessages
-} from "./wellknown-6jtjggv5.js";
+} from "./catalog-6jtjggv5.js";
 import {
   exports_prompt_cache_key
-} from "./wellknown-52jzav25.js";
+} from "./catalog-52jzav25.js";
+import {
+  exports_model_http
+} from "./catalog-93qdgxxd.js";
 import {
   exports_model_headers
-} from "./wellknown-1xksxgzs.js";
+} from "./catalog-1xksxgzs.js";
 import {
   exports_question
-} from "./wellknown-0cjwzmdv.js";
+} from "./catalog-9s9me6y6.js";
 import {
   exports_tool
-} from "./wellknown-68kcdzx8.js";
-import {
-  exports_permission
-} from "./wellknown-bt7xmf0d.js";
+} from "./catalog-6t8191pv.js";
 import {
   exports_hooks
-} from "./wellknown-t2j2ttmx.js";
+} from "./catalog-t2j2ttmx.js";
 import {
   exports_app
-} from "./wellknown-50jxp3hw.js";
+} from "./catalog-50jxp3hw.js";
+import {
+  exports_permission
+} from "./catalog-xc67d6rc.js";
 import {
   __export
-} from "./wellknown-rvfvac9x.js";
+} from "./catalog-rvfvac9x.js";
 
 // src/session/model-request.ts
 var exports_model_request = {};