@wildo-ai/presets-components 1.0.1 → 1.1.0

package/dist/esm/components/data-display/markdown-stream.lazy.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The ONLY door onto the markdown-rendering pipeline (`streamdown` + `katex` + `marked` + the
+ * `micromark`/`mdast`/`parse5` stack).
+ *
+ * Lazy-boundary wrapper (`*.lazy.tsx` convention — `graph.lazy` / `ChartView.lazy` /
+ * `pdf-viewer.lazy` precedent). It owns the single `React.lazy(() => import('./markdown-stream-runtime'))`
+ * split point and the Suspense fallback, and re-exports the props type via `import type` so callers
+ * stay fully typed with NO runtime edge onto the pipeline.
+ *
+ * ## What it keeps out of the eager graph, and what that measured
+ *
+ * `streamdown` was statically imported by three preset components — `data-display/markdown-content`,
+ * `ai-elements/trace/reasoning` and `ai-elements/chat/message` — and all three are registered
+ * eagerly by `registration/register-default-presets.ts`. Preset registration runs at application
+ * bootstrap, so the whole markdown pipeline was in the first-load set of every generated
+ * application whether or not it ever renders markdown. Measured on `examples/wonder-crm`
+ * (production `vite build`, eager set = the assets `dist/index.html` itself references): **210 kB
+ * gzipped**, against a 1,674 kB gzipped first load.
+ *
+ * See `markdown-stream-runtime.ts` for the per-payload breakdown and for why one runtime module is
+ * used rather than three per-leaf split points.
+ *
+ * ## Suspense fallback
+ *
+ * Markdown always occupies flow layout, so the fallback reserves height with a three-line
+ * `Skeleton` block rather than collapsing to zero and reflowing the surface underneath. Only the
+ * FIRST markdown block on a surface realistically suspends: the chunk is resident for every later
+ * one, so this is a one-time cost at the moment the user opens a markdown-bearing surface.
+ *
+ * ## The rule
+ *
+ * Everything except this wrapper (and tests) must render markdown through `MarkdownStream`. A
+ * static import of `./markdown-stream-runtime`, or of `streamdown` itself, from the eager graph
+ * silently merges the whole pipeline back into the entry chunk — enforced by
+ * `pnpm check:lazy-boundaries`.
+ */
+import * as React from "react";
+import type { Streamdown } from "streamdown";
+/** Props of the underlying renderer, forwarded verbatim. */
+export type MarkdownStreamProps = React.ComponentProps<typeof Streamdown>;
+/**
+ * Renders markdown, resolving the pipeline on first render.
+ *
+ * A drop-in replacement for `<Streamdown …>`: every prop is forwarded unchanged, so call sites keep
+ * their `components` overrides, their `parseIncompleteMarkdown` streaming flag and their class
+ * names exactly as before. The one prop that gains a DEFAULT is `mermaid` — see
+ * `MermaidSourceFallback` above; passing `mermaid` explicitly overrides it.
+ */
+export declare function MarkdownStream({ mermaid, ...props }: MarkdownStreamProps): React.JSX.Element;
+//# sourceMappingURL=markdown-stream.lazy.d.ts.map

package/dist/esm/components/data-display/markdown-stream.lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-stream.lazy.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/markdown-stream.lazy.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C,4DAA4D;AAC5D,MAAM,MAAM,mBAAmB,GAAG,KAAK,CAAC,cAAc,CAAC,OAAO,UAAU,CAAC,CAAA;AAqDzE;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAyB,EAAE,GAAG,KAAK,EAAE,EAAE,mBAAmB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAc9G"}

package/dist/esm/components/data-display/markdown-stream.lazy.js

@@ -0,0 +1,92 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The ONLY door onto the markdown-rendering pipeline (`streamdown` + `katex` + `marked` + the
+ * `micromark`/`mdast`/`parse5` stack).
+ *
+ * Lazy-boundary wrapper (`*.lazy.tsx` convention — `graph.lazy` / `ChartView.lazy` /
+ * `pdf-viewer.lazy` precedent). It owns the single `React.lazy(() => import('./markdown-stream-runtime.js'))`
+ * split point and the Suspense fallback, and re-exports the props type via `import type` so callers
+ * stay fully typed with NO runtime edge onto the pipeline.
+ *
+ * ## What it keeps out of the eager graph, and what that measured
+ *
+ * `streamdown` was statically imported by three preset components — `data-display/markdown-content`,
+ * `ai-elements/trace/reasoning` and `ai-elements/chat/message` — and all three are registered
+ * eagerly by `registration/register-default-presets.ts`. Preset registration runs at application
+ * bootstrap, so the whole markdown pipeline was in the first-load set of every generated
+ * application whether or not it ever renders markdown. Measured on `examples/wonder-crm`
+ * (production `vite build`, eager set = the assets `dist/index.html` itself references): **210 kB
+ * gzipped**, against a 1,674 kB gzipped first load.
+ *
+ * See `markdown-stream-runtime.ts` for the per-payload breakdown and for why one runtime module is
+ * used rather than three per-leaf split points.
+ *
+ * ## Suspense fallback
+ *
+ * Markdown always occupies flow layout, so the fallback reserves height with a three-line
+ * `Skeleton` block rather than collapsing to zero and reflowing the surface underneath. Only the
+ * FIRST markdown block on a surface realistically suspends: the chunk is resident for every later
+ * one, so this is a one-time cost at the moment the user opens a markdown-bearing surface.
+ *
+ * ## The rule
+ *
+ * Everything except this wrapper (and tests) must render markdown through `MarkdownStream`. A
+ * static import of `./markdown-stream-runtime`, or of `streamdown` itself, from the eager graph
+ * silently merges the whole pipeline back into the entry chunk — enforced by
+ * `pnpm check:lazy-boundaries`.
+ */
+import * as React from "react";
+import { Skeleton, cn, useUI } from "@wildo-ai/saas-frontend-lib";
+import { TypographyVariant, UIBehavior } from "@wildo-ai/presets-components-models";
+/**
+ * What a ```` ```mermaid ```` fence renders as, now that diagram rendering is switched off.
+ *
+ * Wildo does not render mermaid diagrams: the applications alias the `mermaid` specifier onto
+ * `~wildo-presets/mermaid-stub`, which removes ~430 kB gzipped across 21 chunks from the built
+ * output (see that module for the measurement and for what it deliberately does NOT save). The stub
+ * rejects, `streamdown` catches, and hands the failure to this component.
+ *
+ * Rendering the SOURCE is the point. `streamdown`'s own fallback is a red error panel with a
+ * `Show Code` disclosure, which reads as a malfunction; a diagram nobody chose to render is not a
+ * malfunction, and the source is the most useful thing left to show. The block is styled through the
+ * CODE typography recipe so it matches every other code surface in the active theme.
+ *
+ * It is passed as a DEFAULT below rather than hardcoded, so an application that keeps the real
+ * `mermaid` (by dropping the alias) is unaffected — the error this renders simply never occurs.
+ */
+function MermaidSourceFallback({ chart }) {
+    const { getRecipe } = useUI();
+    const code = getRecipe(UIBehavior.TYPOGRAPHY, TypographyVariant.CODE);
+    return (_jsx("pre", { className: cn("my-4 overflow-x-auto rounded-md border bg-muted/50 p-card-sm text-sm", code.base), "data-streamdown": "mermaid-source", children: _jsx("code", { children: chart }) }));
+}
+/**
+ * Default `mermaid` options handed to `streamdown`.
+ *
+ * Module-level constant, never an inline object literal: `streamdown` memoizes its context value on
+ * this prop's identity, so a fresh object per render would invalidate that memo on every keystroke
+ * of a streaming response.
+ */
+const MERMAID_OPTIONS = { errorComponent: MermaidSourceFallback };
+/**
+ * Resolves to `MarkdownStreamRuntime`, NOT to `Streamdown` itself.
+ *
+ * That indirection is what applies the reordered rehype chain (`raw → sanitize → harden → katex`)
+ * that makes LaTeX render at all — see `DEFAULT_REHYPE_PLUGINS` in the runtime module for the defect
+ * and the security reasoning. It cannot be applied here: the plugin list is derived from
+ * `streamdown`'s own exports, and naming them from this file would put the whole 210 kB pipeline back
+ * into the eager graph, which is the one thing this wrapper exists to prevent.
+ */
+const LazyStreamdown = React.lazy(() => import("./markdown-stream-runtime.js").then((module) => ({ default: module.MarkdownStreamRuntime })));
+/**
+ * Renders markdown, resolving the pipeline on first render.
+ *
+ * A drop-in replacement for `<Streamdown …>`: every prop is forwarded unchanged, so call sites keep
+ * their `components` overrides, their `parseIncompleteMarkdown` streaming flag and their class
+ * names exactly as before. The one prop that gains a DEFAULT is `mermaid` — see
+ * `MermaidSourceFallback` above; passing `mermaid` explicitly overrides it.
+ */
+export function MarkdownStream({ mermaid = MERMAID_OPTIONS, ...props }) {
+    return (_jsx(React.Suspense, { fallback: _jsxs("div", { className: "space-y-2", "aria-busy": "true", children: [_jsx(Skeleton, { className: "h-4 w-full" }), _jsx(Skeleton, { className: "h-4 w-11/12" }), _jsx(Skeleton, { className: "h-4 w-4/6" })] }), children: _jsx(LazyStreamdown, { mermaid: mermaid, ...props }) }));
+}
+//# sourceMappingURL=markdown-stream.lazy.js.map

package/dist/esm/components/data-display/markdown-stream.lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-stream.lazy.js","sourceRoot":"","sources":["../../../../../src/components/data-display/markdown-stream.lazy.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAA;;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAA;AAMnF;;;;;;;;;;;;;;;GAeG;AACH,SAAS,qBAAqB,CAAC,EAAE,KAAK,EAAuD;IAC3F,MAAM,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,CAAA;IAC7B,MAAM,IAAI,GAAG,SAAS,CAAC,UAAU,CAAC,UAAU,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAA;IACrE,OAAO,CACL,cACE,SAAS,EAAE,EAAE,CAAC,sEAAsE,EAAE,IAAI,CAAC,IAAI,CAAC,qBAChF,gBAAgB,YAEhC,yBAAO,KAAK,GAAQ,GAChB,CACP,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,eAAe,GAAgD,EAAE,cAAc,EAAE,qBAAqB,EAAE,CAAA;AAE9G;;;;;;;;GAQG;AACH,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CACrC,MAAM,CAAC,2BAA2B,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,qBAAqB,EAAE,CAAC,CAAC,CAClG,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,EAAE,OAAO,GAAG,eAAe,EAAE,GAAG,KAAK,EAAuB;IACzF,OAAO,CACL,KAAC,KAAK,CAAC,QAAQ,IACb,QAAQ,EACN,eAAK,SAAS,EAAC,WAAW,eAAW,MAAM,aACzC,KAAC,QAAQ,IAAC,SAAS,EAAC,YAAY,GAAG,EACnC,KAAC,QAAQ,IAAC,SAAS,EAAC,aAAa,GAAG,EACpC,KAAC,QAAQ,IAAC,SAAS,EAAC,WAAW,GAAG,IAC9B,YAGR,KAAC,cAAc,IAAC,OAAO,EAAE,OAAO,KAAM,KAAK,GAAI,GAChC,CAClB,CAAA;AACH,CAAC","sourcesContent":["\"use client\"\n\n/**\n * The ONLY door onto the markdown-rendering pipeline (`streamdown` + `katex` + `marked` + the\n * `micromark`/`mdast`/`parse5` stack).\n *\n * Lazy-boundary wrapper (`*.lazy.tsx` convention — `graph.lazy` / `ChartView.lazy` /\n * `pdf-viewer.lazy` precedent). It owns the single `React.lazy(() => import('./markdown-stream-runtime'))`\n * split point and the Suspense fallback, and re-exports the props type via `import type` so callers\n * stay fully typed with NO runtime edge onto the pipeline.\n *\n * ## What it keeps out of the eager graph, and what that measured\n *\n * `streamdown` was statically imported by three preset components — `data-display/markdown-content`,\n * `ai-elements/trace/reasoning` and `ai-elements/chat/message` — and all three are registered\n * eagerly by `registration/register-default-presets.ts`. Preset registration runs at application\n * bootstrap, so the whole markdown pipeline was in the first-load set of every generated\n * application whether or not it ever renders markdown. Measured on `examples/wonder-crm`\n * (production `vite build`, eager set = the assets `dist/index.html` itself references): **210 kB\n * gzipped**, against a 1,674 kB gzipped first load.\n *\n * See `markdown-stream-runtime.ts` for the per-payload breakdown and for why one runtime module is\n * used rather than three per-leaf split points.\n *\n * ## Suspense fallback\n *\n * Markdown always occupies flow layout, so the fallback reserves height with a three-line\n * `Skeleton` block rather than collapsing to zero and reflowing the surface underneath. Only the\n * FIRST markdown block on a surface realistically suspends: the chunk is resident for every later\n * one, so this is a one-time cost at the moment the user opens a markdown-bearing surface.\n *\n * ## The rule\n *\n * Everything except this wrapper (and tests) must render markdown through `MarkdownStream`. A\n * static import of `./markdown-stream-runtime`, or of `streamdown` itself, from the eager graph\n * silently merges the whole pipeline back into the entry chunk — enforced by\n * `pnpm check:lazy-boundaries`.\n */\n\nimport * as React from \"react\"\nimport { Skeleton, cn, useUI } from \"@wildo-ai/saas-frontend-lib\"\nimport { TypographyVariant, UIBehavior } from \"@wildo-ai/presets-components-models\"\nimport type { Streamdown } from \"streamdown\"\n\n/** Props of the underlying renderer, forwarded verbatim. */\nexport type MarkdownStreamProps = React.ComponentProps<typeof Streamdown>\n\n/**\n * What a ```` ```mermaid ```` fence renders as, now that diagram rendering is switched off.\n *\n * Wildo does not render mermaid diagrams: the applications alias the `mermaid` specifier onto\n * `~wildo-presets/mermaid-stub`, which removes ~430 kB gzipped across 21 chunks from the built\n * output (see that module for the measurement and for what it deliberately does NOT save). The stub\n * rejects, `streamdown` catches, and hands the failure to this component.\n *\n * Rendering the SOURCE is the point. `streamdown`'s own fallback is a red error panel with a\n * `Show Code` disclosure, which reads as a malfunction; a diagram nobody chose to render is not a\n * malfunction, and the source is the most useful thing left to show. The block is styled through the\n * CODE typography recipe so it matches every other code surface in the active theme.\n *\n * It is passed as a DEFAULT below rather than hardcoded, so an application that keeps the real\n * `mermaid` (by dropping the alias) is unaffected — the error this renders simply never occurs.\n */\nfunction MermaidSourceFallback({ chart }: { chart: string; error: string; retry: () => void }): React.JSX.Element {\n  const { getRecipe } = useUI()\n  const code = getRecipe(UIBehavior.TYPOGRAPHY, TypographyVariant.CODE)\n  return (\n    <pre\n      className={cn(\"my-4 overflow-x-auto rounded-md border bg-muted/50 p-card-sm text-sm\", code.base)}\n      data-streamdown=\"mermaid-source\"\n    >\n      <code>{chart}</code>\n    </pre>\n  )\n}\n\n/**\n * Default `mermaid` options handed to `streamdown`.\n *\n * Module-level constant, never an inline object literal: `streamdown` memoizes its context value on\n * this prop's identity, so a fresh object per render would invalidate that memo on every keystroke\n * of a streaming response.\n */\nconst MERMAID_OPTIONS: NonNullable<MarkdownStreamProps[\"mermaid\"]> = { errorComponent: MermaidSourceFallback }\n\n/**\n * Resolves to `MarkdownStreamRuntime`, NOT to `Streamdown` itself.\n *\n * That indirection is what applies the reordered rehype chain (`raw → sanitize → harden → katex`)\n * that makes LaTeX render at all — see `DEFAULT_REHYPE_PLUGINS` in the runtime module for the defect\n * and the security reasoning. It cannot be applied here: the plugin list is derived from\n * `streamdown`'s own exports, and naming them from this file would put the whole 210 kB pipeline back\n * into the eager graph, which is the one thing this wrapper exists to prevent.\n */\nconst LazyStreamdown = React.lazy(() =>\n  import(\"./markdown-stream-runtime\").then((module) => ({ default: module.MarkdownStreamRuntime })),\n)\n\n/**\n * Renders markdown, resolving the pipeline on first render.\n *\n * A drop-in replacement for `<Streamdown …>`: every prop is forwarded unchanged, so call sites keep\n * their `components` overrides, their `parseIncompleteMarkdown` streaming flag and their class\n * names exactly as before. The one prop that gains a DEFAULT is `mermaid` — see\n * `MermaidSourceFallback` above; passing `mermaid` explicitly overrides it.\n */\nexport function MarkdownStream({ mermaid = MERMAID_OPTIONS, ...props }: MarkdownStreamProps): React.JSX.Element {\n  return (\n    <React.Suspense\n      fallback={\n        <div className=\"space-y-2\" aria-busy=\"true\">\n          <Skeleton className=\"h-4 w-full\" />\n          <Skeleton className=\"h-4 w-11/12\" />\n          <Skeleton className=\"h-4 w-4/6\" />\n        </div>\n      }\n    >\n      <LazyStreamdown mermaid={mermaid} {...props} />\n    </React.Suspense>\n  )\n}\n"]}

package/dist/esm/components/data-display/notification-indicator.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { NotificationIndicatorProps } from "@wildo-ai/saas-frontend-lib";
+export declare function NotificationIndicator({ mode, tone, count, pulse, label, className, }: NotificationIndicatorProps): React.JSX.Element | null;
+//# sourceMappingURL=notification-indicator.d.ts.map

package/dist/esm/components/data-display/notification-indicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-indicator.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/notification-indicator.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAK9B,OAAO,KAAK,EAAE,0BAA0B,EAAyB,MAAM,6BAA6B,CAAA;AA2BpG,wBAAgB,qBAAqB,CAAC,EACpC,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,KAAa,EACb,KAAK,EACL,SAAS,GACV,EAAE,0BAA0B,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CA0BvD"}

package/dist/esm/components/data-display/notification-indicator.js

@@ -0,0 +1,43 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { IndicatorVariant, UIBehavior } from "@wildo-ai/presets-components-models";
+import { NotificationBadgeDisplayMode } from "@wildo-ai/saas-models";
+import { cn, useUI, Badge, formatBadgeCount } from "@wildo-ai/saas-frontend-lib";
+/**
+ * DEFAULT preset for `LOW_LEVEL_NOTIFICATION_INDICATOR` (R4). Composes the
+ * design-system `Badge`:
+ * - `NONE`, or a non-positive count → renders nothing (a dot means "≥ 1").
+ * - `DOT` → a color signal dot (the enum-icon fallback pattern), label in `sr-only`.
+ * - `COUNT` → the truncated number, announced via `aria-live`.
+ *
+ * Pulse is THEME-OWNED: when `pulse` is true we append the active theme's
+ * `INDICATOR` recipe `motion.attention` (a theme may customize it; falls back to
+ * a reduced-motion-safe default). The DEFINITION decides whether/when to pulse;
+ * the theme decides how it looks.
+ */
+/** IndicatorVariant (definition tone) → Badge public variant. */
+const TONE_TO_VARIANT = {
+    [IndicatorVariant.NEUTRAL]: "default",
+    [IndicatorVariant.INFO]: "info",
+    [IndicatorVariant.SUCCESS]: "success",
+    [IndicatorVariant.WARNING]: "warning",
+    [IndicatorVariant.ERROR]: "destructive",
+};
+/** Framework fallback when a theme's INDICATOR recipe declares no `motion.attention`. */
+const DEFAULT_ATTENTION = "animate-pulse motion-reduce:animate-none";
+export function NotificationIndicator({ mode, tone, count, pulse = false, label, className, }) {
+    const { getRecipe } = useUI();
+    // A dot/count only makes sense for a positive count; NONE is always silent.
+    if (mode === NotificationBadgeDisplayMode.NONE || count <= 0) {
+        return null;
+    }
+    const variant = TONE_TO_VARIANT[tone];
+    const attention = pulse
+        ? (getRecipe(UIBehavior.INDICATOR, tone).motion.attention ?? DEFAULT_ATTENTION)
+        : undefined;
+    if (mode === NotificationBadgeDisplayMode.DOT) {
+        return (_jsx(Badge, { variant: variant, title: label, className: cn("h-2.5 w-2.5 rounded-full p-0", attention, className), children: _jsx("span", { className: "sr-only", children: label }) }));
+    }
+    return (_jsx(Badge, { variant: variant, "aria-live": "polite", "aria-label": label, className: cn(attention, className), children: formatBadgeCount(count) }));
+}
+//# sourceMappingURL=notification-indicator.js.map

package/dist/esm/components/data-display/notification-indicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-indicator.js","sourceRoot":"","sources":["../../../../../src/components/data-display/notification-indicator.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAA;;AAIZ,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAA;AAClF,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAGhF;;;;;;;;;;;GAWG;AAEH,iEAAiE;AACjE,MAAM,eAAe,GAAoD;IACvE,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,SAAS;IACrC,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM;IAC/B,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,SAAS;IACrC,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,SAAS;IACrC,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,aAAa;CACxC,CAAA;AAED,yFAAyF;AACzF,MAAM,iBAAiB,GAAG,0CAA0C,CAAA;AAEpE,MAAM,UAAU,qBAAqB,CAAC,EACpC,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,KAAK,GAAG,KAAK,EACb,KAAK,EACL,SAAS,GACkB;IAC3B,MAAM,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,CAAA;IAE7B,4EAA4E;IAC5E,IAAI,IAAI,KAAK,4BAA4B,CAAC,IAAI,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QAC7D,OAAO,IAAI,CAAA;IACb,CAAC;IAED,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,CAAA;IACrC,MAAM,SAAS,GAAG,KAAK;QACrB,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,IAAI,iBAAiB,CAAC;QAC/E,CAAC,CAAC,SAAS,CAAA;IAEb,IAAI,IAAI,KAAK,4BAA4B,CAAC,GAAG,EAAE,CAAC;QAC9C,OAAO,CACL,KAAC,KAAK,IAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,8BAA8B,EAAE,SAAS,EAAE,SAAS,CAAC,YACxG,eAAM,SAAS,EAAC,SAAS,YAAE,KAAK,GAAQ,GAClC,CACT,CAAA;IACH,CAAC;IAED,OAAO,CACL,KAAC,KAAK,IAAC,OAAO,EAAE,OAAO,eAAY,QAAQ,gBAAa,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,YAC/F,gBAAgB,CAAC,KAAK,CAAC,GAClB,CACT,CAAA;AACH,CAAC","sourcesContent":["\"use client\"\n\nimport * as React from \"react\"\n\nimport { IndicatorVariant, UIBehavior } from \"@wildo-ai/presets-components-models\"\nimport { NotificationBadgeDisplayMode } from \"@wildo-ai/saas-models\"\nimport { cn, useUI, Badge, formatBadgeCount } from \"@wildo-ai/saas-frontend-lib\"\nimport type { NotificationIndicatorProps, BadgeVariants_Variant } from \"@wildo-ai/saas-frontend-lib\"\n\n/**\n * DEFAULT preset for `LOW_LEVEL_NOTIFICATION_INDICATOR` (R4). Composes the\n * design-system `Badge`:\n * - `NONE`, or a non-positive count → renders nothing (a dot means \"≥ 1\").\n * - `DOT` → a color signal dot (the enum-icon fallback pattern), label in `sr-only`.\n * - `COUNT` → the truncated number, announced via `aria-live`.\n *\n * Pulse is THEME-OWNED: when `pulse` is true we append the active theme's\n * `INDICATOR` recipe `motion.attention` (a theme may customize it; falls back to\n * a reduced-motion-safe default). The DEFINITION decides whether/when to pulse;\n * the theme decides how it looks.\n */\n\n/** IndicatorVariant (definition tone) → Badge public variant. */\nconst TONE_TO_VARIANT: Record<IndicatorVariant, BadgeVariants_Variant> = {\n  [IndicatorVariant.NEUTRAL]: \"default\",\n  [IndicatorVariant.INFO]: \"info\",\n  [IndicatorVariant.SUCCESS]: \"success\",\n  [IndicatorVariant.WARNING]: \"warning\",\n  [IndicatorVariant.ERROR]: \"destructive\",\n}\n\n/** Framework fallback when a theme's INDICATOR recipe declares no `motion.attention`. */\nconst DEFAULT_ATTENTION = \"animate-pulse motion-reduce:animate-none\"\n\nexport function NotificationIndicator({\n  mode,\n  tone,\n  count,\n  pulse = false,\n  label,\n  className,\n}: NotificationIndicatorProps): React.JSX.Element | null {\n  const { getRecipe } = useUI()\n\n  // A dot/count only makes sense for a positive count; NONE is always silent.\n  if (mode === NotificationBadgeDisplayMode.NONE || count <= 0) {\n    return null\n  }\n\n  const variant = TONE_TO_VARIANT[tone]\n  const attention = pulse\n    ? (getRecipe(UIBehavior.INDICATOR, tone).motion.attention ?? DEFAULT_ATTENTION)\n    : undefined\n\n  if (mode === NotificationBadgeDisplayMode.DOT) {\n    return (\n      <Badge variant={variant} title={label} className={cn(\"h-2.5 w-2.5 rounded-full p-0\", attention, className)}>\n        <span className=\"sr-only\">{label}</span>\n      </Badge>\n    )\n  }\n\n  return (\n    <Badge variant={variant} aria-live=\"polite\" aria-label={label} className={cn(attention, className)}>\n      {formatBadgeCount(count)}\n    </Badge>\n  )\n}\n"]}

package/dist/esm/components/data-display/notification-indicator.labels.d.ts

@@ -0,0 +1,3 @@
+import { type LabellingUnitaryDef } from '@wildo-ai/presets-components-models';
+export declare const LowLevelNotificationIndicatorLabels: LabellingUnitaryDef[];
+//# sourceMappingURL=notification-indicator.labels.d.ts.map

package/dist/esm/components/data-display/notification-indicator.labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-indicator.labels.d.ts","sourceRoot":"","sources":["../../../../../src/components/data-display/notification-indicator.labels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,mBAAmB,EAA2B,MAAM,qCAAqC,CAAC;AAO/H,eAAO,MAAM,mCAAmC,EAAE,mBAAmB,EAAO,CAAC"}

package/dist/esm/components/data-display/notification-indicator.labels.js

@@ -0,0 +1,8 @@
+import { FrontendComponentType, registerComponentLabels } from '@wildo-ai/presets-components-models';
+// Companion-only label metadata. Statically scanned by the dev companion; NOT
+// imported at runtime, so it never ships in the bundle. The indicator has no
+// authored copy — the count is numeric and the accessible name is supplied by
+// the calling nav item — so the inventory is intentionally empty.
+export const LowLevelNotificationIndicatorLabels = [];
+registerComponentLabels(FrontendComponentType.LOW_LEVEL_NOTIFICATION_INDICATOR, LowLevelNotificationIndicatorLabels);
+//# sourceMappingURL=notification-indicator.labels.js.map

package/dist/esm/components/data-display/notification-indicator.labels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-indicator.labels.js","sourceRoot":"","sources":["../../../../../src/components/data-display/notification-indicator.labels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAA4B,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAE/H,8EAA8E;AAC9E,6EAA6E;AAC7E,8EAA8E;AAC9E,kEAAkE;AAElE,MAAM,CAAC,MAAM,mCAAmC,GAA0B,EAAE,CAAC;AAC7E,uBAAuB,CAAC,qBAAqB,CAAC,gCAAgC,EAAE,mCAAmC,CAAC,CAAC","sourcesContent":["import { FrontendComponentType, type LabellingUnitaryDef, registerComponentLabels } from '@wildo-ai/presets-components-models';\n\n// Companion-only label metadata. Statically scanned by the dev companion; NOT\n// imported at runtime, so it never ships in the bundle. The indicator has no\n// authored copy — the count is numeric and the accessible name is supplied by\n// the calling nav item — so the inventory is intentionally empty.\n\nexport const LowLevelNotificationIndicatorLabels: LabellingUnitaryDef[] = [];\nregisterComponentLabels(FrontendComponentType.LOW_LEVEL_NOTIFICATION_INDICATOR, LowLevelNotificationIndicatorLabels);\n"]}

package/dist/esm/components/data-display/pdf-viewer/pdf-viewer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * PdfViewer — the PDF.js rendering core.
+ *
+ * ⚠ HEAVY MODULE — LAZY-BOUNDARY DISCIPLINE ⚠
+ * This module (and everything only it depends on: `pdfjs-dist` and its worker) must
+ * stay behind the dynamic-import boundary owned by `pdf-viewer.lazy.tsx`. NEVER
+ * static-import this file from anywhere except that wrapper (tests may). A module
+ * that is both statically and dynamically imported is MERGED into the static
+ * importer's chunk by Rollup, with no warning — that is how the ECharts boundary
+ * silently rotted. `pnpm check:lazy-boundaries` enforces this.
+ *
+ * ## Why PDF.js rather than the browser's viewer
+ *
+ * The previous document display embedded an `<iframe>` on the file URL, which hands
+ * the page to the browser's built-in viewer: unstyleable (it ignores the design
+ * system entirely), unmeasurable, and blocked outright by a strict `frame-src` CSP.
+ * PDF.js renders into our own canvas, so the surrounding chrome is ours.
+ *
+ * ## Rendering model
+ *
+ * Pages rasterise to `<canvas>` at device pixel ratio, sequentially, into a plain
+ * scroll container. Deliberately NOT virtualised in this first increment: a bounded
+ * `maxPages` cap keeps a pathological 900-page document from freezing the tab, and
+ * virtualisation can be added behind the same contract when a real document demands
+ * it. `THUMBNAIL` presentation renders page 1 only — the cheapest useful signal.
+ *
+ * ## Worker
+ *
+ * PDF.js parses on a Web Worker. The URL is resolved through `import.meta.url` so
+ * every bundler (the app's Vite, the site's Astro, the docs' Docusaurus) emits and
+ * fingerprints it as an asset rather than fetching from a CDN — a CDN worker would
+ * both leak document bytes' provenance and require a `worker-src` exception the CSP
+ * pipeline should not have to make. The app's CSP must allow `worker-src 'self' blob:`.
+ */
+import * as React from "react";
+export interface PdfViewerProps {
+    /** Bytes of the PDF. Fetched by the host over the authenticated serve route. */
+    data: ArrayBuffer;
+    /** Render only the first page (THUMBNAIL presentation). */
+    firstPageOnly?: boolean;
+    /** Target CSS width in px for a rendered page. Height follows the page aspect. */
+    targetWidth?: number;
+    className?: string;
+    /** Accessible name for the rendered document region. */
+    ariaLabel?: string;
+}
+export declare function PdfViewer({ data, firstPageOnly, targetWidth, className, ariaLabel, }: PdfViewerProps): React.JSX.Element;
+export default PdfViewer;
+//# sourceMappingURL=pdf-viewer.d.ts.map

package/dist/esm/components/data-display/pdf-viewer/pdf-viewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-viewer.d.ts","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA0C9B,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,IAAI,EAAE,WAAW,CAAA;IACjB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,SAAS,CAAC,EACxB,IAAI,EACJ,aAAqB,EACrB,WAAW,EACX,SAAS,EACT,SAAS,GACV,EAAE,cAAc,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAwGpC;AAED,eAAe,SAAS,CAAA"}

package/dist/esm/components/data-display/pdf-viewer/pdf-viewer.js

@@ -0,0 +1,165 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * PdfViewer — the PDF.js rendering core.
+ *
+ * ⚠ HEAVY MODULE — LAZY-BOUNDARY DISCIPLINE ⚠
+ * This module (and everything only it depends on: `pdfjs-dist` and its worker) must
+ * stay behind the dynamic-import boundary owned by `pdf-viewer.lazy.tsx`. NEVER
+ * static-import this file from anywhere except that wrapper (tests may). A module
+ * that is both statically and dynamically imported is MERGED into the static
+ * importer's chunk by Rollup, with no warning — that is how the ECharts boundary
+ * silently rotted. `pnpm check:lazy-boundaries` enforces this.
+ *
+ * ## Why PDF.js rather than the browser's viewer
+ *
+ * The previous document display embedded an `<iframe>` on the file URL, which hands
+ * the page to the browser's built-in viewer: unstyleable (it ignores the design
+ * system entirely), unmeasurable, and blocked outright by a strict `frame-src` CSP.
+ * PDF.js renders into our own canvas, so the surrounding chrome is ours.
+ *
+ * ## Rendering model
+ *
+ * Pages rasterise to `<canvas>` at device pixel ratio, sequentially, into a plain
+ * scroll container. Deliberately NOT virtualised in this first increment: a bounded
+ * `maxPages` cap keeps a pathological 900-page document from freezing the tab, and
+ * virtualisation can be added behind the same contract when a real document demands
+ * it. `THUMBNAIL` presentation renders page 1 only — the cheapest useful signal.
+ *
+ * ## Worker
+ *
+ * PDF.js parses on a Web Worker. The URL is resolved through `import.meta.url` so
+ * every bundler (the app's Vite, the site's Astro, the docs' Docusaurus) emits and
+ * fingerprints it as an asset rather than fetching from a CDN — a CDN worker would
+ * both leak document bytes' provenance and require a `worker-src` exception the CSP
+ * pipeline should not have to make. The app's CSP must allow `worker-src 'self' blob:`.
+ */
+import * as React from "react";
+import { cn, Text, Skeleton } from "@wildo-ai/saas-frontend-lib";
+import * as pdfjs from "pdfjs-dist";
+// Same-origin, bundler-emitted worker (see the header note on CSP).
+//
+// ⚠️ TWO earlier attempts failed at RENDER time, not build time — which is why they
+// survived typecheck and the lazy-boundary guard. Both are recorded so the next
+// author does not walk back into them:
+//
+//  1. `new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url)` — `new URL()`
+//     resolves only RELATIVE paths against the module URL; a bare package specifier
+//     is not bundler-resolved, so the browser requested a path that does not exist
+//     and pdf.js reported `Setting up fake worker failed`.
+//  2. `?url` + `GlobalWorkerOptions.workerSrc` — the URL resolved and the file was
+//     served (200), but pdf.js instantiates a `workerSrc` string as a CLASSIC worker
+//     while pdf.js 6 ships the worker as an ES module. The worker never completed its
+//     handshake, so `getDocument()` hung forever with no error to show.
+//
+// `?worker` hands us a bundler-generated constructor that already carries the right
+// worker type, which removes the classic-vs-module question entirely. It is a Vite
+// asset-import suffix: Vite is what the generated application uses, and the
+// alternatives are worse (a relative path into `node_modules` breaks under any
+// hoisting layout; a CDN URL leaks document provenance and needs a `worker-src`
+// exception the CSP pipeline should not have to make). A non-Vite consumer must
+// supply its own worker — tracked as portability work, not papered over here.
+//
+// ONE port for the whole module, assigned to `GlobalWorkerOptions.workerPort`. A
+// per-instance `PDFWorker` was tried first out of a concurrency worry that does not
+// apply: the pdf.js worker multiplexes documents by id, so several viewers mounted at
+// once (a THUMBNAIL in a list plus an overlay, say) share it safely — and the shared
+// port also avoids spawning a worker per rendered thumbnail. The worker is created
+// when this module loads, which is already behind the lazy boundary.
+// @ts-expect-error -- `?worker` is a Vite asset-import suffix with no TS declaration.
+import PdfJsWorker from 'pdfjs-dist/build/pdf.worker.min.mjs?worker';
+pdfjs.GlobalWorkerOptions.workerPort = new PdfJsWorker();
+/** Hard cap on rasterised pages — a bound, not a product limit. */
+const MAX_RENDERED_PAGES = 50;
+export function PdfViewer({ data, firstPageOnly = false, targetWidth, className, ariaLabel, }) {
+    const containerRef = React.useRef(null);
+    const [pageCount, setPageCount] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    const [rendering, setRendering] = React.useState(true);
+    React.useEffect(() => {
+        let cancelled = false;
+        let document_ = null;
+        let loadingTask = null;
+        const container = containerRef.current;
+        if (!container)
+            return;
+        // pdf.js TRANSFERS the buffer it is given, which would detach a caller-owned
+        // ArrayBuffer and make a re-render (or a second consumer) read zero bytes.
+        // Hand it a copy; the host keeps its own.
+        const ownedData = data.slice(0);
+        setRendering(true);
+        setError(null);
+        container.replaceChildren();
+        void (async () => {
+            try {
+                loadingTask = pdfjs.getDocument({ data: ownedData });
+                document_ = await loadingTask.promise;
+                if (cancelled)
+                    return;
+                setPageCount(document_.numPages);
+                const lastPage = firstPageOnly ? 1 : Math.min(document_.numPages, MAX_RENDERED_PAGES);
+                const dpr = typeof window !== 'undefined' ? (window.devicePixelRatio || 1) : 1;
+                for (let pageNumber = 1; pageNumber <= lastPage; pageNumber++) {
+                    if (cancelled)
+                        return;
+                    const page = await document_.getPage(pageNumber);
+                    const unscaled = page.getViewport({ scale: 1 });
+                    // `??` would NOT rescue a ZERO width: `0 ?? fallback` is 0, and a container
+                    // that has not been laid out yet measures exactly 0 — which yields scale 0,
+                    // a 0x0 canvas, and a `page.render()` that never settles (observed live:
+                    // "rendering page 1" logged with no completion and a permanent skeleton).
+                    // Fall back on the page's own width whenever the measurement is unusable.
+                    const measuredWidth = targetWidth ?? container.clientWidth;
+                    const width = measuredWidth && measuredWidth > 0 ? measuredWidth : unscaled.width;
+                    const scale = width / unscaled.width;
+                    const viewport = page.getViewport({ scale: scale * dpr });
+                    const canvas = window.document.createElement('canvas');
+                    canvas.width = Math.floor(viewport.width);
+                    canvas.height = Math.floor(viewport.height);
+                    // CSS size stays in layout px; the canvas is oversampled by DPR so text
+                    // is crisp on retina without the layout changing.
+                    canvas.style.width = `${Math.floor(viewport.width / dpr)}px`;
+                    canvas.style.height = `${Math.floor(viewport.height / dpr)}px`;
+                    canvas.className = 'mx-auto max-w-full rounded-md border border-border shadow-xs';
+                    canvas.setAttribute('role', 'img');
+                    canvas.setAttribute('aria-label', `Page ${pageNumber}`);
+                    // ATTACH BEFORE RENDERING. Rendering into a detached canvas and appending
+                    // afterwards left `page.render()` unsettled indefinitely (observed live:
+                    // "rendering page 1" with no completion). Attaching first also makes pages
+                    // appear progressively instead of all at once at the end.
+                    container.appendChild(canvas);
+                    // pdf.js 6 takes the CANVAS, not a 2D context: `canvasContext` is the legacy
+                    // parameter and its own typings state that using it requires `canvas` to be
+                    // explicitly null. Passing both (the first attempt here) is not a supported
+                    // combination and left the render promise unsettled.
+                    await page.render({ canvas, viewport }).promise;
+                    if (cancelled)
+                        return;
+                }
+            }
+            catch (cause) {
+                if (!cancelled)
+                    setError(cause instanceof Error ? cause.message : String(cause));
+            }
+            finally {
+                if (!cancelled)
+                    setRendering(false);
+            }
+        })();
+        return () => {
+            cancelled = true;
+            // Do NOT call `loadingTask.destroy()`: with an externally-supplied worker port
+            // that also destroys the SHARED worker, and React StrictMode's double-mount
+            // then hits `PDFWorker.create - the worker is being destroyed` on the second
+            // pass (observed live). Releasing the document's own worker-side resources is
+            // what this component actually owns; the port outlives it by design.
+            void document_?.cleanup();
+        };
+    }, [data, firstPageOnly, targetWidth]);
+    return (_jsxs("div", { className: cn('w-full', className), "aria-label": ariaLabel, "aria-busy": rendering || undefined, children: [rendering && _jsx(Skeleton, { className: "h-64 w-full", "aria-hidden": "true" }), error && (_jsx(Text, { className: "text-sm text-destructive", role: "alert", children: error })), _jsx("div", { ref: containerRef, className: "flex flex-col gap-item" }), !firstPageOnly && pageCount !== null && pageCount > MAX_RENDERED_PAGES && (
+            // Say what was NOT rendered rather than silently truncating — a document that
+            // looks complete but is not is worse than an explicit bound.
+            _jsx(Text, { className: "mt-item text-xs text-muted-foreground", children: `Showing the first ${MAX_RENDERED_PAGES} of ${pageCount} pages.` }))] }));
+}
+export default PdfViewer;
+//# sourceMappingURL=pdf-viewer.js.map

package/dist/esm/components/data-display/pdf-viewer/pdf-viewer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-viewer.js","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer.tsx"],"names":[],"mappings":"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","sourcesContent":["\"use client\"\n\n/**\n * PdfViewer — the PDF.js rendering core.\n *\n * ⚠ HEAVY MODULE — LAZY-BOUNDARY DISCIPLINE ⚠\n * This module (and everything only it depends on: `pdfjs-dist` and its worker) must\n * stay behind the dynamic-import boundary owned by `pdf-viewer.lazy.tsx`. NEVER\n * static-import this file from anywhere except that wrapper (tests may). A module\n * that is both statically and dynamically imported is MERGED into the static\n * importer's chunk by Rollup, with no warning — that is how the ECharts boundary\n * silently rotted. `pnpm check:lazy-boundaries` enforces this.\n *\n * ## Why PDF.js rather than the browser's viewer\n *\n * The previous document display embedded an `<iframe>` on the file URL, which hands\n * the page to the browser's built-in viewer: unstyleable (it ignores the design\n * system entirely), unmeasurable, and blocked outright by a strict `frame-src` CSP.\n * PDF.js renders into our own canvas, so the surrounding chrome is ours.\n *\n * ## Rendering model\n *\n * Pages rasterise to `<canvas>` at device pixel ratio, sequentially, into a plain\n * scroll container. Deliberately NOT virtualised in this first increment: a bounded\n * `maxPages` cap keeps a pathological 900-page document from freezing the tab, and\n * virtualisation can be added behind the same contract when a real document demands\n * it. `THUMBNAIL` presentation renders page 1 only — the cheapest useful signal.\n *\n * ## Worker\n *\n * PDF.js parses on a Web Worker. The URL is resolved through `import.meta.url` so\n * every bundler (the app's Vite, the site's Astro, the docs' Docusaurus) emits and\n * fingerprints it as an asset rather than fetching from a CDN — a CDN worker would\n * both leak document bytes' provenance and require a `worker-src` exception the CSP\n * pipeline should not have to make. The app's CSP must allow `worker-src 'self' blob:`.\n */\n\nimport * as React from \"react\"\nimport { cn, Text, Skeleton } from \"@wildo-ai/saas-frontend-lib\"\nimport * as pdfjs from \"pdfjs-dist\"\nimport type { PDFDocumentProxy } from \"pdfjs-dist\"\n\n// Same-origin, bundler-emitted worker (see the header note on CSP).\n//\n// ⚠️ TWO earlier attempts failed at RENDER time, not build time — which is why they\n// survived typecheck and the lazy-boundary guard. Both are recorded so the next\n// author does not walk back into them:\n//\n//  1. `new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url)` — `new URL()`\n//     resolves only RELATIVE paths against the module URL; a bare package specifier\n//     is not bundler-resolved, so the browser requested a path that does not exist\n//     and pdf.js reported `Setting up fake worker failed`.\n//  2. `?url` + `GlobalWorkerOptions.workerSrc` — the URL resolved and the file was\n//     served (200), but pdf.js instantiates a `workerSrc` string as a CLASSIC worker\n//     while pdf.js 6 ships the worker as an ES module. The worker never completed its\n//     handshake, so `getDocument()` hung forever with no error to show.\n//\n// `?worker` hands us a bundler-generated constructor that already carries the right\n// worker type, which removes the classic-vs-module question entirely. It is a Vite\n// asset-import suffix: Vite is what the generated application uses, and the\n// alternatives are worse (a relative path into `node_modules` breaks under any\n// hoisting layout; a CDN URL leaks document provenance and needs a `worker-src`\n// exception the CSP pipeline should not have to make). A non-Vite consumer must\n// supply its own worker — tracked as portability work, not papered over here.\n//\n// ONE port for the whole module, assigned to `GlobalWorkerOptions.workerPort`. A\n// per-instance `PDFWorker` was tried first out of a concurrency worry that does not\n// apply: the pdf.js worker multiplexes documents by id, so several viewers mounted at\n// once (a THUMBNAIL in a list plus an overlay, say) share it safely — and the shared\n// port also avoids spawning a worker per rendered thumbnail. The worker is created\n// when this module loads, which is already behind the lazy boundary.\n// @ts-expect-error -- `?worker` is a Vite asset-import suffix with no TS declaration.\nimport PdfJsWorker from 'pdfjs-dist/build/pdf.worker.min.mjs?worker'\n\npdfjs.GlobalWorkerOptions.workerPort = new PdfJsWorker()\n\n/** Hard cap on rasterised pages — a bound, not a product limit. */\nconst MAX_RENDERED_PAGES = 50\n\nexport interface PdfViewerProps {\n  /** Bytes of the PDF. Fetched by the host over the authenticated serve route. */\n  data: ArrayBuffer\n  /** Render only the first page (THUMBNAIL presentation). */\n  firstPageOnly?: boolean\n  /** Target CSS width in px for a rendered page. Height follows the page aspect. */\n  targetWidth?: number\n  className?: string\n  /** Accessible name for the rendered document region. */\n  ariaLabel?: string\n}\n\nexport function PdfViewer({\n  data,\n  firstPageOnly = false,\n  targetWidth,\n  className,\n  ariaLabel,\n}: PdfViewerProps): React.JSX.Element {\n  const containerRef = React.useRef<HTMLDivElement | null>(null)\n  const [pageCount, setPageCount] = React.useState<number | null>(null)\n  const [error, setError] = React.useState<string | null>(null)\n  const [rendering, setRendering] = React.useState(true)\n\n  React.useEffect(() => {\n    let cancelled = false\n    let document_: PDFDocumentProxy | null = null\n    let loadingTask: ReturnType<typeof pdfjs.getDocument> | null = null\n    const container = containerRef.current\n    if (!container) return\n\n    // pdf.js TRANSFERS the buffer it is given, which would detach a caller-owned\n    // ArrayBuffer and make a re-render (or a second consumer) read zero bytes.\n    // Hand it a copy; the host keeps its own.\n    const ownedData = data.slice(0)\n\n    setRendering(true)\n    setError(null)\n    container.replaceChildren()\n\n    void (async () => {\n      try {\n        loadingTask = pdfjs.getDocument({ data: ownedData })\n        document_ = await loadingTask.promise\n        if (cancelled) return\n        setPageCount(document_.numPages)\n\n        const lastPage = firstPageOnly ? 1 : Math.min(document_.numPages, MAX_RENDERED_PAGES)\n        const dpr = typeof window !== 'undefined' ? (window.devicePixelRatio || 1) : 1\n\n        for (let pageNumber = 1; pageNumber <= lastPage; pageNumber++) {\n          if (cancelled) return\n          const page = await document_.getPage(pageNumber)\n          const unscaled = page.getViewport({ scale: 1 })\n          // `??` would NOT rescue a ZERO width: `0 ?? fallback` is 0, and a container\n          // that has not been laid out yet measures exactly 0 — which yields scale 0,\n          // a 0x0 canvas, and a `page.render()` that never settles (observed live:\n          // \"rendering page 1\" logged with no completion and a permanent skeleton).\n          // Fall back on the page's own width whenever the measurement is unusable.\n          const measuredWidth = targetWidth ?? container.clientWidth\n          const width = measuredWidth && measuredWidth > 0 ? measuredWidth : unscaled.width\n          const scale = width / unscaled.width\n          const viewport = page.getViewport({ scale: scale * dpr })\n\n          const canvas = window.document.createElement('canvas')\n          canvas.width = Math.floor(viewport.width)\n          canvas.height = Math.floor(viewport.height)\n          // CSS size stays in layout px; the canvas is oversampled by DPR so text\n          // is crisp on retina without the layout changing.\n          canvas.style.width = `${Math.floor(viewport.width / dpr)}px`\n          canvas.style.height = `${Math.floor(viewport.height / dpr)}px`\n          canvas.className = 'mx-auto max-w-full rounded-md border border-border shadow-xs'\n          canvas.setAttribute('role', 'img')\n          canvas.setAttribute('aria-label', `Page ${pageNumber}`)\n\n          // ATTACH BEFORE RENDERING. Rendering into a detached canvas and appending\n          // afterwards left `page.render()` unsettled indefinitely (observed live:\n          // \"rendering page 1\" with no completion). Attaching first also makes pages\n          // appear progressively instead of all at once at the end.\n          container.appendChild(canvas)\n\n          // pdf.js 6 takes the CANVAS, not a 2D context: `canvasContext` is the legacy\n          // parameter and its own typings state that using it requires `canvas` to be\n          // explicitly null. Passing both (the first attempt here) is not a supported\n          // combination and left the render promise unsettled.\n          await page.render({ canvas, viewport }).promise\n          if (cancelled) return\n        }\n      } catch (cause) {\n        if (!cancelled) setError(cause instanceof Error ? cause.message : String(cause))\n      } finally {\n        if (!cancelled) setRendering(false)\n      }\n    })()\n\n    return () => {\n      cancelled = true\n      // Do NOT call `loadingTask.destroy()`: with an externally-supplied worker port\n      // that also destroys the SHARED worker, and React StrictMode's double-mount\n      // then hits `PDFWorker.create - the worker is being destroyed` on the second\n      // pass (observed live). Releasing the document's own worker-side resources is\n      // what this component actually owns; the port outlives it by design.\n      void document_?.cleanup()\n    }\n  }, [data, firstPageOnly, targetWidth])\n\n  return (\n    <div className={cn('w-full', className)} aria-label={ariaLabel} aria-busy={rendering || undefined}>\n      {rendering && <Skeleton className=\"h-64 w-full\" aria-hidden=\"true\" />}\n      {error && (\n        <Text className=\"text-sm text-destructive\" role=\"alert\">{error}</Text>\n      )}\n      <div ref={containerRef} className=\"flex flex-col gap-item\" />\n      {!firstPageOnly && pageCount !== null && pageCount > MAX_RENDERED_PAGES && (\n        // Say what was NOT rendered rather than silently truncating — a document that\n        // looks complete but is not is worse than an explicit bound.\n        <Text className=\"mt-item text-xs text-muted-foreground\">\n          {`Showing the first ${MAX_RENDERED_PAGES} of ${pageCount} pages.`}\n        </Text>\n      )}\n    </div>\n  )\n}\n\nexport default PdfViewer\n"]}

package/dist/esm/components/data-display/pdf-viewer/pdf-viewer.lazy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PdfViewerLazy — the ONLY public door onto the PDF.js rendering core.
+ *
+ * Lazy-boundary wrapper (`*.lazy.tsx` convention, ChartView.lazy precedent): owns the
+ * `React.lazy(() => import(...))` split point and the layout-reserving Suspense
+ * fallback, and re-exports the props type via `import type` so consumers get typing
+ * with no runtime edge onto the heavy module. Everything except this wrapper (and
+ * tests) must import the viewer from HERE — enforced by `pnpm check:lazy-boundaries`.
+ */
+import * as React from "react";
+import type { PdfViewerProps } from "./pdf-viewer";
+export declare function PdfViewerLazy(props: PdfViewerProps): React.JSX.Element;
+export type { PdfViewerProps } from "./pdf-viewer";
+//# sourceMappingURL=pdf-viewer.lazy.d.ts.map

package/dist/esm/components/data-display/pdf-viewer/pdf-viewer.lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-viewer.lazy.d.ts","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer.lazy.tsx"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAIlD,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAMtE;AAED,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/dist/esm/components/data-display/pdf-viewer/pdf-viewer.lazy.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * PdfViewerLazy — the ONLY public door onto the PDF.js rendering core.
+ *
+ * Lazy-boundary wrapper (`*.lazy.tsx` convention, ChartView.lazy precedent): owns the
+ * `React.lazy(() => import(...))` split point and the layout-reserving Suspense
+ * fallback, and re-exports the props type via `import type` so consumers get typing
+ * with no runtime edge onto the heavy module. Everything except this wrapper (and
+ * tests) must import the viewer from HERE — enforced by `pnpm check:lazy-boundaries`.
+ */
+import * as React from "react";
+import { Skeleton } from "@wildo-ai/saas-frontend-lib";
+const LazyPdfViewerInner = React.lazy(() => import("./pdf-viewer.js"));
+export function PdfViewerLazy(props) {
+    return (_jsx(React.Suspense, { fallback: _jsx(Skeleton, { className: "h-64 w-full", "aria-hidden": "true" }), children: _jsx(LazyPdfViewerInner, { ...props }) }));
+}
+//# sourceMappingURL=pdf-viewer.lazy.js.map

package/dist/esm/components/data-display/pdf-viewer/pdf-viewer.lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-viewer.lazy.js","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer.lazy.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAA;;AAEZ;;;;;;;;GAQG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AAGtD,MAAM,kBAAkB,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAA;AAEnE,MAAM,UAAU,aAAa,CAAC,KAAqB;IACjD,OAAO,CACL,KAAC,KAAK,CAAC,QAAQ,IAAC,QAAQ,EAAE,KAAC,QAAQ,IAAC,SAAS,EAAC,aAAa,iBAAa,MAAM,GAAG,YAC/E,KAAC,kBAAkB,OAAK,KAAK,GAAI,GAClB,CAClB,CAAA;AACH,CAAC","sourcesContent":["\"use client\"\n\n/**\n * PdfViewerLazy — the ONLY public door onto the PDF.js rendering core.\n *\n * Lazy-boundary wrapper (`*.lazy.tsx` convention, ChartView.lazy precedent): owns the\n * `React.lazy(() => import(...))` split point and the layout-reserving Suspense\n * fallback, and re-exports the props type via `import type` so consumers get typing\n * with no runtime edge onto the heavy module. Everything except this wrapper (and\n * tests) must import the viewer from HERE — enforced by `pnpm check:lazy-boundaries`.\n */\n\nimport * as React from \"react\"\nimport { Skeleton } from \"@wildo-ai/saas-frontend-lib\"\nimport type { PdfViewerProps } from \"./pdf-viewer\"\n\nconst LazyPdfViewerInner = React.lazy(() => import(\"./pdf-viewer\"))\n\nexport function PdfViewerLazy(props: PdfViewerProps): React.JSX.Element {\n  return (\n    <React.Suspense fallback={<Skeleton className=\"h-64 w-full\" aria-hidden=\"true\" />}>\n      <LazyPdfViewerInner {...props} />\n    </React.Suspense>\n  )\n}\n\nexport type { PdfViewerProps } from \"./pdf-viewer\"\n"]}

package/dist/esm/components/feedback/celebration-overlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"celebration-overlay.d.ts","sourceRoot":"","sources":["../../../../src/components/feedback/celebration-overlay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAM1E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,gGA8H9B,CAAC"}
+{"version":3,"file":"celebration-overlay.d.ts","sourceRoot":"","sources":["../../../../../src/components/feedback/celebration-overlay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AA4B1E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,gGA4J9B,CAAC"}