@tantawowa/hosanna-tools 3.30.0 → 3.31.1

package/dist/artwork/app-artwork.d.ts

@@ -0,0 +1,122 @@
+import type { HosannaPwaIcon } from '../vite-pwa.js';
+export type AppArtworkPlatform = 'browser' | 'roku' | 'ios' | 'apple-tv' | 'android' | 'android-tv';
+/** Build-time sources. Paths are relative to this manifest, never runtime URLs. */
+export interface AppArtworkManifest {
+    schemaVersion: 1;
+    icon?: string;
+    ios?: {
+        icon?: string;
+        launchScreen?: {
+            image: string;
+            backgroundColor: string;
+        };
+    };
+    android?: {
+        icon?: string;
+        adaptive?: {
+            foreground: string;
+            background: string;
+            monochrome?: string;
+        };
+        launchScreen?: {
+            backgroundColor: string;
+            icon?: string;
+        };
+    };
+    androidTv?: {
+        icon?: string;
+        banner: string;
+        launchScreen?: {
+            backgroundColor: string;
+            icon?: string;
+        };
+    };
+    appleTv?: {
+        assetCatalog: string;
+        appIconName?: string;
+        launchScreen?: {
+            image: string;
+            backgroundColor: string;
+        };
+    };
+    roku?: {
+        channel: {
+            hd: string;
+            fhd: string;
+        };
+        splash?: {
+            sd: string;
+            hd: string;
+            fhd?: string;
+        };
+    };
+    web?: {
+        icon?: string;
+        maskableIcon?: string;
+        appleTouchIcon?: string;
+        favicon?: string;
+        loadingScreen?: {
+            image: string;
+            backgroundColor: string;
+        };
+    };
+}
+export interface PrepareAppArtworkOptions {
+    cwd: string;
+    app: string;
+    platform: AppArtworkPlatform;
+    manifest: string;
+}
+export interface PreparedAppArtwork {
+    schemaVersion: 1;
+    app: string;
+    platform: AppArtworkPlatform;
+    manifestPath: string;
+    inputHash: string;
+    outputDir: string;
+    receiptPath: string;
+    apple?: {
+        assetCatalogPath: string;
+        appIconName: string;
+        watchAppIconName?: string;
+        launchScreen?: {
+            storyboardPath: string;
+            storyboardName: string;
+            imageName: string;
+            backgroundColor: string;
+        };
+    };
+    android?: {
+        resourceDirectory: string;
+        iconResource: string;
+        bannerResource?: string;
+        launchScreen?: {
+            iconResource: string;
+            backgroundColor: string;
+        };
+    };
+    roku?: {
+        files: Array<{
+            source: string;
+            path: string;
+        }>;
+        manifestValues: Record<string, string>;
+    };
+    web?: {
+        icons: HosannaPwaIcon[];
+        appleTouchIcon?: string;
+        favicon?: {
+            source: string;
+            src: string;
+        };
+        loadingScreen?: {
+            source: string;
+            src: string;
+            backgroundColor: string;
+        };
+    };
+}
+/** Prepare one selected target without modifying any supplied source or native project. */
+export declare function prepareAppArtwork(options: PrepareAppArtworkOptions): Promise<PreparedAppArtwork>;
+/** Validate the generic local manifest shape before an app-owned downloader activates it. */
+export declare function validateAppArtworkManifest(value: unknown): AppArtworkManifest;

package/dist/artwork/app-artwork.js

@@ -0,0 +1,525 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareAppArtwork = prepareAppArtwork;
+exports.validateAppArtworkManifest = validateAppArtworkManifest;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sharp_1 = __importDefault(require("sharp"));
+const RECIPE_VERSION = 4;
+const PLATFORMS = ['browser', 'roku', 'ios', 'apple-tv', 'android', 'android-tv'];
+const SAFE_APP = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/** Prepare one selected target without modifying any supplied source or native project. */
+async function prepareAppArtwork(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+    const cwd = fs_1.default.realpathSync(path_1.default.resolve(options.cwd));
+    if (!SAFE_APP.test(options.app) || options.app === '.' || options.app === '..') {
+        throw new Error(`Invalid artwork app key: ${JSON.stringify(options.app)}`);
+    }
+    if (!PLATFORMS.includes(options.platform))
+        throw new Error(`Unsupported artwork platform: ${options.platform}`);
+    const manifestPath = insideFile(cwd, path_1.default.resolve(cwd, options.manifest), 'artwork manifest');
+    const context = `Artwork for ${options.app} (${options.platform}), manifest ${manifestPath}`;
+    const sources = new Map();
+    const read = (absolute) => {
+        const resolved = insideFile(cwd, absolute, context);
+        const cached = sources.get(resolved);
+        if (cached)
+            return cached;
+        const contents = fs_1.default.readFileSync(resolved);
+        const source = { path: resolved, contents, sha256: digest(contents) };
+        sources.set(resolved, source);
+        return source;
+    };
+    let manifest;
+    try {
+        manifest = validateAppArtworkManifest(JSON.parse(read(manifestPath).contents.toString('utf8')));
+    }
+    catch (error) {
+        throw new Error(`${context}: ${errorMessage(error)}`);
+    }
+    const image = async (role, source, square = false, opaque = false, minimum = 1) => {
+        if (!source)
+            throw new Error(`${context}: missing required ${role} source. Add ${role} to the artwork manifest.`);
+        let decoded;
+        try {
+            const file = read(path_1.default.resolve(path_1.default.dirname(manifestPath), source));
+            // A full decode catches truncated files that can still supply valid metadata.
+            const { info, data } = await (0, sharp_1.default)(file.contents, { failOn: 'warning' }).toColourspace('srgb').ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+            let isOpaque = true;
+            for (let offset = 3; offset < data.length; offset += 4) {
+                if (data[offset] !== 255) {
+                    isOpaque = false;
+                    break;
+                }
+            }
+            decoded = Object.assign(Object.assign({}, file), { width: info.width, height: info.height, opaque: isOpaque });
+        }
+        catch (error) {
+            throw new Error(`${context}: invalid ${role} source ${source}: ${errorMessage(error)}`);
+        }
+        if (square && decoded.width !== decoded.height)
+            throw new Error(`${context}: ${role} must be square; got ${decoded.width}x${decoded.height}. Supply the approved composition; artwork preparation does not crop.`);
+        if (Math.min(decoded.width, decoded.height) < minimum)
+            throw new Error(`${context}: ${role} must be at least ${minimum}px in each dimension; got ${decoded.width}x${decoded.height}.`);
+        if (opaque && !decoded.opaque)
+            throw new Error(`${context}: ${role} must be opaque.`);
+        return decoded;
+    };
+    const images = new Map();
+    let tvCatalog;
+    if (options.platform === 'ios') {
+        images.set('icon', await image('ios.icon (or icon)', (_b = (_a = manifest.ios) === null || _a === void 0 ? void 0 : _a.icon) !== null && _b !== void 0 ? _b : manifest.icon, true, true, 1024));
+    }
+    else if (options.platform === 'android' || options.platform === 'android-tv') {
+        images.set('icon', await image(`${options.platform === 'android-tv' ? 'androidTv' : 'android'}.icon (or icon)`, options.platform === 'android-tv' ? (_d = (_c = manifest.androidTv) === null || _c === void 0 ? void 0 : _c.icon) !== null && _d !== void 0 ? _d : manifest.icon : (_f = (_e = manifest.android) === null || _e === void 0 ? void 0 : _e.icon) !== null && _f !== void 0 ? _f : manifest.icon, true, false, 192));
+        if (options.platform === 'android-tv') {
+            const banner = await image('androidTv.banner', (_g = manifest.androidTv) === null || _g === void 0 ? void 0 : _g.banner, false, true);
+            if (banner.width * 9 !== banner.height * 16 || banner.width < 320)
+                throw new Error(`${context}: androidTv.banner must be an opaque 16:9 image of at least 320x180; got ${banner.width}x${banner.height}. Supply a TV banner composition.`);
+            images.set('banner', banner);
+        }
+        else if ((_h = manifest.android) === null || _h === void 0 ? void 0 : _h.adaptive) {
+            for (const key of ['foreground', 'background', 'monochrome']) {
+                const source = manifest.android.adaptive[key];
+                if (key === 'monochrome' && !source)
+                    continue;
+                images.set(key, await image(`android.adaptive.${key}`, source, true, key === 'background', 108));
+            }
+        }
+    }
+    else if (options.platform === 'browser') {
+        const icon = (_k = (_j = manifest.web) === null || _j === void 0 ? void 0 : _j.icon) !== null && _k !== void 0 ? _k : manifest.icon;
+        images.set('icon', await image('web.icon (or icon)', icon, true, false, 512));
+        images.set('apple-touch-icon', await image('web.appleTouchIcon (or web.icon/icon)', (_m = (_l = manifest.web) === null || _l === void 0 ? void 0 : _l.appleTouchIcon) !== null && _m !== void 0 ? _m : icon, true, true, 180));
+        images.set('favicon', await image('web.favicon (or web.icon/icon)', (_p = (_o = manifest.web) === null || _o === void 0 ? void 0 : _o.favicon) !== null && _p !== void 0 ? _p : icon, true, false, 32));
+        if ((_q = manifest.web) === null || _q === void 0 ? void 0 : _q.maskableIcon)
+            images.set('maskable', await image('web.maskableIcon', manifest.web.maskableIcon, true, true, 512));
+    }
+    else if (options.platform === 'roku') {
+        if (!((_s = (_r = manifest.roku) === null || _r === void 0 ? void 0 : _r.channel) === null || _s === void 0 ? void 0 : _s.hd))
+            throw new Error(`${context}: missing required roku.channel.hd source. Supply channel artwork explicitly.`);
+        if (!manifest.roku.channel.fhd)
+            throw new Error(`${context}: missing required roku.channel.fhd source. Supply the approved 540x405 channel artwork explicitly.`);
+        if (manifest.roku.splash && !manifest.roku.splash.sd)
+            throw new Error(`${context}: missing required roku.splash.sd source. Supply the approved 720x480 splash composition.`);
+        for (const role of ['channel', 'splash']) {
+            const values = (_t = manifest.roku) === null || _t === void 0 ? void 0 : _t[role];
+            if (!values)
+                continue;
+            const dimensions = role === 'channel'
+                ? { hd: [290, 218], fhd: [540, 405] }
+                : { sd: [720, 480], hd: [1280, 720], fhd: [1920, 1080] };
+            for (const [resolution, [width, height]] of Object.entries(dimensions)) {
+                const source = values[resolution];
+                if (!source)
+                    continue;
+                const rolePath = `roku.${role}.${resolution}`;
+                const decoded = await image(rolePath, source, false, true);
+                if (decoded.width !== width || decoded.height !== height)
+                    throw new Error(`${context}: ${rolePath} must be exactly ${width}x${height}; got ${decoded.width}x${decoded.height} from ${source}. Supply the approved composition; artwork preparation does not crop.`);
+                images.set(`${role}-${resolution}`, decoded);
+            }
+        }
+    }
+    else {
+        if (!((_u = manifest.appleTv) === null || _u === void 0 ? void 0 : _u.assetCatalog))
+            throw new Error(`${context}: missing required appleTv.assetCatalog. Supply an approved layered icon and top-shelf catalog; a splash screenshot is not an icon.`);
+        try {
+            tvCatalog = await readTvCatalog(cwd, path_1.default.resolve(path_1.default.dirname(manifestPath), manifest.appleTv.assetCatalog), manifest.appleTv.appIconName, read);
+        }
+        catch (error) {
+            throw new Error(`${context}: invalid appleTv.assetCatalog: ${errorMessage(error)}`);
+        }
+    }
+    const screen = options.platform === 'ios' ? (_v = manifest.ios) === null || _v === void 0 ? void 0 : _v.launchScreen
+        : options.platform === 'apple-tv' ? (_w = manifest.appleTv) === null || _w === void 0 ? void 0 : _w.launchScreen
+            : options.platform === 'android' ? (_x = manifest.android) === null || _x === void 0 ? void 0 : _x.launchScreen
+                : options.platform === 'android-tv' ? (_y = manifest.androidTv) === null || _y === void 0 ? void 0 : _y.launchScreen
+                    : options.platform === 'browser' ? (_z = manifest.web) === null || _z === void 0 ? void 0 : _z.loadingScreen : undefined;
+    if (screen) {
+        if ('image' in screen)
+            images.set('launch', await image(`${options.platform}.launch/loadingScreen.image`, screen.image));
+        else if (screen.icon)
+            images.set('launch', await image(`${options.platform}.launchScreen.icon`, screen.icon, true, false, 192));
+        else
+            images.set('launch', images.get('icon'));
+    }
+    const sourceList = [...sources.values()].sort((a, b) => projectRelative(cwd, a.path).localeCompare(projectRelative(cwd, b.path)));
+    const inputHash = digest(JSON.stringify({
+        recipeVersion: RECIPE_VERSION, app: options.app, platform: options.platform,
+        sources: sourceList.map(source => ({ path: projectRelative(cwd, source.path), sha256: source.sha256 })),
+    }));
+    const outputDir = path_1.default.join(cwd, '.hosanna-tools/artwork', options.app, options.platform, inputHash);
+    ensureOutputParents(cwd, outputDir);
+    const result = resultFor(cwd, options, manifestPath, inputHash, outputDir, images, screen === null || screen === void 0 ? void 0 : screen.backgroundColor);
+    if (validReceipt(outputDir, inputHash))
+        return result;
+    const temporary = fs_1.default.mkdtempSync(path_1.default.join(path_1.default.dirname(outputDir), '.prepare-'));
+    try {
+        const write = (relative, contents) => {
+            const destination = path_1.default.join(temporary, relative);
+            fs_1.default.mkdirSync(path_1.default.dirname(destination), { recursive: true });
+            fs_1.default.writeFileSync(destination, contents);
+        };
+        const png = async (role, relative, width, height = width, opaque = false) => {
+            const source = images.get(role);
+            let raster = (0, sharp_1.default)(source.contents, { failOn: 'warning' });
+            if (width !== undefined)
+                raster = raster.resize(width, height, { fit: 'fill' }); // callers validate matching aspect first
+            if (opaque)
+                raster = raster.removeAlpha();
+            write(relative, await raster.png().toBuffer());
+        };
+        if (result.apple && options.platform === 'ios') {
+            for (const [name, platform] of [[result.apple.appIconName, 'ios'], [result.apple.watchAppIconName, 'watchos']]) {
+                const directory = `Assets.xcassets/${name}.appiconset`;
+                await png('icon', `${directory}/icon-1024.png`, 1024, 1024, true);
+                write(`${directory}/Contents.json`, json({ images: [{ filename: 'icon-1024.png', idiom: 'universal', platform, size: '1024x1024' }], info: { author: 'xcode', version: 1 } }));
+            }
+            write('Assets.xcassets/Contents.json', json({ info: { author: 'xcode', version: 1 } }));
+        }
+        else if (result.apple && tvCatalog) {
+            write('Assets.xcassets/Contents.json', json({ info: { author: 'xcode', version: 1 } }));
+            for (const source of tvCatalog.files)
+                write(`Assets.xcassets/${result.apple.appIconName}.brandassets/${path_1.default.relative(tvCatalog.root, source.path)}`, source.contents);
+        }
+        else if (result.android) {
+            const name = result.android.iconResource.slice('@mipmap/'.length);
+            for (const [density, size] of [['mdpi', 48], ['hdpi', 72], ['xhdpi', 96], ['xxhdpi', 144], ['xxxhdpi', 192]]) {
+                await png('icon', `res/mipmap-${density}/${name}.png`, size);
+            }
+            if (images.has('banner'))
+                await png('banner', `res/drawable-xhdpi/${result.android.bannerResource.slice('@drawable/'.length)}.png`, 320, 180, true);
+            if (images.has('foreground')) {
+                for (const role of ['foreground', 'background', 'monochrome']) {
+                    if (images.has(role))
+                        await png(role, `res/drawable-nodpi/${name}_${role}.png`, 432, 432, role === 'background');
+                }
+                const adaptive = (monochrome) => `<?xml version="1.0" encoding="utf-8"?>\n<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">\n  <background android:drawable="@drawable/${name}_background" />\n  <foreground android:drawable="@drawable/${name}_foreground" />\n${monochrome ? `  <monochrome android:drawable="@drawable/${name}_monochrome" />\n` : ''}</adaptive-icon>\n`;
+                write(`res/mipmap-anydpi-v26/${name}.xml`, adaptive(false));
+                if (images.has('monochrome'))
+                    write(`res/mipmap-anydpi-v33/${name}.xml`, adaptive(true));
+            }
+        }
+        else if (result.web) {
+            await png('icon', 'web/icon-192.png', 192);
+            await png('icon', 'web/icon-512.png', 512);
+            await png('apple-touch-icon', 'web/apple-touch-icon-180.png', 180, 180, true);
+            await png('favicon', 'web/favicon-32.png', 32);
+            if (images.has('maskable'))
+                await png('maskable', 'web/icon-maskable-512.png', 512, 512, true);
+        }
+        else if (result.roku) {
+            for (const key of images.keys())
+                await png(key, `roku/images/${key}.png`, undefined, undefined, true);
+        }
+        if ((_0 = result.apple) === null || _0 === void 0 ? void 0 : _0.launchScreen) {
+            const launch = result.apple.launchScreen;
+            const imageSet = `Assets.xcassets/${launch.imageName}.imageset`;
+            await png('launch', `${imageSet}/launch.png`);
+            write(`${imageSet}/Contents.json`, json({ images: [{ filename: 'launch.png', idiom: 'universal' }], info: { author: 'xcode', version: 1 } }));
+            write(`apple/${launch.storyboardName}.storyboard`, launchStoryboard(launch, images.get('launch'), options.platform === 'apple-tv'));
+        }
+        if ((_1 = result.android) === null || _1 === void 0 ? void 0 : _1.launchScreen) {
+            // Android masks its OS splash icon. Contain the complete supplied image in
+            // the documented 192dp circular safe area; the square's diagonal fits
+            // inside that circle, so even fully opaque source corners remain visible.
+            const launch = images.get('launch');
+            const bytes = await (0, sharp_1.default)(launch.contents).resize(135, 135).extend({ top: 76, bottom: 77, left: 76, right: 77, background: '#00000000' }).png().toBuffer();
+            write(`res/drawable-mdpi/${result.android.launchScreen.iconResource.slice('@drawable/'.length)}.png`, bytes);
+        }
+        if ((_2 = result.web) === null || _2 === void 0 ? void 0 : _2.loadingScreen)
+            await png('launch', 'web/loading-screen.png');
+        const receipt = {
+            schemaVersion: 1, recipeVersion: RECIPE_VERSION, app: options.app, platform: options.platform, inputHash,
+            sources: sourceList.map(source => ({ path: projectRelative(cwd, source.path), sha256: source.sha256 })),
+            outputs: filesIn(temporary).map(file => {
+                const contents = fs_1.default.readFileSync(file);
+                return { path: projectRelative(temporary, file), sha256: digest(contents), bytes: contents.length };
+            }),
+        };
+        write('receipt.json', json(receipt));
+        // Never expose an incomplete directory. A concurrent identical preparation can win.
+        if (fs_1.default.existsSync(outputDir)) {
+            if (validReceipt(outputDir, inputHash))
+                return result;
+            fs_1.default.rmSync(outputDir, { recursive: true, force: true });
+        }
+        try {
+            fs_1.default.renameSync(temporary, outputDir);
+        }
+        catch (error) {
+            if (!validReceipt(outputDir, inputHash))
+                throw error;
+        }
+        return result;
+    }
+    finally {
+        fs_1.default.rmSync(temporary, { recursive: true, force: true });
+    }
+}
+function resultFor(cwd, options, manifestPath, inputHash, outputDir, images, backgroundColor) {
+    const result = { schemaVersion: 1, app: options.app, platform: options.platform, manifestPath, inputHash, outputDir, receiptPath: path_1.default.join(outputDir, 'receipt.json') };
+    const suffix = inputHash.slice(0, 16);
+    if (options.platform === 'ios' || options.platform === 'apple-tv') {
+        result.apple = Object.assign({ assetCatalogPath: path_1.default.join(outputDir, 'Assets.xcassets'), appIconName: `HstAppIcon_${suffix}` }, (options.platform === 'ios' ? { watchAppIconName: `HstWatchAppIcon_${suffix}` } : {}));
+        if (backgroundColor)
+            result.apple.launchScreen = { storyboardPath: path_1.default.join(outputDir, 'apple', `HstLaunch_${suffix}.storyboard`),
+                storyboardName: `HstLaunch_${suffix}`, imageName: `HstLaunchImage_${suffix}`, backgroundColor };
+    }
+    else if (options.platform === 'android' || options.platform === 'android-tv') {
+        result.android = Object.assign({ resourceDirectory: path_1.default.join(outputDir, 'res'), iconResource: `@mipmap/hst_app_icon_${suffix}` }, (options.platform === 'android-tv' ? { bannerResource: `@drawable/hst_app_banner_${suffix}` } : {}));
+        if (backgroundColor)
+            result.android.launchScreen = { iconResource: `@drawable/hst_launch_icon_${suffix}`, backgroundColor };
+    }
+    else if (options.platform === 'browser') {
+        const publicRoot = `/_hosanna/artwork/${options.app}/${inputHash}`;
+        const icon = (filename, size, purpose) => ({ source: projectRelative(cwd, path_1.default.join(outputDir, 'web', filename)), src: `${publicRoot}/${filename}`, sizes: `${size}x${size}`, type: 'image/png', purpose });
+        result.web = Object.assign({ icons: [icon('icon-192.png', 192, 'any'), icon('icon-512.png', 512, 'any'), icon('apple-touch-icon-180.png', 180, 'any'),
+                ...(images.has('maskable') ? [icon('icon-maskable-512.png', 512, 'maskable')] : [])], appleTouchIcon: `${publicRoot}/apple-touch-icon-180.png`, favicon: { source: projectRelative(cwd, path_1.default.join(outputDir, 'web/favicon-32.png')), src: `${publicRoot}/favicon-32.png` } }, (backgroundColor ? { loadingScreen: { source: projectRelative(cwd, path_1.default.join(outputDir, 'web/loading-screen.png')), src: `${publicRoot}/loading-screen.png`, backgroundColor } } : {}));
+    }
+    else {
+        const files = [];
+        const manifestValues = {};
+        for (const key of images.keys()) {
+            const [role, resolution] = key.split('-');
+            const packagePath = `images/hst-artwork/${options.app}/${inputHash}/${key}.png`;
+            files.push({ source: path_1.default.join(outputDir, 'roku/images', `${key}.png`), path: packagePath });
+            manifestValues[`${role === 'channel' ? 'mm_icon_focus' : 'splash_screen'}_${resolution}`] = `pkg:/${packagePath}`;
+        }
+        result.roku = { files, manifestValues };
+    }
+    return result;
+}
+function launchStoryboard(launch, image, tv) {
+    const [red, green, blue] = [1, 3, 5].map(index => parseInt(launch.backgroundColor.slice(index, index + 2), 16) / 255);
+    const width = tv ? 1920 : 375;
+    const height = tv ? 1080 : 667;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<document type="${tv ? 'com.apple.InterfaceBuilder.AppleTV.Storyboard' : 'com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB'}" version="3.0" toolsVersion="13122.16" targetRuntime="${tv ? 'AppleTV' : 'iOS.CocoaTouch'}" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" colorMatched="YES" initialViewController="hst-controller">
+  <dependencies><plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/><capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/></dependencies>
+  <scenes><scene sceneID="hst-scene"><objects>
+    <viewController id="hst-controller" sceneMemberID="viewController"><view key="view" contentMode="scaleToFill" id="hst-root">
+      <rect key="frame" x="0" y="0" width="${width}" height="${height}"/><autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+      <subviews><imageView userInteractionEnabled="NO" contentMode="scaleAspectFit" image="${launch.imageName}" translatesAutoresizingMaskIntoConstraints="NO" id="hst-image"><rect key="frame" x="0" y="0" width="${width}" height="${height}"/></imageView></subviews>
+      <color key="backgroundColor" red="${red}" green="${green}" blue="${blue}" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+      <constraints><constraint firstItem="hst-image" firstAttribute="leading" secondItem="hst-root" secondAttribute="leading" id="hst-leading"/><constraint firstItem="hst-image" firstAttribute="trailing" secondItem="hst-root" secondAttribute="trailing" id="hst-trailing"/><constraint firstItem="hst-image" firstAttribute="top" secondItem="hst-root" secondAttribute="top" id="hst-top"/><constraint firstItem="hst-image" firstAttribute="bottom" secondItem="hst-root" secondAttribute="bottom" id="hst-bottom"/></constraints>
+    </view></viewController><placeholder placeholderIdentifier="IBFirstResponder" id="hst-responder" sceneMemberID="firstResponder"/>
+  </objects></scene></scenes><resources><image name="${launch.imageName}" width="${image.width}" height="${image.height}"/></resources>
+</document>\n`;
+}
+/** Validate the generic local manifest shape before an app-owned downloader activates it. */
+function validateAppArtworkManifest(value) {
+    const object = checkedObject(value, 'manifest', ['schemaVersion', 'icon', 'ios', 'android', 'androidTv', 'appleTv', 'roku', 'web']);
+    if (object.schemaVersion !== 1)
+        throw new Error('schemaVersion must be 1.');
+    checkSource(object, 'icon', 'icon');
+    for (const [section, fields] of Object.entries({ ios: ['icon', 'launchScreen'], android: ['icon', 'adaptive', 'launchScreen'], androidTv: ['icon', 'banner', 'launchScreen'], appleTv: ['assetCatalog', 'appIconName', 'launchScreen'], roku: ['channel', 'splash'], web: ['icon', 'maskableIcon', 'appleTouchIcon', 'favicon', 'loadingScreen'] })) {
+        if (object[section] === undefined)
+            continue;
+        const values = checkedObject(object[section], section, fields);
+        for (const field of fields) {
+            if (field === 'launchScreen' || field === 'loadingScreen') {
+                if (values[field] === undefined)
+                    continue;
+                const android = section === 'android' || section === 'androidTv';
+                const screen = checkedObject(values[field], `${section}.${field}`, [android ? 'icon' : 'image', 'backgroundColor']);
+                checkSource(screen, android ? 'icon' : 'image', `${section}.${field}.${android ? 'icon' : 'image'}`);
+                if (!android && !screen.image)
+                    throw new Error(`${section}.${field}.image is required.`);
+                if (typeof screen.backgroundColor !== 'string' || !/^#[0-9a-fA-F]{6}$/.test(screen.backgroundColor))
+                    throw new Error(`${section}.${field}.backgroundColor must be an opaque #RRGGBB color.`);
+            }
+            else if (field === 'adaptive') {
+                if (values.adaptive === undefined)
+                    continue;
+                const adaptive = checkedObject(values.adaptive, 'android.adaptive', ['foreground', 'background', 'monochrome']);
+                for (const key of ['foreground', 'background', 'monochrome'])
+                    checkSource(adaptive, key, `android.adaptive.${key}`);
+                if (!adaptive.foreground || !adaptive.background)
+                    throw new Error('android.adaptive requires foreground and background sources.');
+            }
+            else if (section === 'roku') {
+                if (values[field] === undefined)
+                    continue;
+                const resolutions = checkedObject(values[field], `roku.${field}`, field === 'channel' ? ['hd', 'fhd'] : ['sd', 'hd', 'fhd']);
+                for (const resolution of ['sd', 'hd', 'fhd'])
+                    checkSource(resolutions, resolution, `roku.${field}.${resolution}`);
+                if (!resolutions.hd)
+                    throw new Error(`roku.${field}.hd is required when ${field} is configured.`);
+            }
+            else
+                checkSource(values, field, `${section}.${field}`);
+        }
+    }
+    return object;
+}
+function checkedObject(value, label, keys) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${label} must be an object.`);
+    for (const key of Object.keys(value))
+        if (!keys.includes(key))
+            throw new Error(`Unknown artwork field: ${label}.${key}`);
+    return value;
+}
+function checkSource(object, key, label) {
+    const value = object[key];
+    if (value === undefined)
+        return;
+    if (typeof value !== 'string' || !value.trim() || value !== value.trim() || value.includes('\0') || /^(?:[a-z]+:|\/|\\)/i.test(value))
+        throw new Error(`${label} must be a non-empty relative local source path.`);
+}
+async function readTvCatalog(cwd, input, name, read) {
+    let root = insideDirectory(cwd, input, 'Apple TV asset catalog');
+    if (root.endsWith('.xcassets')) {
+        const candidates = fs_1.default.readdirSync(root).filter(entry => entry.endsWith('.brandassets'));
+        const selected = name ? `${name.replace(/\.brandassets$/, '')}.brandassets` : candidates.length === 1 ? candidates[0] : undefined;
+        if (!selected || !candidates.includes(selected))
+            throw new Error('Specify appIconName matching one .brandassets set in the catalog.');
+        root = insideDirectory(cwd, path_1.default.join(root, selected), 'Apple TV brand assets');
+    }
+    if (!root.endsWith('.brandassets'))
+        throw new Error('assetCatalog must be a .xcassets catalog or a .brandassets directory.');
+    const files = filesIn(root).map(file => read(file));
+    const byPath = new Map(files.map(file => [file.path, file]));
+    const contents = (directory) => {
+        const file = byPath.get(path_1.default.join(directory, 'Contents.json'));
+        if (!file)
+            throw new Error(`Missing Contents.json: ${directory}`);
+        const value = JSON.parse(file.contents.toString('utf8'));
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error(`Invalid Contents.json: ${directory}`);
+        return value;
+    };
+    const child = (directory, value) => {
+        if (typeof value !== 'string' || !value || path_1.default.basename(value) !== value || value === '.' || value === '..')
+            throw new Error(`Catalog filename must name a child of ${directory}`);
+        return path_1.default.join(directory, value);
+    };
+    const validateImages = async (directory, width, height, opaque) => {
+        const entries = contents(directory).images;
+        if (!Array.isArray(entries) || entries.length === 0)
+            throw new Error(`Missing image entries: ${directory}`);
+        for (const entry of entries) {
+            const filePath = child(directory, entry.filename);
+            const file = byPath.get(filePath);
+            if (!file)
+                throw new Error(`Referenced artwork is missing: ${filePath}`);
+            const scale = entry.scale === undefined ? 1 : entry.scale === '1x' ? 1 : entry.scale === '2x' ? 2 : undefined;
+            if (!scale)
+                throw new Error(`Unsupported TV image scale: ${String(entry.scale)}`);
+            const metadata = await (0, sharp_1.default)(file.contents, { failOn: 'warning' }).metadata();
+            const stats = await (0, sharp_1.default)(file.contents, { failOn: 'warning' }).stats();
+            if (metadata.format !== 'png' || metadata.width !== width * scale || metadata.height !== height * scale)
+                throw new Error(`Expected ${width * scale}x${height * scale} PNG at ${filePath}; got ${metadata.width}x${metadata.height}.`);
+            if (opaque && !stats.isOpaque)
+                throw new Error(`TV background/top-shelf artwork must be opaque: ${filePath}`);
+        }
+    };
+    const assets = contents(root).assets;
+    if (!Array.isArray(assets))
+        throw new Error('TV brand assets require assets entries.');
+    const icons = assets.filter(asset => asset.role === 'primary-app-icon');
+    if (!icons.some(asset => asset.size === '400x240') || !icons.some(asset => asset.size === '1280x768'))
+        throw new Error('TV brand assets require 400x240 launcher and 1280x768 App Store image stacks.');
+    if (!assets.some(asset => asset.role === 'top-shelf-image' || asset.role === 'top-shelf-image-wide'))
+        throw new Error('TV brand assets require explicit top-shelf artwork.');
+    for (const asset of assets) {
+        const size = typeof asset.size === 'string' ? /^(\d+)x(\d+)$/.exec(asset.size) : null;
+        if (!size)
+            throw new Error(`Missing catalog asset size for ${String(asset.filename)}`);
+        const directory = child(root, asset.filename);
+        if (asset.role === 'primary-app-icon') {
+            const layers = contents(directory).layers;
+            if (!Array.isArray(layers) || layers.length < 2 || layers.length > 5)
+                throw new Error(`TV image stack requires two to five explicit layers: ${directory}`);
+            for (const [index, layer] of layers.entries()) {
+                const layerDirectory = child(directory, layer.filename);
+                contents(layerDirectory);
+                const imageSets = fs_1.default.readdirSync(layerDirectory).filter(entry => entry.endsWith('.imageset'));
+                if (imageSets.length !== 1)
+                    throw new Error(`TV layer must contain one image set: ${layerDirectory}`);
+                await validateImages(path_1.default.join(layerDirectory, imageSets[0]), Number(size[1]), Number(size[2]), index === layers.length - 1);
+            }
+        }
+        else if (asset.role === 'top-shelf-image' || asset.role === 'top-shelf-image-wide') {
+            await validateImages(directory, Number(size[1]), Number(size[2]), true);
+        }
+        else
+            throw new Error(`Unsupported TV brand asset role: ${String(asset.role)}`);
+    }
+    return { root, files };
+}
+function validReceipt(outputDir, inputHash) {
+    try {
+        if (fs_1.default.lstatSync(outputDir).isSymbolicLink())
+            return false;
+        const receipt = JSON.parse(fs_1.default.readFileSync(path_1.default.join(outputDir, 'receipt.json'), 'utf8'));
+        if (receipt.recipeVersion !== RECIPE_VERSION || receipt.inputHash !== inputHash || !Array.isArray(receipt.outputs) || !receipt.outputs.length)
+            return false;
+        const actual = filesIn(outputDir).filter(file => path_1.default.basename(file) !== 'receipt.json');
+        if (actual.length !== receipt.outputs.length)
+            return false;
+        return receipt.outputs.every(output => {
+            const file = insideFile(outputDir, path_1.default.resolve(outputDir, output.path), 'generated artwork');
+            const contents = fs_1.default.readFileSync(file);
+            return contents.length === output.bytes && digest(contents) === output.sha256;
+        });
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function ensureOutputParents(cwd, outputDir) {
+    let current = cwd;
+    for (const segment of path_1.default.relative(cwd, outputDir).split(path_1.default.sep)) {
+        current = path_1.default.join(current, segment);
+        if (fs_1.default.existsSync(current) && fs_1.default.lstatSync(current).isSymbolicLink())
+            throw new Error(`Refusing artwork output through a symbolic link: ${current}`);
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(outputDir), { recursive: true });
+}
+function insideFile(root, file, label) {
+    assertInside(root, file, label);
+    if (!fs_1.default.existsSync(file) || !fs_1.default.statSync(file).isFile())
+        throw new Error(`${label}: file not found: ${file}`);
+    const real = fs_1.default.realpathSync(file);
+    assertInside(root, real, label);
+    return real;
+}
+function insideDirectory(root, directory, label) {
+    assertInside(root, directory, label);
+    if (!fs_1.default.existsSync(directory) || !fs_1.default.statSync(directory).isDirectory())
+        throw new Error(`${label}: directory not found: ${directory}`);
+    const real = fs_1.default.realpathSync(directory);
+    assertInside(root, real, label);
+    return real;
+}
+function assertInside(root, candidate, label) {
+    const relative = path_1.default.relative(root, candidate);
+    if (relative === '' || (!relative.startsWith(`..${path_1.default.sep}`) && relative !== '..' && !path_1.default.isAbsolute(relative)))
+        return;
+    throw new Error(`${label}: path is outside project root: ${candidate}`);
+}
+function filesIn(root) {
+    const files = [];
+    for (const entry of fs_1.default.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = path_1.default.join(root, entry.name);
+        if (entry.isSymbolicLink())
+            throw new Error(`Artwork directories must not contain symbolic links: ${file}`);
+        if (entry.isDirectory())
+            files.push(...filesIn(file));
+        else if (entry.isFile())
+            files.push(file);
+    }
+    return files;
+}
+function digest(contents) { return crypto_1.default.createHash('sha256').update(contents).digest('hex'); }
+function json(value) { return `${JSON.stringify(value, undefined, 2)}\n`; }
+function projectRelative(root, file) { return path_1.default.relative(root, file).split(path_1.default.sep).join('/'); }
+function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
+//# sourceMappingURL=app-artwork.js.map