libaribhtml5 0.1.5 → 0.1.7

package/dist/types/receiver/canvas-controller.d.ts

@@ -0,0 +1,30 @@
+type ReceiverCanvasSize = {
+    width: number;
+    height: number;
+};
+type CanvasResizeObserver = Pick<ResizeObserver, 'observe' | 'disconnect'>;
+type ReceiverCanvasControllerOptions = {
+    iframe: HTMLIFrameElement;
+    viewport: HTMLElement;
+    createResizeObserver?: (callback: ResizeObserverCallback) => CanvasResizeObserver;
+};
+/** Owns receiver-canvas geometry and background selection for the host facade. */
+export declare class ReceiverCanvasController {
+    private readonly iframe;
+    private readonly viewport;
+    private readonly resizeObserver;
+    private logicalWidth;
+    private logicalHeight;
+    private lctBackgroundColor;
+    private stageBackgroundColor;
+    constructor(options: ReceiverCanvasControllerOptions);
+    get logicalSize(): ReceiverCanvasSize;
+    setLctBackgroundColor(backgroundColorRgb: number | null): void;
+    setStageBackgroundColor(backgroundColor: string | null): void;
+    resetStageBackground(): void;
+    applyScreenSize(width: number, height: number): void;
+    fit(): void;
+    dispose(): void;
+    private applyBackgroundColor;
+}
+export {};

package/dist/types/receiver/protocol.d.ts

@@ -0,0 +1,21 @@
+import type { AribMediaPlane, AribMediaPlaneLayer } from '../media-plane';
+/** Untrusted runtime-to-host wire message before session and event filtering. */
+export type RuntimeMessage = Record<string, unknown> & {
+    type?: string;
+    runtimeId?: string;
+    event?: string;
+};
+export type AribApplicationReplaceRequest = {
+    organizationId: number;
+    applicationId: number;
+    aitUrl: string | null;
+};
+export type ReceiverMediaPlaneFallback = {
+    screenWidth: number;
+    screenHeight: number;
+};
+export declare function normalizeStageBackgroundColor(value: unknown): string | null;
+export declare function normalizeCaptionSubscriptionTags(value: unknown): number[];
+export declare function normalizeApplicationReplaceRequest(message: RuntimeMessage): AribApplicationReplaceRequest | null;
+export declare function normalizeMediaLayer(value: unknown): AribMediaPlaneLayer;
+export declare function normalizeMediaPlane(message: RuntimeMessage, fallback: ReceiverMediaPlaneFallback): AribMediaPlane;

package/dist/types/receiver/runtime-session-controller.d.ts

@@ -0,0 +1,40 @@
+import type { ProgramInfo } from '../program-info';
+import type { RuntimeApplicationInformation } from '../runtime/application-controller';
+import type { RuntimeEvent } from '../runtime/stream-event';
+export type RuntimeInstalledSnapshot = {
+    captionComponentTags: readonly number[];
+    applicationInformation: RuntimeApplicationInformation;
+    inputActive: boolean;
+    programInfo: ProgramInfo | null;
+};
+type RuntimeSessionControllerOptions = {
+    ownerWindow: Window;
+    iframe: HTMLIFrameElement;
+    origin: string;
+    applicationLoadTimeoutMs: number;
+    onApplicationLoadTimeout: (url: string) => void;
+};
+/** Owns receiver-to-runtime transport and the runtime installation session. */
+export declare class RuntimeSessionController {
+    private readonly ownerWindow;
+    private readonly iframe;
+    private readonly origin;
+    private readonly applicationLoadTimeoutMs;
+    private readonly onApplicationLoadTimeout;
+    private readonly pendingStreamEvents;
+    private activeRuntimeId;
+    private applicationLoadTimer;
+    private disposed;
+    constructor(options: RuntimeSessionControllerOptions);
+    get hasActiveRuntime(): boolean;
+    matches(runtimeId: unknown): boolean;
+    acceptInstalled(runtimeId: string, snapshot: RuntimeInstalledSnapshot, beforeReplay?: () => void): void;
+    postToRuntime(event: string, detail?: Record<string, unknown>): void;
+    emitStreamEvent(value: RuntimeEvent): void;
+    clearPendingStreamEvents(): void;
+    invalidate(): void;
+    armWatchdog(url: string): void;
+    clearWatchdog(): void;
+    dispose(): void;
+}
+export {};

package/dist/types/receiver/types.d.ts

@@ -0,0 +1,91 @@
+import type { ReceiverDeviceIdentifierProvider } from '../device-identifier';
+import type { AribMediaPlane, AribMediaPlaneAdapter } from '../media-plane';
+import type { AribProgramGuideHandler, AribProgramGuideUnavailableHandler } from '../program-guide';
+import type { RuntimeApplicationInformation } from '../runtime/install';
+import type { BroadcastResourceStore } from '../runtime/resources';
+import type { ReceiverSystemInformationOverrides } from '../runtime/system-information';
+import type { AribViewerParticipationEvent } from '../viewer-participation';
+import type { AribApplicationReplaceRequest } from './protocol';
+export type AribCaptionPacket = {
+    componentTag: number;
+    payload?: string;
+    dataType?: string;
+    tmd?: string;
+    data?: string;
+};
+export type AribCaptionSubscription = {
+    componentTags: number[];
+};
+export type AribApplicationInformation = RuntimeApplicationInformation;
+export type { AribApplicationReplaceRequest } from './protocol';
+export type AribApplicationReplaceHandler = (request: AribApplicationReplaceRequest) => void | Promise<void>;
+export type AribExitManagedStateHandler = (url: string) => void | Promise<void>;
+export type AribBroadcastClock = {
+    /** Absolute broadcast time at the anchor, as Unix epoch milliseconds. */
+    epochMilliseconds: number;
+    /** Media timeline value which corresponds to epochMilliseconds. */
+    mediaTimeSeconds?: number;
+    /** Current playback position; enables pause, rate, and seek aware projection. */
+    currentMediaTimeSeconds?: () => number;
+};
+export type AribReceiverLifecycleEvent = {
+    type: 'loading';
+    url: string;
+} | {
+    type: 'installed';
+    url: string;
+    runtimeId: string;
+} | {
+    type: 'navigating';
+    url: string;
+} | {
+    type: 'exited';
+} | {
+    type: 'navigation-blocked';
+    url: string;
+} | {
+    type: 'frame-blocked';
+    url: string;
+} | {
+    type: 'error';
+    message: string;
+};
+export type AribReceiverHostOptions = {
+    iframe: HTMLIFrameElement;
+    viewport: HTMLElement;
+    /** Surface used only by the behind-iframe compatibility adapter. */
+    videoSurface?: HTMLElement;
+    mediaPlaneAdapter?: AribMediaPlaneAdapter;
+    onStatus?: (status: string) => void;
+    /** Machine-readable application/runtime lifecycle; never branch on onStatus text. */
+    onLifecycle?: (event: AribReceiverLifecycleEvent) => void;
+    /** Time to wait for a loaded document to install the receiver runtime. 0 disables the fallback. */
+    applicationLoadTimeoutMs?: number;
+    onUrlChange?: (url: string) => void;
+    onMediaPlane?: (plane: AribMediaPlane) => void;
+    /** @deprecated Use onMediaPlane. */
+    onVideoPlane?: (plane: AribMediaPlane) => void;
+    keepVideoVisible?: boolean;
+    /** Allow broadcaster applications to use HTTP origins outside this host. */
+    allowExternalNetwork?: boolean;
+    /** Same-origin namespace where a Worker or HTTP server exposes carousel data. */
+    broadcastBaseUrl?: string | URL;
+    /** Optional bridge to a Service Worker, Cache Storage, or carousel VFS. */
+    resourceStore?: BroadcastResourceStore;
+    /** Receiver/WebView bridge which opens the native EPG or a program detail page. */
+    onOpenProgramGuide?: AribProgramGuideHandler;
+    /** Active caption components requested by the current broadcast document. */
+    onCaptionSubscription?: (subscription: AribCaptionSubscription) => void;
+    /** Resolve Application.replaceApplication() through the receiver's current MH-AIT. */
+    onReplaceApplication?: AribApplicationReplaceHandler;
+    /** Transfer an application to an unmanaged general-application URL. */
+    onExitManagedState?: AribExitManagedStateHandler;
+    /** Override the default browser alert when the receiver cannot open the EPG. */
+    onProgramGuideUnavailable?: AribProgramGuideUnavailableHandler;
+    /** Receiver identity/capabilities exposed to the broadcast application. */
+    systemInformation?: ReceiverSystemInformationOverrides;
+    /** Resolve receiver/CAS identifiers; defaults to the bundled Huggy demo identity. */
+    getDeviceIdentifier?: ReceiverDeviceIdentifierProvider;
+    /** Receiver UI hook for a TR-B39 viewer-participation corner notification. */
+    onViewerParticipation?: (event: AribViewerParticipationEvent) => void;
+};

package/dist/types/receiver-host.d.ts

@@ -1,99 +1,11 @@
-import { type RuntimeApplicationInformation, type RuntimeEvent, type RuntimeWindow } from './runtime/install';
+import { type RuntimeEvent, type RuntimeWindow } from './runtime/install';
 import { type ProgramInfo } from './program-info';
-import type { ReceiverSystemInformationOverrides } from './runtime/system-information';
-import type { ReceiverDeviceIdentifierProvider } from './device-identifier';
-import { type AribMediaPlane, type AribMediaPlaneAdapter } from './media-plane';
-import type { BroadcastResourceChange, BroadcastResourceStore } from './runtime/resources';
-import { type AribProgramGuideHandler, type AribProgramGuideRequest, type AribProgramGuideUnavailableHandler } from './program-guide';
-import { type AribApplicationPresentationState, type AribViewerParticipationEvent, type AribViewerParticipationNotification } from './viewer-participation';
+import type { BroadcastResourceChange } from './runtime/resources';
+import { type AribProgramGuideRequest } from './program-guide';
+import { type AribApplicationPresentationState, type AribViewerParticipationNotification } from './viewer-participation';
+import type { AribApplicationInformation, AribBroadcastClock, AribCaptionPacket, AribReceiverHostOptions } from './receiver/types';
 export type { AribMediaPlane, AribMediaPlaneAdapter, AribMediaPlaneLayer, AribMediaPlaneStackEntry, AribMediaPlaneUnmountReason, AribVideoPlane, } from './media-plane';
-export type AribCaptionPacket = {
-    componentTag: number;
-    payload?: string;
-    dataType?: string;
-    tmd?: string;
-    data?: string;
-};
-export type AribCaptionSubscription = {
-    componentTags: number[];
-};
-export type AribApplicationInformation = RuntimeApplicationInformation;
-export type AribApplicationReplaceRequest = {
-    organizationId: number;
-    applicationId: number;
-    aitUrl: string | null;
-};
-export type AribApplicationReplaceHandler = (request: AribApplicationReplaceRequest) => void | Promise<void>;
-export type AribExitManagedStateHandler = (url: string) => void | Promise<void>;
-export type AribBroadcastClock = {
-    /** Absolute broadcast time at the anchor, as Unix epoch milliseconds. */
-    epochMilliseconds: number;
-    /** Media timeline value which corresponds to epochMilliseconds. */
-    mediaTimeSeconds?: number;
-    /** Current playback position; enables pause, rate, and seek aware projection. */
-    currentMediaTimeSeconds?: () => number;
-};
-export type AribReceiverLifecycleEvent = {
-    type: 'loading';
-    url: string;
-} | {
-    type: 'installed';
-    url: string;
-    runtimeId: string;
-} | {
-    type: 'navigating';
-    url: string;
-} | {
-    type: 'exited';
-} | {
-    type: 'navigation-blocked';
-    url: string;
-} | {
-    type: 'frame-blocked';
-    url: string;
-} | {
-    type: 'error';
-    message: string;
-};
-export type AribReceiverHostOptions = {
-    iframe: HTMLIFrameElement;
-    viewport: HTMLElement;
-    /** Surface used only by the behind-iframe compatibility adapter. */
-    videoSurface?: HTMLElement;
-    mediaPlaneAdapter?: AribMediaPlaneAdapter;
-    onStatus?: (status: string) => void;
-    /** Machine-readable application/runtime lifecycle; never branch on onStatus text. */
-    onLifecycle?: (event: AribReceiverLifecycleEvent) => void;
-    /** Time to wait for a loaded document to install the receiver runtime. 0 disables the fallback. */
-    applicationLoadTimeoutMs?: number;
-    onUrlChange?: (url: string) => void;
-    onMediaPlane?: (plane: AribMediaPlane) => void;
-    /** @deprecated Use onMediaPlane. */
-    onVideoPlane?: (plane: AribMediaPlane) => void;
-    keepVideoVisible?: boolean;
-    /** Allow broadcaster applications to use HTTP origins outside this host. */
-    allowExternalNetwork?: boolean;
-    /** Same-origin namespace where a Worker or HTTP server exposes carousel data. */
-    broadcastBaseUrl?: string | URL;
-    /** Optional bridge to a Service Worker, Cache Storage, or carousel VFS. */
-    resourceStore?: BroadcastResourceStore;
-    /** Receiver/WebView bridge which opens the native EPG or a program detail page. */
-    onOpenProgramGuide?: AribProgramGuideHandler;
-    /** Active caption components requested by the current broadcast document. */
-    onCaptionSubscription?: (subscription: AribCaptionSubscription) => void;
-    /** Resolve Application.replaceApplication() through the receiver's current MH-AIT. */
-    onReplaceApplication?: AribApplicationReplaceHandler;
-    /** Transfer an application to an unmanaged general-application URL. */
-    onExitManagedState?: AribExitManagedStateHandler;
-    /** Override the default browser alert when the receiver cannot open the EPG. */
-    onProgramGuideUnavailable?: AribProgramGuideUnavailableHandler;
-    /** Receiver identity/capabilities exposed to the broadcast application. */
-    systemInformation?: ReceiverSystemInformationOverrides;
-    /** Resolve receiver/CAS identifiers; defaults to the bundled Huggy demo identity. */
-    getDeviceIdentifier?: ReceiverDeviceIdentifierProvider;
-    /** Receiver UI hook for a TR-B39 viewer-participation corner notification. */
-    onViewerParticipation?: (event: AribViewerParticipationEvent) => void;
-};
+export type { AribApplicationInformation, AribApplicationReplaceHandler, AribApplicationReplaceRequest, AribBroadcastClock, AribCaptionPacket, AribCaptionSubscription, AribExitManagedStateHandler, AribReceiverHostOptions, AribReceiverLifecycleEvent, } from './receiver/types';
 export declare class AribReceiverHost {
     readonly iframe: HTMLIFrameElement;
     readonly viewport: HTMLElement;
@@ -120,21 +32,15 @@ export declare class AribReceiverHost {
     private readonly getDeviceIdentifier?;
     private readonly onViewerParticipation?;
     private readonly viewerParticipation;
-    private readonly resizeObserver;
-    private activeRuntimeId;
-    private logicalWidth;
-    private logicalHeight;
+    private readonly canvas;
+    private readonly runtimeSession;
     private captionComponentTags;
     private applicationInformation;
     private programInfo;
-    private readonly pendingStreamEvents;
     private broadcastClock;
-    private lctBackgroundColor;
-    private stageBackgroundColor;
     private video;
     private mediaPlaneEnabled;
     private applicationExited;
-    private applicationLoadTimer;
     private destroyed;
     constructor(options: AribReceiverHostOptions);
     installRuntime(target: RuntimeWindow): void;
@@ -184,13 +90,8 @@ export declare class AribReceiverHost {
     private readonly reportProgramGuideUnavailable;
     private readonly handleRuntimeMessage;
     private applyMediaPlane;
-    private readMediaLayer;
-    private postToRuntime;
-    private armApplicationLoadTimer;
     private failApplicationLoad;
-    private clearApplicationLoadTimer;
     private invalidateRuntime;
-    private fitBroadcastCanvas;
+    private disableRuntime;
     private assertAlive;
-    private applyReceiverBackgroundColor;
 }

package/dist/types/runtime/application-controller.d.ts

@@ -0,0 +1,48 @@
+import { type AribPermissionBit, type RuntimePermissionManagedArea } from './application-boundary';
+type RuntimeWindow = Window & typeof globalThis & Record<string, unknown>;
+export type RuntimeApplicationInformation = {
+    type?: string;
+    organizationId?: number;
+    applicationId?: number;
+    controlCode?: string;
+    autostartPriority?: number;
+    /** Decoded loops from MH-AIT descriptor 0x802C. Omit when absent. */
+    permissionManagedAreas?: readonly RuntimePermissionManagedArea[];
+};
+type RuntimeApplicationControllerOptions = {
+    target: RuntimeWindow;
+    broadcastBaseUrl: string | URL;
+    resolveRuntimeUrl: (value: unknown) => URL;
+    allowExternalNetwork: boolean;
+    application?: RuntimeApplicationInformation;
+    postRuntime: (event: string, detail?: Record<string, unknown>) => void;
+};
+/** Owns the application-manager, permission-boundary, and navigation state. */
+export declare class RuntimeApplicationController {
+    private readonly target;
+    private readonly resolveRuntimeUrl;
+    private readonly allowExternalNetwork;
+    private readonly postRuntime;
+    private readonly boundary;
+    private applicationInformation;
+    private applicationVisible;
+    private applicationInputActive;
+    private navigationCaptureInstalled;
+    private readonly keySet;
+    private readonly boundaryDescriptor;
+    private readonly ownerApplication;
+    constructor(options: RuntimeApplicationControllerOptions);
+    requirePermission(bit: AribPermissionBit): void;
+    permits(bit: AribPermissionBit): boolean;
+    updateApplicationInformation(value: RuntimeApplicationInformation): boolean;
+    setHostInputActive(active: boolean): void;
+    startDocument(): void;
+    startNavigationCapture(): void;
+    dispose(): void;
+    private applyApplicationVisibility;
+    private reportApplicationPresentation;
+    private reportBlockedNavigation;
+    private allowedNavigationUrl;
+    private readonly handleDocumentClick;
+}
+export {};

package/dist/types/runtime/caption-controller.d.ts

@@ -0,0 +1,27 @@
+type RuntimeCaptionControllerOptions = {
+    requirePermission: () => void;
+    postRuntime: (event: string, detail?: Record<string, unknown>) => void;
+};
+type RuntimeCaptionMessage = {
+    event?: unknown;
+    componentTags?: Iterable<unknown> | null;
+    componentTag?: unknown;
+    payload?: unknown;
+    dataType?: unknown;
+    tmd?: unknown;
+    data?: unknown;
+};
+/** Owns the document-side caption tracks, subscriptions, and broadcast object API. */
+export declare class RuntimeCaptionController {
+    private readonly requirePermission;
+    private readonly postRuntime;
+    private readonly tracks;
+    private readonly listeners;
+    constructor(options: RuntimeCaptionControllerOptions);
+    readonly installBroadcastObjectApi: (element: HTMLElement) => void;
+    /** Handle a host caption event; return false when it belongs to another subsystem. */
+    handleHostMessage(message: RuntimeCaptionMessage): boolean;
+    private componentTag;
+    private reportSubscriptions;
+}
+export {};

package/dist/types/runtime/external-media-hole.d.ts

@@ -0,0 +1,28 @@
+import type { AribMediaPlaneStackEntry } from '../media-plane';
+type RuntimeWindow = Window & typeof globalThis;
+/**
+ * Temporarily clears the DOM paint that covers an externally composed media
+ * plane and restores the exact inline values when the slot changes or exits.
+ */
+export declare class ExternalMediaHoleController {
+    private readonly target;
+    private readonly placeholderOpacities;
+    private readonly backgrounds;
+    constructor(target: RuntimeWindow);
+    set(object: HTMLElement, enabled: boolean): void;
+    restore(): void;
+    /** Read application styles while temporarily exposing backgrounds hidden for external video. */
+    withApplicationBackgrounds<T>(callback: () => T): T;
+    describeStackingPath(object: HTMLElement): AribMediaPlaneStackEntry[];
+    private hasTransparentBackground;
+    private placeholderElements;
+    private setPlaceholder;
+    private restorePlaceholder;
+    private restorePlaceholders;
+    private restoreBackground;
+    private applyBackground;
+    private captureApplicationBackgroundChanges;
+    private clearBackground;
+    private restoreBackgrounds;
+}
+export {};

package/dist/types/runtime/external-network.d.ts

@@ -0,0 +1,7 @@
+type ExternalNetworkTarget = Window & typeof globalThis;
+/**
+ * Make the receiver's optional external HTTP communication path fail fast while
+ * preserving same-origin access to receiver-managed broadcast resources.
+ */
+export declare function installExternalNetworkPolicy(target: ExternalNetworkTarget, allowExternalNetwork: boolean | undefined): void;
+export {};

package/dist/types/runtime/install.d.ts

@@ -3,10 +3,11 @@ import type { AribMediaPlaneAdapter } from '../media-plane';
 import { type BroadcastResourceStore } from './resources';
 import { type ReceiverSystemInformationOverrides } from './system-information';
 import { type ReceiverDeviceIdentifierProvider } from '../device-identifier';
-import { type RuntimePermissionManagedArea } from './application-boundary';
+import { type RuntimeApplicationInformation } from './application-controller';
 export type { ProgramInfo } from '../program-info';
 export type { RuntimeEvent, RuntimeEventSelector, RuntimeEventSource, } from './stream-event';
 export type { AribPermissionManagedArea, RuntimePermissionManagedArea, } from './application-boundary';
+export type { RuntimeApplicationInformation } from './application-controller';
 export type RuntimeWindow = Window & typeof globalThis & Record<string, unknown>;
 export type RuntimeOptions = {
     /** Permit HTTP requests outside the receiver-managed application origin. */
@@ -26,13 +27,4 @@ export type RuntimeOptions = {
     /** MH-AIT metadata for the application which owns this document. */
     application?: RuntimeApplicationInformation;
 };
-export type RuntimeApplicationInformation = {
-    type?: string;
-    organizationId?: number;
-    applicationId?: number;
-    controlCode?: string;
-    autostartPriority?: number;
-    /** Decoded loops from MH-AIT descriptor 0x802C. Omit when absent. */
-    permissionManagedAreas?: readonly RuntimePermissionManagedArea[];
-};
 export declare function installRuntime(target: RuntimeWindow, options?: RuntimeOptions): void;

package/dist/types/runtime/media-plane-runtime.d.ts

@@ -0,0 +1,54 @@
+import type { AribMediaPlaneAdapter, AribMediaPlaneUnmountReason } from '../media-plane';
+type RuntimeWindow = Window & typeof globalThis;
+type RuntimeMediaPlaneControllerOptions = {
+    target: RuntimeWindow;
+    adapter?: AribMediaPlaneAdapter;
+    canUseBroadcastMedia: () => boolean;
+    installBroadcastObjectApi: (object: HTMLElement) => void;
+    postRuntime: (event: string, detail?: Record<string, unknown>) => void;
+};
+/** Owns the document-side media-plane observation and compositor lifecycle. */
+export declare class RuntimeMediaPlaneController {
+    private readonly target;
+    private readonly adapter?;
+    private readonly canUseBroadcastMedia;
+    private readonly installBroadcastObjectApi;
+    private readonly postRuntime;
+    private readonly mediaObjectIds;
+    private readonly externalMediaHole;
+    private readonly resizeObserver;
+    private applicationCanvasStyle;
+    private mutationObserver;
+    private nextMediaObjectId;
+    private activeMediaObject;
+    private lastMediaPlane;
+    private lastStageBackgroundColor;
+    private observedMediaObject;
+    private mediaPlaneFrame;
+    private observing;
+    private disposed;
+    constructor(options: RuntimeMediaPlaneControllerOptions);
+    /** Install APIs needed by static objects, prepare the canvas, and queue a report. */
+    startDocument(): void;
+    /** Start document observers after the runtime's installed handshake was sent. */
+    startObserving(): void;
+    readonly schedule: () => void;
+    /**
+     * Stop observation, run document-owned cleanup, then restore and unmount the
+     * media plane. The cleanup hook preserves the original pagehide ordering.
+     */
+    dispose(reason: Extract<AribMediaPlaneUnmountReason, 'document-unload'>, beforeUnmount?: () => void): void;
+    private findMediaObject;
+    private reportStageStyle;
+    private prepareExternalMediaPlaneCanvas;
+    private withApplicationCanvasBackgrounds;
+    private observeDocumentMutations;
+    private activeMediaAnimation;
+    private observeMediaObject;
+    private logicalViewport;
+    private slotIdFor;
+    private callMediaPlaneAdapter;
+    private unmountMediaPlane;
+    private reportMediaPlane;
+}
+export {};

package/dist/types/service-worker-vfs.d.ts

@@ -1,84 +1,3 @@
-export type BroadcastVfsResource = {
-    path: string;
-    contentType?: string;
-    data: Uint8Array | ArrayBuffer;
-};
-export type ServiceWorkerBroadcastVfsOptions = {
-    workerUrl: string | URL;
-    /** Same-origin scope used to expose broadcast files. */
-    baseUrl?: string | URL;
-    /** Compatibility fallback for applications which omit a carousel directory. */
-    uniqueBasenameFallback?: boolean;
-};
-export type BroadcastVfsBackend = {
-    begin(): Promise<void>;
-    put(resource: BroadcastVfsResource): Promise<void>;
-    canRead(path: string): Promise<boolean>;
-};
-export type BroadcastVfsSessionOptions = {
-    /** Report background write failures; ensure() still rejects to its caller. */
-    onError?: (error: unknown) => void;
-    /** Override background scheduling, primarily for embedded hosts and tests. */
-    schedule?: (task: () => void) => void;
-};
-/**
- * Ordered, recoverable write session above a VFS backend. enqueue() copies
- * callback-lifetime data synchronously and returns a revision barrier.
- */
-export declare class BroadcastVfsSession {
-    private readonly backend;
-    private readonly onError?;
-    private readonly scheduleTask;
-    private readonly mirror;
-    private readonly queue;
-    private waiters;
-    private generation;
-    private nextRevision;
-    private completedRevision;
-    private drainScheduled;
-    private ioTail;
-    private sessionReady;
-    private disposed;
-    constructor(backend: BroadcastVfsBackend, options?: BroadcastVfsSessionOptions);
-    beginSession(): Promise<void>;
-    enqueue(resource: BroadcastVfsResource): number;
-    waitFor(revision: number): Promise<void>;
-    /** Ensure a staged path is readable, replaying the page-owned mirror if needed. */
-    ensure(path: string, revision?: number): Promise<void>;
-    /**
-     * Stop accepting resources, discard queued writes, and wait for the one
-     * backend operation which may already be running. The backend itself remains
-     * owned by the caller and can be reset or disposed after this resolves.
-     */
-    dispose(): Promise<void>;
-    private appendIo;
-    private scheduleDrain;
-    private drainOne;
-    private resolveWaiters;
-}
-export declare class ServiceWorkerBroadcastVfs {
-    private readonly workerUrl;
-    private readonly scopeUrl;
-    private readonly uniqueBasenameFallback;
-    private registration;
-    private ready;
-    private readonly inFlight;
-    private disposing;
-    private disposed;
-    constructor(options: ServiceWorkerBroadcastVfsOptions);
-    initialize(): Promise<ServiceWorkerRegistration>;
-    begin(): Promise<void>;
-    put(resource: BroadcastVfsResource): Promise<void>;
-    canRead(path: string): Promise<boolean>;
-    reset(): Promise<void>;
-    /**
-     * Clear the receiver-owned VFS session after outstanding requests finish.
-     * The shared Service Worker registration is intentionally retained so other
-     * tabs and future receiver instances keep a stable scoped fetch handler.
-     */
-    dispose(): Promise<void>;
-    private request;
-    private performRequest;
-    private performRequestWithRegistration;
-    private waitForActivation;
-}
+export { BroadcastVfsSession } from './vfs/session.js';
+export { ServiceWorkerBroadcastVfs } from './vfs/service-worker-backend.js';
+export type { BroadcastVfsBackend, BroadcastVfsResource, BroadcastVfsSessionOptions, ServiceWorkerBroadcastVfsOptions, } from './vfs/types.js';

package/dist/types/vfs/service-worker-backend.d.ts

@@ -0,0 +1,27 @@
+import type { BroadcastVfsResource, ServiceWorkerBroadcastVfsOptions } from './types.js';
+export declare class ServiceWorkerBroadcastVfs {
+    private readonly workerUrl;
+    private readonly scopeUrl;
+    private readonly uniqueBasenameFallback;
+    private registration;
+    private ready;
+    private readonly inFlight;
+    private disposing;
+    private disposed;
+    constructor(options: ServiceWorkerBroadcastVfsOptions);
+    initialize(): Promise<ServiceWorkerRegistration>;
+    begin(): Promise<void>;
+    put(resource: BroadcastVfsResource): Promise<void>;
+    canRead(path: string): Promise<boolean>;
+    reset(): Promise<void>;
+    /**
+     * Clear the receiver-owned VFS session after outstanding requests finish.
+     * The shared Service Worker registration is intentionally retained so other
+     * tabs and future receiver instances keep a stable scoped fetch handler.
+     */
+    dispose(): Promise<void>;
+    private request;
+    private performRequest;
+    private performRequestWithRegistration;
+    private waitForActivation;
+}