@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-qgn6gcr1.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/plugin.ts
+var exports_plugin3 = {};
+__export(exports_plugin3, {
+  ConfigPluginV1: () => exports_plugin3,
+  Options: () => Options7,
+  Spec: () => Spec2
+});
+import { Schema } from "effect";
+var Options7 = Schema.Record(Schema.String, Schema.Unknown);
+var Spec2 = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options7]))]);
+
+export { Options7, Spec2, exports_plugin3 };

package/dist/chunks/worktree-qn0ybd26.js

@@ -0,0 +1,55 @@
+import {
+  Service38,
+  node41,
+  canonical2
+} from "./worktree-w2jjwenf.js";
+import {
+  Service35,
+  node38
+} from "./worktree-vkez6a4k.js";
+import {
+  layer2
+} from "./worktree-3q1qkym4.js";
+
+// src/location-services.ts
+import { Duration, Effect, Exit, Layer, LayerMap, MutableHashMap, Option } from "effect";
+function buildLocationServiceMap2(replacements = []) {
+  return Layer.effect(Service38, Effect.gen(function* () {
+    const owner = yield* Effect.scope;
+    const booting = MutableHashMap.empty();
+    const inner = yield* LayerMap.make((ref) => {
+      const build = {};
+      MutableHashMap.set(booting, ref, build);
+      return Layer.fromBuild((memoMap, scope) => Effect.suspend(() => Layer.buildWithMemoMap(layer2(ref, { replacements: bindings }), memoMap, scope)).pipe(Effect.onExit((exit) => {
+        const finish = Effect.suspend(() => {
+          if (Option.getOrUndefined(MutableHashMap.get(booting, ref)) !== build)
+            return Effect.void;
+          MutableHashMap.remove(booting, ref);
+          return Exit.isFailure(exit) ? inner.invalidate(ref) : Effect.void;
+        });
+        return Exit.isFailure(exit) ? finish.pipe(Effect.forkIn(owner, { startImmediately: true }), Effect.asVoid) : finish;
+      })));
+    }, { idleTimeToLive: Duration.infinity });
+    const map = {
+      ...inner,
+      get: (ref) => inner.get(canonical2(ref)),
+      contextEffect: (ref) => inner.contextEffect(canonical2(ref)),
+      contextEffectOption: (ref) => inner.contextEffectOption(canonical2(ref)),
+      invalidate: (ref) => Effect.suspend(() => {
+        const key = canonical2(ref);
+        MutableHashMap.remove(booting, key);
+        return inner.invalidate(key);
+      })
+    };
+    const bindings = [
+      node38.replace(Layer.succeed(Service35, {
+        provide: (session) => Effect.provide(map.get(session.location))
+      })),
+      ...replacements,
+      node41.replace(Layer.succeed(Service38, map))
+    ];
+    return map;
+  }));
+}
+
+export { buildLocationServiceMap2 };

package/dist/chunks/worktree-qr42g2ex.js

@@ -0,0 +1,148 @@
+import {
+  cleanup3
+} from "./worktree-gd4qta3r.js";
+import {
+  ascending2
+} from "./worktree-tvtrv512.js";
+import {
+  create3
+} from "./worktree-kg06axw8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool-output.ts
+var exports_tool_output2 = {};
+__export(exports_tool_output2, {
+  DIRECTORY: () => DIRECTORY3,
+  MAX_BYTES: () => MAX_BYTES2,
+  MAX_LINES: () => MAX_LINES2,
+  RETENTION: () => RETENTION3,
+  Service: () => Service49,
+  ToolOutput: () => exports_tool_output2,
+  node: () => node52
+});
+import path from "path";
+import { Context, Duration, Effect, Layer, Schedule } from "effect";
+import { makeGlobalNode, makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var MAX_LINES2 = 2000;
+var MAX_BYTES2 = 50 * 1024;
+var RETENTION3 = Duration.days(7);
+var DIRECTORY3 = "tool-output";
+
+class Service49 extends Context.Service()("@opencode/ToolOutput") {
+}
+var cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs, directory) {
+  const entries = yield* fs.readDirectory(directory).pipe(Effect.map((entries) => entries.filter((entry) => /^tool_[0-9a-f]{12}/.test(entry))), Effect.orElseSucceed(() => []));
+  yield* cleanup3(fs, entries.map((entry) => path.join(directory, entry)), RETENTION3);
+});
+var layer = Layer.effect(Service49, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const directory = path.join(global.data, DIRECTORY3);
+  const state = create3({
+    name: "tool-output",
+    initial: () => ({ maxLines: MAX_LINES2, maxBytes: MAX_BYTES2 }),
+    editor: (editor) => ({
+      configure: (limits) => {
+        if (limits.maxLines !== undefined)
+          editor.maxLines = limits.maxLines;
+        if (limits.maxBytes !== undefined)
+          editor.maxBytes = limits.maxBytes;
+      }
+    })
+  });
+  const truncate = Effect.fnUntraced(function* (result) {
+    if (result.metadata?.truncated !== undefined)
+      return result;
+    const content = result.content;
+    const text = content.flatMap((item) => item.type === "text" ? [item.text] : []).join(`
+`);
+    const limits = state.get();
+    const lines = text.split(`
+`);
+    if (text.endsWith(`
+`))
+      lines.pop();
+    const totalBytes = Buffer.byteLength(text, "utf-8");
+    if (lines.length <= limits.maxLines && totalBytes <= limits.maxBytes)
+      return { ...result, metadata: { ...result.metadata, truncated: false } };
+    const kept = [];
+    let bytes = 0;
+    let hitBytes = false;
+    for (const line of lines.slice(0, limits.maxLines)) {
+      const size = Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0);
+      if (bytes + size > limits.maxBytes) {
+        hitBytes = true;
+        break;
+      }
+      kept.push(line);
+      bytes += size;
+    }
+    if (!hitBytes && kept.length === lines.length && totalBytes > bytes)
+      hitBytes = true;
+    const removed = hitBytes ? totalBytes - bytes : lines.length - kept.length;
+    const unit = hitBytes ? removed === 1 ? "byte" : "bytes" : removed === 1 ? "line" : "lines";
+    const file = path.join(directory, ascending2("tool"));
+    yield* fs.ensureDir(directory).pipe(Effect.orDie);
+    yield* fs.writeFileString(file, text).pipe(Effect.orDie);
+    const marker = `... ${removed} ${unit} truncated; full content saved to ${file} ...`;
+    const bounded = [];
+    let remaining = kept.join(`
+`).length;
+    let seenText = false;
+    let marked = false;
+    for (const item of content) {
+      if (item.type === "file") {
+        bounded.push(item);
+        continue;
+      }
+      if (seenText && remaining > 0)
+        remaining--;
+      seenText = true;
+      if (remaining >= item.text.length) {
+        bounded.push(item);
+        remaining -= item.text.length;
+        continue;
+      }
+      if (remaining > 0)
+        bounded.push({ ...item, text: item.text.slice(0, remaining) });
+      if (!marked)
+        bounded.push({ type: "text", text: marker });
+      remaining = 0;
+      marked = true;
+    }
+    if (!marked)
+      bounded.push({ type: "text", text: marker });
+    return {
+      ...result,
+      content: bounded,
+      metadata: { ...result.metadata, truncated: true, outputPath: file }
+    };
+  });
+  return Service49.of({
+    transform: state.transform,
+    reload: state.reload,
+    truncate,
+    cleanup: () => cleanup(fs, directory)
+  });
+}));
+var cleanupLayer = Layer.effectDiscard(Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  yield* cleanup(fs, path.join(global.data, DIRECTORY3)).pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped);
+}));
+var cleanupNode = makeGlobalNode({
+  name: "tool-output-cleanup",
+  layer: cleanupLayer,
+  deps: [FSUtil.node, Global.node]
+});
+var node52 = makeLocationNode({
+  service: Service49,
+  layer,
+  deps: [FSUtil.node, Global.node, cleanupNode]
+});
+
+export { MAX_LINES2, MAX_BYTES2, RETENTION3, DIRECTORY3, Service49, node52, exports_tool_output2 };

package/dist/chunks/worktree-qrg20bc0.js

@@ -0,0 +1,26 @@
+// src/database/migration/20260413175956_chief_energizer.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260413175956_chief_energizer",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_entry\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_entry_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`session_entry_session_idx\` ON \`session_entry\` (\`session_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_entry_session_type_idx\` ON \`session_entry\` (\`session_id\`,\`type\`);`);
+      yield* tx.run(`CREATE INDEX \`session_entry_time_created_idx\` ON \`session_entry\` (\`time_created\`);`);
+    });
+  }
+};
+var _20260413175956_chief_energizer_default = migration;
+
+export { _20260413175956_chief_energizer_default };

package/dist/chunks/worktree-qsdy395h.js

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/plugin/entry-observer.ts
+var exports_entry_observer = {};
+__export(exports_entry_observer, {
+  ConfigEntryObserver: () => exports_entry_observer,
+  observe: () => observe2
+});
+import { Effect, Stream } from "effect";
+var observe2 = Effect.fnUntraced(function* (config, event, reload) {
+  const loaded = { entries: yield* config.entries() };
+  const refresh = config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(reload));
+  yield* event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => refresh), Effect.forkScoped({ startImmediately: true }));
+  loaded.entries = yield* config.entries();
+  return loaded;
+});
+
+export { observe2, exports_entry_observer };

package/dist/chunks/worktree-qt1vhyrn.js

@@ -0,0 +1,61 @@
+import {
+  Service37
+} from "./worktree-y5h7afh3.js";
+import {
+  Service17
+} from "./worktree-p9690q97.js";
+import {
+  text2,
+  deliver2
+} from "./worktree-x1ezjp6w.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/subagent-job.ts
+var exports_subagent_job = {};
+__export(exports_subagent_job, {
+  SubagentJob: () => exports_subagent_job,
+  make: () => make5
+});
+import { Effect, Scope } from "effect";
+var make5 = Effect.gen(function* () {
+  const sessions = yield* Service17;
+  const jobs = yield* Service37;
+  const scope = yield* Scope.Scope;
+  const notifications = new Set;
+  const notify = Effect.fn("SubagentJob.notify")(function* (recovery, startedAt) {
+    const key = `${recovery.childSessionID}:${startedAt}`;
+    if (notifications.has(key))
+      return;
+    notifications.add(key);
+    yield* Effect.gen(function* () {
+      const info = (yield* jobs.wait({ id: recovery.childSessionID })).info;
+      if (info)
+        yield* deliver2(sessions, jobs, { ...info, recovery });
+    }).pipe(Effect.ensuring(Effect.sync(() => notifications.delete(key))), Effect.forkIn(scope, { startImmediately: true }));
+  });
+  return {
+    start: (recovery) => jobs.start({
+      id: recovery.childSessionID,
+      type: "subagent",
+      title: recovery.description,
+      metadata: {},
+      recovery,
+      run: Effect.gen(function* () {
+        yield* sessions.resume(recovery.childSessionID);
+        const messages = yield* sessions.messages({ sessionID: recovery.childSessionID, order: "desc", limit: 20 });
+        const assistant = messages.find((message) => message.type === "assistant" && message.time.completed !== undefined && message.error === undefined);
+        return text2(assistant);
+      })
+    }),
+    background: Effect.fn("SubagentJob.background")(function* (recovery) {
+      const info = yield* jobs.background(recovery.childSessionID);
+      if (info)
+        yield* notify(recovery, info.started_at);
+    }),
+    notify
+  };
+});
+
+export { make5, exports_subagent_job };

package/dist/chunks/worktree-qwyrfpbr.js

@@ -0,0 +1,226 @@
+import {
+  resolveNullableObjectPaths2,
+  mapResultRow2
+} from "./worktree-emrn6kk6.js";
+import {
+  SQLiteEffectDatabase2
+} from "./worktree-d57x1pyx.js";
+
+// src/database/drizzle/sqlite-core/effect/session.ts
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import { NoopCache, strategyFor } from "drizzle-orm/cache/core/cache";
+import { EffectDrizzleQueryError, EffectTransactionRollbackError } from "drizzle-orm/effect-core/errors";
+import { entityKind, is } from "drizzle-orm/entity";
+import { makeJitRqbMapper } from "drizzle-orm/relations";
+import { fillPlaceholders } from "drizzle-orm/sql/sql";
+import { assertUnreachable, makeJitQueryMapper } from "drizzle-orm/utils";
+class SQLiteEffectPreparedQuery2 {
+  executor;
+  query;
+  logger;
+  cache;
+  queryMetadata;
+  fields;
+  useJitMappers;
+  customResultMapper;
+  isRqbV2Query;
+  rqbConfig;
+  isInTransaction;
+  static [entityKind] = "SQLiteEffectPreparedQuery";
+  joinsNotNullableMap;
+  jitMapper;
+  cacheConfig;
+  effectExecuteMethod;
+  constructor(executor, query, logger, cache, queryMetadata, cacheConfig, fields, executeMethod, useJitMappers, customResultMapper, isRqbV2Query, rqbConfig, isInTransaction = Effect.succeed(false)) {
+    this.executor = executor;
+    this.query = query;
+    this.logger = logger;
+    this.cache = cache;
+    this.queryMetadata = queryMetadata;
+    this.fields = fields;
+    this.useJitMappers = useJitMappers;
+    this.customResultMapper = customResultMapper;
+    this.isRqbV2Query = isRqbV2Query;
+    this.rqbConfig = rqbConfig;
+    this.isInTransaction = isInTransaction;
+    this.effectExecuteMethod = executeMethod;
+    this.cacheConfig = cache.strategy() === "all" && cacheConfig === undefined ? { enabled: true, autoInvalidate: true } : cacheConfig;
+    if (!this.cacheConfig?.enabled) {
+      this.cacheConfig = undefined;
+    }
+  }
+  run(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "run");
+  }
+  all(placeholderValues) {
+    if (this.isRqbV2Query)
+      return this.allRqbV2(placeholderValues);
+    if (!this.fields && !this.customResultMapper) {
+      return this.executeWithCache(placeholderValues, "all");
+    }
+    return this.executeWithCache(placeholderValues, "values", (rows) => this.mapAllResult(rows));
+  }
+  get(placeholderValues) {
+    if (this.isRqbV2Query)
+      return this.getRqbV2(placeholderValues);
+    if (!this.fields && !this.customResultMapper) {
+      return this.executeWithCache(placeholderValues, "get");
+    }
+    return this.executeWithCache(placeholderValues, "values", (rows) => this.mapGetResult(rows));
+  }
+  values(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "values");
+  }
+  execute(placeholderValues) {
+    return this[this.effectExecuteMethod](placeholderValues);
+  }
+  mapRunResult(result, _isFromBatch) {
+    return result;
+  }
+  mapAllResult(rows, isFromBatch) {
+    if (isFromBatch) {
+      rows = Array.isArray(rows) ? rows : [];
+    }
+    if (!this.fields && !this.customResultMapper) {
+      return rows;
+    }
+    if (this.isRqbV2Query) {
+      return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitRqbMapper(this.rqbConfig))(rows) : this.customResultMapper(rows);
+    }
+    if (this.customResultMapper) {
+      return this.customResultMapper(rows);
+    }
+    return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitQueryMapper(this.fields, resolveNullableObjectPaths2(this.fields, this.joinsNotNullableMap)))(rows) : rows.map((row) => mapResultRow2(this.fields, row, this.joinsNotNullableMap));
+  }
+  mapGetResult(rows, isFromBatch) {
+    if (isFromBatch) {
+      rows = Array.isArray(rows) ? rows : [];
+    }
+    if (!this.fields && !this.customResultMapper) {
+      return Array.isArray(rows) ? rows[0] : rows;
+    }
+    const row = Array.isArray(rows) ? rows[0] : rows;
+    if (!row)
+      return;
+    if (this.isRqbV2Query) {
+      return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitRqbMapper(this.rqbConfig))([
+        row
+      ]) : this.customResultMapper([row]);
+    }
+    if (this.customResultMapper) {
+      return this.customResultMapper([row]);
+    }
+    return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitQueryMapper(this.fields, resolveNullableObjectPaths2(this.fields, this.joinsNotNullableMap)))([row])[0] : mapResultRow2(this.fields, row, this.joinsNotNullableMap);
+  }
+  allRqbV2(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "all", (rows) => this.mapAllResult(rows));
+  }
+  getRqbV2(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "get", (row) => row === undefined ? undefined : this.mapGetResult(row));
+  }
+  executeWithCache(placeholderValues, executeMethod, mapResult) {
+    return Effect.gen({ self: this }, function* () {
+      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+      yield* this.logger.logQuery(this.query.sql, params);
+      return yield* this.queryWithCache(this.query.sql, params, Effect.suspend(() => this.executor(params, executeMethod)), mapResult);
+    });
+  }
+  mapCachedResult(result, mapResult) {
+    if (!mapResult)
+      return Effect.succeed(result);
+    return Effect.try({
+      try: () => mapResult(result),
+      catch: (cause) => cause
+    });
+  }
+  queryWithCache(queryString, params, query, mapResult) {
+    return Effect.gen({ self: this }, function* () {
+      if (this.queryMetadata?.type === "select" && this.cacheConfig?.enabled && (yield* this.isInTransaction)) {
+        return yield* this.mapCachedResult(yield* query, mapResult);
+      }
+      const cacheStrat = !is(this.cache.cache, NoopCache) ? yield* Effect.tryPromise(() => strategyFor(queryString, params, this.queryMetadata, this.cacheConfig)) : { type: "skip" };
+      if (cacheStrat.type === "skip") {
+        return yield* this.mapCachedResult(yield* query, mapResult);
+      }
+      if (cacheStrat.type === "invalidate") {
+        const result = yield* query;
+        yield* this.cache.onMutate({ tables: cacheStrat.tables });
+        return yield* this.mapCachedResult(result, mapResult);
+      }
+      if (cacheStrat.type === "try") {
+        if (yield* this.isInTransaction) {
+          return yield* this.mapCachedResult(yield* query, mapResult);
+        }
+        const { tables, key, isTag, autoInvalidate, config } = cacheStrat;
+        const fromCache = yield* this.cache.get(key, tables, isTag, autoInvalidate);
+        if (typeof fromCache !== "undefined") {
+          return yield* this.mapCachedResult(fromCache, mapResult);
+        }
+        const result = yield* query;
+        yield* this.cache.put(key, result, autoInvalidate ? tables : [], isTag, config);
+        return yield* this.mapCachedResult(result, mapResult);
+      }
+      assertUnreachable(cacheStrat);
+    }).pipe(Effect.mapError((e) => new EffectDrizzleQueryError({ query: queryString, params, cause: Cause.fail(e) })));
+  }
+  getQuery() {
+    return this.query;
+  }
+  mapResult(response, isFromBatch) {
+    switch (this.effectExecuteMethod) {
+      case "run": {
+        return this.mapRunResult(response, isFromBatch);
+      }
+      case "all": {
+        return this.mapAllResult(response, isFromBatch);
+      }
+      case "get": {
+        return this.mapGetResult(response, isFromBatch);
+      }
+    }
+  }
+}
+
+class SQLiteEffectSession2 {
+  dialect;
+  static [entityKind] = "SQLiteEffectSession";
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  prepareOneTimeQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig) {
+    return this.prepareQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig);
+  }
+  prepareOneTimeRelationalQuery(query, fields, executeMethod, customResultMapper, config) {
+    return this.prepareRelationalQuery(query, fields, executeMethod, customResultMapper, config);
+  }
+  run(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "run").run();
+  }
+  all(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "all").all();
+  }
+  get(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "get").get();
+  }
+  values(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "all").values();
+  }
+  count(query) {
+    return this.values(query).pipe(Effect.map((result) => result[0]?.[0] ?? 0));
+  }
+}
+
+class SQLiteEffectTransaction2 extends SQLiteEffectDatabase2 {
+  relations;
+  static [entityKind] = "SQLiteEffectTransaction";
+  constructor(dialect, session, relations) {
+    super(dialect, session, relations);
+    this.relations = relations;
+  }
+  rollback() {
+    return new EffectTransactionRollbackError;
+  }
+}
+
+export { SQLiteEffectPreparedQuery2, SQLiteEffectSession2, SQLiteEffectTransaction2 };

package/dist/chunks/worktree-r05k2dy1.js

@@ -0,0 +1,61 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/hooks.ts
+var exports_hooks = {};
+__export(exports_hooks, {
+  PluginHooks: () => exports_hooks,
+  Service: () => Service77,
+  node: () => node82
+});
+import { Context, Effect, Layer, Scope } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var eventProviderID = (event) => {
+  if (typeof event !== "object" || event === null || !("model" in event))
+    return;
+  const model = event.model;
+  if (typeof model !== "object" || model === null || !("providerID" in model))
+    return;
+  return typeof model.providerID === "string" ? model.providerID : undefined;
+};
+
+class Service77 extends Context.Service()("@opencode/PluginHooks") {
+}
+var layer = Layer.effect(Service77, Effect.gen(function* () {
+  const callbacks = new Map;
+  const key = (domain, name) => `${domain}.${String(name)}`;
+  const register = Effect.fn("PluginHooks.register")(function* (domain, name, callback, options) {
+    const scope = yield* Scope.Scope;
+    const id = key(domain, name);
+    let active = true;
+    const entry = { callback, options };
+    callbacks.set(id, [...callbacks.get(id) ?? [], entry]);
+    const dispose = Effect.sync(() => {
+      if (!active)
+        return;
+      active = false;
+      const next = (callbacks.get(id) ?? []).filter((item) => item !== entry);
+      if (next.length === 0)
+        callbacks.delete(id);
+      else
+        callbacks.set(id, next);
+    });
+    yield* Scope.addFinalizer(scope, dispose);
+    return { dispose };
+  });
+  const trigger = Effect.fnUntraced(function* (domain, name, event) {
+    for (const entry of callbacks.get(key(domain, name)) ?? []) {
+      if (entry.options?.providerID !== undefined && entry.options.providerID !== eventProviderID(event))
+        continue;
+      const result = Reflect.apply(entry.callback, undefined, [event]);
+      yield* result;
+    }
+    return event;
+  });
+  const has = (domain, name, providerID) => Effect.sync(() => (callbacks.get(key(domain, name)) ?? []).some((entry) => entry.options?.providerID === undefined || entry.options.providerID === providerID));
+  return Service77.of({ has, register, trigger });
+}));
+var node82 = makeLocationNode({ service: Service77, layer, deps: [] });
+
+export { Service77, node82, exports_hooks };