@webpresso/agent-kit 0.21.5 → 0.23.0

package/dist/esm/cli/commands/typecheck.js

@@ -1,7 +1,6 @@
 import { getManagedRunner } from '#tool-runtime';
+import { getPackageScript, isRecursiveWpScript } from '#cli/package-scripts.js';
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
 export const TYPECHECK_COMMAND_HELP = [
     'Typecheck the current workspace through the portable wp surface.',
     '',
@@ -17,17 +16,15 @@ export function registerTypecheckCommand(cli) {
 }
 export function buildTypecheckCommand(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    if (hasCheckTypesScript(cwd)) {
-        const resolution = getManagedRunner('vp');
+    const checkTypesScript = getPackageScript(cwd, 'check-types');
+    if (checkTypesScript && !isRecursiveWpScript(checkTypesScript, 'typecheck')) {
+        const resolution = getManagedRunner('vp', { outputPolicy: 'structured' });
         return {
             command: resolution.command,
             args: [...resolution.args, 'run', 'check-types'],
         };
     }
-    const resolution = getManagedRunner('tsc', {
-        fallbackCommand: 'tsc',
-        fallbackArgs: [],
-    });
+    const resolution = getManagedRunner('tsc', { outputPolicy: 'structured' });
     return {
         command: resolution.command,
         args: [...resolution.args, '--noEmit', ...(options.pretty ? [] : ['--pretty', 'false'])],
@@ -48,16 +45,4 @@ function defaultRun(command, args) {
         windowsHide: true,
     });
 }
-function hasCheckTypesScript(cwd) {
-    const packageJsonPath = join(cwd, 'package.json');
-    if (!existsSync(packageJsonPath))
-        return false;
-    try {
-        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-        return typeof parsed.scripts?.['check-types'] === 'string';
-    }
-    catch {
-        return false;
-    }
-}
 //# sourceMappingURL=typecheck.js.map

package/dist/esm/cli/package-scripts.d.ts

@@ -0,0 +1,12 @@
+export interface PackageJsonLike {
+    readonly scripts?: Record<string, unknown>;
+    readonly dependencies?: Record<string, unknown>;
+    readonly devDependencies?: Record<string, unknown>;
+    readonly optionalDependencies?: Record<string, unknown>;
+}
+export declare function readPackageJson(cwd: string): PackageJsonLike | undefined;
+export declare function getPackageScript(cwd: string, name: string): string | undefined;
+export declare function packageHasDependency(cwd: string, dependencyName: string): boolean;
+export declare function packageUsesVitest(cwd: string): boolean;
+export declare function isRecursiveWpScript(script: string, verb: string): boolean;
+//# sourceMappingURL=package-scripts.d.ts.map

package/dist/esm/cli/package-scripts.js

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function readPackageJson(cwd) {
+    const packageJsonPath = join(cwd, 'package.json');
+    if (!existsSync(packageJsonPath))
+        return;
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return;
+        return parsed;
+    }
+    catch {
+        return;
+    }
+}
+export function getPackageScript(cwd, name) {
+    const parsed = readPackageJson(cwd);
+    const candidate = parsed?.scripts?.[name];
+    return typeof candidate === 'string' ? candidate : undefined;
+}
+export function packageHasDependency(cwd, dependencyName) {
+    const parsed = readPackageJson(cwd);
+    if (!parsed)
+        return false;
+    return ['dependencies', 'devDependencies', 'optionalDependencies'].some((section) => {
+        const dependencies = parsed[section];
+        return Boolean(dependencies &&
+            typeof dependencies === 'object' &&
+            !Array.isArray(dependencies) &&
+            dependencyName in dependencies);
+    });
+}
+export function packageUsesVitest(cwd) {
+    return packageHasDependency(cwd, 'vitest');
+}
+export function isRecursiveWpScript(script, verb) {
+    const normalized = stripLeadingEnvAssignments(script.trim());
+    if (!normalized)
+        return false;
+    const patterns = [
+        new RegExp(`^(?:vp\\s+exec\\s+)?wp\\s+${escapeRegExp(verb)}(?:\\s|$)`),
+        new RegExp(`^(?:bunx?|npx)\\s+(?:--yes\\s+)?(?:@webpresso/agent-kit\\s+)?wp\\s+${escapeRegExp(verb)}(?:\\s|$)`),
+    ];
+    return patterns.some((pattern) => pattern.test(normalized));
+}
+function stripLeadingEnvAssignments(input) {
+    let remaining = input.replace(/^env\s+/u, '');
+    while (true) {
+        const next = remaining.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s+)/u, '');
+        if (next === remaining)
+            return remaining.trim();
+        remaining = next;
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+//# sourceMappingURL=package-scripts.js.map

package/dist/esm/cli/utils.js

@@ -5,8 +5,9 @@
  * unknown-command formatting) and webpresso/packages/cli/cli-utils
  * (getProjectRoot) so this package has no @webpresso/* runtime dependencies.
  */
-import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { readOwnedPackageVersion } from '#runtime/package-version.js';
 // ---------------------------------------------------------------------------
 // Project root resolution
 // ---------------------------------------------------------------------------
@@ -131,26 +132,6 @@ export function formatUnknownCommandError(input, commands, binName = 'wp') {
  * having to know how many `..` segments to append.
  */
 export function readPackageVersion(metaUrl) {
-    const url = new URL(metaUrl);
-    let dir = path.dirname(url.pathname);
-    for (let i = 0; i < 6; i++) {
-        const candidate = path.join(dir, 'package.json');
-        if (existsSync(candidate)) {
-            try {
-                const parsed = JSON.parse(readFileSync(candidate, 'utf-8'));
-                if (parsed.name === 'webpresso') {
-                    return parsed.version ?? '0.0.0';
-                }
-            }
-            catch {
-                // keep walking
-            }
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return '0.0.0';
+    return readOwnedPackageVersion(metaUrl);
 }
 //# sourceMappingURL=utils.js.map

package/dist/esm/cli/wp-extensions.d.ts

@@ -0,0 +1,14 @@
+import type { CAC } from 'cac';
+import { type LoadWpExtensionsOptions, type WpExtensionAliasV1 } from '#wp-extension';
+export interface RegisterWpExtensionsOptions extends LoadWpExtensionsOptions {
+    readonly cli: CAC;
+    readonly baseCommands: readonly string[];
+}
+export interface RegisteredWpExtensions {
+    readonly aliasMap: ReadonlyMap<string, WpExtensionAliasV1>;
+    readonly warnings: readonly string[];
+    readonly commandNames: readonly string[];
+}
+export declare function registerWpExtensions(options: RegisterWpExtensionsOptions): Promise<RegisteredWpExtensions>;
+export declare function resolveWpCommandAlias(command: string | undefined, aliasMap: ReadonlyMap<string, WpExtensionAliasV1>): string | undefined;
+//# sourceMappingURL=wp-extensions.d.ts.map

package/dist/esm/cli/wp-extensions.js

@@ -0,0 +1,34 @@
+import { loadWpExtensions, resolveAcceptedExtensionAliases, } from '#wp-extension';
+export async function registerWpExtensions(options) {
+    const loaded = await loadWpExtensions(options);
+    const warnings = loaded.flatMap((entry) => entry.warnings);
+    const commandNames = [];
+    const blockedCommandNames = new Set(options.baseCommands);
+    const registeredCommandNames = new Set();
+    for (const extension of loaded) {
+        if (!extension.extension || !extension.compatible || !extension.detected)
+            continue;
+        for (const command of extension.extension.commands) {
+            if (blockedCommandNames.has(command.name)) {
+                warnings.push(`${extension.packageName}: skipped command "${command.name}" because it collides with an existing command`);
+                continue;
+            }
+            command.register(options.cli);
+            commandNames.push(command.name);
+            blockedCommandNames.add(command.name);
+            registeredCommandNames.add(command.name);
+        }
+    }
+    const aliasResolution = resolveAcceptedExtensionAliases(loaded, options.baseCommands, registeredCommandNames);
+    return {
+        aliasMap: aliasResolution.aliases,
+        warnings: [...warnings, ...aliasResolution.warnings],
+        commandNames,
+    };
+}
+export function resolveWpCommandAlias(command, aliasMap) {
+    if (!command)
+        return command;
+    return aliasMap.get(command)?.commandName ?? command;
+}
+//# sourceMappingURL=wp-extensions.js.map

package/dist/esm/config/docs-lint/schemas/common.d.ts

@@ -46,8 +46,8 @@ export declare const implementationStatus: z.ZodEnum<{
     completed: "completed";
     draft: "draft";
     planned: "planned";
-    "in-progress": "in-progress";
     parked: "parked";
+    "in-progress": "in-progress";
     archived: "archived";
     current: "current";
     complete: "complete";

package/dist/esm/config/docs-lint/schemas/implementation-plan.d.ts

@@ -15,8 +15,8 @@ export declare const implementationPlanFrontmatter: z.ZodObject<{
         completed: "completed";
         draft: "draft";
         planned: "planned";
-        "in-progress": "in-progress";
         parked: "parked";
+        "in-progress": "in-progress";
         archived: "archived";
         current: "current";
         complete: "complete";
@@ -40,8 +40,8 @@ export declare const implementationPlanFrontmatter: z.ZodObject<{
             completed: "completed";
             draft: "draft";
             planned: "planned";
-            "in-progress": "in-progress";
             parked: "parked";
+            "in-progress": "in-progress";
             archived: "archived";
             current: "current";
             complete: "complete";

package/dist/esm/config/docs-lint/schemas/parent-roadmap.d.ts

@@ -14,8 +14,8 @@ export declare const parentRoadmapFrontmatter: z.ZodObject<{
         completed: "completed";
         draft: "draft";
         planned: "planned";
-        "in-progress": "in-progress";
         parked: "parked";
+        "in-progress": "in-progress";
         archived: "archived";
         current: "current";
         complete: "complete";

package/dist/esm/config/stryker/index.d.ts

@@ -40,5 +40,90 @@ export declare const baseConfig: {
     incremental: boolean;
     incrementalFile: string;
 };
+/**
+ * Extends baseConfig with TypeScript checker defaults.
+ * Use this in any TypeScript package instead of baseConfig directly.
+ *
+ * @example
+ * import { typescriptBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptBaseConfig }
+ * // or, for packages with a CF-pool vitest config:
+ * export default { ...typescriptBaseConfig, vitest: { configFile: 'vitest.stryker.config.ts' } }
+ */
+export declare const typescriptBaseConfig: {
+    checkers: string[];
+    tsconfigFile: string;
+    packageManager: string;
+    testRunner: string;
+    plugins: string[];
+    ignorePatterns: string[];
+    mutate: string[];
+    concurrency: number;
+    timeoutMS: number;
+    dryRunTimeoutMinutes: number;
+    ignoreStatic: boolean;
+    thresholds: {
+        high: number;
+        low: number;
+        break: number;
+    };
+    mutator: {
+        excludedMutations: string[];
+    };
+    reporters: string[];
+    htmlReporter: {
+        fileName: string;
+    };
+    jsonReporter: {
+        fileName: string;
+    };
+    incremental: boolean;
+    incrementalFile: string;
+};
+/**
+ * Extends typescriptBaseConfig for Cloudflare Workers packages whose vitest config
+ * uses @cloudflare/vitest-pool-workers (incompatible with Stryker's pool injection).
+ * Points to a per-package vitest.stryker.config.ts that uses the standard forks pool
+ * and excludes any tests that require CF runtime globals (cloudflare:test).
+ *
+ * @example
+ * import { typescriptWorkersBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptWorkersBaseConfig }
+ */
+export declare const typescriptWorkersBaseConfig: {
+    vitest: {
+        configFile: string;
+    };
+    checkers: string[];
+    tsconfigFile: string;
+    packageManager: string;
+    testRunner: string;
+    plugins: string[];
+    ignorePatterns: string[];
+    mutate: string[];
+    concurrency: number;
+    timeoutMS: number;
+    dryRunTimeoutMinutes: number;
+    ignoreStatic: boolean;
+    thresholds: {
+        high: number;
+        low: number;
+        break: number;
+    };
+    mutator: {
+        excludedMutations: string[];
+    };
+    reporters: string[];
+    htmlReporter: {
+        fileName: string;
+    };
+    jsonReporter: {
+        fileName: string;
+    };
+    incremental: boolean;
+    incrementalFile: string;
+};
 export default baseConfig;
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/config/stryker/index.js

@@ -75,5 +75,36 @@ export const baseConfig = {
     incremental: true,
     incrementalFile: 'reports/stryker-incremental.json',
 };
+/**
+ * Extends baseConfig with TypeScript checker defaults.
+ * Use this in any TypeScript package instead of baseConfig directly.
+ *
+ * @example
+ * import { typescriptBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptBaseConfig }
+ * // or, for packages with a CF-pool vitest config:
+ * export default { ...typescriptBaseConfig, vitest: { configFile: 'vitest.stryker.config.ts' } }
+ */
+export const typescriptBaseConfig = {
+    ...baseConfig,
+    checkers: ['typescript'],
+    tsconfigFile: 'tsconfig.json',
+};
+/**
+ * Extends typescriptBaseConfig for Cloudflare Workers packages whose vitest config
+ * uses @cloudflare/vitest-pool-workers (incompatible with Stryker's pool injection).
+ * Points to a per-package vitest.stryker.config.ts that uses the standard forks pool
+ * and excludes any tests that require CF runtime globals (cloudflare:test).
+ *
+ * @example
+ * import { typescriptWorkersBaseConfig } from '@webpresso/agent-kit/stryker'
+ *
+ * export default { ...typescriptWorkersBaseConfig }
+ */
+export const typescriptWorkersBaseConfig = {
+    ...typescriptBaseConfig,
+    vitest: { configFile: 'vitest.stryker.config.ts' },
+};
 export default baseConfig;
 //# sourceMappingURL=index.js.map

package/dist/esm/e2e/command-builder.js

@@ -16,7 +16,9 @@ function buildPlaywrightCommand(options) {
         throw new Error(`Step ${step.logName} uses runner "playwright" but does not define configPath.`);
     }
     const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
-    const resolution = withBaseDir(getManagedRunner('playwright', { filterOutput: options.filterOutput }), baseDir);
+    const resolution = withBaseDir(getManagedRunner('playwright', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    }), baseDir);
     const args = [...resolution.args, 'test', '--config', configArg];
     appendPlaywrightFlags(args, options);
     args.push(...(step.fixedArgs ?? []), ...files, ...(options.passthrough ?? []));
@@ -28,7 +30,9 @@ function buildVitestE2eCommand(options) {
         throw new Error(`Step ${step.logName} uses runner "vitest" but does not define configPath.`);
     }
     const { baseDir, configArg, files } = resolveRunnerPaths(step.configPath, options.files ?? []);
-    const resolution = withBaseDir(getManagedRunner('vitest', { filterOutput: options.filterOutput }), baseDir);
+    const resolution = withBaseDir(getManagedRunner('vitest', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    }), baseDir);
     const args = [...resolution.args, 'run', '--config', configArg];
     if (options.workers !== undefined) {
         args.push('--poolOptions.threads.maxThreads', String(options.workers));
@@ -114,4 +118,9 @@ function withBaseDir(resolution, baseDir) {
     }
     return { command: resolution.command, args: [...resolution.args] };
 }
+function resolveOutputPolicy(outputPolicy, filterOutput) {
+    if (outputPolicy)
+        return outputPolicy;
+    return filterOutput === false ? 'structured' : 'rtk-filtered';
+}
 //# sourceMappingURL=command-builder.js.map

package/dist/esm/e2e/config.d.ts

@@ -6,6 +6,62 @@ declare const webpressoConfigSchema: z.ZodObject<{
         hostAdapterModule: z.ZodString;
         hostAdapterExport: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    deploy: z.ZodOptional<z.ZodObject<{
+        cloudflare: z.ZodOptional<z.ZodObject<{
+            lanes: z.ZodObject<{
+                dev: z.ZodObject<{
+                    wranglerEnvName: z.ZodString;
+                }, z.core.$strict>;
+                preview_main: z.ZodObject<{
+                    wranglerEnvName: z.ZodString;
+                }, z.core.$strict>;
+                preview_pr: z.ZodObject<{
+                    wranglerEnvNamePattern: z.ZodString;
+                }, z.core.$strict>;
+                prd: z.ZodObject<{
+                    wranglerEnvName: z.ZodString & z.ZodType<"production", string, z.core.$ZodTypeInternals<"production", string>>;
+                    deployedWorkerNameMode: z.ZodLiteral<"top_level_name">;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            production: z.ZodObject<{
+                metadataPath: z.ZodLiteral<"infra/release-metadata.production.json">;
+            }, z.core.$strict>;
+            targets: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    single_worker: "single_worker";
+                    worker_plus_assets: "worker_plus_assets";
+                    monorepo_multi_target: "monorepo_multi_target";
+                }>;
+                topLevelWorkerName: z.ZodString;
+                previewTransport: z.ZodEnum<{
+                    custom_domain_env: "custom_domain_env";
+                    workers_dev_env: "workers_dev_env";
+                }>;
+                routeSpec: z.ZodOptional<z.ZodObject<{
+                    pattern: z.ZodString;
+                }, z.core.$strict>>;
+                durableObjectBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    className: z.ZodString;
+                    scriptName: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                vars: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                requiredSecrets: z.ZodArray<z.ZodString>;
+                storageMode: z.ZodEnum<{
+                    isolated: "isolated";
+                    shared_via_script_name: "shared_via_script_name";
+                }>;
+                destroyMode: z.ZodLiteral<"wrangler_delete_env">;
+                repoCleanupHook: z.ZodOptional<z.ZodString>;
+                blastRadiusDoc: z.ZodOptional<z.ZodString>;
+                productionStrategyDefault: z.ZodEnum<{
+                    direct: "direct";
+                    gradual: "gradual";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type WebpressoConfig = z.infer<typeof webpressoConfigSchema>;
 export type WebpressoE2eConfig = NonNullable<WebpressoConfig['e2e']>;

package/dist/esm/e2e/config.js

@@ -1,15 +1,129 @@
 import { z } from 'zod';
 export const WEBPRESSO_CONFIG_FILE_NAME = 'webpresso.config.ts';
 export const WEBPRESSO_CONFIG_EXPORT_NAME = 'webpressoConfig';
+const wranglerEnvNameSchema = z
+    .string()
+    .min(1, 'wranglerEnvName must not be empty.')
+    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'wranglerEnvName must be dash-safe lowercase letters, numbers, and hyphens only.');
 const e2eWebpressoConfigSchema = z
     .object({
     hostAdapterModule: z.string().min(1, 'e2e.hostAdapterModule must not be empty.'),
     hostAdapterExport: z.string().min(1, 'e2e.hostAdapterExport must not be empty.').optional(),
 })
     .strict();
+const cloudflareDeployLaneSchema = z
+    .object({
+    wranglerEnvName: wranglerEnvNameSchema,
+})
+    .strict();
+const previewPrCloudflareDeployLaneSchema = z
+    .object({
+    wranglerEnvNamePattern: z
+        .string()
+        .min(1, 'wranglerEnvNamePattern must not be empty.')
+        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*-<n>$/, 'wranglerEnvNamePattern must be dash-safe and end with -<n>.'),
+})
+    .strict();
+const productionCloudflareDeployLaneSchema = cloudflareDeployLaneSchema.extend({
+    wranglerEnvName: wranglerEnvNameSchema.refine((value) => value === 'production', {
+        message: 'deploy.cloudflare.lanes.prd.wranglerEnvName must be "production".',
+    }),
+    deployedWorkerNameMode: z.literal('top_level_name'),
+});
+const cloudflareRouteSpecSchema = z
+    .object({
+    pattern: z.string().min(1, 'routeSpec.pattern must not be empty.'),
+})
+    .strict();
+const cloudflareDurableObjectBindingSchema = z
+    .object({
+    name: z.string().min(1, 'durableObjectBindings[].name must not be empty.'),
+    className: z.string().min(1, 'durableObjectBindings[].className must not be empty.'),
+    scriptName: z.string().min(1, 'durableObjectBindings[].scriptName must not be empty.').optional(),
+})
+    .strict();
+const cloudflareTargetSchema = z
+    .object({
+    id: z.string().min(1, 'deploy.cloudflare.targets[].id must not be empty.'),
+    type: z.enum(['single_worker', 'worker_plus_assets', 'monorepo_multi_target']),
+    topLevelWorkerName: z.string().min(1, 'topLevelWorkerName must not be empty.'),
+    previewTransport: z.enum(['custom_domain_env', 'workers_dev_env']),
+    routeSpec: cloudflareRouteSpecSchema.optional(),
+    durableObjectBindings: z.array(cloudflareDurableObjectBindingSchema).optional(),
+    vars: z.record(z.string(), z.unknown()),
+    requiredSecrets: z.array(z.string().min(1, 'requiredSecrets[] must not be empty.')),
+    storageMode: z.enum(['isolated', 'shared_via_script_name']),
+    destroyMode: z.literal('wrangler_delete_env'),
+    repoCleanupHook: z.string().min(1, 'repoCleanupHook must not be empty.').optional(),
+    blastRadiusDoc: z.string().min(1, 'blastRadiusDoc must not be empty.').optional(),
+    productionStrategyDefault: z.enum(['direct', 'gradual']),
+})
+    .strict()
+    .superRefine((target, ctx) => {
+    const isDurableObjectTarget = (target.durableObjectBindings?.length ?? 0) > 0;
+    if (target.previewTransport === 'custom_domain_env' && !target.routeSpec) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['routeSpec'],
+            message: 'routeSpec is required when previewTransport is "custom_domain_env".',
+        });
+    }
+    if (isDurableObjectTarget && target.previewTransport !== 'custom_domain_env') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['previewTransport'],
+            message: 'Durable Object targets must use previewTransport "custom_domain_env" unless a future explicit exception contract is introduced.',
+        });
+    }
+    if (isDurableObjectTarget && Object.keys(target.vars).length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['vars'],
+            message: 'Durable Object targets must declare at least one env-specific var.',
+        });
+    }
+    if (isDurableObjectTarget && target.requiredSecrets.length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['requiredSecrets'],
+            message: 'Durable Object targets must declare at least one required secret name.',
+        });
+    }
+    if (target.storageMode === 'shared_via_script_name' && !target.blastRadiusDoc) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['blastRadiusDoc'],
+            message: 'blastRadiusDoc is required when storageMode is "shared_via_script_name".',
+        });
+    }
+});
+const cloudflareDeployConfigSchema = z
+    .object({
+    lanes: z
+        .object({
+        dev: cloudflareDeployLaneSchema,
+        preview_main: cloudflareDeployLaneSchema,
+        preview_pr: previewPrCloudflareDeployLaneSchema,
+        prd: productionCloudflareDeployLaneSchema,
+    })
+        .strict(),
+    production: z
+        .object({
+        metadataPath: z.literal('infra/release-metadata.production.json'),
+    })
+        .strict(),
+    targets: z.array(cloudflareTargetSchema),
+})
+    .strict();
+const deployWebpressoConfigSchema = z
+    .object({
+    cloudflare: cloudflareDeployConfigSchema.optional(),
+})
+    .strict();
 const webpressoConfigSchema = z
     .object({
     e2e: e2eWebpressoConfigSchema.optional(),
+    deploy: deployWebpressoConfigSchema.optional(),
 })
     .strict();
 export class WebpressoConfigValidationError extends Error {

package/dist/esm/e2e/execution.js

@@ -18,6 +18,7 @@ export async function createE2eExecutionPlan(input, cwd = process.cwd()) {
             workers: input.workers,
             testList: input.testList,
             passthrough: input.passthrough,
+            outputPolicy: input.outputPolicy,
             filterOutput: input.filterOutput,
         });
     }
@@ -36,6 +37,7 @@ export async function createE2eExecutionPlan(input, cwd = process.cwd()) {
             workers: input.workers,
             testList: input.testList,
             passthrough: input.passthrough,
+            outputPolicy: input.outputPolicy,
             filterOutput: input.filterOutput,
         });
     }
@@ -51,6 +53,7 @@ export async function createE2eExecutionPlan(input, cwd = process.cwd()) {
             workers: input.workers,
             testList: input.testList,
             passthrough: input.passthrough,
+            outputPolicy: input.outputPolicy,
             filterOutput: input.filterOutput,
         });
     }
@@ -63,6 +66,7 @@ export async function createE2eExecutionPlan(input, cwd = process.cwd()) {
         workers: input.workers,
         testList: input.testList,
         passthrough: input.passthrough,
+        outputPolicy: input.outputPolicy,
         filterOutput: input.filterOutput,
     });
 }

package/dist/esm/e2e/run-planner.js

@@ -76,6 +76,7 @@ function planE2eRunsFromSuites(options) {
                 workers: options.request.workers,
                 testList: options.request.testList,
                 passthrough: options.request.passthrough,
+                outputPolicy: options.request.outputPolicy,
                 filterOutput: options.request.filterOutput,
             });
             runs.push({

package/dist/esm/e2e/types.d.ts

@@ -1,3 +1,4 @@
+import type { ManagedRunnerOutputPolicy } from '#tool-runtime';
 export type E2eRunnerKind = 'playwright' | 'vitest' | 'command';
 export interface CommandConfig {
     command: string;
@@ -49,6 +50,7 @@ export interface E2eCommandRequest {
     testList?: string;
     passthrough?: readonly string[];
     filterOutput?: boolean;
+    outputPolicy?: ManagedRunnerOutputPolicy;
 }
 export interface E2eExecutionRequest extends E2eCommandRequest {
     suite?: string;

package/dist/esm/format/index.js

@@ -35,9 +35,7 @@ export async function runFormat(options = {}) {
     if (options.files && options.files.length > 0)
         args.push(...options.files);
     const resolution = getManagedRunner('oxfmt', {
-        fallbackCommand: 'oxfmt',
-        fallbackArgs: [],
-        filterOutput: false,
+        outputPolicy: 'structured',
     });
     const outcome = await runCommand(resolution.command, [...resolution.args, ...args], runOptions);
     if (isRunFailure(outcome)) {