@opencode-ai/core 0.0.0-beta-18593 → 0.0.0-beta-18684

package/dist/chunks/{persistent-pty-pp6dntfs.js → state-az57h3s3.js}

@@ -1,19 +1,12 @@
 import {
   exports_model_resolver
-} from "./persistent-pty-7hq60rpc.js";
-import {
-  ID,
-  Ref
-} from "./persistent-pty-r13w8t0w.js";
-import {
-  exports_provider
-} from "./persistent-pty-krsqcmnj.js";
+} from "./state-j29rhpt4.js";
 import {
   SessionSchema
-} from "./persistent-pty-bjwj8hwv.js";
+} from "./state-bjwj8hwv.js";
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/session/runner/model.ts
 var exports_model = {};
@@ -29,6 +22,8 @@ __export(exports_model, {
   ModelNotSelectedError: () => ModelNotSelectedError
 });
 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 }) {
   get message() {
@@ -36,7 +31,7 @@ class ModelNotSelectedError extends Schema.TaggedError()("SessionRunnerModel.Mod
   }
 }
 
-class ModelUnavailableError extends Schema.TaggedError()("SessionRunnerModel.ModelUnavailableError", { providerID: exports_provider.ID, modelID: ID }) {
+class ModelUnavailableError 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.`;
@@ -53,9 +48,9 @@ class Service extends Context.Service()("@opencode/SessionRunnerModel") {
 }
 var resolved = (model, options) => ({
   model,
-  ref: Ref.make({
-    id: ID.make(model.id),
-    providerID: exports_provider.ID.make(model.provider),
+  ref: Model.Ref.make({
+    id: Model.ID.make(model.id),
+    providerID: Provider.ID.make(model.provider),
     ...options.variant === undefined ? {} : { variant: options.variant }
   }),
   capabilities: options.capabilities,

package/dist/chunks/{persistent-pty-bbhffenw.js → state-bbhffenw.js}

@@ -1,12 +1,12 @@
 import {
   which
-} from "./persistent-pty-k3e42drn.js";
+} from "./state-k3e42drn.js";
 import {
   exports_state
-} from "./persistent-pty-x89rah0x.js";
+} from "./state-x89rah0x.js";
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/shell/select.ts
 var exports_select = {};

package/dist/chunks/{persistent-pty-bh1wr8rq.js → state-bh1wr8rq.js}

@@ -1,9 +1,9 @@
 import {
   exports_app
-} from "./persistent-pty-50jxp3hw.js";
+} from "./state-50jxp3hw.js";
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/plugin/websearch/tavily.ts
 var exports_tavily = {};

package/dist/chunks/{persistent-pty-caycsp33.js → state-bktc4s3t.js}

@@ -1,9 +1,9 @@
 import {
   exports_bus
-} from "./persistent-pty-8dqs26x1.js";
+} from "./state-cgy4zpa6.js";
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/plugin/sdk.ts
 var exports_sdk = {};

package/dist/chunks/{persistent-pty-r5b5j3z1.js → state-bsjatayh.js}

@@ -1,24 +1,24 @@
+import {
+  exports_integration
+} from "./state-kse1g3vm.js";
 import {
   exports_config
-} from "./persistent-pty-0dfzjmdz.js";
+} from "./state-5hbk2f5z.js";
 import {
   exports_provider_options
-} from "./persistent-pty-y0x38cee.js";
-import {
-  exports_model
-} from "./persistent-pty-r13w8t0w.js";
-import {
-  exports_integration
-} from "./persistent-pty-tayw3q5q.js";
+} from "./state-y0x38cee.js";
 import {
   exports_credential
-} from "./persistent-pty-a7xc44k8.js";
+} from "./state-cynvptsh.js";
+import {
+  exports_model
+} from "./state-r13w8t0w.js";
 import {
   exports_provider
-} from "./persistent-pty-krsqcmnj.js";
+} from "./state-krsqcmnj.js";
 import {
   exports_bus
-} from "./persistent-pty-8dqs26x1.js";
+} from "./state-cgy4zpa6.js";
 
 // src/plugin/provider/opencode.ts
 import { Duration, Effect, Schema, Semaphore, Stream } from "effect";

package/dist/chunks/{persistent-pty-byab506k.js → state-byab506k.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/database/v1-migration.ts
 var exports_v1_migration = {};

package/dist/chunks/{persistent-pty-c4wcb9vc.js → state-c4wcb9vc.js}

@@ -1,9 +1,9 @@
 import {
   collectBoundedResponseBody
-} from "./persistent-pty-jve7t217.js";
+} from "./state-jve7t217.js";
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/plugin/websearch/mcp.ts
 var exports_mcp = {};

package/dist/chunks/{persistent-pty-c8ya26sa.js → state-c8ya26sa.js}

@@ -1,10 +1,10 @@
 import {
   absoluteArrayColumn,
   absoluteColumn
-} from "./persistent-pty-zbqqnp0n.js";
+} from "./state-zbqqnp0n.js";
 import {
   Timestamps
-} from "./persistent-pty-sem2g21k.js";
+} from "./state-sem2g21k.js";
 
 // src/project/sql.ts
 import { isNotNull, isNull, ne, or } from "drizzle-orm";

package/dist/chunks/{persistent-pty-hggmzd1z.js → state-cbp56nj8.js}

@@ -1,27 +1,27 @@
 import {
   fileDiff
-} from "./persistent-pty-c77ad0vh.js";
-import {
-  exports_location_mutation
-} from "./persistent-pty-j8t12rx3.js";
+} from "./state-c77ad0vh.js";
 import {
   exports_formatter
-} from "./persistent-pty-02s8hgfb.js";
+} from "./state-qnk6x8hc.js";
 import {
-  exports_permission
-} from "./persistent-pty-ckw7ggwg.js";
+  exports_location_mutation
+} from "./state-rg042c41.js";
 import {
   exports_file_mutation
-} from "./persistent-pty-0tya1wfq.js";
+} from "./state-h8499ys5.js";
+import {
+  exports_permission
+} from "./state-6xryfvfs.js";
 import {
   exports_environment1 as exports_environment
-} from "./persistent-pty-q22ck3r9.js";
+} from "./state-546qm8gr.js";
 import {
   exports_location
-} from "./persistent-pty-d88p9jy9.js";
+} from "./state-qph0wk53.js";
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/tool/plugin/patch.ts
 var exports_patch = {};

package/dist/chunks/state-cgqn2mrm.js

@@ -0,0 +1,147 @@
+import {
+  SessionMessage
+} from "./state-8rpfd2h6.js";
+import {
+  SessionSchema
+} from "./state-bjwj8hwv.js";
+import {
+  __export
+} from "./state-rvfvac9x.js";
+
+// src/session/error.ts
+var exports_error = {};
+__export(exports_error, {
+  UserInterruptedError: () => UserInterruptedError,
+  SyntheticConflictError: () => SyntheticConflictError,
+  StepFailedError: () => StepFailedError,
+  SkillNotFoundError: () => SkillNotFoundError,
+  SessionErrors: () => exports_error,
+  PromptConflictError: () => PromptConflictError,
+  NotFoundError: () => NotFoundError,
+  MessageToolIncompleteError: () => MessageToolIncompleteError,
+  MessageNotFoundError: () => MessageNotFoundError,
+  MessageNotAssistantError: () => MessageNotAssistantError,
+  MessageIncompleteError: () => MessageIncompleteError,
+  MessageDecodeError: () => MessageDecodeError,
+  InboxConflictError: () => InboxConflictError,
+  ForkEmptyError: () => ForkEmptyError,
+  CompactionConflictError: () => CompactionConflictError,
+  BusyError: () => BusyError,
+  AttachmentError: () => AttachmentError,
+  AgentNotFoundError: () => AgentNotFoundError
+});
+import { Schema } from "effect";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Skill } from "@opencode-ai/schema/skill";
+import { SessionError } from "@opencode-ai/schema/session-error";
+
+class NotFoundError extends Schema.TaggedError()("Session.NotFoundError", {
+  sessionID: SessionSchema.ID
+}) {
+}
+
+class MessageNotFoundError extends Schema.TaggedError()("Session.MessageNotFoundError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class MessageNotAssistantError extends Schema.TaggedError()("Session.MessageNotAssistantError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class MessageIncompleteError extends Schema.TaggedError()("Session.MessageIncompleteError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class MessageToolIncompleteError extends Schema.TaggedError()("Session.MessageToolIncompleteError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class ForkEmptyError extends Schema.TaggedError()("Session.ForkEmptyError", {
+  sessionID: SessionSchema.ID
+}) {
+  get message() {
+    return `Cannot fork empty session: ${this.sessionID}`;
+  }
+}
+
+class MessageDecodeError extends Schema.TaggedError()("Session.MessageDecodeError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+  get message() {
+    return `Failed to decode message ${this.messageID} in session ${this.sessionID}`;
+  }
+}
+
+class AgentNotFoundError extends Schema.TaggedError()("Session.AgentNotFoundError", {
+  sessionID: SessionSchema.ID,
+  agent: Agent.ID
+}) {
+  get message() {
+    return `Agent not found: "${this.agent}"`;
+  }
+}
+
+class StepFailedError extends Schema.TaggedError()("Session.StepFailedError", {
+  error: SessionError.Error
+}) {
+  get message() {
+    return this.error.message;
+  }
+}
+
+class UserInterruptedError extends Schema.TaggedError()("Session.UserInterruptedError", {}) {
+  get message() {
+    return "Session interrupted by user";
+  }
+}
+
+class PromptConflictError extends Schema.TaggedError()("Session.PromptConflictError", {
+  sessionID: SessionSchema.ID,
+  messageID: SessionMessage.ID
+}) {
+}
+
+class SyntheticConflictError extends Schema.TaggedError()("Session.SyntheticConflictError", {
+  sessionID: SessionSchema.ID,
+  inputID: SessionMessage.ID
+}) {
+}
+
+class AttachmentError extends Schema.TaggedError()("Session.AttachmentError", {
+  uri: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CompactionConflictError extends Schema.TaggedError()("Session.CompactionConflictError", {
+  sessionID: SessionSchema.ID,
+  inputID: SessionMessage.ID
+}) {
+}
+
+class BusyError extends Schema.TaggedError()("Session.BusyError", {
+  sessionID: SessionSchema.ID
+}) {
+}
+
+class InboxConflictError extends Schema.TaggedError()("Session.InboxConflictError", {
+  sessionID: SessionSchema.ID,
+  inboxID: SessionMessage.ID
+}) {
+}
+
+class SkillNotFoundError extends Schema.TaggedError()("Session.SkillNotFoundError", {
+  skill: Skill.ID
+}) {
+}
+
+export { NotFoundError, MessageNotFoundError, MessageNotAssistantError, MessageIncompleteError, MessageToolIncompleteError, ForkEmptyError, MessageDecodeError, AgentNotFoundError, StepFailedError, UserInterruptedError, PromptConflictError, SyntheticConflictError, AttachmentError, CompactionConflictError, BusyError, InboxConflictError, SkillNotFoundError, exports_error };

package/dist/chunks/{persistent-pty-8dqs26x1.js → state-cgy4zpa6.js}

@@ -1,17 +1,17 @@
 import {
   EventSequenceTable,
   EventTable
-} from "./persistent-pty-zsf8rs93.js";
-import {
-  exports_database
-} from "./persistent-pty-agy32ytt.js";
+} from "./state-zsf8rs93.js";
 import {
   exports_keyed_mutex
-} from "./persistent-pty-0kvmztkf.js";
+} from "./state-0kvmztkf.js";
+import {
+  exports_database
+} from "./state-vpac0x8g.js";
 import {
   __export,
   __require
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/bus.ts
 var exports_bus = {};
@@ -161,103 +161,101 @@ function configured(options) {
       function commitDurableEvent(definition, event, input, commit) {
         return Effect.gen(function* () {
           const durable2 = definition.durable;
-          if (durable2) {
-            const aggregateID = event.data[durable2.aggregate];
-            if (typeof aggregateID !== "string") {
-              yield* Effect.die(new InvalidDurableEventError({
-                type: event.type,
-                message: `Expected string aggregate field ${durable2.aggregate}`
-              }));
-            } else {
-              if (input && input.aggregateID !== aggregateID) {
+          if (!durable2)
+            return yield* Effect.void;
+          const aggregateID = event.data[durable2.aggregate];
+          if (typeof aggregateID !== "string")
+            return yield* Effect.die(new InvalidDurableEventError({
+              type: event.type,
+              message: `Expected string aggregate field ${durable2.aggregate}`
+            }));
+          if (input && input.aggregateID !== aggregateID) {
+            yield* Effect.die(new InvalidDurableEventError({
+              type: event.type,
+              message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`
+            }));
+          }
+          const list = projectors.get(versionedType(definition.type, durable2.version)) ?? [];
+          return yield* Effect.uninterruptible(Effect.gen(function* () {
+            const committed = yield* db.transaction(() => Effect.gen(function* () {
+              const row = yield* db.select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+              const latest = row?.seq ?? -1;
+              const encoded = Schema.encodeUnknownSync(definition.data)(event.data);
+              if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
                 yield* Effect.die(new InvalidDurableEventError({
                   type: event.type,
-                  message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`
+                  message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`
                 }));
               }
-              const list = projectors.get(versionedType(definition.type, durable2.version)) ?? [];
-              return yield* Effect.uninterruptible(Effect.gen(function* () {
-                const committed = yield* db.transaction(() => Effect.gen(function* () {
-                  const row = yield* db.select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
-                  const latest = row?.seq ?? -1;
-                  const encoded = Schema.encodeUnknownSync(definition.data)(event.data);
-                  if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
-                    yield* Effect.die(new InvalidDurableEventError({
-                      type: event.type,
-                      message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`
-                    }));
-                  }
-                  if (input && input.seq <= latest) {
-                    if (!persist)
-                      return;
-                    const stored = yield* db.select().from(EventTable).where(and(eq(EventTable.aggregate_id, aggregateID), eq(EventTable.seq, input.seq))).get().pipe(Effect.orDie);
-                    if (stored?.id === event.id && stored.type === versionedType(definition.type, durable2.version) && stored.created === (event.created ?? 0) && isDeepStrictEqual(stored.data, encoded)) {
-                      if (input.ownerID && row?.ownerID == null) {
-                        yield* db.update(EventSequenceTable).set({ owner_id: input.ownerID }).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
-                      }
-                      return;
-                    }
-                    yield* Effect.die(new InvalidDurableEventError({
-                      type: event.type,
-                      message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`
-                    }));
-                  }
-                  if (input && row?.ownerID && row.ownerID !== input.ownerID) {
-                    return;
-                  }
-                  const seq = input?.seq ?? latest + 1;
-                  if (input && seq !== latest + 1) {
-                    yield* Effect.die(new InvalidDurableEventError({
-                      type: event.type,
-                      message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`
-                    }));
-                  }
-                  if (persist) {
-                    const stored = yield* db.select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq }).from(EventTable).where(eq(EventTable.id, event.id)).get().pipe(Effect.orDie);
-                    if (stored)
-                      yield* Effect.die(new InvalidDurableEventError({
-                        type: event.type,
-                        message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
-                      }));
-                  }
-                  const committed2 = {
-                    ...event,
-                    durable: { aggregateID, seq, version: durable2.version }
-                  };
-                  const route = yield* prepareRoutes([committed2]);
-                  for (const projector of list) {
-                    yield* projector(committed2);
+              if (input && input.seq <= latest) {
+                if (!persist)
+                  return;
+                const stored = yield* db.select().from(EventTable).where(and(eq(EventTable.aggregate_id, aggregateID), eq(EventTable.seq, input.seq))).get().pipe(Effect.orDie);
+                if (stored?.id === event.id && stored.type === versionedType(definition.type, durable2.version) && stored.created === (event.created ?? 0) && isDeepStrictEqual(stored.data, encoded)) {
+                  if (input.ownerID && row?.ownerID == null) {
+                    yield* db.update(EventSequenceTable).set({ owner_id: input.ownerID }).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
                   }
-                  if (commit)
-                    yield* commit(seq);
-                  yield* db.insert(EventSequenceTable).values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }]).onConflictDoUpdate({
-                    target: EventSequenceTable.aggregate_id,
-                    set: {
-                      seq: sql`max(${EventSequenceTable.seq}, ${seq})`,
-                      ...input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}
-                    }
-                  }).run().pipe(Effect.orDie);
-                  if (persist)
-                    yield* db.insert(EventTable).values([
-                      {
-                        id: event.id,
-                        aggregate_id: aggregateID,
-                        seq,
-                        created: event.created ?? 0,
-                        type: versionedType(definition.type, durable2.version),
-                        data: encoded
-                      }
-                    ]).run().pipe(Effect.orDie);
-                  return { aggregateID, seq, event: committed2, route };
-                }), { behavior: "immediate" }).pipe(Effect.orDie);
-                if (committed) {
-                  committed.route();
-                  yield* Effect.forEach(pubsub.durable.get(committed.aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), { discard: true });
+                  return;
                 }
-                return committed;
-              }));
+                yield* Effect.die(new InvalidDurableEventError({
+                  type: event.type,
+                  message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`
+                }));
+              }
+              if (input && row?.ownerID && row.ownerID !== input.ownerID) {
+                return;
+              }
+              const seq = input?.seq ?? latest + 1;
+              if (input && seq !== latest + 1) {
+                yield* Effect.die(new InvalidDurableEventError({
+                  type: event.type,
+                  message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`
+                }));
+              }
+              if (persist) {
+                const stored = yield* db.select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq }).from(EventTable).where(eq(EventTable.id, event.id)).get().pipe(Effect.orDie);
+                if (stored)
+                  yield* Effect.die(new InvalidDurableEventError({
+                    type: event.type,
+                    message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
+                  }));
+              }
+              const committed2 = {
+                ...event,
+                durable: { aggregateID, seq, version: durable2.version }
+              };
+              const route = yield* prepareRoutes([committed2]);
+              for (const projector of list) {
+                yield* projector(committed2);
+              }
+              if (commit)
+                yield* commit(seq);
+              yield* db.insert(EventSequenceTable).values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }]).onConflictDoUpdate({
+                target: EventSequenceTable.aggregate_id,
+                set: {
+                  seq: sql`max(${EventSequenceTable.seq}, ${seq})`,
+                  ...input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}
+                }
+              }).run().pipe(Effect.orDie);
+              if (persist)
+                yield* db.insert(EventTable).values([
+                  {
+                    id: event.id,
+                    aggregate_id: aggregateID,
+                    seq,
+                    created: event.created ?? 0,
+                    type: versionedType(definition.type, durable2.version),
+                    data: encoded
+                  }
+                ]).run().pipe(Effect.orDie);
+              return { aggregateID, seq, event: committed2, route };
+            }), { behavior: "immediate" }).pipe(Effect.orDie);
+            if (committed) {
+              committed.route();
+              yield* Effect.forEach(pubsub.durable.get(committed.aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), { discard: true });
             }
-          }
+            return committed;
+          }));
         });
       }
       function publishEvent(definition, event, commit) {
@@ -507,10 +505,10 @@ function configured(options) {
           aggregateID: input.aggregateID,
           ...target >= 0 ? { seq: Event.Seq.make(target) } : {}
         };
-        const replay2 = readThrough(target).pipe(Stream.map((event) => event), Stream.concat(Stream.make(marker)));
+        const replay2 = readThrough(target).pipe(Stream.concat(Stream.make(marker)));
         if (!wakes)
           return replay2;
-        const live = Stream.fromSubscription(wakes).pipe(Stream.mapEffect(() => latestSequence(db, input.aggregateID)), Stream.filter((target2) => target2 > sequence), Stream.flatMap((target2) => readThrough(target2)), Stream.map((event) => event));
+        const live = Stream.fromSubscription(wakes).pipe(Stream.mapEffect(() => latestSequence(db, input.aggregateID)), Stream.filter((target2) => target2 > sequence), Stream.flatMap((target2) => readThrough(target2)));
         return Stream.concat(replay2, live);
       }));
       const listen = (listener) => Effect.sync(() => {

package/dist/chunks/{persistent-pty-8n5xz4y2.js → state-cnsekzdm.js}

@@ -1,15 +1,15 @@
 import {
   InstructionEntryTable
-} from "./persistent-pty-q606pcse.js";
+} from "./state-q606pcse.js";
 import {
   exports_instructions
-} from "./persistent-pty-ec8vrfw5.js";
+} from "./state-ec8vrfw5.js";
 import {
   exports_database
-} from "./persistent-pty-agy32ytt.js";
+} from "./state-vpac0x8g.js";
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/session/instruction-entry.ts
 var exports_instruction_entry = {};

package/dist/chunks/{persistent-pty-4fpv6vze.js → state-cp8v16sk.js}

@@ -1,18 +1,18 @@
-import {
-  exports_sdk
-} from "./persistent-pty-caycsp33.js";
 import {
   exports_source_directory
-} from "./persistent-pty-6272rtjg.js";
+} from "./state-6272rtjg.js";
 import {
   exports_module
-} from "./persistent-pty-75h1hfe2.js";
+} from "./state-g5tvq2z7.js";
+import {
+  exports_sdk
+} from "./state-bktc4s3t.js";
 import {
   AbsolutePath
-} from "./persistent-pty-j07kk359.js";
+} from "./state-j07kk359.js";
 import {
   __export
-} from "./persistent-pty-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/project/markers.ts
 var exports_markers = {};