@buoy-gg/shared-ui 7.0.78 → 7.0.80

package/lib/typescript/module/bugCase/teamKey.d.ts

@@ -0,0 +1,185 @@
+/** A P-256 key pair: the 32-byte private scalar and the 65-byte uncompressed public point. */
+export interface P256Pair {
+    d: Uint8Array;
+    pub: Uint8Array;
+}
+export interface TeamKeyCrypto {
+    randomBytes(length: number): Uint8Array;
+    sha256(data: Uint8Array): Promise<Uint8Array>;
+    hmacSha256(key: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
+    /** AES-GCM with a 16- or 32-byte key; returns ciphertext with the tag at the end. */
+    seal(key: Uint8Array, nonce: Uint8Array, data: Uint8Array, aad: Uint8Array): Promise<Uint8Array>;
+    /** Throws when the key is wrong or a byte changed. */
+    open(key: Uint8Array, nonce: Uint8Array, sealed: Uint8Array, aad: Uint8Array): Promise<Uint8Array>;
+    p256Generate(): Promise<P256Pair>;
+    /** The shared x coordinate (32 bytes). Throws on a point that isn't on the curve. */
+    p256Ecdh(own: P256Pair, peerPub: Uint8Array): Promise<Uint8Array>;
+    /** ECDSA over SHA-256 of `message`; 64 bytes, r then s. */
+    p256Sign(own: P256Pair, message: Uint8Array): Promise<Uint8Array>;
+    /** Takes high-S signatures too: WebCrypto makes them. */
+    p256Verify(pub: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean>;
+}
+export type TeamKeyErrorCode = 
+/** A kit that isn't a kit, or the wrong kind. */
+"bad_kit"
+/** The kit is fine but doesn't open this lock. */
+ | "wrong_kit"
+/** A record, wrap or card that isn't the right shape. */
+ | "bad_shape"
+/** A signature or a key id that doesn't check out. */
+ | "untrusted"
+/** Won't open: the wrong key, or a byte changed. */
+ | "locked" | "too_big";
+export declare class TeamKeyError extends Error {
+    readonly code: TeamKeyErrorCode;
+    constructor(code: TeamKeyErrorCode, message: string);
+}
+export declare function concatBytes(...parts: Uint8Array[]): Uint8Array;
+export declare function hkdfExtract(c: TeamKeyCrypto, salt: Uint8Array, ikm: Uint8Array): Promise<Uint8Array>;
+export declare function hkdfExpand(c: TeamKeyCrypto, prk: Uint8Array, info: Uint8Array, length: number): Promise<Uint8Array>;
+export declare function hkdf(c: TeamKeyCrypto, ikm: Uint8Array, info: string, length?: number): Promise<Uint8Array>;
+export declare const HPKE_AES128_GCM = 1;
+export declare const HPKE_AES256_GCM = 2;
+/** Exposed for the RFC vector test. */
+export declare function hpkeKeySchedule(c: TeamKeyCrypto, sharedSecret: Uint8Array, info: Uint8Array, aeadId: number): Promise<{
+    key: Uint8Array<ArrayBufferLike>;
+    baseNonce: Uint8Array<ArrayBufferLike>;
+}>;
+/**
+ * One message to `pkR` (sequence 0). `ephemeral` is for test vectors only;
+ * a real seal always makes a fresh one.
+ */
+export declare function hpkeSeal(c: TeamKeyCrypto, pkR: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array, options?: {
+    aeadId?: number;
+    ephemeral?: P256Pair;
+}): Promise<{
+    enc: Uint8Array;
+    ct: Uint8Array;
+    sharedSecret: Uint8Array;
+}>;
+export declare function hpkeOpen(c: TeamKeyCrypto, skR: P256Pair, encapped: Uint8Array, info: Uint8Array, aad: Uint8Array, ct: Uint8Array, aeadId?: number): Promise<Uint8Array>;
+export type KitKind = "team" | "admin";
+/** A new kit as text, like `buoy-team-7F3Q-K2M9-…`. Shown once; never sent to Buoy. */
+export declare function makeKit(c: TeamKeyCrypto, kind: KitKind): string;
+export declare function formatKit(kind: KitKind, bytes: Uint8Array): string;
+/** Reads a pasted kit. Spaces, dashes and case don't matter; O reads as 0 and I or L as 1. */
+export declare function parseKit(text: string, kind: KitKind): Uint8Array;
+/** The kit's lock key. */
+export declare function kitKey(c: TeamKeyCrypto, kit: Uint8Array, kind: KitKind): Promise<Uint8Array>;
+/** A short id for a kit, so the server can say which kit locked a key. It can't open anything. */
+export declare function kitId(c: TeamKeyCrypto, kit: Uint8Array, kind: KitKind): Promise<string>;
+/** `nonce | sealed`, as base64url. */
+export declare function lockSecret(c: TeamKeyCrypto, key: Uint8Array, aad: string, secret: Uint8Array): Promise<string>;
+export declare function openSecret(c: TeamKeyCrypto, key: Uint8Array, aad: string, locked: string): Promise<Uint8Array>;
+export declare const rootLockAad: (owner: string, teamKeyId: string) => string;
+export declare const versionLockAad: (owner: string, teamKeyId: string, keyVersion: number) => string;
+/** A private key and its public key, as stored inside a lock. */
+export declare const pairBytes: (pair: P256Pair) => Uint8Array<ArrayBufferLike>;
+export declare function pairFrom(bytes: Uint8Array, expectPub?: Uint8Array): P256Pair;
+/**
+ * Checks a private key really belongs to its public key: a pair that doesn't
+ * would make wraps no one can open. ECDH with itself and with a fresh key
+ * from each side must agree.
+ */
+export declare function checkPair(c: TeamKeyCrypto, pair: P256Pair): Promise<void>;
+/** A root's id: the SHA-256 of its public key. Apps can pin it. */
+export declare function teamKeyIdOf(c: TeamKeyCrypto, rootPub: Uint8Array): Promise<string>;
+export interface TeamKeyRecord {
+    owner: string;
+    teamKeyId: string;
+    keyVersion: number;
+    /** The version's ECDH public key, base64url. */
+    pub: string;
+    /** The root's signature over `recordMessage`, base64url. */
+    sig: string;
+}
+export declare function recordMessage(owner: string, teamKeyId: string, keyVersion: number, pub: string): Uint8Array;
+export declare function signRecord(c: TeamKeyCrypto, root: P256Pair, owner: string, keyVersion: number, versionPub: Uint8Array): Promise<TeamKeyRecord>;
+/** Throws unless `record` is signed by `rootPub` and names that root. Returns the version's public key. */
+export declare function verifyRecord(c: TeamKeyCrypto, rootPub: Uint8Array, record: TeamKeyRecord): Promise<Uint8Array>;
+export interface CaseKeyParts {
+    /** The link's key, base64url (32 bytes). */
+    key: string;
+    /** 16 random bytes, base64url: goes in the blob's plain header. */
+    caseTag: string;
+    /** SHA-256 of the key proof, base64url: goes in the blob's plain header. */
+    keyProofHash: string;
+}
+export declare function newCaseTag(c: TeamKeyCrypto): string;
+export declare const isCaseTag: (text: unknown) => text is string;
+export declare const isKeyHash: (text: unknown) => text is string;
+/**
+ * Proof that someone holds a case's key, without showing the key. The blob's
+ * header has its hash, so the server can check a late wrap comes from someone
+ * who can open the case.
+ */
+export declare function keyProof(c: TeamKeyCrypto, caseKey: string): Promise<string>;
+export declare function keyProofHash(c: TeamKeyCrypto, proof: string): Promise<string>;
+/** A fresh key, a fresh tag, and the key proof's hash, for a new case. */
+export declare function newCaseKeyParts(c: TeamKeyCrypto, existing?: {
+    key?: string;
+    caseTag?: string;
+}): Promise<CaseKeyParts>;
+export declare const WRAP_SUITE = "P256-SHA256-A256GCM";
+export interface BugWrap {
+    v: 1;
+    suite: typeof WRAP_SUITE;
+    teamKeyId: string;
+    keyVersion: number;
+    /** The HPKE key share, base64url (65 bytes). */
+    enc: string;
+    /** The sealed case key, base64url (48 bytes). */
+    ct: string;
+}
+export declare const wrapInfo: (owner: string, teamKeyId: string, keyVersion: number, caseTag: string) => Uint8Array<ArrayBufferLike>;
+export declare function wrapCaseKey(c: TeamKeyCrypto, target: {
+    owner: string;
+    teamKeyId: string;
+    keyVersion: number;
+    pub: Uint8Array;
+}, caseKey: string, caseTag: string): Promise<BugWrap>;
+export declare function unwrapCaseKey(c: TeamKeyCrypto, wrap: BugWrap, owner: string, versionKey: P256Pair, caseTag: string): Promise<string>;
+/** Rebuilt field by field from untrusted JSON. */
+export declare function parseWrap(raw: unknown): BugWrap;
+export interface BugCardFields {
+    note?: string;
+    app?: string;
+    version?: string;
+    build?: string;
+    route?: string;
+    error?: string;
+    sender?: string;
+}
+export interface BugCard extends BugCardFields {
+    v: 1;
+    caseTag: string;
+    /** SHA-256 of the blob this card goes with, base64url. */
+    blobSha256: string;
+}
+/** The whole card as JSON stays under this, so the locked card fits in 4 KB. */
+export declare const MAX_CARD_JSON_BYTES = 3800;
+/** Cuts text to at most `maxBytes` of UTF-8, at a whole letter, with "…" when cut. */
+export declare function cutUtf8(text: string, maxBytes: number): string;
+/** Caps each field, then trims the note, the error and the route until the JSON fits. */
+export declare function fitCard(card: BugCard): BugCard;
+export declare function blobSha256(c: TeamKeyCrypto, blob: Uint8Array): Promise<string>;
+/** `nonce | sealed`, as base64url. */
+export declare function sealCard(c: TeamKeyCrypto, caseKey: string, caseTag: string, cardRevision: number, fields: BugCardFields, blob: Uint8Array): Promise<string>;
+export declare function openCard(c: TeamKeyCrypto, caseKey: string, caseTag: string, cardRevision: number, sealed: string): Promise<BugCard>;
+export declare const DEVICE_NONCE_BYTES = 16;
+export declare function newDeviceNonce(c: TeamKeyCrypto): string;
+/** What the new device sends first: a hash of its key and nonce. */
+export declare function deviceCommit(c: TeamKeyCrypto, devicePub: Uint8Array, deviceNonce: string): Promise<string>;
+/** The code both screens show. If they match, no one swapped the device's key. */
+export declare function deviceCode(c: TeamKeyCrypto, check: {
+    owner: string;
+    requestId: string;
+    devicePub: Uint8Array;
+    deviceNonce: string;
+    approverNonce: string;
+}): Promise<string>;
+/** The approving device seals the team kit to the new device's public key. */
+export declare function sealKitForDevice(c: TeamKeyCrypto, owner: string, requestId: string, devicePub: Uint8Array, kit: Uint8Array): Promise<string>;
+export declare function openKitForDevice(c: TeamKeyCrypto, owner: string, requestId: string, device: P256Pair, sealed: string): Promise<Uint8Array>;
+export declare function webTeamKeyCrypto(): TeamKeyCrypto;
+//# sourceMappingURL=teamKey.d.ts.map

package/lib/typescript/module/bugCase/types.d.ts

@@ -6,6 +6,7 @@
 import type { SuperJSONResult } from "../utils/minimalSuperJSON";
 import type { ScrubbedItem } from "./scrub";
 import type { BugCaseStep, BugCaseTouch } from "./steps";
+import type { BugCaseMedia } from "./media";
 export declare const BUG_CASE_VERSION = 1;
 export interface BugCaseNetworkCall {
     t: number;
@@ -19,6 +20,8 @@ export interface BugCaseNetworkCall {
     requestData?: unknown;
     responseHeaders?: Record<string, string>;
     responseData?: unknown;
+    /** The answer was parsed from JSON text, so a string was a JSON string. Missing in older cases. */
+    responseJson?: boolean;
     /** True when a body was over the case budget and left out. */
     bodyOmitted?: boolean;
 }
@@ -48,6 +51,11 @@ export interface BugCase {
     app: {
         platform: string;
         os: string;
+        /** Bundle id or package name, when the app could say. */
+        id?: string;
+        /** The version people see ("4.2.0") and the build number ("4210"), so a load on another build can say so. */
+        version?: string;
+        build?: string;
         appearance?: string;
         locale?: string;
         timeZone?: string;
@@ -82,6 +90,8 @@ export interface BugCase {
     /** B2: newest first, with answers for replay. */
     network: BugCaseNetworkCall[];
     console: BugCaseConsoleLine[];
+    /** Pictures and video, boxed on the phone (media/SPEC.md C1). Old cases and old phones have none. */
+    media?: BugCaseMedia;
     missing: BugCaseMissing[];
     scrub: {
         removed: number;

package/lib/typescript/module/bugCase/validate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Check an opened bug case before anyone uses it.
+ *
+ * A case comes from someone else's phone, and a hand-made blob can say
+ * anything. Every reader (the link page, the Mac, the phone's loader) gets the
+ * same shapes: wrong-typed parts become empty, oversize text is cut, and a
+ * case without its core (version, date, app) is refused.
+ */
+import { type BugCase } from "./types";
+export declare class BugCaseShapeError extends Error {
+    constructor(part: string);
+}
+export declare function validateBugCase(raw: unknown): BugCase;
+//# sourceMappingURL=validate.d.ts.map

package/lib/typescript/module/clipboard/autoDetectClipboard.d.ts

@@ -15,7 +15,7 @@
  * - Metro sees static imports only
  * - Works with any Metro version
  */
-export { clipboardFunction, clipboardType, isClipboardAvailable, type ClipboardFunction, } from "./clipboard-impl";
+export { clipboardFunction, clipboardType, isClipboardAvailable, readClipboardText, type ClipboardFunction, } from "./clipboard-impl";
 import { clipboardFunction } from "./clipboard-impl";
 /**
  * Attempts to auto-detect and return a clipboard implementation.

package/lib/typescript/module/clipboard/clipboard-impl.d.ts

@@ -21,4 +21,10 @@ export type ClipboardFunction = (text: string) => Promise<boolean>;
 export declare const clipboardType: () => "expo" | "react-native" | "web" | null;
 export declare const isClipboardAvailable: () => boolean;
 export declare const clipboardFunction: ClipboardFunction;
+/**
+ * The clipboard's text, for a Paste button. Only ever called from a tap: iOS
+ * shows its "pasted from" banner for each read, and a silent read on open
+ * would show it for nothing (the bug links panels ruled that out).
+ */
+export declare const readClipboardText: () => Promise<string | null>;
 //# sourceMappingURL=clipboard-impl.d.ts.map

package/lib/typescript/module/clipboard/clipboard-impl.web.d.ts

@@ -2,4 +2,6 @@ export type ClipboardFunction = (text: string) => Promise<boolean>;
 export declare const isClipboardAvailable: () => boolean;
 export declare const clipboardType: () => "web" | null;
 export declare const clipboardFunction: ClipboardFunction;
+/** The clipboard's text, for a Paste button. Only ever called from a tap. */
+export declare const readClipboardText: () => Promise<string | null>;
 //# sourceMappingURL=clipboard-impl.web.d.ts.map

package/lib/typescript/module/clipboard/index.d.ts

@@ -1,4 +1,4 @@
 export { copyToClipboard } from "./copyToClipboard";
-export { createAutoDetectedClipboard, getAutoDetectedClipboard, } from "./autoDetectClipboard";
+export { createAutoDetectedClipboard, getAutoDetectedClipboard, readClipboardText, } from "./autoDetectClipboard";
 export type { ClipboardFunction } from "./autoDetectClipboard";
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/dataViewer/flattenTree.d.ts

@@ -0,0 +1,35 @@
+import { JsonValue } from "../types/types";
+/**
+ * Pure tree → rows flattening for VirtualizedDataExplorer.
+ *
+ * Lives outside the component so it can be unit tested without React Native.
+ * Every child of an expanded node becomes a row: the list is virtualized, so
+ * rows are cheap, and the header's "(N items)" must match what you can scroll
+ * to. An earlier version stopped after 150 children (a leftover `break` meant to
+ * "yield" that nothing ever resumed) and capped the count at 500.
+ */
+export declare const MAX_DEPTH_LIMIT = 15;
+export interface FlatDataItem {
+    id: string;
+    key: string;
+    value: JsonValue;
+    valueType: string;
+    depth: number;
+    isExpandable: boolean;
+    isExpanded: boolean;
+    parentId?: string;
+    hasChildren: boolean;
+    childCount: number;
+    path: string[];
+    type: string;
+    isLastChild?: boolean;
+    parentHasMoreSiblings?: boolean[];
+    siblingIndex?: number;
+    totalSiblings?: number;
+}
+export declare const getValueType: (value: JsonValue) => string;
+export declare const getValueCount: (value: JsonValue, valueType: string) => number;
+/** A collection's children as [key, value] pairs, in display order. */
+export declare const getChildEntries: (value: JsonValue, valueType: string) => [string, JsonValue][];
+export declare function flattenTree(value: JsonValue, expandedSet: Set<string>, circularCache: WeakSet<object>, maxDepth: number, key?: string, depth?: number, parentId?: string, path?: string[], siblingIndex?: number, totalSiblings?: number, parentHasMoreSiblings?: boolean[]): FlatDataItem[];
+//# sourceMappingURL=flattenTree.d.ts.map

package/lib/typescript/module/dataViewer/liveEntries.d.ts

@@ -0,0 +1,19 @@
+import { JsonValue } from "../types/types";
+/**
+ * Pure helpers for LiveExplorer's child list, kept out of the component so they
+ * can be unit tested without React Native.
+ *
+ * Every child is listed. Long lists are split into collapsed pages of
+ * `LIVE_PAGE_SIZE`, so a huge array costs one header row per page until you
+ * open one. Children past 1,000 used to be dropped, so they could not be reached.
+ */
+export declare const LIVE_PAGE_SIZE = 100;
+export type LiveEntry = {
+    label: string;
+    value: JsonValue;
+};
+/** A node's children, in display order. */
+export declare function getLiveSubEntries(value: JsonValue): LiveEntry[];
+/** `[first...last]` for page `index`; the last page stops at the real end. */
+export declare function livePageRange(index: number, total: number, size?: number): string;
+//# sourceMappingURL=liveEntries.d.ts.map

package/lib/typescript/module/hooks/safe-area-impl.d.ts

@@ -1,7 +1,7 @@
 /**
  * Auto-generated safe area implementation
  * Detected: none
- * Generated at: 2026-10-23T07:23:13.273Z
+ * Generated at: 2026-10-31T18:38:31.842Z
  *
  * DO NOT EDIT - This file is generated by scripts/detect-safe-area.js
  *

package/lib/typescript/module/icons/index.d.ts

@@ -28,4 +28,5 @@ export { ClockToolIcon, CLOCK_TOOL_ICON_COLOR } from "@buoy-gg/floating-tools-co
 export { PermissionsIcon, PERMISSIONS_ICON_COLOR } from "@buoy-gg/floating-tools-core";
 export { LifecycleToolIcon, LIFECYCLE_TOOL_ICON_COLOR } from "@buoy-gg/floating-tools-core";
 export { LocationToolIcon, LOCATION_TOOL_ICON_COLOR } from "@buoy-gg/floating-tools-core";
+export { OtaInspectorIcon, OTA_INSPECTOR_ICON_COLOR } from '@buoy-gg/floating-tools-core';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/index.d.ts

@@ -14,10 +14,11 @@ export * from "./tools/defineTool";
 export * from "./sync/toolActionRegistry";
 export * from "./sync/toolUiBridge";
 export * from "./sync/toolScreenHeader";
-export { absoluteFill, displayValue, parseDisplayValue, getSafeAreaInsets, persistentStorage, isUsingPersistentStorage, getStorageBackendType, safeStringify, getValueType, isPrimitive, isJsonSerializable, isValidJson, getConstructorName, isEmpty, getValueSize, parseValue, formatValue, getTypeColor, truncateText, flattenObject, formatPath, loadOptionalModule, getCachedOptionalModule, setRenderCaptureProvider, getRenderCaptureProvider, type RenderCaptureProvider, type RenderCaptureSummary, type RenderCaptureTopComponent, type RenderCauseCounts, registerStateSnapshotProvider, getStateSnapshotProviders, getStateSnapshotProvider, subscribeToStateSnapshotProviders, type StateSnapshotProvider, type StateSnapshotProviderStatus, type StateSnapshotCapture, type StateSnapshotRestoreResult, type StateSnapshotPreview, type StateSnapshotPreviewItem, type StateSnapshotPreviewVerdict, superJsonSerialize, superJsonDeserialize, type SuperJSONResult, realNow, getRealAppState, subscribeRealAppState, BUOY_SYNTHETIC_MARK, countBuoyListener, type RealAppState, reloadApp, scheduleReloadApp, resolveReloadStrategy, REMOTE_RELOAD_DELAY_MS, type ReloadStrategy, type ResolvedReloadStrategy, getDevServerOrigin, Subscribable, type SubscribableListener, subscriberCountNotifier, subscribeToSubscriberCountChanges, notifySubscriberCountChange, useSafeRouter, useSafePathname, useSafeSegments, useSafeGlobalSearchParams, getSafeRouter, getSafeCurrentPathname, getSafeCurrentRoute, isExpoRouterAvailable, } from "./utils";
+export { absoluteFill, displayValue, parseDisplayValue, getSafeAreaInsets, persistentStorage, setItemChecked, getItemChecked, storageIsMemoryOnly, isUsingPersistentStorage, getStorageBackendType, safeStringify, getValueType, isPrimitive, isJsonSerializable, isValidJson, getConstructorName, isEmpty, getValueSize, parseValue, formatValue, getTypeColor, truncateText, flattenObject, formatPath, loadOptionalModule, getCachedOptionalModule, setRenderCaptureProvider, getRenderCaptureProvider, type RenderCaptureProvider, type RenderCaptureSummary, type RenderCaptureTopComponent, type RenderCauseCounts, registerStateSnapshotProvider, getStateSnapshotProviders, getStateSnapshotProvider, subscribeToStateSnapshotProviders, type StateSnapshotProvider, type StateSnapshotProviderStatus, type StateSnapshotCapture, type StateSnapshotRestoreResult, type StateSnapshotPreview, type StateSnapshotPreviewItem, type StateSnapshotPreviewVerdict, superJsonSerialize, superJsonDeserialize, type SuperJSONResult, realNow, getRealAppState, subscribeRealAppState, BUOY_SYNTHETIC_MARK, countBuoyListener, type RealAppState, reloadApp, scheduleReloadApp, resolveReloadStrategy, REMOTE_RELOAD_DELAY_MS, type ReloadStrategy, type ResolvedReloadStrategy, getDevServerOrigin, Subscribable, type SubscribableListener, subscriberCountNotifier, subscribeToSubscriberCountChanges, notifySubscriberCountChange, useSafeRouter, useSafePathname, useSafeSegments, useSafeGlobalSearchParams, getSafeRouter, getSafeCurrentPathname, getSafeCurrentRoute, isExpoRouterAvailable, } from "./utils";
 export type { SafeRouteLocation } from "./utils";
 export * from "./utils/toolModules";
 export { subscribeStorageWrites } from "./utils/storageWrites";
+export { FiberRootAnchor, getAnchoredFiberRoots } from "./utils/fiberRootAnchor";
 export { registerBrowserRouter, browserRouter, subscribeBrowserNavigation } from "./utils/browserNavigation";
 export { PREVIEW_ITEM_RENDER_BYTE_LIMIT, createRestoreScope, emptyRestoreResult, failedRestore, skippedRestore, classifyPreviewItem, wontApply, unionKeys, type RestoreScope, type RestoreScopeOptions, type ClassifyOptions, type ClassifyInput, } from "./utils/snapshotProviderKit";
 export { entityColor, formatValuePreview, shallowDiffSummary, type ValuePreviewOptions, type ShallowDiffSummary, } from "./utils/stateTools";
@@ -51,7 +52,7 @@ export type { Environment } from "./types/types";
 export { normalizeEnvironment } from "./types/types";
 export { HintsProvider, useHintsDisabled, useHintsContext } from "./context";
 export * from "./history";
-export { FeatureGate, UpgradePrompt, useFeatureGate, ProFeatureBanner, UpgradeModal, BuoyUpgradeSheet, BuoySignInCard, BuoyNeedsPlanCard, useSignInState, ProBadge, ProUpgradeModal, FreeAccountPrompt, LOGIN_COMMAND, getUseIsPro, getUseLicense, getUseTier, signOutOfBuoy, TIER_LIMITS, useLimit, resolveEffectiveTier } from "./license";
+export { FeatureGate, UpgradePrompt, useFeatureGate, ProFeatureBanner, UpgradeModal, BuoyUpgradeSheet, BuoySignInCard, BuoyNeedsPlanCard, BuoyGetProCard, useSignInState, ProBadge, ProUpgradeModal, FreeAccountPrompt, LOGIN_COMMAND, getUseIsPro, getUseLicense, getUseTier, signOutOfBuoy, TIER_LIMITS, useLimit, resolveEffectiveTier } from "./license";
 export type { FeatureGateProps, ProFeatureBannerProps, UpgradeModalProps, BuoyUpgradeSheetProps, ProUpgradeModalProps, FreeAccountPromptProps, BuoyTier, TierLimitKey } from "./license";
 export { getAccountAccess, hasAccountAccess, assertAccountAccess, subscribeAccountAccess, getUseAccountAccess, retryAccountAccess, isProNow, getTeamCredential } from "./license/licenseModule";
 export { setBuoyAppId, getBuoyAppId } from "./utils/appIdentity";

package/lib/typescript/module/license/BuoyUpgradeSheet.d.ts

@@ -14,6 +14,14 @@ export declare function BuoySignInCard({ onClose, onNotConfigured, footer, }: {
 export declare function BuoyNeedsPlanCard({ onClose }: {
     onClose: () => void;
 }): import("react").JSX.Element;
+/**
+ * "Get Buoy Pro": a QR code and a link to buoy.gg/pricing, then a way to
+ * check again. BuoyUpgradeSheet shows it in a Modal; the parity sheet draws
+ * it inline.
+ */
+export declare function BuoyGetProCard({ onClose }: {
+    onClose: () => void;
+}): import("react").JSX.Element;
 export interface BuoyUpgradeSheetProps {
     visible: boolean;
     onClose: () => void;

package/lib/typescript/module/license/index.d.ts

@@ -1,6 +1,6 @@
 export { FeatureGate, UpgradePrompt, useFeatureGate, ProFeatureBanner, UpgradeModal, ProBadge, ProUpgradeModal } from "./FeatureGate";
 export type { FeatureGateProps, ProFeatureBannerProps, UpgradeModalProps, ProUpgradeModalProps } from "./FeatureGate";
-export { BuoyUpgradeSheet, BuoySignInCard, BuoyNeedsPlanCard, useSignInState } from "./BuoyUpgradeSheet";
+export { BuoyUpgradeSheet, BuoySignInCard, BuoyNeedsPlanCard, BuoyGetProCard, useSignInState } from "./BuoyUpgradeSheet";
 export type { BuoyUpgradeSheetProps } from "./BuoyUpgradeSheet";
 export { FreeAccountPrompt, LOGIN_COMMAND } from "./FreeAccountPrompt";
 export type { FreeAccountPromptProps } from "./FreeAccountPrompt";

package/lib/typescript/module/sync/keyedArrays.d.ts

@@ -4,8 +4,13 @@
  * Every item must carry it, and every value must be a distinct string/number —
  * a duplicated id would make an addressed edit ambiguous, and silently picking
  * the first match is exactly the kind of "helpful" guess that loses data.
+ *
+ * A unique `…Id` field counts too: Haiven's `/chat/me` rows carry only
+ * `channelId`, and a keyed edit on them was written over the list as an object.
+ * When `keys` are given, the field holding one of them wins, so a studio patch
+ * keyed by slug edits that studio instead of appending a new one under `id`.
  */
-export declare function identityField(items: unknown[]): string | undefined;
+export declare function identityField(items: unknown[], keys?: string[]): string | undefined;
 /**
  * Let a caller address list items by their own id instead of resending the list.
  *

package/lib/typescript/module/ui/floating/FloatingTool.d.ts

@@ -27,6 +27,11 @@ export type FloatingToolProps = {
      * out of the way of app headers.
      */
     defaultPlacement?: "top" | "bottom";
+    /**
+     * Extra room a "bottom" tool keeps above the safe area, e.g. for the dev
+     * warning banner (LogBox) that covers the bottom of a dev build.
+     */
+    bottomClearance?: number;
     children?: ReactNode;
     /** When true, pushes the bubble to the side (hidden position) */
     pushToSide?: boolean;
@@ -70,7 +75,7 @@ export type FloatingToolProps = {
  * @performance Implements efficient boundary checking and position validation
  * @performance Includes debounced position saving for optimal storage performance
  */
-export declare function FloatingTool({ id, suspendPointerEvents, revealToken, variant, dragFromSurface, accessibilityLabel, minimizedStack, hasMinimizedStack, accessory, handleAdornment, enablePositionPersistence, defaultPlacement, pushToSide, centerOnboarding, children, environment, availableEnvironments, onEnvironmentSwitch, showEnvironmentSelector, }: FloatingToolProps): import("react").JSX.Element | null;
+export declare function FloatingTool({ id, suspendPointerEvents, revealToken, variant, dragFromSurface, accessibilityLabel, minimizedStack, hasMinimizedStack, accessory, handleAdornment, enablePositionPersistence, defaultPlacement, bottomClearance, pushToSide, centerOnboarding, children, environment, availableEnvironments, onEnvironmentSwitch, showEnvironmentSelector, }: FloatingToolProps): import("react").JSX.Element | null;
 /** Native AppHost gets its anchor from the minimized-tools provider. */
 export declare function getBubbleAnchorPosition(): {
     x: number;

package/lib/typescript/module/ui/listPresets.d.ts

@@ -5,14 +5,14 @@
  * Spread them onto a FlatList: `<FlatList {...EVENT_LIST_PRESET} … />`.
  * A tool that later moves to FlashList changes this file, not eleven.
  */
-import type { FlatListProps } from "react-native";
+import { type FlatListProps } from "react-native";
 /**
  * `removeClippedSubviews` is off in E2E bundles: clipped rows leave the
  * hierarchy entirely, so a row past the fold reads to the test as "the tool
  * stopped capturing".
  */
 export declare const CLIP_OFFSCREEN_CELLS: boolean;
-type ListPreset = Pick<FlatListProps<unknown>, "initialNumToRender" | "maxToRenderPerBatch" | "windowSize" | "updateCellsBatchingPeriod" | "removeClippedSubviews">;
+type ListPreset = Pick<FlatListProps<unknown>, "initialNumToRender" | "maxToRenderPerBatch" | "windowSize" | "updateCellsBatchingPeriod" | "removeClippedSubviews" | "keyboardShouldPersistTaps" | "keyboardDismissMode">;
 /**
  * Event / change / request lists: rows are tall-ish and arrive in bursts.
  * Window and batch values are the "tuned" winner of the buoy-optimize

package/lib/typescript/module/utils/fiberRootAnchor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The app's React roots, found without React DevTools.
+ *
+ * Highlight Updates finds roots through `__REACT_DEVTOOLS_GLOBAL_HOOK__`. React
+ * Native sets that hook up only in dev builds, so in a release build Bug Links
+ * got no taps and no screen text. A class component's instance holds its own
+ * fiber (`_reactInternals`) in every React build. Walking up from it reaches
+ * the root it is mounted in. FloatingDevTools mounts one inside the app's tree.
+ */
+import { Component } from "react";
+/** Renders nothing. While mounted, its root shows in `getAnchoredFiberRoots()`. */
+export declare class FiberRootAnchor extends Component {
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): null;
+}
+/** The FiberRoot (with `.current`) of every mounted anchor, once each. */
+export declare function getAnchoredFiberRoots(): any[];
+//# sourceMappingURL=fiberRootAnchor.d.ts.map

package/lib/typescript/module/utils/index.d.ts

@@ -1,7 +1,7 @@
 export { absoluteFill } from "./absoluteFill";
 export { displayValue, parseDisplayValue } from "./displayValue";
 export { getSafeAreaInsets } from "./getSafeAreaInsets";
-export { persistentStorage, isUsingPersistentStorage, getStorageBackendType, type DevToolsStorage, } from "./persistentStorage";
+export { persistentStorage, setItemChecked, getItemChecked, storageIsMemoryOnly, isUsingPersistentStorage, getStorageBackendType, type DevToolsStorage, } from "./persistentStorage";
 export { safeStringify } from "./safeStringify";
 export { getValueType, isPrimitive, isJsonSerializable, isValidJson, getConstructorName, isEmpty, getValueSize, } from "./typeHelpers";
 export { parseValue, formatValue, getTypeColor, truncateText, flattenObject, formatPath, } from "./valueFormatting";
@@ -21,4 +21,5 @@ export { browserRouter, getBrowserHref, getBrowserRouteURL, registerBrowserRoute
 export { isDOMElement, getDOMControlProps, getDOMFiber, getDOMNodeHandle, getDOMPublicInstance, resolveDOMEventEmitter } from "./domRuntime";
 export { registerToolModules, getRegisteredToolModule, getToolModuleVersion, type ToolModule } from "./toolModules";
 export { loadToolModule } from "./loadToolModule";
+export { FiberRootAnchor, getAnchoredFiberRoots } from "./fiberRootAnchor";
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/utils/minimalSuperJSON.d.ts

@@ -13,12 +13,14 @@ export interface SuperJSONResult {
     };
 }
 export declare function serialize(object: any): SuperJSONResult;
-export declare function deserialize<T = unknown>(payload: SuperJSONResult): T;
+export declare function deserialize<T = unknown>(payload: SuperJSONResult, options?: {
+    skipBadAnnotations?: boolean;
+}): T;
 /**
  * Drop the annotations whose value `drop` rejects. A bug case's scrubber can
  * replace a Date with "[removed:pii]"; the Date annotation left behind would
  * turn that into Invalid Date (or throw, for a BigInt) on deserialize.
  */
-export declare function dropAnnotations(payload: SuperJSONResult, drop: (value: unknown) => boolean): SuperJSONResult;
+export declare function dropAnnotations(payload: SuperJSONResult, drop: (value: unknown, type: unknown) => boolean): SuperJSONResult;
 export {};
 //# sourceMappingURL=minimalSuperJSON.d.ts.map

package/lib/typescript/module/utils/persistentStorage.d.ts

@@ -29,6 +29,21 @@ type StorageBackend = "filesystem" | "asyncstorage" | "localstorage" | "memory";
  * Same API as AsyncStorage for easy migration.
  */
 export declare const persistentStorage: DevToolsStorage;
+/**
+ * Like persistentStorage.setItem, but says whether the value reached disk:
+ * false when the backend failed or kept it in memory only. For data that is
+ * worthless half saved (a blob in chunks, an undo copy).
+ */
+export declare function setItemChecked(key: string, value: string, options?: {
+    strict?: boolean;
+}): Promise<boolean>;
+/**
+ * Like persistentStorage.getItem, but a read that fails throws instead of
+ * looking like a missing value: null means nothing is saved there. For data
+ * that a save would replace whole (a list), where "empty" and "couldn't
+ * read" must never be mixed up.
+ */
+export declare function getItemChecked(key: string): Promise<string | null>;
 /**
  * Check if persistent storage (FileSystem) is being used
  */
@@ -36,10 +51,14 @@ export declare function isUsingPersistentStorage(): Promise<boolean>;
 /**
  * Get the current storage backend type
  */
+/** True when nothing saved outlives the app (no file store, AsyncStorage or localStorage). */
+export declare function storageIsMemoryOnly(): Promise<boolean>;
 export declare function getStorageBackendType(): Promise<StorageBackend>;
 /**
  * Force re-initialization of storage (useful for testing)
  */
 export declare function resetStorageInit(): void;
+/** Tests only: use this file module (or none) and pick the store again. */
+export declare function setFileSystemForTests(fs: unknown): void;
 export {};
 //# sourceMappingURL=persistentStorage.d.ts.map

package/lib/typescript/module/utils/persistentStorage.web.d.ts

@@ -3,4 +3,21 @@ export type { DevToolsStorage } from "./persistentStorage";
 export declare const persistentStorage: DevToolsStorage;
 export declare function isUsingPersistentStorage(): Promise<boolean>;
 export declare function getStorageBackendType(): Promise<"localstorage" | "memory">;
+/**
+ * Write and report whether it reached the browser's storage, like the native
+ * setItemChecked: false when storage is blocked or full (the value is still
+ * kept for this session). Bug links saves a loaded case this way, so a reload
+ * can still restore the app.
+ */
+export declare function setItemChecked(key: string, value: string, _options?: {
+    strict?: boolean;
+}): Promise<boolean>;
+/**
+ * Like getItem, but a read that fails throws instead of looking like a
+ * missing value (the native getItemChecked). With no browser storage at all,
+ * this session's own copy is all there is.
+ */
+export declare function getItemChecked(key: string): Promise<string | null>;
+/** True when nothing saved outlives the page. */
+export declare function storageIsMemoryOnly(): Promise<boolean>;
 //# sourceMappingURL=persistentStorage.web.d.ts.map