@opencode-ai/core 0.0.0-beta-18600 → 0.0.0-beta-18707

package/dist/chunks/model-pwd75nyq.js

@@ -0,0 +1,405 @@
+import {
+  exports_projector
+} from "./model-wf85cm54.js";
+import {
+  exports_instruction_entry
+} from "./model-hd3n7xxs.js";
+import {
+  exports_session
+} from "./model-c8fhf3ac.js";
+import {
+  exports_generate
+} from "./model-xgv25zxy.js";
+import {
+  exports_execution
+} from "./model-wk5ccvwp.js";
+import {
+  exports_inbox
+} from "./model-kvhsphac.js";
+import {
+  exports_model_transport
+} from "./model-tjrfm0xh.js";
+import {
+  exports_supervisor_service
+} from "./model-s33fw6zm.js";
+import {
+  exports_environment
+} from "./model-6ky7rqk7.js";
+import {
+  exports_job
+} from "./model-ys131sm2.js";
+import {
+  exports_store
+} from "./model-bym1j60d.js";
+import {
+  exports_instruction_state
+} from "./model-hxcd35r2.js";
+import {
+  AttachmentError,
+  BusyError,
+  CompactionConflictError,
+  ForkEmptyError,
+  InboxConflictError,
+  MessageDecodeError,
+  MessageIncompleteError,
+  MessageNotAssistantError,
+  MessageNotFoundError,
+  MessageToolIncompleteError,
+  NotFoundError,
+  PromptConflictError,
+  SkillNotFoundError,
+  SyntheticConflictError
+} from "./model-cgqn2mrm.js";
+import {
+  SessionMessageTable
+} from "./model-q606pcse.js";
+import {
+  SessionMessage
+} from "./model-8rpfd2h6.js";
+import {
+  ID,
+  Info,
+  SessionSchema
+} from "./model-bjwj8hwv.js";
+import {
+  SessionEvent
+} from "./model-a83yvq99.js";
+import {
+  exports_command
+} from "./model-mdperjk5.js";
+import {
+  exports_location_service_map
+} from "./model-zdkg1k91.js";
+import {
+  exports_app
+} from "./model-50jxp3hw.js";
+import {
+  Slug
+} from "./model-df3v2q6j.js";
+import {
+  exports_location
+} from "./model-xy3y21dp.js";
+import {
+  exports_project
+} from "./model-b7g40f0s.js";
+import {
+  AbsolutePath,
+  RelativePath
+} from "./model-j07kk359.js";
+import {
+  exports_bus
+} from "./model-vwkfg4n5.js";
+import {
+  exports_database
+} from "./model-rrbd0qbq.js";
+import {
+  __export
+} from "./model-rvfvac9x.js";
+
+// src/session.ts
+var exports_session2 = {};
+__export(exports_session2, {
+  node: () => node,
+  SyntheticConflictError: () => SyntheticConflictError,
+  SkillNotFoundError: () => SkillNotFoundError,
+  SessionSchema: () => SessionSchema,
+  Session: () => exports_session2,
+  Service: () => Service,
+  PromptConflictError: () => PromptConflictError,
+  NotFoundError: () => NotFoundError,
+  MessageToolIncompleteError: () => MessageToolIncompleteError,
+  MessageNotFoundError: () => MessageNotFoundError,
+  MessageNotAssistantError: () => MessageNotAssistantError,
+  MessageIncompleteError: () => MessageIncompleteError,
+  MessageDecodeError: () => MessageDecodeError,
+  ListInput: () => ListInput,
+  ListAnchor: () => ListAnchor,
+  Info: () => Info,
+  InboxConflictError: () => InboxConflictError,
+  ID: () => ID,
+  DestinationUnavailableError: () => DestinationUnavailableError,
+  DestinationNotFoundError: () => DestinationNotFoundError,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
+  CompactionConflictError: () => CompactionConflictError,
+  BusyError: () => BusyError,
+  AttachmentError: () => AttachmentError
+});
+import { Cause, Effect, Layer, Schema, Context, RcMap, Stream } from "effect";
+import { ListAnchor } from "@opencode-ai/schema/session";
+import { and, desc, eq } from "drizzle-orm";
+import { Model } from "@opencode-ai/schema/model";
+import path from "path";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+var ListInput = exports_store.ListInput;
+class DestinationNotFoundError extends Schema.TaggedError()("Session.DestinationNotFoundError", { directory: AbsolutePath }) {
+}
+
+class DestinationNotDirectoryError extends Schema.TaggedError()("Session.DestinationNotDirectoryError", { directory: AbsolutePath }) {
+}
+
+class DestinationUnavailableError extends Schema.TaggedError()("Session.DestinationUnavailableError", { directory: AbsolutePath }) {
+}
+
+class Service extends Context.Service()("@opencode/Session") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const app = yield* exports_app.Metadata;
+  const database = yield* exports_database.Service;
+  const db = database.db;
+  const bus = yield* exports_bus.Service;
+  const projects = yield* exports_project.Service;
+  const global = yield* Global.Service;
+  const execution = yield* exports_execution.Service;
+  const store = yield* exports_store.Service;
+  const locations = yield* exports_location_service_map.Service;
+  const fs = yield* FSUtil.Service;
+  const jobs = yield* exports_job.Service;
+  const environments = yield* exports_environment.Service;
+  const sessions = yield* exports_session.make((ref) => locations.get(ref));
+  const admission = yield* exports_inbox.Service;
+  const closeTransport = Effect.fn("Session.closeTransport")(function* (session) {
+    const location = exports_location.Ref.make({
+      directory: session.location.directory,
+      workspaceID: session.location.workspaceID
+    });
+    if (!(yield* RcMap.has(locations.rcMap, location)))
+      return;
+    yield* exports_model_transport.Service.use((transport) => transport.close(session.id)).pipe(Effect.provide(locations.get(location)));
+  });
+  const isDurableSessionEvent = Schema.is(SessionEvent.Durable);
+  const result = Service.of({
+    create: Effect.fn("Session.create")(function* (input) {
+      const sessionID = input.id ?? SessionSchema.ID.create();
+      const recorded = yield* store.get(sessionID);
+      if (recorded)
+        return recorded;
+      const parent = input.parentID ? yield* store.get(input.parentID) : undefined;
+      if (input.parentID && parent === undefined)
+        return yield* new NotFoundError({ sessionID: input.parentID });
+      const location = parent?.location ?? input.location;
+      if (location === undefined)
+        return yield* Effect.die(new Error("Session.create requires either location or an existing parentID"));
+      const project = yield* projects.resolve(location.directory);
+      const projected = yield* bus.publish(SessionEvent.Created, {
+        sessionID,
+        slug: Slug.create(),
+        version: app.version,
+        projectID: project.id,
+        parentID: input.parentID,
+        location,
+        subpath: RelativePath.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
+        title: input.title,
+        agent: input.agent,
+        metadata: input.metadata ?? parent?.metadata,
+        model: input.model ? {
+          id: Model.ID.make(input.model.id),
+          providerID: input.model.providerID,
+          variant: input.model.variant
+        } : undefined
+      }, { location }).pipe(Effect.as({ type: "created" }), Effect.catchDefect((defect) => {
+        if (!(defect instanceof exports_projector.SessionAlreadyProjected)) {
+          return Effect.die(defect);
+        }
+        return store.get(sessionID).pipe(Effect.flatMap((session) => session ? Effect.succeed({ type: "existing", session }) : Effect.die(defect)));
+      }));
+      if (projected.type === "existing")
+        return projected.session;
+      return yield* result.get(sessionID).pipe(Effect.orDie);
+    }),
+    fork: Effect.fn("Session.fork")(function* (input) {
+      const parent = yield* result.get(input.sessionID);
+      const boundary = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), input.boundary.type === "before" ? eq(SessionMessageTable.id, input.boundary.messageID) : undefined)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+      if (!boundary && input.boundary.type === "before")
+        return yield* new MessageNotFoundError({
+          sessionID: input.sessionID,
+          messageID: input.boundary.messageID
+        });
+      if (!boundary)
+        return yield* new ForkEmptyError({ sessionID: input.sessionID });
+      const sessionID = SessionSchema.ID.create();
+      const inherited = yield* db.transaction(() => Effect.all({
+        instructions: exports_instruction_state.current(db, parent.id),
+        instructionEntries: exports_instruction_entry.snapshot(db, parent.id)
+      })).pipe(Effect.orDie);
+      yield* bus.publish(SessionEvent.Forked, {
+        sessionID,
+        parentID: parent.id,
+        boundary: { ...input.boundary, messageID: boundary.id },
+        ...inherited
+      });
+      return yield* result.get(sessionID).pipe(Effect.orDie);
+    }),
+    get: (sessionID) => sessions.forSession(sessionID).get(),
+    environment: Effect.fn("Session.environment")(function* (input) {
+      yield* result.get(input.sessionID);
+      if (input.variables !== undefined)
+        yield* environments.set(input.sessionID, input.variables);
+      return yield* environments.get(input.sessionID);
+    }),
+    view: (input) => sessions.forSession(input.sessionID).view(input),
+    remove: Effect.fn("Session.remove")(function* (sessionID) {
+      const session = yield* result.get(sessionID);
+      yield* execution.interrupt(sessionID);
+      yield* execution.awaitIdle(sessionID);
+      yield* closeTransport(session);
+      const children = yield* result.list({ parentID: sessionID });
+      yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true });
+      yield* environments.clear(sessionID);
+      yield* bus.publish(SessionEvent.Deleted, { sessionID });
+      yield* bus.remove(sessionID);
+    }),
+    list: Effect.fn("Session.list")(function* (input) {
+      return { data: yield* store.list(input) };
+    }),
+    messages: Effect.fn("Session.messages")(function* (input) {
+      yield* result.get(input.sessionID);
+      return yield* store.messages(input);
+    }),
+    message: (input) => sessions.forSession(input.sessionID).message(input.messageID),
+    updateMessage: (input) => sessions.forSession(input.sessionID).updateMessage(input),
+    context: Effect.fn("Session.context")(function* (sessionID) {
+      yield* result.get(sessionID);
+      return yield* store.context(sessionID);
+    }),
+    inbox: (sessionID) => sessions.forSession(sessionID).inbox(),
+    cancelInbox: (input) => sessions.forSession(input.sessionID).cancelInbox(input.inboxID),
+    steerInbox: (input) => sessions.forSession(input.sessionID).steerInbox(input.inboxID),
+    queueInbox: (input) => sessions.forSession(input.sessionID).queueInbox(input.inboxID),
+    log: (input) => Stream.unwrap(result.get(input.sessionID).pipe(Effect.as(bus.log({ aggregateID: input.sessionID, after: input.after, follow: input.follow })))).pipe(Stream.filter((item) => exports_bus.isSynced(item) || isDurableSessionEvent(item))),
+    prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
+    generate: Effect.fn("Session.generate")(function* (input) {
+      const session = yield* result.get(input.sessionID);
+      const generate = yield* exports_generate.Service.pipe(Effect.provide(locations.get(session.location)));
+      return yield* generate.generate(input);
+    }),
+    command: Effect.fn("Session.command")(function* (input) {
+      const session = yield* result.get(input.sessionID);
+      const commands = yield* Effect.gen(function* () {
+        const plugins = yield* exports_supervisor_service.Service;
+        yield* plugins.flush;
+        return yield* exports_command.Service;
+      }).pipe(Effect.provide(locations.get(session.location)));
+      const delivery = input.delivery ?? "steer";
+      yield* commands.execute({
+        name: input.command,
+        invocation: {
+          sessionID: input.sessionID,
+          prompt: {
+            text: input.text,
+            files: input.files,
+            agents: input.agents,
+            skills: input.skills
+          },
+          delivery
+        }
+      });
+    }),
+    shell: (input) => sessions.forSession(input.sessionID).shell(input),
+    skill: (input) => sessions.forSession(input.sessionID).skill(input),
+    switchAgent: (input) => sessions.forSession(input.sessionID).switchAgent(input),
+    switchModel: (input) => sessions.forSession(input.sessionID).switchModel(input),
+    rename: (input) => sessions.forSession(input.sessionID).rename(input),
+    move: Effect.fn("Session.move")(function* (input) {
+      const current = yield* result.get(input.sessionID);
+      const value = input.directory.trim();
+      const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value;
+      const directory = AbsolutePath.make(path.resolve(current.location.directory, expanded));
+      const info = yield* fs.stat(directory).pipe(Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (!info)
+        return yield* new DestinationNotFoundError({ directory });
+      if (info.type !== "Directory")
+        return yield* new DestinationNotDirectoryError({ directory });
+      const project = yield* projects.resolve(directory);
+      const payload = {
+        location: exports_location.Ref.make({ directory, workspaceID: input.workspaceID }),
+        projectID: project.id,
+        subpath: RelativePath.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
+      };
+      yield* exports_location.Service.pipe(Effect.provide(locations.get(payload.location)), Effect.scoped, Effect.catchCause((cause) => {
+        if (Cause.hasInterruptsOnly(cause))
+          return Effect.failCause(cause);
+        return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(Effect.andThen(Effect.fail(new DestinationUnavailableError({ directory }))));
+      }));
+      const item = exports_inbox.Item.make({
+        type: "move",
+        payload,
+        delivery: input.delivery ?? "steer"
+      });
+      yield* exports_inbox.serialized(input.sessionID, Effect.gen(function* () {
+        const latest = yield* result.get(input.sessionID);
+        const source = yield* fs.stat(latest.location.directory).pipe(Effect.orElseSucceed(() => {
+          return;
+        }));
+        if (!source || source.type !== "Directory") {
+          const cancellations = (yield* exports_inbox.moveIDs(db, input.sessionID)).map((item2) => [SessionEvent.InboxCancelled, { sessionID: input.sessionID, inboxID: item2.id }]);
+          const moved = [SessionEvent.Moved, { sessionID: input.sessionID, ...payload }];
+          const first = cancellations[0];
+          if (!first)
+            return yield* bus.publish(...moved).pipe(Effect.asVoid);
+          return yield* bus.publishAll([first, ...cancellations.slice(1), moved]);
+        }
+        yield* admission.admit({
+          id: SessionMessage.ID.create(),
+          sessionID: input.sessionID,
+          item
+        }).pipe(Effect.orDie);
+      }));
+      yield* execution.wake(input.sessionID);
+    }),
+    compact: (input) => sessions.forSession(input.sessionID).compact(input),
+    wait: (sessionID) => sessions.forSession(sessionID).wait(),
+    active: execution.active,
+    background: Effect.fn("Session.background")(function* (sessionID) {
+      yield* result.get(sessionID);
+      const backgrounded = yield* jobs.backgroundAll({ sessionID });
+      if (backgrounded.length === 0)
+        return;
+      yield* result.synthetic({
+        sessionID,
+        text: [
+          "User requested that active blocking work be moved to the background.",
+          "",
+          "Backgrounded work:",
+          ...backgrounded.map((job) => `- ${job.type}: ${job.title && job.title.length > 0 ? job.title : job.id}`),
+          "",
+          "The backgrounded work is still unfinished. Move on to other work if you can. If there is nothing else useful to do, finish your response. Do not wait, sleep, poll, or report the backgrounded work as complete until a later completion notification is added to the conversation."
+        ].join(`
+`)
+      }).pipe(Effect.catchTag("Session.SyntheticConflictError", Effect.die));
+    }),
+    resume: (sessionID) => sessions.forSession(sessionID).resume(),
+    synthetic: (input) => sessions.forSession(input.sessionID).synthetic(input),
+    interrupt: (sessionID, options) => sessions.forSession(sessionID).interrupt(options),
+    revert: {
+      stage: (input) => sessions.forSession(input.sessionID).revert.stage(input),
+      clear: (sessionID) => sessions.forSession(sessionID).revert.clear(),
+      commit: (sessionID) => sessions.forSession(sessionID).revert.commit()
+    }
+  });
+  return result;
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_job.node,
+    exports_environment.node,
+    exports_database.node,
+    exports_bus.node,
+    exports_project.node,
+    exports_execution.node,
+    exports_store.node,
+    exports_inbox.node,
+    exports_location_service_map.node,
+    exports_projector.node,
+    FSUtil.node,
+    Global.node,
+    exports_app.node
+  ]
+});
+
+export { ListAnchor, ListInput, DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError, Service, node, exports_session2 as exports_session };

package/dist/chunks/{project-qxsjpy8c.js → model-pywyq33w.js}

@@ -1,21 +1,21 @@
 import {
   exports_repository_cache
-} from "./project-eeta29b7.js";
+} from "./model-k828h0dz.js";
 import {
   exports_repository
-} from "./project-y198y2ra.js";
-import {
-  exports_state
-} from "./project-x89rah0x.js";
+} from "./model-y198y2ra.js";
 import {
   AbsolutePath
-} from "./project-j07kk359.js";
+} from "./model-j07kk359.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./model-vwkfg4n5.js";
+import {
+  exports_state
+} from "./model-x89rah0x.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/reference.ts
 var exports_reference = {};

package/dist/chunks/{project-jcsmb80n.js → model-pz1bk8bf.js}

@@ -1,9 +1,9 @@
 import {
   exports_environment1 as exports_environment
-} from "./project-0xzcm754.js";
+} from "./model-bach7bae.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/mcp/stdio.ts
 var exports_stdio = {};

package/dist/chunks/{project-n79xa5zf.js → model-pzatkvvd.js}

@@ -1,19 +1,19 @@
-import {
-  exports_state
-} from "./project-x89rah0x.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./model-xy3y21dp.js";
 import {
   exports_git
-} from "./project-kt491qp2.js";
+} from "./model-dyj7wa6j.js";
 import {
   AbsolutePath,
   RelativePath
-} from "./project-j07kk359.js";
+} from "./model-j07kk359.js";
+import {
+  exports_state
+} from "./model-x89rah0x.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/snapshot.ts
 var exports_snapshot = {};

package/dist/chunks/{project-27gfv7vw.js → model-q2p1j5t8.js}

@@ -1,12 +1,12 @@
-import {
-  exports_state
-} from "./project-x89rah0x.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./model-xy3y21dp.js";
+import {
+  exports_state
+} from "./model-x89rah0x.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/formatter.ts
 var exports_formatter = {};

package/dist/chunks/{project-q606pcse.js → model-q606pcse.js}

@@ -1,13 +1,13 @@
 import {
   ProjectTable
-} from "./project-c8ya26sa.js";
+} from "./model-c8ya26sa.js";
 import {
   directoryColumn,
   pathColumn
-} from "./project-zbqqnp0n.js";
+} from "./model-zbqqnp0n.js";
 import {
   Timestamps
-} from "./project-sem2g21k.js";
+} from "./model-sem2g21k.js";
 
 // src/session/sql.ts
 import { sqliteTable, text, integer, index, primaryKey, real, uniqueIndex } from "drizzle-orm/sqlite-core";

package/dist/chunks/{project-m55whf0h.js → model-q66tjefk.js}

@@ -1,9 +1,9 @@
 import {
   exports_provider
-} from "./project-krsqcmnj.js";
+} from "./model-fex42j86.js";
 import {
   __require
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/plugin/provider/amazon-bedrock.ts
 import { Effect } from "effect";

package/dist/chunks/model-q8ep280n.js

@@ -0,0 +1,33 @@
+import {
+  exports_supervisor
+} from "./model-z8cvg98n.js";
+import {
+  exports_revert
+} from "./model-0r5t5x9k.js";
+import {
+  exports_snapshot
+} from "./model-pzatkvvd.js";
+import {
+  exports_bus
+} from "./model-vwkfg4n5.js";
+import {
+  exports_database
+} from "./model-rrbd0qbq.js";
+import {
+  __export
+} from "./model-rvfvac9x.js";
+
+// src/session/revert-node.ts
+var exports_revert_node = {};
+__export(exports_revert_node, {
+  node: () => node,
+  SessionRevertNode: () => exports_revert_node
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var node = makeLocationNode({
+  service: exports_revert.Service,
+  layer: exports_revert.layer,
+  deps: [exports_database.node, exports_bus.node, exports_supervisor.node, exports_snapshot.node]
+});
+
+export { node, exports_revert_node };

package/dist/chunks/{project-tpx671s8.js → model-q9vfn5x4.js}

@@ -1,9 +1,9 @@
 import {
   exports_integration
-} from "./project-pm64n062.js";
+} from "./model-19vx63bj.js";
 import {
   exports_provider
-} from "./project-krsqcmnj.js";
+} from "./model-fex42j86.js";
 
 // src/plugin/provider/llmgateway.ts
 import { Effect } from "effect";

package/dist/chunks/{project-qe0d689s.js → model-qe0d689s.js}

@@ -1,9 +1,9 @@
 import {
   createProviderPlugin
-} from "./project-0zz82cjq.js";
+} from "./model-0zz82cjq.js";
 import {
   __require
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/plugin/provider/cohere.ts
 var CoherePlugin = createProviderPlugin({

package/dist/chunks/{project-1cvksg4c.js → model-qert5162.js}

@@ -1,10 +1,10 @@
 import {
   exports_state
-} from "./project-x89rah0x.js";
+} from "./model-x89rah0x.js";
 import {
   __export,
   __require
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/image.ts
 var exports_image = {};

package/dist/chunks/{project-r67bz3x8.js → model-qgqfrqw3.js}

@@ -1,24 +1,24 @@
 import {
-  SQLiteEffectRelationalQueryBuilder
-} from "./project-bxdhjb3y.js";
+  SQLiteEffectCountBuilder
+} from "./model-0f48qthw.js";
 import {
-  SQLiteEffectInsertBuilder
-} from "./project-tcptxgyq.js";
+  SQLiteEffectDeleteBase
+} from "./model-vcwr2vpf.js";
 import {
-  SQLiteEffectCountBuilder
-} from "./project-0f48qthw.js";
+  SQLiteEffectRaw
+} from "./model-s7whb9gt.js";
 import {
-  SQLiteEffectSelectBuilder
-} from "./project-wbkt8qpj.js";
+  SQLiteEffectRelationalQueryBuilder
+} from "./model-bxdhjb3y.js";
 import {
   SQLiteEffectUpdateBuilder
-} from "./project-zxcy6vhn.js";
+} from "./model-j0feex7e.js";
 import {
-  SQLiteEffectRaw
-} from "./project-s7whb9gt.js";
+  SQLiteEffectSelectBuilder
+} from "./model-wbkt8qpj.js";
 import {
-  SQLiteEffectDeleteBase
-} from "./project-vcwr2vpf.js";
+  SQLiteEffectInsertBuilder
+} from "./model-hgr9y616.js";
 
 // src/database/drizzle/sqlite-core/effect/db.ts
 import { Effect } from "effect";

package/dist/chunks/{project-9nk9mkqn.js → model-qhdy39gn.js}

@@ -1,12 +1,12 @@
 import {
   exports_skill
-} from "./project-p2h03eta.js";
+} from "./model-9w1y4hdv.js";
 import {
   exports_instructions
-} from "./project-ec8vrfw5.js";
+} from "./model-ec8vrfw5.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/skill/instructions.ts
 var exports_instructions2 = {};