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

package/dist/chunks/{schema-e2jftvbf.js → pty-wrtxarjq.js}

@@ -1,34 +1,35 @@
 import {
-  exports_service as exports_service2
-} from "./schema-esv5q40e.js";
+  Service57
+} from "./pty-cznc2qrv.js";
 import {
-  exports_service
-} from "./schema-6bxzghb6.js";
+  Service35
+} from "./pty-k558dr3h.js";
 import {
-  exports_mime
-} from "./schema-kq3q54gz.js";
+  detect2
+} from "./pty-3smtnn6g.js";
 import {
-  exports_skill
-} from "./schema-tbzs2pmr.js";
+  awaitActivation2
+} from "./pty-1x11rq2a.js";
 import {
-  exports_image
-} from "./schema-22x56hdn.js";
+  Service69
+} from "./pty-s0gfpzhy.js";
 import {
-  AttachmentError,
-  SkillNotFoundError
-} from "./schema-2sqw2jjm.js";
+  AttachmentError2,
+  SkillNotFoundError2
+} from "./pty-3wx44s71.js";
 import {
-  exports_hooks
-} from "./schema-xws7arpm.js";
+  prepare3,
+  Service52
+} from "./pty-5b9mh310.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/session/prompt.ts
 var exports_prompt = {};
 __export(exports_prompt, {
   SessionPrompt: () => exports_prompt,
-  prepare: () => prepare
+  prepare: () => prepare2
 });
 import { Base64, FileAttachment, Prompt } from "@opencode-ai/schema/prompt";
 import { SessionInbox } from "@opencode-ai/schema/session-inbox";
@@ -36,12 +37,12 @@ import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Effect } from "effect";
 import path from "path";
 import { fileURLToPath } from "url";
-var prepare = Effect.fn("SessionPrompt.prepare")(function* (request) {
+var prepare2 = Effect.fn("SessionPrompt.prepare")(function* (request) {
   const fs = yield* FSUtil.Service;
-  const instances = yield* exports_service.Service;
+  const instances = yield* Service35;
   return yield* Effect.gen(function* () {
-    yield* exports_service2.awaitActivation;
-    const hooks = yield* exports_hooks.Service;
+    yield* awaitActivation2;
+    const hooks = yield* Service69;
     const event = yield* hooks.trigger("session", "prompt", {
       sessionID: request.session.id,
       messageID: request.messageID,
@@ -60,7 +61,7 @@ var prepare = Effect.fn("SessionPrompt.prepare")(function* (request) {
     const selected = yield* Effect.gen(function* () {
       if (!requested?.length)
         return;
-      const skillService = yield* exports_skill.Service;
+      const skillService = yield* Service52;
       const prepared = new Map;
       return yield* Effect.forEach(requested, (attachment) => Effect.gen(function* () {
         const name = prepared.get(attachment.id);
@@ -68,12 +69,12 @@ var prepare = Effect.fn("SessionPrompt.prepare")(function* (request) {
           return { id: attachment.id, name, mention: attachment.mention };
         const skill = yield* skillService.get(attachment.id);
         if (!skill)
-          return yield* new SkillNotFoundError({ skill: attachment.id });
+          return yield* new SkillNotFoundError2({ skill: attachment.id });
         prepared.set(skill.id, skill.name);
         return {
           id: skill.id,
           name: skill.name,
-          text: (yield* exports_skill.prepare(fs, skill).pipe(Effect.orDie)).output,
+          text: (yield* prepare3(fs, skill).pipe(Effect.orDie)).output,
           mention: attachment.mention
         };
       }));
@@ -103,11 +104,11 @@ var materializeAttachment = Effect.fn("SessionPrompt.materializeAttachment")(fun
     mime: undefined
   } : yield* readFileAttachment(input.uri);
   if (resolved.bytes.byteLength > MAX_ATTACHMENT_BYTES)
-    return yield* new AttachmentError({
+    return yield* new AttachmentError2({
       uri: input.uri,
       message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${input.uri}`
     });
-  const mime = resolved.mime ?? exports_mime.detect(resolved.bytes);
+  const mime = resolved.mime ?? detect2(resolved.bytes);
   const content = mime === "text/plain" && resolved.start !== undefined ? Buffer.from(Buffer.from(resolved.bytes).toString("utf8").split(`
 `).slice(resolved.start - 1, resolved.end).join(`
 `)) : resolved.bytes;
@@ -124,20 +125,20 @@ var materializeAttachment = Effect.fn("SessionPrompt.materializeAttachment")(fun
 var normalizeImageAttachment = Effect.fn("SessionPrompt.normalizeImageAttachment")(function* (input, data, mime) {
   if (!mime.startsWith("image/"))
     return { data: Base64.make(data), mime };
-  const image = yield* exports_image.Service;
+  const image = yield* Service57;
   const label = input.name ?? (input.uri.startsWith("data:") ? "inline attachment" : input.uri);
   const content = { uri: label, content: data, encoding: "base64", mime };
-  const normalized = yield* image.normalize(label, content).pipe(Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(content)), Effect.mapError((error) => new AttachmentError({ uri: label, message: error.message })));
+  const normalized = yield* image.normalize(label, content).pipe(Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(content)), Effect.mapError((error) => new AttachmentError2({ uri: label, message: error.message })));
   return { data: Base64.make(normalized.content), mime: normalized.mime };
 });
 var readFileAttachment = Effect.fn("SessionPrompt.readFileAttachment")(function* (uri) {
   const fs = yield* FSUtil.Service;
   const url = yield* Effect.try({
     try: () => new URL(uri),
-    catch: () => new AttachmentError({ uri, message: `Invalid attachment URI: ${uri}` })
+    catch: () => new AttachmentError2({ uri, message: `Invalid attachment URI: ${uri}` })
   });
   if (url.protocol !== "file:")
-    return yield* new AttachmentError({ uri, message: `Unsupported attachment URI: ${uri}` });
+    return yield* new AttachmentError2({ uri, message: `Unsupported attachment URI: ${uri}` });
   const start = positiveInt(url.searchParams.get("start"));
   const end = positiveInt(url.searchParams.get("end"));
   const target = yield* Effect.try({
@@ -146,11 +147,11 @@ var readFileAttachment = Effect.fn("SessionPrompt.readFileAttachment")(function*
       url.hash = "";
       return fileURLToPath(url);
     },
-    catch: () => new AttachmentError({ uri, message: `Invalid file URI: ${uri}` })
+    catch: () => new AttachmentError2({ uri, message: `Invalid file URI: ${uri}` })
   });
-  const info = yield* fs.stat(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+  const info = yield* fs.stat(target).pipe(Effect.mapError(() => new AttachmentError2({ uri, message: `Unable to read attachment: ${uri}` })));
   if (info.type === "Directory") {
-    const entries = yield* fs.readDirectoryEntries(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+    const entries = yield* fs.readDirectoryEntries(target).pipe(Effect.mapError(() => new AttachmentError2({ uri, message: `Unable to read attachment: ${uri}` })));
     return {
       bytes: Buffer.from(entries.filter((entry) => entry.type === "file" || entry.type === "directory").sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1).map((entry) => entry.name + (entry.type === "directory" ? path.sep : "")).join(`
 `)),
@@ -162,13 +163,13 @@ var readFileAttachment = Effect.fn("SessionPrompt.readFileAttachment")(function*
     };
   }
   if (info.type !== "File")
-    return yield* new AttachmentError({ uri, message: `Attachment is not a file: ${uri}` });
+    return yield* new AttachmentError2({ uri, message: `Attachment is not a file: ${uri}` });
   if (Number(info.size) > MAX_ATTACHMENT_BYTES)
-    return yield* new AttachmentError({
+    return yield* new AttachmentError2({
       uri,
       message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${uri}`
     });
-  const bytes = yield* fs.readFile(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+  const bytes = yield* fs.readFile(target).pipe(Effect.mapError(() => new AttachmentError2({ uri, message: `Unable to read attachment: ${uri}` })));
   return { bytes, source: { type: "uri", uri }, start, end, name: path.basename(target), mime: undefined };
 });
 var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
@@ -187,7 +188,7 @@ function decodeDataURL(uri) {
         throw new Error("Non-canonical base64");
       return bytes;
     },
-    catch: () => new AttachmentError({ uri, message: "Invalid attachment data URL" })
+    catch: () => new AttachmentError2({ uri, message: "Invalid attachment data URL" })
   });
 }
 function positiveInt(value) {
@@ -197,4 +198,4 @@ function positiveInt(value) {
   return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
 
-export { prepare, exports_prompt };
+export { prepare2, exports_prompt };

package/dist/chunks/{schema-g70ev3a2.js → pty-wxcf70d6.js}

@@ -1,20 +1,25 @@
 import {
-  exports_catalog
-} from "./schema-rr7wbarq.js";
+  Key3,
+  removed2,
+  make19,
+  diffByKey2
+} from "./pty-6e958v7x.js";
 import {
-  exports_instructions
-} from "./schema-c54e84vp.js";
+  Summary2,
+  summarize2,
+  namespaceLine2
+} from "./pty-3fc6dm20.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/codemode/instructions.ts
 var exports_instructions2 = {};
 __export(exports_instructions2, {
   CodeModeInstructions: () => exports_instructions2,
-  make: () => make,
-  render: () => render,
-  update: () => update
+  make: () => make15,
+  render: () => render2,
+  update: () => update2
 });
 import { searchSignature, toolExpression } from "@opencode-ai/codemode";
 import { Effect, Schema } from "effect";
@@ -29,54 +34,54 @@ Use \`search\` to discover exact paths and signatures for additional tools:
 - ${searchSignature}` : ""}
 
 ## Available tools`;
-function render(catalog) {
+function render2(catalog) {
   if (catalog.total === 0)
     return "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool.";
   const tools = catalog.namespaces.flatMap((namespace) => {
-    return [exports_catalog.namespaceLine(namespace), ...namespace.entries.map((entry) => entry.line)];
+    return [namespaceLine2(namespace), ...namespace.entries.map((entry) => entry.line)];
   });
   return `${prompt(catalog.shown < catalog.total)}
 
 ${tools.join(`
 `)}`;
 }
-function update(previous, current) {
+function update2(previous, current) {
   const replacement = `The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.
 
-${render(current)}`;
+${render2(current)}`;
   if (current.total === 0)
     return replacement;
   const previousComplete = previous.shown === previous.total;
   const currentComplete = current.shown === current.total;
   if (previousComplete !== currentComplete)
     return replacement;
-  const descriptions = exports_instructions.diffByKey(previous.namespaces.filter((namespace) => namespace.description !== undefined), current.namespaces.filter((namespace) => namespace.description !== undefined), (namespace) => namespace.name, (before, after) => before.description !== after.description);
+  const descriptions = diffByKey2(previous.namespaces.filter((namespace) => namespace.description !== undefined), current.namespaces.filter((namespace) => namespace.description !== undefined), (namespace) => namespace.name, (before, after) => before.description !== after.description);
   if (descriptions.added.length > 0 || descriptions.removed.length > 0 || descriptions.changed.length > 0)
     return replacement;
-  const diff = exports_instructions.diffByKey(previous.namespaces.flatMap((namespace) => namespace.entries), current.namespaces.flatMap((namespace) => namespace.entries), (entry) => entry.path, (before, after) => before.line !== after.line);
+  const diff = diffByKey2(previous.namespaces.flatMap((namespace) => namespace.entries), current.namespaces.flatMap((namespace) => namespace.entries), (entry) => entry.path, (before, after) => before.line !== after.line);
   const entriesChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
   if (!currentComplete) {
     if (entriesChanged)
       return replacement;
-    const namespaces = exports_instructions.diffByKey(previous.namespaces, current.namespaces, (namespace) => namespace.name, (before, after) => before.count !== after.count);
+    const namespaces = diffByKey2(previous.namespaces, current.namespaces, (namespace) => namespace.name, (before, after) => before.count !== after.count);
     const changed = namespaces.added.length > 0 || namespaces.removed.length > 0 || namespaces.changed.length > 0;
     if (!changed)
       return replacement;
-    const parts2 = ["The Code Mode tool catalog has changed."];
+    const parts = ["The Code Mode tool catalog has changed."];
     if (namespaces.added.length > 0) {
-      parts2.push(`New tool namespaces are available: ${namespaces.added.map((namespace) => `\`${namespace.name}\` (${namespace.count} tools)`).join(", ")}.`);
+      parts.push(`New tool namespaces are available: ${namespaces.added.map((namespace) => `\`${namespace.name}\` (${namespace.count} tools)`).join(", ")}.`);
     }
     if (namespaces.changed.length > 0) {
-      parts2.push(`The following namespace inventories changed; search them again before relying on previous results: ${namespaces.changed.map((change) => `\`${change.current.name}\` now has ${change.current.count} tools`).join(", ")}.`);
+      parts.push(`The following namespace inventories changed; search them again before relying on previous results: ${namespaces.changed.map((change) => `\`${change.current.name}\` now has ${change.current.count} tools`).join(", ")}.`);
     }
     if (namespaces.removed.length > 0) {
-      parts2.push(`The following tool namespaces are no longer available and must not be used: ${namespaces.removed.map((namespace) => `\`${namespace.name}\``).join(", ")}.`);
+      parts.push(`The following tool namespaces are no longer available and must not be used: ${namespaces.removed.map((namespace) => `\`${namespace.name}\``).join(", ")}.`);
     }
-    const delta2 = parts2.join(`
+    const delta = parts.join(`
 
 `);
-    if (delta2.length < replacement.length)
-      return delta2;
+    if (delta.length < replacement.length)
+      return delta;
     return replacement;
   }
   if (!entriesChanged)
@@ -106,20 +111,20 @@ ${render(current)}`;
     return delta;
   return replacement;
 }
-var key = exports_instructions.Key.make("core/codemode");
-var codec = Schema.toCodecJson(exports_catalog.Summary);
-var make = (inventory) => {
-  const catalog = inventory === undefined ? exports_instructions.removed : exports_catalog.summarize(inventory);
-  return exports_instructions.make({
+var key = Key3.make("core/codemode");
+var codec = Schema.toCodecJson(Summary2);
+var make15 = (inventory) => {
+  const catalog = inventory === undefined ? removed2 : summarize2(inventory);
+  return make19({
     key,
     codec,
     read: Effect.succeed(catalog),
     render: {
-      initial: render,
-      changed: update,
+      initial: render2,
+      changed: update2,
       removed: () => "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools."
     }
   });
 };
 
-export { render, update, make, exports_instructions2 as exports_instructions };
+export { render2, update2, make15, exports_instructions2 };

package/dist/chunks/{schema-ezs3tagn.js → pty-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 };

package/dist/chunks/{schema-snpn6bap.js → pty-x1b8g1yb.js}

@@ -1,7 +1,7 @@
 // src/plugin/provider/sdk-factory.ts
 import { Effect } from "effect";
 import { importModule, resolveModule } from "@opencode-ai/util/runtime-import";
-var loadSDKFactory = Effect.fnUntraced(function* (npm, packageName) {
+var loadSDKFactory2 = Effect.fnUntraced(function* (npm, packageName) {
   const installedPath = packageName.startsWith("file://") ? packageName : yield* npm.add(packageName).pipe(Effect.orDie, Effect.map((installed) => resolveModule(installed.name, installed.directory)));
   const mod = yield* Effect.promise(() => importModule(installedPath));
   const match = Object.keys(mod).find((name) => name.startsWith("create"));
@@ -10,4 +10,4 @@ var loadSDKFactory = Effect.fnUntraced(function* (npm, packageName) {
   return mod[match];
 });
 
-export { loadSDKFactory };
+export { loadSDKFactory2 };

package/dist/chunks/{schema-hbtzhcxr.js → pty-x1ezjp6w.js}

@@ -1,34 +1,34 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/session/subagent-completion.ts
 var exports_subagent_completion = {};
 __export(exports_subagent_completion, {
-  NO_TEXT: () => NO_TEXT,
+  NO_TEXT: () => NO_TEXT2,
   SubagentCompletion: () => exports_subagent_completion,
-  deliver: () => deliver,
-  text: () => text
+  deliver: () => deliver2,
+  text: () => text2
 });
 import { Effect } from "effect";
-var NO_TEXT = "Subagent completed without a text response.";
-function text(message) {
+var NO_TEXT2 = "Subagent completed without a text response.";
+function text2(message) {
   if (message?.type !== "assistant")
-    return NO_TEXT;
-  return message.content.filter((part) => part.type === "text").map((part) => part.text).join("") || NO_TEXT;
+    return NO_TEXT2;
+  return message.content.filter((part) => part.type === "text").map((part) => part.text).join("") || NO_TEXT2;
 }
-var deliver = Effect.fnUntraced(function* (sessions, jobs, input) {
+var deliver2 = Effect.fnUntraced(function* (sessions, jobs, input) {
   if (input.status === "running")
     return;
   const recovery = input.recovery;
-  const text2 = input.status === "completed" ? input.output ?? NO_TEXT : input.status === "error" ? input.error ?? "Subagent failed" : "Subagent cancelled";
+  const text = input.status === "completed" ? input.output ?? NO_TEXT2 : input.status === "error" ? input.error ?? "Subagent failed" : "Subagent cancelled";
   yield* sessions.synthetic({
     ...input.notificationID ? { id: input.notificationID } : {},
     sessionID: recovery.parentSessionID,
     ...input.resume === false ? { resume: false } : {},
     description: recovery.description,
     text: `<subagent sessionID="${recovery.childSessionID}" state="${input.status}" description="${recovery.description}">
-${text2}
+${text}
 </subagent>`,
     metadata: { source: "subagent", childID: recovery.childSessionID, agent: recovery.agent, state: input.status }
   });
@@ -36,4 +36,4 @@ ${text2}
     yield* jobs.completeBackground(input.notificationID);
 });
 
-export { NO_TEXT, text, deliver, exports_subagent_completion };
+export { NO_TEXT2, text2, deliver2, exports_subagent_completion };

package/dist/chunks/{schema-8c5xq4gn.js → pty-x5hde6ee.js}

@@ -1,36 +1,41 @@
 import {
-  InstructionBlobTable,
-  InstructionStateTable
-} from "./schema-q606pcse.js";
+  Hash2,
+  read3,
+  diff2,
+  renderInitial2,
+  renderUpdate2,
+  applyHashDelta2
+} from "./pty-6e958v7x.js";
 import {
-  SessionEvent
-} from "./schema-a83yvq99.js";
+  SessionEvent2
+} from "./pty-mntxs535.js";
 import {
-  exports_instructions
-} from "./schema-c54e84vp.js";
+  InstructionBlobTable2,
+  InstructionStateTable2
+} from "./pty-g2dy4bvs.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/session/instruction-state.ts
 var exports_instruction_state = {};
 __export(exports_instruction_state, {
   InstructionState: () => exports_instruction_state,
-  advanceEpoch: () => advanceEpoch,
-  apply: () => apply,
-  commit: () => commit,
-  current: () => current,
-  initial: () => initial,
-  initialize: () => initialize,
-  observe: () => observe,
-  prepare: () => prepare,
-  preview: () => preview,
-  reset: () => reset
+  advanceEpoch: () => advanceEpoch2,
+  apply: () => apply2,
+  commit: () => commit3,
+  current: () => current2,
+  initial: () => initial2,
+  initialize: () => initialize3,
+  observe: () => observe3,
+  prepare: () => prepare4,
+  preview: () => preview3,
+  reset: () => reset2
 });
 import { eq, inArray, sql } from "drizzle-orm";
 import { Effect, Option } from "effect";
-var observe = Effect.fn("InstructionState.observe")(function* (db, instructions, sessionID) {
-  const [observed, stored] = yield* Effect.all([exports_instructions.read(instructions), find(db, sessionID)], {
+var observe3 = Effect.fn("InstructionState.observe")(function* (db, instructions, sessionID) {
+  const [observed, stored] = yield* Effect.all([read3(instructions), find(db, sessionID)], {
     concurrency: "unbounded"
   });
   const result = yield* observeAgainst(observed, stored?.current_values);
@@ -41,11 +46,11 @@ var observe = Effect.fn("InstructionState.observe")(function* (db, instructions,
     ...result
   };
 });
-var commit = Effect.fn("InstructionState.commit")(function* (db, bus, instructions, observation) {
+var commit3 = Effect.fn("InstructionState.commit")(function* (db, bus, instructions, observation) {
   if (!observation.initial && Object.keys(observation.delta).length === 0)
     return;
   const text = observation.initial ? "" : yield* renderUpdateText(db, instructions, observation);
-  yield* bus.publish(SessionEvent.InstructionsUpdated, {
+  yield* bus.publish(SessionEvent2.InstructionsUpdated, {
     sessionID: observation.sessionID,
     delta: observation.delta,
     ...text.length > 0 ? { text } : {}
@@ -58,17 +63,17 @@ var renderUpdateText = Effect.fnUntraced(function* (db, instructions, observatio
   const replaced = Object.entries(observation.previous).filter(([key]) => Object.hasOwn(observation.delta, key));
   const blobs = yield* loadBlobs(db, replaced.map(([, hash]) => hash));
   const previous = Object.fromEntries(replaced.map(([key, hash]) => [key, requireBlob(blobs, hash)]));
-  const admitted = new Map(Object.entries(observation.blobs).map(([hash, value]) => [exports_instructions.Hash.make(hash), value]));
-  return exports_instructions.renderUpdate(instructions, previous, dereferenceDelta(observation.delta, admitted));
+  const admitted = new Map(Object.entries(observation.blobs).map(([hash, value]) => [Hash2.make(hash), value]));
+  return renderUpdate2(instructions, previous, dereferenceDelta(observation.delta, admitted));
 });
-var prepare = Effect.fn("InstructionState.prepare")(function* (db, bus, instructions, sessionID) {
-  yield* commit(db, bus, instructions, yield* observe(db, instructions, sessionID));
+var prepare4 = Effect.fn("InstructionState.prepare")(function* (db, bus, instructions, sessionID) {
+  yield* commit3(db, bus, instructions, yield* observe3(db, instructions, sessionID));
 });
-var apply = Effect.fn("InstructionState.apply")(function* (db, sessionID, seq, delta) {
+var apply2 = Effect.fn("InstructionState.apply")(function* (db, sessionID, seq, delta) {
   const stored = yield* find(db, sessionID);
-  const current = exports_instructions.applyHashDelta(stored?.current_values ?? {}, delta);
+  const current = applyHashDelta2(stored?.current_values ?? {}, delta);
   if (!stored) {
-    yield* db.insert(InstructionStateTable).values({
+    yield* db.insert(InstructionStateTable2).values({
       session_id: sessionID,
       epoch_start: seq,
       through_seq: seq,
@@ -77,10 +82,10 @@ var apply = Effect.fn("InstructionState.apply")(function* (db, sessionID, seq, d
     }).run().pipe(Effect.orDie);
     return;
   }
-  yield* db.update(InstructionStateTable).set({ through_seq: seq, current_values: current }).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+  yield* db.update(InstructionStateTable2).set({ through_seq: seq, current_values: current }).where(eq(InstructionStateTable2.session_id, sessionID)).run().pipe(Effect.orDie);
 });
-var initialize = Effect.fn("InstructionState.initialize")(function* (db, sessionID, seq, values) {
-  yield* db.insert(InstructionStateTable).values({
+var initialize3 = Effect.fn("InstructionState.initialize")(function* (db, sessionID, seq, values) {
+  yield* db.insert(InstructionStateTable2).values({
     session_id: sessionID,
     epoch_start: seq,
     through_seq: seq,
@@ -88,60 +93,60 @@ var initialize = Effect.fn("InstructionState.initialize")(function* (db, session
     current_values: values
   }).onConflictDoNothing().run().pipe(Effect.orDie);
 });
-var advanceEpoch = Effect.fn("InstructionState.advanceEpoch")(function* (db, sessionID, epochStart) {
-  yield* db.update(InstructionStateTable).set({
+var advanceEpoch2 = Effect.fn("InstructionState.advanceEpoch")(function* (db, sessionID, epochStart) {
+  yield* db.update(InstructionStateTable2).set({
     epoch_start: epochStart,
     through_seq: epochStart,
-    initial_values: sql`${InstructionStateTable.current_values}`
-  }).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+    initial_values: sql`${InstructionStateTable2.current_values}`
+  }).where(eq(InstructionStateTable2.session_id, sessionID)).run().pipe(Effect.orDie);
 });
-var reset = Effect.fn("InstructionState.reset")(function* (db, sessionID) {
-  yield* db.delete(InstructionStateTable).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+var reset2 = Effect.fn("InstructionState.reset")(function* (db, sessionID) {
+  yield* db.delete(InstructionStateTable2).where(eq(InstructionStateTable2.session_id, sessionID)).run().pipe(Effect.orDie);
 });
-var initial = Effect.fn("InstructionState.initial")(function* (db, sessionID, instructions) {
+var initial2 = Effect.fn("InstructionState.initial")(function* (db, sessionID, instructions) {
   const state = yield* find(db, sessionID);
   if (!state)
     return yield* Effect.die(new Error(`Instruction state not found during assembly: ${sessionID}`));
   const blobs = yield* loadBlobs(db, Object.values(state.initial_values));
-  return exports_instructions.renderInitial(instructions, dereference(state.initial_values, blobs));
+  return renderInitial2(instructions, dereference(state.initial_values, blobs));
 });
-var current = Effect.fn("InstructionState.current")(function* (db, sessionID) {
+var current2 = Effect.fn("InstructionState.current")(function* (db, sessionID) {
   return (yield* find(db, sessionID))?.current_values;
 });
-var preview = Effect.fn("InstructionState.preview")(function* (db, sessionID, instructions, observed) {
+var preview3 = Effect.fn("InstructionState.preview")(function* (db, sessionID, instructions, observed) {
   const state = yield* find(db, sessionID);
   const result = yield* observeAgainst(observed, state?.current_values);
-  const observedBlobs = new Map(Object.entries(result.blobs).map(([hash, value]) => [exports_instructions.Hash.make(hash), value]));
+  const observedBlobs = new Map(Object.entries(result.blobs).map(([hash, value]) => [Hash2.make(hash), value]));
   if (!state) {
     const values = dereference(result.current, observedBlobs);
-    return { initial: exports_instructions.renderInitial(instructions, values), update: "" };
+    return { initial: renderInitial2(instructions, values), update: "" };
   }
   const stored = yield* loadBlobs(db, [...Object.values(state.initial_values), ...Object.values(state.current_values)]);
   return {
-    initial: exports_instructions.renderInitial(instructions, dereference(state.initial_values, stored)),
-    update: exports_instructions.renderUpdate(instructions, dereference(state.current_values, stored), dereferenceDelta(result.delta, observedBlobs))
+    initial: renderInitial2(instructions, dereference(state.initial_values, stored)),
+    update: renderUpdate2(instructions, dereference(state.current_values, stored), dereferenceDelta(result.delta, observedBlobs))
   };
 });
 var observeAgainst = Effect.fnUntraced(function* (observed, previous) {
-  const admission = yield* exports_instructions.diff(observed, previous);
+  const admission = yield* diff2(observed, previous);
   return {
-    current: exports_instructions.applyHashDelta(previous ?? {}, admission.delta),
+    current: applyHashDelta2(previous ?? {}, admission.delta),
     ...admission
   };
 });
 var find = Effect.fnUntraced(function* (db, sessionID) {
-  return yield* db.select().from(InstructionStateTable).where(eq(InstructionStateTable.session_id, sessionID)).get().pipe(Effect.orDie);
+  return yield* db.select().from(InstructionStateTable2).where(eq(InstructionStateTable2.session_id, sessionID)).get().pipe(Effect.orDie);
 });
 var insertBlobs = Effect.fnUntraced(function* (db, blobs) {
-  const rows = Object.entries(blobs).map(([hash, value]) => ({ hash: exports_instructions.Hash.make(hash), value }));
+  const rows = Object.entries(blobs).map(([hash, value]) => ({ hash: Hash2.make(hash), value }));
   if (rows.length === 0)
     return;
-  yield* db.insert(InstructionBlobTable).values(rows).onConflictDoNothing().run().pipe(Effect.orDie);
+  yield* db.insert(InstructionBlobTable2).values(rows).onConflictDoNothing().run().pipe(Effect.orDie);
 });
 var loadBlobs = Effect.fnUntraced(function* (db, values) {
   const hashes = [...new Set(values)];
   const batches = Array.from({ length: Math.ceil(hashes.length / 500) }, (_, index) => hashes.slice(index * 500, (index + 1) * 500));
-  const rows = (yield* Effect.forEach(batches, (batch) => db.select().from(InstructionBlobTable).where(inArray(InstructionBlobTable.hash, batch)).all().pipe(Effect.orDie), { concurrency: 4 })).flat();
+  const rows = (yield* Effect.forEach(batches, (batch) => db.select().from(InstructionBlobTable2).where(inArray(InstructionBlobTable2.hash, batch)).all().pipe(Effect.orDie), { concurrency: 4 })).flat();
   const blobs = new Map(rows.map((row) => [row.hash, row.value]));
   for (const hash of hashes) {
     if (!blobs.has(hash))
@@ -165,4 +170,4 @@ function requireBlob(blobs, hash) {
   return value;
 }
 
-export { observe, commit, prepare, apply, initialize, advanceEpoch, reset, initial, current, preview, exports_instruction_state };
+export { observe3, commit3, prepare4, apply2, initialize3, advanceEpoch2, reset2, initial2, current2, preview3, exports_instruction_state };

package/dist/chunks/{schema-0cgt0xh2.js → pty-x61499pn.js}

@@ -1,5 +1,5 @@
 // src/github-copilot/chat/map-openai-compatible-finish-reason.ts
-function mapOpenAICompatibleFinishReason(finishReason) {
+function mapOpenAICompatibleFinishReason2(finishReason) {
   switch (finishReason) {
     case "stop":
       return "stop";
@@ -15,4 +15,4 @@ function mapOpenAICompatibleFinishReason(finishReason) {
   }
 }
 
-export { mapOpenAICompatibleFinishReason };
+export { mapOpenAICompatibleFinishReason2 };