@reekon-tools/boldr-utils 1.13.0 → 1.13.2

package/dist/annotation/canvas/AnnotationCanvasInner.native.js

@@ -121,7 +121,11 @@ export const AnnotationCanvasInner = (props) => {
     const zoom = useSharedValue(state.viewport.zoom);
     const panX = useSharedValue(state.viewport.pan.x);
     const panY = useSharedValue(state.viewport.pan.y);
-    const pinchStartZoom = useSharedValue(state.viewport.zoom);
+    // Set by the viewport gestures' onChange, consumed by their onFinalize: the
+    // post-gesture sync to React state happens iff a gesture actually moved the
+    // viewport, and in onFinalize rather than onEnd because on Android the
+    // viewport gestures routinely exit through fail()/cancel() (see the pan).
+    const viewportDirty = useSharedValue(false);
     // Skia consumes this directly and re-renders the transform on the UI thread.
     const worldTransform = useDerivedValue(() => {
         'worklet';
@@ -748,8 +752,17 @@ export const AnnotationCanvasInner = (props) => {
             world: stateRef.current.ctx.viewport.screenToWorld(screen),
         });
         // Commit the final viewport to the JS snapshot once a gesture ends, so
-        // tools' screenToWorld/worldToScreen reflect the new pan/zoom.
+        // tools' screenToWorld/worldToScreen reflect the new pan/zoom. Skips the
+        // no-op commit: the pan and the pinch can finalize on the same lift, and
+        // the second sync would re-render (and re-settle any background layer)
+        // for values React already has.
         const syncViewport = (next) => {
+            const current = stateRef.current.ctx.viewport.state;
+            if (current.zoom === next.zoom &&
+                current.pan.x === next.pan.x &&
+                current.pan.y === next.pan.y) {
+                return;
+            }
             stateRef.current.setViewport(next);
         };
         const beginViewportGesture = () => {
@@ -873,9 +886,17 @@ export const AnnotationCanvasInner = (props) => {
         // Viewport pan — runs on the UI thread (no runOnJS), mutating the shared
         // viewport directly. Mirrors viewport.ts `panBy`. Used for both the
         // two-finger pan (always available) and the one-finger Hand tool.
+        //
+        // averageTouches(true) is load-bearing on Android: PanGestureHandler
+        // defaults to tracking the LAST-LANDED pointer, not the centroid (iOS
+        // always averages). Running simultaneously with the pinch, a non-averaged
+        // two-finger pan translates the canvas by finger 2's whole travel — during
+        // a spread that is half the spread distance of sideways drift, which reads
+        // as "the zoom runs away from where I aimed".
         const buildViewportPan = (minP, maxP) => Gesture.Pan()
             .minPointers(minP)
             .maxPointers(maxP)
+            .averageTouches(true)
             .onBegin(() => {
             'worklet';
             runOnJS(beginViewportGesture)();
@@ -884,47 +905,91 @@ export const AnnotationCanvasInner = (props) => {
             'worklet';
             panX.value -= e.changeX / zoom.value;
             panY.value -= e.changeY / zoom.value;
+            viewportDirty.value = true;
         })
-            .onEnd(() => {
-            'worklet';
-            runOnJS(syncViewport)({
-                zoom: zoom.value,
-                pan: { x: panX.value, y: panY.value },
-            });
-        })
+            // onFinalize, not onEnd: on Android this pan normally exits through
+            // fail() — a (2,2) pan the moment the first finger lifts (pointer
+            // count below minPointers), and a pure two-finger translate whose
+            // pinch never activated at the final lift. onEnd never runs on those
+            // paths, and the movement would never reach React state: hit-tests go
+            // stale, a background layer never re-rasterizes for the new view, and
+            // the next JS-side viewport write snaps the canvas back.
             .onFinalize(() => {
             'worklet';
+            if (viewportDirty.value) {
+                viewportDirty.value = false;
+                runOnJS(syncViewport)({
+                    zoom: zoom.value,
+                    pan: { x: panX.value, y: panY.value },
+                });
+            }
             runOnJS(endViewportGesture)();
         });
-        const viewportPan = buildViewportPan(2, 2);
+        // With the Hand tool the viewport pan spans one AND two fingers as a
+        // single gesture. Two separate gestures (a one-finger pan racing the
+        // two-finger pair) cannot express a staggered pinch: finger 1 panning
+        // past the slop resolves the Race before finger 2 lands, the pinch is
+        // cancelled with it, and finger 2's touch then kills the one-finger pan
+        // too (pointer count over maxPointers cancels an active Android pan) —
+        // a dead canvas until every finger lifts. One pan spanning both counts
+        // stays active across 1→2→1, and its translation is continuous across
+        // pointer transitions (the handler rebases its origin on every
+        // POINTER_DOWN/UP).
+        const viewportPan = buildViewportPan(panViewport ? 1 : 2, 2);
         // Pinch-to-zoom about the focal point — UI thread. Mirrors viewport.ts
         // `zoomAt`: keep the world point under the focal screen point fixed.
+        //
+        // Driven by the per-event ratio (`scaleChange`), not by cumulative
+        // `e.scale` against a zoom snapshotted in onBegin. On Android onBegin
+        // fires at the FIRST finger down — before a pinch provably exists — so a
+        // snapshot there can go stale against anything else driving the shared
+        // values (the glide animation, the simultaneous pan). The native
+        // cumulative scale also freezes rather than rebases across pointer-set
+        // changes (2→1→2, a third finger) and sticks at 0 for the rest of the
+        // gesture if the fingers ever collapse to a single point, so only ratios
+        // between consecutive events are trustworthy. The live focal needs no
+        // snapshot either: a focal that merely moves leaves this update a no-op
+        // (translation is the pan's job), which is also what makes Android's
+        // wrong-focal BEGAN event (it reports the first finger's touch-down
+        // position, not a centroid) harmless here.
         const pinch = Gesture.Pinch()
             .onBegin(() => {
             'worklet';
-            pinchStartZoom.value = zoom.value;
             runOnJS(beginViewportGesture)();
         })
-            .onUpdate((e) => {
+            .onChange((e) => {
             'worklet';
-            const clamped = Math.min(50, Math.max(0.05, pinchStartZoom.value * e.scale));
+            // Drop corrupt ratios instead of applying them: a native span
+            // collapse yields scale 0, and the ratio of the frame after that is
+            // 0/0. Applying either would slam the zoom to a bound (or NaN it).
+            const ratio = e.scaleChange;
+            if (!Number.isFinite(ratio) || ratio <= 0)
+                return;
+            const next = Math.min(50, Math.max(0.05, zoom.value * ratio));
+            if (next === zoom.value)
+                return; // clamped at a bound, or ratio 1
             // World point currently under the focal screen point (using the live
             // zoom/pan), then re-anchor pan so it stays put at the new zoom.
             const focalWorldX = e.focalX / zoom.value + panX.value;
             const focalWorldY = e.focalY / zoom.value + panY.value;
-            panX.value = focalWorldX - e.focalX / clamped;
-            panY.value = focalWorldY - e.focalY / clamped;
-            zoom.value = clamped;
-        })
-            .onEnd(() => {
-            'worklet';
-            runOnJS(syncViewport)({
-                zoom: zoom.value,
-                pan: { x: panX.value, y: panY.value },
-            });
+            panX.value = focalWorldX - e.focalX / next;
+            panY.value = focalWorldY - e.focalY / next;
+            zoom.value = next;
+            viewportDirty.value = true;
         })
+            // onFinalize, not onEnd, for the same reason as the pan: an Android
+            // pinch that never activated fails at the final lift, and a cancelled
+            // gesture never reaches onEnd — the dirty check keeps the no-gesture
+            // paths from committing anything.
             .onFinalize(() => {
             'worklet';
+            if (viewportDirty.value) {
+                viewportDirty.value = false;
+                runOnJS(syncViewport)({
+                    zoom: zoom.value,
+                    pan: { x: panX.value, y: panY.value },
+                });
+            }
             runOnJS(endViewportGesture)();
         });
         // Freehand drawing (pen/marker/highlighter) — one finger, UI thread.
@@ -1425,7 +1490,8 @@ export const AnnotationCanvasInner = (props) => {
         // One finger, by active tool:
         //  - freehand (pen/marker/highlighter) → draw on the UI thread
         //  - shape tools (line/rect/…) → rubber-band on the UI thread
-        //  - Hand → pan the viewport on the UI thread (live, no JS round-trip)
+        //  - Hand → no separate gesture: viewportPan above already spans one
+        //    finger (min 1), so panning and pinching stay one uncancelled stream
         //  - select → drag the hit element on the UI thread
         //  - everything else → dispatch pointer events on the JS thread
         const oneFinger = freehand
@@ -1433,18 +1499,18 @@ export const AnnotationCanvasInner = (props) => {
             : shapeDraw
                 ? buildShapeDrawPan(shapeDraw)
                 : panViewport
-                    ? buildViewportPan(1, 1)
+                    ? null
                     : dragSelection
                         ? buildSelectDragPan(dragSelection)
                         : toolPan;
         // Long-press only joins the race when the active tool acts on it, so it
         // never pre-empts a one-finger drag/draw on tools that ignore holds.
-        return Gesture.Race(tap, ...(longPressEnabled ? [longPress] : []), Gesture.Simultaneous(viewportPan, pinch), oneFinger);
+        return Gesture.Race(tap, ...(longPressEnabled ? [longPress] : []), Gesture.Simultaneous(viewportPan, pinch), ...(oneFinger ? [oneFinger] : []));
     }, [
         zoom,
         panX,
         panY,
-        pinchStartZoom,
+        viewportDirty,
         livePoints,
         handoffStrokes,
         removeHandoffStrokes,

package/dist/calculator/schema.d.ts

@@ -195,6 +195,12 @@ export interface CalculatorDefinition {
     /** Public calculators are readable by everyone; rules/query key. */
     isPublic: boolean;
     sharedUserIds?: string[];
+    /**
+     * Orgs this calculator is shared with. Written only by the backend
+     * shareCalculatorWithOrg / unshareCalculatorWithOrg callables, which also
+     * maintain the organizations/{orgId}/sharedCalculators pointer docs clients
+     * use for discovery (rules can't authorize an array-contains query here).
+     */
     sharedOrgIds?: string[];
     createdBy?: {
         userId: string;

package/dist/theme/index.d.ts

@@ -0,0 +1,3 @@
+export * from './colors.js';
+export * from './semantic.js';
+export * from './preset.js';

package/dist/theme/index.js

@@ -0,0 +1,3 @@
+export * from './colors.js';
+export * from './semantic.js';
+export * from './preset.js';

package/dist/theme/preset.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Shared Tailwind preset. COLORS ONLY, by design.
+ *
+ * Must never define `content`, `plugins`, `presets`, or `darkMode`:
+ * NativeWind recurses `config.presets[].presets` hunting for its own marker
+ * preset, and a `content` key here would silently narrow the consuming app's
+ * globs.
+ *
+ * Consumed from CJS Tailwind configs, so this is a NAMED export with no
+ * default — that keeps ESM/CJS interop semantics irrelevant:
+ *
+ *   const { boldrPreset } = require('@reekon-tools/boldr-utils/theme/preset');
+ *   module.exports = { presets: [require('nativewind/preset'), boldrPreset] };
+ *
+ * Tailwind loads configs through jiti + sucrase, so requiring this ESM file
+ * from a CJS config works regardless of Node version.
+ *
+ * Note that Tailwind merges `theme.extend` per key with the *app* winning, and
+ * replaces a color key wholesale rather than deep-merging. An app that keeps
+ * its own `colors.background` will silently shadow this preset.
+ */
+export declare const boldrPreset: {
+    theme: {
+        extend: {
+            colors: {
+                background: "#1D1F21";
+                foreground: {
+                    DEFAULT: "#FFFFFF";
+                    disabled: "#626364";
+                };
+                card: {
+                    DEFAULT: "#2B2C2E";
+                    foreground: "#FFFFFF";
+                };
+                popover: {
+                    DEFAULT: "#2B2C2E";
+                    foreground: "#FFFFFF";
+                };
+                muted: {
+                    DEFAULT: "#424345";
+                    foreground: "#9FA0A2";
+                };
+                accent: {
+                    DEFAULT: "#424345";
+                    foreground: "#FFFFFF";
+                };
+                secondary: {
+                    DEFAULT: "#424345";
+                    foreground: "#FFFFFF";
+                };
+                border: {
+                    DEFAULT: "#424345";
+                    strong: "#626364";
+                };
+                input: "#424345";
+                ring: "#FFAD00";
+                primary: {
+                    DEFAULT: "#FFAD00";
+                    foreground: "#1D1F21";
+                };
+                destructive: {
+                    DEFAULT: "#DF6358";
+                    foreground: "#1D1F21";
+                };
+                elevated: {
+                    DEFAULT: "#424345";
+                    foreground: "#FFFFFF";
+                };
+                interactive: {
+                    DEFAULT: "#0066FF";
+                    foreground: "#FFFFFF";
+                };
+                nav: {
+                    DEFAULT: "#2D3843";
+                    foreground: "#FFFFFF";
+                };
+                paper: {
+                    DEFAULT: "#E8EAED";
+                    foreground: "#1D1F21";
+                    field: "#FFFFFF";
+                    line: "#BCBEC2";
+                    muted: "#626364";
+                };
+                tile: {
+                    foreground: "#FFFFFF";
+                    measurement: {
+                        DEFAULT: "#0066FF";
+                        badge: "#50A6FF";
+                    };
+                    formula: {
+                        DEFAULT: "#BD30A8";
+                        badge: "#6C155F";
+                    };
+                    count: {
+                        DEFAULT: "#02274B";
+                        foreground: "#FFFFFF";
+                    };
+                };
+                diagram: {
+                    1: "#2E4C6A";
+                    2: "#4B6074";
+                    3: "#67819A";
+                };
+                tolerance: {
+                    in: {
+                        DEFAULT: "#58A942";
+                        warning: "#00E920";
+                        muted: "#8BB380";
+                    };
+                    out: {
+                        DEFAULT: "#E83D2F";
+                        warning: "#DA1100";
+                        muted: "#DF6358";
+                    };
+                };
+            };
+        };
+    };
+};
+export type BoldrPreset = typeof boldrPreset;

package/dist/theme/preset.js

@@ -0,0 +1,25 @@
+import { boldrColors } from './semantic.js';
+/**
+ * Shared Tailwind preset. COLORS ONLY, by design.
+ *
+ * Must never define `content`, `plugins`, `presets`, or `darkMode`:
+ * NativeWind recurses `config.presets[].presets` hunting for its own marker
+ * preset, and a `content` key here would silently narrow the consuming app's
+ * globs.
+ *
+ * Consumed from CJS Tailwind configs, so this is a NAMED export with no
+ * default — that keeps ESM/CJS interop semantics irrelevant:
+ *
+ *   const { boldrPreset } = require('@reekon-tools/boldr-utils/theme/preset');
+ *   module.exports = { presets: [require('nativewind/preset'), boldrPreset] };
+ *
+ * Tailwind loads configs through jiti + sucrase, so requiring this ESM file
+ * from a CJS config works regardless of Node version.
+ *
+ * Note that Tailwind merges `theme.extend` per key with the *app* winning, and
+ * replaces a color key wholesale rather than deep-merging. An app that keeps
+ * its own `colors.background` will silently shadow this preset.
+ */
+export const boldrPreset = {
+    theme: { extend: { colors: boldrColors } },
+};

package/dist/theme/semantic.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Structural shape of a Tailwind `theme.extend.colors` tree.
+ *
+ * Declared locally on purpose: annotating with tailwindcss's own `Config` type
+ * would put `import type { Config } from 'tailwindcss'` into the emitted .d.ts
+ * and make tailwindcss a hard type dependency of this package.
+ */
+export type ColorTree = {
+    [key: string]: string | ColorTree;
+};
+/**
+ * Semantic design tokens — the layer apps actually consume.
+ *
+ * `colors.ts` is the palette (raw Figma variables, named by value).
+ * This file maps those values onto *roles*, and is the only color surface the
+ * apps should reference. The raw palette is deliberately NOT exposed as Tailwind
+ * classes; naming by value is how both apps accumulated hundreds of arbitrary
+ * hex classes in the first place.
+ *
+ * The shadcn/ui token names (background, card, popover, foreground, muted,
+ * accent, secondary, border, input, ring, primary, destructive) are reused
+ * rather than paralleled, so every shadcn component is re-skinned without any
+ * component edits and `shadcn add` keeps generating markup that lands on these
+ * tokens.
+ *
+ * The design is dark-only. The light calculator / form surfaces are the
+ * explicitly-named `paper.*` tokens, not a light/dark variant pair — on native
+ * NativeWind's `dark:` variant is global, and portal-rendered surfaces
+ * (bottom sheets, dialogs, selects) mount outside any scoped subtree, so a
+ * scoped override would leak dark chrome onto a light page.
+ */
+export declare const boldrColors: {
+    background: "#1D1F21";
+    foreground: {
+        DEFAULT: "#FFFFFF";
+        disabled: "#626364";
+    };
+    card: {
+        DEFAULT: "#2B2C2E";
+        foreground: "#FFFFFF";
+    };
+    popover: {
+        DEFAULT: "#2B2C2E";
+        foreground: "#FFFFFF";
+    };
+    muted: {
+        DEFAULT: "#424345";
+        foreground: "#9FA0A2";
+    };
+    accent: {
+        DEFAULT: "#424345";
+        foreground: "#FFFFFF";
+    };
+    secondary: {
+        DEFAULT: "#424345";
+        foreground: "#FFFFFF";
+    };
+    border: {
+        DEFAULT: "#424345";
+        strong: "#626364";
+    };
+    input: "#424345";
+    ring: "#FFAD00";
+    primary: {
+        DEFAULT: "#FFAD00";
+        foreground: "#1D1F21";
+    };
+    destructive: {
+        DEFAULT: "#DF6358";
+        foreground: "#1D1F21";
+    };
+    /** Chips, inset controls, thumbnail placeholders. */
+    elevated: {
+        DEFAULT: "#424345";
+        foreground: "#FFFFFF";
+    };
+    /**
+     * Steppers and other interactive fills. FILL ONLY — #0066FF as text on
+     * #2B2C2E is 2.89:1. Never `text-interactive`.
+     */
+    interactive: {
+        DEFAULT: "#0066FF";
+        foreground: "#FFFFFF";
+    };
+    /** Nav chrome (the web app's sidebar). */
+    nav: {
+        DEFAULT: "#2D3843";
+        foreground: "#FFFFFF";
+    };
+    paper: {
+        DEFAULT: "#E8EAED";
+        foreground: "#1D1F21";
+        field: "#FFFFFF";
+        line: "#BCBEC2";
+        muted: "#626364";
+    };
+    tile: {
+        /**
+         * Ink for any tile fill — `text-tile-foreground`. Shared across the
+         * measurement and formula variants because both carry white type; keeping it
+         * at the family level avoids two identical `foreground` keys that could
+         * drift apart by accident.
+         */
+        foreground: "#FFFFFF";
+        measurement: {
+            DEFAULT: "#0066FF";
+            badge: "#50A6FF";
+        };
+        formula: {
+            DEFAULT: "#BD30A8";
+            badge: "#6C155F";
+        };
+        count: {
+            DEFAULT: "#02274B";
+            foreground: "#FFFFFF";
+        };
+    };
+    diagram: {
+        1: "#2E4C6A";
+        2: "#4B6074";
+        3: "#67819A";
+    };
+    tolerance: {
+        in: {
+            DEFAULT: "#58A942";
+            warning: "#00E920";
+            muted: "#8BB380";
+        };
+        out: {
+            DEFAULT: "#E83D2F";
+            warning: "#DA1100";
+            muted: "#DF6358";
+        };
+    };
+};
+export type BoldrColors = typeof boldrColors;

package/dist/theme/semantic.js

@@ -0,0 +1,116 @@
+import { GeneralColors, SecondaryColors, FormColors, TileColors, FormulaColors, YellowColors, RedColors, GreenColors, } from './colors.js';
+/**
+ * Semantic design tokens — the layer apps actually consume.
+ *
+ * `colors.ts` is the palette (raw Figma variables, named by value).
+ * This file maps those values onto *roles*, and is the only color surface the
+ * apps should reference. The raw palette is deliberately NOT exposed as Tailwind
+ * classes; naming by value is how both apps accumulated hundreds of arbitrary
+ * hex classes in the first place.
+ *
+ * The shadcn/ui token names (background, card, popover, foreground, muted,
+ * accent, secondary, border, input, ring, primary, destructive) are reused
+ * rather than paralleled, so every shadcn component is re-skinned without any
+ * component edits and `shadcn add` keeps generating markup that lands on these
+ * tokens.
+ *
+ * The design is dark-only. The light calculator / form surfaces are the
+ * explicitly-named `paper.*` tokens, not a light/dark variant pair — on native
+ * NativeWind's `dark:` variant is global, and portal-rendered surfaces
+ * (bottom sheets, dialogs, selects) mount outside any scoped subtree, so a
+ * scoped override would leak dark chrome onto a light page.
+ */
+export const boldrColors = {
+    // ── dark app chrome — shadcn-compatible names, re-pointed ────────────────
+    background: GeneralColors.darkGrey, // screen + header
+    foreground: {
+        DEFAULT: GeneralColors.white,
+        disabled: GeneralColors.grey3, // text-foreground-disabled
+    },
+    card: { DEFAULT: GeneralColors.grey1, foreground: GeneralColors.white },
+    popover: { DEFAULT: GeneralColors.grey1, foreground: GeneralColors.white },
+    // muted / accent / secondary exist so unmodified shadcn components look
+    // right. Prefer `elevated` in new boldr components — it gives future
+    // divergence a seam.
+    muted: { DEFAULT: GeneralColors.grey2, foreground: GeneralColors.grey4 },
+    accent: { DEFAULT: GeneralColors.grey2, foreground: GeneralColors.white },
+    secondary: { DEFAULT: GeneralColors.grey2, foreground: GeneralColors.white },
+    border: { DEFAULT: GeneralColors.grey2, strong: GeneralColors.grey3 },
+    input: GeneralColors.grey2,
+    ring: YellowColors.mainYellow,
+    primary: {
+        DEFAULT: YellowColors.mainYellow,
+        // White on #FFAD00 is 1.87:1. Dark ink is 8.84:1, and matches the mockups.
+        foreground: GeneralColors.darkGrey,
+    },
+    destructive: {
+        DEFAULT: RedColors.mutedRed,
+        // Confirmed against the Settings frame: the Log Out label is dark ink.
+        // White on #DF6358 would be 3.46:1; #1D1F21 is 4.77:1.
+        foreground: GeneralColors.darkGrey,
+    },
+    // ── boldr additions the shadcn vocabulary has no word for ───────────────
+    /** Chips, inset controls, thumbnail placeholders. */
+    elevated: { DEFAULT: GeneralColors.grey2, foreground: GeneralColors.white },
+    /**
+     * Steppers and other interactive fills. FILL ONLY — #0066FF as text on
+     * #2B2C2E is 2.89:1. Never `text-interactive`.
+     */
+    interactive: {
+        DEFAULT: TileColors.activeBlue,
+        foreground: GeneralColors.white,
+    },
+    /** Nav chrome (the web app's sidebar). */
+    nav: {
+        DEFAULT: SecondaryColors.accentBlue1,
+        foreground: GeneralColors.white,
+    },
+    // ── light "paper": the calculator page and form fields ──────────────────
+    paper: {
+        DEFAULT: FormColors.lightGrey2, // bg-paper            page / canvas
+        foreground: GeneralColors.darkGrey, // text-paper-foreground
+        field: GeneralColors.white, // bg-paper-field      inputs, cards on paper
+        line: FormColors.lightGrey1, // border-paper-line   field borders, dividers
+        // grey3, not lightGrey1: #BCBEC2 on #E8EAED is 1.54:1 — invisible.
+        // lightGrey1 is a border color only, which is why it's `paper.line`.
+        muted: GeneralColors.grey3, // text-paper-muted
+    },
+    // ── product tiles ───────────────────────────────────────────────────────
+    tile: {
+        /**
+         * Ink for any tile fill — `text-tile-foreground`. Shared across the
+         * measurement and formula variants because both carry white type; keeping it
+         * at the family level avoids two identical `foreground` keys that could
+         * drift apart by accident.
+         */
+        foreground: GeneralColors.white,
+        measurement: {
+            DEFAULT: TileColors.activeBlue,
+            badge: TileColors.lightBlue1,
+        },
+        // Note the badge is DARKER than the tile here, inverting the old app-local
+        // values. Confirmed in the mockups: a magenta tile with a darker magenta
+        // label bar.
+        formula: { DEFAULT: FormulaColors.purple, badge: FormulaColors.darkPurple },
+        count: { DEFAULT: TileColors.darkBlue, foreground: GeneralColors.white },
+    },
+    // ── 3D / diagram depth ramp (ordered; the steps have no individual meaning) ─
+    diagram: {
+        1: SecondaryColors.accentBlue2,
+        2: SecondaryColors.accentBlue3,
+        3: SecondaryColors.accentBlue4,
+    },
+    // ── measurement tolerance ───────────────────────────────────────────────
+    tolerance: {
+        in: {
+            DEFAULT: GreenColors.green,
+            warning: GreenColors.warningGreen,
+            muted: GreenColors.mutedGreen,
+        },
+        out: {
+            DEFAULT: RedColors.red,
+            warning: RedColors.warningRed,
+            muted: RedColors.mutedRed,
+        },
+    },
+};

package/dist/types/firestore.d.ts

@@ -93,6 +93,7 @@ export interface Template extends Timestamps {
     orgName: string;
     parentFolderId?: string | null;
     formulas?: Formula[];
+    sharedOrgIds?: string[];
 }
 export interface SelectedTemplate extends FirestoreDoc {
     count: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",

package/dist/canvas/AnnotationCanvas.d.ts

@@ -1,11 +0,0 @@
-import { type ReactNode } from 'react';
-import type { AnnotationCanvasInnerProps } from './AnnotationCanvasInner.js';
-export type { AnnotationCanvasHandle, GestureConfig, PanTrigger, } from './AnnotationCanvasInner.js';
-export interface CanvasKitOpts {
-    locateFile?: (file: string) => string;
-}
-export type AnnotationCanvasProps = AnnotationCanvasInnerProps & {
-    fallback?: ReactNode;
-    canvasKitOpts?: CanvasKitOpts;
-};
-export declare const AnnotationCanvas: ({ fallback, canvasKitOpts, ...rest }: AnnotationCanvasProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvas.js

@@ -1,10 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { WithSkiaWeb } from '@shopify/react-native-skia/lib/module/web/index.js';
-// Web-only entry point: lazy-loads CanvasKit wasm via WithSkiaWeb. Imperative
-// API (undo/redo/zoom) is exposed through the `imperativeRef` prop rather
-// than React refs, since WithSkiaWeb can't forward refs through its lazy
-// component boundary. The native build sits in `AnnotationCanvas.native.tsx`
-// and skips WithSkiaWeb entirely (no wasm to load).
-export const AnnotationCanvas = ({ fallback, canvasKitOpts, ...rest }) => (_jsx(WithSkiaWeb, { getComponent: () => import('./AnnotationCanvasInner.js').then((m) => ({
-        default: m.AnnotationCanvasInner,
-    })), fallback: fallback ?? null, componentProps: rest, opts: canvasKitOpts }));

package/dist/canvas/AnnotationCanvas.native.d.ts

@@ -1,8 +0,0 @@
-import type { AnnotationCanvasInnerProps } from './AnnotationCanvasInner.native.js';
-export type { AnnotationCanvasHandle, } from './useAnnotationCanvasState.js';
-export type { GestureConfig, PanTrigger, } from './AnnotationCanvasInner.js';
-export type AnnotationCanvasProps = AnnotationCanvasInnerProps & {
-    fallback?: unknown;
-    canvasKitOpts?: unknown;
-};
-export declare const AnnotationCanvas: (props: AnnotationCanvasProps) => import("react/jsx-runtime").JSX.Element;