@mpgd/target-config 0.19.0 → 0.21.0

package/dist/adaptive-shell/shell.js

@@ -0,0 +1,359 @@
+import { measureTargetViewport, readTargetViewportSafeAreaInsets, resolveTargetViewportSnapshot, waitForTargetViewportMeasurement, } from '../viewport.js';
+import { assertAdaptiveShellPolicy, assertAdaptiveShellRailSlots, resolveAdaptiveShellComposition, resolveAdaptiveShellRailBounds, resolveAdaptiveShellRailSlot, } from './policy.js';
+/**
+ * DOM attributes the shell owns. `base.css` selects the marker attributes; game stylesheets may
+ * select the state attributes. Element ids and class names stay game-owned.
+ */
+export const adaptiveShellAttributes = {
+    /** Marker on the outer full-viewport shell element. */
+    shell: 'data-game-shell',
+    /** Marker on the game mount (the stage). */
+    stage: 'data-game-shell-stage',
+    /** `left` or `right` on each rail element. */
+    rail: 'data-game-shell-rail',
+    /** Shell: `side-rails`, `bottom-controls` or `compact-portrait`. */
+    compositionMode: 'data-composition-mode',
+    /** Shell: where primary controls belong for the current composition. */
+    primaryControls: 'data-primary-controls',
+    /** Stage: the same composition mode, for selectors scoped under the game mount. */
+    layoutMode: 'data-layout-mode',
+    /** Stage: `portrait` or `landscape` from the measured viewport layout. */
+    viewportOrientation: 'data-viewport-orientation',
+};
+export const defaultAdaptiveShellId = 'game-shell';
+const shellOwners = new WeakMap();
+const documentSlotOwners = new WeakMap();
+/**
+ * Root custom-property prefixes the shell reads back (`--mpgd-safe-area-top`, ...). A rail slot
+ * using one would shadow the safe-area tokens and skew every composition.
+ */
+export const adaptiveShellReservedVariablePrefixes = ['--mpgd-safe-area'];
+/** Wait for host layout instead of booting the engine with a zero-sized viewport. */
+export function waitForAdaptiveShellViewport(container, options = {}) {
+    const view = requireWindow(container);
+    const doc = container.ownerDocument;
+    return waitForTargetViewportMeasurement({
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+        measure: () => measureContainer(container),
+        subscribe: (refresh) => {
+            const observer = new view.ResizeObserver(refresh);
+            observer.observe(container);
+            view.addEventListener('resize', refresh);
+            view.visualViewport?.addEventListener('resize', refresh);
+            view.visualViewport?.addEventListener('scroll', refresh);
+            doc.addEventListener('visibilitychange', refresh);
+            return () => {
+                observer.disconnect();
+                view.removeEventListener('resize', refresh);
+                view.visualViewport?.removeEventListener('resize', refresh);
+                view.visualViewport?.removeEventListener('scroll', refresh);
+                doc.removeEventListener('visibilitychange', refresh);
+            };
+        },
+    });
+}
+/**
+ * Mount the full-viewport shell around `gameRoot` and keep stage/rail bounds in sync.
+ * An existing ancestor with the shell id is reused when it already contains both rails.
+ */
+export function mountAdaptiveGameShell(input) {
+    const view = requireWindow(input.gameRoot);
+    const ownedInput = { ...input, policy: structuredClone(input.policy) };
+    const providedRailSlots = input.railSlots ?? [];
+    assertAdaptiveShellPolicy(ownedInput.policy);
+    assertAdaptiveShellRailSlots(providedRailSlots, {
+        attributes: Object.values(adaptiveShellAttributes),
+        variablePrefixes: adaptiveShellReservedVariablePrefixes,
+    });
+    const railSlots = providedRailSlots.map((slot) => Object.freeze({ ...slot }));
+    const doc = input.gameRoot.ownerDocument;
+    const previousOwner = shellOwners.get(input.gameRoot);
+    const slotOwners = documentSlotOwners.get(doc) ?? new Map();
+    for (const slot of railSlots) {
+        const owner = slotOwners.get(slot.cssVariablePrefix);
+        if (owner !== undefined && owner !== previousOwner) {
+            throw new Error(`Rail slot cssVariablePrefix is already in use in this document: ${slot.cssVariablePrefix}`);
+        }
+    }
+    // Measure before restructuring the DOM, so an unmeasurable host fails without a half-built shell.
+    // Prefer the visible viewport for this fixed full-window shell.
+    const initialMeasurement = input.initialMeasurement ?? measureContainer(input.gameRoot);
+    if (initialMeasurement === null) {
+        throw new Error('Wait for a measurable viewport before mounting the game shell.');
+    }
+    // Validate the viewport/orientation before restructuring an authored mount.
+    resolveAdaptiveShellComposition(resolveTargetViewportSnapshot({
+        ...initialMeasurement,
+        runtime: input.runtime,
+        orientationPolicy: ownedInput.policy.orientationPolicy ?? { mode: 'responsive' },
+    }), ownedInput.policy);
+    previousOwner?.();
+    const elements = ensureShellElements(input.gameRoot, input.elements ?? {});
+    const listeners = new Set();
+    let animationFrame;
+    let destroyed = false;
+    let state = resolveShellState(elements.shell, ownedInput, initialMeasurement);
+    let offset = visualViewportOffset(elements.shell);
+    applyShellState(elements, state, railSlots, offset);
+    const refresh = () => {
+        animationFrame = undefined;
+        if (destroyed) {
+            return;
+        }
+        const next = resolveShellState(elements.shell, ownedInput);
+        const nextOffset = visualViewportOffset(elements.shell);
+        if (next === null || (shellStateSignature(next) === shellStateSignature(state)
+            && nextOffset.x === offset.x && nextOffset.y === offset.y)) {
+            return;
+        }
+        state = next;
+        offset = nextOffset;
+        applyShellState(elements, state, railSlots, offset);
+        for (const listener of listeners) {
+            notifyListener(listener, state);
+        }
+    };
+    const scheduleRefresh = () => {
+        if (destroyed || animationFrame !== undefined) {
+            return;
+        }
+        animationFrame = view.requestAnimationFrame(refresh);
+    };
+    const resizeObserver = new view.ResizeObserver(scheduleRefresh);
+    resizeObserver.observe(elements.shell);
+    view.addEventListener('resize', scheduleRefresh);
+    view.visualViewport?.addEventListener('resize', scheduleRefresh);
+    view.visualViewport?.addEventListener('scroll', scheduleRefresh);
+    const controller = {
+        shell: elements.shell,
+        stage: elements.gameRoot,
+        leftRail: elements.leftRail,
+        rightRail: elements.rightRail,
+        get state() {
+            return state;
+        },
+        subscribe(listener) {
+            if (destroyed) {
+                return () => undefined;
+            }
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        destroy() {
+            if (destroyed) {
+                return;
+            }
+            destroyed = true;
+            if (shellOwners.get(input.gameRoot) === controller.destroy) {
+                shellOwners.delete(input.gameRoot);
+            }
+            listeners.clear();
+            resizeObserver.disconnect();
+            view.removeEventListener('resize', scheduleRefresh);
+            view.visualViewport?.removeEventListener('resize', scheduleRefresh);
+            view.visualViewport?.removeEventListener('scroll', scheduleRefresh);
+            if (animationFrame !== undefined) {
+                view.cancelAnimationFrame(animationFrame);
+            }
+            for (const slot of railSlots) {
+                if (slotOwners.get(slot.cssVariablePrefix) === controller.destroy) {
+                    slotOwners.delete(slot.cssVariablePrefix);
+                    clearRailSlot(elements.shell, slot);
+                }
+            }
+        },
+    };
+    shellOwners.set(input.gameRoot, controller.destroy);
+    documentSlotOwners.set(doc, slotOwners);
+    for (const slot of railSlots) {
+        slotOwners.set(slot.cssVariablePrefix, controller.destroy);
+    }
+    return controller;
+}
+/**
+ * One failing subscriber must not skip the others for this update. Its error is rethrown from a
+ * microtask, so it still reaches the host's uncaught-error reporting.
+ */
+function notifyListener(listener, state) {
+    try {
+        listener(state);
+    }
+    catch (error) {
+        queueMicrotask(() => {
+            throw error;
+        });
+    }
+}
+function resolveShellState(shell, input, fallback) {
+    const measurement = measureContainer(shell) ?? fallback;
+    if (measurement === undefined) {
+        return null;
+    }
+    const viewport = resolveTargetViewportSnapshot({
+        ...measurement,
+        runtime: input.runtime,
+        orientationPolicy: input.policy.orientationPolicy ?? { mode: 'responsive' },
+        safeAreaInsets: readTargetViewportSafeAreaInsets(requireWindow(shell).getComputedStyle(shell.ownerDocument.documentElement)),
+    });
+    return {
+        viewport,
+        composition: resolveAdaptiveShellComposition(viewport, input.policy),
+    };
+}
+function measureContainer(container) {
+    const view = requireWindow(container);
+    return measureTargetViewport({ visualViewport: view.visualViewport, window: view })
+        ?? measureTargetViewport({ container });
+}
+function ensureShellElements(gameRoot, names) {
+    const shellId = names.shellId ?? defaultAdaptiveShellId;
+    const existingShell = findAncestorById(gameRoot, shellId);
+    if (existingShell !== null) {
+        const leftRail = requireRail(existingShell, 'left');
+        const rightRail = requireRail(existingShell, 'right');
+        markShellElements(existingShell, gameRoot);
+        return { shell: existingShell, gameRoot, leftRail, rightRail };
+    }
+    const parent = gameRoot.parentElement;
+    if (parent === null) {
+        const mountLabel = gameRoot.id === '' ? gameRoot.tagName.toLowerCase() : `#${gameRoot.id}`;
+        throw new Error(`Game mount ${mountLabel} must have a parent element.`);
+    }
+    const doc = gameRoot.ownerDocument;
+    const shell = doc.createElement('main');
+    const leftRail = createRail(doc, 'left', names.railClassName);
+    const rightRail = createRail(doc, 'right', names.railClassName);
+    shell.id = shellId;
+    if (names.shellClassName !== undefined) {
+        shell.className = names.shellClassName;
+    }
+    markShellElements(shell, gameRoot);
+    parent.insertBefore(shell, gameRoot);
+    shell.append(leftRail, gameRoot, rightRail);
+    return { shell, gameRoot, leftRail, rightRail };
+}
+function findAncestorById(element, id) {
+    for (let current = element.parentElement; current !== null; current = current.parentElement) {
+        if (current.id === id) {
+            return current;
+        }
+    }
+    return null;
+}
+function markShellElements(shell, gameRoot) {
+    shell.setAttribute(adaptiveShellAttributes.shell, '');
+    gameRoot.setAttribute(adaptiveShellAttributes.stage, '');
+}
+function requireRail(shell, side) {
+    const rail = shell.querySelector(`[${adaptiveShellAttributes.rail}="${side}"]`);
+    if (rail === null) {
+        throw new Error(`Game shell ${side} rail is missing.`);
+    }
+    return rail;
+}
+function createRail(doc, side, className) {
+    const rail = doc.createElement('aside');
+    if (className !== undefined) {
+        rail.className = className;
+    }
+    rail.setAttribute(adaptiveShellAttributes.rail, side);
+    rail.setAttribute('aria-hidden', 'true');
+    return rail;
+}
+function applyShellState(elements, state, railSlots, offset) {
+    const { composition } = state;
+    elements.shell.style.left = `${offset.x}px`;
+    elements.shell.style.top = `${offset.y}px`;
+    elements.shell.style.right = 'auto';
+    elements.shell.style.bottom = 'auto';
+    elements.shell.style.width = `${state.viewport.layout.width}px`;
+    elements.shell.style.height = `${state.viewport.layout.height}px`;
+    elements.shell.setAttribute(adaptiveShellAttributes.compositionMode, composition.mode);
+    elements.shell.setAttribute(adaptiveShellAttributes.primaryControls, composition.primaryControls);
+    elements.gameRoot.setAttribute(adaptiveShellAttributes.layoutMode, composition.mode);
+    elements.gameRoot.setAttribute(adaptiveShellAttributes.viewportOrientation, state.viewport.layout.orientation);
+    const leftRailBounds = resolveAdaptiveShellRailBounds(composition, 'left');
+    const rightRailBounds = resolveAdaptiveShellRailBounds(composition, 'right');
+    applyBounds(elements.gameRoot, composition.gameBounds);
+    applyOptionalBounds(elements.leftRail, leftRailBounds);
+    applyOptionalBounds(elements.rightRail, rightRailBounds);
+    for (const slot of railSlots) {
+        const bounds = slot.rail === 'left' ? leftRailBounds : rightRailBounds;
+        applyRailSlot(elements.shell, slot, bounds === undefined
+            ? undefined
+            : { ...bounds, x: bounds.x + offset.x, y: bounds.y + offset.y });
+    }
+    applyRailVisibility(elements.leftRail, leftRailBounds);
+    applyRailVisibility(elements.rightRail, rightRailBounds);
+}
+function applyRailVisibility(rail, bounds) {
+    if (bounds === undefined) {
+        rail.setAttribute('aria-hidden', 'true');
+    }
+    else {
+        rail.removeAttribute('aria-hidden');
+    }
+}
+/**
+ * Slot variables live on the document root so body-mounted overlays (popovers, dialogs) outside
+ * the shell subtree can position themselves against the rail.
+ */
+function applyRailSlot(shell, slot, railBounds) {
+    const placement = resolveAdaptiveShellRailSlot(railBounds, slot);
+    if (placement === undefined) {
+        clearRailSlot(shell, slot);
+        return;
+    }
+    const rootStyle = shell.ownerDocument.documentElement.style;
+    shell.setAttribute(slot.readyAttribute, 'true');
+    rootStyle.setProperty(`${slot.cssVariablePrefix}-left`, `${placement.left}px`);
+    rootStyle.setProperty(`${slot.cssVariablePrefix}-top`, `${placement.top}px`);
+    rootStyle.setProperty(`${slot.cssVariablePrefix}-width`, `${placement.width}px`);
+}
+function clearRailSlot(shell, slot) {
+    shell.removeAttribute(slot.readyAttribute);
+    const rootStyle = shell.ownerDocument.documentElement.style;
+    rootStyle.removeProperty(`${slot.cssVariablePrefix}-left`);
+    rootStyle.removeProperty(`${slot.cssVariablePrefix}-top`);
+    rootStyle.removeProperty(`${slot.cssVariablePrefix}-width`);
+}
+function applyBounds(element, bounds) {
+    element.style.display = '';
+    element.style.left = `${bounds.x}px`;
+    element.style.top = `${bounds.y}px`;
+    element.style.width = `${bounds.width}px`;
+    element.style.height = `${bounds.height}px`;
+}
+function applyOptionalBounds(element, bounds) {
+    if (bounds === undefined) {
+        element.style.display = 'none';
+        return;
+    }
+    applyBounds(element, bounds);
+}
+function shellStateSignature(state) {
+    return JSON.stringify({
+        composition: state.composition,
+        layout: state.viewport.layout,
+        safeArea: state.viewport.safeArea,
+    });
+}
+function requireWindow(element) {
+    const view = element.ownerDocument.defaultView;
+    if (view === null) {
+        throw new Error('Adaptive shell needs a document with a window.');
+    }
+    return view;
+}
+function visualViewportOffset(element) {
+    const viewport = requireWindow(element).visualViewport;
+    if ((viewport === null || viewport === undefined) || measureTargetViewport({ visualViewport: viewport }) === null) {
+        return { x: 0, y: 0 };
+    }
+    return {
+        x: Number.isFinite(viewport.offsetLeft) ? viewport.offsetLeft : 0,
+        y: Number.isFinite(viewport.offsetTop) ? viewport.offsetTop : 0,
+    };
+}

package/dist/asset-packs.d.ts

@@ -0,0 +1,33 @@
+/** Provider-neutral locations for non-executable asset-pack payloads. */
+export type AssetPackLocation = 'packaged' | 'remote';
+export interface AssetPackDeliveryPolicy {
+  readonly defaultLocation: AssetPackLocation;
+  readonly packs?: Readonly<Record<string, AssetPackLocation>>;
+  /** These packs and their dependency closure must work on first launch offline. */
+  readonly offlineRequired?: readonly string[];
+  /** HTTPS directory URL; HTTP is accepted only for loopback development. */
+  readonly remoteBaseUrl?: string;
+  /** Total packaged asset namespace, including manifest and policy metadata. */
+  readonly maxPackagedBytes?: number;
+}
+export interface AssetPackTargetPolicy extends AssetPackDeliveryPolicy {
+  /** Build config path relative to mpgd.targets.json. No credentials belong here. */
+  readonly buildConfig: string;
+}
+export interface AssetPackPolicyPack {
+  readonly packId: string;
+  readonly revision: string;
+  readonly dependencies: readonly {
+    readonly packId: string;
+    readonly revision: string;
+  }[];
+}
+export declare function assertAssetPackDeliveryPolicy(input: unknown): asserts input is AssetPackDeliveryPolicy;
+export declare function assertAssetPackTargetPolicy(input: unknown): asserts input is AssetPackTargetPolicy;
+/** Resolve the offline dependency closure; explicit remote conflicts fail closed. */
+export declare function resolveAssetPackLocations(policy: AssetPackDeliveryPolicy, packs: readonly AssetPackPolicyPack[]): Readonly<Record<string, AssetPackLocation>>;
+/** Compatible with Phaser delivery's resolveURL; its path is already encoded once. */
+export declare function createAssetPackTargetURLResolver(policy: AssetPackDeliveryPolicy, packs: readonly AssetPackPolicyPack[], packagedBaseUrl: string): (encodedPath: string, context: {
+  readonly packId: string;
+  readonly revision: string;
+}) => string;

package/dist/asset-packs.js

@@ -0,0 +1,122 @@
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function assertAssetPackDeliveryPolicy(input) {
+    if (!record(input) || (input.defaultLocation !== 'packaged' && input.defaultLocation !== 'remote')) {
+        throw new Error('assetPacks.defaultLocation must be packaged or remote');
+    }
+    const keys = new Set([
+        'buildConfig',
+        'defaultLocation',
+        'packs',
+        'offlineRequired',
+        'remoteBaseUrl',
+        'maxPackagedBytes',
+    ]);
+    if (Object.keys(input).some((key) => !keys.has(key))) {
+        throw new Error('assetPacks contains an unknown field; credentials are not target configuration');
+    }
+    if (input.packs !== undefined) {
+        if (!record(input.packs) || Object.keys(input.packs).length > 4096) {
+            throw new Error('assetPacks.packs must be a bounded pack-location map');
+        }
+        for (const [id, location] of Object.entries(input.packs)) {
+            if (!id || (location !== 'packaged' && location !== 'remote')) {
+                throw new Error('assetPacks.packs contains an invalid pack location');
+            }
+        }
+    }
+    if (input.offlineRequired !== undefined && (!Array.isArray(input.offlineRequired)
+        || input.offlineRequired.length > 4096
+        || input.offlineRequired.some((id) => typeof id !== 'string' || !id))) {
+        throw new Error('assetPacks.offlineRequired must be a bounded list of pack IDs');
+    }
+    if (input.maxPackagedBytes !== undefined && (!Number.isSafeInteger(input.maxPackagedBytes)
+        || input.maxPackagedBytes <= 0)) {
+        throw new Error('assetPacks.maxPackagedBytes must be a positive safe integer');
+    }
+    if (input.remoteBaseUrl !== undefined) {
+        if (typeof input.remoteBaseUrl !== 'string') {
+            throw new Error('assetPacks.remoteBaseUrl must be a directory URL');
+        }
+        const url = new URL(input.remoteBaseUrl);
+        const loopback = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+        if ((url.protocol !== 'https:' && !(url.protocol === 'http:' && loopback))
+            || url.username || url.password || url.search || url.hash || !url.pathname.endsWith('/')) {
+            throw new Error('assetPacks.remoteBaseUrl requires an HTTPS directory URL without credentials, query or fragment (HTTP loopback allowed)');
+        }
+    }
+}
+export function assertAssetPackTargetPolicy(input) {
+    assertAssetPackDeliveryPolicy(input);
+    const buildConfig = input.buildConfig;
+    if (typeof buildConfig !== 'string' || !buildConfig.trim()) {
+        throw new Error('assetPacks.buildConfig must be a non-empty path');
+    }
+}
+/** Resolve the offline dependency closure; explicit remote conflicts fail closed. */
+export function resolveAssetPackLocations(policy, packs) {
+    assertAssetPackDeliveryPolicy(policy);
+    const byId = new Map(packs.map((pack) => [pack.packId, pack]));
+    if (byId.size !== packs.length || packs.length > 4096) {
+        throw new Error('Asset pack policy requires unique, bounded pack IDs');
+    }
+    const locations = Object.create(null);
+    for (const pack of packs) {
+        locations[pack.packId] = policy.packs && Object.hasOwn(policy.packs, pack.packId)
+            ? policy.packs[pack.packId] : policy.defaultLocation;
+        for (const dependency of pack.dependencies) {
+            if (byId.get(dependency.packId)?.revision !== dependency.revision) {
+                throw new Error(`Unknown dependency revision in pack ${pack.packId}`);
+            }
+        }
+    }
+    for (const id of Object.keys(policy.packs ?? {})) {
+        if (!byId.has(id)) {
+            throw new Error(`Unknown asset pack override: ${id}`);
+        }
+    }
+    const pending = [...(policy.offlineRequired ?? [])];
+    const visited = new Set();
+    while (pending.length) {
+        const id = pending.pop();
+        if (visited.has(id)) {
+            continue;
+        }
+        const pack = byId.get(id);
+        if (!pack) {
+            throw new Error(`Unknown offline-required asset pack: ${id}`);
+        }
+        if (policy.packs && Object.hasOwn(policy.packs, id) && policy.packs[id] === 'remote') {
+            throw new Error(`Offline-required dependency ${id} is explicitly remote`);
+        }
+        visited.add(id);
+        locations[id] = 'packaged';
+        pending.push(...pack.dependencies.map((dependency) => dependency.packId));
+    }
+    if (Object.values(locations).includes('remote') && policy.remoteBaseUrl === undefined) {
+        throw new Error('Remote asset packs require assetPacks.remoteBaseUrl');
+    }
+    return Object.freeze(locations);
+}
+/** Compatible with Phaser delivery's resolveURL; its path is already encoded once. */
+export function createAssetPackTargetURLResolver(policy, packs, packagedBaseUrl) {
+    const locations = resolveAssetPackLocations(policy, packs);
+    const revisions = new Map(packs.map((pack) => [pack.packId, pack.revision]));
+    const local = new URL(packagedBaseUrl);
+    if (!local.pathname.endsWith('/') || local.username || local.password || local.search || local.hash) {
+        throw new Error('Packaged asset base must be a directory URL');
+    }
+    const remote = policy.remoteBaseUrl;
+    return (encodedPath, context) => {
+        if (revisions.get(context.packId) !== context.revision) {
+            throw new Error('Asset URL context does not match the selected pack revision');
+        }
+        if (!encodedPath || encodedPath.startsWith('/') || /[?#:\\]/.test(encodedPath)
+            || encodedPath.split('/').some((part) => !part || ['.', '..'].includes(decodeURIComponent(part))
+                || /[/\\]/.test(decodeURIComponent(part)))) {
+            throw new Error('Asset URL requires an encoded relative artifact path');
+        }
+        return new URL(encodedPath, locations[context.packId] === 'remote' ? remote : local).href;
+    };
+}

package/dist/effective.d.ts

@@ -1,7 +1,9 @@
 import { type AdPlacementEntry, type AdPlacements, type ProductCatalog, type ProductCatalogEntry } from '@mpgd/catalog';
 import { type FeatureAvailabilityReason, type TargetCapabilityConfig, type TargetConfig, type TargetConfigMatrix, type TargetFeatureConfig, type TargetIntegrationConfig, type TargetLocalizationConfig, type TargetPolicyRestrictions, type TargetReleaseConfig, type TargetRuntimeKind } from './runtime.js';
+import { type AssetPackDeliveryPolicy, type AssetPackTargetPolicy } from './asset-packs.js';
 export type EffectiveAvailabilityReason = FeatureAvailabilityReason | 'missing-platform-id';
 export interface EffectivePlatformTargetMetadata {
+  readonly assetPacks?: AssetPackTargetPolicy;
   readonly kind: string;
   readonly adapter: string;
   readonly crazyGamesLaunch?: 'basic' | 'full';
@@ -61,6 +63,7 @@ export interface EffectiveLocalizationConfig {
   readonly fallbackLocale: TargetLocalizationConfig['fallbackLocale'];
 }
 export interface EffectiveTargetConfig {
+  readonly assetPacks?: AssetPackDeliveryPolicy;
   readonly version: string;
   readonly target: string;
   readonly runtime: TargetRuntimeKind;

package/dist/effective.js

@@ -1,5 +1,6 @@
 import { resolveAdPlacementPlatformId, resolveProductPlatformId, } from '@mpgd/catalog';
 import { adPlacementFeatureFor, assertTargetIntegrationRuntimeBounds, } from './runtime.js';
+import { assertAssetPackTargetPolicy, } from './asset-packs.js';
 export const defaultLeaderboardId = 'default';
 const disabledAuthoritativeMonetization = {
     iap: false,
@@ -10,6 +11,17 @@ const disabledAuthoritativeMonetization = {
 };
 export function createEffectiveTargetConfig(input) {
     const config = resolveAuthoritativeGameServicesConfig(input.config, input.platformTarget);
+    if (input.platformTarget?.assetPacks !== undefined) {
+        assertAssetPackTargetPolicy(input.platformTarget.assetPacks);
+    }
+    const assetPolicy = input.platformTarget?.assetPacks;
+    const runtimeAssetPacks = assetPolicy === undefined ? undefined : {
+        defaultLocation: assetPolicy.defaultLocation,
+        ...(assetPolicy.packs === undefined ? {} : { packs: { ...assetPolicy.packs } }),
+        ...(assetPolicy.offlineRequired === undefined ? {} : { offlineRequired: [...assetPolicy.offlineRequired] }),
+        ...(assetPolicy.remoteBaseUrl === undefined ? {} : { remoteBaseUrl: assetPolicy.remoteBaseUrl }),
+        ...(assetPolicy.maxPackagedBytes === undefined ? {} : { maxPackagedBytes: assetPolicy.maxPackagedBytes }),
+    };
     const products = input.catalog.products.map((product) => createEffectiveProductConfig(input.target, config, product));
     const placements = input.adPlacements.placements.map((placement) => createEffectiveAdPlacementConfig(input.target, config, placement));
     const leaderboardEnabled = config.features.leaderboard;
@@ -24,6 +36,7 @@ export function createEffectiveTargetConfig(input) {
             adPlacements: input.adPlacements.version,
         }),
         target: input.target,
+        ...(runtimeAssetPacks === undefined ? {} : { assetPacks: runtimeAssetPacks }),
         runtime: config.runtime,
         release: config.release,
         features: config.features,

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { EffectiveTargetConfigMatrix } from './effective.js';
 import type { TargetConfigMatrix } from './runtime.js';
 export * from './effective.js';
+export * from './asset-packs.js';
 export * from './platformVersionAllocation.js';
 export * from './releaseIdentity.js';
 export * from './runtime.js';