@buoy-gg/shared-ui 7.0.35 → 7.0.38

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

@@ -1,14 +1,13 @@
 /**
- * The upsell an ANONYMOUS user sees — someone with no key at all.
+ * The account setup sheet — what a locked manager shows instead of the tools.
  *
- * Deliberately not the Pro modal. Their next step is free and takes about
- * thirty seconds, so asking them for money would be asking the wrong question
- * at the wrong moment, and would suppress exactly the signup this exists to
- * produce. Pro is still offered, as a secondary action.
+ * Deliberately not the Pro modal. The next step is a free account and takes
+ * about thirty seconds, so asking for money here would be asking the wrong
+ * question at the wrong moment. Pro is still offered, as a secondary action.
  *
- * The command is shown inline and copyable rather than linked, because there is
- * no grace period: someone who just watched their limits shrink needs the fix
- * in front of them, not a link to a page that has a link to a command.
+ * The command is shown inline and copyable rather than linked, because
+ * someone who cannot open the tools needs the fix in front of them, not a link
+ * to a page that has a link to a command.
  */
 import React from "react";
 /** The one thing a reader has to be able to act on. */
@@ -16,8 +15,6 @@ export declare const LOGIN_COMMAND = "npx buoy login";
 export interface FreeAccountPromptProps {
     visible: boolean;
     onClose: () => void;
-    /** What the user just bumped into, e.g. "Network requests". */
-    featureName?: string;
 }
-export declare const FreeAccountPrompt: ({ visible, onClose, featureName, }: FreeAccountPromptProps) => React.JSX.Element | null;
+export declare const FreeAccountPrompt: ({ visible, onClose, }: FreeAccountPromptProps) => React.JSX.Element | null;
 //# sourceMappingURL=FreeAccountPrompt.d.ts.map

package/lib/typescript/module/license/FreeAccountPrompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FreeAccountPrompt.d.ts","sourceRoot":"","sources":["../../../../src/license/FreeAccountPrompt.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAmD,MAAM,OAAO,CAAC;AAcxE,uDAAuD;AACvD,eAAO,MAAM,aAAa,mBAAmB,CAAC;AAE9C,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,iBAAiB,GAAI,oCAI/B,sBAAsB,6BAoFxB,CAAC"}
+{"version":3,"file":"FreeAccountPrompt.d.ts","sourceRoot":"","sources":["../../../../src/license/FreeAccountPrompt.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAmD,MAAM,OAAO,CAAC;AAexE,uDAAuD;AACvD,eAAO,MAAM,aAAa,mBAAmB,CAAC;AAE9C,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,eAAO,MAAM,iBAAiB,GAAI,uBAG/B,sBAAsB,6BAgGxB,CAAC"}

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

@@ -6,6 +6,6 @@ export type { FreeAccountPromptProps } from "./FreeAccountPrompt";
 export type { LicenseEntryModalProps, LicenseState } from "./LicenseEntryModal";
 export { getUseIsPro, getUseLicense, getUseTier, } from "./licenseModule";
 export type { BuoyTier } from "./licenseModule";
-export { TIER_LIMITS, useLimit, resolveEffectiveTier, freeKeyRaises } from "./tierLimits";
+export { TIER_LIMITS, useLimit, resolveEffectiveTier } from "./tierLimits";
 export type { TierLimitKey } from "./tierLimits";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/license/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACtI,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAEtH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACvE,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,YAAY,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIhF,OAAO,EACL,WAAW,EACX,aAAa,EACb,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC1F,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/license/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACtI,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAEtH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACvE,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,YAAY,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIhF,OAAO,EACL,WAAW,EACX,aAAa,EACb,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAC3E,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}

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

@@ -1,13 +1,13 @@
 /**
- * Centralized lazy loading of `@buoy-gg/license`.
+ * Centralized access of `@buoy-gg/license`.
  *
  * This is the SINGLE place any package resolves license hooks — tools must not
- * `require("@buoy-gg/license")` themselves. Lives in its own module (rather
+ * resolve the license module themselves. Lives in its own module (rather
  * than `./index`) so `tierLimits` can consume it without an import cycle.
  */
 import type { LicenseState as LicenseStateType } from "./LicenseEntryModal";
-/** Access tier. Mirrors BuoyTier in @buoy-gg/license. */
-export type BuoyTier = "anonymous" | "free" | "pro";
+/** Tier. Mirrors BuoyTier in @buoy-gg/license. */
+export type BuoyTier = "free" | "pro";
 /**
  * Get the useIsPro hook from @buoy-gg/license.
  * Falls back to () => false if the license package is not available.
@@ -23,33 +23,20 @@ export declare function getUseIsPro(): () => boolean;
  */
 export declare function getUseLicense(): (() => LicenseStateType) | null;
 /**
- * Get the useTier hook from @buoy-gg/license.
- *
- * Falls back to `"free"` — NOT `"anonymous"` — when the license package can't
- * be resolved. That deliberately matches the existing `getUseIsPro()` fallback,
- * which yields free-tier behavior today, and it picks the safer failure:
- *
- *  - falling back to "anonymous" would let one bundler quirk silently cut every
- *    legitimate user's limits by ~80%;
- *  - falling back to "free" costs no revenue, because Pro still requires a key
- *    that a live license server validated — this path can never grant Pro.
- *
- * Reaching it at all requires `@buoy-gg/license` to be missing, and it is a
- * hard dependency of `@buoy-gg/core`.
+ * Falls back to "free" without the license package. That grants nothing: a
+ * missing license module also means no account admission, and nothing is
+ * exposed without it.
  */
 export declare function getUseTier(): () => BuoyTier;
-/**
- * Whether the anonymous tier is switched on.
- *
- * The switch itself lives in @buoy-gg/license (see its config.ts) because the
- * Weekend Pass change has to flip at the same moment as the reduced limits, and
- * those live in different packages. Read through the same lazy loader as the
- * hooks so a missing license package degrades gracefully rather than throwing
- * at module load.
- *
- * Falls back to `false` — the anonymous tier off, everyone on free limits —
- * which matches the `getUseTier()` fallback of "free". A build that cannot
- * resolve the license package must never take limits AWAY from someone.
- */
-export declare function isAnonymousTierEnabled(): boolean;
+export type AccountAccess = {
+    status: "initializing" | "locked" | "admitted";
+    reason: string | null;
+    validUntil: number | null;
+};
+export declare function getAccountAccess(): AccountAccess;
+export declare function hasAccountAccess(): boolean;
+export declare function assertAccountAccess(): void;
+export declare function subscribeAccountAccess(listener: () => void): () => void;
+export declare function getUseAccountAccess(): () => AccountAccess;
+export declare function retryAccountAccess(): Promise<void>;
 //# sourceMappingURL=licenseModule.d.ts.map

package/lib/typescript/module/license/licenseModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"licenseModule.d.ts","sourceRoot":"","sources":["../../../../src/license/licenseModule.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,yDAAyD;AACzD,MAAM,MAAM,QAAQ,GAAG,WAAW,GAAG,MAAM,GAAG,KAAK,CAAC;AA4BpD;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,MAAM,OAAO,CAG3C;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,CAAC,MAAM,gBAAgB,CAAC,GAAG,IAAI,CAG/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,IAAI,MAAM,QAAQ,CAG3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAGhD"}
+{"version":3,"file":"licenseModule.d.ts","sourceRoot":"","sources":["../../../../src/license/licenseModule.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,kDAAkD;AAClD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAuBtC;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,MAAM,OAAO,CAG3C;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,CAAC,MAAM,gBAAgB,CAAC,GAAG,IAAI,CAG/D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,MAAM,QAAQ,CAG3C;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,cAAc,GAAG,QAAQ,GAAG,UAAU,CAAC;IAC/C,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AAYF,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AACD,wBAAgB,gBAAgB,IAAI,OAAO,CAAqD;AAChG,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AACD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAEvE;AACD,wBAAgB,mBAAmB,IAAI,MAAM,aAAa,CAGzD;AACD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAKxD"}

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

@@ -1,111 +1,89 @@
 /**
- * Per-tier numeric limits — the ONLY thing that separates anonymous from free.
+ * Per-tier numeric limits — the ONLY thing that separates free from pro on a
+ * count.
  *
- * Every binary Pro gate (copy-to-clipboard, state editing, storage mutations,
- * navigation) is identical for both: locked. That keeps the tier split to one
- * table instead of scattered conditionals.
- *
- * The governing rule: **the free column never moves.** Anonymous is carved out
- * BELOW today's free tier — nothing is ever added to free in exchange for an
- * account, because that would come straight out of the Pro upgrade.
+ * Binary Pro gates (copy-to-clipboard, state editing, storage mutations,
+ * navigation) live in the tools themselves; this table is only for "how many".
+ * Whether the tools are usable at all is account admission, which is a
+ * separate question from the tier and is never expressed as a limit.
  */
 import { type BuoyTier } from "./licenseModule";
 interface TierLimit {
-    /** No credential — a trial: every tool visible, much smaller caps. */
-    readonly anonymous: number;
-    /** A validated key on the Free policy. Today's free tier, unchanged. */
+    /** A validated key on the Free policy. */
     readonly free: number;
     /** A validated key on the Solo or Business policy. */
     readonly pro: number;
 }
 declare const LIMITS: {
     "network.requests": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "network.saved": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "network.overrideRules": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "storage.events": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "storage.keys": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "storage.mmkvInstances": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "redux.actions": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "zustand.changes": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "jotai.changes": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "events.entries": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "highlightUpdates.components": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "highlightUpdates.historyEvents": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "highlightUpdates.detailEvents": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "routeEvents.entries": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "timeMachine.snapshots": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "perfMonitor.automationCases": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "scenarios.saved": {
-        anonymous: number;
         free: number;
         pro: number;
     };
     "scenarios.active": {
-        anonymous: number;
         free: number;
         pro: number;
     };
@@ -116,10 +94,8 @@ export declare const TIER_LIMITS: Record<TierLimitKey, TierLimit>;
  * The tier whose limits actually apply.
  *
  * `hasProAccess` is `useIsPro()`, which is true for a real Pro license OR the
- * free Weekend Pass. Routing the Weekend Pass through here is what keeps
- * today's behavior intact: weekend users get Pro limits, exactly as they do
- * now. When the Weekend Pass is later gated to key-holders, that change lands
- * here for free — no limit call site has to know about it.
+ * Weekend Pass. Routing the Weekend Pass through here is what gives weekend
+ * users Pro limits without any limit call site having to know about it.
  */
 export declare function resolveEffectiveTier(tier: BuoyTier, hasProAccess: boolean): BuoyTier;
 /**
@@ -130,24 +106,5 @@ export declare function resolveEffectiveTier(tier: BuoyTier, hasProAccess: boole
  * directly in `slice(0, limit)` and `length >= limit` comparisons.
  */
 export declare function useLimit(key: TierLimitKey): number;
-/**
- * Whether claiming a FREE key would actually raise this limit right now.
- *
- * The anonymous upsell must never promise something a free key won't deliver.
- * Two ways it could lie, and this closes both:
- *
- *  - **Pro-exclusive features.** Copy-to-clipboard, state editing, storage
- *    mutations and navigation are locked for anonymous AND free alike. Telling
- *    an anonymous user a free key opens them would be false.
- *  - **Limits that are already equal.** Override rules and MMKV instances sit
- *    at 1 for both tiers, so a key changes nothing there either.
- *
- * It also respects `ANONYMOUS_TIER_ENABLED`: while the anonymous tier is off,
- * an anonymous user is *already* getting the free limits, so there is nothing
- * to claim and this correctly returns false everywhere. That falls out of
- * asking `resolveEffectiveTier` rather than reading the table directly, so the
- * switch and the copy can never disagree.
- */
-export declare function freeKeyRaises(key: TierLimitKey): boolean;
 export {};
 //# sourceMappingURL=tierLimits.d.ts.map

package/lib/typescript/module/license/tierLimits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tierLimits.d.ts","sourceRoot":"","sources":["../../../../src/license/tierLimits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAIL,KAAK,QAAQ,EACd,MAAM,iBAAiB,CAAC;AAEzB,UAAU,SAAS;IACjB,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCX,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,MAAM,CAAC;AAE/C,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,SAAS,CAAU,CAAC;AAEnE;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,OAAO,GACpB,QAAQ,CAMV;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAIlD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAMxD"}
+{"version":3,"file":"tierLimits.d.ts","sourceRoot":"","sources":["../../../../src/license/tierLimits.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAA2B,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEzE,UAAU,SAAS;IACjB,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCX,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,MAAM,CAAC;AAE/C,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,SAAS,CAAU,CAAC;AAEnE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,OAAO,GACpB,QAAQ,CAEV;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAIlD"}

package/lib/typescript/module/storage/devToolsStorageKeys.d.ts

@@ -122,6 +122,12 @@ export declare const devToolsStorageKeys: {
     readonly timeMachine: {
         readonly root: () => "@react_buoy_time_machine";
         readonly diffViewerMode: () => "@react_buoy_time_machine_diff_viewer_mode";
+        /** The restore point the floating restore bar restores on tap (snapshot id). */
+        readonly armedPoint: () => "@react_buoy_time_machine_armed_point";
+        /** "1" when the action bar restores in reload mode (storage, then a JS reload). */
+        readonly barReloadMode: () => "@react_buoy_time_machine_bar_reload_mode";
+        /** Source ids switched OFF in the Sources strip (JSON string array). */
+        readonly disabledSources: () => "@react_buoy_time_machine_disabled_sources";
     };
     /**
      * Scenarios storage keys. The library (saved + draft scenarios) and the

package/lib/typescript/module/storage/devToolsStorageKeys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devToolsStorageKeys.d.ts","sourceRoot":"","sources":["../../../../src/storage/devToolsStorageKeys.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;OAEG;;IAGH;;OAEG;;;;;;;IASH;;OAEG;;;;;;;;IAUH;;;;;;;;;;OAUG;8BACc,MAAM;;QAInB,kEAAkE;;;QAGlE,iCAAiC;sBACnB,MAAM;;IAIxB;;OAEG;;;;;;QAQD,kDAAkD;;QAElD,gCAAgC;;QAGhC,gCAAgC;;;IAKlC;;OAEG;;;QAGD,mCAAmC;;QAEnC,qEAAqE;;;IAIvE;;OAEG;;;;;IAOH;;OAEG;;;;;;;IAQH;;OAEG;;;;;;;IASH;;OAEG;;;;;;;;;;;;;;IAuBH;;;;OAIG;;;;;IAOH;;;;;OAKG;;;;;;;IAQH;;OAEG;;;;;;;;;;;IAiBH;;OAEG;;;;;;;;;;QAcD;;;WAGG;;QAEH;;;;;WAKG;;;IAIL;;OAEG;;;;;;;;;;IAgBH;;OAEG;;;;;;;QAUD,2BAA2B;;;IAK7B;;OAEG;;;;;;;;;IAcH;;OAEG;;;QAGD,8DAA8D;;;IAKhE;;OAEG;;;QAGD;;;;;;;;WAQG;;QAEH,oCAAoC;;QAGpC,wCAAwC;;QAGxC;;;;;WAKG;;QAEH,2BAA2B;;;IAK7B;;OAEG;;;QAGD;;;;WAIG;;;CAGG,CAAC;AAwBX;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CA0BzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAE9D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,EAAE,CAsBpD"}
+{"version":3,"file":"devToolsStorageKeys.d.ts","sourceRoot":"","sources":["../../../../src/storage/devToolsStorageKeys.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;OAEG;;IAGH;;OAEG;;;;;;;IASH;;OAEG;;;;;;;;IAUH;;;;;;;;;;OAUG;8BACc,MAAM;;QAInB,kEAAkE;;;QAGlE,iCAAiC;sBACnB,MAAM;;IAIxB;;OAEG;;;;;;QAQD,kDAAkD;;QAElD,gCAAgC;;QAGhC,gCAAgC;;;IAKlC;;OAEG;;;QAGD,mCAAmC;;QAEnC,qEAAqE;;;IAIvE;;OAEG;;;;;IAOH;;OAEG;;;;;;;IAQH;;OAEG;;;;;;;IASH;;OAEG;;;;;;;;;;;;;;IAuBH;;;;OAIG;;;;QAKD,gFAAgF;;QAGhF,mFAAmF;;QAGnF,wEAAwE;;;IAK1E;;;;;OAKG;;;;;;;IAQH;;OAEG;;;;;;;;;;;IAiBH;;OAEG;;;;;;;;;;QAcD;;;WAGG;;QAEH;;;;;WAKG;;;IAIL;;OAEG;;;;;;;;;;IAgBH;;OAEG;;;;;;;QAUD,2BAA2B;;;IAK7B;;OAEG;;;;;;;;;IAcH;;OAEG;;;QAGD,8DAA8D;;;IAKhE;;OAEG;;;QAGD;;;;;;;;WAQG;;QAEH,oCAAoC;;QAGpC,wCAAwC;;QAGxC;;;;;WAKG;;QAEH,2BAA2B;;;IAK7B;;OAEG;;;QAGD;;;;WAIG;;;CAGG,CAAC;AAwBX;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CA0BzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAE9D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,EAAE,CAsBpD"}

package/lib/typescript/module/stores/BaseEventStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseEventStore.d.ts","sourceRoot":"","sources":["../../../../src/stores/BaseEventStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AAE/D;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,8BAAsB,cAAc,CAAC,MAAM,CAAE,SAAQ,YAAY,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACtF,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,CAAM;IAChC,SAAS,CAAC,cAAc,EAAE,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAa;IACjE,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,cAAc,CAA8B;gBAExC,OAAO,EAAE,qBAAqB;IAU1C;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEzD;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,IAAI,IAAI;IAExC;;OAEG;IACH,QAAQ,CAAC,WAAW,IAAI,OAAO;IAM/B;;;OAGG;IACH,SAAS,CAAC,WAAW,IAAI,IAAI;IAO7B;;;OAGG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAW/B;;OAEG;IACH,SAAS,CAAC,uBAAuB,IAAI,MAAM;IAI3C;;;;;;OAMG;IACH,iBAAiB,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,IAAI;IA8B9D;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,IAAI;IASpD;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAWvC;;OAEG;IACH,SAAS,CAAC,oBAAoB,IAAI,IAAI;IAWtC;;OAEG;IACH,SAAS,IAAI,MAAM,EAAE;IAIrB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,WAAW,IAAI,IAAI;IAYnB;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAWzC;;;;;OAKG;IACH,cAAc,IAAI,IAAI;IAOtB;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAKrC;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAgBlB;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAY/B;;OAEG;IACH,mBAAmB,IAAI;QACrB,cAAc,EAAE,MAAM,CAAC;QACvB,cAAc,EAAE,MAAM,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC;KACf;CAOF"}
+{"version":3,"file":"BaseEventStore.d.ts","sourceRoot":"","sources":["../../../../src/stores/BaseEventStore.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AAE/D;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,8BAAsB,cAAc,CAAC,MAAM,CAAE,SAAQ,YAAY,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACtF,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,CAAM;IAChC,SAAS,CAAC,cAAc,EAAE,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAa;IACjE,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,cAAc,CAA8B;gBAExC,OAAO,EAAE,qBAAqB;IAwB1C;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEzD;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,IAAI,IAAI;IAExC;;OAEG;IACH,QAAQ,CAAC,WAAW,IAAI,OAAO;IAM/B;;;OAGG;IACH,SAAS,CAAC,WAAW,IAAI,IAAI;IAO7B;;;OAGG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAW/B;;OAEG;IACH,SAAS,CAAC,uBAAuB,IAAI,MAAM;IAI3C;;;;;;OAMG;IACH,iBAAiB,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,IAAI;IA8B9D;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,IAAI;IASpD;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAYvC;;OAEG;IACH,SAAS,CAAC,oBAAoB,IAAI,IAAI;IAWtC;;OAEG;IACH,SAAS,IAAI,MAAM,EAAE;IAIrB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,WAAW,IAAI,IAAI;IAYnB;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAWzC;;;;;OAKG;IACH,cAAc,IAAI,IAAI;IAOtB;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAKrC;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAgBlB;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAY/B;;OAEG;IACH,mBAAmB,IAAI;QACrB,cAAc,EAAE,MAAM,CAAC;QACvB,cAAc,EAAE,MAAM,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC;KACf;CAOF"}

package/lib/typescript/module/stores/createToolStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createToolStore.d.ts","sourceRoot":"","sources":["../../../../src/stores/createToolStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC;AAE3C,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,SAAS,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B;qEACiE;IACjE,EAAE,EAAE,MAAM,CAAC;IACX,yBAAyB;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC5B,oFAAoF;IACpF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,6EAA6E;IAC7E,SAAS,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAAC;IACnD,yDAAyD;IACzD,WAAW,IAAI,CAAC,EAAE,CAAC;IACnB,uBAAuB;IACvB,IAAI,IAAI,MAAM,CAAC;IACf,uFAAuF;IACvF,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,iFAAiF;IACjF,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC;IACrB,gFAAgF;IAChF,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC;IACtC,iEAAiE;IACjE,KAAK,IAAI,IAAI,CAAC;IACd,sFAAsF;IACtF,OAAO,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAAC;IACjD,2EAA2E;IAC3E,MAAM,IAAI,IAAI,CAAC;IACf;;;;OAIG;IACH,SAAS,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,4EAA4E;IAC5E,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,QAAQ,IAAI,OAAO,CAAC;IACpB,oEAAoE;IACpE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,IAAI,MAAM,CAAC;IACjB,oDAAoD;IACpD,OAAO,IAAI,MAAM,CAAC;IAClB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mDAAmD;IACnD,aAAa,IAAI,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAYD,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAC,CAAC,CAAC,CA6J1E"}
+{"version":3,"file":"createToolStore.d.ts","sourceRoot":"","sources":["../../../../src/stores/createToolStore.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC;AAE3C,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,SAAS,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B;qEACiE;IACjE,EAAE,EAAE,MAAM,CAAC;IACX,yBAAyB;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC5B,oFAAoF;IACpF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,6EAA6E;IAC7E,SAAS,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAAC;IACnD,yDAAyD;IACzD,WAAW,IAAI,CAAC,EAAE,CAAC;IACnB,uBAAuB;IACvB,IAAI,IAAI,MAAM,CAAC;IACf,uFAAuF;IACvF,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,iFAAiF;IACjF,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC;IACrB,gFAAgF;IAChF,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC;IACtC,iEAAiE;IACjE,KAAK,IAAI,IAAI,CAAC;IACd,sFAAsF;IACtF,OAAO,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAAC;IACjD,2EAA2E;IAC3E,MAAM,IAAI,IAAI,CAAC;IACf;;;;OAIG;IACH,SAAS,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,4EAA4E;IAC5E,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,QAAQ,IAAI,OAAO,CAAC;IACpB,oEAAoE;IACpE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,IAAI,MAAM,CAAC;IACjB,oDAAoD;IACpD,OAAO,IAAI,MAAM,CAAC;IAClB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mDAAmD;IACnD,aAAa,IAAI,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAYD,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAC,CAAC,CAAC,CA8K1E"}

package/lib/typescript/module/stores/floatingToolStore.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from "react";
+export interface FloatingToolRenderContext {
+    id: string;
+    /** Changes when an existing tool is opened again, so its grip can restore it. */
+    revealToken: number;
+    dismiss(): void;
+}
+export interface FloatingToolRegistration {
+    /** Unique across the app; also use this id on FloatingTool for isolated position storage. */
+    id: string;
+    render(context: FloatingToolRenderContext): ReactNode;
+}
+export interface FloatingToolEntry extends FloatingToolRegistration {
+    revealToken: number;
+}
+export declare const getFloatingTools: () => readonly FloatingToolEntry[];
+export declare const subscribeFloatingTools: (listener: () => void) => () => void;
+/** Open or restore one tool. Mount FloatingToolHost once at the application root. */
+export declare function openFloatingTool(tool: FloatingToolRegistration): void;
+/** Removes the UI only. Tool actions such as Stop belong to the tool's own controller. */
+export declare function dismissFloatingTool(id: string): void;
+/** Register at app startup to restore an open tool using its existing position storage. */
+export declare function registerPersistentFloatingTool(tool: FloatingToolRegistration, storage: {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<unknown>;
+}): () => void;
+//# sourceMappingURL=floatingToolStore.d.ts.map

package/lib/typescript/module/stores/floatingToolStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floatingToolStore.d.ts","sourceRoot":"","sources":["../../../../src/stores/floatingToolStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,IAAI,IAAI,CAAC;CACjB;AACD,MAAM,WAAW,wBAAwB;IACvC,6FAA6F;IAC7F,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,OAAO,EAAE,yBAAyB,GAAG,SAAS,CAAC;CACvD;AACD,MAAM,WAAW,iBAAkB,SAAQ,wBAAwB;IAAG,WAAW,EAAE,MAAM,CAAA;CAAE;AAK3F,eAAO,MAAM,gBAAgB,oCAAgB,CAAC;AAC9C,eAAO,MAAM,sBAAsB,GAAI,UAAU,MAAM,IAAI,eAA+E,CAAC;AAE3I,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,wBAAwB,GAAG,IAAI,CAOrE;AAED,0FAA0F;AAC1F,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAIpD;AAED,2FAA2F;AAC3F,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,wBAAwB,EAC9B,OAAO,EAAE;IAAE,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAAC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,GAC/G,MAAM,IAAI,CAqBZ"}

package/lib/typescript/module/stores/floatingToolStore.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=floatingToolStore.test.d.ts.map

package/lib/typescript/module/stores/floatingToolStore.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floatingToolStore.test.d.ts","sourceRoot":"","sources":["../../../../src/stores/floatingToolStore.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,35 @@
+/**
+ * The field that identifies items in this list, or undefined if there isn't one.
+ *
+ * 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.
+ */
+export declare function identityField(items: unknown[]): string | undefined;
+/**
+ * Let a caller address list items by their own id instead of resending the list.
+ *
+ *   { lines: { "seed-1": { qty: 5 } } }   change one field of one item
+ *   { lines: { "seed-2": null } }         remove that item
+ *   { lines: { "new-1": { …all fields… } } }  append (id not already present)
+ *
+ * WHY THIS EXISTS. Resending the whole array is correct only when the caller has
+ * SEEN the whole array, and reads are capped — so on a long list the honest
+ * agents refuse and the careless ones send back only the items they were shown,
+ * silently destroying the rest. Measured: with a 20-item bag truncated to 5, the
+ * whole-array form scored 0/9 across three models and one of them deleted 15
+ * lines without a word. Addressed edits scored 9/9. (`pnpm ai:array`.)
+ *
+ * It also makes mass deletion impossible BY OMISSION: `lines: []` empties a bag,
+ * but a keyed edit can only remove ids it names.
+ *
+ * Returns the patch with keyed objects expanded into real arrays, so everything
+ * downstream — the typed-edit guard, the receipt, the store write — is unchanged
+ * and keeps all of its protections.
+ */
+export declare function expandKeyedArrays(current: unknown, patch: unknown, path?: string, notes?: string[]): {
+    patch: unknown;
+    notes: string[];
+    error?: string;
+};
+//# sourceMappingURL=keyedArrays.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyedArrays.d.ts","sourceRoot":"","sources":["../../../../src/sync/keyedArrays.ts"],"names":[],"mappings":"AAwBA;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,GAAG,SAAS,CAYlE;AA6CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,OAAO,EACd,IAAI,SAAK,EACT,KAAK,GAAE,MAAM,EAAO,GACnB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAyDrD"}

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

@@ -1,38 +1,8 @@
-/**
- * toolActionRegistry — the on-device twin of the broker's action dispatch.
- *
- * Buoy already has exactly one place where `{toolId, action, params}` becomes a
- * real call into a tool: `handleAction` in external-sync, fed by the adapter
- * map that `autoExternalSync` assembles. That map was private to the React
- * tree, so anything running ON the device (the Scenarios runner) had no way to
- * reach it and would have had to duplicate the map — two dispatch paths that
- * drift the first time an adapter changes.
- *
- * This module publishes the SAME map through a global seam, so a scenario step,
- * a desktop click and an MCP call are one code path with two entry points.
- *
- * WHY A GLOBAL, NOT AN IMPORT: the map is built inside a component (the
- * react-query adapter is a hook, the env adapter is a factory closed over a
- * prop, and custom tools arrive as props), so it cannot be a module constant.
- * Meanwhile the consumer must not import `@buoy-gg/core` — that package imports
- * the tools, and a tool importing it back is the require cycle that puts a
- * LogBox on every reload. Same reasoning, and the same shape, as
- * `crashFlush.ts` in external-sync.
- *
- * WE STORE A GETTER, NOT A SNAPSHOT, for the reason `attachDeviceSync` does:
- * the adapter map is re-created on renders that change its inputs, and a stale
- * captured copy would keep dispatching into adapters the tree has replaced.
- *
- * SAFETY: this registry is populated only while `AutoExternalSync` is mounted,
- * which is itself gated (dev, or release + an explicit opt-in + a real Pro
- * license). It is deliberately NOT a substitute for a caller's own production
- * gate — anything that bends app state through it must check `__DEV__` itself,
- * because the actions reachable here (network overrides, storage writes,
- * impersonation) have no business running in a shipped app.
- */
 /** The duck-typed adapter shape, matching external-sync's `ToolSyncAdapter`. */
 export interface RegisteredToolAdapter {
     version?: number;
+    /** Internal teardown of resources this adapter owns. Never exposed as an action. */
+    dispose?: (cleanup: (toolId: string, action: string, params?: unknown) => Promise<unknown>) => void | Promise<void>;
     getSnapshot?: () => unknown;
     subscribe?: (onChange: () => void) => () => void;
     actions?: Record<string, (params: unknown) => unknown | Promise<unknown>>;
@@ -82,4 +52,6 @@ export declare function dispatchToolAction(toolId: string, action: string, param
  * caller can say "Buoy tools are still starting up" instead of "unknown tool".
  */
 export declare function waitForToolRegistry(timeoutMs?: number): Promise<boolean>;
+/** Guard retained references too, and discard results completed after revocation. */
+export declare function guardToolAdapter<T extends RegisteredToolAdapter>(adapter: T): T;
 //# sourceMappingURL=toolActionRegistry.d.ts.map

package/lib/typescript/module/sync/toolActionRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolActionRegistry.d.ts","sourceRoot":"","sources":["../../../../src/sync/toolActionRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAIH,gFAAgF;AAChF,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC;IAC5B,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;CAC3E;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;AAenE;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,cAAc,GAC7B,MAAM,IAAI,CAMZ;AAED,uDAAuD;AACvD,wBAAgB,eAAe,IAAI,cAAc,CAUhD;AAED,uCAAuC;AACvC,wBAAgB,WAAW,IAAI,MAAM,EAAE,CAEtC;AAED,kFAAkF;AAClF,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAM1D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAI9C;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQvE;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,CAAC,CAYlB;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,SAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ5E"}
+{"version":3,"file":"toolActionRegistry.d.ts","sourceRoot":"","sources":["../../../../src/sync/toolActionRegistry.ts"],"names":[],"mappings":"AAoCA,gFAAgF;AAChF,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpH,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC;IAC5B,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;CAC3E;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;AAenE;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,cAAc,GAC7B,MAAM,IAAI,CAkCZ;AAED,uDAAuD;AACvD,wBAAgB,eAAe,IAAI,cAAc,CAWhD;AAED,uCAAuC;AACvC,wBAAgB,WAAW,IAAI,MAAM,EAAE,CAEtC;AAED,kFAAkF;AAClF,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAM1D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAI9C;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CASvE;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,CAAC,CAalB;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,SAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ5E;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,qBAAqB,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAgC/E"}

package/lib/typescript/module/sync/toolAttention.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=toolAttention.test.d.ts.map

package/lib/typescript/module/sync/toolAttention.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolAttention.test.d.ts","sourceRoot":"","sources":["../../../../src/sync/toolAttention.test.ts"],"names":[],"mappings":""}

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

@@ -36,4 +36,29 @@ export declare function registerToolOpener(opener: ToolOpener): () => void;
 export declare function openBuoyTool(toolId: string): boolean;
 /** True when some host is listening — for deciding whether to offer the button. */
 export declare function canOpenBuoyTools(): boolean;
+/**
+ * "This tool needs you" — shown as a badge on its chip in the minimized rail.
+ *
+ * The case: Ask Buoy is minimized so a tester can watch the app, and the
+ * agent hits a step that needs a tap. Nobody can see the card. The sheet used
+ * to fail safe by DECLINING the change and ending the turn — which made
+ * minimize mean "stop", the opposite of what it is for. Now the approval
+ * holds, the chip gets a badge, and tapping the chip (the existing restore
+ * path) brings the card back. Same seam shape as the opener above: the rail
+ * lives inside the host, the tool cannot import the host, so it publishes
+ * through a global.
+ *
+ * `done` and `failed` cover the other thing a hidden tool cannot say — that
+ * the work you minimized it to wait for has finished.
+ */
+export type ToolAttention = {
+    kind: "needsInput" | "done" | "failed";
+    /** Read by screen readers and shown as the chip's accessibility label. */
+    label: string;
+};
+/** Set, replace or (with null) clear a tool's badge. No-op when nothing changed. */
+export declare function setToolAttention(toolId: string, next: ToolAttention | null): void;
+export declare function getToolAttention(toolId: string): ToolAttention | null;
+/** For `useSyncExternalStore` in the rail. */
+export declare function subscribeToolAttention(fn: () => void): () => void;
 //# sourceMappingURL=toolUiBridge.d.ts.map

package/lib/typescript/module/sync/toolUiBridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolUiBridge.d.ts","sourceRoot":"","sources":["../../../../src/sync/toolUiBridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;AAUrD,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,IAAI,CAMjE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CASpD;AAED,mFAAmF;AACnF,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C"}
+{"version":3,"file":"toolUiBridge.d.ts","sourceRoot":"","sources":["../../../../src/sync/toolUiBridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;AAUrD,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,IAAI,CAMjE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CASpD;AAED,mFAAmF;AACnF,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAID;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,YAAY,GAAG,MAAM,GAAG,QAAQ,CAAC;IACvC,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAcF,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAajF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAErE;AAED,8CAA8C;AAC9C,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAMjE"}

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

@@ -0,0 +1,70 @@
+/**
+ * The typed-edit guard — ONE implementation, for every surface that takes a
+ * merge patch from a remote caller.
+ *
+ * The rule, which is the React Query devtools value-editor rule: you may change
+ * the VALUE of a field that already exists, to the same kind of thing. You may
+ * not add a field, change a field's type, or null a list or object the screen
+ * renders. A list may grow or shrink — carts are lists you add to — but every
+ * item in it must have the same fields as the items already there, because an
+ * item missing a field the others have is what crashes the list on render.
+ *
+ * WHY IT LIVES HERE. This existed twice, once in the zustand adapter and once in
+ * react-query, drifting slightly (one said "the ones already in the list", the
+ * other "the items"; only one had the did-you-mean hint). Jotai had NO copy at
+ * all, so `setAtom` accepted a string over a number or a one-item array over a
+ * fifty-item one with nothing to stop it. Three copies of a data-destroying
+ * safety rule is two more than anyone can keep in step — the same argument
+ * `keyedArrays.ts` makes about the expansion it owns.
+ *
+ * The one behavioural knob is `noun`: what to call the thing being edited in a
+ * refusal ("this store", "this data", "this atom"). Everything else is shared,
+ * deliberately — a rule that differs per surface is a rule nobody can state.
+ */
+/** The shape category the screen depends on: array vs object vs the rest. */
+export declare function shapeKind(v: unknown): string;
+export interface EditViolation {
+    path: string;
+    kind: "add-key" | "type-change" | "missing-key";
+    detail: string;
+    /** For an `add-key`: where a field of that name DOES live, if anywhere. */
+    movedTo?: string;
+}
+/**
+ * Where a key actually lives in a nested value, as a dotted path — first match,
+ * breadth-first, capped so a huge payload cannot stall the walk.
+ *
+ * This is what turns "you put `name` at the top" into "`name` lives at
+ * `item.name`", which is the difference between a caller that gives up and one
+ * that fixes it. Ten of eleven measured `query` write failures were this exact
+ * mistake.
+ */
+export declare function findKeyPath(obj: unknown, key: string, maxNodes?: number): string | undefined;
+export interface TypedEditOptions {
+    /** What a refusal calls the thing being edited: "store", "data", "atom". */
+    noun?: string;
+}
+/**
+ * Every way this patch would break the value it is merged into. Empty means the
+ * edit is safe to apply.
+ */
+export declare function typedEditViolations(current: unknown, patch: unknown, opts?: TypedEditOptions, root?: unknown, path?: string, out?: EditViolation[]): EditViolation[];
+/**
+ * The patch the caller should have sent, when every problem was a field written
+ * at the wrong DEPTH.
+ *
+ * The guard already worked out where each field really lives in order to say
+ * "did you mean `item.name`?", so it can rebuild the patch instead of leaving
+ * the caller to re-derive it from prose. Returns undefined unless EVERY
+ * violation is a relocatable add-key: a partial suggestion that silently drops
+ * the parts we could not fix would be worse than none, because the caller would
+ * send it, be refused again, and learn nothing.
+ */
+export declare function suggestedPatch(patch: unknown, violations: EditViolation[]): Record<string, unknown> | undefined;
+/**
+ * The sentence a refusal ends with. Shared so every surface refuses in the same
+ * words — a caller that learns the rule on one tool should recognise it on the
+ * next.
+ */
+export declare function refusalText(violations: EditViolation[], noun: string, suggestion?: Record<string, unknown>): string;
+//# sourceMappingURL=typedEdit.d.ts.map

package/lib/typescript/module/sync/typedEdit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedEdit.d.ts","sourceRoot":"","sources":["../../../../src/sync/typedEdit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAK5C;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,GAAG,aAAa,GAAG,aAAa,CAAC;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAID;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,SAAO,GAAG,MAAM,GAAG,SAAS,CAiB1F;AAED,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,OAAO,EACd,IAAI,GAAE,gBAAqB,EAC3B,IAAI,GAAE,OAAiB,EACvB,IAAI,SAAK,EACT,GAAG,GAAE,aAAa,EAAO,GACxB,aAAa,EAAE,CA6EjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAoB/G;AAWD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAanH"}