@fkn/lib 0.4.8 → 0.5.0

package/index.d.ts

@@ -1,5 +1,5 @@
 import * as osra from 'osra';
-import { BoxBase, Capable, UnderlyingType, RevivableContext } from 'osra';
+import { BoxBase, Capable, UnderlyingType, RevivableContext, DefaultRevivableModules } from 'osra';
 import * as osra_build_revivables_event_target from 'osra/build/revivables/event-target';
 import * as osra_build_revivables_fallbacks from 'osra/build/revivables/fallbacks';
 import * as osra_build_revivables_json_primitives from 'osra/build/revivables/json-primitives';
@@ -27,36 +27,37 @@ import * as osra_build_revivables_identity from 'osra/build/revivables/identity'
 import * as osra_build_revivables_transfer from 'osra/build/revivables/transfer';
 import * as ip_address from 'ip-address';
 import { Address4, Address6 } from 'ip-address';
+import * as node_fs from 'node:fs';
 import { Socket as Socket$2, SocketConstructorOpts, SocketConnectOpts, AddressInfo, Server as Server$2, ServerOpts, ListenOptions } from 'net';
 import { Stream, DuplexOptions } from 'stream';
 import { EventEmitter } from 'events';
 import { Socket as Socket$3, SocketOptions, BindOptions, SocketType, RemoteInfo } from 'dgram';
-import { Buffer } from 'buffer';
+import { Buffer as Buffer$1 } from 'buffer';
 import { OutgoingHttpHeaders, IncomingHttpHeaders, RequestOptions } from 'http';
 import { CSSProperties, ReactElement } from 'react';
 
 declare const fetchPermission: {
-    readonly scope: "network.fetch";
-    readonly category: "network";
+    readonly scope: 'network.fetch';
+    readonly category: 'network';
     readonly severity: 0;
-    readonly title: "Fetch data from other sites";
-    readonly description: "Lets the app download public data from other websites directly, past the usual cross-origin limits.";
+    readonly title: 'Fetch data from other sites';
+    readonly description: 'Lets the app download public data from other websites directly, past the usual cross-origin limits.';
 };
 declare const fetchCredentialedPermission: {
-    readonly scope: "network.fetchCredentialed";
-    readonly category: "network";
+    readonly scope: 'network.fetchCredentialed';
+    readonly category: 'network';
     readonly severity: 3;
     readonly unsafe: true;
-    readonly title: "Fetch from other sites, signed in as you";
-    readonly description: "Lets the app fetch other sites using your logged-in session cookies, so it can read data only you should see.";
+    readonly title: 'Fetch from other sites, signed in as you';
+    readonly description: 'Lets the app fetch other sites using your logged-in session cookies, so it can read data only you should see.';
 };
 declare const fetchLocalPermission: {
-    readonly scope: "network.fetchLocal";
-    readonly category: "network";
+    readonly scope: 'network.fetchLocal';
+    readonly category: 'network';
     readonly severity: 3;
     readonly unsafe: true;
-    readonly title: "Access devices on your local network";
-    readonly description: "Lets the app reach devices and services on your home or work network, which websites normally cannot touch.";
+    readonly title: 'Access devices on your local network';
+    readonly description: 'Lets the app reach devices and services on your home or work network, which websites normally cannot touch.';
 };
 declare const isLocalNetworkUrl: (raw: string) => boolean;
 type ProxyFetchRequest = {
@@ -75,15 +76,15 @@ type FetchInit = RequestInit & {
 };
 declare const isBlockedFetchUrl: (raw: string) => boolean;
 declare const assertFetchableUrl: (raw: string) => void;
-declare const fetch$2: (input: URL | RequestInfo, init?: FetchInit | undefined) => Promise<Response>;
+declare const fetch$2: (input: RequestInfo | URL, init?: FetchInit) => Promise<Response>;
 
 declare const readCookiePermission: {
-    readonly scope: "network.readCookie";
-    readonly category: "network";
+    readonly scope: 'network.readCookie';
+    readonly category: 'network';
     readonly severity: 3;
     readonly unsafe: true;
-    readonly title: "Read a site’s cookie";
-    readonly description: "Lets the app read a named cookie from another site, which can include the login token only that site should see.";
+    readonly title: 'Read a site’s cookie';
+    readonly description: 'Lets the app read a named cookie from another site, which can include the login token only that site should see.';
 };
 type CookieDetails = {
     url: string;
@@ -98,12 +99,12 @@ declare const cookies: {
 };
 
 declare const modifyRequestHeadersPermission: {
-    readonly scope: "network.modifyRequestHeaders";
-    readonly category: "network";
+    readonly scope: 'network.modifyRequestHeaders';
+    readonly category: 'network';
     readonly severity: 2;
     readonly unsafe: true;
-    readonly title: "Rewrite request headers to other sites";
-    readonly description: "Lets the app set or remove headers (like Origin and Referer) on this page’s own requests to the listed sites.";
+    readonly title: 'Rewrite request headers to other sites';
+    readonly description: 'Lets the app set or remove headers (like Origin and Referer) on this page’s own requests to the listed sites.';
 };
 type HeaderOperation = {
     header: string;
@@ -133,7 +134,7 @@ type ExtractResolverReturn<M> = M extends {
     resolve: (context: any, ...args: any[]) => infer R;
 } ? R : never;
 
-declare const type$i: "locator";
+declare const type$i: 'locator';
 declare const resolve$h: (context: LocatorContext, selector: string) => Element[];
 declare const render$7: SelectorRenderer;
 
@@ -145,7 +146,7 @@ declare namespace locatorSel {
   };
 }
 
-declare const type$h: "getByRole";
+declare const type$h: 'getByRole';
 declare const resolve$g: (context: LocatorContext, role: string) => Element[];
 declare const render$6: SelectorRenderer;
 
@@ -157,7 +158,7 @@ declare namespace getByRole {
   };
 }
 
-declare const type$g: "getByText";
+declare const type$g: 'getByText';
 declare const resolve$f: (context: LocatorContext, text: string) => Element[];
 declare const render$5: SelectorRenderer;
 
@@ -169,7 +170,7 @@ declare namespace getByText {
   };
 }
 
-declare const type$f: "getByTestId";
+declare const type$f: 'getByTestId';
 declare const resolve$e: (context: LocatorContext, testId: string) => Element[];
 declare const render$4: SelectorRenderer;
 
@@ -181,7 +182,7 @@ declare namespace getByTestId {
   };
 }
 
-declare const type$e: "first";
+declare const type$e: 'first';
 declare const resolve$d: (context: LocatorContext) => Element[];
 declare const render$3: SelectorRenderer;
 
@@ -193,7 +194,7 @@ declare namespace first {
   };
 }
 
-declare const type$d: "nth";
+declare const type$d: 'nth';
 declare const resolve$c: (context: LocatorContext, index: number) => Element[];
 declare const render$2: SelectorRenderer;
 
@@ -205,19 +206,19 @@ declare namespace nth {
   };
 }
 
-declare const type$c: "click";
+declare const type$c: 'click';
 declare const permission$9: {
-    readonly scope: "act.click";
-    readonly category: "act";
+    readonly scope: 'act.click';
+    readonly category: 'act';
     readonly severity: 3;
-    readonly title: "Click on the page";
-    readonly description: "Lets the app press buttons or links for you.";
+    readonly title: 'Click on the page';
+    readonly description: 'Lets the app press buttons or links for you.';
 };
 declare const resolve$b: (context: LocatorContext, options?: OperationTimeoutOptions & {
     position?: {
-        x?: number | undefined;
-        y?: number | undefined;
-    } | undefined;
+        x?: number;
+        y?: number;
+    };
 }) => void;
 
 declare namespace click {
@@ -228,13 +229,13 @@ declare namespace click {
   };
 }
 
-declare const type$b: "fill";
+declare const type$b: 'fill';
 declare const permission$8: {
-    readonly scope: "act.type";
-    readonly category: "act";
+    readonly scope: 'act.type';
+    readonly category: 'act';
     readonly severity: 1;
-    readonly title: "Type into a text field";
-    readonly description: "Lets the app fill in form fields on your behalf.";
+    readonly title: 'Type into a text field';
+    readonly description: 'Lets the app fill in form fields on your behalf.';
 };
 declare const resolve$a: (context: LocatorContext, value: string, _options?: OperationTimeoutOptions) => void;
 
@@ -246,19 +247,19 @@ declare namespace fill {
   };
 }
 
-declare const type$a: "hover";
+declare const type$a: 'hover';
 declare const permission$7: {
-    readonly scope: "act.hover";
-    readonly category: "act";
+    readonly scope: 'act.hover';
+    readonly category: 'act';
     readonly severity: 1;
-    readonly title: "Hover over the page";
-    readonly description: "Lets the app point at things to reveal menus or tooltips.";
+    readonly title: 'Hover over the page';
+    readonly description: 'Lets the app point at things to reveal menus or tooltips.';
 };
 declare const resolve$9: (context: LocatorContext, options?: OperationTimeoutOptions & {
     position?: {
-        x?: number | undefined;
-        y?: number | undefined;
-    } | undefined;
+        x?: number;
+        y?: number;
+    };
 }) => void;
 
 declare namespace hover {
@@ -269,13 +270,13 @@ declare namespace hover {
   };
 }
 
-declare const type$9: "textContent";
+declare const type$9: 'textContent';
 declare const permission$6: {
-    readonly scope: "read.text";
-    readonly category: "read";
+    readonly scope: 'read.text';
+    readonly category: 'read';
     readonly severity: 1;
-    readonly title: "Read text from the page";
-    readonly description: "Lets the app see the text shown on this page.";
+    readonly title: 'Read text from the page';
+    readonly description: 'Lets the app see the text shown on this page.';
 };
 declare const resolve$8: (context: LocatorContext, _options?: OperationTimeoutOptions) => string;
 
@@ -287,13 +288,13 @@ declare namespace textContent {
   };
 }
 
-declare const type$8: "isVisible";
+declare const type$8: 'isVisible';
 declare const permission$5: {
-    readonly scope: "read.visible";
-    readonly category: "read";
+    readonly scope: 'read.visible';
+    readonly category: 'read';
     readonly severity: 0;
-    readonly title: "See what’s visible on the page";
-    readonly description: "Lets the app check which elements are currently on screen.";
+    readonly title: 'See what’s visible on the page';
+    readonly description: 'Lets the app check which elements are currently on screen.';
 };
 declare const resolve$7: (context: LocatorContext, _options?: OperationTimeoutOptions) => boolean;
 
@@ -305,13 +306,13 @@ declare namespace isVisible {
   };
 }
 
-declare const type$7: "count";
+declare const type$7: 'count';
 declare const permission$4: {
-    readonly scope: "read.count";
-    readonly category: "read";
+    readonly scope: 'read.count';
+    readonly category: 'read';
     readonly severity: 0;
-    readonly title: "Count items on the page";
-    readonly description: "Lets the app count how many matching elements are present.";
+    readonly title: 'Count items on the page';
+    readonly description: 'Lets the app count how many matching elements are present.';
 };
 declare const resolve$6: (context: LocatorContext, _options?: OperationTimeoutOptions) => number;
 
@@ -323,17 +324,17 @@ declare namespace count {
   };
 }
 
-declare const type$6: "exists";
+declare const type$6: 'exists';
 declare const permission$3: {
-    readonly scope: "read.check";
-    readonly category: "read";
+    readonly scope: 'read.check';
+    readonly category: 'read';
     readonly severity: 0;
-    readonly title: "Check if something is on the page";
-    readonly description: "Lets the app test whether a specific element exists.";
+    readonly title: 'Check if something is on the page';
+    readonly description: 'Lets the app test whether a specific element exists.';
 };
 declare const resolve$5: (context: LocatorContext, _options?: OperationTimeoutOptions) => boolean;
 
-declare namespace exists {
+declare namespace exists$2 {
   export {
     permission$3 as permission,
     resolve$5 as resolve,
@@ -341,13 +342,13 @@ declare namespace exists {
   };
 }
 
-declare const type$5: "getAttribute";
+declare const type$5: 'getAttribute';
 declare const permission$2: {
-    readonly scope: "read.info";
-    readonly category: "read";
+    readonly scope: 'read.info';
+    readonly category: 'read';
     readonly severity: 1;
-    readonly title: "Read info from the page";
-    readonly description: "Lets the app read the href value from a part of the page.";
+    readonly title: 'Read info from the page';
+    readonly description: 'Lets the app read the href value from a part of the page.';
 };
 declare const resolve$4: (context: LocatorContext, name: string, _options?: OperationTimeoutOptions) => string | null;
 
@@ -359,13 +360,13 @@ declare namespace getAttribute {
   };
 }
 
-declare const type$4: "videoElement";
+declare const type$4: 'videoElement';
 declare const permission$1: {
-    readonly scope: "media.video";
-    readonly category: "media";
+    readonly scope: 'media.video';
+    readonly category: 'media';
     readonly severity: 0;
-    readonly title: "Control video playback";
-    readonly description: "Lets the app play, pause, seek, and read the video on the page.";
+    readonly title: 'Control video playback';
+    readonly description: 'Lets the app play, pause, seek, and read the video on the page.';
 };
 declare const resolve$3: (context: LocatorContext, _options?: OperationTimeoutOptions) => RemoteVideoElement;
 
@@ -380,19 +381,19 @@ declare namespace videoElement$1 {
 declare const locatorModule: {
     readonly type: "locator";
     readonly selectorModules: readonly [typeof locatorSel, {
-        readonly type: "frameLocator";
+        readonly type: 'frameLocator';
         readonly resolve: (context: LocatorContext, selector: string) => HTMLIFrameElement[];
         readonly resolvePeer: BarrierResolver;
         readonly render: SelectorRenderer;
-        readonly nextLocatorType: "frameLocator";
+        readonly nextLocatorType: 'frameLocator';
     }, typeof getByRole, typeof getByText, typeof getByTestId, typeof first, typeof nth];
-    readonly operationModules: readonly [typeof click, typeof fill, typeof hover, typeof textContent, typeof isVisible, typeof count, typeof exists, typeof getAttribute, typeof videoElement$1];
+    readonly operationModules: readonly [typeof click, typeof fill, typeof hover, typeof textContent, typeof isVisible, typeof count, typeof exists$2, typeof getAttribute, typeof videoElement$1];
 };
 type LocatorModule = typeof locatorModule;
 interface Locator extends LocatorChain<LocatorModule, Locator> {
 }
 
-declare const type$3: "frameLocator";
+declare const type$3: 'frameLocator';
 declare const resolve$2: (context: LocatorContext, selector: string) => HTMLIFrameElement[];
 declare const resolvePeer$1: BarrierResolver;
 declare const render$1: SelectorRenderer;
@@ -406,7 +407,7 @@ declare namespace frameLocatorSel {
   };
 }
 
-declare const type$2: "owner";
+declare const type$2: 'owner';
 declare const resolve$1: (_: LocatorContext) => never;
 declare const resolvePeer: BarrierResolver;
 declare const render: SelectorRenderer;
@@ -422,39 +423,39 @@ declare namespace owner {
   };
 }
 
-declare const type$1: "addStyleTag";
+declare const type$1: 'addStyleTag';
 type AddStyleTagOptions = OperationTimeoutOptions & {
     content: string;
     noSanitize?: boolean;
 };
 declare const appearPermission: {
-    readonly scope: "media.appear";
-    readonly category: "media";
+    readonly scope: 'media.appear';
+    readonly category: 'media';
     readonly severity: 0;
-    readonly title: "Change page appearance";
-    readonly description: "Lets the app restyle parts of the page (safely filtered).";
+    readonly title: 'Change page appearance';
+    readonly description: 'Lets the app restyle parts of the page (safely filtered).';
 };
 declare const appearUnsafePermission: {
-    readonly scope: "media.appearU";
-    readonly category: "media";
+    readonly scope: 'media.appearU';
+    readonly category: 'media';
     readonly severity: 2;
     readonly unsafe: true;
-    readonly title: "Change page appearance (unsafe)";
-    readonly description: "Lets the app restyle the page WITHOUT safety filtering. Could be used to leak data over the network.";
+    readonly title: 'Change page appearance (unsafe)';
+    readonly description: 'Lets the app restyle the page WITHOUT safety filtering. Could be used to leak data over the network.';
 };
-declare const permission: (options?: AddStyleTagOptions | undefined) => {
-    readonly scope: "media.appear";
-    readonly category: "media";
+declare const permission: (options?: AddStyleTagOptions) => {
+    readonly scope: 'media.appear';
+    readonly category: 'media';
     readonly severity: 0;
-    readonly title: "Change page appearance";
-    readonly description: "Lets the app restyle parts of the page (safely filtered).";
+    readonly title: 'Change page appearance';
+    readonly description: 'Lets the app restyle parts of the page (safely filtered).';
 } | {
-    readonly scope: "media.appearU";
-    readonly category: "media";
+    readonly scope: 'media.appearU';
+    readonly category: 'media';
     readonly severity: 2;
     readonly unsafe: true;
-    readonly title: "Change page appearance (unsafe)";
-    readonly description: "Lets the app restyle the page WITHOUT safety filtering. Could be used to leak data over the network.";
+    readonly title: 'Change page appearance (unsafe)';
+    readonly description: 'Lets the app restyle the page WITHOUT safety filtering. Could be used to leak data over the network.';
 };
 declare const setInjectedStylesDisabled: (disabled: boolean) => void;
 declare const resolve: (_context: LocatorContext, options: AddStyleTagOptions) => Promise<void>;
@@ -473,10 +474,10 @@ declare namespace addStyleTag {
 declare const frameLocatorModule: {
     readonly type: "frameLocator";
     readonly selectorModules: readonly [{
-        readonly type: "locator";
+        readonly type: 'locator';
         readonly resolve: (context: LocatorContext, selector: string) => Element[];
         readonly render: SelectorRenderer;
-        readonly nextLocatorType: "locator";
+        readonly nextLocatorType: 'locator';
     }, typeof frameLocatorSel, typeof owner];
     readonly operationModules: readonly [typeof addStyleTag];
 };
@@ -563,24 +564,24 @@ declare const ATTACH_FRAME_EVENT_KEY = "FKN_WEB_EXTENSION_ATTACH_FRAME_EVENT_KEY
 declare const isBlockedFrameUrl: (raw: string) => boolean;
 declare const assertAttachableFrameUrl: (raw: string) => void;
 declare const attachFramePermission: {
-    readonly scope: "embed.iframe";
-    readonly category: "embed";
+    readonly scope: 'embed.iframe';
+    readonly category: 'embed';
     readonly severity: 0;
-    readonly title: "Load another website inside this app";
-    readonly description: "Lets the app embed external pages directly inside its own view.";
+    readonly title: 'Load another website inside this app';
+    readonly description: 'Lets the app embed external pages directly inside its own view.';
 };
 declare const gotoPermission: {
-    readonly scope: "embed.open";
-    readonly category: "embed";
+    readonly scope: 'embed.open';
+    readonly category: 'embed';
     readonly severity: 0;
-    readonly title: "Open a website inside this app";
-    readonly description: "Lets the app navigate to another site without leaving its window.";
+    readonly title: 'Open a website inside this app';
+    readonly description: 'Lets the app navigate to another site without leaving its window.';
 };
 declare const evaluatePermission: {
-    readonly scope: "embed.evaluate";
-    readonly category: "embed";
+    readonly scope: 'embed.evaluate';
+    readonly category: 'embed';
     readonly severity: 0;
-    readonly title: "Run app code inside an embedded frame";
+    readonly title: 'Run app code inside an embedded frame';
     readonly description: "Lets the app execute its own code inside a page it embedded, to read back a computed result.";
 };
 type GotoOptions = {
@@ -601,124 +602,124 @@ type AttachFrameOptions = {
 declare const attachFrame: ({ iframe, domains, syncCookies, lockdown }: AttachFrameOptions) => Promise<Frame>;
 
 declare const PERMISSIONS: readonly [{
-    readonly scope: "read.text";
-    readonly category: "read";
+    readonly scope: 'read.text';
+    readonly category: 'read';
     readonly severity: 1;
-    readonly title: "Read text from the page";
-    readonly description: "Lets the app see the text shown on this page.";
+    readonly title: 'Read text from the page';
+    readonly description: 'Lets the app see the text shown on this page.';
 }, {
-    readonly scope: "read.info";
-    readonly category: "read";
+    readonly scope: 'read.info';
+    readonly category: 'read';
     readonly severity: 1;
-    readonly title: "Read info from the page";
-    readonly description: "Lets the app read the href value from a part of the page.";
+    readonly title: 'Read info from the page';
+    readonly description: 'Lets the app read the href value from a part of the page.';
 }, {
-    readonly scope: "read.visible";
-    readonly category: "read";
+    readonly scope: 'read.visible';
+    readonly category: 'read';
     readonly severity: 0;
-    readonly title: "See what’s visible on the page";
-    readonly description: "Lets the app check which elements are currently on screen.";
+    readonly title: 'See what’s visible on the page';
+    readonly description: 'Lets the app check which elements are currently on screen.';
 }, {
-    readonly scope: "read.check";
-    readonly category: "read";
+    readonly scope: 'read.check';
+    readonly category: 'read';
     readonly severity: 0;
-    readonly title: "Check if something is on the page";
-    readonly description: "Lets the app test whether a specific element exists.";
+    readonly title: 'Check if something is on the page';
+    readonly description: 'Lets the app test whether a specific element exists.';
 }, {
-    readonly scope: "read.count";
-    readonly category: "read";
+    readonly scope: 'read.count';
+    readonly category: 'read';
     readonly severity: 0;
-    readonly title: "Count items on the page";
-    readonly description: "Lets the app count how many matching elements are present.";
+    readonly title: 'Count items on the page';
+    readonly description: 'Lets the app count how many matching elements are present.';
 }, {
-    readonly scope: "act.click";
-    readonly category: "act";
+    readonly scope: 'act.click';
+    readonly category: 'act';
     readonly severity: 3;
-    readonly title: "Click on the page";
-    readonly description: "Lets the app press buttons or links for you.";
+    readonly title: 'Click on the page';
+    readonly description: 'Lets the app press buttons or links for you.';
 }, {
-    readonly scope: "act.type";
-    readonly category: "act";
+    readonly scope: 'act.type';
+    readonly category: 'act';
     readonly severity: 1;
-    readonly title: "Type into a text field";
-    readonly description: "Lets the app fill in form fields on your behalf.";
+    readonly title: 'Type into a text field';
+    readonly description: 'Lets the app fill in form fields on your behalf.';
 }, {
-    readonly scope: "act.hover";
-    readonly category: "act";
+    readonly scope: 'act.hover';
+    readonly category: 'act';
     readonly severity: 1;
-    readonly title: "Hover over the page";
-    readonly description: "Lets the app point at things to reveal menus or tooltips.";
+    readonly title: 'Hover over the page';
+    readonly description: 'Lets the app point at things to reveal menus or tooltips.';
 }, {
-    readonly scope: "media.video";
-    readonly category: "media";
+    readonly scope: 'media.video';
+    readonly category: 'media';
     readonly severity: 0;
-    readonly title: "Control video playback";
-    readonly description: "Lets the app play, pause, seek, and read the video on the page.";
+    readonly title: 'Control video playback';
+    readonly description: 'Lets the app play, pause, seek, and read the video on the page.';
 }, {
-    readonly scope: "media.appear";
-    readonly category: "media";
+    readonly scope: 'media.appear';
+    readonly category: 'media';
     readonly severity: 0;
-    readonly title: "Change page appearance";
-    readonly description: "Lets the app restyle parts of the page (safely filtered).";
+    readonly title: 'Change page appearance';
+    readonly description: 'Lets the app restyle parts of the page (safely filtered).';
 }, {
-    readonly scope: "media.appearU";
-    readonly category: "media";
+    readonly scope: 'media.appearU';
+    readonly category: 'media';
     readonly severity: 2;
     readonly unsafe: true;
-    readonly title: "Change page appearance (unsafe)";
-    readonly description: "Lets the app restyle the page WITHOUT safety filtering. Could be used to leak data over the network.";
+    readonly title: 'Change page appearance (unsafe)';
+    readonly description: 'Lets the app restyle the page WITHOUT safety filtering. Could be used to leak data over the network.';
 }, {
-    readonly scope: "embed.iframe";
-    readonly category: "embed";
+    readonly scope: 'embed.iframe';
+    readonly category: 'embed';
     readonly severity: 0;
-    readonly title: "Load another website inside this app";
-    readonly description: "Lets the app embed external pages directly inside its own view.";
+    readonly title: 'Load another website inside this app';
+    readonly description: 'Lets the app embed external pages directly inside its own view.';
 }, {
-    readonly scope: "embed.open";
-    readonly category: "embed";
+    readonly scope: 'embed.open';
+    readonly category: 'embed';
     readonly severity: 0;
-    readonly title: "Open a website inside this app";
-    readonly description: "Lets the app navigate to another site without leaving its window.";
+    readonly title: 'Open a website inside this app';
+    readonly description: 'Lets the app navigate to another site without leaving its window.';
 }, {
-    readonly scope: "embed.evaluate";
-    readonly category: "embed";
+    readonly scope: 'embed.evaluate';
+    readonly category: 'embed';
     readonly severity: 0;
-    readonly title: "Run app code inside an embedded frame";
+    readonly title: 'Run app code inside an embedded frame';
     readonly description: "Lets the app execute its own code inside a page it embedded, to read back a computed result.";
 }, {
-    readonly scope: "network.fetch";
-    readonly category: "network";
+    readonly scope: 'network.fetch';
+    readonly category: 'network';
     readonly severity: 0;
-    readonly title: "Fetch data from other sites";
-    readonly description: "Lets the app download public data from other websites directly, past the usual cross-origin limits.";
+    readonly title: 'Fetch data from other sites';
+    readonly description: 'Lets the app download public data from other websites directly, past the usual cross-origin limits.';
 }, {
-    readonly scope: "network.fetchCredentialed";
-    readonly category: "network";
+    readonly scope: 'network.fetchCredentialed';
+    readonly category: 'network';
     readonly severity: 3;
     readonly unsafe: true;
-    readonly title: "Fetch from other sites, signed in as you";
-    readonly description: "Lets the app fetch other sites using your logged-in session cookies, so it can read data only you should see.";
+    readonly title: 'Fetch from other sites, signed in as you';
+    readonly description: 'Lets the app fetch other sites using your logged-in session cookies, so it can read data only you should see.';
 }, {
-    readonly scope: "network.fetchLocal";
-    readonly category: "network";
+    readonly scope: 'network.fetchLocal';
+    readonly category: 'network';
     readonly severity: 3;
     readonly unsafe: true;
-    readonly title: "Access devices on your local network";
-    readonly description: "Lets the app reach devices and services on your home or work network, which websites normally cannot touch.";
+    readonly title: 'Access devices on your local network';
+    readonly description: 'Lets the app reach devices and services on your home or work network, which websites normally cannot touch.';
 }, {
-    readonly scope: "network.readCookie";
-    readonly category: "network";
+    readonly scope: 'network.readCookie';
+    readonly category: 'network';
     readonly severity: 3;
     readonly unsafe: true;
-    readonly title: "Read a site’s cookie";
-    readonly description: "Lets the app read a named cookie from another site, which can include the login token only that site should see.";
+    readonly title: 'Read a site’s cookie';
+    readonly description: 'Lets the app read a named cookie from another site, which can include the login token only that site should see.';
 }, {
-    readonly scope: "network.modifyRequestHeaders";
-    readonly category: "network";
+    readonly scope: 'network.modifyRequestHeaders';
+    readonly category: 'network';
     readonly severity: 2;
     readonly unsafe: true;
-    readonly title: "Rewrite request headers to other sites";
-    readonly description: "Lets the app set or remove headers (like Origin and Referer) on this page’s own requests to the listed sites.";
+    readonly title: 'Rewrite request headers to other sites';
+    readonly description: 'Lets the app set or remove headers (like Origin and Referer) on this page’s own requests to the listed sites.';
 }];
 type PermissionScope = (typeof PERMISSIONS)[number]['scope'];
 
@@ -736,7 +737,7 @@ declare const permissions: {
     request: (requests: PermissionRequest[]) => Promise<PermissionGrant[]>;
 };
 
-declare const type: "videoElement";
+declare const type: 'videoElement';
 type TimeRangesTuple = [number, number][];
 type VideoElementState = {
     currentTime: number;
@@ -799,7 +800,7 @@ type BoxedVideoElement = BoxBase<typeof type> & {
 declare const createVideoElementHandle: (element: HTMLVideoElement) => RemoteVideoElement;
 declare const isType: (value: unknown) => value is RemoteVideoElement;
 declare const box: <T extends RemoteVideoElement, T2 extends RevivableContext>(value: T, context: T2) => BoxedVideoElement;
-declare const revive: <T extends BoxedVideoElement, T2 extends RevivableContext>(value: T, context: T2) => T[typeof UnderlyingType];
+declare const revive: <T extends BoxedVideoElement, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
 
 type videoElement_BoxedVideoElement = BoxedVideoElement;
 type videoElement_RemoteVideoElement = RemoteVideoElement;
@@ -814,57 +815,30 @@ declare namespace videoElement {
   export type { videoElement_BoxedVideoElement as BoxedVideoElement, videoElement_RemoteVideoElement as RemoteVideoElement, videoElement_VideoElementState as VideoElementState };
 }
 
-declare const handleRevivableModules: (defaults: readonly [typeof osra_build_revivables_transfer, typeof osra_build_revivables_identity, typeof osra_build_revivables_array_buffer, typeof osra_build_revivables_date, typeof osra_build_revivables_headers, typeof osra_build_revivables_error, typeof osra_build_revivables_typed_array, typeof osra_build_revivables_blob, typeof osra_build_revivables_promise, typeof osra_build_revivables_function, typeof osra_build_revivables_message_port, typeof osra_build_revivables_readable_stream, typeof osra_build_revivables_writable_stream, typeof osra_build_revivables_abort_signal, typeof osra_build_revivables_response, typeof osra_build_revivables_request, typeof osra_build_revivables_map, typeof osra_build_revivables_set, typeof osra_build_revivables_bigint, typeof osra_build_revivables_symbol, typeof osra_build_revivables_event, typeof osra_build_revivables_async_iterator, {
-    readonly type: "nonFiniteNumber";
-    readonly isType: (value: unknown) => value is number;
-    readonly box: (value: number, context: osra.RevivableContext<any>) => number | osra_build_revivables_json_primitives.BoxedNonFiniteNumber;
-    readonly revive: (value: osra_build_revivables_json_primitives.BoxedNonFiniteNumber, _context: osra.RevivableContext<any>) => number;
-}, {
-    readonly type: "undefined";
-    readonly isType: (value: unknown) => value is undefined;
-    readonly box: (value: undefined, context: osra.RevivableContext<any>) => osra_build_revivables_json_primitives.BoxedUndefined | undefined;
-    readonly revive: (_value: osra_build_revivables_json_primitives.BoxedUndefined, _context: osra.RevivableContext<any>) => undefined;
-}, {
-    readonly type: "clonable";
-    readonly capableOnly: true;
-    readonly isType: (value: unknown) => value is osra_build_revivables_fallbacks.Clonable;
-    readonly box: (value: osra_build_revivables_fallbacks.Clonable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Clonable;
-    readonly revive: (value: osra_build_revivables_fallbacks.BoxedClonable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Clonable;
-}, {
-    readonly type: "transferable";
-    readonly capableOnly: true;
-    readonly isType: (value: unknown) => value is osra_build_revivables_fallbacks.Transferable;
-    readonly box: (value: osra_build_revivables_fallbacks.Transferable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Transferable;
-    readonly revive: (value: osra_build_revivables_fallbacks.BoxedTransferable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Transferable;
-}, typeof osra_build_revivables_event_target, {
-    readonly type: "unclonable";
-    readonly isType: (value: unknown) => value is never;
-    readonly box: (_value: never, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.BoxedUnclonable;
-    readonly revive: (_value: osra_build_revivables_fallbacks.BoxedUnclonable, _context: osra.RevivableContext<any>) => Record<string, never>;
-}]) => readonly [typeof videoElement, typeof osra_build_revivables_transfer, typeof osra_build_revivables_identity, typeof osra_build_revivables_array_buffer, typeof osra_build_revivables_date, typeof osra_build_revivables_headers, typeof osra_build_revivables_error, typeof osra_build_revivables_typed_array, typeof osra_build_revivables_blob, typeof osra_build_revivables_promise, typeof osra_build_revivables_function, typeof osra_build_revivables_message_port, typeof osra_build_revivables_readable_stream, typeof osra_build_revivables_writable_stream, typeof osra_build_revivables_abort_signal, typeof osra_build_revivables_response, typeof osra_build_revivables_request, typeof osra_build_revivables_map, typeof osra_build_revivables_set, typeof osra_build_revivables_bigint, typeof osra_build_revivables_symbol, typeof osra_build_revivables_event, typeof osra_build_revivables_async_iterator, {
-    readonly type: "nonFiniteNumber";
+declare const handleRevivableModules: (defaults: DefaultRevivableModules) => readonly [typeof videoElement, typeof osra_build_revivables_transfer, typeof osra_build_revivables_identity, typeof osra_build_revivables_array_buffer, typeof osra_build_revivables_date, typeof osra_build_revivables_headers, typeof osra_build_revivables_error, typeof osra_build_revivables_typed_array, typeof osra_build_revivables_blob, typeof osra_build_revivables_promise, typeof osra_build_revivables_function, typeof osra_build_revivables_message_port, typeof osra_build_revivables_readable_stream, typeof osra_build_revivables_writable_stream, typeof osra_build_revivables_abort_signal, typeof osra_build_revivables_response, typeof osra_build_revivables_request, typeof osra_build_revivables_map, typeof osra_build_revivables_set, typeof osra_build_revivables_bigint, typeof osra_build_revivables_symbol, typeof osra_build_revivables_event, typeof osra_build_revivables_async_iterator, {
+    readonly type: 'nonFiniteNumber';
     readonly isType: (value: unknown) => value is number;
-    readonly box: (value: number, context: osra.RevivableContext<any>) => number | osra_build_revivables_json_primitives.BoxedNonFiniteNumber;
+    readonly box: (value: number, context: osra.RevivableContext<any>) => osra_build_revivables_json_primitives.BoxedNonFiniteNumber | number;
     readonly revive: (value: osra_build_revivables_json_primitives.BoxedNonFiniteNumber, _context: osra.RevivableContext<any>) => number;
 }, {
-    readonly type: "undefined";
+    readonly type: 'undefined';
     readonly isType: (value: unknown) => value is undefined;
     readonly box: (value: undefined, context: osra.RevivableContext<any>) => osra_build_revivables_json_primitives.BoxedUndefined | undefined;
     readonly revive: (_value: osra_build_revivables_json_primitives.BoxedUndefined, _context: osra.RevivableContext<any>) => undefined;
 }, {
-    readonly type: "clonable";
+    readonly type: 'clonable';
     readonly capableOnly: true;
     readonly isType: (value: unknown) => value is osra_build_revivables_fallbacks.Clonable;
     readonly box: (value: osra_build_revivables_fallbacks.Clonable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Clonable;
     readonly revive: (value: osra_build_revivables_fallbacks.BoxedClonable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Clonable;
 }, {
-    readonly type: "transferable";
+    readonly type: 'transferable';
     readonly capableOnly: true;
     readonly isType: (value: unknown) => value is osra_build_revivables_fallbacks.Transferable;
     readonly box: (value: osra_build_revivables_fallbacks.Transferable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Transferable;
     readonly revive: (value: osra_build_revivables_fallbacks.BoxedTransferable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Transferable;
 }, typeof osra_build_revivables_event_target, {
-    readonly type: "unclonable";
+    readonly type: 'unclonable';
     readonly isType: (value: unknown) => value is never;
     readonly box: (_value: never, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.BoxedUnclonable;
     readonly revive: (_value: osra_build_revivables_fallbacks.BoxedUnclonable, _context: osra.RevivableContext<any>) => Record<string, never>;
@@ -1114,6 +1088,21 @@ declare const processTcpSocket: ({ connectedPacket, dataReadableStream, dataWrit
 }>;
 type TcpSocketResult = Awaited<ReturnType<typeof processTcpSocket>>;
 
+type StorageEntry = {
+    path: string;
+    size: number;
+    contentType: string | null;
+    updatedAt: string;
+};
+type StorageQuota$1 = {
+    usedBytes: number;
+    limitBytes: number;
+    remaining: number;
+    objects: number;
+    maxObjects: number;
+};
+type WriteData$1 = Blob | ArrayBuffer | Uint8Array | string;
+
 type Account = {
     name: string;
     image: string | null;
@@ -1137,7 +1126,7 @@ type Quota = {
 
 declare const resolvers: {
     readonly cloud: {
-        readonly fetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
+        readonly fetch: (input: string | Request | URL, init?: (RequestInit | undefined) & {
             render?: boolean;
         }) => Promise<Response>;
         readonly quota: () => Promise<Quota>;
@@ -1147,6 +1136,14 @@ declare const resolvers: {
                 family: 0 | 4 | 6;
             }) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
         };
+        readonly fs: {
+            readonly available: () => Promise<boolean>;
+            readonly list: () => Promise<StorageEntry[]>;
+            readonly quota: () => Promise<StorageQuota$1>;
+            readonly readFile: (path: string) => Promise<Blob>;
+            readonly writeFile: (path: string, data: WriteData$1, contentType: string | null) => Promise<void>;
+            readonly remove: (path: string) => Promise<void>;
+        };
         readonly webvpn: {
             readonly tcpSocket: ({ remoteAddress: _remoteAddress, remotePort }: {
                 remoteAddress: string;
@@ -1232,7 +1229,7 @@ declare const resolvers: {
         readonly logout: () => void;
         readonly onChange: (listener: () => void) => (() => void);
     };
-    readonly proxyFetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
+    readonly proxyFetch: (input: string | Request | URL, init?: (RequestInit | undefined) & {
         render?: boolean;
     }) => Promise<Response>;
     readonly webVpnTcpSocket: ({ remoteAddress: _remoteAddress, remotePort }: {
@@ -1334,7 +1331,7 @@ type QuotaStatus = {
     /** current effective egress rate cap, bits per second (for display) */
     bitsPerSecond: number;
 };
-declare const quota: () => Promise<QuotaStatus>;
+declare const quota$1: () => Promise<QuotaStatus>;
 
 declare const lookup: <T extends boolean = false>(hostname: string, options?: {
     all?: T;
@@ -1348,6 +1345,86 @@ declare namespace dns$1 {
   export type { dns$1_AddressLookupResult as AddressLookupResult };
 }
 
+type ReadOptions = BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+} | null | undefined;
+type WriteOptions = BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    mode?: number;
+    flag?: string;
+    contentType?: string;
+} | null | undefined;
+type WriteData = string | Uint8Array | ArrayBuffer | DataView;
+type MakeOptions = {
+    recursive?: boolean;
+} | number | null | undefined;
+type Callback<R> = (error: NodeJS.ErrnoException | null, result?: R) => void;
+type Stats = {
+    size: number;
+    mtimeMs: number;
+    mtime: Date;
+    atimeMs: number;
+    ctimeMs: number;
+    mode: number;
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+    isSymbolicLink: () => boolean;
+};
+
+type FileEntry = {
+    path: string;
+    size: number;
+    contentType: string | null;
+    updatedAt: string;
+};
+type StorageQuota = {
+    usedBytes: number;
+    limitBytes: number;
+    remaining: number;
+    objects: number;
+    maxObjects: number;
+};
+declare const quota: () => Promise<StorageQuota>;
+
+declare const available$4: () => Promise<boolean>;
+declare const readFile$2: (path: node_fs.PathLike, a: ReadOptions | Callback<Buffer | string>, b?: Callback<Buffer | string>) => void;
+declare const writeFile$2: (path: node_fs.PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void;
+declare const unlink$2: (path: node_fs.PathLike, callback: Callback<void>) => void;
+declare const rename$2: (from: node_fs.PathLike, to: node_fs.PathLike, callback: Callback<void>) => void;
+declare const readdir$2: (path: node_fs.PathLike, a: unknown, b?: Callback<string[]>) => void;
+declare const mkdir$2: (path: node_fs.PathLike, a: MakeOptions | Callback<void>, b?: Callback<void>) => void;
+declare const rm$2: (path: node_fs.PathLike, a: {
+    recursive?: boolean;
+} | Callback<void>, b?: Callback<void>) => void;
+declare const stat$2: (path: node_fs.PathLike, callback: Callback<Stats>) => void;
+declare const promises$2: {
+    readFile: (path: node_fs.PathLike, options?: ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    unlink: (path: node_fs.PathLike) => Promise<void>;
+    rename: (from: node_fs.PathLike, to: node_fs.PathLike) => Promise<void>;
+    readdir: (path: node_fs.PathLike) => Promise<string[]>;
+    mkdir: (_path?: node_fs.PathLike, _options?: MakeOptions) => Promise<void>;
+    rm: (path: node_fs.PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    rmdir: (path: node_fs.PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    stat: (path: node_fs.PathLike) => Promise<Stats>;
+    lstat: (path: node_fs.PathLike) => Promise<Stats>;
+    access: (path: node_fs.PathLike) => Promise<void>;
+};
+
+type fs$1_FileEntry = FileEntry;
+type fs$1_Stats = Stats;
+type fs$1_StorageQuota = StorageQuota;
+declare const fs$1_quota: typeof quota;
+declare namespace fs$1 {
+  export { available$4 as available, mkdir$2 as mkdir, promises$2 as promises, fs$1_quota as quota, readFile$2 as readFile, readdir$2 as readdir, rename$2 as rename, rm$2 as rm, stat$2 as stat, unlink$2 as unlink, writeFile$2 as writeFile };
+  export type { fs$1_FileEntry as FileEntry, fs$1_Stats as Stats, fs$1_StorageQuota as StorageQuota };
+}
+
 declare const isIPv4: (input: string) => boolean;
 declare const isIPv6: (input: string) => boolean;
 declare const isIP: (input: string) => 0 | 4 | 6;
@@ -1587,7 +1664,7 @@ declare class Socket extends EventEmitter implements Socket$3 {
     dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
     [Symbol.asyncDispose](): Promise<void>;
 }
-declare const createSocket: (options: SocketType | SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void) => Socket;
+declare const createSocket: (options: SocketType | SocketOptions, callback?: (msg: Buffer$1, rinfo: RemoteInfo) => void) => Socket;
 
 type dgram$1_Socket = Socket;
 declare const dgram$1_Socket: typeof Socket;
@@ -1681,9 +1758,9 @@ declare abstract class OutgoingMessage extends Stream.Writable {
     protected _storeHeader(startLine: string): string;
     protected abstract _shouldSendBody(): boolean;
     protected abstract _implicitHeader(): void;
-    protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+    protected _writeToSocket(data: Buffer$1, callback: (error?: Error | null) => void): void;
     write(chunk: unknown, encoding?: BufferEncoding | ((error: Error | null | undefined) => void), callback?: (error: Error | null | undefined) => void): boolean;
-    _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _write(chunk: Buffer$1, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
     _final(callback: (error?: Error | null) => void): void;
     end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
     protected _headBlock?: string;
@@ -1731,7 +1808,7 @@ declare class ClientRequest extends OutgoingMessage {
     abort(): void;
     destroy(error?: Error): this;
     end(chunk?: unknown, encoding?: unknown, callback?: unknown): this;
-    protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+    protected _writeToSocket(data: Buffer$1, callback: (error?: Error | null) => void): void;
     setTimeout(timeout: number, callback?: () => void): this;
     setNoDelay(noDelay?: boolean): void;
     setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
@@ -1802,13 +1879,12 @@ declare namespace http {
   export type { http_ClientRequestArgs as ClientRequestArgs, http_ParsedHead as ParsedHead, http_RequestListener as RequestListener, http_Server as Server, http_ServerResponseOptions as ServerResponseOptions };
 }
 
-declare const available$1: () => boolean;
+declare const available$3: () => boolean;
 
 type cloud_QuotaStatus = QuotaStatus;
 declare const cloud_http: typeof http;
-declare const cloud_quota: typeof quota;
 declare namespace cloud {
-  export { available$1 as available, dgram$1 as dgram, dns$1 as dns, cloudFetch as fetch, cloud_http as http, net$1 as net, cloud_quota as quota };
+  export { available$3 as available, dgram$1 as dgram, dns$1 as dns, cloudFetch as fetch, fs$1 as fs, cloud_http as http, net$1 as net, quota$1 as quota };
   export type { cloud_QuotaStatus as QuotaStatus };
 }
 
@@ -1868,7 +1944,7 @@ declare namespace extension {
   export type { extension_AttachFrameOptions as AttachFrameOptions, extension_BoxedVideoElement as BoxedVideoElement, extension_CookieDetails as CookieDetails, extension_FetchInit as FetchInit, extension_Frame as Frame, extension_GotoOptions as GotoOptions, extension_HeaderOperation as HeaderOperation, extension_PermissionGrant as PermissionGrant, extension_PermissionRequest as PermissionRequest, extension_ProxyFetchRequest as ProxyFetchRequest, extension_RemoteVideoElement as RemoteVideoElement, extension_RequestHeaderRule as RequestHeaderRule, extension_SiteCookie as SiteCookie, extension_VideoElementState as VideoElementState };
 }
 
-declare const available: () => boolean;
+declare const available$2: () => boolean;
 declare const fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 declare const dns: {
     lookup: (..._args: unknown[]) => never;
@@ -1881,49 +1957,200 @@ declare const net: {
 declare const dgram: {
     createSocket: (..._args: unknown[]) => never;
 };
-declare const fs$1: {
-    isLocalDirectorySupported: () => boolean;
-    pickLocalDirectory: (..._args: unknown[]) => never;
-    queryDirectoryPermission: (..._args: unknown[]) => never;
-    ensureDirectoryPermission: (..._args: unknown[]) => never;
+declare const fs: {
+    available: () => Promise<boolean>;
+    readFile: (..._args: unknown[]) => never;
+    readFileSync: (..._args: unknown[]) => never;
+    writeFile: (..._args: unknown[]) => never;
+    writeFileSync: (..._args: unknown[]) => never;
+    appendFile: (..._args: unknown[]) => never;
+    appendFileSync: (..._args: unknown[]) => never;
+    existsSync: (..._args: unknown[]) => never;
+    stat: (..._args: unknown[]) => never;
+    statSync: (..._args: unknown[]) => never;
+    readdir: (..._args: unknown[]) => never;
+    readdirSync: (..._args: unknown[]) => never;
+    mkdir: (..._args: unknown[]) => never;
+    mkdirSync: (..._args: unknown[]) => never;
+    rm: (..._args: unknown[]) => never;
+    rmSync: (..._args: unknown[]) => never;
+    unlink: (..._args: unknown[]) => never;
+    unlinkSync: (..._args: unknown[]) => never;
+    rename: (..._args: unknown[]) => never;
+    renameSync: (..._args: unknown[]) => never;
+    mount: (..._args: unknown[]) => never;
+    flush: (..._args: unknown[]) => never;
+    promises: {
+        readFile: (..._args: unknown[]) => never;
+        writeFile: (..._args: unknown[]) => never;
+        unlink: (..._args: unknown[]) => never;
+        rename: (..._args: unknown[]) => never;
+        readdir: (..._args: unknown[]) => never;
+        mkdir: (..._args: unknown[]) => never;
+        rm: (..._args: unknown[]) => never;
+        stat: (..._args: unknown[]) => never;
+    };
 };
 
-declare const desktop_available: typeof available;
 declare const desktop_dgram: typeof dgram;
 declare const desktop_dns: typeof dns;
 declare const desktop_fetch: typeof fetch;
+declare const desktop_fs: typeof fs;
 declare const desktop_net: typeof net;
 declare namespace desktop {
   export {
-    desktop_available as available,
+    available$2 as available,
     desktop_dgram as dgram,
     desktop_dns as dns,
     desktop_fetch as fetch,
-    fs$1 as fs,
+    desktop_fs as fs,
     desktop_net as net,
   };
 }
 
-type DirectoryPermissionMode = 'read' | 'readwrite';
-type PickLocalDirectoryOptions = {
-    id?: string;
-    mode?: DirectoryPermissionMode;
-    startIn?: 'desktop' | 'documents' | 'downloads' | 'music' | 'pictures' | 'videos';
-};
-declare const isLocalDirectorySupported: () => boolean;
-declare const pickLocalDirectory: (options?: PickLocalDirectoryOptions) => Promise<FileSystemDirectoryHandle | undefined>;
-declare const queryDirectoryPermission: (handle: FileSystemDirectoryHandle, mode?: DirectoryPermissionMode) => Promise<PermissionState>;
-declare const ensureDirectoryPermission: (handle: FileSystemDirectoryHandle, mode?: DirectoryPermissionMode) => Promise<boolean>;
-
-type fs_DirectoryPermissionMode = DirectoryPermissionMode;
-type fs_PickLocalDirectoryOptions = PickLocalDirectoryOptions;
-declare const fs_ensureDirectoryPermission: typeof ensureDirectoryPermission;
-declare const fs_isLocalDirectorySupported: typeof isLocalDirectorySupported;
-declare const fs_pickLocalDirectory: typeof pickLocalDirectory;
-declare const fs_queryDirectoryPermission: typeof queryDirectoryPermission;
-declare namespace fs {
-  export { fs_ensureDirectoryPermission as ensureDirectoryPermission, fs_isLocalDirectorySupported as isLocalDirectorySupported, fs_pickLocalDirectory as pickLocalDirectory, fs_queryDirectoryPermission as queryDirectoryPermission };
-  export type { fs_DirectoryPermissionMode as DirectoryPermissionMode, fs_PickLocalDirectoryOptions as PickLocalDirectoryOptions };
+declare const available$1: () => Promise<boolean>;
+declare const readFileSync$1: (path: node_fs.PathLike, options?: ReadOptions) => Buffer | string;
+declare const writeFileSync$1: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => void;
+declare const appendFileSync$1: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => void;
+declare const existsSync$1: (path: node_fs.PathLike) => boolean;
+declare const statSync$1: (path: node_fs.PathLike) => Stats;
+declare const lstatSync$1: (path: node_fs.PathLike) => Stats;
+declare const readdirSync$1: (path: node_fs.PathLike) => string[];
+declare const mkdirSync$1: (path: node_fs.PathLike, options?: MakeOptions) => void;
+declare const rmSync$1: (path: node_fs.PathLike, options?: {
+    recursive?: boolean;
+    force?: boolean;
+}) => void;
+declare const rmdirSync$1: (path: node_fs.PathLike, options?: {
+    recursive?: boolean;
+}) => void;
+declare const unlinkSync$1: (path: node_fs.PathLike) => void;
+declare const renameSync$1: (from: node_fs.PathLike, to: node_fs.PathLike) => void;
+declare const readFile$1: (path: node_fs.PathLike, a: ReadOptions | Callback<Buffer | string>, b?: Callback<Buffer | string>) => void;
+declare const writeFile$1: (path: node_fs.PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void;
+declare const appendFile$1: (path: node_fs.PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void;
+declare const stat$1: (path: node_fs.PathLike, callback: Callback<Stats>) => void;
+declare const readdir$1: (path: node_fs.PathLike, a: unknown, b?: Callback<string[]>) => void;
+declare const mkdir$1: (path: node_fs.PathLike, a: MakeOptions | Callback<void>, b?: Callback<void>) => void;
+declare const rm$1: (path: node_fs.PathLike, a: {
+    recursive?: boolean;
+} | Callback<void>, b?: Callback<void>) => void;
+declare const unlink$1: (path: node_fs.PathLike, callback: Callback<void>) => void;
+declare const rename$1: (from: node_fs.PathLike, to: node_fs.PathLike, callback: Callback<void>) => void;
+declare const exists$1: (path: node_fs.PathLike, callback: (exists: boolean) => void) => void;
+declare const promises$1: {
+    readFile: (path: node_fs.PathLike, options?: ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    appendFile: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    stat: (path: node_fs.PathLike) => Promise<Stats>;
+    lstat: (path: node_fs.PathLike) => Promise<Stats>;
+    readdir: (path: node_fs.PathLike) => Promise<string[]>;
+    mkdir: (path: node_fs.PathLike, options?: MakeOptions) => Promise<void>;
+    rm: (path: node_fs.PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    rmdir: (path: node_fs.PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    unlink: (path: node_fs.PathLike) => Promise<void>;
+    rename: (from: node_fs.PathLike, to: node_fs.PathLike) => Promise<void>;
+    access: (path: node_fs.PathLike) => Promise<void>;
+};
+declare const mount$1: () => Promise<void>;
+declare const flush$1: () => Promise<void>;
+declare const remount$1: () => Promise<void>;
+declare const pull: (path: string) => Promise<Blob>;
+
+type index$1_Stats = Stats;
+declare const index$1_pull: typeof pull;
+declare namespace index$1 {
+  export { appendFile$1 as appendFile, appendFileSync$1 as appendFileSync, available$1 as available, exists$1 as exists, existsSync$1 as existsSync, flush$1 as flush, lstatSync$1 as lstatSync, mkdir$1 as mkdir, mkdirSync$1 as mkdirSync, mount$1 as mount, promises$1 as promises, index$1_pull as pull, readFile$1 as readFile, readFileSync$1 as readFileSync, readdir$1 as readdir, readdirSync$1 as readdirSync, remount$1 as remount, rename$1 as rename, renameSync$1 as renameSync, rm$1 as rm, rmSync$1 as rmSync, rmdirSync$1 as rmdirSync, stat$1 as stat, statSync$1 as statSync, unlink$1 as unlink, unlinkSync$1 as unlinkSync, writeFile$1 as writeFile, writeFileSync$1 as writeFileSync };
+  export type { index$1_Stats as Stats };
+}
+
+declare const available: () => Promise<boolean>;
+declare const readFileSync: (path: node_fs.PathLike, options?: ReadOptions) => Buffer | string;
+declare const writeFileSync: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => void;
+declare const appendFileSync: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => void;
+declare const existsSync: (path: node_fs.PathLike) => boolean;
+declare const statSync: (path: node_fs.PathLike) => Stats;
+declare const lstatSync: (path: node_fs.PathLike) => Stats;
+declare const readdirSync: (path: node_fs.PathLike) => string[];
+declare const mkdirSync: (path: node_fs.PathLike, options?: MakeOptions) => void;
+declare const rmSync: (path: node_fs.PathLike, options?: {
+    recursive?: boolean;
+    force?: boolean;
+}) => void;
+declare const rmdirSync: (path: node_fs.PathLike, options?: {
+    recursive?: boolean;
+}) => void;
+declare const unlinkSync: (path: node_fs.PathLike) => void;
+declare const renameSync: (from: node_fs.PathLike, to: node_fs.PathLike) => void;
+declare const readFile: (path: node_fs.PathLike, a: ReadOptions | Callback<Buffer | string>, b?: Callback<Buffer | string>) => void;
+declare const writeFile: (path: node_fs.PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void;
+declare const appendFile: (path: node_fs.PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void;
+declare const stat: (path: node_fs.PathLike, callback: Callback<Stats>) => void;
+declare const readdir: (path: node_fs.PathLike, a: unknown, b?: Callback<string[]>) => void;
+declare const mkdir: (path: node_fs.PathLike, a: MakeOptions | Callback<void>, b?: Callback<void>) => void;
+declare const rm: (path: node_fs.PathLike, a: {
+    recursive?: boolean;
+} | Callback<void>, b?: Callback<void>) => void;
+declare const unlink: (path: node_fs.PathLike, callback: Callback<void>) => void;
+declare const rename: (from: node_fs.PathLike, to: node_fs.PathLike, callback: Callback<void>) => void;
+declare const exists: (path: node_fs.PathLike, callback: (exists: boolean) => void) => void;
+declare const promises: {
+    readFile: (path: node_fs.PathLike, options?: ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    appendFile: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    stat: (path: node_fs.PathLike) => Promise<Stats>;
+    lstat: (path: node_fs.PathLike) => Promise<Stats>;
+    readdir: (path: node_fs.PathLike) => Promise<string[]>;
+    mkdir: (path: node_fs.PathLike, options?: MakeOptions) => Promise<void>;
+    rm: (path: node_fs.PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    rmdir: (path: node_fs.PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    unlink: (path: node_fs.PathLike) => Promise<void>;
+    rename: (from: node_fs.PathLike, to: node_fs.PathLike) => Promise<void>;
+    access: (path: node_fs.PathLike) => Promise<void>;
+};
+declare const mount: () => Promise<void>;
+declare const flush: () => Promise<void>;
+declare const remount: () => Promise<void>;
+
+type index_Stats = Stats;
+declare const index_appendFile: typeof appendFile;
+declare const index_appendFileSync: typeof appendFileSync;
+declare const index_available: typeof available;
+declare const index_exists: typeof exists;
+declare const index_existsSync: typeof existsSync;
+declare const index_flush: typeof flush;
+declare const index_lstatSync: typeof lstatSync;
+declare const index_mkdir: typeof mkdir;
+declare const index_mkdirSync: typeof mkdirSync;
+declare const index_mount: typeof mount;
+declare const index_promises: typeof promises;
+declare const index_readFile: typeof readFile;
+declare const index_readFileSync: typeof readFileSync;
+declare const index_readdir: typeof readdir;
+declare const index_readdirSync: typeof readdirSync;
+declare const index_remount: typeof remount;
+declare const index_rename: typeof rename;
+declare const index_renameSync: typeof renameSync;
+declare const index_rm: typeof rm;
+declare const index_rmSync: typeof rmSync;
+declare const index_rmdirSync: typeof rmdirSync;
+declare const index_stat: typeof stat;
+declare const index_statSync: typeof statSync;
+declare const index_unlink: typeof unlink;
+declare const index_unlinkSync: typeof unlinkSync;
+declare const index_writeFile: typeof writeFile;
+declare const index_writeFileSync: typeof writeFileSync;
+declare namespace index {
+  export { index_appendFile as appendFile, index_appendFileSync as appendFileSync, index_available as available, index_exists as exists, index_existsSync as existsSync, index_flush as flush, index_lstatSync as lstatSync, index_mkdir as mkdir, index_mkdirSync as mkdirSync, index_mount as mount, index_promises as promises, index_readFile as readFile, index_readFileSync as readFileSync, index_readdir as readdir, index_readdirSync as readdirSync, index_remount as remount, index_rename as rename, index_renameSync as renameSync, index_rm as rm, index_rmSync as rmSync, index_rmdirSync as rmdirSync, index_stat as stat, index_statSync as statSync, index_unlink as unlink, index_unlinkSync as unlinkSync, index_writeFile as writeFile, index_writeFileSync as writeFileSync };
+  export type { index_Stats as Stats };
 }
 
 declare const relayWorker: (worker: Worker, options?: {
@@ -1966,5 +2193,5 @@ type ConnectButtonProps = {
 };
 declare const ConnectButton: ({ className, style }?: ConnectButtonProps) => ReactElement;
 
-export { ATTACH_FRAME_EVENT_KEY, ConnectButton, account, assertAttachableFrameUrl, assertFetchableUrl, attachFrame, attachFramePermission, box, cloud, connect, connectButtonUrl, cookies, createVideoElementHandle, desktop, dgram$1 as dgram, dns$1 as dns, evaluatePermission, extension, fetch$1 as fetch, fetchCredentialedPermission, fetchLocalPermission, fetchPermission, fs, gotoPermission, handleRevivableModules, http, isBlockedFetchUrl, isBlockedFrameUrl, isExtensionExposed, isLocalNetworkUrl, isType, modifyRequestHeadersPermission, net$1 as net, permissions, promptInstall, readCookiePermission, relayWorker, removeRequestHeaderRule, revive, setMissingExtensionHandler, setRequestHeaderRule, type, waitForExtensionExposure };
+export { ATTACH_FRAME_EVENT_KEY, ConnectButton, account, assertAttachableFrameUrl, assertFetchableUrl, attachFrame, attachFramePermission, box, cloud, connect, connectButtonUrl, cookies, createVideoElementHandle, desktop, dgram$1 as dgram, dns$1 as dns, evaluatePermission, extension, fetch$1 as fetch, fetchCredentialedPermission, fetchLocalPermission, fetchPermission, index$1 as fs, gotoPermission, handleRevivableModules, http, isBlockedFetchUrl, isBlockedFrameUrl, isExtensionExposed, isLocalNetworkUrl, isType, modifyRequestHeadersPermission, net$1 as net, index as opfs, permissions, promptInstall, readCookiePermission, relayWorker, removeRequestHeaderRule, revive, setMissingExtensionHandler, setRequestHeaderRule, type, waitForExtensionExposure };
 export type { AttachFrameOptions, BoxedVideoElement, ConnectButtonProps, CookieDetails, FetchInit, Frame, GotoOptions, HeaderOperation, PermissionGrant, PermissionRequest, ProxyFetchRequest, RemoteVideoElement, RequestHeaderRule, SiteCookie, VideoElementState };