@graphrefly/ts 0.0.0

package/dist/adapters/index.js

@@ -0,0 +1,2894 @@
+import {
+  AGENTIC_MEMORY_RECORD_CHANGE_FORMAT,
+  AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+  AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+  agenticMemoryRecordChangeFrame,
+  agenticMemoryRecordSnapshotFrame,
+  agenticMemoryRecordsSnapshotKey,
+  assertAgenticMemoryRecordChangeFrame,
+  assertAgenticMemoryRecordSnapshotFrame,
+  loadAgenticMemoryRecordsState,
+  openPersistentAgenticMemoryRecords,
+  openPersistentReactiveIndex,
+  openPersistentReactiveList,
+  openPersistentReactiveLog,
+  openPersistentReactiveMap,
+  persistAgenticMemoryRecords,
+  persistReactiveCollection
+} from "../chunk-DJC4CHLQ.js";
+import "../chunk-GTPCOEOZ.js";
+import "../chunk-COHO25CZ.js";
+import "../chunk-JIMUDQN3.js";
+import "../chunk-K3FXTC3I.js";
+import "../chunk-6PHB5CJS.js";
+import "../chunk-Z2ANQ6JW.js";
+import "../chunk-2ILL7HQI.js";
+import {
+  nextRetryDelayMs,
+  retryPolicy,
+  shouldRetry
+} from "../chunk-OOEN33FB.js";
+import "../chunk-DKP56CSW.js";
+import "../chunk-RIIOUTGM.js";
+import "../chunk-G4M3NHRJ.js";
+import "../chunk-PKVBHGBM.js";
+import "../chunk-I3IHOHCJ.js";
+import "../chunk-4VLAQHZI.js";
+import {
+  depBatch
+} from "../chunk-SWTLEQL6.js";
+import {
+  errorPayload
+} from "../chunk-DK554R7P.js";
+
+// src/adapters/bridge.ts
+var envelopeTypes = /* @__PURE__ */ new Set([
+  "start",
+  "data",
+  "ack",
+  "nack",
+  "status",
+  "error",
+  "close"
+]);
+var defaultAckTimeoutMs = 3e4;
+var bridgeCommandSources = /* @__PURE__ */ new WeakMap();
+var bridgeInboundTargets = /* @__PURE__ */ new WeakMap();
+function wireBridgeIdempotencyKey(sessionId, seq) {
+  return `${sessionId}:${seq}`;
+}
+function wireBridgeEnvelope(input) {
+  if (typeof input.sessionId !== "string" || input.sessionId.length === 0) {
+    throw new RangeError("wireBridgeEnvelope: sessionId must be a non-empty string");
+  }
+  if (!envelopeTypes.has(input.type)) {
+    throw new RangeError("wireBridgeEnvelope: type is not recognized");
+  }
+  if (!isSafePositiveInteger(input.seq)) {
+    throw new RangeError("wireBridgeEnvelope: seq must be a positive integer");
+  }
+  const cursor = input.cursor ?? 0;
+  if (!isSafeNonNegativeInteger(cursor)) {
+    throw new RangeError("wireBridgeEnvelope: cursor must be a non-negative integer");
+  }
+  const attempt = input.attempt ?? 1;
+  if (!isSafePositiveInteger(attempt)) {
+    throw new RangeError("wireBridgeEnvelope: attempt must be a positive integer");
+  }
+  const maxAttempts = input.maxAttempts ?? attempt;
+  if (!isSafePositiveInteger(maxAttempts) || maxAttempts < attempt) {
+    throw new RangeError("wireBridgeEnvelope: maxAttempts must be >= attempt");
+  }
+  if (input.ackForSeq !== void 0 && !isSafePositiveInteger(input.ackForSeq)) {
+    throw new RangeError("wireBridgeEnvelope: ackForSeq must be a positive integer");
+  }
+  if ((input.type === "ack" || input.type === "nack") && input.ackForSeq === void 0) {
+    throw new RangeError(`wireBridgeEnvelope: ${input.type} envelope requires ackForSeq`);
+  }
+  if (input.idempotencyKey !== void 0 && input.idempotencyKey.length === 0) {
+    throw new RangeError("wireBridgeEnvelope: idempotencyKey must be a non-empty string");
+  }
+  const payloadError = validatePayloadForType(input.type, input.payload, "wireBridgeEnvelope");
+  if (payloadError !== void 0) {
+    throw new RangeError(payloadError);
+  }
+  return {
+    sessionId: input.sessionId,
+    type: input.type,
+    payload: input.payload,
+    metadata: {
+      seq: input.seq,
+      cursor,
+      idempotencyKey: input.idempotencyKey ?? wireBridgeIdempotencyKey(input.sessionId, input.seq),
+      attempt,
+      maxAttempts,
+      timestampMs: input.timestampMs,
+      ackForSeq: input.ackForSeq,
+      requestId: input.requestId
+    }
+  };
+}
+function wireBridge(graph, opts) {
+  const name = opts.name ?? "wireBridge";
+  const policy = opts.retry ?? retryPolicy();
+  const command = graph.node([], null, {
+    name: `${name}/command`,
+    factory: "wireBridgeCommand"
+  });
+  const inboundCore = graph.node(
+    [],
+    null,
+    {
+      name: `${name}/inbound`,
+      factory: "wireBridgeInbound"
+    }
+  );
+  const inbound = guardedInboundNode(inboundCore, opts.sessionId);
+  const events = wireBridgeEventsNode(
+    graph,
+    command,
+    inboundCore,
+    name,
+    opts,
+    policy
+  );
+  const outbound = projectOutbound(graph, events, name);
+  const acks = projectAcks(graph, events, name);
+  const nacks = projectNacks(graph, events, name);
+  const status = projectStatus(graph, events, name, opts.sessionId);
+  const errors = projectErrors(graph, events, name);
+  const cursor = projectCursor(graph, events, name);
+  const attempts = projectAttempts(graph, events, name);
+  const bundle = {
+    sessionId: opts.sessionId,
+    command,
+    outbound,
+    inbound,
+    events,
+    acks,
+    nacks,
+    status,
+    errors,
+    cursor,
+    attempts,
+    start: () => command.down([["DATA", { kind: "start" }]]),
+    send: (payload, sendOpts) => command.down([
+      [
+        "DATA",
+        {
+          kind: "send",
+          payload,
+          idempotencyKey: sendOpts?.idempotencyKey,
+          requestId: sendOpts?.requestId
+        }
+      ]
+    ]),
+    ack: (ackForSeq, ackOpts) => command.down([
+      [
+        "DATA",
+        {
+          kind: "ack",
+          ackForSeq,
+          idempotencyKey: ackOpts?.idempotencyKey,
+          requestId: ackOpts?.requestId
+        }
+      ]
+    ]),
+    nack: (ackForSeq, error, nackOpts) => command.down([
+      [
+        "DATA",
+        {
+          kind: "nack",
+          ackForSeq,
+          error,
+          idempotencyKey: nackOpts?.idempotencyKey,
+          requestId: nackOpts?.requestId
+        }
+      ]
+    ]),
+    close: (reason, closeOpts) => command.down([
+      ["DATA", { kind: "close", reason, idempotencyKey: closeOpts?.idempotencyKey }]
+    ])
+  };
+  bridgeCommandSources.set(bundle, { sources: [] });
+  bridgeInboundTargets.set(bundle, inboundCore);
+  return bundle;
+}
+function remoteCall(graph, bridge, opts = {}) {
+  const name = opts.name ?? "remoteCall";
+  const timeouts = graph.node([], null, {
+    name: `${name}/timeouts`,
+    factory: "remoteCallTimeouts",
+    completeWhenDepsComplete: false,
+    errorWhenDepsError: false
+  });
+  const responses = remoteCallResponsesNode(graph, bridge.events, timeouts, name);
+  const results = remoteCallResultsNode(graph, responses, name);
+  const status = remoteCallStatusNode(graph, bridge.events, responses, timeouts, name);
+  const errors = remoteCallErrorsNode(graph, responses, timeouts, bridge.events, name);
+  return {
+    responses,
+    results,
+    status,
+    errors,
+    timeouts,
+    call(operation, requestId, payload, callOpts) {
+      const request = remoteCallRequest(operation, requestId, payload);
+      bridge.command.down([
+        [
+          "DATA",
+          {
+            kind: "send",
+            payload: request,
+            idempotencyKey: callOpts?.idempotencyKey,
+            requestId
+          }
+        ]
+      ]);
+      return request;
+    },
+    timeout(requestId, operation, error) {
+      const timeout = remoteCallTimeout(requestId, operation, error);
+      timeouts.down([["DATA", timeout]]);
+      return timeout;
+    }
+  };
+}
+function remoteResponderHandler(operation, handle) {
+  if (operation.length === 0) {
+    throw new RangeError("remoteResponderHandler: operation must be non-empty");
+  }
+  if (typeof handle !== "function") {
+    throw new TypeError("remoteResponderHandler: handle must be a function");
+  }
+  return { operation, handle };
+}
+function remoteResponder(graph, bridge, opts = {}) {
+  const name = opts.name ?? "remoteResponder";
+  const handlers = normalizeRemoteHandlers(opts.handlers ?? []);
+  const topology = graph.topologyGroup({ name: `${name}.remoteResponder` });
+  const events = topology.add(
+    remoteResponderEventsNode(
+      graph,
+      wireBridgeInboundTarget(bridge),
+      name,
+      bridge.sessionId,
+      handlers,
+      opts.rejectUnknown === true
+    )
+  );
+  const responseCommands = topology.add(remoteResponderResponseCommandsNode(graph, events, name));
+  const requests = topology.add(remoteResponderRequestsNode(graph, events, name));
+  const status = topology.add(remoteResponderStatusNode(graph, events, name));
+  const errors = topology.add(remoteResponderErrorsNode(graph, events, name));
+  try {
+    attachWireBridgeCommandSource(bridge, responseCommands);
+  } catch (error) {
+    topology.release({ reason: `${name}.remoteResponder.failedAttach` });
+    throw error;
+  }
+  let released = false;
+  return {
+    events,
+    responseCommands,
+    requests,
+    status,
+    errors,
+    release() {
+      if (released) return;
+      detachWireBridgeCommandSource(bridge, responseCommands);
+      try {
+        topology.release({ reason: `${name}.remoteResponder.release` });
+        released = true;
+      } catch (error) {
+        attachWireBridgeCommandSource(bridge, responseCommands);
+        throw error;
+      }
+    }
+  };
+}
+function wireBridgeEventsNode(graph, command, inbound, name, opts, policy) {
+  const now = opts.now ?? Date.now;
+  return graph.node(
+    [command, inbound],
+    (ctx) => {
+      const state = initBridgeState(ctx);
+      const emitOutbound = (type, payload, commandOpts = {}, beforeEmit) => {
+        if (!isSafePositiveInteger(state.nextSeq)) {
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "invalid",
+                error: `${opts.sessionId}: next outbound seq exceeded Number.MAX_SAFE_INTEGER`
+              }
+            ]
+          ]);
+          return;
+        }
+        const seq = state.nextSeq;
+        let envelope;
+        try {
+          envelope = wireBridgeEnvelope({
+            sessionId: opts.sessionId,
+            type,
+            seq,
+            cursor: state.cursor,
+            payload,
+            idempotencyKey: commandOpts.idempotencyKey,
+            attempt: 1,
+            maxAttempts: policy.maxAttempts,
+            timestampMs: now(),
+            ackForSeq: commandOpts.ackForSeq,
+            requestId: commandOpts.requestId
+          });
+        } catch (error) {
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "invalid",
+                error: error instanceof Error ? error.message : String(error)
+              }
+            ]
+          ]);
+          return;
+        }
+        state.nextSeq++;
+        beforeEmit?.();
+        ctx.down([["DATA", { kind: "outbound", envelope }]]);
+        if (shouldTrackAck(type)) armAckTimeout(ctx, state, envelope, opts, policy, now);
+      };
+      for (const raw of depBatch(ctx, 1) ?? []) {
+        processInbound(ctx, state, raw, opts.sessionId);
+      }
+      const inboundTerminal = ctx.terminal[1];
+      if (inboundTerminal !== false && inboundTerminal !== void 0 && !state.terminalReported) {
+        state.terminalReported = true;
+        const error = inboundTerminal === true ? `${opts.sessionId}: inbound protocol COMPLETE is local misuse; remote completion must arrive as a DATA envelope fact` : `${opts.sessionId}: inbound protocol ERROR ${String(
+          errorPayload(inboundTerminal)
+        )} is local misuse; remote errors must arrive as DATA envelope facts`;
+        ctx.down([["DATA", { kind: "invalid", error }]]);
+      }
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const invalid = validateCommand(raw);
+        if (invalid !== void 0) {
+          ctx.down([["DATA", { kind: "invalid", error: invalid }]]);
+          continue;
+        }
+        const commandValue = raw;
+        switch (commandValue.kind) {
+          case "start":
+            emitOutbound("start", void 0, commandValue);
+            break;
+          case "send":
+            emitOutbound("data", { kind: "data", value: commandValue.payload }, commandValue);
+            break;
+          case "ack":
+            emitOutbound("ack", void 0, {
+              idempotencyKey: commandValue.idempotencyKey,
+              requestId: commandValue.requestId,
+              ackForSeq: commandValue.ackForSeq
+            });
+            break;
+          case "nack":
+            emitOutbound(
+              "nack",
+              { kind: "error", error: errorPayload(commandValue.error) },
+              {
+                idempotencyKey: commandValue.idempotencyKey,
+                requestId: commandValue.requestId,
+                ackForSeq: commandValue.ackForSeq
+              }
+            );
+            break;
+          case "close":
+            emitOutbound(
+              "close",
+              { kind: "close", reason: commandValue.reason },
+              commandValue,
+              () => {
+                for (const pending of state.pending.values()) {
+                  if (pending.timer !== void 0) clearTimeout(pending.timer);
+                }
+                state.pending.clear();
+              }
+            );
+            break;
+        }
+      }
+    },
+    {
+      name: `${name}/events`,
+      factory: "wireBridgeEvents",
+      partial: true,
+      errorWhenDepsError: false,
+      completeWhenDepsComplete: false,
+      terminalAsRealInput: true
+    }
+  );
+}
+function initBridgeState(ctx) {
+  let state = ctx.state.get();
+  if (state === void 0) {
+    state = {
+      active: true,
+      cleanupInstalled: false,
+      nextSeq: 1,
+      cursor: 0,
+      remoteCursor: 0,
+      terminalReported: false,
+      pending: /* @__PURE__ */ new Map()
+    };
+    ctx.state.set(state);
+  }
+  state.active = true;
+  if (!state.cleanupInstalled) {
+    state.cleanupInstalled = true;
+    ctx.onDeactivation(() => {
+      state.active = false;
+      state.cleanupInstalled = false;
+      for (const pending of state.pending.values()) {
+        if (pending.timer !== void 0) clearTimeout(pending.timer);
+      }
+      state.pending.clear();
+    });
+  }
+  return state;
+}
+function attachWireBridgeCommandSource(bridge, source) {
+  const attached = bridgeCommandSources.get(bridge);
+  if (attached === void 0) {
+    throw new Error("remoteResponder: bridge command source registry missing");
+  }
+  const sources = attached.sources;
+  const previousSources = [...sources];
+  if (!sources.includes(source)) sources.push(source);
+  try {
+    bridge.command.replaceDeps([...sources], wireBridgeCommandSourceFn(sources.length));
+  } catch (error) {
+    sources.splice(0, sources.length, ...previousSources);
+    bridge.command.replaceDeps(
+      [...previousSources],
+      wireBridgeCommandSourceFn(previousSources.length)
+    );
+    throw error;
+  }
+}
+function detachWireBridgeCommandSource(bridge, source) {
+  const attached = bridgeCommandSources.get(bridge);
+  if (attached === void 0) {
+    throw new Error("remoteResponder: bridge command source registry missing");
+  }
+  const sources = attached.sources;
+  if (!sources.includes(source)) return;
+  const previousSources = [...sources];
+  const nextSources = sources.filter((candidate) => candidate !== source);
+  sources.splice(0, sources.length, ...nextSources);
+  try {
+    bridge.command.replaceDeps([...nextSources], wireBridgeCommandSourceFn(nextSources.length));
+  } catch (error) {
+    sources.splice(0, sources.length, ...previousSources);
+    bridge.command.replaceDeps(
+      [...previousSources],
+      wireBridgeCommandSourceFn(previousSources.length)
+    );
+    throw error;
+  }
+}
+function wireBridgeInboundTarget(bridge) {
+  const target = bridgeInboundTargets.get(bridge);
+  if (target === void 0) {
+    throw new Error("remoteResponder: bridge inbound target registry missing");
+  }
+  return target;
+}
+function wireBridgeCommandSourceFn(sourceCount) {
+  return (ctx) => {
+    for (let i = 0; i < sourceCount; i += 1) {
+      for (const command of depBatch(ctx, i) ?? []) {
+        ctx.down([["DATA", command]]);
+      }
+    }
+  };
+}
+function remoteCallRequest(operation, requestId, payload) {
+  if (operation.length === 0) throw new RangeError("remoteCall: operation must be non-empty");
+  if (requestId.length === 0) throw new RangeError("remoteCall: requestId must be non-empty");
+  return { operation, requestId, payload };
+}
+function remoteCallTimeout(requestId, operation, error) {
+  if (requestId.length === 0)
+    throw new RangeError("remoteCall: timeout requestId must be non-empty");
+  if (error.length === 0) throw new RangeError("remoteCall: timeout error must be non-empty");
+  return { ...operation === void 0 ? {} : { operation }, requestId, error };
+}
+function remotePendingState() {
+  return { requestIds: /* @__PURE__ */ new Set(), bySeq: /* @__PURE__ */ new Map() };
+}
+function remotePendingContains(state, requestId) {
+  return state.requestIds.has(requestId);
+}
+function remotePendingDuplicate(state, request) {
+  const current = remotePendingTakeBySeqPreview(state, request.seq);
+  return current?.requestId !== request.requestId && state.requestIds.has(request.requestId);
+}
+function remotePendingTakeBySeqPreview(state, seq) {
+  return state.bySeq.get(seq);
+}
+function remotePendingInsert(state, request) {
+  const existingBySeq = state.bySeq.get(request.seq);
+  if (existingBySeq !== void 0) {
+    state.requestIds.delete(existingBySeq.requestId);
+  }
+  for (const [seq, pending] of state.bySeq) {
+    if (pending.requestId === request.requestId && seq !== request.seq) {
+      state.bySeq.delete(seq);
+      break;
+    }
+  }
+  state.requestIds.add(request.requestId);
+  state.bySeq.set(request.seq, request);
+}
+function remotePendingTakeByRequestId(state, requestId) {
+  if (!state.requestIds.delete(requestId)) return void 0;
+  let seq;
+  let found;
+  for (const [candidateSeq, request] of state.bySeq) {
+    if (request.requestId === requestId) {
+      seq = candidateSeq;
+      found = request;
+      break;
+    }
+  }
+  if (seq !== void 0) state.bySeq.delete(seq);
+  return found;
+}
+function remotePendingTakeBySeq(state, seq) {
+  const request = state.bySeq.get(seq);
+  if (request === void 0) return void 0;
+  state.bySeq.delete(seq);
+  state.requestIds.delete(request.requestId);
+  return request;
+}
+function remotePendingFromReceipt(state, envelope) {
+  const bySeq = remotePendingTakeBySeq(state, envelope.metadata.seq);
+  if (bySeq !== void 0) return bySeq;
+  const fallback = pendingRequestFromEnvelope(envelope);
+  if (fallback === void 0 || remotePendingContains(state, fallback.requestId)) {
+    return void 0;
+  }
+  return fallback;
+}
+function pendingRequestFromEnvelope(envelope) {
+  if (envelope.payload?.kind !== "data") return void 0;
+  const request = validateRemoteCallRequest(envelope.payload.value);
+  if (request === void 0) return void 0;
+  return {
+    operation: request.operation,
+    requestId: request.requestId,
+    seq: envelope.metadata.seq
+  };
+}
+function validateRemoteCallRequest(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value.operation !== "string" || value.operation.length === 0) return void 0;
+  if (typeof value.requestId !== "string" || value.requestId.length === 0) return void 0;
+  if (!("payload" in value)) return void 0;
+  return {
+    operation: value.operation,
+    requestId: value.requestId,
+    payload: value.payload
+  };
+}
+function validateRemoteCallResponse(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value.operation !== "string" || value.operation.length === 0) return void 0;
+  if (typeof value.requestId !== "string" || value.requestId.length === 0) return void 0;
+  if (value.kind === "result" && "payload" in value) {
+    return {
+      kind: "result",
+      operation: value.operation,
+      requestId: value.requestId,
+      payload: value.payload
+    };
+  }
+  if (value.kind === "error" && typeof value.error === "string" && value.error.length > 0) {
+    return {
+      kind: "error",
+      operation: value.operation,
+      requestId: value.requestId,
+      error: value.error
+    };
+  }
+  if (value.kind === "status" && typeof value.status === "string" && value.status.length > 0) {
+    return {
+      kind: "status",
+      operation: value.operation,
+      requestId: value.requestId,
+      status: value.status
+    };
+  }
+  return void 0;
+}
+function remoteMalformedResponseRequestId(value) {
+  if (!isRecord(value)) return void 0;
+  return typeof value.requestId === "string" && value.requestId.length > 0 ? value.requestId : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isThenable(value) {
+  return isRecord(value) && typeof value.then === "function";
+}
+function remoteCallResponseRequestId(response) {
+  return response.requestId;
+}
+function remoteCallResponseIsTerminal(response) {
+  return response.kind === "result" || response.kind === "error";
+}
+function remoteCallResponsesNode(graph, events, timeouts, name) {
+  return graph.node(
+    [events, timeouts],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        pending: remotePendingState()
+      };
+      const ready = [];
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "outbound") {
+          const request = pendingRequestFromEnvelope(event.envelope);
+          if (request === void 0) continue;
+          if (remotePendingDuplicate(state.pending, request)) continue;
+          remotePendingInsert(state.pending, request);
+        } else if (event.kind === "inbound" && event.envelope.payload?.kind === "data") {
+          const response = validateRemoteCallResponse(event.envelope.payload.value);
+          if (response === void 0) {
+            const requestId2 = remoteMalformedResponseRequestId(event.envelope.payload.value);
+            if (requestId2 !== void 0 && remotePendingContains(state.pending, requestId2)) {
+              remotePendingTakeByRequestId(state.pending, requestId2);
+            }
+            continue;
+          }
+          const requestId = remoteCallResponseRequestId(response);
+          if (remotePendingContains(state.pending, requestId)) {
+            if (remoteCallResponseIsTerminal(response)) {
+              remotePendingTakeByRequestId(state.pending, requestId);
+            }
+            ready.push(response);
+          }
+        } else if (event.kind === "nack") {
+          remotePendingFromReceipt(state.pending, event.outbound);
+        } else if (event.kind === "exhausted") {
+          remotePendingTakeBySeq(state.pending, event.seq);
+        }
+      }
+      for (const raw of depBatch(ctx, 1) ?? []) {
+        const timeout = raw;
+        remotePendingTakeByRequestId(state.pending, timeout.requestId);
+      }
+      ctx.state.set(state);
+      for (const response of ready) ctx.down([["DATA", response]]);
+    },
+    {
+      name: `${name}/responses`,
+      factory: "remoteCallResponses",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function remoteCallResultsNode(graph, responses, name) {
+  return graph.node(
+    [responses],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const response = raw;
+        if (response.kind === "result") {
+          ctx.down([
+            [
+              "DATA",
+              {
+                operation: response.operation,
+                requestId: response.requestId,
+                payload: response.payload
+              }
+            ]
+          ]);
+        }
+      }
+    },
+    { name: `${name}/results`, factory: "remoteCallResults", completeWhenDepsComplete: false }
+  );
+}
+function remoteCallStatusNode(graph, events, responses, timeouts, name) {
+  return graph.node(
+    [events, responses, timeouts],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        status: { state: "idle", pending: 0, completed: 0, errors: 0, timeouts: 0 },
+        pending: remotePendingState()
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "outbound") {
+          const request = pendingRequestFromEnvelope(event.envelope);
+          if (request !== void 0) {
+            if (remotePendingDuplicate(state.pending, request)) {
+              state.status = {
+                ...state.status,
+                state: "errored",
+                operation: request.operation,
+                requestId: request.requestId,
+                errors: state.status.errors + 1
+              };
+              continue;
+            }
+            remotePendingInsert(state.pending, request);
+            state.status = {
+              ...state.status,
+              state: "requested",
+              operation: request.operation,
+              requestId: request.requestId
+            };
+          }
+        } else if (event.kind === "invalid" || event.kind === "session-mismatch" || event.kind === "out-of-order" || event.kind === "late-receipt") {
+          state.status = {
+            ...state.status,
+            state: "bridge-errored",
+            errors: state.status.errors + 1
+          };
+        } else if (event.kind === "nack") {
+          const request = remotePendingFromReceipt(state.pending, event.outbound);
+          state.status = {
+            ...state.status,
+            state: "bridge-errored",
+            ...request === void 0 ? {} : { operation: request.operation, requestId: request.requestId },
+            errors: state.status.errors + 1
+          };
+        } else if (event.kind === "exhausted") {
+          const request = remotePendingTakeBySeq(state.pending, event.seq);
+          state.status = {
+            ...state.status,
+            state: "bridge-errored",
+            ...request === void 0 ? {} : { operation: request.operation, requestId: request.requestId },
+            errors: state.status.errors + 1
+          };
+        } else if (event.kind === "inbound" && event.envelope.payload?.kind === "data") {
+          const response = validateRemoteCallResponse(event.envelope.payload.value);
+          if (response === void 0) {
+            const requestId = remoteMalformedResponseRequestId(event.envelope.payload.value);
+            if (requestId !== void 0) {
+              const request = remotePendingTakeByRequestId(state.pending, requestId);
+              if (request !== void 0) {
+                state.status = {
+                  ...state.status,
+                  state: "errored",
+                  operation: request.operation,
+                  requestId,
+                  errors: state.status.errors + 1
+                };
+              }
+            }
+          }
+        }
+      }
+      for (const raw of depBatch(ctx, 1) ?? []) {
+        const response = raw;
+        if (response.kind === "result") {
+          remotePendingTakeByRequestId(state.pending, response.requestId);
+          state.status = {
+            ...state.status,
+            state: "responded",
+            operation: response.operation,
+            requestId: response.requestId,
+            completed: state.status.completed + 1
+          };
+        } else if (response.kind === "error") {
+          remotePendingTakeByRequestId(state.pending, response.requestId);
+          state.status = {
+            ...state.status,
+            state: "errored",
+            operation: response.operation,
+            requestId: response.requestId,
+            errors: state.status.errors + 1
+          };
+        } else {
+          state.status = {
+            ...state.status,
+            operation: response.operation,
+            requestId: response.requestId
+          };
+        }
+      }
+      for (const raw of depBatch(ctx, 2) ?? []) {
+        const timeout = raw;
+        remotePendingTakeByRequestId(state.pending, timeout.requestId);
+        state.status = {
+          ...state.status,
+          state: "timed-out",
+          operation: timeout.operation,
+          requestId: timeout.requestId,
+          errors: state.status.errors + 1,
+          timeouts: state.status.timeouts + 1
+        };
+      }
+      state.status = { ...state.status, pending: state.pending.requestIds.size };
+      ctx.state.set(state);
+      ctx.down([["DATA", state.status]]);
+    },
+    {
+      name: `${name}/status`,
+      factory: "remoteCallStatus",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function remoteCallErrorsNode(graph, responses, timeouts, events, name) {
+  return graph.node(
+    [responses, timeouts, events],
+    (ctx) => {
+      const pending = ctx.state.get() ?? remotePendingState();
+      for (const raw of depBatch(ctx, 2) ?? []) {
+        const event = raw;
+        if (event.kind === "outbound") {
+          const request = pendingRequestFromEnvelope(event.envelope);
+          if (request !== void 0) {
+            if (remotePendingDuplicate(pending, request)) {
+              ctx.down([
+                [
+                  "DATA",
+                  {
+                    operation: request.operation,
+                    requestId: request.requestId,
+                    error: `remoteCall: duplicate in-flight requestId '${request.requestId}'`
+                  }
+                ]
+              ]);
+              continue;
+            }
+            remotePendingInsert(pending, request);
+          }
+        }
+      }
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const response = raw;
+        if (response.kind === "error") {
+          remotePendingTakeByRequestId(pending, response.requestId);
+          ctx.down([
+            [
+              "DATA",
+              {
+                operation: response.operation,
+                requestId: response.requestId,
+                error: response.error
+              }
+            ]
+          ]);
+        } else if (response.kind === "result") {
+          remotePendingTakeByRequestId(pending, response.requestId);
+        }
+      }
+      for (const raw of depBatch(ctx, 1) ?? []) {
+        const timeout = raw;
+        remotePendingTakeByRequestId(pending, timeout.requestId);
+        ctx.down([
+          [
+            "DATA",
+            { operation: timeout.operation, requestId: timeout.requestId, error: timeout.error }
+          ]
+        ]);
+      }
+      for (const raw of depBatch(ctx, 2) ?? []) {
+        const event = raw;
+        if (event.kind === "inbound" && event.envelope.payload?.kind === "data") {
+          const response = validateRemoteCallResponse(event.envelope.payload.value);
+          if (response === void 0) {
+            const requestId = remoteMalformedResponseRequestId(event.envelope.payload.value);
+            const request = requestId === void 0 ? void 0 : remotePendingTakeByRequestId(pending, requestId);
+            if (request === void 0) continue;
+            ctx.down([
+              [
+                "DATA",
+                {
+                  operation: request.operation,
+                  requestId: request.requestId,
+                  error: "remoteCall: response payload is malformed"
+                }
+              ]
+            ]);
+          }
+          continue;
+        }
+        if (event.kind === "nack") {
+          const request = remotePendingFromReceipt(pending, event.outbound);
+          ctx.down([
+            [
+              "DATA",
+              {
+                operation: request?.operation,
+                requestId: request?.requestId,
+                error: String(event.error)
+              }
+            ]
+          ]);
+        } else if (event.kind === "exhausted") {
+          const request = remotePendingTakeBySeq(pending, event.seq);
+          ctx.down([
+            [
+              "DATA",
+              {
+                operation: request?.operation,
+                requestId: request?.requestId,
+                error: String(event.error)
+              }
+            ]
+          ]);
+        } else if (event.kind === "invalid") {
+          ctx.down([["DATA", { error: event.error }]]);
+        } else if (event.kind === "session-mismatch" || event.kind === "out-of-order" || event.kind === "late-receipt") {
+          ctx.down([["DATA", { error: remoteCallBridgeErrorMessage(event) }]]);
+        }
+      }
+      ctx.state.set(pending);
+    },
+    {
+      name: `${name}/errors`,
+      factory: "remoteCallErrors",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function remoteCallBridgeErrorMessage(event) {
+  if (event.kind === "session-mismatch") {
+    return `remoteCall: inbound session ${event.actual} did not match expected ${event.expected}`;
+  }
+  if (event.kind === "out-of-order") {
+    return `remoteCall: inbound seq ${event.seq} arrived before expected seq ${event.expected}`;
+  }
+  if (event.kind === "late-receipt") {
+    return `remoteCall: late ${event.receipt} for unknown or completed ackForSeq ${event.ackForSeq}`;
+  }
+  return "remoteCall: bridge error";
+}
+function normalizeRemoteHandlers(handlers) {
+  const out = /* @__PURE__ */ new Map();
+  for (const handler of handlers) {
+    if (handler.operation.length === 0) {
+      throw new RangeError("remoteResponder: operation must be non-empty");
+    }
+    if (out.has(handler.operation)) {
+      throw new RangeError(`remoteResponder: duplicate operation '${handler.operation}'`);
+    }
+    out.set(handler.operation, handler.handle);
+  }
+  return out;
+}
+function reduceRemoteResponderInbound(cursor, envelope, expectedSessionId) {
+  const envelopeError = validateInboundEnvelope(envelope);
+  if (envelopeError !== void 0) {
+    return { kind: "invalid", error: envelopeError };
+  }
+  if (envelope.sessionId !== expectedSessionId) {
+    return {
+      kind: "invalid",
+      error: `remoteResponder: inbound session ${envelope.sessionId} did not match expected ${expectedSessionId}`
+    };
+  }
+  const seq = envelope.metadata.seq;
+  const expected = cursor.cursor + 1;
+  if (seq <= cursor.cursor) {
+    return {
+      kind: "invalid",
+      error: `remoteResponder: duplicate request seq ${seq} at cursor ${cursor.cursor}`
+    };
+  }
+  if (seq > expected) {
+    return {
+      kind: "invalid",
+      error: `remoteResponder: out-of-order request seq ${seq}, expected ${expected}`
+    };
+  }
+  if (envelope.metadata.cursor < cursor.remoteCursor) {
+    return {
+      kind: "invalid",
+      error: `${envelope.sessionId}: remoteResponder inbound cursor ${envelope.metadata.cursor} regressed below ${cursor.remoteCursor}`
+    };
+  }
+  cursor.cursor = seq;
+  cursor.remoteCursor = envelope.metadata.cursor;
+  if (envelope.type !== "data") return { kind: "consumed" };
+  if (envelope.payload?.kind !== "data") {
+    return { kind: "invalid", error: "remoteResponder: request envelope must carry request DATA" };
+  }
+  const request = validateRemoteCallRequest(envelope.payload.value);
+  if (request === void 0) {
+    return { kind: "invalid", error: "remoteResponder: request payload is malformed" };
+  }
+  return { kind: "request", request, seq };
+}
+function remoteResponderEventsNode(graph, inbound, name, expectedSessionId, handlers, rejectUnknown) {
+  return graph.node(
+    [inbound],
+    (ctx) => {
+      const cursor = ctx.state.get() ?? { cursor: 0, remoteCursor: 0 };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const envelope = raw;
+        const received = reduceRemoteResponderInbound(cursor, envelope, expectedSessionId);
+        if (received.kind === "consumed") continue;
+        if (received.kind === "invalid") {
+          ctx.down([["DATA", { kind: "invalid", error: received.error }]]);
+          continue;
+        }
+        const { request, seq } = received;
+        ctx.down([["DATA", { kind: "request", request, seq }]]);
+        const handler = handlers.get(request.operation);
+        if (handler === void 0) {
+          if (!rejectUnknown) continue;
+          const error = `remoteResponder: unknown operation '${request.operation}'`;
+          const response = remoteCallErrorResponse(request, error);
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "rejected",
+                requestId: request.requestId,
+                operation: request.operation,
+                error,
+                command: { kind: "send", payload: response, requestId: request.requestId }
+              }
+            ]
+          ]);
+          continue;
+        }
+        try {
+          const payload = handler(request);
+          if (isThenable(payload)) {
+            throw new Error("remoteResponder: async handler results require a later adapter shape");
+          }
+          const response = {
+            kind: "result",
+            operation: request.operation,
+            requestId: request.requestId,
+            payload
+          };
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "response",
+                requestId: request.requestId,
+                operation: request.operation,
+                command: { kind: "send", payload: response, requestId: request.requestId }
+              }
+            ]
+          ]);
+        } catch (error) {
+          rethrowGraphRuntimeInvariant(error);
+          const message = errorMessage(error);
+          const response = remoteCallErrorResponse(request, message);
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "rejected",
+                requestId: request.requestId,
+                operation: request.operation,
+                error: message,
+                command: { kind: "send", payload: response, requestId: request.requestId }
+              }
+            ]
+          ]);
+        }
+      }
+      ctx.state.set(cursor);
+    },
+    {
+      name: `${name}/events`,
+      factory: "remoteResponderEvents",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function remoteCallErrorResponse(request, error) {
+  return {
+    kind: "error",
+    operation: request.operation,
+    requestId: request.requestId,
+    error
+  };
+}
+function remoteResponderResponseCommandsNode(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if ((event.kind === "response" || event.kind === "rejected") && event.command !== void 0) {
+          ctx.down([["DATA", event.command]]);
+        }
+      }
+    },
+    {
+      name: `${name}/responseCommands`,
+      factory: "remoteResponderResponseCommands",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function remoteResponderRequestsNode(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "request") ctx.down([["DATA", event.request]]);
+      }
+    },
+    {
+      name: `${name}/requests`,
+      factory: "remoteResponderRequests",
+      completeWhenDepsComplete: false
+    }
+  );
+}
+function remoteResponderStatusNode(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      let status = ctx.state.get() ?? { state: "idle", handled: 0, rejected: 0, errors: 0 };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "response") {
+          status = {
+            ...status,
+            state: "responded",
+            operation: event.operation,
+            requestId: event.requestId,
+            handled: status.handled + 1
+          };
+        } else if (event.kind === "rejected") {
+          status = {
+            ...status,
+            state: "rejected",
+            operation: event.operation,
+            requestId: event.requestId,
+            rejected: status.rejected + 1,
+            errors: status.errors + 1
+          };
+        } else if (event.kind === "invalid") {
+          status = { ...status, state: "errored", errors: status.errors + 1 };
+        }
+      }
+      ctx.state.set(status);
+      ctx.down([["DATA", status]]);
+    },
+    {
+      name: `${name}/status`,
+      factory: "remoteResponderStatus",
+      partial: true,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function remoteResponderErrorsNode(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "rejected") {
+          ctx.down([
+            [
+              "DATA",
+              { operation: event.operation, requestId: event.requestId, error: event.error }
+            ]
+          ]);
+        } else if (event.kind === "invalid") {
+          ctx.down([["DATA", { error: event.error }]]);
+        }
+      }
+    },
+    { name: `${name}/errors`, factory: "remoteResponderErrors", completeWhenDepsComplete: false }
+  );
+}
+function armAckTimeout(ctx, state, envelope, opts, policy, now) {
+  const timeoutMs = opts.ackTimeoutMs ?? defaultAckTimeoutMs;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+    throw new RangeError("wireBridge: ackTimeoutMs must be a non-negative finite number");
+  }
+  const pending = { envelope };
+  const schedule = (current) => {
+    pending.timer = setTimeout(() => {
+      pending.timer = void 0;
+      if (!state.active || !state.pending.has(current.metadata.seq)) return;
+      ctx.down([
+        [
+          "DATA",
+          {
+            kind: "timeout",
+            seq: current.metadata.seq,
+            attempt: current.metadata.attempt
+          }
+        ]
+      ]);
+      if (!shouldRetry(policy, current.metadata.attempt)) {
+        const error = `${opts.sessionId}: ack timeout for seq ${current.metadata.seq}`;
+        state.pending.delete(current.metadata.seq);
+        ctx.down([
+          [
+            "DATA",
+            {
+              kind: "exhausted",
+              seq: current.metadata.seq,
+              attempt: current.metadata.attempt,
+              error
+            }
+          ]
+        ]);
+        return;
+      }
+      const attempt = current.metadata.attempt + 1;
+      const delayMs = nextRetryDelayMs(policy, attempt) ?? 0;
+      ctx.down([
+        [
+          "DATA",
+          {
+            kind: "retry",
+            seq: current.metadata.seq,
+            attempt,
+            delayMs,
+            error: `${opts.sessionId}: ack timeout for seq ${current.metadata.seq}`
+          }
+        ]
+      ]);
+      const retry = wireBridgeEnvelope({
+        sessionId: current.sessionId,
+        type: current.type,
+        seq: current.metadata.seq,
+        cursor: state.cursor,
+        payload: current.payload,
+        idempotencyKey: current.metadata.idempotencyKey,
+        attempt,
+        maxAttempts: policy.maxAttempts,
+        timestampMs: now(),
+        requestId: current.metadata.requestId
+      });
+      pending.timer = setTimeout(() => {
+        pending.timer = void 0;
+        if (!state.active || !state.pending.has(current.metadata.seq)) return;
+        pending.envelope = retry;
+        ctx.down([["DATA", { kind: "outbound", envelope: retry }]]);
+        schedule(retry);
+      }, delayMs);
+    }, timeoutMs);
+  };
+  state.pending.set(envelope.metadata.seq, pending);
+  schedule(envelope);
+}
+function processInbound(ctx, state, input, sessionId) {
+  if (isInvalidIngress(input)) {
+    ctx.down([["DATA", { kind: "invalid", error: input.error }]]);
+    return;
+  }
+  const invalid = validateInboundEnvelope(input);
+  if (invalid !== void 0) {
+    ctx.down([["DATA", { kind: "invalid", error: invalid }]]);
+    return;
+  }
+  const envelope = input;
+  if (envelope.sessionId !== sessionId) {
+    ctx.down([
+      [
+        "DATA",
+        {
+          kind: "session-mismatch",
+          expected: sessionId,
+          actual: envelope.sessionId
+        }
+      ]
+    ]);
+    return;
+  }
+  const seq = envelope.metadata.seq;
+  const expected = state.cursor + 1;
+  if (seq <= state.cursor) {
+    ctx.down([["DATA", { kind: "duplicate", seq, cursor: state.cursor }]]);
+    return;
+  }
+  if (seq > expected) {
+    ctx.down([["DATA", { kind: "out-of-order", seq, expected }]]);
+    return;
+  }
+  if (envelope.metadata.cursor < state.remoteCursor) {
+    ctx.down([
+      [
+        "DATA",
+        {
+          kind: "invalid",
+          error: `${sessionId}: inbound cursor ${envelope.metadata.cursor} regressed below ${state.remoteCursor}`
+        }
+      ]
+    ]);
+    return;
+  }
+  state.remoteCursor = envelope.metadata.cursor;
+  state.cursor = seq;
+  ctx.down([["DATA", { kind: "cursor", cursor: state.cursor }]]);
+  ctx.down([["DATA", { kind: "inbound", envelope }]]);
+  if (envelope.type === "ack" && envelope.metadata.ackForSeq !== void 0) {
+    const pending = state.pending.get(envelope.metadata.ackForSeq);
+    if (pending === void 0) {
+      ctx.down([
+        ["DATA", { kind: "late-receipt", receipt: "ack", ackForSeq: envelope.metadata.ackForSeq }]
+      ]);
+      return;
+    }
+    if (pending?.timer !== void 0) clearTimeout(pending.timer);
+    state.pending.delete(envelope.metadata.ackForSeq);
+    ctx.down([
+      [
+        "DATA",
+        {
+          kind: "ack",
+          ackForSeq: envelope.metadata.ackForSeq,
+          envelope,
+          outbound: pending.envelope
+        }
+      ]
+    ]);
+  } else if (envelope.type === "nack" && envelope.metadata.ackForSeq !== void 0) {
+    const pending = state.pending.get(envelope.metadata.ackForSeq);
+    if (pending === void 0) {
+      ctx.down([
+        ["DATA", { kind: "late-receipt", receipt: "nack", ackForSeq: envelope.metadata.ackForSeq }]
+      ]);
+      return;
+    }
+    if (pending?.timer !== void 0) clearTimeout(pending.timer);
+    state.pending.delete(envelope.metadata.ackForSeq);
+    ctx.down([
+      [
+        "DATA",
+        {
+          kind: "nack",
+          ackForSeq: envelope.metadata.ackForSeq,
+          envelope,
+          outbound: pending.envelope,
+          error: bridgePayloadError(envelope.payload, "remote nack")
+        }
+      ]
+    ]);
+  }
+}
+function validateInboundEnvelope(envelope) {
+  if (typeof envelope !== "object" || envelope === null) {
+    return "wireBridge: inbound envelope must be an object";
+  }
+  const candidate = envelope;
+  if (typeof candidate.sessionId !== "string" || candidate.sessionId.length === 0) {
+    return "wireBridge: inbound envelope sessionId must be a non-empty string";
+  }
+  if (typeof candidate.type !== "string" || !envelopeTypes.has(candidate.type)) {
+    return "wireBridge: inbound envelope type is not recognized";
+  }
+  const metadata = candidate.metadata;
+  if (typeof metadata !== "object" || metadata === null) {
+    return "wireBridge: inbound envelope metadata must be an object";
+  }
+  if (!isSafePositiveInteger(metadata.seq)) {
+    return "wireBridge: inbound envelope seq must be a positive integer";
+  }
+  if (!isSafeNonNegativeInteger(metadata.cursor)) {
+    return "wireBridge: inbound envelope cursor must be a non-negative integer";
+  }
+  if (typeof metadata.idempotencyKey !== "string" || metadata.idempotencyKey.length === 0) {
+    return "wireBridge: inbound envelope idempotencyKey must be a non-empty string";
+  }
+  if (!isSafePositiveInteger(metadata.attempt)) {
+    return "wireBridge: inbound envelope attempt must be a positive integer";
+  }
+  if (!isSafePositiveInteger(metadata.maxAttempts) || metadata.maxAttempts < metadata.attempt) {
+    return "wireBridge: inbound envelope maxAttempts must be >= attempt";
+  }
+  if (metadata.ackForSeq !== void 0 && !isSafePositiveInteger(metadata.ackForSeq)) {
+    return "wireBridge: inbound envelope ackForSeq must be a positive integer";
+  }
+  if ((candidate.type === "ack" || candidate.type === "nack") && metadata.ackForSeq === void 0) {
+    return `wireBridge: inbound ${candidate.type} envelope requires ackForSeq`;
+  }
+  const payloadError = validatePayloadForType(
+    candidate.type,
+    candidate.payload,
+    "wireBridge: inbound envelope"
+  );
+  if (payloadError !== void 0) return payloadError;
+  return void 0;
+}
+function validateCommand(value) {
+  if (typeof value !== "object" || value === null) {
+    return "wireBridge: command fact must be an object";
+  }
+  const kind = value.kind;
+  if (kind !== "start" && kind !== "send" && kind !== "ack" && kind !== "nack" && kind !== "close") {
+    return "wireBridge: command kind is not recognized";
+  }
+  if ((kind === "ack" || kind === "nack") && !isSafePositiveInteger(value.ackForSeq)) {
+    return `wireBridge: ${kind} command ackForSeq must be a positive integer`;
+  }
+  return void 0;
+}
+function projectOutbound(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "outbound") ctx.down([["DATA", event.envelope]]);
+      }
+    },
+    { name: `${name}/outbound`, factory: "wireBridgeOutbound" }
+  );
+}
+function projectAcks(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "ack") {
+          ctx.down([["DATA", { ackForSeq: event.ackForSeq, envelope: event.envelope }]]);
+        }
+      }
+    },
+    { name: `${name}/acks`, factory: "wireBridgeAcks" }
+  );
+}
+function projectNacks(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "nack") {
+          ctx.down([
+            ["DATA", { ackForSeq: event.ackForSeq, envelope: event.envelope, error: event.error }]
+          ]);
+        }
+      }
+    },
+    { name: `${name}/nacks`, factory: "wireBridgeNacks" }
+  );
+}
+function projectStatus(graph, events, name, sessionId) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      let next = ctx.state.get() ?? {
+        sessionId,
+        state: "idle",
+        cursor: 0,
+        nextSeq: 1,
+        pending: 0,
+        attempts: 0,
+        acked: 0,
+        nacked: 0,
+        errors: 0
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "outbound") {
+          const { seq, attempt } = event.envelope.metadata;
+          const trackAck = shouldTrackAck(event.envelope.type);
+          next = {
+            ...next,
+            state: event.envelope.type === "start" ? "started" : event.envelope.type === "close" ? "closed" : "open",
+            nextSeq: Math.max(next.nextSeq, seq + 1),
+            pending: event.envelope.type === "close" ? 1 : trackAck && attempt === 1 ? next.pending + 1 : next.pending,
+            attempts: trackAck ? next.attempts + 1 : next.attempts,
+            lastSeq: seq
+          };
+        } else if (event.kind === "ack") {
+          next = {
+            ...next,
+            state: event.outbound.type === "close" ? "closed" : "open",
+            pending: Math.max(0, next.pending - 1),
+            acked: next.acked + 1,
+            lastSeq: event.envelope.metadata.seq
+          };
+        } else if (event.kind === "nack") {
+          next = {
+            ...next,
+            state: "errored",
+            pending: Math.max(0, next.pending - 1),
+            nacked: next.nacked + 1,
+            errors: next.errors + 1,
+            lastSeq: event.envelope.metadata.seq
+          };
+        } else if (event.kind === "retry") {
+          next = {
+            ...next,
+            state: "waiting",
+            lastSeq: event.seq,
+            lastDelayMs: event.delayMs
+          };
+        } else if (event.kind === "exhausted") {
+          next = {
+            ...next,
+            state: "exhausted",
+            pending: Math.max(0, next.pending - 1),
+            errors: next.errors + 1,
+            lastSeq: event.seq
+          };
+        } else if (event.kind === "cursor") {
+          next = { ...next, cursor: event.cursor };
+        } else if (event.kind === "out-of-order") {
+          next = { ...next, state: "errored", errors: next.errors + 1, lastSeq: event.seq };
+        } else if (event.kind === "session-mismatch") {
+          next = { ...next, state: "errored", errors: next.errors + 1 };
+        } else if (event.kind === "late-receipt" || event.kind === "invalid") {
+          next = { ...next, state: "errored", errors: next.errors + 1 };
+        } else if (event.kind === "inbound" && event.envelope.type === "error") {
+          next = {
+            ...next,
+            state: "errored",
+            errors: next.errors + 1,
+            lastSeq: event.envelope.metadata.seq
+          };
+        } else if (event.kind === "inbound" && event.envelope.type === "close") {
+          next = { ...next, state: "closed", lastSeq: event.envelope.metadata.seq };
+        }
+      }
+      ctx.state.set(next);
+      ctx.down([["DATA", next]]);
+    },
+    { name: `${name}/status`, factory: "wireBridgeStatus" }
+  );
+}
+function projectErrors(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "nack") ctx.down([["DATA", event.error]]);
+        else if (event.kind === "exhausted") ctx.down([["DATA", event.error]]);
+        else if (event.kind === "out-of-order") {
+          ctx.down([
+            [
+              "DATA",
+              `${name}: inbound seq ${event.seq} arrived before expected seq ${event.expected}`
+            ]
+          ]);
+        } else if (event.kind === "inbound" && event.envelope.type === "error") {
+          ctx.down([["DATA", bridgePayloadError(event.envelope.payload, "remote error envelope")]]);
+        } else if (event.kind === "session-mismatch") {
+          ctx.down([
+            [
+              "DATA",
+              `${name}: inbound session ${event.actual} did not match expected ${event.expected}`
+            ]
+          ]);
+        } else if (event.kind === "late-receipt") {
+          ctx.down([
+            [
+              "DATA",
+              `${name}: late ${event.receipt} for unknown or completed ackForSeq ${event.ackForSeq}`
+            ]
+          ]);
+        } else if (event.kind === "invalid") {
+          ctx.down([["DATA", event.error]]);
+        }
+      }
+    },
+    { name: `${name}/errors`, factory: "wireBridgeErrors" }
+  );
+}
+function projectCursor(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "cursor") ctx.down([["DATA", event.cursor]]);
+      }
+    },
+    { name: `${name}/cursor`, factory: "wireBridgeCursor" }
+  );
+}
+function projectAttempts(graph, events, name) {
+  return graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "outbound" && shouldTrackAck(event.envelope.type)) {
+          ctx.down([
+            [
+              "DATA",
+              {
+                seq: event.envelope.metadata.seq,
+                attempt: event.envelope.metadata.attempt,
+                maxAttempts: event.envelope.metadata.maxAttempts
+              }
+            ]
+          ]);
+        }
+      }
+    },
+    { name: `${name}/attempts`, factory: "wireBridgeAttempts" }
+  );
+}
+function guardedInboundNode(node, sessionId) {
+  return new Proxy(node, {
+    get(target, property) {
+      if (property === "down") {
+        return (msgs) => target.down(guardInboundWave(msgs, sessionId));
+      }
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function guardInboundWave(msgs, sessionId) {
+  return msgs.map((msg) => {
+    if (msg[0] === "DATA") return msg;
+    if (msg[0] === "ERROR") {
+      return [
+        "DATA",
+        invalidIngress(
+          `${sessionId}: inbound protocol ERROR ${String(
+            errorPayload(msg[1])
+          )} is local misuse; remote errors must arrive as DATA envelope facts`
+        )
+      ];
+    }
+    if (msg[0] === "COMPLETE") {
+      return [
+        "DATA",
+        invalidIngress(
+          `${sessionId}: inbound protocol COMPLETE is local misuse; remote completion must arrive as a DATA envelope fact`
+        )
+      ];
+    }
+    return [
+      "DATA",
+      invalidIngress(
+        `${sessionId}: inbound port accepts DATA envelope facts only; ${msg[0]} is local protocol traffic`
+      )
+    ];
+  });
+}
+function invalidIngress(error) {
+  return { __wireBridgeInvalidIngress: true, error };
+}
+function isInvalidIngress(value) {
+  return typeof value === "object" && value !== null && value.__wireBridgeInvalidIngress === true && typeof value.error === "string";
+}
+function shouldTrackAck(type) {
+  return type === "start" || type === "data" || type === "close";
+}
+function isSafePositiveInteger(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+function isSafeNonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function validatePayloadForType(type, payload, prefix) {
+  const kind = typeof payload === "object" && payload !== null ? payload.kind : void 0;
+  switch (type) {
+    case "data":
+      return kind === "data" && payload.value !== void 0 ? void 0 : `${prefix}: data envelope requires data payload`;
+    case "nack":
+    case "error":
+      return kind === "error" && payload.error !== void 0 ? void 0 : `${prefix}: ${type} envelope requires error payload`;
+    case "status":
+      return kind === "status" && payload.status !== void 0 ? void 0 : `${prefix}: status envelope requires status payload`;
+    case "close":
+      return kind === "close" ? void 0 : `${prefix}: close envelope requires close payload`;
+    case "start":
+    case "ack":
+      return payload === void 0 ? void 0 : `${prefix}: ${type} envelope must not carry a payload`;
+  }
+}
+function bridgePayloadError(payload, fallback) {
+  if (typeof payload === "object" && payload !== null && payload.kind === "error") {
+    return payload.error;
+  }
+  return fallback;
+}
+function rethrowGraphRuntimeInvariant(error) {
+  const message = errorMessage(error);
+  if (message.includes("R-reentrancy") || message.includes("R-rewire") || message.includes("R-graph-domain") || message.includes("D37") || message.includes("D22") || message.includes("different graph") || message.includes("cross-graph") || message.includes("wire bridge") || message.includes("mid-fn topology mutation") || message.includes("reentrant dep mutation") || message.includes("feedback cycle")) {
+    throw error;
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/adapters/environment.ts
+function assertSourceLocal(source) {
+  return source;
+}
+function initSendState(ctx) {
+  let state = ctx.state.get();
+  if (state === void 0) {
+    state = {
+      seq: 0,
+      cancels: /* @__PURE__ */ new Map(),
+      timers: /* @__PURE__ */ new Map(),
+      active: true,
+      cleanupInstalled: false
+    };
+    ctx.state.set(state);
+  }
+  state.active = true;
+  if (!state.cleanupInstalled) {
+    state.cleanupInstalled = true;
+    ctx.onDeactivation(() => {
+      state.active = false;
+      state.cleanupInstalled = false;
+      for (const cancel of state.cancels.values()) runCancel(cancel);
+      for (const timer of state.timers.values()) clearTimeout(timer);
+      state.cancels.clear();
+      state.timers.clear();
+    });
+  }
+  return state;
+}
+function runCancel(cancel) {
+  try {
+    cancel();
+  } catch {
+  }
+}
+function outboundNodes(graph, events, name) {
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      const current = ctx.state.get() ?? { state: "idle", inFlight: 0, attempt: 0, sent: 0, failed: 0 };
+      let next = current;
+      for (const event of depBatch(ctx, 0) ?? []) {
+        next = reduceStatus(next, event);
+      }
+      ctx.state.set(next);
+      ctx.down([["DATA", next]]);
+    },
+    { name: `${name}/status`, factory: "outboundStatus" }
+  );
+  const attempts = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if ("attempt" in typed) ctx.down([["DATA", typed.attempt]]);
+      }
+    },
+    { name: `${name}/attempts`, factory: "outboundAttempts" }
+  );
+  const errors = graph.node(
+    [events],
+    (ctx) => {
+      for (const event of depBatch(ctx, 0) ?? []) {
+        const typed = event;
+        if ("error" in typed) ctx.down([["DATA", typed.error]]);
+      }
+    },
+    { name: `${name}/errors`, factory: "outboundErrors" }
+  );
+  return { events, status, attempts, errors };
+}
+function reduceStatus(current, event) {
+  switch (event.kind) {
+    case "attempt":
+      return {
+        ...current,
+        state: "running",
+        inFlight: current.inFlight + 1,
+        attempt: event.attempt
+      };
+    case "retry":
+      return {
+        ...current,
+        state: "waiting",
+        inFlight: Math.max(0, current.inFlight - 1),
+        attempt: event.attempt,
+        lastDelayMs: event.delayMs
+      };
+    case "sent":
+      return {
+        ...current,
+        state: "succeeded",
+        inFlight: Math.max(0, current.inFlight - 1),
+        attempt: event.attempt,
+        sent: current.sent + 1,
+        lastDelayMs: void 0
+      };
+    case "failed":
+      return {
+        ...current,
+        state: "failed",
+        inFlight: Math.max(0, current.inFlight - 1),
+        attempt: event.attempt,
+        failed: current.failed + 1
+      };
+    case "exhausted":
+      return {
+        ...current,
+        state: "exhausted",
+        inFlight: Math.max(0, current.inFlight - 1),
+        attempt: event.attempt,
+        failed: current.failed + 1
+      };
+    case "upstream-complete":
+      return { ...current, state: "completed" };
+    case "upstream-error":
+      return { ...current, state: "failed", failed: current.failed + 1 };
+  }
+}
+function initWebSocketSessionState(ctx) {
+  let state = ctx.state.get();
+  if (state === void 0) {
+    state = {
+      active: true,
+      connected: false,
+      cleanupInstalled: false,
+      currentAttempt: 0,
+      currentSession: void 0,
+      sendCancels: /* @__PURE__ */ new Map(),
+      liveSends: /* @__PURE__ */ new Map(),
+      pendingOutbound: [],
+      timers: /* @__PURE__ */ new Map(),
+      seq: 0,
+      outboundSeq: 0
+    };
+    ctx.state.set(state);
+  }
+  state.active = true;
+  if (!state.cleanupInstalled) {
+    state.cleanupInstalled = true;
+    ctx.onDeactivation(() => {
+      const sendCancels = [...state.sendCancels.values()];
+      const timers = [...state.timers.values()];
+      const session = state.currentSession;
+      state.active = false;
+      state.cleanupInstalled = false;
+      state.connected = false;
+      state.currentAttempt = 0;
+      state.currentSession = void 0;
+      state.sendCancels.clear();
+      state.liveSends.clear();
+      state.pendingOutbound = [];
+      state.timers.clear();
+      for (const cancel of sendCancels) runCancel(cancel);
+      for (const timer of timers) clearTimeout(timer);
+      session?.cancel();
+    });
+  }
+  return state;
+}
+function closeWebSocketSessionState(state, driverAction = "cancel") {
+  const session = state.currentSession;
+  const timers = [...state.timers.values()];
+  const sendCancels = [...state.sendCancels.values()];
+  const canceled = [...state.pendingOutbound, ...state.liveSends.values()];
+  state.connected = false;
+  state.currentAttempt = 0;
+  state.currentSession = void 0;
+  state.timers.clear();
+  state.sendCancels.clear();
+  state.pendingOutbound = [];
+  state.liveSends.clear();
+  for (const timer of timers) clearTimeout(timer);
+  for (const cancelSend of sendCancels) runCancel(cancelSend);
+  if (driverAction === "cancel") session?.cancel();
+  return { canceled, session };
+}
+function cancelRetryTimers(state) {
+  for (const timer of state.timers.values()) clearTimeout(timer);
+  state.timers.clear();
+}
+function cleanupWebSocketConnection(state, driverAction = "cancel") {
+  const session = state.currentSession;
+  const sendCancels = [...state.sendCancels.values()];
+  const canceled = [...state.liveSends.values()];
+  state.connected = false;
+  state.currentAttempt = 0;
+  state.currentSession = void 0;
+  state.sendCancels.clear();
+  state.liveSends.clear();
+  for (const cancelSend of sendCancels) runCancel(cancelSend);
+  if (driverAction === "cancel") session?.cancel();
+  return canceled;
+}
+function normalizeWebSocketSessionSendPolicy(policy) {
+  if (policy?.kind !== "buffer") return { kind: "reject" };
+  if (!Number.isFinite(policy.maxPending) || policy.maxPending < 1) {
+    throw new Error("webSocketSession: buffer sendPolicy requires finite maxPending >= 1");
+  }
+  return { kind: "buffer", maxPending: Math.floor(policy.maxPending) };
+}
+function webSocketSessionEventNode(graph, command, request, name, policy, sendPolicy) {
+  return graph.node(
+    [command],
+    (ctx) => {
+      const state = initWebSocketSessionState(ctx);
+      const emitOutbound = (fact) => {
+        ctx.down([["DATA", { kind: "outbound", fact }]]);
+      };
+      const emitOutboundCanceled = (items, reason) => {
+        for (const item of items) {
+          emitOutbound({
+            kind: "canceled",
+            seq: item.seq,
+            message: item.message,
+            reason
+          });
+        }
+      };
+      const emitOutboundRejected = (items, error) => {
+        const payload = errorPayload(error);
+        for (const item of items) {
+          emitOutbound({
+            kind: "rejected",
+            seq: item.seq,
+            message: item.message,
+            error: payload
+          });
+        }
+      };
+      const retryOrExhaust = (attempt, error) => {
+        const payload = errorPayload(error);
+        const canceled = cleanupWebSocketConnection(state);
+        emitOutboundCanceled(canceled, `${name}: connection cleanup`);
+        if (shouldRetry(policy, attempt)) {
+          const nextAttempt = attempt + 1;
+          const delayMs = nextRetryDelayMs(policy, nextAttempt) ?? 0;
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "retry",
+                attempt,
+                nextAttempt,
+                delayMs,
+                error: payload
+              }
+            ]
+          ]);
+          const timerId = state.seq++;
+          const timer = setTimeout(() => {
+            state.timers.delete(timerId);
+            if (!state.active) return;
+            start(nextAttempt);
+          }, delayMs);
+          state.timers.set(timerId, timer);
+        } else {
+          emitOutboundRejected(state.pendingOutbound, payload);
+          state.pendingOutbound = [];
+          ctx.down([
+            [
+              "DATA",
+              { kind: "exhausted", attempt, error: payload }
+            ]
+          ]);
+        }
+      };
+      const start = (attempt) => {
+        if (!state.active || state.connected || state.currentAttempt !== 0 || state.timers.size > 0) {
+          return;
+        }
+        const driver = ctx.environment().webSocketDriver();
+        state.currentAttempt = attempt;
+        ctx.down([
+          [
+            "DATA",
+            {
+              kind: "attempt",
+              attempt,
+              maxAttempts: policy.maxAttempts
+            }
+          ]
+        ]);
+        const connectSession = driver?.connectSession;
+        if (connectSession === void 0) {
+          retryOrExhaust(attempt, `${name}: missing WebSocket session capability`);
+          return;
+        }
+        let session;
+        try {
+          session = connectSession.call(driver, request, (event) => {
+            if (!state.active || state.currentAttempt !== attempt) return;
+            if (event.kind === "event") {
+              const ws = event.event;
+              if (ws.kind === "open") {
+                state.connected = true;
+                ctx.down([["DATA", { kind: "open", attempt }]]);
+                flushPending();
+              } else if (ws.kind === "text" || ws.kind === "binary") {
+                ctx.down([
+                  [
+                    "DATA",
+                    {
+                      kind: "message",
+                      message: ws
+                    }
+                  ]
+                ]);
+              } else if (ws.kind === "close") {
+                const normalClose = ws.code === 1e3;
+                const canceled = cleanupWebSocketConnection(state);
+                emitOutboundCanceled(canceled, `${name}: session closed`);
+                ctx.down([
+                  [
+                    "DATA",
+                    {
+                      kind: "closed",
+                      code: ws.code,
+                      reason: ws.reason
+                    }
+                  ]
+                ]);
+                if (!normalClose) {
+                  retryOrExhaust(attempt, {
+                    kind: "close",
+                    code: ws.code,
+                    reason: ws.reason
+                  });
+                }
+              }
+            } else if (event.kind === "error") {
+              retryOrExhaust(attempt, event.error);
+            } else if (event.kind === "complete") {
+              retryOrExhaust(attempt, `${name}: connection completed`);
+            }
+          });
+        } catch (error) {
+          retryOrExhaust(attempt, error);
+          return;
+        }
+        if (session === void 0) {
+          retryOrExhaust(attempt, `${name}: missing WebSocket session capability`);
+          return;
+        }
+        if (state.active && state.currentAttempt === attempt) {
+          state.currentSession = session;
+        } else {
+          session.cancel();
+        }
+      };
+      function sendNow(item) {
+        if (!state.connected) {
+          emitOutbound({
+            kind: "rejected",
+            seq: item.seq,
+            message: item.message,
+            error: `${name}: session is not open`
+          });
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "error",
+                error: `${name}: session is not open`
+              }
+            ]
+          ]);
+          return;
+        }
+        const session = state.currentSession;
+        if (session === void 0) {
+          emitOutbound({
+            kind: "rejected",
+            seq: item.seq,
+            message: item.message,
+            error: `${name}: missing WebSocket session capability`
+          });
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "error",
+                error: `${name}: missing WebSocket session capability`
+              }
+            ]
+          ]);
+          return;
+        }
+        const sendId = state.seq++;
+        state.liveSends.set(sendId, item);
+        emitOutbound({ kind: "sending", seq: item.seq, message: item.message });
+        let done = false;
+        let cancel;
+        try {
+          cancel = session.send(item.message, (result) => {
+            if (done || !state.active || !state.liveSends.has(sendId)) return;
+            done = true;
+            state.liveSends.delete(sendId);
+            state.sendCancels.delete(sendId);
+            if (result.ok) {
+              emitOutbound({ kind: "sent", seq: item.seq, message: item.message });
+              ctx.down([
+                ["DATA", { kind: "sent", message: item.message }]
+              ]);
+            } else {
+              const payload = errorPayload(result.error);
+              emitOutbound({
+                kind: "rejected",
+                seq: item.seq,
+                message: item.message,
+                error: payload
+              });
+              ctx.down([
+                [
+                  "DATA",
+                  {
+                    kind: "error",
+                    error: payload
+                  }
+                ]
+              ]);
+            }
+          });
+        } catch (error) {
+          state.liveSends.delete(sendId);
+          const payload = errorPayload(error);
+          emitOutbound({
+            kind: "rejected",
+            seq: item.seq,
+            message: item.message,
+            error: payload
+          });
+          ctx.down([["DATA", { kind: "error", error: payload }]]);
+          return;
+        }
+        if (cancel !== void 0 && !done && state.active && state.liveSends.has(sendId)) {
+          state.sendCancels.set(sendId, cancel);
+        } else if (cancel !== void 0 && !state.active) runCancel(cancel);
+      }
+      function flushPending() {
+        const pending = state.pendingOutbound;
+        state.pendingOutbound = [];
+        for (let index = 0; index < pending.length; index++) {
+          const item = pending[index];
+          if (!state.connected || state.currentSession === void 0) {
+            emitOutboundCanceled(pending.slice(index), `${name}: session closed`);
+            return;
+          }
+          sendNow(item);
+        }
+      }
+      const send = (message) => {
+        const item = { seq: state.outboundSeq++, message };
+        if (state.connected) {
+          sendNow(item);
+          return;
+        }
+        if (sendPolicy.kind === "buffer") {
+          if (state.pendingOutbound.length >= sendPolicy.maxPending) {
+            emitOutbound({
+              kind: "rejected",
+              seq: item.seq,
+              message,
+              error: `${name}: outbound buffer full`
+            });
+            ctx.down([
+              [
+                "DATA",
+                {
+                  kind: "error",
+                  error: `${name}: outbound buffer full`
+                }
+              ]
+            ]);
+            return;
+          }
+          state.pendingOutbound.push(item);
+          emitOutbound({ kind: "queued", seq: item.seq, message });
+          return;
+        }
+        emitOutbound({
+          kind: "rejected",
+          seq: item.seq,
+          message,
+          error: `${name}: session is not open`
+        });
+        ctx.down([
+          [
+            "DATA",
+            {
+              kind: "error",
+              error: `${name}: session is not open`
+            }
+          ]
+        ]);
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const commandValue = raw;
+        if (commandValue.kind === "start") start(1);
+        else if (commandValue.kind === "send") send(commandValue.message);
+        else {
+          cancelRetryTimers(state);
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "closing",
+                code: commandValue.code,
+                reason: commandValue.reason
+              }
+            ]
+          ]);
+          const { canceled, session } = closeWebSocketSessionState(state, "none");
+          emitOutboundCanceled(canceled, `${name}: session closed`);
+          session?.close(commandValue.code, commandValue.reason);
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "closed",
+                code: commandValue.code,
+                reason: commandValue.reason
+              }
+            ]
+          ]);
+        }
+      }
+    },
+    { name: `${name}/events`, factory: "webSocketSessionEvents" }
+  );
+}
+function webSocketSessionNodes(graph, command, events, name, policy) {
+  const inbound = graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "message") ctx.down([["DATA", event.message]]);
+      }
+    },
+    { name: `${name}/inbound`, factory: "webSocketSessionInbound" }
+  );
+  const lifecycle = graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "attempt") {
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "starting",
+                attempt: event.attempt,
+                maxAttempts: event.maxAttempts
+              }
+            ]
+          ]);
+        } else if (event.kind === "open") {
+          ctx.down([["DATA", { kind: "open", attempt: event.attempt }]]);
+        } else if (event.kind === "sent") {
+          ctx.down([["DATA", { kind: "sent", message: event.message }]]);
+        } else if (event.kind === "closing" || event.kind === "closed") {
+          ctx.down([["DATA", event]]);
+        } else if (event.kind === "retry") {
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "retrying",
+                attempt: event.attempt,
+                nextAttempt: event.nextAttempt,
+                delayMs: event.delayMs,
+                error: event.error
+              }
+            ]
+          ]);
+        } else if (event.kind === "exhausted") {
+          ctx.down([["DATA", event]]);
+        }
+      }
+    },
+    { name: `${name}/lifecycle`, factory: "webSocketSessionLifecycle" }
+  );
+  const outbound = graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "outbound") ctx.down([["DATA", event.fact]]);
+      }
+    },
+    { name: `${name}/outbound`, factory: "webSocketSessionOutbound" }
+  );
+  const status = graph.node(
+    [events],
+    (ctx) => {
+      let next = ctx.state.get() ?? {
+        state: "idle",
+        attempt: 0,
+        maxAttempts: policy.maxAttempts,
+        sent: 0,
+        received: 0,
+        errors: 0
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "attempt") {
+          next = {
+            ...next,
+            state: "connecting",
+            attempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            lastDelayMs: void 0
+          };
+        } else if (event.kind === "open") {
+          next = { ...next, state: "open", attempt: event.attempt, lastDelayMs: void 0 };
+        } else if (event.kind === "message") {
+          next = { ...next, received: next.received + 1 };
+        } else if (event.kind === "sent") {
+          next = { ...next, sent: next.sent + 1 };
+        } else if (event.kind === "closing") {
+          next = { ...next, state: "closing" };
+        } else if (event.kind === "closed") {
+          next = { ...next, state: "closed" };
+        } else if (event.kind === "retry") {
+          next = {
+            ...next,
+            state: "waiting",
+            attempt: event.attempt,
+            errors: next.errors + 1,
+            lastDelayMs: event.delayMs
+          };
+        } else if (event.kind === "error") {
+          next = {
+            ...next,
+            state: "errored",
+            attempt: event.attempt ?? next.attempt,
+            errors: next.errors + 1
+          };
+        } else if (event.kind === "exhausted") {
+          next = {
+            ...next,
+            state: "exhausted",
+            attempt: event.attempt,
+            errors: next.errors + 1
+          };
+        }
+      }
+      ctx.state.set(next);
+      ctx.down([["DATA", next]]);
+    },
+    { name: `${name}/status`, factory: "webSocketSessionStatus" }
+  );
+  const errors = graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if ("error" in event) ctx.down([["DATA", event.error]]);
+      }
+    },
+    { name: `${name}/errors`, factory: "webSocketSessionErrors" }
+  );
+  const attempts = graph.node(
+    [events],
+    (ctx) => {
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (event.kind === "attempt") ctx.down([["DATA", event.attempt]]);
+      }
+    },
+    { name: `${name}/attempts`, factory: "webSocketSessionAttempts" }
+  );
+  return {
+    command,
+    inbound,
+    lifecycle,
+    outbound,
+    status,
+    errors,
+    attempts,
+    start: () => command.down([["DATA", { kind: "start" }]]),
+    send: (message) => command.down([
+      [
+        "DATA",
+        {
+          kind: "send",
+          message: typeof message === "string" || message instanceof Uint8Array ? { data: message } : message
+        }
+      ]
+    ]),
+    close: (code, reason) => command.down([["DATA", { kind: "close", code, reason }]])
+  };
+}
+function webSocketSession(graph, request, opts = {}) {
+  const name = opts.name ?? "webSocketSession";
+  const policy = opts.retry ?? retryPolicy();
+  const sendPolicy = normalizeWebSocketSessionSendPolicy(opts.sendPolicy);
+  const command = graph.node([], null, {
+    name: `${name}/command`,
+    factory: "webSocketSessionCommand"
+  });
+  const events = webSocketSessionEventNode(graph, command, request, name, policy, sendPolicy);
+  return webSocketSessionNodes(graph, command, events, name, policy);
+}
+function outboundNode(graph, source, name, send, opts) {
+  const policy = opts.retry ?? retryPolicy();
+  return graph.node(
+    [assertSourceLocal(source)],
+    (ctx) => {
+      const state = initSendState(ctx);
+      const start = (value, attempt) => {
+        if (!state.active) return;
+        const id = state.seq++;
+        ctx.down([
+          ["DATA", { kind: "attempt", value, attempt }]
+        ]);
+        const failTerminal = (error) => {
+          const payload = errorPayload(error);
+          ctx.down([
+            [
+              "DATA",
+              { kind: "exhausted", value, attempt, error: payload }
+            ]
+          ]);
+          ctx.down([["ERROR", payload]]);
+        };
+        let cancel;
+        let done = false;
+        try {
+          cancel = send(ctx, value, (result) => {
+            if (done || !state.active) return;
+            done = true;
+            state.cancels.delete(id);
+            if (result.ok) {
+              ctx.down([
+                [
+                  "DATA",
+                  { kind: "sent", value, attempt, result: result.value }
+                ]
+              ]);
+              return;
+            }
+            if (shouldRetry(policy, attempt)) {
+              const nextAttempt = attempt + 1;
+              const delayMs = nextRetryDelayMs(policy, nextAttempt) ?? 0;
+              ctx.down([
+                [
+                  "DATA",
+                  {
+                    kind: "retry",
+                    value,
+                    attempt,
+                    delayMs,
+                    error: errorPayload(result.error)
+                  }
+                ]
+              ]);
+              const timer = setTimeout(() => {
+                state.timers.delete(id);
+                if (!state.active) return;
+                start(value, nextAttempt);
+              }, delayMs);
+              state.timers.set(id, timer);
+            } else {
+              ctx.down([
+                [
+                  "DATA",
+                  {
+                    kind: "exhausted",
+                    value,
+                    attempt,
+                    error: errorPayload(result.error)
+                  }
+                ]
+              ]);
+            }
+          });
+        } catch (error) {
+          if (!done) {
+            done = true;
+            state.cancels.delete(id);
+            failTerminal(error);
+          }
+          return;
+        }
+        if (cancel === void 0) {
+          if (!done) {
+            done = true;
+            failTerminal(`${name}: missing environment driver capability`);
+          }
+          return;
+        }
+        if (!done && state.active) {
+          state.cancels.set(id, cancel);
+        } else if (!state.active) {
+          runCancel(cancel);
+        }
+      };
+      for (const value of depBatch(ctx, 0) ?? []) start(value, 1);
+      const terminal = ctx.terminal[0];
+      if (terminal === true) {
+        ctx.down([
+          ["DATA", { kind: "upstream-complete" }]
+        ]);
+      } else if (terminal !== false && terminal !== void 0) {
+        ctx.down([
+          [
+            "DATA",
+            { kind: "upstream-error", error: terminal }
+          ]
+        ]);
+      }
+    },
+    { name, factory: name }
+  );
+}
+function toHttp(graph, source, requestOf, opts = {}) {
+  const name = opts.name ?? "toHttp";
+  const events = outboundNode(
+    graph,
+    source,
+    name,
+    (ctx, value, callback) => {
+      const request = requestOf(value);
+      return ctx.environment().httpDriver()?.request(request, callback);
+    },
+    opts
+  );
+  return outboundNodes(graph, events, name);
+}
+function toProcess(graph, source, commandOf, opts = {}) {
+  const name = opts.name ?? "toProcess";
+  const events = outboundNode(
+    graph,
+    source,
+    name,
+    (ctx, value, callback) => {
+      const command = commandOf(value);
+      return ctx.environment().processDriver()?.run(command, callback);
+    },
+    opts
+  );
+  return outboundNodes(graph, events, name);
+}
+function toWebSocket(graph, source, request, sendOf, opts = {}) {
+  const name = opts.name ?? "toWebSocket";
+  const events = outboundNode(
+    graph,
+    source,
+    name,
+    (ctx, value, callback) => {
+      const driver = ctx.environment().webSocketDriver();
+      return driver?.send?.(request, sendOf(value), callback);
+    },
+    opts
+  );
+  return outboundNodes(graph, events, name);
+}
+
+// src/adapters/nestjs.ts
+var GRAPHREFLY_ROOT_GRAPH = /* @__PURE__ */ Symbol.for("graphrefly:root-graph");
+var GRAPHREFLY_MODULE_OPTIONS = /* @__PURE__ */ Symbol.for("graphrefly:module-options");
+var GRAPHREFLY_REQUEST_GRAPH = /* @__PURE__ */ Symbol.for("graphrefly:request-graph");
+var EVENT_HANDLERS = /* @__PURE__ */ new Map();
+var INTERVAL_HANDLERS = /* @__PURE__ */ new Map();
+var CRON_HANDLERS = /* @__PURE__ */ new Map();
+function getGraphToken(name) {
+  return /* @__PURE__ */ Symbol.for(`graphrefly:graph:${name}`);
+}
+function getNodeToken(path) {
+  return /* @__PURE__ */ Symbol.for(`graphrefly:node:${path}`);
+}
+function sameMeta(a, b) {
+  const left = a;
+  const right = b;
+  const keys = Reflect.ownKeys(left);
+  if (keys.length !== Reflect.ownKeys(right).length) return false;
+  for (const key of keys) {
+    if (!Object.is(left[key], right[key])) return false;
+  }
+  return true;
+}
+function pushUniqueMeta(registry, ctor, item) {
+  const existing = registry.get(ctor) ?? [];
+  if (existing.some((current) => sameMeta(current, item))) return;
+  registry.set(ctor, [...existing, item]);
+}
+function registerMeta(registry, meta) {
+  return ((targetOrValue, contextOrKey) => {
+    if (typeof contextOrKey === "object" && contextOrKey !== null) {
+      const methodKey = contextOrKey.name;
+      contextOrKey.addInitializer(function() {
+        const ctor2 = this.constructor;
+        pushUniqueMeta(registry, ctor2, meta(methodKey));
+      });
+      return;
+    }
+    const ctor = targetOrValue.constructor;
+    pushUniqueMeta(registry, ctor, meta(contextOrKey));
+  });
+}
+function OnGraphEvent(nodeName) {
+  return registerMeta(EVENT_HANDLERS, (methodKey) => ({ nodeName, methodKey }));
+}
+function GraphInterval(ms) {
+  return registerMeta(INTERVAL_HANDLERS, (methodKey) => ({ ms, methodKey }));
+}
+function GraphCron(expr) {
+  return registerMeta(CRON_HANDLERS, (methodKey) => ({ expr, methodKey }));
+}
+
+// src/adapters/store.ts
+function nodeSnapshot(node) {
+  return node.cache;
+}
+function subscribeNodeValues(node, run, opts = {}) {
+  const read = opts.getSnapshot ?? (() => nodeSnapshot(node));
+  if (opts.immediate) run(read());
+  let subscribing = true;
+  const skipSynchronousHandshakeData = opts.changesOnly || opts.immediate;
+  const sink = (msg, delivery) => {
+    switch (msg[0]) {
+      case "DATA":
+        if (skipSynchronousHandshakeData && subscribing && delivery === void 0) {
+          return;
+        }
+        run(msg[1]);
+        return;
+      case "ERROR":
+        opts.onError?.(msg[1]);
+        return;
+      case "COMPLETE":
+        opts.onComplete?.();
+        return;
+    }
+  };
+  const unsubscribe = node.subscribe(sink);
+  subscribing = false;
+  return unsubscribe;
+}
+function readableStore(node, opts = {}) {
+  return {
+    get: () => (opts.getSnapshot ?? (() => nodeSnapshot(node)))(),
+    subscribe: (run) => subscribeNodeValues(node, run, { immediate: true, ...opts })
+  };
+}
+function hasWritableSet(node) {
+  return typeof node.set === "function";
+}
+function defaultWrite(node, value) {
+  node.set(value);
+}
+function writableStore(node, opts = {}) {
+  const read = opts.getSnapshot ?? (() => nodeSnapshot(node));
+  const write = opts.write ?? (hasWritableSet(node) ? defaultWrite : void 0);
+  if (!write) {
+    throw new TypeError("writableStore: node must expose set(value) or opts.write");
+  }
+  const writable = node;
+  return {
+    get: read,
+    subscribe: (run) => subscribeNodeValues(node, run, { immediate: true, ...opts }),
+    set: (value) => write(writable, value),
+    update: (fn) => write(writable, fn(read()))
+  };
+}
+function externalStore(node, opts = {}) {
+  const read = opts.getSnapshot ?? (() => nodeSnapshot(node));
+  return {
+    getSnapshot: read,
+    getServerSnapshot: read,
+    subscribe: (onStoreChange) => subscribeNodeValues(node, () => onStoreChange(), {
+      changesOnly: true,
+      onError: opts.onError,
+      onComplete: opts.onComplete
+    })
+  };
+}
+var reactExternalStore = externalStore;
+var svelteReadableStore = readableStore;
+var svelteWritableStore = writableStore;
+function recordReadableStore(keysNode, factory, opts = {}) {
+  const read = () => {
+    const keys = keysNode.cache ?? [];
+    const out = {};
+    for (const key of keys) {
+      const nodes = factory(key);
+      const values = {};
+      for (const field of Object.keys(nodes)) {
+        values[field] = nodes[field].cache;
+      }
+      out[key] = values;
+    }
+    return out;
+  };
+  return {
+    get: read,
+    subscribe(run) {
+      const entryUnsubs = [];
+      const cleanupEntries = () => {
+        for (const unsub of entryUnsubs.splice(0)) unsub();
+      };
+      const sync = () => {
+        cleanupEntries();
+        for (const key of keysNode.cache ?? []) {
+          const nodes = factory(key);
+          for (const field of Object.keys(nodes)) {
+            entryUnsubs.push(
+              subscribeNodeValues(nodes[field], () => run(read()), {
+                changesOnly: true,
+                onError: opts.onError,
+                onComplete: opts.onComplete
+              })
+            );
+          }
+        }
+        run(read());
+      };
+      const keysUnsub = subscribeNodeValues(keysNode, sync, {
+        changesOnly: true,
+        onError: opts.onError,
+        onComplete: opts.onComplete
+      });
+      sync();
+      return () => {
+        keysUnsub();
+        cleanupEntries();
+      };
+    }
+  };
+}
+function zustandStore(node, initialState = nodeSnapshot(node), opts = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const read = opts.getSnapshot ?? (() => nodeSnapshot(node));
+  const write = opts.write ?? (hasWritableSet(node) ? defaultWrite : void 0);
+  if (!write) {
+    throw new TypeError("zustandStore: node must expose set(value) or opts.write");
+  }
+  const writable = node;
+  const api = {
+    getState: () => read(),
+    setState(partial, replace) {
+      const prev = api.getState();
+      const next = typeof partial === "function" ? partial(prev) : partial;
+      write(writable, replace ? next : { ...prev, ...next });
+    },
+    getInitialState: () => initialState,
+    subscribe(listener) {
+      let prev = api.getState();
+      const unsub = subscribeNodeValues(
+        node,
+        (value) => {
+          const next = value;
+          listener(next, prev);
+          prev = next;
+        },
+        { changesOnly: true, onError: opts.onError, onComplete: opts.onComplete }
+      );
+      listeners.add(unsub);
+      return () => {
+        if (!listeners.delete(unsub)) return;
+        unsub();
+      };
+    },
+    destroy() {
+      for (const unsub of [...listeners]) {
+        listeners.delete(unsub);
+        unsub();
+      }
+    }
+  };
+  return api;
+}
+function jotaiAtom(node, opts = {}) {
+  const base = {
+    get: () => (opts.getSnapshot ?? (() => nodeSnapshot(node)))(),
+    subscribe: (callback) => subscribeNodeValues(node, callback, { changesOnly: true, ...opts }),
+    _node: node
+  };
+  if (hasWritableSet(node) || typeof opts.write === "function") {
+    const writable = writableStore(
+      node,
+      opts
+    );
+    return { ...base, set: writable.set, update: writable.update };
+  }
+  return base;
+}
+function nanoAtom(node, opts = {}) {
+  const base = {
+    get: () => (opts.getSnapshot ?? (() => nodeSnapshot(node)))(),
+    subscribe: (callback) => subscribeNodeValues(node, callback, { immediate: true, ...opts }),
+    listen: (callback) => subscribeNodeValues(node, callback, { changesOnly: true, ...opts }),
+    _node: node
+  };
+  if (hasWritableSet(node) || typeof opts.write === "function") {
+    const writable = writableStore(
+      node,
+      opts
+    );
+    return { ...base, set: writable.set, update: writable.update };
+  }
+  return base;
+}
+function signalFromNode(node, opts = {}) {
+  const base = {
+    get: () => (opts.getSnapshot ?? (() => nodeSnapshot(node)))(),
+    subscribe: (callback) => subscribeNodeValues(node, callback, { changesOnly: true, ...opts }),
+    _node: node
+  };
+  if (hasWritableSet(node) || typeof opts.write === "function") {
+    const writable = writableStore(
+      node,
+      opts
+    );
+    return { ...base, set: writable.set, update: writable.update };
+  }
+  return base;
+}
+export {
+  AGENTIC_MEMORY_RECORD_CHANGE_FORMAT,
+  AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+  AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+  CRON_HANDLERS,
+  EVENT_HANDLERS,
+  GRAPHREFLY_MODULE_OPTIONS,
+  GRAPHREFLY_REQUEST_GRAPH,
+  GRAPHREFLY_ROOT_GRAPH,
+  GraphCron,
+  GraphInterval,
+  INTERVAL_HANDLERS,
+  OnGraphEvent,
+  agenticMemoryRecordChangeFrame,
+  agenticMemoryRecordSnapshotFrame,
+  agenticMemoryRecordsSnapshotKey,
+  assertAgenticMemoryRecordChangeFrame,
+  assertAgenticMemoryRecordSnapshotFrame,
+  externalStore,
+  getGraphToken,
+  getNodeToken,
+  jotaiAtom,
+  loadAgenticMemoryRecordsState,
+  nanoAtom,
+  nodeSnapshot,
+  openPersistentAgenticMemoryRecords,
+  openPersistentReactiveIndex,
+  openPersistentReactiveList,
+  openPersistentReactiveLog,
+  openPersistentReactiveMap,
+  persistAgenticMemoryRecords,
+  persistReactiveCollection,
+  reactExternalStore,
+  readableStore,
+  recordReadableStore,
+  remoteCall,
+  remoteResponder,
+  remoteResponderHandler,
+  signalFromNode,
+  subscribeNodeValues,
+  svelteReadableStore,
+  svelteWritableStore,
+  toHttp,
+  toProcess,
+  toWebSocket,
+  webSocketSession,
+  wireBridge,
+  wireBridgeEnvelope,
+  wireBridgeIdempotencyKey,
+  writableStore,
+  zustandStore
+};
+//# sourceMappingURL=index.js.map