deepline 0.1.119 → 0.1.121

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -0,0 +1,838 @@
+import { createWriteStream } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import type { PlaySheetContract } from '@shared_libs/plays/static-pipeline';
+import type { PlayRowUpdate } from '@shared_libs/play-runtime/ctx-types';
+import type { PlayRunTimelineEntry } from '@shared_libs/play-runtime/live-events';
+import {
+  buildPlayRunLedgerEventsFromStatusPatch,
+  buildTerminalLogReplayEvents,
+  createEmptyPlayRunLedgerSnapshot,
+  reducePlayRunLedgerEvents,
+  slicePositionalLogLines,
+  type PlayRunLedgerEvent,
+  type PlayRunLedgerSnapshot,
+} from '@shared_libs/play-runtime/run-ledger';
+import type {
+  ComputeBillingItem,
+  PlayStagedFileRef,
+  PlayVisualNodeProgressMap,
+} from '@shared_libs/play-runtime/worker-api-types';
+import type { RuntimeStepReceipt } from '@shared_libs/play-runtime/ctx-types';
+import type {
+  CreateDbSessionRequest,
+  CreateDbSessionResponse,
+} from '@shared_libs/play-runtime/db-session';
+import type { PlayBundleArtifact } from '@shared_libs/plays/artifact-types';
+
+export type StoredPlayArtifactPayload = {
+  sourceCode: string;
+  codeFormat: 'function' | 'cjs_module' | 'esm_module';
+  artifact: PlayBundleArtifact;
+};
+
+export type RuntimeStatusUpdate = {
+  playId: string;
+  status: string;
+  error?: string;
+  runtimeBackend?: string | null;
+  artifactHash?: string | null;
+  graphHash?: string | null;
+  waitKind?: string | null;
+  waitUntil?: number | null;
+  activeBoundaryId?: string | null;
+  lastCheckpointAt?: number | null;
+  liveLogs?: string[];
+  /**
+   * Monotonic count of log lines the producer ever emitted on this run's
+   * channel. `liveLogs` is a rotating tail of those lines; the total lets the
+   * positional cursor stay correct once the buffer has rotated.
+   */
+  liveLogTotalCount?: number;
+  /**
+   * Explicit terminal-output replay for final runner logs when the caller must
+   * keep `status` nonterminal. Hatchet/Postgres progress finalizers do this so
+   * scheduler projection remains the only terminal run writer, while the Run
+   * Log Stream still gets terminal transport recovery semantics.
+   */
+  terminalLogReplay?: {
+    lines: string[];
+    totalCount?: number;
+  } | null;
+  liveTimeline?: PlayRunTimelineEntry[];
+  liveNodeProgress?: PlayVisualNodeProgressMap;
+  result?: Record<string, unknown> | null;
+};
+
+export type RuntimeSaveResults = {
+  playId: string;
+  result: {
+    success: boolean;
+    error?: string;
+    publicResult?: Record<string, unknown> | null;
+    maxCreditsPerRun?: number | null;
+    temporalActionEstimate?: {
+      totalActions?: number;
+      [key: string]: unknown;
+    } | null;
+  };
+  userId?: string | null;
+};
+
+type RuntimeApiRequest =
+  | {
+      action: 'create_signed_artifact_url';
+      storageKey: string;
+    }
+  | {
+      action: 'create_signed_staged_file_url';
+      file: Pick<PlayStagedFileRef, 'storageKey'>;
+    }
+  | ({
+      action: 'create_db_session';
+    } & CreateDbSessionRequest)
+  | {
+      action: 'append_run_events';
+      playId: string;
+      events: PlayRunLedgerEvent[];
+    }
+  | {
+      action: 'start_inline_child_run';
+      playName: string;
+      runId: string;
+      workflowFamilyKey?: string | null;
+      artifactStorageKey?: string | null;
+      artifactHash?: string | null;
+      graphHash?: string | null;
+      runtimeBackend?: string | null;
+      schedulerBackend?: string | null;
+      schedulerSchema?: string | null;
+      executionProfile?: string | null;
+      maxCreditsPerRun?: number | null;
+      staticPipeline?: unknown;
+      source?: 'published' | 'ad_hoc' | 'draft';
+      activeRunLimit?: number | null;
+    }
+  | ({
+      action: 'save_results';
+    } & RuntimeSaveResults)
+  | {
+      action: 'apply_row_updates';
+      playName: string;
+      tableNamespace: string;
+      sheetContract: PlaySheetContract;
+      runId: string;
+      userEmail: string;
+      updates: Array<Omit<PlayRowUpdate, 'rowId'> & { runId?: string }>;
+    }
+  | {
+      action: 'compute_billing_upsert';
+      sessionId: string;
+      orgId: string;
+      userId?: string | null;
+      operation: string;
+      workflowId?: string;
+      runId?: string;
+    }
+  | {
+      action: 'compute_billing_record_item';
+      sessionId: string;
+      orgId: string;
+      userId?: string | null;
+      operation: string;
+      item: ComputeBillingItem;
+    }
+  | {
+      action: 'compute_billing_finalize';
+      sessionId: string;
+      orgId: string;
+      userId?: string | null;
+      operation: string;
+      status: 'completed' | 'error';
+      workflowId?: string;
+      runId?: string;
+      maxCreditsPerRun?: number | null;
+      finalItem: ComputeBillingItem;
+    }
+  | {
+      action: 'get_runtime_step_receipt';
+      playName: string;
+      runId: string;
+      key: string;
+    }
+  | {
+      action: 'claim_runtime_step_receipt';
+      playName: string;
+      runId: string;
+      key: string;
+      reclaimRunning?: boolean;
+    }
+  | {
+      action: 'complete_runtime_step_receipt';
+      playName: string;
+      runId: string;
+      key: string;
+      output: unknown;
+    }
+  | {
+      action: 'fail_runtime_step_receipt';
+      playName: string;
+      runId: string;
+      key: string;
+      error: string;
+    }
+  | {
+      action: 'skip_runtime_step_receipt';
+      playName: string;
+      runId: string;
+      key: string;
+      output?: unknown;
+    };
+
+export type WorkerRuntimeApiContext = {
+  baseUrl: string;
+  executorToken: string;
+  vercelProtectionBypassToken?: string | null;
+  fetch?: typeof fetch;
+};
+
+const APP_RUNTIME_API_RETRY_DELAYS_MS = [100, 250, 500, 1_000] as const;
+const APP_RUNTIME_API_APPEND_RETRY_DELAYS_MS = [
+  100, 250, 500, 1_000, 2_000, 4_000, 8_000,
+] as const;
+const RUN_STATUS_LEDGER_SNAPSHOT_CACHE_LIMIT = 1_000;
+const runStatusLedgerSnapshots = new Map<string, PlayRunLedgerSnapshot>();
+// Positional log cursor per run: count of liveLogs lines already forwarded to
+// the ledger from this process. Process-local on purpose — a fresh process
+// re-sends from offset 0 and Run Log Stream ingestion skips the overlap
+// positionally (exactly-once on the channel, repeated identical lines kept).
+const runLogChannelSentCounts = new Map<string, number>();
+const runStatusUpdateChains = new Map<string, Promise<void>>();
+const vercelProtectionCookieCache = new Map<string, Promise<string | null>>();
+
+function isTerminalRuntimeStatus(status: string): boolean {
+  return (
+    status === 'completed' ||
+    status === 'failed' ||
+    status === 'cancelled' ||
+    status === 'terminated' ||
+    status === 'timed_out'
+  );
+}
+
+function rememberRunStatusLedgerSnapshot(
+  runId: string,
+  snapshot: PlayRunLedgerSnapshot,
+) {
+  runStatusLedgerSnapshots.delete(runId);
+  runStatusLedgerSnapshots.set(runId, snapshot);
+  while (
+    runStatusLedgerSnapshots.size > RUN_STATUS_LEDGER_SNAPSHOT_CACHE_LIMIT
+  ) {
+    const oldestRunId = runStatusLedgerSnapshots.keys().next().value;
+    if (!oldestRunId) break;
+    runStatusLedgerSnapshots.delete(oldestRunId);
+    runLogChannelSentCounts.delete(oldestRunId);
+    runStatusUpdateChains.delete(oldestRunId);
+  }
+}
+
+function isRetryableAppRuntimeResponse(input: {
+  action: RuntimeApiRequest['action'];
+  status: number;
+  body: string;
+}): boolean {
+  if (!isRetryableAppRuntimeAction(input.action)) {
+    return false;
+  }
+  if (
+    input.action === 'append_run_events' &&
+    input.status === 500 &&
+    /Play run .+ not found/i.test(input.body)
+  ) {
+    return true;
+  }
+  if (input.status === 500 && isTransientAppRuntimeFailureBody(input.body)) {
+    return true;
+  }
+  return (
+    input.status === 429 ||
+    input.status === 502 ||
+    input.status === 503 ||
+    input.status === 504
+  );
+}
+
+function isTransientAppRuntimeFailureBody(body: string): boolean {
+  return /WorkerOverloaded|"\s*code\s*"\s*:\s*"\s*InternalServerError\s*"|Your request couldn't be completed\. Try again later\.|timeout exceeded when trying to connect|timed out|fetch failed|ECONNRESET|ECONNREFUSED|UND_ERR_CONNECT_TIMEOUT/i.test(
+    body,
+  );
+}
+
+function isRetryableAppRuntimeFetchError(input: {
+  action: RuntimeApiRequest['action'];
+  error: unknown;
+}): boolean {
+  if (!isRetryableAppRuntimeAction(input.action)) {
+    return false;
+  }
+  const message =
+    input.error instanceof Error ? input.error.message : String(input.error);
+  return /fetch failed|connection (terminated|timeout|timed out|closed|reset)|econnreset|etimedout|econnrefused/i.test(
+    message,
+  );
+}
+
+function isRetryableAppRuntimeAction(
+  action: RuntimeApiRequest['action'],
+): boolean {
+  return (
+    action === 'append_run_events' ||
+    action === 'create_db_session' ||
+    action === 'create_signed_artifact_url' ||
+    action === 'create_signed_staged_file_url'
+  );
+}
+
+function appRuntimeRetryDelaysForAction(
+  action: RuntimeApiRequest['action'],
+): readonly number[] {
+  return action === 'append_run_events'
+    ? APP_RUNTIME_API_APPEND_RETRY_DELAYS_MS
+    : APP_RUNTIME_API_RETRY_DELAYS_MS;
+}
+
+function appRuntimeMaxAttempts(action: RuntimeApiRequest['action']): number {
+  return appRuntimeRetryDelaysForAction(action).length + 1;
+}
+
+function appRuntimeRetryDelayMs(
+  action: RuntimeApiRequest['action'],
+  attempt: number,
+): number {
+  return appRuntimeRetryDelaysForAction(action)[attempt - 1] ?? 1_000;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function resolveAppRuntimeApiUrl(context: WorkerRuntimeApiContext): string {
+  const baseUrl = context.baseUrl.trim().replace(/\/$/, '');
+  const url = new URL(`${baseUrl}/api/v2/plays/internal/runtime`);
+  const bypassToken = context.vercelProtectionBypassToken?.trim();
+  if (bypassToken) {
+    url.searchParams.set('x-vercel-set-bypass-cookie', 'true');
+    url.searchParams.set('x-vercel-protection-bypass', bypassToken);
+  }
+  return url.toString();
+}
+
+function setCookieHeaders(headers: Headers): string[] {
+  const getter = (headers as Headers & { getSetCookie?: () => string[] })
+    .getSetCookie;
+  if (typeof getter === 'function') {
+    return getter.call(headers);
+  }
+  const single = headers.get('set-cookie');
+  return single ? [single] : [];
+}
+
+function cookieHeaderFromSetCookie(headers: Headers): string | null {
+  const cookies = setCookieHeaders(headers)
+    .flatMap((header) => header.split(/,(?=\s*[^;,=]+=[^;,]+)/g))
+    .map((header) => header.split(';', 1)[0]?.trim() ?? '')
+    .filter(Boolean);
+  return cookies.length > 0 ? cookies.join('; ') : null;
+}
+
+function resolveVercelProtectionCookie(
+  context: WorkerRuntimeApiContext,
+): Promise<string | null> {
+  const bypassToken = context.vercelProtectionBypassToken?.trim();
+  if (!bypassToken) return Promise.resolve(null);
+
+  const baseUrl = context.baseUrl.trim().replace(/\/$/, '');
+  const cacheKey = `${baseUrl}\n${bypassToken}`;
+  const cached = vercelProtectionCookieCache.get(cacheKey);
+  if (cached) return cached;
+
+  const promise = (async () => {
+    const url = new URL(`${baseUrl}/api/v2/health`);
+    url.searchParams.set('x-vercel-set-bypass-cookie', 'true');
+    url.searchParams.set('x-vercel-protection-bypass', bypassToken);
+    const runtimeFetch = context.fetch ?? fetch;
+    const response = await runtimeFetch(url.toString(), {
+      headers: { 'x-vercel-protection-bypass': bypassToken },
+    }).catch(() => null);
+    return response ? cookieHeaderFromSetCookie(response.headers) : null;
+  })();
+  vercelProtectionCookieCache.set(cacheKey, promise);
+  return promise;
+}
+
+async function postAppRuntimeApi<TResponse>(
+  context: WorkerRuntimeApiContext,
+  body: RuntimeApiRequest,
+): Promise<TResponse> {
+  const baseUrl = context.baseUrl.trim().replace(/\/$/, '');
+  const token = context.executorToken.trim();
+  if (!baseUrl) {
+    throw new Error('Worker runtime API requires baseUrl.');
+  }
+  if (!token) {
+    throw new Error('Worker runtime API requires executorToken.');
+  }
+  const vercelProtectionCookie = await resolveVercelProtectionCookie(context);
+
+  const maxAttempts = appRuntimeMaxAttempts(body.action);
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    let response: Response;
+    try {
+      const runtimeFetch = context.fetch ?? fetch;
+      response = await runtimeFetch(resolveAppRuntimeApiUrl(context), {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          authorization: `Bearer ${token}`,
+          ...(context.vercelProtectionBypassToken?.trim()
+            ? {
+                'x-vercel-protection-bypass':
+                  context.vercelProtectionBypassToken.trim(),
+              }
+            : {}),
+          ...(vercelProtectionCookie ? { cookie: vercelProtectionCookie } : {}),
+        },
+        body: JSON.stringify(body),
+      });
+    } catch (error) {
+      if (
+        attempt < maxAttempts &&
+        isRetryableAppRuntimeFetchError({ action: body.action, error })
+      ) {
+        await sleep(appRuntimeRetryDelayMs(body.action, attempt));
+        continue;
+      }
+      throw error;
+    }
+    if (response.ok) {
+      return (await response.json()) as TResponse;
+    }
+    const responseText = await response.text();
+    if (
+      attempt < maxAttempts &&
+      isRetryableAppRuntimeResponse({
+        action: body.action,
+        status: response.status,
+        body: responseText,
+      })
+    ) {
+      await sleep(appRuntimeRetryDelayMs(body.action, attempt));
+      continue;
+    }
+    throw new Error(
+      `App runtime API ${body.action} failed with status ${response.status}: ${responseText}`,
+    );
+  }
+
+  throw new Error(`App runtime API ${body.action} failed after retries.`);
+}
+
+type SignedR2ReadUrlResponse = {
+  url: string;
+  storageKey: string;
+  expiresAt: string;
+};
+
+function logSignedR2FetchPerf(input: {
+  kind: 'artifact' | 'staged_file';
+  storageKey: string;
+  startedAt: number;
+  bytes: number;
+}) {
+  console.info('[perf][worker.r2.signed_fetch]', {
+    kind: input.kind,
+    storageKey: input.storageKey,
+    bytes: input.bytes,
+    ms: Date.now() - input.startedAt,
+  });
+}
+
+async function fetchSignedR2Buffer(input: {
+  kind: 'artifact' | 'staged_file';
+  signed: SignedR2ReadUrlResponse;
+}): Promise<Buffer> {
+  const startedAt = Date.now();
+  const response = await fetch(input.signed.url);
+  if (!response.ok) {
+    throw new Error(
+      `Signed R2 ${input.kind} fetch failed for ${input.signed.storageKey} with status ${response.status}: ${await response.text()}`,
+    );
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  logSignedR2FetchPerf({
+    kind: input.kind,
+    storageKey: input.signed.storageKey,
+    startedAt,
+    bytes: buffer.byteLength,
+  });
+  return buffer;
+}
+
+async function fetchSignedR2ToFile(input: {
+  kind: 'staged_file';
+  signed: SignedR2ReadUrlResponse;
+  targetPath: string;
+}): Promise<void> {
+  const startedAt = Date.now();
+  const response = await fetch(input.signed.url);
+  if (!response.ok) {
+    throw new Error(
+      `Signed R2 ${input.kind} fetch failed for ${input.signed.storageKey} with status ${response.status}: ${await response.text()}`,
+    );
+  }
+  if (!response.body) {
+    throw new Error(
+      `Signed R2 ${input.kind} fetch returned an empty response body for ${input.signed.storageKey}.`,
+    );
+  }
+  await pipeline(
+    Readable.fromWeb(response.body as Parameters<typeof Readable.fromWeb>[0]),
+    createWriteStream(input.targetPath),
+  );
+  const written = await stat(input.targetPath);
+  logSignedR2FetchPerf({
+    kind: input.kind,
+    storageKey: input.signed.storageKey,
+    startedAt,
+    bytes: written.size,
+  });
+}
+
+export async function loadArtifactFromAppRuntime(
+  context: WorkerRuntimeApiContext,
+  storageKey: string,
+): Promise<StoredPlayArtifactPayload> {
+  const signed = await postAppRuntimeApi<SignedR2ReadUrlResponse>(context, {
+    action: 'create_signed_artifact_url',
+    storageKey,
+  });
+  const buffer = await fetchSignedR2Buffer({
+    kind: 'artifact',
+    signed,
+  });
+  return JSON.parse(buffer.toString('utf-8')) as StoredPlayArtifactPayload;
+}
+
+export async function loadStagedFileFromAppRuntime(
+  context: WorkerRuntimeApiContext,
+  file: Pick<PlayStagedFileRef, 'storageKey'>,
+): Promise<Buffer> {
+  const signed = await postAppRuntimeApi<SignedR2ReadUrlResponse>(context, {
+    action: 'create_signed_staged_file_url',
+    file,
+  });
+  return fetchSignedR2Buffer({
+    kind: 'staged_file',
+    signed,
+  });
+}
+
+export async function createSignedStagedFileReadUrl(
+  context: WorkerRuntimeApiContext,
+  file: Pick<PlayStagedFileRef, 'storageKey'>,
+): Promise<SignedR2ReadUrlResponse> {
+  return await postAppRuntimeApi<SignedR2ReadUrlResponse>(context, {
+    action: 'create_signed_staged_file_url',
+    file,
+  });
+}
+
+export async function writeStagedFileFromAppRuntime(
+  context: WorkerRuntimeApiContext,
+  file: Pick<PlayStagedFileRef, 'storageKey'>,
+  targetPath: string,
+): Promise<void> {
+  const signed = await postAppRuntimeApi<SignedR2ReadUrlResponse>(context, {
+    action: 'create_signed_staged_file_url',
+    file,
+  });
+  await fetchSignedR2ToFile({
+    kind: 'staged_file',
+    signed,
+    targetPath,
+  });
+}
+
+export async function updateRunStatusViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  update: RuntimeStatusUpdate,
+): Promise<void> {
+  const previous =
+    runStatusUpdateChains.get(update.playId) ?? Promise.resolve();
+  const queued = previous
+    .catch(() => {})
+    .then(() => updateRunStatusViaAppRuntimeUnlocked(context, update));
+  const tracked = queued.finally(() => {
+    if (runStatusUpdateChains.get(update.playId) === tracked) {
+      runStatusUpdateChains.delete(update.playId);
+    }
+  });
+  runStatusUpdateChains.set(update.playId, tracked);
+  await tracked;
+}
+
+async function updateRunStatusViaAppRuntimeUnlocked(
+  context: WorkerRuntimeApiContext,
+  update: RuntimeStatusUpdate,
+): Promise<void> {
+  const previousSnapshot =
+    runStatusLedgerSnapshots.get(update.playId) ??
+    createEmptyPlayRunLedgerSnapshot({
+      runId: update.playId,
+      status: 'queued',
+    });
+  // Positional cursor over this producer's log buffer. Running updates forward
+  // only the unsent suffix; terminal updates resend the retained buffer so the
+  // durable stream can recover any progress flush that was lost in transit.
+  const sentCount = isTerminalRuntimeStatus(update.status)
+    ? 0
+    : (runLogChannelSentCounts.get(update.playId) ?? 0);
+  const logSlice = Array.isArray(update.liveLogs)
+    ? slicePositionalLogLines({
+        bufferLines: update.liveLogs,
+        bufferTotalCount: update.liveLogTotalCount ?? update.liveLogs.length,
+        sentCount,
+      })
+    : null;
+  const terminalLogReplay =
+    update.terminalLogReplay && update.terminalLogReplay.lines.length > 0
+      ? update.terminalLogReplay
+      : isTerminalRuntimeStatus(update.status) && Array.isArray(update.liveLogs)
+        ? {
+            lines: update.liveLogs,
+            totalCount: update.liveLogTotalCount,
+          }
+        : null;
+  const statusPatchLogSlice = terminalLogReplay ? null : logSlice;
+  const events = buildPlayRunLedgerEventsFromStatusPatch({
+    patch: {
+      runId: update.playId,
+      status: update.status,
+      error: update.error ?? null,
+      runtimeBackend: update.runtimeBackend ?? null,
+      lastCheckpointAt: update.lastCheckpointAt ?? null,
+      liveLogs: statusPatchLogSlice?.lines ?? null,
+      liveLogsChannelOffset: statusPatchLogSlice?.channelOffset ?? null,
+      liveNodeProgress: update.liveNodeProgress ?? null,
+      result: update.result,
+    },
+    previousSnapshot,
+    now: update.lastCheckpointAt ?? Date.now(),
+    source: 'temporal',
+  });
+  if (terminalLogReplay && terminalLogReplay.lines.length > 0) {
+    events.push(
+      ...buildTerminalLogReplayEvents({
+        runId: update.playId,
+        source: 'temporal',
+        occurredAt: update.lastCheckpointAt ?? Date.now(),
+        lines: terminalLogReplay.lines,
+        liveLogTotalCount: terminalLogReplay.totalCount,
+      }),
+    );
+  }
+  if (events.length === 0) {
+    return;
+  }
+  await appendRunEventsViaAppRuntime(context, {
+    playId: update.playId,
+    events,
+  });
+  if (statusPatchLogSlice) {
+    runLogChannelSentCounts.set(
+      update.playId,
+      statusPatchLogSlice.channelOffset + statusPatchLogSlice.lines.length,
+    );
+  }
+  rememberRunStatusLedgerSnapshot(
+    update.playId,
+    reducePlayRunLedgerEvents(previousSnapshot, events),
+  );
+}
+
+export async function appendRunEventsViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: { playId: string; events: PlayRunLedgerEvent[] },
+): Promise<void> {
+  await postAppRuntimeApi<{ ok: true }>(context, {
+    action: 'append_run_events',
+    ...input,
+  });
+}
+
+export async function startRunViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: {
+    playName: string;
+    runId: string;
+    workflowFamilyKey?: string | null;
+    artifactStorageKey?: string | null;
+    artifactHash?: string | null;
+    graphHash?: string | null;
+    runtimeBackend?: string | null;
+    schedulerBackend?: string | null;
+    schedulerSchema?: string | null;
+    executionProfile?: string | null;
+    maxCreditsPerRun?: number | null;
+    staticPipeline?: unknown;
+    source?: 'published' | 'ad_hoc' | 'draft';
+    activeRunLimit?: number | null;
+  },
+): Promise<void> {
+  await postAppRuntimeApi<{ ok: true }>(context, {
+    action: 'start_inline_child_run',
+    ...input,
+  });
+}
+
+export async function saveResultsViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: RuntimeSaveResults,
+): Promise<void> {
+  await postAppRuntimeApi<{ ok: true }>(context, {
+    action: 'save_results',
+    ...input,
+  });
+}
+
+export async function applyRowUpdatesViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Extract<
+    RuntimeApiRequest,
+    { action: 'apply_row_updates' }
+  > extends infer T
+    ? Omit<T & { action: 'apply_row_updates' }, 'action'>
+    : never,
+): Promise<void> {
+  await postAppRuntimeApi<{ ok: true }>(context, {
+    action: 'apply_row_updates',
+    ...input,
+  });
+}
+
+export async function createDbSessionViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: CreateDbSessionRequest,
+): Promise<CreateDbSessionResponse> {
+  return await postAppRuntimeApi<CreateDbSessionResponse>(context, {
+    action: 'create_db_session',
+    ...input,
+  });
+}
+
+export async function upsertComputeBillingSessionViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'compute_billing_upsert' }>,
+    'action'
+  >,
+): Promise<void> {
+  await postAppRuntimeApi<{ ok: true }>(context, {
+    action: 'compute_billing_upsert',
+    ...input,
+  });
+}
+
+export async function recordComputeBillingItemViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'compute_billing_record_item' }>,
+    'action'
+  >,
+): Promise<void> {
+  await postAppRuntimeApi<{ ok: true }>(context, {
+    action: 'compute_billing_record_item',
+    ...input,
+  });
+}
+
+export async function finalizeComputeBillingSessionViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'compute_billing_finalize' }>,
+    'action'
+  >,
+): Promise<void> {
+  await postAppRuntimeApi<{ ok: true }>(context, {
+    action: 'compute_billing_finalize',
+    ...input,
+  });
+}
+
+export async function getRuntimeStepReceiptViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'get_runtime_step_receipt' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt | null> {
+  return await postAppRuntimeApi<RuntimeStepReceipt | null>(context, {
+    action: 'get_runtime_step_receipt',
+    ...input,
+  });
+}
+
+export async function claimRuntimeStepReceiptViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'claim_runtime_step_receipt' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt | null> {
+  return await postAppRuntimeApi<RuntimeStepReceipt | null>(context, {
+    action: 'claim_runtime_step_receipt',
+    ...input,
+  });
+}
+
+export async function completeRuntimeStepReceiptViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'complete_runtime_step_receipt' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt | null> {
+  return await postAppRuntimeApi<RuntimeStepReceipt | null>(context, {
+    action: 'complete_runtime_step_receipt',
+    ...input,
+  });
+}
+
+export async function failRuntimeStepReceiptViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'fail_runtime_step_receipt' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt | null> {
+  return await postAppRuntimeApi<RuntimeStepReceipt | null>(context, {
+    action: 'fail_runtime_step_receipt',
+    ...input,
+  });
+}
+
+export async function skipRuntimeStepReceiptViaAppRuntime(
+  context: WorkerRuntimeApiContext,
+  input: Omit<
+    Extract<RuntimeApiRequest, { action: 'skip_runtime_step_receipt' }>,
+    'action'
+  >,
+): Promise<RuntimeStepReceipt | null> {
+  return await postAppRuntimeApi<RuntimeStepReceipt | null>(context, {
+    action: 'skip_runtime_step_receipt',
+    ...input,
+  });
+}