@buoy-gg/shared-ui 7.0.35 → 7.0.38

package/lib/typescript/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/stores/floatingToolStore.test.d.ts

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

package/lib/typescript/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/sync/toolAttention.test.d.ts

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

package/lib/typescript/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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"}

package/lib/typescript/commonjs/sync/valuePath.d.ts

@@ -0,0 +1,52 @@
+export type PathSegment = {
+    kind: "key";
+    key: string;
+} | {
+    kind: "index";
+    index: number;
+}
+/**
+ * `[field=value]`. `field` may itself be dotted — `[stat.name=hp]` — because
+ * that is what models actually write when the thing identifying a row is
+ * nested inside it, and a list of `{stat: {name}, base_stat}` is an ordinary
+ * shape. Measured: grok reached for `stats[stat.name=hp].base_stat`
+ * unprompted on `edit-on-screen/edit-nested-field`.
+ */
+ | {
+    kind: "match";
+    field: string;
+    value: string;
+};
+/**
+ * `lines[0].addonIds`, `item.name`, `results[name=pikachu].url` → segments.
+ *
+ * Returns undefined for syntax it does not understand rather than doing
+ * something approximate with it.
+ */
+export declare function parsePath(path: string): PathSegment[] | undefined;
+/** Read the value at `path`, or undefined if any step of it does not exist. */
+export declare function readPath(value: unknown, path: string): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Build the merge patch that sets `path` to `value`, against the data as it is
+ * now.
+ *
+ * The result is an ordinary merge patch, so it goes through the SAME typed-edit
+ * guard as a hand-written one and gains no new powers — `path` is a way to say
+ * the same thing without being able to get the depth wrong, not a way around
+ * the rules. A list step becomes the id-addressed form, so the write stays
+ * proof against a truncated read.
+ */
+export declare function patchFromPath(current: unknown, path: string, value: unknown): {
+    ok: true;
+    patch: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+//# sourceMappingURL=valuePath.d.ts.map

package/lib/typescript/commonjs/sync/valuePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valuePath.d.ts","sourceRoot":"","sources":["../../../../src/sync/valuePath.ts"],"names":[],"mappings":"AA6BA,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AAClC;;;;;;GAMG;GACD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAuDpD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,GAAG,SAAS,CAgCjE;AAED,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAiClH;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,GACb;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CA8F7E"}

package/lib/typescript/commonjs/sync/valueShape.d.ts

@@ -0,0 +1,77 @@
+/**
+ * A compact type sketch of a runtime value — one implementation, shared by every
+ * adapter that hands data to a model.
+ *
+ * WHY. A model cannot write a well-formed item into a list it has never seen the
+ * shape of, and we were not showing it. Measured on `cart/bag-still-zustand`: the
+ * rendered prompt is 83,000 characters and the words `lineId`, `itemId`,
+ * `sizeId`, `addonIds` and `unitPrice` appear in it ZERO times. Every model
+ * "failing" that case invented a line shape because inventing was the only move
+ * available. The zustand typed-edit guard would have caught the invention — but
+ * only on a list that already holds an item, since it builds its template from
+ * `list[0]`. On an EMPTY list there is no template, the guard has nothing to
+ * compare against, and the invented shape is written silently.
+ *
+ * So the sketch has two jobs, and the second is the one that pays:
+ *
+ *   1. Say what the items in a list look like, so an addition can match.
+ *   2. Say when NOTHING knows — an empty list's item shape is not merely
+ *      unread, it is unknowable from runtime state, and the honest answer is to
+ *      admit that rather than let a guess through unremarked.
+ *
+ * It is deliberately tiny. A sketch of a 120-line bag is the same size as a
+ * sketch of a 2-line one, so unlike the data it survives the engine's 24,000-
+ * character result cap — which is the whole point, because the cases where the
+ * model most needs the shape are exactly the ones where the data got cut off.
+ */
+/**
+ * `{lineId: string, qty: number, addonIds: string[]}` — a one-line type for a
+ * value, built from the value itself.
+ *
+ * An array is described by its FIRST item, because a list whose items disagree
+ * is a list nothing can safely add to and the guard will say so anyway. An empty
+ * array is `unknown[]`, which is the true answer and the one that matters: it
+ * tells a reader that adding to this list is unchecked.
+ */
+export declare function shapeOf(value: unknown, depth?: number): string;
+export interface ListShape {
+    /** Dotted path from the value's root: `lines`, `user.addresses`. */
+    path: string;
+    /** How many items are in it right now. */
+    length: number;
+    /** The item type, or undefined when the list is empty and nothing can know it. */
+    item?: string;
+}
+/**
+ * Every list inside a value, with the shape of what goes in it.
+ *
+ * This is what a caller needs before adding to a list, and it is the part that
+ * cannot be recovered from a truncated read of the data itself.
+ *
+ * A list with `item: undefined` is the warning case: it is empty, so its item
+ * shape exists nowhere in the running app — not in the store, not in the
+ * persisted copy, not in this sketch. Anything added to it goes in unchecked.
+ */
+export declare function listShapes(value: unknown, path?: string, out?: ListShape[], depth?: number, budget?: {
+    visited: number;
+}): ListShape[];
+/** True when a sketch stopped early, so a caller can say so rather than imply completeness. */
+export declare function shapesWereTruncated(value: unknown): boolean;
+/**
+ * The lists in a value that a caller could add to WITHOUT any way to know the
+ * item shape. Empty by definition on a healthy value; non-empty means a write
+ * into one of these paths cannot be checked by anything.
+ */
+export declare function unshapedLists(value: unknown): string[];
+/**
+ * The sketch an adapter attaches to a read: the value's own type, plus the item
+ * type of every list in it.
+ *
+ * Returns undefined when there is nothing worth saying (a scalar, or an object
+ * holding no lists) so adapters can spread it and add no noise.
+ */
+export declare function shapeSummary(value: unknown): {
+    shape: string;
+    lists?: ListShape[];
+} | undefined;
+//# sourceMappingURL=valueShape.d.ts.map

package/lib/typescript/commonjs/sync/valueShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueShape.d.ts","sourceRoot":"","sources":["../../../../src/sync/valueShape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAkBH;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,MAAM,CAkBzD;AAED,MAAM,WAAW,SAAS;IACxB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,EACd,IAAI,SAAK,EACT,GAAG,GAAE,SAAS,EAAO,EACrB,KAAK,SAAI,EACT,MAAM,GAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAmB,GAC3C,SAAS,EAAE,CAwBb;AAED,+FAA+F;AAC/F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAI3D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAItD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAA;CAAE,GAAG,SAAS,CAM/F"}

package/lib/typescript/commonjs/ui/backgrounds/ToolBackground.d.ts

@@ -14,7 +14,7 @@
  * selection (`backgroundStore`), so switching it in one tool switches it in all
  * of them.
  */
-import type { BackgroundId } from "./types";
+import type { BackgroundFocus, BackgroundId } from "./types";
 export interface ToolBackgroundProps {
     /**
      * Force a specific preset instead of following the shared selection. The
@@ -25,6 +25,12 @@ export interface ToolBackgroundProps {
     motion?: boolean;
     /** Multiplied into the whole layer's opacity — dial it down per tool. */
     opacity?: number;
+    /**
+     * Pin the preset's point of interest (Wormhole's eye) to a spot on this
+     * surface, as fractions of its size. The dial passes the centre so the eye
+     * sits under the hub; tools omit it and get the preset's own framing.
+     */
+    focus?: BackgroundFocus;
 }
 export declare const ToolBackground: import("react").NamedExoticComponent<ToolBackgroundProps>;
 //# sourceMappingURL=ToolBackground.d.ts.map

package/lib/typescript/commonjs/ui/backgrounds/ToolBackground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolBackground.d.ts","sourceRoot":"","sources":["../../../../../src/ui/backgrounds/ToolBackground.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAU5C,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB,yDAAyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,cAAc,2DAgCzB,CAAC"}
+{"version":3,"file":"ToolBackground.d.ts","sourceRoot":"","sources":["../../../../../src/ui/backgrounds/ToolBackground.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAU7D,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB,yDAAyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB;AAED,eAAO,MAAM,cAAc,2DAiCzB,CAAC"}