@graphrefly/ts 0.0.0 → 0.0.2

package/dist/chunk-PVC7WDKI.js

@@ -0,0 +1,885 @@
+import {
+  attachMessageBusCommandSource,
+  getMessageBusState,
+  registerMessageBusState
+} from "./chunk-UT3MHJCW.js";
+import {
+  depBatch
+} from "./chunk-WQIA3GFB.js";
+
+// src/messaging/utils.ts
+function pullParams(pull) {
+  return isObjectRecord(pull?.params) ? pull.params : {};
+}
+function publishCommand(commandNode, command) {
+  commandNode.down([["DATA", command]]);
+  return command;
+}
+function makeTopicState() {
+  return { closed: false, headSeq: 1, nextSeq: 1, messages: [] };
+}
+function uniqueTopics(topics) {
+  const unique = [...new Set(topics)];
+  if (unique.length !== topics.length) throw new Error("messageBus: duplicate topic");
+  for (const topic of unique) assertTopicKey(topic, "messageBus");
+  return Object.freeze(unique.sort());
+}
+function assertTopicKey(topic, owner) {
+  const error = validateTopicKey(topic, owner);
+  if (error !== void 0) throw new Error(error);
+}
+function validateTopicKey(topic, owner) {
+  if (typeof topic !== "string" || topic.length === 0)
+    return `${owner}: topic must be a non-empty string`;
+  return void 0;
+}
+function assertNonEmpty(value, owner) {
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error(`${owner}: must be a non-empty string`);
+}
+function positiveLimit(limit) {
+  if (limit === void 0) return 100;
+  if (!Number.isInteger(limit) || limit < 1)
+    throw new Error("messageBus: limit must be a positive integer");
+  return limit;
+}
+function isPositiveSeq(value) {
+  return Number.isInteger(value) && value >= 1;
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function commandTopic(command) {
+  return isObjectRecord(command) && typeof command.topic === "string" ? command.topic : void 0;
+}
+function commandIdOf(command) {
+  return isObjectRecord(command) && typeof command.commandId === "string" ? command.commandId : void 0;
+}
+function idempotencyKey(topic, key) {
+  return `${topic}\0${key}`;
+}
+
+// src/messaging/event-message.ts
+function eventMessage(type, payload, opts) {
+  assertNonEmpty(type, "eventMessage.type");
+  assertNonEmpty(opts.id, "eventMessage.id");
+  return {
+    id: opts.id,
+    type,
+    payload,
+    ...opts.key === void 0 ? {} : { key: opts.key },
+    ...opts.subjectId === void 0 ? {} : { subjectId: opts.subjectId },
+    ...opts.correlationId === void 0 ? {} : { correlationId: opts.correlationId },
+    ...opts.causationId === void 0 ? {} : { causationId: opts.causationId },
+    ...opts.occurredAtMs === void 0 ? {} : { occurredAtMs: opts.occurredAtMs },
+    ...opts.actor === void 0 ? {} : { actor: opts.actor },
+    ...opts.evidenceRefs === void 0 ? {} : { evidenceRefs: opts.evidenceRefs },
+    ...opts.schema === void 0 ? {} : { schema: opts.schema },
+    ...opts.metadata === void 0 ? {} : { metadata: opts.metadata }
+  };
+}
+function isEventMessage(value) {
+  return eventMessageIssue(value) === void 0;
+}
+function eventMessageIssue(value) {
+  if (!isObjectRecord(value)) {
+    return eventIssue("event message must be an object");
+  }
+  if (typeof value.id !== "string" || value.id.length === 0) {
+    return eventIssue("event message id must be a non-empty string");
+  }
+  if (typeof value.type !== "string" || value.type.length === 0) {
+    return eventIssue("event message type must be a non-empty string");
+  }
+  if (!("payload" in value)) {
+    return eventIssue("event message payload field is required");
+  }
+  return void 0;
+}
+function eventIssue(message) {
+  return {
+    kind: "issue",
+    code: "malformed-event-message",
+    message,
+    severity: "error",
+    source: "messageBus.eventMessage"
+  };
+}
+
+// src/messaging/types.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
+]);
+
+// src/messaging/index.ts
+function messageBus(graph, opts = {}) {
+  const name = opts.name ?? "messageBus";
+  const initialTopics = uniqueTopics(opts.topics ?? []);
+  const commandSources = [];
+  const commandBody = (ctx) => {
+    for (let i = 0; i < commandSources.length; i++) {
+      for (const command of depBatch(ctx, i) ?? []) ctx.down([["DATA", command]]);
+    }
+  };
+  const commands = graph.node([], commandBody, {
+    name: `${name}/commands`,
+    factory: "messageBusCommands",
+    completeWhenDepsComplete: false,
+    errorWhenDepsError: false
+  });
+  const state = {
+    graph,
+    name,
+    now: opts.now ?? Date.now,
+    topicPolicy: opts.topicPolicy ?? "strict",
+    retention: opts.retention ?? {},
+    dedupe: opts.dedupe ?? { commandId: "status" },
+    topics: new Map(initialTopics.map((topic) => [topic, makeTopicState()])),
+    subscriptions: /* @__PURE__ */ new Map(),
+    seenCommandIds: /* @__PURE__ */ new Set(),
+    seenIdempotencyKeys: /* @__PURE__ */ new Set(),
+    deadLetters: [],
+    deadLetterSeq: 0,
+    commandSources,
+    commandBody
+  };
+  const runtime = graph.node(
+    [commands],
+    (ctx) => {
+      for (const command of depBatch(ctx, 0) ?? []) {
+        for (const event of reduceMessageBusCommand(state, command)) {
+          ctx.down([["DATA", event]]);
+        }
+      }
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "messageBusRuntime",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  graph.retain(runtime, { reason: `${name}.messageBus.runtime` });
+  const messages = graph.node(
+    [runtime],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind === "message") ctx.down([["DATA", typed.message]]);
+      }
+    },
+    {
+      name: `${name}/messages`,
+      factory: "messageBusMessages",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const status = graph.node(
+    [runtime],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind === "status") ctx.down([["DATA", typed.status]]);
+      }
+    },
+    {
+      name: `${name}/status`,
+      factory: "messageBusStatus",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const issues = graph.node(
+    [runtime],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if (typed.kind === "issue") ctx.down([["DATA", typed.issue]]);
+      }
+    },
+    {
+      name: `${name}/issues`,
+      factory: "messageBusIssues",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const bus = {
+    commands,
+    messages,
+    status,
+    issues,
+    ensureTopic(topic, commandOpts = {}) {
+      return publishCommand(commands, {
+        kind: "ensure-topic",
+        topic,
+        ...commandOpts.commandId === void 0 ? {} : { commandId: commandOpts.commandId }
+      });
+    },
+    closeTopic(topic, commandOpts = {}) {
+      return publishCommand(commands, {
+        kind: "close-topic",
+        topic,
+        ...commandOpts.commandId === void 0 ? {} : { commandId: commandOpts.commandId }
+      });
+    },
+    publish(topic, payload, publishOpts = {}) {
+      return publishCommand(commands, {
+        kind: "publish",
+        topic,
+        payload,
+        ...publishOpts.key === void 0 ? {} : { key: publishOpts.key },
+        ...publishOpts.commandId === void 0 ? {} : { commandId: publishOpts.commandId },
+        ...publishOpts.idempotencyKey === void 0 ? {} : { idempotencyKey: publishOpts.idempotencyKey }
+      });
+    },
+    topic(topic, projectionOpts = {}) {
+      assertTopicKey(topic, "messageBus.topic");
+      const snapshotPullId = /* @__PURE__ */ Symbol(`${name}/${topic}/topicSnapshot`);
+      const snapshot = graph.node(
+        [messages],
+        (ctx) => {
+          const params = pullParams(ctx.pull);
+          ctx.down([["DATA", topicPage(state, topic, params)]]);
+        },
+        {
+          name: projectionOpts.name ?? `${name}/${topic}/topic`,
+          factory: "messageBusTopicProjection",
+          meta: { topic },
+          pullId: snapshotPullId,
+          partial: true,
+          completeWhenDepsComplete: false,
+          errorWhenDepsError: false
+        }
+      );
+      return { snapshot, snapshotPullId, status, issues };
+    },
+    catalog(projectionOpts = {}) {
+      const snapshotPullId = /* @__PURE__ */ Symbol(`${name}/catalogSnapshot`);
+      const snapshot = graph.node(
+        [runtime],
+        (ctx) => {
+          const params = pullParams(ctx.pull);
+          ctx.down([["DATA", catalogPage(state, params)]]);
+        },
+        {
+          name: projectionOpts.name ?? `${name}/catalog`,
+          factory: "messageBusCatalog",
+          pullId: snapshotPullId,
+          partial: true,
+          completeWhenDepsComplete: false,
+          errorWhenDepsError: false
+        }
+      );
+      return { snapshot, snapshotPullId, status, issues };
+    },
+    deadLetter(projectionOpts = {}) {
+      const snapshotPullId = /* @__PURE__ */ Symbol(`${name}/deadLetterSnapshot`);
+      const snapshot = graph.node(
+        [runtime],
+        (ctx) => {
+          const params = pullParams(ctx.pull);
+          ctx.down([["DATA", deadLetterPage(state, params)]]);
+        },
+        {
+          name: projectionOpts.name ?? `${name}/deadLetter`,
+          factory: "messageBusDeadLetter",
+          pullId: snapshotPullId,
+          partial: true,
+          completeWhenDepsComplete: false,
+          errorWhenDepsError: false
+        }
+      );
+      return { snapshot, snapshotPullId, status, issues };
+    },
+    subscription(subscriptionOpts) {
+      assertTopicKey(subscriptionOpts.topic, "messageBus.subscription");
+      assertNonEmpty(subscriptionOpts.subscriptionId, "messageBus.subscriptionId");
+      const sub = ensureSubscription(state, {
+        topic: subscriptionOpts.topic,
+        subscriptionId: subscriptionOpts.subscriptionId,
+        from: subscriptionOpts.from ?? "earliest"
+      });
+      const availablePullId = /* @__PURE__ */ Symbol(
+        `${name}/${subscriptionOpts.topic}/${subscriptionOpts.subscriptionId}/available`
+      );
+      const projectionName = subscriptionOpts.name ?? `${name}/${subscriptionOpts.topic}/${subscriptionOpts.subscriptionId}`;
+      const available = graph.node(
+        [messages, status],
+        (ctx) => {
+          const params = pullParams(ctx.pull);
+          ctx.down([["DATA", availablePage(state, sub, params)]]);
+        },
+        {
+          name: `${projectionName}/available`,
+          factory: "messageBusSubscriptionAvailable",
+          meta: { topic: subscriptionOpts.topic, subscriptionId: subscriptionOpts.subscriptionId },
+          pullId: availablePullId,
+          partial: true,
+          completeWhenDepsComplete: false,
+          errorWhenDepsError: false
+        }
+      );
+      const cursor = graph.node(
+        [status],
+        (ctx) => {
+          for (const fact of depBatch(ctx, 0) ?? []) {
+            const typed = fact;
+            const subscriptionMoved = typed.topic === sub.topic && typed.subscriptionId === sub.subscriptionId && (typed.kind === "subscription-acked" || typed.kind === "subscription-sought" || typed.kind === "subscription-closed");
+            const retentionMoved = typed.topic === sub.topic && typed.kind === "retention-trimmed";
+            if (subscriptionMoved || retentionMoved) {
+              ctx.down([["DATA", cursorSnapshot(state, sub)]]);
+            }
+          }
+        },
+        {
+          name: `${projectionName}/cursor`,
+          factory: "messageBusSubscriptionCursor",
+          completeWhenDepsComplete: false,
+          errorWhenDepsError: false
+        }
+      );
+      return {
+        available,
+        availablePullId,
+        cursor,
+        status,
+        issues,
+        ack(seq, commandOpts = {}) {
+          return publishCommand(commands, {
+            kind: "ack",
+            topic: sub.topic,
+            subscriptionId: sub.subscriptionId,
+            seq,
+            ...commandOpts.commandId === void 0 ? {} : { commandId: commandOpts.commandId }
+          });
+        },
+        seek(nextSeq, commandOpts = {}) {
+          return publishCommand(commands, {
+            kind: "seek",
+            topic: sub.topic,
+            subscriptionId: sub.subscriptionId,
+            nextSeq,
+            ...commandOpts.commandId === void 0 ? {} : { commandId: commandOpts.commandId }
+          });
+        },
+        close(commandOpts = {}) {
+          return publishCommand(commands, {
+            kind: "close-subscription",
+            topic: sub.topic,
+            subscriptionId: sub.subscriptionId,
+            ...commandOpts.commandId === void 0 ? {} : { commandId: commandOpts.commandId }
+          });
+        }
+      };
+    }
+  };
+  registerMessageBusState(bus, state);
+  return bus;
+}
+function fromTopic(bus, topic) {
+  return bus.topic(topic).snapshot;
+}
+function toTopic(graph, source, bus, topic, opts = {}) {
+  const state = getMessageBusState(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");
+  assertTopicKey(topic, "toTopic");
+  const commands = graph.node(
+    [source],
+    (ctx) => {
+      for (const value of depBatch(ctx, 0) ?? []) {
+        const key = opts.keyOf?.(value);
+        const commandId = opts.commandIdOf?.(value);
+        ctx.down([
+          [
+            "DATA",
+            {
+              kind: "publish",
+              topic,
+              payload: value,
+              ...key === void 0 ? {} : { key },
+              ...commandId === void 0 ? {} : { commandId }
+            }
+          ]
+        ]);
+      }
+    },
+    {
+      name: opts.name ?? `${state.name}/${topic}/toTopic`,
+      factory: "toTopic",
+      meta: { topic },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const releaseSource = attachMessageBusCommandSource(
+    graph,
+    bus,
+    commands
+  );
+  let released = false;
+  return {
+    commands,
+    release() {
+      if (released) return;
+      released = true;
+      releaseSource();
+    }
+  };
+}
+function reduceMessageBusCommand(state, command) {
+  const malformed = validateCommand(command);
+  if (malformed !== void 0) return rejectCommand(state, command, malformed);
+  if (command.commandId !== void 0) {
+    if (state.seenCommandIds.has(command.commandId)) {
+      return duplicateCommandEvents(state, command, "duplicate commandId");
+    }
+    state.seenCommandIds.add(command.commandId);
+  }
+  if (command.kind === "publish" && command.idempotencyKey !== void 0 && state.seenIdempotencyKeys.has(idempotencyKey(command.topic, command.idempotencyKey))) {
+    return duplicateCommandEvents(state, command, "duplicate idempotencyKey");
+  }
+  switch (command.kind) {
+    case "ensure-topic":
+      return ensureTopic(state, command.topic, command.commandId);
+    case "close-topic": {
+      const topic = state.topics.get(command.topic);
+      if (topic === void 0) {
+        return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+      }
+      topic.closed = true;
+      return [
+        {
+          kind: "status",
+          status: statusFact(state, "topic-closed", {
+            topic: command.topic,
+            commandId: command.commandId
+          })
+        }
+      ];
+    }
+    case "topic-policy":
+      state.topicPolicy = command.topicPolicy;
+      return [
+        {
+          kind: "status",
+          status: statusFact(state, "projection-ready", {
+            commandId: command.commandId,
+            details: { topicPolicy: command.topicPolicy }
+          })
+        }
+      ];
+    case "publish":
+      return publishMessage(state, command);
+    case "ack":
+      return ackSubscription(state, command);
+    case "seek":
+      return seekSubscription(state, command);
+    case "close-subscription":
+      return closeSubscription(state, command);
+  }
+}
+function publishMessage(state, command) {
+  let topic = state.topics.get(command.topic);
+  const events = [];
+  if (topic === void 0) {
+    if (state.topicPolicy !== "create-as-fact") {
+      return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+    }
+    events.push(...ensureTopic(state, command.topic, command.commandId));
+    topic = state.topics.get(command.topic);
+  }
+  if (topic === void 0)
+    return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+  if (topic.closed)
+    return issueEvents(state, command, "closed-topic", `closed topic '${command.topic}'`);
+  const message = {
+    topic: command.topic,
+    seq: topic.nextSeq++,
+    payload: command.payload,
+    timestampMs: state.now(),
+    ...command.key === void 0 ? {} : { key: command.key },
+    ...command.idempotencyKey === void 0 ? {} : { idempotencyKey: command.idempotencyKey },
+    ...command.commandId === void 0 ? {} : { commandId: command.commandId }
+  };
+  if (command.idempotencyKey !== void 0) {
+    state.seenIdempotencyKeys.add(idempotencyKey(command.topic, command.idempotencyKey));
+  }
+  topic.messages.push(message);
+  events.push({ kind: "message", message });
+  events.push({
+    kind: "status",
+    status: statusFact(state, "message-published", {
+      topic: command.topic,
+      seq: message.seq,
+      commandId: command.commandId
+    })
+  });
+  events.push(...trimRetention(state, command.topic, topic));
+  return events;
+}
+function ensureTopic(state, topic, commandId) {
+  assertTopicKey(topic, "messageBus");
+  if (!state.topics.has(topic)) state.topics.set(topic, makeTopicState());
+  return [
+    {
+      kind: "status",
+      status: statusFact(state, "topic-created", { topic, commandId })
+    }
+  ];
+}
+function trimRetention(state, topicName, topic) {
+  const max = state.retention.maxMessages;
+  if (max === void 0 || topic.messages.length <= max) return [];
+  if (!Number.isInteger(max) || max < 1) {
+    return issueEvents(
+      state,
+      { kind: "publish", topic: topicName, payload: void 0 },
+      "policy-rejected",
+      "retention.maxMessages must be a positive integer"
+    );
+  }
+  const trimCount = topic.messages.length - max;
+  topic.messages.splice(0, trimCount);
+  topic.headSeq = topic.messages[0]?.seq ?? topic.nextSeq;
+  const events = [
+    {
+      kind: "status",
+      status: statusFact(state, "retention-trimmed", {
+        topic: topicName,
+        headSeq: topic.headSeq,
+        details: { trimCount }
+      })
+    }
+  ];
+  for (const sub of state.subscriptions.values()) {
+    if (sub.closed || sub.topic !== topicName || sub.nextSeq >= topic.headSeq) continue;
+    sub.retentionGap = true;
+    events.push(
+      ...issueEvents(
+        state,
+        {
+          kind: "seek",
+          topic: topicName,
+          subscriptionId: sub.subscriptionId,
+          nextSeq: sub.nextSeq
+        },
+        "retention-gap",
+        `subscription '${sub.subscriptionId}' is before retained headSeq`
+      )
+    );
+  }
+  return events;
+}
+function ackSubscription(state, command) {
+  const topic = state.topics.get(command.topic);
+  if (topic === void 0)
+    return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+  const sub = getSubscription(state, command.topic, command.subscriptionId);
+  if (sub === void 0)
+    return issueEvents(
+      state,
+      command,
+      "unknown-subscription",
+      `unknown subscription '${command.subscriptionId}'`
+    );
+  if (sub.closed)
+    return issueEvents(state, command, "subscription-closed", "subscription is closed");
+  if (sub.retentionGap)
+    return issueEvents(state, command, "retention-gap", "subscription must seek before ack");
+  if (command.seq < sub.nextSeq)
+    return issueEvents(state, command, "source-cursor-stale", "ack is behind subscription cursor");
+  if (command.seq >= topic.nextSeq)
+    return issueEvents(state, command, "cursor-out-of-range", "ack is beyond topic tail");
+  sub.nextSeq = Math.max(sub.nextSeq, command.seq + 1);
+  return [
+    {
+      kind: "status",
+      status: statusFact(state, "subscription-acked", {
+        topic: command.topic,
+        subscriptionId: command.subscriptionId,
+        nextSeq: sub.nextSeq,
+        commandId: command.commandId
+      })
+    }
+  ];
+}
+function seekSubscription(state, command) {
+  const topic = state.topics.get(command.topic);
+  if (topic === void 0)
+    return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+  const sub = getSubscription(state, command.topic, command.subscriptionId);
+  if (sub === void 0)
+    return issueEvents(
+      state,
+      command,
+      "unknown-subscription",
+      `unknown subscription '${command.subscriptionId}'`
+    );
+  if (sub.closed)
+    return issueEvents(state, command, "subscription-closed", "subscription is closed");
+  if (command.nextSeq < topic.headSeq)
+    return issueEvents(state, command, "retention-gap", "seek is before retained headSeq");
+  if (command.nextSeq > topic.nextSeq)
+    return issueEvents(state, command, "cursor-out-of-range", "seek is beyond topic tail");
+  sub.nextSeq = command.nextSeq;
+  sub.retentionGap = false;
+  return [
+    {
+      kind: "status",
+      status: statusFact(state, "subscription-sought", {
+        topic: command.topic,
+        subscriptionId: command.subscriptionId,
+        nextSeq: sub.nextSeq,
+        commandId: command.commandId
+      })
+    }
+  ];
+}
+function closeSubscription(state, command) {
+  if (!state.topics.has(command.topic))
+    return issueEvents(state, command, "unknown-topic", `unknown topic '${command.topic}'`);
+  const sub = getSubscription(state, command.topic, command.subscriptionId);
+  if (sub === void 0)
+    return issueEvents(
+      state,
+      command,
+      "unknown-subscription",
+      `unknown subscription '${command.subscriptionId}'`
+    );
+  sub.closed = true;
+  return [
+    {
+      kind: "status",
+      status: statusFact(state, "subscription-closed", {
+        topic: command.topic,
+        subscriptionId: command.subscriptionId,
+        nextSeq: sub.nextSeq,
+        commandId: command.commandId
+      })
+    }
+  ];
+}
+function issueEvents(state, command, code, message) {
+  const topic = commandTopic(command);
+  const commandId = commandIdOf(command);
+  const issue = {
+    kind: "issue",
+    code,
+    message,
+    severity: "error",
+    source: "messageBus",
+    details: command,
+    metadata: topic === void 0 ? void 0 : { topic }
+  };
+  const entry = {
+    entrySeq: ++state.deadLetterSeq,
+    ...topic === void 0 ? {} : { topic },
+    ...isObjectRecord(command) ? { command } : {},
+    issue,
+    timestampMs: state.now()
+  };
+  state.deadLetters.push(entry);
+  return [
+    { kind: "issue", issue },
+    { kind: "dead-letter", entry },
+    {
+      kind: "status",
+      status: statusFact(state, "command-rejected", {
+        topic,
+        commandId,
+        issueCode: code
+      })
+    }
+  ];
+}
+function rejectCommand(state, command, reason) {
+  return issueEvents(state, command, "malformed-command", reason);
+}
+function duplicateCommandEvents(state, command, message) {
+  const status = statusFact(state, "duplicate-command", {
+    topic: "topic" in command ? command.topic : void 0,
+    commandId: command.commandId
+  });
+  if (state.dedupe.commandId === "issue") {
+    return [
+      { kind: "status", status },
+      ...issueEvents(state, command, "duplicate-command", message)
+    ];
+  }
+  return [{ kind: "status", status }];
+}
+function statusFact(state, kind, fields) {
+  return {
+    kind,
+    timestampMs: state.now(),
+    ...fields.topic === void 0 ? {} : { topic: fields.topic },
+    ...fields.seq === void 0 ? {} : { seq: fields.seq },
+    ...fields.headSeq === void 0 ? {} : { headSeq: fields.headSeq },
+    ...fields.subscriptionId === void 0 ? {} : { subscriptionId: fields.subscriptionId },
+    ...fields.nextSeq === void 0 ? {} : { nextSeq: fields.nextSeq },
+    ...fields.commandId === void 0 ? {} : { commandId: fields.commandId },
+    ...fields.issueCode === void 0 ? {} : { issueCode: fields.issueCode },
+    ...fields.details === void 0 ? {} : { details: fields.details }
+  };
+}
+function validateCommand(command) {
+  if (!isObjectRecord(command)) return "command must be an object";
+  if (typeof command.kind !== "string") return "command kind is required";
+  if (!isMessageBusCommandKind(command.kind)) return `unknown command kind '${command.kind}'`;
+  if ("topic" in command) {
+    if (typeof command.topic !== "string") return "messageBus: topic must be a non-empty string";
+    const topicError = validateTopicKey(command.topic, "messageBus");
+    if (topicError !== void 0) return topicError;
+  }
+  if ("subscriptionId" in command && typeof command.subscriptionId !== "string") {
+    return "subscriptionId must be a string";
+  }
+  if (command.kind === "publish" && command.payload === void 0)
+    return "publish payload is required";
+  if (command.kind === "ack" && !isPositiveSeq(command.seq))
+    return "ack seq must be a positive integer";
+  if (command.kind === "seek" && !isPositiveSeq(command.nextSeq)) {
+    return "seek nextSeq must be a positive integer";
+  }
+  if (command.kind === "topic-policy" && command.topicPolicy !== "strict" && command.topicPolicy !== "create-as-fact") {
+    return "topicPolicy is not recognized";
+  }
+  return void 0;
+}
+function isMessageBusCommandKind(kind) {
+  return kind === "ensure-topic" || kind === "close-topic" || kind === "publish" || kind === "topic-policy" || kind === "ack" || kind === "seek" || kind === "close-subscription";
+}
+function catalogPage(state, params) {
+  const limit = positiveLimit(params.limit);
+  const topics = [...state.topics.entries()].filter(
+    ([topic, value]) => (params.includeClosed ? true : !value.closed) && (params.afterTopic === void 0 || topic > params.afterTopic)
+  ).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  const page = topics.slice(0, limit);
+  const hasMore = topics.length > limit;
+  return {
+    topics: page.map(([topic, value]) => ({
+      topic,
+      closed: value.closed,
+      headSeq: value.headSeq,
+      nextSeq: value.nextSeq,
+      messageCount: value.messages.length
+    })),
+    ...hasMore && page.length > 0 ? { nextAfterTopic: page[page.length - 1]?.[0] } : {},
+    hasMore
+  };
+}
+function topicPage(state, topicName, params) {
+  const topic = state.topics.get(topicName);
+  const start = params.afterSeq === void 0 ? topic?.headSeq ?? 1 : params.afterSeq + 1;
+  const all = (topic?.messages ?? []).filter((message) => message.seq >= start);
+  const limit = positiveLimit(params.limit);
+  const messages = all.slice(0, limit);
+  const hasMore = all.length > limit;
+  return {
+    topic: topicName,
+    messages,
+    fromSeq: start,
+    ...messages.length > 0 ? { throughSeq: messages[messages.length - 1]?.seq } : {},
+    ...hasMore && messages.length > 0 ? { nextAfterSeq: messages[messages.length - 1]?.seq } : {},
+    hasMore
+  };
+}
+function availablePage(state, sub, params) {
+  const cursor = cursorSnapshot(state, sub);
+  const start = params.afterSeq === void 0 ? sub.nextSeq : params.afterSeq + 1;
+  const topic = state.topics.get(sub.topic);
+  const all = sub.retentionGap ? [] : (topic?.messages ?? []).filter((message) => message.seq >= start);
+  const limit = positiveLimit(params.limit);
+  const messages = all.slice(0, limit);
+  const hasMore = all.length > limit;
+  return {
+    topic: sub.topic,
+    subscriptionId: sub.subscriptionId,
+    cursor,
+    messages,
+    fromSeq: start,
+    ...messages.length > 0 ? { throughSeq: messages[messages.length - 1]?.seq } : {},
+    ...hasMore && messages.length > 0 ? { nextAfterSeq: messages[messages.length - 1]?.seq } : {},
+    hasMore
+  };
+}
+function deadLetterPage(state, params) {
+  const limit = positiveLimit(params.limit);
+  const entries = state.deadLetters.filter((entry) => {
+    if (params.afterEntrySeq !== void 0 && entry.entrySeq <= params.afterEntrySeq) return false;
+    if (params.topic !== void 0 && entry.topic !== params.topic) return false;
+    if (params.code !== void 0 && entry.issue.code !== params.code) return false;
+    return true;
+  });
+  const page = entries.slice(0, limit);
+  const hasMore = entries.length > limit;
+  return {
+    entries: page,
+    ...hasMore && page.length > 0 ? { nextAfterEntrySeq: page[page.length - 1]?.entrySeq } : {},
+    hasMore
+  };
+}
+function cursorSnapshot(state, sub) {
+  const topic = state.topics.get(sub.topic);
+  return {
+    topic: sub.topic,
+    subscriptionId: sub.subscriptionId,
+    nextSeq: sub.nextSeq,
+    closed: sub.closed,
+    retentionGap: sub.retentionGap,
+    headSeq: topic?.headSeq ?? 1
+  };
+}
+function ensureSubscription(state, opts) {
+  const key = `${opts.topic}\0${opts.subscriptionId}`;
+  const existing = state.subscriptions.get(key);
+  if (existing !== void 0) return existing;
+  const topic = state.topics.get(opts.topic);
+  const nextSeq = opts.from === "earliest" ? topic?.headSeq ?? 1 : opts.from === "latest" ? topic?.nextSeq ?? 1 : opts.from;
+  const sub = {
+    topic: opts.topic,
+    subscriptionId: opts.subscriptionId,
+    nextSeq,
+    closed: false,
+    retentionGap: topic !== void 0 && nextSeq < topic.headSeq
+  };
+  state.subscriptions.set(key, sub);
+  return sub;
+}
+function getSubscription(state, topic, subscriptionId) {
+  return state.subscriptions.get(`${topic}\0${subscriptionId}`);
+}
+
+export {
+  eventMessage,
+  isEventMessage,
+  eventMessageIssue,
+  PROMPTS_TOPIC,
+  RESPONSES_TOPIC,
+  INJECTIONS_TOPIC,
+  DEFERRED_TOPIC,
+  SPAWNS_TOPIC,
+  CONTEXT_TOPIC,
+  TODOS_TOPIC,
+  STANDARD_TOPICS,
+  messageBus,
+  fromTopic,
+  toTopic
+};
+//# sourceMappingURL=chunk-PVC7WDKI.js.map