@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-34gk67xh.js

@@ -0,0 +1,61 @@
+import {
+  useragent2
+} from "./worktree-xrd4famk.js";
+import {
+  ID12
+} from "./worktree-9qn3qky1.js";
+
+// src/plugin/provider/gitlab.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var GitLabPlugin2 = define({
+  id: "opencode.provider.gitlab",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "gitlab-ai-provider")
+        return;
+      const mod = yield* Effect.promise(() => import("gitlab-ai-provider"));
+      evt.sdk = mod.createGitLab({
+        ...evt.options,
+        instanceUrl: typeof evt.options.instanceUrl === "string" ? evt.options.instanceUrl : process.env.GITLAB_INSTANCE_URL ?? "https://gitlab.com",
+        apiKey: typeof evt.options.apiKey === "string" ? evt.options.apiKey : process.env.GITLAB_TOKEN,
+        aiGatewayHeaders: {
+          "User-Agent": `${useragent2(ctx.app)} gitlab-ai-provider/${mod.VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`,
+          "anthropic-beta": "context-1m-2025-08-07",
+          ...evt.options.aiGatewayHeaders
+        },
+        featureFlags: {
+          duo_agent_platform_agentic_chat: true,
+          duo_agent_platform: true,
+          ...evt.options.featureFlags
+        }
+      });
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID12.gitlab)
+        return;
+      const featureFlags = typeof evt.options.featureFlags === "object" && evt.options.featureFlags ? evt.options.featureFlags : {};
+      const id = evt.model.modelID ?? evt.model.id;
+      if (id.startsWith("duo-workflow-")) {
+        const gitlab = yield* Effect.promise(() => import("gitlab-ai-provider"));
+        const workflowRef = typeof evt.model.settings?.workflowRef === "string" ? evt.model.settings.workflowRef : undefined;
+        const workflowDefinition = typeof evt.model.settings?.workflowDefinition === "string" ? evt.model.settings.workflowDefinition : undefined;
+        const language = evt.sdk.workflowChat(gitlab.isWorkflowModel(id) ? id : "duo-workflow", {
+          featureFlags,
+          workflowDefinition
+        });
+        if (workflowRef)
+          language.selectedModelRef = workflowRef;
+        evt.language = language;
+        return;
+      }
+      evt.language = evt.sdk.agenticChat(id, {
+        aiGatewayHeaders: evt.options.aiGatewayHeaders,
+        featureFlags
+      });
+    }));
+  })
+});
+
+export { GitLabPlugin2 };

package/dist/chunks/worktree-359p4xyc.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260823191254_nullable_workspace_binding.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260823191254_nullable_workspace_binding",
+  foreignKeys: false,
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`__new_workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`INSERT INTO \`__new_workspace\`(\`id\`, \`provider\`, \`binding\`, \`created_at\`, \`last_used_at\`) SELECT \`id\`, \`provider\`, \`binding\`, \`created_at\`, \`last_used_at\` FROM \`workspace\`;`);
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_workspace\` RENAME TO \`workspace\`;`);
+    });
+  }
+};
+var _20260823191254_nullable_workspace_binding_default = migration;
+
+export { _20260823191254_nullable_workspace_binding_default };

package/dist/chunks/worktree-3asan66x.js

@@ -0,0 +1,19 @@
+// src/github-copilot/responses/map-openai-responses-finish-reason.ts
+function mapOpenAIResponseFinishReason2({
+  finishReason,
+  hasFunctionCall
+}) {
+  switch (finishReason) {
+    case undefined:
+    case null:
+      return hasFunctionCall ? "tool-calls" : "stop";
+    case "max_output_tokens":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return hasFunctionCall ? "tool-calls" : "other";
+  }
+}
+
+export { mapOpenAIResponseFinishReason2 };

package/dist/chunks/worktree-3bgy0jaw.js

@@ -0,0 +1,131 @@
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  SessionTable2,
+  SessionMessageTable2
+} from "./worktree-5c4hm403.js";
+import {
+  decodeMessageRow2,
+  load3
+} from "./worktree-wpdyyhk3.js";
+import {
+  fromRow2
+} from "./worktree-p72z5xx6.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/store.ts
+var exports_store = {};
+__export(exports_store, {
+  ListInput: () => ListInput5,
+  Service: () => Service72,
+  SessionStore: () => exports_store,
+  node: () => node77
+});
+import { and, asc, desc, eq, gt, isNotNull, isNull, like, lt, notInArray, or, sql } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Project } from "@opencode/schema/project";
+import { Workspace } from "@opencode/schema/workspace";
+import { AbsolutePath, PositiveInt, RelativePath } from "@opencode/schema/schema";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Session } from "@opencode/schema/session";
+var ListInputBase = {
+  workspaceID: Workspace.ID.pipe(Schema.optional),
+  search: Schema.String.pipe(Schema.optional),
+  limit: PositiveInt.pipe(Schema.optional),
+  order: Schema.Literals(["asc", "desc"]).pipe(Schema.optional),
+  parentID: Schema.NullOr(Session.ID).pipe(Schema.optional),
+  anchor: Session.ListAnchor.pipe(Schema.optional)
+};
+var ListDirectoryInput = Schema.Struct({
+  ...ListInputBase,
+  directory: AbsolutePath
+});
+var ListProjectInput = Schema.Struct({
+  ...ListInputBase,
+  project: Project.ID,
+  subpath: RelativePath.pipe(Schema.optional)
+});
+var ListAllInput = Schema.Struct(ListInputBase);
+var ListInput5 = Schema.Union([ListDirectoryInput, ListProjectInput, ListAllInput]);
+
+class Service72 extends Context.Service()("@opencode/SessionStore") {
+}
+var layer = Layer.effect(Service72, Effect.gen(function* () {
+  const { db } = yield* Service80;
+  return Service72.of({
+    get: Effect.fnUntraced(function* (sessionID) {
+      const row = yield* db.select().from(SessionTable2).where(eq(SessionTable2.id, sessionID)).get().pipe(Effect.orDie);
+      return row ? fromRow2(row) : undefined;
+    }),
+    list: Effect.fn("SessionStore.list")(function* (input = {}) {
+      const direction = input.anchor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const sortColumn = SessionTable2.time_updated;
+      const conditions = [];
+      if ("directory" in input)
+        conditions.push(eq(SessionTable2.directory, input.directory));
+      if (input.workspaceID)
+        conditions.push(eq(SessionTable2.workspace_id, input.workspaceID));
+      if ("project" in input)
+        conditions.push(eq(SessionTable2.project_id, input.project));
+      if ("project" in input && input.subpath !== undefined)
+        conditions.push(eq(SessionTable2.path, input.subpath));
+      if (input.search)
+        conditions.push(like(SessionTable2.title, `%${input.search}%`));
+      if (input.parentID !== undefined)
+        conditions.push(input.parentID === null ? isNull(SessionTable2.parent_id) : eq(SessionTable2.parent_id, input.parentID));
+      if (input.anchor) {
+        conditions.push(order === "asc" ? or(gt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), gt(SessionTable2.id, input.anchor.id))) : or(lt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), lt(SessionTable2.id, input.anchor.id))));
+      }
+      const query = db.select().from(SessionTable2).where(conditions.length > 0 ? and(...conditions) : undefined).orderBy(order === "asc" ? asc(sortColumn) : desc(sortColumn), order === "asc" ? asc(SessionTable2.id) : desc(SessionTable2.id));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow2(row));
+    }),
+    messages: Effect.fn("SessionStore.messages")(function* (input) {
+      const direction = input.cursor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const anchor = input.cursor ? yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.id, input.cursor.id))).get().pipe(Effect.orDie) : undefined;
+      if (input.cursor && !anchor)
+        return [];
+      const boundary = anchor ? order === "asc" ? gt(SessionMessageTable2.seq, anchor.seq) : lt(SessionMessageTable2.seq, anchor.seq) : undefined;
+      const where = boundary ? and(eq(SessionMessageTable2.session_id, input.sessionID), boundary) : eq(SessionMessageTable2.session_id, input.sessionID);
+      const query = db.select().from(SessionMessageTable2).where(where).orderBy(order === "asc" ? asc(SessionMessageTable2.seq) : desc(SessionMessageTable2.seq));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decodeMessageRow2);
+    }),
+    context: Effect.fn("SessionStore.context")((sessionID) => load3(db, sessionID, "latest")),
+    message: Effect.fn("SessionStore.message")(function* (messageID) {
+      const row = yield* db.select().from(SessionMessageTable2).where(eq(SessionMessageTable2.id, messageID)).get().pipe(Effect.orDie);
+      return row ? {
+        sessionID: Session.ID.make(row.session_id),
+        message: yield* decodeMessageRow2(row).pipe(Effect.orDie)
+      } : undefined;
+    }),
+    listSuspended: Effect.fn("SessionStore.listSuspended")(function* () {
+      return yield* db.select({ sessionID: SessionTable2.id }).from(SessionTable2).where(and(isNotNull(SessionTable2.time_suspended), isNull(SessionTable2.parent_id))).all().pipe(Effect.orDie, Effect.map((rows) => rows.map((row) => row.sessionID)));
+    }),
+    claim: Effect.fn("SessionStore.claim")(function* (sessionID) {
+      yield* db.update(SessionTable2).set({ time_suspended: Date.now(), time_updated: sql`${SessionTable2.time_updated}` }).where(and(eq(SessionTable2.id, sessionID), isNull(SessionTable2.time_suspended))).run().pipe(Effect.orDie);
+    }),
+    release: Effect.fn("SessionStore.release")(function* (sessionID) {
+      yield* db.update(SessionTable2).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable2.time_updated}` }).where(eq(SessionTable2.id, sessionID)).run().pipe(Effect.orDie);
+    }),
+    releaseChildClaims: Effect.fn("SessionStore.releaseChildClaims")((recoverable) => db.update(SessionTable2).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable2.time_updated}` }).where(and(isNotNull(SessionTable2.time_suspended), isNotNull(SessionTable2.parent_id), recoverable.length > 0 ? notInArray(SessionTable2.id, Array.from(recoverable)) : undefined)).run().pipe(Effect.orDie, Effect.asVoid)),
+    countResume: Effect.fn("SessionStore.countResume")(function* (sessionID) {
+      const row = yield* db.update(SessionTable2).set({
+        resume_attempts: sql`${SessionTable2.resume_attempts} + 1`,
+        time_updated: sql`${SessionTable2.time_updated}`
+      }).where(eq(SessionTable2.id, sessionID)).returning({ attempts: SessionTable2.resume_attempts }).get().pipe(Effect.orDie);
+      return row?.attempts;
+    })
+  });
+}));
+var node77 = makeGlobalNode({ service: Service72, layer, deps: [node85] });
+
+export { ListInput5, Service72, node77, exports_store };

package/dist/chunks/worktree-3fc6dm20.js

@@ -0,0 +1,151 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/codemode/catalog.ts
+var exports_catalog = {};
+__export(exports_catalog, {
+  CodeModeCatalog: () => exports_catalog,
+  Summary: () => Summary2,
+  Tool: () => Tool2,
+  namespaceLine: () => namespaceLine2,
+  summarize: () => summarize2
+});
+import { Schema } from "effect";
+var Tool2 = Schema.Struct({
+  type: Schema.Literal("tool"),
+  name: Schema.String,
+  description: Schema.String,
+  signature: Schema.String,
+  pinned: Schema.optionalKey(Schema.Boolean)
+});
+var Listing = Schema.Struct({
+  path: Schema.String,
+  line: Schema.String
+});
+var NamespaceSummary = Schema.Struct({
+  name: Schema.String,
+  description: Schema.optionalKey(Schema.String),
+  count: Schema.Number,
+  entries: Schema.Array(Listing)
+});
+var Summary2 = Schema.Struct({
+  total: Schema.Number,
+  shown: Schema.Number,
+  namespaces: Schema.Array(NamespaceSummary)
+});
+var DESCRIPTION_LIMIT = 120;
+var CHARACTERS_PER_TOKEN = 4;
+var INLINE_BUDGET = 2000;
+function summarize2(inventory, options = {}) {
+  const budget = options.budget ?? INLINE_BUDGET;
+  const flattened = flatten(inventory.tools);
+  const namespaces = [...Map.groupBy(flattened.tools, (tool) => tool.path.split(".", 1)[0] ?? tool.path)].sort(([left], [right]) => {
+    if (left < right)
+      return -1;
+    if (left > right)
+      return 1;
+    return 0;
+  }).map(([name, namespaceEntries]) => {
+    const description = flattened.namespaces.get(name)?.description;
+    const listings = namespaceEntries.map((entry) => {
+      const firstLine = entry.description.split(`
+`, 1)[0]?.trim() ?? "";
+      const description = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
+      const suffix = description.length === 0 ? "" : ` // ${description}`;
+      return { path: entry.path, line: `  - ${entry.signature}${suffix}` };
+    }).toSorted((left, right) => {
+      if (left.path < right.path)
+        return -1;
+      if (left.path > right.path)
+        return 1;
+      return 0;
+    });
+    const ranked = rankListings(listings);
+    const pinned = new Set(namespaceEntries.filter((entry) => entry.pinned).map((entry) => listings.find((listing) => listing.path === entry.path)).filter((listing) => listing !== undefined));
+    return {
+      name,
+      ...description === undefined ? {} : { description },
+      listings,
+      selectionOrder: ranked.filter((candidate) => !pinned.has(candidate.listing)),
+      selectedListings: pinned,
+      selectionIndex: 0
+    };
+  });
+  const active = new Set(namespaces);
+  let remaining = budget - namespaces.reduce((total, namespace) => total + cost(namespaceLine2({
+    name: namespace.name,
+    ...namespace.description === undefined ? {} : { description: namespace.description },
+    count: namespace.listings.length,
+    entries: []
+  })), 0) - namespaces.flatMap((namespace) => namespace.listings.filter((listing) => namespace.selectedListings.has(listing))).reduce((total, listing) => total + cost(listing.line), 0);
+  while (active.size > 0) {
+    for (const namespace of active) {
+      const candidate = namespace.selectionOrder[namespace.selectionIndex];
+      if (!candidate || candidate.cost > remaining) {
+        active.delete(namespace);
+        continue;
+      }
+      namespace.selectedListings.add(candidate.listing);
+      namespace.selectionIndex += 1;
+      remaining -= candidate.cost;
+      if (namespace.selectionIndex === namespace.selectionOrder.length)
+        active.delete(namespace);
+    }
+  }
+  const namespaceSummaries = namespaces.map((namespace) => ({
+    name: namespace.name,
+    ...namespace.description === undefined ? {} : { description: namespace.description },
+    count: namespace.listings.length,
+    entries: namespace.listings.filter((listing) => namespace.selectedListings.has(listing))
+  }));
+  return {
+    total: flattened.tools.length,
+    shown: namespaceSummaries.reduce((total, namespace) => total + namespace.entries.length, 0),
+    namespaces: namespaceSummaries
+  };
+}
+function flatten(entries, path = []) {
+  const tools = [];
+  const namespaces = new Map;
+  for (const entry of entries) {
+    if (entry.type === "tool") {
+      tools.push({
+        type: "tool",
+        path: [...path, entry.name].join("."),
+        description: entry.description,
+        signature: entry.signature,
+        ...entry.pinned === undefined ? {} : { pinned: entry.pinned }
+      });
+      continue;
+    }
+    const next = [...path, entry.name];
+    namespaces.set(next.join("."), entry);
+    const nested = flatten(entry.tools, next);
+    tools.push(...nested.tools);
+    for (const [name, namespace] of nested.namespaces)
+      namespaces.set(name, namespace);
+  }
+  return { tools, namespaces };
+}
+function namespaceLine2(namespace) {
+  const count = namespace.count === 1 ? "1 tool" : `${namespace.count} tools`;
+  const label = namespace.entries.length === namespace.count ? count : namespace.entries.length === 0 ? `${count}, none shown` : `${count}, ${namespace.entries.length} shown`;
+  return `- ${namespace.name} (${label})${namespace.description === undefined ? "" : ` // ${namespace.description}`}`;
+}
+function rankListings(listings) {
+  return listings.map((listing) => ({ listing, cost: cost(listing.line) })).toSorted((left, right) => {
+    if (left.cost !== right.cost)
+      return left.cost - right.cost;
+    if (left.listing.path < right.listing.path)
+      return -1;
+    if (left.listing.path > right.listing.path)
+      return 1;
+    return 0;
+  });
+}
+function cost(text) {
+  return Math.round(text.length / CHARACTERS_PER_TOKEN);
+}
+
+export { Tool2, Summary2, summarize2, namespaceLine2, exports_catalog };

package/dist/chunks/worktree-3hepkmqq.js

@@ -0,0 +1,13 @@
+import {
+  Timestamps2
+} from "./worktree-qfa1cgps.js";
+
+// src/kv/sql.ts
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+var KVTable2 = sqliteTable("kv", {
+  key: text().primaryKey(),
+  value: text({ mode: "json" }).$type().notNull(),
+  ...Timestamps2
+});
+
+export { KVTable2 };

package/dist/chunks/worktree-3q1qkym4.js

@@ -0,0 +1,247 @@
+import {
+  node78
+} from "./worktree-7vcja736.js";
+import {
+  node67
+} from "./worktree-b1x7x3xx.js";
+import {
+  node70
+} from "./worktree-rjbw5qw4.js";
+import {
+  node69
+} from "./worktree-g0he3e83.js";
+import {
+  node68
+} from "./worktree-e3fx731j.js";
+import {
+  node47
+} from "./worktree-4m55frd1.js";
+import {
+  node79,
+  boundNode2
+} from "./worktree-z82wee6n.js";
+import {
+  configured7,
+  node58
+} from "./worktree-r82b328h.js";
+import {
+  node55
+} from "./worktree-pr7ch8ks.js";
+import {
+  node54
+} from "./worktree-nsx3nvvw.js";
+import {
+  node18
+} from "./worktree-8mvsftc3.js";
+import {
+  node17
+} from "./worktree-skcgd3vv.js";
+import {
+  node16
+} from "./worktree-neswnnnm.js";
+import {
+  node66
+} from "./worktree-zf4nb4wp.js";
+import {
+  node65
+} from "./worktree-fvhg6c42.js";
+import {
+  node73
+} from "./worktree-nzwzy72p.js";
+import {
+  node31
+} from "./worktree-146a62k1.js";
+import {
+  Service35,
+  node38
+} from "./worktree-vkez6a4k.js";
+import {
+  node26
+} from "./worktree-7hhzr64w.js";
+import {
+  node82
+} from "./worktree-r05k2dy1.js";
+import {
+  node75
+} from "./worktree-k56d8zdx.js";
+import {
+  node39
+} from "./worktree-t3vqhd9s.js";
+import {
+  configured11,
+  node83
+} from "./worktree-t2pd0szj.js";
+import {
+  node32
+} from "./worktree-zjffjh2a.js";
+import {
+  node72
+} from "./worktree-249ffbnn.js";
+import {
+  node30
+} from "./worktree-44gvr517.js";
+import {
+  node44
+} from "./worktree-q3ac6zk1.js";
+import {
+  node33
+} from "./worktree-km7f0hwj.js";
+import {
+  node42
+} from "./worktree-5ycqwtsz.js";
+import {
+  node25
+} from "./worktree-f41x9hg9.js";
+import {
+  node24
+} from "./worktree-0k40b2vq.js";
+import {
+  node35
+} from "./worktree-mp9h7a8n.js";
+import {
+  node51
+} from "./worktree-w55j1d38.js";
+import {
+  node52
+} from "./worktree-qr42g2ex.js";
+import {
+  node49
+} from "./worktree-7c3npc5w.js";
+import {
+  node53
+} from "./worktree-2t421ajn.js";
+import {
+  node43
+} from "./worktree-vp47j2z8.js";
+import {
+  node34
+} from "./worktree-2qnjyx3m.js";
+import {
+  node64
+} from "./worktree-nrs7ag5n.js";
+import {
+  node20
+} from "./worktree-dvgvg99t.js";
+import {
+  node3
+} from "./worktree-h3njrwgg.js";
+import {
+  node74
+} from "./worktree-13bmfrpk.js";
+import {
+  node15,
+  bound2
+} from "./worktree-kbmmzrfa.js";
+import {
+  node12
+} from "./worktree-dvh2p5hy.js";
+import {
+  node9
+} from "./worktree-m6vfy410.js";
+import {
+  node10
+} from "./worktree-11zk2b76.js";
+import {
+  node6
+} from "./worktree-047x8f8f.js";
+import {
+  node5
+} from "./worktree-76j77zm8.js";
+import {
+  node19
+} from "./worktree-7003dbs4.js";
+import {
+  node4
+} from "./worktree-q18k77y0.js";
+import {
+  node2
+} from "./worktree-fjttjfbj.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/instance.ts
+var exports_instance = {};
+__export(exports_instance, {
+  Instance: () => exports_instance,
+  Service: () => Service35,
+  graph: () => graph2,
+  layer: () => layer2,
+  node: () => node38
+});
+import { Effect, Layer } from "effect";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { Node } from "@opencode/util/effect/app-node";
+var nodes = [
+  node79,
+  node55,
+  node58,
+  node78,
+  node47,
+  node44,
+  node53,
+  node34,
+  node69,
+  node68,
+  node66,
+  node67,
+  node20,
+  node82,
+  node15,
+  node6,
+  node5,
+  node64,
+  node17,
+  node16,
+  node51,
+  node19,
+  node49,
+  node42,
+  node32,
+  node83,
+  node74,
+  node54,
+  node18,
+  node31,
+  node75,
+  node72,
+  node52,
+  node73,
+  node25,
+  node33,
+  node26,
+  node70,
+  node65,
+  node10,
+  node30,
+  node9,
+  node39,
+  node12,
+  node4,
+  node24,
+  node35,
+  node2,
+  node43,
+  node3
+];
+var graph2 = LayerNode.group(nodes);
+var vanillaReplacements = [
+  node58.replace(configured7({ project: false, global: false })),
+  node83.replace(configured11({ project: false, global: false }))
+];
+function layer2(ref, options = {}) {
+  const startedAt = performance.now();
+  const replacements = [
+    ...options.discovery === false ? vanillaReplacements : [],
+    ...options.replacements ?? [],
+    node79.replace(boundNode2(ref, { discovery: options.discovery })),
+    node15.replace(bound2(options.plugins ?? []))
+  ];
+  return LayerNode.compile(graph2, { replacements, shared: Node.tags.values.global }).pipe(Layer.orDie, Layer.tap(() => Effect.logInfo("location services booted", {
+    directory: ref.directory,
+    workspaceID: ref.workspaceID,
+    durationMs: Math.round(performance.now() - startedAt)
+  })));
+}
+
+export { graph2, layer2, exports_instance };