@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-x0v86zgp.js

@@ -0,0 +1,121 @@
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/agent.ts
+var exports_agent4 = {};
+__export(exports_agent4, {
+  Agent: () => exports_agent4,
+  Color: () => Color2,
+  Event: () => Event15,
+  ID: () => ID9,
+  Info: () => Info22,
+  Name: () => Name3,
+  Service: () => Service62,
+  defaultID: () => defaultID2,
+  node: () => node66
+});
+import path from "path";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Array, Context, Effect, Layer } from "effect";
+import { Agent } from "@opencode/schema/agent";
+import { Global } from "@opencode/util/global";
+import { Event as Event15 } from "@opencode/schema/agent";
+var SHELL_OUTPUT_GLOB = (data) => path.join(data, "shell", "*", "*");
+var TOOL_OUTPUT_GLOB = (data) => path.join(data, "tool-output", "*");
+var ID9 = Agent.ID;
+var Name3 = Agent.Name;
+var defaultID2 = ID9.make("build");
+var Color2 = Agent.Color;
+var Info22 = Agent.Info;
+
+class Service62 extends Context.Service()("@opencode/Agent") {
+}
+var layer = Layer.effect(Service62, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const global = yield* Global.Service;
+  const permissions = [
+    { action: "external_directory", resource: SHELL_OUTPUT_GLOB(global.data), effect: "allow" },
+    { action: "external_directory", resource: TOOL_OUTPUT_GLOB(global.data), effect: "allow" },
+    { action: "external_directory", resource: path.join(global.tmp, "*"), effect: "allow" },
+    { action: "external_directory", resource: path.join(global.config, "*"), effect: "allow" }
+  ];
+  const state = create3({
+    name: "agent",
+    initial: () => ({ agents: new Map }),
+    editor: (editor) => ({
+      list: () => Array.fromIterable(editor.agents.values()),
+      get: (id) => editor.agents.get(id),
+      default: (id) => {
+        editor.default = id;
+      },
+      update: (id, fn) => {
+        const defaults = Info22.default(id);
+        const current = editor.agents.get(id) ?? {
+          ...defaults,
+          permissions: [...defaults.permissions, ...permissions]
+        };
+        if (!editor.agents.has(id))
+          editor.agents.set(id, current);
+        fn(current);
+        current.id = id;
+      },
+      remove: (id) => {
+        editor.agents.delete(id);
+      }
+    }),
+    notify: () => bus.publish(Agent.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const selectable = (agent) => agent && agent.mode !== "subagent" && !agent.hidden ? agent : undefined;
+  const selectedDefault = () => {
+    const data = state.get();
+    const configured = data.default ? selectable(data.agents.get(data.default)) : undefined;
+    if (configured)
+      return configured;
+    const build = selectable(data.agents.get(ID9.make("build")));
+    if (build)
+      return build;
+    for (const agent of data.agents.values()) {
+      const fallback = selectable(agent);
+      if (fallback)
+        return fallback;
+    }
+  };
+  return Service62.of({
+    transform: state.transform,
+    reload: state.reload,
+    get: Effect.fn("Agent.get")(function* (id) {
+      return state.get().agents.get(id);
+    }),
+    resolve: Effect.fnUntraced(function* (id) {
+      if (id !== undefined)
+        return state.get().agents.get(ID9.make(id));
+      return selectedDefault();
+    }),
+    select: Effect.fn("Agent.select")(function* (id) {
+      if (id !== undefined) {
+        const selected = ID9.make(id);
+        return { id: selected, info: state.get().agents.get(selected) };
+      }
+      const info = selectedDefault();
+      return { id: info?.id ?? defaultID2, info };
+    }),
+    list: Effect.fn("Agent.list")(function* () {
+      const agents = Array.fromIterable(state.get().agents.values());
+      const selected = selectedDefault();
+      if (!selected)
+        return agents;
+      return [selected, ...agents.filter((agent) => agent.id !== selected.id)];
+    })
+  });
+}));
+var node66 = makeLocationNode({ service: Service62, layer, deps: [node84, Global.node] });
+
+export { ID9, Name3, defaultID2, Color2, Info22, Service62, node66, exports_agent4, Event15 };

package/dist/chunks/aisdk-native-x1ezjp6w.js

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

package/dist/chunks/aisdk-native-x61499pn.js

@@ -0,0 +1,18 @@
+// src/github-copilot/chat/map-openai-compatible-finish-reason.ts
+function mapOpenAICompatibleFinishReason2(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+
+export { mapOpenAICompatibleFinishReason2 };

package/dist/chunks/aisdk-native-xbfgt74t.js

@@ -0,0 +1,38 @@
+import {
+  ephemeral2,
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/sdk.ts
+var exports_sdk = {};
+__export(exports_sdk, {
+  SdkPlugins: () => exports_sdk,
+  Service: () => Service6,
+  Updated: () => Updated2,
+  layer: () => layer6,
+  node: () => node9
+});
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var Updated2 = ephemeral2({ type: "sdk.plugin.updated", schema: {} });
+
+class Service6 extends Context.Service()("@opencode/SdkPlugins") {
+}
+var layer6 = Layer.effect(Service6, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const plugins = new Map;
+  let revision = 0;
+  return Service6.of({
+    register: (plugin) => Effect.sync(() => {
+      plugins.set(plugin.id, { ...plugin, revision: String(++revision), source: { type: "sdk" } });
+    }).pipe(Effect.andThen(bus.publish(Updated2, {})), Effect.asVoid),
+    all: () => [...plugins.values()]
+  });
+}));
+var node9 = makeGlobalNode({ service: Service6, layer: layer6, deps: [node84] });
+
+export { Updated2, Service6, layer6, node9, exports_sdk };

package/dist/chunks/aisdk-native-xbrnje9f.js

@@ -0,0 +1,83 @@
+import {
+  call2
+} from "./aisdk-native-mfqp6xfm.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/websearch/exa.ts
+var exports_exa = {};
+__export(exports_exa, {
+  Plugin: () => Plugin24,
+  WebSearchExa: () => exports_exa,
+  endpoint: () => endpoint5
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint5 = "https://mcp.exa.ai/mcp";
+var McpInput = Schema.Struct({
+  query: Schema.String,
+  numResults: Schema.Number.pipe(Schema.optional)
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    _meta: Schema.Struct({ searchTime: Schema.Number }).pipe(Schema.optional)
+  }))
+});
+var Plugin24 = define({
+  id: "opencode.websearch.exa",
+  effect: Effect.fn("WebSearchExa.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((editor) => {
+      editor.update("exa", (integration) => integration.name = "Exa");
+      editor.method.update({
+        integrationID: "exa",
+        method: { type: "key" }
+      });
+      editor.method.update({
+        integrationID: "exa",
+        method: { type: "env", names: ["EXA_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((editor) => {
+      editor.add({
+        id: "exa",
+        name: "Exa",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("exa");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const url = new URL(endpoint5);
+          if (credential?.type === "key")
+            url.searchParams.set("exaApiKey", credential.key);
+          const result = yield* call2(http, url.toString(), "web_search_exa", { input: McpInput, output: McpOutput }, { query: input.query, numResults: 8 });
+          const content = result?.content.find((item) => item.text);
+          return content ? parseResults(content.text) : [];
+        })
+      });
+    });
+  })
+});
+function parseResults(text) {
+  return text.split(/\n\n---\n\n/).flatMap((block) => {
+    const url = block.match(/^URL:\s*(.+)$/m)?.[1]?.trim();
+    if (!url)
+      return [];
+    const title = block.match(/^Title:\s*(.+)$/m)?.[1]?.trim();
+    const publishedText = block.match(/^Published:\s*(.+)$/m)?.[1]?.trim();
+    const published = publishedText && publishedText !== "N/A" ? Date.parse(publishedText) : undefined;
+    const content = block.match(/^(?:Highlights|Text):\s*\n?([\s\S]*)$/m)?.[1]?.trim();
+    return [
+      {
+        url,
+        ...title && title !== "N/A" ? { title } : {},
+        ...content ? { content } : {},
+        time: { ...published !== undefined && Number.isFinite(published) ? { published } : {} }
+      }
+    ];
+  });
+}
+
+export { endpoint5, Plugin24, exports_exa };

package/dist/chunks/aisdk-native-xekzrwwc.js

@@ -0,0 +1,155 @@
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/skill/discovery.ts
+var exports_discovery = {};
+__export(exports_discovery, {
+  Service: () => Service7,
+  SkillDiscovery: () => exports_discovery,
+  node: () => node10
+});
+import path from "path";
+import { Context, Effect, Layer, Schedule, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+import { Hash } from "@opencode/util/hash";
+var skillConcurrency = 4;
+var fileConcurrency = 8;
+function isSafeSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("\x00");
+}
+function isSafeRelativePath(value) {
+  const segments = value.split("/");
+  return value.length > 0 && !value.includes("\\") && !value.includes("\x00") && !value.includes("?") && !value.includes("#") && !URL.canParse(value) && !path.posix.isAbsolute(value) && !path.win32.isAbsolute(value) && segments.every((segment) => {
+    try {
+      return isSafeSegment(decodeURIComponent(segment));
+    } catch {
+      return false;
+    }
+  });
+}
+
+class IndexSkill extends Schema.Class("SkillDiscovery.IndexSkill")({
+  name: Schema.String,
+  version: Schema.optional(Schema.String),
+  files: Schema.Array(Schema.String)
+}) {
+}
+
+class Index extends Schema.Class("SkillDiscovery.Index")({
+  skills: Schema.Array(IndexSkill)
+}) {
+}
+
+class Service7 extends Context.Service()("@opencode/SkillDiscovery") {
+}
+var layer = Layer.effect(Service7, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const http = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
+    retryOn: "errors-and-responses",
+    times: 2,
+    schedule: Schedule.exponential(200).pipe(Schedule.jittered)
+  }), HttpClient.filterStatusOk);
+  const download = Effect.fn("SkillDiscovery.download")(function* (url, destination) {
+    if (yield* fs.exists(destination).pipe(Effect.orDie))
+      return true;
+    return yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.flatMap((body) => fs.writeWithDirs(destination, new Uint8Array(body))), Effect.as(true), Effect.catch((error) => Effect.logError("failed to download skill file", { url, error }).pipe(Effect.as(false))));
+  });
+  return Service7.of({
+    pull: Effect.fn("SkillDiscovery.pull")(function* (url) {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      const source = new URL(base);
+      const index = new URL("index.json", source).href;
+      const data = yield* HttpClientRequest.get(index).pipe(HttpClientRequest.acceptJson, http.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)), Effect.catch((error) => Effect.logError("failed to fetch skill index", { url: index, error }).pipe(Effect.as(undefined))));
+      if (!data)
+        return [];
+      const sourceRoot = path.resolve(global.cache, "skills", Hash.fast(base));
+      return yield* Effect.forEach(data.skills.flatMap((skill) => {
+        if (!isSafeSegment(skill.name)) {
+          return [];
+        }
+        if (!skill.files.includes("SKILL.md") && !skill.files.includes(`${skill.name}.md`)) {
+          return [];
+        }
+        const root = path.resolve(sourceRoot, skill.name);
+        if (!FSUtil.contains(sourceRoot, root) || root === sourceRoot) {
+          return [];
+        }
+        const skillUrl = new URL(`${encodeURIComponent(skill.name)}/`, source);
+        const versionFile = path.join(root, ".opencode-version");
+        const files = skill.files.map((file) => {
+          if (!isSafeRelativePath(file))
+            return;
+          let resource;
+          try {
+            resource = new URL(file, skillUrl);
+          } catch {
+            return;
+          }
+          if (resource.origin !== source.origin)
+            return;
+          const destination = path.resolve(root, file);
+          if (!FSUtil.contains(root, destination) || destination === root)
+            return;
+          return {
+            url: resource.href,
+            destination,
+            file
+          };
+        });
+        if (!files.every((file) => file !== undefined))
+          return [];
+        return [{ skill, root, versionFile, files }];
+      }), ({ skill, root, versionFile, files }) => Effect.gen(function* () {
+        const version = skill.version;
+        const current = version === undefined ? undefined : yield* fs.readFileStringSafe(versionFile).pipe(Effect.orElseSucceed(() => {
+          return;
+        }));
+        if (version === undefined || current === version) {
+          yield* Effect.forEach(files, (file) => download(file.url, file.destination), {
+            concurrency: fileConcurrency,
+            discard: true
+          });
+        } else {
+          const token = crypto.randomUUID();
+          const staging = `${root}.tmp-${token}`;
+          const backup = `${root}.old-${token}`;
+          yield* Effect.gen(function* () {
+            const downloaded = yield* Effect.forEach(files, (file) => download(file.url, path.resolve(staging, file.file)), { concurrency: fileConcurrency });
+            if (!downloaded.every(Boolean))
+              return;
+            const exists = (yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(staging, `${skill.name}.md`)).pipe(Effect.orDie));
+            if (!exists)
+              return;
+            yield* fs.writeFileString(path.join(staging, ".opencode-version"), version);
+            yield* Effect.uninterruptible(Effect.gen(function* () {
+              const cached = yield* fs.exists(root).pipe(Effect.orDie);
+              if (cached)
+                yield* fs.rename(root, backup);
+              yield* fs.rename(staging, root).pipe(Effect.catch((error) => Effect.gen(function* () {
+                if (cached)
+                  yield* fs.rename(backup, root).pipe(Effect.ignore);
+                return yield* Effect.fail(error);
+              })));
+              if (cached)
+                yield* fs.remove(backup, { recursive: true, force: true }).pipe(Effect.ignore);
+            }));
+          }).pipe(Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })), Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)));
+        }
+        const exists = (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(root, `${skill.name}.md`)).pipe(Effect.orDie));
+        return exists ? [AbsolutePath2.make(root)] : [];
+      }), { concurrency: skillConcurrency }).pipe(Effect.map((directories) => directories.flat()));
+    })
+  });
+}));
+var node10 = makeGlobalNode({ service: Service7, layer, deps: [httpClient, FSUtil.node, Global.node] });
+
+export { Service7, node10, exports_discovery };

package/dist/chunks/aisdk-native-xkq70t77.js

@@ -0,0 +1,96 @@
+import {
+  latest2,
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/warming.ts
+var exports_warming = {};
+__export(exports_warming, {
+  Plugin: () => Plugin25,
+  WarmingPlugin: () => exports_warming
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Duration, Effect, Scope } from "effect";
+var defaults = {
+  prompt: "This is a keep-alive request. Do not perform any work or use tools. Reply with exactly: OK",
+  interval: Duration.minutes(4),
+  duration: Duration.minutes(30)
+};
+var Plugin25 = define({
+  id: "opencode.warming",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service35;
+    const loadSettings = Effect.fn("WarmingPlugin.loadSettings")(function* () {
+      const warming = latest2(yield* config.entries(), "warming");
+      if (!warming)
+        return;
+      const settings = warming === true ? defaults : { ...defaults, ...warming };
+      const interval = Duration.toMillis(settings.interval);
+      const duration = Duration.toMillis(settings.duration);
+      if (Number.isFinite(interval) && interval > 0 && Number.isFinite(duration) && duration > 0)
+        return settings;
+      yield* Effect.logWarning("warming interval and duration must be finite positive durations");
+    });
+    const scope = yield* Scope.Scope;
+    const sessions = new Map;
+    const loop = Effect.fn("WarmingPlugin.loop")(function* (sessionID) {
+      const current = sessions.get(sessionID);
+      if (!current)
+        return;
+      const now = yield* Clock.currentTimeMillis;
+      const next = Math.min(current.last + Duration.toMillis(current.settings.interval), current.expires);
+      if (now < next) {
+        yield* Effect.sleep(Duration.millis(next - now));
+        return yield* loop(sessionID);
+      }
+      if (now >= current.expires) {
+        sessions.delete(sessionID);
+        return;
+      }
+      const last = current.last;
+      yield* Effect.logInfo("warming session", { sessionID, last });
+      yield* ctx.session.generate({ sessionID, prompt: current.settings.prompt }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to warm session", { sessionID, cause })));
+      const latest = sessions.get(sessionID);
+      if (latest === current && latest.last === last)
+        latest.last = yield* Clock.currentTimeMillis;
+      return yield* loop(sessionID);
+    });
+    const hook = (event) => Effect.gen(function* () {
+      const active = sessions.get(event.sessionID);
+      const settings = yield* loadSettings();
+      if (!settings) {
+        sessions.delete(event.sessionID);
+        return;
+      }
+      const message = event.messages.at(-1);
+      if (message?.role === "user" && message.content.length === 1 && message.content[0]?.type === "text" && (message.content[0].text === active?.settings.prompt || message.content[0].text === settings.prompt)) {
+        if (active)
+          active.settings = settings;
+        return;
+      }
+      const now = yield* Clock.currentTimeMillis;
+      const duration = Duration.toMillis(settings.duration);
+      if (active) {
+        active.last = now;
+        active.expires = now + duration;
+        active.settings = settings;
+        return;
+      }
+      sessions.set(event.sessionID, { last: now, expires: now + duration, settings });
+      yield* Effect.logInfo("scheduled session warming", {
+        sessionID: event.sessionID,
+        interval: settings.interval,
+        expires: now + duration
+      });
+      yield* loop(event.sessionID).pipe(Effect.catchCause((cause) => Effect.logError("session warming loop failed", { sessionID: event.sessionID, cause })), Effect.forkIn(scope));
+    });
+    yield* ctx.session.hook("context", hook);
+    yield* ctx.session.hook("compaction", hook);
+    yield* ctx.session.hook("generate", hook);
+  })
+});
+
+export { Plugin25, exports_warming };

package/dist/chunks/aisdk-native-xmvvg8ty.js

@@ -0,0 +1,121 @@
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  parse4,
+  parseRemote2,
+  validateBranch3,
+  isRemote2,
+  cachePath2
+} from "./aisdk-native-2402vzrj.js";
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service47,
+  node50
+} from "./aisdk-native-dgf53888.js";
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/reference.ts
+var exports_reference2 = {};
+__export(exports_reference2, {
+  Event: () => Event6,
+  GitSource: () => GitSource2,
+  Info: () => Info16,
+  LocalSource: () => LocalSource2,
+  Reference: () => exports_reference2,
+  Service: () => Service44,
+  Source: () => Source3,
+  node: () => node47
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Scope } from "effect";
+import { Reference } from "@opencode/schema/reference";
+import { Global } from "@opencode/util/global";
+import { Event as Event6 } from "@opencode/schema/reference";
+var LocalSource2 = Reference.LocalSource;
+var GitSource2 = Reference.GitSource;
+var Source3 = Reference.Source;
+var Info16 = Reference.Info;
+
+class Service44 extends Context.Service()("@opencode/Reference") {
+}
+var layer = Layer.effect(Service44, Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const bus = yield* Service79;
+  const cache = yield* Service47;
+  const scope = yield* Scope.Scope;
+  const list = () => Array.from(state.get().sources).flatMap(([name, source]) => {
+    const info = {
+      name,
+      source,
+      ...source.description === undefined ? {} : { description: source.description },
+      ...source.hidden === undefined ? {} : { hidden: source.hidden }
+    };
+    if (source.type === "local")
+      return [Info16.make({ ...info, path: source.path })];
+    const repository = parse4(source.repository);
+    if (!repository || !isRemote2(repository))
+      return [];
+    if (source.branch) {
+      try {
+        validateBranch3(source.branch);
+      } catch {
+        return [];
+      }
+    }
+    return [
+      Info16.make({
+        ...info,
+        path: AbsolutePath2.make(cachePath2(global.repos, repository, source.branch))
+      })
+    ];
+  });
+  const refresh = Effect.fn("Reference.refresh")(function* () {
+    yield* Effect.forEach(list(), (reference) => Effect.gen(function* () {
+      if (reference.source.type !== "git")
+        return;
+      yield* cache.ensure({
+        reference: parseRemote2(reference.source.repository),
+        branch: reference.source.branch,
+        refresh: "daily"
+      });
+    }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to materialize reference", { name: reference.name, cause }))), { concurrency: 4, discard: true });
+  });
+  const state = create3({
+    name: "reference",
+    initial: () => ({ sources: new Map }),
+    editor: (editor) => ({
+      add: (name, source) => editor.sources.set(name, source),
+      remove: (name) => editor.sources.delete(name),
+      list: () => Array.from(editor.sources),
+      get: (name) => editor.sources.get(name)
+    }),
+    notify: () => Effect.gen(function* () {
+      yield* refresh().pipe(Effect.forkIn(scope));
+      yield* bus.publish(Reference.Event.Updated, {});
+    })
+  });
+  yield* Effect.sleep("1 hour").pipe(Effect.andThen(refresh()), Effect.forever, Effect.forkScoped);
+  return Service44.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Reference.list")(function* () {
+      return list();
+    })
+  });
+}));
+var node47 = makeLocationNode({
+  service: Service44,
+  layer,
+  deps: [Global.node, node84, node50]
+});
+
+export { LocalSource2, GitSource2, Source3, Info16, Service44, node47, exports_reference2, Event6 };