@ai-matrx/kit 0.5.0

package/dist/index.js

@@ -0,0 +1,3088 @@
+"use client";
+
+// src/autosave.ts
+import { useEffect, useRef, useState } from "react";
+function useAutosave(opts) {
+  const { save, debounceMs = 900 } = opts;
+  const [status, setStatus] = useState("idle");
+  const [lastSavedAt, setLastSavedAt] = useState(null);
+  const pendingRef = useRef(null);
+  const timerRef = useRef(null);
+  const savingRef = useRef(false);
+  const saveRef = useRef(save);
+  useEffect(() => {
+    saveRef.current = save;
+  });
+  async function saveNow() {
+    if (savingRef.current) return;
+    const pending = pendingRef.current;
+    if (!pending) return;
+    pendingRef.current = null;
+    savingRef.current = true;
+    setStatus("saving");
+    let failed = false;
+    try {
+      const res = await saveRef.current(pending.value);
+      if (res.error) {
+        failed = true;
+        pendingRef.current = pendingRef.current ?? pending;
+        setStatus("error");
+      } else {
+        setLastSavedAt(/* @__PURE__ */ new Date());
+        setStatus(pendingRef.current ? "unsaved" : "saved");
+      }
+    } catch {
+      failed = true;
+      pendingRef.current = pendingRef.current ?? pending;
+      setStatus("error");
+    } finally {
+      savingRef.current = false;
+      if (pendingRef.current && !failed) void saveNow();
+    }
+  }
+  function schedule(value) {
+    pendingRef.current = { value };
+    setStatus("unsaved");
+    if (timerRef.current) clearTimeout(timerRef.current);
+    timerRef.current = setTimeout(() => void saveNow(), debounceMs);
+  }
+  function flush2() {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    void saveNow();
+  }
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      const pending = pendingRef.current;
+      if (pending && !savingRef.current) {
+        pendingRef.current = null;
+        void saveRef.current(pending.value);
+      }
+    };
+  }, []);
+  return { status, lastSavedAt, schedule, flush: flush2 };
+}
+
+// src/latest-request.ts
+import { useCallback, useRef as useRef2 } from "react";
+function useLatestRequest() {
+  const seqRef = useRef2(0);
+  return useCallback(() => {
+    const mySeq = ++seqRef.current;
+    return () => mySeq === seqRef.current;
+  }, []);
+}
+
+// src/clipboard.ts
+import { useCallback as useCallback2, useState as useState2 } from "react";
+function toError(err, fallback) {
+  if (err instanceof Error) return err;
+  if (typeof err === "string" && err) return new Error(err);
+  return new Error(fallback);
+}
+function useClipboard(options = {}) {
+  const { notify } = options;
+  const [lastCopied, setLastCopied] = useState2(null);
+  const [error, setError] = useState2(null);
+  const handleSuccess = (type, successMessage) => {
+    setLastCopied(type);
+    setError(null);
+    notify?.(
+      successMessage ?? `${type.charAt(0).toUpperCase() + type.slice(1)} copied to clipboard!`,
+      "success"
+    );
+  };
+  const handleError = (err, type) => {
+    const message = `Failed to copy ${type}`;
+    setError(toError(err, message));
+    console.error(message, err);
+    notify?.(message, "error");
+  };
+  const copyText = useCallback2(
+    async (text, successMessage) => {
+      try {
+        await navigator.clipboard.writeText(text);
+        handleSuccess("text", successMessage);
+      } catch (err) {
+        handleError(err, "text");
+      }
+    },
+    [notify]
+  );
+  const copyImage = useCallback2(
+    async (imageSrc, successMessage) => {
+      try {
+        const response = await fetch(imageSrc);
+        if (!response.ok)
+          throw new Error(`HTTP error! status: ${response.status}`);
+        const blob = await response.blob();
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+        if (!ctx) throw new Error("Failed to get canvas context");
+        return new Promise((resolve, reject) => {
+          const img = new Image();
+          img.onload = () => {
+            canvas.width = img.width;
+            canvas.height = img.height;
+            ctx.drawImage(img, 0, 0);
+            canvas.toBlob((pngBlob) => {
+              if (pngBlob) {
+                const item = new ClipboardItem({ "image/png": pngBlob });
+                navigator.clipboard.write([item]).then(
+                  () => {
+                    handleSuccess("image", successMessage);
+                    resolve();
+                  },
+                  (err) => reject(
+                    toError(err, "Failed to write image to clipboard")
+                  )
+                );
+              } else {
+                reject(new Error("Failed to convert image to PNG"));
+              }
+            }, "image/png");
+          };
+          img.onerror = () => reject(new Error("Failed to load image"));
+          img.src = URL.createObjectURL(blob);
+        });
+      } catch (err) {
+        handleError(err, "image");
+      }
+    },
+    [notify]
+  );
+  const copyLink = useCallback2(
+    async (link, stripParams = false, successMessage) => {
+      try {
+        let value = link;
+        if (stripParams) {
+          const url = new URL(link);
+          value = `${url.origin}${url.pathname}`;
+        }
+        await navigator.clipboard.writeText(value);
+        handleSuccess("link", successMessage);
+      } catch (err) {
+        handleError(err, "link");
+      }
+    },
+    [notify]
+  );
+  const pasteText = useCallback2(async () => {
+    try {
+      const text = await navigator.clipboard.readText();
+      setError(null);
+      return text;
+    } catch (err) {
+      setError(toError(err, "Failed to paste text"));
+      console.error("Failed to paste text: ", err);
+      return "";
+    }
+  }, []);
+  const pasteImage = useCallback2(async () => {
+    try {
+      if (!navigator.clipboard?.read) return null;
+      const items = await navigator.clipboard.read();
+      for (const item of items) {
+        const imageType = item.types.find((type) => type.startsWith("image/"));
+        if (imageType) {
+          const blob = await item.getType(imageType);
+          return new File([blob], "pasted-image.png", { type: imageType });
+        }
+      }
+      return null;
+    } catch (err) {
+      setError(toError(err, "Failed to paste image"));
+      console.error("Failed to paste image: ", err);
+      return null;
+    }
+  }, []);
+  return { copyText, copyImage, copyLink, pasteText, pasteImage, lastCopied, error };
+}
+
+// src/search-scoring.ts
+var WEIGHT_TABLE = {
+  title: { exact: 1e4, startsWith: 5e3, includes: 2e3 },
+  subtitle: { exact: 2e3, startsWith: 1e3, includes: 500 },
+  body: { exact: 1e3, startsWith: 600, includes: 400 },
+  tag: { exact: 500, startsWith: 400, includes: 300 },
+  meta: { exact: 200, startsWith: 150, includes: 100 },
+  id: { exact: 100, startsWith: 75, includes: 50 }
+};
+var MIN_AUTO_ID_QUERY_LEN = 3;
+function getStringId(item) {
+  if (item && typeof item === "object" && "id" in item) {
+    const id = item.id;
+    if (typeof id === "string" && id.length > 0) return id;
+  }
+  return null;
+}
+function resolveTiers(field) {
+  if (field.weight === "custom" || field.exact != null) {
+    return {
+      exact: field.exact ?? 0,
+      startsWith: field.startsWith ?? 0,
+      includes: field.includes ?? 0
+    };
+  }
+  return WEIGHT_TABLE[field.weight ?? "body"];
+}
+function scoreValue(value, q, tiers) {
+  if (!value) return 0;
+  const v = value.toLowerCase();
+  if (v === q) return tiers.exact;
+  if (v.startsWith(q)) return tiers.startsWith;
+  if (v.includes(q)) return tiers.includes;
+  return 0;
+}
+function computeSearchScore(item, query, fields) {
+  const trimmed = query.trim();
+  if (!trimmed) return 0;
+  const q = trimmed.toLowerCase();
+  let total = 0;
+  fields.forEach((field, idx) => {
+    const raw = field.get(item);
+    if (raw == null) return;
+    const tiers = resolveTiers(field);
+    let best = 0;
+    if (Array.isArray(raw)) {
+      for (const v of raw) {
+        if (typeof v !== "string") continue;
+        const s = scoreValue(v, q, tiers);
+        if (s > best) best = s;
+      }
+    } else if (typeof raw === "string") {
+      best = scoreValue(raw, q, tiers);
+    }
+    if (best > 0) {
+      total += best + (fields.length - idx);
+    }
+  });
+  const hasExplicitId = fields.some((f) => f.weight === "id");
+  if (!hasExplicitId && q.length >= MIN_AUTO_ID_QUERY_LEN) {
+    const id = getStringId(item);
+    if (id) {
+      total += scoreValue(id, q, WEIGHT_TABLE.id);
+    }
+  }
+  return total;
+}
+function matchesSearch(item, query, fields) {
+  return computeSearchScore(item, query, fields) > 0;
+}
+function idMatchesQuery(item, query) {
+  const q = query.trim().toLowerCase();
+  if (q.length < MIN_AUTO_ID_QUERY_LEN) return false;
+  const id = getStringId(item);
+  return id != null && id.toLowerCase().includes(q);
+}
+function filterAndSortBySearch(items, query, fields) {
+  const trimmed = query.trim();
+  if (!trimmed) return items.slice();
+  const scored = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const score = computeSearchScore(item, trimmed, fields);
+    if (score > 0) scored.push({ item, score, idx: i });
+  }
+  scored.sort((a, b) => b.score - a.score || a.idx - b.idx);
+  return scored.map((s) => s.item);
+}
+
+// src/concurrency.ts
+async function runWithConcurrency(items, limit, worker, shouldStart = () => true) {
+  if (items.length === 0) {
+    return { started: 0, succeeded: 0, failed: 0, failures: [] };
+  }
+  let cursor = 0;
+  let started = 0;
+  let succeeded = 0;
+  const failures = [];
+  const requestedLimit = Number.isFinite(limit) ? Math.floor(limit) : 1;
+  const workerCount = Math.max(1, Math.min(requestedLimit, items.length));
+  const runners = Array.from({ length: workerCount }, async () => {
+    while (shouldStart()) {
+      const index = cursor++;
+      if (index >= items.length) return;
+      started += 1;
+      const item = items[index];
+      try {
+        await worker(item, index);
+        succeeded += 1;
+      } catch (error) {
+        failures.push({ item, index, error });
+      }
+    }
+  });
+  await Promise.all(runners);
+  failures.sort((left, right) => left.index - right.index);
+  return {
+    started,
+    succeeded,
+    failed: failures.length,
+    failures
+  };
+}
+
+// src/text-case.ts
+var DEFAULT_WORD_REPLACEMENTS = {
+  // Acronyms & initialisms
+  "api": "API",
+  "apis": "APIs",
+  "ui": "UI",
+  "ux": "UX",
+  "id": "ID",
+  "ids": "IDs",
+  "qr": "QR",
+  "ssr": "SSR",
+  "csr": "CSR",
+  "ssg": "SSG",
+  "isr": "ISR",
+  "spa": "SPA",
+  "pwa": "PWA",
+  "sdk": "SDK",
+  "sdks": "SDKs",
+  "cli": "CLI",
+  "tty": "TTY",
+  "repl": "REPL",
+  "ci": "CI",
+  "cd": "CD",
+  "cpu": "CPU",
+  "cpus": "CPUs",
+  "gpu": "GPU",
+  "gpus": "GPUs",
+  "ram": "RAM",
+  "rom": "ROM",
+  "ssd": "SSD",
+  "ssds": "SSDs",
+  "hdd": "HDD",
+  "hdds": "HDDs",
+  "kpi": "KPI",
+  "kpis": "KPIs",
+  "sla": "SLA",
+  "slas": "SLAs",
+  "slo": "SLO",
+  "slos": "SLOs",
+  "sli": "SLI",
+  "slis": "SLIs",
+  "dom": "DOM",
+  // Web, formats, protocols
+  "url": "URL",
+  "urls": "URLs",
+  "uri": "URI",
+  "uris": "URIs",
+  "http": "HTTP",
+  "https": "HTTPS",
+  "html": "HTML",
+  "css": "CSS",
+  "json": "JSON",
+  "yaml": "YAML",
+  "yml": "YML",
+  "toml": "TOML",
+  "csv": "CSV",
+  "pdf": "PDF",
+  "tsv": "TSV",
+  "jpg": "JPG",
+  "jpeg": "JPEG",
+  "png": "PNG",
+  "gif": "GIF",
+  "webp": "WebP",
+  "heic": "HEIC",
+  "heif": "HEIF",
+  "bmp": "BMP",
+  "tiff": "TIFF",
+  "ico": "ICO",
+  "xml": "XML",
+  "sql": "SQL",
+  "db": "DB",
+  "dbs": "DBs",
+  "nosql": "NoSQL",
+  "graphql": "GraphQL",
+  "grpc": "gRPC",
+  "rest": "REST",
+  "restful": "RESTful",
+  "websocket": "WebSocket",
+  "websockets": "WebSockets",
+  "webrtc": "WebRTC",
+  // Networking
+  "ip": "IP",
+  "ipv4": "IPv4",
+  "ipv6": "IPv6",
+  "dns": "DNS",
+  "dhcp": "DHCP",
+  "nat": "NAT",
+  "tcp": "TCP",
+  "udp": "UDP",
+  "icmp": "ICMP",
+  "ttl": "TTL",
+  "lan": "LAN",
+  "wan": "WAN",
+  "vlan": "VLAN",
+  "cdn": "CDN",
+  "ftp": "FTP",
+  "ssh": "SSH",
+  "tls": "TLS",
+  "ssl": "SSL",
+  // Security & crypto
+  "jwt": "JWT",
+  "jws": "JWS",
+  "jwe": "JWE",
+  "hmac": "HMAC",
+  "rsa": "RSA",
+  "ecdsa": "ECDSA",
+  "aes": "AES",
+  "pbkdf2": "PBKDF2",
+  "argon2": "Argon2",
+  "scrypt": "scrypt",
+  "totp": "TOTP",
+  "hotp": "HOTP",
+  "mfa": "MFA",
+  "2fa": "2FA",
+  "csrf": "CSRF",
+  "xss": "XSS",
+  "ssrf": "SSRF",
+  "rce": "RCE",
+  "dos": "DoS",
+  "ddos": "DDoS",
+  "mitm": "MITM",
+  "csp": "CSP",
+  "cors": "CORS",
+  "pii": "PII",
+  "phi": "PHI",
+  "gdpr": "GDPR",
+  "ccpa": "CCPA",
+  "hipaa": "HIPAA",
+  "rfc": "RFC",
+  // Platforms, langs, tools (single-token)
+  "javascript": "JavaScript",
+  "typescript": "TypeScript",
+  "jsx": "JSX",
+  "tsx": "TSX",
+  "node": "Node",
+  // (used when tokenized alone)
+  "deno": "Deno",
+  "bun": "Bun",
+  "react": "React",
+  "nextjs": "Next.js",
+  // if your tokenizer drops dots, keep this
+  "nodejs": "Node.js",
+  "postgresql": "PostgreSQL",
+  "postgres": "Postgres",
+  "mysql": "MySQL",
+  "sqlite": "SQLite",
+  "redis": "Redis",
+  "supabase": "Supabase",
+  "docker": "Docker",
+  "kubernetes": "Kubernetes",
+  "k8s": "Kubernetes",
+  "helm": "Helm",
+  "npm": "npm",
+  "pnpm": "pnpm",
+  "yarn": "Yarn",
+  "eslint": "ESLint",
+  "prettier": "Prettier",
+  "vite": "Vite",
+  "webpack": "Webpack",
+  "babel": "Babel",
+  // OS & vendors
+  "macos": "macOS",
+  "ios": "iOS",
+  "ipados": "iPadOS",
+  "watchos": "watchOS",
+  "tvos": "tvOS",
+  "windows": "Windows",
+  "linux": "Linux",
+  "ubuntu": "Ubuntu",
+  "github": "GitHub",
+  "gitlab": "GitLab",
+  "bitbucket": "Bitbucket",
+  // Data & analytics
+  "etl": "ETL",
+  "elt": "ELT",
+  "olap": "OLAP",
+  "oltp": "OLTP",
+  "bi": "BI",
+  // Time & locales
+  "utc": "UTC",
+  "gmt": "GMT",
+  "pst": "PST",
+  "pdt": "PDT",
+  "pt": "PT",
+  // Common “small words” to keep lowercase (unless first/last word)
+  "or": "or",
+  "and": "and",
+  "the": "the",
+  "of": "of",
+  "in": "in",
+  "to": "to",
+  "with": "with",
+  "as": "as",
+  "by": "by",
+  "for": "for",
+  "on": "on",
+  "at": "at",
+  "up": "up",
+  "a": "a",
+  "an": "an",
+  "is": "is",
+  "are": "are",
+  "was": "was",
+  "were": "were",
+  "be": "be",
+  "but": "but",
+  "nor": "nor",
+  "so": "so",
+  "yet": "yet",
+  "per": "per",
+  "via": "via",
+  // Latin abbreviations (tokenized as words in some pipelines)
+  "eg": "e.g.",
+  "ie": "i.e.",
+  "etc": "etc.",
+  "aka": "aka",
+  "vs": "vs.",
+  "v": "v.",
+  // Client abbreviations
+  "CIC": "CIC",
+  "AGR": "AGR",
+  "AGER": "AGER",
+  "DD": "DD",
+  "TS": "TS",
+  "TM": "TM",
+  "arman": "Arman"
+};
+var DEFAULT_OPTIONS = {
+  textCase: "title",
+  wordReplacements: DEFAULT_WORD_REPLACEMENTS,
+  trim: true
+};
+function formatText(text, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (!text) return "";
+  let normalized = text.replace(/_/g, " ").replace(/-/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\s+/g, " ");
+  if (opts.trim) {
+    normalized = normalized.trim();
+  }
+  let caseTransformed = normalized;
+  switch (opts.textCase) {
+    case "title":
+      caseTransformed = normalized.replace(
+        /\w\S*/g,
+        (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+      );
+      break;
+    case "sentence":
+      if (normalized.length > 0) {
+        caseTransformed = normalized.charAt(0).toUpperCase() + normalized.slice(1).toLowerCase();
+      }
+      break;
+    case "lower":
+      caseTransformed = normalized.toLowerCase();
+      break;
+    case "upper":
+      caseTransformed = normalized.toUpperCase();
+      break;
+    case "normal":
+    default:
+      break;
+  }
+  let result = caseTransformed;
+  if (opts.wordReplacements) {
+    Object.entries(opts.wordReplacements).forEach(([key, value]) => {
+      const regex = new RegExp(`\\b${key}\\b`, "gi");
+      result = result.replace(regex, value);
+    });
+  }
+  return result;
+}
+function createFormatter(defaultOptions = {}) {
+  return (text, overrideOptions = {}) => formatText(text, { ...defaultOptions, ...overrideOptions });
+}
+var formatTitleCase = createFormatter({ textCase: "title" });
+var formatSentenceCase = createFormatter({ textCase: "sentence" });
+var formatNormalCase = createFormatter({ textCase: "normal" });
+var formatUpperCase = createFormatter({ textCase: "upper" });
+var formatLowerCase = createFormatter({ textCase: "lower" });
+var formatWithoutReplacements = createFormatter({ wordReplacements: {} });
+
+// src/drafts/use-durable-draft.ts
+import { useEffect as useEffect2, useRef as useRef3, useState as useState3 } from "react";
+var PREFIX = "matrx:durable-draft:";
+var warnedStorageUnavailable = false;
+function storageWrite(storageKey, value) {
+  try {
+    if (value) window.localStorage.setItem(storageKey, value);
+    else window.localStorage.removeItem(storageKey);
+  } catch (err) {
+    if (!warnedStorageUnavailable) {
+      warnedStorageUnavailable = true;
+      console.warn(
+        "[useDurableDraft] localStorage unavailable \u2014 drafts survive only in memory this session",
+        err
+      );
+    }
+  }
+}
+function useDurableDraft(key) {
+  const storageKey = PREFIX + key;
+  const [draft, setDraftState] = useState3("");
+  const touchedKeyRef = useRef3(null);
+  useEffect2(() => {
+    let saved = null;
+    try {
+      saved = window.localStorage.getItem(storageKey);
+    } catch {
+    }
+    setDraftState(
+      (current) => touchedKeyRef.current === storageKey && current ? current : saved ?? ""
+    );
+  }, [storageKey]);
+  const setDraft = (value) => {
+    touchedKeyRef.current = storageKey;
+    setDraftState(value);
+    storageWrite(storageKey, value);
+  };
+  const clearDraft = () => {
+    touchedKeyRef.current = storageKey;
+    setDraftState("");
+    storageWrite(storageKey, "");
+  };
+  return { draft, setDraft, clearDraft };
+}
+
+// src/drafts/local-drafts.ts
+var STORAGE_KEY = "matrx.local-drafts.v1";
+var DRAFT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var MAX_DRAFT_CHARS = 4e5;
+var MAX_TOTAL_CHARS = 15e5;
+var TRUNCATION_MARKER = "\n\n[\u2026 truncated by the local draft store \u2014 the note was too large to snapshot in full]";
+var sources = /* @__PURE__ */ new Map();
+var unloadListenerAttached = false;
+var listeners = /* @__PURE__ */ new Set();
+var version = 0;
+function subscribeDrafts(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function getDraftsVersion() {
+  return version;
+}
+function emitDraftsChanged() {
+  version += 1;
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch (err) {
+      console.error("[LocalDrafts] subscriber threw:", err);
+    }
+  }
+}
+function registerDraftSource(id, collect) {
+  sources.set(id, collect);
+  attachUnloadListener();
+  return () => {
+    if (sources.get(id) === collect) sources.delete(id);
+  };
+}
+function attachUnloadListener() {
+  if (unloadListenerAttached || typeof window === "undefined") return;
+  unloadListenerAttached = true;
+  window.addEventListener("pagehide", () => {
+    captureDrafts("unload");
+  });
+}
+function captureDrafts(reason) {
+  if (typeof window === "undefined") return [];
+  const collected = [];
+  for (const [id, collect] of sources) {
+    try {
+      collected.push(...collect());
+    } catch (err) {
+      console.error("[LocalDrafts] draft source failed:", id, err);
+    }
+  }
+  if (collected.length === 0) return [];
+  const now = Date.now();
+  const written = collected.map((input) => ({
+    ...input,
+    content: input.content.length > MAX_DRAFT_CHARS ? input.content.slice(0, MAX_DRAFT_CHARS) + TRUNCATION_MARKER : input.content,
+    key: draftKey(input.namespace, input.entityId),
+    capturedAt: now,
+    reason
+  }));
+  const existing = readAll().filter(
+    (d) => !written.some((w) => w.key === d.key)
+  );
+  writeAll([...written, ...existing]);
+  console.warn(
+    `[LocalDrafts] snapshotted ${written.length} unsaved item(s) to this browser (reason: ${reason}).`,
+    written.map((d) => `${d.key} (${d.content.length} chars)`)
+  );
+  return written;
+}
+function listDrafts(namespace, ownerId) {
+  if (!ownerId) return [];
+  return readAll().filter((d) => d.namespace === namespace && d.ownerId === ownerId).sort((a, b) => b.capturedAt - a.capturedAt);
+}
+function getDraft(namespace, entityId, ownerId) {
+  if (!ownerId) return null;
+  const key = draftKey(namespace, entityId);
+  return readAll().find((d) => d.key === key && d.ownerId === ownerId) ?? null;
+}
+function discardDraft(namespace, entityId) {
+  const key = draftKey(namespace, entityId);
+  const all = readAll();
+  const next = all.filter((d) => d.key !== key);
+  if (next.length !== all.length) writeAll(next);
+}
+function draftKey(namespace, entityId) {
+  return `${namespace}:${entityId}`;
+}
+function readAll() {
+  if (typeof window === "undefined") return [];
+  let raw = null;
+  try {
+    raw = window.localStorage.getItem(STORAGE_KEY);
+  } catch {
+    return [];
+  }
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    const cutoff = Date.now() - DRAFT_TTL_MS;
+    return parsed.filter(isLocalDraft).filter((d) => d.capturedAt >= cutoff);
+  } catch {
+    return [];
+  }
+}
+function writeAll(drafts) {
+  if (typeof window === "undefined") return;
+  const cutoff = Date.now() - DRAFT_TTL_MS;
+  const fresh = drafts.filter((d) => d.capturedAt >= cutoff).sort((a, b) => b.capturedAt - a.capturedAt);
+  const kept = [];
+  let total = 0;
+  for (const draft of fresh) {
+    if (total + draft.content.length > MAX_TOTAL_CHARS && kept.length > 0) {
+      console.warn(
+        "[LocalDrafts] draft budget exhausted \u2014 dropping older draft",
+        draft.key
+      );
+      continue;
+    }
+    kept.push(draft);
+    total += draft.content.length;
+  }
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(kept));
+  } catch (err) {
+    console.error("[LocalDrafts] failed to persist drafts:", err);
+    if (kept.length > 1) {
+      try {
+        window.localStorage.setItem(STORAGE_KEY, JSON.stringify([kept[0]]));
+      } catch {
+      }
+    }
+  }
+  emitDraftsChanged();
+}
+function isLocalDraft(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const d = value;
+  return typeof d.key === "string" && typeof d.namespace === "string" && typeof d.entityId === "string" && typeof d.content === "string" && typeof d.capturedAt === "number";
+}
+
+// src/confirm/opener.ts
+var STATE_SLOT = /* @__PURE__ */ Symbol.for("ai-matrx.kit.confirm-opener-state");
+function getState() {
+  const holder = globalThis;
+  let state = holder[STATE_SLOT];
+  if (!state) {
+    state = { host: null, queue: [] };
+    holder[STATE_SLOT] = state;
+  }
+  return state;
+}
+function _registerHost(controller) {
+  const state = getState();
+  state.host = controller;
+  while (state.queue.length > 0) {
+    const next = state.queue.shift();
+    controller.show(next.opts, next.resolve);
+  }
+}
+function _unregisterHost(controller) {
+  const state = getState();
+  if (state.host === controller) state.host = null;
+}
+function confirm(opts) {
+  return new Promise((resolve) => {
+    const state = getState();
+    if (state.host) {
+      state.host.show(opts, resolve);
+    } else {
+      state.queue.push({ opts, resolve });
+    }
+  });
+}
+
+// src/confirm/host.tsx
+import * as React3 from "react";
+
+// src/confirm/cn.ts
+import { twMerge } from "tailwind-merge";
+function cn(...values) {
+  return twMerge(values.filter(Boolean).join(" "));
+}
+
+// src/confirm/alert-dialog.tsx
+import * as React2 from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+
+// 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;
+}
+
+// src/confirm/alert-dialog.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var buttonBase = "inline-flex cursor-pointer items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all duration-200 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-0 disabled:pointer-events-none disabled:opacity-50 active:scale-[0.98] [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0 h-9 px-4 py-2";
+var buttonDefault = "bg-primary text-primary-foreground shadow-sm hover:bg-primary/90";
+var buttonOutline = "border border-border bg-card shadow-sm hover:bg-accent hover:text-accent-foreground";
+var AlertDialog = AlertDialogPrimitive.Root;
+var AlertDialogPortal = AlertDialogPrimitive.Portal;
+var AlertDialogOverlay = React2.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  AlertDialogPrimitive.Overlay,
+  {
+    className: cn(
+      "fixed inset-0 z-[10000] bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      className
+    ),
+    ...props,
+    ref
+  }
+));
+AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName;
+var AlertDialogContentPrimitive = React2.forwardRef(({ ...props }, ref) => /* @__PURE__ */ jsx(AlertDialogPrimitive.Content, { ...props, ref, "aria-modal": "true" }));
+AlertDialogContentPrimitive.displayName = "AlertDialogContentPrimitive";
+var AlertDialogDescription = React2.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  AlertDialogPrimitive.Description,
+  {
+    ref,
+    className: cn("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+AlertDialogDescription.displayName = AlertDialogPrimitive.Description.displayName;
+var AlertDialogContent = React2.forwardRef(({ className, children, ...props }, ref) => {
+  const hasDescription = treeContainsComponent(children, AlertDialogDescription) || treeContainsComponent(children, AlertDialogPrimitive.Description);
+  return /* @__PURE__ */ jsxs(AlertDialogPortal, { children: [
+    /* @__PURE__ */ jsx(AlertDialogOverlay, {}),
+    /* @__PURE__ */ jsxs(
+      AlertDialogContentPrimitive,
+      {
+        ref,
+        className: cn(
+          "fixed left-[50%] top-[50%] z-[10000] grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+          className
+        ),
+        ...props,
+        children: [
+          !hasDescription && /* @__PURE__ */ jsx(AlertDialogPrimitive.Description, { className: "sr-only", children: "Please confirm the action described in this dialog." }),
+          children
+        ]
+      }
+    )
+  ] });
+});
+AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName;
+var AlertDialogHeader = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    className: cn(
+      "flex flex-col space-y-2 text-center sm:text-left",
+      className
+    ),
+    ...props
+  }
+);
+AlertDialogHeader.displayName = "AlertDialogHeader";
+var AlertDialogFooter = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    className: cn(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+      className
+    ),
+    ...props
+  }
+);
+AlertDialogFooter.displayName = "AlertDialogFooter";
+var AlertDialogTitle = React2.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  AlertDialogPrimitive.Title,
+  {
+    ref,
+    className: cn("text-lg font-semibold", className),
+    ...props
+  }
+));
+AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName;
+var AlertDialogAction = React2.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  AlertDialogPrimitive.Action,
+  {
+    ref,
+    className: cn(buttonBase, buttonDefault, className),
+    ...props
+  }
+));
+AlertDialogAction.displayName = AlertDialogPrimitive.Action.displayName;
+var AlertDialogCancel = React2.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  AlertDialogPrimitive.Cancel,
+  {
+    ref,
+    className: cn(buttonBase, buttonOutline, "mt-2 sm:mt-0", className),
+    ...props
+  }
+));
+AlertDialogCancel.displayName = AlertDialogPrimitive.Cancel.displayName;
+
+// src/confirm/confirm-dialog.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function SpinnerIcon({ className }) {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: 24,
+      height: 24,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 2,
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      className,
+      children: /* @__PURE__ */ jsx2("path", { d: "M21 12a9 9 0 1 1-6.219-8.56" })
+    }
+  );
+}
+function ConfirmDialog({
+  open,
+  onOpenChange,
+  title,
+  description,
+  content,
+  contentClassName,
+  confirmLabel = "Confirm",
+  cancelLabel = "Cancel",
+  variant = "default",
+  busy = false,
+  confirmDisabled = false,
+  onConfirm
+}) {
+  return /* @__PURE__ */ jsx2(AlertDialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs2(AlertDialogContent, { className: contentClassName, children: [
+    /* @__PURE__ */ jsxs2(AlertDialogHeader, { children: [
+      /* @__PURE__ */ jsx2(AlertDialogTitle, { children: title }),
+      description ? /* @__PURE__ */ jsx2(AlertDialogDescription, { children: description }) : null
+    ] }),
+    content ?? null,
+    /* @__PURE__ */ jsxs2(AlertDialogFooter, { children: [
+      cancelLabel === null ? null : /* @__PURE__ */ jsx2(AlertDialogCancel, { className: "max-lg:min-h-11", disabled: busy, children: cancelLabel }),
+      /* @__PURE__ */ jsxs2(
+        AlertDialogAction,
+        {
+          disabled: busy || confirmDisabled,
+          onClick: (event) => {
+            event.preventDefault();
+            void onConfirm();
+          },
+          className: cn(
+            "max-lg:min-h-11",
+            variant === "destructive" && "bg-destructive text-destructive-foreground hover:bg-destructive/90"
+          ),
+          children: [
+            busy ? /* @__PURE__ */ jsx2(SpinnerIcon, { className: "mr-2 h-4 w-4 animate-spin" }) : null,
+            confirmLabel
+          ]
+        }
+      )
+    ] })
+  ] }) });
+}
+
+// src/confirm/host.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function ConfirmDialogHost() {
+  const [active, setActive] = React3.useState(null);
+  const [tick, setTick] = React3.useState(0);
+  const queueRef = React3.useRef([]);
+  React3.useEffect(() => {
+    const controller = {
+      show: (opts, resolve) => {
+        queueRef.current.push({ opts, resolve });
+        setTick((n) => n + 1);
+      }
+    };
+    _registerHost(controller);
+    return () => _unregisterHost(controller);
+  }, []);
+  React3.useEffect(() => {
+    if (active === null && queueRef.current.length > 0) {
+      setActive(queueRef.current.shift());
+    }
+  }, [active, tick]);
+  const handleConfirm = React3.useCallback(() => {
+    if (!active) return;
+    active.resolve(true);
+    setActive(null);
+  }, [active]);
+  const handleOpenChange = React3.useCallback(
+    (open) => {
+      if (!open && active) {
+        active.resolve(false);
+        setActive(null);
+      }
+    },
+    [active]
+  );
+  return /* @__PURE__ */ jsx3(
+    ConfirmDialog,
+    {
+      open: !!active,
+      onOpenChange: handleOpenChange,
+      title: active?.opts.title ?? "",
+      description: active?.opts.description,
+      confirmLabel: active?.opts.confirmLabel,
+      cancelLabel: active?.opts.cancelLabel,
+      variant: active?.opts.variant,
+      onConfirm: handleConfirm
+    }
+  );
+}
+
+// src/toast.ts
+function messageText(message, data) {
+  const description = data && typeof data.description === "string" ? data.description : "";
+  const title = typeof message === "string" ? message : "";
+  return [title, description].filter(Boolean).join(" \u2014 ") || "Error toast";
+}
+function createMatrxToast({
+  toast: hostToast,
+  capture
+}) {
+  if (typeof hostToast !== "function") {
+    throw new Error(
+      "createMatrxToast: options.toast must be the sonner `toast` object (or a structural equivalent) \u2014 got " + typeof hostToast
+    );
+  }
+  function captureToast(kind, message, data) {
+    if (!capture) return;
+    try {
+      capture({
+        source: "user-toast",
+        message: `${kind === "warning" ? "[warning] " : ""}${messageText(message, data)}`,
+        userMessage: messageText(message, data),
+        raw: {
+          kind,
+          message: typeof message === "string" ? message : void 0,
+          data
+        }
+      });
+    } catch {
+    }
+  }
+  const error = (message, data) => {
+    captureToast("error", message, data);
+    return hostToast.error(message, data);
+  };
+  const warning = (message, data) => {
+    captureToast("warning", message, data);
+    return hostToast.warning(message, data);
+  };
+  const forward = hostToast;
+  const toast = Object.assign(
+    ((...args) => forward(...args)),
+    hostToast,
+    { error, warning }
+  );
+  const toastErrorAlreadyCaptured = ((message, data) => hostToast.error(message, data));
+  return { toast, toastErrorAlreadyCaptured };
+}
+
+// src/invalidation.ts
+var STATE_SLOT2 = /* @__PURE__ */ Symbol.for("ai-matrx.kit.invalidation-registry");
+function getCallbacks() {
+  const holder = globalThis;
+  let state = holder[STATE_SLOT2];
+  if (!state) {
+    state = /* @__PURE__ */ new Map();
+    holder[STATE_SLOT2] = state;
+  }
+  return state;
+}
+function registerInvalidationCallback(name, callback) {
+  const callbacks = getCallbacks();
+  let set = callbacks.get(name);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    callbacks.set(name, set);
+  }
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+  };
+}
+function fireInvalidation(name, detail) {
+  const set = getCallbacks().get(name);
+  if (!set || set.size === 0) return false;
+  for (const callback of set) {
+    try {
+      callback(detail);
+    } catch (error) {
+      console.error(
+        `[invalidation-registry] callback for "${name}" threw`,
+        error
+      );
+    }
+  }
+  return true;
+}
+
+// src/delimiter-guard.ts
+var ZWSP = "\u200B";
+var ESCAPED_DOLLARS = `${ZWSP}$${ZWSP}$`;
+var ESCAPED_BRACKET = `${ZWSP}&#91;`;
+var MAX_MATH_SPAN = 600;
+var STRUCTURAL_MARKDOWN = /\]\(|https?:\/\/|\*\*|(?:^|\n)[ \t]{0,3}#{1,6}[ \t]|(?:^|\n)[ \t]*[-*+][ \t]+|(?:^|\n)[ \t]*\d+[.)][ \t]/;
+var LATEX_COMMAND = /\\[a-zA-Z]/;
+var PROSE_WORD = /[A-Za-z]{3,}/g;
+var PROSE_WORD_LIMIT = 6;
+function looksLikeMath(inner) {
+  const s = inner.trim();
+  if (!s) return false;
+  if (STRUCTURAL_MARKDOWN.test(s)) return false;
+  if (s.length > MAX_MATH_SPAN) return false;
+  if (LATEX_COMMAND.test(s)) {
+    return (s.match(PROSE_WORD) ?? []).length < PROSE_WORD_LIMIT * 3;
+  }
+  if (/\n[ \t]*\n/.test(s)) return false;
+  return (s.match(PROSE_WORD) ?? []).length < PROSE_WORD_LIMIT;
+}
+function protectedRanges(text) {
+  const ranges = [];
+  const patterns = [/```[\s\S]*?(?:```|$)/g, /~~~[\s\S]*?(?:~~~|$)/g, /`[^`\n]*`/g];
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      ranges.push([m.index, m.index + m[0].length]);
+    }
+  }
+  return ranges;
+}
+function isProtected(index, ranges) {
+  return ranges.some(([start, end]) => index >= start && index < end);
+}
+function preview(text, max = 160) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max)}\u2026` : flat;
+}
+function guardMathDelimiters(text) {
+  if (!text.includes("$$")) return { text, violations: [] };
+  const ranges = protectedRanges(text);
+  const tokens = [];
+  for (let i = 0; i < text.length - 1; i++) {
+    if (text[i] !== "$" || text[i + 1] !== "$") continue;
+    if (!isProtected(i, ranges)) tokens.push(i);
+    i++;
+  }
+  if (tokens.length === 0) return { text, violations: [] };
+  const violations = [];
+  const escapeAt = [];
+  let j = 0;
+  while (j < tokens.length) {
+    const open = tokens[j];
+    const close = tokens[j + 1];
+    if (close === void 0) {
+      violations.push({
+        reason: "unpaired",
+        index: open,
+        spanLength: 0,
+        // An unpaired `$$` is inert to remark-math (nothing closes it), so it
+        // is reported but NOT escaped — it already renders as literal text.
+        preview: preview(text.slice(open, open + 120))
+      });
+      break;
+    }
+    const inner = text.slice(open + 2, close);
+    if (looksLikeMath(inner)) {
+      j += 2;
+      continue;
+    }
+    escapeAt.push(open);
+    violations.push({
+      reason: "prose-span",
+      index: open,
+      spanLength: inner.length,
+      preview: preview(inner)
+    });
+    j += 1;
+  }
+  let guarded = text;
+  for (const index of [...escapeAt].sort((a, b) => b - a)) {
+    guarded = `${guarded.slice(0, index)}${ESCAPED_DOLLARS}${guarded.slice(index + 2)}`;
+  }
+  return { text: guarded, violations };
+}
+var MAX_LINK_LABEL = 200;
+var LABEL_BLOCK_STRUCTURE = /\n[ \t]*\n|(?:^|\n)[ \t]*[-*+][ \t]+|#{2,6}[ \t]/;
+function guardRunawayLinks(text) {
+  if (!text.includes("[")) return { text, violations: [] };
+  const ranges = protectedRanges(text);
+  const violations = [];
+  const escapeAt = [];
+  const linkRe = /\[((?:[^[\]]|\\.)*)\]\(([^\s)]*)/g;
+  let m;
+  while ((m = linkRe.exec(text)) !== null) {
+    const open = m.index;
+    if (isProtected(open, ranges)) continue;
+    const label = m[1] ?? "";
+    const runaway = label.length > MAX_LINK_LABEL || LABEL_BLOCK_STRUCTURE.test(label);
+    if (!runaway) continue;
+    escapeAt.push(open);
+    violations.push({
+      reason: "runaway-link",
+      index: open,
+      spanLength: label.length,
+      preview: preview(label)
+    });
+  }
+  let guarded = text;
+  for (const index of [...escapeAt].sort((a, b) => b - a)) {
+    guarded = `${guarded.slice(0, index)}${ESCAPED_BRACKET}${guarded.slice(index + 1)}`;
+  }
+  return { text: guarded, violations };
+}
+function guardMarkdownDelimiters(text) {
+  const math = guardMathDelimiters(text);
+  const links = guardRunawayLinks(math.text);
+  return {
+    text: links.text,
+    violations: [...math.violations, ...links.violations]
+  };
+}
+function reportDelimiterViolations(violations, context) {
+  if (violations.length === 0) return;
+  try {
+    const worst = violations.find((v) => v.reason !== "unpaired") ?? violations[0];
+    if (!worst) return;
+    const message = worst.reason === "prose-span" ? `Malformed math delimiters: a stray "$$" would have turned ${worst.spanLength} chars of prose into a math span (KaTeX would render it as red error text). Escaped it.` : worst.reason === "runaway-link" ? `Runaway markdown link: an unclosed "[" would have turned ${worst.spanLength} chars into one link label. Escaped it.` : `Malformed math delimiters: an unpaired "$$" reached the renderer.`;
+    console.warn(`[markdown-delimiter-guard] ${message}`, {
+      renderPath: context.renderPath,
+      violations
+    });
+    context.capture?.({
+      source: "markdown-delimiters",
+      message,
+      relation: `markdown:${context.renderPath}`,
+      details: worst.preview,
+      conversationId: context.conversationId,
+      callSite: "guardMarkdownDelimiters",
+      raw: { messageId: context.messageId, violations }
+    });
+  } catch {
+  }
+}
+
+// src/json-format/detect.ts
+import JSON5 from "json5";
+var FENCE_OPEN = /^([ \t]*)(`{3,}|~{3,})[ \t]*([^\s`~]*)[ \t]*$/;
+var JSON_FENCE_LANGS = /* @__PURE__ */ new Set(["json", "jsonc", "json5", "geojson", "jsonl"]);
+function splitFence(text) {
+  const lines = text.split("\n");
+  const openIdx = lines.findIndex((l) => FENCE_OPEN.test(l));
+  if (openIdx === -1) return null;
+  const open = FENCE_OPEN.exec(lines[openIdx] ?? "");
+  if (!open) return null;
+  const [, indent = "", marker = "```", lang = ""] = open;
+  const fenceChar = marker[0] ?? "`";
+  const closeRe = new RegExp(`^[ \\t]*\\${fenceChar}{${marker.length},}[ \\t]*$`);
+  let closeIdx = -1;
+  for (let i = openIdx + 1; i < lines.length; i++) {
+    if (closeRe.test(lines[i] ?? "")) {
+      closeIdx = i;
+      break;
+    }
+  }
+  const afterClose = closeIdx === -1 ? [] : lines.slice(closeIdx + 1);
+  if (afterClose.some((l) => FENCE_OPEN.test(l))) return null;
+  const bodyEnd = closeIdx === -1 ? lines.length : closeIdx;
+  return {
+    leading: openIdx > 0 ? `${lines.slice(0, openIdx).join("\n")}
+` : "",
+    payload: lines.slice(openIdx + 1, bodyEnd).join("\n"),
+    trailing: afterClose.length > 0 ? `
+${afterClose.join("\n")}` : "",
+    fence: {
+      marker,
+      lang: lang.toLowerCase(),
+      indent,
+      closed: closeIdx !== -1
+    }
+  };
+}
+function splitBare(text) {
+  const payload = text.trim();
+  if (payload === "") {
+    return { leading: text, payload: "", trailing: "", fence: null };
+  }
+  const start = text.indexOf(payload);
+  return {
+    leading: text.slice(0, start),
+    payload,
+    trailing: text.slice(start + payload.length),
+    fence: null
+  };
+}
+function rootKindOf(value) {
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "object" && value !== null) return "object";
+  return "scalar";
+}
+function isBracketShaped(payload) {
+  const first = payload[0];
+  const last = payload[payload.length - 1];
+  if (payload.length < 2) return false;
+  return first === "{" && last === "}" || first === "[" && last === "]";
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : "Invalid JSON";
+}
+function countLines(s) {
+  if (s === "") return 0;
+  let n = 1;
+  for (let i = 0; i < s.length; i++) if (s[i] === "\n") n++;
+  return n;
+}
+function detectJson(text) {
+  const split = splitFence(text) ?? splitBare(text);
+  const payload = split.fence ? split.payload.trim() : split.payload;
+  const fenceSaysJson = split.fence !== null && (split.fence.lang === "" || JSON_FENCE_LANGS.has(split.fence.lang));
+  const base = {
+    fence: split.fence,
+    leading: split.leading,
+    trailing: split.trailing,
+    payload,
+    lineCount: countLines(payload),
+    charCount: payload.length
+  };
+  if (payload === "") {
+    return { ...base, ok: false, looksLikeJson: false };
+  }
+  if (split.fence !== null && !fenceSaysJson) {
+    return { ...base, ok: false, looksLikeJson: false };
+  }
+  const shaped = isBracketShaped(payload);
+  let value;
+  let parser;
+  let error;
+  try {
+    value = JSON.parse(payload);
+    parser = "strict";
+  } catch (strictErr) {
+    try {
+      value = JSON5.parse(payload);
+      parser = "tolerant";
+    } catch {
+      error = errorMessage(strictErr);
+    }
+  }
+  if (value === void 0 || parser === void 0) {
+    return { ...base, ok: false, looksLikeJson: shaped, error };
+  }
+  const root = rootKindOf(value);
+  const worthOffering = root !== "scalar" || fenceSaysJson;
+  return { ...base, ok: true, looksLikeJson: worthOffering, value, parser, root };
+}
+
+// src/json-format/json-value.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+// src/json-format/format.ts
+var DEFAULT_JSON_INDENT = 2;
+var DEFAULT_JSON_WIDTH = 100;
+function orderedKeys(obj, sortKeys) {
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0);
+  return sortKeys ? [...keys].sort((a, b) => a.localeCompare(b)) : keys;
+}
+function writeScalar(value) {
+  return JSON.stringify(value) ?? "null";
+}
+function flatten(value, cfg) {
+  if (isJsonArray(value)) {
+    if (value.length === 0) return "[]";
+    const parts = value.map((v) => flatten(v ?? null, cfg));
+    return cfg.spaced ? `[${parts.join(", ")}]` : `[${parts.join(",")}]`;
+  }
+  if (isJsonObject(value)) {
+    const keys = orderedKeys(value, cfg.sortKeys);
+    if (keys.length === 0) return "{}";
+    const colon = cfg.spaced ? ": " : ":";
+    const parts = keys.map(
+      (k) => `${JSON.stringify(k)}${colon}${flatten(value[k] ?? null, cfg)}`
+    );
+    return cfg.spaced ? `{ ${parts.join(", ")} }` : `{${parts.join(",")}}`;
+  }
+  return writeScalar(value);
+}
+function layoutEntries(entries, pad, cfg) {
+  if (!cfg.pack) return entries.map((e) => pad + e);
+  const lines = [];
+  let current = "";
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i] ?? "";
+    const isLast = i === entries.length - 1;
+    const piece = isLast ? entry : `${entry},`;
+    if (entry.includes("\n")) {
+      if (current !== "") {
+        lines.push(pad + current);
+        current = "";
+      }
+      lines.push(pad + piece);
+      continue;
+    }
+    if (current === "") {
+      current = piece;
+      continue;
+    }
+    const merged = `${current} ${piece}`;
+    if (pad.length + merged.length <= cfg.width) {
+      current = merged;
+    } else {
+      lines.push(pad + current);
+      current = piece;
+    }
+  }
+  if (current !== "") lines.push(pad + current);
+  return lines;
+}
+function renderNode(value, level, used, cfg) {
+  const isContainer = isJsonArray(value) || isJsonObject(value);
+  if (!isContainer) return writeScalar(value);
+  const flat = flatten(value, cfg);
+  if (flat === "[]" || flat === "{}") return flat;
+  if (cfg.width >= 0 && used + flat.length <= cfg.width) return flat;
+  const pad = " ".repeat((level + 1) * cfg.indent);
+  const closePad = " ".repeat(level * cfg.indent);
+  if (isJsonArray(value)) {
+    const entries2 = value.map(
+      (v) => renderNode(v ?? null, level + 1, pad.length, cfg)
+    );
+    const body2 = layoutEntries(entries2, pad, cfg);
+    const joined2 = cfg.pack ? body2.join("\n") : body2.join(",\n");
+    return `[
+${joined2}
+${closePad}]`;
+  }
+  const keys = orderedKeys(value, cfg.sortKeys);
+  const entries = keys.map((k) => {
+    const prefix = `${JSON.stringify(k)}: `;
+    const rendered = renderNode(
+      value[k] ?? null,
+      level + 1,
+      pad.length + prefix.length,
+      cfg
+    );
+    return prefix + rendered;
+  });
+  const body = layoutEntries(entries, pad, cfg);
+  const joined = cfg.pack ? body.join("\n") : body.join(",\n");
+  return `{
+${joined}
+${closePad}}`;
+}
+function stringifyJson(value, options) {
+  const indent = options.indent ?? DEFAULT_JSON_INDENT;
+  const sortKeys = options.sortKeys ?? false;
+  if (options.style === "minify") {
+    return flatten(value, { indent, width: -1, pack: false, spaced: false, sortKeys });
+  }
+  const cfg = {
+    indent,
+    width: options.style === "pretty" ? -1 : options.width ?? DEFAULT_JSON_WIDTH,
+    pack: options.style === "compact",
+    spaced: true,
+    sortKeys
+  };
+  return renderNode(value, 0, 0, cfg);
+}
+function sizeOf(text) {
+  let lines = text === "" ? 0 : 1;
+  for (let i = 0; i < text.length; i++) if (text[i] === "\n") lines++;
+  return { lines, chars: text.length };
+}
+function reassemble(detection, payload, mode) {
+  const { fence, leading, trailing } = detection;
+  const keepFence = mode === "add" || mode === "preserve" && fence !== null;
+  if (!keepFence) {
+    return leading + payload + trailing;
+  }
+  const marker = fence?.marker ?? "```";
+  const lang = fence?.lang && fence.lang !== "" ? fence.lang : "json";
+  const indent = fence?.indent ?? "";
+  const body = indent ? payload.split("\n").map((l) => l === "" ? l : indent + l).join("\n") : payload;
+  const close = fence !== null && !fence.closed ? "" : `
+${indent}${marker}`;
+  return `${leading}${indent}${marker}${lang}
+${body}${close}${trailing}`;
+}
+function formatJsonText(text, options) {
+  const detection = detectJson(text);
+  const before = sizeOf(text);
+  if (!detection.ok || detection.value === void 0) {
+    return {
+      ok: false,
+      text,
+      error: detection.error ?? "Selection is not JSON.",
+      changed: false,
+      detection,
+      before,
+      after: before
+    };
+  }
+  const payload = stringifyJson(detection.value, options);
+  const next = reassemble(detection, payload, options.fence ?? "preserve");
+  return {
+    ok: true,
+    text: next,
+    changed: next !== text,
+    detection,
+    before,
+    after: sizeOf(next)
+  };
+}
+
+// src/idle-scheduler/scheduler.ts
+var STATE_SLOT3 = /* @__PURE__ */ Symbol.for("ai-matrx.kit.idle-scheduler-state");
+function getState2() {
+  const holder = globalThis;
+  let state = holder[STATE_SLOT3];
+  if (!state) {
+    state = {
+      queue: /* @__PURE__ */ new Map(),
+      flushState: "idle",
+      cleanupFns: [],
+      flushListeners: /* @__PURE__ */ new Set()
+    };
+    holder[STATE_SLOT3] = state;
+    if (typeof window !== "undefined") {
+      window.__idleSched = getSchedulerState;
+    }
+  }
+  return state;
+}
+function registerIdleTask(key, priority, callback) {
+  const state = getState2();
+  if (state.flushState === "done") {
+    scheduleImmediate(callback);
+    return () => {
+    };
+  }
+  state.queue.set(key, { key, priority, callback });
+  if (state.flushState === "idle") {
+    startFlushPipeline(state);
+  }
+  return () => {
+    state.queue.delete(key);
+  };
+}
+function onFlushComplete(listener) {
+  const state = getState2();
+  if (state.flushState === "done") {
+    queueMicrotask(listener);
+    return () => {
+    };
+  }
+  state.flushListeners.add(listener);
+  if (state.flushState === "idle") {
+    startFlushPipeline(state);
+  }
+  return () => {
+    state.flushListeners.delete(listener);
+  };
+}
+function whenPageIdle(signal) {
+  if (signal?.aborted) return Promise.resolve(false);
+  return new Promise((resolve) => {
+    let settled = false;
+    let unsubscribe = () => {
+    };
+    const finish = (ready) => {
+      if (settled) return;
+      settled = true;
+      unsubscribe();
+      signal?.removeEventListener("abort", onAbort);
+      resolve(ready);
+    };
+    const onAbort = () => finish(false);
+    unsubscribe = onFlushComplete(() => finish(true));
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function getSchedulerState() {
+  const state = getState2();
+  return {
+    flushState: state.flushState,
+    pendingCount: state.queue.size,
+    pendingKeys: Array.from(state.queue.keys())
+  };
+}
+function resetScheduler() {
+  const state = getState2();
+  state.cleanupFns.forEach((fn) => fn());
+  state.cleanupFns = [];
+  state.queue.clear();
+  state.flushListeners.clear();
+  state.flushState = "idle";
+}
+function startFlushPipeline(state) {
+  if (typeof window === "undefined") return;
+  state.flushState = "waiting";
+  const waitForLoad = () => {
+    if (document.readyState === "complete") {
+      waitForPaint();
+    } else {
+      const onLoad = () => waitForPaint();
+      window.addEventListener("load", onLoad, { once: true });
+      state.cleanupFns.push(() => window.removeEventListener("load", onLoad));
+    }
+  };
+  const waitForPaint = () => {
+    let advanced = false;
+    const advance = () => {
+      if (advanced) return;
+      advanced = true;
+      waitForIdle();
+    };
+    const rafId = requestAnimationFrame(advance);
+    const timeoutId = setTimeout(
+      advance,
+      document.visibilityState === "hidden" ? 250 : 1500
+    );
+    state.cleanupFns.push(() => {
+      cancelAnimationFrame(rafId);
+      clearTimeout(timeoutId);
+    });
+  };
+  const waitForIdle = () => {
+    const schedulerGlobal = globalThis.scheduler;
+    if (schedulerGlobal && "postTask" in schedulerGlobal) {
+      schedulerGlobal.postTask(() => void flush(state), { priority: "background" }).catch(() => {
+      });
+      return;
+    }
+    if ("requestIdleCallback" in window) {
+      const idleId = requestIdleCallback(() => void flush(state));
+      state.cleanupFns.push(() => cancelIdleCallback(idleId));
+      return;
+    }
+    const channel = new MessageChannel();
+    channel.port1.onmessage = () => void flush(state);
+    channel.port2.postMessage(void 0);
+  };
+  waitForLoad();
+}
+async function flush(state) {
+  if (state.flushState === "done" || state.flushState === "flushing") return;
+  state.flushState = "flushing";
+  const sorted = Array.from(state.queue.values()).sort(
+    (a, b) => a.priority - b.priority
+  );
+  state.queue.clear();
+  for (const task of sorted) {
+    try {
+      await task.callback();
+    } catch (err) {
+      console.error(`[IdleScheduler] Task "${task.key}" failed:`, err);
+    }
+  }
+  state.flushState = "done";
+  if (state.queue.size > 0) {
+    const late = Array.from(state.queue.values()).sort(
+      (a, b) => a.priority - b.priority
+    );
+    state.queue.clear();
+    for (const task of late) scheduleImmediate(task.callback);
+  }
+  state.flushListeners.forEach((listener) => {
+    try {
+      listener();
+    } catch (err) {
+      console.error("[IdleScheduler] Flush listener failed:", err);
+    }
+  });
+  state.flushListeners.clear();
+}
+function scheduleImmediate(callback) {
+  requestAnimationFrame(() => {
+    const schedulerGlobal = globalThis.scheduler;
+    if (schedulerGlobal && "postTask" in schedulerGlobal) {
+      schedulerGlobal.postTask(() => void callback(), { priority: "background" }).catch(() => {
+      });
+      return;
+    }
+    if ("requestIdleCallback" in window) {
+      requestIdleCallback(() => void callback());
+      return;
+    }
+    const channel = new MessageChannel();
+    channel.port1.onmessage = () => void callback();
+    channel.port2.postMessage(void 0);
+  });
+}
+
+// src/idle-scheduler/hooks.ts
+import { useEffect as useEffect4, useRef as useRef5, useState as useState5, useCallback as useCallback4 } from "react";
+function useIdleTask(key, priority, callback) {
+  const callbackRef = useRef5(callback);
+  callbackRef.current = callback;
+  useEffect4(() => {
+    const unregister = registerIdleTask(key, priority, () => {
+      return callbackRef.current();
+    });
+    return unregister;
+  }, [key, priority]);
+}
+function useIdleReady() {
+  const [ready, setReady] = useState5(false);
+  useEffect4(() => {
+    const unsubscribe = onFlushComplete(() => {
+      setReady(true);
+    });
+    return unsubscribe;
+  }, []);
+  return ready;
+}
+function useIdleGate(key, priority, callback) {
+  const [ready, setReady] = useState5(false);
+  const callbackRef = useRef5(callback);
+  callbackRef.current = callback;
+  useEffect4(() => {
+    const unregister = registerIdleTask(key, priority, async () => {
+      await callbackRef.current();
+      setReady(true);
+    });
+    return unregister;
+  }, [key, priority]);
+  return { ready };
+}
+function useIdleRegister() {
+  const unregisterRefs = useRef5(/* @__PURE__ */ new Map());
+  useEffect4(() => {
+    const refs = unregisterRefs.current;
+    return () => {
+      refs.forEach((unregister) => unregister());
+      refs.clear();
+    };
+  }, []);
+  return useCallback4(
+    (key, priority, callback) => {
+      unregisterRefs.current.get(key)?.();
+      const unregister = registerIdleTask(key, priority, callback);
+      unregisterRefs.current.set(key, unregister);
+    },
+    []
+  );
+}
+
+// src/url-state.ts
+import {
+  useCallback as useCallback5,
+  useEffect as useEffect5,
+  useMemo,
+  useRef as useRef6,
+  useState as useState6,
+  useSyncExternalStore
+} from "react";
+var URL_STATE_EVENT = "matrx:url-state";
+var ROUTER_SLOT = /* @__PURE__ */ Symbol.for("ai-matrx.kit.url-state-router");
+function getRouter() {
+  return globalThis[ROUTER_SLOT] ?? null;
+}
+function setUrlStateRouter(router) {
+  globalThis[ROUTER_SLOT] = router;
+}
+function currentLocation() {
+  const custom = getRouter()?.getLocation;
+  if (custom) return custom();
+  return {
+    pathname: window.location.pathname,
+    search: window.location.search,
+    hash: window.location.hash
+  };
+}
+function subscribeToUrl(listener) {
+  window.addEventListener("popstate", listener);
+  window.addEventListener(URL_STATE_EVENT, listener);
+  return () => {
+    window.removeEventListener("popstate", listener);
+    window.removeEventListener(URL_STATE_EVENT, listener);
+  };
+}
+function getUrlSnapshot() {
+  return currentLocation().search;
+}
+function getServerUrlSnapshot() {
+  return "";
+}
+function useUrlSearchParams() {
+  const search = useSyncExternalStore(
+    subscribeToUrl,
+    getUrlSnapshot,
+    getServerUrlSnapshot
+  );
+  return useMemo(() => new URLSearchParams(search), [search]);
+}
+function commitUrlParams(patch, history) {
+  const location = currentLocation();
+  const params = new URLSearchParams(location.search);
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === null || value === "") params.delete(key);
+    else params.set(key, value);
+  }
+  const query = params.toString();
+  const next = `${location.pathname}${query ? `?${query}` : ""}${location.hash}`;
+  const current = `${location.pathname}${location.search}${location.hash}`;
+  if (next === current) return;
+  const router = getRouter();
+  if (router) {
+    if (history === "replace") router.replace(next);
+    else router.push(next);
+  } else if (history === "replace") {
+    window.history.replaceState(window.history.state, "", next);
+  } else {
+    window.history.pushState(window.history.state, "", next);
+  }
+  window.dispatchEvent(new Event(URL_STATE_EVENT));
+}
+function historyModeForParamChange(current, next, textKeys) {
+  const keys = /* @__PURE__ */ new Set([...current.keys(), ...next.keys()]);
+  const changed = [...keys].filter(
+    (key) => current.get(key) !== next.get(key)
+  );
+  if (changed.length === 0) return "replace";
+  return changed.every((key) => textKeys.includes(key)) ? "replace" : "push";
+}
+function useUrlState(key, codec) {
+  const searchParams = useUrlSearchParams();
+  const value = codec.parse(searchParams.get(key));
+  const setValue = (next, options) => {
+    commitUrlParams(
+      { [key]: codec.serialize(next) },
+      options?.history ?? "push"
+    );
+  };
+  return [value, setValue];
+}
+function stringUrlCodec(defaultValue = "") {
+  return {
+    defaultValue,
+    parse: (raw) => raw ?? defaultValue,
+    serialize: (value) => value === defaultValue ? null : value
+  };
+}
+function enumUrlCodec(values, defaultValue) {
+  const allowed = new Set(values);
+  return {
+    defaultValue,
+    parse: (raw) => raw && allowed.has(raw) ? raw : defaultValue,
+    serialize: (value) => value === defaultValue ? null : value
+  };
+}
+function booleanUrlCodec(defaultValue = false) {
+  return {
+    defaultValue,
+    parse: (raw) => raw === null ? defaultValue : raw === "1",
+    serialize: (value) => value === defaultValue ? null : value ? "1" : "0"
+  };
+}
+function positiveIntegerUrlCodec(defaultValue) {
+  return {
+    defaultValue,
+    parse: (raw) => {
+      const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultValue;
+    },
+    serialize: (value) => value === defaultValue || !Number.isFinite(value) || value <= 0 ? null : String(Math.trunc(value))
+  };
+}
+function jsonUrlCodec(defaultValue, isValid) {
+  return {
+    defaultValue,
+    parse: (raw) => {
+      if (!raw) return defaultValue;
+      try {
+        const parsed = JSON.parse(raw);
+        return isValid(parsed) ? parsed : defaultValue;
+      } catch {
+        return defaultValue;
+      }
+    },
+    serialize: (value) => JSON.stringify(value) === JSON.stringify(defaultValue) ? null : JSON.stringify(value)
+  };
+}
+function useMirroredUrlState(options) {
+  const { parse, toParams, isSame, textKeys = [], resetKey } = options;
+  const params = useUrlSearchParams();
+  const optionsRef = useRef6(options);
+  optionsRef.current = options;
+  const [value, setValue] = useState6(
+    () => parse(
+      typeof window === "undefined" ? new URLSearchParams() : new URLSearchParams(currentLocation().search)
+    )
+  );
+  useEffect5(() => {
+    if (typeof window === "undefined") return;
+    const current = new URLSearchParams(currentLocation().search);
+    const patch = optionsRef.current.toParams(value);
+    const next = new URLSearchParams(current);
+    for (const [key, v] of Object.entries(patch)) {
+      if (v === null || v === "") next.delete(key);
+      else next.set(key, v);
+    }
+    if (next.toString() === current.toString()) return;
+    commitUrlParams(patch, historyModeForParamChange(current, next, textKeys));
+  }, [value]);
+  useEffect5(() => {
+    const fromUrl = optionsRef.current.parse(
+      new URLSearchParams(currentLocation().search)
+    );
+    setValue((prev) => optionsRef.current.isSame(prev, fromUrl) ? prev : fromUrl);
+  }, [params]);
+  const previousResetKey = useRef6(resetKey);
+  useEffect5(() => {
+    const previous = previousResetKey.current;
+    previousResetKey.current = resetKey;
+    if (previous === resetKey) return;
+    if (previous === void 0 || previous === "") return;
+    if (resetKey === void 0 || resetKey === "") return;
+    const cleared = optionsRef.current.parse(new URLSearchParams());
+    setValue(cleared);
+    commitUrlParams(optionsRef.current.toParams(cleared), "replace");
+  }, [resetKey]);
+  const update = useCallback5((updater) => {
+    setValue(
+      (prev) => typeof updater === "function" ? updater(prev) : updater
+    );
+  }, []);
+  return [value, update];
+}
+
+// src/idb-store/store-manager.ts
+import { openDB } from "idb";
+var DBStoreManager = class {
+  db = null;
+  dbName;
+  version;
+  constructor(dbName, version2) {
+    this.dbName = dbName;
+    this.version = version2;
+  }
+  async initDB() {
+    if (this.db) return;
+    try {
+      this.db = await openDB(this.dbName, this.version, {
+        upgrade: (db) => {
+          this.setupStores(db);
+        }
+      });
+    } catch (error) {
+      console.error("Failed to initialize database:", error);
+      throw error;
+    }
+  }
+  // `add`/`get` carry their own generic (like `query` below) so a subclass
+  // whose `T` covers one IDB object store (e.g. Recording) can still read/write
+  // a different store's record shape (e.g. RecordingChunk) without a cast —
+  // see the audio store in the original host, which manages both `recordings`
+  // and `chunks` stores.
+  async add(storeName, data) {
+    try {
+      if (!this.db) throw new Error("Database not initialized");
+      const id = await this.db.add(storeName, data);
+      return { data: id.toString(), error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async get(storeName, id) {
+    try {
+      if (!this.db) throw new Error("Database not initialized");
+      const result = await this.db.get(storeName, id);
+      return { data: result, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async getAll(storeName) {
+    try {
+      if (!this.db) throw new Error("Database not initialized");
+      const result = await this.db.getAll(storeName);
+      return { data: result, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async update(storeName, id, data) {
+    try {
+      if (!this.db) throw new Error("Database not initialized");
+      const existing = await this.db.get(storeName, id);
+      if (!existing) throw new Error("Record not found");
+      const updated = { ...existing, ...data };
+      await this.db.put(storeName, updated);
+      return { data: true, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async delete(storeName, id) {
+    try {
+      if (!this.db) throw new Error("Database not initialized");
+      await this.db.delete(storeName, id);
+      return { data: true, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async query(storeName, indexName, query) {
+    try {
+      if (!this.db) throw new Error("Database not initialized");
+      const result = await this.db.getAllFromIndex(storeName, indexName, query);
+      return { data: result, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/idb-store/store-interface.ts
+var PublicStoreManager = class extends DBStoreManager {
+  constructor(dbName, version2) {
+    super(dbName, version2);
+  }
+  addItem(storeName, data) {
+    return this.add(storeName, data);
+  }
+  getItem(storeName, id) {
+    return this.get(storeName, id);
+  }
+  getAllItems(storeName) {
+    return this.getAll(storeName);
+  }
+  updateItem(storeName, id, data) {
+    return this.update(storeName, id, data);
+  }
+  deleteItem(storeName, id) {
+    return this.delete(storeName, id);
+  }
+  queryItems(storeName, indexName, query) {
+    return this.query(storeName, indexName, query);
+  }
+};
+
+// src/idb-store/feature-store.ts
+var FeatureStore = class extends PublicStoreManager {
+  storeName;
+  constructor(dbName, version2, storeName) {
+    super(dbName, version2);
+    this.storeName = storeName;
+    this.initDB().catch(() => {
+    });
+  }
+  getStoreName() {
+    return this.storeName;
+  }
+};
+
+// src/idb-store/singleton.ts
+var STATE_SLOT4 = /* @__PURE__ */ Symbol.for("ai-matrx.kit.idb-store-state");
+function getState3() {
+  const holder = globalThis;
+  let state = holder[STATE_SLOT4];
+  if (!state) {
+    state = { instances: /* @__PURE__ */ new Map() };
+    holder[STATE_SLOT4] = state;
+  }
+  return state;
+}
+function getIdbStoreSingleton(key, create) {
+  const state = getState3();
+  if (!state.instances.has(key)) {
+    state.instances.set(key, create());
+  }
+  return state.instances.get(key);
+}
+function _resetIdbStoreSingletons() {
+  getState3().instances.clear();
+}
+
+// src/color-util/lab-delta.ts
+function round(value, digits = 0) {
+  const factor = Math.pow(10, digits);
+  return Math.round(factor * value) / factor + 0;
+}
+function clamp(value, min = 0, max = 1) {
+  return value > max ? max : value > min ? value : min;
+}
+function linearize(channel) {
+  const c = channel / 255;
+  return c < 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+var WHITE_X = 96.422;
+var WHITE_Y = 100;
+var WHITE_Z = 82.521;
+var EPSILON = 216 / 24389;
+var KAPPA = 24389 / 27;
+function rgbToXyz(rgb) {
+  const r = linearize(rgb.r);
+  const g = linearize(rgb.g);
+  const b = linearize(rgb.b);
+  const d65 = {
+    x: 100 * (0.4124564 * r + 0.3575761 * g + 0.1804375 * b),
+    y: 100 * (0.2126729 * r + 0.7151522 * g + 0.072175 * b),
+    z: 100 * (0.0193339 * r + 0.119192 * g + 0.9503041 * b)
+  };
+  const d50 = {
+    x: 1.0478112 * d65.x + 0.0228866 * d65.y + -0.050127 * d65.z,
+    y: 0.0295424 * d65.x + 0.9904844 * d65.y + -0.0170491 * d65.z,
+    z: -92345e-7 * d65.x + 0.0150436 * d65.y + 0.7521316 * d65.z
+  };
+  return {
+    x: clamp(d50.x, 0, WHITE_X),
+    y: clamp(d50.y, 0, WHITE_Y),
+    z: clamp(d50.z, 0, WHITE_Z)
+  };
+}
+function rgbToLab(rgb) {
+  const xyz = rgbToXyz(rgb);
+  let x = xyz.x / WHITE_X;
+  let y = xyz.y / WHITE_Y;
+  let z = xyz.z / WHITE_Z;
+  x = x > EPSILON ? Math.cbrt(x) : (KAPPA * x + 16) / 116;
+  y = y > EPSILON ? Math.cbrt(y) : (KAPPA * y + 16) / 116;
+  z = z > EPSILON ? Math.cbrt(z) : (KAPPA * z + 16) / 116;
+  return {
+    l: round(116 * y - 16, 2),
+    a: round(500 * (x - y), 2),
+    b: round(200 * (y - z), 2)
+  };
+}
+function ciede2000(lab1, lab2) {
+  const { l: l1, a: a1, b: b1 } = lab1;
+  const { l: l2, a: a2, b: b2 } = lab2;
+  const toDeg = 180 / Math.PI;
+  const toRad = Math.PI / 180;
+  const c1 = Math.pow(Math.pow(a1, 2) + Math.pow(b1, 2), 0.5);
+  const c2 = Math.pow(Math.pow(a2, 2) + Math.pow(b2, 2), 0.5);
+  const lBar = (l1 + l2) / 2;
+  const cBar7 = Math.pow((c1 + c2) / 2, 7);
+  const g = 0.5 * (1 - Math.pow(cBar7 / (cBar7 + Math.pow(25, 7)), 0.5));
+  const a1p = a1 * (1 + g);
+  const a2p = a2 * (1 + g);
+  const c1p = Math.pow(Math.pow(a1p, 2) + Math.pow(b1, 2), 0.5);
+  const c2p = Math.pow(Math.pow(a2p, 2) + Math.pow(b2, 2), 0.5);
+  const cBarP = (c1p + c2p) / 2;
+  let h1p = a1p === 0 && b1 === 0 ? 0 : Math.atan2(b1, a1p) * toDeg;
+  let h2p = a2p === 0 && b2 === 0 ? 0 : Math.atan2(b2, a2p) * toDeg;
+  if (h1p < 0) h1p += 360;
+  if (h2p < 0) h2p += 360;
+  let dhp = h2p - h1p;
+  const hAbs = Math.abs(h2p - h1p);
+  if (hAbs > 180 && h2p <= h1p) {
+    dhp += 360;
+  } else if (hAbs > 180 && h2p > h1p) {
+    dhp -= 360;
+  }
+  let hBarP = h1p + h2p;
+  if (hAbs <= 180) {
+    hBarP /= 2;
+  } else {
+    hBarP = (h1p + h2p < 360 ? hBarP + 360 : hBarP - 360) / 2;
+  }
+  const t = 1 - 0.17 * Math.cos(toRad * (hBarP - 30)) + 0.24 * Math.cos(2 * toRad * hBarP) + 0.32 * Math.cos(toRad * (3 * hBarP + 6)) - 0.2 * Math.cos(toRad * (4 * hBarP - 63));
+  const dL = l2 - l1;
+  const dCp = c2p - c1p;
+  const dHp = 2 * Math.sin(toRad * dhp / 2) * Math.pow(c1p * c2p, 0.5);
+  const sl = 1 + 0.015 * Math.pow(lBar - 50, 2) / Math.pow(20 + Math.pow(lBar - 50, 2), 0.5);
+  const sc = 1 + 0.045 * cBarP;
+  const sh = 1 + 0.015 * cBarP * t;
+  const dTheta = 30 * Math.exp(-1 * Math.pow((hBarP - 275) / 25, 2));
+  const cBarP7 = Math.pow(cBarP, 7);
+  const rt = -2 * Math.pow(cBarP7 / (cBarP7 + Math.pow(25, 7)), 0.5) * Math.sin(2 * toRad * dTheta);
+  return Math.pow(
+    Math.pow(dL / 1 / sl, 2) + Math.pow(dCp / 1 / sc, 2) + Math.pow(dHp / 1 / sh, 2) + rt * dCp * dHp / (1 * sc * 1 * sh),
+    0.5
+  );
+}
+function rgbDelta(rgb1, rgb2) {
+  return clamp(round(ciede2000(rgbToLab(rgb1), rgbToLab(rgb2)) / 100, 3));
+}
+var HEX_RE = /^#?([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var RGB_FN_RE = /^rgba?\(\s*([+-]?[\d.]+)\s*[,\s]\s*([+-]?[\d.]+)\s*[,\s]\s*([+-]?[\d.]+)(?:\s*[,/]\s*[+-]?[\d.]+%?)?\s*\)$/i;
+function parseHexOrRgb(input) {
+  const text = input.trim();
+  const hexMatch = text.match(HEX_RE);
+  if (hexMatch) {
+    const hex = hexMatch[1];
+    if (hex.length === 3 || hex.length === 4) {
+      return {
+        r: parseInt(hex[0] + hex[0], 16),
+        g: parseInt(hex[1] + hex[1], 16),
+        b: parseInt(hex[2] + hex[2], 16)
+      };
+    }
+    return {
+      r: parseInt(hex.slice(0, 2), 16),
+      g: parseInt(hex.slice(2, 4), 16),
+      b: parseInt(hex.slice(4, 6), 16)
+    };
+  }
+  const rgbMatch = text.match(RGB_FN_RE);
+  if (rgbMatch) {
+    const r = Number(rgbMatch[1]);
+    const g = Number(rgbMatch[2]);
+    const b = Number(rgbMatch[3]);
+    if ([r, g, b].some((v) => Number.isNaN(v))) return null;
+    return { r: clamp(r, 0, 255), g: clamp(g, 0, 255), b: clamp(b, 0, 255) };
+  }
+  return null;
+}
+
+// src/color-util/tailwind-colors.ts
+var tailwindColors = [
+  {
+    name: "Slate",
+    shades: {
+      "50": "#f8fafc",
+      "100": "#f1f5f9",
+      "200": "#e2e8f0",
+      "300": "#cbd5e1",
+      "400": "#94a3b8",
+      "500": "#64748b",
+      "600": "#475569",
+      "700": "#334155",
+      "800": "#1e293b",
+      "900": "#0f172a",
+      "950": "#020617"
+    }
+  },
+  {
+    name: "Gray",
+    shades: {
+      "50": "#f9fafb",
+      "100": "#f3f4f6",
+      "200": "#e5e7eb",
+      "300": "#d1d5db",
+      "400": "#9ca3af",
+      "500": "#6b7280",
+      "600": "#4b5563",
+      "700": "#374151",
+      "800": "#1f2937",
+      "900": "#111827",
+      "950": "#030712"
+    }
+  },
+  {
+    name: "Zinc",
+    shades: {
+      "50": "#fafafa",
+      "100": "#f4f4f5",
+      "200": "#e4e4e7",
+      "300": "#d4d4d8",
+      "400": "#a1a1aa",
+      "500": "#71717a",
+      "600": "#52525b",
+      "700": "#3f3f46",
+      "800": "#27272a",
+      "900": "#18181b",
+      "950": "#09090b"
+    }
+  },
+  {
+    name: "Neutral",
+    shades: {
+      "50": "#fafafa",
+      "100": "#f5f5f5",
+      "200": "#e5e5e5",
+      "300": "#d4d4d4",
+      "400": "#a3a3a3",
+      "500": "#737373",
+      "600": "#525252",
+      "700": "#404040",
+      "800": "#262626",
+      "900": "#171717",
+      "950": "#0a0a0a"
+    }
+  },
+  {
+    name: "Stone",
+    shades: {
+      "50": "#fafaf9",
+      "100": "#f5f5f4",
+      "200": "#e7e5e4",
+      "300": "#d6d3d1",
+      "400": "#a8a29e",
+      "500": "#78716c",
+      "600": "#57534e",
+      "700": "#44403c",
+      "800": "#292524",
+      "900": "#1c1917",
+      "950": "#0c0a09"
+    }
+  },
+  {
+    name: "Red",
+    shades: {
+      "50": "#fef2f2",
+      "100": "#fee2e2",
+      "200": "#fecaca",
+      "300": "#fca5a5",
+      "400": "#f87171",
+      "500": "#ef4444",
+      "600": "#dc2626",
+      "700": "#b91c1c",
+      "800": "#991b1b",
+      "900": "#7f1d1d",
+      "950": "#450a0a"
+    }
+  },
+  {
+    name: "Orange",
+    shades: {
+      "50": "#fff7ed",
+      "100": "#ffedd5",
+      "200": "#fed7aa",
+      "300": "#fdba74",
+      "400": "#fb923c",
+      "500": "#f97316",
+      "600": "#ea580c",
+      "700": "#c2410c",
+      "800": "#9a3412",
+      "900": "#7c2d12",
+      "950": "#431407"
+    }
+  },
+  {
+    name: "Amber",
+    shades: {
+      "50": "#fffbeb",
+      "100": "#fef3c7",
+      "200": "#fde68a",
+      "300": "#fcd34d",
+      "400": "#fbbf24",
+      "500": "#f59e0b",
+      "600": "#d97706",
+      "700": "#b45309",
+      "800": "#92400e",
+      "900": "#78350f",
+      "950": "#451a03"
+    }
+  },
+  {
+    name: "Yellow",
+    shades: {
+      "50": "#fefce8",
+      "100": "#fef9c3",
+      "200": "#fef08a",
+      "300": "#fde047",
+      "400": "#facc15",
+      "500": "#eab308",
+      "600": "#ca8a04",
+      "700": "#a16207",
+      "800": "#854d0e",
+      "900": "#713f12",
+      "950": "#422006"
+    }
+  },
+  {
+    name: "Lime",
+    shades: {
+      "50": "#f7fee7",
+      "100": "#ecfccb",
+      "200": "#d9f99d",
+      "300": "#bef264",
+      "400": "#a3e635",
+      "500": "#84cc16",
+      "600": "#65a30d",
+      "700": "#4d7c0f",
+      "800": "#3f6212",
+      "900": "#365314",
+      "950": "#1a2e05"
+    }
+  },
+  {
+    name: "Green",
+    shades: {
+      "50": "#f0fdf4",
+      "100": "#dcfce7",
+      "200": "#bbf7d0",
+      "300": "#86efac",
+      "400": "#4ade80",
+      "500": "#22c55e",
+      "600": "#16a34a",
+      "700": "#15803d",
+      "800": "#166534",
+      "900": "#14532d",
+      "950": "#052e16"
+    }
+  },
+  {
+    name: "Emerald",
+    shades: {
+      "50": "#ecfdf5",
+      "100": "#d1fae5",
+      "200": "#a7f3d0",
+      "300": "#6ee7b7",
+      "400": "#34d399",
+      "500": "#10b981",
+      "600": "#059669",
+      "700": "#047857",
+      "800": "#065f46",
+      "900": "#064e3b",
+      "950": "#022c22"
+    }
+  },
+  {
+    name: "Teal",
+    shades: {
+      "50": "#f0fdfa",
+      "100": "#ccfbf1",
+      "200": "#99f6e4",
+      "300": "#5eead4",
+      "400": "#2dd4bf",
+      "500": "#14b8a6",
+      "600": "#0d9488",
+      "700": "#0f766e",
+      "800": "#115e59",
+      "900": "#134e4a",
+      "950": "#042f2e"
+    }
+  },
+  {
+    name: "Cyan",
+    shades: {
+      "50": "#ecfeff",
+      "100": "#cffafe",
+      "200": "#a5f3fc",
+      "300": "#67e8f9",
+      "400": "#22d3ee",
+      "500": "#06b6d4",
+      "600": "#0891b2",
+      "700": "#0e7490",
+      "800": "#155e75",
+      "900": "#164e63",
+      "950": "#083344"
+    }
+  },
+  {
+    name: "Sky",
+    shades: {
+      "50": "#f0f9ff",
+      "100": "#e0f2fe",
+      "200": "#bae6fd",
+      "300": "#7dd3fc",
+      "400": "#38bdf8",
+      "500": "#0ea5e9",
+      "600": "#0284c7",
+      "700": "#0369a1",
+      "800": "#075985",
+      "900": "#0c4a6e",
+      "950": "#082f49"
+    }
+  },
+  {
+    name: "Blue",
+    shades: {
+      "50": "#eff6ff",
+      "100": "#dbeafe",
+      "200": "#bfdbfe",
+      "300": "#93c5fd",
+      "400": "#60a5fa",
+      "500": "#3b82f6",
+      "600": "#2563eb",
+      "700": "#1d4ed8",
+      "800": "#1e40af",
+      "900": "#1e3a8a",
+      "950": "#172554"
+    }
+  },
+  {
+    name: "Indigo",
+    shades: {
+      "50": "#eef2ff",
+      "100": "#e0e7ff",
+      "200": "#c7d2fe",
+      "300": "#a5b4fc",
+      "400": "#818cf8",
+      "500": "#6366f1",
+      "600": "#4f46e5",
+      "700": "#4338ca",
+      "800": "#3730a3",
+      "900": "#312e81",
+      "950": "#1e1b4b"
+    }
+  },
+  {
+    name: "Violet",
+    shades: {
+      "50": "#f5f3ff",
+      "100": "#ede9fe",
+      "200": "#ddd6fe",
+      "300": "#c4b5fd",
+      "400": "#a78bfa",
+      "500": "#8b5cf6",
+      "600": "#7c3aed",
+      "700": "#6d28d9",
+      "800": "#5b21b6",
+      "900": "#4c1d95",
+      "950": "#2e1065"
+    }
+  },
+  {
+    name: "Purple",
+    shades: {
+      "50": "#faf5ff",
+      "100": "#f3e8ff",
+      "200": "#e9d5ff",
+      "300": "#d8b4fe",
+      "400": "#c084fc",
+      "500": "#a855f7",
+      "600": "#9333ea",
+      "700": "#7e22ce",
+      "800": "#6b21a8",
+      "900": "#581c87",
+      "950": "#3b0764"
+    }
+  },
+  {
+    name: "Fuchsia",
+    shades: {
+      "50": "#fdf4ff",
+      "100": "#fae8ff",
+      "200": "#f5d0fe",
+      "300": "#f0abfc",
+      "400": "#e879f9",
+      "500": "#d946ef",
+      "600": "#c026d3",
+      "700": "#a21caf",
+      "800": "#86198f",
+      "900": "#701a75",
+      "950": "#4a044e"
+    }
+  },
+  {
+    name: "Pink",
+    shades: {
+      "50": "#fdf2f8",
+      "100": "#fce7f3",
+      "200": "#fbcfe8",
+      "300": "#f9a8d4",
+      "400": "#f472b6",
+      "500": "#ec4899",
+      "600": "#db2777",
+      "700": "#be185d",
+      "800": "#9d174d",
+      "900": "#831843",
+      "950": "#500724"
+    }
+  },
+  {
+    name: "Rose",
+    shades: {
+      "50": "#fff1f2",
+      "100": "#ffe4e6",
+      "200": "#fecdd3",
+      "300": "#fda4af",
+      "400": "#fb7185",
+      "500": "#f43f5e",
+      "600": "#e11d48",
+      "700": "#be123c",
+      "800": "#9f1239",
+      "900": "#881337",
+      "950": "#4c0519"
+    }
+  }
+];
+
+// src/color-util/tailwind.ts
+function getColorFromTailwind(tailwindColorString) {
+  const [colorName, shade] = tailwindColorString.split("-");
+  const colorGroup = tailwindColors.find((group) => group.name.toLowerCase() === (colorName ?? "").toLowerCase());
+  if (colorGroup) {
+    const shadeEntry = Object.entries(colorGroup.shades).find(([key]) => key === shade);
+    if (shadeEntry) {
+      return shadeEntry[1];
+    }
+  }
+  return "";
+}
+function findNearestTailwindColor(inputColor) {
+  let measure;
+  if (typeof inputColor === "string") {
+    const rgb = parseHexOrRgb(inputColor);
+    if (!rgb) return "";
+    measure = (hexValue) => {
+      const target = parseHexOrRgb(hexValue);
+      return target ? rgbDelta(rgb, target) : Infinity;
+    };
+  } else {
+    measure = (hexValue) => inputColor.delta(hexValue);
+  }
+  let nearestColor = "";
+  let smallestDistance = Infinity;
+  tailwindColors.forEach((colorGroup) => {
+    Object.entries(colorGroup.shades).forEach(([shade, hexValue]) => {
+      const distance = measure(hexValue);
+      if (distance < smallestDistance) {
+        smallestDistance = distance;
+        nearestColor = `${colorGroup.name.toLowerCase()}-${shade}`;
+      }
+    });
+  });
+  return nearestColor;
+}
+function formatTailwindColor(tailwindColor) {
+  const tailwindColorNames = [
+    "Slate",
+    "Gray",
+    "Zinc",
+    "Neutral",
+    "Stone",
+    "Red",
+    "Orange",
+    "Amber",
+    "Yellow",
+    "Lime",
+    "Green",
+    "Emerald",
+    "Teal",
+    "Cyan",
+    "Blue",
+    "Indigo",
+    "Violet",
+    "Sky",
+    "Purple",
+    "Fuchsia",
+    "Pink",
+    "Rose"
+  ];
+  const splitIndex = tailwindColor.search(/\d/);
+  if (splitIndex === -1) {
+    const colorName = tailwindColorNames.find((color) => tailwindColor.toLowerCase().includes(color.toLowerCase()));
+    if (colorName) {
+      return getColorFromTailwind(`${colorName.toLowerCase()}-500`);
+    }
+  }
+  if (splitIndex > 0) {
+    const colorNamePart = tailwindColor.slice(0, splitIndex);
+    let shadePart = tailwindColor.slice(splitIndex);
+    const matchedColors = tailwindColorNames.filter((color) => colorNamePart.toLowerCase().includes(color.toLowerCase()));
+    matchedColors.sort((a, b) => colorNamePart.toLowerCase().indexOf(a.toLowerCase()) - colorNamePart.toLowerCase().indexOf(b.toLowerCase()));
+    if (matchedColors.length > 0) {
+      const colorName = matchedColors[0].toLowerCase();
+      let shade = Math.round(parseInt(shadePart) / 100) * 100;
+      const formattedColor = getColorFromTailwind(`${colorName}-${shade.toString()}`);
+      if (formattedColor) {
+        return formattedColor;
+      }
+    }
+  }
+  return "";
+}
+
+// src/color-util/formats.ts
+function formatHex(hex) {
+  return hex.startsWith("#") ? hex : `#${hex}`;
+}
+function formatRgbString(rgb) {
+  const rgbValues = rgb.replace(/[^\d,]/g, "").split(",");
+  if (rgbValues.length === 3) {
+    return `rgb(${rgbValues[0].trim()}, ${rgbValues[1].trim()}, ${rgbValues[2].trim()})`;
+  }
+  return "";
+}
+function formatRgbObject(rgbObject) {
+  const regex = /["']?r["']?\s*[:=]\s*(\d+)\s*[,]\s*["']?g["']?\s*[:=]\s*(\d+)\s*[,]\s*["']?b["']?\s*[:=]\s*(\d+)(?:\s*[,]\s*["']?a["']?\s*[:=]\s*(\d+))?/i;
+  const match = rgbObject.match(regex);
+  if (match) {
+    const r = match[1], g = match[2], b = match[3], a = match[4] || 1;
+    return `{"r":${r},"g":${g},"b":${b},"a":${a}}`;
+  }
+  return "";
+}
+function formatHslObject(hslObject) {
+  const regex = /["']?h["']?\s*[:=]\s*(\d+)\s*,\s*["']?s["']?\s*[:=]\s*(\d+)\s*,\s*["']?l["']?\s*[:=]\s*(\d+)(?:\s*,\s*["']?a["']?\s*[:=]\s*(\d+))?/i;
+  const match = hslObject.match(regex);
+  if (match) {
+    const h = match[1], s = match[2], l = match[3], a = match[4] || 1;
+    return `{"h":${h},"s":${s},"l":${l},"a":${a}}`;
+  }
+  return "";
+}
+function formatHslString(hslString) {
+  const hslValues = hslString.replace(/[^\d,%]/g, "").split(/\s*,\s*/);
+  if (hslValues.length === 3) {
+    return `hsl(${hslValues[0]}, ${hslValues[1]}%, ${hslValues[2]}%)`;
+  }
+  return "";
+}
+function formatHsvString(hsvString) {
+  const hsvValues = hsvString.replace(/[^\d%\s]/g, "").split(/\s+/).map((value) => parseInt(value.replace("%", ""), 10));
+  if (hsvValues.length === 3 && hsvValues.every((val) => !isNaN(val))) {
+    return `hsv(${hsvValues[0]}, ${hsvValues[1]}%, ${hsvValues[2]}%)`;
+  }
+  return "";
+}
+function formatRegularCmykString(cmykString) {
+  const cmykValues = cmykString.replace(/[^\d,]/g, "").split(/\s*,\s*/);
+  if (cmykValues.length === 4 && cmykValues.every((val) => !isNaN(Number(val)))) {
+    return `cmyk(${cmykValues[0]}, ${cmykValues[1]}, ${cmykValues[2]}, ${cmykValues[3]})`;
+  }
+  return "";
+}
+function formatCmykObject(cmykObject) {
+  const regex = /["']?c["']?\s*[:=]\s*(\d+)\s*,\s*["']?m["']?\s*[:=]\s*(\d+)\s*,\s*["']?y["']?\s*[:=]\s*(\d+)\s*,\s*["']?k["']?\s*[:=]\s*(\d+)(?:\s*,\s*["']?a["']?\s*[:=]\s*(\d+))?/i;
+  const match = cmykObject.match(regex);
+  if (match) {
+    const c = match[1], m = match[2], y = match[3], k = match[4], a = match[5] || 1;
+    return `{"c":${c},"m":${m},"y":${y},"k":${k},"a":${a}}`;
+  }
+  return "";
+}
+function formatCmykString(cmykString) {
+  const cmykValues = cmykString.replace(/[^\d%\s]/g, "").split(/\s+/).map((value) => parseInt(value.replace("%", ""), 10));
+  if (cmykValues.length === 4 && cmykValues.every((val) => !isNaN(val))) {
+    return `device-cmyk(${cmykValues[0]}% ${cmykValues[1]}% ${cmykValues[2]}% ${cmykValues[3]}%)`;
+  }
+  return "";
+}
+function isDeviceCmyk(cmykString) {
+  const regex = /device-cmyk\(\s*\d+%\s+\d+%\s+\d+%\s+\d+%\s*\)/;
+  return regex.test(cmykString);
+}
+function formatHwbString(hwbString) {
+  const hwbValues = hwbString.replace(/[^\d,%\s]/g, "").split(/\s+/);
+  if (hwbValues.length === 3) {
+    return `hwb(${hwbValues[0]}, ${hwbValues[1]}%, ${hwbValues[2]}%)`;
+  }
+  return "";
+}
+function formatLabString(labString) {
+  const match = labString.match(/(?:lab\()?\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s*\)?/i);
+  if (match) {
+    const [, l, a, b] = match;
+    return `lab(${l} ${a} ${b})`;
+  }
+  return "";
+}
+function formatLchString(lchString) {
+  const match = lchString.match(/(?:lch\()?\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s*\)?/i);
+  if (match) {
+    const [, l, c, h] = match;
+    return `lch(${l} ${c} ${h})`;
+  }
+  return "";
+}
+function formatHexWith0x(hex) {
+  if (hex.startsWith("0x")) {
+    return `#${hex.slice(2)}`;
+  }
+  return "";
+}
+
+// src/color-util/normalize.ts
+function createColorNormalizer({ isValid }) {
+  return function normalizeColorInput(colorInput) {
+    if (isValid(colorInput)) {
+      return { value: colorInput, type: "standard" };
+    }
+    if (isDeviceCmyk(colorInput)) {
+      return { value: colorInput, type: "device-cmyk" };
+    }
+    const hex = formatHex(colorInput);
+    if (isValid(hex)) {
+      return { value: hex, type: "hex" };
+    }
+    const rgbString = formatRgbString(colorInput);
+    if (isValid(rgbString)) {
+      return { value: rgbString, type: "rgb" };
+    }
+    const rgbObject = formatRgbObject(colorInput);
+    if (rgbObject !== "") {
+      return { value: rgbObject, type: "rgb-object" };
+    }
+    const hslObject = formatHslObject(colorInput);
+    if (hslObject !== "") {
+      return { value: hslObject, type: "hsl-object" };
+    }
+    const hslString = formatHslString(colorInput);
+    if (isValid(hslString)) {
+      return { value: hslString, type: "hsl" };
+    }
+    const hsvString = formatHsvString(colorInput);
+    if (isValid(hsvString)) {
+      return { value: hsvString, type: "hsv" };
+    }
+    const tailwindColor = formatTailwindColor(colorInput);
+    if (tailwindColor !== "") {
+      return { value: tailwindColor, type: "tailwind" };
+    }
+    const regularCmykString = formatRegularCmykString(colorInput);
+    if (regularCmykString !== "") {
+      return { value: regularCmykString, type: "cmyk" };
+    }
+    const cmykObject = formatCmykObject(colorInput);
+    if (cmykObject !== "") {
+      return { value: cmykObject, type: "cmyk-object" };
+    }
+    const cmykString = formatCmykString(colorInput);
+    if (isValid(cmykString)) {
+      return { value: cmykString, type: "cmyk-percentage" };
+    }
+    const hwbString = formatHwbString(colorInput);
+    if (isValid(hwbString)) {
+      return { value: hwbString, type: "hwb" };
+    }
+    const labString = formatLabString(colorInput);
+    if (labString !== "") {
+      return { value: labString, type: "lab" };
+    }
+    const lchString = formatLchString(colorInput);
+    if (lchString !== "") {
+      return { value: lchString, type: "lch" };
+    }
+    const hexWith0x = formatHexWith0x(colorInput);
+    if (isValid(hexWith0x)) {
+      return { value: hexWith0x, type: "hex-0x" };
+    }
+    return null;
+  };
+}
+
+// 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 {
+  ConfirmDialog,
+  ConfirmDialogHost,
+  DBStoreManager,
+  DEFAULT_JSON_INDENT,
+  DEFAULT_JSON_WIDTH,
+  DEFAULT_WORD_REPLACEMENTS,
+  FeatureStore,
+  PublicStoreManager,
+  _resetIdbStoreSingletons,
+  booleanUrlCodec,
+  captureDrafts,
+  commitUrlParams,
+  computeSearchScore,
+  confirm,
+  createColorNormalizer,
+  createFormatter,
+  createMatrxToast,
+  decodeQrFromElement,
+  decodeQrFromImageData,
+  decodeQrFromImageFile,
+  detectJson,
+  discardDraft,
+  enumUrlCodec,
+  filterAndSortBySearch,
+  findNearestTailwindColor,
+  fireInvalidation,
+  formatCmykObject,
+  formatCmykString,
+  formatHex,
+  formatHexWith0x,
+  formatHslObject,
+  formatHslString,
+  formatHsvString,
+  formatHwbString,
+  formatJsonText,
+  formatLabString,
+  formatLchString,
+  formatLowerCase,
+  formatNormalCase,
+  formatRegularCmykString,
+  formatRgbObject,
+  formatRgbString,
+  formatSentenceCase,
+  formatTailwindColor,
+  formatText,
+  formatTitleCase,
+  formatUpperCase,
+  formatWithoutReplacements,
+  getColorFromTailwind,
+  getDraft,
+  getDraftsVersion,
+  getIdbStoreSingleton,
+  getSchedulerState,
+  guardMarkdownDelimiters,
+  guardMathDelimiters,
+  guardRunawayLinks,
+  hasNativeQrDetector,
+  historyModeForParamChange,
+  idMatchesQuery,
+  isDeviceCmyk,
+  isJsonArray,
+  isJsonObject,
+  isJsonPrimitive,
+  jsonUrlCodec,
+  listDrafts,
+  matchesSearch,
+  onFlushComplete,
+  parseHexOrRgb,
+  positiveIntegerUrlCodec,
+  registerDraftSource,
+  registerIdleTask,
+  registerInvalidationCallback,
+  reportDelimiterViolations,
+  resetScheduler,
+  rgbDelta,
+  rgbToLab,
+  runWithConcurrency,
+  setUrlStateRouter,
+  stringUrlCodec,
+  stringifyJson,
+  subscribeDrafts,
+  tailwindColors,
+  treeContainsComponent,
+  useAutosave,
+  useClipboard,
+  useDurableDraft,
+  useIdleGate,
+  useIdleReady,
+  useIdleRegister,
+  useIdleTask,
+  useLatestRequest,
+  useMirroredUrlState,
+  useUrlSearchParams,
+  useUrlState,
+  whenPageIdle
+};
+//# sourceMappingURL=index.js.map