@scalebun/web 1.0.0 → 1.2.2

package/dist/features/replay/lifecycle/recorder.js

@@ -1,12 +1,12 @@
-import { uuid, now } from '../../../core';
-import { PersistentBuffer } from '../../../storage/idb';
-import { capBytes } from '../../../core/prune';
-import { approxBytes } from './segmentBuffer';
-import { AdaptiveController, adapt } from './adaptive';
-import { redactFrame } from './pii';
-import { shouldDeferHeavyEgress } from './deviceSignals';
-import { getTabId, getViewId, getRoute } from './viewContext';
-import { reserveSeq, ensureSeqAtLeast } from '../../session/sessionStore';
+import { uuid, now } from '../../../core/index.js';
+import { PersistentBuffer } from '../../../storage/idb.js';
+import { capBytes } from '../../../core/prune.js';
+import { approxBytes } from './segmentBuffer.js';
+import { AdaptiveController, adapt } from './adaptive.js';
+import { redactFrame } from './pii.js';
+import { shouldDeferHeavyEgress } from './deviceSignals.js';
+import { getTabId, getViewId, getRoute } from './viewContext.js';
+import { reserveSeq, ensureSeqAtLeast } from '../../session/sessionStore.js';
 const SEGMENT_MAX_FRAMES = 120;
 const SEGMENT_MAX_BYTES = 200000; // seal a segment at ~200KB even if it hasn't hit the frame cap
 const MAX_SEGMENTS = 8; // ring depth (count guard; the byte budget is the real bound)
@@ -97,8 +97,8 @@ export class RecorderController {
      *  ARM the capture pipeline (observers + first keyframe). The re-armable part lives in `arm()`. */
     async init() {
         const [{ ReplayEncoder }, { SegmentBuffer }] = await Promise.all([
-            import('../engine/replayWorker'),
-            import('./segmentBuffer'),
+            import('../engine/replayWorker.js'),
+            import('./segmentBuffer.js'),
         ]);
         this.segBuf = new SegmentBuffer(MAX_SEGMENTS, MAX_BUFFER_BYTES);
         // M6 crash-survival (opt-in): recover a PRIOR session's pre-roll if it was retained (i.e. the
@@ -128,14 +128,14 @@ export class RecorderController {
             return;
         const ctx = this.ctx;
         const [{ NodeRegistry }, { takeSnapshot }, { MutationRecorder }, { InteractionRecorder }, { CssomRecorder }, { IframeManager },] = await Promise.all([
-            import('../engine/nodeRegistry'),
-            import('../engine/snapshot'),
-            import('../engine/mutations'),
-            import('../engine/interactions'),
-            import('../engine/cssom'),
+            import('../engine/nodeRegistry.js'),
+            import('../engine/snapshot.js'),
+            import('../engine/mutations.js'),
+            import('../engine/interactions.js'),
+            import('../engine/cssom.js'),
             // R3: folded into the same Promise.all. As a separate `await` it added a round trip to
             // time-to-first-keyframe for no reason — nothing above it depends on the iframe manager.
-            import('../engine/iframe'),
+            import('../engine/iframe.js'),
         ]);
         const reg = new NodeRegistry();
         // maskAllText defaults FALSE (text shown); host masks via privacy.maskReplayText or setPrivacy(). Inputs always masked.
@@ -190,7 +190,7 @@ export class RecorderController {
             frameOrigins: ctx.replayFrameOrigins ?? [],
         });
         if ((ctx.replayFrameOrigins ?? []).length) {
-            void import('../engine/crossOrigin').then(({ installChildSatellite }) => {
+            void import('../engine/crossOrigin.js').then(({ installChildSatellite }) => {
                 this.childSatelliteStop = installChildSatellite(ctx.replayFrameOrigins ?? [], snapOpts);
             });
         }
@@ -205,7 +205,7 @@ export class RecorderController {
         this.disconnectCssom = () => cssom.disconnect();
         this.disconnectIframes = () => iframes.disconnect();
         if (ctx.replayCanvas) {
-            const { CanvasRecorder } = await import('../engine/canvas');
+            const { CanvasRecorder } = await import('../engine/canvas.js');
             const canvas = new CanvasRecorder(reg, (mutations) => {
                 interactions.notifyDomActivity();
                 this.push(this.delta({ mutations }));
@@ -217,7 +217,7 @@ export class RecorderController {
         // egress pressure; recovers automatically when pressure clears.
         this.adaptive = new AdaptiveController(ctx.egressPending);
         // Checkpoint cadence: time / visibility-return / SPA URL change → re-keyframe.
-        const { installCadence } = await import('./cadence');
+        const { installCadence } = await import('./cadence.js');
         this.disconnectCadence = installCadence({
             keyframeIntervalMs: KEYFRAME_INTERVAL_MS,
             onCheckpoint: (reason) => this.checkpoint(reason),

package/dist/features/replay/lifecycle/sampling.js

@@ -1,4 +1,4 @@
-import { bucketOf } from '../../config/bucketing';
+import { bucketOf } from '../../config/bucketing.js';
 /** Immutable salt — changing it re-buckets every session, so treat as versioned + frozen. */
 // 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

package/dist/features/replay/lifecycle/viewContext.js

@@ -10,7 +10,7 @@
  * a cadence-triggered keyframe naturally carries the new route via these getters — no extra watcher.)
  * Zero-dependency; SSR-safe.
  */
-import { uuid } from '../../../core';
+import { uuid } from '../../../core/index.js';
 const TAB_KEY = 'scalebun_replay_tab';
 /** Stable per-tab id. sessionStorage is per-tab and survives in-tab reload → exactly per-tab identity. */
 export function getTabId() {

package/dist/features/scroll/index.js

@@ -13,7 +13,7 @@
  */
 // Depth is defined ONCE in core/scrollDepth — see that file for why the previous local formula
 // (`maxPx / (docH - viewportH)`) was wrong in two separate ways.
-import { scrollDepthPct, foldBucketOf, isScrollable } from '../../core/scrollDepth';
+import { scrollDepthPct, foldBucketOf, isScrollable } from '../../core/scrollDepth.js';
 export function installScrollTracker() {
     if (typeof window === 'undefined' || typeof document === 'undefined') {
         // SSR / non-DOM: a no-op that never contributes props (autocapture keeps its own scalar).

package/dist/features/session/sessionManager.d.ts

@@ -6,7 +6,7 @@
  * store; this stays a thin header source.
  */
 import type { ClientInfo, DeviceInfo, AppInfo, ContextInfo } from '@scalebun/protocol';
-import type { ResolvedConfig } from '../../config/schema';
+import type { ResolvedConfig } from '../../config/schema.js';
 export declare class SessionManager {
     private readonly config;
     readonly sessionId: string;

package/dist/features/session/sessionManager.js

@@ -5,8 +5,8 @@
  * a second tab continues the same session instead of starting a new one. Boundary rules live in the
  * store; this stays a thin header source.
  */
-import { getOrCreateDeviceId, buildClient, buildDevice, buildApp, buildContext } from '../../core';
-import { resolveSession, touchSession, DEFAULT_SESSION_TIMEOUT_MS, DEFAULT_SESSION_MAX_MS, } from './sessionStore';
+import { getOrCreateDeviceId, buildClient, buildDevice, buildApp, buildContext } from '../../core/index.js';
+import { resolveSession, touchSession, DEFAULT_SESSION_TIMEOUT_MS, DEFAULT_SESSION_MAX_MS, } from './sessionStore.js';
 export class SessionManager {
     constructor(config) {
         this.config = config;

package/dist/features/session/sessionStore.js

@@ -39,7 +39,7 @@
  * sorts *before* the first load's later frames and scrambles the replay. Persisting the id without
  * the counter would have traded a visible bug for a subtler one.
  */
-import { uuid, now } from '../../core';
+import { uuid, now } from '../../core/index.js';
 const SESSION_KEY = 'scalebun_session';
 /** Inactivity that ends a session. 30 min is the de-facto standard (GA, and most RUM tools). */
 export const DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1000;

package/dist/features/watchdog/WatchdogFeature.d.ts

@@ -9,7 +9,7 @@
  * in the lazy chunk to keep the core bundle gate.
  */
 import type { IFeature, FeatureContext } from '@scalebun/sdk-contracts';
-import type { WatchdogStats } from './engine';
+import type { WatchdogStats } from './engine.js';
 export declare class WatchdogFeature implements IFeature {
     readonly name = "watchdog";
     private active;

package/dist/features/watchdog/WatchdogFeature.js

@@ -11,7 +11,7 @@ export class WatchdogFeature {
         if (typeof window === 'undefined' || typeof performance === 'undefined')
             return;
         this.active = true;
-        const { startWatchdog } = await import('./engine');
+        const { startWatchdog } = await import('./engine.js');
         if (!this.active)
             return; // torn down while the chunk loaded
         this.handle = startWatchdog(ctx);

package/dist/features/watchdog/collectors.d.ts

@@ -1,4 +1,4 @@
-import type { PressureState } from './incidents';
+import type { PressureState } from './incidents.js';
 export interface CollectorSinks {
     onHeartbeat: (lagMs: number) => void;
     onPressure: (state: PressureState) => void;

package/dist/features/watchdog/collectors.js

@@ -6,7 +6,7 @@
  * FPS + LoAF are NOT collected here — the watchdog taps PerformanceFeature's existing observer
  * (jankTap) rather than opening a second one. Every collector is feature-detected and fail-soft.
  */
-import { now } from '../../core';
+import { now } from '../../core/index.js';
 function isVisible() {
     try {
         return typeof document === 'undefined' || document.visibilityState !== 'hidden';

package/dist/features/watchdog/engine.js

@@ -1,11 +1,11 @@
-import { uuid, now, getReplayCoord } from '../../core';
-import { fnv1a32 } from '../config/bucketing';
-import { onJank } from '../performance/jankTap';
-import { flameAvailable, captureFlameWindow } from '../profiler/capture';
-import { IncidentEngine } from './incidents';
-import { HealthRollup } from './rollup';
-import { startCollectors } from './collectors';
-import { resolveThresholds } from './config';
+import { uuid, now, getReplayCoord } from '../../core/index.js';
+import { fnv1a32 } from '../config/bucketing.js';
+import { onJank } from '../performance/jankTap.js';
+import { flameAvailable, captureFlameWindow } from '../profiler/capture.js';
+import { IncidentEngine } from './incidents.js';
+import { HealthRollup } from './rollup.js';
+import { startCollectors } from './collectors.js';
+import { resolveThresholds } from './config.js';
 const NOOP = {
     stop: () => { },
     stats: () => ({ incidents: 0, droppedIncidents: 0, rollups: 0, tiers: { pressure: false, memory: false } }),

package/dist/features/watchdog/incidents.d.ts

@@ -9,7 +9,7 @@
  * a real dwell model for compute-pressure (which is edge-triggered, not sampled), — and implements
  * `main_thread_stall` + `memory_leak_suspicion`, which mobile declares but never built.
  */
-import type { WatchdogThresholds } from './config';
+import type { WatchdogThresholds } from './config.js';
 export type Severity = 'info' | 'warning' | 'critical';
 export type Confidence = 'low' | 'medium' | 'high';
 export type IncidentType = 'cpu_spike' | 'main_thread_stall' | 'jank_burst' | 'frozen_frame' | 'memory_surge' | 'memory_leak_suspicion' | 'low_memory_pressure';

package/dist/features/watchdog/incidents.js

@@ -1,4 +1,4 @@
-import { RATE_MAX, RATE_WINDOW_MS } from './config';
+import { RATE_MAX, RATE_WINDOW_MS } from './config.js';
 function p95(sorted) {
     if (!sorted.length)
         return 0;

package/dist/features/watchdog/rollup.d.ts

@@ -1,4 +1,4 @@
-import type { PressureState } from './incidents';
+import type { PressureState } from './incidents.js';
 export interface HealthSnapshot {
     lagP50: number;
     lagP95: number;

package/dist/features/watchdog/rollup.js

@@ -4,7 +4,7 @@
  * distribution, heap slope, incident/drop counts, honest tier availability). Rollups — not raw samples —
  * are what egress, so a session costs ≤ ~2 perf items/min regardless of sampling cadence.
  */
-import { now } from '../../core';
+import { now } from '../../core/index.js';
 function pct(sorted, q) {
     if (!sorted.length)
         return 0;

package/dist/features/webVitals/WebVitalsFeature.js

@@ -8,10 +8,10 @@
  * visibilitychange listener is registered before the pipeline's flush listener → we emit the CWV
  * items, then the pipeline flushes them (keepalive). Do not reorder bootstrap without preserving this.
  */
-import { safeObserve } from './observe';
-import { lcpFrom, maxInp, newClsState, addClsWindowed, stripUrlQuery, lcpPhases, ttfbPhases, loafScriptFor, rateVital } from './vitals';
-import { lcpAttribution, newShiftAcc, addShiftSources, clsAttribution, newInpAcc, addInpInteraction, inpAttribution, } from './attribution';
-import { uuid, now } from '../../core';
+import { safeObserve } from './observe.js';
+import { lcpFrom, maxInp, newClsState, addClsWindowed, stripUrlQuery, lcpPhases, ttfbPhases, loafScriptFor, rateVital } from './vitals.js';
+import { lcpAttribution, newShiftAcc, addShiftSources, clsAttribution, newInpAcc, addInpInteraction, inpAttribution, } from './attribution.js';
+import { uuid, now } from '../../core/index.js';
 export class WebVitalsFeature {
     constructor() {
         this.name = 'webVitals';

package/dist/features/webVitals/observe.d.ts

@@ -2,5 +2,5 @@
  * Re-export of the shared PerformanceObserver helper (moved to core/ so F-VIT and F-PERF share one
  * implementation). Kept here so existing F-VIT imports stay stable.
  */
-export { safeObserve } from '../../core/observe';
+export { safeObserve } from '../../core/observe.js';
 //# sourceMappingURL=observe.d.ts.map

package/dist/features/webVitals/observe.js

@@ -2,5 +2,5 @@
  * Re-export of the shared PerformanceObserver helper (moved to core/ so F-VIT and F-PERF share one
  * implementation). Kept here so existing F-VIT imports stay stable.
  */
-export { safeObserve } from '../../core/observe';
+export { safeObserve } from '../../core/observe.js';
 //# sourceMappingURL=observe.js.map

package/dist/features/webperf/WebPerfFeature.d.ts

@@ -5,7 +5,7 @@
  * buffered LoAF) so it stays out of the core bundle. Raw web APIs only (zero third-party deps).
  */
 import type { IFeature, FeatureContext } from '@scalebun/sdk-contracts';
-export { fpsFromFrames, loafSeverity, navMetric } from './math';
+export { fpsFromFrames, loafSeverity, navMetric } from './math.js';
 export declare class WebPerfFeature implements IFeature {
     readonly name = "webPerf";
     private ctx;

package/dist/features/webperf/WebPerfFeature.js

@@ -1,6 +1,6 @@
-import { uuid, now } from '../../core';
+import { uuid, now } from '../../core/index.js';
 // Re-export the pure math (also covered by the unit tests).
-export { fpsFromFrames, loafSeverity, navMetric } from './math';
+export { fpsFromFrames, loafSeverity, navMetric } from './math.js';
 function currentScreen() {
     try {
         return typeof location !== 'undefined' ? location.pathname : undefined;
@@ -23,7 +23,7 @@ export class WebPerfFeature {
         if (typeof window === 'undefined' || typeof performance === 'undefined')
             return;
         this.active = true;
-        const { startCollectors } = await import('./collectors');
+        const { startCollectors } = await import('./collectors.js');
         if (this.active)
             this.stop = startCollectors((metric, value, metadata, duration) => this.emit(metric, value, metadata, duration), () => this.active);
     }

package/dist/features/webperf/collectors.js

@@ -1,6 +1,6 @@
 // Web-perf collectors (page-load / FPS / LoAF) — the LAZY chunk. Loaded by WebPerfFeature.setup so the
 // observer/rAF wiring stays out of the core bundle. Returns a stop() that tears everything down.
-import { fpsFromFrames, loafSeverity, navMetric } from './math';
+import { fpsFromFrames, loafSeverity, navMetric } from './math.js';
 const FPS_WINDOW_MS = 5000;
 const FPS_GAP_MS = 25000;
 const LOAF_MIN_MS = 50;

package/dist/inapp.d.ts

@@ -2,5 +2,5 @@
  * Subpath entry for `@scalebun/web/inapp` — the In-App Messaging 2.0 public API. Kept separate from
  * the size-gated `index.ts` so none of the IAM engine loads into the eager core bundle.
  */
-export * from './features/inapp';
+export * from './features/inapp/index.js';
 //# sourceMappingURL=inapp.d.ts.map

package/dist/inapp.js

@@ -2,5 +2,5 @@
  * Subpath entry for `@scalebun/web/inapp` — the In-App Messaging 2.0 public API. Kept separate from
  * the size-gated `index.ts` so none of the IAM engine loads into the eager core bundle.
  */
-export * from './features/inapp';
+export * from './features/inapp/index.js';
 //# sourceMappingURL=inapp.js.map

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  *
  * 🚧 Scaffold: the facade is stubbed; capture features are not implemented yet.
  */
-export { ScaleBun as default, ScaleBun } from './public/ScaleBunFacade';
+export { ScaleBun as default, ScaleBun } from './public/ScaleBunFacade.js';
 export type { ScaleBunInitConfig, ScaleBunFeatures, ScaleBunUser, PrivacyConfig, } from '@scalebun/sdk-contracts';
 /**
  * The gamified in-app contract, so a host can type its `onInAppGameRequest` handler — and share one
@@ -16,7 +16,7 @@ export type { ScaleBunInitConfig, ScaleBunFeatures, ScaleBunUser, PrivacyConfig,
  *
  * TYPES ONLY: `export type` erases at build time, so this adds nothing to the bundle.
  */
-export type { InAppGameRequest, InAppGameResult, InAppGameOutcome, InAppGameAction, InAppGameVariantKey, InAppGameRequestHandler, } from './features/engage/gameTypes';
+export type { InAppGameRequest, InAppGameResult, InAppGameOutcome, InAppGameAction, InAppGameVariantKey, InAppGameRequestHandler, } from './features/engage/gameTypes.js';
 /**
  * Inbox contracts, so a host can render the message list in its OWN design system.
  *
@@ -27,5 +27,5 @@ export type { InAppGameRequest, InAppGameResult, InAppGameOutcome, InAppGameActi
  *
  * TYPES ONLY — `export type` erases at build time, so this costs zero bytes.
  */
-export type { InboxMessage, InboxController, InboxState, InboxCta, InboxQueryOptions, InboxPage, InboxMessageState, InboxSyncStatus, InboxMountOptions, InboxLabels, InboxLayout, } from './features/inbox/types';
+export type { InboxMessage, InboxController, InboxState, InboxCta, InboxQueryOptions, InboxPage, InboxMessageState, InboxSyncStatus, InboxMountOptions, InboxLabels, InboxLayout, } from './features/inbox/types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -8,5 +8,5 @@
  *
  * 🚧 Scaffold: the facade is stubbed; capture features are not implemented yet.
  */
-export { ScaleBun as default, ScaleBun } from './public/ScaleBunFacade';
+export { ScaleBun as default, ScaleBun } from './public/ScaleBunFacade.js';
 //# sourceMappingURL=index.js.map

package/dist/pipeline/index.d.ts

@@ -1,3 +1,3 @@
 /** pipeline/ — the single unified egress (envelope → queue → batch → flush). */
-export * from './pipeline';
+export * from './pipeline.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/pipeline/index.js

@@ -1,3 +1,3 @@
 /** pipeline/ — the single unified egress (envelope → queue → batch → flush). */
-export * from './pipeline';
+export * from './pipeline.js';
 //# sourceMappingURL=index.js.map

package/dist/pipeline/pipeline.d.ts

@@ -4,9 +4,9 @@
  * re-queued and mirrored to IndexedDB so it survives a reload.
  */
 import type { Item } from '@scalebun/protocol';
-import type { ResolvedConfig } from '../config/schema';
-import type { SessionManager } from '../features/session/sessionManager';
-import type { HttpClient } from '../transport/httpClient';
+import type { ResolvedConfig } from '../config/schema.js';
+import type { SessionManager } from '../features/session/sessionManager.js';
+import type { HttpClient } from '../transport/httpClient.js';
 export declare class Pipeline {
     private readonly config;
     private readonly session;

package/dist/pipeline/pipeline.js

@@ -3,10 +3,10 @@
  * SessionEnvelopes and flushes on a timer / on page-hide. At-least-once: a failed batch is
  * re-queued and mirrored to IndexedDB so it survives a reload.
  */
-import { PersistentBuffer } from '../storage/idb';
-import { now } from '../core';
-import { Backoff, isOnline } from '../core/retry';
-import { capBytes, freshOnly } from '../core/prune';
+import { PersistentBuffer } from '../storage/idb.js';
+import { now } from '../core/index.js';
+import { Backoff, isOnline } from '../core/retry.js';
+import { capBytes, freshOnly } from '../core/prune.js';
 // Inlined (not imported) so the zod-laden `@scalebun/protocol` barrel — and zod itself (~12 KB gz) —
 // stays OUT of the SDK bundle; SCHEMA_VERSION was the only runtime import that pulled it. The type
 // annotation pins this to the contract: a protocol SCHEMA_VERSION bump fails the SDK build. The

package/dist/public/ScaleBunFacade.d.ts

@@ -3,22 +3,22 @@
  * app. Everything funnels into the ONE pipeline as contract Items.
  */
 import type { ScaleBunInitConfig, ScaleBunUser } from '@scalebun/sdk-contracts';
-import type { ReplayStats } from '../features/replay/lifecycle/recorder';
-import { type BreadcrumbLevel } from '../core';
-import { type RevenueInput } from '../features/analytics/revenue';
-import type { SubscriptionInput } from '../features/analytics/subscription';
-import { type ErrorLevel } from '../features/errors/scope';
-import type { ErrorStats } from '../features/errors/ErrorsFeature';
-import { type TransactionHandle } from '../features/performance/trace/types';
-import type { PerfStats } from '../features/performance/PerformanceFeature';
-import type { WatchdogStats } from '../features/watchdog/engine';
-import type { NetworkStats } from '../features/network/NetworkFeature';
-import type { VariationDetail } from '../features/config/types';
-import type { SurveyResult as EngageSurveyResult, RatingEventType as EngageRatingEventType, RatingEventInput as EngageRatingEventInput } from '../features/engage/types';
-import type { PushEnableOptions, PushEnableStatus, PushStatus } from '../features/push/PushFeature';
-import type { PushDiagnostics } from '../features/push/diagnostics';
-import type { InboxController } from '../features/inbox/types';
-import type { TourSpec } from '../features/coach/types';
+import type { ReplayStats } from '../features/replay/lifecycle/recorder.js';
+import { type BreadcrumbLevel } from '../core/index.js';
+import { type RevenueInput } from '../features/analytics/revenue.js';
+import type { SubscriptionInput } from '../features/analytics/subscription.js';
+import { type ErrorLevel } from '../features/errors/scope.js';
+import type { ErrorStats } from '../features/errors/ErrorsFeature.js';
+import { type TransactionHandle } from '../features/performance/trace/types.js';
+import type { PerfStats } from '../features/performance/PerformanceFeature.js';
+import type { WatchdogStats } from '../features/watchdog/engine.js';
+import type { NetworkStats } from '../features/network/NetworkFeature.js';
+import type { VariationDetail } from '../features/config/types.js';
+import type { SurveyResult as EngageSurveyResult, RatingEventType as EngageRatingEventType, RatingEventInput as EngageRatingEventInput } from '../features/engage/types.js';
+import type { PushEnableOptions, PushEnableStatus, PushStatus } from '../features/push/PushFeature.js';
+import type { PushDiagnostics } from '../features/push/diagnostics.js';
+import type { InboxController } from '../features/inbox/types.js';
+import type { TourSpec } from '../features/coach/types.js';
 declare class ScaleBunFacade {
     private rt;
     private ready;
@@ -351,14 +351,14 @@ declare class ScaleBunFacade {
 interface CoachController {
     start(tour: TourSpec, opts?: {
         resume?: boolean;
-        context?: import('../features/coach/types').TourContext;
+        context?: import('../features/coach/types.js').TourContext;
     }): void;
     startInline(tour: TourSpec): void;
     /** Start a dashboard-authored, published tour by id (fetched from the config lane). Pass a `preview`
      *  token (from the dashboard's Preview action) to run a DRAFT tour before it's published. */
     startById(id: string, opts?: {
         resume?: boolean;
-        context?: import('../features/coach/types').TourContext;
+        context?: import('../features/coach/types.js').TourContext;
         preview?: string;
     }): void;
     /** Report this page's  keys so the dashboard tour composer can offer them as

package/dist/public/ScaleBunFacade.js

@@ -2,12 +2,12 @@
  * ScaleBunFacade — the public singleton. Methods are crash-safe: the SDK never throws into the host
  * app. Everything funnels into the ONE pipeline as contract Items.
  */
-import { SDKBootstrapper } from '../bootstrap/SDKBootstrapper';
-import { buildBugReportPayload } from '../features/bugreport/collect';
-import { now, uuid, addBreadcrumb as addCrumb, getReplayCoord, scrubProps, patchEvalContext, clearEvalContext, isServer, getRuntime, setNonce } from '../core';
-import { normalizeRevenue } from '../features/analytics/revenue';
-import { setTag, setContext, setErrorLevel } from '../features/errors/scope';
-import { NOOP_TXN } from '../features/performance/trace/types';
+import { SDKBootstrapper } from '../bootstrap/SDKBootstrapper.js';
+import { buildBugReportPayload } from '../features/bugreport/collect.js';
+import { now, uuid, addBreadcrumb as addCrumb, getReplayCoord, scrubProps, patchEvalContext, clearEvalContext, isServer, getRuntime, setNonce } from '../core/index.js';
+import { normalizeRevenue } from '../features/analytics/revenue.js';
+import { setTag, setContext, setErrorLevel } from '../features/errors/scope.js';
+import { NOOP_TXN } from '../features/performance/trace/types.js';
 class ScaleBunFacade {
     constructor() {
         this.rt = null;
@@ -120,7 +120,7 @@ class ScaleBunFacade {
                 if (p)
                     return p.check(opts);
                 // Not initialized — the explanatory report lives in the lazy chunk, not in eager core.
-                return (await import('../features/push/diagnostics')).notInitializedReport();
+                return (await import('../features/push/diagnostics.js')).notInitializedReport();
             },
         };
         // ── Install attribution (W1b) — MMP primitives on the analytics lane ────────────
@@ -283,7 +283,7 @@ class ScaleBunFacade {
              */
             const softAsk = config?.push?.softAsk;
             if (softAsk) {
-                void import('../features/push/softAsk')
+                void import('../features/push/softAsk.js')
                     .then(({ armSoftAsk }) => armSoftAsk(softAsk, {
                     enable: () => this.enablePush(),
                     permission: () => Notification.permission,
@@ -523,7 +523,7 @@ class ScaleBunFacade {
      * Dynamic-imported so a host that never places inline messages pays nothing for the registry.
      */
     async registerInAppSlot(name, el) {
-        const { registerInAppSlot } = await import('../features/engage/inappSlots');
+        const { registerInAppSlot } = await import('../features/engage/inappSlots.js');
         return registerInAppSlot(name, el);
     }
     async reportBug(input) {
@@ -631,7 +631,7 @@ class ScaleBunFacade {
             return Promise.resolve(this.coachFeature);
         if (!this.rt)
             return Promise.resolve(null);
-        return import('../features/coach/CoachmarkFeature').then(({ CoachmarkFeature }) => {
+        return import('../features/coach/CoachmarkFeature.js').then(({ CoachmarkFeature }) => {
             if (this.coachFeature)
                 return this.coachFeature;
             const deps = {
@@ -682,7 +682,7 @@ class ScaleBunFacade {
             return this.pushFeature;
         if (!this.rt)
             return null;
-        const { PushFeature } = await import('../features/push/PushFeature');
+        const { PushFeature } = await import('../features/push/PushFeature.js');
         this.pushFeature = new PushFeature({
             apiBaseUrl: this.rt.config.apiBaseUrl,
             clientKey: this.rt.config.clientKey,

package/dist/public/index.d.ts

@@ -1,5 +1,5 @@
-export { ScaleBun } from './ScaleBunFacade';
-export type { ScaleBunFacade } from './ScaleBunFacade';
-export { createTypedTracker, defineTrackingPlan } from './typedTracker';
-export type { TypedTracker, TypedTrackerPlan, TrackedEventMap, TrackedEventSpec, PlanPropType, PropsFor, TrackTarget, } from './typedTracker';
+export { ScaleBun } from './ScaleBunFacade.js';
+export type { ScaleBunFacade } from './ScaleBunFacade.js';
+export { createTypedTracker, defineTrackingPlan } from './typedTracker.js';
+export type { TypedTracker, TypedTrackerPlan, TrackedEventMap, TrackedEventSpec, PlanPropType, PropsFor, TrackTarget, } from './typedTracker.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/public/index.js

@@ -1,4 +1,4 @@
-export { ScaleBun } from './ScaleBunFacade';
+export { ScaleBun } from './ScaleBunFacade.js';
 // Typed tracking plan — compile-time checking for `track()`, sharing ONE object with the runtime plan.
-export { createTypedTracker, defineTrackingPlan } from './typedTracker';
+export { createTypedTracker, defineTrackingPlan } from './typedTracker.js';
 //# sourceMappingURL=index.js.map