deepline 0.1.91 → 0.1.94

package/dist/repo/sdk/src/client.ts

@@ -36,6 +36,15 @@
 import { resolveConfig } from './config.js';
 import { DeeplineError } from './errors.js';
 import { HttpClient } from './http.js';
+import {
+  STREAM_HEALTHY_CONNECTION_MS,
+  isTransientPlayStreamError,
+  streamReconnectDelayMs,
+} from './stream-reconnect.js';
+import {
+  observeRunEvents,
+  RunObserveTransportUnavailableError,
+} from './runs/observe-transport.js';
 import type {
   DeeplineClientOptions,
   ResolvedConfig,
@@ -129,11 +138,29 @@ export type RunsListOptions = {
 /** Streaming options for `client.runs.tail(...)`. */
 export type RunsTailOptions = {
   signal?: AbortSignal;
+  /**
+   * Called before each stream reconnect. Server stream windows are finite, so
+   * long runs reconnect with backoff until a terminal status is observed.
+   */
+  onReconnect?: (info: {
+    attempt: number;
+    delayMs: number;
+    reason: string;
+  }) => void;
+  /**
+   * Display-only transport notices: subscription-transport reconnects,
+   * staleness warnings, and the one-time fallback notice when the server
+   * cannot serve the Convex subscription transport (ADR-0008).
+   */
+  onNotice?: (message: string) => void;
 };
 
 /** Log fetch options for `client.runs.logs(...)`. */
 export type RunsLogsOptions = {
+  /** Return the LAST `limit` stored log lines (default 200). */
   limit?: number;
+  /** Fetch every stored log line, paginating to the full totalCount. */
+  all?: boolean;
 };
 
 /** Persisted log response for one play run. */
@@ -146,6 +173,28 @@ export type RunsLogsResult = {
   truncated: boolean;
   hasMore: boolean;
   entries: string[];
+  /**
+   * True when the run crossed the Run Log Stream retention cap: `totalCount`
+   * keeps counting, but stored line bodies end at a loud truncation marker.
+   */
+  logsTruncated?: boolean;
+};
+
+/** Server page cap for GET /api/v2/runs/:runId/logs (ADR-0009). */
+const RUN_LOGS_PAGE_LIMIT = 1_000;
+
+/** Wire shape of one GET /api/v2/runs/:runId/logs page. */
+type RunLogsPageResponse = {
+  runId: string;
+  totalLogCount: number;
+  logsTruncated: boolean;
+  lastStoredSeq: number;
+  afterSeq: number;
+  entries: Array<{ seq: number; line: string }>;
+  firstSeq: number | null;
+  lastSeq: number | null;
+  hasMore: boolean;
+  nextAfterSeq: number | null;
 };
 
 /** One persisted runtime-sheet row returned by `client.runs.exportDatasetRows(...)`. */
@@ -328,6 +377,13 @@ type PlayLiveStatusState = {
   runId: string;
   status: PlayStatus['status'];
   logs: string[];
+  /**
+   * Absolute (1-based) sequence number of the last log line appended to
+   * `logs`. play.run.log payloads carry `firstSeq` (ADR-0009), so overlapping
+   * re-deliveries are skipped positionally — repeated identical lines are
+   * preserved and snapshots never replace the accumulated log list.
+   */
+  lastLogSeq: number;
   result?: unknown;
   error?: string;
   latest: PlayStatus | null;
@@ -355,13 +411,52 @@ function normalizeLiveStatus(value: unknown): PlayStatus['status'] | null {
   return null;
 }
 
+function appendPlayLiveLogLines(
+  state: PlayLiveStatusState,
+  payload: Record<string, unknown>,
+): void {
+  const lines = readStringArray(payload.lines);
+  if (lines.length === 0) {
+    return;
+  }
+  const firstSeq =
+    typeof payload.firstSeq === 'number' &&
+    Number.isFinite(payload.firstSeq) &&
+    payload.firstSeq >= 1
+      ? Math.trunc(payload.firstSeq)
+      : null;
+  if (firstSeq === null) {
+    // Marker payloads (gap/unavailable notices) and pre-ADR-0009 servers
+    // carry no seq: append verbatim and advance the cursor by the payload's
+    // cumulative count when present so later seq-stamped lines line up.
+    state.logs.push(...lines);
+    const totalLogCount =
+      typeof payload.totalLogCount === 'number' &&
+      Number.isFinite(payload.totalLogCount)
+        ? Math.trunc(payload.totalLogCount)
+        : null;
+    if (totalLogCount !== null) {
+      state.lastLogSeq = Math.max(state.lastLogSeq, totalLogCount);
+    }
+    return;
+  }
+  // Positional append: skip the already-seen prefix of overlapping
+  // re-deliveries; repeated identical lines are preserved.
+  const skip = Math.max(0, state.lastLogSeq + 1 - firstSeq);
+  if (skip >= lines.length) {
+    return;
+  }
+  state.logs.push(...lines.slice(skip));
+  state.lastLogSeq = Math.max(state.lastLogSeq, firstSeq + lines.length - 1);
+}
+
 function updatePlayLiveStatusState(
   state: PlayLiveStatusState,
   event: PlayLiveEvent,
 ): PlayStatus | null {
   const payload = getPlayLiveEventPayload(event);
   if (event.type === 'play.run.log') {
-    state.logs.push(...readStringArray(payload.lines));
+    appendPlayLiveLogLines(state, payload);
     return null;
   }
   if (
@@ -385,15 +480,23 @@ function updatePlayLiveStatusState(
       : null) ??
     state.status;
   const progressPayload = isRecord(payload.progress) ? payload.progress : {};
-  const payloadLogs = readStringArray(payload.logs);
-  const progressLogs = readStringArray(progressPayload.logs);
-  const logs = payloadLogs.length > 0 ? payloadLogs : progressLogs;
+  // Snapshots no longer REPLACE accumulated logs (ADR-0009): the snapshot
+  // only retains a bounded tail, so replacing would clobber the seq-keyed
+  // log list built from play.run.log events (the stream differ always emits
+  // log lines through play.run.log, snapshot ticks included). A terminal
+  // final_status payload may still seed an EMPTY state — that is the only
+  // event some non-stream flows ever see.
   if (
-    logs.length > 0 ||
-    event.type === 'play.run.snapshot' ||
-    (event.type === 'play.run.final_status' && !isPlayRunPackage(payload))
+    event.type === 'play.run.final_status' &&
+    state.logs.length === 0 &&
+    state.lastLogSeq === 0
   ) {
-    state.logs = logs;
+    const payloadLogs = readStringArray(payload.logs);
+    const progressLogs = readStringArray(progressPayload.logs);
+    const seedLogs = payloadLogs.length > 0 ? payloadLogs : progressLogs;
+    if (seedLogs.length > 0) {
+      state.logs = seedLogs;
+    }
   }
   if ('result' in payload) {
     state.result = payload.result;
@@ -1138,6 +1241,7 @@ export class DeeplineClient {
   async compileEnrichPlan(input: {
     plan_args?: string[];
     config?: unknown;
+    native_play_materialization?: 'macro' | 'inline_prebuilt';
   }): Promise<{ config: EnrichCompiledConfig }> {
     return this.http.post('/api/v2/enrich/compile', input);
   }
@@ -1510,6 +1614,128 @@ export class DeeplineClient {
     return response.runs ?? [];
   }
 
+  // ---------------------------------------------------------------------------
+  // Legacy workflows (double-shipped). Thin pass-throughs over the live cloud
+  // `/api/v2/workflows/*` API so the SDK CLI keeps existing cloud workflows
+  // working while users migrate them to plays via `workflows transform`. Kept
+  // intentionally minimal — workflows are a deprecated surface.
+  // ---------------------------------------------------------------------------
+
+  /** List the org's workflows. `GET /api/v2/workflows`. */
+  async listWorkflows(options?: { limit?: number }): Promise<{
+    workflows: Array<{
+      id: string;
+      name: string;
+      status: string;
+      current_published_version: number | null;
+    }>;
+  }> {
+    const params = new URLSearchParams();
+    if (typeof options?.limit === 'number') {
+      params.set('limit', String(options.limit));
+    }
+    const query = params.size > 0 ? `?${params.toString()}` : '';
+    return this.http.get(`/api/v2/workflows${query}`);
+  }
+
+  /**
+   * Fetch a single workflow (including its published-revision config — the
+   * input to `compileWorkflowConfigToPlay`). `GET /api/v2/workflows/:id`.
+   */
+  async getWorkflow(id: string): Promise<{
+    workflow: {
+      id: string;
+      name: string;
+      status: string;
+      current_published_version: number | null;
+      current_published_revision: {
+        version: number;
+        config: unknown;
+      } | null;
+    } | null;
+    validation?: unknown;
+  }> {
+    return this.http.get(`/api/v2/workflows/${encodeURIComponent(id)}`);
+  }
+
+  /** Delete a workflow. `DELETE /api/v2/workflows/:id`. */
+  async deleteWorkflow(id: string): Promise<unknown> {
+    return this.http.delete(`/api/v2/workflows/${encodeURIComponent(id)}`);
+  }
+
+  /** Turn a workflow off. `POST /api/v2/workflows/:id/disable`. */
+  async disableWorkflow(id: string): Promise<unknown> {
+    return this.http.post(
+      `/api/v2/workflows/${encodeURIComponent(id)}/disable`,
+      {},
+    );
+  }
+
+  /** Turn a workflow back on. `POST /api/v2/workflows/:id/enable`. */
+  async enableWorkflow(id: string): Promise<unknown> {
+    return this.http.post(
+      `/api/v2/workflows/${encodeURIComponent(id)}/enable`,
+      {},
+    );
+  }
+
+  /** Create/update a workflow from config. `POST /api/v2/workflows/apply`. */
+  async applyWorkflow(body: Record<string, unknown>): Promise<unknown> {
+    return this.http.post('/api/v2/workflows/apply', body);
+  }
+
+  /** Validate a workflow config without saving. `POST /api/v2/workflows/lint`. */
+  async lintWorkflow(body: Record<string, unknown>): Promise<unknown> {
+    return this.http.post('/api/v2/workflows/lint', body);
+  }
+
+  /** Fetch live workflow request schemas. `GET /api/v2/workflows/schema`. */
+  async getWorkflowSchema(subject?: string): Promise<unknown> {
+    const params = new URLSearchParams();
+    if (subject) params.set('subject', subject);
+    const query = params.size > 0 ? `?${params.toString()}` : '';
+    return this.http.get(`/api/v2/workflows/schema${query}`);
+  }
+
+  /** Queue a workflow run. `POST /api/v2/workflows/call`. */
+  async callWorkflow(body: Record<string, unknown>): Promise<unknown> {
+    return this.http.post('/api/v2/workflows/call', body);
+  }
+
+  /** List a workflow's runs. `GET /api/v2/workflows/:id/runs`. */
+  async listWorkflowRuns(
+    id: string,
+    options?: { limit?: number },
+  ): Promise<unknown> {
+    const params = new URLSearchParams();
+    if (typeof options?.limit === 'number') {
+      params.set('limit', String(options.limit));
+    }
+    const query = params.size > 0 ? `?${params.toString()}` : '';
+    return this.http.get(
+      `/api/v2/workflows/${encodeURIComponent(id)}/runs${query}`,
+    );
+  }
+
+  /** Fetch one workflow run. `GET /api/v2/workflows/:id/runs/:runId`. */
+  async getWorkflowRun(id: string, runId: string): Promise<unknown> {
+    return this.http.get(
+      `/api/v2/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(
+        runId,
+      )}`,
+    );
+  }
+
+  /** Cancel a workflow run. `POST /api/v2/workflows/:id/runs/:runId/cancel`. */
+  async cancelWorkflowRun(id: string, runId: string): Promise<unknown> {
+    return this.http.post(
+      `/api/v2/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(
+        runId,
+      )}/cancel`,
+      {},
+    );
+  }
+
   /**
    * Get a run by id using the public runs resource model.
    *
@@ -1560,44 +1786,161 @@ export class DeeplineClient {
     return response.runs ?? [];
   }
 
-  /** Read the canonical run stream and return the latest run snapshot. */
-  async tailRun(runId: string, options?: RunsTailOptions): Promise<PlayStatus> {
+  /**
+   * Observe one run's live events through the Convex Run Snapshot
+   * subscription transport (ADR-0008). Yields the same `play.*` event
+   * envelopes as {@link streamPlayRunEvents} and ends after the terminal
+   * snapshot. Throws {@link RunObserveTransportUnavailableError} when this
+   * server cannot serve the transport (older server, unconfigured grants, or
+   * unreachable Convex) — callers fall back to the SSE stream with a notice.
+   */
+  observeRunEvents(
+    runId: string,
+    options?: { signal?: AbortSignal; onNotice?: (message: string) => void },
+  ): AsyncGenerator<PlayLiveEvent> {
+    return observeRunEvents({
+      http: this.http,
+      runId,
+      signal: options?.signal,
+      onNotice: options?.onNotice,
+    }) as AsyncGenerator<PlayLiveEvent>;
+  }
+
+  /**
+   * Tail one run through the subscription transport until terminal, then
+   * return one durable REST status read (the final Run Response Package).
+   */
+  private async tailRunViaObserveTransport(
+    runId: string,
+    options?: RunsTailOptions,
+  ): Promise<PlayStatus> {
     const state: PlayLiveStatusState = {
       runId,
       status: 'running',
       logs: [],
+      lastLogSeq: 0,
       latest: null,
     };
-    let terminal = false;
-    for await (const event of this.streamPlayRunEvents(runId, {
-      mode: 'cli',
+    for await (const event of this.observeRunEvents(runId, {
       signal: options?.signal,
+      onNotice: options?.onNotice,
     })) {
       const status = updatePlayLiveStatusState(state, event);
-      if (!status) {
+      if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
         continue;
       }
-      terminal = TERMINAL_PLAY_STATUSES.has(status.status);
-      if (terminal) {
-        break;
-      }
-    }
-    if (terminal && state.latest) {
-      return await this.getRunStatus(state.latest.runId || runId).catch(
+      return await this.getRunStatus(status.runId || runId).catch(
         () => state.latest ?? playRunStatusFromState(state),
       );
     }
-    if (state.latest) {
-      return state.latest;
+    if (options?.signal?.aborted) {
+      throw new DeeplineError('Run observation aborted.', undefined, 'ABORTED');
+    }
+    // The transport ends only after a terminal snapshot; the differ always
+    // emits a terminal `play.run.status` first, so reaching here means the
+    // terminal package read raced — re-check durable status once, loudly.
+    const refreshed = await this.getRunStatus(runId);
+    if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
+      return refreshed;
     }
     throw new DeeplineError(
-      `Run stream for ${runId} ended before the initial snapshot.`,
+      `Run observation for ${runId} ended before a terminal status.`,
       undefined,
-      'PLAY_RUN_STREAM_EMPTY',
-      { runId },
+      '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: string, options?: RunsTailOptions): Promise<PlayStatus> {
+    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: PlayLiveStatusState = {
+      runId,
+      status: 'running',
+      logs: [],
+      lastLogSeq: 0,
+      latest: null,
+    };
+    let reconnectAttempt = 0;
+
+    for (;;) {
+      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,
+        })) {
+          sawEvent = true;
+          const status = updatePlayLiveStatusState(state, event);
+          if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
+            continue;
+          }
+          return await this.getRunStatus(status.runId || runId).catch(
+            () => state.latest ?? playRunStatusFromState(state),
+          );
+        }
+      } catch (error) {
+        if (options?.signal?.aborted || !isTransientPlayStreamError(error)) {
+          throw error;
+        }
+        endedReason = error instanceof Error ? error.message : String(error);
+      }
+
+      // Window ended without a terminal event. The run may have finished
+      // during the gap — re-check durable status once before reconnecting.
+      // Non-transient status failures (e.g. 404 = run gone) fail loudly.
+      let refreshed: PlayStatus | null = null;
+      try {
+        refreshed = await this.getRunStatus(runId);
+      } catch (error) {
+        if (!isTransientPlayStreamError(error)) {
+          throw error;
+        }
+      }
+      if (refreshed && 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 sleep(delayMs);
+    }
+  }
+
   /**
    * Fetch persisted logs for a run using the public runs resource model.
    *
@@ -1611,23 +1954,51 @@ export class DeeplineClient {
     runId: string,
     options?: RunsLogsOptions,
   ): Promise<RunsLogsResult> {
-    const status = await this.getRunStatus(runId, { full: true });
-    const logs = status.progress?.logs ?? [];
-    const limit =
-      typeof options?.limit === 'number' && Number.isFinite(options.limit)
-        ? Math.max(0, Math.trunc(options.limit))
+    const limit = options?.all
+      ? Number.MAX_SAFE_INTEGER
+      : typeof options?.limit === 'number' &&
+          Number.isFinite(options.limit) &&
+          options.limit > 0
+        ? Math.trunc(options.limit)
         : 200;
-    const entries = logs.slice(Math.max(0, logs.length - limit));
+    const fetchPage = (afterSeq: number, pageLimit: number) =>
+      this.http.get<RunLogsPageResponse>(
+        `/api/v2/runs/${encodeURIComponent(runId)}/logs?afterSeq=${afterSeq}&limit=${pageLimit}`,
+      );
+    // Probe for the run's stored extent, then read the LAST `limit` stored
+    // lines (matching the historical tail-slice semantics), paginating in
+    // server-capped pages until the window is exhausted.
+    const probe = await fetchPage(0, 1);
+    const lastStoredSeq = probe.lastStoredSeq;
+    let afterSeq = options?.all ? 0 : Math.max(0, lastStoredSeq - limit);
+    const entries: Array<{ seq: number; line: string }> = [];
+    while (entries.length < limit) {
+      const page = await fetchPage(
+        afterSeq,
+        Math.min(RUN_LOGS_PAGE_LIMIT, limit - entries.length),
+      );
+      if (page.entries.length === 0) {
+        break;
+      }
+      entries.push(...page.entries);
+      afterSeq = page.entries[page.entries.length - 1]!.seq;
+      if (!page.hasMore) {
+        break;
+      }
+    }
+    const firstSequence = entries.length > 0 ? entries[0]!.seq : null;
+    const lastSequence =
+      entries.length > 0 ? entries[entries.length - 1]!.seq : null;
     return {
-      runId: status.runId,
-      totalCount: logs.length,
+      runId: probe.runId,
+      totalCount: probe.totalLogCount,
       returnedCount: entries.length,
-      firstSequence:
-        logs.length === 0 ? null : logs.length - entries.length + 1,
-      lastSequence: logs.length === 0 ? null : logs.length,
-      truncated: logs.length > entries.length,
-      hasMore: logs.length > entries.length,
-      entries,
+      firstSequence,
+      lastSequence,
+      truncated: entries.length < probe.totalLogCount,
+      hasMore: lastSequence !== null && lastSequence < lastStoredSeq,
+      entries: entries.map((entry) => entry.line),
+      ...(probe.logsTruncated ? { logsTruncated: true } : {}),
     };
   }
 
@@ -1993,6 +2364,7 @@ export class DeeplineClient {
       runId: workflowId,
       status: 'running',
       logs: [],
+      lastLogSeq: 0,
       latest: null,
     };
 

package/dist/repo/sdk/src/index.ts

@@ -55,6 +55,7 @@
 
 // ——— Client ———
 export { DeeplineClient } from './client.js';
+export { RunObserveTransportUnavailableError } from './runs/observe-transport.js';
 export type {
   PlayStatus,
   PlaySheetRow,

package/dist/repo/sdk/src/play.ts

@@ -73,6 +73,10 @@
 import { DeeplineClient } from './client.js';
 import { DeeplineError } from './errors.js';
 import { createToolExecuteResult } from '../../shared_libs/play-runtime/tool-result.js';
+export {
+  readValue,
+  readList,
+} from '../../shared_libs/play-runtime/tool-result.js';
 import type {
   PlayDataset,
   PlayDatasetInput,
@@ -81,6 +85,7 @@ import type {
   ToolExecuteResult,
   ToolResultMetadataInput,
 } from '../../shared_libs/play-runtime/tool-result-types.js';
+import type { EmailStatusExtractorConfig } from '../../shared_libs/play-runtime/email-status.js';
 import type { PreviousCell } from '../../shared_libs/play-runtime/cell-staleness.js';
 import type {
   DeeplineClientOptions,
@@ -1549,6 +1554,50 @@ function stringArray(value: unknown): string[] {
   return Array.isArray(value) ? value.map(String) : [];
 }
 
+function emailStatusExtractorConfig(
+  value: unknown,
+): EmailStatusExtractorConfig | undefined {
+  if (!isRecord(value)) return undefined;
+  const readPaths = (key: string): string[] | undefined => {
+    const paths = stringArray(value[key])
+      .map((path) => path.trim())
+      .filter(Boolean);
+    return paths.length > 0 ? paths : undefined;
+  };
+  const provider =
+    typeof value.provider === 'string' && value.provider.trim()
+      ? value.provider.trim()
+      : null;
+  if (!provider) return undefined;
+  const config: EmailStatusExtractorConfig = { provider };
+  for (const key of [
+    'rawStatus',
+    'rawScore',
+    'valid',
+    'deliverability',
+    'catchAll',
+    'mxProvider',
+    'mxRecord',
+    'fraudScore',
+    'disposable',
+    'roleBased',
+    'freeEmail',
+    'abuse',
+    'spamtrap',
+    'suspect',
+  ] as const) {
+    const paths = readPaths(key);
+    if (paths) config[key] = paths;
+  }
+  if (isRecord(value.statusMap)) {
+    config.statusMap = value.statusMap as EmailStatusExtractorConfig['statusMap'];
+  }
+  if (Array.isArray(value.rules)) {
+    config.rules = value.rules as EmailStatusExtractorConfig['rules'];
+  }
+  return config;
+}
+
 function extractorDescriptorRecord(
   value: unknown,
 ): ToolResultMetadataInput['extractors'] {
@@ -1566,6 +1615,7 @@ function extractorDescriptorRecord(
       const enumValues = stringArray(descriptor.enum)
         .map((entry) => entry.trim())
         .filter(Boolean);
+      const emailStatus = emailStatusExtractorConfig(descriptor.emailStatus);
       return [
         [
           key,
@@ -1573,6 +1623,7 @@ function extractorDescriptorRecord(
             paths,
             ...(transforms.length > 0 ? { transforms } : {}),
             ...(enumValues.length > 0 ? { enum: enumValues } : {}),
+            ...(emailStatus ? { emailStatus } : {}),
           },
         ],
       ];

package/dist/repo/sdk/src/release.ts

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.91',
+  version: '0.1.94',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.91',
+    latest: '0.1.94',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },