wrangler 0.0.0-e1d50407 → 0.0.0-e1f2576e

package/wrangler-dist/cli.d.ts

@@ -6,11 +6,14 @@ import type { DispatchFetch } from 'miniflare';
 import { Duplex } from 'stream';
 import { EventEmitter } from 'events';
 import { EventEmitter as EventEmitter_2 } from 'node:events';
+import type { IncomingRequestCfProperties as IncomingRequestCfProperties_2 } from '@cloudflare/workers-types/experimental';
 import { IpcNetConnectOpts } from 'net';
 import type { Json } from 'miniflare';
+import type { MessagePort as MessagePort_2 } from 'worker_threads';
 import type { Metafile } from 'esbuild';
 import { Miniflare } from 'miniflare';
 import type { MiniflareOptions } from 'miniflare';
+import type { ModuleRule as ModuleRule_2 } from 'miniflare';
 import { Mutex } from 'miniflare';
 import { Readable } from 'stream';
 import { ReadableStream as ReadableStream_2 } from 'stream/web';
@@ -18,12 +21,12 @@ import type { Request as Request_3 } from 'miniflare';
 import { Response as Response_3 } from 'miniflare';
 import { Socket as Socket_2 } from 'net';
 import { TcpNetConnectOpts } from 'net';
-import { TlsOptions as TlsOptions_2 } from 'tls';
 import { TLSSocket } from 'tls';
 import { URL as URL_2 } from 'url';
 import { UrlObject } from 'url';
 import { URLSearchParams as URLSearchParams_2 } from 'url';
 import { WebSocket as WebSocket_3 } from 'miniflare';
+import type { WorkerOptions } from 'miniflare';
 import { Writable } from 'stream';
 
 declare type AbortSignal_2 = unknown;
@@ -47,7 +50,7 @@ declare class Agent extends Dispatcher{
 declare namespace Agent {
     interface Options extends Pool.Options {
         /** Default: `(origin, opts) => new Pool(origin, opts)`. */
-        factory?(origin: URL_2, opts: Object): Dispatcher;
+        factory?(origin: string | URL_2, opts: Object): Dispatcher;
         /** Integer. Default: `0` */
         maxRedirections?: number;
 
@@ -68,10 +71,10 @@ declare type ApiCredentials = {
 };
 
 declare class BalancedPool extends Dispatcher {
-    constructor(url: string | URL_2 | string[], options?: Pool.Options);
+    constructor(url: string | string[] | URL_2 | URL_2[], options?: Pool.Options);
 
-    addUpstream(upstream: string): BalancedPool;
-    removeUpstream(upstream: string): BalancedPool;
+    addUpstream(upstream: string | URL_2): BalancedPool;
+    removeUpstream(upstream: string | URL_2): BalancedPool;
     upstreams: Array<string>;
 
     /** `true` after `pool.close()` has been called. */
@@ -133,6 +136,16 @@ declare type Binding = {
     [key: string]: unknown;
 };
 
+/**
+ * Result of the `getBindingsProxy` utility
+ */
+export declare type BindingsProxy<Bindings = Record<string, unknown>, CfProperties extends Record<string, unknown> = IncomingRequestCfProperties_2> = Omit<PlatformProxy<Bindings, CfProperties>, "env"> & {
+    /**
+     * Object containing the various proxies
+     */
+    bindings: Bindings;
+};
+
 declare interface BlobPropertyBag {
     type?: string
     endings?: 'native' | 'transparent'
@@ -175,7 +188,7 @@ declare class BodyReadable extends Readable {
     /** Consumes and returns the body as a JavaScript Object
      *  https://fetch.spec.whatwg.org/#dom-body-json
      */
-    json(): Promise<any>
+    json(): Promise<unknown>
 
     /** Consumes and returns the body as a Blob
      *  https://fetch.spec.whatwg.org/#dom-body-blob
@@ -221,6 +234,7 @@ declare function buildConnector (options?: buildConnector.BuildOptions): buildCo
 
 declare namespace buildConnector {
     type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+        allowH2?: boolean;
         maxCachedSessions?: number | null;
         socketPath?: string | null;
         timeout?: number | null;
@@ -242,13 +256,7 @@ declare namespace buildConnector {
     type Callback = (...args: CallbackArgs) => void
     type CallbackArgs = [null, Socket_2 | TLSSocket] | [Error, null]
 
-    type connector = connectorAsync | connectorSync
-
-    interface connectorSync {
-        (options: buildConnector.Options): Socket_2 | TLSSocket
-    }
-
-    interface connectorAsync {
+    interface connector {
         (options: buildConnector.Options, callback: buildConnector.Callback): void
     }
 }
@@ -275,6 +283,82 @@ declare type BundleStartEvent = {
     config: StartDevWorkerOptions;
 };
 
+declare interface Cache_2 {
+    match (request: RequestInfo_2, options?: CacheQueryOptions_2): Promise<Response_2 | undefined>,
+    matchAll (request?: RequestInfo_2, options?: CacheQueryOptions_2): Promise<readonly Response_2[]>,
+    add (request: RequestInfo_2): Promise<undefined>,
+    addAll (requests: RequestInfo_2[]): Promise<undefined>,
+    put (request: RequestInfo_2, response: Response_2): Promise<undefined>,
+    delete (request: RequestInfo_2, options?: CacheQueryOptions_2): Promise<boolean>,
+    keys (request?: RequestInfo_2, options?: CacheQueryOptions_2): Promise<readonly Request_2[]>
+}
+
+/**
+ * No-op implementation of Cache
+ */
+declare class Cache_3 {
+    delete(request: CacheRequest, options?: CacheQueryOptions_3): Promise<boolean>;
+    match(request: CacheRequest, options?: CacheQueryOptions_3): Promise<CacheResponse | undefined>;
+    put(request: CacheRequest, response: CacheResponse): Promise<void>;
+}
+
+declare interface CacheQueryOptions_2 {
+    ignoreSearch?: boolean,
+    ignoreMethod?: boolean,
+    ignoreVary?: boolean
+}
+
+declare type CacheQueryOptions_3 = {
+    ignoreMethod?: boolean;
+};
+
+declare type CacheRequest = any;
+
+declare type CacheResponse = any;
+
+declare const caches_2: CacheStorage_2;
+
+declare interface CacheStorage_2 {
+    match (request: RequestInfo_2, options?: MultiCacheQueryOptions): Promise<Response_2 | undefined>,
+    has (cacheName: string): Promise<boolean>,
+    open (cacheName: string): Promise<Cache_2>,
+    delete (cacheName: string): Promise<boolean>,
+    keys (): Promise<string[]>
+}
+
+declare const CacheStorage_2: {
+    prototype: CacheStorage_2
+    new(): CacheStorage_2
+};
+
+/**
+ * Note about this file:
+ *
+ * Here we are providing a no-op implementation of the runtime Cache API instead of using
+ * the miniflare implementation (via `mf.getCaches()`).
+ *
+ * We are not using miniflare's implementation because that would require the user to provide
+ * miniflare-specific Request objects and they would receive back miniflare-specific Response
+ * objects, this (in particular the Request part) is not really suitable for `getPlatformProxy`
+ * as people would ideally interact with their bindings in a very production-like manner and
+ * requiring them to deal with miniflare-specific classes defeats a bit the purpose of the utility.
+ *
+ * Similarly the Request and Response types here are set to `undefined` as not to use specific ones
+ * that would require us to make a choice right now or the user to adapt their code in order to work
+ * with the api.
+ *
+ * We need to find a better/generic manner in which we can reuse the miniflare cache implementation,
+ * but until then the no-op implementation below will have to do.
+ */
+/**
+ * No-op implementation of CacheStorage
+ */
+declare class CacheStorage_3 {
+    constructor();
+    open(cacheName: string): Promise<Cache_3>;
+    get default(): Cache_3;
+}
+
 /**
  * A Cloudflare account.
  */
@@ -291,6 +375,16 @@ declare interface CfAccount {
     accountId: string;
 }
 
+/**
+ * A Durable Object.
+ */
+declare interface CfDurableObject {
+    name: string;
+    class_name: string;
+    script_name?: string;
+    environment?: string;
+}
+
 /**
  * An imported module.
  */
@@ -333,14 +427,16 @@ declare interface CfModule {
 /**
  * A module type.
  */
-declare type CfModuleType = "esm" | "commonjs" | "compiled-wasm" | "text" | "buffer";
+declare type CfModuleType = "esm" | "commonjs" | "compiled-wasm" | "text" | "buffer" | "python" | "python-requirement";
 
 /**
  * The type of Worker
  */
 declare type CfScriptFormat = "modules" | "service-worker";
 
-/** A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default. */
+/**
+ * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
+ */
 declare class Client extends Dispatcher {
     constructor(url: string | URL_2, options?: Client.Options);
     /** Property to get and set the pipelining factor. */
@@ -352,39 +448,71 @@ declare class Client extends Dispatcher {
 }
 
 declare namespace Client {
+    interface OptionsInterceptors {
+        Client: readonly Dispatcher.DispatchInterceptor[];
+    }
     interface Options {
-        /** the timeout after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
-        keepAliveTimeout?: number | null;
-        /** the maximum allowed `idleTimeout` when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
-        keepAliveMaxTimeout?: number | null;
-        /** A number subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
-        keepAliveTimeoutThreshold?: number | null;
-        /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
-        pipelining?: number | null;
-        /** **/
-        connect?: buildConnector.BuildOptions | buildConnector.connector | null;
-        /** The maximum length of request headers in bytes. Default: `16384` (16KiB). */
-        maxHeaderSize?: number | null;
+        /** TODO */
+        interceptors?: OptionsInterceptors;
+        /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+        maxHeaderSize?: number;
+        /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+        headersTimeout?: number;
+        /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
+        socketTimeout?: never;
+        /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
+        requestTimeout?: never;
+        /** TODO */
+        connectTimeout?: number;
         /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
-        bodyTimeout?: number | null;
-        /** The amount of time the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
-        headersTimeout?: number | null;
+        bodyTimeout?: number;
+        /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
+        idleTimeout?: never;
+        /** @deprecated unsupported keepAlive, use pipelining=0 instead */
+        keepAlive?: never;
+        /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+        keepAliveTimeout?: number;
+        /** @deprecated unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead */
+        maxKeepAliveTimeout?: never;
+        /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+        keepAliveMaxTimeout?: number;
+        /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+        keepAliveTimeoutThreshold?: number;
+        /** TODO */
+        socketPath?: string;
+        /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+        pipelining?: number;
+        /** @deprecated use the connect option instead */
+        tls?: never;
         /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
         strictContentLength?: boolean;
-        /** @deprecated use the connect option instead */
-        tls?: TlsOptions_2 | null;
-        /** */
+        /** TODO */
+        maxCachedSessions?: number;
+        /** TODO */
+        maxRedirections?: number;
+        /** TODO */
+        connect?: buildConnector.BuildOptions | buildConnector.connector;
+        /** TODO */
         maxRequestsPerClient?: number;
+        /** TODO */
+        localAddress?: string;
         /** Max response body size in bytes, -1 is disabled */
-        maxResponseSize?: number | null;
+        maxResponseSize?: number;
         /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
         autoSelectFamily?: boolean;
         /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
         autoSelectFamilyAttemptTimeout?: number;
-
-        interceptors?: {Client: readonly Dispatcher[] | undefined}
+        /**
+         * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
+         * @default false
+         */
+        allowH2?: boolean;
+        /**
+         * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+         * @default 100
+         */
+        maxConcurrentStreams?: number
     }
-
     interface SocketInfo {
         localAddress?: string
         localPort?: number
@@ -395,8 +523,6 @@ declare namespace Client {
         bytesWritten?: number
         bytesRead?: number
     }
-
-
 }
 
 declare interface CloseEvent_2 extends Event_2 {
@@ -416,6 +542,14 @@ declare interface CloseEventInit_2 extends EventInit_2 {
     wasClean?: boolean
 }
 
+/**
+ * Configuration in wrangler for Cloudchamber
+ */
+declare type CloudchamberConfig = {
+    vcpu?: number;
+    memory?: string;
+};
+
 declare class ConfigController extends EventEmitter_2 {
     config?: StartDevWorkerOptions;
     setOptions(_: StartDevWorkerOptions): void;
@@ -562,7 +696,7 @@ declare interface ConfigFields<Dev extends RawDevConfig> {
 /**
  * The possible types for a `Rule`.
  */
-declare type ConfigModuleRuleType = "ESModule" | "CommonJS" | "CompiledWasm" | "Text" | "Data";
+declare type ConfigModuleRuleType = "ESModule" | "CommonJS" | "CompiledWasm" | "Text" | "Data" | "PythonModule" | "PythonRequirement";
 
 declare type ConfigUpdateEvent = {
     type: "configUpdate";
@@ -621,8 +755,8 @@ attributes?: { name?: string, domain?: string }
  */
 declare function deploy({ directory, accountId, projectName, branch, skipCaching, commitMessage, commitHash, commitDirty, functionsDirectory: customFunctionsDirectory, bundle, }: PagesDeployOptions): Promise<{
     url: string;
-    environment: "production" | "preview";
     id: string;
+    environment: "production" | "preview";
     project_id: string;
     project_name: string;
     build_config: {
@@ -765,11 +899,10 @@ declare interface DevConfig {
     /**
      * Protocol that wrangler dev forwards requests on
      *
-     * Setting this to `http` is not currently implemented.
+     * Setting this to `http` is not currently implemented for remote mode.
      * See https://github.com/cloudflare/workers-sdk/issues/583
      *
-     * @default `https`
-     * @todo this needs to be implemented https://github.com/cloudflare/workers-sdk/issues/583
+     * @default `https` in remote mode; same as local_protocol in local mode.
      */
     upstream_protocol: "https" | "http";
     /**
@@ -955,7 +1088,7 @@ declare namespace Dispatcher {
         blocking?: boolean;
         /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
         upgrade?: boolean | string | null;
-        /** The amount of time the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
+        /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
         headersTimeout?: number | null;
         /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. */
         bodyTimeout?: number | null;
@@ -963,6 +1096,8 @@ declare namespace Dispatcher {
         reset?: boolean;
         /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
         throwOnError?: boolean;
+        /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server*/
+        expectContinue?: boolean;
     }
     interface ConnectOptions {
         path: string;
@@ -988,6 +1123,8 @@ declare namespace Dispatcher {
         onInfo?: (info: { statusCode: number, headers: Record<string, string | string[]> }) => void;
         /** Default: `null` */
         responseHeader?: 'raw' | null;
+        /** Default: `64 KiB` */
+        highWaterMark?: number;
     }
     interface PipelineOptions extends RequestOptions {
         /** `true` if the `handler` will return an object stream. Default: `false` */
@@ -1053,7 +1190,7 @@ declare namespace Dispatcher {
         /** Invoked when request is upgraded either due to a `Upgrade` header or `CONNECT` method. */
         onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex): void;
         /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
-        onHeaders?(statusCode: number, headers: Buffer[] | string[] | null, resume: () => void): boolean;
+        onHeaders?(statusCode: number, headers: Buffer[] | string[] | null, resume: () => void, statusText: string): boolean;
         /** Invoked when response payload data is received. */
         onData?(chunk: Buffer): boolean;
         /** Invoked when response payload and trailers have been received and the request has completed. */
@@ -1073,7 +1210,7 @@ declare namespace Dispatcher {
         arrayBuffer(): Promise<ArrayBuffer>;
         blob(): Promise<Blob_2>;
         formData(): Promise<never>;
-        json(): Promise<any>;
+        json(): Promise<unknown>;
         text(): Promise<string>;
     }
 
@@ -1224,6 +1361,13 @@ declare interface EnvironmentInheritable {
      * @inheritable
      */
     find_additional_modules: boolean | undefined;
+    /**
+     * Determines whether Wrangler will preserve bundled file names.
+     * Defaults to false.
+     * If left unset, files will be named using the pattern ${fileHash}-${basename},
+     * for example, `34de60b44167af5c5a709e62a4e20c4f18c9e3b6-favicon.ico`.
+     */
+    preserve_file_names: boolean | undefined;
     /**
      * The directory in which module rules should be evaluated when including additional files into a worker deployment.
      * This defaults to the directory containing the `main` entry point of the worker if not specified.
@@ -1478,6 +1622,16 @@ declare interface EnvironmentNonInheritable {
     durable_objects: {
         bindings: DurableObjectBindings;
     };
+    /**
+     * Cloudchamber configuration
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default `{}`
+     * @nonInheritable
+     */
+    cloudchamber: CloudchamberConfig;
     /**
      * These specify any Workers KV Namespaces you want to
      * access from inside your Worker.
@@ -1708,7 +1862,7 @@ declare interface EnvironmentNonInheritable {
          * here will always be applied to metadata last, so can add new or override existing fields.
          */
         metadata?: {
-            [key: string]: string;
+            [key: string]: unknown;
         };
         /**
          * Used for internal capnp uploads for the Workers runtime
@@ -1738,7 +1892,10 @@ declare type ErrorEvent_2 = BaseErrorEvent<"ConfigController" | "BundlerControll
 }>;
 
 declare namespace Errors {
-    class UndiciError extends Error { }
+    class UndiciError extends Error {
+        name: string;
+        code: string;
+    }
 
     /** Connect timeout error. */
     class ConnectTimeoutError extends UndiciError {
@@ -1765,6 +1922,12 @@ declare namespace Errors {
     }
 
     class ResponseStatusCodeError extends UndiciError {
+        constructor (
+        message?: string,
+        statusCode?: number,
+        headers?: IncomingHttpHeaders | string[] | null,
+        body?: null | Record<string, any> | string
+        );
         name: 'ResponseStatusCodeError';
         code: 'UND_ERR_RESPONSE_STATUS_CODE';
         body: null | Record<string, any> | string
@@ -1923,6 +2086,11 @@ declare type EventTarget_2 = typeof globalThis extends { EventTarget: infer T }
     ): void
 }
 
+declare class ExecutionContext_2 {
+    waitUntil(promise: Promise<any>): void;
+    passThroughOnException(): void;
+}
+
 declare function fetch_2 (
 input: RequestInfo_2,
 init?: RequestInit_2
@@ -2102,12 +2270,61 @@ declare class FormData_2 {
  */
 declare type FormDataEntryValue = string | File_2
 
+/**
+ * By reading from a `wrangler.toml` file this function generates proxy binding objects that can be
+ * used to simulate the interaction with bindings during local development in a Node.js environment
+ *
+ * @deprecated use `getPlatformProxy` instead
+ *
+ * @param options The various options that can tweak this function's behavior
+ * @returns An Object containing the generated proxies alongside other related utilities
+ */
+export declare function getBindingsProxy<Bindings = Record<string, unknown>, CfProperties extends Record<string, unknown> = IncomingRequestCfProperties_2>(options?: GetBindingsProxyOptions): Promise<BindingsProxy<Bindings, CfProperties>>;
+
+/** Options for the `getBindingsProxy` utility */
+export declare type GetBindingsProxyOptions = GetPlatformProxyOptions;
+
 declare function getCookies (headers: Headers_2): Record<string, string>
 
 declare function getGlobalDispatcher(): Dispatcher;
 
 declare function getGlobalOrigin(): URL | undefined;
 
+/**
+ * By reading from a `wrangler.toml` file this function generates proxy objects that can be
+ * used to simulate the interaction with the Cloudflare platform during local development
+ * in a Node.js environment
+ *
+ * @param options The various options that can tweak this function's behavior
+ * @returns An Object containing the generated proxies alongside other related utilities
+ */
+export declare function getPlatformProxy<Env = Record<string, unknown>, CfProperties extends Record<string, unknown> = IncomingRequestCfProperties_2>(options?: GetPlatformProxyOptions): Promise<PlatformProxy<Env, CfProperties>>;
+
+/**
+ * Options for the `getPlatformProxy` utility
+ */
+export declare type GetPlatformProxyOptions = {
+    /**
+     * The path to the config object to use (default `wrangler.toml`)
+     */
+    configPath?: string;
+    /**
+     * Flag to indicate the utility to read a json config file (`wrangler.json`)
+     * instead of the toml one (`wrangler.toml`)
+     *
+     * Note: this feature is experimental
+     */
+    experimentalJsonConfig?: boolean;
+    /**
+     * Indicates if and where to persist the bindings data, if not present or `true` it defaults to the same location
+     * used by wrangler v3: `.wrangler/state/v3` (so that the same data can be easily used by the caller and wrangler).
+     * If `false` is specified no data is persisted on the filesystem.
+     */
+    persist?: boolean | {
+        path: string;
+    };
+};
+
 declare function getSetCookies (headers: Headers_2): Cookie[]
 
 declare class Headers_2 implements SpecIterable<[string, string]> {
@@ -2174,8 +2391,8 @@ declare interface MessageEvent_2<T = any> extends Event_2 {
     readonly data: T
     readonly lastEventId: string
     readonly origin: string
-    readonly ports: ReadonlyArray<typeof MessagePort>
-    readonly source: typeof MessagePort | null
+    readonly ports: ReadonlyArray<typeof MessagePort_2>
+    readonly source: typeof MessagePort_2 | null
     initMessageEvent(
     type: string,
     bubbles?: boolean,
@@ -2183,8 +2400,8 @@ declare interface MessageEvent_2<T = any> extends Event_2 {
     data?: any,
     origin?: string,
     lastEventId?: string,
-    source?: typeof MessagePort | null,
-    ports?: (typeof MessagePort)[]
+    source?: typeof MessagePort_2 | null,
+    ports?: (typeof MessagePort_2)[]
     ): void;
 }
 
@@ -2197,8 +2414,8 @@ declare interface MessageEventInit_2<T = any> extends EventInit_2 {
     data?: T
     lastEventId?: string
     origin?: string
-    ports?: (typeof MessagePort)[]
-    source?: typeof MessagePort | null
+    ports?: (typeof MessagePort_2)[]
+    source?: typeof MessagePort_2 | null
 }
 
 declare interface MIMEType {
@@ -2376,6 +2593,21 @@ declare interface ModuleRule {
     fallthrough?: boolean;
 }
 
+declare interface MultiCacheQueryOptions extends CacheQueryOptions_2 {
+    cacheName?: string
+}
+
+declare interface PagesConfigFields {
+    /**
+     * The directory of static assets to serve.
+     *
+     * The presence of this field in `wrangler.toml` indicates a Pages project,
+     * and will prompt the handling of the configuration file according to the
+     * Pages-specific validation rules.
+     */
+    pages_build_output_dir?: string;
+}
+
 declare interface PagesDeployOptions {
     /**
      * Path to static assets to deploy to Pages
@@ -2448,6 +2680,32 @@ options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions, 'origin'
 handler: Dispatcher.PipelineHandler
 ): Duplex;
 
+/**
+ * Result of the `getPlatformProxy` utility
+ */
+export declare type PlatformProxy<Env = Record<string, unknown>, CfProperties extends Record<string, unknown> = IncomingRequestCfProperties_2> = {
+    /**
+     * Environment object containing the various Cloudflare bindings
+     */
+    env: Env;
+    /**
+     * Mock of the context object that Workers received in their request handler, all the object's methods are no-op
+     */
+    cf: CfProperties;
+    /**
+     * Mock of the context object that Workers received in their request handler, all the object's methods are no-op
+     */
+    ctx: ExecutionContext_2;
+    /**
+     * Caches object emulating the Workers Cache runtime API
+     */
+    caches: CacheStorage_3;
+    /**
+     * Function used to dispose of the child process providing the bindings implementation
+     */
+    dispose: () => Promise<void>;
+};
+
 declare class Pool extends Dispatcher {
     constructor(url: string | URL_2, options?: Pool.Options)
     /** `true` after `pool.close()` has been called. */
@@ -22767,6 +23025,7 @@ declare namespace ProxyAgent {
         headers?: IncomingHttpHeaders;
         requestTls?: buildConnector.BuildOptions;
         proxyTls?: buildConnector.BuildOptions;
+        clientFactory?(origin: URL, opts: object): Dispatcher;
     }
 }
 
@@ -22805,9 +23064,10 @@ declare type ProxyData = {
     userWorkerUrl: UrlOriginParts;
     userWorkerInspectorUrl: UrlOriginAndPathnameParts;
     userWorkerInnerUrlOverrides: Partial<UrlOriginParts>;
-    headers: Record<string, string | undefined>;
+    headers: Record<string, string>;
     liveReload?: boolean;
     proxyLogsToController?: boolean;
+    internalDurableObjects?: CfDurableObject[];
 };
 
 declare type ProxyWorkerIncomingRequestBody = {
@@ -22828,7 +23088,7 @@ declare type ProxyWorkerOutgoingRequestBody = {
     args: Parameters<typeof console.debug>;
 };
 
-declare type RawConfig = Partial<ConfigFields<RawDevConfig>> & RawEnvironment & DeprecatedConfigFields & EnvironmentMap;
+declare type RawConfig = Partial<ConfigFields<RawDevConfig>> & PagesConfigFields & RawEnvironment & DeprecatedConfigFields & EnvironmentMap;
 
 declare type RawDevConfig = Partial<DevConfig>;
 
@@ -22952,7 +23212,7 @@ declare interface RequestInit_2 {
     body?: BodyInit_2
     redirect?: RequestRedirect
     integrity?: string
-    signal?: AbortSignal
+    signal?: AbortSignal | null
     credentials?: RequestCredentials
     mode?: RequestMode
     referrer?: string
@@ -23009,6 +23269,119 @@ declare type ResponseType =
 | 'opaque'
 | 'opaqueredirect'
 
+declare class RetryHandler implements Dispatcher.DispatchHandlers {
+    constructor(
+    options: Dispatcher.DispatchOptions & {
+        retryOptions?: RetryHandler.RetryOptions;
+    },
+    retryHandlers: RetryHandler.RetryHandlers
+    );
+}
+
+declare namespace RetryHandler {
+    type RetryState = { counter: number; currentTimeout: number };
+
+    type RetryContext = {
+        state: RetryState;
+        opts: Dispatcher.DispatchOptions & {
+            retryOptions?: RetryHandler.RetryOptions;
+        };
+    }
+
+    type OnRetryCallback = (result?: Error | null) => void;
+
+    type RetryCallback = (
+    err: Error,
+    context: {
+        state: RetryState;
+        opts: Dispatcher.DispatchOptions & {
+            retryOptions?: RetryHandler.RetryOptions;
+        };
+    },
+    callback: OnRetryCallback
+    ) => number | null;
+
+    interface RetryOptions {
+        /**
+         * Callback to be invoked on every retry iteration.
+         * It receives the error, current state of the retry object and the options object
+         * passed when instantiating the retry handler.
+         *
+         * @type {RetryCallback}
+         * @memberof RetryOptions
+         */
+        retry?: RetryCallback;
+        /**
+         * Maximum number of retries to allow.
+         *
+         * @type {number}
+         * @memberof RetryOptions
+         * @default 5
+         */
+        maxRetries?: number;
+        /**
+         * Max number of milliseconds allow between retries
+         *
+         * @type {number}
+         * @memberof RetryOptions
+         * @default 30000
+         */
+        maxTimeout?: number;
+        /**
+         * Initial number of milliseconds to wait before retrying for the first time.
+         *
+         * @type {number}
+         * @memberof RetryOptions
+         * @default 500
+         */
+        minTimeout?: number;
+        /**
+         * Factior to multiply the timeout factor between retries.
+         *
+         * @type {number}
+         * @memberof RetryOptions
+         * @default 2
+         */
+        timeoutFactor?: number;
+        /**
+         * It enables to automatically infer timeout between retries based on the `Retry-After` header.
+         *
+         * @type {boolean}
+         * @memberof RetryOptions
+         * @default true
+         */
+        retryAfter?: boolean;
+        /**
+         * HTTP methods to retry.
+         *
+         * @type {Dispatcher.HttpMethod[]}
+         * @memberof RetryOptions
+         * @default ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
+         */
+        methods?: Dispatcher.HttpMethod[];
+        /**
+         * Error codes to be retried. e.g. `ECONNRESET`, `ENOTFOUND`, `ETIMEDOUT`, `ECONNREFUSED`, etc.
+         *
+         * @type {string[]}
+         * @default ['ECONNRESET','ECONNREFUSED','ENOTFOUND','ENETDOWN','ENETUNREACH','EHOSTDOWN','EHOSTUNREACH','EPIPE']
+         */
+        errorCodes?: string[];
+        /**
+         * HTTP status codes to be retried.
+         *
+         * @type {number[]}
+         * @memberof RetryOptions
+         * @default [500, 502, 503, 504, 429],
+         */
+        statusCodes?: number[];
+    }
+
+    interface RetryHandlers {
+        dispatch: Dispatcher["dispatch"];
+        handler: Dispatcher.DispatchHandlers;
+    }
+}
+
 declare type Route = SimpleRoute | ZoneIdRoute | ZoneNameRoute | CustomDomainRoute;
 
 /**
@@ -23061,6 +23434,10 @@ declare function setGlobalOrigin(origin: string | URL | undefined): void;
 
 declare type SimpleRoute = string;
 
+export declare type SourcelessWorkerOptions = Omit<WorkerOptions, "script" | "scriptPath" | "modules" | "modulesRoot"> & {
+    modulesRules?: ModuleRule_2[];
+};
+
 /**
  * Information about Wrangler's bundling process that needs passed through
  * for DevTools sourcemap transformation
@@ -23156,6 +23533,8 @@ declare interface StartDevWorkerOptions {
             hostname?: string;
             port?: number;
             secure?: boolean;
+            httpsKeyPath?: string;
+            httpsCertPath?: string;
         };
         /** Controls what request.url looks like inside the worker. */
         urlOverrides?: {
@@ -23218,6 +23597,7 @@ declare namespace Undici {
     var Pool: Pool;
     var RedirectHandler: RedirectHandler
     var DecoratorHandler: DecoratorHandler
+    var RetryHandler: RetryHandler
     var createRedirectInterceptor: createRedirectInterceptor
     var BalancedPool: BalancedPool;
     var Client: Client;
@@ -23236,10 +23616,18 @@ declare namespace Undici {
     var MockAgent: MockAgent;
     var mockErrors: MockErrors;
     var fetch: fetch_2;
+    var Headers: Headers_2;
+    var Response: Response_2;
+    var Request: Request_2;
+    var FormData: FormData_2;
+    var File: File_2;
+    var FileReader: FileReader;
+    var caches: caches_2;
 }
 
 declare namespace undici {
     export {
+        Undici as default,
         Interceptable,
         Dispatcher,
         BalancedPool,
@@ -23264,7 +23652,7 @@ declare namespace undici {
         ProxyAgent,
         RedirectHandler,
         DecoratorHandler,
-        Undici as default,
+        RetryHandler,
         deleteCookie,
         getCookies,
         getSetCookies,
@@ -23308,9 +23696,15 @@ declare namespace undici {
         CloseEvent_2 as CloseEvent,
         MessageEventInit_2 as MessageEventInit,
         MessageEvent_2 as MessageEvent,
+        WebSocketInit,
         parseMIMEType,
         serializeAMimeType,
-        MIMEType
+        MIMEType,
+        CacheStorage_2 as CacheStorage,
+        Cache_2 as Cache,
+        CacheQueryOptions_2 as CacheQueryOptions,
+        MultiCacheQueryOptions,
+        caches_2 as caches
     }
 }
 
@@ -23338,10 +23732,21 @@ export declare class unstable_DevEnv extends EventEmitter_2 {
     emitErrorEvent(ev: ErrorEvent_2): void;
 }
 
+export declare function unstable_getMiniflareWorkerOptions(configPath: string): {
+    workerOptions: SourcelessWorkerOptions;
+    define: Record<string, string>;
+    main?: string;
+};
+
 export declare const unstable_pages: {
     deploy: typeof deploy;
 };
 
+/**
+ * Split an SQLQuery into an array of statements
+ */
+export declare function unstable_splitSqlQuery(sql: string): string[];
+
 export declare interface UnstableDevOptions {
     config?: string;
     env?: string;
@@ -23350,6 +23755,8 @@ export declare interface UnstableDevOptions {
     bundle?: boolean;
     inspectorPort?: number;
     localProtocol?: "http" | "https";
+    httpsKeyPath?: string;
+    httpsCertPath?: string;
     assets?: string;
     site?: string;
     siteInclude?: string[];
@@ -23447,7 +23854,7 @@ declare interface WebSocket_2 extends EventTarget_2 {
     readonly url: string
 
     close(code?: number, reason?: string): void
-    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
+    send(data: string | ArrayBufferLike | Blob_2 | ArrayBufferView): void
 
     readonly CLOSED: number
     readonly CLOSING: number
@@ -23478,7 +23885,7 @@ declare interface WebSocket_2 extends EventTarget_2 {
 
 declare const WebSocket_2: {
     prototype: WebSocket_2
-    new (url: string | URL, protocols?: string | string[]): WebSocket_2
+    new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket_2
     readonly CLOSED: number
     readonly CLOSING: number
     readonly CONNECTING: number
@@ -23492,6 +23899,12 @@ declare interface WebSocketEventMap_2 {
     open: Event_2
 }
 
+declare interface WebSocketInit {
+    protocols?: string | string[],
+    dispatcher?: Dispatcher,
+    headers?: HeadersInit_2
+}
+
 declare type ZoneIdRoute = {
     pattern: string;
     zone_id: string;