@ai-matrx/kit 0.5.0

package/dist/latest-request.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/latest-request.ts"],"sourcesContent":["\"use client\";\n\n/**\n * useLatestRequest — makes a superseded async response impossible to apply.\n *\n * THE BUG THIS KILLS: a surface refetches whenever some input changes (a\n * `?app=` scope, a search box, a selected id). Two fetches are then in flight\n * at once, and **responses do not arrive in the order they were sent.** The\n * older one lands last, calls `setRows`, and wins — so the table shows app A's\n * runs while the banner, the URL, and every label already say app B.\n *\n * That is not stale data, which announces itself. It is the WRONG RECORD under\n * a CONFIDENT label — the same failure `StaleDataNotice` exists to prevent on\n * the error path, arriving through the success path instead. Clearing rows when\n * a fetch FAILS (which this repo already does) closes only half the hole: a\n * fetch that succeeds late is just as capable of mislabeling the screen, and\n * nothing about it looks wrong.\n *\n * `AbortController` is the other half of the answer and a good thing to add on\n * top — but it is not a substitute. An abort races the response; the request may\n * already have resolved, and a non-`fetch` data source (a Supabase client call,\n * an RPC wrapper) often has no signal to give. This guard is source-agnostic and\n * final: it decides at APPLY time, which is the only moment that matters.\n *\n * ```ts\n * const beginRequest = useLatestRequest();\n *\n * const load = useCallback(async () => {\n *   const isCurrent = beginRequest();   // claim this attempt\n *   setLoading(true);\n *   try {\n *     const data = await fetchScopedRows(appId);\n *     if (!isCurrent()) return;         // a newer load already started\n *     setRows(data);\n *   } catch (err) {\n *     if (!isCurrent()) return;         // don't let an old failure blank new rows\n *     setRows([]);\n *     setLoadFailed(true);\n *   } finally {\n *     if (isCurrent()) setLoading(false);\n *   }\n * }, [appId, beginRequest]);\n * ```\n *\n * **Guard the catch and the finally too, not just the success path.** A stale\n * REJECTION is the mirror-image bug: it wipes the rows the current request just\n * loaded and raises a \"couldn't load\" notice about a request nobody is waiting\n * for. And an early `setLoading(false)` from a superseded attempt reports the\n * surface as settled while the real one is still in flight.\n *\n * `begin()` returns the predicate rather than exposing a counter, so there is no\n * sequence number to compare wrongly and no way to ask \"is my request current?\"\n * without first having declared one.\n *\n * Three hand-rolled copies of this exact `requestSeq`/`reqIdRef` pattern predate\n * it — `useServerAgentSearch`, `useRagSearch`, `useContextPreview`. They are\n * correct; they are just the evidence that this is a class, not an incident. New\n * code uses this hook, and those three collapse onto it when next touched.\n */\n\nimport { useCallback, useRef } from \"react\";\n\n/**\n * Marks a new attempt as the current one and returns a predicate reporting\n * whether it still is. Call it once at the top of the async function, then\n * check the predicate before EVERY state write that follows an `await`.\n */\nexport type BeginRequest = () => () => boolean;\n\n/**\n * 🚨 RETURNS THE FUNCTION ITSELF, NOT AN OBJECT WRAPPING IT — deliberately, and\n * this is the whole reason the signature looks like that.\n *\n * The first version returned `{ begin }`. That object literal is a NEW\n * reference on every render, and the entire point of this hook is to be named\n * in the dependency array of the very `useCallback` that performs the fetch. An\n * unstable dependency there makes `load` unstable, which makes the\n * `useEffect(…, [load])` that calls it re-run on every render — an unbroken\n * refetch loop against the database with no user input at all. A guard against\n * a fetch race that instead causes infinite fetches is worse than the bug it\n * was written to fix, and it is a High-severity defect that shipped.\n *\n * Returning the `useCallback`-stable function directly removes the hazard by\n * construction: there is no object whose identity a caller could depend on. If\n * this ever needs to return more than one thing, it must be wrapped in\n * `useMemo` — never a bare literal. (Do not lean on the React Compiler to\n * memoize it for you: a primitive has to be correct on its own terms, and\n * correctness here is the difference between one fetch and unbounded ones.)\n */\nexport function useLatestRequest(): BeginRequest {\n  const seqRef = useRef(0);\n\n  return useCallback(() => {\n    const mySeq = ++seqRef.current;\n    return () => mySeq === seqRef.current;\n  }, []);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA4DA,mBAAoC;AA6B7B,SAAS,mBAAiC;AAC/C,QAAM,aAAS,qBAAO,CAAC;AAEvB,aAAO,0BAAY,MAAM;AACvB,UAAM,QAAQ,EAAE,OAAO;AACvB,WAAO,MAAM,UAAU,OAAO;AAAA,EAChC,GAAG,CAAC,CAAC;AACP;","names":[]}

package/dist/latest-request.d.cts

@@ -0,0 +1,29 @@
+/**
+ * Marks a new attempt as the current one and returns a predicate reporting
+ * whether it still is. Call it once at the top of the async function, then
+ * check the predicate before EVERY state write that follows an `await`.
+ */
+type BeginRequest = () => () => boolean;
+/**
+ * 🚨 RETURNS THE FUNCTION ITSELF, NOT AN OBJECT WRAPPING IT — deliberately, and
+ * this is the whole reason the signature looks like that.
+ *
+ * The first version returned `{ begin }`. That object literal is a NEW
+ * reference on every render, and the entire point of this hook is to be named
+ * in the dependency array of the very `useCallback` that performs the fetch. An
+ * unstable dependency there makes `load` unstable, which makes the
+ * `useEffect(…, [load])` that calls it re-run on every render — an unbroken
+ * refetch loop against the database with no user input at all. A guard against
+ * a fetch race that instead causes infinite fetches is worse than the bug it
+ * was written to fix, and it is a High-severity defect that shipped.
+ *
+ * Returning the `useCallback`-stable function directly removes the hazard by
+ * construction: there is no object whose identity a caller could depend on. If
+ * this ever needs to return more than one thing, it must be wrapped in
+ * `useMemo` — never a bare literal. (Do not lean on the React Compiler to
+ * memoize it for you: a primitive has to be correct on its own terms, and
+ * correctness here is the difference between one fetch and unbounded ones.)
+ */
+declare function useLatestRequest(): BeginRequest;
+
+export { type BeginRequest, useLatestRequest };

package/dist/latest-request.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Marks a new attempt as the current one and returns a predicate reporting
+ * whether it still is. Call it once at the top of the async function, then
+ * check the predicate before EVERY state write that follows an `await`.
+ */
+type BeginRequest = () => () => boolean;
+/**
+ * 🚨 RETURNS THE FUNCTION ITSELF, NOT AN OBJECT WRAPPING IT — deliberately, and
+ * this is the whole reason the signature looks like that.
+ *
+ * The first version returned `{ begin }`. That object literal is a NEW
+ * reference on every render, and the entire point of this hook is to be named
+ * in the dependency array of the very `useCallback` that performs the fetch. An
+ * unstable dependency there makes `load` unstable, which makes the
+ * `useEffect(…, [load])` that calls it re-run on every render — an unbroken
+ * refetch loop against the database with no user input at all. A guard against
+ * a fetch race that instead causes infinite fetches is worse than the bug it
+ * was written to fix, and it is a High-severity defect that shipped.
+ *
+ * Returning the `useCallback`-stable function directly removes the hazard by
+ * construction: there is no object whose identity a caller could depend on. If
+ * this ever needs to return more than one thing, it must be wrapped in
+ * `useMemo` — never a bare literal. (Do not lean on the React Compiler to
+ * memoize it for you: a primitive has to be correct on its own terms, and
+ * correctness here is the difference between one fetch and unbounded ones.)
+ */
+declare function useLatestRequest(): BeginRequest;
+
+export { type BeginRequest, useLatestRequest };

package/dist/latest-request.js

@@ -0,0 +1,16 @@
+"use client";
+"use client";
+
+// src/latest-request.ts
+import { useCallback, useRef } from "react";
+function useLatestRequest() {
+  const seqRef = useRef(0);
+  return useCallback(() => {
+    const mySeq = ++seqRef.current;
+    return () => mySeq === seqRef.current;
+  }, []);
+}
+export {
+  useLatestRequest
+};
+//# sourceMappingURL=latest-request.js.map

package/dist/latest-request.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/latest-request.ts"],"sourcesContent":["\"use client\";\n\n/**\n * useLatestRequest — makes a superseded async response impossible to apply.\n *\n * THE BUG THIS KILLS: a surface refetches whenever some input changes (a\n * `?app=` scope, a search box, a selected id). Two fetches are then in flight\n * at once, and **responses do not arrive in the order they were sent.** The\n * older one lands last, calls `setRows`, and wins — so the table shows app A's\n * runs while the banner, the URL, and every label already say app B.\n *\n * That is not stale data, which announces itself. It is the WRONG RECORD under\n * a CONFIDENT label — the same failure `StaleDataNotice` exists to prevent on\n * the error path, arriving through the success path instead. Clearing rows when\n * a fetch FAILS (which this repo already does) closes only half the hole: a\n * fetch that succeeds late is just as capable of mislabeling the screen, and\n * nothing about it looks wrong.\n *\n * `AbortController` is the other half of the answer and a good thing to add on\n * top — but it is not a substitute. An abort races the response; the request may\n * already have resolved, and a non-`fetch` data source (a Supabase client call,\n * an RPC wrapper) often has no signal to give. This guard is source-agnostic and\n * final: it decides at APPLY time, which is the only moment that matters.\n *\n * ```ts\n * const beginRequest = useLatestRequest();\n *\n * const load = useCallback(async () => {\n *   const isCurrent = beginRequest();   // claim this attempt\n *   setLoading(true);\n *   try {\n *     const data = await fetchScopedRows(appId);\n *     if (!isCurrent()) return;         // a newer load already started\n *     setRows(data);\n *   } catch (err) {\n *     if (!isCurrent()) return;         // don't let an old failure blank new rows\n *     setRows([]);\n *     setLoadFailed(true);\n *   } finally {\n *     if (isCurrent()) setLoading(false);\n *   }\n * }, [appId, beginRequest]);\n * ```\n *\n * **Guard the catch and the finally too, not just the success path.** A stale\n * REJECTION is the mirror-image bug: it wipes the rows the current request just\n * loaded and raises a \"couldn't load\" notice about a request nobody is waiting\n * for. And an early `setLoading(false)` from a superseded attempt reports the\n * surface as settled while the real one is still in flight.\n *\n * `begin()` returns the predicate rather than exposing a counter, so there is no\n * sequence number to compare wrongly and no way to ask \"is my request current?\"\n * without first having declared one.\n *\n * Three hand-rolled copies of this exact `requestSeq`/`reqIdRef` pattern predate\n * it — `useServerAgentSearch`, `useRagSearch`, `useContextPreview`. They are\n * correct; they are just the evidence that this is a class, not an incident. New\n * code uses this hook, and those three collapse onto it when next touched.\n */\n\nimport { useCallback, useRef } from \"react\";\n\n/**\n * Marks a new attempt as the current one and returns a predicate reporting\n * whether it still is. Call it once at the top of the async function, then\n * check the predicate before EVERY state write that follows an `await`.\n */\nexport type BeginRequest = () => () => boolean;\n\n/**\n * 🚨 RETURNS THE FUNCTION ITSELF, NOT AN OBJECT WRAPPING IT — deliberately, and\n * this is the whole reason the signature looks like that.\n *\n * The first version returned `{ begin }`. That object literal is a NEW\n * reference on every render, and the entire point of this hook is to be named\n * in the dependency array of the very `useCallback` that performs the fetch. An\n * unstable dependency there makes `load` unstable, which makes the\n * `useEffect(…, [load])` that calls it re-run on every render — an unbroken\n * refetch loop against the database with no user input at all. A guard against\n * a fetch race that instead causes infinite fetches is worse than the bug it\n * was written to fix, and it is a High-severity defect that shipped.\n *\n * Returning the `useCallback`-stable function directly removes the hazard by\n * construction: there is no object whose identity a caller could depend on. If\n * this ever needs to return more than one thing, it must be wrapped in\n * `useMemo` — never a bare literal. (Do not lean on the React Compiler to\n * memoize it for you: a primitive has to be correct on its own terms, and\n * correctness here is the difference between one fetch and unbounded ones.)\n */\nexport function useLatestRequest(): BeginRequest {\n  const seqRef = useRef(0);\n\n  return useCallback(() => {\n    const mySeq = ++seqRef.current;\n    return () => mySeq === seqRef.current;\n  }, []);\n}\n"],"mappings":";;;;AA4DA,SAAS,aAAa,cAAc;AA6B7B,SAAS,mBAAiC;AAC/C,QAAM,SAAS,OAAO,CAAC;AAEvB,SAAO,YAAY,MAAM;AACvB,UAAM,QAAQ,EAAE,OAAO;AACvB,WAAO,MAAM,UAAU,OAAO;AAAA,EAChC,GAAG,CAAC,CAAC;AACP;","names":[]}

package/dist/qr.cjs

@@ -0,0 +1,109 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/qr.ts
+var qr_exports = {};
+__export(qr_exports, {
+  decodeQrFromElement: () => decodeQrFromElement,
+  decodeQrFromImageData: () => decodeQrFromImageData,
+  decodeQrFromImageFile: () => decodeQrFromImageFile,
+  hasNativeQrDetector: () => hasNativeQrDetector
+});
+module.exports = __toCommonJS(qr_exports);
+var MAX_EDGE = 1600;
+function nativeDetector() {
+  const ctor = globalThis.BarcodeDetector;
+  return typeof ctor === "function" ? ctor : null;
+}
+function hasNativeQrDetector() {
+  return nativeDetector() !== null;
+}
+async function decodeNative(source) {
+  const Ctor = nativeDetector();
+  if (!Ctor) return null;
+  try {
+    const detector = new Ctor({ formats: ["qr_code"] });
+    const results = await detector.detect(source);
+    const value = results.find((r) => r.rawValue)?.rawValue;
+    return value ? value : null;
+  } catch {
+    return null;
+  }
+}
+async function decodeWithJsQr(frame) {
+  const { default: jsQR } = await import("jsqr");
+  const both = jsQR(frame.data, frame.width, frame.height, {
+    inversionAttempts: "attemptBoth"
+  });
+  return both?.data ? both.data : null;
+}
+function toImageData(source, width, height) {
+  if (!width || !height) return null;
+  const scale = Math.min(1, MAX_EDGE / Math.max(width, height));
+  const w = Math.max(1, Math.round(width * scale));
+  const h = Math.max(1, Math.round(height * scale));
+  const canvas = document.createElement("canvas");
+  canvas.width = w;
+  canvas.height = h;
+  const ctx = canvas.getContext("2d", { willReadFrequently: true });
+  if (!ctx) return null;
+  ctx.drawImage(source, 0, 0, w, h);
+  return ctx.getImageData(0, 0, w, h);
+}
+async function decodeQrFromImageData(frame) {
+  return await decodeWithJsQr(frame) ?? null;
+}
+async function decodeQrFromElement(element) {
+  const width = element instanceof HTMLVideoElement ? element.videoWidth : element.width;
+  const height = element instanceof HTMLVideoElement ? element.videoHeight : element.height;
+  if (!width || !height) return null;
+  const native = await decodeNative(element);
+  if (native) return native;
+  const frame = toImageData(element, width, height);
+  return frame ? decodeQrFromImageData(frame) : null;
+}
+async function decodeQrFromImageFile(file) {
+  const direct = await decodeNative(file);
+  if (direct) return direct;
+  let bitmap = null;
+  try {
+    bitmap = await createImageBitmap(file);
+  } catch {
+    throw new Error("That file could not be read as an image.");
+  }
+  try {
+    const viaBitmap = await decodeNative(bitmap);
+    if (viaBitmap) return viaBitmap;
+    const frame = toImageData(bitmap, bitmap.width, bitmap.height);
+    return frame ? decodeQrFromImageData(frame) : null;
+  } finally {
+    bitmap.close();
+  }
+}
+//# sourceMappingURL=qr.cjs.map

package/dist/qr.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/qr.ts"],"sourcesContent":["/**\n * @ai-matrx/kit/qr — THE QR-code decoder (client-side, in memory). Ported\n * verbatim from matrx-frontend `lib/qr/decode.ts`.\n *\n * One primitive, three inputs (a File/Blob, an `ImageData` frame, a\n * `<video>`/`<canvas>` element), one answer: the text the QR encodes, or\n * `null` when no code is present. Nothing here uploads, stores, or persists\n * anything — the bytes live in a canvas for the length of one call.\n *\n * Engine order:\n *   1. `BarcodeDetector` — native, fast, handles rotation and poor contrast.\n *   2. `jsqr` — pure-JS fallback (lazily imported, so it only enters the\n *      bundle of a surface that actually decodes), for Safari/Firefox where\n *      the native detector does not exist.\n *\n * Runtime dependency of this subpath (and only when the fallback fires):\n * `jsqr` — a browser without `BarcodeDetector` decoding a pasted screenshot\n * IS the capability, not an optional extra; without the fallback the unit\n * silently does nothing on Safari/Firefox.\n *\n * Browser capability: decoding needs a DOM (`document`, canvas 2D,\n * `createImageBitmap`) at call time; importing is inert and SSR-safe, and\n * `hasNativeQrDetector()` is safe to call anywhere (it only probes\n * `globalThis`).\n *\n * 🚨 Reach for THIS, never a second decoder. If a surface needs a new input\n * shape, add an adapter here.\n */\n\n/** Longest edge we rasterise to. Big enough for a phone screenshot of a QR,\n *  small enough that a 48MP photo cannot stall the main thread. */\nconst MAX_EDGE = 1600;\n\ntype NativeBarcodeDetector = {\n  detect: (source: CanvasImageSource | ImageBitmap | Blob) => Promise<{ rawValue: string }[]>;\n};\n\ntype BarcodeDetectorCtor = {\n  new (options?: { formats?: string[] }): NativeBarcodeDetector;\n  getSupportedFormats?: () => Promise<string[]>;\n};\n\nfunction nativeDetector(): BarcodeDetectorCtor | null {\n  const ctor = (globalThis as { BarcodeDetector?: BarcodeDetectorCtor })\n    .BarcodeDetector;\n  return typeof ctor === \"function\" ? ctor : null;\n}\n\n/** True when the browser can decode without downloading the JS fallback. */\nexport function hasNativeQrDetector(): boolean {\n  return nativeDetector() !== null;\n}\n\nasync function decodeNative(\n  source: CanvasImageSource | ImageBitmap | Blob,\n): Promise<string | null> {\n  const Ctor = nativeDetector();\n  if (!Ctor) return null;\n  try {\n    const detector = new Ctor({ formats: [\"qr_code\"] });\n    const results = await detector.detect(source);\n    const value = results.find((r) => r.rawValue)?.rawValue;\n    return value ? value : null;\n  } catch {\n    // A detector that throws (unsupported format, decode error) is a miss,\n    // never a crash — the jsqr fallback still gets its turn.\n    return null;\n  }\n}\n\nasync function decodeWithJsQr(frame: ImageData): Promise<string | null> {\n  const { default: jsQR } = await import(\"jsqr\");\n  const both = jsQR(frame.data, frame.width, frame.height, {\n    inversionAttempts: \"attemptBoth\",\n  });\n  return both?.data ? both.data : null;\n}\n\n/** Draw any image source onto a canvas, capped at {@link MAX_EDGE}. */\nfunction toImageData(\n  source: CanvasImageSource,\n  width: number,\n  height: number,\n): ImageData | null {\n  if (!width || !height) return null;\n  const scale = Math.min(1, MAX_EDGE / Math.max(width, height));\n  const w = Math.max(1, Math.round(width * scale));\n  const h = Math.max(1, Math.round(height * scale));\n  const canvas = document.createElement(\"canvas\");\n  canvas.width = w;\n  canvas.height = h;\n  const ctx = canvas.getContext(\"2d\", { willReadFrequently: true });\n  if (!ctx) return null;\n  ctx.drawImage(source, 0, 0, w, h);\n  return ctx.getImageData(0, 0, w, h);\n}\n\n/** Decode a QR code out of an already-rasterised frame. */\nexport async function decodeQrFromImageData(\n  frame: ImageData,\n): Promise<string | null> {\n  return (await decodeWithJsQr(frame)) ?? null;\n}\n\n/**\n * Decode a QR code out of a live `<video>` (a camera preview) or a `<canvas>`.\n * Returns `null` when the current frame holds no code — call it on a tick.\n */\nexport async function decodeQrFromElement(\n  element: HTMLVideoElement | HTMLCanvasElement,\n): Promise<string | null> {\n  const width =\n    element instanceof HTMLVideoElement ? element.videoWidth : element.width;\n  const height =\n    element instanceof HTMLVideoElement ? element.videoHeight : element.height;\n  if (!width || !height) return null;\n\n  const native = await decodeNative(element);\n  if (native) return native;\n\n  const frame = toImageData(element, width, height);\n  return frame ? decodeQrFromImageData(frame) : null;\n}\n\n/**\n * Decode a QR code out of an image File/Blob — a pasted screenshot, a dropped\n * PNG, a photo from the OS camera sheet.\n *\n * Resolves `null` when the image holds no QR code. Throws only when the file\n * is not decodable as an image at all.\n */\nexport async function decodeQrFromImageFile(\n  file: Blob,\n): Promise<string | null> {\n  // The native detector accepts a Blob directly on Chromium — cheapest path.\n  const direct = await decodeNative(file);\n  if (direct) return direct;\n\n  let bitmap: ImageBitmap | null = null;\n  try {\n    bitmap = await createImageBitmap(file);\n  } catch {\n    throw new Error(\"That file could not be read as an image.\");\n  }\n  try {\n    const viaBitmap = await decodeNative(bitmap);\n    if (viaBitmap) return viaBitmap;\n    const frame = toImageData(bitmap, bitmap.width, bitmap.height);\n    return frame ? decodeQrFromImageData(frame) : null;\n  } finally {\n    bitmap.close();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BA,IAAM,WAAW;AAWjB,SAAS,iBAA6C;AACpD,QAAM,OAAQ,WACX;AACH,SAAO,OAAO,SAAS,aAAa,OAAO;AAC7C;AAGO,SAAS,sBAA+B;AAC7C,SAAO,eAAe,MAAM;AAC9B;AAEA,eAAe,aACb,QACwB;AACxB,QAAM,OAAO,eAAe;AAC5B,MAAI,CAAC,KAAM,QAAO;AAClB,MAAI;AACF,UAAM,WAAW,IAAI,KAAK,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC;AAClD,UAAM,UAAU,MAAM,SAAS,OAAO,MAAM;AAC5C,UAAM,QAAQ,QAAQ,KAAK,CAAC,MAAM,EAAE,QAAQ,GAAG;AAC/C,WAAO,QAAQ,QAAQ;AAAA,EACzB,QAAQ;AAGN,WAAO;AAAA,EACT;AACF;AAEA,eAAe,eAAe,OAA0C;AACtE,QAAM,EAAE,SAAS,KAAK,IAAI,MAAM,OAAO,MAAM;AAC7C,QAAM,OAAO,KAAK,MAAM,MAAM,MAAM,OAAO,MAAM,QAAQ;AAAA,IACvD,mBAAmB;AAAA,EACrB,CAAC;AACD,SAAO,MAAM,OAAO,KAAK,OAAO;AAClC;AAGA,SAAS,YACP,QACA,OACA,QACkB;AAClB,MAAI,CAAC,SAAS,CAAC,OAAQ,QAAO;AAC9B,QAAM,QAAQ,KAAK,IAAI,GAAG,WAAW,KAAK,IAAI,OAAO,MAAM,CAAC;AAC5D,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,KAAK,CAAC;AAC/C,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,SAAS,KAAK,CAAC;AAChD,QAAM,SAAS,SAAS,cAAc,QAAQ;AAC9C,SAAO,QAAQ;AACf,SAAO,SAAS;AAChB,QAAM,MAAM,OAAO,WAAW,MAAM,EAAE,oBAAoB,KAAK,CAAC;AAChE,MAAI,CAAC,IAAK,QAAO;AACjB,MAAI,UAAU,QAAQ,GAAG,GAAG,GAAG,CAAC;AAChC,SAAO,IAAI,aAAa,GAAG,GAAG,GAAG,CAAC;AACpC;AAGA,eAAsB,sBACpB,OACwB;AACxB,SAAQ,MAAM,eAAe,KAAK,KAAM;AAC1C;AAMA,eAAsB,oBACpB,SACwB;AACxB,QAAM,QACJ,mBAAmB,mBAAmB,QAAQ,aAAa,QAAQ;AACrE,QAAM,SACJ,mBAAmB,mBAAmB,QAAQ,cAAc,QAAQ;AACtE,MAAI,CAAC,SAAS,CAAC,OAAQ,QAAO;AAE9B,QAAM,SAAS,MAAM,aAAa,OAAO;AACzC,MAAI,OAAQ,QAAO;AAEnB,QAAM,QAAQ,YAAY,SAAS,OAAO,MAAM;AAChD,SAAO,QAAQ,sBAAsB,KAAK,IAAI;AAChD;AASA,eAAsB,sBACpB,MACwB;AAExB,QAAM,SAAS,MAAM,aAAa,IAAI;AACtC,MAAI,OAAQ,QAAO;AAEnB,MAAI,SAA6B;AACjC,MAAI;AACF,aAAS,MAAM,kBAAkB,IAAI;AAAA,EACvC,QAAQ;AACN,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC5D;AACA,MAAI;AACF,UAAM,YAAY,MAAM,aAAa,MAAM;AAC3C,QAAI,UAAW,QAAO;AACtB,UAAM,QAAQ,YAAY,QAAQ,OAAO,OAAO,OAAO,MAAM;AAC7D,WAAO,QAAQ,sBAAsB,KAAK,IAAI;AAAA,EAChD,UAAE;AACA,WAAO,MAAM;AAAA,EACf;AACF;","names":[]}

package/dist/qr.d.cts

@@ -0,0 +1,47 @@
+/**
+ * @ai-matrx/kit/qr — THE QR-code decoder (client-side, in memory). Ported
+ * verbatim from matrx-frontend `lib/qr/decode.ts`.
+ *
+ * One primitive, three inputs (a File/Blob, an `ImageData` frame, a
+ * `<video>`/`<canvas>` element), one answer: the text the QR encodes, or
+ * `null` when no code is present. Nothing here uploads, stores, or persists
+ * anything — the bytes live in a canvas for the length of one call.
+ *
+ * Engine order:
+ *   1. `BarcodeDetector` — native, fast, handles rotation and poor contrast.
+ *   2. `jsqr` — pure-JS fallback (lazily imported, so it only enters the
+ *      bundle of a surface that actually decodes), for Safari/Firefox where
+ *      the native detector does not exist.
+ *
+ * Runtime dependency of this subpath (and only when the fallback fires):
+ * `jsqr` — a browser without `BarcodeDetector` decoding a pasted screenshot
+ * IS the capability, not an optional extra; without the fallback the unit
+ * silently does nothing on Safari/Firefox.
+ *
+ * Browser capability: decoding needs a DOM (`document`, canvas 2D,
+ * `createImageBitmap`) at call time; importing is inert and SSR-safe, and
+ * `hasNativeQrDetector()` is safe to call anywhere (it only probes
+ * `globalThis`).
+ *
+ * 🚨 Reach for THIS, never a second decoder. If a surface needs a new input
+ * shape, add an adapter here.
+ */
+/** True when the browser can decode without downloading the JS fallback. */
+declare function hasNativeQrDetector(): boolean;
+/** Decode a QR code out of an already-rasterised frame. */
+declare function decodeQrFromImageData(frame: ImageData): Promise<string | null>;
+/**
+ * Decode a QR code out of a live `<video>` (a camera preview) or a `<canvas>`.
+ * Returns `null` when the current frame holds no code — call it on a tick.
+ */
+declare function decodeQrFromElement(element: HTMLVideoElement | HTMLCanvasElement): Promise<string | null>;
+/**
+ * Decode a QR code out of an image File/Blob — a pasted screenshot, a dropped
+ * PNG, a photo from the OS camera sheet.
+ *
+ * Resolves `null` when the image holds no QR code. Throws only when the file
+ * is not decodable as an image at all.
+ */
+declare function decodeQrFromImageFile(file: Blob): Promise<string | null>;
+
+export { decodeQrFromElement, decodeQrFromImageData, decodeQrFromImageFile, hasNativeQrDetector };

package/dist/qr.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @ai-matrx/kit/qr — THE QR-code decoder (client-side, in memory). Ported
+ * verbatim from matrx-frontend `lib/qr/decode.ts`.
+ *
+ * One primitive, three inputs (a File/Blob, an `ImageData` frame, a
+ * `<video>`/`<canvas>` element), one answer: the text the QR encodes, or
+ * `null` when no code is present. Nothing here uploads, stores, or persists
+ * anything — the bytes live in a canvas for the length of one call.
+ *
+ * Engine order:
+ *   1. `BarcodeDetector` — native, fast, handles rotation and poor contrast.
+ *   2. `jsqr` — pure-JS fallback (lazily imported, so it only enters the
+ *      bundle of a surface that actually decodes), for Safari/Firefox where
+ *      the native detector does not exist.
+ *
+ * Runtime dependency of this subpath (and only when the fallback fires):
+ * `jsqr` — a browser without `BarcodeDetector` decoding a pasted screenshot
+ * IS the capability, not an optional extra; without the fallback the unit
+ * silently does nothing on Safari/Firefox.
+ *
+ * Browser capability: decoding needs a DOM (`document`, canvas 2D,
+ * `createImageBitmap`) at call time; importing is inert and SSR-safe, and
+ * `hasNativeQrDetector()` is safe to call anywhere (it only probes
+ * `globalThis`).
+ *
+ * 🚨 Reach for THIS, never a second decoder. If a surface needs a new input
+ * shape, add an adapter here.
+ */
+/** True when the browser can decode without downloading the JS fallback. */
+declare function hasNativeQrDetector(): boolean;
+/** Decode a QR code out of an already-rasterised frame. */
+declare function decodeQrFromImageData(frame: ImageData): Promise<string | null>;
+/**
+ * Decode a QR code out of a live `<video>` (a camera preview) or a `<canvas>`.
+ * Returns `null` when the current frame holds no code — call it on a tick.
+ */
+declare function decodeQrFromElement(element: HTMLVideoElement | HTMLCanvasElement): Promise<string | null>;
+/**
+ * Decode a QR code out of an image File/Blob — a pasted screenshot, a dropped
+ * PNG, a photo from the OS camera sheet.
+ *
+ * Resolves `null` when the image holds no QR code. Throws only when the file
+ * is not decodable as an image at all.
+ */
+declare function decodeQrFromImageFile(file: Blob): Promise<string | null>;
+
+export { decodeQrFromElement, decodeQrFromImageData, decodeQrFromImageFile, hasNativeQrDetector };

package/dist/qr.js

@@ -0,0 +1,78 @@
+// src/qr.ts
+var MAX_EDGE = 1600;
+function nativeDetector() {
+  const ctor = globalThis.BarcodeDetector;
+  return typeof ctor === "function" ? ctor : null;
+}
+function hasNativeQrDetector() {
+  return nativeDetector() !== null;
+}
+async function decodeNative(source) {
+  const Ctor = nativeDetector();
+  if (!Ctor) return null;
+  try {
+    const detector = new Ctor({ formats: ["qr_code"] });
+    const results = await detector.detect(source);
+    const value = results.find((r) => r.rawValue)?.rawValue;
+    return value ? value : null;
+  } catch {
+    return null;
+  }
+}
+async function decodeWithJsQr(frame) {
+  const { default: jsQR } = await import("jsqr");
+  const both = jsQR(frame.data, frame.width, frame.height, {
+    inversionAttempts: "attemptBoth"
+  });
+  return both?.data ? both.data : null;
+}
+function toImageData(source, width, height) {
+  if (!width || !height) return null;
+  const scale = Math.min(1, MAX_EDGE / Math.max(width, height));
+  const w = Math.max(1, Math.round(width * scale));
+  const h = Math.max(1, Math.round(height * scale));
+  const canvas = document.createElement("canvas");
+  canvas.width = w;
+  canvas.height = h;
+  const ctx = canvas.getContext("2d", { willReadFrequently: true });
+  if (!ctx) return null;
+  ctx.drawImage(source, 0, 0, w, h);
+  return ctx.getImageData(0, 0, w, h);
+}
+async function decodeQrFromImageData(frame) {
+  return await decodeWithJsQr(frame) ?? null;
+}
+async function decodeQrFromElement(element) {
+  const width = element instanceof HTMLVideoElement ? element.videoWidth : element.width;
+  const height = element instanceof HTMLVideoElement ? element.videoHeight : element.height;
+  if (!width || !height) return null;
+  const native = await decodeNative(element);
+  if (native) return native;
+  const frame = toImageData(element, width, height);
+  return frame ? decodeQrFromImageData(frame) : null;
+}
+async function decodeQrFromImageFile(file) {
+  const direct = await decodeNative(file);
+  if (direct) return direct;
+  let bitmap = null;
+  try {
+    bitmap = await createImageBitmap(file);
+  } catch {
+    throw new Error("That file could not be read as an image.");
+  }
+  try {
+    const viaBitmap = await decodeNative(bitmap);
+    if (viaBitmap) return viaBitmap;
+    const frame = toImageData(bitmap, bitmap.width, bitmap.height);
+    return frame ? decodeQrFromImageData(frame) : null;
+  } finally {
+    bitmap.close();
+  }
+}
+export {
+  decodeQrFromElement,
+  decodeQrFromImageData,
+  decodeQrFromImageFile,
+  hasNativeQrDetector
+};
+//# sourceMappingURL=qr.js.map

package/dist/qr.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/qr.ts"],"sourcesContent":["/**\n * @ai-matrx/kit/qr — THE QR-code decoder (client-side, in memory). Ported\n * verbatim from matrx-frontend `lib/qr/decode.ts`.\n *\n * One primitive, three inputs (a File/Blob, an `ImageData` frame, a\n * `<video>`/`<canvas>` element), one answer: the text the QR encodes, or\n * `null` when no code is present. Nothing here uploads, stores, or persists\n * anything — the bytes live in a canvas for the length of one call.\n *\n * Engine order:\n *   1. `BarcodeDetector` — native, fast, handles rotation and poor contrast.\n *   2. `jsqr` — pure-JS fallback (lazily imported, so it only enters the\n *      bundle of a surface that actually decodes), for Safari/Firefox where\n *      the native detector does not exist.\n *\n * Runtime dependency of this subpath (and only when the fallback fires):\n * `jsqr` — a browser without `BarcodeDetector` decoding a pasted screenshot\n * IS the capability, not an optional extra; without the fallback the unit\n * silently does nothing on Safari/Firefox.\n *\n * Browser capability: decoding needs a DOM (`document`, canvas 2D,\n * `createImageBitmap`) at call time; importing is inert and SSR-safe, and\n * `hasNativeQrDetector()` is safe to call anywhere (it only probes\n * `globalThis`).\n *\n * 🚨 Reach for THIS, never a second decoder. If a surface needs a new input\n * shape, add an adapter here.\n */\n\n/** Longest edge we rasterise to. Big enough for a phone screenshot of a QR,\n *  small enough that a 48MP photo cannot stall the main thread. */\nconst MAX_EDGE = 1600;\n\ntype NativeBarcodeDetector = {\n  detect: (source: CanvasImageSource | ImageBitmap | Blob) => Promise<{ rawValue: string }[]>;\n};\n\ntype BarcodeDetectorCtor = {\n  new (options?: { formats?: string[] }): NativeBarcodeDetector;\n  getSupportedFormats?: () => Promise<string[]>;\n};\n\nfunction nativeDetector(): BarcodeDetectorCtor | null {\n  const ctor = (globalThis as { BarcodeDetector?: BarcodeDetectorCtor })\n    .BarcodeDetector;\n  return typeof ctor === \"function\" ? ctor : null;\n}\n\n/** True when the browser can decode without downloading the JS fallback. */\nexport function hasNativeQrDetector(): boolean {\n  return nativeDetector() !== null;\n}\n\nasync function decodeNative(\n  source: CanvasImageSource | ImageBitmap | Blob,\n): Promise<string | null> {\n  const Ctor = nativeDetector();\n  if (!Ctor) return null;\n  try {\n    const detector = new Ctor({ formats: [\"qr_code\"] });\n    const results = await detector.detect(source);\n    const value = results.find((r) => r.rawValue)?.rawValue;\n    return value ? value : null;\n  } catch {\n    // A detector that throws (unsupported format, decode error) is a miss,\n    // never a crash — the jsqr fallback still gets its turn.\n    return null;\n  }\n}\n\nasync function decodeWithJsQr(frame: ImageData): Promise<string | null> {\n  const { default: jsQR } = await import(\"jsqr\");\n  const both = jsQR(frame.data, frame.width, frame.height, {\n    inversionAttempts: \"attemptBoth\",\n  });\n  return both?.data ? both.data : null;\n}\n\n/** Draw any image source onto a canvas, capped at {@link MAX_EDGE}. */\nfunction toImageData(\n  source: CanvasImageSource,\n  width: number,\n  height: number,\n): ImageData | null {\n  if (!width || !height) return null;\n  const scale = Math.min(1, MAX_EDGE / Math.max(width, height));\n  const w = Math.max(1, Math.round(width * scale));\n  const h = Math.max(1, Math.round(height * scale));\n  const canvas = document.createElement(\"canvas\");\n  canvas.width = w;\n  canvas.height = h;\n  const ctx = canvas.getContext(\"2d\", { willReadFrequently: true });\n  if (!ctx) return null;\n  ctx.drawImage(source, 0, 0, w, h);\n  return ctx.getImageData(0, 0, w, h);\n}\n\n/** Decode a QR code out of an already-rasterised frame. */\nexport async function decodeQrFromImageData(\n  frame: ImageData,\n): Promise<string | null> {\n  return (await decodeWithJsQr(frame)) ?? null;\n}\n\n/**\n * Decode a QR code out of a live `<video>` (a camera preview) or a `<canvas>`.\n * Returns `null` when the current frame holds no code — call it on a tick.\n */\nexport async function decodeQrFromElement(\n  element: HTMLVideoElement | HTMLCanvasElement,\n): Promise<string | null> {\n  const width =\n    element instanceof HTMLVideoElement ? element.videoWidth : element.width;\n  const height =\n    element instanceof HTMLVideoElement ? element.videoHeight : element.height;\n  if (!width || !height) return null;\n\n  const native = await decodeNative(element);\n  if (native) return native;\n\n  const frame = toImageData(element, width, height);\n  return frame ? decodeQrFromImageData(frame) : null;\n}\n\n/**\n * Decode a QR code out of an image File/Blob — a pasted screenshot, a dropped\n * PNG, a photo from the OS camera sheet.\n *\n * Resolves `null` when the image holds no QR code. Throws only when the file\n * is not decodable as an image at all.\n */\nexport async function decodeQrFromImageFile(\n  file: Blob,\n): Promise<string | null> {\n  // The native detector accepts a Blob directly on Chromium — cheapest path.\n  const direct = await decodeNative(file);\n  if (direct) return direct;\n\n  let bitmap: ImageBitmap | null = null;\n  try {\n    bitmap = await createImageBitmap(file);\n  } catch {\n    throw new Error(\"That file could not be read as an image.\");\n  }\n  try {\n    const viaBitmap = await decodeNative(bitmap);\n    if (viaBitmap) return viaBitmap;\n    const frame = toImageData(bitmap, bitmap.width, bitmap.height);\n    return frame ? decodeQrFromImageData(frame) : null;\n  } finally {\n    bitmap.close();\n  }\n}\n"],"mappings":";AA+BA,IAAM,WAAW;AAWjB,SAAS,iBAA6C;AACpD,QAAM,OAAQ,WACX;AACH,SAAO,OAAO,SAAS,aAAa,OAAO;AAC7C;AAGO,SAAS,sBAA+B;AAC7C,SAAO,eAAe,MAAM;AAC9B;AAEA,eAAe,aACb,QACwB;AACxB,QAAM,OAAO,eAAe;AAC5B,MAAI,CAAC,KAAM,QAAO;AAClB,MAAI;AACF,UAAM,WAAW,IAAI,KAAK,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC;AAClD,UAAM,UAAU,MAAM,SAAS,OAAO,MAAM;AAC5C,UAAM,QAAQ,QAAQ,KAAK,CAAC,MAAM,EAAE,QAAQ,GAAG;AAC/C,WAAO,QAAQ,QAAQ;AAAA,EACzB,QAAQ;AAGN,WAAO;AAAA,EACT;AACF;AAEA,eAAe,eAAe,OAA0C;AACtE,QAAM,EAAE,SAAS,KAAK,IAAI,MAAM,OAAO,MAAM;AAC7C,QAAM,OAAO,KAAK,MAAM,MAAM,MAAM,OAAO,MAAM,QAAQ;AAAA,IACvD,mBAAmB;AAAA,EACrB,CAAC;AACD,SAAO,MAAM,OAAO,KAAK,OAAO;AAClC;AAGA,SAAS,YACP,QACA,OACA,QACkB;AAClB,MAAI,CAAC,SAAS,CAAC,OAAQ,QAAO;AAC9B,QAAM,QAAQ,KAAK,IAAI,GAAG,WAAW,KAAK,IAAI,OAAO,MAAM,CAAC;AAC5D,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,KAAK,CAAC;AAC/C,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,SAAS,KAAK,CAAC;AAChD,QAAM,SAAS,SAAS,cAAc,QAAQ;AAC9C,SAAO,QAAQ;AACf,SAAO,SAAS;AAChB,QAAM,MAAM,OAAO,WAAW,MAAM,EAAE,oBAAoB,KAAK,CAAC;AAChE,MAAI,CAAC,IAAK,QAAO;AACjB,MAAI,UAAU,QAAQ,GAAG,GAAG,GAAG,CAAC;AAChC,SAAO,IAAI,aAAa,GAAG,GAAG,GAAG,CAAC;AACpC;AAGA,eAAsB,sBACpB,OACwB;AACxB,SAAQ,MAAM,eAAe,KAAK,KAAM;AAC1C;AAMA,eAAsB,oBACpB,SACwB;AACxB,QAAM,QACJ,mBAAmB,mBAAmB,QAAQ,aAAa,QAAQ;AACrE,QAAM,SACJ,mBAAmB,mBAAmB,QAAQ,cAAc,QAAQ;AACtE,MAAI,CAAC,SAAS,CAAC,OAAQ,QAAO;AAE9B,QAAM,SAAS,MAAM,aAAa,OAAO;AACzC,MAAI,OAAQ,QAAO;AAEnB,QAAM,QAAQ,YAAY,SAAS,OAAO,MAAM;AAChD,SAAO,QAAQ,sBAAsB,KAAK,IAAI;AAChD;AASA,eAAsB,sBACpB,MACwB;AAExB,QAAM,SAAS,MAAM,aAAa,IAAI;AACtC,MAAI,OAAQ,QAAO;AAEnB,MAAI,SAA6B;AACjC,MAAI;AACF,aAAS,MAAM,kBAAkB,IAAI;AAAA,EACvC,QAAQ;AACN,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC5D;AACA,MAAI;AACF,UAAM,YAAY,MAAM,aAAa,MAAM;AAC3C,QAAI,UAAW,QAAO;AACtB,UAAM,QAAQ,YAAY,QAAQ,OAAO,OAAO,OAAO,MAAM;AAC7D,WAAO,QAAQ,sBAAsB,KAAK,IAAI;AAAA,EAChD,UAAE;AACA,WAAO,MAAM;AAAA,EACf;AACF;","names":[]}

package/dist/react-tree.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react-tree.ts
+var react_tree_exports = {};
+__export(react_tree_exports, {
+  treeContainsComponent: () => treeContainsComponent
+});
+module.exports = __toCommonJS(react_tree_exports);
+var React = __toESM(require("react"), 1);
+var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
+function treeContainsComponent(node, Component) {
+  if (node == null || typeof node === "boolean") return false;
+  if (Array.isArray(node)) {
+    return node.some((child) => treeContainsComponent(child, Component));
+  }
+  if (React.isValidElement(node)) {
+    if (node.type === Component) return true;
+    const props = node.props;
+    return props.children != null ? treeContainsComponent(props.children, Component) : false;
+  }
+  if (typeof node === "string" || typeof node === "number") return false;
+  if (typeof node === "object" && node.$$typeof === REACT_PORTAL_TYPE) {
+    return treeContainsComponent(
+      node.children,
+      Component
+    );
+  }
+  if (typeof node === "object" && Symbol.iterator in node) {
+    return Array.from(node).some(
+      (child) => treeContainsComponent(child, Component)
+    );
+  }
+  if (typeof process !== "undefined" && true) {
+    const keys = typeof node === "object" ? ` with keys {${Object.keys(node).join(", ")}}` : "";
+    console.error(
+      `[treeContainsComponent] A non-renderable value${keys} is being passed as a React child. React will throw 'Objects are not valid as a React child' at the real render site. Stringify it (e.g. JSON.stringify) before rendering.`,
+      node
+    );
+  }
+  return false;
+}
+//# sourceMappingURL=react-tree.cjs.map

package/dist/react-tree.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react-tree.ts"],"sourcesContent":["/**\n * @ai-matrx/kit/react-tree — safe React children-tree scanning.\n *\n * Ported from matrx-frontend `lib/react/treeContainsComponent.ts`; this\n * subpath is the ONE home of the scanner inside the kit (the `/confirm`\n * subpath's alert-dialog imports it from here — no duplicate bodies).\n *\n * Two deliberate divergences from the frontend original, both documented:\n * - the dev-mode scream checks `typeof process` first, since this package may\n *   load in an unbundled browser context where `process` is undefined;\n * - a React PORTAL child (`createPortal(...)` passed as a child) is a valid\n *   React child, but it is not an element, an iterable, or a primitive — the\n *   original fell through to the non-renderable branch, screamed a false\n *   positive in dev, and skipped the portal's content. Portals are now\n *   recognized and their children traversed.\n */\n\nimport * as React from \"react\";\n\nconst REACT_PORTAL_TYPE = Symbol.for(\"react.portal\");\n\n/**\n * Returns true if `Component` appears anywhere in the React element tree under\n * `node`. Used to detect optional a11y children (e.g. DialogDescription)\n * without rendering duplicates.\n *\n * DEFENSIVE + LOUD. A non-renderable node — a plain object or function passed\n * as a React child — is a real bug: React throws \"Objects are not valid as a\n * React child\" the instant it renders one. This a11y probe must NOT be the\n * crash site. `React.Children.toArray` would throw HERE, producing a trace that\n * points at the dialog primitive instead of the component that leaked the\n * object (this misdirection has burned real debugging hours). So we walk the\n * tree by hand, SKIP any non-renderable node, and scream in dev with its keys —\n * then let React report the defect at the true render site with the offending\n * component in the stack. For every VALID tree the result is identical to the\n * old `React.Children.toArray(node).some(...)`.\n */\nexport function treeContainsComponent(\n  node: React.ReactNode,\n  Component: React.ElementType,\n): boolean {\n  if (node == null || typeof node === \"boolean\") return false;\n\n  if (Array.isArray(node)) {\n    return node.some((child) => treeContainsComponent(child, Component));\n  }\n\n  if (React.isValidElement(node)) {\n    if (node.type === Component) return true;\n    const props = node.props as { children?: React.ReactNode };\n    return props.children != null\n      ? treeContainsComponent(props.children, Component)\n      : false;\n  }\n\n  // Strings / numbers are valid leaf children but never the Component.\n  if (typeof node === \"string\" || typeof node === \"number\") return false;\n\n  // A portal is a valid child that is NOT an element: traverse its content.\n  if (\n    typeof node === \"object\" &&\n    (node as { $$typeof?: unknown }).$$typeof === REACT_PORTAL_TYPE\n  ) {\n    return treeContainsComponent(\n      (node as { children?: React.ReactNode }).children,\n      Component,\n    );\n  }\n\n  // Non-array iterables (Set, Map, generator) are valid React children — React\n  // supports them — so traverse rather than reject.\n  if (typeof node === \"object\" && Symbol.iterator in node) {\n    return Array.from(node as Iterable<React.ReactNode>).some((child) =>\n      treeContainsComponent(child, Component),\n    );\n  }\n\n  // Anything else (a raw object, a function) is NOT a valid React child. React\n  // will throw when it renders this; we must not throw first and hide the cause.\n  if (\n    typeof process !== \"undefined\" &&\n    process.env.NODE_ENV !== \"production\"\n  ) {\n    const keys =\n      typeof node === \"object\"\n        ? ` with keys {${Object.keys(node).join(\", \")}}`\n        : \"\";\n    console.error(\n      `[treeContainsComponent] A non-renderable value${keys} is being passed as a React child. ` +\n        \"React will throw 'Objects are not valid as a React child' at the real render site. \" +\n        \"Stringify it (e.g. JSON.stringify) before rendering.\",\n      node,\n    );\n  }\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,YAAuB;AAEvB,IAAM,oBAAoB,uBAAO,IAAI,cAAc;AAkB5C,SAAS,sBACd,MACA,WACS;AACT,MAAI,QAAQ,QAAQ,OAAO,SAAS,UAAW,QAAO;AAEtD,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,WAAO,KAAK,KAAK,CAAC,UAAU,sBAAsB,OAAO,SAAS,CAAC;AAAA,EACrE;AAEA,MAAU,qBAAe,IAAI,GAAG;AAC9B,QAAI,KAAK,SAAS,UAAW,QAAO;AACpC,UAAM,QAAQ,KAAK;AACnB,WAAO,MAAM,YAAY,OACrB,sBAAsB,MAAM,UAAU,SAAS,IAC/C;AAAA,EACN;AAGA,MAAI,OAAO,SAAS,YAAY,OAAO,SAAS,SAAU,QAAO;AAGjE,MACE,OAAO,SAAS,YACf,KAAgC,aAAa,mBAC9C;AACA,WAAO;AAAA,MACJ,KAAwC;AAAA,MACzC;AAAA,IACF;AAAA,EACF;AAIA,MAAI,OAAO,SAAS,YAAY,OAAO,YAAY,MAAM;AACvD,WAAO,MAAM,KAAK,IAAiC,EAAE;AAAA,MAAK,CAAC,UACzD,sBAAsB,OAAO,SAAS;AAAA,IACxC;AAAA,EACF;AAIA,MACE,OAAO,YAAY,eACnB,MACA;AACA,UAAM,OACJ,OAAO,SAAS,WACZ,eAAe,OAAO,KAAK,IAAI,EAAE,KAAK,IAAI,CAAC,MAC3C;AACN,YAAQ;AAAA,MACN,iDAAiD,IAAI;AAAA,MAGrD;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/react-tree.d.cts

@@ -0,0 +1,38 @@
+import * as React from 'react';
+
+/**
+ * @ai-matrx/kit/react-tree — safe React children-tree scanning.
+ *
+ * Ported from matrx-frontend `lib/react/treeContainsComponent.ts`; this
+ * subpath is the ONE home of the scanner inside the kit (the `/confirm`
+ * subpath's alert-dialog imports it from here — no duplicate bodies).
+ *
+ * Two deliberate divergences from the frontend original, both documented:
+ * - the dev-mode scream checks `typeof process` first, since this package may
+ *   load in an unbundled browser context where `process` is undefined;
+ * - a React PORTAL child (`createPortal(...)` passed as a child) is a valid
+ *   React child, but it is not an element, an iterable, or a primitive — the
+ *   original fell through to the non-renderable branch, screamed a false
+ *   positive in dev, and skipped the portal's content. Portals are now
+ *   recognized and their children traversed.
+ */
+
+/**
+ * Returns true if `Component` appears anywhere in the React element tree under
+ * `node`. Used to detect optional a11y children (e.g. DialogDescription)
+ * without rendering duplicates.
+ *
+ * DEFENSIVE + LOUD. A non-renderable node — a plain object or function passed
+ * as a React child — is a real bug: React throws "Objects are not valid as a
+ * React child" the instant it renders one. This a11y probe must NOT be the
+ * crash site. `React.Children.toArray` would throw HERE, producing a trace that
+ * points at the dialog primitive instead of the component that leaked the
+ * object (this misdirection has burned real debugging hours). So we walk the
+ * tree by hand, SKIP any non-renderable node, and scream in dev with its keys —
+ * then let React report the defect at the true render site with the offending
+ * component in the stack. For every VALID tree the result is identical to the
+ * old `React.Children.toArray(node).some(...)`.
+ */
+declare function treeContainsComponent(node: React.ReactNode, Component: React.ElementType): boolean;
+
+export { treeContainsComponent };

package/dist/react-tree.d.ts

@@ -0,0 +1,38 @@
+import * as React from 'react';
+
+/**
+ * @ai-matrx/kit/react-tree — safe React children-tree scanning.
+ *
+ * Ported from matrx-frontend `lib/react/treeContainsComponent.ts`; this
+ * subpath is the ONE home of the scanner inside the kit (the `/confirm`
+ * subpath's alert-dialog imports it from here — no duplicate bodies).
+ *
+ * Two deliberate divergences from the frontend original, both documented:
+ * - the dev-mode scream checks `typeof process` first, since this package may
+ *   load in an unbundled browser context where `process` is undefined;
+ * - a React PORTAL child (`createPortal(...)` passed as a child) is a valid
+ *   React child, but it is not an element, an iterable, or a primitive — the
+ *   original fell through to the non-renderable branch, screamed a false
+ *   positive in dev, and skipped the portal's content. Portals are now
+ *   recognized and their children traversed.
+ */
+
+/**
+ * Returns true if `Component` appears anywhere in the React element tree under
+ * `node`. Used to detect optional a11y children (e.g. DialogDescription)
+ * without rendering duplicates.
+ *
+ * DEFENSIVE + LOUD. A non-renderable node — a plain object or function passed
+ * as a React child — is a real bug: React throws "Objects are not valid as a
+ * React child" the instant it renders one. This a11y probe must NOT be the
+ * crash site. `React.Children.toArray` would throw HERE, producing a trace that
+ * points at the dialog primitive instead of the component that leaked the
+ * object (this misdirection has burned real debugging hours). So we walk the
+ * tree by hand, SKIP any non-renderable node, and scream in dev with its keys —
+ * then let React report the defect at the true render site with the offending
+ * component in the stack. For every VALID tree the result is identical to the
+ * old `React.Children.toArray(node).some(...)`.
+ */
+declare function treeContainsComponent(node: React.ReactNode, Component: React.ElementType): boolean;
+
+export { treeContainsComponent };

package/dist/react-tree.js

@@ -0,0 +1,38 @@
+// src/react-tree.ts
+import * as React from "react";
+var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
+function treeContainsComponent(node, Component) {
+  if (node == null || typeof node === "boolean") return false;
+  if (Array.isArray(node)) {
+    return node.some((child) => treeContainsComponent(child, Component));
+  }
+  if (React.isValidElement(node)) {
+    if (node.type === Component) return true;
+    const props = node.props;
+    return props.children != null ? treeContainsComponent(props.children, Component) : false;
+  }
+  if (typeof node === "string" || typeof node === "number") return false;
+  if (typeof node === "object" && node.$$typeof === REACT_PORTAL_TYPE) {
+    return treeContainsComponent(
+      node.children,
+      Component
+    );
+  }
+  if (typeof node === "object" && Symbol.iterator in node) {
+    return Array.from(node).some(
+      (child) => treeContainsComponent(child, Component)
+    );
+  }
+  if (typeof process !== "undefined" && true) {
+    const keys = typeof node === "object" ? ` with keys {${Object.keys(node).join(", ")}}` : "";
+    console.error(
+      `[treeContainsComponent] A non-renderable value${keys} is being passed as a React child. React will throw 'Objects are not valid as a React child' at the real render site. Stringify it (e.g. JSON.stringify) before rendering.`,
+      node
+    );
+  }
+  return false;
+}
+export {
+  treeContainsComponent
+};
+//# sourceMappingURL=react-tree.js.map

package/dist/react-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react-tree.ts"],"sourcesContent":["/**\n * @ai-matrx/kit/react-tree — safe React children-tree scanning.\n *\n * Ported from matrx-frontend `lib/react/treeContainsComponent.ts`; this\n * subpath is the ONE home of the scanner inside the kit (the `/confirm`\n * subpath's alert-dialog imports it from here — no duplicate bodies).\n *\n * Two deliberate divergences from the frontend original, both documented:\n * - the dev-mode scream checks `typeof process` first, since this package may\n *   load in an unbundled browser context where `process` is undefined;\n * - a React PORTAL child (`createPortal(...)` passed as a child) is a valid\n *   React child, but it is not an element, an iterable, or a primitive — the\n *   original fell through to the non-renderable branch, screamed a false\n *   positive in dev, and skipped the portal's content. Portals are now\n *   recognized and their children traversed.\n */\n\nimport * as React from \"react\";\n\nconst REACT_PORTAL_TYPE = Symbol.for(\"react.portal\");\n\n/**\n * Returns true if `Component` appears anywhere in the React element tree under\n * `node`. Used to detect optional a11y children (e.g. DialogDescription)\n * without rendering duplicates.\n *\n * DEFENSIVE + LOUD. A non-renderable node — a plain object or function passed\n * as a React child — is a real bug: React throws \"Objects are not valid as a\n * React child\" the instant it renders one. This a11y probe must NOT be the\n * crash site. `React.Children.toArray` would throw HERE, producing a trace that\n * points at the dialog primitive instead of the component that leaked the\n * object (this misdirection has burned real debugging hours). So we walk the\n * tree by hand, SKIP any non-renderable node, and scream in dev with its keys —\n * then let React report the defect at the true render site with the offending\n * component in the stack. For every VALID tree the result is identical to the\n * old `React.Children.toArray(node).some(...)`.\n */\nexport function treeContainsComponent(\n  node: React.ReactNode,\n  Component: React.ElementType,\n): boolean {\n  if (node == null || typeof node === \"boolean\") return false;\n\n  if (Array.isArray(node)) {\n    return node.some((child) => treeContainsComponent(child, Component));\n  }\n\n  if (React.isValidElement(node)) {\n    if (node.type === Component) return true;\n    const props = node.props as { children?: React.ReactNode };\n    return props.children != null\n      ? treeContainsComponent(props.children, Component)\n      : false;\n  }\n\n  // Strings / numbers are valid leaf children but never the Component.\n  if (typeof node === \"string\" || typeof node === \"number\") return false;\n\n  // A portal is a valid child that is NOT an element: traverse its content.\n  if (\n    typeof node === \"object\" &&\n    (node as { $$typeof?: unknown }).$$typeof === REACT_PORTAL_TYPE\n  ) {\n    return treeContainsComponent(\n      (node as { children?: React.ReactNode }).children,\n      Component,\n    );\n  }\n\n  // Non-array iterables (Set, Map, generator) are valid React children — React\n  // supports them — so traverse rather than reject.\n  if (typeof node === \"object\" && Symbol.iterator in node) {\n    return Array.from(node as Iterable<React.ReactNode>).some((child) =>\n      treeContainsComponent(child, Component),\n    );\n  }\n\n  // Anything else (a raw object, a function) is NOT a valid React child. React\n  // will throw when it renders this; we must not throw first and hide the cause.\n  if (\n    typeof process !== \"undefined\" &&\n    process.env.NODE_ENV !== \"production\"\n  ) {\n    const keys =\n      typeof node === \"object\"\n        ? ` with keys {${Object.keys(node).join(\", \")}}`\n        : \"\";\n    console.error(\n      `[treeContainsComponent] A non-renderable value${keys} is being passed as a React child. ` +\n        \"React will throw 'Objects are not valid as a React child' at the real render site. \" +\n        \"Stringify it (e.g. JSON.stringify) before rendering.\",\n      node,\n    );\n  }\n  return false;\n}\n"],"mappings":";AAiBA,YAAY,WAAW;AAEvB,IAAM,oBAAoB,uBAAO,IAAI,cAAc;AAkB5C,SAAS,sBACd,MACA,WACS;AACT,MAAI,QAAQ,QAAQ,OAAO,SAAS,UAAW,QAAO;AAEtD,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,WAAO,KAAK,KAAK,CAAC,UAAU,sBAAsB,OAAO,SAAS,CAAC;AAAA,EACrE;AAEA,MAAU,qBAAe,IAAI,GAAG;AAC9B,QAAI,KAAK,SAAS,UAAW,QAAO;AACpC,UAAM,QAAQ,KAAK;AACnB,WAAO,MAAM,YAAY,OACrB,sBAAsB,MAAM,UAAU,SAAS,IAC/C;AAAA,EACN;AAGA,MAAI,OAAO,SAAS,YAAY,OAAO,SAAS,SAAU,QAAO;AAGjE,MACE,OAAO,SAAS,YACf,KAAgC,aAAa,mBAC9C;AACA,WAAO;AAAA,MACJ,KAAwC;AAAA,MACzC;AAAA,IACF;AAAA,EACF;AAIA,MAAI,OAAO,SAAS,YAAY,OAAO,YAAY,MAAM;AACvD,WAAO,MAAM,KAAK,IAAiC,EAAE;AAAA,MAAK,CAAC,UACzD,sBAAsB,OAAO,SAAS;AAAA,IACxC;AAAA,EACF;AAIA,MACE,OAAO,YAAY,eACnB,MACA;AACA,UAAM,OACJ,OAAO,SAAS,WACZ,eAAe,OAAO,KAAK,IAAI,EAAE,KAAK,IAAI,CAAC,MAC3C;AACN,YAAQ;AAAA,MACN,iDAAiD,IAAI;AAAA,MAGrD;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;","names":[]}