deepline 0.3.236 → 0.3.238

package/dist/index.mjs

@@ -1171,7 +1171,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.236",
+  version: "0.3.238",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -1783,19 +1783,19 @@ function withErrorCause(error, cause) {
   }
   return error;
 }
-function mapNetworkError(baseUrl, error, targetLabel2) {
+function mapNetworkError(baseUrl, error, targetLabel) {
   const tagged = error;
   const timeoutMs = tagged?.[REQUEST_TIMEOUT_MARKER];
   if (typeof timeoutMs === "number") {
     return {
-      message: `Request to ${targetLabel2} timed out after ${timeoutMs}ms while waiting for a response.`,
+      message: `Request to ${targetLabel} timed out after ${timeoutMs}ms while waiting for a response.`,
       code: "NETWORK_TIMEOUT",
-      details: { timeoutMs, target: targetLabel2 }
+      details: { timeoutMs, target: targetLabel }
     };
   }
   if (tagged?.[REQUEST_ABORT_MARKER]) {
     return {
-      message: `Request to ${targetLabel2} was aborted before it completed.`,
+      message: `Request to ${targetLabel} was aborted before it completed.`,
       code: "NETWORK_ABORTED"
     };
   }
@@ -2533,30 +2533,6 @@ var DEFAULT_PRODUCT_NOTIFICATION_DELIVERY_TIMING = {
   windowMs: 36e5
 };
 
-// src/stream-reconnect.ts
-var STREAM_RECONNECT_BASE_DELAY_MS = 500;
-var STREAM_RECONNECT_MAX_DELAY_MS = 15e3;
-var STREAM_HEALTHY_CONNECTION_MS = 3e4;
-function streamReconnectDelayMs(attempt) {
-  const cappedExponentialMs = Math.min(
-    STREAM_RECONNECT_MAX_DELAY_MS,
-    STREAM_RECONNECT_BASE_DELAY_MS * 2 ** Math.max(0, attempt)
-  );
-  return Math.max(1, Math.floor(Math.random() * (cappedExponentialMs + 1)));
-}
-function isTransientPlayStreamError(error) {
-  if (error instanceof DeeplineError && error.code === "PLAY_STREAM_NETWORK_ABORTED") {
-    return true;
-  }
-  if (error instanceof DeeplineError && typeof error.statusCode === "number") {
-    return error.statusCode >= 500 && error.statusCode < 600;
-  }
-  const text = error instanceof Error ? error.message : String(error);
-  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
-    text
-  );
-}
-
 // ../play-runtime/live-events.ts
 function resolveTimingWindow(input) {
   const startedAt = typeof input.startedAt === "number" && Number.isFinite(input.startedAt) ? input.startedAt : null;
@@ -2572,19 +2548,6 @@ function resolveTimingWindow(input) {
 // ../play-runtime/run-failure.ts
 var PUBLIC_FAILURE_TEXT_BYTE_LIMIT = 64 * 1024;
 
-// ../play-runtime/run-terminal-source.ts
-var PLAY_RUN_LEDGER_EVENT_SOURCES = [
-  "worker",
-  "convex",
-  "coordinator",
-  "system"
-];
-function normalizePlayRunLedgerTerminalSource(value) {
-  return PLAY_RUN_LEDGER_EVENT_SOURCES.includes(
-    value
-  ) ? value : null;
-}
-
 // ../play-runtime/run-log-buffer.ts
 var RUNNER_LOG_MAX_BYTES = 5 * 1024 * 1024;
 var TERMINAL_RESERVE_BYTES = 64 * 1024;
@@ -2755,12 +2718,12 @@ function createSecretRedactionContext(initialValues = []) {
     }
     return output;
   }
-  function redactString2(value) {
+  function redactString(value) {
     const output = redactRegisteredSecrets(value);
     return redactSecretLikeString(output);
   }
   function redact(value) {
-    if (typeof value === "string") return redactString2(value);
+    if (typeof value === "string") return redactString(value);
     if (Array.isArray(value)) {
       let changed = false;
       const next = new Array(value.length);
@@ -2793,7 +2756,7 @@ function createSecretRedactionContext(initialValues = []) {
     return value;
   }
   function redactKnownSecrets(value) {
-    if (typeof value === "string") return redactString2(value);
+    if (typeof value === "string") return redactString(value);
     if (Array.isArray(value)) {
       return value.map((entry) => redactKnownSecrets(entry));
     }
@@ -2812,7 +2775,7 @@ function createSecretRedactionContext(initialValues = []) {
     containsRegisteredSecret,
     matchesRegisteredSecret,
     redactRegisteredSecrets,
-    redactString: redactString2,
+    redactString,
     redactKnownSecrets,
     redact
   };
@@ -2836,981 +2799,8 @@ var JSON_SIZE_LIMIT_REACHED = Symbol("JSON_SIZE_LIMIT_REACHED");
 var ledgerIngressRedactor = createSecretRedactionContext();
 
 // ../play-runtime/docflow-node-io.ts
-var DOCFLOW_NODE_IO_LIMITS = {
-  maxPaths: 16,
-  maxDepth: 3,
-  maxObjectFields: 12,
-  maxArrayItems: 3,
-  maxStringBytes: 256,
-  maxPhaseBytes: 2e3,
-  maxErrorBytes: 512
-};
 var utf8Encoder = new TextEncoder();
 var PLAY_DATASET_BRAND = Symbol.for("deepline.play.dataset");
-var MAX_CONVEX_PREVIEW_KEY_LENGTH = 1024;
-function ledgerSafeDocflowPreviewKey(key) {
-  const source = key.startsWith("$") ? key.replace(/^\$+/, "") || "output" : key || "output";
-  let encoded = "";
-  for (const character of source) {
-    const code = character.charCodeAt(0);
-    if (code >= 32 && code < 127) {
-      encoded += character;
-      continue;
-    }
-    for (const byte of utf8Encoder.encode(character)) {
-      encoded += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
-    }
-  }
-  if (encoded.length <= MAX_CONVEX_PREVIEW_KEY_LENGTH) return encoded;
-  let hashA = 2166136261;
-  let hashB = 2654435769;
-  for (let index = 0; index < encoded.length; index += 1) {
-    const code = encoded.charCodeAt(index);
-    hashA = Math.imul(hashA ^ code, 16777619);
-    hashB = Math.imul(hashB ^ code, 16777619);
-  }
-  const suffix = `~${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
-  return `${encoded.slice(0, MAX_CONVEX_PREVIEW_KEY_LENGTH - suffix.length)}${suffix}`;
-}
-function utf8Bytes(value) {
-  return utf8Encoder.encode(value).byteLength;
-}
-function truncateUtf8(value, maxBytes) {
-  if (utf8Bytes(value) <= maxBytes) return value;
-  let output = "";
-  for (const character of value) {
-    if (utf8Bytes(`${output}${character}\u2026`) > maxBytes) break;
-    output += character;
-  }
-  return `${output}\u2026`;
-}
-function redactString(redactor, value, key) {
-  if (!key) return redactor.redactString(value);
-  const wrapped = redactor.redact({ [key]: value });
-  return typeof wrapped[key] === "string" ? wrapped[key] : redactor.redactString(value);
-}
-function safeString(value, redactor, key) {
-  if (typeof value !== "string") return void 0;
-  return truncateUtf8(
-    redactString(redactor, value, key),
-    DOCFLOW_NODE_IO_LIMITS.maxStringBytes
-  );
-}
-function previewValue(value, input) {
-  if (value === null) return { kind: "null" };
-  if (value === void 0) return { kind: "unavailable", reason: "undefined" };
-  if (typeof value === "string") {
-    return {
-      kind: "scalar",
-      value: safeString(value, input.redactor, input.key) ?? ""
-    };
-  }
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? { kind: "scalar", value } : { kind: "unavailable", reason: "unsupported" };
-  }
-  if (typeof value === "boolean") return { kind: "scalar", value };
-  if (typeof value === "bigint") {
-    return { kind: "unavailable", reason: "bigint" };
-  }
-  if (typeof value === "function") {
-    return { kind: "unavailable", reason: "function" };
-  }
-  if (typeof value === "symbol") {
-    return { kind: "unavailable", reason: "symbol" };
-  }
-  if (typeof value !== "object") {
-    return { kind: "unavailable", reason: "unsupported" };
-  }
-  try {
-    const brand = readDataProperty(value, PLAY_DATASET_BRAND);
-    const datasetKind = readDataProperty(value, "datasetKind");
-    const datasetId = readDataProperty(value, "datasetId");
-    const tableNamespace = readDataProperty(value, "tableNamespace");
-    if (brand.ok && brand.value === true && datasetKind.ok && (datasetKind.value === "csv" || datasetKind.value === "map") && datasetId.ok && typeof datasetId.value === "string") {
-      return {
-        kind: "dataset",
-        datasetId: safeString(datasetId.value, input.redactor, "datasetId") ?? "dataset",
-        datasetKind: datasetKind.value,
-        tableNamespace: tableNamespace.ok && tableNamespace.value === null ? null : tableNamespace.ok ? safeString(
-          tableNamespace.value,
-          input.redactor,
-          "tableNamespace"
-        ) : void 0
-      };
-    }
-    const kind = readDataProperty(value, "kind");
-    const count = readDataProperty(value, "count");
-    const preview = readDataProperty(value, "preview");
-    if (kind.ok && kind.value === "dataset" && datasetKind.ok && (datasetKind.value === "csv" || datasetKind.value === "map") && datasetId.ok && typeof datasetId.value === "string" && count.ok && typeof count.value === "number" && preview.ok && Array.isArray(preview.value)) {
-      return {
-        kind: "dataset",
-        datasetId: safeString(datasetId.value, input.redactor, "datasetId") ?? "dataset",
-        datasetKind: datasetKind.value,
-        tableNamespace: tableNamespace.ok && tableNamespace.value === null ? null : tableNamespace.ok ? safeString(
-          tableNamespace.value,
-          input.redactor,
-          "tableNamespace"
-        ) : void 0,
-        rowCount: Math.max(0, Math.floor(count.value))
-      };
-    }
-  } catch {
-    return { kind: "unavailable", reason: "access_error" };
-  }
-  if (input.ancestors.has(value)) {
-    return { kind: "unavailable", reason: "cycle" };
-  }
-  if (input.depth >= DOCFLOW_NODE_IO_LIMITS.maxDepth) {
-    return { kind: "unavailable", reason: "depth" };
-  }
-  input.ancestors.add(value);
-  try {
-    if (Array.isArray(value)) {
-      const items = [];
-      for (let index = 0; index < Math.min(value.length, DOCFLOW_NODE_IO_LIMITS.maxArrayItems); index += 1) {
-        const descriptor = Object.getOwnPropertyDescriptor(
-          value,
-          String(index)
-        );
-        items.push(
-          descriptor && "value" in descriptor ? previewValue(descriptor.value, {
-            ...input,
-            depth: input.depth + 1
-          }) : { kind: "unavailable", reason: "access_error" }
-        );
-      }
-      return {
-        kind: "array",
-        items,
-        totalItems: value.length,
-        ...value.length > items.length ? { truncated: true } : {}
-      };
-    }
-    let descriptors;
-    try {
-      descriptors = Object.getOwnPropertyDescriptors(value);
-    } catch {
-      return { kind: "unavailable", reason: "access_error" };
-    }
-    const entries = Object.entries(descriptors).filter(
-      ([, descriptor]) => descriptor.enumerable
-    );
-    const selected = entries.slice(0, DOCFLOW_NODE_IO_LIMITS.maxObjectFields);
-    const fields = {};
-    for (const [key, descriptor] of selected) {
-      const safeKey = truncateUtf8(
-        ledgerSafeDocflowPreviewKey(input.redactor.redactString(key)),
-        DOCFLOW_NODE_IO_LIMITS.maxStringBytes
-      );
-      fields[safeKey] = "value" in descriptor ? previewValue(descriptor.value, {
-        ...input,
-        depth: input.depth + 1,
-        key
-      }) : { kind: "unavailable", reason: "access_error" };
-    }
-    return {
-      kind: "object",
-      fields,
-      totalFields: entries.length,
-      ...entries.length > selected.length ? { truncated: true } : {}
-    };
-  } catch {
-    return { kind: "unavailable", reason: "access_error" };
-  } finally {
-    input.ancestors.delete(value);
-  }
-}
-function readDataProperty(value, property) {
-  if ((typeof value !== "object" || value === null) && typeof value !== "function") {
-    return { ok: false };
-  }
-  try {
-    let owner = value;
-    while (owner) {
-      const descriptor = Object.getOwnPropertyDescriptor(owner, property);
-      if (descriptor) {
-        return "value" in descriptor ? { ok: true, value: descriptor.value } : { ok: false };
-      }
-      owner = Object.getPrototypeOf(owner);
-    }
-  } catch {
-    return { ok: false };
-  }
-  return { ok: false };
-}
-function buildPlayDocflowNodeErrorPreview(error, redactor = createSecretRedactionContext()) {
-  try {
-    const message = error instanceof Error ? error.message : String(error);
-    return truncateUtf8(
-      redactor.redactString(message),
-      DOCFLOW_NODE_IO_LIMITS.maxErrorBytes
-    );
-  } catch {
-    return "Non-Error value thrown (message unavailable)";
-  }
-}
-function isRecord4(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function normalizePreview(value, depth) {
-  if (!isRecord4(value) || typeof value.kind !== "string") return null;
-  if (value.kind === "null") return { kind: "null" };
-  if (value.kind === "scalar") {
-    if (typeof value.value === "string" || typeof value.value === "boolean" || typeof value.value === "number" && Number.isFinite(value.value)) {
-      return previewValue(value.value, {
-        depth: 0,
-        ancestors: /* @__PURE__ */ new WeakSet(),
-        redactor: createSecretRedactionContext()
-      });
-    }
-    return null;
-  }
-  if (value.kind === "unavailable") {
-    const reason = value.reason;
-    return typeof reason === "string" && [
-      "undefined",
-      "function",
-      "symbol",
-      "bigint",
-      "cycle",
-      "depth",
-      "access_error",
-      "limit",
-      "unsupported"
-    ].includes(reason) ? {
-      kind: "unavailable",
-      reason
-    } : null;
-  }
-  if (value.kind === "dataset") {
-    const datasetId = safeString(
-      value.datasetId,
-      createSecretRedactionContext(),
-      "datasetId"
-    );
-    if (!datasetId || value.datasetKind !== "csv" && value.datasetKind !== "map") {
-      return null;
-    }
-    return {
-      kind: "dataset",
-      datasetId,
-      datasetKind: value.datasetKind,
-      ...value.tableNamespace === null ? { tableNamespace: null } : typeof value.tableNamespace === "string" ? {
-        tableNamespace: safeString(
-          value.tableNamespace,
-          createSecretRedactionContext(),
-          "tableNamespace"
-        )
-      } : {},
-      ...typeof value.rowCount === "number" && Number.isFinite(value.rowCount) ? { rowCount: Math.max(0, Math.floor(value.rowCount)) } : {}
-    };
-  }
-  if (depth >= DOCFLOW_NODE_IO_LIMITS.maxDepth) {
-    return { kind: "unavailable", reason: "depth" };
-  }
-  if (value.kind === "array" && Array.isArray(value.items)) {
-    const items = value.items.slice(0, DOCFLOW_NODE_IO_LIMITS.maxArrayItems).map((item) => normalizePreview(item, depth + 1)).filter((item) => item !== null);
-    const totalItems = typeof value.totalItems === "number" && Number.isFinite(value.totalItems) ? Math.max(items.length, Math.floor(value.totalItems)) : items.length;
-    return {
-      kind: "array",
-      items,
-      totalItems,
-      ...value.truncated === true || totalItems > items.length ? { truncated: true } : {}
-    };
-  }
-  if (value.kind === "object" && isRecord4(value.fields)) {
-    const fields = {};
-    for (const [key, field] of Object.entries(value.fields).slice(
-      0,
-      DOCFLOW_NODE_IO_LIMITS.maxObjectFields
-    )) {
-      const normalized = normalizePreview(field, depth + 1);
-      if (normalized) fields[ledgerSafeDocflowPreviewKey(key)] = normalized;
-    }
-    const totalFields = typeof value.totalFields === "number" && Number.isFinite(value.totalFields) ? Math.max(Object.keys(fields).length, Math.floor(value.totalFields)) : Object.keys(fields).length;
-    return {
-      kind: "object",
-      fields,
-      totalFields,
-      ...value.truncated === true || totalFields > Object.keys(fields).length ? { truncated: true } : {}
-    };
-  }
-  return null;
-}
-function normalizePlayDocflowNodeIoState(value) {
-  if (!isRecord4(value)) return void 0;
-  const attempt = typeof value.attempt === "number" && Number.isFinite(value.attempt) ? Math.max(0, Math.floor(value.attempt)) : 0;
-  const normalizeMap = (raw) => {
-    if (!isRecord4(raw)) return void 0;
-    const output = {};
-    for (const [path, preview] of Object.entries(raw).slice(
-      0,
-      DOCFLOW_NODE_IO_LIMITS.maxPaths
-    )) {
-      const normalized = normalizePreview(preview, 0);
-      if (!normalized) continue;
-      const safePath = ledgerSafeDocflowPreviewKey(path);
-      const candidate = { ...output, [safePath]: normalized };
-      if (utf8Bytes(JSON.stringify(candidate)) > DOCFLOW_NODE_IO_LIMITS.maxPhaseBytes) {
-        break;
-      }
-      output[safePath] = normalized;
-    }
-    return output;
-  };
-  const inputs = normalizeMap(value.inputs);
-  const outputs = normalizeMap(value.outputs);
-  const error = typeof value.error === "string" ? buildPlayDocflowNodeErrorPreview(value.error) : value.error === null ? null : void 0;
-  return {
-    attempt,
-    ...typeof value.invocationId === "string" && value.invocationId.trim() ? {
-      invocationId: truncateUtf8(
-        value.invocationId.trim(),
-        DOCFLOW_NODE_IO_LIMITS.maxStringBytes
-      )
-    } : {},
-    ...inputs ? { inputs } : {},
-    ...outputs ? { outputs } : {},
-    ...value.inputsTruncated === true ? { inputsTruncated: true } : {},
-    ...value.outputsTruncated === true ? { outputsTruncated: true } : {},
-    ...error !== void 0 ? { error } : {}
-  };
-}
-
-// ../play-runtime/activity-observation.ts
-function isRecord5(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function isPlayActivityObservation(value) {
-  if (!isRecord5(value) || value.schemaVersion !== void 0 && value.schemaVersion !== 1 || typeof value.activityId !== "string" || !value.activityId.trim() || typeof value.observedAt !== "number" || !Number.isFinite(value.observedAt) || !isRecord5(value.target) || !isRecord5(value.state)) {
-    return false;
-  }
-  const targetKinds = /* @__PURE__ */ new Set([
-    "provider",
-    "dataset",
-    "lease",
-    "runner",
-    "step",
-    "capacity"
-  ]);
-  const stateKinds = /* @__PURE__ */ new Set([
-    "active",
-    "queued",
-    "waiting",
-    "retrying",
-    "scheduled",
-    "completed",
-    "failed"
-  ]);
-  return typeof value.target.kind === "string" && targetKinds.has(value.target.kind) && typeof value.state.kind === "string" && stateKinds.has(value.state.kind);
-}
-function derivePlayActivityVisibility(input) {
-  const { state } = input.observation;
-  if (state.kind === "failed") return "action";
-  if (state.kind === "waiting") {
-    return state.reason.kind === "external_event" ? "action" : "headline";
-  }
-  if (state.kind === "queued" || state.kind === "scheduled") return "headline";
-  if (state.kind === "retrying") {
-    if (state.reason === "rate_limit" && input.observation.target.kind === "capacity") {
-      return "headline";
-    }
-    if (state.retryAt - input.now <= 3e4) return "hidden";
-    return state.reason === "rate_limit" ? "headline" : "timeline";
-  }
-  if (state.kind === "active") return "headline";
-  return "timeline";
-}
-function targetLabel(target) {
-  switch (target.kind) {
-    case "provider":
-      return target.label ?? `${target.provider} ${target.operation}`;
-    case "dataset":
-      return target.label ?? `dataset ${target.tableNamespace}`;
-    case "lease":
-      return `${target.resourceKind} ${target.resourceLabel}`;
-    case "runner":
-      return target.label ?? `${target.backend} runner`;
-    case "step":
-      return target.label ?? target.stepId;
-    case "capacity":
-      return target.label ?? `${target.pool} capacity`;
-  }
-}
-function summarizePlayActivity(observation) {
-  const label = targetLabel(observation.target);
-  const { state } = observation;
-  switch (state.kind) {
-    case "active": {
-      const progress = state.progress;
-      const counts = typeof progress?.completed === "number" && typeof progress.total === "number" ? ` (${progress.completed}/${progress.total})` : "";
-      return `Active: ${label}${counts}.`;
-    }
-    case "queued":
-      return `Queued: waiting for ${label}.`;
-    case "waiting":
-      if (state.reason.kind === "external_event") {
-        const provider = state.reason.provider ? ` from ${state.reason.provider}` : "";
-        return `Blocked: waiting for an external event${provider}.`;
-      }
-      if (state.reason.kind === "dataset") {
-        return `Blocked: waiting for dataset ${state.reason.tableNamespace} to become ${state.reason.requiredPhase}.`;
-      }
-      if (state.reason.kind === "lease") {
-        return `Contended: waiting for ${state.reason.resourceKind} lease ${state.reason.resourceLabel}.`;
-      }
-      return `Paused: ${label}; the legacy producer did not report a typed reason.`;
-    case "retrying":
-      if (state.reason === "rate_limit") {
-        return `Waiting for ${label} request capacity; the run will retry automatically.`;
-      }
-      return `Delayed: ${label} will retry automatically.`;
-    case "scheduled":
-      return `Scheduled: ${label} will resume automatically.`;
-    case "completed":
-      return `Completed: ${label}.`;
-    case "failed":
-      return `Failed: ${label}.`;
-  }
-}
-function isTerminalActivityState(state) {
-  return state.kind === "completed" || state.kind === "failed";
-}
-function projection(observation, now, classified = true) {
-  return {
-    observation,
-    summary: summarizePlayActivity(observation),
-    visibility: derivePlayActivityVisibility({ observation, now }),
-    classified
-  };
-}
-function projectPlayRunActivity(input) {
-  const now = input.now ?? Date.now();
-  const observedAt = input.updatedAt ?? now;
-  const normalizedStatus = input.status.trim().toLowerCase();
-  if (normalizedStatus === "completed" || normalizedStatus === "failed" || normalizedStatus === "cancelled" || normalizedStatus === "terminated" || normalizedStatus === "timed_out") {
-    return null;
-  }
-  const latestExplicit = [...input.explicit ?? []].filter((candidate) => !isTerminalActivityState(candidate.state)).sort((left, right) => right.observedAt - left.observedAt)[0];
-  const explicit = latestExplicit?.target.kind === "capacity" && latestExplicit.target.pool === "provider" && latestExplicit.state.kind === "retrying" && latestExplicit.state.retryAt < now ? null : latestExplicit;
-  if (explicit) return projection(explicit, now);
-  if (input.waitKind === "detached_runner") {
-    return projection(
-      {
-        activityId: "runner:managed",
-        target: {
-          kind: "runner",
-          backend: input.runtimeBackend ?? "managed",
-          label: "managed play runner"
-        },
-        state: { kind: "active" },
-        observedAt
-      },
-      now
-    );
-  }
-  if (input.waitKind === "sleep") {
-    return projection(
-      {
-        activityId: "run:sleep",
-        target: {
-          kind: "step",
-          stepId: input.activeNodeId ?? "run",
-          label: input.playName ?? "play"
-        },
-        state: {
-          kind: "scheduled",
-          reason: "sleep",
-          resumeAt: input.waitUntil ?? observedAt
-        },
-        observedAt
-      },
-      now
-    );
-  }
-  if (input.waitKind === "integration_event" || input.waitKind === "integration_event_batch") {
-    return projection(
-      {
-        activityId: `event:${input.activeNodeId ?? "run"}`,
-        stepId: input.activeNodeId ?? void 0,
-        target: {
-          kind: "step",
-          stepId: input.activeNodeId ?? "run",
-          label: input.playName ?? "play"
-        },
-        state: {
-          kind: "waiting",
-          reason: {
-            kind: "external_event",
-            eventKey: input.eventKey ?? void 0,
-            deadlineAt: input.waitUntil ?? void 0
-          }
-        },
-        observedAt
-      },
-      now
-    );
-  }
-  if (normalizedStatus === "waiting") {
-    return projection(
-      {
-        activityId: "run:legacy-wait",
-        target: {
-          kind: "step",
-          stepId: input.activeNodeId ?? "run",
-          label: input.playName ?? "play"
-        },
-        state: { kind: "waiting", reason: { kind: "unknown" } },
-        observedAt
-      },
-      now,
-      false
-    );
-  }
-  const pendingDataset = [...input.datasets ?? []].filter(
-    (dataset) => dataset.phase === "registered" || dataset.complete !== true && dataset.phase !== "failed"
-  ).sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
-  if (pendingDataset) {
-    const activeDatasetStep = input.nodeStates?.find(
-      (candidate) => candidate.nodeId === input.activeNodeId && candidate.status === "running" && candidate.artifactTableNamespace === pendingDataset.tableNamespace
-    );
-    const datasetStep = activeDatasetStep ?? input.nodeStates?.find(
-      (candidate) => candidate.artifactTableNamespace === pendingDataset.tableNamespace
-    );
-    const datasetProgress = datasetStep?.progress ?? null;
-    return projection(
-      {
-        activityId: `dataset:${pendingDataset.datasetId ?? pendingDataset.tableNamespace}`,
-        target: {
-          kind: "dataset",
-          tableNamespace: pendingDataset.tableNamespace,
-          operation: "materializing"
-        },
-        state: {
-          kind: "active",
-          progress: {
-            completed: datasetProgress?.completed ?? pendingDataset.persistedRows,
-            total: datasetProgress?.total ?? (typeof pendingDataset.succeededRows === "number" || typeof pendingDataset.failedRows === "number" ? (pendingDataset.succeededRows ?? 0) + (pendingDataset.failedRows ?? 0) : void 0),
-            failed: datasetProgress?.failed ?? pendingDataset.failedRows
-          }
-        },
-        observedAt: datasetStep?.updatedAt ?? pendingDataset.updatedAt ?? observedAt
-      },
-      now
-    );
-  }
-  const activeStep = input.nodeStates?.find(
-    (candidate) => candidate.nodeId === input.activeNodeId
-  ) ?? input.nodeStates?.find((candidate) => candidate.status === "running") ?? null;
-  if (activeStep) {
-    const toolId = activeStep.nodeId.startsWith("tool:") ? activeStep.nodeId.split(":").at(-1)?.trim() || null : null;
-    const provider = toolId?.split(/[._]/)[0]?.trim() || null;
-    return projection(
-      {
-        activityId: `step:${activeStep.nodeId}`,
-        stepId: activeStep.nodeId,
-        target: toolId && provider ? {
-          kind: "provider",
-          provider,
-          operation: toolId,
-          label: activeStep.label ?? toolId
-        } : {
-          kind: "step",
-          stepId: activeStep.nodeId,
-          label: activeStep.label
-        },
-        state: {
-          kind: "active",
-          progress: activeStep.progress ?? void 0
-        },
-        observedAt: activeStep.updatedAt ?? observedAt
-      },
-      now
-    );
-  }
-  if (normalizedStatus === "queued") {
-    return projection(
-      {
-        activityId: "capacity:worker",
-        target: { kind: "capacity", pool: "worker" },
-        state: { kind: "queued", reason: "capacity" },
-        observedAt
-      },
-      now
-    );
-  }
-  const fallback = {
-    activityId: "run:legacy",
-    target: {
-      kind: "step",
-      stepId: input.activeNodeId ?? "run",
-      label: input.playName ?? "play"
-    },
-    state: normalizedStatus === "waiting" ? { kind: "waiting", reason: { kind: "unknown" } } : { kind: "active" },
-    observedAt
-  };
-  return projection(fallback, now, normalizedStatus !== "waiting");
-}
-
-// ../play-runtime/cell-provenance.ts
-function finiteNonNegativeInteger2(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    return null;
-  }
-  return Math.trunc(value);
-}
-function nonEmptyString(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed ? trimmed : null;
-}
-function normalizeDatasetBornFrom(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const record3 = value;
-  const table = nonEmptyString(record3.table);
-  const rowCountIn = finiteNonNegativeInteger2(record3.rowCountIn);
-  if (!table || rowCountIn === null) return null;
-  return { table, rowCountIn };
-}
-
-// ../play-runtime/run-ledger.ts
-var LOG_TAIL_LIMIT = 100;
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  "completed",
-  "failed",
-  "cancelled",
-  "terminated",
-  "timed_out"
-]);
-function isRecord6(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function nonnegativeSafeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function isWorkCounterSegmentId(value) {
-  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
-    value
-  );
-}
-function normalizePlayRunLedgerTerminalWorkCounterSegment(value) {
-  if (!isRecord6(value)) return void 0;
-  if (!nonnegativeSafeInteger(value.attempt) || !nonnegativeSafeInteger(value.invocationSeq) || value.invocationSeq === 0 || !isWorkCounterSegmentId(value.segmentId)) {
-    return void 0;
-  }
-  return {
-    attempt: value.attempt,
-    invocationSeq: value.invocationSeq,
-    segmentId: value.segmentId
-  };
-}
-function hasConfirmedPlayRunLedgerWorkCounters(snapshot) {
-  const counters = snapshot.workCounters;
-  const terminal = snapshot.terminalWorkCounterSegment;
-  return Boolean(
-    isTerminalPlayRunLedgerStatus(snapshot.status) && (snapshot.terminalSource === "worker" || snapshot.terminalSource === "system") && counters?.final && counters.completeThroughAttempt && counters.consistent && terminal && counters.attempt === terminal.attempt && counters.invocationSeq === terminal.invocationSeq && counters.segmentId === terminal.segmentId && Number.isSafeInteger(
-      counters.completedLogicalCalls + counters.logicalCalls
-    ) && Number.isSafeInteger(
-      counters.completedProviderRequests + counters.providerRequests
-    ) && Number.isSafeInteger(
-      counters.completedProvider429s + counters.provider429s
-    )
-  );
-}
-function normalizeWorkCounters(value) {
-  if (!isRecord6(value)) return void 0;
-  for (const field of [
-    "attempt",
-    "invocationSeq",
-    "logicalCalls",
-    "providerRequests",
-    "provider429s",
-    "completedLogicalCalls",
-    "completedProviderRequests",
-    "completedProvider429s"
-  ]) {
-    if (!nonnegativeSafeInteger(value[field])) return void 0;
-  }
-  if (value.invocationSeq === 0 || !isWorkCounterSegmentId(value.segmentId) || typeof value.final !== "boolean" || typeof value.completeThroughAttempt !== "boolean" || typeof value.consistent !== "boolean") {
-    return void 0;
-  }
-  return {
-    ...value,
-    attempt: value.attempt,
-    invocationSeq: value.invocationSeq,
-    segmentId: value.segmentId,
-    logicalCalls: value.logicalCalls,
-    providerRequests: value.providerRequests,
-    provider429s: value.provider429s,
-    final: value.final,
-    completedLogicalCalls: value.completedLogicalCalls,
-    completedProviderRequests: value.completedProviderRequests,
-    completedProvider429s: value.completedProvider429s,
-    completeThroughAttempt: value.completeThroughAttempt,
-    consistent: value.consistent
-  };
-}
-function optionalFiniteNumber(value) {
-  const normalized = finiteNumber(value);
-  return normalized === null ? void 0 : normalized;
-}
-function optionalString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function optionalNullableString(value) {
-  if (value === null) return null;
-  return optionalString(value);
-}
-function normalizePlayRunLedgerStatus(value) {
-  const normalized = String(value ?? "").trim().toLowerCase();
-  switch (normalized) {
-    case "queued":
-    case "pending":
-      return "queued";
-    case "running":
-    case "started":
-      return "running";
-    case "waiting":
-      return "waiting";
-    case "completed":
-    case "complete":
-    case "succeeded":
-      return "completed";
-    case "failed":
-    case "error":
-      return "failed";
-    case "cancelled":
-    case "canceled":
-      return "cancelled";
-    case "terminated":
-      return "terminated";
-    case "timed_out":
-    case "timeout":
-      return "timed_out";
-    default:
-      return "unknown";
-  }
-}
-function isTerminalPlayRunLedgerStatus(status) {
-  return TERMINAL_STATUSES.has(status);
-}
-function summarizeRunRowOutcomes(snapshot) {
-  let completedRows = 0;
-  let failedRows = 0;
-  let totalRows = 0;
-  let supersededRows = 0;
-  for (const step of Object.values(snapshot.stepsById)) {
-    const progress = step.progress;
-    if (!progress) continue;
-    completedRows += Math.max(0, finiteNumber(progress.completed) ?? 0);
-    failedRows += Math.max(0, finiteNumber(progress.failed) ?? 0);
-    supersededRows += Math.max(0, finiteNumber(progress.supersededRows) ?? 0);
-    const stepTotal = finiteNumber(progress.total);
-    totalRows += stepTotal !== null && stepTotal >= 0 ? stepTotal : Math.max(0, finiteNumber(progress.completed) ?? 0) + Math.max(0, finiteNumber(progress.failed) ?? 0) + Math.max(0, finiteNumber(progress.supersededRows) ?? 0);
-  }
-  const resultSummary = isRecord6(snapshot.resultSummary) ? snapshot.resultSummary : null;
-  const resultRowOutcomes = isRecord6(resultSummary?.rowOutcomes) ? resultSummary.rowOutcomes : null;
-  const terminalCompletedRows = finiteNumber(resultRowOutcomes?.completedRows);
-  const terminalFailedRows = finiteNumber(resultRowOutcomes?.failedRows);
-  const terminalTotalRows = finiteNumber(resultRowOutcomes?.totalRows);
-  const terminalSupersededRows = finiteNumber(
-    resultRowOutcomes?.supersededRows
-  );
-  const settledCompletedRows = terminalCompletedRows ?? completedRows;
-  const settledFailedRows = terminalFailedRows ?? failedRows;
-  return {
-    completedRows: settledCompletedRows,
-    failedRows: settledFailedRows,
-    totalRows: terminalTotalRows ?? totalRows,
-    hasRowFailures: settledFailedRows > 0,
-    ...(terminalSupersededRows ?? supersededRows) > 0 ? { supersededRows: terminalSupersededRows ?? supersededRows } : {}
-  };
-}
-function createEmptyPlayRunLedgerSnapshot(input) {
-  const status = normalizePlayRunLedgerStatus(input.status ?? "unknown");
-  const startedAt = finiteNumber(input.startedAt) ?? null;
-  const finishedAt = finiteNumber(input.finishedAt) ?? null;
-  return {
-    runId: input.runId,
-    playName: input.playName ?? null,
-    status,
-    waitKind: null,
-    waitUntil: null,
-    error: optionalNullableString(input.error) ?? null,
-    createdAt: finiteNumber(input.createdAt) ?? null,
-    startedAt,
-    updatedAt: finiteNumber(input.updatedAt) ?? finishedAt ?? startedAt ?? finiteNumber(input.createdAt) ?? null,
-    finishedAt,
-    durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : null,
-    orderedStepIds: [],
-    stepsById: {},
-    orderedDatasetIds: [],
-    datasetsById: {},
-    orderedActivityIds: [],
-    activitiesById: {},
-    logTail: [],
-    totalLogCount: 0,
-    logsTruncated: false,
-    activeStepId: null,
-    activeActivityId: null,
-    activeArtifactTableNamespace: null,
-    resultTableNamespace: null
-  };
-}
-function normalizePlayRunLedgerSnapshot(value, fallback) {
-  if (!isRecord6(value)) {
-    return createEmptyPlayRunLedgerSnapshot(fallback);
-  }
-  const orderedStepIds = Array.isArray(value.orderedStepIds) ? value.orderedStepIds.filter(
-    (entry) => typeof entry === "string" && Boolean(entry.trim())
-  ) : [];
-  const rawSteps = isRecord6(value.stepsById) ? value.stepsById : {};
-  const stepsById = {};
-  for (const [stepId, rawStep] of Object.entries(rawSteps)) {
-    if (!stepId.trim() || !isRecord6(rawStep)) continue;
-    const rawStatus = normalizeStepStatus(rawStep.status);
-    if (!rawStatus) continue;
-    const completedAt = finiteNumber(rawStep.completedAt);
-    const status = rawStatus === "running" && completedAt !== null ? "completed" : rawStatus;
-    const rawProgress = isRecord6(rawStep.progress) ? rawStep.progress : null;
-    stepsById[stepId] = {
-      stepId,
-      label: optionalString(rawStep.label),
-      kind: optionalString(rawStep.kind),
-      status,
-      error: optionalNullableString(rawStep.error),
-      artifactTableNamespace: optionalNullableString(
-        rawStep.artifactTableNamespace
-      ),
-      startedAt: finiteNumber(rawStep.startedAt),
-      completedAt,
-      updatedAt: finiteNumber(rawStep.updatedAt),
-      progress: rawProgress ? normalizeStepProgress(rawProgress) : null
-    };
-  }
-  const rawDatasets = isRecord6(value.datasetsById) ? value.datasetsById : {};
-  const datasetsById = {};
-  for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
-    if (!datasetId.trim() || !isRecord6(rawDataset)) continue;
-    const phase = rawDataset.phase === "available" || rawDataset.phase === "failed" ? rawDataset.phase : "registered";
-    const datasetBornFrom = normalizeDatasetBornFrom(rawDataset.bornFrom);
-    datasetsById[datasetId] = {
-      datasetId,
-      path: optionalString(rawDataset.path) ?? `datasets.${datasetId}`,
-      tableNamespace: optionalString(rawDataset.tableNamespace) ?? datasetId,
-      phase,
-      persistedRows: Math.max(0, finiteNumber(rawDataset.persistedRows) ?? 0),
-      persistedRowsObserved: rawDataset.persistedRowsObserved === true,
-      succeededRows: Math.max(0, finiteNumber(rawDataset.succeededRows) ?? 0),
-      succeededRowsObserved: rawDataset.succeededRowsObserved === true,
-      failedRows: Math.max(0, finiteNumber(rawDataset.failedRows) ?? 0),
-      failedRowsObserved: rawDataset.failedRowsObserved === true,
-      complete: rawDataset.complete === true,
-      completeObserved: rawDataset.completeObserved === true,
-      // ADR 0019 birth survives the snapshot round trip. A partial record is
-      // dropped rather than half-admitted, so a dataset either states where its
-      // rows came from or says nothing.
-      ...datasetBornFrom ? { bornFrom: datasetBornFrom } : {},
-      updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0
-    };
-  }
-  const rawActivities = isRecord6(value.activitiesById) ? value.activitiesById : {};
-  const activitiesById = {};
-  for (const [activityId, rawActivity] of Object.entries(rawActivities)) {
-    if (activityId.trim() && isPlayActivityObservation(rawActivity) && rawActivity.activityId === activityId) {
-      activitiesById[activityId] = rawActivity;
-    }
-  }
-  const createdAt = finiteNumber(value.createdAt) ?? fallback.createdAt ?? null;
-  const startedAt = finiteNumber(value.startedAt) ?? fallback.startedAt ?? null;
-  const finishedAt = finiteNumber(value.finishedAt) ?? fallback.finishedAt ?? null;
-  const updatedAt = finiteNumber(value.updatedAt) ?? fallback.updatedAt ?? finishedAt ?? startedAt ?? createdAt ?? null;
-  const error = Object.prototype.hasOwnProperty.call(value, "error") ? optionalNullableString(value.error) ?? null : fallback.error ?? null;
-  const rawTail = Array.isArray(value.logTail) ? value.logTail : value.logs;
-  const logTail = Array.isArray(rawTail) ? rawTail.filter((line) => typeof line === "string") : [];
-  const workCounters = normalizeWorkCounters(value.workCounters);
-  const terminalWorkCounterSegment = normalizePlayRunLedgerTerminalWorkCounterSegment(
-    value.terminalWorkCounterSegment
-  );
-  return {
-    runId: optionalString(value.runId) ?? fallback.runId,
-    playName: optionalNullableString(value.playName) ?? fallback.playName ?? null,
-    status: normalizePlayRunLedgerStatus(value.status ?? fallback.status),
-    waitKind: optionalNullableString(value.waitKind),
-    waitUntil: finiteNumber(value.waitUntil),
-    error,
-    createdAt,
-    startedAt,
-    updatedAt,
-    finishedAt,
-    durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : finiteNumber(value.durationMs),
-    orderedStepIds: orderedStepIds.filter((stepId) => stepsById[stepId]),
-    stepsById,
-    orderedDatasetIds: (Array.isArray(value.orderedDatasetIds) ? value.orderedDatasetIds : Object.keys(datasetsById)).filter(
-      (datasetId) => typeof datasetId === "string" && Boolean(datasetsById[datasetId])
-    ),
-    datasetsById,
-    orderedActivityIds: (Array.isArray(value.orderedActivityIds) ? value.orderedActivityIds : Object.keys(activitiesById)).filter(
-      (activityId) => typeof activityId === "string" && Boolean(activitiesById[activityId])
-    ),
-    activitiesById,
-    ...workCounters ? { workCounters } : {},
-    ...terminalWorkCounterSegment ? { terminalWorkCounterSegment } : {},
-    logTail: logTail.slice(-LOG_TAIL_LIMIT),
-    // Snapshots persisted before totalLogCount existed only know the retained
-    // tail, so the best lower bound for the cumulative count is the tail size.
-    totalLogCount: Math.max(
-      finiteNumber(value.totalLogCount) ?? logTail.length,
-      logTail.length
-    ),
-    // A persisted snapshot carrying more lines than the tail keeps is
-    // truncated here, whatever the stored flag says. Reporting `false` while
-    // dropping lines is silent loss: a reader would take the tail for the
-    // whole log.
-    logsTruncated: value.logsTruncated === true || logTail.length > LOG_TAIL_LIMIT,
-    activeStepId: optionalNullableString(value.activeStepId),
-    activeActivityId: optionalNullableString(value.activeActivityId),
-    activeArtifactTableNamespace: optionalNullableString(
-      value.activeArtifactTableNamespace
-    ),
-    resultTableNamespace: optionalNullableString(value.resultTableNamespace),
-    resultSummary: value.resultSummary,
-    result: value.result,
-    terminalSource: normalizePlayRunLedgerTerminalSource(value.terminalSource)
-  };
-}
-function normalizeStepStatus(value) {
-  const normalized = String(value ?? "").trim().toLowerCase();
-  if (normalized === "running" || normalized === "completed" || normalized === "failed" || normalized === "skipped") {
-    return normalized;
-  }
-  return null;
-}
-function normalizeStepProgress(value) {
-  return {
-    ...optionalFiniteNumber(value.completed) !== void 0 ? { completed: optionalFiniteNumber(value.completed) } : {},
-    ...optionalFiniteNumber(value.total) !== void 0 ? { total: optionalFiniteNumber(value.total) } : {},
-    ...optionalFiniteNumber(value.failed) !== void 0 ? { failed: optionalFiniteNumber(value.failed) } : {},
-    ...optionalFiniteNumber(value.startedRows) !== void 0 ? { startedRows: optionalFiniteNumber(value.startedRows) } : {},
-    ...optionalFiniteNumber(value.activeRows) !== void 0 ? { activeRows: optionalFiniteNumber(value.activeRows) } : {},
-    ...optionalFiniteNumber(value.waitingRows) !== void 0 ? { waitingRows: optionalFiniteNumber(value.waitingRows) } : {},
-    ...optionalFiniteNumber(value.completedRows) !== void 0 ? { completedRows: optionalFiniteNumber(value.completedRows) } : {},
-    ...optionalFiniteNumber(value.supersededRows) !== void 0 ? { supersededRows: optionalFiniteNumber(value.supersededRows) } : {},
-    ...optionalString(value.message) ? { message: optionalString(value.message) } : {},
-    ...optionalNullableString(value.artifactTableNamespace) !== void 0 ? {
-      artifactTableNamespace: optionalNullableString(
-        value.artifactTableNamespace
-      )
-    } : {},
-    ...finiteNumber(value.startedAt) !== null ? { startedAt: finiteNumber(value.startedAt) } : {},
-    ...finiteNumber(value.completedAt) !== null ? { completedAt: finiteNumber(value.completedAt) } : {},
-    ...finiteNumber(value.updatedAt) !== null ? { updatedAt: finiteNumber(value.updatedAt) } : {},
-    ...normalizePlayDocflowNodeIoState(value.nodeIo) ? { nodeIo: normalizePlayDocflowNodeIoState(value.nodeIo) } : {}
-  };
-}
 
 // ../play-runtime/run-lifecycle-policy.ts
 var TERMINAL_PLAY_RUN_STATUSES = /* @__PURE__ */ new Set([
@@ -3874,170 +2864,13 @@ function decodePlayRunPublicStatus(value) {
 }
 
 // ../play-runtime/log-provenance.ts
-var LOG_PROVENANCE_CLASSES = [
-  "user",
-  "lifecycle",
-  "replay",
-  "infra",
-  "diagnostic",
-  "receipt"
-];
 var PROVENANCE_SENTINEL = "
";
 var PROVENANCE_PREFIX = `${PROVENANCE_SENTINEL}prov:`;
-function readProvenanceTag(line) {
-  if (!line.startsWith(PROVENANCE_PREFIX)) {
-    return { provenance: null, line };
-  }
-  const end = line.indexOf(PROVENANCE_SENTINEL, PROVENANCE_PREFIX.length);
-  if (end === -1) {
-    return { provenance: null, line };
-  }
-  const candidate = line.slice(PROVENANCE_PREFIX.length, end);
-  const provenance = LOG_PROVENANCE_CLASSES.includes(candidate) ? candidate : null;
-  return { provenance, line: line.slice(end + 1) };
-}
-function stripProvenanceTag(line) {
-  return readProvenanceTag(line).line;
-}
 
 // ../play-runtime/run-snapshot-stream.ts
-function normalizePlayRunLiveStatus(value) {
-  return normalizePlayRunLifecycleStatus(value);
-}
 function isTerminalPlayRunLiveStatus(status) {
   return isTerminalPlayRunLifecycleStatus(status);
 }
-function isRecord7(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function finiteNumber2(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function extractTerminalRunLogTail(result) {
-  if (!isRecord7(result) || !isRecord7(result._metadata)) {
-    return null;
-  }
-  const runLogTail = result._metadata.runLogTail;
-  if (!isRecord7(runLogTail) || !Array.isArray(runLogTail.tail)) {
-    return null;
-  }
-  const logTail = runLogTail.tail.filter(
-    (line) => typeof line === "string" && line.trim().length > 0
-  );
-  if (logTail.length === 0) {
-    return null;
-  }
-  const totalLogCount = Math.max(
-    finiteNumber2(runLogTail.totalLogCount) ?? logTail.length,
-    logTail.length
-  );
-  return {
-    logTail: logTail.slice(-LOG_TAIL_LIMIT),
-    totalLogCount
-  };
-}
-function buildSnapshotFromLedger(snapshot) {
-  const nodeStates = snapshot.orderedStepIds.map((stepId) => snapshot.stepsById[stepId]).filter((step) => Boolean(step)).map((step) => ({
-    nodeId: step.stepId,
-    status: step.status,
-    error: step.error ?? null,
-    artifactTableNamespace: step.artifactTableNamespace ?? null,
-    progress: step.progress ? {
-      completed: step.progress.completed,
-      total: step.progress.total,
-      failed: step.progress.failed,
-      startedRows: step.progress.startedRows,
-      activeRows: step.progress.activeRows,
-      waitingRows: step.progress.waitingRows,
-      completedRows: step.progress.completedRows,
-      supersededRows: step.progress.supersededRows,
-      message: step.progress.message,
-      artifactTableNamespace: step.progress.artifactTableNamespace ?? step.artifactTableNamespace ?? null,
-      startedAt: step.startedAt ?? null,
-      completedAt: step.completedAt ?? null,
-      updatedAt: step.progress.updatedAt ?? step.updatedAt ?? null,
-      nodeIo: step.progress.nodeIo
-    } : null,
-    startedAt: step.startedAt ?? null,
-    completedAt: step.completedAt ?? null,
-    updatedAt: step.updatedAt ?? null,
-    ...step.progress?.nodeIo ? { nodeIo: step.progress.nodeIo } : {}
-  }));
-  const liveStatus = normalizePlayRunLiveStatus(snapshot.status);
-  const terminalRowOutcomes = isTerminalPlayRunLiveStatus(liveStatus) ? summarizeRunRowOutcomes(snapshot) : null;
-  const rowOutcomes = terminalRowOutcomes && (Object.keys(snapshot.stepsById).length > 0 || terminalRowOutcomes.totalRows > 0 || (terminalRowOutcomes.supersededRows ?? 0) > 0) ? terminalRowOutcomes : null;
-  const workCounters = snapshot.workCounters;
-  const calls = workCounters ? {
-    logicalCalls: workCounters.completedLogicalCalls + workCounters.logicalCalls,
-    providerRequests: workCounters.completedProviderRequests + workCounters.providerRequests,
-    provider429s: workCounters.completedProvider429s + workCounters.provider429s,
-    confirmed: isTerminalPlayRunLiveStatus(liveStatus) && hasConfirmedPlayRunLedgerWorkCounters(snapshot)
-  } : null;
-  return {
-    runId: snapshot.runId,
-    status: liveStatus,
-    createdAt: snapshot.createdAt ?? null,
-    startedAt: snapshot.startedAt ?? null,
-    finishedAt: snapshot.finishedAt ?? null,
-    durationMs: snapshot.durationMs ?? null,
-    updatedAt: snapshot.updatedAt ?? snapshot.finishedAt ?? snapshot.startedAt ?? null,
-    // This snapshot is public SDK/API transport. Keep the historical plain
-    // timestamp-prefixed text while provenance remains runtime metadata.
-    logs: snapshot.logTail.map(stripProvenanceTag),
-    totalLogCount: snapshot.totalLogCount,
-    ...snapshot.logsTruncated ? { logsTruncated: true } : {},
-    activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
-    resultTableNamespace: snapshot.resultTableNamespace ?? null,
-    datasets: snapshot.orderedDatasetIds.map((datasetId) => snapshot.datasetsById[datasetId]).filter(
-      (dataset) => Boolean(dataset)
-    ),
-    activities: snapshot.orderedActivityIds.map((activityId) => snapshot.activitiesById[activityId]).filter(
-      (activity) => Boolean(activity)
-    ),
-    activeActivity: snapshot.activeActivityId ? snapshot.activitiesById[snapshot.activeActivityId] ?? null : null,
-    nodeStates,
-    activeNodeId: snapshot.activeStepId ?? null,
-    ...rowOutcomes ? { rowOutcomes } : {},
-    ...calls && Object.values(calls).every(
-      (value) => typeof value === "boolean" || Number.isSafeInteger(value)
-    ) ? { calls } : {}
-  };
-}
-function buildPlayRunStatusSnapshot(input) {
-  const ledgerSnapshot = normalizePlayRunLedgerSnapshot(input.run.runSnapshot, {
-    runId: input.run.workflowId,
-    playName: input.run.name ?? null,
-    status: input.run.status,
-    createdAt: input.run.createdAt ?? null,
-    startedAt: input.run.startedAt ?? null,
-    updatedAt: input.run.updatedAt ?? null,
-    finishedAt: input.run.finishedAt ?? null
-  });
-  const terminalRunLogTail = extractTerminalRunLogTail(input.run.result);
-  const projectedSnapshot = terminalRunLogTail && terminalRunLogTail.totalLogCount > ledgerSnapshot.totalLogCount ? buildSnapshotFromLedger({
-    ...ledgerSnapshot,
-    logTail: terminalRunLogTail.logTail,
-    totalLogCount: terminalRunLogTail.totalLogCount
-  }) : buildSnapshotFromLedger(ledgerSnapshot);
-  const activity = projectPlayRunActivity({
-    runId: input.run.workflowId,
-    playName: input.run.name,
-    status: projectedSnapshot.status,
-    updatedAt: projectedSnapshot.updatedAt,
-    waitKind: input.run.waitKind ?? input.run.wait?.kind ?? null,
-    waitUntil: input.run.waitUntil,
-    eventKey: input.run.wait?.eventKey ?? null,
-    runtimeBackend: input.run.runtimeBackend,
-    activeNodeId: input.run.activeBoundaryId ?? projectedSnapshot.activeNodeId,
-    nodeStates: projectedSnapshot.nodeStates,
-    datasets: projectedSnapshot.datasets,
-    explicit: projectedSnapshot.activities
-  });
-  return {
-    ...projectedSnapshot,
-    activity
-  };
-}
 function makeRunStreamEvent(input) {
   return {
     ...input,
@@ -4120,7 +2953,7 @@ function diffLogLines(input) {
   const missingCount = tailFirstSeq - 1 - input.lastLogSeq;
   return {
     lines: [
-      `[stream] ${missingCount} log lines not retained in the live window; full logs via runs logs`,
+      `[watch] ${missingCount} log lines not retained in the live window; full logs via runs logs`,
       ...logs
     ],
     lastLogSeq: totalLogCount,
@@ -4266,310 +3099,156 @@ function diffPlayRunStreamEvents(input) {
   return { events, next };
 }
 
-// src/runs/observe-transport.ts
-var RunObserveTransportUnavailableError = class extends Error {
-  constructor(message, reason) {
-    super(message);
-    this.reason = reason;
-    this.name = "RunObserveTransportUnavailableError";
+// src/stream-reconnect.ts
+function isTransientPlayRunReadError(error) {
+  if (error instanceof DeeplineError && error.code === "PLAY_STREAM_NETWORK_ABORTED") {
+    return true;
   }
-};
-var OBSERVE_BOOTSTRAP_TIMEOUT_MS = 1e4;
-var OBSERVE_RECONNECT_NOTICE_MS = 1e4;
-var OBSERVE_STALE_WARNING_MS = 12e4;
-var OBSERVE_WATCHDOG_TICK_MS = 5e3;
-var GRANT_REFRESH_MARGIN_MS = 5 * 6e4;
-var BACKFILL_PAGE_LIMIT = 1e3;
-var BACKFILL_MAX_PAGES = 30;
-var OBSERVER_SNAPSHOT_QUERY = "runObservers:getPlayRunSnapshotForObserver";
-var OBSERVER_LOG_PAGE_QUERY = "runObservers:getRunLogPageForObserver";
-function errorText(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-async function mintRunObserveGrant(http, runId) {
-  let response;
-  try {
-    response = await http.post(
-      `/api/v2/runs/${encodeURIComponent(runId)}/observe-grant`,
-      {}
-    );
-  } catch (error) {
-    if (error instanceof DeeplineError) {
-      if (error.statusCode === 401 || error.statusCode === 403) {
-        throw error;
-      }
-      throw new RunObserveTransportUnavailableError(
-        `observe-grant endpoint unavailable (${error.statusCode ?? "network"}): ${error.message}`,
-        "grant_endpoint_unavailable"
-      );
-    }
-    throw new RunObserveTransportUnavailableError(
-      `observe-grant request failed: ${errorText(error)}`,
-      "grant_request_failed"
-    );
+  if (error instanceof DeeplineError && typeof error.statusCode === "number") {
+    return error.statusCode >= 500 && error.statusCode < 600;
+  }
+  const text = error instanceof Error ? error.message : String(error);
+  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
+    text
+  );
+}
+
+// src/runs/watch-polling.ts
+var RUN_WATCH_POLL_INTERVAL_MS = 2e3;
+function waitForNextPoll(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve2) => {
+    const finish = (elapsed) => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+      resolve2(elapsed);
+    };
+    const onAbort = () => finish(false);
+    const timeout = setTimeout(() => finish(true), ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function readSnapshotResponse(response, runId) {
+  if (!response || typeof response !== "object" || Array.isArray(response)) {
+    throw new Error("Run watch returned an invalid snapshot response.");
   }
-  const grant = response;
-  if (!grant || typeof grant.convexUrl !== "string" || !grant.convexUrl.trim() || typeof grant.token !== "string" || !grant.token.trim() || typeof grant.expiresAt !== "number") {
-    throw new RunObserveTransportUnavailableError(
-      "observe-grant endpoint returned an invalid grant payload.",
-      "grant_payload_invalid"
-    );
+  const record3 = response;
+  const snapshot = record3.snapshot;
+  if (record3.runId !== runId || !snapshot || typeof snapshot !== "object" || Array.isArray(snapshot) || snapshot.runId !== runId || typeof snapshot.status !== "string" || !Array.isArray(snapshot.logs) || !snapshot.logs.every(
+    (line) => typeof line === "string"
+  ) || typeof snapshot.totalLogCount !== "number" || !Array.isArray(snapshot.nodeStates)) {
+    throw new Error(`Run watch returned an invalid snapshot for ${runId}.`);
   }
-  return grant;
+  return { runId, snapshot };
 }
-async function backfillLogGap(input) {
+async function backfillRotatedLogTail(input) {
+  if (!input.previous.runSignature) {
+    return input.snapshot;
+  }
+  const gap = resolvePlayRunLogGap(input.snapshot, input.previous.lastLogSeq);
+  if (!gap) {
+    return input.snapshot;
+  }
   const lines = [];
-  let cursor = input.lastLogSeq;
-  for (let page = 0; page < BACKFILL_MAX_PAGES; page += 1) {
-    if (cursor >= input.tailFirstSeq - 1) {
-      break;
-    }
-    let logPage;
-    try {
-      logPage = await input.queryLogPage(
-        cursor,
-        Math.min(BACKFILL_PAGE_LIMIT, input.tailFirstSeq - 1 - cursor)
-      );
-    } catch {
-      return null;
-    }
-    const entries = (logPage?.entries ?? []).filter(
-      (entry) => entry.seq > cursor && entry.seq < input.tailFirstSeq
+  let cursor = input.previous.lastLogSeq;
+  const targetSeq = gap.tailFirstSeq - 1;
+  while (cursor < targetSeq) {
+    const limit = Math.min(1e3, targetSeq - cursor);
+    const page = await input.http.get(
+      `/api/v2/runs/${encodeURIComponent(input.runId)}/logs?afterSeq=${cursor}&limit=${limit}`,
+      { signal: input.signal }
     );
-    if (entries.length === 0) {
-      break;
+    if (!page || !Array.isArray(page.entries) || page.entries.length === 0) {
+      return input.snapshot;
     }
-    for (const entry of entries) {
-      if (entry.seq !== cursor + 1) {
-        return null;
+    for (const entry of page.entries) {
+      if (!entry || entry.seq !== cursor + 1 || typeof entry.line !== "string") {
+        return input.snapshot;
       }
       lines.push(entry.line);
       cursor = entry.seq;
     }
   }
-  if (cursor < input.tailFirstSeq - 1) {
-    return null;
+  if (cursor !== targetSeq) {
+    return input.snapshot;
   }
-  return lines;
+  return { ...input.snapshot, logs: [...lines, ...input.snapshot.logs] };
 }
-async function* observeRunEvents(options) {
-  const { http, runId } = options;
-  let grant = await mintRunObserveGrant(http, runId);
-  let convexBrowser;
-  let convexServer;
-  try {
-    convexBrowser = await import("convex/browser");
-    convexServer = await import("convex/server");
-  } catch (error) {
-    throw new RunObserveTransportUnavailableError(
-      `convex client module unavailable: ${errorText(error)}`,
-      "convex_module_unavailable"
-    );
-  }
-  let webSocketConstructor;
-  if (typeof WebSocket === "undefined") {
+async function* watchRunEvents(options) {
+  const { http, runId, signal } = options;
+  const path = `/api/v2/runs/${encodeURIComponent(runId)}?watchSnapshot=true`;
+  const streamId = `play-run-watch:${runId}`;
+  const pollIntervalMs = options.pollIntervalMs ?? RUN_WATCH_POLL_INTERVAL_MS;
+  let previous = EMPTY_PLAY_RUN_STREAM_DIFF_STATE;
+  let consecutiveFailures = 0;
+  let outageNoticeSent = false;
+  while (!signal?.aborted) {
+    const pollStartedAt = Date.now();
+    let snapshot;
     try {
-      const wsModuleName = "ws";
-      const ws = await import(wsModuleName);
-      webSocketConstructor = ws.default;
-    } catch (error) {
-      throw new RunObserveTransportUnavailableError(
-        `no WebSocket implementation available: ${errorText(error)}`,
-        "websocket_unavailable"
-      );
-    }
-  }
-  const snapshotQuery = convexServer.makeFunctionReference(
-    OBSERVER_SNAPSHOT_QUERY
-  );
-  const logPageQuery = convexServer.makeFunctionReference(
-    OBSERVER_LOG_PAGE_QUERY
-  );
-  const client = new convexBrowser.ConvexClient(grant.convexUrl, {
-    ...webSocketConstructor ? { webSocketConstructor } : {},
-    unsavedChangesWarning: false
-  });
-  const queue = [];
-  let wake = null;
-  const push = (item) => {
-    queue.push(item);
-    wake?.();
-    wake = null;
-  };
-  let lastForcedRefreshAt = 0;
-  client.setAuth(async ({ forceRefreshToken }) => {
-    const now = Date.now();
-    if (!forceRefreshToken && grant.expiresAt - now > GRANT_REFRESH_MARGIN_MS) {
-      return grant.token;
-    }
-    if (forceRefreshToken && now - lastForcedRefreshAt < 5e3) {
-      push({
-        kind: "error",
-        error: new DeeplineError(
-          `Run observe grant for ${runId} was rejected after a re-mint. The server and Convex deployment disagree on the grant issuer/JWKS.`,
-          401,
-          "RUN_OBSERVE_GRANT_REJECTED"
-        )
+      const response = await http.get(path, { signal });
+      snapshot = await backfillRotatedLogTail({
+        http,
+        runId,
+        snapshot: readSnapshotResponse(response, runId).snapshot,
+        previous,
+        signal
       });
-      return null;
-    }
-    if (forceRefreshToken) {
-      lastForcedRefreshAt = now;
-    }
-    try {
-      grant = await mintRunObserveGrant(http, runId);
-      return grant.token;
     } catch (error) {
-      push({ kind: "error", error });
-      return null;
-    }
-  });
-  const unsubscribe = client.onUpdate(
-    snapshotQuery,
-    { workflowId: runId },
-    (run) => push({ kind: "run", run: run ?? null }),
-    (error) => push({ kind: "error", error })
-  );
-  let lastUpdateAt = Date.now();
-  let lastStatusTerminal = false;
-  let disconnectedSince = null;
-  let warnedReconnecting = false;
-  let warnedStale = false;
-  const watchdog = setInterval(() => {
-    const now = Date.now();
-    try {
-      const connectionState = client.connectionState();
-      if (connectionState.isWebSocketConnected) {
-        disconnectedSince = null;
-        warnedReconnecting = false;
-      } else {
-        disconnectedSince ??= now;
-        if (!warnedReconnecting && now - disconnectedSince >= OBSERVE_RECONNECT_NOTICE_MS) {
-          warnedReconnecting = true;
-          options.onNotice?.(
-            `[observe] connection lost; reconnecting to live run ${runId}\u2026`
-          );
-        }
-      }
-    } catch {
-    }
-    if (!lastStatusTerminal && !warnedStale && now - lastUpdateAt >= OBSERVE_STALE_WARNING_MS) {
-      warnedStale = true;
-      options.onNotice?.(
-        `[observe] no live updates for ${Math.round((now - lastUpdateAt) / 1e3)}s; run ${runId} may be stalled (status checks continue)`
-      );
-    }
-  }, OBSERVE_WATCHDOG_TICK_MS);
-  watchdog.unref?.();
-  const abortListener = () => push({
-    kind: "error",
-    error: new DeeplineError(
-      "Run observation aborted.",
-      void 0,
-      "ABORTED"
-    )
-  });
-  options.signal?.addEventListener("abort", abortListener, { once: true });
-  let diffState = EMPTY_PLAY_RUN_STREAM_DIFF_STATE;
-  const streamId = ["observe", runId].join(":");
-  let sawFirstSnapshot = false;
-  try {
-    for (; ; ) {
-      if (queue.length === 0) {
-        const waitForItem = new Promise((resolve2) => {
-          wake = resolve2;
-        });
-        if (!sawFirstSnapshot) {
-          const timedOut = await Promise.race([
-            waitForItem.then(() => false),
-            new Promise(
-              (resolve2) => setTimeout(() => resolve2(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
-            )
-          ]);
-          if (timedOut && queue.length === 0) {
-            throw new RunObserveTransportUnavailableError(
-              `no snapshot from Convex at ${grant.convexUrl} within ${OBSERVE_BOOTSTRAP_TIMEOUT_MS}ms`,
-              "convex_unreachable"
-            );
-          }
-        } else {
-          await waitForItem;
-        }
-        continue;
-      }
-      const item = queue.shift();
-      if (item.kind === "error") {
-        if (options.signal?.aborted) {
-          return;
-        }
-        throw item.error;
+      if (signal?.aborted) {
+        return;
       }
-      sawFirstSnapshot = true;
-      lastUpdateAt = Date.now();
-      warnedStale = false;
-      if (item.run === null) {
-        throw new DeeplineError(
-          `Run ${runId} was not found (or is not visible to this grant).`,
-          404,
-          "RUN_NOT_FOUND"
-        );
+      if (!isTransientPlayRunReadError(error)) {
+        throw error;
       }
-      const snapshot = buildPlayRunStatusSnapshot({ run: item.run });
-      lastStatusTerminal = isTerminalPlayRunLiveStatus(snapshot.status);
-      const gap = resolvePlayRunLogGap(snapshot, diffState.lastLogSeq);
-      if (gap && diffState.lastLogSeq > 0) {
-        const backfilled = await backfillLogGap({
-          queryLogPage: (afterSeq, limit) => client.query(logPageQuery, {
-            workflowId: runId,
-            afterSeq,
-            limit
-          }),
-          lastLogSeq: diffState.lastLogSeq,
-          tailFirstSeq: gap.tailFirstSeq
+      consecutiveFailures += 1;
+      const reason = error instanceof Error ? error.message : String(error);
+      if (!outageNoticeSent) {
+        options.onRetry?.({
+          attempt: consecutiveFailures,
+          delayMs: pollIntervalMs,
+          reason
         });
-        if (backfilled && backfilled.length > 0) {
-          yield {
-            cursor: String(snapshot.updatedAt ?? Date.now()),
-            streamId,
-            scope: "play",
-            type: "play.run.log",
-            at: (/* @__PURE__ */ new Date()).toISOString(),
-            payload: {
-              runId: snapshot.runId,
-              lines: backfilled,
-              source: "worker",
-              firstSeq: diffState.lastLogSeq + 1,
-              totalLogCount: snapshot.totalLogCount
-            }
-          };
-          diffState = { ...diffState, lastLogSeq: gap.tailFirstSeq - 1 };
-        }
-      }
-      const { events, next } = diffPlayRunStreamEvents({
-        streamId,
-        snapshot,
-        previous: diffState
-      });
-      diffState = next;
-      const ordered = [
-        ...events.filter((event) => event.type === "play.run.snapshot"),
-        ...events.filter((event) => event.type !== "play.run.snapshot")
-      ];
-      for (const event of ordered) {
-        yield event;
+        options.onNotice?.(
+          `[watch] run snapshot request failed; retrying every ${pollIntervalMs / 1e3}s (${reason})`
+        );
+        outageNoticeSent = true;
       }
-      if (lastStatusTerminal) {
+      const remaining2 = Math.max(
+        0,
+        pollIntervalMs - (Date.now() - pollStartedAt)
+      );
+      if (!await waitForNextPoll(remaining2, signal)) {
         return;
       }
+      continue;
     }
-  } finally {
-    clearInterval(watchdog);
-    options.signal?.removeEventListener("abort", abortListener);
-    try {
-      unsubscribe();
-    } catch {
+    if (outageNoticeSent) {
+      options.onNotice?.("[watch] run snapshot polling recovered");
+      outageNoticeSent = false;
+    }
+    consecutiveFailures = 0;
+    const diff = diffPlayRunStreamEvents({
+      streamId,
+      snapshot,
+      previous
+    });
+    previous = diff.next;
+    for (const event of diff.events) {
+      yield event;
+    }
+    if (isTerminalPlayRunLiveStatus(snapshot.status)) {
+      return;
+    }
+    const remaining = Math.max(
+      0,
+      pollIntervalMs - (Date.now() - pollStartedAt)
+    );
+    if (!await waitForNextPoll(remaining, signal)) {
+      return;
     }
-    await client.close().catch(() => void 0);
   }
 }
 
@@ -4921,7 +3600,7 @@ function requireTargetBillingIdempotencyKey(value) {
   }
   return normalized;
 }
-function isRecord8(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPrebuiltPlayDescription(play) {
@@ -4953,10 +3632,10 @@ function normalizePlayStatus(raw) {
   return {
     ...raw,
     runId,
-    ...isRecord8(legacyOverview) ? {
+    ...isRecord4(legacyOverview) ? {
       overview: legacyOverview
     } : {},
-    ...isRecord8(runStatus) ? { runStatus } : {},
+    ...isRecord4(runStatus) ? { runStatus } : {},
     ...runPackage ? {
       package: runPackage,
       outputs: runPackage.outputs
@@ -5095,7 +3774,7 @@ function updatePlayLiveStatusState(state, event) {
   }
   const runId = typeof payload.runId === "string" && payload.runId ? payload.runId : isPlayRunPackage(payload) ? payload.run.id : state.runId;
   const status = normalizeLiveStatus(payload.status) ?? (isPlayRunPackage(payload) ? normalizeLiveStatus(payload.run.status) : null) ?? state.status;
-  const progressPayload = isRecord8(payload.progress) ? payload.progress : {};
+  const progressPayload = isRecord4(payload.progress) ? payload.progress : {};
   if (event.type === "play.run.final_status" && state.logs.length === 0 && state.lastLogSeq === 0) {
     const payloadLogs = readStringArray(payload.logs);
     const progressLogs = readStringArray(progressPayload.logs);
@@ -5174,6 +3853,7 @@ var DeeplineClient = class _DeeplineClient {
       status: (runId) => this.getRunLifecycleStatus(runId),
       list: (options2) => this.listRuns(options2),
       listPage: (options2) => this.listRunsPage(options2),
+      watch: (runId, options2) => this.watchRunToTerminal(runId, options2),
       tail: (runId, options2) => this.tailRun(runId, options2),
       logs: (runId, options2) => this.getRunLogs(runId, options2),
       input: (runId) => this.getRunInput(runId),
@@ -5296,9 +3976,9 @@ var DeeplineClient = class _DeeplineClient {
     return fields.length > 0 ? { fields } : schema;
   }
   schemaMetadata(schema, key) {
-    if (!isRecord8(schema)) return null;
+    if (!isRecord4(schema)) return null;
     const value = schema[key];
-    return isRecord8(value) ? value : null;
+    return isRecord4(value) ? value : null;
   }
   playRunCommand(play, options) {
     const target = play.reference || play.name;
@@ -5353,7 +4033,7 @@ var DeeplineClient = class _DeeplineClient {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
-      staticPipeline: isRecord8(play.staticPipeline) ? play.staticPipeline : isRecord8(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord8(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
+      staticPipeline: isRecord4(play.staticPipeline) ? play.staticPipeline : isRecord4(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord4(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand,
@@ -5713,15 +4393,17 @@ var DeeplineClient = class _DeeplineClient {
     return normalizePlayRunStart(response);
   }
   /**
-   * Start a play run and stream live runtime events from the same request.
+   * Submit a play run through the legacy event response.
+   *
+   * This reports admission from the start request; it does not watch an
+   * existing run. Use `startPlayRun()` and `watchRunEvents(runId)` separately.
    *
-   * Use this when a caller wants low-level event handling instead of submitting
-   * first and then connecting to `streamPlayRunEvents(runId)`.
+   * @deprecated Use the separate start and watch methods.
    *
    * @param request - Play run configuration.
-   * @param options - Optional streaming options.
-   * @param options.signal - Optional abort signal for the streaming request.
-   * @returns Async stream of play-scoped live events.
+   * @param options - Optional compatibility response options.
+   * @param options.signal - Abort the start response.
+   * @returns Async generator of play-scoped live events.
    */
   async *startPlayRunStream(request, options) {
     const integrationMode = resolvePlayRunIntegrationMode(request);
@@ -6203,11 +4885,23 @@ var DeeplineClient = class _DeeplineClient {
     );
     return normalizePlayStatus(response);
   }
+  /** Poll authenticated run snapshots every two seconds and emit changed events. */
+  async *watchRunEvents(workflowId, options) {
+    for await (const event of watchRunEvents({
+      http: this.http,
+      runId: workflowId,
+      signal: options?.signal,
+      onNotice: options?.onNotice,
+      onRetry: options?.onRetry
+    })) {
+      yield event;
+    }
+  }
   /**
-   * Stream semantic play-run events using the same SSE feed as the dashboard.
+   * Read raw legacy SSE events for callers that explicitly require that
+   * compatibility endpoint. Ordinary run watching uses REST snapshot polling.
    *
-   * The server emits a canonical `play.run.snapshot` event first for every
-   * connection, then incremental live events until terminal state or reconnect.
+   * @deprecated Use `watchRunEvents` for ordinary run watching.
    */
   async *streamPlayRunEvents(workflowId, options) {
     const headers = options?.lastEventId && options.lastEventId.trim() ? { "Last-Event-ID": options.lastEventId.trim() } : void 0;
@@ -6222,6 +4916,68 @@ var DeeplineClient = class _DeeplineClient {
       }
     }
   }
+  /**
+   * Compatibility alias for polling canonical run snapshots and emitting
+   * their changed events.
+   *
+   * @deprecated Use `watchRunEvents`; kept as a source-compatible alias.
+   * The `fallback` option is ignored because watching uses REST polling.
+   */
+  async *observeRunEvents(runId, options) {
+    yield* this.watchRunEvents(runId, {
+      signal: options?.signal,
+      onNotice: options?.onNotice
+    });
+  }
+  /** Poll snapshots to terminal status and return the durable package. */
+  async watchRunToTerminal(runId, options) {
+    const state = {
+      runId,
+      status: "running",
+      logs: [],
+      lastLogSeq: 0,
+      latest: null
+    };
+    let terminalObserved = false;
+    for await (const event of this.watchRunEvents(runId, {
+      signal: options?.signal,
+      onNotice: options?.onNotice,
+      onRetry: options?.onRetry ?? options?.onReconnect
+    })) {
+      options?.onEvent?.(event);
+      const status = updatePlayLiveStatusState(state, event);
+      if (status && TERMINAL_PLAY_STATUSES.has(status.status)) {
+        terminalObserved = true;
+      }
+    }
+    if (options?.signal?.aborted) {
+      throw new DeeplineError("Run watch aborted.", void 0, "ABORTED");
+    }
+    if (terminalObserved) {
+      return await this.getRunStatus(runId);
+    }
+    const refreshed = await this.getRunStatus(runId);
+    if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) return refreshed;
+    throw new DeeplineError(
+      `Run watch for ${runId} ended before a terminal status.`,
+      void 0,
+      "PLAY_WATCH_ENDED"
+    );
+  }
+  /**
+   * Wait for a run and return its terminal status.
+   *
+   * This source-compatible alias uses the same authenticated two-second REST
+   * snapshot polling as `client.runs.watch`.
+   *
+   * @deprecated Use `client.runs.watch`; retained for SDK compatibility.
+   * @param runId - Public Deepline play-run id.
+   * @param options - Optional callbacks and cancellation signal.
+   * @returns The final durable run status.
+   */
+  async tailRun(runId, options) {
+    return this.watchRunToTerminal(runId, options);
+  }
   /**
    * Cancel a running play execution.
    *
@@ -6385,10 +5141,10 @@ var DeeplineClient = class _DeeplineClient {
     const responseRunStatus = isPlayRunPackage(response) ? response.runStatus : isPlayRunPackage(response.package) ? response.package.runStatus : response.runStatus;
     const responseOverview = isPlayRunPackage(response) ? response.overview : isPlayRunPackage(response.package) ? response.package.overview : response.overview;
     const status = normalizePlayStatus(response);
-    if (isRecord8(responseRunStatus)) {
+    if (isRecord4(responseRunStatus)) {
       status.runStatus = responseRunStatus;
     }
-    if (isRecord8(responseOverview)) {
+    if (isRecord4(responseOverview)) {
       status.overview = responseOverview;
     }
     if (options?.failedLogs !== true || status.status !== "failed") {
@@ -6487,222 +5243,6 @@ var DeeplineClient = class _DeeplineClient {
     );
     return { ...response, runs: response.runs ?? [] };
   }
-  /**
-   * Observe one run's live events. Uses the Convex Run Snapshot subscription
-   * transport first (ADR-0008), then falls back to the canonical SSE stream
-   * when the subscription transport or its optional client modules are not
-   * available. Pass `fallback: 'none'` to receive
-   * {@link RunObserveTransportUnavailableError} instead.
-   */
-  async *observeRunEvents(runId, options) {
-    let yieldedObserveEvent = false;
-    try {
-      for await (const event of observeRunEvents({
-        http: this.http,
-        runId,
-        signal: options?.signal,
-        onNotice: options?.onNotice
-      })) {
-        yieldedObserveEvent = true;
-        yield event;
-      }
-    } catch (error) {
-      if (!(error instanceof RunObserveTransportUnavailableError) || yieldedObserveEvent || options?.fallback === "none") {
-        throw error;
-      }
-      options?.onNotice?.(
-        `[observe] live subscription unavailable (${error.reason}); falling back to SSE tail (support window, ADR-0008)`
-      );
-      yield* this.streamPlayRunEventsUntilTerminal(runId, options);
-    }
-  }
-  async *streamPlayRunEventsUntilTerminal(runId, options) {
-    const state = {
-      runId,
-      status: "running",
-      logs: [],
-      lastLogSeq: 0,
-      latest: null
-    };
-    let lastEventId;
-    let reconnectAttempt = 0;
-    for (; ; ) {
-      if (options?.signal?.aborted) {
-        return;
-      }
-      const connectedAt = Date.now();
-      let sawEvent = false;
-      let endedReason = "stream window ended before a terminal event";
-      try {
-        for await (const event of this.streamPlayRunEvents(runId, {
-          mode: "cli",
-          signal: options?.signal,
-          ...lastEventId ? { lastEventId } : {}
-        })) {
-          sawEvent = true;
-          if (event.cursor?.trim()) {
-            lastEventId = event.cursor;
-          }
-          yield event;
-          const status = updatePlayLiveStatusState(state, event);
-          if (status && TERMINAL_PLAY_STATUSES.has(status.status)) {
-            return;
-          }
-        }
-      } catch (error) {
-        if (options?.signal?.aborted) {
-          return;
-        }
-        if (!isTransientPlayStreamError(error)) {
-          throw error;
-        }
-        endedReason = error instanceof Error ? error.message : String(error);
-      }
-      let refreshed = null;
-      try {
-        refreshed = await this.getRunStatus(runId);
-      } catch (error) {
-        if (!isTransientPlayStreamError(error)) {
-          throw error;
-        }
-      }
-      if (refreshed && TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
-        yield {
-          cursor: String(Date.now()),
-          streamId: `sse-fallback:${runId}`,
-          scope: "play",
-          type: "play.run.status",
-          at: (/* @__PURE__ */ new Date()).toISOString(),
-          payload: refreshed
-        };
-        return;
-      }
-      if (sawEvent || Date.now() - connectedAt >= STREAM_HEALTHY_CONNECTION_MS) {
-        reconnectAttempt = 0;
-      }
-      const delayMs = streamReconnectDelayMs(reconnectAttempt);
-      reconnectAttempt += 1;
-      options?.onNotice?.(
-        `[observe] SSE tail window ended before terminal status (${endedReason}); reconnecting to run ${runId}`
-      );
-      await sleep2(delayMs);
-    }
-  }
-  /**
-   * Tail one run through the subscription transport until terminal, then
-   * return one durable REST status read (the final Run Response Package).
-   */
-  async tailRunViaObserveTransport(runId, options) {
-    const state = {
-      runId,
-      status: "running",
-      logs: [],
-      lastLogSeq: 0,
-      latest: null
-    };
-    for await (const event of this.observeRunEvents(runId, {
-      signal: options?.signal,
-      onNotice: options?.onNotice,
-      fallback: "none"
-    })) {
-      options?.onEvent?.(event);
-      const status = updatePlayLiveStatusState(state, event);
-      if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
-        continue;
-      }
-      return await this.getRunStatus(status.runId || runId);
-    }
-    if (options?.signal?.aborted) {
-      throw new DeeplineError("Run observation aborted.", void 0, "ABORTED");
-    }
-    const refreshed = await this.getRunStatus(runId);
-    if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
-      return refreshed;
-    }
-    throw new DeeplineError(
-      `Run observation for ${runId} ended before a terminal status.`,
-      void 0,
-      "PLAY_LIVE_STREAM_ENDED"
-    );
-  }
-  /**
-   * Read the canonical run stream until a terminal run status is observed.
-   *
-   * Tries the Convex Run Snapshot subscription transport first (ADR-0008);
-   * when the server cannot serve it (grant endpoint missing/unconfigured or
-   * Convex unreachable) it falls back — with one `onNotice` message — to the
-   * support-window SSE stream below.
-   *
-   * Server stream windows are finite: they end cleanly at the function
-   * ceiling even while the run keeps executing. A window that ends (cleanly
-   * or via transient network error) without a terminal event triggers one
-   * durable-status re-check followed by a backed-off reconnect, so long runs
-   * tail to completion. Abort via `options.signal` to stop waiting.
-   */
-  async tailRun(runId, options) {
-    try {
-      return await this.tailRunViaObserveTransport(runId, options);
-    } catch (error) {
-      if (!(error instanceof RunObserveTransportUnavailableError)) {
-        throw error;
-      }
-      options?.onNotice?.(
-        `[observe] live subscription unavailable (${error.reason}); falling back to SSE tail (support window, ADR-0008)`
-      );
-    }
-    const state = {
-      runId,
-      status: "running",
-      logs: [],
-      lastLogSeq: 0,
-      latest: null
-    };
-    let reconnectAttempt = 0;
-    for (; ; ) {
-      const connectedAt = Date.now();
-      let sawEvent = false;
-      let terminalRunId = null;
-      let endedReason = "stream window ended before a terminal event";
-      try {
-        for await (const event of this.streamPlayRunEvents(runId, {
-          mode: "cli",
-          signal: options?.signal
-        })) {
-          options?.onEvent?.(event);
-          sawEvent = true;
-          const status = updatePlayLiveStatusState(state, event);
-          if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
-            continue;
-          }
-          terminalRunId = status.runId || runId;
-          break;
-        }
-      } catch (error) {
-        if (options?.signal?.aborted || !isTransientPlayStreamError(error)) {
-          throw error;
-        }
-        endedReason = error instanceof Error ? error.message : String(error);
-      }
-      if (terminalRunId) {
-        return await this.getRunStatus(terminalRunId);
-      }
-      const refreshed = await this.getRunStatus(runId);
-      if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
-        return refreshed;
-      }
-      if (sawEvent || Date.now() - connectedAt >= STREAM_HEALTHY_CONNECTION_MS) {
-        reconnectAttempt = 0;
-      }
-      const delayMs = streamReconnectDelayMs(reconnectAttempt);
-      reconnectAttempt += 1;
-      options?.onReconnect?.({
-        attempt: reconnectAttempt,
-        delayMs,
-        reason: endedReason
-      });
-      await sleep2(delayMs);
-    }
-  }
   /** Get the exact original input retained for a run. This is intentionally separate from status. */
   async getRunInput(runId) {
     return this.http.get(`/api/v2/runs/${encodeURIComponent(runId)}/input`);
@@ -7493,10 +6033,10 @@ var DeeplineClient = class _DeeplineClient {
   // Plays — high-level orchestration
   // ——————————————————————————————————————————————————————————
   /**
-   * Run a play end-to-end: submit, stream until terminal, return result.
+   * Run a play end-to-end: submit, poll progress until terminal, return result.
    *
    * This is the highest-level play execution method. It submits the play,
-   * reads the canonical run stream for status updates, and returns a structured
+   * reads the canonical run snapshot for status updates, and returns a structured
    * result with logs and timing. Supports cancellation via `AbortSignal`.
    *
    * @param code - Source string fallback; pass the bundled artifact in `options.artifact`
@@ -7552,6 +6092,7 @@ var DeeplineClient = class _DeeplineClient {
       lastLogSeq: 0,
       latest: null
     };
+    let terminalObserved = null;
     if (options?.signal?.aborted) {
       await this.cancelPlay(workflowId);
       return {
@@ -7562,8 +6103,7 @@ var DeeplineClient = class _DeeplineClient {
         error: "Cancelled by user"
       };
     }
-    for await (const event of this.streamPlayRunEvents(workflowId, {
-      mode: "cli",
+    for await (const event of this.watchRunEvents(workflowId, {
       signal: options?.signal
     })) {
       if (options?.signal?.aborted) {
@@ -7576,20 +6116,36 @@ var DeeplineClient = class _DeeplineClient {
           error: "Cancelled by user"
         };
       }
+      const previousStatus = state.latest?.status;
       const status = updatePlayLiveStatusState(state, event);
       if (!status) {
         continue;
       }
-      options?.onProgress?.(status);
+      if (event.type !== "play.run.status" || status.status !== previousStatus) {
+        options?.onProgress?.(status);
+      }
       if (TERMINAL_PLAY_STATUSES.has(status.status)) {
-        const finalStatus = await this.getPlayStatus(
-          status.runId || workflowId
-        ).catch(() => status);
-        return playRunResultFromStatus(finalStatus, start, workflowId);
+        terminalObserved = status;
       }
     }
+    if (options?.signal?.aborted) {
+      await this.cancelPlay(workflowId);
+      return {
+        success: false,
+        runId: workflowId,
+        logs: state.logs,
+        durationMs: Date.now() - start,
+        error: "Cancelled by user"
+      };
+    }
+    if (terminalObserved) {
+      const finalStatus = await this.getPlayStatus(
+        terminalObserved.runId || workflowId
+      ).catch(() => terminalObserved);
+      return playRunResultFromStatus(finalStatus, start, workflowId);
+    }
     throw new DeeplineError(
-      `Run stream for ${workflowId} ended before the run reached a terminal state.`,
+      `Run watch for ${workflowId} ended before the run reached a terminal state.`,
       void 0,
       "PLAY_RUN_STREAM_ENDED",
       { runId: workflowId, workflowId }
@@ -9227,7 +7783,7 @@ var TARGET_FALLBACK_KEYS = {
   status: { match: [/^email_status$/i, /^status$/i] },
   email_status: { match: [/^email_status$/i, /^status$/i] }
 };
-function isRecord9(value) {
+function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function toV2RawToolOutputPath(path) {
@@ -9287,7 +7843,7 @@ function valuesAtSegments(current, segments, path = []) {
     if (!Array.isArray(current)) return [];
     return valuesAtSegments(current[segment], rest, [...path, segment]);
   }
-  if (!isRecord9(current)) return [];
+  if (!isRecord5(current)) return [];
   const directMatches = valuesAtSegments(current[segment], rest, [
     ...path,
     segment
@@ -9317,7 +7873,7 @@ function getValuesAtPath(root, path) {
   return valuesAtSegments(root, parsePath(path)).map((entry) => entry.value);
 }
 function toResultEnvelope(value) {
-  if (isRecord9(value) && "data" in value) {
+  if (isRecord5(value) && "data" in value) {
     const envelope = { data: value.data };
     if ("meta" in value) envelope.meta = value.meta;
     return envelope;
@@ -9370,7 +7926,7 @@ function getAtPath(root, path) {
       current = current[segment];
       continue;
     }
-    if (!isRecord9(current)) return void 0;
+    if (!isRecord5(current)) return void 0;
     current = current[segment];
   }
   return current;
@@ -9387,7 +7943,7 @@ function normalizeString(value) {
 }
 function normalizeRows(value) {
   if (!Array.isArray(value)) return null;
-  return value.map((entry) => isRecord9(entry) ? entry : { value: entry });
+  return value.map((entry) => isRecord5(entry) ? entry : { value: entry });
 }
 function findFirstTargetByPath(result, paths) {
   for (const path of paths ?? []) {
@@ -9457,7 +8013,7 @@ function findFirstTargetByKey(result, target, depth = 0, path = []) {
     }
     return null;
   }
-  if (!isRecord9(result)) return null;
+  if (!isRecord5(result)) return null;
   const rule = TARGET_FALLBACK_KEYS[target] ?? {
     match: [new RegExp(`^${target}$`, "i")]
   };
@@ -9518,7 +8074,7 @@ function normalizeJobChangeStatus(value) {
 function firstExperienceDate(value) {
   if (!Array.isArray(value)) return null;
   for (const entry of value) {
-    if (!isRecord9(entry)) continue;
+    if (!isRecord5(entry)) continue;
     const date = normalizeString(
       entry.start_date ?? entry.started_at ?? entry.startDate
     );
@@ -9527,10 +8083,10 @@ function firstExperienceDate(value) {
   return null;
 }
 function normalizeJobChange(value) {
-  const record3 = isRecord9(value) ? value : {};
-  const nested = isRecord9(record3.job_change) ? record3.job_change : record3;
-  const output = isRecord9(nested.output) ? nested.output : nested;
-  const person = isRecord9(output.person) ? output.person : {};
+  const record3 = isRecord5(value) ? value : {};
+  const nested = isRecord5(record3.job_change) ? record3.job_change : record3;
+  const output = isRecord5(nested.output) ? nested.output : nested;
+  const person = isRecord5(output.person) ? output.person : {};
   const status = normalizeJobChangeStatus(
     output.status ?? output.job_change_status ?? output.job_changed ?? output.changed
   );
@@ -9941,7 +8497,7 @@ function attachToolResultListDataset(result, input) {
     root = replaceAtPath(root, candidate, serialized.preview);
     break;
   }
-  if (isRecord9(root) && isRecord9(root.toolResponse) && Object.prototype.hasOwnProperty.call(root.toolResponse, "raw")) {
+  if (isRecord5(root) && isRecord5(root.toolResponse) && Object.prototype.hasOwnProperty.call(root.toolResponse, "raw")) {
     result.toolResponse.raw = root.toolResponse.raw;
     result.toolOutput.raw = root.toolResponse.raw;
   }
@@ -9959,7 +8515,7 @@ function replaceAtPath(root, path, replacement) {
       copy[segment] = replace(copy[segment], index + 1);
       return copy;
     }
-    if (!isRecord9(current)) return current;
+    if (!isRecord5(current)) return current;
     return {
       ...current,
       [segment]: replace(current[segment], index + 1)
@@ -11929,11 +10485,11 @@ var Deepline = class {
     return new DeeplineContext(options);
   }
 };
-function isRecord10(value) {
+function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function stringArrayRecord(value) {
-  if (!isRecord10(value)) return {};
+  if (!isRecord6(value)) return {};
   return Object.fromEntries(
     Object.entries(value).map(([key, paths]) => [
       key,
@@ -11945,7 +10501,7 @@ function stringArray(value) {
   return Array.isArray(value) ? value.map(String) : [];
 }
 function emailStatusExtractorConfig(value) {
-  if (!isRecord10(value)) return void 0;
+  if (!isRecord6(value)) return void 0;
   const readPaths = (key) => {
     const paths = stringArray(value[key]).map((path) => path.trim()).filter(Boolean);
     return paths.length > 0 ? paths : void 0;
@@ -11972,7 +10528,7 @@ function emailStatusExtractorConfig(value) {
     const paths = readPaths(key);
     if (paths) config[key] = paths;
   }
-  if (isRecord10(value.statusMap)) {
+  if (isRecord6(value.statusMap)) {
     config.statusMap = value.statusMap;
   }
   if (Array.isArray(value.rules)) {
@@ -11981,10 +10537,10 @@ function emailStatusExtractorConfig(value) {
   return config;
 }
 function extractorDescriptorRecord(value) {
-  if (!isRecord10(value)) return {};
+  if (!isRecord6(value)) return {};
   return Object.fromEntries(
     Object.entries(value).flatMap(([key, descriptor]) => {
-      if (!isRecord10(descriptor)) return [];
+      if (!isRecord6(descriptor)) return [];
       const paths = stringArray(descriptor.paths).map((path) => path.trim()).filter(Boolean);
       if (paths.length === 0) return [];
       const transforms = stringArray(descriptor.transforms).map((transform) => transform.trim()).filter(Boolean);
@@ -12006,16 +10562,16 @@ function extractorDescriptorRecord(value) {
 }
 function rowsFromUnknown(value) {
   if (!Array.isArray(value)) return [];
-  return value.map((row) => isRecord10(row) ? row : { value: row });
+  return value.map((row) => isRecord6(row) ? row : { value: row });
 }
-function finiteNonNegativeInteger3(value) {
+function finiteNonNegativeInteger2(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
     return null;
   }
   return Math.floor(value);
 }
 function finitePositiveInteger(value) {
-  const integer = finiteNonNegativeInteger3(value);
+  const integer = finiteNonNegativeInteger2(value);
   return integer !== null && integer > 0 ? integer : null;
 }
 function stableHash(value) {
@@ -12028,9 +10584,9 @@ function stableHash(value) {
 }
 function attachSdkQueryResultDatasetResult(toolId, result, options) {
   if (!options || !isQueryResultDatasetTool(toolId)) return result;
-  const raw = isRecord10(result.toolResponse.raw) ? result.toolResponse.raw : null;
-  const dataset = isRecord10(raw?.dataset) ? raw.dataset : null;
-  const totalRows = finiteNonNegativeInteger3(dataset?.total_rows);
+  const raw = isRecord6(result.toolResponse.raw) ? result.toolResponse.raw : null;
+  const dataset = isRecord6(raw?.dataset) ? raw.dataset : null;
+  const totalRows = finiteNonNegativeInteger2(dataset?.total_rows);
   const sql = typeof options.input.sql === "string" ? options.input.sql : typeof options.input.query === "string" ? options.input.query : typeof raw?.sql === "string" ? raw.sql : null;
   if (!dataset || totalRows === null || !sql) {
     return result;
@@ -12061,7 +10617,7 @@ function attachSdkQueryResultDatasetResult(toolId, result, options) {
         } : {}
       }
     });
-    const pageRaw = isRecord10(response.toolResponse?.raw) ? response.toolResponse.raw : null;
+    const pageRaw = isRecord6(response.toolResponse?.raw) ? response.toolResponse.raw : null;
     return rowsFromUnknown(pageRaw?.rows);
   };
   const collectRows = async (limit) => {
@@ -12118,8 +10674,8 @@ function toolExecutionEnvelopeToResult(fallbackToolId, response, options) {
   const rawV2 = response.toolResponse?.rawV2;
   const view = response.toolResponse?.view;
   const meta = response.toolResponse?.meta;
-  const metadata = isRecord10(response._metadata) ? response._metadata.tool : null;
-  const toolMetadata = isRecord10(metadata) ? metadata : {};
+  const metadata = isRecord6(response._metadata) ? response._metadata.tool : null;
+  const toolMetadata = isRecord6(metadata) ? metadata : {};
   const result = attachSdkQueryResultDatasetResult(
     fallbackToolId,
     createToolExecuteResult({
@@ -12127,12 +10683,12 @@ function toolExecutionEnvelopeToResult(fallbackToolId, response, options) {
       jobId: typeof response.job_id === "string" ? response.job_id : void 0,
       result: {
         data: raw,
-        ...isRecord10(meta) ? { meta } : {}
+        ...isRecord6(meta) ? { meta } : {}
       },
       response: {
         ...rawV2 !== void 0 ? { rawV2 } : {},
         ...view === "data" || view === "rawV2" ? { view } : {},
-        ...isRecord10(meta) ? { meta } : {}
+        ...isRecord6(meta) ? { meta } : {}
       },
       metadata: {
         toolId: typeof toolMetadata.toolId === "string" ? toolMetadata.toolId : fallbackToolId,
@@ -12148,12 +10704,12 @@ function toolExecutionEnvelopeToResult(fallbackToolId, response, options) {
         cached: false,
         source: "live"
       },
-      meta: isRecord10(response.meta) ? response.meta : void 0,
+      meta: isRecord6(response.meta) ? response.meta : void 0,
       billing: response.billing
     }),
     options
   );
-  const executionRecovery = isRecord10(response.executionRecovery) ? response.executionRecovery : void 0;
+  const executionRecovery = isRecord6(response.executionRecovery) ? response.executionRecovery : void 0;
   if (typeof response.idempotencyKey === "string") {
     result.idempotencyKey = response.idempotencyKey;
   }
@@ -12290,6 +10846,15 @@ function getDefinedPlayMetadata(value) {
   return candidate;
 }
 
+// src/runs/observe-transport.ts
+var RunObserveTransportUnavailableError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "RunObserveTransportUnavailableError";
+  }
+};
+
 // src/monitors.ts
 function defineMonitor(definition) {
   if (!definition || typeof definition !== "object") {