@fkn/lib 0.9.43 → 0.9.44

package/{extension-BtDg-F2g.d.ts → extension-BlEtNAYc.d.ts}

@@ -1,4 +1,4 @@
-import { $ as GateTools, A as attachFramePermission, B as CategoryMeta, C as FrameWindowRefusal, D as StorageState, E as Locator, F as LegacyPermissionRequest, G as VideoElementState, H as handleRevivableModules, I as PermissionGrant, J as isType, K as box, L as PermissionRequest, M as gotoPermission, N as CategoryGrant, O as StorageStateCookie, P as CategoryRequest, Q as Gate, R as permissions, S as FrameWindowOptions, T as GotoOptions, U as BoxedVideoElement, V as PermissionCategory, W as RemoteVideoElement, X as type, Y as revive, Z as Executor, _ as FrameEventMap, a as AttachCookies, b as FramePostMessageOptions, c as BlankPage, d as CookieMatchWire, et as OperationRequest, f as Frame, g as FrameEventListener, h as FrameDocumentEvent, i as AddScriptTagOptions, j as createFrame, k as WindowFrame, l as ClearCookiesOptions, m as FrameBackendEvent, n as attachFrame, o as AttachFrameOptions, p as FrameBackend, q as createVideoElementHandle, s as AttachWindowOptions, t as ATTACH_FRAME_EVENT_KEY, tt as SelectorPart, u as ClearCookiesWire, v as FrameLocator, w as FrameWindowRefusedError, x as FrameWindowBlockedError, y as FrameMessageEvent, z as CATEGORIES } from "./index-Cgnfjh9o.js";
+import { $ as GateTools, A as attachFramePermission, B as CategoryMeta, C as FrameWindowRefusal, D as StorageState, E as Locator, F as LegacyPermissionRequest, G as VideoElementState, H as handleRevivableModules, I as PermissionGrant, J as isType, K as box, L as PermissionRequest, M as gotoPermission, N as CategoryGrant, O as StorageStateCookie, P as CategoryRequest, Q as Gate, R as permissions, S as FrameWindowOptions, T as GotoOptions, U as BoxedVideoElement, V as PermissionCategory, W as RemoteVideoElement, X as type, Y as revive, Z as Executor, _ as FrameEventMap, a as AttachCookies, b as FramePostMessageOptions, c as BlankPage, d as CookieMatchWire, et as OperationRequest, f as Frame, g as FrameEventListener, h as FrameDocumentEvent, i as AddScriptTagOptions, j as createFrame, k as WindowFrame, l as ClearCookiesOptions, m as FrameBackendEvent, n as attachFrame, o as AttachFrameOptions, p as FrameBackend, q as createVideoElementHandle, s as AttachWindowOptions, t as ATTACH_FRAME_EVENT_KEY, tt as SelectorPart, u as ClearCookiesWire, v as FrameLocator, w as FrameWindowRefusedError, x as FrameWindowBlockedError, y as FrameMessageEvent, z as CATEGORIES } from "./index-BOInGaEl.js";
 //#region ../frame-locator/lib/errors.d.ts
 declare const LOCATOR_ERROR = "LocatorError";
 declare const LOCATOR_UNSUPPORTED = "LocatorUnsupportedError";
@@ -121,6 +121,7 @@ type RequestHeaderRule = {
   requestHeaders: HeaderOperation[];
   reason?: string;
 };
+/** Tab-scoped: the rule is dropped when the tab goes away. */
 declare const setRequestHeaderRule: (rule: RequestHeaderRule) => Promise<{
   ruleId: number;
 }>;
@@ -158,9 +159,7 @@ declare const BACKGROUND_STOPPED = "BackgroundStoppedError";
 /**
  * What a call into the extension rejects with when Chrome stopped the extension's worker before it finished
  * answering: before the call resolved, or, for a `fetch`, while its response body was still arriving.
- *
- * The call may or may not have run, so the extension never sends it again. Retrying is the app's decision, and a
- * retry is answered by the restarted worker.
+ * The call may or may not have run, so it is never resent; a retry by the app reaches the restarted worker.
  */
 type BackgroundStoppedError = Error & {
   name: typeof BACKGROUND_STOPPED;
@@ -170,31 +169,21 @@ declare const isBackgroundStopped: (error: unknown) => boolean;
 //#endregion
 //#region ../web-extension/lib/utils/extension-abi.d.ts
 /**
- * What the extension half announces about itself. Increment when the callable surface CHANGES in a
- * way a page could notice: an operation added, removed, renamed, or given different semantics.
- *
- * This is not the package version and not the manifest version. Those move for reasons that have
- * nothing to do with the protocol (a dependency bump, a store resubmission), and tying the contract
- * to them would make every release look like a protocol change.
+ * What the extension half announces about itself. Increment when the callable surface changes in a
+ * way a page could notice: an operation added, removed, renamed, or given different semantics. Not
+ * the package or manifest version, which move for reasons unrelated to the protocol.
  */
 declare const EXTENSION_ABI = 4;
 /**
- * The oldest extension the page half will talk to. Raise it ONLY when the page half starts depending
- * on something older extensions cannot do, never merely because `EXTENSION_ABI` moved: an added
- * operation does not break a page that does not call it.
- *
- * Deliberately 0 for this release. Every extension currently installed predates versioning and
- * announces no ABI at all, so a floor of 1 would refuse all of them the moment this page half
- * deployed, which is precisely the failure this file exists to prevent.
+ * The oldest extension the page half will talk to. Raise it only when the page half starts depending
+ * on something older extensions cannot do, never merely because `EXTENSION_ABI` moved. Deliberately 0:
+ * extensions that predate versioning announce no ABI, and a floor of 1 would refuse all of them.
  */
 declare const REQUIRED_EXTENSION_ABI = 0;
 /**
- * Three answers, never a boolean.
- *
- * `operations` is `null` when the extension announced no list, which is NOT the same as announcing an
- * empty one. A pre-versioning extension supports the whole original surface and simply cannot say so,
- * so an absent list has to read as "unknown, assume the old set" rather than "supports nothing".
- * Reading it the other way would refuse every operation on every currently installed extension.
+ * `operations` is `null` when the extension announced no list, which is not the same as an empty one:
+ * a pre-versioning extension supports the whole original surface and cannot say so, so `null` reads
+ * as "assume the original set", never "supports nothing".
  */
 type ExtensionHandshake = {
   status: 'absent';
@@ -209,19 +198,14 @@ type ExtensionHandshake = {
   operations: readonly string[] | null;
 };
 /**
- * Whether a named operation is callable.
- *
- * `null` operations means the extension could not tell us, and the answer is YES: it predates the
- * ops list and supports the original surface. The ABI floor is the mechanism for refusing an
- * extension that is genuinely too old; this one only refines a list that was actually announced.
+ * Whether a named operation is callable. A `null` list answers true (the extension predates the list
+ * and supports the original surface); refusing a too-old extension is the ABI floor's job.
  */
 declare const supportsOperation: (handshake: ExtensionHandshake, operation: string) => boolean;
 /**
- * Thrown instead of the generic "not installed" message when the extension IS there and merely too
- * old. Carries both numbers so an app can say which, and link its listing.
- *
- * A named class rather than a message match: only the name survives a structured-clone hop, and the
- * codebase has been bitten before by an error whose identity was its text.
+ * Thrown instead of the generic "not installed" message when the extension is installed but too old.
+ * Carries both numbers so an app can say which and link its listing. Match it by `name`, which
+ * survives a structured-clone hop.
  */
 declare class ExtensionOutdatedError extends Error {
   readonly abi: number;
@@ -248,10 +232,8 @@ type ExtensionEventMap = {
 };
 declare const extension: import("osra").TypedEventTarget<ExtensionEventMap>;
 /**
- * Unchanged on purpose, and still exported: a page half built before versioning calls exactly this,
- * and an extension that announces an ABI must keep answering it the same way. Backwards
- * compatibility here runs in BOTH directions, which is the only property that matters when neither
- * end updates on demand.
+ * Unchanged on purpose: a page half built before versioning calls exactly this, so an extension that
+ * announces an ABI keeps answering it the same way. An outdated extension also answers true.
  */
 declare const isExtensionExposed: () => boolean;
 /** The three-way answer: absent, present but too old, or usable. */

package/extension.d.ts

@@ -1,3 +1,3 @@
-import { $ as GateTools, A as attachFramePermission, B as CategoryMeta, C as FrameWindowRefusal, D as StorageState, E as Locator, F as LegacyPermissionRequest, G as VideoElementState, H as handleRevivableModules, I as PermissionGrant, J as isType, K as box, L as PermissionRequest, M as gotoPermission, N as CategoryGrant, O as StorageStateCookie, P as CategoryRequest, Q as Gate, R as permissions, S as FrameWindowOptions, T as GotoOptions, U as BoxedVideoElement, V as PermissionCategory, W as RemoteVideoElement, X as type, Y as revive, Z as Executor, _ as FrameEventMap, a as AttachCookies, b as FramePostMessageOptions, c as BlankPage, d as CookieMatchWire, et as OperationRequest, f as Frame, g as FrameEventListener, h as FrameDocumentEvent, i as AddScriptTagOptions, j as createFrame, k as WindowFrame, l as ClearCookiesOptions, m as FrameBackendEvent, n as attachFrame, o as AttachFrameOptions, p as FrameBackend, q as createVideoElementHandle, s as AttachWindowOptions, t as ATTACH_FRAME_EVENT_KEY, tt as SelectorPart, u as ClearCookiesWire, v as FrameLocator, w as FrameWindowRefusedError, x as FrameWindowBlockedError, y as FrameMessageEvent, z as CATEGORIES } from "./index-Cgnfjh9o.js";
-import { $ as isLocatorInvalid, A as CookieDetails, B as fetchPermission, C as assertLockdownApplicable, D as modifyRequestHeadersPermission, E as RequestHeaderRule, F as ProxyFetchRequest, G as assertOneCookieIdentity, H as isLocalNetworkUrl, I as assertFetchableUrl, J as LOCATOR_ERROR, K as hasForgedCookie, L as fetch, M as cookies, N as readCookiePermission, O as removeRequestHeaderRule, P as FetchInit, Q as isLocatorDenied, R as fetchCredentialedPermission, S as assertAttachableFrameUrl, T as HeaderOperation, U as FORGEABLE_HEADERS, V as isBlockedFetchUrl, W as assertForgeableHeaders, X as LOCATOR_UNSUPPORTED, Y as LOCATOR_INVALID, Z as TimeoutError, _ as BackgroundStoppedError, a as extension, b as PermissionDeniedError, c as setMissingExtensionHandler, d as ExtensionHandshake, et as isLocatorUnsupported, f as ExtensionOperationUnsupportedError, g as BACKGROUND_STOPPED, h as supportsOperation, i as promptInstall, j as SiteCookie, k as setRequestHeaderRule, l as waitForExtensionExposure, m as REQUIRED_EXTENSION_ABI, o as isExtensionExposed, p as ExtensionOutdatedError, q as LOCATOR_DENIED, r as isExtensionAvailable, s as readExtensionHandshake, tt as isTerminalError, u as EXTENSION_ABI, v as isBackgroundStopped, w as isBlockedFrameUrl, x as isPermissionDenied, y as PERMISSION_DENIED, z as fetchLocalPermission } from "./extension-BtDg-F2g.js";
+import { $ as GateTools, A as attachFramePermission, B as CategoryMeta, C as FrameWindowRefusal, D as StorageState, E as Locator, F as LegacyPermissionRequest, G as VideoElementState, H as handleRevivableModules, I as PermissionGrant, J as isType, K as box, L as PermissionRequest, M as gotoPermission, N as CategoryGrant, O as StorageStateCookie, P as CategoryRequest, Q as Gate, R as permissions, S as FrameWindowOptions, T as GotoOptions, U as BoxedVideoElement, V as PermissionCategory, W as RemoteVideoElement, X as type, Y as revive, Z as Executor, _ as FrameEventMap, a as AttachCookies, b as FramePostMessageOptions, c as BlankPage, d as CookieMatchWire, et as OperationRequest, f as Frame, g as FrameEventListener, h as FrameDocumentEvent, i as AddScriptTagOptions, j as createFrame, k as WindowFrame, l as ClearCookiesOptions, m as FrameBackendEvent, n as attachFrame, o as AttachFrameOptions, p as FrameBackend, q as createVideoElementHandle, s as AttachWindowOptions, t as ATTACH_FRAME_EVENT_KEY, tt as SelectorPart, u as ClearCookiesWire, v as FrameLocator, w as FrameWindowRefusedError, x as FrameWindowBlockedError, y as FrameMessageEvent, z as CATEGORIES } from "./index-BOInGaEl.js";
+import { $ as isLocatorInvalid, A as CookieDetails, B as fetchPermission, C as assertLockdownApplicable, D as modifyRequestHeadersPermission, E as RequestHeaderRule, F as ProxyFetchRequest, G as assertOneCookieIdentity, H as isLocalNetworkUrl, I as assertFetchableUrl, J as LOCATOR_ERROR, K as hasForgedCookie, L as fetch, M as cookies, N as readCookiePermission, O as removeRequestHeaderRule, P as FetchInit, Q as isLocatorDenied, R as fetchCredentialedPermission, S as assertAttachableFrameUrl, T as HeaderOperation, U as FORGEABLE_HEADERS, V as isBlockedFetchUrl, W as assertForgeableHeaders, X as LOCATOR_UNSUPPORTED, Y as LOCATOR_INVALID, Z as TimeoutError, _ as BackgroundStoppedError, a as extension, b as PermissionDeniedError, c as setMissingExtensionHandler, d as ExtensionHandshake, et as isLocatorUnsupported, f as ExtensionOperationUnsupportedError, g as BACKGROUND_STOPPED, h as supportsOperation, i as promptInstall, j as SiteCookie, k as setRequestHeaderRule, l as waitForExtensionExposure, m as REQUIRED_EXTENSION_ABI, o as isExtensionExposed, p as ExtensionOutdatedError, q as LOCATOR_DENIED, r as isExtensionAvailable, s as readExtensionHandshake, tt as isTerminalError, u as EXTENSION_ABI, v as isBackgroundStopped, w as isBlockedFrameUrl, x as isPermissionDenied, y as PERMISSION_DENIED, z as fetchLocalPermission } from "./extension-BlEtNAYc.js";
 export { ATTACH_FRAME_EVENT_KEY, AddScriptTagOptions, AttachCookies, AttachFrameOptions, AttachWindowOptions, BACKGROUND_STOPPED, type BackgroundStoppedError, BlankPage, BoxedVideoElement, CATEGORIES, CategoryGrant, type CategoryMeta, CategoryRequest, ClearCookiesOptions, ClearCookiesWire, CookieDetails, CookieMatchWire, EXTENSION_ABI, type Executor, type ExtensionHandshake, ExtensionOperationUnsupportedError, ExtensionOutdatedError, FORGEABLE_HEADERS, FetchInit, Frame, FrameBackend, FrameBackendEvent, FrameDocumentEvent, FrameEventListener, FrameEventMap, FrameLocator, FrameMessageEvent, FramePostMessageOptions, FrameWindowBlockedError, FrameWindowOptions, FrameWindowRefusal, FrameWindowRefusedError, type Gate, type GateTools, GotoOptions, HeaderOperation, LOCATOR_DENIED, LOCATOR_ERROR, LOCATOR_INVALID, LOCATOR_UNSUPPORTED, LegacyPermissionRequest, Locator, type OperationRequest, PERMISSION_DENIED, type PermissionCategory, type PermissionDeniedError, PermissionGrant, PermissionRequest, ProxyFetchRequest, REQUIRED_EXTENSION_ABI, RemoteVideoElement, RequestHeaderRule, type SelectorPart, SiteCookie, StorageState, StorageStateCookie, TimeoutError, VideoElementState, WindowFrame, assertAttachableFrameUrl, assertFetchableUrl, assertForgeableHeaders, assertLockdownApplicable, assertOneCookieIdentity, attachFrame, attachFramePermission, isExtensionAvailable as available, box, cookies, createFrame, createVideoElementHandle, extension as events, extension, fetch, fetchCredentialedPermission, fetchLocalPermission, fetchPermission, gotoPermission, handleRevivableModules, hasForgedCookie, isBackgroundStopped, isBlockedFetchUrl, isBlockedFrameUrl, isExtensionExposed, isLocalNetworkUrl, isLocatorDenied, isLocatorInvalid, isLocatorUnsupported, isPermissionDenied, isTerminalError, isType, modifyRequestHeadersPermission, permissions, promptInstall, readCookiePermission, readExtensionHandshake, removeRequestHeaderRule, revive, setMissingExtensionHandler, setRequestHeaderRule, supportsOperation, type, waitForExtensionExposure };

package/fs/promises.d.ts

@@ -1,5 +1,5 @@
 import { a as WriteData, i as Stats, n as MakeOptions, o as WriteOptions, r as ReadOptions } from "../index-BQgZVQl7.js";
-import { v as promises } from "../index-D2lvaQDs.js";
+import { v as promises } from "../index-DKr9L2RI.js";
 //#region src/fs/promises.d.ts
 export declare const readFile: (path: import("node:fs").PathLike, options?: ReadOptions) => Promise<Buffer | string>, writeFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>, appendFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>, unlink: (path: import("node:fs").PathLike) => Promise<void>, rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>, readdir: (path: import("node:fs").PathLike) => Promise<string[]>, mkdir: (path: import("node:fs").PathLike, options?: MakeOptions) => Promise<void>, rm: (path: import("node:fs").PathLike, options?: {
   recursive?: boolean;

package/{fs-D0MMRnHC.d.ts → fs-KA1Mgisv.d.ts}

@@ -1,6 +1,6 @@
 import { a as WriteData, i as Stats, n as MakeOptions, o as WriteOptions, r as ReadOptions, t as Callback } from "./index-BQgZVQl7.js";
-import { _ as unlock, a as StorageAccountChangedError, c as StorageNotFoundError, f as encryption, g as storage_d_exports, h as quota, i as SealedRead, l as StorageQuota, m as isNotFound, n as EncryptionStatus, o as StorageAccountPinUnsupportedError, p as isAccountChanged, r as FileEntry, s as StorageLockedError, t as CloudAvailability, u as availability } from "./storage-BVr2Rb-d.js";
-import { c as STORAGE_ACCOUNT_CHANGED, l as STORAGE_ACCOUNT_PIN_UNSUPPORTED, u as STORAGE_NOT_FOUND } from "./messages-CRcziTuC.js";
+import { _ as unlock, a as StorageAccountChangedError, c as StorageNotFoundError, f as encryption, g as storage_d_exports, h as quota, i as SealedRead, l as StorageQuota, m as isNotFound, n as EncryptionStatus, o as StorageAccountPinUnsupportedError, p as isAccountChanged, r as FileEntry, s as StorageLockedError, t as CloudAvailability, u as availability } from "./storage-BLBsmkmp.js";
+import { c as STORAGE_ACCOUNT_CHANGED, l as STORAGE_ACCOUNT_PIN_UNSUPPORTED, u as STORAGE_NOT_FOUND } from "./messages-d7pvCXPn.js";
 declare namespace fs_d_exports {
   export { CloudAvailability, EncryptionStatus, FileEntry, STORAGE_ACCOUNT_CHANGED, STORAGE_ACCOUNT_PIN_UNSUPPORTED, STORAGE_NOT_FOUND, SealedRead, Stats, StorageAccountChangedError, StorageAccountPinUnsupportedError, StorageLockedError, StorageNotFoundError, StorageQuota, availability, available, encryption, isAccountChanged, isNotFound, list, mkdir, promises, quota, readFile, readFileSealed, readdir, rename, rm, stat, unlink, unlock, writeFile };
 }

package/fs.d.ts

@@ -1,5 +1,5 @@
 import { i as Stats } from "./index-BQgZVQl7.js";
-import { a as StorageAccountChangedError, i as SealedRead, o as StorageAccountPinUnsupportedError, p as isAccountChanged } from "./storage-BVr2Rb-d.js";
-import { c as STORAGE_ACCOUNT_CHANGED, l as STORAGE_ACCOUNT_PIN_UNSUPPORTED } from "./messages-CRcziTuC.js";
-import { A as rmSync, B as ConflictResolver, C as readdir, D as renameSync, E as rename, F as unlinkSync, H as FileConflict, I as writeFile, L as writeFileSync, M as stat, N as statSync, O as replicating, P as unlink, R as AdoptSummary, S as readFileSync, T as remount, V as ConflictSide, _ as pendingDeletes, a as appendFileSync, b as readFile, c as existsSync, d as lstatSync, f as mkdir, g as pending, h as onConflict, i as appendFile, j as rmdirSync, k as rm, l as flush, m as mount, n as adopt, o as available, p as mkdirSync, r as adoptable, s as exists, t as _default, v as promises, w as readdirSync, x as readFileSealed, y as pull, z as ConflictResolution } from "./index-D2lvaQDs.js";
+import { a as StorageAccountChangedError, i as SealedRead, o as StorageAccountPinUnsupportedError, p as isAccountChanged } from "./storage-BLBsmkmp.js";
+import { c as STORAGE_ACCOUNT_CHANGED, l as STORAGE_ACCOUNT_PIN_UNSUPPORTED } from "./messages-d7pvCXPn.js";
+import { A as rmSync, B as ConflictResolver, C as readdir, D as renameSync, E as rename, F as unlinkSync, H as FileConflict, I as writeFile, L as writeFileSync, M as stat, N as statSync, O as replicating, P as unlink, R as AdoptSummary, S as readFileSync, T as remount, V as ConflictSide, _ as pendingDeletes, a as appendFileSync, b as readFile, c as existsSync, d as lstatSync, f as mkdir, g as pending, h as onConflict, i as appendFile, j as rmdirSync, k as rm, l as flush, m as mount, n as adopt, o as available, p as mkdirSync, r as adoptable, s as exists, t as _default, v as promises, w as readdirSync, x as readFileSealed, y as pull, z as ConflictResolution } from "./index-DKr9L2RI.js";
 export { type AdoptSummary, type ConflictResolution, type ConflictResolver, type ConflictSide, type FileConflict, STORAGE_ACCOUNT_CHANGED, STORAGE_ACCOUNT_PIN_UNSUPPORTED, type SealedRead, type Stats, StorageAccountChangedError, StorageAccountPinUnsupportedError, adopt, adoptable, appendFile, appendFileSync, available, _default as default, exists, existsSync, flush, isAccountChanged, lstatSync, mkdir, mkdirSync, mount, onConflict, pending, pendingDeletes, promises, pull, readFile, readFileSealed, readFileSync, readdir, readdirSync, remount, rename, renameSync, replicating, rm, rmSync, rmdirSync, stat, statSync, unlink, unlinkSync, writeFile, writeFileSync };

package/http.d.ts

@@ -1,4 +1,4 @@
-import { n as Socket, t as Server$1 } from "./net-BOswhyfE.js";
+import { n as Socket, t as Server$1 } from "./net-CmMZgV2a.js";
 import { Buffer } from "buffer";
 import { Stream } from "stream";
 import { IncomingHttpHeaders, OutgoingHttpHeaders, RequestOptions } from "http";

package/{index-Cgnfjh9o.d.ts → index-BOInGaEl.d.ts}

@@ -24,35 +24,24 @@ type SelectorModule = {
 type OperationModule = {
   resolve: (context: LocatorContext, ...args: any[]) => unknown;
   /**
-   * Pins the operation to one chain kind, opting it out of the executor's cross-kind fallback.
-   *
-   * That fallback is deliberate and load bearing in the frame-to-element direction:
-   * `frameLocator('#f').click()` resolves to kind `frame`, the frame kind has no `click`, and the
-   * element `click` then runs against the child's `documentElement`. It is also bidirectional, so
-   * without this an operation registered only on the `frame` kind is silently reachable from an
-   * element chain too.
-   *
-   * For most operations that is a convenience. For one whose whole meaning is WHICH REALM it runs
-   * in, it is a silent identity confusion: `locator('#x').fetch()` would run in the document that
-   * CONTAINS `#x` while reading as though it ran in `#x`. Pin those, so the wrong spelling is
-   * refused by name instead of quietly doing something else.
+   * Pins the operation to one chain kind, opting it out of the executor's cross-kind fallback. That
+   * fallback is load bearing (`frameLocator('#f').click()` runs the element `click` against the
+   * child's `documentElement`) and bidirectional, so pin an operation whose meaning is which realm it
+   * runs in: unpinned, `locator('#x').fetch()` would run in the document containing `#x`.
    */
   kind?: ChainKind;
   /**
-   * The argument list a gate sees when `ensure(operation, options)` asks about this operation.
-   *
-   * Without it the gate gets `[options]`, which is right for an operation whose options are its first
-   * argument. An operation that takes them later must say where, or a gate keyed on an argument
-   * settles a different key at `ensure` than the real call does: `fetch(url, init)` reads the method
-   * from `args[1]`, so it declares `options => [undefined, options]`.
+   * The argument list a gate sees when `ensure(operation, options)` asks about this operation, so a
+   * gate keyed on an argument settles the same key at `ensure` as the real call. Defaults to
+   * `[options]`; `fetch(url, init)` reads the method from `args[1]`, so it declares
+   * `options => [undefined, options]`.
    */
   ensureArgs?: (options: Record<string, unknown>) => unknown[];
   /**
-   * Maps the arguments a caller passes to the ones the wire carries, on the calling side, before the
-   * gate and the executor see them, and gives the chain method its parameter types. It lets a public
-   * option take a new name while every backend keeps reading the old one, since a backend resolves
-   * options by its own copy. Throw to refuse a call before anything is gated or sent. Absent, the
-   * arguments travel verbatim.
+   * Maps the caller's arguments to the ones the wire carries, before the gate and the executor see
+   * them, and gives the chain method its parameter types, so a public option can take a new name while
+   * every backend keeps reading the old one. Throw to refuse a call before anything is gated or sent.
+   * Absent, the arguments travel verbatim.
    */
   send?: (...args: any[]) => unknown[];
   /**
@@ -72,10 +61,9 @@ type Modules = {
 };
 /**
  * A chain method answered on the calling side by rewriting the parts collected so far into parts every
- * executor already resolves, rather than by appending a part of its own name. An executor resolves
- * selector names by its own copy of the registry and refuses one it lacks, so a member added this way
- * reaches an older executor with a meaning it already has. `to` is the kind of chain it returns.
- * Throw to refuse a chain the rewrite cannot express. The executor never sees it.
+ * executor already resolves, so it reaches an older executor (which refuses a selector name it lacks)
+ * with a meaning it already has. `to` is the kind of chain it returns. Throw to refuse a chain the
+ * rewrite cannot express. The executor never sees it.
  */
 type ChainRewrite = {
   to: ChainKind;
@@ -122,16 +110,13 @@ type AddStyleTagOptions$1 = OperationOptions & {
 //#endregion
 //#region ../frame-locator/lib/fetch.d.ts
 /**
- * A request issued from the realm the chain LANDS in, so the browser supplies that document's own
- * identity: its cookie jar (partitioned, on the extension path), its `Origin`, its `Referer` and its
- * `Sec-Fetch-*`. Nothing here synthesizes any of those, which is the point: a synthesized initiator is
- * exactly the degraded shape a CSRF-protected private API refuses.
+ * A request issued from the realm the chain lands in, so the browser supplies that document's own
+ * cookie jar (partitioned, on the extension path), `Origin`, `Referer` and `Sec-Fetch-*`. Nothing here
+ * synthesizes them: a private API declines a request whose initiator was synthesized.
  *
- * This module is the MECHANISM only. It carries no allowlist and no consent, because frame-locator has
- * no idea what an app is. The consumer gates it: in the FKN extension that is `LOCATOR_PERMISSIONS`,
- * whose `satisfies Record<LocatorOperation, OperationPermission>` makes registering this operation
- * without a permission a type error, plus an authoritative origin check in the content-script resolver.
- * Do not add a "convenience" path that skips the consumer's gate.
+ * This is the mechanism only, with no allowlist and no consent. The consumer gates it (in the FKN
+ * extension, `LOCATOR_PERMISSIONS` plus an origin check in the content-script resolver), so do not add
+ * a path that skips the consumer's gate.
  */
 type FrameFetchInit = OperationOptions & {
   method?: string;
@@ -144,16 +129,12 @@ type FrameFetchInit = OperationOptions & {
    */
   credentials?: RequestCredentials;
 };
-/**
- * Deliberately NOT a `Response`. It crosses at least one RPC boundary, and a `Response` rebuilt on the
- * far side with `new Response()` would be a different object with different headers anyway, so the
- * shape says plainly what actually survives.
- */
+/** Not a `Response`: it crosses at least one RPC boundary, so the shape states what survives. */
 type FrameFetchResult = {
   status: number;
   statusText: string;
   ok: boolean;
-  /** Where the response came from AFTER redirects, which is the only honest answer to "who replied". */
+  /** Where the response came from after redirects. */
   url: string;
   redirected: boolean;
   type: ResponseType;
@@ -364,11 +345,7 @@ type ToOf<M> = M extends {
 } ? K : 'element';
 type KindRewrites<R, K extends ChainKind> = K extends keyof R ? (R[K] extends Record<string, ChainRewrite> ? R[K] : {}) : {};
 type ChainOf<M extends Modules, K extends ChainKind, R extends Rewrites> = K extends 'frame' ? FrameLocator$1<M, R> : Locator$1<M, R>;
-/**
- * What `ensure` may carry. An option no gate reads is accepted and ignored rather than refused:
- * `subtree` is the one apps still pass, and the scope it once narrowed is now decided per site by
- * the gate, so passing it changes nothing.
- */
+/** What `ensure` may carry. An option no gate reads, `subtree` included, is accepted and ignored rather than refused. */
 type EnsureOptions = OperationOptions & Record<string, unknown>;
 type Chain<M extends Modules, K extends ChainKind, R extends Rewrites = {}> = { [N in Exclude<keyof M[K]['selectors'], keyof KindRewrites<R, K>>]: (...args: ArgsOf<M[K]['selectors'][N]>) => ChainOf<M, ToOf<M[K]['selectors'][N]>, R>; } & { [N in keyof M[K]['operations'] as M[K]['operations'][N] extends {
   typed: false;
@@ -724,17 +701,17 @@ type LocatorRewrites = typeof locatorRewrites;
 type PermissionCategory = 'interaction' | 'storage' | 'network' | 'evaluation';
 /**
  * What a category row says. `heading` is the name the popup, dashboard and activity log print;
- * `summary` is the owner's one-line account of the category. The row copy is a template over
- * `site`, the host the row consults (or its "first and N more" form), with a cloud variant for the
- * cloud card: `cloudTitle` is the one short line the card shows, `cloudDescription` the line it
- * draws under it where hovering cannot be counted on, and its tooltip everywhere else.
+ * `summary` is a one-line account of the category. The row copy is a template over `site` (the host
+ * the row consults, or its "first and N more" form). On the cloud card `cloudTitle` is its one short
+ * line and `cloudDescription` the line under it where hovering cannot be counted on, its tooltip
+ * everywhere else.
  */
 type CategoryMeta = {
   id: PermissionCategory;
   heading: string;
   summary: string;
   title: (site: string) => string;
-  /** `signedIn` is false when the attach's wire carried `syncCookies: false`, which only a library that predates `cookies` sends; `cookies: 'native'` sends true */
+  /** `signedIn` is false only when the attach carried `syncCookies: false`, which only a library that predates `cookies` sends */
   description: (site: string, signedIn: boolean) => string;
   cloudTitle: (site: string) => string;
   cloudDescription: (site: string) => string;
@@ -1134,9 +1111,8 @@ type Frame = Omit<FrameLocator, 'owner'> & {
   /**
    * Which backend serves this attachment, fixed for its life. The same call can draw a card on one
    * backend and not the other, and spends a different identity on each, so an app must be able to
-   * tell. A method, as Playwright's scalar facts are (`frame.url()`, `frame.name()`,
-   * `page.isClosed()`). Undefined only for a Frame an app built itself with `createFrame` from a
-   * backend that names none.
+   * tell. Undefined only for a Frame an app built itself with `createFrame` from a backend that
+   * names none.
    */
   backend(): 'cloud' | 'extension' | undefined;
   /**

package/{index-D2lvaQDs.d.ts → index-DKr9L2RI.d.ts}

@@ -1,6 +1,6 @@
 import { a as WriteData, i as Stats, n as MakeOptions, o as WriteOptions, r as ReadOptions, t as Callback } from "./index-BQgZVQl7.js";
-import { a as StorageAccountChangedError, b as PinOptions, d as captureAccount$1, g as storage_d_exports, i as SealedRead, o as StorageAccountPinUnsupportedError, p as isAccountChanged, v as FileEntry, x as WriteData$1, y as FileSystem } from "./storage-BVr2Rb-d.js";
-import { c as STORAGE_ACCOUNT_CHANGED, l as STORAGE_ACCOUNT_PIN_UNSUPPORTED } from "./messages-CRcziTuC.js";
+import { a as StorageAccountChangedError, b as PinOptions, d as captureAccount$1, g as storage_d_exports, i as SealedRead, o as StorageAccountPinUnsupportedError, p as isAccountChanged, v as FileEntry, x as WriteData$1, y as FileSystem } from "./storage-BLBsmkmp.js";
+import { c as STORAGE_ACCOUNT_CHANGED, l as STORAGE_ACCOUNT_PIN_UNSUPPORTED } from "./messages-d7pvCXPn.js";
 declare namespace hybrid_d_exports {
   export { AdoptSummary, ConflictResolution, ConflictResolver, ConflictSide, FileConflict, FileEntry, FileSystem, WriteData$1 as WriteData, adopt$1 as adopt, adoptable$1 as adoptable, available$1 as available, captureAccount, list, onConflict$1 as onConflict, pending$1 as pending, pendingDeletes$1 as pendingDeletes, pull$1 as pull, readFile$1 as readFile, readFileSealed$1 as readFileSealed, remove, replicating$1 as replicating, writeFile$1 as writeFile };
 }
@@ -46,15 +46,10 @@ type FileConflict = {
  * What should be at that path. Return one side's bytes, or anything else as a merge; null leaves the
  * file alone and the summary reports it unresolved.
  *
- * There is no vocabulary to learn: whatever comes back is what wins. Returning the very Blob that
- * `readLocal()` or `readCloud()` handed you is recognised by identity, so picking a side costs one
- * write rather than two.
- *
- * That identity is sound only because the resolver runs in THIS realm: the reads are memoized here,
- * so the object the app holds is the object compared. A value that crosses osra arrives as a
- * different object with equal content, in both directions, which `tests/osra-identity.browser.test.ts`
- * pins against a real channel. So a resolver whose answer ever crossed a realm would simply read as a
- * merge: one redundant write, never a wrong file.
+ * Whatever comes back is what wins. Returning the very Blob that `readLocal()` or `readCloud()`
+ * handed you is recognised by identity, so picking a side costs one write rather than two. An answer
+ * that crossed a realm (osra) arrives as a different object, so it reads as a merge: one redundant
+ * write, never a wrong file.
  */
 type ConflictResolution = WriteData$1 | null;
 type ConflictResolver = (conflict: FileConflict) => Promise<ConflictResolution> | ConflictResolution;

package/index.d.ts

@@ -1,13 +1,13 @@
 import { t as account_d_exports } from "./account.js";
-import { $ as GateTools, A as attachFramePermission, B as CategoryMeta, C as FrameWindowRefusal, D as StorageState, E as Locator, F as LegacyPermissionRequest, G as VideoElementState, H as handleRevivableModules, I as PermissionGrant, J as isType, K as box, L as PermissionRequest, M as gotoPermission, N as CategoryGrant, O as StorageStateCookie, P as CategoryRequest, Q as Gate, R as permissions, S as FrameWindowOptions, T as GotoOptions, U as BoxedVideoElement, V as PermissionCategory, W as RemoteVideoElement, X as type, Y as revive, Z as Executor, _ as FrameEventMap, a as AttachCookies, b as FramePostMessageOptions, c as BlankPage, d as CookieMatchWire, et as OperationRequest, f as Frame, g as FrameEventListener, h as FrameDocumentEvent, i as AddScriptTagOptions, j as createFrame, k as WindowFrame, l as ClearCookiesOptions, m as FrameBackendEvent, o as AttachFrameOptions, p as FrameBackend, q as createVideoElementHandle, r as AttachFrameFunction, s as AttachWindowOptions, t as ATTACH_FRAME_EVENT_KEY, tt as SelectorPart, u as ClearCookiesWire, v as FrameLocator, w as FrameWindowRefusedError, x as FrameWindowBlockedError, y as FrameMessageEvent, z as CATEGORIES } from "./index-Cgnfjh9o.js";
-import { $ as isLocatorInvalid, A as CookieDetails, B as fetchPermission, C as assertLockdownApplicable, D as modifyRequestHeadersPermission, E as RequestHeaderRule, F as ProxyFetchRequest, G as assertOneCookieIdentity, H as isLocalNetworkUrl, I as assertFetchableUrl, J as LOCATOR_ERROR, K as hasForgedCookie, M as cookies, N as readCookiePermission, O as removeRequestHeaderRule, P as FetchInit, Q as isLocatorDenied, R as fetchCredentialedPermission, S as assertAttachableFrameUrl, T as HeaderOperation, U as FORGEABLE_HEADERS, V as isBlockedFetchUrl, W as assertForgeableHeaders, X as LOCATOR_UNSUPPORTED, Y as LOCATOR_INVALID, Z as TimeoutError, _ as BackgroundStoppedError, b as PermissionDeniedError, c as setMissingExtensionHandler, d as ExtensionHandshake, et as isLocatorUnsupported, f as ExtensionOperationUnsupportedError, g as BACKGROUND_STOPPED, h as supportsOperation, i as promptInstall, j as SiteCookie, k as setRequestHeaderRule, l as waitForExtensionExposure, m as REQUIRED_EXTENSION_ABI, n as fetch, o as isExtensionExposed, p as ExtensionOutdatedError, q as LOCATOR_DENIED, s as readExtensionHandshake, t as extension_d_exports, tt as isTerminalError, u as EXTENSION_ABI, v as isBackgroundStopped, w as isBlockedFrameUrl, x as isPermissionDenied, y as PERMISSION_DENIED, z as fetchLocalPermission } from "./extension-BtDg-F2g.js";
-import { n as cloud_d_exports } from "./cloud-Y0FzWpFT.js";
+import { $ as GateTools, A as attachFramePermission, B as CategoryMeta, C as FrameWindowRefusal, D as StorageState, E as Locator, F as LegacyPermissionRequest, G as VideoElementState, H as handleRevivableModules, I as PermissionGrant, J as isType, K as box, L as PermissionRequest, M as gotoPermission, N as CategoryGrant, O as StorageStateCookie, P as CategoryRequest, Q as Gate, R as permissions, S as FrameWindowOptions, T as GotoOptions, U as BoxedVideoElement, V as PermissionCategory, W as RemoteVideoElement, X as type, Y as revive, Z as Executor, _ as FrameEventMap, a as AttachCookies, b as FramePostMessageOptions, c as BlankPage, d as CookieMatchWire, et as OperationRequest, f as Frame, g as FrameEventListener, h as FrameDocumentEvent, i as AddScriptTagOptions, j as createFrame, k as WindowFrame, l as ClearCookiesOptions, m as FrameBackendEvent, o as AttachFrameOptions, p as FrameBackend, q as createVideoElementHandle, r as AttachFrameFunction, s as AttachWindowOptions, t as ATTACH_FRAME_EVENT_KEY, tt as SelectorPart, u as ClearCookiesWire, v as FrameLocator, w as FrameWindowRefusedError, x as FrameWindowBlockedError, y as FrameMessageEvent, z as CATEGORIES } from "./index-BOInGaEl.js";
+import { $ as isLocatorInvalid, A as CookieDetails, B as fetchPermission, C as assertLockdownApplicable, D as modifyRequestHeadersPermission, E as RequestHeaderRule, F as ProxyFetchRequest, G as assertOneCookieIdentity, H as isLocalNetworkUrl, I as assertFetchableUrl, J as LOCATOR_ERROR, K as hasForgedCookie, M as cookies, N as readCookiePermission, O as removeRequestHeaderRule, P as FetchInit, Q as isLocatorDenied, R as fetchCredentialedPermission, S as assertAttachableFrameUrl, T as HeaderOperation, U as FORGEABLE_HEADERS, V as isBlockedFetchUrl, W as assertForgeableHeaders, X as LOCATOR_UNSUPPORTED, Y as LOCATOR_INVALID, Z as TimeoutError, _ as BackgroundStoppedError, b as PermissionDeniedError, c as setMissingExtensionHandler, d as ExtensionHandshake, et as isLocatorUnsupported, f as ExtensionOperationUnsupportedError, g as BACKGROUND_STOPPED, h as supportsOperation, i as promptInstall, j as SiteCookie, k as setRequestHeaderRule, l as waitForExtensionExposure, m as REQUIRED_EXTENSION_ABI, n as fetch, o as isExtensionExposed, p as ExtensionOutdatedError, q as LOCATOR_DENIED, s as readExtensionHandshake, t as extension_d_exports, tt as isTerminalError, u as EXTENSION_ABI, v as isBackgroundStopped, w as isBlockedFrameUrl, x as isPermissionDenied, y as PERMISSION_DENIED, z as fetchLocalPermission } from "./extension-BlEtNAYc.js";
+import { n as cloud_d_exports } from "./cloud-DyOQPyUB.js";
 import { t as dns_d_exports } from "./dns.js";
-import { s as net_d_exports } from "./net-BOswhyfE.js";
+import { s as net_d_exports } from "./net-CmMZgV2a.js";
 import { t as dgram_d_exports } from "./dgram.js";
 import { t as http_d_exports } from "./http.js";
 import { t as desktop_d_exports } from "./desktop.js";
-import { u as index_d_exports } from "./index-D2lvaQDs.js";
+import { u as index_d_exports } from "./index-DKr9L2RI.js";
 import { t as index_d_exports$1 } from "./opfs.js";
 import { t as packages_d_exports } from "./packages.js";
 import { t as rooms_d_exports } from "./rooms.js";
@@ -31,6 +31,18 @@ import { t as connectButtonUrl } from "./connect-button-Cp0NS95-.js";
 export declare const attachFrame: AttachFrameFunction;
 //#endregion
 //#region src/relay.d.ts
+/**
+ * Bridges a worker into the FKN API: once called, the worker can import `@fkn/lib` and use `net` /
+ * `dgram` exactly like the main thread. Main thread only.
+ *
+ * `originA` (default `WEB_ORIGIN`) is the `targetOrigin` for posts to the iframe, `originB` (default
+ * `'*'`) the one for posts to the worker, which enforces none. Pass `WEB_ORIGIN` for both only when
+ * relaying between two windows on the FKN origin.
+ *
+ * The page hands its `fkn-api` channel to the worker for good, and its own calls move to
+ * `fkn-api-window`. Against a cached FKN page from before that channel, the page's own calls refuse
+ * with `OwnChannelUnavailableError` and FKN's UI and account changes stay off here until a reload.
+ */
 export declare const relayWorker: (worker: Worker, options?: {
   unregisterSignal?: AbortSignal;
   originA?: string;
@@ -47,31 +59,20 @@ declare namespace shell_d_exports {
 }
 /**
  * The FKN shell's update surface, for apps that want a say in when the platform frame reloads.
+ * Nothing here fires on its own schedule. Two moments:
  *
- * Nothing here ever fires on its own schedule. Two moments, and the difference between them is the
- * whole design:
+ * - **READY**, `onUpdate` / `updateReady`: a newer shell is downloaded and nothing has happened. The
+ *   broker offers it in its own header and `applyUpdate` lets the app offer it too. It is never taken
+ *   without a person asking, since only the app knows what a reload costs right now. The one
+ *   exception: a broker frame that finds a newer shell while loading, before answering this page and
+ *   with no other fkn.app window open, reloads itself first, so nothing of the app is interrupted.
+ * - **TAKEN**, `onUpdateTaken`: someone pressed update, here or in another tab, and the new shell
+ *   controls every page on the origin. Each page now runs a new worker against an old-build document,
+ *   so the lib RELOADS THE PAGE by default; an app that cannot be interrupted registers a handler.
  *
- * - **READY**, `onUpdate` / `updateReady`. A newer shell has been downloaded behind the page and
- *   nothing has happened. The broker offers it in its own header, and `applyUpdate` is the app's
- *   way to offer it too. It is never taken without a person asking, because only the app knows what
- *   a reload costs right now, and a torrent mid-download is the case that matters. The one exception
- *   is a broker frame that finds a newer shell as it loads, before it has answered this page at all,
- *   while no other fkn.app window is open: it reloads its own frame first, so this page's first
- *   connection is simply to the newer shell and nothing of the app is interrupted.
- * - **TAKEN**, `onUpdateTaken`. Someone pressed update, here or in another tab, and the new shell is
- *   now in control of every page on the origin. That leaves each one running a new worker against a
- *   document from the old build, so the lib RELOADS THE PAGE by default to end the mix. An app that
- *   cannot be interrupted registers a handler and decides for itself.
- *
- * A lib-side driver that took a ready update by ITSELF, on an idle-looking page, shipped in 0.9.20
- * to 0.9.22 and was removed. Idleness measured from the app realm cannot see a transfer running in
- * a worker, and the cost of being wrong is someone's download. The default reload above is not that
- * driver returning: it happens only after a person has pressed update, and only to finish what they
- * asked for.
- *
- * The page's connection to a replaced frame is re-established automatically either way, which is
- * what makes the button cheap to press: a call in flight at that moment rejects with a named error
- * rather than hanging.
+ * The lib never takes a ready update by itself: idleness seen from the app realm cannot see a
+ * transfer running in a worker. The page's connection to a replaced frame is re-established
+ * automatically, and a call in flight at that moment rejects with a named error rather than hanging.
  */
 /** Whether a newer FKN shell is downloaded and ready to apply. */
 declare const updateReady: () => Promise<boolean>;
@@ -106,17 +107,13 @@ declare const onUpdate: (callback: () => void) => Promise<() => void>;
  */
 declare const onUpdateTaken: (handler: () => void) => (() => void);
 /**
- * What a shell reload would sever right now, as a list of human-readable reasons, empty when
- * nothing is bound to the broker connection.
- *
- * This is the evidence for deciding whether to call `applyUpdate` yet: open sockets and listening
- * servers, a streaming proxy response, a mounted package, a live frame attachment, unflushed
- * write-behind. An empty list is not a promise that a reload is free, only that this realm holds
- * nothing the lib knows about, so an app with state of its own should weigh that too.
+ * What a shell reload would sever right now, as human-readable reasons, empty when nothing is bound
+ * to the broker connection: open sockets and listening servers, a streaming proxy response, a mounted
+ * package, a live frame attachment, unflushed write-behind. Empty is not a promise that a reload is
+ * free, only that this realm holds nothing the lib knows about.
  *
- * It is per REALM, and that distinction has already caused a wrong reading once. A worker that
- * imports `@fkn/lib/net` keeps its own tally, which this function cannot see from the window. An
- * app whose transfers live in a worker should ask the worker, not the page.
+ * It is per REALM: a worker that imports `@fkn/lib/net` keeps its own tally, which the window cannot
+ * see. An app whose transfers live in a worker should ask the worker, not the page.
  */
 declare const busyReasons: () => string[];
 /**

package/messages-d7pvCXPn.d.ts

@@ -0,0 +1,34 @@
+//#region src/messages.d.ts
+declare const E2E_LOCKED_MESSAGE = "fkn:e2e-locked";
+declare const E2E_STALE_EPOCH_MESSAGE = "fkn:e2e-stale-epoch: this file is encrypted under a previous key you reset";
+declare const E2E_INTEGRITY_MESSAGE = "fkn:e2e-integrity: stored data failed its integrity check";
+/** sealed in an envelope older than v3; distinct from integrity, since the bytes are intact */
+declare const E2E_RETIRED_FORMAT_MESSAGE = "fkn:e2e-retired-format: stored data is in a format this version no longer opens";
+/**
+ * The error code for "there is no object at this path", so a caller tests absence instead of parsing
+ * a message. osra drops custom codes at the SharedWorker boundary, so storage.ts's rethrow re-mints
+ * it from the message on the app side.
+ */
+declare const STORAGE_NOT_FOUND = "FKN_STORAGE_NOT_FOUND";
+/**
+ * The error code for "the api never answered". A caller that relaxes anything when the server is
+ * unreachable must never relax it on an answered error: an answered 500 lands exactly when a key
+ * rotation or a setting flip may be propagating. Across the SharedWorker hop the message prefix is
+ * the wire contract, since osra drops the code; same-realm callers can test the code.
+ */
+declare const STORAGE_UNREACHABLE = "FKN_API_UNREACHABLE";
+/**
+ * The account pin's refusals, as message prefixes the broker throws. `ACCOUNT_CHANGED_MESSAGE`: the
+ * signed-in account is not the one the pin was taken under. `ACCOUNT_PIN_INVALID_MESSAGE`: the api
+ * could not read the pin. `ACCOUNT_PIN_UNSUPPORTED_MESSAGE`: a hop (the broker document or its shared
+ * worker) predates the pin, so the call was refused rather than sent unpinned. None is a sign-out.
+ */
+declare const ACCOUNT_CHANGED_MESSAGE = "fkn:account-changed";
+declare const ACCOUNT_PIN_INVALID_MESSAGE = "fkn:account-pin-invalid";
+declare const ACCOUNT_PIN_UNSUPPORTED_MESSAGE = "fkn:account-pin-unsupported";
+/** The code of `StorageAccountChangedError`: a call made under one account was refused under another. */
+declare const STORAGE_ACCOUNT_CHANGED = "FKN_ACCOUNT_CHANGED";
+/** The code of `StorageAccountPinUnsupportedError`: the broker cannot pin calls, so none was sent. */
+declare const STORAGE_ACCOUNT_PIN_UNSUPPORTED = "FKN_ACCOUNT_PIN_UNSUPPORTED";
+//#endregion
+export { E2E_LOCKED_MESSAGE as a, STORAGE_ACCOUNT_CHANGED as c, STORAGE_UNREACHABLE as d, E2E_INTEGRITY_MESSAGE as i, STORAGE_ACCOUNT_PIN_UNSUPPORTED as l, ACCOUNT_PIN_INVALID_MESSAGE as n, E2E_RETIRED_FORMAT_MESSAGE as o, ACCOUNT_PIN_UNSUPPORTED_MESSAGE as r, E2E_STALE_EPOCH_MESSAGE as s, ACCOUNT_CHANGED_MESSAGE as t, STORAGE_NOT_FOUND as u };

package/messages.d.ts

@@ -1,2 +1,2 @@
-import { a as E2E_LOCKED_MESSAGE, c as STORAGE_ACCOUNT_CHANGED, d as STORAGE_UNREACHABLE, i as E2E_INTEGRITY_MESSAGE, l as STORAGE_ACCOUNT_PIN_UNSUPPORTED, n as ACCOUNT_PIN_INVALID_MESSAGE, o as E2E_RETIRED_FORMAT_MESSAGE, r as ACCOUNT_PIN_UNSUPPORTED_MESSAGE, s as E2E_STALE_EPOCH_MESSAGE, t as ACCOUNT_CHANGED_MESSAGE, u as STORAGE_NOT_FOUND } from "./messages-CRcziTuC.js";
+import { a as E2E_LOCKED_MESSAGE, c as STORAGE_ACCOUNT_CHANGED, d as STORAGE_UNREACHABLE, i as E2E_INTEGRITY_MESSAGE, l as STORAGE_ACCOUNT_PIN_UNSUPPORTED, n as ACCOUNT_PIN_INVALID_MESSAGE, o as E2E_RETIRED_FORMAT_MESSAGE, r as ACCOUNT_PIN_UNSUPPORTED_MESSAGE, s as E2E_STALE_EPOCH_MESSAGE, t as ACCOUNT_CHANGED_MESSAGE, u as STORAGE_NOT_FOUND } from "./messages-d7pvCXPn.js";
 export { ACCOUNT_CHANGED_MESSAGE, ACCOUNT_PIN_INVALID_MESSAGE, ACCOUNT_PIN_UNSUPPORTED_MESSAGE, E2E_INTEGRITY_MESSAGE, E2E_LOCKED_MESSAGE, E2E_RETIRED_FORMAT_MESSAGE, E2E_STALE_EPOCH_MESSAGE, STORAGE_ACCOUNT_CHANGED, STORAGE_ACCOUNT_PIN_UNSUPPORTED, STORAGE_NOT_FOUND, STORAGE_UNREACHABLE };

package/{net-BOswhyfE.d.ts → net-CmMZgV2a.d.ts}

@@ -1,6 +1,6 @@
-import { Ct as TcpSocketListenerResult, K as Resolvers, Tt as TcpSocketResult } from "./contract-DJxGa8lb.js";
-import { o as TcpSocketOption } from "./wire-Gbo-D74t.js";
-import "./api-H1TzWitc.js";
+import { Ct as TcpSocketListenerResult, K as Resolvers, Tt as TcpSocketResult } from "./contract-6Xfd_qel.js";
+import { o as TcpSocketOption } from "./wire-BwA4JjZH.js";
+import "./api-CFkZVr53.js";
 import { AddressInfo, ListenOptions, Server, ServerOpts, Socket, SocketConnectOpts, SocketConstructorOpts } from "net";
 import { DuplexOptions, Stream } from "stream";
 import { EventEmitter } from "events";
@@ -32,19 +32,6 @@ declare class Socket$2 extends Stream.Duplex implements Socket {
   constructor(options?: SocketConstructorOpts & DuplexOptions & {
     connection?: ReturnType<WebVpnTcpSocket>;
   });
-  /**
-   * `endpoints` publishes the four addresses SYNCHRONOUSLY, for a socket whose connection is
-   * already in hand.
-   *
-   * Node fills an accepted socket's endpoints in before it emits 'connection', and consumers read
-   * them right there in the handler. Without this the values only land in the `.then()` below, one
-   * microtask after the emit, and until then every address getter on this class THROWS
-   * `Socket is not connected` rather than answering undefined, so a caller reading them the way
-   * Node allows gets an exception and, if it wrapped all four in one try block, loses every one of
-   * them. libtorrent-wasm's socket shim does exactly that on accept, and libtorrent drops a peer it
-   * cannot name with no alert and no reply, which reads from outside as the relay never delivering
-   * the connection at all.
-   */
   _busyRelease?: () => void;
   __webvpn_tcp_socket_init__(connection: ReturnType<WebVpnTcpSocket>, endpoints?: Awaited<ReturnType<WebVpnTcpSocket>>): Promise<(TcpSocketResult & {
     reader: ReadableStreamDefaultReader<Uint8Array>;
@@ -95,9 +82,6 @@ declare class Socket$2 extends Stream.Duplex implements Socket {
   timeout?: number | undefined;
 }
 interface EventEmitterOptions {
-  /**
-   * Enables automatic capturing of promise rejection.
-   */
   captureRejections?: boolean | undefined;
 }
 declare class Server$1 extends EventEmitter implements Server {

package/net.d.ts

@@ -1,2 +1,2 @@
-import { a as createConnection, c as isIP, i as connect, l as isIPv4, n as Socket, o as createServer, r as _default, t as Server, u as isIPv6 } from "./net-BOswhyfE.js";
+import { a as createConnection, c as isIP, i as connect, l as isIPv4, n as Socket, o as createServer, r as _default, t as Server, u as isIPv6 } from "./net-CmMZgV2a.js";
 export { Server, Socket, _default, _default as default, connect, createConnection, createServer, isIP, isIPv4, isIPv6 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fkn/lib",
-  "version": "0.9.43",
+  "version": "0.9.44",
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",

package/packages.d.ts

@@ -1,4 +1,4 @@
-import { E as InstalledPackage, F as PackageResult, G as Radii, I as PackagesErrorCode, P as PackageQuery, R as PickOptions, T as InstallOptions, m as ConnectOptions, xt as SurfaceRect, z as Placement } from "./contract-DJxGa8lb.js";
+import { E as InstalledPackage, F as PackageResult, G as Radii, I as PackagesErrorCode, P as PackageQuery, R as PickOptions, T as InstallOptions, m as ConnectOptions, xt as SurfaceRect, z as Placement } from "./contract-6Xfd_qel.js";
 import { Remote } from "osra";
 declare namespace packages_d_exports {
   export { AppConnectOptions, Connect, ConnectOptions, ConnectPayload, IncomingConnection, IncomingConnectionInfo, InstallOptions, InstalledPackage, MountOptions, MountedPackage, PackageConnection, PackageQuery, PackageResult, PackageView, PackagesError, PackagesErrorCode, PickOptions, Placement, Radii, RawPackageConnection, ShowOptions, SurfaceRect, attach, connect, hide, install, isVisible, list, mount, onConnect, onVisibilityChange, pick, search, show, uninstall };

package/{proxy-ylK5lpw8.d.ts → proxy-dOOmiMl4.d.ts}

@@ -1,5 +1,5 @@
-import { K as Resolvers } from "./contract-DJxGa8lb.js";
-import "./api-H1TzWitc.js";
+import { K as Resolvers } from "./contract-6Xfd_qel.js";
+import "./api-CFkZVr53.js";
 //#region src/proxy.d.ts
 type ProxyFetch = Resolvers['cloud']['fetch'];
 type FetchParameters = Parameters<ProxyFetch>;