deepline 0.1.73 → 0.1.76

package/dist/index.d.mts

@@ -1051,6 +1051,43 @@ interface PlayStagedFileRef {
     bytes: number;
 }
 
+type EnrichStepCommand = {
+    alias: string;
+    tool: string;
+    operation?: string;
+    payload: Record<string, unknown>;
+    extract_js?: string;
+    run_if_js?: string;
+    description?: string;
+    disabled?: boolean;
+};
+type EnrichWaterfallCommand = {
+    with_waterfall: string;
+    min_results?: number;
+    commands: EnrichCommand[];
+    description?: string;
+};
+type EnrichCommand = EnrichStepCommand | EnrichWaterfallCommand;
+type EnrichCompiledConfig = {
+    version: 1;
+    commands: EnrichCommand[];
+    cost_cap_usd_per_run?: number;
+    _comments?: Array<{
+        path: string;
+        lines: string[];
+    }>;
+    _expansion_preview?: {
+        plays: Array<{
+            alias: string;
+            tool_id: string;
+            template_group: string;
+            runtime_group: string;
+            estimated_credits_range: string;
+            steps: Array<Record<string, unknown>>;
+        }>;
+    };
+};
+
 type ExecuteToolRawOptions = {
     includeToolMetadata?: boolean;
 };
@@ -1350,6 +1387,12 @@ declare class DeeplineClient {
         sourceFiles?: Record<string, string>;
         artifact: Record<string, unknown>;
     }): Promise<PlayCheckResult>;
+    compileEnrichPlan(input: {
+        plan_args?: string[];
+        config?: unknown;
+    }): Promise<{
+        config: EnrichCompiledConfig;
+    }>;
     startPlayRunFromBundle(input: {
         name: string;
         sourceCode: string;
@@ -2143,12 +2186,17 @@ type ConditionalStepResolver<Row, Value, Else = null> = {
     readonly elseValue: Else;
     else<ValueElse>(value: ValueElse): ConditionalStepResolver<Row, Value, ValueElse>;
 };
+type StepOptions<Row> = {
+    readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+    readonly staleAfterSeconds?: number;
+};
 type StepProgram<Input, Output, Return = Output> = {
     readonly kind: 'steps';
     readonly steps: readonly PlayStepProgramStep[];
     readonly returnResolver?: StepResolver<Output, Return>;
     readonly __inputType?: (input: Input) => void;
     step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | ConditionalStepResolver<Output, Value> | StepProgramResolver<Output, Value>): StepProgram<Input, Output & Record<Name, Value>, Return>;
+    step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output>): StepProgram<Input, Output & Record<Name, Value | null>, Return>;
     return<Value>(resolver: StepResolver<Output, Value>): StepProgram<Input, Output, Value>;
 };
 type StepProgramResolver<Input, Return> = {
@@ -2159,9 +2207,11 @@ type StepProgramResolver<Input, Return> = {
 };
 type PlayStepProgramStep = {
     readonly name: string;
+    readonly staleAfterSeconds?: number;
     readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown>;
 };
 type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | StepProgramResolver<Row, Value>;
+type StepProgramOutput<TProgram> = TProgram extends StepProgram<any, infer Output, any> ? Output : never;
 type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
     /**
      * Define one output column for every row in this dataset.
@@ -2177,6 +2227,8 @@ type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
      * @returns The same dataset builder with the new column type.
      */
     withColumn<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;
+    withColumn<Name extends string, Value>(name: Name, resolver: StepResolver<OutputRow, Value> | StepProgramResolver<OutputRow, Value>, options: StepOptions<OutputRow>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;
+    withColumns<Program extends StepProgram<OutputRow, object, unknown>>(program: Program): DatasetBuilder<InputRow, StepProgramOutput<Program>>;
     /** @deprecated Dataset `.step(...)` was replaced by `.withColumn(...)`. */
     step<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): never;
     /**
@@ -2190,7 +2242,6 @@ type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
      */
     run(options?: {
         description?: string;
-        staleAfterSeconds?: number;
         key?: (keyof InputRow & string) | readonly (keyof InputRow & string)[] | ((row: InputRow, index: number) => string | number | readonly unknown[]);
     }): Promise<PlayDataset<OutputRow>>;
 };

package/dist/index.d.ts

@@ -1051,6 +1051,43 @@ interface PlayStagedFileRef {
     bytes: number;
 }
 
+type EnrichStepCommand = {
+    alias: string;
+    tool: string;
+    operation?: string;
+    payload: Record<string, unknown>;
+    extract_js?: string;
+    run_if_js?: string;
+    description?: string;
+    disabled?: boolean;
+};
+type EnrichWaterfallCommand = {
+    with_waterfall: string;
+    min_results?: number;
+    commands: EnrichCommand[];
+    description?: string;
+};
+type EnrichCommand = EnrichStepCommand | EnrichWaterfallCommand;
+type EnrichCompiledConfig = {
+    version: 1;
+    commands: EnrichCommand[];
+    cost_cap_usd_per_run?: number;
+    _comments?: Array<{
+        path: string;
+        lines: string[];
+    }>;
+    _expansion_preview?: {
+        plays: Array<{
+            alias: string;
+            tool_id: string;
+            template_group: string;
+            runtime_group: string;
+            estimated_credits_range: string;
+            steps: Array<Record<string, unknown>>;
+        }>;
+    };
+};
+
 type ExecuteToolRawOptions = {
     includeToolMetadata?: boolean;
 };
@@ -1350,6 +1387,12 @@ declare class DeeplineClient {
         sourceFiles?: Record<string, string>;
         artifact: Record<string, unknown>;
     }): Promise<PlayCheckResult>;
+    compileEnrichPlan(input: {
+        plan_args?: string[];
+        config?: unknown;
+    }): Promise<{
+        config: EnrichCompiledConfig;
+    }>;
     startPlayRunFromBundle(input: {
         name: string;
         sourceCode: string;
@@ -2143,12 +2186,17 @@ type ConditionalStepResolver<Row, Value, Else = null> = {
     readonly elseValue: Else;
     else<ValueElse>(value: ValueElse): ConditionalStepResolver<Row, Value, ValueElse>;
 };
+type StepOptions<Row> = {
+    readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+    readonly staleAfterSeconds?: number;
+};
 type StepProgram<Input, Output, Return = Output> = {
     readonly kind: 'steps';
     readonly steps: readonly PlayStepProgramStep[];
     readonly returnResolver?: StepResolver<Output, Return>;
     readonly __inputType?: (input: Input) => void;
     step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | ConditionalStepResolver<Output, Value> | StepProgramResolver<Output, Value>): StepProgram<Input, Output & Record<Name, Value>, Return>;
+    step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output>): StepProgram<Input, Output & Record<Name, Value | null>, Return>;
     return<Value>(resolver: StepResolver<Output, Value>): StepProgram<Input, Output, Value>;
 };
 type StepProgramResolver<Input, Return> = {
@@ -2159,9 +2207,11 @@ type StepProgramResolver<Input, Return> = {
 };
 type PlayStepProgramStep = {
     readonly name: string;
+    readonly staleAfterSeconds?: number;
     readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown>;
 };
 type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | StepProgramResolver<Row, Value>;
+type StepProgramOutput<TProgram> = TProgram extends StepProgram<any, infer Output, any> ? Output : never;
 type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
     /**
      * Define one output column for every row in this dataset.
@@ -2177,6 +2227,8 @@ type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
      * @returns The same dataset builder with the new column type.
      */
     withColumn<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;
+    withColumn<Name extends string, Value>(name: Name, resolver: StepResolver<OutputRow, Value> | StepProgramResolver<OutputRow, Value>, options: StepOptions<OutputRow>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;
+    withColumns<Program extends StepProgram<OutputRow, object, unknown>>(program: Program): DatasetBuilder<InputRow, StepProgramOutput<Program>>;
     /** @deprecated Dataset `.step(...)` was replaced by `.withColumn(...)`. */
     step<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): never;
     /**
@@ -2190,7 +2242,6 @@ type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
      */
     run(options?: {
         description?: string;
-        staleAfterSeconds?: number;
         key?: (keyof InputRow & string) | readonly (keyof InputRow & string)[] | ((row: InputRow, index: number) => string | number | readonly unknown[]);
     }): Promise<PlayDataset<OutputRow>>;
 };

package/dist/index.js

@@ -241,10 +241,10 @@ var import_node_path2 = require("path");
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.73",
-  apiContract: "2026-06-dataset-column-syntax-cutover",
+  version: "0.1.76",
+  apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.73",
+    latest: "0.1.76",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -1127,6 +1127,9 @@ var DeeplineClient = class {
   async checkPlayArtifact(input) {
     return this.http.post("/api/v2/plays/check", input);
   }
+  async compileEnrichPlan(input) {
+    return this.http.post("/api/v2/enrich/compile", input);
+  }
   async startPlayRunFromBundle(input) {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
@@ -2410,18 +2413,23 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
   steps;
   returnResolver;
   kind = "steps";
-  step(name, resolver) {
+  step(name, resolver, options) {
     if (!name.trim()) {
       throw new Error(
         "steps().step(name, ...) requires a non-empty step name."
       );
     }
+    const stepResolver = options?.runIf && !isConditionalStepResolver(resolver) ? new DeeplineConditionalStepResolver(
+      options.runIf,
+      resolver,
+      null
+    ) : resolver;
     return new _DeeplineStepProgram(
       [
         ...this.steps,
         {
           name,
-          resolver
+          resolver: stepResolver
         }
       ],
       this.returnResolver
@@ -2431,6 +2439,9 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
     return new _DeeplineStepProgram(this.steps, resolver);
   }
 };
+function isConditionalStepResolver(value) {
+  return value !== null && typeof value === "object" && value.kind === "conditional";
+}
 function steps() {
   return new DeeplineStepProgram([]);
 }

package/dist/index.mjs

@@ -179,10 +179,10 @@ import { join as join2 } from "path";
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.73",
-  apiContract: "2026-06-dataset-column-syntax-cutover",
+  version: "0.1.76",
+  apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.73",
+    latest: "0.1.76",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -1065,6 +1065,9 @@ var DeeplineClient = class {
   async checkPlayArtifact(input) {
     return this.http.post("/api/v2/plays/check", input);
   }
+  async compileEnrichPlan(input) {
+    return this.http.post("/api/v2/enrich/compile", input);
+  }
   async startPlayRunFromBundle(input) {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
@@ -2348,18 +2351,23 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
   steps;
   returnResolver;
   kind = "steps";
-  step(name, resolver) {
+  step(name, resolver, options) {
     if (!name.trim()) {
       throw new Error(
         "steps().step(name, ...) requires a non-empty step name."
       );
     }
+    const stepResolver = options?.runIf && !isConditionalStepResolver(resolver) ? new DeeplineConditionalStepResolver(
+      options.runIf,
+      resolver,
+      null
+    ) : resolver;
     return new _DeeplineStepProgram(
       [
         ...this.steps,
         {
           name,
-          resolver
+          resolver: stepResolver
         }
       ],
       this.returnResolver
@@ -2369,6 +2377,9 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
     return new _DeeplineStepProgram(this.steps, resolver);
   }
 };
+function isConditionalStepResolver(value) {
+  return value !== null && typeof value === "object" && value.kind === "conditional";
+}
 function steps() {
   return new DeeplineStepProgram([]);
 }

package/dist/repo/apps/play-runner-workers/src/entry.ts

@@ -151,6 +151,14 @@ import {
   isHardBillingToolHttpError,
   normalizeToolHttpErrorMessage,
 } from './runtime/tool-http-errors';
+import {
+  StepProgramDatasetBuilder,
+  type StepProgramDatasetOptions,
+} from '../../../shared_libs/play-runtime/step-program-dataset-builder';
+import {
+  DEEPLINE_CELL_META_FIELD,
+  shouldRecomputeCell,
+} from '../../../shared_libs/play-runtime/cell-staleness';
 
 // The play's default export. The bundler injects this — see bundle-play-file.ts.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -2028,6 +2036,7 @@ type WorkerConditionalStepResolver = {
 
 type WorkerStepProgramStep = {
   name: string;
+  staleAfterSeconds?: number;
   resolver:
     | WorkerStepResolver
     | WorkerConditionalStepResolver
@@ -3045,6 +3054,7 @@ async function prepareMapRows(input: {
   tableNamespace: string;
   rows: Record<string, unknown>[];
   outputFields: string[];
+  cellPolicies?: Record<string, { staleAfterSeconds?: number }>;
 }): Promise<{
   inserted: number;
   skipped: number;
@@ -3069,6 +3079,7 @@ async function prepareMapRows(input: {
     rows: input.rows.map((row) => ({ ...row })),
     runId: input.req.runId,
     userEmail: input.req.userEmail,
+    cellPolicies: input.cellPolicies,
   });
   for (const timing of result.timings ?? []) {
     const phase =
@@ -3217,12 +3228,16 @@ function createMinimalWorkerCtx(
       },
     );
     if (!response.ok) {
-      throw new Error(`Secret ${auth.secret.name} is not available to this run.`);
+      throw new Error(
+        `Secret ${auth.secret.name} is not available to this run.`,
+      );
     }
     const payload = (await response.json()) as { value?: unknown };
     const value = typeof payload.value === 'string' ? payload.value : null;
     if (!value) {
-      throw new Error(`Secret ${auth.secret.name} is not available to this run.`);
+      throw new Error(
+        `Secret ${auth.secret.name} is not available to this run.`,
+      );
     }
     secretRedactor.register(value);
     return auth.kind === 'bearer'
@@ -3355,6 +3370,7 @@ function createMinimalWorkerCtx(
           index: number,
         ) => Promise<unknown> | unknown)
     >,
+    cellPolicies?: Record<string, { staleAfterSeconds?: number }>,
     opts?: WorkerMapOptions,
   ): Promise<unknown> => {
     const mapStartedAt = nowMs();
@@ -3494,6 +3510,7 @@ function createMinimalWorkerCtx(
         req,
         tableNamespace: name,
         outputFields,
+        cellPolicies,
         rows: chunkEntries.map(({ row, rowKey }) => ({
           ...row,
           __deeplineRowKey: rowKey,
@@ -3568,10 +3585,11 @@ function createMinimalWorkerCtx(
         | Record<
             string,
             {
-              status: 'cached' | 'skipped';
+              status: 'cached' | 'skipped' | 'completed';
               stage?: string | null;
               reused?: boolean;
               runId?: string;
+              completedAt?: number;
             }
           >
         | undefined
@@ -3600,10 +3618,11 @@ function createMinimalWorkerCtx(
               const cellMetaPatch: Record<
                 string,
                 {
-                  status: 'cached' | 'skipped';
+                  status: 'cached' | 'skipped' | 'completed';
                   stage?: string | null;
                   reused?: boolean;
                   runId?: string;
+                  completedAt?: number;
                 }
               > = {};
               const waterfallOutputs: RecordedWaterfallOutput[] = [];
@@ -3639,7 +3658,28 @@ function createMinimalWorkerCtx(
                   ),
               };
               for (const [key, value] of fieldEntries) {
-                if (isCompletedWorkerFieldValue(enriched[key])) {
+                const rawCellMeta =
+                  enriched[DEEPLINE_CELL_META_FIELD] &&
+                  typeof enriched[DEEPLINE_CELL_META_FIELD] === 'object'
+                    ? (
+                        enriched[DEEPLINE_CELL_META_FIELD] as Record<
+                          string,
+                          unknown
+                        >
+                      )[key]
+                    : null;
+                const reuseDecision = shouldRecomputeCell({
+                  hasValue: isCompletedWorkerFieldValue(enriched[key]),
+                  meta:
+                    rawCellMeta && typeof rawCellMeta === 'object'
+                      ? (rawCellMeta as {
+                          status?: string;
+                          completedAt?: number;
+                        })
+                      : null,
+                  policy: cellPolicies?.[key],
+                });
+                if (reuseDecision.action === 'reuse') {
                   cellMetaPatch[key] = {
                     status: 'cached',
                     stage: key,
@@ -3669,6 +3709,13 @@ function createMinimalWorkerCtx(
                     stage: key,
                     runId: req.runId,
                   };
+                } else {
+                  cellMetaPatch[key] = {
+                    status: 'completed',
+                    stage: key,
+                    runId: req.runId,
+                    completedAt: nowMs(),
+                  };
                 }
               }
               for (const stepOutput of stepProgramOutputs) {
@@ -4017,37 +4064,63 @@ function createMinimalWorkerCtx(
   };
 
   class WorkerDatasetBuilder<T extends Record<string, unknown>> {
-    private readonly program: WorkerStepProgram = {
-      kind: 'steps',
-      steps: [],
-    };
+    private readonly builder: StepProgramDatasetBuilder<
+      WorkerStepProgramStep,
+      WorkerStepProgramStep['resolver'],
+      WorkerMapOptions,
+      Promise<unknown>
+    >;
 
     constructor(
       private readonly name: string,
       private readonly rows: WorkerDatasetInput<T>,
-    ) {}
+    ) {
+      this.builder = new StepProgramDatasetBuilder(
+        (program, opts) => {
+          const fields = Object.fromEntries(
+            program.steps.map((step) => [step.name, step.resolver]),
+          );
+          const cellPolicies = Object.fromEntries(
+            program.steps.map((step) => [
+              step.name,
+              step.staleAfterSeconds === undefined
+                ? {}
+                : { staleAfterSeconds: step.staleAfterSeconds },
+            ]),
+          );
+          return runMap(this.name, this.rows, fields, cellPolicies, opts);
+        },
+        {
+          emptyColumnName:
+            'ctx.dataset(...).withColumn(name, ...) requires a name.',
+          invalidColumnsProgram:
+            'ctx.dataset(...).withColumns(...) requires a steps() program.',
+          legacyStep:
+            'ctx.dataset(...).step(...) has been replaced by ctx.dataset(...).withColumn(...).',
+        },
+      );
+    }
 
-    withColumn(name: string, resolver: WorkerStepProgramStep['resolver']): this {
-      if (!name.trim()) {
-        throw new Error(
-          'ctx.dataset(...).withColumn(name, ...) requires a name.',
-        );
-      }
-      this.program.steps = [...this.program.steps, { name, resolver }];
+    withColumn(
+      name: string,
+      resolver: WorkerStepProgramStep['resolver'],
+      options?: StepProgramDatasetOptions,
+    ): this {
+      this.builder.withColumn(name, resolver, options);
+      return this;
+    }
+
+    withColumns(program: WorkerStepProgram): this {
+      this.builder.withColumns(program);
       return this;
     }
 
     step(): never {
-      throw new Error(
-        'ctx.dataset(...).step(...) has been replaced by ctx.dataset(...).withColumn(...).',
-      );
+      return this.builder.step();
     }
 
     run(opts?: WorkerMapOptions): Promise<unknown> {
-      const fields = Object.fromEntries(
-        this.program.steps.map((step) => [step.name, step.resolver]),
-      );
-      return runMap(this.name, this.rows, fields, opts);
+      return this.builder.run(opts);
     }
   }
 
@@ -4233,7 +4306,15 @@ function createMinimalWorkerCtx(
         const fields = Object.fromEntries(
           fieldsDef.steps.map((step) => [step.name, step.resolver]),
         );
-        return runMap(name, rows, fields, opts);
+        const cellPolicies = Object.fromEntries(
+          fieldsDef.steps.map((step) => [
+            step.name,
+            step.staleAfterSeconds === undefined
+              ? {}
+              : { staleAfterSeconds: step.staleAfterSeconds },
+          ]),
+        );
+        return runMap(name, rows, fields, cellPolicies, opts);
       }
       throw new Error(
         'ctx.dataset(key, rows, fields, options) is not supported. Use ctx.dataset(key, rows).withColumn(...).run(options).',
@@ -4244,11 +4325,11 @@ function createMinimalWorkerCtx(
         'ctx.map(...) has been replaced by ctx.dataset(...). Use ctx.dataset(key, rows).withColumn(...).run(options).',
       );
     },
-	    tools: {
-	      async execute(requestArg: unknown): Promise<unknown> {
+    tools: {
+      async execute(requestArg: unknown): Promise<unknown> {
         assertNotAborted(abortSignal);
         const request = normalizeToolExecuteArgs(requestArg);
-	        assertNoSecretTaint(request.input, 'ctx.tools.execute input');
+        assertNoSecretTaint(request.input, 'ctx.tools.execute input');
         return await executeWithRuntimeReceipt(
           `tool:${request.id}:${deriveToolRequestIdentity({
             toolId: request.toolId,
@@ -4318,9 +4399,9 @@ function createMinimalWorkerCtx(
         timeoutMs?: number;
         staleAfterSeconds?: number;
       },
-	    ): Promise<unknown> {
-	      const normalizedKey = normalizeContextKey(key, 'runPlay');
-	      const resolvedName = resolvePlayRefName(playRef);
+    ): Promise<unknown> {
+      const normalizedKey = normalizeContextKey(key, 'runPlay');
+      const resolvedName = resolvePlayRefName(playRef);
       assertNoSecretTaint(input, 'ctx.runPlay input');
       if (!resolvedName) {
         throw new Error('ctx.runPlay(...) requires a resolvable play name.');
@@ -4560,18 +4641,15 @@ function createMinimalWorkerCtx(
         }
       });
     },
-	    async fetch(
-	      key: string,
-	      input: string | URL,
-	      init: SecretAwareRequestInit = {},
-	      options?: { staleAfterSeconds?: number },
-	    ): Promise<WorkerFetchResponse> {
-	      assertNotAborted(abortSignal);
-	      const normalizedKey = normalizeContextKey(key, 'fetch');
-      if (
-        valueContainsSecret(input) ||
-        valueContainsSecret(init.body)
-      ) {
+    async fetch(
+      key: string,
+      input: string | URL,
+      init: SecretAwareRequestInit = {},
+      options?: { staleAfterSeconds?: number },
+    ): Promise<WorkerFetchResponse> {
+      assertNotAborted(abortSignal);
+      const normalizedKey = normalizeContextKey(key, 'fetch');
+      if (valueContainsSecret(input) || valueContainsSecret(init.body)) {
         throw new Error(
           'ctx.fetch does not allow secrets in the URL or body. Use an approved secret auth helper.',
         );
@@ -4584,10 +4662,10 @@ function createMinimalWorkerCtx(
       if (init.auth !== undefined && !isSecretAuth(init.auth)) {
         throw new Error('ctx.fetch auth must come from ctx.secrets.');
       }
-	      const url = input.toString();
-	      const method = (init.method ?? 'GET').toUpperCase();
+      const url = input.toString();
+      const method = (init.method ?? 'GET').toUpperCase();
       const secretHeaderMarkers = secretAuthHeaderMarkers(init.auth);
-	      const safeHeaders = {
+      const safeHeaders = {
         ...normalizeFetchHeaders(init.headers),
         ...secretHeaderMarkers,
       };
@@ -4606,7 +4684,7 @@ function createMinimalWorkerCtx(
         safeHeaders,
         url,
       })}${staleRuntimeSuffix(options?.staleAfterSeconds)}`;
-	      return await executeWithRuntimeReceipt(receiptKey, async () => {
+      return await executeWithRuntimeReceipt(receiptKey, async () => {
         const secretHeaders = await resolveSecretAuth(init.auth);
         const headers = {
           ...normalizeFetchHeaders(init.headers),
@@ -4614,23 +4692,23 @@ function createMinimalWorkerCtx(
         };
         const fetchInit = { ...init, headers };
         delete fetchInit.auth;
-	        const response = await fetch(url, fetchInit);
-	        assertNotAborted(abortSignal);
-	        const bodyText = await response.text();
+        const response = await fetch(url, fetchInit);
+        assertNotAborted(abortSignal);
+        const bodyText = await response.text();
         const redactedBodyText = secretRedactor.redactString(bodyText);
-	        return {
-	          ok: response.ok,
-	          status: response.status,
-	          statusText: response.statusText,
-	          url: response.url,
-	          headers: secretRedactor.redact(
-              Object.fromEntries(response.headers.entries()),
-            ) as Record<string, string>,
-	          bodyText: redactedBodyText,
-	          json: secretRedactor.redact(parseFetchJsonOrNull(bodyText)),
-	        };
-	      });
-	    },
+        return {
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          headers: secretRedactor.redact(
+            Object.fromEntries(response.headers.entries()),
+          ) as Record<string, string>,
+          bodyText: redactedBodyText,
+          json: secretRedactor.redact(parseFetchJsonOrNull(bodyText)),
+        };
+      });
+    },
     secrets: {
       get(name: string): SecretHandle {
         if (typeof name !== 'string' || !name.trim()) {