wrangler 4.99.0 → 4.101.0

package/wrangler-dist/cli.d.ts

@@ -1,6 +1,6 @@
-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, RawConfig as RawConfig$1, NormalizeAndValidateConfigArgs, ResolveConfigPathOptions, 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, WorkerdStructuredLog, 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';
@@ -9,6 +9,7 @@ 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';
+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;
@@ -476,17 +520,6 @@ declare abstract class RuntimeController extends Controller {
     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;
@@ -495,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>;
@@ -561,219 +601,131 @@ 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, or a normalized configuration object. */
-    config?: string | Config$1;
-    /** 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;
-        /** Handles structured runtime logs. */
-        structuredLogsHandler?: (log: WorkerdStructuredLog) => void;
-        /** 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;
-        /** Whether to infer the local request origin from configured routes. */
-        inferOriginFromRoutes?: 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" | "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;
+    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>;
+declare function convertConfigBindingsToStartWorkerBindings(configBindings: Partial<Pick<Config$1, ConfigBindingFieldName>>): StartDevWorkerOptions["bindings"];
 
 type TestHarnessOptions = {
     /**
@@ -812,6 +764,47 @@ type WorkerHandle = {
      * ```
      */
     scheduled(options: FetcherScheduledOptions): Promise<FetcherScheduledResult>;
+    /**
+     * Returns a KV namespace binding configured on this Worker.
+     *
+     * @example
+     * ```ts
+     * const store = await worker.getKVNamespace("STORE");
+     * const value = await store.get("key");
+     * ```
+     */
+    getKVNamespace(bindingName: string): ReturnType<Miniflare["getKVNamespace"]>;
+    /**
+     * Returns an R2 bucket binding configured on this Worker.
+     *
+     * @example
+     * ```ts
+     * const bucket = await worker.getR2Bucket("BUCKET");
+     * const object = await bucket.get("key");
+     * ```
+     */
+    getR2Bucket(bindingName: string): ReturnType<Miniflare["getR2Bucket"]>;
+    /**
+     * Returns a D1 database binding configured on this Worker.
+     *
+     * @example
+     * ```ts
+     * const db = await worker.getD1Database("DB");
+     * const value = await db.prepare("SELECT value FROM entries").first("value");
+     * ```
+     */
+    getD1Database(bindingName: string): ReturnType<Miniflare["getD1Database"]>;
+    /**
+     * Returns a Durable Object namespace binding configured on this Worker.
+     *
+     * @example
+     * ```ts
+     * const namespace = await worker.getDurableObjectNamespace("OBJECT");
+     * const stub = namespace.getByName("counter");
+     * const response = await stub.fetch("http://example.com/");
+     * ```
+     */
+    getDurableObjectNamespace(bindingName: string): ReturnType<Miniflare["getDurableObjectNamespace"]>;
 };
 type TestHarness = {
     /**
@@ -3125,6 +3118,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"];
@@ -3174,23 +3183,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;
@@ -3220,23 +3220,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
@@ -3250,6 +3233,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
  */
@@ -3257,6 +3262,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.
  */
@@ -3267,6 +3284,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;
@@ -3395,6 +3420,8 @@ type HandlerContext = {
      */
     fetchResult: typeof fetchResult;
     fetchListResult: typeof fetchListResult;
+    fetchPagedListResult: typeof fetchPagedListResult;
+    fetchKVGetValue: typeof fetchKVGetValue;
     /**
      * Interactive prompts
      */
@@ -3476,12 +3503,25 @@ type CommandDefinition<NamedArgDefs extends NamedArgDefinitions = NamedArgDefini
          */
         sendMetrics?: boolean;
         /**
-         * Skip the AI coding agent skills installation prompt for this command.
-         * Set to `true` for commands whose stdout is captured by the shell (e.g. `complete`),
-         * where interactive prompts would corrupt the output.
+         * After the command handler completes successfully, suggest installing
+         * Cloudflare skills for detected AI coding agents that don't have them.
+         *
+         * When set to `true`, the suggestion always runs after the handler.
+         * When set to a function, it receives the parsed args and should return
+         * `true` to enable the suggestion — use this to skip the prompt in modes
+         * where interactive output is inappropriate (e.g. `--json`).
+         *
          * @default false
          */
-        skipSkillsPrompt?: boolean;
+        suggestSkillsAfterHandler?: boolean | ((args: HandlerArgs<NamedArgDefs>) => boolean);
+        /**
+         * Whether this command can authenticate with a temporary preview account
+         * (via the hidden `--temporary` flag) when no real credentials are available.
+         * Only enable this for commands whose API calls are covered by the temporary
+         * preview-account deploy token (Workers, KV, D1, Hyperdrive, Queues, SSL/Certs).
+         * @default false
+         */
+        supportTemporary?: boolean;
     };
     /**
      * A plain key-value object describing the CLI args for this command.
@@ -3499,8 +3539,11 @@ type CommandDefinition<NamedArgDefs extends NamedArgDefinitions = NamedArgDefini
      * A hook to implement custom validation of the args before the handler is called.
      * Throw `CommandLineArgsError` with actionable error message if args are invalid.
      * The return value is ignored.
+     *
+     * @param args - The parsed CLI arguments
+     * @param def - The command definition, useful for passing to helpers like `demandOneOfOption`
      */
-    validateArgs?: (args: HandlerArgs<NamedArgDefs>) => void | Promise<void>;
+    validateArgs?: (args: HandlerArgs<NamedArgDefs>, def: CommandDefinition<NamedArgDefs>) => void | Promise<void>;
     /**
      * The implementation of the command which is given camelCase'd args
      * and a ctx object of convenience properties
@@ -3644,7 +3687,7 @@ declare function createCLIParser(argv: string[]): {
             readonly alias: "x-auto-create";
         };
         readonly "install-skills": {
-            readonly describe: "Install Cloudflare agents skills, if not already present, without asking the user for confirmation";
+            readonly describe: "Install Cloudflare skills for detected AI coding agents before running the command";
             readonly type: "boolean";
             readonly default: false;
         };
@@ -3676,4 +3719,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 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, 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 };