@replayablejs/config 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Replayable contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# @replayablejs/config
+
+Validate project settings and expand versions, networks and languages into playable variants.
+
+Part of [Replayable](https://github.com/replayablejs/replayable) **0.1.0-alpha.0**.
+APIs may change during the alpha series.
+
+## Install
+
+```sh
+pnpm add -D @replayablejs/config@0.1.0-alpha.0
+```
+
+## Public surface
+
+`defineConfig`, `replayableConfigSchema`, `replayableAssetsSchema`, `createVariants`; configuration input/output and `PlayableVariant` types.
+
+[Usage and reference](https://github.com/replayablejs/replayable/blob/main/docs/reference/config.md).
+The package manifest defines supported import paths; internal source files are not public APIs.
+
+## Development
+
+From the repository root, install with `pnpm install --frozen-lockfile` and build dependencies
+with `pnpm build`. Run `pnpm --filter @replayablejs/config test` for this package's tests.
+
+## License
+
+Original code is [MIT licensed](https://github.com/replayablejs/replayable/blob/main/LICENSE). Bundled third-party resources retain
+their accompanying license terms.

package/dist/index.d.mts

@@ -0,0 +1,608 @@
+import { z } from "zod";
+import { AssetConfig } from "@replayablejs/assets";
+//#region src/config/schemas/assets.d.ts
+/**
+ * Language-independent asset configuration authored as part of a project config.
+ *
+ * Replayable derives this contract from the assets package instead of
+ * maintaining a second copy. Variant expansion adds each playable's fixed
+ * language before producing the complete asset configuration.
+ */
+declare const replayableAssetsSchema: z.ZodObject<{
+  sourceDir: z.ZodString;
+  outDir: z.ZodString;
+  bundles: z.ZodPrefault<z.ZodObject<{
+    secondary: z.ZodOptional<z.ZodObject<{
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      include: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
+  assets: z.ZodObject<{
+    atlases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      match: z.ZodDefault<z.ZodString>;
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      options: z.ZodPrefault<z.ZodUnion<readonly [z.ZodObject<{
+        scale: z.ZodDefault<z.ZodNumber>;
+        lossless: z.ZodDefault<z.ZodLiteral<false>>;
+        quality: z.ZodOptional<z.ZodNumber>;
+        allowTrim: z.ZodDefault<z.ZodBoolean>;
+        allowRotation: z.ZodDefault<z.ZodBoolean>;
+        padding: z.ZodDefault<z.ZodNumber>;
+        extrude: z.ZodDefault<z.ZodNumber>;
+        powerOfTwo: z.ZodDefault<z.ZodBoolean>;
+      }, z.core.$strict>, z.ZodObject<{
+        scale: z.ZodDefault<z.ZodNumber>;
+        lossless: z.ZodLiteral<true>;
+        allowTrim: z.ZodDefault<z.ZodBoolean>;
+        allowRotation: z.ZodDefault<z.ZodBoolean>;
+        padding: z.ZodDefault<z.ZodNumber>;
+        extrude: z.ZodDefault<z.ZodNumber>;
+        powerOfTwo: z.ZodDefault<z.ZodBoolean>;
+      }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    fonts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      match: z.ZodDefault<z.ZodString>;
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      options: z.ZodObject<{
+        family: z.ZodString;
+        extraCharacters: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    locales: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      match: z.ZodDefault<z.ZodString>;
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    shaders: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      match: z.ZodDefault<z.ZodString>;
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    sounds: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      match: z.ZodDefault<z.ZodString>;
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      options: z.ZodPrefault<z.ZodObject<{
+        bitrate: z.ZodDefault<z.ZodNumber>;
+        channels: z.ZodDefault<z.ZodEnum<{
+          mono: "mono";
+          source: "source";
+          stereo: "stereo";
+        }>>;
+        sampleRate: z.ZodDefault<z.ZodNumber>;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    spines: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      match: z.ZodDefault<z.ZodString>;
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      options: z.ZodPrefault<z.ZodUnion<readonly [z.ZodObject<{
+        scale: z.ZodDefault<z.ZodNumber>;
+        lossless: z.ZodDefault<z.ZodLiteral<false>>;
+        quality: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strict>, z.ZodObject<{
+        scale: z.ZodDefault<z.ZodNumber>;
+        lossless: z.ZodLiteral<true>;
+      }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    sprites: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      match: z.ZodDefault<z.ZodString>;
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      options: z.ZodPrefault<z.ZodUnion<readonly [z.ZodObject<{
+        scale: z.ZodDefault<z.ZodNumber>;
+        lossless: z.ZodDefault<z.ZodLiteral<false>>;
+        quality: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strict>, z.ZodObject<{
+        scale: z.ZodDefault<z.ZodNumber>;
+        lossless: z.ZodLiteral<true>;
+      }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    textures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      match: z.ZodDefault<z.ZodString>;
+      exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      options: z.ZodPrefault<z.ZodUnion<readonly [z.ZodObject<{
+        scale: z.ZodDefault<z.ZodNumber>;
+        lossless: z.ZodDefault<z.ZodLiteral<false>>;
+        quality: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strict>, z.ZodObject<{
+        scale: z.ZodDefault<z.ZodNumber>;
+        lossless: z.ZodLiteral<true>;
+      }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>;
+  exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  emit: z.ZodObject<{
+    assets: z.ZodDefault<z.ZodString>;
+    registries: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+//#endregion
+//#region src/config/schema.d.ts
+/**
+ * Runtime schema for the human-authored `replayable.config.ts` contract.
+ *
+ * Parsing trims meaningful strings; applies the default audio capability,
+ * background color, entry, version, and preview network; and rejects unknown
+ * fields.
+ */
+declare const replayableConfigSchema: z.ZodObject<{
+  assets: z.ZodObject<{
+    sourceDir: z.ZodString;
+    outDir: z.ZodString;
+    bundles: z.ZodPrefault<z.ZodObject<{
+      secondary: z.ZodOptional<z.ZodObject<{
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        include: z.ZodArray<z.ZodString>;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    assets: z.ZodObject<{
+      atlases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        match: z.ZodDefault<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        options: z.ZodPrefault<z.ZodUnion<readonly [z.ZodObject<{
+          scale: z.ZodDefault<z.ZodNumber>;
+          lossless: z.ZodDefault<z.ZodLiteral<false>>;
+          quality: z.ZodOptional<z.ZodNumber>;
+          allowTrim: z.ZodDefault<z.ZodBoolean>;
+          allowRotation: z.ZodDefault<z.ZodBoolean>;
+          padding: z.ZodDefault<z.ZodNumber>;
+          extrude: z.ZodDefault<z.ZodNumber>;
+          powerOfTwo: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+          scale: z.ZodDefault<z.ZodNumber>;
+          lossless: z.ZodLiteral<true>;
+          allowTrim: z.ZodDefault<z.ZodBoolean>;
+          allowRotation: z.ZodDefault<z.ZodBoolean>;
+          padding: z.ZodDefault<z.ZodNumber>;
+          extrude: z.ZodDefault<z.ZodNumber>;
+          powerOfTwo: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>]>>;
+      }, z.core.$strict>>>;
+      fonts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        match: z.ZodDefault<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        options: z.ZodObject<{
+          family: z.ZodString;
+          extraCharacters: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+      }, z.core.$strict>>>;
+      locales: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        match: z.ZodDefault<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      }, z.core.$strict>>>;
+      shaders: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        match: z.ZodDefault<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      }, z.core.$strict>>>;
+      sounds: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        match: z.ZodDefault<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        options: z.ZodPrefault<z.ZodObject<{
+          bitrate: z.ZodDefault<z.ZodNumber>;
+          channels: z.ZodDefault<z.ZodEnum<{
+            mono: "mono";
+            source: "source";
+            stereo: "stereo";
+          }>>;
+          sampleRate: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+      }, z.core.$strict>>>;
+      spines: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        match: z.ZodDefault<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        options: z.ZodPrefault<z.ZodUnion<readonly [z.ZodObject<{
+          scale: z.ZodDefault<z.ZodNumber>;
+          lossless: z.ZodDefault<z.ZodLiteral<false>>;
+          quality: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+          scale: z.ZodDefault<z.ZodNumber>;
+          lossless: z.ZodLiteral<true>;
+        }, z.core.$strict>]>>;
+      }, z.core.$strict>>>;
+      sprites: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        match: z.ZodDefault<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        options: z.ZodPrefault<z.ZodUnion<readonly [z.ZodObject<{
+          scale: z.ZodDefault<z.ZodNumber>;
+          lossless: z.ZodDefault<z.ZodLiteral<false>>;
+          quality: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+          scale: z.ZodDefault<z.ZodNumber>;
+          lossless: z.ZodLiteral<true>;
+        }, z.core.$strict>]>>;
+      }, z.core.$strict>>>;
+      textures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        match: z.ZodDefault<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        options: z.ZodPrefault<z.ZodUnion<readonly [z.ZodObject<{
+          scale: z.ZodDefault<z.ZodNumber>;
+          lossless: z.ZodDefault<z.ZodLiteral<false>>;
+          quality: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+          scale: z.ZodDefault<z.ZodNumber>;
+          lossless: z.ZodLiteral<true>;
+        }, z.core.$strict>]>>;
+      }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    emit: z.ZodObject<{
+      assets: z.ZodDefault<z.ZodString>;
+      registries: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+  }, z.core.$strict>;
+  audio: z.ZodDefault<z.ZodBoolean>;
+  backgroundColor: z.ZodDefault<z.ZodString>;
+  build: z.ZodPrefault<z.ZodObject<{
+    outDir: z.ZodDefault<z.ZodString>;
+  }, z.core.$strict>>;
+  completion: z.ZodDefault<z.ZodObject<{
+    duration: z.ZodOptional<z.ZodNumber>;
+    inactivity: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+  controls: z.ZodPrefault<z.ZodObject<{
+    persistentCta: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  devtools: z.ZodPrefault<z.ZodObject<{
+    stats: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+      display: z.ZodDefault<z.ZodEnum<{
+        compact: "compact";
+        expanded: "expanded";
+      }>>;
+      fps: z.ZodDefault<z.ZodBoolean>;
+      frameInterval: z.ZodDefault<z.ZodBoolean>;
+      jsHeap: z.ZodDefault<z.ZodBoolean>;
+      drawCalls: z.ZodDefault<z.ZodBoolean>;
+      textureBinds: z.ZodDefault<z.ZodBoolean>;
+      programUses: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>]>>, z.ZodTransform<false | {
+      display: "compact" | "expanded";
+      fps: boolean;
+      frameInterval: boolean;
+      jsHeap: boolean;
+      drawCalls: boolean;
+      textureBinds: boolean;
+      programUses: boolean;
+    }, boolean | {
+      display: "compact" | "expanded";
+      fps: boolean;
+      frameInterval: boolean;
+      jsHeap: boolean;
+      drawCalls: boolean;
+      textureBinds: boolean;
+      programUses: boolean;
+    }>>;
+    endCardTrigger: z.ZodDefault<z.ZodBoolean>;
+    soundControl: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  entry: z.ZodDefault<z.ZodString>;
+  localization: z.ZodObject<{
+    languages: z.ZodArray<z.ZodString>;
+    fallback: z.ZodString;
+  }, z.core.$strict>;
+  name: z.ZodString;
+  networks: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
+    applovin: "applovin";
+    google: "google";
+    liftoff: "liftoff";
+    meta: "meta";
+    mintegral: "mintegral";
+    moloco: "moloco";
+    preview: "preview";
+    unity: "unity";
+  }> & z.core.$partial, z.ZodObject<{
+    assets: z.ZodOptional<z.ZodObject<{
+      exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    audio: z.ZodOptional<z.ZodLiteral<false>>;
+    completion: z.ZodOptional<z.ZodObject<{
+      duration: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
+      inactivity: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
+    }, z.core.$strict>>;
+    params: z.ZodOptional<z.ZodType<Record<string, string | number | boolean>, Record<string, string | number | boolean>, z.core.$ZodTypeInternals<Record<string, string | number | boolean>, Record<string, string | number | boolean>>>>;
+  }, z.core.$strict>>>;
+  params: z.ZodDefault<z.ZodType<Record<string, {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "boolean";
+    default: boolean;
+  } | {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "number";
+    default: number;
+    range: {
+      min: number;
+      max: number;
+      step: number;
+    };
+  } | {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "string";
+    default: string;
+    options: string[];
+  }>, Record<string, {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "boolean";
+    default: boolean;
+  } | {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "number";
+    default: number;
+    range: {
+      min: number;
+      max: number;
+      step: number;
+    };
+  } | {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "string";
+    default: string;
+    options: string[];
+  }>, z.core.$ZodTypeInternals<Record<string, {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "boolean";
+    default: boolean;
+  } | {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "number";
+    default: number;
+    range: {
+      min: number;
+      max: number;
+      step: number;
+    };
+  } | {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "string";
+    default: string;
+    options: string[];
+  }>, Record<string, {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "boolean";
+    default: boolean;
+  } | {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "number";
+    default: number;
+    range: {
+      min: number;
+      max: number;
+      step: number;
+    };
+  } | {
+    description: string;
+    when?: {
+      param: string;
+      equals: string | number | boolean;
+    } | undefined;
+    type: "string";
+    default: string;
+    options: string[];
+  }>>>>;
+  screen: z.ZodObject<{
+    orientations: z.ZodObject<{
+      portrait: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        ratio: z.ZodObject<{
+          min: z.ZodNumber;
+          max: z.ZodNumber;
+        }, z.core.$strict>;
+      }, z.core.$strict>;
+      landscape: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        ratio: z.ZodObject<{
+          min: z.ZodNumber;
+          max: z.ZodNumber;
+        }, z.core.$strict>;
+      }, z.core.$strict>;
+    }, z.core.$strict>;
+    resolution: z.ZodObject<{
+      pixelRatio: z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+      }, z.core.$strict>;
+      renderScale: z.ZodObject<{
+        minimal: z.ZodNumber;
+        reduced: z.ZodNumber;
+        balanced: z.ZodNumber;
+        full: z.ZodNumber;
+      }, z.core.$strict>;
+    }, z.core.$strict>;
+  }, z.core.$strict>;
+  store: z.ZodObject<{
+    androidUrl: z.ZodPipe<z.ZodString, z.ZodURL>;
+    iosUrl: z.ZodPipe<z.ZodString, z.ZodURL>;
+  }, z.core.$strict>;
+  versions: z.ZodDefault<z.ZodType<Record<string, {
+    assets?: {
+      exclude: string[];
+    } | undefined;
+    audio?: false | undefined;
+    completion?: {
+      duration?: number | false | undefined;
+      inactivity?: number | false | undefined;
+    } | undefined;
+    params?: Record<string, string | number | boolean> | undefined;
+  }>, Record<string, {
+    assets?: {
+      exclude?: string[] | undefined;
+    } | undefined;
+    audio?: false | undefined;
+    completion?: {
+      duration?: number | false | undefined;
+      inactivity?: number | false | undefined;
+    } | undefined;
+    params?: Record<string, string | number | boolean> | undefined;
+  }>, z.core.$ZodTypeInternals<Record<string, {
+    assets?: {
+      exclude: string[];
+    } | undefined;
+    audio?: false | undefined;
+    completion?: {
+      duration?: number | false | undefined;
+      inactivity?: number | false | undefined;
+    } | undefined;
+    params?: Record<string, string | number | boolean> | undefined;
+  }>, Record<string, {
+    assets?: {
+      exclude?: string[] | undefined;
+    } | undefined;
+    audio?: false | undefined;
+    completion?: {
+      duration?: number | false | undefined;
+      inactivity?: number | false | undefined;
+    } | undefined;
+    params?: Record<string, string | number | boolean> | undefined;
+  }>>>>;
+}, z.core.$strict>;
+//#endregion
+//#region src/config/schemas/variants.d.ts
+/** Delivery networks whose behavior is implemented internally by Replayable. */
+declare const networkSchema: z.ZodEnum<{
+  applovin: "applovin";
+  google: "google";
+  liftoff: "liftoff";
+  meta: "meta";
+  mintegral: "mintegral";
+  moloco: "moloco";
+  preview: "preview";
+  unity: "unity";
+}>;
+//#endregion
+//#region src/types/config.d.ts
+/** Validated Replayable project configuration with every schema default applied. */
+type ReplayableConfig = z.infer<typeof replayableConfigSchema>;
+/** Human-authored Replayable project configuration accepted before defaults are applied. */
+type ReplayableConfigInput = z.input<typeof replayableConfigSchema>;
+/** Validated language-independent asset configuration stored in the project config. */
+type ReplayableAssetsConfig = z.infer<typeof replayableAssetsSchema>;
+/** Language-independent asset configuration accepted from project authors. */
+type ReplayableAssetsConfigInput = z.input<typeof replayableAssetsSchema>;
+/** Validated project-wide build configuration. */
+type ReplayableBuild = ReplayableConfig['build'];
+/** Project-wide build configuration accepted before defaults are applied. */
+type ReplayableBuildInput = ReplayableConfigInput['build'];
+/** Validated automatic playable completion conditions. */
+type ReplayableCompletion = ReplayableConfig['completion'];
+/** Automatic completion conditions accepted before defaults are applied. */
+type ReplayableCompletionInput = ReplayableConfigInput['completion'];
+/** Preview control preferences; ad-network profiles own the final visibility. */
+type ReplayableControls = ReplayableConfig['controls'];
+/** Optional preview controls accepted before defaults are applied. */
+type ReplayableControlsInput = ReplayableConfigInput['controls'];
+/** Validated project-wide development tool settings. */
+type ReplayableDevtools = ReplayableConfig['devtools'];
+/** Development tool shorthand accepted before defaults are applied. */
+type ReplayableDevtoolsInput = ReplayableConfigInput['devtools'];
+/** Validated build languages and missing-translation fallback. */
+type ReplayableLocalization = ReplayableConfig['localization'];
+/** Localization configuration accepted in a human-authored Replayable config. */
+type ReplayableLocalizationInput = ReplayableConfigInput['localization'];
+/** Delivery network with an implementation owned by Replayable. */
+type ReplayableNetwork = z.infer<typeof networkSchema>;
+/** One validated boolean, number, or string parameter definition. */
+type ReplayableParamDefinition = ReplayableConfig['params'][string];
+/** Primitive value accepted by a concrete parameter. */
+type ReplayableParamValue = ReplayableParamDefinition['default'];
+/** Parameter definitions accepted in a human-authored Replayable config. */
+type ReplayableParamsInput = ReplayableConfigInput['params'];
+/** Validated rendering dimensions and resolution policy. */
+type ReplayableScreen = ReplayableConfig['screen'];
+/** Screen configuration accepted in a human-authored Replayable config. */
+type ReplayableScreenInput = ReplayableConfigInput['screen'];
+/** Validated iOS and Android destinations for the playable's call to action. */
+type ReplayableStore = ReplayableConfig['store'];
+/** Store destinations accepted in a human-authored Replayable config. */
+type ReplayableStoreInput = ReplayableConfigInput['store'];
+//#endregion
+//#region src/config/define-config.d.ts
+/**
+ * Validates an authored Replayable project configuration and applies defaults.
+ *
+ * @param input - Human-authored Replayable configuration.
+ * @returns The validated and normalized project configuration.
+ * @throws When a field is missing, unknown, or invalid.
+ */
+declare function defineConfig(input: ReplayableConfigInput): ReplayableConfig;
+//#endregion
+//#region src/types/variant.d.ts
+/** One concrete version, network, and language combination. */
+interface PlayableVariant {
+  readonly assets: AssetConfig;
+  readonly audio: boolean;
+  readonly backgroundColor: string;
+  readonly completion: Readonly<ReplayableConfig['completion']>;
+  /** Preview preferences; ad-network profiles replace these during build resolution. */
+  readonly controls: Readonly<ReplayableConfig['controls']>;
+  readonly devtools: Readonly<ReplayableConfig['devtools']>;
+  readonly entry: string;
+  readonly id: string;
+  readonly localization: {
+    readonly language: string;
+    readonly fallback: string;
+  };
+  readonly network: ReplayableNetwork;
+  readonly params: Readonly<Record<string, ReplayableParamValue>>;
+  readonly projectName: string;
+  readonly screen: Readonly<ReplayableConfig['screen']>;
+  readonly store: Readonly<ReplayableConfig['store']>;
+  readonly version: string;
+}
+//#endregion
+//#region src/variants/create-variants.d.ts
+/**
+ * Expands one project configuration into every version/network/language combination.
+ *
+ * Every returned variant contains resolved values. Base parameters are extended
+ * by network parameters and then version parameters, making the version the
+ * most specific override. Asset exclusions follow the same precedence.
+ *
+ * @param config - Validated Replayable project configuration.
+ * @returns The ordered concrete playable variants.
+ */
+declare function createVariants(config: ReplayableConfig): PlayableVariant[];
+//#endregion
+export { type PlayableVariant, type ReplayableAssetsConfig, type ReplayableAssetsConfigInput, type ReplayableBuild, type ReplayableBuildInput, type ReplayableCompletion, type ReplayableCompletionInput, type ReplayableConfig, type ReplayableConfigInput, type ReplayableControls, type ReplayableControlsInput, type ReplayableDevtools, type ReplayableDevtoolsInput, type ReplayableLocalization, type ReplayableLocalizationInput, type ReplayableNetwork, type ReplayableParamDefinition, type ReplayableParamValue, type ReplayableParamsInput, type ReplayableScreen, type ReplayableScreenInput, type ReplayableStore, type ReplayableStoreInput, createVariants, defineConfig, replayableAssetsSchema, replayableConfigSchema };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,485 @@
+import { z } from "zod";
+import { assetConfigSchema } from "@replayablejs/assets";
+//#region src/config/schemas/base.ts
+/** Non-empty authored text normalized by trimming surrounding whitespace. */
+const requiredStringSchema = z.string().trim().min(1);
+/** Stable lowercase name accepted for a project-defined version. */
+const dimensionNameSchema = requiredStringSchema.regex(/^[a-z][a-z0-9_-]*$/, "Target names must begin with a lowercase letter and contain only lowercase letters, numbers, underscores, and hyphens.");
+/** Finite numeric value greater than zero. */
+const positiveNumberSchema = z.number().positive();
+//#endregion
+//#region src/config/schemas/assets.ts
+/**
+* Language-independent asset configuration authored as part of a project config.
+*
+* Replayable derives this contract from the assets package instead of
+* maintaining a second copy. Variant expansion adds each playable's fixed
+* language before producing the complete asset configuration.
+*/
+const replayableAssetsSchema = assetConfigSchema.omit({ localization: true });
+/** Asset changes that may be applied by one version or network. */
+const assetOverrideSchema = z.strictObject({ exclude: z.array(requiredStringSchema).default([]) });
+//#endregion
+//#region src/config/schemas/audio.ts
+/** Whether generated playable variants include runtime audio capability. */
+const audioSchema = z.boolean().default(true);
+/** Allows a variant dimension to disable—but never re-enable—project audio. */
+const audioOverrideSchema = z.literal(false);
+/** First-paint color shown behind the playable before and after content mounts. */
+const backgroundColorSchema = z.string().regex(/^#(?:[\da-f]{3}|[\da-f]{6})$/i, "Background color must be an opaque three- or six-digit hexadecimal CSS color.").default("#000000");
+//#endregion
+//#region src/config/schemas/build.ts
+/** Project-wide destinations used when producing playable output. */
+const buildSchema = z.strictObject({ outDir: requiredStringSchema.default("dist") }).prefault({});
+//#endregion
+//#region src/config/schemas/completion.ts
+/** Positive duration in seconds used by a playable completion timer. */
+const completionDurationSchema = z.number().positive();
+/** Automatic conditions that may complete a playable. */
+const completionSchema = z.strictObject({
+	/** Maximum playable duration in seconds. */
+	duration: completionDurationSchema.optional(),
+	/** Allowed inactivity in seconds after the first interaction. */
+	inactivity: completionDurationSchema.optional()
+}).default({});
+/** Per-variant completion values, where `false` disables an inherited timer. */
+const completionOverrideSchema = z.strictObject({
+	duration: completionDurationSchema.or(z.literal(false)).optional(),
+	inactivity: completionDurationSchema.or(z.literal(false)).optional()
+});
+//#endregion
+//#region src/config/schemas/controls.ts
+/**
+* Authored control visibility for local development and exported preview.
+* Ad-network profiles replace these preferences with their delivery policy.
+*/
+const controlsSchema = z.strictObject({ 
+/** Shows the persistent CTA in preview; ad networks own their final policy. */
+persistentCta: z.boolean().default(true) }).prefault({});
+//#endregion
+//#region src/config/schemas/stats.ts
+/** Enabled stats request every metric in expanded mode unless explicitly configured. */
+const statsOptionsSchema = z.strictObject({
+	display: z.enum(["expanded", "compact"]).default("expanded"),
+	fps: z.boolean().default(true),
+	frameInterval: z.boolean().default(true),
+	jsHeap: z.boolean().default(true),
+	/** Submitted draw operations, not rendered objects, triangles, or instances. */
+	drawCalls: z.boolean().default(true),
+	/** Calls to bindTexture, not the number of allocated or unique textures. */
+	textureBinds: z.boolean().default(true),
+	/** Calls to useProgram, not the number of allocated or unique programs. */
+	programUses: z.boolean().default(true)
+});
+/** Resolves the shorthand once into disabled stats or explicit display and panel settings. */
+const statsSchema = z.union([z.boolean(), statsOptionsSchema]).default(false).transform((stats) => stats === true ? statsOptionsSchema.parse({}) : stats);
+//#endregion
+//#region src/config/schemas/devtools.ts
+/** Project-wide development tools; omitted tools remain disabled. */
+const devtoolsSchema = z.strictObject({
+	stats: statsSchema,
+	/** Development-only Escape shortcut and DOM Skip button; never included in exports. */
+	endCardTrigger: z.boolean().default(false),
+	/** Development-only audio toggle; omitted from every production build, including preview. */
+	soundControl: z.boolean().default(false)
+}).prefault({});
+//#endregion
+//#region src/config/schemas/localization.ts
+const languageSchema = requiredStringSchema.refine(isLanguageTag, {
+	message: "Language must be a valid BCP 47 tag.",
+	abort: true
+});
+/** Languages expanded into fixed-language variants and their missing-value fallback. */
+const localizationSchema = z.strictObject({
+	languages: z.array(languageSchema).min(1),
+	fallback: languageSchema
+}).superRefine(({ fallback, languages }, context) => {
+	if (Intl.getCanonicalLocales(languages).length !== languages.length) context.addIssue({
+		code: "custom",
+		message: "Localization languages must be unique after BCP 47 canonicalization.",
+		path: ["languages"]
+	});
+	if (!languages.includes(fallback)) context.addIssue({
+		code: "custom",
+		message: "The fallback language must also appear in localization.languages.",
+		path: ["fallback"]
+	});
+});
+/** Uses the runtime's Unicode locale data instead of maintaining a fixed language list. */
+function isLanguageTag(language) {
+	try {
+		Intl.getCanonicalLocales(language);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/config/validation/params.ts
+/** Validates catalog values and conditions after schema parsing. */
+function validateParamDefinitions(params, context) {
+	for (const [name, definition] of Object.entries(params)) validateParamDefinition(name, definition, params, context);
+}
+/** Validates constraints and dependency references within the parameter catalog. */
+function validateParamDefinition(name, definition, params, context) {
+	switch (definition.type) {
+		case "boolean": break;
+		case "number":
+			validateNumberParam(name, definition, context);
+			break;
+		case "string": validateStringParam(name, definition, context);
+	}
+	validateParamCondition(name, definition, params, context);
+}
+/** Validates one number parameter's range and default value. */
+function validateNumberParam(name, definition, context) {
+	const { max, min } = definition.range;
+	if (min > max) addParamIssue(context, name, ["range"], "The minimum cannot exceed the maximum.");
+	else if (!isStepAligned(max, definition.range)) addParamIssue(context, name, ["range", "step"], "The maximum must be reachable from the minimum using the configured step.");
+	else if (definition.default < min || definition.default > max) addParamIssue(context, name, ["default"], "The default must be within its configured range.");
+	else if (!isStepAligned(definition.default, definition.range)) addParamIssue(context, name, ["default"], "The default must align with the configured range step.");
+}
+/** Validates one string parameter's options and default value. */
+function validateStringParam(name, definition, context) {
+	if (new Set(definition.options).size !== definition.options.length) addParamIssue(context, name, ["options"], "Parameter options must be unique.");
+	if (!definition.options.includes(definition.default)) addParamIssue(context, name, ["default"], "The default must appear in its configured options.");
+}
+/** Validates one parameter's optional condition against the complete catalog. */
+function validateParamCondition(name, definition, params, context) {
+	const condition = definition.when;
+	if (condition === void 0) return;
+	const referencedParam = params[condition.param];
+	if (referencedParam === void 0) {
+		addParamIssue(context, name, ["when", "param"], "The condition references a parameter that does not exist.");
+		return;
+	}
+	if (condition.param === name) addParamIssue(context, name, ["when", "param"], "A parameter cannot condition itself.");
+	if (!isAllowedParamValue(referencedParam, condition.equals)) addParamIssue(context, name, ["when", "equals"], "The condition value must be allowed by the referenced parameter.");
+}
+/** Ensures every dimension override names an existing parameter and supplies an allowed value. */
+function validateParamOverrides(groupName, overrides, params, context) {
+	for (const [dimensionName, dimensionOverride] of Object.entries(overrides)) for (const [paramName, value] of Object.entries(dimensionOverride.params ?? {})) {
+		const definition = params[paramName];
+		if (definition === void 0) {
+			context.addIssue({
+				code: "custom",
+				message: "The overridden parameter does not exist.",
+				path: [
+					groupName,
+					dimensionName,
+					"params",
+					paramName
+				]
+			});
+			continue;
+		}
+		if (!isAllowedParamValue(definition, value)) context.addIssue({
+			code: "custom",
+			message: "The override does not satisfy the parameter definition.",
+			path: [
+				groupName,
+				dimensionName,
+				"params",
+				paramName
+			]
+		});
+	}
+}
+/** Checks an override against the parameter's finite set of allowed values. */
+function isAllowedParamValue(definition, value) {
+	let allowed;
+	switch (definition.type) {
+		case "boolean":
+			allowed = typeof value === "boolean";
+			break;
+		case "number":
+			allowed = typeof value === "number" && isAllowedNumberValue(value, definition.range);
+			break;
+		case "string": allowed = typeof value === "string" && definition.options.includes(value);
+	}
+	return allowed;
+}
+/** Checks both numeric bounds and membership in the range's discrete step sequence. */
+function isAllowedNumberValue(value, range) {
+	return value >= range.min && value <= range.max && isStepAligned(value, range);
+}
+/** Tolerates the small rounding error produced by fractional JavaScript arithmetic. */
+function isStepAligned(value, range) {
+	const stepsFromMinimum = (value - range.min) / range.step;
+	return Math.abs(stepsFromMinimum - Math.round(stepsFromMinimum)) < 1e-9;
+}
+/** Adds one issue at a parameter-relative path. */
+function addParamIssue(context, name, path, message) {
+	context.addIssue({
+		code: "custom",
+		message,
+		path: [name, ...path]
+	});
+}
+//#endregion
+//#region src/config/schemas/record.ts
+/** Checks authored keys before a record schema trims them and could overwrite a value. */
+function withUniqueTrimmedKeys(schema) {
+	return z.transform((input, context) => {
+		if (typeof input !== "object" || input === null || Array.isArray(input)) return input;
+		const keys = /* @__PURE__ */ new Set();
+		for (const key of Object.keys(input)) {
+			const normalized = key.trim();
+			if (keys.has(normalized)) context.addIssue({
+				code: "custom",
+				message: "Names must be unique after trimming whitespace.",
+				path: [key]
+			});
+			keys.add(normalized);
+		}
+		return input;
+	}).pipe(schema);
+}
+//#endregion
+//#region src/config/schemas/params.ts
+const paramValueSchema = z.union([
+	z.boolean(),
+	z.number(),
+	requiredStringSchema
+]);
+/** Another parameter value that controls when a parameter is relevant. */
+const paramConditionSchema = z.strictObject({
+	param: requiredStringSchema,
+	equals: paramValueSchema
+});
+const paramDescriptionField = { description: requiredStringSchema };
+const paramConditionField = { when: paramConditionSchema.optional() };
+const numberRangeSchema = z.strictObject({
+	min: z.number(),
+	max: z.number(),
+	step: z.number().positive()
+});
+/** Boolean, number, and string parameters exposed to builds and development tools. */
+const paramDefinitionSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("boolean"),
+		default: z.boolean(),
+		...paramDescriptionField,
+		...paramConditionField
+	}),
+	z.strictObject({
+		type: z.literal("number"),
+		default: z.number(),
+		...paramDescriptionField,
+		range: numberRangeSchema,
+		...paramConditionField
+	}),
+	z.strictObject({
+		type: z.literal("string"),
+		default: requiredStringSchema,
+		...paramDescriptionField,
+		options: z.array(requiredStringSchema).min(1),
+		...paramConditionField
+	})
+]);
+const paramsSchema = withUniqueTrimmedKeys(z.record(requiredStringSchema, paramDefinitionSchema)).superRefine(validateParamDefinitions).default({});
+const paramOverridesSchema = withUniqueTrimmedKeys(z.record(requiredStringSchema, paramValueSchema));
+//#endregion
+//#region src/config/schemas/screen.ts
+/** Inclusive numeric bounds whose lower value cannot exceed the upper value. */
+const rangeSchema = z.strictObject({
+	min: positiveNumberSchema,
+	max: positiveNumberSchema
+}).refine(({ max, min }) => min <= max, "The minimum cannot exceed the maximum.");
+/** One orientation's authored coordinate system and availability. */
+const orientationSchema = z.strictObject({
+	enabled: z.boolean(),
+	width: z.number().int().positive(),
+	height: z.number().int().positive(),
+	ratio: rangeSchema
+});
+/** Ordered renderer-quality multipliers from the lowest to the highest policy. */
+const renderScaleSchema = z.strictObject({
+	minimal: positiveNumberSchema.max(1),
+	reduced: positiveNumberSchema.max(1),
+	balanced: positiveNumberSchema.max(1),
+	full: positiveNumberSchema.max(1)
+}).refine(({ balanced, full, minimal, reduced }) => minimal <= reduced && reduced <= balanced && balanced <= full, "Render scales must be ordered: minimal <= reduced <= balanced <= full.");
+/** Device-pixel bounds and the render scale assigned to each quality policy. */
+const resolutionSchema = z.strictObject({
+	pixelRatio: rangeSchema,
+	renderScale: renderScaleSchema
+});
+/** Rendering dimensions, supported aspect ratios, and resolution scaling policy. */
+const screenSchema = z.strictObject({
+	orientations: z.strictObject({
+		portrait: orientationSchema,
+		landscape: orientationSchema
+	}),
+	resolution: resolutionSchema
+}).refine(({ orientations }) => orientations.landscape.enabled || orientations.portrait.enabled, "At least one screen orientation must be enabled.");
+//#endregion
+//#region src/config/schemas/store.ts
+/** Platform destinations opened when the playable's call to action is activated. */
+const storeSchema = z.strictObject({
+	androidUrl: requiredStringSchema.pipe(z.url()),
+	iosUrl: requiredStringSchema.pipe(z.url())
+});
+//#endregion
+//#region src/config/schemas/variants.ts
+/** Values that one version or network may override for its playable variants. */
+const variantOverrideSchema = z.strictObject({
+	assets: assetOverrideSchema.optional(),
+	audio: audioOverrideSchema.optional(),
+	completion: completionOverrideSchema.optional(),
+	params: paramOverridesSchema.optional()
+});
+/** Named versions normalized to the default version when omitted. */
+const versionsSchema = withUniqueTrimmedKeys(z.record(dimensionNameSchema, variantOverrideSchema)).refine((versions) => Object.keys(versions).length > 0, "At least one version is required.").default({ default: {} });
+/** Delivery networks whose behavior is implemented internally by Replayable. */
+const networkSchema = z.enum([
+	"preview",
+	"applovin",
+	"meta",
+	"google",
+	"liftoff",
+	"mintegral",
+	"moloco",
+	"unity"
+]);
+/** Selected supported networks, normalized to local preview when omitted. */
+const networksSchema = z.partialRecord(networkSchema, variantOverrideSchema).refine((networks) => Object.keys(networks).length > 0, "At least one network is required.").default({ preview: {} });
+//#endregion
+//#region src/config/schema.ts
+/**
+* Runtime schema for the human-authored `replayable.config.ts` contract.
+*
+* Parsing trims meaningful strings; applies the default audio capability,
+* background color, entry, version, and preview network; and rejects unknown
+* fields.
+*/
+const replayableConfigSchema = z.strictObject({
+	assets: replayableAssetsSchema,
+	audio: audioSchema,
+	backgroundColor: backgroundColorSchema,
+	build: buildSchema,
+	completion: completionSchema,
+	controls: controlsSchema,
+	devtools: devtoolsSchema,
+	entry: requiredStringSchema.default("src/main.ts"),
+	localization: localizationSchema,
+	name: requiredStringSchema,
+	networks: networksSchema,
+	params: paramsSchema,
+	screen: screenSchema,
+	store: storeSchema,
+	versions: versionsSchema
+}).superRefine(({ networks, params, versions }, context) => {
+	validateParamOverrides("networks", networks, params, context);
+	validateParamOverrides("versions", versions, params, context);
+});
+//#endregion
+//#region src/config/define-config.ts
+/**
+* Validates an authored Replayable project configuration and applies defaults.
+*
+* @param input - Human-authored Replayable configuration.
+* @returns The validated and normalized project configuration.
+* @throws When a field is missing, unknown, or invalid.
+*/
+function defineConfig(input) {
+	return replayableConfigSchema.parse(input);
+}
+//#endregion
+//#region src/variants/create-variants.ts
+const ALL_SOUNDS_PATTERN = "sounds/**";
+/**
+* Expands one project configuration into every version/network/language combination.
+*
+* Every returned variant contains resolved values. Base parameters are extended
+* by network parameters and then version parameters, making the version the
+* most specific override. Asset exclusions follow the same precedence.
+*
+* @param config - Validated Replayable project configuration.
+* @returns The ordered concrete playable variants.
+*/
+function createVariants(config) {
+	const variants = [];
+	for (const [version, versionOverride] of Object.entries(config.versions)) for (const network of networkSchema.options) {
+		const networkOverride = config.networks[network];
+		if (networkOverride === void 0) continue;
+		for (const language of config.localization.languages) variants.push(createPlayableVariant(config, {
+			language,
+			network,
+			networkOverride,
+			version,
+			versionOverride
+		}));
+	}
+	return variants;
+}
+/** Creates one fully concrete playable from the three configured dimensions. */
+function createPlayableVariant(config, selection) {
+	const { language, network, networkOverride, version, versionOverride } = selection;
+	const audio = resolveAudio(config.audio, networkOverride.audio, versionOverride.audio);
+	const localization = {
+		language,
+		fallback: config.localization.fallback
+	};
+	return {
+		assets: resolveAssetConfig(config.assets, localization, audio, networkOverride.assets, versionOverride.assets),
+		audio,
+		backgroundColor: config.backgroundColor,
+		completion: resolveCompletion(config.completion, networkOverride.completion, versionOverride.completion),
+		controls: config.controls,
+		devtools: config.devtools,
+		entry: config.entry,
+		id: `${version}/${network}/${language}`,
+		localization,
+		network,
+		params: resolveParams(config.params, networkOverride.params, versionOverride.params),
+		projectName: config.name,
+		screen: config.screen,
+		store: config.store,
+		version
+	};
+}
+/** Resolves each completion timer independently using project, network, then version precedence. */
+function resolveCompletion(project, network, version) {
+	const duration = resolveCompletionDuration(project.duration, network?.duration, version?.duration);
+	const inactivity = resolveCompletionDuration(project.inactivity, network?.inactivity, version?.inactivity);
+	const completion = {};
+	if (duration !== void 0) completion.duration = duration;
+	if (inactivity !== void 0) completion.inactivity = inactivity;
+	return completion;
+}
+/** Selects the most specific timer value and removes an explicit `false`. */
+function resolveCompletionDuration(project, network, version) {
+	const resolved = version ?? network ?? project;
+	return resolved === false ? void 0 : resolved;
+}
+/** Completes the shared asset configuration for one fixed-language variant. */
+function resolveAssetConfig(base, localization, audio, network, version) {
+	const exclude = [
+		...base.exclude,
+		...network?.exclude ?? [],
+		...version?.exclude ?? []
+	];
+	if (!audio && !exclude.includes(ALL_SOUNDS_PATTERN)) exclude.push(ALL_SOUNDS_PATTERN);
+	return {
+		...base,
+		localization,
+		exclude
+	};
+}
+/** Resolves audio as a capability that any configuration dimension may disable. */
+function resolveAudio(project, network, version) {
+	return project && network !== false && version !== false;
+}
+/** Extracts authored defaults, then applies network and version value overrides. */
+function resolveParams(definitions, network, version) {
+	return {
+		...Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, definition.default])),
+		...network,
+		...version
+	};
+}
+//#endregion
+export { createVariants, defineConfig, replayableAssetsSchema, replayableConfigSchema };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/config/schemas/base.ts","../src/config/schemas/assets.ts","../src/config/schemas/audio.ts","../src/config/schemas/background.ts","../src/config/schemas/build.ts","../src/config/schemas/completion.ts","../src/config/schemas/controls.ts","../src/config/schemas/stats.ts","../src/config/schemas/devtools.ts","../src/config/schemas/localization.ts","../src/config/validation/params.ts","../src/config/schemas/record.ts","../src/config/schemas/params.ts","../src/config/schemas/screen.ts","../src/config/schemas/store.ts","../src/config/schemas/variants.ts","../src/config/schema.ts","../src/config/define-config.ts","../src/variants/create-variants.ts"],"sourcesContent":["import { z } from 'zod';\n\n/** Non-empty authored text normalized by trimming surrounding whitespace. */\nexport const requiredStringSchema = z.string().trim().min(1);\n\n/** Stable lowercase name accepted for a project-defined version. */\nexport const dimensionNameSchema = requiredStringSchema.regex(\n  /^[a-z][a-z0-9_-]*$/,\n  'Target names must begin with a lowercase letter and contain only lowercase letters, numbers, underscores, and hyphens.',\n);\n\n/** Finite numeric value greater than zero. */\nexport const positiveNumberSchema = z.number().positive();\n","import { assetConfigSchema } from '@replayablejs/assets';\nimport { z } from 'zod';\n\nimport { requiredStringSchema } from './base.js';\n\n/**\n * Language-independent asset configuration authored as part of a project config.\n *\n * Replayable derives this contract from the assets package instead of\n * maintaining a second copy. Variant expansion adds each playable's fixed\n * language before producing the complete asset configuration.\n */\nexport const replayableAssetsSchema = assetConfigSchema.omit({ localization: true });\n\n/** Asset changes that may be applied by one version or network. */\nexport const assetOverrideSchema = z.strictObject({\n  exclude: z.array(requiredStringSchema).default([]),\n});\n","import { z } from 'zod';\n\n/** Whether generated playable variants include runtime audio capability. */\nexport const audioSchema = z.boolean().default(true);\n\n/** Allows a variant dimension to disable—but never re-enable—project audio. */\nexport const audioOverrideSchema = z.literal(false);\n","import { z } from 'zod';\n\nconst OPAQUE_HEX_COLOR_PATTERN = /^#(?:[\\da-f]{3}|[\\da-f]{6})$/i;\n\n/** First-paint color shown behind the playable before and after content mounts. */\nexport const backgroundColorSchema = z\n  .string()\n  .regex(\n    OPAQUE_HEX_COLOR_PATTERN,\n    'Background color must be an opaque three- or six-digit hexadecimal CSS color.',\n  )\n  .default('#000000');\n","import { z } from 'zod';\n\nimport { requiredStringSchema } from './base.js';\n\n/** Project-wide destinations used when producing playable output. */\nexport const buildSchema = z\n  .strictObject({\n    outDir: requiredStringSchema.default('dist'),\n  })\n  .prefault({});\n","import { z } from 'zod';\n\n/** Positive duration in seconds used by a playable completion timer. */\nconst completionDurationSchema = z.number().positive();\n\n/** Automatic conditions that may complete a playable. */\nexport const completionSchema = z\n  .strictObject({\n    /** Maximum playable duration in seconds. */\n    duration: completionDurationSchema.optional(),\n    /** Allowed inactivity in seconds after the first interaction. */\n    inactivity: completionDurationSchema.optional(),\n  })\n  .default({});\n\n/** Per-variant completion values, where `false` disables an inherited timer. */\nexport const completionOverrideSchema = z.strictObject({\n  duration: completionDurationSchema.or(z.literal(false)).optional(),\n  inactivity: completionDurationSchema.or(z.literal(false)).optional(),\n});\n","import { z } from 'zod';\n\n/**\n * Authored control visibility for local development and exported preview.\n * Ad-network profiles replace these preferences with their delivery policy.\n */\nexport const controlsSchema = z\n  .strictObject({\n    /** Shows the persistent CTA in preview; ad networks own their final policy. */\n    persistentCta: z.boolean().default(true),\n  })\n  .prefault({});\n","import { z } from 'zod';\n\n/** Enabled stats request every metric in expanded mode unless explicitly configured. */\nconst statsOptionsSchema = z.strictObject({\n  display: z.enum(['expanded', 'compact']).default('expanded'),\n  fps: z.boolean().default(true),\n  frameInterval: z.boolean().default(true),\n  jsHeap: z.boolean().default(true),\n  /** Submitted draw operations, not rendered objects, triangles, or instances. */\n  drawCalls: z.boolean().default(true),\n  /** Calls to bindTexture, not the number of allocated or unique textures. */\n  textureBinds: z.boolean().default(true),\n  /** Calls to useProgram, not the number of allocated or unique programs. */\n  programUses: z.boolean().default(true),\n});\n\n/** Resolves the shorthand once into disabled stats or explicit display and panel settings. */\nexport const statsSchema = z\n  .union([z.boolean(), statsOptionsSchema])\n  .default(false)\n  .transform((stats) => (stats === true ? statsOptionsSchema.parse({}) : stats));\n","import { z } from 'zod';\n\nimport { statsSchema } from './stats.js';\n\n/** Project-wide development tools; omitted tools remain disabled. */\nexport const devtoolsSchema = z\n  .strictObject({\n    stats: statsSchema,\n    /** Development-only Escape shortcut and DOM Skip button; never included in exports. */\n    endCardTrigger: z.boolean().default(false),\n    /** Development-only audio toggle; omitted from every production build, including preview. */\n    soundControl: z.boolean().default(false),\n  })\n  .prefault({});\n","import { z } from 'zod';\n\nimport { requiredStringSchema } from './base.js';\n\nconst languageSchema = requiredStringSchema.refine(isLanguageTag, {\n  message: 'Language must be a valid BCP 47 tag.',\n  // Canonical uniqueness below only runs after every tag is known to be valid.\n  abort: true,\n});\n\n/** Languages expanded into fixed-language variants and their missing-value fallback. */\nexport const localizationSchema = z\n  .strictObject({\n    languages: z.array(languageSchema).min(1),\n    fallback: languageSchema,\n  })\n  .superRefine(({ fallback, languages }, context) => {\n    // Preserve authored spelling for asset lookup, but reject equivalent language identities.\n    if (Intl.getCanonicalLocales(languages).length !== languages.length) {\n      context.addIssue({\n        code: 'custom',\n        message: 'Localization languages must be unique after BCP 47 canonicalization.',\n        path: ['languages'],\n      });\n    }\n\n    if (!languages.includes(fallback)) {\n      context.addIssue({\n        code: 'custom',\n        message: 'The fallback language must also appear in localization.languages.',\n        path: ['fallback'],\n      });\n    }\n  });\n\n/** Uses the runtime's Unicode locale data instead of maintaining a fixed language list. */\nfunction isLanguageTag(language: string): boolean {\n  try {\n    Intl.getCanonicalLocales(language);\n\n    return true;\n  } catch {\n    return false;\n  }\n}\n","import type {\n  ParamDefinition,\n  ParamDefinitions,\n  ParamOverrideGroup,\n  NumberParamRange,\n  ValidationContext,\n} from '#types/params.js';\n\n/** Validates catalog values and conditions after schema parsing. */\nexport function validateParamDefinitions(\n  params: ParamDefinitions,\n  context: ValidationContext,\n): void {\n  for (const [name, definition] of Object.entries(params)) {\n    validateParamDefinition(name, definition, params, context);\n  }\n}\n\n/** Validates constraints and dependency references within the parameter catalog. */\nfunction validateParamDefinition(\n  name: string,\n  definition: ParamDefinition,\n  params: ParamDefinitions,\n  context: ValidationContext,\n): void {\n  switch (definition.type) {\n    case 'boolean':\n      break;\n    case 'number':\n      validateNumberParam(name, definition, context);\n      break;\n    case 'string':\n      validateStringParam(name, definition, context);\n      break;\n  }\n\n  validateParamCondition(name, definition, params, context);\n}\n\n/** Validates one number parameter's range and default value. */\nfunction validateNumberParam(\n  name: string,\n  definition: Extract<ParamDefinition, { type: 'number' }>,\n  context: ValidationContext,\n): void {\n  const { max, min } = definition.range;\n\n  if (min > max) {\n    addParamIssue(context, name, ['range'], 'The minimum cannot exceed the maximum.');\n  } else if (!isStepAligned(max, definition.range)) {\n    addParamIssue(\n      context,\n      name,\n      ['range', 'step'],\n      'The maximum must be reachable from the minimum using the configured step.',\n    );\n  } else if (definition.default < min || definition.default > max) {\n    addParamIssue(context, name, ['default'], 'The default must be within its configured range.');\n  } else if (!isStepAligned(definition.default, definition.range)) {\n    addParamIssue(\n      context,\n      name,\n      ['default'],\n      'The default must align with the configured range step.',\n    );\n  }\n}\n\n/** Validates one string parameter's options and default value. */\nfunction validateStringParam(\n  name: string,\n  definition: Extract<ParamDefinition, { type: 'string' }>,\n  context: ValidationContext,\n): void {\n  if (new Set(definition.options).size !== definition.options.length) {\n    addParamIssue(context, name, ['options'], 'Parameter options must be unique.');\n  }\n\n  if (!definition.options.includes(definition.default)) {\n    addParamIssue(context, name, ['default'], 'The default must appear in its configured options.');\n  }\n}\n\n/** Validates one parameter's optional condition against the complete catalog. */\nfunction validateParamCondition(\n  name: string,\n  definition: ParamDefinition,\n  params: ParamDefinitions,\n  context: ValidationContext,\n): void {\n  const condition = definition.when;\n\n  if (condition === undefined) {\n    return;\n  }\n\n  const referencedParam = params[condition.param];\n\n  if (referencedParam === undefined) {\n    addParamIssue(\n      context,\n      name,\n      ['when', 'param'],\n      'The condition references a parameter that does not exist.',\n    );\n\n    return;\n  }\n\n  if (condition.param === name) {\n    addParamIssue(context, name, ['when', 'param'], 'A parameter cannot condition itself.');\n  }\n\n  if (!isAllowedParamValue(referencedParam, condition.equals)) {\n    addParamIssue(\n      context,\n      name,\n      ['when', 'equals'],\n      'The condition value must be allowed by the referenced parameter.',\n    );\n  }\n}\n\n/** Ensures every dimension override names an existing parameter and supplies an allowed value. */\nexport function validateParamOverrides(\n  groupName: 'networks' | 'versions',\n  overrides: ParamOverrideGroup,\n  params: ParamDefinitions,\n  context: ValidationContext,\n): void {\n  for (const [dimensionName, dimensionOverride] of Object.entries(overrides)) {\n    for (const [paramName, value] of Object.entries(dimensionOverride.params ?? {})) {\n      const definition = params[paramName];\n\n      if (definition === undefined) {\n        context.addIssue({\n          code: 'custom',\n          message: 'The overridden parameter does not exist.',\n          path: [groupName, dimensionName, 'params', paramName],\n        });\n\n        continue;\n      }\n\n      if (!isAllowedParamValue(definition, value)) {\n        context.addIssue({\n          code: 'custom',\n          message: 'The override does not satisfy the parameter definition.',\n          path: [groupName, dimensionName, 'params', paramName],\n        });\n      }\n    }\n  }\n}\n\n/** Checks an override against the parameter's finite set of allowed values. */\nfunction isAllowedParamValue(definition: ParamDefinition, value: unknown): boolean {\n  let allowed: boolean;\n\n  switch (definition.type) {\n    case 'boolean':\n      allowed = typeof value === 'boolean';\n      break;\n    case 'number':\n      allowed = typeof value === 'number' && isAllowedNumberValue(value, definition.range);\n      break;\n    case 'string':\n      allowed = typeof value === 'string' && definition.options.includes(value);\n      break;\n  }\n\n  return allowed;\n}\n\n/** Checks both numeric bounds and membership in the range's discrete step sequence. */\nfunction isAllowedNumberValue(value: number, range: NumberParamRange): boolean {\n  return value >= range.min && value <= range.max && isStepAligned(value, range);\n}\n\n/** Tolerates the small rounding error produced by fractional JavaScript arithmetic. */\nfunction isStepAligned(value: number, range: NumberParamRange): boolean {\n  const stepsFromMinimum = (value - range.min) / range.step;\n\n  return Math.abs(stepsFromMinimum - Math.round(stepsFromMinimum)) < 1e-9;\n}\n\n/** Adds one issue at a parameter-relative path. */\nfunction addParamIssue(\n  context: ValidationContext,\n  name: string,\n  path: readonly PropertyKey[],\n  message: string,\n): void {\n  context.addIssue({\n    code: 'custom',\n    message,\n    path: [name, ...path],\n  });\n}\n","import { z } from 'zod';\n\n/** Checks authored keys before a record schema trims them and could overwrite a value. */\nexport function withUniqueTrimmedKeys<Value extends z.ZodType>(\n  schema: z.ZodRecord<z.ZodString, Value>,\n): z.ZodType<Record<string, z.output<Value>>, Record<string, z.input<Value>>> {\n  return z\n    .transform((input: Record<string, z.input<Value>>, context) => {\n      // Leave shape errors to the record schema; this check only owns key collisions.\n      if (typeof input !== 'object' || input === null || Array.isArray(input)) {\n        return input;\n      }\n\n      const keys = new Set<string>();\n      for (const key of Object.keys(input)) {\n        const normalized = key.trim();\n        if (keys.has(normalized)) {\n          context.addIssue({\n            code: 'custom',\n            message: 'Names must be unique after trimming whitespace.',\n            path: [key],\n          });\n        }\n        keys.add(normalized);\n      }\n\n      return input;\n    })\n    .pipe(schema);\n}\n","import { z } from 'zod';\n\nimport { validateParamDefinitions } from '../validation/params.js';\nimport { requiredStringSchema } from './base.js';\nimport { withUniqueTrimmedKeys } from './record.js';\n\nconst paramValueSchema = z.union([z.boolean(), z.number(), requiredStringSchema]);\n\n/** Another parameter value that controls when a parameter is relevant. */\nconst paramConditionSchema = z.strictObject({\n  param: requiredStringSchema,\n  equals: paramValueSchema,\n});\n\nconst paramDescriptionField = {\n  description: requiredStringSchema,\n};\nconst paramConditionField = {\n  when: paramConditionSchema.optional(),\n};\n\nconst numberRangeSchema = z.strictObject({\n  min: z.number(),\n  max: z.number(),\n  step: z.number().positive(),\n});\n\n/** Boolean, number, and string parameters exposed to builds and development tools. */\nexport const paramDefinitionSchema = z.discriminatedUnion('type', [\n  z.strictObject({\n    type: z.literal('boolean'),\n    default: z.boolean(),\n    ...paramDescriptionField,\n    ...paramConditionField,\n  }),\n  z.strictObject({\n    type: z.literal('number'),\n    default: z.number(),\n    ...paramDescriptionField,\n    range: numberRangeSchema,\n    ...paramConditionField,\n  }),\n  z.strictObject({\n    type: z.literal('string'),\n    default: requiredStringSchema,\n    ...paramDescriptionField,\n    options: z.array(requiredStringSchema).min(1),\n    ...paramConditionField,\n  }),\n]);\n\nexport const paramsSchema = withUniqueTrimmedKeys(\n  z.record(requiredStringSchema, paramDefinitionSchema),\n)\n  .superRefine(validateParamDefinitions)\n  .default({});\n\nexport const paramOverridesSchema = withUniqueTrimmedKeys(\n  z.record(requiredStringSchema, paramValueSchema),\n);\n","import { z } from 'zod';\n\nimport { positiveNumberSchema } from './base.js';\n\n/** Inclusive numeric bounds whose lower value cannot exceed the upper value. */\nconst rangeSchema = z\n  .strictObject({\n    min: positiveNumberSchema,\n    max: positiveNumberSchema,\n  })\n  .refine(({ max, min }) => min <= max, 'The minimum cannot exceed the maximum.');\n\n/** One orientation's authored coordinate system and availability. */\nconst orientationSchema = z.strictObject({\n  enabled: z.boolean(),\n  width: z.number().int().positive(),\n  height: z.number().int().positive(),\n  ratio: rangeSchema,\n});\n\n/** Ordered renderer-quality multipliers from the lowest to the highest policy. */\nconst renderScaleSchema = z\n  .strictObject({\n    minimal: positiveNumberSchema.max(1),\n    reduced: positiveNumberSchema.max(1),\n    balanced: positiveNumberSchema.max(1),\n    full: positiveNumberSchema.max(1),\n  })\n  .refine(\n    ({ balanced, full, minimal, reduced }) =>\n      minimal <= reduced && reduced <= balanced && balanced <= full,\n    'Render scales must be ordered: minimal <= reduced <= balanced <= full.',\n  );\n\n/** Device-pixel bounds and the render scale assigned to each quality policy. */\nconst resolutionSchema = z.strictObject({\n  pixelRatio: rangeSchema,\n  renderScale: renderScaleSchema,\n});\n\n/** Rendering dimensions, supported aspect ratios, and resolution scaling policy. */\nexport const screenSchema = z\n  .strictObject({\n    orientations: z.strictObject({\n      portrait: orientationSchema,\n      landscape: orientationSchema,\n    }),\n    resolution: resolutionSchema,\n  })\n  .refine(\n    ({ orientations }) => orientations.landscape.enabled || orientations.portrait.enabled,\n    'At least one screen orientation must be enabled.',\n  );\n","import { z } from 'zod';\n\nimport { requiredStringSchema } from './base.js';\n\n/** Platform destinations opened when the playable's call to action is activated. */\nexport const storeSchema = z.strictObject({\n  androidUrl: requiredStringSchema.pipe(z.url()),\n  iosUrl: requiredStringSchema.pipe(z.url()),\n});\n","import { z } from 'zod';\n\nimport { assetOverrideSchema } from './assets.js';\nimport { audioOverrideSchema } from './audio.js';\nimport { dimensionNameSchema } from './base.js';\nimport { completionOverrideSchema } from './completion.js';\nimport { paramOverridesSchema } from './params.js';\nimport { withUniqueTrimmedKeys } from './record.js';\n\n/** Values that one version or network may override for its playable variants. */\nconst variantOverrideSchema = z.strictObject({\n  assets: assetOverrideSchema.optional(),\n  audio: audioOverrideSchema.optional(),\n  completion: completionOverrideSchema.optional(),\n  params: paramOverridesSchema.optional(),\n});\n\n/** Named versions normalized to the default version when omitted. */\nexport const versionsSchema = withUniqueTrimmedKeys(\n  z.record(dimensionNameSchema, variantOverrideSchema),\n)\n  .refine((versions) => Object.keys(versions).length > 0, 'At least one version is required.')\n  .default({ default: {} });\n\n/** Delivery networks whose behavior is implemented internally by Replayable. */\nexport const networkSchema = z.enum([\n  'preview',\n  'applovin',\n  'meta',\n  'google',\n  'liftoff',\n  'mintegral',\n  'moloco',\n  'unity',\n]);\n\n/** Selected supported networks, normalized to local preview when omitted. */\nexport const networksSchema = z\n  .partialRecord(networkSchema, variantOverrideSchema)\n  .refine((networks) => Object.keys(networks).length > 0, 'At least one network is required.')\n  .default({ preview: {} });\n","import { z } from 'zod';\n\nimport { replayableAssetsSchema } from './schemas/assets.js';\nimport { audioSchema } from './schemas/audio.js';\nimport { backgroundColorSchema } from './schemas/background.js';\nimport { requiredStringSchema } from './schemas/base.js';\nimport { buildSchema } from './schemas/build.js';\nimport { completionSchema } from './schemas/completion.js';\nimport { controlsSchema } from './schemas/controls.js';\nimport { devtoolsSchema } from './schemas/devtools.js';\nimport { localizationSchema } from './schemas/localization.js';\nimport { paramsSchema } from './schemas/params.js';\nimport { screenSchema } from './schemas/screen.js';\nimport { storeSchema } from './schemas/store.js';\nimport { networksSchema, versionsSchema } from './schemas/variants.js';\nimport { validateParamOverrides } from './validation/params.js';\n\nexport { replayableAssetsSchema } from './schemas/assets.js';\n\n/**\n * Runtime schema for the human-authored `replayable.config.ts` contract.\n *\n * Parsing trims meaningful strings; applies the default audio capability,\n * background color, entry, version, and preview network; and rejects unknown\n * fields.\n */\nexport const replayableConfigSchema = z\n  .strictObject({\n    assets: replayableAssetsSchema,\n    audio: audioSchema,\n    backgroundColor: backgroundColorSchema,\n    build: buildSchema,\n    completion: completionSchema,\n    controls: controlsSchema,\n    devtools: devtoolsSchema,\n    entry: requiredStringSchema.default('src/main.ts'),\n    localization: localizationSchema,\n    name: requiredStringSchema,\n    networks: networksSchema,\n    params: paramsSchema,\n    screen: screenSchema,\n    store: storeSchema,\n    versions: versionsSchema,\n  })\n  .superRefine(({ networks, params, versions }, context) => {\n    validateParamOverrides('networks', networks, params, context);\n    validateParamOverrides('versions', versions, params, context);\n  });\n","import type { ReplayableConfig, ReplayableConfigInput } from '#types/config.js';\n\nimport { replayableConfigSchema } from './schema.js';\n\n/**\n * Validates an authored Replayable project configuration and applies defaults.\n *\n * @param input - Human-authored Replayable configuration.\n * @returns The validated and normalized project configuration.\n * @throws When a field is missing, unknown, or invalid.\n */\nexport function defineConfig(input: ReplayableConfigInput): ReplayableConfig {\n  return replayableConfigSchema.parse(input);\n}\n","import { networkSchema } from '#config/schemas/variants.js';\nimport type { ReplayableConfig } from '#types/config.js';\nimport type { PlayableVariant, VariantOverride, VariantSelection } from '#types/variant.js';\n\nconst ALL_SOUNDS_PATTERN = 'sounds/**';\n\n/**\n * Expands one project configuration into every version/network/language combination.\n *\n * Every returned variant contains resolved values. Base parameters are extended\n * by network parameters and then version parameters, making the version the\n * most specific override. Asset exclusions follow the same precedence.\n *\n * @param config - Validated Replayable project configuration.\n * @returns The ordered concrete playable variants.\n */\nexport function createVariants(config: ReplayableConfig): PlayableVariant[] {\n  const variants: PlayableVariant[] = [];\n\n  for (const [version, versionOverride] of Object.entries(config.versions)) {\n    for (const network of networkSchema.options) {\n      const networkOverride = config.networks[network];\n\n      if (networkOverride === undefined) {\n        continue;\n      }\n\n      for (const language of config.localization.languages) {\n        variants.push(\n          createPlayableVariant(config, {\n            language,\n            network,\n            networkOverride,\n            version,\n            versionOverride,\n          }),\n        );\n      }\n    }\n  }\n\n  return variants;\n}\n\n/** Creates one fully concrete playable from the three configured dimensions. */\nfunction createPlayableVariant(\n  config: ReplayableConfig,\n  selection: VariantSelection,\n): PlayableVariant {\n  const { language, network, networkOverride, version, versionOverride } = selection;\n  const audio = resolveAudio(config.audio, networkOverride.audio, versionOverride.audio);\n  const localization = {\n    language,\n    fallback: config.localization.fallback,\n  };\n\n  return {\n    assets: resolveAssetConfig(\n      config.assets,\n      localization,\n      audio,\n      networkOverride.assets,\n      versionOverride.assets,\n    ),\n    audio,\n    backgroundColor: config.backgroundColor,\n    completion: resolveCompletion(\n      config.completion,\n      networkOverride.completion,\n      versionOverride.completion,\n    ),\n    controls: config.controls,\n    devtools: config.devtools,\n    entry: config.entry,\n    id: `${version}/${network}/${language}`,\n    localization,\n    network,\n    params: resolveParams(config.params, networkOverride.params, versionOverride.params),\n    projectName: config.name,\n    screen: config.screen,\n    store: config.store,\n    version,\n  };\n}\n\n/** Resolves each completion timer independently using project, network, then version precedence. */\nfunction resolveCompletion(\n  project: ReplayableConfig['completion'],\n  network: VariantOverride['completion'],\n  version: VariantOverride['completion'],\n): PlayableVariant['completion'] {\n  const duration = resolveCompletionDuration(\n    project.duration,\n    network?.duration,\n    version?.duration,\n  );\n  const inactivity = resolveCompletionDuration(\n    project.inactivity,\n    network?.inactivity,\n    version?.inactivity,\n  );\n  const completion: { duration?: number; inactivity?: number } = {};\n\n  if (duration !== undefined) {\n    completion.duration = duration;\n  }\n\n  if (inactivity !== undefined) {\n    completion.inactivity = inactivity;\n  }\n\n  return completion;\n}\n\n/** Selects the most specific timer value and removes an explicit `false`. */\nfunction resolveCompletionDuration(\n  project: number | undefined,\n  network: number | false | undefined,\n  version: number | false | undefined,\n): number | undefined {\n  const resolved = version ?? network ?? project;\n\n  return resolved === false ? undefined : resolved;\n}\n\n/** Completes the shared asset configuration for one fixed-language variant. */\nfunction resolveAssetConfig(\n  base: ReplayableConfig['assets'],\n  localization: PlayableVariant['localization'],\n  audio: boolean,\n  network: VariantOverride['assets'],\n  version: VariantOverride['assets'],\n): PlayableVariant['assets'] {\n  const exclude = [...base.exclude, ...(network?.exclude ?? []), ...(version?.exclude ?? [])];\n\n  // A silent variant must not process or emit sound files. Preserve an authored\n  // all-sounds exclusion without adding the same pattern a second time.\n  if (!audio && !exclude.includes(ALL_SOUNDS_PATTERN)) {\n    exclude.push(ALL_SOUNDS_PATTERN);\n  }\n\n  return {\n    ...base,\n    localization,\n    exclude,\n  };\n}\n\n/** Resolves audio as a capability that any configuration dimension may disable. */\nfunction resolveAudio(\n  project: boolean,\n  network: VariantOverride['audio'],\n  version: VariantOverride['audio'],\n): boolean {\n  return project && network !== false && version !== false;\n}\n\n/** Extracts authored defaults, then applies network and version value overrides. */\nfunction resolveParams(\n  definitions: ReplayableConfig['params'],\n  network: VariantOverride['params'],\n  version: VariantOverride['params'],\n): PlayableVariant['params'] {\n  const defaults = Object.fromEntries(\n    Object.entries(definitions).map(([name, definition]) => [name, definition.default]),\n  );\n\n  return {\n    ...defaults,\n    ...network,\n    ...version,\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@replayablejs/config",
+  "version": "0.1.0-alpha.0",
+  "description": "Validated Replayable project configuration and playable variant expansion",
+  "homepage": "https://github.com/replayablejs/replayable#readme",
+  "bugs": {
+    "url": "https://github.com/replayablejs/replayable/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/replayablejs/replayable.git",
+    "directory": "packages/config"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "imports": {
+    "#config/*": "./src/config/*",
+    "#variants/*": "./src/variants/*",
+    "#types/*": "./src/types/*"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "4.4.3",
+    "@replayablejs/assets": "0.1.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/node": "26.2.0",
+    "tsdown": "0.22.14",
+    "typescript": "7.0.2",
+    "vitest": "4.1.10"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "oxlint --type-aware --max-warnings 0 .",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}