@scalebun/web 1.0.0 → 1.2.1

package/dist/features/errors/ErrorsFeature.js

@@ -3,11 +3,11 @@
  * Auto path (window.onerror + unhandledrejection) is throttled (anti-flood); the manual path
  * (captureError) is NOT — it's dev-intentional, not a loop.
  */
-import { toErrorItem } from './normalize';
-import { ErrorThrottle } from './dedup';
-import { resolveScope } from './scope';
-import { shouldSampleErrors } from './sampling';
-import { breadcrumbs } from '../../core';
+import { toErrorItem } from './normalize.js';
+import { ErrorThrottle } from './dedup.js';
+import { resolveScope } from './scope.js';
+import { shouldSampleErrors } from './sampling.js';
+import { breadcrumbs } from '../../core/index.js';
 const noParse = () => [];
 function firstFrame(stack) {
     if (!stack)
@@ -65,7 +65,7 @@ export class ErrorsFeature {
         // Per-session sampling gates only the AUTO firehose; manual captureError always works.
         this.sampled = shouldSampleErrors(opts?.sampleRate, ctx.sessionId);
         // Load the enrichment chunk now (at init), so it's ready well before the first error.
-        void import('./lazy')
+        void import('./lazy.js')
             .then((m) => {
             this.parseStack = m.parseStack;
             this.computeFingerprint = m.computeFingerprint;

package/dist/features/errors/group/fingerprint.js

@@ -1,4 +1,4 @@
-import { fnv1a32 } from '../../config/bucketing';
+import { fnv1a32 } from '../../config/bucketing.js';
 const MAX_FP_FRAMES = 5; // top N frames define the group
 /** Drop the scheme://host from a URL file (keep the path) so the same error on staging vs prod —
  *  or behind a CDN — fingerprints identically. Non-URL files (native, <anonymous>, relative) pass through. */

package/dist/features/errors/lazy.d.ts

@@ -2,7 +2,7 @@
  * The error-enrichment helpers, bundled into ONE lazy chunk (loaded once in ErrorsFeature.setup) so
  * the parser + fingerprint (+ fnv1a) stay out of the core bundle. Add new heavy enrichers here.
  */
-export { parseStack } from './parse/stacktrace';
-export { computeFingerprint } from './group/fingerprint';
-export { extractCauses } from './causes';
+export { parseStack } from './parse/stacktrace.js';
+export { computeFingerprint } from './group/fingerprint.js';
+export { extractCauses } from './causes.js';
 //# sourceMappingURL=lazy.d.ts.map

package/dist/features/errors/lazy.js

@@ -2,7 +2,7 @@
  * The error-enrichment helpers, bundled into ONE lazy chunk (loaded once in ErrorsFeature.setup) so
  * the parser + fingerprint (+ fnv1a) stay out of the core bundle. Add new heavy enrichers here.
  */
-export { parseStack } from './parse/stacktrace';
-export { computeFingerprint } from './group/fingerprint';
-export { extractCauses } from './causes';
+export { parseStack } from './parse/stacktrace.js';
+export { computeFingerprint } from './group/fingerprint.js';
+export { extractCauses } from './causes.js';
 //# sourceMappingURL=lazy.js.map

package/dist/features/errors/normalize.d.ts

@@ -1,7 +1,7 @@
 /** Builds a contract `error` Item from a raw browser error. Shared by the auto + manual paths. */
 import type { ErrorItem, StackFrame } from '@scalebun/protocol';
-import type { ResolvedScope } from './scope';
-import type { Cause } from './causes';
+import type { ResolvedScope } from './scope.js';
+import type { Cause } from './causes.js';
 /** How an error reached the SDK — provenance for the dashboard (handled vs unhandled vs resource). */
 export type ErrorMechanism = 'onerror' | 'onunhandledrejection' | 'captureError' | 'resource';
 export interface RawError {

package/dist/features/errors/normalize.js

@@ -1,6 +1,6 @@
 /** Builds a contract `error` Item from a raw browser error. Shared by the auto + manual paths. */
-import { uuid, now, scrubText, breadcrumbs, getReplayCoord } from '../../core';
-import { scrubStack, scrubExtra } from './redact';
+import { uuid, now, scrubText, breadcrumbs, getReplayCoord } from '../../core/index.js';
+import { scrubStack, scrubExtra } from './redact.js';
 const MAX_STACK = 16 * 1024; // protect payloads from pathological stacks
 export function toErrorItem(raw, enrich = {}) {
     const { droppedSince = 0, extra, frames, fingerprint, causes, scope } = enrich;

package/dist/features/errors/redact.js

@@ -5,7 +5,7 @@
  *    those intact), so we strip only emails + URL query strings — never the opaque-token pass.
  *  - `scrubExtra`: scrub user-supplied `extra`/context string values (these ARE free-text PII).
  */
-import { scrubText } from '../../core';
+import { scrubText } from '../../core/index.js';
 /** Scrub a stack conservatively: emails + URL query strings (which can carry tokens/PII), while
  *  preserving `:line:col` and minified frame names so issue-grouping stays stable. */
 export function scrubStack(stack) {

package/dist/features/errors/sampling.js

@@ -7,7 +7,7 @@
  * Most apps should leave this at 1 and manage volume via grouping / `ignoreErrors` / `beforeSend`;
  * sampling trades error completeness for cost and should be an explicit choice.
  */
-import { bucketOf } from '../config/bucketing';
+import { bucketOf } from '../config/bucketing.js';
 // NOTE: keeps the legacy `wzb-` prefix on purpose. This salt is a bucketing input, not
 // branding — nobody ever sees it, and changing the string reshuffles which sessions are
 // sampled. It was left untouched by the ScaleBun rebrand for that reason.

package/dist/features/exit-intent/ExitIntentFeature.js

@@ -10,7 +10,7 @@ export class ExitIntentFeature {
         if (typeof window === 'undefined' || typeof document === 'undefined')
             return;
         this.active = true;
-        const { startExitIntent } = await import('./engine');
+        const { startExitIntent } = await import('./engine.js');
         // Host-supplied thresholds (config.exitIntent) override REVERSAL_DEFAULTS per key; undefined = defaults.
         if (!this.active)
             return; // torn down while the chunk loaded

package/dist/features/exit-intent/engine.js

@@ -1,4 +1,4 @@
-import { scrollDepthPct } from '../../core/scrollDepth';
+import { scrollDepthPct } from '../../core/scrollDepth.js';
 export const EXIT_WEIGHTS = {
     top_exit: 0.8, // pointer leaves the document at the top edge (toward the tab bar/URL)
     scroll_reversal: 0.5, // fast scroll-up after having scrolled down (works on touch)

package/dist/features/forms/index.js

@@ -19,7 +19,7 @@
  * VOLUME: terminal-summary model — `$form_start` plus ONE terminal event (`$submit` enriched, or
  * `$form_abandon`) carrying a per-field summary. ~2–3 events per form, not one per field.
  */
-import { scrubText } from '../../core';
+import { scrubText } from '../../core/index.js';
 /** Inputs we never observe at all — not even metadata. */
 const SENSITIVE_TYPES = new Set(['password', 'hidden']);
 const SENSITIVE_AUTOCOMPLETE = /(^|\s|-)(cc-|new-password|current-password|one-time-code)/i;

package/dist/features/inapp/InApp2Feature.js

@@ -12,7 +12,7 @@ export class InApp2Feature {
         if (!ctx.clientKey || !ctx.apiBaseUrl)
             return;
         this.active = true;
-        const { InAppEngine } = await import('./core/engine');
+        const { InAppEngine } = await import('./core/engine.js');
         if (!this.active)
             return; // torn down while the chunk loaded
         this.engine = new InAppEngine({

package/dist/features/inapp/anchor/controller.d.ts

@@ -1,5 +1,5 @@
-import { ObserverHub } from '../../coach/observers';
-import type { AnchorSpec, Placement, PositionResult } from '../../coach/types';
+import { ObserverHub } from '../../coach/observers.js';
+import type { AnchorSpec, Placement, PositionResult } from '../../coach/types.js';
 export interface LiveAnchorHooks {
     /** Apply the computed position to the surface (x/y in viewport coords). */
     onReposition(pos: PositionResult, anchorEl: Element): void;

package/dist/features/inapp/anchor/controller.js

@@ -12,9 +12,9 @@
  * vanishes and can't be re-found within a grace window, it calls `onLost` so the surface can degrade
  * gracefully (e.g. fall back to a toast) instead of floating in a dead spot.
  */
-import { resolveAnchor, didHeal } from '../../coach/anchor';
-import { computePosition } from '../../coach/position';
-import { ObserverHub } from '../../coach/observers';
+import { resolveAnchor, didHeal } from '../../coach/anchor.js';
+import { computePosition } from '../../coach/position.js';
+import { ObserverHub } from '../../coach/observers.js';
 function viewportRect() {
     const w = typeof innerWidth !== 'undefined' ? innerWidth : 1024;
     const h = typeof innerHeight !== 'undefined' ? innerHeight : 768;

package/dist/features/inapp/api.d.ts

@@ -9,11 +9,11 @@
  * The engine (later) uses the same `render` path; adapters use `registerSlot`. One code path, many
  * front-ends.
  */
-import { ShadowHost, type ThemeMode } from './core/host';
-import { SlotRegistry } from './core/slots';
-import { type RenderedSurface } from './surfaces/render';
-import type { SurfaceHooks } from './surfaces/surface';
-import type { Variant } from './types';
+import { ShadowHost, type ThemeMode } from './core/host.js';
+import { SlotRegistry } from './core/slots.js';
+import { type RenderedSurface } from './surfaces/render.js';
+import type { SurfaceHooks } from './surfaces/surface.js';
+import type { Variant } from './types.js';
 /** No-op hooks so callers can render without wiring analytics (e.g. dashboard preview). */
 export declare function noopHooks(): SurfaceHooks;
 export declare class InAppHeadless {

package/dist/features/inapp/api.js

@@ -9,9 +9,9 @@
  * The engine (later) uses the same `render` path; adapters use `registerSlot`. One code path, many
  * front-ends.
  */
-import { ShadowHost } from './core/host';
-import { SlotRegistry } from './core/slots';
-import { renderVariant } from './surfaces/render';
+import { ShadowHost } from './core/host.js';
+import { SlotRegistry } from './core/slots.js';
+import { renderVariant } from './surfaces/render.js';
 /** No-op hooks so callers can render without wiring analytics (e.g. dashboard preview). */
 export function noopHooks() {
     return { onImpression() { }, onView() { }, onCtaClick() { }, onInteraction() { }, onDismiss() { } };

package/dist/features/inapp/blocks/blocks.d.ts

@@ -10,7 +10,7 @@
  * Safety: text is always written via `textContent`/text nodes (the DOM escapes it) — never innerHTML.
  * Zero-dependency; the caller supplies the `Document` so it's jsdom-testable and SSR-inert.
  */
-import type { BlockKind, ContentBlock } from '../types';
+import type { BlockKind, ContentBlock } from '../types.js';
 export interface BlockAction {
     action: string;
     label?: string;

package/dist/features/inapp/blocks/blocks.js

@@ -1,4 +1,4 @@
-import { npsRenderer, ratingRenderer, emojiRenderer, pollRenderer, quizRenderer } from './feedback';
+import { npsRenderer, ratingRenderer, emojiRenderer, pollRenderer, quizRenderer } from './feedback.js';
 const str = (v, fallback = '') => (typeof v === 'string' ? v : v == null ? fallback : String(v));
 /** Set multi-line text safely: text nodes + <br>, never innerHTML. */
 function setMultiline(el, text, doc) {

package/dist/features/inapp/blocks/feedback.d.ts

@@ -4,7 +4,7 @@
  * a poll shows the tally the server sends (`props.results`), a quiz reveals correctness only from the
  * server's `props.outcome`. The SDK never ships an answer key or computes results locally.
  */
-import type { BlockRenderer } from './blocks';
+import type { BlockRenderer } from './blocks.js';
 export declare const npsRenderer: BlockRenderer;
 export declare const ratingRenderer: BlockRenderer;
 export declare const emojiRenderer: BlockRenderer;

package/dist/features/inapp/blocks/heavy/carousel.d.ts

@@ -3,6 +3,6 @@
  * prev/next. Each slide: optional image + title + text. CSS scroll-snap does the heavy lifting (no JS
  * animation), so it's smooth + reduced-motion friendly. Safe DOM; own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const carouselRenderer: BlockRenderer;
 //# sourceMappingURL=carousel.d.ts.map

package/dist/features/inapp/blocks/heavy/chart.d.ts

@@ -2,7 +2,7 @@
  * Heavy blocks: chart / sparkline / stat (P3.6). SVG-based, zero-dependency mini visualizations for
  * usage insights ("you used 82% of your limit"). Own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const sparklineRenderer: BlockRenderer;
 export declare const statRenderer: BlockRenderer;
 export declare const chartRenderer: BlockRenderer;

package/dist/features/inapp/blocks/heavy/code.d.ts

@@ -3,6 +3,6 @@
  * fallback). No syntax-highlighting library — zero-dependency by design; a language label is shown.
  * Text is set via textContent (safe). Own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const codeRenderer: BlockRenderer;
 //# sourceMappingURL=code.d.ts.map

package/dist/features/inapp/blocks/heavy/confetti.d.ts

@@ -4,6 +4,6 @@
  * of animating). Self-cleaning: the rAF loop stops when particles settle or the element leaves the
  * DOM. Zero-dependency; own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const confettiRenderer: BlockRenderer;
 //# sourceMappingURL=confetti.d.ts.map

package/dist/features/inapp/blocks/heavy/countdown.d.ts

@@ -4,6 +4,6 @@
  * once the element leaves the DOM (surface closed), so it never leaks. Reduced-motion just skips the
  * pulse. Zero-dependency; own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const countdownRenderer: BlockRenderer;
 //# sourceMappingURL=countdown.d.ts.map

package/dist/features/inapp/blocks/heavy/index.d.ts

@@ -3,7 +3,7 @@
  * into the shared BLOCK_RENDERERS only when a variant actually uses it — pay-per-capability. The engine
  * calls `ensureHeavyBlocks(variant's kinds)` before rendering; `renderBlocks` then picks them up.
  */
-import type { BlockKind } from '../../types';
+import type { BlockKind } from '../../types.js';
 export declare const HEAVY_BLOCK_KINDS: BlockKind[];
 export declare function isHeavyBlock(kind: BlockKind): boolean;
 /** Lazy-load + register every requested heavy block that isn't already available. Idempotent. */

package/dist/features/inapp/blocks/heavy/index.js

@@ -1,27 +1,27 @@
-import { BLOCK_RENDERERS } from '../blocks';
+import { BLOCK_RENDERERS } from '../blocks.js';
 const HEAVY_LOADERS = {
-    markdown: () => import('./markdown').then((m) => m.markdownRenderer),
-    code: () => import('./code').then((m) => m.codeRenderer),
-    chart: () => import('./chart').then((m) => m.chartRenderer),
-    sparkline: () => import('./chart').then((m) => m.sparklineRenderer),
-    stat: () => import('./chart').then((m) => m.statRenderer),
-    table: () => import('./table').then((m) => m.tableRenderer),
-    video: () => import('./video').then((m) => m.videoRenderer),
+    markdown: () => import('./markdown.js').then((m) => m.markdownRenderer),
+    code: () => import('./code.js').then((m) => m.codeRenderer),
+    chart: () => import('./chart.js').then((m) => m.chartRenderer),
+    sparkline: () => import('./chart.js').then((m) => m.sparklineRenderer),
+    stat: () => import('./chart.js').then((m) => m.statRenderer),
+    table: () => import('./table.js').then((m) => m.tableRenderer),
+    video: () => import('./video.js').then((m) => m.videoRenderer),
     // mechanic blocks (full-fidelity plan)
-    countdown: () => import('./countdown').then((m) => m.countdownRenderer),
-    carousel: () => import('./carousel').then((m) => m.carouselRenderer),
-    'product-grid': () => import('./productgrid').then((m) => m.productGridRenderer),
-    confetti: () => import('./confetti').then((m) => m.confettiRenderer),
-    spinwheel: () => import('./spinwheel').then((m) => m.spinwheelRenderer),
-    scratch: () => import('./scratch').then((m) => m.scratchRenderer),
-    slot: () => import('./slot').then((m) => m.slotRenderer),
-    qr: () => import('./qr').then((m) => m.qrRenderer),
+    countdown: () => import('./countdown.js').then((m) => m.countdownRenderer),
+    carousel: () => import('./carousel.js').then((m) => m.carouselRenderer),
+    'product-grid': () => import('./productgrid.js').then((m) => m.productGridRenderer),
+    confetti: () => import('./confetti.js').then((m) => m.confettiRenderer),
+    spinwheel: () => import('./spinwheel.js').then((m) => m.spinwheelRenderer),
+    scratch: () => import('./scratch.js').then((m) => m.scratchRenderer),
+    slot: () => import('./slot.js').then((m) => m.slotRenderer),
+    qr: () => import('./qr.js').then((m) => m.qrRenderer),
     // streak / daily check-in day cells. Lazy because only 2 of 100 variants use it and core has
     // ~560 B of headroom against the 32 KB gate.
-    streak: () => import('./streak').then((m) => m.streakRenderer),
+    streak: () => import('./streak.js').then((m) => m.streakRenderer),
     // multiStepSheet's wizard paging. A block, not a surface: the registry calls that archetype
     // "a bottom sheet, just wizard-paged", so the container stays slideover[bottom].
-    steps: () => import('./steps').then((m) => m.stepsRenderer),
+    steps: () => import('./steps.js').then((m) => m.stepsRenderer),
 };
 export const HEAVY_BLOCK_KINDS = Object.keys(HEAVY_LOADERS);
 export function isHeavyBlock(kind) {

package/dist/features/inapp/blocks/heavy/markdown.d.ts

@@ -4,6 +4,6 @@
  * innerHTML), so it's XSS-safe by construction. Zero-dependency; ships in its own lazy chunk (a plain
  * announcement never pays for it).
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const markdownRenderer: BlockRenderer;
 //# sourceMappingURL=markdown.d.ts.map

package/dist/features/inapp/blocks/heavy/productgrid.d.ts

@@ -3,6 +3,6 @@
  * (image + title + price + optional CTA), for cross-sell, bundles, video-commerce, compare-plans.
  * Clicking a card emits a select interaction. Safe DOM; own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const productGridRenderer: BlockRenderer;
 //# sourceMappingURL=productgrid.d.ts.map

package/dist/features/inapp/blocks/heavy/qr.d.ts

@@ -5,6 +5,6 @@
  * NOTE: a spec-compliant scannable encoder (Reed-Solomon + masking) is a production follow-up; this is
  * the faithful *preview* representation. Zero-dependency; own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const qrRenderer: BlockRenderer;
 //# sourceMappingURL=qr.d.ts.map

package/dist/features/inapp/blocks/heavy/scratch.d.ts

@@ -3,6 +3,6 @@
  * **server-provided** prize (`props.prize`) — the outcome never comes from the client. Drag to erase.
  * Reduced-motion or no-canvas → the prize is shown directly. Zero-dependency; own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const scratchRenderer: BlockRenderer;
 //# sourceMappingURL=scratch.d.ts.map

package/dist/features/inapp/blocks/heavy/scratch.js

@@ -1,4 +1,4 @@
-import { showUnavailable, clearUnavailable } from './unavailable';
+import { showUnavailable, clearUnavailable } from './unavailable.js';
 function reducedMotion() {
     try {
         return typeof matchMedia !== 'undefined' && matchMedia('(prefers-reduced-motion: reduce)').matches;

package/dist/features/inapp/blocks/heavy/slot.d.ts

@@ -3,6 +3,6 @@
  * **server-provided** combo (`props.result` = 3 symbols) — never client-decided. Reduced-motion →
  * the result is shown without spinning. Zero-dependency; own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const slotRenderer: BlockRenderer;
 //# sourceMappingURL=slot.d.ts.map

package/dist/features/inapp/blocks/heavy/slot.js

@@ -1,4 +1,4 @@
-import { showUnavailable, clearUnavailable } from './unavailable';
+import { showUnavailable, clearUnavailable } from './unavailable.js';
 const DEFAULT_SYMBOLS = ['🍒', '🔔', '⭐', '7️⃣', '💎', '🍀'];
 function reducedMotion() {
     try {

package/dist/features/inapp/blocks/heavy/spinwheel.d.ts

@@ -4,6 +4,6 @@
  * wheel to land there (no client RNG, so it can't be gamed). Reduced-motion → no spin, reveal result.
  * Zero-dependency; own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const spinwheelRenderer: BlockRenderer;
 //# sourceMappingURL=spinwheel.d.ts.map

package/dist/features/inapp/blocks/heavy/spinwheel.js

@@ -1,4 +1,4 @@
-import { showUnavailable, clearUnavailable } from './unavailable';
+import { showUnavailable, clearUnavailable } from './unavailable.js';
 const COLORS = ['#6C5CE7', '#8b7bff', '#5b4bd6', '#a99cff', '#4c3fb0', '#7c6ef0'];
 const labelOf = (x) => (typeof x === 'string' ? x : String(x?.label ?? ''));
 function polar(cx, cy, r, deg) {

package/dist/features/inapp/blocks/heavy/steps.d.ts

@@ -13,7 +13,7 @@
  * Zero-dependency; own lazy chunk. No client state is persisted — a wizard that resumed mid-flow
  * after a dismiss would contradict the frequency/throttle contract that governs when it may show.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 /** Labels, resolved with the RN precedence so one authored payload reads the same on both platforms. */
 export declare function stepLabels(props: Record<string, unknown> | undefined): {
     back: string;

package/dist/features/inapp/blocks/heavy/streak.d.ts

@@ -13,6 +13,6 @@
  *
  * Zero-dependency, own lazy chunk (2 of 100 variants use it, so it must not sit in core).
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const streakRenderer: BlockRenderer;
 //# sourceMappingURL=streak.d.ts.map

package/dist/features/inapp/blocks/heavy/table.d.ts

@@ -2,6 +2,6 @@
  * Heavy block: table (P3.6). Renders a data/comparison/pricing table from columns + rows. Text via
  * textContent (safe). Own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const tableRenderer: BlockRenderer;
 //# sourceMappingURL=table.d.ts.map

package/dist/features/inapp/blocks/heavy/unavailable.d.ts

@@ -9,7 +9,7 @@
  * One element, one behaviour: say what happened, and offer a retry only when the host said the
  * failure was retryable. Lives with the heavy blocks so it costs core nothing.
  */
-import type { BlockOutcome } from '../blocks';
+import type { BlockOutcome } from '../blocks.js';
 export interface UnavailableOptions {
     /** Called when the user asks to try again. Only wired when the outcome is retryable. */
     onRetry?: () => void;

package/dist/features/inapp/blocks/heavy/video.d.ts

@@ -2,6 +2,6 @@
  * Heavy block: video (P3.6). Poster + click-to-load — NO autoplay by default (respectful + light: the
  * <video> element and network fetch happen only on interaction). Own lazy chunk.
  */
-import type { BlockRenderer } from '../blocks';
+import type { BlockRenderer } from '../blocks.js';
 export declare const videoRenderer: BlockRenderer;
 //# sourceMappingURL=video.d.ts.map