wrangler 4.98.0 → 4.100.0

package/wrangler-dist/cli.d.ts

@@ -1,14 +1,15 @@
-import { Rule as Rule$1, CfModule, Environment as Environment$1, Entry, CfModuleType, ApiCredentials, Config as Config$1, Binding, DurableObjectMigration as DurableObjectMigration$1, ContainerApp as ContainerApp$1, Trigger, CfTailConsumer, ServiceFetch, ContainerEngine as ContainerEngine$1, CfUnsafe, CfScriptFormat, AssetsOptions as AssetsOptions$1, ConfigBindingFieldName, NormalizeAndValidateConfigArgs, ResolveConfigPathOptions, RawConfig as RawConfig$1, PackageJSON, ParseError, ComplianceConfig, UserError, FatalError } from '@cloudflare/workers-utils';
+import { Rule as Rule$1, CfModule, Environment as Environment$1, Entry, CfModuleType, StartDevWorkerInput, NodeJSCompatMode, CfScriptFormat, Config as Config$1, AsyncHook, CfAccount as CfAccount$1, AssetsOptions as AssetsOptions$1, Binding, ConfigBindingFieldName, RawConfig as RawConfig$1, NormalizeAndValidateConfigArgs, ResolveConfigPathOptions, PackageJSON, ApiCredentials, ParseError, LoggerLevel, ComplianceConfig, UserError, FatalError } from '@cloudflare/workers-utils';
 export { Binding, experimental_patchConfig, experimental_readRawConfig, defaultWranglerConfig as unstable_defaultWranglerConfig } from '@cloudflare/workers-utils';
-import { Json as Json$1, WorkerRegistry, Miniflare, MiniflareOptions, Mutex, Response as Response$1, NodeJSCompatMode, DispatchFetch, RemoteProxyConnectionString, WorkerOptions, ModuleRule, Request } from 'miniflare';
+import { Json as Json$1, WorkerdStructuredLog, DispatchFetch, Miniflare, WorkerRegistry, MiniflareOptions, Mutex, Response as Response$1, RemoteProxyConnectionString, WorkerOptions, ModuleRule, Request } from 'miniflare';
 import * as undici from 'undici';
 import { RequestInfo, RequestInit, Response, FormData } from 'undici';
 import { Metafile } from 'esbuild';
 import Protocol from 'devtools-protocol/types/protocol-mapping';
 import { EventEmitter } from 'node:events';
 import { ContainerNormalizedConfig } from '@cloudflare/containers-shared';
+import { FetcherScheduledOptions, FetcherScheduledResult, IncomingRequestCfProperties } from '@cloudflare/workers-types/experimental';
 import { RouterConfig, AssetConfig } from '@cloudflare/workers-shared';
-import { IncomingRequestCfProperties } from '@cloudflare/workers-types/experimental';
+export { printBindings as unstable_printBindings } from '@cloudflare/deploy-helpers';
 import { URLSearchParams } from 'node:url';
 import { Argv, PositionalOptions, Options, ArgumentsCamelCase, InferredOptionTypes, InferredOptionType } from 'yargs';
 import Cloudflare from 'cloudflare';
@@ -168,8 +169,8 @@ interface PagesDeployOptions {
  */
 declare function deploy({ directory, accountId, projectName, branch, skipCaching, commitMessage, commitHash, commitDirty, functionsDirectory: customFunctionsDirectory, bundle, sourceMaps, args, }: PagesDeployOptions): Promise<{
     deploymentResponse: {
-        url: string;
         id: string;
+        url: string;
         environment: "production" | "preview";
         build_config: {
             build_command: string;
@@ -192,14 +193,14 @@ declare function deploy({ directory, accountId, projectName, branch, skipCaching
             };
         };
         latest_stage: {
-            status: "skipped" | "active" | "canceled" | "idle" | "success" | "failure";
-            name: "build" | "queued" | "deploy" | "initialize" | "clone_repo";
+            status: "skipped" | "active" | "canceled" | "success" | "idle" | "failure";
+            name: "queued" | "build" | "deploy" | "initialize" | "clone_repo";
             started_on: string | null;
             ended_on: string | null;
         };
         stages: {
-            status: "skipped" | "active" | "canceled" | "idle" | "success" | "failure";
-            name: "build" | "queued" | "deploy" | "initialize" | "clone_repo";
+            status: "skipped" | "active" | "canceled" | "success" | "idle" | "failure";
+            name: "queued" | "build" | "deploy" | "initialize" | "clone_repo";
             started_on: string | null;
             ended_on: string | null;
         }[];
@@ -303,6 +304,13 @@ type Experimental_GenerateTypesResult = GenerateTypesResult;
  */
 declare function generateTypes(options: Experimental_GenerateTypesOptions): Promise<Experimental_GenerateTypesResult>;
 
+type _Params<ParamsArray extends [unknown?]> = ParamsArray extends [infer P] ? P : undefined;
+type _EventMethods = keyof Protocol.Events;
+type DevToolsEvent<Method extends _EventMethods> = Method extends unknown ? {
+    method: Method;
+    params: _Params<Protocol.Events[Method]>;
+} : never;
+
 /**
  * Information about Wrangler's bundling process that needs passed through
  * for DevTools sourcemap transformation
@@ -324,28 +332,64 @@ type EsbuildBundle = {
     sourceMapMetadata: SourceMapMetadata | undefined;
 };
 
-/**
- * A Cloudflare account.
- */
-interface CfAccount {
-    /**
-     * An API token.
-     *
-     * @link https://api.cloudflare.com/#user-api-tokens-properties
-     */
-    apiToken: ApiCredentials;
-    /**
-     * An account ID.
-     */
-    accountId: string;
+declare class ConfigController extends Controller {
+    #private;
+    latestInput?: StartDevWorkerInput;
+    latestConfig?: StartDevWorkerOptions;
+    set(input: StartDevWorkerInput, throwErrors?: boolean): Promise<StartDevWorkerOptions | undefined>;
+    patch(input: Partial<StartDevWorkerInput>): Promise<StartDevWorkerOptions | undefined>;
+    onDevRegistryUpdate(event: DevRegistryUpdateEvent): void;
+    teardown(): Promise<void>;
+    emitConfigUpdateEvent(config: StartDevWorkerOptions): void;
 }
 
-type _Params<ParamsArray extends [unknown?]> = ParamsArray extends [infer P] ? P : undefined;
-type _EventMethods = keyof Protocol.Events;
-type DevToolsEvent<Method extends _EventMethods> = Method extends unknown ? {
-    method: Method;
-    params: _Params<Protocol.Events[Method]>;
-} : never;
+type MiniflareWorker = Awaited<ReturnType<Miniflare["getWorker"]>>;
+interface Worker {
+    ready: Promise<void>;
+    url: Promise<URL>;
+    inspectorUrl: Promise<URL | undefined>;
+    config: StartDevWorkerOptions;
+    setConfig: ConfigController["set"];
+    patchConfig: ConfigController["patch"];
+    fetch: DispatchFetch;
+    scheduled: MiniflareWorker["scheduled"];
+    queue: MiniflareWorker["queue"];
+    dispose(): Promise<void>;
+    raw: DevEnv;
+}
+type StartDevWorkerOptions = Omit<StartDevWorkerInput, "assets" | "config" | "containers" | "dev"> & {
+    /** The configuration path of the worker */
+    config?: string;
+    /** A worker's directory. Usually where the Wrangler configuration file is located */
+    projectRoot: string;
+    build: StartDevWorkerInput["build"] & {
+        nodejsCompatMode: NodeJSCompatMode;
+        format: CfScriptFormat;
+        moduleRoot: string;
+        moduleRules: Rule$1[];
+        define: Record<string, string>;
+        additionalModules: CfModule[];
+        exports: string[];
+        processEntrypoint: boolean;
+    };
+    legacy: StartDevWorkerInput["legacy"] & {
+        site?: Config$1["site"];
+    };
+    dev: StartDevWorkerInput["dev"] & {
+        persist: string | false;
+        auth?: AsyncHook<CfAccount$1>;
+        /** Handles structured runtime logs. */
+        structuredLogsHandler?: (log: WorkerdStructuredLog) => void;
+        /** An undici MockAgent to declaratively mock fetch calls to particular resources. */
+        mockFetch?: undici.MockAgent;
+    };
+    entrypoint: string;
+    assets?: AssetsOptions$1;
+    containers?: ContainerNormalizedConfig[];
+    name: string;
+    complianceRegion: Config$1["compliance_region"];
+};
+type Bundle = EsbuildBundle;
 
 type ErrorEvent = BaseErrorEvent<"ConfigController" | "BundlerController" | "LocalRuntimeController" | "RemoteRuntimeController" | "ProxyWorker" | "InspectorProxyWorker" | "MultiworkerRuntimeController"> | BaseErrorEvent<"ProxyController", {
     config?: StartDevWorkerOptions;
@@ -470,22 +514,12 @@ declare abstract class RuntimeController extends Controller {
     abstract onBundleStart(_: BundleStartEvent): void;
     abstract onBundleComplete(_: BundleCompleteEvent): void;
     abstract onPreviewTokenExpired(_: PreviewTokenExpiredEvent): void;
+    abstract get mf(): Miniflare | undefined;
     protected emitReloadStartEvent(data: ReloadStartEvent): void;
     protected emitReloadCompleteEvent(data: ReloadCompleteEvent): void;
     protected emitDevRegistryUpdateEvent(data: DevRegistryUpdateEvent): void;
 }
 
-declare class ConfigController extends Controller {
-    #private;
-    latestInput?: StartDevWorkerInput;
-    latestConfig?: StartDevWorkerOptions;
-    set(input: StartDevWorkerInput, throwErrors?: boolean): Promise<StartDevWorkerOptions | undefined>;
-    patch(input: Partial<StartDevWorkerInput>): Promise<StartDevWorkerOptions | undefined>;
-    onDevRegistryUpdate(event: DevRegistryUpdateEvent): void;
-    teardown(): Promise<void>;
-    emitConfigUpdateEvent(config: StartDevWorkerOptions): void;
-}
-
 declare class BundlerController extends Controller {
     #private;
     onConfigUpdate(event: ConfigUpdateEvent): void;
@@ -494,6 +528,13 @@ declare class BundlerController extends Controller {
     emitBundleCompleteEvent(config: StartDevWorkerOptions, bundle: EsbuildBundle): void;
 }
 
+type MaybePromise<T> = T | Promise<T>;
+type DeferredPromise<T> = {
+    promise: Promise<T>;
+    resolve: (_: MaybePromise<T>) => void;
+    reject: (_: Error) => void;
+};
+
 declare class ProxyController extends Controller {
     ready: DeferredPromise<ReadyEvent>;
     localServerReady: DeferredPromise<void>;
@@ -560,213 +601,294 @@ declare class DevEnv extends EventEmitter implements ControllerBus {
     teardown(): Promise<void>;
 }
 
-type MiniflareWorker = Awaited<ReturnType<Miniflare["getWorker"]>>;
-interface Worker {
-    ready: Promise<void>;
-    url: Promise<URL>;
-    inspectorUrl: Promise<URL | undefined>;
-    config: StartDevWorkerOptions;
-    setConfig: ConfigController["set"];
-    patchConfig: ConfigController["patch"];
-    fetch: DispatchFetch;
-    scheduled: MiniflareWorker["scheduled"];
-    queue: MiniflareWorker["queue"];
-    dispose(): Promise<void>;
-    raw: DevEnv;
-}
-interface StartDevWorkerInput {
-    /** The name of the worker. */
-    name?: string;
-    /**
-     * The javascript or typescript entry-point of the worker.
-     * This is the `main` property of a Wrangler configuration file.
-     */
-    entrypoint?: string;
-    /** The configuration path of the worker. */
-    config?: string;
-    /** The compatibility date for the workerd runtime. */
-    compatibilityDate?: string;
-    /** The compatibility flags for the workerd runtime. */
-    compatibilityFlags?: string[];
-    /** Specify the compliance region mode of the Worker. */
-    complianceRegion?: Config$1["compliance_region"];
-    /** Configuration for Python modules. */
-    pythonModules?: {
-        /** A list of glob patterns to exclude files from the python_modules directory when bundling. */
-        exclude?: string[];
+declare function startWorker(options: StartDevWorkerInput): Promise<Worker>;
+
+declare const dev: {
+    args: {
+        v: boolean | undefined;
+        cwd: string | undefined;
+        config: string | undefined;
+        env: string | undefined;
+        envFile: string[] | undefined;
+        experimentalProvision: boolean | undefined;
+        experimentalAutoCreate: boolean;
+        installSkills: boolean;
+        script: string | undefined;
+        name: string | undefined;
+        compatibilityDate: string | undefined;
+        compatibilityFlags: string[] | undefined;
+        latest: boolean;
+        assets: string | undefined;
+        bundle: boolean | undefined;
+        noBundle: boolean;
+        ip: string | undefined;
+        port: number | undefined;
+        inspectorPort: number | undefined;
+        inspectorIp: string | undefined;
+        routes: string[] | undefined;
+        host: string | undefined;
+        localProtocol: "http" | "https" | undefined;
+        httpsKeyPath: string | undefined;
+        httpsCertPath: string | undefined;
+        localUpstream: string | undefined;
+        enableContainers: boolean | undefined;
+        site: string | undefined;
+        siteInclude: string[] | undefined;
+        siteExclude: string[] | undefined;
+        upstreamProtocol: "http" | "https" | undefined;
+        var: string[] | undefined;
+        define: string[] | undefined;
+        alias: string[] | undefined;
+        jsxFactory: string | undefined;
+        jsxFragment: string | undefined;
+        tsconfig: string | undefined;
+        remote: boolean;
+        local: boolean | undefined;
+        minify: boolean | undefined;
+        nodeCompat: boolean | undefined;
+        persistTo: string | undefined;
+        liveReload: boolean | undefined;
+        legacyEnv: boolean | undefined;
+        testScheduled: boolean;
+        logLevel: "debug" | "none" | "error" | "log" | "info" | "warn" | undefined;
+        showInteractiveDevSession: boolean | undefined;
+        types: boolean | undefined;
+        tunnel: boolean | undefined;
+        tunnelName: string | undefined;
+        experimentalNewConfig: boolean;
+        _: (string | number)[];
+        $0: string;
     };
-    env?: string;
-    /**
-     * An array of paths to the .env files to load for this worker, relative to the project directory.
-     *
-     * If not specified, defaults to the standard `.env` files as given by `getDefaultEnvFiles()`.
-     * The project directory is where the Wrangler configuration file is located or the current working directory otherwise.
-     */
-    envFiles?: string[];
-    /** The bindings available to the worker. The specified bindind type will be exposed to the worker on the `env` object under the same key. */
-    bindings?: Record<string, Binding>;
+};
+type AdditionalDevProps = {
     /**
-     * Default bindings that can be overridden by config bindings.
+     * Default vars that can be overridden by config vars.
      * Useful for injecting environment-specific defaults like CF_PAGES variables.
      */
     defaultBindings?: Record<string, Extract<Binding, {
         type: "plain_text";
     }>>;
-    migrations?: DurableObjectMigration$1[];
-    containers?: ContainerApp$1[];
-    /** The triggers which will cause the worker's exported default handlers to be called. */
-    triggers?: Trigger[];
-    tailConsumers?: CfTailConsumer[];
-    streamingTailConsumers?: CfTailConsumer[];
-    /**
-     * Whether Wrangler should send usage metrics to Cloudflare for this project.
-     *
-     * When defined this will override any user settings.
-     * Otherwise, Wrangler will use the user's preference.
-     */
-    sendMetrics?: boolean;
-    /** Options applying to the worker's build step. Applies to deploy and dev. */
-    build?: {
-        /** Whether the worker and its dependencies are bundled. Defaults to true. */
-        bundle?: boolean;
-        additionalModules?: CfModule[];
-        findAdditionalModules?: boolean;
-        processEntrypoint?: boolean;
-        /** Specifies types of modules matched by globs. */
-        moduleRules?: Rule$1[];
-        /** Replace global identifiers with constant expressions, e.g. { debug: 'true', version: '"1.0.0"' }. Only takes effect if bundle: true. */
-        define?: Record<string, string>;
-        /** Alias modules */
-        alias?: Record<string, string>;
-        /** Whether the bundled worker is minified. Only takes effect if bundle: true. */
-        minify?: boolean;
-        /** Whether to keep function names after JavaScript transpilations. */
-        keepNames?: boolean;
-        /** Options controlling a custom build step. */
-        custom?: {
-            /** Custom shell command to run before bundling. Runs even if bundle. */
-            command?: string;
-            /** The cwd to run the command in. */
-            workingDirectory?: string;
-            /** Filepath(s) to watch for changes. Upon changes, the command will be rerun. */
-            watch?: string | string[];
-        };
-        jsxFactory?: string;
-        jsxFragment?: string;
-        tsconfig?: string;
-        nodejsCompatMode?: Hook<NodeJSCompatMode, [Config$1]>;
-        moduleRoot?: string;
-    };
-    /** Options applying to the worker's development preview environment. */
-    dev?: {
-        /** Options applying to the worker's inspector server. False disables the inspector server. */
-        inspector?: {
-            hostname?: string;
-            port?: number;
-            secure?: boolean;
-        } | false;
-        /** Whether the worker runs on the edge or locally. This has several options:
-         *   - true | "minimal": Run your Worker's code & bindings in a remote preview session, optionally using minimal mode as an internal detail
-         *   - false: Run your Worker's code & bindings in a local simulator
-         *   - undefined (default): Run your Worker's code locally, and any configured remote bindings remotely
-         */
-        remote?: boolean | "minimal";
-        /** Cloudflare Account credentials. Can be provided upfront or as a function which will be called only when required. */
-        auth?: AsyncHook<CfAccount, [Pick<Config$1, "account_id">]>;
-        /** Whether local storage (KV, Durable Objects, R2, D1, etc) is persisted. You can also specify the directory to persist data to. Set to `false` to disable persistence. */
-        persist?: string | false;
-        /** Controls which logs are logged 🤙. */
-        logLevel?: LogLevel;
-        /** Whether the worker server restarts upon source/config file changes. */
-        watch?: boolean;
-        /** Whether a script tag is inserted on text/html responses which will reload the page upon file changes. Defaults to false. */
-        liveReload?: boolean;
-        /** The local address to reach your worker. Applies to remote: true (remote mode) and remote: false (local mode). */
-        server?: {
-            hostname?: string;
-            port?: number;
-            secure?: boolean;
-            httpsKeyPath?: string;
-            httpsCertPath?: string;
-        };
-        /** Controls what request.url looks like inside the worker. */
-        origin?: {
-            hostname?: string;
-            secure?: boolean;
-        };
-        /** A hook for outbound fetch calls from within the worker. */
-        outboundService?: ServiceFetch;
-        /** An undici MockAgent to declaratively mock fetch calls to particular resources. */
-        mockFetch?: undici.MockAgent;
-        testScheduled?: boolean;
-        /** Treat this as the primary worker in a multiworker setup (i.e. the first Worker in Miniflare's options) */
-        multiworkerPrimary?: boolean;
-        containerBuildId?: string;
-        /** Whether to build and connect to containers during local dev. Requires Docker daemon to be running. Defaults to true. */
-        enableContainers?: boolean;
-        /** Path to the dev registry directory */
-        registry?: string;
-        /** Path to the docker executable. Defaults to 'docker' */
-        dockerPath?: string;
-        /** Options for the container engine */
-        containerEngine?: ContainerEngine$1;
-        /** Re-generate your worker types when your Wrangler configuration file changes */
-        generateTypes?: boolean;
-        /** Tunnel configuration for this dev session. */
-        tunnel?: {
-            enabled: boolean;
-            name?: string;
-        };
-    };
-    legacy?: {
-        site?: Hook<Config$1["site"], [Config$1]>;
-        useServiceEnvironments?: boolean;
-    };
-    unsafe?: Omit<CfUnsafe, "bindings">;
-    assets?: string;
-    experimental?: Record<string, never>;
-}
-type StartDevWorkerOptions = Omit<StartDevWorkerInput, "assets" | "containers" | "dev"> & {
-    /** A worker's directory. Usually where the Wrangler configuration file is located */
-    projectRoot: string;
-    build: StartDevWorkerInput["build"] & {
-        nodejsCompatMode: NodeJSCompatMode;
-        format: CfScriptFormat;
-        moduleRoot: string;
-        moduleRules: Rule$1[];
-        define: Record<string, string>;
-        additionalModules: CfModule[];
-        exports: string[];
-        processEntrypoint: boolean;
+    vars?: Record<string, string | Json$1>;
+    kv?: {
+        binding: string;
+        id?: string;
+        preview_id?: string;
+    }[];
+    durableObjects?: {
+        name: string;
+        class_name: string;
+        script_name?: string | undefined;
+        environment?: string | undefined;
+    }[];
+    services?: {
+        binding: string;
+        service: string;
+        environment?: string;
+        entrypoint?: string;
+    }[];
+    r2?: {
+        binding: string;
+        bucket_name?: string;
+        preview_bucket_name?: string;
+        jurisdiction?: string;
+    }[];
+    ai?: {
+        binding: string;
     };
-    legacy: StartDevWorkerInput["legacy"] & {
-        site?: Config$1["site"];
+    stream?: {
+        binding: string;
+        remote?: boolean;
     };
-    dev: StartDevWorkerInput["dev"] & {
-        persist: string | false;
-        auth?: AsyncHook<CfAccount>;
+    version_metadata?: {
+        binding: string;
     };
-    entrypoint: string;
-    assets?: AssetsOptions$1;
-    containers?: ContainerNormalizedConfig[];
-    name: string;
-    complianceRegion: Config$1["compliance_region"];
+    d1Databases?: Array<Omit<Environment$1["d1_databases"][number], "database_id"> & {
+        database_id?: string;
+    }>;
+    processEntrypoint?: boolean;
+    additionalModules?: CfModule[];
+    moduleRoot?: string;
+    rules?: Rule$1[];
+    showInteractiveDevSession?: boolean;
 };
-type HookValues = string | number | boolean | object | undefined | null;
-type Hook<T extends HookValues, Args extends unknown[] = []> = T | ((...args: Args) => T);
-type AsyncHook<T extends HookValues, Args extends unknown[] = []> = Hook<T, Args> | Hook<Promise<T>, Args>;
-type Bundle = EsbuildBundle;
-type LogLevel = "debug" | "info" | "log" | "warn" | "error" | "none";
-
-type MaybePromise<T> = T | Promise<T>;
-type DeferredPromise<T> = {
-    promise: Promise<T>;
-    resolve: (_: MaybePromise<T>) => void;
-    reject: (_: Error) => void;
+type DevArguments = Omit<(typeof dev)["args"], "installSkills">;
+type StartDevOptions = DevArguments & AdditionalDevProps & {
+    forceLocal?: boolean;
+    accountId?: string;
+    disableDevRegistry?: boolean;
+    enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
+    onReady?: (ip: string, port: number) => void;
+    enableIpc?: boolean;
+    dockerPath?: string;
+    containerEngine?: string;
+    /** Set to `false` to disable persistence. When `true` or `undefined`, uses default persistence path. */
+    persist?: boolean;
 };
+
 declare function convertConfigBindingsToStartWorkerBindings(configBindings: Partial<Pick<Config$1, ConfigBindingFieldName>>): StartDevWorkerOptions["bindings"];
 
-declare function startWorker(options: StartDevWorkerInput): Promise<Worker>;
+type TestHarnessOptions = {
+    /**
+     * Base directory used to resolve relative worker config paths.
+     * Defaults to `process.cwd()`.
+     */
+    root?: string | undefined;
+    /**
+     * Workers to run in this server. The first worker is the primary worker.
+     */
+    workers: WorkerInput[];
+};
+type WorkerHandle = {
+    /**
+     * Dispatches a fetch event directly to this worker.
+     * Relative URL inputs are resolved against the URL returned by `listen()`.
+     *
+     * @example
+     * ```ts
+     * const response = await worker.fetch("/", {
+     *   method: "POST",
+     *   body: "Hello, world!"
+     * });
+     * ```
+     */
+    fetch: DispatchFetch;
+    /**
+     * Dispatches a scheduled event directly to this Worker.
+     *
+     * @example
+     * ```ts
+     * const result = await worker.scheduled({
+     *   cron: "0 * * * *",
+     *   scheduledTime: new Date(),
+     * });
+     * ```
+     */
+    scheduled(options: FetcherScheduledOptions): Promise<FetcherScheduledResult>;
+};
+type TestHarness = {
+    /**
+     * Starts the server and returns its current URL.
+     * Calling this more than once returns the same running server session until
+     * the server is closed or reset.
+     *
+     * If no options were passed to `createTestHarness()`, call `update(options)`
+     * before starting the server.
+     */
+    listen(): Promise<{
+        url: URL;
+    }>;
+    /**
+     * Dispatches a fetch request through the server.
+     *
+     * - Relative URLs are resolved against the current server URL. Absolute URLs
+     * are also accepted, and can be used to control the hostname seen by the Worker.
+     * - Requests are matched against each Worker's configured routes and dispatched to
+     * the first matching Worker, or to the primary Worker if no routes match.
+     * - To dispatch directly to a specific Worker, use `server.getWorker(name).fetch()`.
+     *
+     * @example
+     * ```ts
+     * const server = createTestHarness({
+     *   workers: [
+     *     { configPath: "./wrangler.dashboard.jsonc" }, // No route pattern
+     *     { configPath: "./wrangler.api.jsonc" }, // Route pattern: "example.com/api/*"
+     *     { configPath: "./wrangler.admin.jsonc" }, // Route pattern: "admin.example.com/*"
+     *   ]
+     * });
+     *
+     * await server.fetch("/users");
+     * // Dispatches a request to the dashboard Worker (the first Worker) with URL "http://localhost:{port}/users"
+     *
+     * await server.fetch("http://admin.example.com/accounts");
+     * // Dispatches a request to the admin Worker with URL "http://admin.example.com/accounts"
+     *
+     * await server.fetch("http://example.com/api/data");
+     * // Dispatches a request to the API Worker with URL "http://example.com/api/data"
+     * ```
+     */
+    fetch: DispatchFetch;
+    /**
+     * Returns a handle for dispatching events directly to a Worker.
+     * When no name is provided, this returns the primary Worker, which is the first
+     * Worker in the server's `workers` options.
+     */
+    getWorker(name?: string): WorkerHandle;
+    /**
+     * Returns captured Workers runtime logs since the current server session
+     * started or `clearLogs()` was last called.
+     */
+    getLogs(): WorkerdStructuredLog[];
+    /**
+     * Clears captured Workers runtime logs.
+     */
+    clearLogs(): void;
+    /**
+     * Prints a diagnostic timeline for this test server.
+     *
+     * Use this to trace the sequence of server events and Workers runtime logs
+     * leading up to a test failure. Call `server.debug()` from your test runner's
+     * failure or cleanup hook when the current test has failed.
+     */
+    debug(): void;
+    /**
+     * Updates the server configuration and reloads the running Workers.
+     *
+     * If the server has not started yet, this configures the options that will be
+     * used by `listen()`.
+     */
+    update(options: TestHarnessOptions | ((currentOptions: TestHarnessOptions) => TestHarnessOptions)): Promise<void>;
+    /**
+     * Restores the server to the options used when the current session first
+     * started. Storage is recreated, and the server URL may change after reset.
+     */
+    reset(): Promise<void>;
+    /**
+     * Stops the server and releases all runtime resources.
+     */
+    close(): Promise<void>;
+};
+type InlineConfig = Omit<RawConfig$1, "env">;
+type WorkerInput = {
+    /**
+     * Path to a Wrangler config file for this Worker.
+     * Relative paths resolve from server `root`.
+     */
+    configPath: string | URL;
+    /**
+     * Wrangler environment to load from the config file.
+     */
+    env?: string;
+    /**
+     * Test-only vars that override vars from the Wrangler config.
+     */
+    vars?: Record<string, Json$1>;
+    /**
+     * Test-only secrets that override values loaded from `.dev.vars` and `.env` files.
+     */
+    secrets?: Record<string, string>;
+} | {
+    /**
+     * Inline Wrangler config for this Worker.
+     */
+    config: InlineConfig;
+};
+/**
+ * Creates a local test server for running Workers.
+ *
+ * The server can run one or more Workers from Wrangler config files, including
+ * generated configs from Vite, or from inline configuration objects.
+ *
+ * @example
+ * ```ts
+ * const server = createTestHarness({
+ *   workers: [{ configPath: "./wrangler.jsonc" }],
+ * });
+ * await server.listen();
+ * const response = await server.fetch("/api/users");
+ * await server.close();
+ * ```
+ */
+declare function createTestHarness(options?: TestHarnessOptions): TestHarness;
 
 type ReadConfigCommandArgs = NormalizeAndValidateConfigArgs & {
     config?: string;
@@ -2955,6 +3077,22 @@ declare function unstable_getMiniflareWorkerOptions(config: Config, env?: string
     containerBuildId?: string;
 }): Unstable_MiniflareWorkerOptions;
 
+/**
+ * A Cloudflare account.
+ */
+interface CfAccount {
+    /**
+     * An API token.
+     *
+     * @link https://api.cloudflare.com/#user-api-tokens-properties
+     */
+    apiToken: ApiCredentials;
+    /**
+     * An account ID.
+     */
+    accountId: string;
+}
+
 type StartRemoteProxySessionOptions = {
     workerName?: string;
     auth?: NonNullable<StartDevWorkerInput["dev"]>["auth"];
@@ -3004,23 +3142,14 @@ declare function maybeStartOrUpdateRemoteProxySession(wranglerOrWorkerConfigObje
     auth?: AsyncHook<CfAccount> | undefined;
 } | null>;
 
-declare const LOGGER_LEVELS: {
-    readonly none: -1;
-    readonly error: 0;
-    readonly warn: 1;
-    readonly info: 2;
-    readonly log: 3;
-    readonly debug: 4;
-};
-type LoggerLevel = keyof typeof LOGGER_LEVELS;
 type TableRow<Keys extends string> = Record<Keys, string>;
 declare class Logger {
     #private;
     constructor();
     private overrideLoggerLevel?;
     private onceHistory;
-    get loggerLevel(): "debug" | "none" | "error" | "info" | "log" | "warn";
-    set loggerLevel(val: "debug" | "none" | "error" | "info" | "log" | "warn");
+    get loggerLevel(): "debug" | "none" | "error" | "log" | "info" | "warn";
+    set loggerLevel(val: "debug" | "none" | "error" | "log" | "info" | "warn");
     resetLoggerLevel(): void;
     columns: number;
     json: (data: unknown) => void;
@@ -3050,23 +3179,6 @@ declare class Logger {
     private formatMessage;
 }
 
-type PrintContext = {
-    log?: (message: string) => void;
-    registry?: WorkerRegistry | null;
-    local?: boolean;
-    isMultiWorker?: boolean;
-    remoteBindingsDisabled?: boolean;
-    name?: string;
-    provisioning?: boolean;
-    warnIfNoBindings?: boolean;
-    unsafeMetadata?: Record<string, unknown>;
-};
-/**
- * Print all the bindings a worker would have access to.
- * Accepts StartDevWorkerInput["bindings"] format
- */
-declare function printBindings(bindings: StartDevWorkerInput["bindings"], tailConsumers?: CfTailConsumer[], streamingTailConsumers?: CfTailConsumer[], containers?: ContainerApp$1[], context?: PrintContext): void;
-
 /**
  * Resolves the named tunnel to hostnames whose ingress rules
  * target the current local dev origin and the token needed
@@ -3080,6 +3192,28 @@ declare function resolveNamedTunnel(name: string, origin: URL, options: {
     token: string;
 }>;
 
+/**
+ * Run the dev server until it tears down (a hotkey quit in a TTY, or a
+ * signal from a non-interactive parent). Mirrors `wrangler dev`'s command
+ * handler and installs no signal handlers of its own, so signal handling
+ * and exit codes match `wrangler dev` exactly.
+ *
+ * @param options Fully-built `StartDevOptions` (built in `bin/cf-wrangler.js`).
+ * @returns `0` on a clean teardown.
+ */
+declare function runCfWranglerDev(options: StartDevOptions): Promise<number>;
+
+interface DevArgs {
+    mode?: string;
+    port?: number;
+    host?: string;
+    local?: boolean;
+}
+declare class ArgParseError extends Error {
+    constructor(message: string);
+}
+declare function parseArgs(argv: string[]): DevArgs;
+
 /**
  * Split an SQLQuery into an array of statements
  */
@@ -3087,6 +3221,18 @@ declare function splitSqlQuery(sql: string): string[];
 
 declare function runAutoConfig(autoConfigDetails: AutoConfigDetails, autoConfigOptions?: AutoConfigOptions): Promise<AutoConfigSummary>;
 
+/**
+ * The implementation for fetching a kv value from the cloudflare API.
+ * We special-case this one call, because it's the only API call that
+ * doesn't return json. We inline the implementation and try not to share
+ * any code with the other calls. We should push back on any new APIs that
+ * try to introduce non-"standard" response structures.
+ *
+ * Note: any calls to fetchKVGetValue must call encodeURIComponent on key
+ * before passing it
+ */
+declare function fetchKVGetValue(complianceConfig: ComplianceConfig, accountId: string, namespaceId: string, key: string): Promise<ArrayBuffer>;
+
 /**
  * Make a fetch request, and extract the `result` from the JSON response.
  */
@@ -3097,6 +3243,14 @@ declare function fetchResult<ResponseType>(complianceConfig: ComplianceConfig, r
  * and repeating the request if the results are paginated.
  */
 declare function fetchListResult<ResponseType>(complianceConfig: ComplianceConfig, resource: string, init?: RequestInit, queryParams?: URLSearchParams): Promise<ResponseType[]>;
+/**
+ * Make a fetch request for a list of values,
+ * extracting the `result` from the JSON response,
+ * and repeating the request if the results are paginated.
+ *
+ * This is similar to fetchListResult, but it uses the `page` query parameter instead of `cursor`.
+ */
+declare function fetchPagedListResult<ResponseType>(complianceConfig: ComplianceConfig, resource: string, init?: RequestInit, queryParams?: URLSearchParams): Promise<ResponseType[]>;
 
 interface ConfirmOptions {
     defaultValue?: boolean;
@@ -3225,6 +3379,8 @@ type HandlerContext = {
      */
     fetchResult: typeof fetchResult;
     fetchListResult: typeof fetchListResult;
+    fetchPagedListResult: typeof fetchPagedListResult;
+    fetchKVGetValue: typeof fetchKVGetValue;
     /**
      * Interactive prompts
      */
@@ -3506,4 +3662,4 @@ interface Unstable_ASSETSBindingsOptions {
 }
 declare const unstable_generateASSETSBinding: (opts: Unstable_ASSETSBindingsOptions) => (request: Request) => Promise<Response$1>;
 
-export { type Experimental_GenerateTypesOptions, type Experimental_GenerateTypesResult, type GetPlatformProxyOptions, type PlatformProxy, type RemoteProxySession, type SourcelessWorkerOptions, type StartRemoteProxySessionOptions, type Unstable_ASSETSBindingsOptions, type Config as Unstable_Config, type Unstable_DevOptions, type Unstable_DevWorker, type Unstable_MiniflareWorkerOptions, type RawConfig as Unstable_RawConfig, type RawEnvironment as Unstable_RawEnvironment, Framework as experimental_AutoConfigFramework, generateTypes as experimental_generateTypes, getDetailsForAutoConfig as experimental_getDetailsForAutoConfig, experimental_getWranglerCommands, runAutoConfig as experimental_runAutoConfig, getPlatformProxy, maybeStartOrUpdateRemoteProxySession, startRemoteProxySession, DevEnv as unstable_DevEnv, convertConfigBindingsToStartWorkerBindings as unstable_convertConfigBindingsToStartWorkerBindings, unstable_dev, unstable_generateASSETSBinding, unstable_getDevCompatibilityDate, getDurableObjectClassNameToUseSQLiteMap as unstable_getDurableObjectClassNameToUseSQLiteMap, unstable_getMiniflareWorkerOptions, getVarsForDev as unstable_getVarsForDev, getWorkerNameFromProject as unstable_getWorkerNameFromProject, unstable_pages, printBindings as unstable_printBindings, readConfig as unstable_readConfig, resolveNamedTunnel as unstable_resolveNamedTunnel, splitSqlQuery as unstable_splitSqlQuery, startWorker as unstable_startWorker };
+export { ArgParseError, type Experimental_GenerateTypesOptions, type Experimental_GenerateTypesResult, type GetPlatformProxyOptions, type PlatformProxy, type RemoteProxySession, type SourcelessWorkerOptions, type StartRemoteProxySessionOptions, type TestHarness, type TestHarnessOptions, type Unstable_ASSETSBindingsOptions, type Config as Unstable_Config, type Unstable_DevOptions, type Unstable_DevWorker, type Unstable_MiniflareWorkerOptions, type RawConfig as Unstable_RawConfig, type RawEnvironment as Unstable_RawEnvironment, type WorkerHandle, createTestHarness, Framework as experimental_AutoConfigFramework, generateTypes as experimental_generateTypes, getDetailsForAutoConfig as experimental_getDetailsForAutoConfig, experimental_getWranglerCommands, runAutoConfig as experimental_runAutoConfig, getPlatformProxy, maybeStartOrUpdateRemoteProxySession, parseArgs as parseCfWranglerArgs, runCfWranglerDev, startRemoteProxySession, DevEnv as unstable_DevEnv, convertConfigBindingsToStartWorkerBindings as unstable_convertConfigBindingsToStartWorkerBindings, unstable_dev, unstable_generateASSETSBinding, unstable_getDevCompatibilityDate, getDurableObjectClassNameToUseSQLiteMap as unstable_getDurableObjectClassNameToUseSQLiteMap, unstable_getMiniflareWorkerOptions, getVarsForDev as unstable_getVarsForDev, getWorkerNameFromProject as unstable_getWorkerNameFromProject, unstable_pages, readConfig as unstable_readConfig, resolveNamedTunnel as unstable_resolveNamedTunnel, splitSqlQuery as unstable_splitSqlQuery, startWorker as unstable_startWorker };