@graphrefly/ts 0.0.0

package/dist/messaging/index.js

@@ -0,0 +1,767 @@
+import {
+  releaseGraphNodes
+} from "../chunk-2ILL7HQI.js";
+import "../chunk-PKVBHGBM.js";
+import "../chunk-I3IHOHCJ.js";
+import "../chunk-4VLAQHZI.js";
+import {
+  depBatch
+} from "../chunk-SWTLEQL6.js";
+import "../chunk-DK554R7P.js";
+
+// src/messaging/index.ts
+var PROMPTS_TOPIC = "prompts";
+var RESPONSES_TOPIC = "responses";
+var INJECTIONS_TOPIC = "injections";
+var DEFERRED_TOPIC = "deferred";
+var SPAWNS_TOPIC = "spawns";
+var CONTEXT_TOPIC = "context";
+var TODOS_TOPIC = "todos";
+var STANDARD_TOPICS = Object.freeze([
+  PROMPTS_TOPIC,
+  RESPONSES_TOPIC,
+  INJECTIONS_TOPIC,
+  DEFERRED_TOPIC,
+  SPAWNS_TOPIC,
+  CONTEXT_TOPIC,
+  TODOS_TOPIC
+]);
+var busStates = /* @__PURE__ */ new WeakMap();
+var dynamicHubStates = /* @__PURE__ */ new WeakMap();
+var DEFAULT_DYNAMIC_HUB_MAX_TOPICS = 1024;
+var DEFAULT_DYNAMIC_HUB_MAX_TOPIC_LENGTH = 256;
+function messageBus(graph, opts) {
+  const unique = [...new Set(opts.topics)];
+  if (unique.length !== opts.topics.length) throw new Error("messageBus: duplicate topic");
+  if (unique.length === 0) throw new Error("messageBus: at least one topic is required");
+  const name = opts.name ?? "messageBus";
+  const state = {
+    graph,
+    name,
+    now: opts.now ?? Date.now,
+    topics: Object.freeze([...unique]),
+    records: /* @__PURE__ */ new Map(),
+    seq: 0
+  };
+  for (const topic of unique) {
+    const producers = [];
+    const body = (ctx) => {
+      for (let i = 0; i < producers.length; i++) {
+        for (const produced of depBatch(ctx, i) ?? []) {
+          if (produced.kind === "publish") {
+            ctx.down([
+              [
+                "DATA",
+                produced.envelope
+              ]
+            ]);
+          }
+        }
+      }
+    };
+    const node = graph.node([], body, {
+      name: `${name}/${topic}`,
+      factory: "messageTopic",
+      meta: { topic },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    });
+    state.records.set(topic, { node, producers, body });
+  }
+  const bus = {
+    topics: state.topics,
+    topic(topic) {
+      return requireTopic(state, topic);
+    },
+    publish(topic, payload, publishOpts = {}) {
+      const node = requireTopic(state, topic);
+      const envelope = {
+        topic,
+        seq: ++state.seq,
+        payload,
+        timestampMs: state.now(),
+        ...publishOpts.key === void 0 ? {} : { key: publishOpts.key }
+      };
+      node.down([["DATA", envelope]]);
+      return envelope;
+    },
+    has(topic) {
+      return state.records.has(topic);
+    }
+  };
+  busStates.set(bus, state);
+  return bus;
+}
+function dynamicHub(graph, opts = {}) {
+  const name = opts.name ?? "dynamicHub";
+  const unknownTopic = normalizeUnknownTopicPolicy(opts.unknownTopic);
+  const maxTopics = normalizeHubLimit(
+    opts.maxTopics,
+    DEFAULT_DYNAMIC_HUB_MAX_TOPICS,
+    "dynamicHub: maxTopics"
+  );
+  const maxTopicLength = normalizeHubLimit(
+    opts.maxTopicLength,
+    DEFAULT_DYNAMIC_HUB_MAX_TOPIC_LENGTH,
+    "dynamicHub: maxTopicLength"
+  );
+  const now = opts.now ?? Date.now;
+  const initialTopics = uniqueTopics(opts.topics ?? [], maxTopicLength);
+  if (initialTopics.length > maxTopics) {
+    throw new Error("dynamicHub: topics exceed maxTopics");
+  }
+  const commandSources = [];
+  const commandBody = (ctx) => {
+    for (let i = 0; i < commandSources.length; i++) {
+      for (const command2 of depBatch(ctx, i) ?? []) ctx.down([["DATA", command2]]);
+    }
+  };
+  const command = graph.node([], commandBody, {
+    name: `${name}/command`,
+    factory: "dynamicHubCommand",
+    completeWhenDepsComplete: false,
+    errorWhenDepsError: false
+  });
+  const events = graph.node(
+    [command],
+    (ctx) => {
+      const runtime = ctx.state.get() ?? {
+        topics: [...initialTopics],
+        open: true,
+        seq: 0,
+        cursor: 0
+      };
+      ctx.state.persist(true);
+      for (const commandFact of depBatch(ctx, 0) ?? []) {
+        const parsed = parseDynamicHubCommand(commandFact);
+        if (typeof parsed === "string") {
+          ctx.down([["DATA", hubError(runtime, commandFact, parsed, timestampOrFallback(now))]]);
+          continue;
+        }
+        const reduced = reduceDynamicHubCommand(
+          runtime,
+          parsed,
+          unknownTopic,
+          maxTopics,
+          maxTopicLength,
+          now
+        );
+        for (const event of reduced) ctx.down([["DATA", event]]);
+      }
+      ctx.state.set(runtime);
+    },
+    {
+      name: `${name}/events`,
+      factory: "dynamicHubEvents",
+      meta: { unknownTopic },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        ctx.down([["DATA", typed.status]]);
+      }
+    },
+    {
+      name: `${name}/status`,
+      factory: "dynamicHubStatus",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const errors = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind !== "error") continue;
+        ctx.down([
+          [
+            "DATA",
+            {
+              ...typed.topic === void 0 ? {} : { topic: typed.topic },
+              error: typed.error,
+              command: typed.command,
+              meta: typed.meta
+            }
+          ]
+        ]);
+      }
+    },
+    {
+      name: `${name}/errors`,
+      factory: "dynamicHubErrors",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const deadLetter = opts.deadLetter === true || unknownTopic === "dead-letter" ? graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind !== "dead-letter") continue;
+        ctx.down([
+          [
+            "DATA",
+            {
+              ...typed.topic === void 0 ? {} : { topic: typed.topic },
+              reason: typed.reason,
+              command: typed.command,
+              meta: typed.meta
+            }
+          ]
+        ]);
+      }
+    },
+    {
+      name: `${name}/deadLetter`,
+      factory: "dynamicHubDeadLetter",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  ) : void 0;
+  const releaseEventsRetain = graph.retain(events, { reason: `${name}.dynamicHub.events` });
+  const hub = {
+    command,
+    events,
+    status,
+    errors,
+    ...deadLetter === void 0 ? {} : { deadLetter },
+    create(topic, commandOpts = {}) {
+      return publishHubCommand(command, {
+        kind: "create",
+        topic,
+        ...commandOpts.key === void 0 ? {} : { key: commandOpts.key },
+        ...commandOpts.payload === void 0 ? {} : { payload: commandOpts.payload }
+      });
+    },
+    delete(topic, commandOpts = {}) {
+      return publishHubCommand(command, {
+        kind: "delete",
+        topic,
+        ...commandOpts.key === void 0 ? {} : { key: commandOpts.key },
+        ...commandOpts.payload === void 0 ? {} : { payload: commandOpts.payload }
+      });
+    },
+    publish(topic, payload, commandOpts = {}) {
+      return publishHubCommand(command, {
+        kind: "publish",
+        topic,
+        payload,
+        ...commandOpts.key === void 0 ? {} : { key: commandOpts.key }
+      });
+    },
+    subscribeTopic(topic, commandOpts = {}) {
+      return publishHubCommand(command, {
+        kind: "subscribe",
+        topic,
+        ...commandOpts.key === void 0 ? {} : { key: commandOpts.key },
+        ...commandOpts.payload === void 0 ? {} : { payload: commandOpts.payload }
+      });
+    },
+    close(commandOpts = {}) {
+      return publishHubCommand(command, {
+        kind: "close",
+        ...commandOpts.key === void 0 ? {} : { key: commandOpts.key },
+        ...commandOpts.payload === void 0 ? {} : { payload: commandOpts.payload }
+      });
+    }
+  };
+  dynamicHubStates.set(hub, {
+    graph,
+    name,
+    maxTopicLength,
+    commandSources,
+    commandBody,
+    releaseEventsRetain
+  });
+  return hub;
+}
+function fromHubTopic(hub, topic, opts = {}) {
+  const state = requireDynamicHubState(hub);
+  assertTopicKey(topic, "fromHubTopic", state.maxTopicLength);
+  return state.graph.node(
+    [hub.events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind !== "message" || typed.topic !== topic) continue;
+        ctx.down([
+          [
+            "DATA",
+            {
+              topic,
+              seq: typed.meta.seq,
+              payload: typed.payload,
+              timestampMs: typed.meta.timestampMs,
+              ...typed.key === void 0 ? {} : { key: typed.key }
+            }
+          ]
+        ]);
+      }
+    },
+    {
+      name: opts.name ?? `${state.name}/${topic}/fromHubTopic`,
+      factory: "fromHubTopic",
+      meta: { topic },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function toHubTopic(graph, source, hub, topic, opts = {}) {
+  const state = requireDynamicHubState(hub);
+  assertTopicKey(topic, "toHubTopic", state.maxTopicLength);
+  if (state.graph !== graph) throw new Error("toHubTopic: hub and source graph must match");
+  if (isReachableUpstream(source, hub.command)) {
+    throw new Error("toHubTopic: source already depends on hub command path");
+  }
+  const commands = graph.node(
+    [source],
+    (ctx) => {
+      for (const value of depBatch(ctx, 0) ?? []) {
+        try {
+          const key = opts.keyOf?.(value);
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "publish",
+                topic,
+                payload: value,
+                ...key === void 0 ? {} : { key }
+              }
+            ]
+          ]);
+        } catch (error) {
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "invalid",
+                topic,
+                error: error instanceof Error ? error.message : String(error)
+              }
+            ]
+          ]);
+        }
+      }
+    },
+    {
+      name: opts.name ?? `${state.name}/${topic}/toHubTopic`,
+      factory: "toHubTopic",
+      meta: { topic },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const commandSource = commands;
+  state.commandSources.push(commandSource);
+  try {
+    hub.command.replaceDeps([...state.commandSources], state.commandBody);
+  } catch (error) {
+    state.commandSources.splice(state.commandSources.indexOf(commandSource), 1);
+    releaseGraphNodes(graph, [commands], {
+      reason: "toHubTopic failed command wiring"
+    });
+    throw error;
+  }
+  return { commands };
+}
+function fromTopic(bus, topic) {
+  return bus.topic(topic);
+}
+function toTopic(graph, source, bus, topic, opts = {}) {
+  const state = busStates.get(bus);
+  if (state === void 0) throw new Error("toTopic: unknown message bus implementation");
+  if (state.graph !== graph) throw new Error("toTopic: bus and source graph must match");
+  const record = requireTopicRecord(state, topic);
+  const name = opts.name ?? `toTopic/${topic}`;
+  const producer = graph.node(
+    [source],
+    (ctx) => {
+      for (const value of depBatch(ctx, 0) ?? []) {
+        try {
+          const key = opts.keyOf?.(value);
+          const envelope = {
+            topic,
+            seq: ++state.seq,
+            payload: value,
+            timestampMs: state.now(),
+            ...key === void 0 ? {} : { key }
+          };
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "publish",
+                envelope
+              }
+            ]
+          ]);
+        } catch (error) {
+          ctx.down([["DATA", { kind: "error", topic, error }]]);
+        }
+      }
+    },
+    {
+      name,
+      factory: "toTopic",
+      meta: { topic },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  record.producers.push(producer);
+  record.node.replaceDeps([...record.producers], record.body);
+  const events = graph.node(
+    [producer, source],
+    (ctx) => {
+      for (const produced of depBatch(ctx, 0) ?? []) {
+        const typed = produced;
+        if (typed.kind === "publish") {
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "publish",
+                topic,
+                seq: typed.envelope.seq,
+                payload: typed.envelope.payload
+              }
+            ]
+          ]);
+        } else {
+          ctx.down([
+            ["DATA", { kind: "error", topic, error: typed.error }]
+          ]);
+        }
+      }
+      const terminal = ctx.terminal[0];
+      if (terminal !== false && terminal !== void 0 && terminal !== true) {
+        ctx.down([
+          ["DATA", { kind: "error", topic, error: terminal }]
+        ]);
+      }
+      const sourceTerminal = ctx.terminal[1];
+      if (sourceTerminal === true) {
+        ctx.down([["DATA", { kind: "complete", topic }]]);
+      } else if (sourceTerminal !== false && sourceTerminal !== void 0) {
+        ctx.down([
+          ["DATA", { kind: "error", topic, error: sourceTerminal }]
+        ]);
+      }
+    },
+    {
+      name: `${name}/events`,
+      factory: "toTopicEvents",
+      meta: { topic },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false,
+      terminalAsRealInput: true
+    }
+  );
+  return { events };
+}
+function requireTopic(state, topic) {
+  return requireTopicRecord(state, topic).node;
+}
+function requireTopicRecord(state, topic) {
+  const record = state.records.get(topic);
+  if (record === void 0) throw new Error(`messageBus: unknown topic '${topic}'`);
+  return record;
+}
+function uniqueTopics(topics, maxTopicLength) {
+  const unique = [...new Set(topics)];
+  if (unique.length !== topics.length) throw new Error("dynamicHub: duplicate topic");
+  for (const topic of unique) assertTopicKey(topic, "dynamicHub", maxTopicLength);
+  return Object.freeze(unique.sort());
+}
+function normalizeUnknownTopicPolicy(policy) {
+  if (policy === void 0) return "error";
+  if (policy === "drop" || policy === "error" || policy === "dead-letter" || policy === "create-as-fact") {
+    return policy;
+  }
+  throw new Error("dynamicHub: unknownTopic policy is not recognized");
+}
+function normalizeHubLimit(value, fallback, owner) {
+  if (value === void 0) return fallback;
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`${owner} must be a positive integer`);
+  }
+  return value;
+}
+function publishHubCommand(commandNode, command) {
+  commandNode.down([["DATA", command]]);
+  return command;
+}
+function parseDynamicHubCommand(value) {
+  if (!isObjectRecord(value)) return "dynamicHub: command fact must be an object";
+  const kind = value.kind;
+  if (kind !== "create" && kind !== "delete" && kind !== "publish" && kind !== "subscribe" && kind !== "close") {
+    return "dynamicHub: command kind is not recognized";
+  }
+  if (kind === "close") {
+    return {
+      kind,
+      ...typeof value.key === "string" ? { key: value.key } : {},
+      ...value.payload === void 0 ? {} : { payload: value.payload }
+    };
+  }
+  const topic = value.topic;
+  if (typeof topic !== "string" || topic.length === 0) {
+    return "dynamicHub: command topic must be a non-empty string";
+  }
+  if (kind === "publish") {
+    if (value.payload === void 0) return "dynamicHub: publish command payload is required";
+    return {
+      kind,
+      topic,
+      payload: value.payload,
+      ...typeof value.key === "string" ? { key: value.key } : {}
+    };
+  }
+  return {
+    kind,
+    topic,
+    ...typeof value.key === "string" ? { key: value.key } : {},
+    ...value.payload === void 0 ? {} : { payload: value.payload }
+  };
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readHubTimestamp(now) {
+  try {
+    const timestampMs = now();
+    return Number.isFinite(timestampMs) ? timestampMs : "dynamicHub: now() must return a finite number";
+  } catch (error) {
+    return `dynamicHub: now() threw: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+function timestampOrFallback(now) {
+  const timestampMs = readHubTimestamp(now);
+  return typeof timestampMs === "number" ? timestampMs : Date.now();
+}
+function reduceDynamicHubCommand(runtime, command, unknownTopic, maxTopics, maxTopicLength, now) {
+  const topic = "topic" in command ? command.topic : void 0;
+  if (topic !== void 0) {
+    const topicError = validateTopicKey(topic, "dynamicHub", maxTopicLength);
+    if (topicError !== void 0) {
+      return [hubError(runtime, command, topicError, timestampOrFallback(now))];
+    }
+  }
+  if (!runtime.open && command.kind !== "close") {
+    return [hubError(runtime, command, "dynamicHub: hub is closed", timestampOrFallback(now))];
+  }
+  switch (command.kind) {
+    case "create": {
+      const capacityError = canAddHubTopic(runtime, command.topic, maxTopics);
+      if (capacityError !== void 0) {
+        return [hubError(runtime, command, capacityError, timestampOrFallback(now))];
+      }
+      const timestampMs = readHubTimestamp(now);
+      if (typeof timestampMs === "string")
+        return [hubError(runtime, command, timestampMs, Date.now())];
+      addHubTopic(runtime, command.topic);
+      return [hubEvent(runtime, timestampMs, command)];
+    }
+    case "delete": {
+      if (!hasHubTopic(runtime, command.topic)) {
+        return unknownHubTopic(runtime, command, unknownTopic, now);
+      }
+      const timestampMs = readHubTimestamp(now);
+      if (typeof timestampMs === "string")
+        return [hubError(runtime, command, timestampMs, Date.now())];
+      deleteHubTopic(runtime, command.topic);
+      return [hubEvent(runtime, timestampMs, command)];
+    }
+    case "publish": {
+      if (!hasHubTopic(runtime, command.topic)) {
+        if (unknownTopic === "create-as-fact") {
+          const capacityError = canAddHubTopic(runtime, command.topic, maxTopics);
+          if (capacityError !== void 0) {
+            return [hubError(runtime, command, capacityError, timestampOrFallback(now))];
+          }
+          const createTimestampMs = readHubTimestamp(now);
+          if (typeof createTimestampMs === "string") {
+            return [hubError(runtime, command, createTimestampMs, Date.now())];
+          }
+          const messageTimestampMs = readHubTimestamp(now);
+          if (typeof messageTimestampMs === "string") {
+            return [hubError(runtime, command, messageTimestampMs, Date.now())];
+          }
+          addHubTopic(runtime, command.topic);
+          return [
+            hubEvent(runtime, createTimestampMs, { kind: "create", topic: command.topic }),
+            hubEvent(runtime, messageTimestampMs, {
+              kind: "message",
+              topic: command.topic,
+              payload: command.payload,
+              ...command.key === void 0 ? {} : { key: command.key }
+            })
+          ];
+        }
+        return unknownHubTopic(runtime, command, unknownTopic, now);
+      }
+      const timestampMs = readHubTimestamp(now);
+      if (typeof timestampMs === "string")
+        return [hubError(runtime, command, timestampMs, Date.now())];
+      return [
+        hubEvent(runtime, timestampMs, {
+          kind: "message",
+          topic: command.topic,
+          payload: command.payload,
+          ...command.key === void 0 ? {} : { key: command.key }
+        })
+      ];
+    }
+    case "subscribe": {
+      if (!hasHubTopic(runtime, command.topic)) {
+        if (unknownTopic === "create-as-fact") {
+          const capacityError = canAddHubTopic(runtime, command.topic, maxTopics);
+          if (capacityError !== void 0) {
+            return [hubError(runtime, command, capacityError, timestampOrFallback(now))];
+          }
+          const createTimestampMs = readHubTimestamp(now);
+          if (typeof createTimestampMs === "string") {
+            return [hubError(runtime, command, createTimestampMs, Date.now())];
+          }
+          const subscribeTimestampMs = readHubTimestamp(now);
+          if (typeof subscribeTimestampMs === "string") {
+            return [hubError(runtime, command, subscribeTimestampMs, Date.now())];
+          }
+          addHubTopic(runtime, command.topic);
+          return [
+            hubEvent(runtime, createTimestampMs, { kind: "create", topic: command.topic }),
+            hubEvent(runtime, subscribeTimestampMs, command)
+          ];
+        }
+        return unknownHubTopic(runtime, command, unknownTopic, now);
+      }
+      const timestampMs = readHubTimestamp(now);
+      if (typeof timestampMs === "string")
+        return [hubError(runtime, command, timestampMs, Date.now())];
+      return [hubEvent(runtime, timestampMs, command)];
+    }
+    case "close": {
+      const timestampMs = readHubTimestamp(now);
+      if (typeof timestampMs === "string")
+        return [hubError(runtime, command, timestampMs, Date.now())];
+      runtime.open = false;
+      return [hubEvent(runtime, timestampMs, command)];
+    }
+  }
+}
+function hubEvent(runtime, timestampMs, event) {
+  const meta = nextHubMetadata(runtime, timestampMs);
+  return {
+    ...event,
+    meta,
+    status: snapshotHubStatus(runtime, meta, event.kind)
+  };
+}
+function hubError(runtime, command, error, timestampMs) {
+  return hubEvent(runtime, timestampMs, {
+    kind: "error",
+    ...isObjectRecord(command) && typeof command.topic === "string" ? { topic: command.topic } : {},
+    error,
+    command
+  });
+}
+function unknownHubTopic(runtime, command, policy, now) {
+  const topic = "topic" in command ? command.topic : void 0;
+  const reason = `dynamicHub: unknown topic '${topic ?? ""}'`;
+  if (policy === "drop") return [];
+  if (policy === "dead-letter") {
+    return [
+      hubEvent(runtime, timestampOrFallback(now), {
+        kind: "dead-letter",
+        ...topic === void 0 ? {} : { topic },
+        reason,
+        command
+      })
+    ];
+  }
+  return [hubError(runtime, command, reason, timestampOrFallback(now))];
+}
+function nextHubMetadata(runtime, timestampMs) {
+  runtime.seq += 1;
+  runtime.cursor = runtime.seq;
+  return { seq: runtime.seq, cursor: runtime.cursor, timestampMs };
+}
+function snapshotHubStatus(runtime, meta, kind) {
+  return {
+    open: runtime.open,
+    topics: Object.freeze([...runtime.topics].sort()),
+    seq: meta.seq,
+    cursor: meta.cursor,
+    lastEventKind: kind
+  };
+}
+function assertTopicKey(topic, owner, maxTopicLength) {
+  const error = validateTopicKey(topic, owner, maxTopicLength);
+  if (error !== void 0) throw new Error(error);
+}
+function validateTopicKey(topic, owner, maxTopicLength) {
+  if (typeof topic !== "string" || topic.length === 0) {
+    return `${owner}: topic must be a non-empty string`;
+  }
+  if (topic.length > maxTopicLength) {
+    return `${owner}: topic exceeds maxTopicLength`;
+  }
+  return void 0;
+}
+function hasHubTopic(runtime, topic) {
+  return runtime.topics.includes(topic);
+}
+function addHubTopic(runtime, topic) {
+  if (!hasHubTopic(runtime, topic)) runtime.topics = [...runtime.topics, topic];
+}
+function deleteHubTopic(runtime, topic) {
+  runtime.topics = runtime.topics.filter((existing) => existing !== topic);
+}
+function canAddHubTopic(runtime, topic, maxTopics) {
+  if (hasHubTopic(runtime, topic)) return void 0;
+  return runtime.topics.length >= maxTopics ? "dynamicHub: topic count exceeds maxTopics" : void 0;
+}
+function isReachableUpstream(from, target) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [from];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === void 0) continue;
+    if (node === target) return true;
+    if (seen.has(node)) continue;
+    seen.add(node);
+    for (const dep of node.deps) stack.push(dep);
+  }
+  return false;
+}
+function requireDynamicHubState(hub) {
+  const state = dynamicHubStates.get(hub);
+  if (state === void 0) throw new Error("dynamicHub: unknown hub implementation");
+  return state;
+}
+export {
+  CONTEXT_TOPIC,
+  DEFERRED_TOPIC,
+  INJECTIONS_TOPIC,
+  PROMPTS_TOPIC,
+  RESPONSES_TOPIC,
+  SPAWNS_TOPIC,
+  STANDARD_TOPICS,
+  TODOS_TOPIC,
+  dynamicHub,
+  fromHubTopic,
+  fromTopic,
+  messageBus,
+  toHubTopic,
+  toTopic
+};
+//# sourceMappingURL=index.js.map