@replayablejs/runtime 0.1.0-alpha.0

package/dist/create-adapter-ByJx4UTX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-adapter-ByJx4UTX.js","names":[],"sources":["../src/mraid/create-adapter.ts"],"sourcesContent":["import { FULL_VOLUME } from '#lifecycle/volume.js';\nimport type { HostAdapter, HostSnapshot, HostUpdateListener } from '#types/host-adapter.js';\nimport type { MraidApi } from '#types/mraid.js';\n\nimport { readMraidViewport, requireMraid, waitForMraidReady } from './api.js';\nimport { subscribeToMraidUpdates } from './events.js';\n\n/** MRAID SDK object injected by the active advertising host. */\ndeclare const mraid: MraidApi;\n\n/**\n * Creates the standard MRAID host behavior shared by networks whose CTA opens\n * the authored store URL directly through `mraid.open(url)`.\n */\nexport function createMraidHostAdapter(): HostAdapter {\n  return {\n    async initialize(listener): Promise<HostSnapshot> {\n      requireMraid();\n      await waitForMraidReady();\n\n      subscribeToMraidUpdates(listener);\n      subscribeToBrowserViewportChanges(listener);\n\n      return {\n        visible: mraid.isViewable(),\n        viewport: readMraidViewport(),\n        // MRAID 2 has no initial volume query. Start audible and let MRAID 3's\n        // audioVolumeChange event publish the host's first authoritative value.\n        volume: FULL_VOLUME,\n      };\n    },\n\n    openStore(url): void {\n      requireMraid();\n      mraid.open(url);\n    },\n  };\n}\n\n/**\n * Supplements MRAID sizeChange with browser signals emitted by host WebViews\n * during device rotation. Runtime state deduplicates equivalent dimensions.\n */\nfunction subscribeToBrowserViewportChanges(listener: HostUpdateListener): void {\n  const handleViewportChange = (): void => {\n    listener({\n      type: 'resize',\n      viewport: readMraidViewport(),\n    });\n  };\n\n  window.addEventListener('resize', handleViewportChange);\n  window.addEventListener('orientationchange', handleViewportChange);\n}\n"],"mappings":";;;;;;AAcA,SAAgB,yBAAsC;CACpD,OAAO;EACL,MAAM,WAAW,UAAiC;GAChD,aAAa;GACb,MAAM,kBAAkB;GAExB,wBAAwB,QAAQ;GAChC,kCAAkC,QAAQ;GAE1C,OAAO;IACL,SAAS,MAAM,WAAW;IAC1B,UAAU,kBAAkB;IAG5B,QAAA;GACF;EACF;EAEA,UAAU,KAAW;GACnB,aAAa;GACb,MAAM,KAAK,GAAG;EAChB;CACF;AACF;;;;;AAMA,SAAS,kCAAkC,UAAoC;CAC7E,MAAM,6BAAmC;EACvC,SAAS;GACP,MAAM;GACN,UAAU,kBAAkB;EAC9B,CAAC;CACH;CAEA,OAAO,iBAAiB,UAAU,oBAAoB;CACtD,OAAO,iBAAiB,qBAAqB,oBAAoB;AACnE"}

package/dist/events-C85TpS5f.js

@@ -0,0 +1,69 @@
+//#region src/adapters/browser/api.ts
+/** Waits until authored application code may safely access the parsed document. */
+async function waitForDocumentReady() {
+	if (document.readyState !== "loading") return;
+	await new Promise((resolve) => {
+		document.addEventListener("DOMContentLoaded", () => resolve(), { once: true });
+	});
+}
+/** Captures every browser-owned lifecycle value as one consistent snapshot. */
+function createBrowserSnapshot() {
+	return {
+		visible: isDocumentVisible(),
+		viewport: readBrowserViewport(),
+		volume: 1
+	};
+}
+/** Uses the visual viewport when available because it represents the visible ad area. */
+function readBrowserViewport() {
+	const viewport = window.visualViewport;
+	if (viewport !== null && viewport !== void 0) return {
+		width: viewport.width,
+		height: viewport.height
+	};
+	return {
+		width: window.innerWidth,
+		height: window.innerHeight
+	};
+}
+/** Treats prerendered and background documents as not viewable. */
+function isDocumentVisible() {
+	return document.visibilityState === "visible";
+}
+//#endregion
+//#region src/adapters/browser/events.ts
+/**
+* Translates browser visibility and viewport events into Replayable host updates.
+*
+* The adapter intentionally publishes every browser notification. The runtime
+* owns state comparison and suppresses duplicate public lifecycle events.
+*/
+function subscribeToBrowserUpdates(listener) {
+	const handleVisibilityChange = () => {
+		listener({
+			type: "visibilitychange",
+			visible: isDocumentVisible()
+		});
+	};
+	const handleResize = () => {
+		listener({
+			type: "resize",
+			viewport: readBrowserViewport()
+		});
+	};
+	document.addEventListener("visibilitychange", handleVisibilityChange);
+	addViewportListener(handleResize);
+}
+/** Observes the same viewport source used by `readBrowserViewport`. */
+function addViewportListener(listener) {
+	const viewport = window.visualViewport;
+	if (viewport !== null && viewport !== void 0) {
+		viewport.addEventListener("resize", listener);
+		return;
+	}
+	window.addEventListener("resize", listener);
+}
+//#endregion
+export { waitForDocumentReady as a, readBrowserViewport as i, createBrowserSnapshot as n, isDocumentVisible as r, subscribeToBrowserUpdates as t };
+
+//# sourceMappingURL=events-C85TpS5f.js.map

package/dist/events-C85TpS5f.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-C85TpS5f.js","names":[],"sources":["../src/adapters/browser/api.ts","../src/adapters/browser/events.ts"],"sourcesContent":["import { FULL_VOLUME } from '#lifecycle/volume.js';\nimport type { HostSnapshot } from '#types/host-adapter.js';\nimport type { RuntimeViewport } from '#types/screen.js';\n\n/** Waits until authored application code may safely access the parsed document. */\nexport async function waitForDocumentReady(): Promise<void> {\n  if (document.readyState !== 'loading') {\n    return;\n  }\n\n  await new Promise<void>((resolve) => {\n    document.addEventListener('DOMContentLoaded', () => resolve(), { once: true });\n  });\n}\n\n/** Captures every browser-owned lifecycle value as one consistent snapshot. */\nexport function createBrowserSnapshot(): HostSnapshot {\n  return {\n    visible: isDocumentVisible(),\n    viewport: readBrowserViewport(),\n    // Ordinary browsers do not expose host-controlled ad volume.\n    volume: FULL_VOLUME,\n  };\n}\n\n/** Uses the visual viewport when available because it represents the visible ad area. */\nexport function readBrowserViewport(): RuntimeViewport {\n  const viewport = window.visualViewport;\n\n  if (viewport !== null && viewport !== undefined) {\n    return {\n      width: viewport.width,\n      height: viewport.height,\n    };\n  }\n\n  return {\n    width: window.innerWidth,\n    height: window.innerHeight,\n  };\n}\n\n/** Treats prerendered and background documents as not viewable. */\nexport function isDocumentVisible(): boolean {\n  return document.visibilityState === 'visible';\n}\n","import type { HostUpdateListener } from '#types/host-adapter.js';\n\nimport { isDocumentVisible, readBrowserViewport } from './api.js';\n\n/**\n * Translates browser visibility and viewport events into Replayable host updates.\n *\n * The adapter intentionally publishes every browser notification. The runtime\n * owns state comparison and suppresses duplicate public lifecycle events.\n */\nexport function subscribeToBrowserUpdates(listener: HostUpdateListener): void {\n  const handleVisibilityChange = (): void => {\n    listener({\n      type: 'visibilitychange',\n      visible: isDocumentVisible(),\n    });\n  };\n\n  const handleResize = (): void => {\n    listener({\n      type: 'resize',\n      viewport: readBrowserViewport(),\n    });\n  };\n\n  document.addEventListener('visibilitychange', handleVisibilityChange);\n  addViewportListener(handleResize);\n}\n\n/** Observes the same viewport source used by `readBrowserViewport`. */\nfunction addViewportListener(listener: () => void): void {\n  const viewport = window.visualViewport;\n\n  if (viewport !== null && viewport !== undefined) {\n    viewport.addEventListener('resize', listener);\n    return;\n  }\n\n  window.addEventListener('resize', listener);\n}\n"],"mappings":";;AAKA,eAAsB,uBAAsC;CAC1D,IAAI,SAAS,eAAe,WAC1B;CAGF,MAAM,IAAI,SAAe,YAAY;EACnC,SAAS,iBAAiB,0BAA0B,QAAQ,GAAG,EAAE,MAAM,KAAK,CAAC;CAC/E,CAAC;AACH;;AAGA,SAAgB,wBAAsC;CACpD,OAAO;EACL,SAAS,kBAAkB;EAC3B,UAAU,oBAAoB;EAE9B,QAAA;CACF;AACF;;AAGA,SAAgB,sBAAuC;CACrD,MAAM,WAAW,OAAO;CAExB,IAAI,aAAa,QAAQ,aAAa,KAAA,GACpC,OAAO;EACL,OAAO,SAAS;EAChB,QAAQ,SAAS;CACnB;CAGF,OAAO;EACL,OAAO,OAAO;EACd,QAAQ,OAAO;CACjB;AACF;;AAGA,SAAgB,oBAA6B;CAC3C,OAAO,SAAS,oBAAoB;AACtC;;;;;;;;;ACnCA,SAAgB,0BAA0B,UAAoC;CAC5E,MAAM,+BAAqC;EACzC,SAAS;GACP,MAAM;GACN,SAAS,kBAAkB;EAC7B,CAAC;CACH;CAEA,MAAM,qBAA2B;EAC/B,SAAS;GACP,MAAM;GACN,UAAU,oBAAoB;EAChC,CAAC;CACH;CAEA,SAAS,iBAAiB,oBAAoB,sBAAsB;CACpE,oBAAoB,YAAY;AAClC;;AAGA,SAAS,oBAAoB,UAA4B;CACvD,MAAM,WAAW,OAAO;CAExB,IAAI,aAAa,QAAQ,aAAa,KAAA,GAAW;EAC/C,SAAS,iBAAiB,UAAU,QAAQ;EAC5C;CACF;CAEA,OAAO,iBAAiB,UAAU,QAAQ;AAC5C"}

package/dist/events-CYG_LvaH.js

@@ -0,0 +1,85 @@
+//#region src/mraid/api.ts
+/** Fails clearly when a MRAID creative runs without its host-injected SDK. */
+function requireMraid() {
+	if (typeof mraid === "undefined") throw new Error("The active network requires the injected global mraid object.");
+}
+/** Waits for MRAID to leave its initial loading state before SDK access. */
+async function waitForMraidReady() {
+	if (mraid.getState() !== "loading") return;
+	await new Promise((resolve) => {
+		const handleReady = () => {
+			mraid.removeEventListener("ready", handleReady);
+			resolve();
+		};
+		mraid.addEventListener("ready", handleReady);
+	});
+}
+/** Reads the current ad container rather than the device's physical screen. */
+function readMraidViewport() {
+	const { height, width } = mraid.getCurrentPosition();
+	return {
+		height,
+		width
+	};
+}
+//#endregion
+//#region src/mraid/volume.ts
+/** Converts MRAID's percentage value into Replayable's normalized range. */
+function normalizeMraidVolume(volume) {
+	const normalizedVolume = volume / 100;
+	return Math.min(1, Math.max(0, normalizedVolume));
+}
+//#endregion
+//#region src/mraid/events.ts
+/**
+* Translates MRAID lifecycle events into Replayable host updates.
+*
+* MRAID 3 replaces the MRAID 2 viewability signal with a more precise exposure
+* percentage and adds host audio volume. Both versions share sizeChange. The
+* adapter subscribes only to the event set supported by the detected SDK version.
+*/
+function subscribeToMraidUpdates(listener) {
+	const handleViewableChange = (visible) => {
+		listener({
+			type: "visibilitychange",
+			visible
+		});
+	};
+	const handleExposureChange = (exposedPercentage) => {
+		listener({
+			type: "visibilitychange",
+			visible: exposedPercentage > 0
+		});
+	};
+	const handleSizeChange = (width, height) => {
+		listener({
+			type: "resize",
+			viewport: {
+				height,
+				width
+			}
+		});
+	};
+	const handleAudioVolumeChange = (volume) => {
+		if (volume === null) return;
+		listener({
+			type: "volumechange",
+			volume: normalizeMraidVolume(volume)
+		});
+	};
+	mraid.addEventListener("sizeChange", handleSizeChange);
+	if (supportsMraid3()) {
+		mraid.addEventListener("exposureChange", handleExposureChange);
+		mraid.addEventListener("audioVolumeChange", handleAudioVolumeChange);
+		return;
+	}
+	mraid.addEventListener("viewableChange", handleViewableChange);
+}
+/** Enables events introduced in MRAID 3 while preserving the MRAID 2 baseline. */
+function supportsMraid3() {
+	return Number.parseFloat(mraid.getVersion()) >= 3;
+}
+//#endregion
+export { waitForMraidReady as i, readMraidViewport as n, requireMraid as r, subscribeToMraidUpdates as t };
+
+//# sourceMappingURL=events-CYG_LvaH.js.map

package/dist/events-CYG_LvaH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-CYG_LvaH.js","names":[],"sources":["../src/mraid/api.ts","../src/mraid/volume.ts","../src/mraid/events.ts"],"sourcesContent":["import type { MraidApi } from '#types/mraid.js';\nimport type { RuntimeViewport } from '#types/screen.js';\n\n/** MRAID SDK object injected by the active advertising host. */\ndeclare const mraid: MraidApi;\n\n/** Fails clearly when a MRAID creative runs without its host-injected SDK. */\nexport function requireMraid(): void {\n  if (typeof mraid === 'undefined') {\n    throw new Error('The active network requires the injected global mraid object.');\n  }\n}\n\n/** Waits for MRAID to leave its initial loading state before SDK access. */\nexport async function waitForMraidReady(): Promise<void> {\n  if (mraid.getState() !== 'loading') {\n    return;\n  }\n\n  await new Promise<void>((resolve) => {\n    const handleReady = (): void => {\n      mraid.removeEventListener('ready', handleReady);\n      resolve();\n    };\n\n    mraid.addEventListener('ready', handleReady);\n  });\n}\n\n/** Reads the current ad container rather than the device's physical screen. */\nexport function readMraidViewport(): RuntimeViewport {\n  const { height, width } = mraid.getCurrentPosition();\n\n  return { height, width };\n}\n","import { FULL_VOLUME } from '#lifecycle/volume.js';\n\n/** Converts MRAID's percentage value into Replayable's normalized range. */\nexport function normalizeMraidVolume(volume: number): number {\n  const normalizedVolume = volume / 100;\n\n  return Math.min(FULL_VOLUME, Math.max(0, normalizedVolume));\n}\n","import type { HostUpdateListener } from '#types/host-adapter.js';\nimport type { MraidApi } from '#types/mraid.js';\n\nimport { normalizeMraidVolume } from './volume.js';\n\n/** MRAID SDK object injected by the active advertising host. */\ndeclare const mraid: MraidApi;\n\n/**\n * Translates MRAID lifecycle events into Replayable host updates.\n *\n * MRAID 3 replaces the MRAID 2 viewability signal with a more precise exposure\n * percentage and adds host audio volume. Both versions share sizeChange. The\n * adapter subscribes only to the event set supported by the detected SDK version.\n */\nexport function subscribeToMraidUpdates(listener: HostUpdateListener): void {\n  const handleViewableChange = (visible: boolean): void => {\n    listener({ type: 'visibilitychange', visible });\n  };\n\n  const handleExposureChange = (exposedPercentage: number): void => {\n    listener({\n      type: 'visibilitychange',\n      visible: exposedPercentage > 0,\n    });\n  };\n\n  const handleSizeChange = (width: number, height: number): void => {\n    listener({\n      type: 'resize',\n      viewport: { height, width },\n    });\n  };\n\n  const handleAudioVolumeChange = (volume: number | null): void => {\n    if (volume === null) {\n      return;\n    }\n\n    listener({\n      type: 'volumechange',\n      volume: normalizeMraidVolume(volume),\n    });\n  };\n\n  mraid.addEventListener('sizeChange', handleSizeChange);\n\n  if (supportsMraid3()) {\n    mraid.addEventListener('exposureChange', handleExposureChange);\n    mraid.addEventListener('audioVolumeChange', handleAudioVolumeChange);\n    return;\n  }\n\n  mraid.addEventListener('viewableChange', handleViewableChange);\n}\n\n/** Enables events introduced in MRAID 3 while preserving the MRAID 2 baseline. */\nfunction supportsMraid3(): boolean {\n  return Number.parseFloat(mraid.getVersion()) >= 3;\n}\n"],"mappings":";;AAOA,SAAgB,eAAqB;CACnC,IAAI,OAAO,UAAU,aACnB,MAAM,IAAI,MAAM,+DAA+D;AAEnF;;AAGA,eAAsB,oBAAmC;CACvD,IAAI,MAAM,SAAS,MAAM,WACvB;CAGF,MAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAA0B;GAC9B,MAAM,oBAAoB,SAAS,WAAW;GAC9C,QAAQ;EACV;EAEA,MAAM,iBAAiB,SAAS,WAAW;CAC7C,CAAC;AACH;;AAGA,SAAgB,oBAAqC;CACnD,MAAM,EAAE,QAAQ,UAAU,MAAM,mBAAmB;CAEnD,OAAO;EAAE;EAAQ;CAAM;AACzB;;;;AC/BA,SAAgB,qBAAqB,QAAwB;CAC3D,MAAM,mBAAmB,SAAS;CAElC,OAAO,KAAK,IAAA,GAAiB,KAAK,IAAI,GAAG,gBAAgB,CAAC;AAC5D;;;;;;;;;;ACQA,SAAgB,wBAAwB,UAAoC;CAC1E,MAAM,wBAAwB,YAA2B;EACvD,SAAS;GAAE,MAAM;GAAoB;EAAQ,CAAC;CAChD;CAEA,MAAM,wBAAwB,sBAAoC;EAChE,SAAS;GACP,MAAM;GACN,SAAS,oBAAoB;EAC/B,CAAC;CACH;CAEA,MAAM,oBAAoB,OAAe,WAAyB;EAChE,SAAS;GACP,MAAM;GACN,UAAU;IAAE;IAAQ;GAAM;EAC5B,CAAC;CACH;CAEA,MAAM,2BAA2B,WAAgC;EAC/D,IAAI,WAAW,MACb;EAGF,SAAS;GACP,MAAM;GACN,QAAQ,qBAAqB,MAAM;EACrC,CAAC;CACH;CAEA,MAAM,iBAAiB,cAAc,gBAAgB;CAErD,IAAI,eAAe,GAAG;EACpB,MAAM,iBAAiB,kBAAkB,oBAAoB;EAC7D,MAAM,iBAAiB,qBAAqB,uBAAuB;EACnE;CACF;CAEA,MAAM,iBAAiB,kBAAkB,oBAAoB;AAC/D;;AAGA,SAAS,iBAA0B;CACjC,OAAO,OAAO,WAAW,MAAM,WAAW,CAAC,KAAK;AAClD"}

package/dist/host-adapter-vFX6DBcY.d.ts

@@ -0,0 +1,43 @@
+import { s as RuntimeViewport } from "./screen-DXf2FPtL.js";
+//#region src/types/host-adapter.d.ts
+/** Host-owned values captured after its SDK or browser environment becomes ready. */
+interface HostSnapshot {
+  /** Host-provided volume normalized from silent (`0`) to full volume (`1`). */
+  readonly volume: number;
+  /** Whether the host currently considers the playable viewable. */
+  readonly visible: boolean;
+  /** Current dimensions of the ad container in CSS pixels. */
+  readonly viewport: RuntimeViewport;
+}
+/** One host-owned lifecycle change reported after initialization. */
+type HostUpdate = {
+  readonly type: 'resize';
+  readonly viewport: RuntimeViewport;
+} | {
+  readonly type: 'visibilitychange';
+  readonly visible: boolean;
+} | {
+  readonly type: 'volumechange';
+  readonly volume: number;
+};
+/** Receives lifecycle changes from the active host adapter. */
+type HostUpdateListener = (update: HostUpdate) => void;
+/**
+ * Connects the runtime to one concrete hosting environment.
+ *
+ * Browser preview and advertising-network implementations provide the same
+ * normalized facts, leaving runtime state and public events host-independent.
+ */
+interface HostAdapter {
+  /** Waits for the host and returns its first complete lifecycle snapshot. */
+  initialize(listener: HostUpdateListener): Promise<HostSnapshot>;
+  /** Notifies hosts that require an explicit terminal playable signal. */
+  notifyComplete?(): void;
+  /** Notifies hosts that require an explicit post-loading readiness signal. */
+  notifyReady?(): void;
+  /** Opens the supplied store destination through the hosting environment. */
+  openStore(url: string): void;
+}
+//#endregion
+export { HostAdapter as t };
+//# sourceMappingURL=host-adapter-vFX6DBcY.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,255 @@
+import { a as RuntimeResolutionConfig, c as Screen, i as RuntimeRenderScaleConfig, l as ScreenDesign, n as RuntimeOrientationConfig, o as RuntimeScreenConfig, r as RuntimeRange, s as RuntimeViewport, t as RuntimeOrientation, u as ScreenFrame } from "./screen-DXf2FPtL.js";
+import { r as AssetMode } from "./assets-BD68MQTL.js";
+import { a as AudioStopOptions, i as AudioPlaybackOptions, n as AudioOneShotOptions, o as PlayableAudio, r as AudioPlayback, s as RuntimeAudioState } from "./audio-CyLjSreN.js";
+import { a as AssetLoadedContext, c as BuiltInAssetCategory, d as RegisteredAssetCategory, i as AssetLoadHandler, l as BuiltInAssetValueByCategory, n as AssetCache, o as AssetLoadedListener, r as AssetLoadContext, s as AssetLoader, t as AssetBundleLoadedListener, u as LoadedShaderAsset } from "./loader-Czz-x3KH.js";
+//#region src/types/completion.d.ts
+/** Supported terminal outcomes reported by a playable. */
+type PlayableCompletionReason = 'duration-timeout' | 'failure' | 'inactivity-timeout' | 'skip' | 'success';
+/** Immutable terminal outcome committed by `playable.complete()`. */
+interface PlayableCompletion {
+  readonly reason: PlayableCompletionReason;
+}
+/** Resolved automatic completion policy for the active playable variant. */
+interface RuntimeCompletionConfig {
+  /** Maximum playable duration in seconds, when enabled. */
+  readonly duration?: number;
+  /** Network-owned point from which the duration timer begins advancing. */
+  readonly durationStart: 'interaction' | 'ready';
+  /** Allowed inactivity in seconds after the first interaction, when enabled. */
+  readonly inactivity?: number;
+}
+//#endregion
+//#region src/types/controls.d.ts
+/** Resolved controls: authored preview preferences or authoritative ad-network policy. */
+interface RuntimeControlsConfig {
+  /** Whether gameplay keeps a store call to action visible. */
+  readonly persistentCta: boolean;
+}
+//#endregion
+//#region src/types/devtools.d.ts
+/** Explicit display and panel settings after project configuration shorthand is resolved. */
+interface RuntimeStatsConfig {
+  /** Expanded shows all panels; compact presents one panel at a time. */
+  readonly display: 'expanded' | 'compact';
+  readonly fps: boolean;
+  readonly frameInterval: boolean;
+  /** Approximate browser-reported JavaScript heap, when supported. */
+  readonly jsHeap: boolean;
+  /** Submitted WebGL draw operations per frame; instances are not separate draws. */
+  readonly drawCalls: boolean;
+  /** WebGL bindTexture calls per frame, including repeated and null bindings. */
+  readonly textureBinds: boolean;
+  /** WebGL useProgram calls per frame, including repeated and null uses. */
+  readonly programUses: boolean;
+}
+/** Settings consumed by optional development tools, not by runtime scheduling. */
+interface RuntimeDevtoolsConfig {
+  /** Development-only Escape shortcut and DOM Skip button. */
+  readonly endCardTrigger: boolean;
+  /** Development-only audio toggle, shown only when audio is enabled. */
+  readonly soundControl: boolean;
+  readonly stats: false | RuntimeStatsConfig;
+}
+//#endregion
+//#region src/types/end-card.d.ts
+/** Network-resolved repetition policy for automatic end-card attention effects. */
+type EndCardAnimation = 'continuous' | 'finite';
+/** Network-resolved interaction policy for a playable's terminal end card. */
+type EndCardInteraction = 'cta-only' | 'full-screen';
+/** Browser-safe end-card behavior injected by the active network profile. */
+interface RuntimeEndCardConfig {
+  /** Determines whether automatic end-card attention effects may repeat continuously. */
+  readonly animation: EndCardAnimation;
+  /**
+   * Determines whether store exits are accepted only from the explicit CTA or
+   * from any primary pointer interaction inside the visible end card.
+   */
+  readonly interaction: EndCardInteraction;
+}
+//#endregion
+//#region src/types/localization.d.ts
+/** Runtime translation lookup over the dictionary loaded for a playable. */
+interface Localization {
+  /** Fixed language selected for the current playable variant. */
+  readonly language: string;
+  /** Resolves one phrase using the selected language and configured fallback. */
+  translate(phrase: string): string;
+}
+//#endregion
+//#region src/types/timers.d.ts
+/** Configuration for one application-owned inactivity timer. */
+interface InactivityTimerOptions {
+  /** Inactive visible time in seconds before `onTimeout` runs. */
+  readonly duration: number;
+  /** Called once after the timer has stopped itself. */
+  readonly onTimeout: () => void;
+}
+/** Controls one reusable application-owned inactivity timer. */
+interface InactivityTimer {
+  /** Starts a stopped timer from its full duration; does nothing while already running. */
+  start(): void;
+  /** Resets the full duration and starts the timer when necessary. */
+  restart(): void;
+  /** Stops the timer and clears its elapsed inactivity. */
+  stop(): void;
+}
+/** Application-owned timers synchronized with Replayable's visible-time clock. */
+interface PlayableTimers {
+  /** Waits for the given amount of active visible time, measured in seconds. */
+  delay(duration: number): Promise<void>;
+  /** Creates a stopped timer that resets after every trusted user interaction. */
+  createInactivityTimer(options: InactivityTimerOptions): InactivityTimer;
+}
+//#endregion
+//#region src/types/update.d.ts
+/** A subscription channel driven by Replayable's runtime update loop. */
+interface UpdateChannel<Context> {
+  /**
+   * Adds a listener to the channel.
+   *
+   * @returns A function that removes this listener.
+   */
+  add(listener: (context: Context) => void): () => void;
+}
+/** Timing values delivered once for every rendered browser frame. */
+interface UpdateContext {
+  /** Active runtime time advanced by this frame, measured in seconds. */
+  readonly deltaSeconds: number;
+  /**
+   * Progress toward the next fixed update, from 0 inclusive to 1 exclusive.
+   *
+   * A value of 0 is exactly on a fixed-step boundary, 0.5 is halfway toward
+   * the next step, and a value near 1 means another fixed update is almost due.
+   * It is 0 on the first frame, after resuming, and without fixed listeners.
+   */
+  readonly fixedInterpolation: number;
+}
+/** Delivered after Motion's update and render phases, not after GPU completion or browser paint. */
+interface PostRenderContext {
+  /** Shared Motion frame timestamp in milliseconds; suitable for real frame intervals and identity. */
+  readonly timestamp: number;
+}
+/** Timing values delivered for one fixed simulation step. */
+interface FixedUpdateContext {
+  /** Constant duration of this simulation step, measured in seconds. */
+  readonly deltaSeconds: number;
+}
+//#endregion
+//#region src/types/runtime.d.ts
+/** Resolved, browser-safe configuration for the active playable variant. */
+interface RuntimeConfig {
+  /** Whether this concrete playable variant includes runtime audio capability. */
+  readonly audio: boolean;
+  /** First-paint color retained behind the playable's mounted content. */
+  readonly backgroundColor: string;
+  readonly completion: RuntimeCompletionConfig;
+  /** Resolved preview preferences or ad-network policy, with sound gated by audio capability. */
+  readonly controls: RuntimeControlsConfig;
+  readonly devtools: RuntimeDevtoolsConfig;
+  readonly endCard: RuntimeEndCardConfig;
+  readonly id: string;
+  readonly localization: RuntimeLocalizationConfig;
+  readonly network: RuntimeNetwork;
+  readonly params: Readonly<Record<string, RuntimeParamValue>>;
+  readonly screen: RuntimeScreenConfig;
+  readonly store: RuntimeStoreConfig;
+  readonly version: string;
+}
+/** Fixed language selected for this playable build. */
+interface RuntimeLocalizationConfig {
+  readonly language: string;
+}
+/** Delivery network selected for the active playable variant. */
+type RuntimeNetwork = 'applovin' | 'google' | 'liftoff' | 'meta' | 'mintegral' | 'moloco' | 'preview' | 'unity';
+/** Primitive value of one resolved playable parameter. */
+type RuntimeParamValue = boolean | number | string;
+/** Resolved iOS and Android call-to-action destinations. */
+interface RuntimeStoreConfig {
+  readonly androidUrl: string;
+  readonly iosUrl: string;
+}
+/** Complete value injected into runtime by Replayable's Vite configuration. */
+interface RuntimeDefinition {
+  /** Internal representation selected by the active network profile. */
+  readonly assetMode: AssetMode;
+  readonly config: RuntimeConfig;
+  /** Platform-specific call-to-action destination resolved by the config entry. */
+  readonly storeUrl: string;
+}
+/** Complete normalized lifecycle state available to playable code. */
+interface RuntimeState {
+  readonly audio: RuntimeAudioState;
+  /** Terminal outcome, or `undefined` while the playable remains active. */
+  readonly completion: PlayableCompletion | undefined;
+  /** Whether the user has interacted with the playable at least once. */
+  readonly interacted: boolean;
+  readonly orientation: RuntimeOrientation;
+  /** Whether the host currently considers the playable viewable. */
+  readonly visible: boolean;
+  readonly viewport: RuntimeViewport;
+}
+/** Values delivered by each public runtime lifecycle event. */
+interface RuntimeEventMap {
+  audiochange: RuntimeAudioState;
+  complete: PlayableCompletion;
+  interaction: true;
+  resize: RuntimeViewport;
+  visibilitychange: boolean;
+}
+/** Listener for one public runtime lifecycle event. */
+type RuntimeEventListener<Event extends keyof RuntimeEventMap> = (value: RuntimeEventMap[Event]) => void;
+/** Public API for the playable currently running in the browser. */
+interface Playable {
+  /** Initializes the selected host and loads the primary asset bundle once. */
+  ready(): Promise<void>;
+  /** Resolved configuration for the active playable variant. */
+  readonly config: RuntimeConfig;
+  /** Latest normalized lifecycle state, available after `ready()` resolves. */
+  readonly state: RuntimeState;
+  /** Screen-sized element into which the playable mounts its content. */
+  readonly container: HTMLElement;
+  /** Current engine-neutral layout derived from runtime screen state. */
+  readonly screen: Screen;
+  /** Loads generated asset bundles and retains their runtime values. */
+  readonly loader: AssetLoader;
+  /** Resolves phrases from the translation dictionary loaded through `loader`. */
+  readonly localization: Localization;
+  /** Plays sounds through Replayable's capability-aware audio facade. */
+  readonly audio: PlayableAudio;
+  /** Creates application-owned timers synchronized with visible runtime time. */
+  readonly timers: PlayableTimers;
+  /** Delivers one variable update for every rendered browser frame. */
+  readonly update: UpdateChannel<UpdateContext>;
+  /** Delivers fixed simulation steps at 60 updates per second. */
+  readonly fixedUpdate: UpdateChannel<FixedUpdateContext>;
+  /**
+   * Runs after Motion's update and render phases, with one shared frame timestamp.
+   * Follows readiness and visibility; listeners keep the runtime frame loop active.
+   * This observes JavaScript rendering submissions, not GPU completion or browser paint.
+   *
+   * @example
+   * const remove = playable.postRender.add(({ timestamp }) => {
+   *   // Read rendering diagnostics after Pixi/Three have submitted their draws.
+   *   console.log(timestamp);
+   * });
+   * remove();
+   */
+  readonly postRender: UpdateChannel<PostRenderContext>;
+  /**
+   * Subscribes to one lifecycle event.
+   *
+   * @returns A function that removes this listener.
+   */
+  on<Event extends keyof RuntimeEventMap>(event: Event, listener: RuntimeEventListener<Event>): () => void;
+  /** Commits the playable's terminal outcome exactly once. */
+  complete(reason: PlayableCompletionReason): void;
+  /** Opens the resolved app-store destination through the active host. */
+  openStore(): void;
+}
+//#endregion
+//#region src/playable.d.ts
+/** Public facade for the playable currently running in the browser. */
+declare const playable: Playable;
+//#endregion
+export { type AssetBundleLoadedListener, type AssetCache, type AssetLoadContext, type AssetLoadHandler, type AssetLoadedContext, type AssetLoadedListener, type AssetLoader, type AudioOneShotOptions, type AudioPlayback, type AudioPlaybackOptions, type AudioStopOptions, type BuiltInAssetCategory, type BuiltInAssetValueByCategory, type EndCardAnimation, type EndCardInteraction, type FixedUpdateContext, type InactivityTimer, type InactivityTimerOptions, type LoadedShaderAsset, type Localization, type Playable, type PlayableAudio, type PlayableCompletion, type PlayableCompletionReason, type PlayableTimers, type PostRenderContext, type RegisteredAssetCategory, type RuntimeAudioState, type RuntimeCompletionConfig, type RuntimeConfig, type RuntimeControlsConfig, type RuntimeDefinition, type RuntimeDevtoolsConfig, type RuntimeEndCardConfig, type RuntimeEventListener, type RuntimeEventMap, type RuntimeLocalizationConfig, type RuntimeNetwork, type RuntimeOrientation, type RuntimeOrientationConfig, type RuntimeParamValue, type RuntimeRange, type RuntimeRenderScaleConfig, type RuntimeResolutionConfig, type RuntimeScreenConfig, type RuntimeState, type RuntimeStatsConfig, type RuntimeStoreConfig, type RuntimeViewport, type Screen, type ScreenDesign, type ScreenFrame, type UpdateChannel, type UpdateContext, playable };
+//# sourceMappingURL=index.d.ts.map