npm package diff

Package: @cloudflare/workers-types

Versions: 4.20230419.0 - 4.20230511.0

Modified:package/package.json

Index: package/package.json
===================================================================
--- package/package.json
+++ package/package.json
@@ -6,6 +6,6 @@
     "url": "https://github.com/cloudflare/workerd"
   },
   "author": "Cloudflare Workers DevProd Team <[email protected]> (https://workers.cloudflare.com)",
   "license": "MIT OR Apache-2.0",
-  "version": "4.20230419.0"
+  "version": "4.20230511.0"
 }

Modified:package/2021-11-03/index.d.ts

Index: package/2021-11-03/index.d.ts
===================================================================
--- package/2021-11-03/index.d.ts
+++ package/2021-11-03/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -280,8 +282,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
   passThroughOnException(): void;
@@ -337,8 +341,13 @@
 declare abstract class PromiseRejectionEvent extends Event {
   readonly promise: Promise<any>;
   readonly reason: any;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -384,8 +393,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -570,8 +581,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
   readonly aborted: boolean;
   readonly reason: any;
   throwIfAborted(): void;
@@ -1065,8 +1077,9 @@
   signal?: AbortSignal | null;
 }
 declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1838,8 +1851,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1857,8 +1872,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+declare interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+declare interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+declare interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+declare interface TlsOptions {
+  expectedServerHostname?: string;
+}
 declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-01-31/index.d.ts

Index: package/2022-01-31/index.d.ts
===================================================================
--- package/2022-01-31/index.d.ts
+++ package/2022-01-31/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -280,8 +282,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
   passThroughOnException(): void;
@@ -337,8 +341,13 @@
 declare abstract class PromiseRejectionEvent extends Event {
   readonly promise: Promise<any>;
   readonly reason: any;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -384,8 +393,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -559,8 +570,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1045,8 +1057,9 @@
   signal?: AbortSignal | null;
 }
 declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1828,8 +1841,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1843,8 +1858,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+declare interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+declare interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+declare interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+declare interface TlsOptions {
+  expectedServerHostname?: string;
+}
 declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-03-21/index.d.ts

Index: package/2022-03-21/index.d.ts
===================================================================
--- package/2022-03-21/index.d.ts
+++ package/2022-03-21/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -282,8 +284,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare const navigator: Navigator;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -343,8 +347,13 @@
 }
 declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -390,8 +399,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -565,8 +576,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1051,8 +1063,9 @@
   signal?: AbortSignal | null;
 }
 declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1834,8 +1847,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1849,8 +1864,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+declare interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+declare interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+declare interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+declare interface TlsOptions {
+  expectedServerHostname?: string;
+}
 declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-08-04/index.d.ts

Index: package/2022-08-04/index.d.ts
===================================================================
--- package/2022-08-04/index.d.ts
+++ package/2022-08-04/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -282,8 +284,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare const navigator: Navigator;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -343,8 +347,13 @@
 }
 declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -390,8 +399,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -565,8 +576,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1051,8 +1063,9 @@
   signal?: AbortSignal | null;
 }
 declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1835,8 +1848,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1850,8 +1865,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+declare interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+declare interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+declare interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+declare interface TlsOptions {
+  expectedServerHostname?: string;
+}
 declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-10-31/index.d.ts

Index: package/2022-10-31/index.d.ts
===================================================================
--- package/2022-10-31/index.d.ts
+++ package/2022-10-31/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -282,8 +284,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare const navigator: Navigator;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -343,8 +347,13 @@
 }
 declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -390,8 +399,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -565,8 +576,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1051,8 +1063,9 @@
   signal?: AbortSignal | null;
 }
 declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1832,8 +1845,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1847,8 +1862,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+declare interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+declare interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+declare interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+declare interface TlsOptions {
+  expectedServerHostname?: string;
+}
 declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-11-30/index.d.ts

Index: package/2022-11-30/index.d.ts
===================================================================
--- package/2022-11-30/index.d.ts
+++ package/2022-11-30/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -286,8 +288,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare const navigator: Navigator;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -347,8 +351,13 @@
 }
 declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -394,8 +403,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -569,8 +580,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1055,8 +1067,9 @@
   signal?: AbortSignal | null;
 }
 declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1835,8 +1848,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1850,8 +1865,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+declare interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+declare interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+declare interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+declare interface TlsOptions {
+  expectedServerHostname?: string;
+}
 declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/experimental/index.d.ts

Index: package/experimental/index.d.ts
===================================================================
--- package/experimental/index.d.ts
+++ package/experimental/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -286,8 +288,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare const navigator: Navigator;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -347,8 +351,13 @@
 }
 declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -398,8 +407,11 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
+  abort(reason?: string): void;
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -574,8 +586,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1858,8 +1871,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1876,8 +1891,11 @@
 };
 declare interface SqlStorage {
   exec(query: string, ...bindings: any[]): SqlStorageCursor;
   prepare(query: string): SqlStorageStatement;
+  get databaseSize(): number;
+  get voluntarySizeLimit(): number;
+  set voluntarySizeLimit(value: number);
   Cursor: typeof SqlStorageCursor;
   Statement: typeof SqlStorageStatement;
 }
 declare abstract class SqlStorageStatement {}

Modified:package/index.d.ts

Index: package/index.d.ts
===================================================================
--- package/index.d.ts
+++ package/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -280,8 +282,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
   passThroughOnException(): void;
@@ -337,8 +341,13 @@
 declare abstract class PromiseRejectionEvent extends Event {
   readonly promise: Promise<any>;
   readonly reason: any;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -384,8 +393,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -570,8 +581,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
   readonly aborted: boolean;
   readonly reason: any;
   throwIfAborted(): void;
@@ -1065,8 +1077,9 @@
   signal?: AbortSignal | null;
 }
 declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1838,8 +1851,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1857,8 +1872,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+declare interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+declare interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+declare interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+declare interface TlsOptions {
+  expectedServerHostname?: string;
+}
 declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/oldest/index.d.ts

Index: package/oldest/index.d.ts
===================================================================
--- package/oldest/index.d.ts
+++ package/oldest/index.d.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -280,8 +282,10 @@
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
 declare const caches: CacheStorage;
 declare const scheduler: Scheduler;
+declare const performance: Performance;
+declare const origin: string;
 declare interface TestController {}
 declare interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
   passThroughOnException(): void;
@@ -337,8 +341,13 @@
 declare abstract class PromiseRejectionEvent extends Event {
   readonly promise: Promise<any>;
   readonly reason: any;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+declare interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 declare interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -384,8 +393,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -570,8 +581,9 @@
 }
 declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
   readonly aborted: boolean;
   readonly reason: any;
   throwIfAborted(): void;
@@ -1065,8 +1077,9 @@
   signal?: AbortSignal | null;
 }
 declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1838,8 +1851,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1857,8 +1872,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+declare interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+declare interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+declare interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+declare interface TlsOptions {
+  expectedServerHostname?: string;
+}
 declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2021-11-03/index.ts

Index: package/2021-11-03/index.ts
===================================================================
--- package/2021-11-03/index.ts
+++ package/2021-11-03/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -282,8 +284,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
   passThroughOnException(): void;
@@ -339,8 +343,13 @@
 export declare abstract class PromiseRejectionEvent extends Event {
   readonly promise: Promise<any>;
   readonly reason: any;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -386,8 +395,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -572,8 +583,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
   readonly aborted: boolean;
   readonly reason: any;
   throwIfAborted(): void;
@@ -1067,8 +1079,9 @@
   signal?: AbortSignal | null;
 }
 export declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 export interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1843,8 +1856,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1862,8 +1877,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+export interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+export interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+export interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+export interface TlsOptions {
+  expectedServerHostname?: string;
+}
 export interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-01-31/index.ts

Index: package/2022-01-31/index.ts
===================================================================
--- package/2022-01-31/index.ts
+++ package/2022-01-31/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -282,8 +284,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
   passThroughOnException(): void;
@@ -339,8 +343,13 @@
 export declare abstract class PromiseRejectionEvent extends Event {
   readonly promise: Promise<any>;
   readonly reason: any;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -386,8 +395,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -561,8 +572,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1047,8 +1059,9 @@
   signal?: AbortSignal | null;
 }
 export declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 export interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1833,8 +1846,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1848,8 +1863,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+export interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+export interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+export interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+export interface TlsOptions {
+  expectedServerHostname?: string;
+}
 export interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-03-21/index.ts

Index: package/2022-03-21/index.ts
===================================================================
--- package/2022-03-21/index.ts
+++ package/2022-03-21/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -284,8 +286,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export declare const navigator: Navigator;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -345,8 +349,13 @@
 }
 export declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -392,8 +401,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -567,8 +578,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1053,8 +1065,9 @@
   signal?: AbortSignal | null;
 }
 export declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 export interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1839,8 +1852,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1854,8 +1869,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+export interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+export interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+export interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+export interface TlsOptions {
+  expectedServerHostname?: string;
+}
 export interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-08-04/index.ts

Index: package/2022-08-04/index.ts
===================================================================
--- package/2022-08-04/index.ts
+++ package/2022-08-04/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -284,8 +286,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export declare const navigator: Navigator;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -345,8 +349,13 @@
 }
 export declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -392,8 +401,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -567,8 +578,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1053,8 +1065,9 @@
   signal?: AbortSignal | null;
 }
 export declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 export interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1840,8 +1853,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1855,8 +1870,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+export interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+export interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+export interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+export interface TlsOptions {
+  expectedServerHostname?: string;
+}
 export interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-10-31/index.ts

Index: package/2022-10-31/index.ts
===================================================================
--- package/2022-10-31/index.ts
+++ package/2022-10-31/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -284,8 +286,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export declare const navigator: Navigator;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -345,8 +349,13 @@
 }
 export declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -392,8 +401,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -567,8 +578,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1053,8 +1065,9 @@
   signal?: AbortSignal | null;
 }
 export declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 export interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1837,8 +1850,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1852,8 +1867,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+export interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+export interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+export interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+export interface TlsOptions {
+  expectedServerHostname?: string;
+}
 export interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/2022-11-30/index.ts

Index: package/2022-11-30/index.ts
===================================================================
--- package/2022-11-30/index.ts
+++ package/2022-11-30/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -288,8 +290,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export declare const navigator: Navigator;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -349,8 +353,13 @@
 }
 export declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -396,8 +405,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -571,8 +582,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1057,8 +1069,9 @@
   signal?: AbortSignal | null;
 }
 export declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 export interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1840,8 +1853,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1855,8 +1870,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+export interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+export interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+export interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+export interface TlsOptions {
+  expectedServerHostname?: string;
+}
 export interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/experimental/index.ts

Index: package/experimental/index.ts
===================================================================
--- package/experimental/index.ts
+++ package/experimental/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -288,8 +290,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export declare const navigator: Navigator;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
@@ -349,8 +353,13 @@
 }
 export declare abstract class Navigator {
   readonly userAgent: string;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -400,8 +409,11 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
+  abort(reason?: string): void;
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -576,8 +588,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   get aborted(): boolean;
   get reason(): any;
   throwIfAborted(): void;
 }
@@ -1863,8 +1876,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1881,8 +1896,11 @@
 };
 export interface SqlStorage {
   exec(query: string, ...bindings: any[]): SqlStorageCursor;
   prepare(query: string): SqlStorageStatement;
+  get databaseSize(): number;
+  get voluntarySizeLimit(): number;
+  set voluntarySizeLimit(value: number);
   Cursor: typeof SqlStorageCursor;
   Statement: typeof SqlStorageStatement;
 }
 export declare abstract class SqlStorageStatement {}

Modified:package/index.ts

Index: package/index.ts
===================================================================
--- package/index.ts
+++ package/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -282,8 +284,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
   passThroughOnException(): void;
@@ -339,8 +343,13 @@
 export declare abstract class PromiseRejectionEvent extends Event {
   readonly promise: Promise<any>;
   readonly reason: any;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -386,8 +395,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -572,8 +583,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
   readonly aborted: boolean;
   readonly reason: any;
   throwIfAborted(): void;
@@ -1067,8 +1079,9 @@
   signal?: AbortSignal | null;
 }
 export declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 export interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1843,8 +1856,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1862,8 +1877,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+export interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+export interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+export interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+export interface TlsOptions {
+  expectedServerHostname?: string;
+}
 export interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */

Modified:package/oldest/index.ts

Index: package/oldest/index.ts
===================================================================
--- package/oldest/index.ts
+++ package/oldest/index.ts
@@ -183,8 +183,10 @@
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  performance: Performance;
+  readonly origin: string;
   Event: typeof Event;
   ExtendableEvent: typeof ExtendableEvent;
   PromiseRejectionEvent: typeof PromiseRejectionEvent;
   FetchEvent: typeof FetchEvent;
@@ -282,8 +284,10 @@
 export declare const self: ServiceWorkerGlobalScope;
 export declare const crypto: Crypto;
 export declare const caches: CacheStorage;
 export declare const scheduler: Scheduler;
+export declare const performance: Performance;
+export declare const origin: string;
 export interface TestController {}
 export interface ExecutionContext {
   waitUntil(promise: Promise<any>): void;
   passThroughOnException(): void;
@@ -339,8 +343,13 @@
 export declare abstract class PromiseRejectionEvent extends Event {
   readonly promise: Promise<any>;
   readonly reason: any;
 }
+/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+export interface Performance {
+  readonly timeOrigin: number;
+  now(): number;
+}
 export interface DurableObject {
   fetch(request: Request): Response | Promise<Response>;
   alarm?(): void | Promise<void>;
 }
@@ -386,8 +395,10 @@
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+  acceptWebSocket(ws: WebSocket, tags?: string[]): void;
+  getWebSockets(tag?: string): WebSocket[];
 }
 export interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
@@ -572,8 +583,9 @@
 }
 export declare abstract class AbortSignal extends EventTarget {
   static abort(reason?: any): AbortSignal;
   static timeout(delay: number): AbortSignal;
+  static any(signals: AbortSignal[]): AbortSignal;
   /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
   readonly aborted: boolean;
   readonly reason: any;
   throwIfAborted(): void;
@@ -1067,8 +1079,9 @@
   signal?: AbortSignal | null;
 }
 export declare abstract class Fetcher {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+  connect(address: SocketAddress | string, options?: SocketOptions): Socket;
 }
 export interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1843,8 +1856,10 @@
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
+  serializeAttachment(attachment: any): void;
+  deserializeAttachment(): any | null;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
@@ -1862,8 +1877,26 @@
     0: WebSocket;
     1: WebSocket;
   };
 };
+export interface Socket {
+  get readable(): ReadableStream;
+  get writable(): WritableStream;
+  get closed(): Promise<void>;
+  close(): Promise<void>;
+  startTls(options?: TlsOptions): Socket;
+}
+export interface SocketOptions {
+  secureTransport?: string;
+  allowHalfOpen: boolean;
+}
+export interface SocketAddress {
+  hostname: string;
+  port: number;
+}
+export interface TlsOptions {
+  expectedServerHostname?: string;
+}
 export interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */