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

package/dist/chunks/{schema-rrqa2v85.js → event-logger-ywes9ebt.js}

@@ -1,95 +1,111 @@
 import {
-  exports_instructions as exports_instructions2
-} from "./schema-g70ev3a2.js";
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
 import {
-  exports_model_request
-} from "./schema-yp4wxmaw.js";
+  ID18,
+  Service78,
+  node83
+} from "./event-logger-8ab07kvc.js";
 import {
-  exports_model
-} from "./schema-ync59mnp.js";
+  Service67,
+  node72
+} from "./event-logger-hdqmeh3c.js";
 import {
-  exports_instruction_entry
-} from "./schema-p0ye3rhn.js";
+  combine2
+} from "./event-logger-1z80kc63.js";
 import {
-  exports_instructions as exports_instructions3
-} from "./schema-ng85ggsa.js";
+  make15
+} from "./event-logger-5ssd2kfs.js";
 import {
-  exports_instructions as exports_instructions4
-} from "./schema-db3nafyd.js";
+  Service42,
+  node45
+} from "./event-logger-m3eazqpa.js";
 import {
-  exports_builtins
-} from "./schema-z0nmzarz.js";
+  Service75,
+  node80
+} from "./event-logger-00s3pqt3.js";
 import {
-  exports_instructions as exports_instructions5
-} from "./schema-zwp7atcb.js";
+  Service34,
+  node37
+} from "./event-logger-5mp6hy2y.js";
 import {
-  exports_mcp
-} from "./schema-e7nnc03a.js";
+  AgentNotFoundError2
+} from "./event-logger-n6wnzfnt.js";
 import {
-  exports_tool
-} from "./schema-y71jz153.js";
+  entriesForRunner2
+} from "./event-logger-825xseqb.js";
 import {
-  exports_store
-} from "./schema-a4wk7wxx.js";
+  Service72,
+  node77
+} from "./event-logger-xf2wyvfy.js";
 import {
-  exports_history
-} from "./schema-ctegtqnq.js";
+  Service43,
+  node46
+} from "./event-logger-b84bthst.js";
 import {
-  AgentNotFoundError
-} from "./schema-2sqw2jjm.js";
+  Service36,
+  node39
+} from "./event-logger-9r3tzwf8.js";
 import {
-  exports_agent
-} from "./schema-p6fb92cp.js";
+  Service31,
+  node34
+} from "./event-logger-dzfg11yk.js";
 import {
-  exports_catalog
-} from "./schema-32ypdbhb.js";
+  Service32,
+  node35
+} from "./event-logger-mp43ttd6.js";
 import {
-  exports_instruction_discovery
-} from "./schema-7480bqmm.js";
+  Service35,
+  node38
+} from "./event-logger-f03pjn97.js";
 import {
-  exports_instructions
-} from "./schema-c54e84vp.js";
+  Service26,
+  node31
+} from "./event-logger-92g85qkt.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  Service38,
+  node41
+} from "./event-logger-0v1ejg55.js";
 import {
-  exports_database
-} from "./schema-8scqw7rh.js";
+  Service37,
+  node40
+} from "./event-logger-amahfvfq.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/session/context.ts
 var exports_context = {};
 __export(exports_context, {
-  Service: () => Service,
+  Service: () => Service25,
   SessionContext: () => exports_context,
-  node: () => node
+  node: () => node30
 });
 import { Model } from "@opencode-ai/schema/model";
 import { Context, Effect, Layer } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-class Service extends Context.Service()("@opencode/SessionContext") {
+class Service25 extends Context.Service()("@opencode/SessionContext") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const agents = yield* exports_agent.Service;
-  const builtins = yield* exports_builtins.Service;
-  const catalog = yield* exports_catalog.Service;
-  const db = (yield* exports_database.Service).db;
-  const discovery = yield* exports_instruction_discovery.Service;
-  const entries = yield* exports_instruction_entry.Service;
-  const location = yield* exports_location.Service;
-  const mcpInstructions = yield* exports_instructions3.Service;
-  const mcpTools = yield* exports_mcp.Service;
-  const models = yield* exports_model.Service;
-  const modelRequests = yield* exports_model_request.Service;
-  const referenceInstructions = yield* exports_instructions4.Service;
-  const skillInstructions = yield* exports_instructions5.Service;
-  const store = yield* exports_store.Service;
-  const registry = yield* exports_tool.Service;
+var layer = Layer.effect(Service25, Effect.gen(function* () {
+  const agents = yield* Service78;
+  const builtins = yield* Service34;
+  const catalog = yield* Service67;
+  const db = (yield* Service80).db;
+  const discovery = yield* Service42;
+  const entries = yield* Service26;
+  const location = yield* Service75;
+  const mcpInstructions = yield* Service31;
+  const mcpTools = yield* Service36;
+  const models = yield* Service37;
+  const modelRequests = yield* Service38;
+  const referenceInstructions = yield* Service32;
+  const skillInstructions = yield* Service35;
+  const store = yield* Service72;
+  const registry = yield* Service43;
   const resolveModel = (session) => models.resolve(session, catalog.model.available);
   const selectTitle = Effect.fn("SessionContext.selectTitle")(function* (session) {
-    const agent = yield* agents.get(exports_agent.ID.make("title"));
+    const agent = yield* agents.get(ID18.make("title"));
     if (!agent)
       return;
     const primary = yield* resolveModel(session).pipe(Effect.orElseSucceed(() => {
@@ -127,7 +143,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     yield* mcpTools.flush;
     const agent = yield* agents.select(session.agent);
     if (!agent.info)
-      return yield* new AgentNotFoundError({ sessionID: session.id, agent: session.agent ?? agent.id });
+      return yield* new AgentNotFoundError2({ sessionID: session.id, agent: session.agent ?? agent.id });
     const loaded = yield* Effect.all({
       tools: registry.snapshot(agent.info.permissions),
       builtins: builtins.load(sessionID),
@@ -140,9 +156,9 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     return {
       session,
       agent: { ...agent, info: agent.info },
-      instructions: exports_instructions.combine([
+      instructions: combine2([
         loaded.builtins,
-        exports_instructions2.make(loaded.tools.codeModeCatalog),
+        make15(loaded.tools.codeModeCatalog),
         loaded.discovery,
         loaded.skills,
         loaded.references,
@@ -154,7 +170,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   const load = Effect.fn("SessionContext.load")(function* (selection) {
     const model = yield* resolveModel(selection.session);
-    const history = yield* exports_history.entriesForRunner(db, selection.session.id, selection.instructions);
+    const history = yield* entriesForRunner2(db, selection.session.id, selection.instructions);
     return {
       session: selection.session,
       agent: selection.agent,
@@ -164,29 +180,29 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       tools: selection.tools
     };
   });
-  return Service.of({ select, load, resolveModel, selectTitle, prepare: modelRequests.prepare });
+  return Service25.of({ select, load, resolveModel, selectTitle, prepare: modelRequests.prepare });
 }));
 var MINIMAL_REASONING_VARIANTS = ["none", "minimal", "low"].map((id) => Model.VariantID.make(id));
-var node = makeLocationNode({
-  service: Service,
+var node30 = makeLocationNode({
+  service: Service25,
   layer,
   deps: [
-    exports_agent.node,
-    exports_catalog.node,
-    exports_database.node,
-    exports_builtins.node,
-    exports_instruction_discovery.node,
-    exports_instruction_entry.node,
-    exports_location.node,
-    exports_instructions3.node,
-    exports_mcp.node,
-    exports_instructions4.node,
-    exports_model.node,
-    exports_model_request.node,
-    exports_store.node,
-    exports_instructions5.node,
-    exports_tool.node
+    node83,
+    node72,
+    node85,
+    node37,
+    node45,
+    node31,
+    node80,
+    node34,
+    node39,
+    node35,
+    node40,
+    node41,
+    node77,
+    node38,
+    node46
   ]
 });
 
-export { Service, node, exports_context };
+export { Service25, node30, exports_context };

package/dist/chunks/{schema-1nf5m1zv.js → event-logger-yzjhj2th.js}

@@ -1,64 +1,71 @@
 import {
-  exports_store
-} from "./schema-a4wk7wxx.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_error
-} from "./schema-2sqw2jjm.js";
+  Service75,
+  node80
+} from "./event-logger-00s3pqt3.js";
 import {
-  exports_saved
-} from "./schema-5j084t57.js";
+  ID18,
+  Service78,
+  node83
+} from "./event-logger-8ab07kvc.js";
 import {
-  exports_wildcard
-} from "./schema-edxnhgvj.js";
+  NotFoundError9
+} from "./event-logger-n6wnzfnt.js";
 import {
-  exports_agent
-} from "./schema-p6fb92cp.js";
+  Service72,
+  node77
+} from "./event-logger-xf2wyvfy.js";
 import {
-  exports_hooks
-} from "./schema-xws7arpm.js";
+  match2
+} from "./event-logger-y1fvbwt7.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  Service73,
+  node78
+} from "./event-logger-9xybsmp2.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  Service74,
+  node79
+} from "./event-logger-t00n1yfv.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/permission.ts
-var exports_permission = {};
-__export(exports_permission, {
-  AskResult: () => AskResult,
-  AssertInput: () => AssertInput,
-  BlockedError: () => BlockedError,
-  CorrectedError: () => CorrectedError,
-  DeclinedError: () => DeclinedError,
+var exports_permission2 = {};
+__export(exports_permission2, {
+  AskResult: () => AskResult2,
+  AssertInput: () => AssertInput2,
+  BlockedError: () => BlockedError2,
+  CorrectedError: () => CorrectedError2,
+  DeclinedError: () => DeclinedError2,
   Effect: () => PermissionEffect,
-  Event: () => Event,
-  ID: () => ID,
-  NotFoundError: () => NotFoundError,
-  Permission: () => exports_permission,
-  Reply: () => Reply,
-  ReplyInput: () => ReplyInput,
-  Request: () => Request,
-  Rule: () => Rule,
-  Ruleset: () => Ruleset,
-  Service: () => Service,
-  Source: () => Source,
-  evaluate: () => evaluate,
-  merge: () => merge,
-  node: () => node
+  Event: () => Event18,
+  ID: () => ID13,
+  NotFoundError: () => NotFoundError8,
+  Permission: () => exports_permission2,
+  Reply: () => Reply3,
+  ReplyInput: () => ReplyInput2,
+  Request: () => Request3,
+  Rule: () => Rule3,
+  Ruleset: () => Ruleset2,
+  Service: () => Service71,
+  Source: () => Source5,
+  evaluate: () => evaluate2,
+  merge: () => merge2,
+  node: () => node76
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Deferred, Effect, Layer, Schema } from "effect";
 import { Permission } from "@opencode-ai/schema/permission";
-import { Rule, Ruleset } from "@opencode-ai/schema/permission";
-import { Event } from "@opencode-ai/schema/permission";
+import { Rule as Rule3, Ruleset as Ruleset2 } from "@opencode-ai/schema/permission";
+import { Event as Event18 } from "@opencode-ai/schema/permission";
 var PermissionEffect = Permission.Effect;
 var missingAgentPermissions = [{ action: "*", resource: "*", effect: "deny" }];
-var ID = Permission.ID;
-var Source = Permission.Source;
+var ID13 = Permission.ID;
+var Source5 = Permission.Source;
 var RequestFields = {
   sessionID: Permission.Request.fields.sessionID,
   action: Permission.Request.fields.action,
@@ -67,32 +74,32 @@ var RequestFields = {
   metadata: Permission.Request.fields.metadata,
   source: Permission.Request.fields.source
 };
-var Request = Permission.Request;
-var Reply = Permission.Reply;
-var AssertInput = Schema.Struct({
-  id: ID.pipe(Schema.optional),
+var Request3 = Permission.Request;
+var Reply3 = Permission.Reply;
+var AssertInput2 = Schema.Struct({
+  id: ID13.pipe(Schema.optional),
   ...RequestFields,
-  agent: exports_agent.ID.pipe(Schema.optional)
+  agent: ID18.pipe(Schema.optional)
 }).annotate({ identifier: "Permission.AssertInput" });
-var ReplyInput = Schema.Struct({
-  requestID: ID,
-  reply: Reply,
+var ReplyInput2 = Schema.Struct({
+  requestID: ID13,
+  reply: Reply3,
   message: Schema.String.pipe(Schema.optional)
 }).annotate({ identifier: "Permission.ReplyInput" });
-var AskResult = Schema.Struct({
-  id: ID,
+var AskResult2 = Schema.Struct({
+  id: ID13,
   effect: Permission.Effect
 }).annotate({ identifier: "Permission.AskResult" });
 
-class DeclinedError extends Schema.TaggedError()("Permission.DeclinedError", {}) {
+class DeclinedError2 extends Schema.TaggedError()("Permission.DeclinedError", {}) {
 }
 
-class CorrectedError extends Schema.TaggedError()("Permission.CorrectedError", {
+class CorrectedError2 extends Schema.TaggedError()("Permission.CorrectedError", {
   feedback: Schema.String
 }) {
 }
 
-class BlockedError extends Schema.TaggedError()("Permission.BlockedError", {
+class BlockedError2 extends Schema.TaggedError()("Permission.BlockedError", {
   rules: Permission.Ruleset,
   permission: Schema.String,
   resources: Schema.Array(Schema.String),
@@ -103,32 +110,32 @@ class BlockedError extends Schema.TaggedError()("Permission.BlockedError", {
   }
 }
 
-class NotFoundError extends Schema.TaggedError()("Permission.NotFoundError", {
-  requestID: ID
+class NotFoundError8 extends Schema.TaggedError()("Permission.NotFoundError", {
+  requestID: ID13
 }) {
 }
-function evaluate(action, resource, ...rulesets) {
-  return rulesets.flat().findLast((rule) => exports_wildcard.match(action, rule.action) && exports_wildcard.match(resource, rule.resource)) ?? {
+function evaluate2(action, resource, ...rulesets) {
+  return rulesets.flat().findLast((rule) => match2(action, rule.action) && match2(resource, rule.resource)) ?? {
     action,
     resource: "*",
     effect: "ask"
   };
 }
-function merge(...rulesets) {
+function merge2(...rulesets) {
   return rulesets.flat();
 }
 
-class Service extends Context.Service()("@opencode/Permission") {
+class Service71 extends Context.Service()("@opencode/Permission") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const location = yield* exports_location.Service;
-  const agents = yield* exports_agent.Service;
-  const sessions = yield* exports_store.Service;
-  const saved = yield* exports_saved.Service;
-  const hooks = yield* exports_hooks.Service;
+var layer = Layer.effect(Service71, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const location = yield* Service75;
+  const agents = yield* Service78;
+  const sessions = yield* Service72;
+  const saved = yield* Service73;
+  const hooks = yield* Service74;
   const pending = new Map;
-  yield* Effect.addFinalizer(() => Effect.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new DeclinedError), {
+  yield* Effect.addFinalizer(() => Effect.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new DeclinedError2), {
     discard: true
   }).pipe(Effect.ensuring(Effect.sync(() => {
     pending.clear();
@@ -143,22 +150,22 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const configured = Effect.fnUntraced(function* (sessionID, agentID) {
     const session = yield* sessions.get(sessionID);
     if (!session)
-      return yield* new exports_error.NotFoundError({ sessionID });
+      return yield* new NotFoundError9({ sessionID });
     const agent = yield* agents.resolve(agentID ?? session.agent);
     return agent?.permissions ?? missingAgentPermissions;
   });
   function denied(input, rules) {
-    return input.resources.some((resource) => evaluate(input.action, resource, rules).effect === "deny");
+    return input.resources.some((resource) => evaluate2(input.action, resource, rules).effect === "deny");
   }
   function relevant(input, rules) {
-    return rules.filter((rule) => exports_wildcard.match(input.action, rule.action));
+    return rules.filter((rule) => match2(input.action, rule.action));
   }
   const evaluateInput = Effect.fnUntraced(function* (input) {
     const rules = yield* configured(input.sessionID, input.agent);
     if (denied(input, rules))
       return { effect: "deny", rules };
     const all = [...rules, ...yield* savedRules()];
-    const effects = input.resources.map((resource) => evaluate(input.action, resource, all).effect);
+    const effects = input.resources.map((resource) => evaluate2(input.action, resource, all).effect);
     const effect = effects.includes("ask") ? "ask" : "allow";
     const event = yield* hooks.trigger("permission", "evaluate", {
       sessionID: input.sessionID,
@@ -173,7 +180,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   function request(input, message) {
     return {
-      id: input.id ?? ID.create(),
+      id: input.id ?? ID13.create(),
       sessionID: input.sessionID,
       action: input.action,
       resources: input.resources,
@@ -183,13 +190,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       message
     };
   }
-  const create = (request2, agent) => Effect.uninterruptible(Effect.gen(function* () {
+  const create = (request, agent) => Effect.uninterruptible(Effect.gen(function* () {
     const deferred = yield* Deferred.make();
-    const item = { request: request2, agent, deferred };
-    if (pending.has(request2.id))
-      return yield* Effect.die(new Error(`Duplicate pending permission ID: ${request2.id}`));
-    pending.set(request2.id, item);
-    yield* bus.publish(Permission.Event.Asked, request2).pipe(Effect.onError(() => Effect.sync(() => pending.delete(request2.id))));
+    const item = { request, agent, deferred };
+    if (pending.has(request.id))
+      return yield* Effect.die(new Error(`Duplicate pending permission ID: ${request.id}`));
+    pending.set(request.id, item);
+    yield* bus.publish(Permission.Event.Asked, request).pipe(Effect.onError(() => Effect.sync(() => pending.delete(request.id))));
     return item;
   }));
   const ask = Effect.fn("Permission.ask")(function* (input) {
@@ -203,7 +210,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const result = yield* evaluateInput(input);
     return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
       if (result.effect === "deny") {
-        return yield* new BlockedError({
+        return yield* new BlockedError2({
           rules: relevant(input, result.rules),
           permission: input.action,
           resources: input.resources,
@@ -221,14 +228,14 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const reply = Effect.fn("Permission.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
     const existing = pending.get(input.requestID);
     if (!existing)
-      return yield* new NotFoundError({ requestID: input.requestID });
+      return yield* new NotFoundError8({ requestID: input.requestID });
     yield* bus.publish(Permission.Event.Replied, {
       sessionID: existing.request.sessionID,
       requestID: existing.request.id,
       reply: input.reply
     });
     if (input.reply === "reject") {
-      yield* Deferred.fail(existing.deferred, input.message ? new CorrectedError({ feedback: input.message }) : new DeclinedError);
+      yield* Deferred.fail(existing.deferred, input.message ? new CorrectedError2({ feedback: input.message }) : new DeclinedError2);
       pending.delete(input.requestID);
       for (const [id, item] of pending) {
         if (item.request.sessionID !== existing.request.sessionID)
@@ -238,7 +245,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           requestID: item.request.id,
           reply: "reject"
         });
-        yield* Deferred.fail(item.deferred, new DeclinedError);
+        yield* Deferred.fail(item.deferred, new DeclinedError2);
         pending.delete(id);
       }
       return;
@@ -274,14 +281,14 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     return pending.get(id)?.request;
   });
   const forSession = Effect.fn("Permission.forSession")(function* (sessionID) {
-    return Array.from(pending.values(), (item) => item.request).filter((request2) => request2.sessionID === sessionID);
+    return Array.from(pending.values(), (item) => item.request).filter((request) => request.sessionID === sessionID);
   });
-  return Service.of({ ask, assert, reply, get, forSession, list });
+  return Service71.of({ ask, assert, reply, get, forSession, list });
 }));
-var node = makeLocationNode({
-  service: Service,
+var node76 = makeLocationNode({
+  service: Service71,
   layer,
-  deps: [exports_bus.node, exports_location.node, exports_agent.node, exports_store.node, exports_saved.node, exports_hooks.node]
+  deps: [node84, node80, node83, node77, node78, node79]
 });
 
-export { PermissionEffect, ID, Source, Request, Reply, AssertInput, ReplyInput, AskResult, DeclinedError, CorrectedError, BlockedError, NotFoundError, evaluate, merge, Service, node, exports_permission, Rule, Ruleset, Event };
+export { PermissionEffect, ID13, Source5, Request3, Reply3, AssertInput2, ReplyInput2, AskResult2, DeclinedError2, CorrectedError2, BlockedError2, NotFoundError8, evaluate2, merge2, Service71, node76, exports_permission2, Rule3, Ruleset2, Event18 };

package/dist/chunks/{schema-g4r9xws8.js → event-logger-z1g5cset.js}

@@ -1,44 +1,44 @@
 import {
-  migrations
-} from "./schema-078tha6v.js";
+  migrations2
+} from "./event-logger-pre7wgsd.js";
 import {
   schema_gen_default
-} from "./schema-39ktntah.js";
+} from "./event-logger-twg0f83k.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/database/migration.ts
 var exports_migration = {};
 __export(exports_migration, {
   DatabaseMigration: () => exports_migration,
-  apply: () => apply,
-  applyOnly: () => applyOnly
+  apply: () => apply3,
+  applyOnly: () => applyOnly2
 });
 import { sql } from "drizzle-orm";
 import { Effect } from "effect";
 import { supportsForeignKeyToggle } from "#sqlite";
-function apply(db) {
+function apply3(db) {
   return Effect.gen(function* () {
     const tables = yield* db.all(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND substr(name, 1, 1) <> '_'`);
     if (tables.some((table) => table.name === "session" || table.name === "session_v2"))
-      return yield* applyOnly(db, migrations);
+      return yield* applyOnly2(db, migrations2);
     if (tables.length > 0)
       return yield* Effect.die(new Error("Database is not empty and has no session table"));
     const started = Date.now();
-    yield* Effect.logInfo("database schema bootstrap started", { migrations: migrations.length });
+    yield* Effect.logInfo("database schema bootstrap started", { migrations: migrations2.length });
     yield* db.transaction((tx) => Effect.gen(function* () {
       yield* schema_gen_default.up(tx);
       yield* tx.run(sql`CREATE TABLE ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
-      yield* Effect.forEach(migrations, (migration) => tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`));
+      yield* Effect.forEach(migrations2, (migration) => tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`));
     }));
     yield* Effect.logInfo("database schema bootstrap completed", {
-      migrations: migrations.length,
+      migrations: migrations2.length,
       durationMs: Date.now() - started
     });
   });
 }
-function applyOnly(db, input) {
+function applyOnly2(db, input) {
   return Effect.gen(function* () {
     yield* db.run(sql`CREATE TABLE IF NOT EXISTS ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
     let completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
@@ -78,15 +78,15 @@ function applyOnly(db, input) {
         continue;
       const started = Date.now();
       yield* Effect.logInfo("database migration started", { migration: migration.id });
-      const apply2 = db.transaction((tx) => Effect.gen(function* () {
+      const apply = db.transaction((tx) => Effect.gen(function* () {
         yield* migration.up(tx);
         yield* tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`);
       }));
-      const run = migration.foreignKeys !== false ? apply2 : Effect.gen(function* () {
+      const run = migration.foreignKeys !== false ? apply : Effect.gen(function* () {
         const relaxForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = OFF`) : db.run(sql`PRAGMA defer_foreign_keys = ON`);
         const restoreForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = ON`) : Effect.void;
         yield* relaxForeignKeys;
-        yield* apply2.pipe(Effect.ensuring(restoreForeignKeys.pipe(Effect.orDie)));
+        yield* apply.pipe(Effect.ensuring(restoreForeignKeys.pipe(Effect.orDie)));
       });
       yield* run.pipe(Effect.tapError((error) => Effect.logError("database migration failed", {
         migration: migration.id,
@@ -101,4 +101,4 @@ function applyOnly(db, input) {
   });
 }
 
-export { apply, applyOnly, exports_migration };
+export { apply3, applyOnly2, exports_migration };