@wildo-ai/presets-components 1.1.4 → 1.1.6

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

@@ -1 +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"]}
+{"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,qBAAqB,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAA;AACxF,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;;;;;GAKG;AACH,SAAS,sBAAsB,CAAC,EAAE,QAAQ,EAAiD;IACzF,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,wGAAwG,EAAE,IAAI,CAAC,IAAI,CAAC,oBACnH,aAAa,YAE5B,yBAAO,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAQ,GACvD,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,qBAAqB,IAAC,QAAQ,EAAC,gBAAgB,EAAC,QAAQ,EAAE,KAAC,sBAAsB,cAAE,KAAK,CAAC,QAAQ,GAA0B,YAC1H,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,GACK,CACzB,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 { LazyDoorErrorBoundary, 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 * What markdown degrades TO when the rendering pipeline never arrives (#963): the SOURCE, in the same\n * code block the mermaid fallback uses. Markdown is readable as text — headings, lists and links keep\n * their meaning unrendered — so the source is the most useful thing left to show, and it is the\n * person's own content rather than a word the door would have to invent.\n */\nfunction MarkdownSourceFallback({ children }: { children: MarkdownStreamProps[\"children\"] }): 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 border-dashed bg-muted/50 p-card-sm text-sm whitespace-pre-wrap\", code.base)}\n      data-lazy-door=\"unavailable\"\n    >\n      <code>{typeof children === \"string\" ? children : \"\"}</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    <LazyDoorErrorBoundary doorName=\"MarkdownStream\" fallback={<MarkdownSourceFallback>{props.children}</MarkdownSourceFallback>}>\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    </LazyDoorErrorBoundary>\n  )\n}\n"]}

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

@@ -1 +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"}
+{"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,EAAE,MAAM,6BAA6B,CAAA;AAkB7E,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

@@ -1,8 +1,8 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { IndicatorVariant, UIBehavior } from "@wildo-ai/presets-components-models";
+import { 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";
+import { cn, useUI, Badge, formatBadgeCount, indicatorBadgeVariant } from "@wildo-ai/saas-frontend-lib";
 /**
  * DEFAULT preset for `LOW_LEVEL_NOTIFICATION_INDICATOR` (R4). Composes the
  * design-system `Badge`:
@@ -15,14 +15,6 @@ import { cn, useUI, Badge, formatBadgeCount } from "@wildo-ai/saas-frontend-lib"
  * 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, }) {
@@ -31,7 +23,7 @@ export function NotificationIndicator({ mode, tone, count, pulse = false, label,
     if (mode === NotificationBadgeDisplayMode.NONE || count <= 0) {
         return null;
     }
-    const variant = TONE_TO_VARIANT[tone];
+    const variant = indicatorBadgeVariant(tone);
     const attention = pulse
         ? (getRecipe(UIBehavior.INDICATOR, tone).motion.attention ?? DEFAULT_ATTENTION)
         : undefined;

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

@@ -1 +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"]}
+{"version":3,"file":"notification-indicator.js","sourceRoot":"","sources":["../../../../../src/components/data-display/notification-indicator.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAA;;AAIZ,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAA;AAChE,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAA;AAGvG;;;;;;;;;;;GAWG;AAEH,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,qBAAqB,CAAC,IAAI,CAAC,CAAA;IAC3C,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 { UIBehavior } from \"@wildo-ai/presets-components-models\"\nimport { NotificationBadgeDisplayMode } from \"@wildo-ai/saas-models\"\nimport { cn, useUI, Badge, formatBadgeCount, indicatorBadgeVariant } from \"@wildo-ai/saas-frontend-lib\"\nimport type { NotificationIndicatorProps } 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/** 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 = indicatorBadgeVariant(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.map

@@ -1 +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"}
+{"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/pdf-viewer/pdf-viewer-worker.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The PDF.js worker SEAM (issue #962) — how a host decides where the viewer's Web Worker comes from.
+ *
+ * `pdf-viewer.tsx` parses on a Web Worker and installs ONE port for the whole module
+ * (`GlobalWorkerOptions.workerPort`). By default that port is built by the Vite path in
+ * `pdf-viewer-worker.vite.ts`, which is what the generated application runs. Two consumers this
+ * framework also produces cannot use that default:
+ *
+ *  - a NON-VITE bundler (the Docusaurus technical documentation is webpack) does not understand the
+ *    `?worker` asset suffix, so it must supply the worker itself;
+ *  - an application whose ASSETS ARE SERVED FROM ANOTHER ORIGIN (the opt-in CDN publish) gets a
+ *    cross-origin worker URL, which `new Worker(url)` refuses outright.
+ *
+ * Both register a factory here BEFORE the viewer's chunk loads (any time before the first document
+ * renders — the port is installed lazily on first use). The factory takes precedence over the Vite
+ * default, and the default's module is then never imported, which is what keeps the `?worker` import
+ * out of a non-Vite bundler's graph.
+ *
+ * This module is deliberately LIGHT: no `pdfjs-dist`, no worker, nothing heavy. It lives outside the
+ * lazy boundary so a host can call it from its bootstrap.
+ *
+ * ## The cross-origin case, and its CSP consequence
+ *
+ * A browser only constructs a Worker from a SAME-ORIGIN script URL. When the bundle (and so the worker
+ * file) is served from a CDN, the answer is a same-origin `blob:` shim whose single statement is
+ * `import "<cdn worker url>"` — `createSameOriginModuleWorker` builds exactly that, and
+ * `createModuleWorkerForUrl` picks it only when the URL's origin differs from the page's. The shim needs
+ * the policy to admit it: `worker-src` (falling back through `child-src` to `script-src`) must include
+ * `blob:`, and `script-src` must already admit the CDN origin for the import inside the shim to load —
+ * which a CDN publish's policy does, since every script comes from there. The `SAAS_APP` CSP baseline
+ * sets no `worker-src`; a CDN deployment adds `worker-src 'self' blob:` (the documentation product's
+ * baseline already carries that pair for its own reasons).
+ *
+ * Under Vite the worker URL is obtained with the `?worker&url` suffix on `pdfjs-dist/build/pdf.worker.min.mjs`,
+ * which names the BUILT worker file; under webpack, `new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url)`
+ * resolves through the bundler (it is Vite that does not resolve a bare specifier there — recorded in
+ * `pdf-viewer-worker.vite.ts`).
+ */
+/** Builds the Worker that PDF.js will parse on. Called at most once per page lifetime. */
+export type PdfViewerWorkerFactory = () => Worker;
+/**
+ * Register how the PDF viewer's worker is built, replacing the Vite default. Pass `null` to return
+ * to the default. Must run before the first document renders: the port is installed once, on first
+ * use, and a factory registered after that is not consulted (the viewer says so in its log).
+ */
+export declare function configurePdfViewerWorker(factory: PdfViewerWorkerFactory | null): void;
+/** The registered factory, or `null` when the Vite default applies. */
+export declare function resolveConfiguredPdfViewerWorkerFactory(): PdfViewerWorkerFactory | null;
+/**
+ * A same-origin MODULE worker for a worker script served from another origin: a `blob:` script whose
+ * only statement imports the real one. The blob URL is kept for the page's lifetime — a module
+ * worker fetches its script asynchronously, and revoking the URL before that fetch completes would
+ * hand the worker a dead URL (which reads as "the worker never answered", the same silent shape as
+ * a classic-vs-module mismatch).
+ */
+export declare function createSameOriginModuleWorker(workerScriptUrl: string): Worker;
+/**
+ * A module worker for `workerScriptUrl`: constructed directly when the script is same-origin with the
+ * page, through the `blob:` shim when it is not. `pageOrigin` defaults to the page's own; a host that
+ * knows better (a test, a non-browser runtime) passes it.
+ */
+export declare function createModuleWorkerForUrl(workerScriptUrl: string, pageOrigin?: string | null): Worker;
+//# sourceMappingURL=pdf-viewer-worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-viewer-worker.d.ts","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,0FAA0F;AAC1F,MAAM,MAAM,sBAAsB,GAAG,MAAM,MAAM,CAAA;AAIjD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,GAAG,IAAI,CAErF;AAED,uEAAuE;AACvE,wBAAgB,uCAAuC,IAAI,sBAAsB,GAAG,IAAI,CAEvF;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,eAAe,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,GAAG,IAA0C,GAAG,MAAM,CAMzI"}

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

@@ -0,0 +1,75 @@
+/**
+ * The PDF.js worker SEAM (issue #962) — how a host decides where the viewer's Web Worker comes from.
+ *
+ * `pdf-viewer.tsx` parses on a Web Worker and installs ONE port for the whole module
+ * (`GlobalWorkerOptions.workerPort`). By default that port is built by the Vite path in
+ * `pdf-viewer-worker.vite.ts`, which is what the generated application runs. Two consumers this
+ * framework also produces cannot use that default:
+ *
+ *  - a NON-VITE bundler (the Docusaurus technical documentation is webpack) does not understand the
+ *    `?worker` asset suffix, so it must supply the worker itself;
+ *  - an application whose ASSETS ARE SERVED FROM ANOTHER ORIGIN (the opt-in CDN publish) gets a
+ *    cross-origin worker URL, which `new Worker(url)` refuses outright.
+ *
+ * Both register a factory here BEFORE the viewer's chunk loads (any time before the first document
+ * renders — the port is installed lazily on first use). The factory takes precedence over the Vite
+ * default, and the default's module is then never imported, which is what keeps the `?worker` import
+ * out of a non-Vite bundler's graph.
+ *
+ * This module is deliberately LIGHT: no `pdfjs-dist`, no worker, nothing heavy. It lives outside the
+ * lazy boundary so a host can call it from its bootstrap.
+ *
+ * ## The cross-origin case, and its CSP consequence
+ *
+ * A browser only constructs a Worker from a SAME-ORIGIN script URL. When the bundle (and so the worker
+ * file) is served from a CDN, the answer is a same-origin `blob:` shim whose single statement is
+ * `import "<cdn worker url>"` — `createSameOriginModuleWorker` builds exactly that, and
+ * `createModuleWorkerForUrl` picks it only when the URL's origin differs from the page's. The shim needs
+ * the policy to admit it: `worker-src` (falling back through `child-src` to `script-src`) must include
+ * `blob:`, and `script-src` must already admit the CDN origin for the import inside the shim to load —
+ * which a CDN publish's policy does, since every script comes from there. The `SAAS_APP` CSP baseline
+ * sets no `worker-src`; a CDN deployment adds `worker-src 'self' blob:` (the documentation product's
+ * baseline already carries that pair for its own reasons).
+ *
+ * Under Vite the worker URL is obtained with the `?worker&url` suffix on `pdfjs-dist/build/pdf.worker.min.mjs`,
+ * which names the BUILT worker file; under webpack, `new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url)`
+ * resolves through the bundler (it is Vite that does not resolve a bare specifier there — recorded in
+ * `pdf-viewer-worker.vite.ts`).
+ */
+let configuredFactory = null;
+/**
+ * Register how the PDF viewer's worker is built, replacing the Vite default. Pass `null` to return
+ * to the default. Must run before the first document renders: the port is installed once, on first
+ * use, and a factory registered after that is not consulted (the viewer says so in its log).
+ */
+export function configurePdfViewerWorker(factory) {
+    configuredFactory = factory;
+}
+/** The registered factory, or `null` when the Vite default applies. */
+export function resolveConfiguredPdfViewerWorkerFactory() {
+    return configuredFactory;
+}
+/**
+ * A same-origin MODULE worker for a worker script served from another origin: a `blob:` script whose
+ * only statement imports the real one. The blob URL is kept for the page's lifetime — a module
+ * worker fetches its script asynchronously, and revoking the URL before that fetch completes would
+ * hand the worker a dead URL (which reads as "the worker never answered", the same silent shape as
+ * a classic-vs-module mismatch).
+ */
+export function createSameOriginModuleWorker(workerScriptUrl) {
+    const shim = new Blob([`import ${JSON.stringify(workerScriptUrl)};\n`], { type: 'text/javascript' });
+    return new Worker(URL.createObjectURL(shim), { type: 'module' });
+}
+/**
+ * A module worker for `workerScriptUrl`: constructed directly when the script is same-origin with the
+ * page, through the `blob:` shim when it is not. `pageOrigin` defaults to the page's own; a host that
+ * knows better (a test, a non-browser runtime) passes it.
+ */
+export function createModuleWorkerForUrl(workerScriptUrl, pageOrigin = globalThis.location?.origin ?? null) {
+    const resolved = new URL(workerScriptUrl, pageOrigin ?? undefined);
+    if (pageOrigin !== null && resolved.origin !== pageOrigin) {
+        return createSameOriginModuleWorker(resolved.href);
+    }
+    return new Worker(resolved, { type: 'module' });
+}
+//# sourceMappingURL=pdf-viewer-worker.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-viewer-worker.js","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAKH,IAAI,iBAAiB,GAAkC,IAAI,CAAA;AAE3D;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAsC;IAC7E,iBAAiB,GAAG,OAAO,CAAA;AAC7B,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,uCAAuC;IACrD,OAAO,iBAAiB,CAAA;AAC1B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,4BAA4B,CAAC,eAAuB;IAClE,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,UAAU,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAA;IACpG,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;AAClE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,eAAuB,EAAE,aAA4B,UAAU,CAAC,QAAQ,EAAE,MAAM,IAAI,IAAI;IAC/H,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,eAAe,EAAE,UAAU,IAAI,SAAS,CAAC,CAAA;IAClE,IAAI,UAAU,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QAC1D,OAAO,4BAA4B,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;IACpD,CAAC;IACD,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;AACjD,CAAC","sourcesContent":["/**\n * The PDF.js worker SEAM (issue #962) — how a host decides where the viewer's Web Worker comes from.\n *\n * `pdf-viewer.tsx` parses on a Web Worker and installs ONE port for the whole module\n * (`GlobalWorkerOptions.workerPort`). By default that port is built by the Vite path in\n * `pdf-viewer-worker.vite.ts`, which is what the generated application runs. Two consumers this\n * framework also produces cannot use that default:\n *\n *  - a NON-VITE bundler (the Docusaurus technical documentation is webpack) does not understand the\n *    `?worker` asset suffix, so it must supply the worker itself;\n *  - an application whose ASSETS ARE SERVED FROM ANOTHER ORIGIN (the opt-in CDN publish) gets a\n *    cross-origin worker URL, which `new Worker(url)` refuses outright.\n *\n * Both register a factory here BEFORE the viewer's chunk loads (any time before the first document\n * renders — the port is installed lazily on first use). The factory takes precedence over the Vite\n * default, and the default's module is then never imported, which is what keeps the `?worker` import\n * out of a non-Vite bundler's graph.\n *\n * This module is deliberately LIGHT: no `pdfjs-dist`, no worker, nothing heavy. It lives outside the\n * lazy boundary so a host can call it from its bootstrap.\n *\n * ## The cross-origin case, and its CSP consequence\n *\n * A browser only constructs a Worker from a SAME-ORIGIN script URL. When the bundle (and so the worker\n * file) is served from a CDN, the answer is a same-origin `blob:` shim whose single statement is\n * `import \"<cdn worker url>\"` — `createSameOriginModuleWorker` builds exactly that, and\n * `createModuleWorkerForUrl` picks it only when the URL's origin differs from the page's. The shim needs\n * the policy to admit it: `worker-src` (falling back through `child-src` to `script-src`) must include\n * `blob:`, and `script-src` must already admit the CDN origin for the import inside the shim to load —\n * which a CDN publish's policy does, since every script comes from there. The `SAAS_APP` CSP baseline\n * sets no `worker-src`; a CDN deployment adds `worker-src 'self' blob:` (the documentation product's\n * baseline already carries that pair for its own reasons).\n *\n * Under Vite the worker URL is obtained with the `?worker&url` suffix on `pdfjs-dist/build/pdf.worker.min.mjs`,\n * which names the BUILT worker file; under webpack, `new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url)`\n * resolves through the bundler (it is Vite that does not resolve a bare specifier there — recorded in\n * `pdf-viewer-worker.vite.ts`).\n */\n\n/** Builds the Worker that PDF.js will parse on. Called at most once per page lifetime. */\nexport type PdfViewerWorkerFactory = () => Worker\n\nlet configuredFactory: PdfViewerWorkerFactory | null = null\n\n/**\n * Register how the PDF viewer's worker is built, replacing the Vite default. Pass `null` to return\n * to the default. Must run before the first document renders: the port is installed once, on first\n * use, and a factory registered after that is not consulted (the viewer says so in its log).\n */\nexport function configurePdfViewerWorker(factory: PdfViewerWorkerFactory | null): void {\n  configuredFactory = factory\n}\n\n/** The registered factory, or `null` when the Vite default applies. */\nexport function resolveConfiguredPdfViewerWorkerFactory(): PdfViewerWorkerFactory | null {\n  return configuredFactory\n}\n\n/**\n * A same-origin MODULE worker for a worker script served from another origin: a `blob:` script whose\n * only statement imports the real one. The blob URL is kept for the page's lifetime — a module\n * worker fetches its script asynchronously, and revoking the URL before that fetch completes would\n * hand the worker a dead URL (which reads as \"the worker never answered\", the same silent shape as\n * a classic-vs-module mismatch).\n */\nexport function createSameOriginModuleWorker(workerScriptUrl: string): Worker {\n  const shim = new Blob([`import ${JSON.stringify(workerScriptUrl)};\\n`], { type: 'text/javascript' })\n  return new Worker(URL.createObjectURL(shim), { type: 'module' })\n}\n\n/**\n * A module worker for `workerScriptUrl`: constructed directly when the script is same-origin with the\n * page, through the `blob:` shim when it is not. `pageOrigin` defaults to the page's own; a host that\n * knows better (a test, a non-browser runtime) passes it.\n */\nexport function createModuleWorkerForUrl(workerScriptUrl: string, pageOrigin: string | null = globalThis.location?.origin ?? null): Worker {\n  const resolved = new URL(workerScriptUrl, pageOrigin ?? undefined)\n  if (pageOrigin !== null && resolved.origin !== pageOrigin) {\n    return createSameOriginModuleWorker(resolved.href)\n  }\n  return new Worker(resolved, { type: 'module' })\n}\n"]}

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

@@ -0,0 +1,32 @@
+/**
+ * The VITE default for the PDF.js worker (issue #962) — the only module in the viewer that carries a
+ * bundler-specific import, kept alone so a host on another bundler never has to compile it.
+ *
+ * `pdf-viewer.tsx` reaches this file through `import(/* webpackIgnore: true *\/ …)` and ONLY when no
+ * factory was registered through `configurePdfViewerWorker`. webpack honours that magic comment by
+ * leaving the import as a native `import()` it does not follow, so the `?worker` specifier below never
+ * enters a webpack graph; Vite ignores the comment and bundles this module as usual.
+ *
+ * ⚠️ TWO earlier attempts at a bundler-neutral default 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)` — Vite's `new URL()` handling
+ *     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
+ * (module in dev, the built format in production), which removes the classic-vs-module question
+ * entirely. Vite emits the worker as its own fingerprinted file served from the SAME ORIGIN as the
+ * bundle — never a CDN, which would both leak document bytes' provenance and need a `worker-src`
+ * exception. A deployment that serves its bundle from another origin registers a factory instead
+ * (`createModuleWorkerForUrl` in `pdf-viewer-worker.ts`, fed the `?worker&url` URL).
+ */
+/** The Vite-built PDF.js worker, as the generated application constructs it. */
+export declare function createViteDefaultPdfViewerWorker(): Worker;
+//# sourceMappingURL=pdf-viewer-worker.vite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-viewer-worker.vite.d.ts","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer-worker.vite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAKH,gFAAgF;AAChF,wBAAgB,gCAAgC,IAAI,MAAM,CAEzD"}

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

@@ -0,0 +1,36 @@
+/**
+ * The VITE default for the PDF.js worker (issue #962) — the only module in the viewer that carries a
+ * bundler-specific import, kept alone so a host on another bundler never has to compile it.
+ *
+ * `pdf-viewer.tsx` reaches this file through `import(/* webpackIgnore: true *\/ …)` and ONLY when no
+ * factory was registered through `configurePdfViewerWorker`. webpack honours that magic comment by
+ * leaving the import as a native `import()` it does not follow, so the `?worker` specifier below never
+ * enters a webpack graph; Vite ignores the comment and bundles this module as usual.
+ *
+ * ⚠️ TWO earlier attempts at a bundler-neutral default 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)` — Vite's `new URL()` handling
+ *     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
+ * (module in dev, the built format in production), which removes the classic-vs-module question
+ * entirely. Vite emits the worker as its own fingerprinted file served from the SAME ORIGIN as the
+ * bundle — never a CDN, which would both leak document bytes' provenance and need a `worker-src`
+ * exception. A deployment that serves its bundle from another origin registers a factory instead
+ * (`createModuleWorkerForUrl` in `pdf-viewer-worker.ts`, fed the `?worker&url` URL).
+ */
+// @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';
+/** The Vite-built PDF.js worker, as the generated application constructs it. */
+export function createViteDefaultPdfViewerWorker() {
+    return new PdfJsWorker();
+}
+//# sourceMappingURL=pdf-viewer-worker.vite.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-viewer-worker.vite.js","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer-worker.vite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,sFAAsF;AACtF,OAAO,WAAW,MAAM,4CAA4C,CAAA;AAEpE,gFAAgF;AAChF,MAAM,UAAU,gCAAgC;IAC9C,OAAO,IAAI,WAAW,EAAY,CAAA;AACpC,CAAC","sourcesContent":["/**\n * The VITE default for the PDF.js worker (issue #962) — the only module in the viewer that carries a\n * bundler-specific import, kept alone so a host on another bundler never has to compile it.\n *\n * `pdf-viewer.tsx` reaches this file through `import(/* webpackIgnore: true *\\/ …)` and ONLY when no\n * factory was registered through `configurePdfViewerWorker`. webpack honours that magic comment by\n * leaving the import as a native `import()` it does not follow, so the `?worker` specifier below never\n * enters a webpack graph; Vite ignores the comment and bundles this module as usual.\n *\n * ⚠️ TWO earlier attempts at a bundler-neutral default failed at RENDER time, not build time — which\n * is why they survived typecheck and the lazy-boundary guard. Both are recorded so the next author does\n * not walk back into them:\n *\n *  1. `new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url)` — Vite's `new URL()` handling\n *     resolves only RELATIVE paths against the module URL; a bare package specifier is not\n *     bundler-resolved, so the browser requested a path that does not exist and pdf.js reported\n *     `Setting up fake worker failed`.\n *  2. `?url` + `GlobalWorkerOptions.workerSrc` — the URL resolved and the file was served (200), but\n *     pdf.js instantiates a `workerSrc` string as a CLASSIC worker while pdf.js 6 ships the worker as an\n *     ES module. The worker never completed its handshake, so `getDocument()` hung forever with no\n *     error to show.\n *\n * `?worker` hands us a bundler-generated constructor that already carries the right worker type\n * (module in dev, the built format in production), which removes the classic-vs-module question\n * entirely. Vite emits the worker as its own fingerprinted file served from the SAME ORIGIN as the\n * bundle — never a CDN, which would both leak document bytes' provenance and need a `worker-src`\n * exception. A deployment that serves its bundle from another origin registers a factory instead\n * (`createModuleWorkerForUrl` in `pdf-viewer-worker.ts`, fed the `?worker&url` URL).\n */\n\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\n/** The Vite-built PDF.js worker, as the generated application constructs it. */\nexport function createViteDefaultPdfViewerWorker(): Worker {\n  return new PdfJsWorker() as Worker\n}\n"]}

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

@@ -26,13 +26,51 @@
  *
  * ## 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:`.
+ * PDF.js parses on a Web Worker. ONE port for the whole module, installed lazily on the
+ * first render (`ensurePdfViewerWorkerPort`) and assigned to `GlobalWorkerOptions.workerPort`:
+ * 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 avoids
+ * spawning a worker per rendered thumbnail. A per-instance `PDFWorker` was tried first
+ * out of a concurrency worry that does not apply.
+ *
+ * WHERE the worker comes from is the host's decision (issue #962, `pdf-viewer-worker.ts`):
+ * a factory registered through `configurePdfViewerWorker` wins; otherwise the Vite default
+ * in `pdf-viewer-worker.vite.ts` is imported — and only then, so a non-Vite bundler that
+ * registered a factory never compiles the `?worker` import. The default is a same-origin
+ * file URL, so the `SAAS_APP` CSP baseline needs nothing beyond `script-src 'self'`; the
+ * cross-origin (CDN publish) case and its `worker-src blob:` note live with the seam.
+ *
+ * ## Text
+ *
+ * The viewer is label-agnostic: every string it shows or announces arrives resolved in
+ * `labels` from its host, which owns the component's i18n catalog. A failure is shown
+ * as the host's labelled message and the cause is logged — a raw pdf.js exception
+ * message is developer text, not something to put in front of a reader.
  */
 import * as React from "react";
+/**
+ * Install the module-wide worker port once, from the host's factory when one is registered and from
+ * the Vite default otherwise (issue #962). Idempotent and memoised: every render awaits the same
+ * installation, and a factory registered AFTER it is not consulted. The Vite module is reached
+ * through a dynamic import that webpack is told not to follow (`webpackIgnore`), which is what keeps
+ * its `?worker` specifier out of a non-Vite graph; a host on such a bundler that registered no
+ * factory gets a rejected installation here — surfaced as the viewer's labelled failure with the
+ * cause in the log, never a hang.
+ */
+export declare function ensurePdfViewerWorkerPort(): Promise<void>;
+/**
+ * Every string the viewer shows or announces, RESOLVED by the host. Functions where
+ * the text carries a number, so the host's i18n interpolation — not this module —
+ * decides word order.
+ */
+export interface PdfViewerLabels {
+    /** Accessible name of one rendered page image. */
+    page(pageNumber: number): string;
+    /** Notice under a document longer than the render cap. */
+    pagesTruncated(shown: number, total: number): string;
+    /** Alert shown when the document cannot be rendered. */
+    renderFailed: string;
+}
 export interface PdfViewerProps {
     /** Bytes of the PDF. Fetched by the host over the authenticated serve route. */
     data: ArrayBuffer;
@@ -43,7 +81,9 @@ export interface PdfViewerProps {
     className?: string;
     /** Accessible name for the rendered document region. */
     ariaLabel?: string;
+    /** Resolved text. Required: the viewer invents no words of its own. */
+    labels: PdfViewerLabels;
 }
-export declare function PdfViewer({ data, firstPageOnly, targetWidth, className, ariaLabel, }: PdfViewerProps): React.JSX.Element;
+export declare function PdfViewer({ data, firstPageOnly, targetWidth, className, ariaLabel, labels, }: 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

@@ -1 +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"}
+{"version":3,"file":"pdf-viewer.d.ts","sourceRoot":"","sources":["../../../../../../src/components/data-display/pdf-viewer/pdf-viewer.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAS9B;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAezD;AAOD;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;IAChC,0DAA0D;IAC1D,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IACpD,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,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;IAClB,uEAAuE;IACvE,MAAM,EAAE,eAAe,CAAA;CACxB;AAED,wBAAgB,SAAS,CAAC,EACxB,IAAI,EACJ,aAAqB,EACrB,WAAW,EACX,SAAS,EACT,SAAS,EACT,MAAM,GACP,EAAE,cAAc,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAoHpC;AAED,eAAe,SAAS,CAAA"}

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

@@ -28,54 +28,71 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  *
  * ## 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:`.
+ * PDF.js parses on a Web Worker. ONE port for the whole module, installed lazily on the
+ * first render (`ensurePdfViewerWorkerPort`) and assigned to `GlobalWorkerOptions.workerPort`:
+ * 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 avoids
+ * spawning a worker per rendered thumbnail. A per-instance `PDFWorker` was tried first
+ * out of a concurrency worry that does not apply.
+ *
+ * WHERE the worker comes from is the host's decision (issue #962, `pdf-viewer-worker.ts`):
+ * a factory registered through `configurePdfViewerWorker` wins; otherwise the Vite default
+ * in `pdf-viewer-worker.vite.ts` is imported — and only then, so a non-Vite bundler that
+ * registered a factory never compiles the `?worker` import. The default is a same-origin
+ * file URL, so the `SAAS_APP` CSP baseline needs nothing beyond `script-src 'self'`; the
+ * cross-origin (CDN publish) case and its `worker-src blob:` note live with the seam.
+ *
+ * ## Text
+ *
+ * The viewer is label-agnostic: every string it shows or announces arrives resolved in
+ * `labels` from its host, which owns the component's i18n catalog. A failure is shown
+ * as the host's labelled message and the cause is logged — a raw pdf.js exception
+ * message is developer text, not something to put in front of a reader.
  */
 import * as React from "react";
-import { cn, Text, Skeleton } from "@wildo-ai/saas-frontend-lib";
+import { cn, Text, Skeleton, LoggerFrontendService } 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();
+import { resolveConfiguredPdfViewerWorkerFactory } from "./pdf-viewer-worker.js";
+import { describeCaughtError } from '@wildo-ai/saas-models';
+let workerPortInstallation = null;
+/**
+ * Install the module-wide worker port once, from the host's factory when one is registered and from
+ * the Vite default otherwise (issue #962). Idempotent and memoised: every render awaits the same
+ * installation, and a factory registered AFTER it is not consulted. The Vite module is reached
+ * through a dynamic import that webpack is told not to follow (`webpackIgnore`), which is what keeps
+ * its `?worker` specifier out of a non-Vite graph; a host on such a bundler that registered no
+ * factory gets a rejected installation here — surfaced as the viewer's labelled failure with the
+ * cause in the log, never a hang.
+ */
+export function ensurePdfViewerWorkerPort() {
+    if (workerPortInstallation === null) {
+        workerPortInstallation = (async () => {
+            const configured = resolveConfiguredPdfViewerWorkerFactory();
+            const worker = configured
+                ? configured()
+                : (await import(/* webpackIgnore: true */ './pdf-viewer-worker.vite')).createViteDefaultPdfViewerWorker();
+            pdfjs.GlobalWorkerOptions.workerPort = worker;
+        })().catch((cause) => {
+            // A failed installation must not poison every later render: the next one asks again.
+            workerPortInstallation = null;
+            throw cause;
+        });
+    }
+    return workerPortInstallation;
+}
 /** 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 logger = LoggerFrontendService.getLogger();
+export function PdfViewer({ data, firstPageOnly = false, targetWidth, className, ariaLabel, labels, }) {
     const containerRef = React.useRef(null);
     const [pageCount, setPageCount] = React.useState(null);
-    const [error, setError] = React.useState(null);
+    const [renderFailed, setRenderFailed] = React.useState(false);
     const [rendering, setRendering] = React.useState(true);
+    // Read through a ref inside the render effect: `labels.page` is a function the host
+    // may recreate every render, and re-rasterising a whole document because a label
+    // closure changed identity would be a visible flicker for no reason.
+    const pageLabelRef = React.useRef(labels.page);
+    pageLabelRef.current = labels.page;
     React.useEffect(() => {
         let cancelled = false;
         let document_ = null;
@@ -88,10 +105,13 @@ export function PdfViewer({ data, firstPageOnly = false, targetWidth, className,
         // Hand it a copy; the host keeps its own.
         const ownedData = data.slice(0);
         setRendering(true);
-        setError(null);
+        setRenderFailed(false);
         container.replaceChildren();
         void (async () => {
             try {
+                await ensurePdfViewerWorkerPort();
+                if (cancelled)
+                    return;
                 loadingTask = pdfjs.getDocument({ data: ownedData });
                 document_ = await loadingTask.promise;
                 if (cancelled)
@@ -122,7 +142,7 @@ export function PdfViewer({ data, firstPageOnly = false, targetWidth, className,
                     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}`);
+                    canvas.setAttribute('aria-label', pageLabelRef.current(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
@@ -138,8 +158,12 @@ export function PdfViewer({ data, firstPageOnly = false, targetWidth, className,
                 }
             }
             catch (cause) {
-                if (!cancelled)
-                    setError(cause instanceof Error ? cause.message : String(cause));
+                if (!cancelled) {
+                    logger.warn('[PdfViewer] document could not be rendered', {
+                        error: describeCaughtError(cause),
+                    });
+                    setRenderFailed(true);
+                }
             }
             finally {
                 if (!cancelled)
@@ -156,10 +180,10 @@ export function PdfViewer({ data, firstPageOnly = false, targetWidth, className,
             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 && (
+    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" }), renderFailed && (_jsx(Text, { className: "text-sm text-destructive", role: "alert", children: labels.renderFailed })), _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.` }))] }));
+            _jsx(Text, { className: "mt-item text-xs text-muted-foreground", children: labels.pagesTruncated(MAX_RENDERED_PAGES, pageCount) }))] }));
 }
 export default PdfViewer;
 //# sourceMappingURL=pdf-viewer.js.map