deepline 0.1.103 → 0.1.105

package/dist/index.mjs

@@ -188,10 +188,13 @@ var SDK_RELEASE = {
   // preflight (existence, data rows, quotes, duplicate headers), HTML error
   // scrubbing, and word-boundary watch truncation.
   // 0.1.103 ships the refined SDK CLI command surface.
-  version: "0.1.103",
+  // 0.1.104 ships postgres_fast suspension/billing parity and runtime worker hardening.
+  // 0.1.105 ships the billing catalog surface: billing plans, subscribe,
+  // subscription status/cancel, invoices, and the client.billing namespace.
+  version: "0.1.105",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.103",
+    latest: "0.1.105",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -322,7 +325,7 @@ var HttpClient = class {
             signal: controller.signal
           });
           clearTimeout(timeoutId);
-          if (response.status === 401 || response.status === 403) {
+          if (response.status === 401 || response.status === 403 && !options?.forbiddenAsApiError) {
             throw new AuthError();
           }
           if (response.status === 429) {
@@ -1414,6 +1417,9 @@ var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
 var EXECUTE_RESPONSE_CONTRACT_HEADER = "x-deepline-execute-response-contract";
 var V2_EXECUTE_RESPONSE_CONTRACT = "v2-tool-response";
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
+var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
+var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
+var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES = 25e5;
 function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
@@ -1426,6 +1432,45 @@ function isTransientCompileManifestError(error) {
     message
   );
 }
+async function mapWithConcurrency(items, concurrency, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      for (; ; ) {
+        const index = nextIndex;
+        nextIndex += 1;
+        if (index >= items.length) {
+          return;
+        }
+        results[index] = await mapper(items[index], index);
+      }
+    })
+  );
+  return results;
+}
+function jsonUtf8Bytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+function chunkRegisterPlayArtifacts(artifacts) {
+  const chunks = [];
+  let current = [];
+  for (const artifact of artifacts) {
+    const candidate = [...current, artifact];
+    const candidateTooLarge = candidate.length > REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT || jsonUtf8Bytes({ artifacts: candidate }) > REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES;
+    if (current.length > 0 && candidateTooLarge) {
+      chunks.push(current);
+      current = [artifact];
+    } else {
+      current = candidate;
+    }
+  }
+  if (current.length > 0) {
+    chunks.push(current);
+  }
+  return chunks;
+}
 var RUN_LOGS_PAGE_LIMIT = 1e3;
 function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -1593,6 +1638,8 @@ var DeeplineClient = class {
   config;
   /** Canonical run lifecycle namespace backed by `/api/v2/runs`. */
   runs;
+  /** Billing namespace: subscription status/cancel and invoice history. */
+  billing;
   /**
    * Create a low-level SDK client.
    *
@@ -1613,6 +1660,16 @@ var DeeplineClient = class {
       exportDatasetRows: (input) => this.getPlaySheetRows(input),
       stop: (runId, options2) => this.stopRun(runId, options2)
     };
+    this.billing = {
+      plans: () => this.getBillingPlans(),
+      subscription: {
+        status: () => this.getBillingSubscriptionStatus(),
+        cancel: (options2) => this.cancelBillingSubscription(options2)
+      },
+      invoices: {
+        list: (options2) => this.listBillingInvoices(options2)
+      }
+    };
   }
   /** The resolved base URL this client is targeting (e.g. `"http://localhost:3000"`). */
   get baseUrl() {
@@ -1981,8 +2038,13 @@ var DeeplineClient = class {
    * first when a compiler manifest is not already supplied.
    */
   async registerPlayArtifacts(artifacts) {
-    const compiledArtifacts = await Promise.all(
-      artifacts.map(async (artifact) => ({
+    if (artifacts.length === 0) {
+      return this.http.post("/api/v2/plays/artifacts", { artifacts });
+    }
+    const compiledArtifacts = await mapWithConcurrency(
+      artifacts,
+      REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY,
+      async (artifact) => ({
         ...artifact,
         compilerManifest: artifact.compilerManifest ?? await this.compilePlayManifest({
           name: artifact.name,
@@ -1990,11 +2052,20 @@ var DeeplineClient = class {
           sourceFiles: artifact.sourceFiles,
           artifact: artifact.artifact
         })
-      }))
+      })
     );
-    return this.http.post("/api/v2/plays/artifacts", {
-      artifacts: compiledArtifacts
-    });
+    const responses = [];
+    for (const chunk of chunkRegisterPlayArtifacts(compiledArtifacts)) {
+      responses.push(
+        await this.http.post("/api/v2/plays/artifacts", {
+          artifacts: chunk
+        })
+      );
+    }
+    return {
+      success: responses.every((response) => response.success),
+      artifacts: responses.flatMap((response) => response.artifacts)
+    };
   }
   /**
    * Compile a bundled play artifact into the server-side compiler manifest.
@@ -2967,6 +3038,61 @@ var DeeplineClient = class {
   // ——————————————————————————————————————————————————————————
   // Health
   // ——————————————————————————————————————————————————————————
+  /**
+   * Published plans plus the caller's active plan: prices, monthly grant
+   * credits, rollover policy, and which plans are open for subscription.
+   * Prefer `client.billing.plans()`.
+   *
+   * @returns Snake_case catalog from `GET /api/v2/billing/catalog/current`
+   */
+  async getBillingPlans() {
+    return this.http.get("/api/v2/billing/catalog/current");
+  }
+  /**
+   * Subscription state for the active workspace: active plan, whether a
+   * Stripe subscription backs it, renewal/cancellation facts, and remaining
+   * Deepline credit pools. Prefer `client.billing.subscription.status()`.
+   *
+   * @returns Snake_case subscription status from `GET /api/v2/billing/subscription/status`
+   */
+  async getBillingSubscriptionStatus() {
+    return this.http.get(
+      "/api/v2/billing/subscription/status"
+    );
+  }
+  /**
+   * Schedule subscription cancellation at period end, or reverse a pending
+   * cancellation with `{ undo: true }`. The customer keeps the cycle they
+   * paid for and every remaining credit — cancellation never claws back
+   * credits. Prefer `client.billing.subscription.cancel(...)`.
+   *
+   * @throws {@link DeeplineError} with `statusCode: 409` when the workspace
+   *   has no active subscription, and `statusCode: 502` when Stripe rejects
+   *   the update (the server message is preserved).
+   */
+  async cancelBillingSubscription(options) {
+    return this.http.post(
+      "/api/v2/billing/subscription/cancel",
+      { action: options?.undo ? "undo_cancel" : "cancel" }
+    );
+  }
+  /**
+   * Customer-facing billing history: subscription invoices plus one-time
+   * credit purchase receipts, newest first, with Stripe-hosted links.
+   * Prefer `client.billing.invoices.list(...)`.
+   *
+   * @param options.limit - Maximum entries to return (server clamps to 1–100, default 24).
+   */
+  async listBillingInvoices(options) {
+    const params = new URLSearchParams();
+    if (options?.limit !== void 0) {
+      params.set("limit", String(options.limit));
+    }
+    const suffix = Array.from(params).length > 0 ? `?${params.toString()}` : "";
+    return this.http.get(
+      `/api/v2/billing/invoices${suffix}`
+    );
+  }
   /**
    * Check API connectivity and server health.
    *

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

@@ -84,6 +84,9 @@ const INCLUDE_TOOL_METADATA_HEADER = 'x-deepline-include-tool-metadata';
 const EXECUTE_RESPONSE_CONTRACT_HEADER = 'x-deepline-execute-response-contract';
 const V2_EXECUTE_RESPONSE_CONTRACT = 'v2-tool-response';
 const COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1_000];
+const REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
+const REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
+const REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES = 2_500_000;
 
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -104,6 +107,58 @@ function isTransientCompileManifestError(error: unknown): boolean {
   );
 }
 
+async function mapWithConcurrency<T, U>(
+  items: T[],
+  concurrency: number,
+  mapper: (item: T, index: number) => Promise<U>,
+): Promise<U[]> {
+  const results = new Array<U>(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      for (;;) {
+        const index = nextIndex;
+        nextIndex += 1;
+        if (index >= items.length) {
+          return;
+        }
+        results[index] = await mapper(items[index]!, index);
+      }
+    }),
+  );
+  return results;
+}
+
+function jsonUtf8Bytes(value: unknown): number {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+
+function chunkRegisterPlayArtifacts<T>(artifacts: T[]): T[][] {
+  const chunks: T[][] = [];
+  let current: T[] = [];
+
+  for (const artifact of artifacts) {
+    const candidate = [...current, artifact];
+    const candidateTooLarge =
+      candidate.length > REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT ||
+      jsonUtf8Bytes({ artifacts: candidate }) >
+        REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES;
+    if (current.length > 0 && candidateTooLarge) {
+      chunks.push(current);
+      current = [artifact];
+    } else {
+      current = candidate;
+    }
+  }
+
+  if (current.length > 0) {
+    chunks.push(current);
+  }
+
+  return chunks;
+}
+
 type ExecuteToolRawOptions = {
   includeToolMetadata?: boolean;
 };
@@ -270,6 +325,153 @@ export type RunsNamespace = {
   ) => Promise<StopPlayRunResult>;
 };
 
+/** One credit grant pool reported by the billing subscription status endpoint. */
+export type BillingCreditPool = {
+  pool: string;
+  credits_remaining: number;
+  credits_granted: number;
+  source: string;
+  cycle_key: string | null;
+  effective_at: string;
+};
+
+/**
+ * Subscription state for the active workspace, from
+ * `GET /api/v2/billing/subscription/status`. All amounts are Deepline credits
+ * and Deepline-facing USD — never provider spend.
+ */
+export type BillingSubscriptionStatus = {
+  org_id: string;
+  plan_version_id: string;
+  plan_name: string;
+  plan_family_id: string;
+  /** Whether a Stripe subscription backs the active plan. */
+  subscribed: boolean;
+  price_usd: number | null;
+  price_interval: string | null;
+  monthly_grant_credits: number;
+  assigned_by: string;
+  assigned_at: string | null;
+  credit_pools: BillingCreditPool[];
+  pooled_credits_remaining: number;
+  /** End of the current paid period (ISO timestamp), when Stripe is reachable. */
+  current_period_end: string | null;
+  /** True when a cancellation is already scheduled for period end. */
+  cancel_at_period_end: boolean | null;
+  stripe_status: string | null;
+};
+
+/**
+ * Result of `POST /api/v2/billing/subscription/cancel`. Cancellation is always
+ * at period end: the customer keeps the cycle they paid for and every
+ * remaining credit. `undo_cancel` reverses a pending cancellation.
+ */
+export type BillingSubscriptionCancelResult = {
+  org_id: string;
+  subscription_id: string;
+  cancel_at_period_end: boolean;
+  current_period_end: string | null;
+  status: string;
+  message: string;
+};
+
+/**
+ * One customer-facing billing history entry from
+ * `GET /api/v2/billing/invoices`: a subscription invoice or a one-time credit
+ * purchase receipt. Amounts are what the customer paid — never provider spend.
+ */
+export type BillingInvoiceEntry = {
+  kind: 'invoice' | 'receipt';
+  id: string;
+  created_at: string;
+  description: string;
+  amount_cents: number;
+  currency: string;
+  status: string;
+  /** Stripe-hosted page (invoice or card receipt). */
+  url: string | null;
+  /** Direct PDF when Stripe provides one (invoices only). */
+  pdf_url: string | null;
+};
+
+export type BillingInvoicesResult = {
+  org_id: string;
+  entries: BillingInvoiceEntry[];
+};
+
+/** One published plan from `GET /api/v2/billing/catalog/current`. */
+export type BillingPlanEntry = {
+  plan_family_id: string;
+  plan_version_id: string;
+  public_name: string;
+  price_usd: number | null;
+  price_interval: string | null;
+  monthly_grant_credits: number;
+  rollover: { mode: string; max_credits?: number };
+  /** Whether the plan can be purchased via subscription checkout. */
+  acquirable: boolean;
+};
+
+/** One usage metric published in the billing catalog. */
+export type BillingMetricEntry = {
+  id: string;
+  name: string;
+};
+
+/** The caller's active plan as reported by the plans endpoint. */
+export type BillingActivePlan = {
+  plan_family_id: string;
+  plan_version_id: string;
+  public_name: string;
+  rate_card_id: string;
+  assigned_by: string;
+  assigned_at: string | null;
+  has_subscription: boolean;
+};
+
+/**
+ * Published plans plus the caller's active plan, from
+ * `GET /api/v2/billing/catalog/current`. Answers "what plans exist and what
+ * am I on". All amounts are Deepline credits and Deepline-facing USD — never
+ * provider spend.
+ */
+export type BillingPlansResult = {
+  catalog_id: string;
+  catalog_version: string;
+  active_plan: BillingActivePlan;
+  plans: BillingPlanEntry[];
+  metrics: BillingMetricEntry[];
+};
+
+/**
+ * Public billing namespace exposed as `client.billing`.
+ *
+ * Carries the durable Deepline billing product model — plans, subscription
+ * state, period-end cancellation, and invoice/receipt history — so CLI
+ * commands and programmatic callers share the same surface.
+ *
+ * @sdkReference client 030 client.billing
+ */
+export type BillingNamespace = {
+  /** Published plans plus the plan you are on ("what plans exist and what am I on"). */
+  plans: () => Promise<BillingPlansResult>;
+  subscription: {
+    /** Active plan, Stripe subscription state, and remaining credit pools. */
+    status: () => Promise<BillingSubscriptionStatus>;
+    /**
+     * Schedule cancellation at period end (credits are kept), or reverse a
+     * pending cancellation with `{ undo: true }`.
+     */
+    cancel: (options?: {
+      undo?: boolean;
+    }) => Promise<BillingSubscriptionCancelResult>;
+  };
+  invoices: {
+    /** Subscription invoices plus credit purchase receipts, newest first. */
+    list: (options?: { limit?: number }) => Promise<BillingInvoicesResult>;
+  };
+};
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
@@ -593,6 +795,8 @@ export class DeeplineClient {
   private readonly config: ResolvedConfig;
   /** Canonical run lifecycle namespace backed by `/api/v2/runs`. */
   readonly runs: RunsNamespace;
+  /** Billing namespace: subscription status/cancel and invoice history. */
+  readonly billing: BillingNamespace;
 
   /**
    * Create a low-level SDK client.
@@ -614,6 +818,16 @@ export class DeeplineClient {
       exportDatasetRows: (input) => this.getPlaySheetRows(input),
       stop: (runId, options) => this.stopRun(runId, options),
     };
+    this.billing = {
+      plans: () => this.getBillingPlans(),
+      subscription: {
+        status: () => this.getBillingSubscriptionStatus(),
+        cancel: (options) => this.cancelBillingSubscription(options),
+      },
+      invoices: {
+        list: (options) => this.listBillingInvoices(options),
+      },
+    };
   }
 
   /** The resolved base URL this client is targeting (e.g. `"http://localhost:3000"`). */
@@ -1164,8 +1378,13 @@ export class DeeplineClient {
       triggerBindings?: unknown;
     }>;
   }> {
-    const compiledArtifacts = await Promise.all(
-      artifacts.map(async (artifact) => ({
+    if (artifacts.length === 0) {
+      return this.http.post('/api/v2/plays/artifacts', { artifacts });
+    }
+    const compiledArtifacts = await mapWithConcurrency(
+      artifacts,
+      REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY,
+      async (artifact) => ({
         ...artifact,
         compilerManifest:
           artifact.compilerManifest ??
@@ -1175,11 +1394,35 @@ export class DeeplineClient {
             sourceFiles: artifact.sourceFiles,
             artifact: artifact.artifact,
           })),
-      })),
+      }),
     );
-    return this.http.post('/api/v2/plays/artifacts', {
-      artifacts: compiledArtifacts,
-    });
+    const responses = [];
+    for (const chunk of chunkRegisterPlayArtifacts(compiledArtifacts)) {
+      responses.push(
+        await this.http.post<{
+          success: boolean;
+          artifacts: Array<{
+            success?: boolean;
+            name?: string;
+            artifactStorageKey: string;
+            artifactMetadata?: Record<string, unknown> | null;
+            staticPipeline?: unknown;
+            definitionId?: string | null;
+            revisionId?: string | null;
+            version?: number | null;
+            liveVersion?: number | null;
+            triggerMetadata?: unknown;
+            triggerBindings?: unknown;
+          }>;
+        }>('/api/v2/plays/artifacts', {
+          artifacts: chunk,
+        }),
+      );
+    }
+    return {
+      success: responses.every((response) => response.success),
+      artifacts: responses.flatMap((response) => response.artifacts),
+    };
   }
 
   /**
@@ -2420,6 +2663,69 @@ export class DeeplineClient {
   // Health
   // ——————————————————————————————————————————————————————————
 
+  /**
+   * Published plans plus the caller's active plan: prices, monthly grant
+   * credits, rollover policy, and which plans are open for subscription.
+   * Prefer `client.billing.plans()`.
+   *
+   * @returns Snake_case catalog from `GET /api/v2/billing/catalog/current`
+   */
+  async getBillingPlans(): Promise<BillingPlansResult> {
+    return this.http.get<BillingPlansResult>('/api/v2/billing/catalog/current');
+  }
+
+  /**
+   * Subscription state for the active workspace: active plan, whether a
+   * Stripe subscription backs it, renewal/cancellation facts, and remaining
+   * Deepline credit pools. Prefer `client.billing.subscription.status()`.
+   *
+   * @returns Snake_case subscription status from `GET /api/v2/billing/subscription/status`
+   */
+  async getBillingSubscriptionStatus(): Promise<BillingSubscriptionStatus> {
+    return this.http.get<BillingSubscriptionStatus>(
+      '/api/v2/billing/subscription/status',
+    );
+  }
+
+  /**
+   * Schedule subscription cancellation at period end, or reverse a pending
+   * cancellation with `{ undo: true }`. The customer keeps the cycle they
+   * paid for and every remaining credit — cancellation never claws back
+   * credits. Prefer `client.billing.subscription.cancel(...)`.
+   *
+   * @throws {@link DeeplineError} with `statusCode: 409` when the workspace
+   *   has no active subscription, and `statusCode: 502` when Stripe rejects
+   *   the update (the server message is preserved).
+   */
+  async cancelBillingSubscription(options?: {
+    undo?: boolean;
+  }): Promise<BillingSubscriptionCancelResult> {
+    return this.http.post<BillingSubscriptionCancelResult>(
+      '/api/v2/billing/subscription/cancel',
+      { action: options?.undo ? 'undo_cancel' : 'cancel' },
+    );
+  }
+
+  /**
+   * Customer-facing billing history: subscription invoices plus one-time
+   * credit purchase receipts, newest first, with Stripe-hosted links.
+   * Prefer `client.billing.invoices.list(...)`.
+   *
+   * @param options.limit - Maximum entries to return (server clamps to 1–100, default 24).
+   */
+  async listBillingInvoices(options?: {
+    limit?: number;
+  }): Promise<BillingInvoicesResult> {
+    const params = new URLSearchParams();
+    if (options?.limit !== undefined) {
+      params.set('limit', String(options.limit));
+    }
+    const suffix = Array.from(params).length > 0 ? `?${params.toString()}` : '';
+    return this.http.get<BillingInvoicesResult>(
+      `/api/v2/billing/invoices${suffix}`,
+    );
+  }
+
   /**
    * Check API connectivity and server health.
    *

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

@@ -42,6 +42,14 @@ interface RequestOptions {
   headers?: Record<string, string>;
   /** Per-request timeout override in milliseconds. */
   timeout?: number;
+  /**
+   * Treat HTTP 403 as a regular API error instead of a generic {@link AuthError}.
+   * Use for endpoints that return 403 with a meaningful server error message
+   * (e.g. feature-flagged-off billing subscription checkout) so the server
+   * message is preserved and surfaced loudly. HTTP 401 still maps to
+   * {@link AuthError}.
+   */
+  forbiddenAsApiError?: boolean;
 }
 
 interface StreamOptions {
@@ -227,7 +235,10 @@ export class HttpClient {
 
           clearTimeout(timeoutId);
 
-          if (response.status === 401 || response.status === 403) {
+          if (
+            response.status === 401 ||
+            (response.status === 403 && !options?.forbiddenAsApiError)
+          ) {
             throw new AuthError();
           }
 

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

@@ -57,6 +57,12 @@
 export { DeeplineClient } from './client.js';
 export { RunObserveTransportUnavailableError } from './runs/observe-transport.js';
 export type {
+  BillingCreditPool,
+  BillingInvoiceEntry,
+  BillingInvoicesResult,
+  BillingNamespace,
+  BillingSubscriptionCancelResult,
+  BillingSubscriptionStatus,
   PlayStatus,
   PlaySheetRow,
   PlaySheetRowsResult,

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

@@ -59,10 +59,13 @@ export const SDK_RELEASE = {
   // preflight (existence, data rows, quotes, duplicate headers), HTML error
   // scrubbing, and word-boundary watch truncation.
   // 0.1.103 ships the refined SDK CLI command surface.
-  version: '0.1.103',
+  // 0.1.104 ships postgres_fast suspension/billing parity and runtime worker hardening.
+  // 0.1.105 ships the billing catalog surface: billing plans, subscribe,
+  // subscription status/cancel, invoices, and the client.billing namespace.
+  version: '0.1.105',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.103',
+    latest: '0.1.105',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/dist/repo/shared_libs/play-runtime/csv-rename.ts

@@ -176,6 +176,32 @@ export function cloneCsvAliasedRow<T extends Record<string, unknown>>(
   return cloned;
 }
 
+/**
+ * Plain enumerable clone for durable serialization (sheet writes, JSON
+ * payloads). Projected alias fields are normally non-enumerable so they stay
+ * out of spreads and Object.keys — but a JSON round-trip would silently drop
+ * them. This materializes every projected alias as a visible field and drops
+ * the internal `__deepline*` metadata keys.
+ */
+export function toSerializableCsvAliasedRow(
+  row: Record<string, unknown>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [field, value] of Object.entries(row)) {
+    if (field.startsWith('__deepline')) continue;
+    out[field] = value;
+  }
+  const projectedFields = getCsvProjectedFields(row);
+  if (projectedFields) {
+    const serializedValues = getCsvProjectedValues(row);
+    for (const field of projectedFields) {
+      if (Object.prototype.hasOwnProperty.call(out, field)) continue;
+      out[field] = row[field] ?? serializedValues?.[field];
+    }
+  }
+  return out;
+}
+
 export function stripCsvProjectedFields<T extends Record<string, unknown>>(
   row: T,
 ): T {

package/dist/repo/shared_libs/play-runtime/providers.ts

@@ -48,7 +48,7 @@ export const PLAY_RUNTIME_PROVIDERS: Record<
     runner: PLAY_RUNTIME_BACKENDS.daytona,
     dedup: PLAY_DEDUP_BACKENDS.durableObject,
     artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: 'Experimental Postgres Scheduler + warm sandbox runner + DO dedup',
+    label: 'BETA: Postgres Scheduler + warm sandbox runner + DO dedup',
   },
   postgres_fast_sandbox: {
     id: PLAY_RUNTIME_PROVIDER_IDS.postgresFastSandbox,
@@ -56,7 +56,7 @@ export const PLAY_RUNTIME_PROVIDERS: Record<
     runner: PLAY_RUNTIME_BACKENDS.daytona,
     dedup: PLAY_DEDUP_BACKENDS.durableObject,
     artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: 'Experimental Postgres Scheduler + warm sandbox runner + DO dedup',
+    label: 'BETA: Postgres Scheduler + warm sandbox runner + DO dedup',
   },
   postgres_fast_workers: {
     id: PLAY_RUNTIME_PROVIDER_IDS.postgresFastWorkers,