@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-nr76rjj3.js

@@ -0,0 +1,46 @@
+import {
+  NamedError
+} from "./ripgrep-hzeg9cfr.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/error.ts
+var exports_error = {};
+__export(exports_error, {
+  RemoteAuthError: () => RemoteAuthError,
+  JsonError: () => JsonError,
+  InvalidError: () => InvalidError,
+  FrontmatterError: () => FrontmatterError,
+  DirectoryTypoError: () => DirectoryTypoError,
+  ConfigErrorV1: () => exports_error
+});
+import { Schema } from "effect";
+var Issue = Schema.StructWithRest(Schema.Struct({
+  message: Schema.String,
+  path: Schema.Array(Schema.String)
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+var JsonError = NamedError.create("ConfigJsonError", {
+  path: Schema.String,
+  message: Schema.optional(Schema.String)
+});
+var InvalidError = NamedError.create("ConfigInvalidError", {
+  path: Schema.String,
+  issues: Schema.optional(Schema.Array(Issue)),
+  message: Schema.optional(Schema.String)
+});
+var FrontmatterError = NamedError.create("ConfigFrontmatterError", {
+  path: Schema.String,
+  message: Schema.String
+});
+var DirectoryTypoError = NamedError.create("ConfigDirectoryTypoError", {
+  path: Schema.String,
+  dir: Schema.String,
+  suggestion: Schema.String
+});
+var RemoteAuthError = NamedError.create("ConfigRemoteAuthError", {
+  url: Schema.String,
+  remote: Schema.String
+});
+
+export { JsonError, InvalidError, FrontmatterError, DirectoryTypoError, RemoteAuthError, exports_error };

package/dist/chunks/ripgrep-nsc0c3zb.js

@@ -0,0 +1,14 @@
+// src/database/migration/20260501142318_next_venus.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260501142318_next_venus",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`agent\` text;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`model\` text;`);
+    });
+  }
+};
+var _20260501142318_next_venus_default = migration;
+
+export { _20260501142318_next_venus_default };

package/dist/chunks/ripgrep-nzrjycs5.js

@@ -0,0 +1,21 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/skills.ts
+var exports_skills = {};
+__export(exports_skills, {
+  Info: () => Info,
+  ConfigSkillsV1: () => exports_skills
+});
+import { Schema } from "effect";
+var Info = Schema.Struct({
+  paths: Schema.optional(Schema.Array(Schema.String)).annotate({
+    description: "Additional paths to skill folders"
+  }),
+  urls: Schema.optional(Schema.Array(Schema.String)).annotate({
+    description: "URLs to fetch skills from (e.g., https://example.com/.well-known/skills/)"
+  })
+});
+
+export { Info, exports_skills };

package/dist/chunks/ripgrep-p3zwavty.js

@@ -0,0 +1,490 @@
+import {
+  exports_usage
+} from "./ripgrep-8ywqk2j9.js";
+import {
+  SessionEvent
+} from "./ripgrep-a83yvq99.js";
+
+// src/session/runner/publish-llm-event.ts
+import { Clock, Effect } from "effect";
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : { value };
+var nonEmpty = (content) => content.length > 0 ? content : undefined;
+var stringify = (value) => {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var hostedContent = (result) => {
+  if (result.type === "content") {
+    const content = nonEmpty(result.value);
+    if (content !== undefined)
+      return content;
+  }
+  return [{ type: "text", text: stringify(result.value) }];
+};
+var createLLMEventPublisher = (bus, input) => {
+  const deltaBatchInterval = 100;
+  const tools = new Map;
+  const failureSnapshot = (tool, metadata) => {
+    if (tool.progress === undefined)
+      return metadata === undefined ? {} : { metadata };
+    if (metadata === undefined)
+      return { metadata: tool.progress };
+    return { metadata: { ...tool.progress, ...metadata } };
+  };
+  const assistantMessageID = input.assistantMessageID;
+  let stepStarted = false;
+  let stepFailed = false;
+  let providerFailed = false;
+  let outputStarted = false;
+  let stepFailure;
+  let stepSettlement;
+  const startAssistant = Effect.fnUntraced(function* () {
+    if (stepStarted)
+      return assistantMessageID;
+    stepStarted = true;
+    yield* bus.publish(SessionEvent.Step.Started, {
+      sessionID: input.sessionID,
+      agent: input.agent,
+      model: input.model,
+      assistantMessageID,
+      snapshot: input.snapshot
+    });
+    return assistantMessageID;
+  });
+  const currentAssistantMessageID = () => stepStarted ? Effect.succeed(assistantMessageID) : Effect.die(new Error("Tool event before assistant step start"));
+  const providerState = (metadata) => metadata?.[input.providerMetadataKey];
+  const fragments = (name, ended, delta, single = false) => {
+    const chunks = new Map;
+    let nextOrdinal = 0;
+    const start = (id, state) => Effect.suspend(() => {
+      if (chunks.has(id))
+        return Effect.die(new Error(`Duplicate ${name} start: ${id}`));
+      if (single && chunks.size > 0)
+        return Effect.die(new Error(`${name} start before end: ${id}`));
+      const ordinal = nextOrdinal++;
+      chunks.set(id, { ordinal, values: [], pending: "", state });
+      return Effect.succeed(ordinal);
+    });
+    const publishDelta = Effect.fnUntraced(function* (id, force = false) {
+      if (!delta)
+        return;
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} delta before start: ${id}`));
+      if (!current.pending)
+        return;
+      const now = yield* Clock.currentTimeMillis;
+      if (!force && current.publishedAt === undefined) {
+        current.publishedAt = now;
+        return;
+      }
+      if (!force && current.publishedAt !== undefined && now - current.publishedAt < deltaBatchInterval)
+        return;
+      yield* delta(id, current.pending, current.ordinal);
+      current.pending = "";
+      current.publishedAt = now;
+      return;
+    });
+    const append = Effect.fnUntraced(function* (id, value, state) {
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} delta before start: ${id}`));
+      current.values.push(value);
+      if (delta)
+        current.pending += value;
+      if (state !== undefined)
+        current.state = { ...current.state, ...state };
+      yield* publishDelta(id);
+      return current.ordinal;
+    });
+    const end = Effect.fnUntraced(function* (id, state, value) {
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} end before start: ${id}`));
+      yield* publishDelta(id, true);
+      yield* ended(id, value ?? current.values.join(""), current.ordinal, state === undefined ? current.state : { ...current.state, ...state });
+      chunks.delete(id);
+      return;
+    });
+    const flush2 = Effect.fnUntraced(function* () {
+      for (const id of Array.from(chunks.keys()))
+        yield* end(id);
+    });
+    return { start, append, end, flush: flush2, has: (id) => chunks.has(id) };
+  };
+  const text = fragments("text", (_textID, value, ordinal, state) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Text.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      text: value,
+      state
+    });
+  }), (_textID, value, ordinal) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Text.Delta, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      delta: value
+    });
+  }), true);
+  const reasoning = fragments("reasoning", (_reasoningID, value, ordinal, state) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Reasoning.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      text: value,
+      state
+    });
+  }), (_reasoningID, value, ordinal) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Reasoning.Delta, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      delta: value
+    });
+  }), true);
+  const toolInput = fragments("tool input", (id, value) => Effect.gen(function* () {
+    const tool = tools.get(id);
+    if (!tool)
+      return yield* Effect.die(new Error(`Tool input end before start: ${id}`));
+    yield* bus.publish(SessionEvent.Tool.Input.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      text: value
+    });
+  }));
+  const flushFragments = Effect.fnUntraced(function* () {
+    yield* text.flush();
+    yield* reasoning.flush();
+    yield* toolInput.flush();
+  });
+  const startToolInput = Effect.fnUntraced(function* (event) {
+    if (tools.has(event.id))
+      return yield* Effect.die(new Error(`Duplicate tool input start: ${event.id}`));
+    const assistantMessageID2 = yield* startAssistant();
+    tools.set(event.id, {
+      assistantMessageID: assistantMessageID2,
+      name: event.name,
+      called: false,
+      settled: false,
+      providerExecuted: event.providerExecuted === true
+    });
+    yield* toolInput.start(event.id);
+    yield* bus.publish(SessionEvent.Tool.Input.Started, {
+      sessionID: input.sessionID,
+      assistantMessageID: assistantMessageID2,
+      id: event.id,
+      name: event.name
+    });
+  });
+  const endToolInput = Effect.fnUntraced(function* (event, value) {
+    const tool = tools.get(event.id);
+    if (!tool)
+      return yield* Effect.die(new Error(`Tool input end before start: ${event.id}`));
+    if (tool.name !== event.name)
+      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+    if (!toolInput.has(event.id))
+      return yield* Effect.die(new Error(`Duplicate tool input end: ${event.id}`));
+    yield* toolInput.end(event.id, undefined, value);
+  });
+  const failMalformedToolInput = Effect.fnUntraced(function* (event) {
+    if (!tools.has(event.id))
+      yield* startToolInput(event);
+    const tool = tools.get(event.id);
+    if (!tool || tool.called || tool.settled)
+      return yield* Effect.die(new Error(`Malformed tool input after call settlement: ${event.id}`));
+    if (tool.name !== event.name)
+      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+    if (toolInput.has(event.id))
+      yield* endToolInput(event, event.raw);
+    tool.settled = true;
+    yield* bus.publish(SessionEvent.Tool.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id: event.id,
+      error: {
+        type: "tool.input-json",
+        message: "Tool call arguments were malformed JSON and were not executed. Retry with valid JSON."
+      },
+      ...failureSnapshot(tool),
+      executed: false
+    });
+  });
+  const flush = Effect.fn("SessionRunner.flush")(function* () {
+    yield* flushFragments();
+  });
+  const failTool = Effect.fnUntraced(function* (id, error, metadata) {
+    const tool = tools.get(id);
+    if (!tool || tool.settled)
+      return false;
+    tool.settled = true;
+    yield* bus.publish(SessionEvent.Tool.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      error,
+      ...failureSnapshot(tool, metadata),
+      executed: tool.providerExecuted
+    });
+    return true;
+  });
+  const failTools = Effect.fnUntraced(function* (error, mode) {
+    let failed = false;
+    for (const [id, tool] of tools) {
+      if (tool.settled || mode === "hosted" && !tool.providerExecuted || mode === "uncalled" && tool.called)
+        continue;
+      failed = (yield* failTool(id, error)) || failed;
+    }
+    return failed;
+  });
+  const failAssistant = Effect.fnUntraced(function* (error) {
+    yield* flush();
+    yield* failTools(error, "uncalled");
+    yield* startAssistant();
+    if (stepFailure === undefined)
+      stepFailure = error;
+  });
+  const publishStepFailure = Effect.fnUntraced(function* (details) {
+    if (stepFailed || stepFailure === undefined)
+      return;
+    const assistantMessageID2 = yield* startAssistant();
+    stepFailed = true;
+    yield* bus.publish(SessionEvent.Step.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: assistantMessageID2,
+      error: stepFailure,
+      ...details
+    });
+  });
+  const failUnsettledTools = Effect.fn("SessionRunner.failUnsettledTools")(function* (error, scope = "all") {
+    return yield* failTools(error, scope);
+  });
+  const assistantMessageIDForTool = (id) => {
+    const tool = tools.get(id);
+    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${id}`));
+  };
+  const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (event) {
+    switch (event.type) {
+      case "step-start":
+        yield* startAssistant();
+        return;
+      case "text-start":
+        outputStarted = true;
+        const startedTextOrdinal = yield* text.start(event.id, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent.Text.Started, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* startAssistant(),
+          ordinal: startedTextOrdinal
+        });
+        return;
+      case "text-delta":
+        yield* text.append(event.id, event.text, providerState(event.providerMetadata));
+        return;
+      case "text-end":
+        yield* text.end(event.id, providerState(event.providerMetadata));
+        return;
+      case "reasoning-start":
+        outputStarted = true;
+        const startedReasoningOrdinal = yield* reasoning.start(event.id, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent.Reasoning.Started, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* startAssistant(),
+          ordinal: startedReasoningOrdinal,
+          state: providerState(event.providerMetadata)
+        });
+        return;
+      case "reasoning-delta":
+        yield* reasoning.append(event.id, event.text, providerState(event.providerMetadata));
+        return;
+      case "reasoning-end":
+        yield* reasoning.end(event.id, providerState(event.providerMetadata));
+        return;
+      case "tool-input-start":
+        outputStarted = true;
+        yield* startToolInput(event);
+        return;
+      case "tool-input-delta": {
+        const tool = tools.get(event.id);
+        if (!tool)
+          return yield* Effect.die(new Error(`Tool input delta before start: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (!toolInput.has(event.id))
+          return yield* Effect.die(new Error(`Tool input delta after end: ${event.id}`));
+        yield* toolInput.append(event.id, event.text);
+        return;
+      }
+      case "tool-input-end":
+        yield* endToolInput(event);
+        return;
+      case "tool-input-error":
+        outputStarted = true;
+        yield* failMalformedToolInput(event);
+        return;
+      case "tool-call": {
+        outputStarted = true;
+        if (!tools.has(event.id))
+          yield* startToolInput(event);
+        const tool = tools.get(event.id);
+        if (toolInput.has(event.id))
+          yield* endToolInput(event);
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool call name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.called)
+          return yield* Effect.die(new Error(`Duplicate tool call: ${event.id}`));
+        tool.called = true;
+        tool.providerExecuted = event.providerExecuted === true;
+        yield* bus.publish(SessionEvent.Tool.Called, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.assistantMessageID,
+          id: event.id,
+          input: asRecord(event.input),
+          executed: tool.providerExecuted,
+          state: providerState(event.providerMetadata)
+        });
+        return;
+      }
+      case "tool-result": {
+        const tool = tools.get(event.id);
+        if (!tool?.called)
+          return yield* Effect.die(new Error(`Tool result before call: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool result name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.settled) {
+          if (event.result.type === "error")
+            return;
+          return yield* Effect.die(new Error(`Duplicate tool result: ${event.id}`));
+        }
+        tool.settled = true;
+        const executed = event.providerExecuted === true || tool.providerExecuted;
+        const resultState = providerState(event.providerMetadata);
+        if (event.result.type === "error") {
+          yield* bus.publish(SessionEvent.Tool.Failed, {
+            sessionID: input.sessionID,
+            assistantMessageID: tool.assistantMessageID,
+            id: event.id,
+            error: { type: "tool.execution", message: stringify(event.result.value) },
+            ...failureSnapshot(tool),
+            executed,
+            resultState
+          });
+          return;
+        }
+        yield* bus.publish(SessionEvent.Tool.Success, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.assistantMessageID,
+          id: event.id,
+          content: hostedContent(event.result),
+          executed,
+          resultState
+        });
+        return;
+      }
+      case "tool-error": {
+        const tool = tools.get(event.id);
+        if (!tool?.called)
+          return yield* Effect.die(new Error(`Tool error before call: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool error name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.settled)
+          return yield* Effect.die(new Error(`Duplicate tool error: ${event.id}`));
+        tool.settled = true;
+        yield* bus.publish(SessionEvent.Tool.Failed, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.assistantMessageID,
+          id: event.id,
+          error: event.message === `Unknown tool: ${event.name}` ? { type: "tool.unknown", message: event.message } : { type: "tool.execution", message: event.message },
+          ...failureSnapshot(tool),
+          executed: tool.providerExecuted,
+          resultState: providerState(event.providerMetadata)
+        });
+        return;
+      }
+      case "step-finish":
+        yield* flush();
+        if (stepSettlement)
+          return yield* Effect.die(new Error("Duplicate step finish"));
+        stepSettlement = { finish: event.reason.normalized, tokens: exports_usage.tokens(event.usage) };
+        if (event.reason.normalized === "content-filter") {
+          providerFailed = true;
+          yield* failAssistant({ type: "provider.content-filter", message: "Provider blocked the response" });
+          return;
+        }
+        return;
+      case "finish":
+        return;
+      case "provider-error":
+        providerFailed = true;
+        yield* failAssistant({ type: "provider.unknown", message: event.message });
+        return;
+    }
+  });
+  const progress = Effect.fnUntraced(function* (id, update) {
+    const tool = tools.get(id);
+    if (!tool?.called || tool.settled)
+      return yield* Effect.die(new Error(`Tool progress outside running call: ${id}`));
+    tool.progress = update;
+    yield* bus.publish(SessionEvent.Tool.Progress, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      metadata: update
+    });
+  });
+  const toolExecution = Effect.fnUntraced(function* (id, name, result) {
+    const tool = tools.get(id);
+    if (!tool?.called)
+      return yield* Effect.die(new Error(`Tool execution before call: ${id}`));
+    if (tool.name !== name)
+      return yield* Effect.die(new Error(`Tool execution name changed for ${id}: ${tool.name} -> ${name}`));
+    if (tool.settled)
+      return yield* Effect.die(new Error(`Duplicate tool execution: ${id}`));
+    tool.settled = true;
+    const content = typeof result.content === "string" ? [{ type: "text", text: result.content }] : result.content === undefined ? [] : [...result.content];
+    if (content.length === 0)
+      return yield* Effect.die(new Error(`Tool execution has no content: ${id}`));
+    yield* bus.publish(SessionEvent.Tool.Success, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      content: [content[0], ...content.slice(1)],
+      ...result.metadata === undefined ? {} : { metadata: result.metadata },
+      executed: tool.providerExecuted
+    });
+  });
+  return {
+    publish,
+    progress,
+    toolExecution,
+    flush,
+    failAssistant,
+    failTool,
+    publishStepFailure,
+    failUnsettledTools,
+    hasProviderError: () => providerFailed,
+    record: () => ({
+      outputStarted,
+      providerFailed,
+      failure: stepFailure,
+      finish: stepSettlement,
+      calls: Array.from(tools, ([id, tool]) => ({
+        id,
+        name: tool.name,
+        called: tool.called,
+        settled: tool.settled,
+        providerExecuted: tool.providerExecuted
+      }))
+    }),
+    startAssistant,
+    assistantMessageID: assistantMessageIDForTool
+  };
+};
+
+export { createLLMEventPublisher };

package/dist/chunks/ripgrep-p5bd5gkc.js

@@ -0,0 +1,103 @@
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_state
+} from "./ripgrep-wt193r4g.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/skill.ts
+var exports_skill = {};
+__export(exports_skill, {
+  toModelOutput: () => toModelOutput,
+  node: () => node,
+  available: () => available,
+  UrlSource: () => UrlSource,
+  Source: () => Source,
+  Skill: () => exports_skill,
+  Service: () => Service,
+  Name: () => Name,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event,
+  EmbeddedSource: () => EmbeddedSource,
+  DirectorySource: () => DirectorySource
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer } from "effect";
+import { Skill } from "@opencode-ai/schema/skill";
+import { Event } from "@opencode-ai/schema/skill";
+var DirectorySource = Skill.DirectorySource;
+var UrlSource = Skill.UrlSource;
+var EmbeddedSource = Skill.EmbeddedSource;
+var Source = Skill.Source;
+var Info = Skill.Info;
+var ID = Skill.ID;
+var Name = Skill.Name;
+var available = (skills, agent) => skills.filter((skill) => exports_permission.evaluate("skill", skill.id, agent.permissions).effect !== "deny");
+var toModelOutput = (skill, files) => {
+  const directory = path.dirname(skill.location);
+  return [
+    `<skill_content name="${skill.name}">`,
+    `# Skill: ${skill.name}`,
+    "",
+    skill.content.trim(),
+    "",
+    `Base directory for this skill: ${directory}`,
+    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+    "Note: file list is sampled.",
+    "",
+    "<skill_files>",
+    ...files.map((file) => `<file>${file}</file>`),
+    "</skill_files>",
+    "</skill_content>"
+  ].join(`
+`);
+};
+
+class Service extends Context.Service()("@opencode/Skill") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const state = exports_state.create({
+    name: "skill",
+    initial: () => ({ skills: new Map }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.skills.values()),
+      add: (skill) => {
+        draft.skills.set(skill.id, { ...skill });
+      },
+      update: (id, update) => {
+        const current = draft.skills.get(ID.make(id));
+        if (!current)
+          return;
+        update(current);
+        current.id = ID.make(id);
+      },
+      remove: (id) => {
+        draft.skills.delete(ID.make(id));
+      }
+    }),
+    finalize: () => bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Skill.list")(function* () {
+      return Array.from(state.get().skills.values());
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_bus.node]
+});
+
+export { DirectorySource, UrlSource, EmbeddedSource, Source, Info, ID, Name, available, toModelOutput, Service, node, exports_skill, Event };