deepline 0.3.461 → 0.3.462

package/dist/bundling-sources/sdk/src/plays/client.ts

@@ -1,426 +1,9 @@
-/**
- * Remote Play operations shared by the full SDK client and imported Play handles.
- * Handles resolve configuration lazily; a submitted job keeps its original client.
- */
+/** Remote Play operations with lazy local configuration discovery. */
 import { resolveConfig } from '../config';
-import { DeeplineError } from '../errors';
 import { HttpClient } from '../http';
-import { SDK_API_MAJOR } from '../version';
-import type {
-  DeeplineClientOptions,
-  ClearPlayHistoryRequest,
-  ClearPlayHistoryResult,
-  PlayDetail,
-  PlayRevisionSummary,
-  PlayRunListItem,
-  PlayRunStart,
-  PlayStatus,
-  PublishPlayVersionRequest,
-  PublishPlayVersionResult,
-  StartPlayRunRequest,
-  StopPlayRunResult,
-} from '../types';
-import {
-  isPlayRunPackage,
-  startPlayRun,
-  type ResolvedStartPlayRunRequest,
-  type PlayRunStartOptions,
-} from './run-request';
-import {
-  RUNTIME_ENVIRONMENT_TOKEN_HEADER,
-  RETAINED_PIPELINE_RECEIVERS_HEADER,
-} from '../../../shared_libs/play-runtime/coordinator-headers.js';
-import {
-  normalizePlayRuntimeEnvironment,
-  normalizePlayRuntimeNamespace,
-  normalizePlayRuntimeSandboxPlacementPolicy,
-  normalizePlayRuntimeSelection,
-  type PlayRuntimeSelection,
-} from '../../../shared_libs/play-runtime/runtime-environment.js';
-import { decodePlayRunPublicStatus } from '../../../shared_libs/play-runtime/run-lifecycle-policy.js';
-
-export function normalizePlayRunIntegrationMode(
-  value: unknown,
-): 'live' | 'eval_stub' | 'fixture' | undefined {
-  if (value === 'live' || value === 'eval_stub' || value === 'fixture') {
-    return value;
-  }
-  return undefined;
-}
-
-export type ClientEnvironment = Readonly<Record<string, string | undefined>>;
-
-function resolvePlayRunIntegrationMode(
-  request: StartPlayRunRequest,
-  env: ClientEnvironment,
-): 'live' | 'eval_stub' | 'fixture' | undefined {
-  return normalizePlayRunIntegrationMode(
-    request.integrationMode ?? env.DEEPLINE_EVAL_INTEGRATION_MODE,
-  );
-}
-
-function resolvePlayRunRuntimeSelection(
-  request: StartPlayRunRequest,
-  env: ClientEnvironment,
-): PlayRuntimeSelection | undefined {
-  if (request.runtime !== undefined) {
-    const runtime = normalizePlayRuntimeSelection(request.runtime);
-    if (!runtime) {
-      throw new DeeplineError(
-        'runtime must be { environment: "preview", namespace, backend?: "daytona" | "modal", sandboxPlacementPolicy?: "policy_name@1" } with namespace matching ^[a-z][a-z0-9-]{0,30}$.',
-        undefined,
-        'INVALID_RUNTIME_SELECTION',
-      );
-    }
-    return runtime;
-  }
-  // These variables select where the app executes a run, not which app the
-  // SDK calls. DEEPLINE_API_BASE_URL still chooses the app host. Environment
-  // opts into remote preview routing, namespace names the isolated lane, and
-  // the token only authorizes that selection. Omitting all three leaves the
-  // app free to use its native runtime (local for a local app, prod for prod).
-  const configured = env.DEEPLINE_RUNTIME_ENVIRONMENT?.trim();
-  const configuredNamespace = env.DEEPLINE_RUNTIME_NAMESPACE?.trim();
-  const configuredToken = env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
-  const configuredPlacementPolicy =
-    env.DEEPLINE_RUNTIME_SANDBOX_PLACEMENT_POLICY?.trim();
-  if (!configured) {
-    if (configuredNamespace || configuredToken || configuredPlacementPolicy) {
-      // Name the variables that are actually set. This branch is almost always
-      // hit by a stale value auto-loaded from a .env/.env.local rather than by
-      // a deliberate export, so the message has to say where to look and how
-      // to run the command anyway.
-      const present: string[] = [];
-      if (configuredNamespace) present.push('DEEPLINE_RUNTIME_NAMESPACE');
-      if (configuredToken) present.push('DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN');
-      if (configuredPlacementPolicy) {
-        present.push('DEEPLINE_RUNTIME_SANDBOX_PLACEMENT_POLICY');
-      }
-      const isPlural = present.length > 1;
-      throw new DeeplineError(
-        [
-          `Incomplete play runtime selection: ${present.join(' and ')} ${isPlural ? 'are' : 'is'} set but DEEPLINE_RUNTIME_ENVIRONMENT is not.`,
-          'Preview routing requires DEEPLINE_RUNTIME_ENVIRONMENT=preview together with DEEPLINE_RUNTIME_NAMESPACE; the token alone authorizes nothing.',
-          `If you did not export ${isPlural ? 'these' : 'this'} yourself, ${isPlural ? 'they were' : 'it was'} most likely auto-loaded from a .env or .env.local in the current directory (bun loads those automatically, and in a git worktree .env.local is usually a symlink to the main checkout).`,
-          `To run against the app-native runtime, clear ${isPlural ? 'them' : 'it'} for this command: ${present.map((name) => `${name}=`).join(' ')} <your deepline command>`,
-        ].join('\n'),
-        undefined,
-        'INVALID_RUNTIME_ENVIRONMENT',
-      );
-    }
-    return undefined;
-  }
-  const environment = normalizePlayRuntimeEnvironment(configured);
-  if (!environment) {
-    throw new DeeplineError(
-      `DEEPLINE_RUNTIME_ENVIRONMENT supports only explicit preview selection. Received "${configured}". Omit it to use the app-native runtime.`,
-      undefined,
-      'INVALID_RUNTIME_ENVIRONMENT',
-    );
-  }
-  const namespace = normalizePlayRuntimeNamespace(configuredNamespace);
-  if (!namespace) {
-    throw new DeeplineError(
-      'DEEPLINE_RUNTIME_NAMESPACE is required for preview and must match ^[a-z][a-z0-9-]{0,30}$.',
-      undefined,
-      'INVALID_RUNTIME_NAMESPACE',
-    );
-  }
-  const configuredBackendValue = env.DEEPLINE_PLAY_RUNNER_BACKEND?.trim();
-  const configuredBackend =
-    configuredBackendValue === 'daytona' || configuredBackendValue === 'modal'
-      ? configuredBackendValue
-      : undefined;
-  if (configuredBackendValue && !configuredBackend) {
-    throw new DeeplineError(
-      `DEEPLINE_PLAY_RUNNER_BACKEND must be daytona or modal for preview runtime selection. Received "${configuredBackendValue}".`,
-      undefined,
-      'INVALID_RUNTIME_BACKEND',
-    );
-  }
-  if (
-    configuredPlacementPolicy &&
-    !normalizePlayRuntimeSandboxPlacementPolicy(configuredPlacementPolicy)
-  ) {
-    throw new DeeplineError(
-      `DEEPLINE_RUNTIME_SANDBOX_PLACEMENT_POLICY must be a versioned placement policy id such as daytona_only@1. Received "${configuredPlacementPolicy}".`,
-      undefined,
-      'INVALID_RUNTIME_SANDBOX_PLACEMENT_POLICY',
-    );
-  }
-  return {
-    environment,
-    namespace,
-    ...(configuredBackend ? { backend: configuredBackend } : {}),
-    ...(configuredPlacementPolicy
-      ? { sandboxPlacementPolicy: configuredPlacementPolicy }
-      : {}),
-  };
-}
-
-/**
- * Resolve the environment-derived run-start fields (eval integration mode,
- * test policy overrides, preview runtime) into explicit request fields, in the
- * order the SDK has always validated them. The shared body builder in
- * `plays/run-request` never reads the environment.
- */
-export function resolveStartPlayRunRequest(
-  request: StartPlayRunRequest,
-  env: ClientEnvironment,
-): {
-  request: ResolvedStartPlayRunRequest;
-  runtime: PlayRuntimeSelection | undefined;
-} {
-  const integrationMode = resolvePlayRunIntegrationMode(request, env);
-  const testPolicyOverrides =
-    request.testPolicyOverrides ?? parseEnvTestPolicyOverrides(env);
-  const runtime = resolvePlayRunRuntimeSelection(request, env);
-  const resolved: ResolvedStartPlayRunRequest = { ...request };
-  delete resolved.integrationMode;
-  delete resolved.runtime;
-  delete resolved.testPolicyOverrides;
-  if (integrationMode) resolved.integrationMode = integrationMode;
-  if (runtime) resolved.runtime = runtime;
-  if (testPolicyOverrides) resolved.testPolicyOverrides = testPolicyOverrides;
-  return { request: resolved, runtime };
-}
-
-export function runtimeSelectionHeaders(
-  runtime: PlayRuntimeSelection | undefined,
-  env: ClientEnvironment,
-): Record<string, string> | undefined {
-  if (!runtime) return undefined;
-  // Keep the credential out of the typed runtime payload. The app consumes it
-  // at the HTTP boundary and never forwards it to Fly, Absurd, or Daytona.
-  const token = env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
-  if (!token) {
-    throw new DeeplineError(
-      'DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN is required for explicit preview runtime selection.',
-      undefined,
-      'RUNTIME_ENVIRONMENT_TOKEN_REQUIRED',
-    );
-  }
-  const receivers = env.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim();
-  return {
-    [RUNTIME_ENVIRONMENT_TOKEN_HEADER]: token,
-    ...(receivers ? { [RETAINED_PIPELINE_RECEIVERS_HEADER]: receivers } : {}),
-  };
-}
-
-function normalizeTestPolicyOverrides(
-  value: unknown,
-  source: string,
-): Record<string, unknown> {
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    return value as Record<string, unknown>;
-  }
-  throw new DeeplineError(
-    `${source} must be a JSON object.`,
-    undefined,
-    'INVALID_TEST_POLICY_OVERRIDES',
-  );
-}
-
-function parseEnvTestPolicyOverrides(
-  env: ClientEnvironment,
-): Record<string, unknown> | undefined {
-  const raw = env.DEEPLINE_TEST_POLICY_OVERRIDES;
-  const trimmed = raw?.trim();
-  if (!trimmed) return undefined;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch (error) {
-    const detail = error instanceof Error ? ` ${error.message}` : '';
-    throw new DeeplineError(
-      `DEEPLINE_TEST_POLICY_OVERRIDES must be valid JSON.${detail}`,
-      undefined,
-      'INVALID_TEST_POLICY_OVERRIDES',
-    );
-  }
-  return normalizeTestPolicyOverrides(parsed, 'DEEPLINE_TEST_POLICY_OVERRIDES');
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
-}
-
-export function normalizePlayStatus(raw: Record<string, unknown>): PlayStatus {
-  const runPackage = isPlayRunPackage(raw)
-    ? raw
-    : isPlayRunPackage(raw.package)
-      ? raw.package
-      : null;
-  const packageRun = runPackage?.run;
-  const rawStatus =
-    typeof raw.status === 'string'
-      ? raw.status
-      : typeof packageRun?.status === 'string'
-        ? packageRun.status
-        : null;
-  const status = decodePlayRunPublicStatus(rawStatus);
-  if (!status) {
-    throw new Error(
-      `Invalid play run lifecycle status in API response: ${JSON.stringify(rawStatus)}.`,
-    );
-  }
-  const runId =
-    typeof raw.runId === 'string'
-      ? raw.runId
-      : typeof raw.workflowId === 'string'
-        ? raw.workflowId
-        : (packageRun?.id ?? '');
-  const legacyOverview = runPackage?.overview ?? raw.overview;
-  const runStatus = runPackage?.runStatus ?? raw.runStatus;
-  return {
-    ...(raw as unknown as Omit<PlayStatus, 'runId' | 'status'>),
-    runId,
-    ...(isRecord(legacyOverview)
-      ? {
-          overview: legacyOverview as unknown as PlayStatus['overview'],
-        }
-      : {}),
-    ...(isRecord(runStatus)
-      ? { runStatus: runStatus as unknown as PlayStatus['runStatus'] }
-      : {}),
-    ...(runPackage
-      ? {
-          package: runPackage,
-          outputs: runPackage.outputs,
-        }
-      : {}),
-    status,
-  };
-}
-
-export class PlayClient {
-  constructor(
-    private readonly http: HttpClient,
-    private readonly environment: ClientEnvironment = process.env,
-  ) {}
-
-  async startPlayRun(
-    request: StartPlayRunRequest,
-    options?: PlayRunStartOptions,
-  ): Promise<PlayRunStart> {
-    const resolved = resolveStartPlayRunRequest(request, this.environment);
-    const headers = runtimeSelectionHeaders(resolved.runtime, this.environment);
-    return startPlayRun(
-      this.http,
-      resolved.request,
-      options?.cliAdmission
-        ? { ...headers, 'X-Deepline-API-Major': String(SDK_API_MAJOR) }
-        : headers,
-      options,
-    );
-  }
-
-  async getPlayStatus(
-    workflowId: string,
-    options?: { billing?: boolean; full?: boolean },
-  ): Promise<PlayStatus> {
-    const params = new URLSearchParams();
-    if (options?.billing === false) {
-      params.set('billing', 'false');
-    }
-    if (options?.full === true) {
-      params.set('full', 'true');
-    }
-    const query = params.size > 0 ? `?${params.toString()}` : '';
-    const response = await this.http.get<Record<string, unknown>>(
-      `/api/v2/runs/${encodeURIComponent(workflowId)}${query}`,
-    );
-    return normalizePlayStatus(response);
-  }
-
-  async cancelPlay(workflowId: string): Promise<void> {
-    await this.http.request(
-      `/api/v2/runs/${encodeURIComponent(workflowId)}/stop`,
-      { method: 'POST' },
-    );
-  }
-
-  async stopPlay(
-    workflowId: string,
-    options?: { reason?: string },
-  ): Promise<StopPlayRunResult> {
-    return this.http.post<StopPlayRunResult>(
-      `/api/v2/runs/${encodeURIComponent(workflowId)}/stop`,
-      options?.reason ? { reason: options.reason } : {},
-    );
-  }
-
-  async listPlayRuns(playName: string): Promise<PlayRunListItem[]> {
-    const encodedName = encodeURIComponent(playName);
-    const response = await this.http.get<{ runs: PlayRunListItem[] }>(
-      `/api/v2/plays/${encodedName}/runs`,
-    );
-    return response.runs ?? [];
-  }
-
-  async getPlay(
-    name: string,
-    options?: {
-      source?: 'working' | 'live' | `version:${number}`;
-      guidance?: boolean;
-    },
-  ): Promise<PlayDetail> {
-    const encodedName = encodeURIComponent(name);
-    const query = options?.source
-      ? `?include=source&revision=${encodeURIComponent(options.source)}`
-      : options?.guidance
-        ? '?include=guidance'
-        : '';
-    return this.http.get<PlayDetail>(`/api/v2/plays/${encodedName}${query}`);
-  }
-
-  async clearPlayHistory(
-    name: string,
-    request: ClearPlayHistoryRequest = {},
-  ): Promise<ClearPlayHistoryResult> {
-    const encodedName = encodeURIComponent(name);
-    return this.http.post<ClearPlayHistoryResult>(
-      `/api/v2/plays/${encodedName}/history/clear`,
-      request,
-    );
-  }
-
-  async listPlayVersions(
-    name: string,
-    options?: { full?: boolean },
-  ): Promise<PlayRevisionSummary[]> {
-    const encodedName = encodeURIComponent(name);
-    const suffix = options?.full ? '?full=true' : '';
-    const response = await this.http.get<{ versions: PlayRevisionSummary[] }>(
-      `/api/v2/plays/${encodedName}/versions${suffix}`,
-    );
-    return response.versions ?? [];
-  }
-
-  async publishPlayVersion(
-    name: string,
-    request: PublishPlayVersionRequest = {},
-  ): Promise<PublishPlayVersionResult> {
-    const encodedName = encodeURIComponent(name);
-    return this.http.post<PublishPlayVersionResult>(
-      `/api/v2/plays/${encodedName}/live`,
-      request,
-    );
-  }
-}
-
-export type PlayClientOperations = Pick<
-  PlayClient,
-  | 'getPlay'
-  | 'listPlayRuns'
-  | 'listPlayVersions'
-  | 'publishPlayVersion'
-  | 'clearPlayHistory'
-  | 'startPlayRun'
-  | 'getPlayStatus'
-  | 'cancelPlay'
-  | 'stopPlay'
->;
+import type { DeeplineClientOptions } from '../types';
+import { PlayClient } from './client-core';
+export * from './client-core';
 
 export function createPlayClient(options?: DeeplineClientOptions): PlayClient {
   const config = resolveConfig(options);

package/dist/bundling-sources/sdk/src/plays/input-example.ts

@@ -2,9 +2,9 @@
 export function playInputExampleArgs(
   schema: Record<string, unknown> | null | undefined,
 ): string {
-  if (!schema) return " --input '@<input.json>'";
+  if (!schema) return ' --input-file <input.json>';
   // Do not guess required inputs hidden behind a reference or intersection.
-  if (schema.$ref || schema.allOf) return " --input '@<input.json>'";
+  if (schema.$ref || schema.allOf) return ' --input-file <input.json>';
   const csv = schema.csvInput as { inputField?: unknown } | undefined;
   const csvField = typeof csv?.inputField === 'string' ? csv.inputField : null;
   const required = Array.isArray(schema.required) ? schema.required : [];
@@ -24,7 +24,6 @@ export function playInputExampleArgs(
   // Only advertise the universally supported CSV shorthand. Other field names
   // may collide with execution flags (e.g. file/name); JSON is unambiguous.
   if (csvField && csvOnlyRequired && (!alternatives || hasCsvAlternative)) {
-    if (csvField === 'csv') return " --csv '<contacts.csv>'";
     const value = JSON.stringify({ [csvField]: '<contacts.csv>' });
     return ` --input '${value.replace(/'/g, "'\\''")}'`;
   }
@@ -36,5 +35,5 @@ export function playInputExampleArgs(
   ) {
     return '';
   }
-  return " --input '@<input.json>'";
+  return ' --input-file <input.json>';
 }

package/dist/bundling-sources/sdk/src/plays/play-description.ts

@@ -102,7 +102,7 @@ export function describePlayListItem(
     play.currentRevision?.description?.trim() ||
     play.liveRevision?.description?.trim() ||
     null;
-  const runCommand = `deepline plays run ${play.reference || play.name}${playInputExampleArgs(play.inputSchema)}`;
+  const runCommand = `deepline run ${play.reference || play.name}${playInputExampleArgs(play.inputSchema)}`;
   const starter = cloneEditStarter(play);
   return {
     name: play.name,

package/dist/bundling-sources/sdk/src/plays/run-request.ts

@@ -1,7 +1,7 @@
 /**
  * The one client-side construction of a Play run start.
  *
- * `deepline plays run <name>` (CLI), `DeeplineClient.startPlayRun` (SDK), and
+ * `deepline run <name>` (CLI), `DeeplineClient.startPlayRun` (SDK), and
  * the dashboard's "Run in UI" form all start a run through this module: the
  * same file-input bindings, the same staged-file upload
  * (`/api/v2/plays/files/stage/mint`, direct PUT, multipart fallback), the same

package/dist/bundling-sources/sdk/src/release.ts

@@ -205,7 +205,7 @@ export const 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.461',
+  version: '0.3.462',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/sdk/src/server.ts

@@ -0,0 +1,43 @@
+/** Explicit server client: credentials and caller environment never use local discovery. */
+import { DeeplineClient as DeeplineClientCore } from './client-core';
+import { HttpClient } from './http-core';
+import { ConfigError } from './errors';
+import type { DeeplineClientOptions, ResolvedConfig } from './types';
+export * from './errors';
+export type * from './types';
+export type * from './client-core';
+
+export type ServerClientOptions = DeeplineClientOptions &
+  Required<Pick<DeeplineClientOptions, 'apiKey' | 'baseUrl' | 'environment'>>;
+
+export class DeeplineClient extends DeeplineClientCore {
+  constructor(options: ServerClientOptions) {
+    const apiKey = options.apiKey?.trim();
+    if (!apiKey)
+      throw new ConfigError('An explicit server API key is required.');
+    if (!options.environment) {
+      throw new ConfigError(
+        'An explicit server caller environment is required.',
+      );
+    }
+    let baseUrl: string;
+    try {
+      const parsed = new URL(options.baseUrl.trim().replace(/\/+$/, ''));
+      if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error('Invalid protocol');
+      }
+      baseUrl = parsed.toString().replace(/\/+$/, '');
+    } catch {
+      throw new ConfigError('An explicit http(s) server base URL is required.');
+    }
+    const config: ResolvedConfig = {
+      apiKey,
+      baseUrl,
+      environment: options.environment,
+      timeout: options.timeout ?? 60_000,
+      maxRetries: options.maxRetries ?? 3,
+      ...(options.headers ? { headers: { ...options.headers } } : {}),
+    };
+    super(config, new HttpClient(config), options.timeout);
+  }
+}

package/dist/bundling-sources/sdk/src/types.ts

@@ -1,3 +1,7 @@
+import type {
+  TerminalRuntimePerformance,
+  TerminalRuntimePerformanceUnavailableReason,
+} from '../../shared_libs/play-runtime/terminal-runtime-performance';
 import type { PlaySettings } from '../../shared_libs/plays/settings-contract';
 import type { ToolRequestWarningRule } from '../../shared_libs/integration-contracts/request-warnings';
 export type {
@@ -7,7 +11,7 @@ export type {
 import type { PlayCompilerManifest } from '../../shared_libs/plays/compiler-manifest';
 import type { RunGetStatus, RunLifecycleStatus } from './client';
 import type { PlayGrepMatch } from '../../shared_libs/plays/play-grep-search';
-import type { PlayRuntimeSelection } from '../../shared_libs/play-runtime/runtime-environment';
+import type { PlayRunRuntimeSelection } from '../../shared_libs/play-runtime/runtime-environment';
 import type {
   PlayActivityObservation,
   PlayActivityState,
@@ -892,6 +896,9 @@ export interface PlayRunPackage {
       sourceRunId?: string;
     };
     error?: string;
+    /** Accepted terminal invocation only; absent on older/unsupported runtimes. */
+    performance?: TerminalRuntimePerformance;
+    performanceUnavailableReason?: TerminalRuntimePerformanceUnavailableReason;
     /** Canonical explanation of what this run is doing or waiting on. */
     activity?: PlayRunActivityProjection | null;
   };
@@ -1864,7 +1871,7 @@ export interface ClearPlayHistoryResult {
  * Response from starting a play run.
  *
  * Internal/advanced payload returned by low-level play submission primitives.
- * Most callers should prefer `deepline plays run`, {@link DeeplineClient.runPlay},
+ * Most callers should prefer `deepline run`, {@link DeeplineClient.runPlay},
  * or {@link PlayJob.get}.
  *
  * @example
@@ -2143,7 +2150,7 @@ export interface PlayCheckToolGetterHint {
  * Request body for starting a play run via {@link DeeplineClient.startPlayRun}.
  *
  * Internal/advanced request shape for low-level submission primitives.
- * Most callers should prefer `deepline plays run`, {@link DeeplineClient.runPlay},
+ * Most callers should prefer `deepline run`, {@link DeeplineClient.runPlay},
  * or {@link Deepline.connect}.
  *
  * Either `name` (for live plays) or `artifactStorageKey` (for packaged ad hoc runs) is required.
@@ -2228,8 +2235,11 @@ export interface StartPlayRunRequest {
   integrationMode?: 'live' | 'eval_stub' | 'fixture';
   /** Fixture-only provider response timing and outcome simulation. */
   fixtureBehavior?: import('../../shared_libs/play-runtime/fixture-behavior').FixtureBehavior;
-  /** Internal runtime estate selection. The app host remains unchanged. */
-  runtime?: PlayRuntimeSelection;
+  /**
+   * Internal runtime selection: a Preview estate, or the app's own runtime on
+   * a named sandbox placement policy. The app host remains unchanged.
+   */
+  runtime?: PlayRunRuntimeSelection;
   /** Internal/dev-only runtime policy overrides for black-box durability tests. */
   testPolicyOverrides?: Record<string, unknown>;
 }

package/dist/bundling-sources/shared_libs/integration-contracts/billing-entitlements.ts

@@ -38,6 +38,21 @@ export type BillingEntitlements = {
         remaining: number;
       };
     };
+    /** Managed database storage (GB) included before overage. */
+    includedStorage?: {
+      status: 'active';
+      usage: {
+        /** GB included. */
+        limit: number;
+        /** GB stored on the latest measured UTC day. */
+        consumed: number;
+        remaining: number;
+        /** The UTC day `consumed` was measured, `YYYY-MM-DD`. */
+        measuredDay: string;
+        /** False when storage charges are not rolled out to the workspace. */
+        overageCharged: boolean;
+      };
+    };
     quickenrichUnlimited?: {
       status: 'active' | 'past_due';
       value: BillingBenefitValues['quickenrichUnlimited'];