deepline 0.1.227 → 0.1.229

package/dist/bundling-sources/apps/play-runner-workers/src/child-manifest-resolver.ts

@@ -1,108 +0,0 @@
-import type {
-  PlayRuntimeManifest,
-  PlayRuntimeManifestMap,
-} from '../../../shared_libs/plays/compiler-manifest';
-import { createSingleFlight } from '../../../shared_libs/play-runtime/single-flight';
-
-type ChildManifestResolverInput = {
-  preloaded?: PlayRuntimeManifestMap | null;
-  resolveManifest: (playRef: string) => Promise<PlayRuntimeManifest | null>;
-};
-
-type ChildManifestResolutionState = {
-  resolved: Map<string, PlayRuntimeManifest>;
-  flights: ReturnType<
-    typeof createSingleFlight<string, PlayRuntimeManifest | null>
-  >;
-  lastAccessedAt: number;
-};
-
-const RUN_RESOLUTION_CACHE_TTL_MS = 10 * 60_000;
-const RUN_RESOLUTION_CACHE_MAX_ENTRIES = 128;
-const runResolutionStates = new Map<string, ChildManifestResolutionState>();
-
-function seedPreloadedManifests(
-  resolved: Map<string, PlayRuntimeManifest>,
-  preloaded?: PlayRuntimeManifestMap | null,
-): void {
-  for (const [playRef, manifest] of Object.entries(preloaded ?? {})) {
-    resolved.set(playRef, manifest);
-  }
-}
-
-function createResolutionState(
-  preloaded?: PlayRuntimeManifestMap | null,
-): ChildManifestResolutionState {
-  const resolved = new Map<string, PlayRuntimeManifest>(
-    Object.entries(preloaded ?? {}),
-  );
-  return {
-    resolved,
-    flights: createSingleFlight<string, PlayRuntimeManifest | null>(),
-    lastAccessedAt: Date.now(),
-  };
-}
-
-function resolveWithState(
-  state: ChildManifestResolutionState,
-  input: ChildManifestResolverInput,
-  playRef: string,
-): Promise<PlayRuntimeManifest | null> {
-  state.lastAccessedAt = Date.now();
-  seedPreloadedManifests(state.resolved, input.preloaded);
-  const cached = state.resolved.get(playRef);
-  if (cached) return Promise.resolve(cached);
-
-  return state.flights.run(playRef, async () => {
-    const cachedAfterAdmission = state.resolved.get(playRef);
-    if (cachedAfterAdmission) return cachedAfterAdmission;
-
-    const manifest = await input.resolveManifest(playRef);
-    if (manifest) state.resolved.set(playRef, manifest);
-    return manifest;
-  });
-}
-
-function pruneRunResolutionStates(now: number): void {
-  for (const [scopeKey, state] of runResolutionStates) {
-    if (
-      state.flights.activeCount() === 0 &&
-      now - state.lastAccessedAt >= RUN_RESOLUTION_CACHE_TTL_MS
-    ) {
-      runResolutionStates.delete(scopeKey);
-    }
-  }
-  if (runResolutionStates.size <= RUN_RESOLUTION_CACHE_MAX_ENTRIES) return;
-
-  const evictable = [...runResolutionStates.entries()]
-    .filter(([, state]) => state.flights.activeCount() === 0)
-    .sort((a, b) => a[1].lastAccessedAt - b[1].lastAccessedAt);
-  for (const [scopeKey] of evictable) {
-    if (runResolutionStates.size <= RUN_RESOLUTION_CACHE_MAX_ENTRIES) break;
-    runResolutionStates.delete(scopeKey);
-  }
-}
-
-export function createChildManifestResolver(
-  input: ChildManifestResolverInput,
-): (playRef: string) => Promise<PlayRuntimeManifest | null> {
-  const state = createResolutionState(input.preloaded);
-
-  return (playRef) => resolveWithState(state, input, playRef);
-}
-
-export function createRunScopedChildManifestResolver(
-  input: ChildManifestResolverInput & { scopeKey: string },
-): (playRef: string) => Promise<PlayRuntimeManifest | null> {
-  const now = Date.now();
-  pruneRunResolutionStates(now);
-  let state = runResolutionStates.get(input.scopeKey);
-  if (!state) {
-    state = createResolutionState(input.preloaded);
-    runResolutionStates.set(input.scopeKey, state);
-    pruneRunResolutionStates(now);
-  }
-  state.lastAccessedAt = now;
-
-  return (playRef) => resolveWithState(state, input, playRef);
-}

package/dist/bundling-sources/apps/play-runner-workers/src/child-play-await.ts

@@ -1,374 +0,0 @@
-/**
- * Child-play terminal await — the race between a Cloudflare Workflow
- * `waitForEvent('child_play_terminal:...')` and a coordinator terminal-state
- * poll, extracted from entry.ts so the runtime keeps a small, testable surface
- * for "block until this child run reaches a terminal state".
- *
- * Behavior is identical to the inline implementation it replaces: arm the
- * workflow event wait, race it against `pollParentChildTerminalState`, and
- * resolve on whichever reports the child's terminal status first. The poll
- * never resolves on a non-terminal/absent state (it returns a never-settling
- * promise on timeout) so the event wait remains the primary path and the poll
- * is a coordinator-side safety net for missed signals.
- */
-
-import { isRetryableWorkerRuntimeApiError } from './runtime-api-retry';
-
-export type WorkflowStepLike = {
-  waitForEvent: (
-    name: string,
-    options: { type: string; timeout: string },
-  ) => Promise<{ payload: unknown }>;
-};
-
-export type ChildTerminalCoordinator = {
-  readChildTerminalState?(
-    parentRunId: string,
-    eventKey: string,
-    timeoutMs?: number,
-  ): Promise<{ data?: unknown } | null>;
-  readRunTerminalState(
-    runId: string,
-    timeoutMs?: number,
-  ): Promise<ChildRunTerminalSnapshotState | null>;
-};
-
-export type ChildPlayTerminalWaitResult = {
-  output: unknown;
-  source: 'workflow_event' | 'parent_child_terminal_cache';
-  attempts?: number;
-  waitMs: number;
-};
-
-export type ChildRunTerminalSnapshotState = {
-  data?: unknown;
-  reason?: string;
-  status?: string;
-  runId?: string;
-  playName?: string;
-  parentRunId?: string | null;
-};
-
-export class ChildPlayTerminalVerificationError extends Error {
-  readonly parentRunId: string;
-  readonly eventKey: string;
-  readonly cause: unknown;
-
-  constructor(input: {
-    parentRunId: string;
-    eventKey: string;
-    cause: unknown;
-  }) {
-    const causeMessage =
-      input.cause instanceof Error
-        ? input.cause.message
-        : String(input.cause ?? '');
-    super(
-      `Child play terminal verification failed for parent run ${input.parentRunId} and event ${input.eventKey}.${
-        causeMessage ? ` Cause: ${causeMessage}` : ''
-      }`,
-    );
-    this.name = 'ChildPlayTerminalVerificationError';
-    this.parentRunId = input.parentRunId;
-    this.eventKey = input.eventKey;
-    this.cause = input.cause;
-  }
-}
-
-const CHILD_TERMINAL_DURABLE_VERIFY_GRACE_MS = 5_000;
-const CHILD_TERMINAL_DURABLE_VERIFY_POLL_MS = 250;
-const CHILD_TERMINAL_DURABLE_VERIFY_READ_TIMEOUT_MS = 3_000;
-const CHILD_TERMINAL_DURABLE_VERIFY_MIN_READ_TIMEOUT_MS = 2_000;
-
-export interface AwaitChildTerminalInput {
-  parentRunId: string;
-  workflowStep: WorkflowStepLike | undefined;
-  workflowId: string;
-  playName: string;
-  key: string;
-  timeoutMs: number;
-  /** Coordinator binding for the terminal-state poll and durable run verification. */
-  coordinator: ChildTerminalCoordinator | null;
-  now: () => number;
-  /** SHA-256 hex digest helper (same canonical hash entry.ts uses). */
-  hashJson: (value: unknown) => Promise<string>;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function workflowEventType(name: string): string {
-  const normalized = name
-    .trim()
-    .replace(/[^A-Za-z0-9_-]+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    .slice(0, 100);
-  return normalized || 'deepline_event';
-}
-
-function integrationEventType(eventKey: string): string {
-  return workflowEventType(`integration_event_${eventKey}`);
-}
-
-function workflowTimeoutFromMs(timeoutMs: number): string {
-  const seconds = Math.max(1, Math.ceil(timeoutMs / 1000));
-  return `${seconds} second${seconds === 1 ? '' : 's'}`;
-}
-
-function readChildTerminalPayload(value: unknown): Record<string, unknown> {
-  if (!isRecord(value)) return {};
-  const data = value.data;
-  return isRecord(data) ? data : value;
-}
-
-function extractChildPlayOutput(status: Record<string, unknown>): unknown {
-  const result = status.result;
-  if (isRecord(result) && 'output' in result) {
-    return result.output;
-  }
-  return result ?? null;
-}
-
-function terminalPayloadFromState(
-  state: { data?: unknown } | null | undefined,
-): Record<string, unknown> | null {
-  return isRecord(state?.data) ? state.data : null;
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function childPlayEventKey(input: {
-  key: string;
-  workflowId: string;
-  hashJson: (value: unknown) => Promise<string>;
-}): Promise<string> {
-  const readableKey = workflowEventType(input.key).slice(0, 40);
-  const digest = (
-    await input.hashJson({ key: input.key, workflowId: input.workflowId })
-  ).slice(0, 32);
-  return `child_play_${digest}_${readableKey}`;
-}
-
-async function pollParentChildTerminalState(input: {
-  coordinator: ChildTerminalCoordinator | null;
-  parentRunId: string;
-  eventKey: string;
-  timeoutMs: number;
-  now: () => number;
-}): Promise<{
-  source: 'parent_child_terminal_cache';
-  payload: Record<string, unknown>;
-  attempts: number;
-}> {
-  const { coordinator, parentRunId } = input;
-  if (!coordinator?.readChildTerminalState || !parentRunId) {
-    return await new Promise(() => undefined);
-  }
-  const startedAt = input.now();
-  let attempts = 0;
-  while (input.now() - startedAt < input.timeoutMs) {
-    attempts += 1;
-    const remainingMs = Math.max(
-      0,
-      input.timeoutMs - (input.now() - startedAt),
-    );
-    const waitMs = Math.min(remainingMs, 30_000);
-    let state: { data?: unknown } | null;
-    try {
-      // prettier-ignore
-      state = await coordinator.readChildTerminalState(parentRunId, input.eventKey, waitMs);
-    } catch {
-      // The parent-child cache is a safety net for missed workflow events.
-      // Transient cache read failures must not beat the event wait plus durable
-      // child run verification path in the race.
-      if (remainingMs > 0) {
-        await sleep(Math.min(remainingMs, CHILD_TERMINAL_DURABLE_VERIFY_POLL_MS));
-      }
-      continue;
-    }
-    if (isRecord(state?.data)) {
-      return {
-        source: 'parent_child_terminal_cache',
-        payload: state.data,
-        attempts,
-      };
-    }
-  }
-  return await new Promise(() => undefined);
-}
-
-async function readVerifiedChildTerminalPayload(input: {
-  coordinator: ChildTerminalCoordinator;
-  workflowId: string;
-  timeoutMs: number;
-}): Promise<{
-  payload: Record<string, unknown> | null;
-  lastState: ChildRunTerminalSnapshotState | null;
-  lastError: unknown;
-}> {
-  const graceMs = Math.max(
-    1,
-    Math.min(input.timeoutMs, CHILD_TERMINAL_DURABLE_VERIFY_GRACE_MS),
-  );
-  const pollMs = Math.max(
-    1,
-    Math.min(
-      CHILD_TERMINAL_DURABLE_VERIFY_POLL_MS,
-      Math.max(1, Math.floor(graceMs / 2)),
-    ),
-  );
-  const deadlineMs = Date.now() + graceMs;
-  let lastState: ChildRunTerminalSnapshotState | null = null;
-  let lastError: unknown = null;
-  const minReadTimeoutMs =
-    graceMs >= CHILD_TERMINAL_DURABLE_VERIFY_MIN_READ_TIMEOUT_MS
-      ? CHILD_TERMINAL_DURABLE_VERIFY_MIN_READ_TIMEOUT_MS
-      : 1;
-  while (Date.now() <= deadlineMs) {
-    const remainingMs = Math.max(0, deadlineMs - Date.now());
-    if (remainingMs < minReadTimeoutMs) break;
-    const readTimeoutMs = Math.max(
-      minReadTimeoutMs,
-      Math.min(remainingMs, CHILD_TERMINAL_DURABLE_VERIFY_READ_TIMEOUT_MS),
-    );
-    try {
-      const state = await input.coordinator.readRunTerminalState(
-        input.workflowId,
-        readTimeoutMs,
-      );
-      lastState = state ?? null;
-      const payload = terminalPayloadFromState(state);
-      if (payload) return { payload, lastState, lastError };
-    } catch (error) {
-      lastError = error;
-      if (!isRetryableWorkerRuntimeApiError(error)) {
-        throw error;
-      }
-    }
-    const sleepMs = Math.min(
-      pollMs,
-      Math.max(0, deadlineMs - Date.now() - minReadTimeoutMs),
-    );
-    if (sleepMs <= 0) break;
-    await sleep(sleepMs);
-  }
-  return { payload: null, lastState, lastError };
-}
-
-function describeSnapshotState(
-  state: ChildRunTerminalSnapshotState | null,
-): string {
-  if (!state) return 'no snapshot response';
-  const parts = [
-    state.reason ? `reason=${state.reason}` : null,
-    state.status ? `status=${state.status}` : null,
-    state.runId ? `runId=${state.runId}` : null,
-    state.playName ? `playName=${state.playName}` : null,
-    state.parentRunId ? `parentRunId=${state.parentRunId}` : null,
-  ].filter((part): part is string => Boolean(part));
-  return parts.length > 0 ? parts.join(' ') : 'empty snapshot response';
-}
-
-/**
- * Block until the child run reaches a terminal state, via the workflow event
- * wait raced against the coordinator terminal-state poll. Throws on a non-
- * completed terminal status.
- */
-export async function awaitChildTerminal(
-  input: AwaitChildTerminalInput,
-): Promise<ChildPlayTerminalWaitResult> {
-  if (!input.workflowStep) {
-    throw new Error(
-      'ctx.runPlay child waits require the cf-workflows runtime event scheduler.',
-    );
-  }
-  const waitStartedAt = input.now();
-  const eventKey = await childPlayEventKey({
-    key: input.key,
-    workflowId: input.workflowId,
-    hashJson: input.hashJson,
-  });
-  if (!input.coordinator?.readRunTerminalState) {
-    throw new ChildPlayTerminalVerificationError({
-      parentRunId: input.parentRunId,
-      eventKey,
-      cause: new Error(
-        `Child run ${input.workflowId} terminal snapshot reader was not available.`,
-      ),
-    });
-  }
-  const eventPromise = input.workflowStep
-    .waitForEvent(`child_play_terminal:${eventKey}`, {
-      type: integrationEventType(eventKey),
-      timeout: workflowTimeoutFromMs(input.timeoutMs),
-    })
-    .then((event) => ({
-      source: 'workflow_event' as const,
-      payload: readChildTerminalPayload(event.payload),
-      attempts: undefined as number | undefined,
-    }));
-  const terminal = await Promise.race([
-    eventPromise,
-    pollParentChildTerminalState({
-      coordinator: input.coordinator,
-      parentRunId: input.parentRunId,
-      eventKey,
-      timeoutMs: Math.min(input.timeoutMs, 30_000),
-      now: input.now,
-    }),
-  ]);
-  let verified:
-    | {
-        payload: Record<string, unknown> | null;
-        lastState: ChildRunTerminalSnapshotState | null;
-        lastError: unknown;
-      }
-    | null = null;
-  try {
-    verified = await readVerifiedChildTerminalPayload({
-      coordinator: input.coordinator,
-      workflowId: input.workflowId,
-      timeoutMs: input.timeoutMs,
-    });
-  } catch (error) {
-    throw new ChildPlayTerminalVerificationError({
-      parentRunId: input.parentRunId,
-      eventKey,
-      cause: error,
-    });
-  }
-  if (!verified?.payload) {
-    const lastErrorMessage =
-      verified?.lastError instanceof Error
-        ? ` lastError=${verified.lastError.message}`
-        : verified?.lastError
-          ? ` lastError=${String(verified.lastError)}`
-          : '';
-    throw new ChildPlayTerminalVerificationError({
-      parentRunId: input.parentRunId,
-      eventKey,
-      cause: new Error(
-        `Child run ${input.workflowId} terminal snapshot was not available after durable verification grace; ${describeSnapshotState(verified?.lastState ?? null)}.${lastErrorMessage}`,
-      ),
-    });
-  }
-  const payload = verified.payload;
-  const status = String(payload.status ?? '').toLowerCase();
-  if (status === 'completed') {
-    return {
-      output: extractChildPlayOutput(payload),
-      source: terminal.source,
-      attempts: terminal.attempts,
-      waitMs: input.now() - waitStartedAt,
-    };
-  }
-  const error = isRecord(payload.error) ? payload.error : null;
-  const message =
-    (typeof error?.message === 'string' && error.message.trim()) ||
-    (typeof payload.error === 'string' && payload.error.trim()) ||
-    `Child play ${input.playName} (${input.workflowId}) finished with status ${status || 'unknown'}.`;
-  throw new Error(message);
-}

package/dist/bundling-sources/apps/play-runner-workers/src/child-play-submit.ts

@@ -1,203 +0,0 @@
-export type ChildSubmitResponse = {
-  workflowId?: string;
-  runId?: string;
-  status?: string;
-  mode?: string;
-  output?: unknown;
-  result?: unknown;
-  error?: unknown;
-  logs?: string[];
-  timings?: Array<{ phase: string; ms: number }>;
-};
-
-export type ChildCoordinatorBinding = {
-  submitChild(
-    parentRunId: string,
-    body: Record<string, unknown>,
-  ): Promise<ChildSubmitResponse>;
-  submitWorkflowChild?(
-    parentRunId: string,
-    body: Record<string, unknown>,
-  ): Promise<ChildSubmitResponse>;
-};
-
-export type ChildSubmitRequest = {
-  runId: string;
-  coordinatorUrl?: string | null;
-  coordinatorInternalToken?: string | null;
-};
-
-export type CoordinatorRequestHeadersInput = {
-  runId: string;
-  contentType?: string;
-  internalToken?: string | null;
-};
-
-export type SubmitChildPlayThroughCoordinatorInput = {
-  req: ChildSubmitRequest;
-  body: unknown;
-  coordinatorBinding?: ChildCoordinatorBinding | null;
-  allowInline?: boolean;
-  makeRequestId: () => string;
-  coordinatorRequestHeaders: (
-    input: CoordinatorRequestHeadersInput,
-  ) => Record<string, string>;
-  fetchFn?: typeof fetch;
-  retryDelaysMs?: readonly number[];
-  sleep?: (ms: number) => Promise<void>;
-};
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function requireChildSubmitBody(body: unknown): Record<string, unknown> {
-  if (!isRecord(body)) {
-    throw new Error('ctx.runPlay child submit requires an object body.');
-  }
-  return body;
-}
-
-function isRetryableChildSubmitError(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error);
-  return /timed out|timeout|fetch failed|ECONNRESET|ECONNREFUSED|UND_ERR_CONNECT_TIMEOUT/i.test(
-    message,
-  );
-}
-
-function isRetryableChildSubmitResponse(status: number, body: string): boolean {
-  if (
-    status === 408 ||
-    status === 429 ||
-    status === 502 ||
-    status === 503 ||
-    status === 504 ||
-    status === 530
-  ) {
-    return true;
-  }
-  return (
-    status === 500 &&
-    /timeout exceeded when trying to connect|timed out|fetch failed|ECONNRESET|UND_ERR_CONNECT_TIMEOUT/i.test(
-      body,
-    )
-  );
-}
-
-function parseChildSubmitResponse(text: string): ChildSubmitResponse {
-  if (!text) {
-    return {};
-  }
-  try {
-    const parsed = JSON.parse(text) as unknown;
-    return isRecord(parsed) ? parsed : { result: parsed };
-  } catch {
-    return { error: text };
-  }
-}
-
-function childSubmitErrorMessage(input: {
-  parsed: ChildSubmitResponse;
-  text: string;
-  status: number;
-}): string {
-  const error = isRecord(input.parsed.error) ? input.parsed.error : null;
-  return (
-    (typeof error?.message === 'string' && error.message.trim()) ||
-    (typeof input.parsed.error === 'string' && input.parsed.error.trim()) ||
-    input.text.slice(0, 800) ||
-    `Coordinator child submit failed with ${input.status}.`
-  );
-}
-
-async function defaultSleep(ms: number): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export async function submitChildPlayThroughCoordinator(
-  input: SubmitChildPlayThroughCoordinatorInput,
-): Promise<ChildSubmitResponse> {
-  const body = requireChildSubmitBody(input.body);
-  const binding = input.coordinatorBinding;
-  if (binding && input.allowInline !== false) {
-    return await binding.submitChild(input.req.runId, body);
-  }
-  if (binding?.submitWorkflowChild) {
-    return await binding.submitWorkflowChild(input.req.runId, body);
-  }
-
-  const coordinatorUrl = input.req.coordinatorUrl?.trim();
-  if (!coordinatorUrl) {
-    throw new Error(
-      'ctx.runPlay child submit requires a coordinator binding in the cf-workflows runtime.',
-    );
-  }
-
-  const fetchFn = input.fetchFn ?? fetch;
-  const retryDelaysMs = input.retryDelaysMs ?? [
-    250, 750, 1500, 3000, 5000, 10000,
-  ];
-  const sleep = input.sleep ?? defaultSleep;
-  const url = `${coordinatorUrl.replace(/\/$/, '')}/workflow/${encodeURIComponent(
-    input.req.runId,
-  )}/submit-child`;
-  const serializedBody = JSON.stringify(body);
-  const requestId = input.makeRequestId();
-  const idempotencyKey =
-    typeof body.childIdempotencyKey === 'string' &&
-    body.childIdempotencyKey.trim()
-      ? body.childIdempotencyKey.trim()
-      : requestId;
-  let lastError: unknown = null;
-
-  for (let attempt = 0; attempt <= retryDelaysMs.length; attempt += 1) {
-    let response: Response;
-    try {
-      response = await fetchFn(url, {
-        method: 'POST',
-        headers: {
-          'x-deepline-request-id': requestId,
-          'x-deepline-idempotency-key': idempotencyKey,
-          ...input.coordinatorRequestHeaders({
-            runId: input.req.runId,
-            contentType: 'application/json',
-            internalToken: input.req.coordinatorInternalToken,
-          }),
-        },
-        body: serializedBody,
-      });
-    } catch (error) {
-      lastError = error;
-      if (
-        attempt >= retryDelaysMs.length ||
-        !isRetryableChildSubmitError(error)
-      ) {
-        throw error;
-      }
-      await sleep(retryDelaysMs[attempt] ?? 0);
-      continue;
-    }
-
-    const text = await response.text().catch(() => '');
-    const parsed = parseChildSubmitResponse(text);
-    if (response.ok) {
-      return parsed;
-    }
-
-    const message = childSubmitErrorMessage({
-      parsed,
-      text,
-      status: response.status,
-    });
-    lastError = new Error(message);
-    if (
-      attempt >= retryDelaysMs.length ||
-      !isRetryableChildSubmitResponse(response.status, text)
-    ) {
-      throw lastError;
-    }
-    await sleep(retryDelaysMs[attempt] ?? 0);
-  }
-
-  throw lastError instanceof Error ? lastError : new Error(String(lastError));
-}

package/dist/bundling-sources/shared_libs/play-runtime/child-execution-placement.ts

@@ -1,14 +0,0 @@
-import type { PlayCallExecution } from './play-call-execution';
-
-export function resolveChildExecutionPlacement(input: {
-  requiresWorkflow: boolean;
-  execution?: PlayCallExecution | null;
-}): { strategy: 'inline' | 'scheduled' } {
-  return {
-    strategy:
-      input.execution === 'child-workflow' ||
-      (input.execution !== 'inline' && input.requiresWorkflow)
-        ? 'scheduled'
-        : 'inline',
-  };
-}