@smthrs/gateway 0.35.0 → 1.0.0-rc.4

package/dist/cjs/Projections.js

@@ -0,0 +1,906 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Projections_exports = {};
+__export(Projections_exports, {
+  Projections: () => Projections,
+  heartbeatIntervalMillis: () => heartbeatIntervalMillis,
+  layer: () => layer,
+  layerWith: () => layerWith,
+  make: () => make,
+  maxDurationRuns: () => maxDurationRuns,
+  maxEventBytes: () => maxEventBytes,
+  maxEventsPerPage: () => maxEventsPerPage,
+  maxEventsPerRun: () => maxEventsPerRun,
+  maxEventsScanned: () => maxEventsScanned,
+  maxProjectionBytes: () => maxProjectionBytes,
+  maxWorkspaceRuns: () => maxWorkspaceRuns
+});
+module.exports = __toCommonJS(Projections_exports);
+var import_Control = require("@smthrs/control/Control");
+var ControlSchema = __toESM(require("@smthrs/control/ControlSchema"), 1);
+var Health = __toESM(require("@smthrs/control/Health"), 1);
+var import_effect = require("effect");
+var Diagnosis = __toESM(require("./Diagnosis.js"), 1);
+var import_GatewayError = require("./GatewayError.js");
+var GatewayProjection = __toESM(require("./GatewayProjection.js"), 1);
+var GatewaySchema = __toESM(require("./GatewaySchema.js"), 1);
+var import_callEvents = require("./internal/callEvents.js");
+var import_digestMemory = require("./internal/digestMemory.js");
+var NativeResolution = __toESM(require("./internal/nativeResolution.js"), 1);
+const heartbeatIntervalMillis = 3e4;
+const maxWorkspaceRuns = 500;
+const createdAfter = (run, other) => run.createdAt !== other.createdAt ? run.createdAt > other.createdAt : run.runId > other.runId;
+const maxEventsPerRun = 1e4;
+const maxEventsScanned = 1e5;
+const maxEventsPerPage = 1e3;
+const maxDurationRuns = 20;
+const maxProjectionBytes = 4 * 1024 * 1024;
+const maxEventBytes = 16 * 1024;
+const clippedTextPoints = 2048;
+const workspaceDeltaCoalesceMillis = 50;
+const workspaceDeltaBatchSize = 1024;
+class Projections extends import_effect.Context.Service()("@smthrs/gateway/Projections") {
+}
+const summarize = (cause) => {
+  const record = typeof cause === "object" && cause !== null ? cause : void 0;
+  if (record === void 0 || typeof record._tag !== "string") return void 0;
+  return typeof record.code === "string" ? { _tag: record._tag, code: record.code } : { _tag: record._tag };
+};
+const logReadFailure = (operation, cause) => {
+  const summary = summarize(cause);
+  const known = summary?._tag === "/control/PersistenceError" && summary.code === "persistence_failed" || summary?._tag === "/control/Unavailable" && summary.code === "unavailable";
+  return import_effect.Effect.logWarning({ operation, ...known ? summary : {} });
+};
+const unavailable = (message, cause) => {
+  const summary = summarize(cause);
+  return new import_GatewayError.GatewayError({
+    code: "run_unavailable",
+    message,
+    ...summary === void 0 ? {} : { cause: summary }
+  });
+};
+const malformed = (message) => new import_GatewayError.GatewayError({ code: "malformed_request", message });
+const resourceLimit = (message) => new import_GatewayError.GatewayError({ code: "resource_limit", message });
+const scopeOf = (selector) => "runId" in selector ? selector.runId : void 0;
+const emptyEventBuffer = (compactHealth = false) => ({
+  compactHealth,
+  seen: false,
+  events: [],
+  encodedBytes: 2,
+  lastPosition: { value: 0, offset: 0 },
+  carry: void 0,
+  dropped: 0
+});
+const textEncoder = new TextEncoder();
+const encodedSize = (value) => textEncoder.encode(JSON.stringify(value)).byteLength;
+const clipDeep = (value) => {
+  if (typeof value === "string") return Diagnosis.clip(value, clippedTextPoints);
+  if (Array.isArray(value)) return value.map(clipDeep);
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(([key, member]) => [key, clipDeep(member)]));
+  }
+  return value;
+};
+const isJsonObject = (json) => typeof json === "object" && json !== null && !Array.isArray(json);
+const retainedEvent = (event) => {
+  if (encodedSize(event) <= maxEventBytes) return event;
+  const clipped = { ...event, payload: clipDeep(event.payload) };
+  if (encodedSize(clipped) <= maxEventBytes) return clipped;
+  const marker = { truncated: true, encodedBytes: encodedSize(event.payload) };
+  const payload = event.payload;
+  if (event.kind === "control.agent.relevance-settled" && isJsonObject(payload)) {
+    const memory = (verdicts) => Array.isArray(verdicts) ? verdicts.filter(
+      (verdict) => typeof verdict === "object" && verdict !== null && verdict.kind === "memory"
+    ) : [];
+    const compact = {
+      ...event,
+      payload: {
+        ...marker,
+        kept: clipDeep(memory(payload.kept)),
+        withheld: clipDeep(memory(payload.withheld))
+      }
+    };
+    if (encodedSize(compact) <= maxEventBytes) return compact;
+  }
+  return { ...event, payload: marker };
+};
+const decodeEvent = import_effect.Schema.decodeUnknownSync(ControlSchema.ControlEvent);
+const decodeFrame = import_effect.Schema.decodeUnknownSync(GatewaySchema.GatewayFrame);
+const decodeSnapshot = import_effect.Schema.decodeUnknownSync(GatewaySchema.ProjectionSnapshot);
+const decodedEvent = (candidate, message) => import_effect.Effect.suspend(() => {
+  try {
+    const event = decodeEvent(candidate);
+    const payload = event.payload;
+    if (event.kind === "control.engine.event" && typeof payload === "object" && payload !== null && "eventType" in payload && (payload.eventType === "flows.engine.plan-recorded" || payload.eventType === "flows.engine.subgraph-appended") && encodedSize(event) > maxEventBytes) {
+      return import_effect.Effect.fail(resourceLimit(`One graph event exceeds ${maxEventBytes} encoded bytes`));
+    }
+    return Number.isSafeInteger(event.sequence) && event.sequence >= 0 ? import_effect.Effect.succeed(event) : import_effect.Effect.fail(unavailable(message, void 0));
+  } catch (cause) {
+    return import_effect.Effect.fail(unavailable(message, cause));
+  }
+});
+const appendEvent = (state, candidate, message, run) => import_effect.Effect.flatMap(decodedEvent(candidate, message), (decoded) => {
+  const resolution = encodedSize(decoded) > maxEventBytes ? NativeResolution.fromEvent(decoded) : void 0;
+  let carry = state.carry;
+  if (resolution?.result !== void 0) {
+    carry = Diagnosis.combine(carry ?? Diagnosis.emptyDigest(), {
+      ...Diagnosis.emptyDigest(),
+      nativeResolution: resolution
+    });
+  }
+  const event = resolution?.result === void 0 ? retainedEvent(decoded) : {
+    ...decoded,
+    payload: { truncated: true, encodedBytes: encodedSize(decoded.payload) }
+  };
+  const bytes = encodedSize(event);
+  let removedBytes = 0;
+  let keep = true;
+  if (state.compactHealth && event.kind === Health.statusObservedEventType) {
+    const decoded2 = import_effect.Schema.decodeUnknownOption(Health.HealthObservation)(event.payload);
+    if (decoded2._tag === "None" || decoded2.value.outcome === "discarded" || decoded2.value.subjectId !== `run:${run.runId}`) keep = false;
+    else {
+      const same = state.events.findIndex(
+        (old) => old.kind === Health.statusObservedEventType && typeof old.payload === "object" && old.payload !== null && !Array.isArray(old.payload) && "incarnation" in old.payload && old.payload.incarnation === decoded2.value.incarnation
+      );
+      if (same >= 0) {
+        const previous = state.events[same];
+        const prior = previous.payload;
+        if (prior.evidenceSeq > decoded2.value.evidenceSeq) keep = false;
+        else removedBytes += textEncoder.encode(JSON.stringify(state.events.splice(same, 1)[0])).byteLength + 1;
+      }
+      const healthEntries = state.events.filter((old) => old.kind === Health.statusObservedEventType);
+      if (keep && healthEntries.length >= 16) {
+        const incarnation = Health.runIncarnation(run);
+        const oldest = state.events.indexOf(
+          healthEntries.find((old) => old.payload.incarnation !== incarnation)
+        );
+        removedBytes += textEncoder.encode(JSON.stringify(state.events.splice(oldest, 1)[0])).byteLength + 1;
+      }
+    }
+  } else if (state.compactHealth && event.kind === "control.monitor.beat") keep = false;
+  let encodedBytes = Math.max(2, state.encodedBytes - removedBytes) + (0, import_digestMemory.retainedDigestBytes)(carry) - (0, import_digestMemory.retainedDigestBytes)(state.carry) + (keep ? bytes + (state.events.length === 0 ? 0 : 1) : 0);
+  if (!Number.isSafeInteger(encodedBytes)) {
+    return import_effect.Effect.fail(unavailable(message, void 0));
+  }
+  const offset = state.seen && event.sequence === state.lastPosition.value ? state.lastPosition.offset + 1 : 0;
+  if (keep) state.events.push(event);
+  let dropped = state.dropped;
+  while (state.events.length > maxEventsPerRun || encodedBytes > maxProjectionBytes) {
+    const evicted = state.events.shift();
+    if (evicted === void 0) {
+      return import_effect.Effect.fail(resourceLimit(`Projection identity state exceeds ${maxProjectionBytes} encoded bytes`));
+    }
+    encodedBytes = Math.max(2, encodedBytes - encodedSize(evicted) - (state.events.length === 0 ? 0 : 1));
+    const previousCarryBytes = (0, import_digestMemory.retainedDigestBytes)(carry);
+    carry = Diagnosis.combine(carry ?? Diagnosis.emptyDigest(), Diagnosis.digest([evicted], run.runId));
+    encodedBytes += (0, import_digestMemory.retainedDigestBytes)(carry) - previousCarryBytes;
+    dropped += 1;
+  }
+  return import_effect.Effect.succeed({
+    compactHealth: state.compactHealth,
+    seen: true,
+    events: state.events,
+    encodedBytes,
+    lastPosition: { value: event.sequence, offset },
+    carry,
+    dropped
+  });
+});
+const bufferOf = (events, message, compactHealth, run) => events.reduce(
+  (state, event) => import_effect.Effect.flatMap(state, (buffer) => appendEvent(buffer, event, message, run)),
+  import_effect.Effect.succeed(emptyEventBuffer(compactHealth))
+);
+const cursorOf = (selector, position) => ({
+  selector,
+  projection: selector._tag,
+  runId: scopeOf(selector) ?? null,
+  value: position.value,
+  offset: position.offset
+});
+const comparePosition = (left, right) => left.value === right.value ? left.offset - right.offset : left.value - right.value;
+const positionedEvents = (events) => {
+  let sequence = -1;
+  let offset = 0;
+  return events.map((event) => {
+    offset = event.sequence === sequence ? offset + 1 : 0;
+    sequence = event.sequence;
+    return { event, position: { value: sequence, offset } };
+  });
+};
+const sameSelector = (left, right) => {
+  if (left._tag !== right._tag) return false;
+  switch (left._tag) {
+    case "workspace-runs":
+      return left.flowId === right.flowId;
+    case "approvals":
+      return left.runId === right.runId;
+    case "node-output": {
+      const candidate = right;
+      return left.runId === candidate.runId && left.nodeId === candidate.nodeId;
+    }
+    case "flow-durations":
+      return left.flowId === right.flowId;
+    default:
+      return left.runId === right.runId;
+  }
+};
+const rowsOfRun = (selector, source, now) => {
+  switch (selector._tag) {
+    case "workspace-runs":
+    case "run-summary":
+      return [GatewayProjection.runSummary(source.run, source.events, now, source.carry)];
+    case "run-tree":
+      return GatewayProjection.runTree(source.run, source.events);
+    case "run-events":
+      return source.events;
+    case "transcript":
+      return GatewayProjection.transcript(source.events);
+    case "approvals":
+      return GatewayProjection.approvals(source.events, source.run);
+    case "node-output":
+      return GatewayProjection.nodeOutput(source.events).filter((row) => row.nodeId === selector.nodeId);
+    case "flow-durations":
+      return GatewayProjection.nodeDurations(source.events, source.carry);
+  }
+};
+const turnsOpened = (events) => GatewayProjection.transcript(events).at(-1)?.turn ?? 0;
+const transcriptAppend = (event, turnsBefore) => GatewayProjection.transcript([event]).map((row) => ({ ...row, turn: row.turn + turnsBefore }));
+const eligibleForWorkspace = (selector, source) => selector._tag !== "approvals" || source.run.status === "waiting-approval" && GatewayProjection.approvals(source.events, source.run).some((row) => row.status === "pending");
+const waitIdentity = (row) => row.waitRunId === void 0 ? void 0 : `${row.waitRunId}:${row.requestId}`;
+const ownerRank = (runs) => {
+  const listed = new Map(runs.map((run) => [run.runId, run]));
+  const depths = /* @__PURE__ */ new Map();
+  const depthOf = (run) => {
+    const known = depths.get(run.runId);
+    if (known !== void 0) return known;
+    depths.set(run.runId, 0);
+    const parent = run.parentRunId === void 0 ? void 0 : listed.get(run.parentRunId);
+    const depth = parent === void 0 ? 0 : depthOf(parent) + 1;
+    depths.set(run.runId, depth);
+    return depth;
+  };
+  return (left, right) => depthOf(left) - depthOf(right) || (createdAfter(left, right) ? 1 : -1);
+};
+const approvalInbox = (perRun) => {
+  const owners = /* @__PURE__ */ new Map();
+  const rank = ownerRank(perRun.map(({ run }) => run));
+  for (const { run, rows } of [...perRun].sort((left, right) => rank(left.run, right.run))) {
+    for (const row of rows) {
+      const identity = waitIdentity(row);
+      if (identity !== void 0 && !owners.has(identity)) owners.set(identity, run.runId);
+    }
+  }
+  const inbox = [];
+  for (const { run, rows } of perRun) {
+    for (const row of rows) {
+      const identity = waitIdentity(row);
+      if (identity !== void 0) {
+        if (owners.get(identity) !== run.runId) continue;
+        owners.delete(identity);
+      }
+      inbox.push(row);
+    }
+  }
+  return inbox;
+};
+const pendingApprovals = (source) => GatewayProjection.approvals(source.events, source.run).filter((row) => row.status === "pending");
+const rowsOfWorkspace = (selector, runs, now) => {
+  if (selector._tag === "flow-durations") {
+    return GatewayProjection.flowDurations(
+      selector.flowId,
+      runs.flatMap((source) => rowsOfRun(selector, source, now))
+    );
+  }
+  if (selector._tag !== "approvals") return runs.flatMap((source) => rowsOfRun(selector, source, now));
+  return approvalInbox(runs.map((source) => ({ run: source.run, rows: pendingApprovals(source) })));
+};
+const rowsOf = (selector, source, now) => source._tag === "run" ? rowsOfRun(selector, source.run, now) : rowsOfWorkspace(selector, source.runs, now);
+const boundedRows = (selector, candidate) => import_effect.Effect.suspend(() => {
+  try {
+    const schema = import_effect.Schema.Array(GatewaySchema.rowSchemaFor(selector));
+    const rows = import_effect.Schema.decodeUnknownSync(schema)(candidate);
+    const encoded = import_effect.Schema.encodeUnknownSync(schema)(rows);
+    const bytes = textEncoder.encode(JSON.stringify(encoded)).byteLength;
+    return bytes <= maxProjectionBytes ? import_effect.Effect.succeed(rows) : import_effect.Effect.fail(resourceLimit(`Projection rows exceed ${maxProjectionBytes} encoded bytes`));
+  } catch (cause) {
+    return import_effect.Effect.fail(unavailable("Projection produced invalid rows", cause));
+  }
+});
+const frameOf = (candidate) => import_effect.Effect.suspend(() => {
+  try {
+    return import_effect.Effect.succeed(decodeFrame(candidate));
+  } catch (cause) {
+    return import_effect.Effect.fail(unavailable("Projection produced an invalid frame", cause));
+  }
+});
+const snapshotOf = (candidate) => import_effect.Effect.suspend(() => {
+  try {
+    return import_effect.Effect.succeed(decodeSnapshot(candidate));
+  } catch (cause) {
+    return import_effect.Effect.fail(unavailable("Projection produced an invalid snapshot", cause));
+  }
+});
+const cursorPositionOf = (source) => source._tag === "run" ? source.run.lastPosition : { value: 0, offset: 0 };
+const makeService = (control, heartbeatMillis, now) => {
+  const journalBuffers = /* @__PURE__ */ new Map();
+  const eventsOf = (run, compactHealth) => import_effect.Effect.suspend(() => {
+    const runId = run.runId;
+    const key = `${runId}:${compactHealth}`;
+    const cached = journalBuffers.get(key);
+    const seed = cached === void 0 ? emptyEventBuffer(compactHealth) : { ...cached, events: [...cached.events] };
+    const message = `Reading the events of ${runId} failed`;
+    let position;
+    return import_effect.Stream.runFoldEffect(
+      control.watch({
+        runId,
+        follow: false,
+        ...cached === void 0 || !cached.seen || cached.lastPosition.value === 0 ? {} : { afterSequence: cached.lastPosition.value - 1 }
+      }).pipe(
+        import_effect.Stream.tapError((cause) => logReadFailure("read-events", cause)),
+        import_effect.Stream.mapError((cause) => unavailable(message, cause)),
+        import_effect.Stream.take(maxEventsScanned)
+      ),
+      () => seed,
+      (buffer, candidate) => import_effect.Effect.flatMap(decodedEvent(candidate, message), (event) => {
+        if (position !== void 0 && event.sequence < position.value) {
+          return import_effect.Effect.fail(unavailable(message, void 0));
+        }
+        position = { value: event.sequence, offset: position?.value === event.sequence ? position.offset + 1 : 0 };
+        if (cached !== void 0 && cached.seen && comparePosition(position, cached.lastPosition) <= 0) {
+          return import_effect.Effect.succeed(buffer);
+        }
+        return appendEvent(buffer, event, message, run);
+      })
+    ).pipe(import_effect.Effect.tap(
+      (buffer) => import_effect.Effect.sync(() => {
+        const current = journalBuffers.get(key);
+        if (current === void 0 || comparePosition(buffer.lastPosition, current.lastPosition) >= 0) {
+          journalBuffers.delete(key);
+          journalBuffers.set(key, { ...buffer, events: [...buffer.events] });
+          if (journalBuffers.size > 32) journalBuffers.delete(journalBuffers.keys().next().value);
+        }
+      })
+    ));
+  });
+  const runEventsPage = (run, after) => {
+    const runId = run.runId;
+    const message = `Reading the events of ${runId} failed`;
+    const empty = { events: [], bytes: 2, seen: void 0, last: void 0, full: false };
+    let stopped = false;
+    return import_effect.Stream.runFoldEffect(
+      control.watch({
+        runId,
+        ...after === void 0 || after.value === 0 ? {} : { afterSequence: after.value - 1 },
+        follow: false
+      }).pipe(
+        import_effect.Stream.tapError((cause) => logReadFailure("read-events", cause)),
+        import_effect.Stream.mapError((cause) => unavailable(message, cause)),
+        import_effect.Stream.take(maxEventsScanned),
+        import_effect.Stream.takeWhile(() => !stopped)
+      ),
+      () => empty,
+      (page, candidate) => page.full ? import_effect.Effect.succeed(page) : import_effect.Effect.flatMap(
+        decodedEvent(candidate, `${message}: the control plane returned an invalid event`),
+        (decoded) => {
+          if (page.seen !== void 0 && decoded.sequence < page.seen.value) {
+            return import_effect.Effect.fail(unavailable(message, void 0));
+          }
+          const position = {
+            value: decoded.sequence,
+            offset: page.seen?.value === decoded.sequence ? page.seen.offset + 1 : 0
+          };
+          const seen = position;
+          if (after !== void 0 && comparePosition(position, after) <= 0) {
+            return import_effect.Effect.succeed({ ...page, seen });
+          }
+          const event = decoded.kind === "control.engine.event" ? decoded : retainedEvent(decoded);
+          if (encodedSize(event) + 2 > maxProjectionBytes) {
+            return import_effect.Effect.fail(resourceLimit(`One journal event exceeds ${maxProjectionBytes} encoded bytes`));
+          }
+          const bytes = page.bytes + encodedSize(event) + (page.events.length === 0 ? 0 : 1);
+          if (page.events.length > 0 && bytes > maxProjectionBytes) {
+            stopped = true;
+            return import_effect.Effect.succeed({ ...page, seen, full: true });
+          }
+          page.events.push(event);
+          stopped = page.events.length >= maxEventsPerPage;
+          return import_effect.Effect.succeed({ events: page.events, bytes, seen, last: position, full: stopped });
+        }
+      )
+    ).pipe(
+      import_effect.Effect.map((page) => ({
+        events: page.events,
+        lastPosition: page.last ?? after ?? { value: 0, offset: 0 }
+      }))
+    );
+  };
+  const runsMatching = (filters, newest) => {
+    const singleRun = filters.runId !== void 0;
+    const ceiling = newest ?? 1;
+    const page = (accumulated, seen, cursor) => {
+      const remaining = ceiling - accumulated.length;
+      return control.list({
+        _tag: "runs",
+        filters,
+        limit: remaining,
+        ...newest === void 0 ? {} : { order: "newest" },
+        ...cursor === void 0 ? {} : { cursor }
+      }).pipe(
+        import_effect.Effect.tapError((cause) => logReadFailure("list-runs", cause)),
+        import_effect.Effect.mapError((cause) => unavailable("Listing runs failed", cause)),
+        import_effect.Effect.flatMap((response) => {
+          if (response._tag !== "runs") return import_effect.Effect.succeed(accumulated);
+          const ids = new Set(accumulated.map((run) => run.runId));
+          const added = response.items.filter((run) => {
+            if (ids.has(run.runId)) return false;
+            ids.add(run.runId);
+            return true;
+          }).slice(0, remaining);
+          const runs = [...accumulated, ...added];
+          if (singleRun || added.length === 0 || response.nextCursor === void 0 || runs.length >= ceiling || seen.has(response.nextCursor)) return import_effect.Effect.succeed(runs);
+          seen.add(response.nextCursor);
+          return page(runs, seen, response.nextCursor);
+        })
+      );
+    };
+    return import_effect.Effect.suspend(() => page([], /* @__PURE__ */ new Set()));
+  };
+  const runOf = (runId) => runsMatching({ runId }).pipe(
+    import_effect.Effect.flatMap((runs) => {
+      const run = runs.find((candidate) => candidate.runId === runId);
+      return run === void 0 ? import_effect.Effect.fail(new import_GatewayError.GatewayError({ code: "run_not_found", message: `No run ${runId}` })) : import_effect.Effect.succeed(run);
+    })
+  );
+  const consistentRunSource = (before, attempts = 8, compactHealth = true) => import_effect.Effect.gen(function* () {
+    const buffer = yield* eventsOf(before, compactHealth);
+    const run = yield* runOf(before.runId);
+    if (JSON.stringify(before) === JSON.stringify(run)) return { run, ...buffer };
+    if (attempts === 1) return yield* import_effect.Effect.fail(unavailable("Run changed throughout the snapshot read", void 0));
+    return yield* consistentRunSource(run, attempts - 1, compactHealth);
+  });
+  const runSourceOf = (runId, compactHealth = true) => import_effect.Effect.flatMap(runOf(runId), (run) => consistentRunSource(run, 8, compactHealth));
+  const durationRunsOf = (flowId) => runsMatching({ flowId, terminal: true }, maxDurationRuns);
+  const workspaceSourceOf = (selector) => import_effect.Effect.flatMap(
+    // The inbox asks the control plane which runs are parked rather than
+    // reading every run's journal to find out, and a duration fold asks it
+    // for one flow's runs rather than for the workspace's.
+    selector._tag === "flow-durations" ? durationRunsOf(selector.flowId) : runsMatching(
+      selector._tag === "approvals" ? { status: "waiting-approval" } : selector._tag === "workspace-runs" && selector.flowId !== void 0 ? { flowId: selector.flowId } : {},
+      maxWorkspaceRuns
+    ),
+    (runs) => import_effect.Effect.map(
+      import_effect.Effect.forEach(runs, (run) => consistentRunSource(run), { concurrency: 8 }),
+      (sources) => sources.filter((source) => eligibleForWorkspace(selector, source))
+    )
+  );
+  const sourceOf = (selector) => {
+    const runId = scopeOf(selector);
+    return runId === void 0 ? import_effect.Effect.map(workspaceSourceOf(selector), (runs) => ({ _tag: "workspace", runs })) : import_effect.Effect.map(runSourceOf(runId, selector._tag !== "run-events"), (run) => ({ _tag: "run", run }));
+  };
+  const snapshot = (selector, after) => import_effect.Effect.gen(function* () {
+    if (after !== void 0) {
+      if (selector._tag !== "run-events") {
+        return yield* malformed("Only run-events snapshots accept an after cursor");
+      }
+      const scope = resumeScope(selector, after);
+      if (typeof scope !== "string") return yield* scope;
+    }
+    if (selector._tag === "run-events") {
+      const run = yield* runOf(selector.runId);
+      const page = yield* runEventsPage(run, after);
+      const rows2 = yield* boundedRows(selector, page.events);
+      return yield* snapshotOf({ selector, cursor: cursorOf(selector, page.lastPosition), rows: rows2 });
+    }
+    const source = yield* sourceOf(selector);
+    const rows = yield* boundedRows(selector, rowsOf(selector, source, now()));
+    return yield* snapshotOf({ selector, cursor: cursorOf(selector, cursorPositionOf(source)), rows });
+  });
+  const snapshotFrames = (selector, source, rows) => {
+    const cursor = cursorOf(selector, cursorPositionOf(source));
+    return import_effect.Effect.forEach([
+      { _tag: "snapshot-start", selector, cursor },
+      ...rows.map((row) => ({ _tag: "row", selector, cursor, row })),
+      { _tag: "snapshot-end", selector, cursor }
+    ], frameOf);
+  };
+  const deltaRows = (selector, run, event, events, turnsBefore, duplicateCall, carry) => {
+    if (selector._tag === "run-events") return import_effect.Effect.succeed([event]);
+    if (selector._tag === "transcript") {
+      return import_effect.Effect.succeed(duplicateCall ? [] : transcriptAppend(event, turnsBefore));
+    }
+    return import_effect.Effect.succeed(rowsOfRun(selector, { run, events, carry }, now()));
+  };
+  const runDeltaFrames = (selector, source, from) => {
+    const runId = source.run.runId;
+    const message = `Following ${runId} failed`;
+    const replayHealth = selector._tag === "run-summary" && comparePosition(from, source.lastPosition) < 0;
+    const seedEvents = positionedEvents(source.events).filter(({ position }) => comparePosition(position, from) <= 0).map(({ event }) => event);
+    const seed = replayHealth ? import_effect.Effect.succeed(emptyEventBuffer(true)) : comparePosition(from, source.lastPosition) === 0 ? import_effect.Effect.succeed({
+      compactHealth: source.compactHealth,
+      seen: source.seen,
+      events: source.events,
+      encodedBytes: source.encodedBytes,
+      lastPosition: source.lastPosition,
+      carry: source.carry,
+      dropped: source.dropped
+    }) : bufferOf(seedEvents, `${message}: the cursor seed is invalid`, source.compactHealth, source.run);
+    return import_effect.Stream.unwrap(import_effect.Effect.map(seed, (initial) => control.watch({
+      runId,
+      // Sequence zero also needs replay for empty seeds and derived offsets.
+      ...from.value === 0 || replayHealth ? {} : { afterSequence: from.value - 1 },
+      follow: true
+    }).pipe(
+      import_effect.Stream.tapError((cause) => logReadFailure("follow-run", cause)),
+      import_effect.Stream.mapError((cause) => unavailable(message, cause)),
+      import_effect.Stream.mapAccumEffect(
+        () => ({
+          buffer: initial,
+          observed: void 0,
+          turns: selector._tag === "transcript" ? turnsOpened(initial.events) : 0,
+          reportedCalls: (() => {
+            const seen = /* @__PURE__ */ new Map();
+            if (selector._tag === "transcript") {
+              for (const event of initial.events) {
+                const key = (0, import_callEvents.callEventKey)(event);
+                if (key !== void 0) {
+                  seen.set(
+                    key,
+                    seen.get(key) === true || ((0, import_callEvents.nativeCallEvent)(event) ?? (0, import_callEvents.nativeStepEvent)(event)) !== void 0
+                  );
+                }
+              }
+            }
+            return seen;
+          })()
+        }),
+        (state, candidate) => import_effect.Effect.flatMap(
+          decodedEvent(candidate, `${message}: the control plane returned an invalid event`),
+          (event) => {
+            if (state.observed !== void 0 && event.sequence < state.observed.value) {
+              return import_effect.Effect.fail(unavailable(`${message}: event sequences moved backward`, void 0));
+            }
+            const position = {
+              value: event.sequence,
+              offset: state.observed?.value === event.sequence ? state.observed.offset + 1 : 0
+            };
+            const nextState = { ...state, observed: position };
+            if ((replayHealth || seedEvents.length > 0 || from.value > 0 || from.offset > 0) && comparePosition(position, from) <= 0) {
+              return replayHealth ? import_effect.Effect.map(
+                appendEvent(state.buffer, event, `${message}: cursor history is invalid`, source.run),
+                (buffer) => [{ ...nextState, buffer }, []]
+              ) : import_effect.Effect.succeed([nextState, []]);
+            }
+            const turnsBefore = state.turns;
+            const callKey = selector._tag === "transcript" ? (0, import_callEvents.callEventKey)(event) : void 0;
+            const duplicateCall = callKey !== void 0 && state.reportedCalls.has(callKey);
+            const authoritative = ((0, import_callEvents.nativeCallEvent)(event) ?? (0, import_callEvents.nativeStepEvent)(event)) !== void 0;
+            const replaceTranscript = duplicateCall && authoritative && state.reportedCalls.get(callKey) === false;
+            if (callKey !== void 0) {
+              state.reportedCalls.set(callKey, authoritative || state.reportedCalls.get(callKey) === true);
+            }
+            const turns = selector._tag === "transcript" ? transcriptAppend(event, turnsBefore).at(-1)?.turn ?? turnsBefore : 0;
+            return import_effect.Effect.flatMap(
+              selector._tag === "run-summary" || selector._tag === "run-tree" || selector._tag === "approvals" ? runOf(runId) : import_effect.Effect.succeed(source.run),
+              (run) => import_effect.Effect.map(
+                appendEvent(state.buffer, event, `${message}: event history is invalid`, run),
+                (buffer) => [
+                  {
+                    buffer,
+                    observed: position,
+                    turns,
+                    reportedCalls: state.reportedCalls
+                  },
+                  [
+                    {
+                      run,
+                      event,
+                      events: buffer.events,
+                      carry: buffer.carry,
+                      position,
+                      turnsBefore,
+                      duplicateCall,
+                      replaceTranscript
+                    }
+                  ]
+                ]
+              )
+            );
+          }
+        )
+      ),
+      import_effect.Stream.mapEffect(
+        ({ carry, duplicateCall, event, events, position, replaceTranscript, run, turnsBefore }) => replaceTranscript ? import_effect.Effect.flatMap(boundedRows(selector, GatewayProjection.transcript(events)), (rows) => import_effect.Effect.forEach([
+          { _tag: "snapshot-start", selector, cursor: cursorOf(selector, position) },
+          ...rows.map((row) => ({ _tag: "row", selector, cursor: cursorOf(selector, position), row })),
+          { _tag: "snapshot-end", selector, cursor: cursorOf(selector, position) }
+        ], frameOf)) : import_effect.Effect.flatMap(deltaRows(selector, run, event, events, turnsBefore, duplicateCall, carry), (rows) => import_effect.Effect.flatMap(boundedRows(selector, rows), (delta) => import_effect.Effect.map(
+          frameOf({
+            _tag: "delta",
+            selector,
+            cursor: cursorOf(selector, position),
+            delta
+          }),
+          (frame) => [frame]
+        )))
+      ),
+      import_effect.Stream.flattenIterable
+    )));
+  };
+  const workspaceDeltaFrames = (selector, runs) => import_effect.Stream.unwrap(import_effect.Effect.sync(() => {
+    const rowsOfSource = (source) => selector._tag === "approvals" ? pendingApprovals(source) : rowsOfRun(selector, source, now());
+    const sources = new Map(runs.map((source) => [
+      source.run.runId,
+      { source, observed: void 0, rows: rowsOfSource(source) }
+    ]));
+    const judged = /* @__PURE__ */ new Map();
+    const makeRoom = () => {
+      if (sources.size + judged.size >= maxWorkspaceRuns) {
+        judged.delete(judged.keys().next().value);
+      }
+    };
+    const remember = (runId, lastPosition, observed) => {
+      judged.delete(runId);
+      makeRoom();
+      judged.set(runId, { lastPosition, observed });
+    };
+    const oldestFollowed = () => {
+      let oldest;
+      for (const followed of sources.values()) {
+        if (oldest === void 0 || createdAfter(oldest.source.run, followed.source.run)) oldest = followed;
+      }
+      return oldest;
+    };
+    const noFrames = [];
+    const delta = () => import_effect.Effect.flatMap(
+      boundedRows(
+        selector,
+        selector._tag === "approvals" ? approvalInbox([...sources.values()].map(({ rows, source }) => ({ run: source.run, rows }))) : [...sources.values()].flatMap(({ rows }) => rows)
+      ),
+      (rows) => import_effect.Effect.map(
+        frameOf({
+          _tag: "delta",
+          selector,
+          cursor: cursorOf(selector, { value: 0, offset: 0 }),
+          delta: rows
+        }),
+        (frame) => [frame]
+      )
+    );
+    const message = "Following the workspace failed";
+    const admit = (event, refreshed) => import_effect.Effect.gen(function* () {
+      const runId = event.runId;
+      if (runId === void 0) return "unchanged";
+      const current = sources.get(runId);
+      const verdict = judged.get(runId);
+      const previous = current?.observed ?? verdict?.observed;
+      if (previous !== void 0 && event.sequence < previous.value) {
+        return yield* import_effect.Effect.fail(unavailable(`${message}: event sequences moved backward`, void 0));
+      }
+      const position = {
+        value: event.sequence,
+        offset: previous?.value === event.sequence ? previous.offset + 1 : 0
+      };
+      if (current !== void 0) {
+        current.observed = position;
+        if (current.source.events.length > 0 && comparePosition(position, current.source.lastPosition) <= 0) return "unchanged";
+        if (!refreshed.has(runId)) {
+          current.source = { ...current.source, run: yield* runOf(runId) };
+          refreshed.add(runId);
+        }
+        const buffer = yield* appendEvent(
+          current.source,
+          event,
+          `${message}: event history is invalid`,
+          current.source.run
+        );
+        current.source = { run: current.source.run, ...buffer };
+        return "stale";
+      }
+      if (verdict !== void 0) {
+        verdict.observed = position;
+        if (verdict.lastPosition === void 0 || comparePosition(position, verdict.lastPosition) <= 0) {
+          return "unchanged";
+        }
+      }
+      const displaced = sources.size >= maxWorkspaceRuns ? oldestFollowed() : void 0;
+      if (displaced !== void 0) {
+        const newer = yield* runOf(runId).pipe(
+          import_effect.Effect.map((run) => createdAfter(run, displaced.source.run)),
+          import_effect.Effect.catchIf((failure) => failure.code === "run_not_found", () => import_effect.Effect.succeed(false))
+        );
+        if (!newer) return "unchanged";
+      }
+      return yield* runSourceOf(runId).pipe(
+        import_effect.Effect.flatMap((source) => {
+          const admitted = source.events.length > 0 && comparePosition(position, source.lastPosition) <= 0 ? import_effect.Effect.succeed(source) : import_effect.Effect.map(
+            appendEvent(source, event, `${message}: event history is invalid`, source.run),
+            (buffer) => ({ run: source.run, ...buffer })
+          );
+          return import_effect.Effect.map(admitted, (complete) => {
+            if (!eligibleForWorkspace(selector, complete)) {
+              remember(runId, complete.lastPosition, position);
+              return "unchanged";
+            }
+            judged.delete(runId);
+            if (displaced !== void 0 && sources.size >= maxWorkspaceRuns) {
+              sources.delete(displaced.source.run.runId);
+            }
+            makeRoom();
+            sources.set(runId, { source: complete, observed: position, rows: rowsOfSource(complete) });
+            return "fresh";
+          });
+        }),
+        import_effect.Effect.catchIf(
+          (failure) => failure.code === "run_not_found",
+          () => {
+            remember(runId, void 0, position);
+            return import_effect.Effect.succeed("unchanged");
+          }
+        )
+      );
+    });
+    const refresh = (runId) => import_effect.Effect.gen(function* () {
+      const current = sources.get(runId);
+      if (current === void 0 || current.observed === void 0) return;
+      const source = current.source;
+      if (eligibleForWorkspace(selector, source)) {
+        current.rows = rowsOfSource(source);
+      } else {
+        sources.delete(runId);
+        remember(runId, source.lastPosition, current.observed);
+      }
+    });
+    return control.watch({ follow: true }).pipe(
+      import_effect.Stream.tapError((cause) => logReadFailure("follow-workspace", cause)),
+      import_effect.Stream.mapError((cause) => unavailable(message, cause)),
+      import_effect.Stream.groupedWithin(workspaceDeltaBatchSize, workspaceDeltaCoalesceMillis),
+      import_effect.Stream.mapEffect(
+        (batch) => import_effect.Effect.gen(function* () {
+          const stale = /* @__PURE__ */ new Set();
+          const refreshed = /* @__PURE__ */ new Set();
+          let changed = false;
+          for (const candidate of batch) {
+            const event = yield* decodedEvent(candidate, `${message}: the control plane returned an invalid event`);
+            const admission = yield* admit(event, refreshed);
+            if (admission === "unchanged") continue;
+            changed = true;
+            if (admission === "stale" && event.runId !== void 0) stale.add(event.runId);
+          }
+          yield* import_effect.Effect.forEach(stale, refresh, { discard: true });
+          return changed ? yield* delta() : noFrames;
+        })
+      ),
+      import_effect.Stream.flattenIterable
+    );
+  }));
+  const deltaFrames = (selector, source, from) => {
+    if (selector._tag === "flow-durations") return import_effect.Stream.empty;
+    return source._tag === "workspace" ? workspaceDeltaFrames(selector, source.runs) : runDeltaFrames(selector, source.run, from);
+  };
+  const heartbeats = import_effect.Stream.tick(heartbeatMillis).pipe(
+    import_effect.Stream.drop(1),
+    import_effect.Stream.mapEffect(
+      () => import_effect.Effect.map(import_effect.Effect.clockWith((clock) => clock.currentTimeMillis), (atMs) => ({
+        _tag: "heartbeat",
+        atMs
+      }))
+    )
+  );
+  const resumeScope = (selector, after) => {
+    const candidate = after;
+    if (!Number.isSafeInteger(candidate.value) || candidate.value < 0) {
+      return malformed(
+        `Cursor value ${String(candidate.value)} must be a non-negative safe integer`
+      );
+    }
+    if (!Number.isSafeInteger(candidate.offset) || candidate.offset < 0) {
+      return malformed(
+        `Cursor offset ${String(candidate.offset)} must be a non-negative safe integer`
+      );
+    }
+    if (!import_effect.Schema.is(GatewaySchema.ProjectionCursor)(after)) {
+      return malformed("The projection cursor is not a valid gateway cursor");
+    }
+    const runId = scopeOf(selector);
+    if (after.projection !== selector._tag) {
+      return malformed(
+        `A cursor for the ${after.projection} projection cannot resume a ${selector._tag} subscription`
+      );
+    }
+    if (!sameSelector(after.selector, selector)) {
+      return malformed("A cursor can resume only the exact selector that issued it");
+    }
+    if (runId === void 0) {
+      return malformed(
+        `A ${selector._tag} subscription has no resumable cursor, because control journal sequences belong to per-run partitions`
+      );
+    }
+    if (after.runId !== runId) {
+      return malformed(`A cursor for run ${after.runId ?? "none"} cannot resume a subscription to run ${runId}`);
+    }
+    return runId;
+  };
+  const fromSnapshot = (selector) => import_effect.Effect.flatMap(
+    sourceOf(selector),
+    (source) => import_effect.Effect.flatMap(boundedRows(selector, rowsOf(selector, source, now())), (rows) => import_effect.Effect.map(snapshotFrames(selector, source, rows), (frames) => import_effect.Stream.concat(
+      import_effect.Stream.fromIterable(frames),
+      deltaFrames(selector, source, cursorPositionOf(source))
+    )))
+  );
+  const fromCursor = (selector, after) => {
+    const scope = resumeScope(selector, after);
+    return typeof scope === "string" ? import_effect.Effect.flatMap(runSourceOf(scope, selector._tag !== "run-events"), (source) => {
+      const position = { value: after.value, offset: after.offset };
+      const last = source.lastPosition;
+      if (comparePosition(position, last) > 0) {
+        return import_effect.Effect.fail(malformed(
+          `Cursor ${after.value}:${after.offset} cannot resume run ${scope} past its last position ${last.value}:${last.offset}`
+        ));
+      }
+      const retained = position.value === 0 && position.offset === 0 || positionedEvents(source.events).some((candidate) => comparePosition(candidate.position, position) === 0);
+      const issued = retained ? import_effect.Effect.succeed(true) : source.compactHealth ? control.watch({
+        runId: scope,
+        follow: false,
+        ...position.value === 0 ? {} : { afterSequence: position.value - 1 }
+      }).pipe(
+        import_effect.Stream.takeWhile((event) => event.sequence <= position.value),
+        import_effect.Stream.take(maxEventsPerRun + 1),
+        import_effect.Stream.runCollect,
+        import_effect.Effect.map(
+          (events) => events.length <= maxEventsPerRun && events[position.offset]?.sequence === position.value
+        ),
+        import_effect.Effect.mapError((cause) => unavailable("Checking the projection cursor failed", cause))
+      ) : import_effect.Effect.succeed(false);
+      return import_effect.Effect.flatMap(issued, (valid) => valid ? import_effect.Effect.succeed(runDeltaFrames(selector, source, position)) : import_effect.Effect.fail(malformed(`Cursor ${after.value}:${after.offset} was not issued by run ${scope}`)));
+    }) : import_effect.Effect.fail(scope);
+  };
+  const subscribe = (selector, after) => import_effect.Stream.merge(
+    import_effect.Stream.unwrap(after === void 0 ? fromSnapshot(selector) : fromCursor(selector, after)),
+    heartbeats,
+    { haltStrategy: "left" }
+  );
+  return { snapshot, subscribe };
+};
+const make = (control, options = {}) => import_effect.Effect.suspend(() => {
+  const refusal = (0, import_GatewayError.settingRefusal)("The gateway keepalive cadence", options.heartbeatMillis);
+  return refusal === void 0 ? import_effect.Effect.clockWith(
+    (clock) => import_effect.Effect.succeed(
+      makeService(
+        control,
+        options.heartbeatMillis ?? heartbeatIntervalMillis,
+        () => clock.currentTimeMillisUnsafe()
+      )
+    )
+  ) : import_effect.Effect.fail(refusal);
+});
+const layer = import_effect.Layer.effect(Projections)(
+  import_effect.Effect.flatMap(import_Control.Control, (control) => make(control))
+);
+const layerWith = (options) => import_effect.Layer.effect(Projections)(import_effect.Effect.flatMap(import_Control.Control, (control) => make(control, options)));
+//# sourceMappingURL=Projections.js.map