@martini-film/cli 0.4.0 → 0.4.2

package/dist/graphics/project.js

@@ -0,0 +1,626 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
+import { ARTIFACT_MAX_DURATION_SECONDS, ARTIFACT_MIN_DURATION_SECONDS, encodedBundleBytes, extensionOf, formatMB, isSafeHyperframesPath, MAX_ASSET_REFS, MAX_BUNDLE_BYTES, MAX_BUNDLE_FILE_BYTES, MAX_DIMENSION, MAX_DURATION_SECONDS, MAX_MEDIA_BYTES, MAX_PATH_LENGTH, MAX_PROJECT_FILES, MAX_TEXT_FILE_BYTES, MIN_DIMENSION, MIN_DURATION_SECONDS, mediaTypeOf, PROJECT_FONT_EXTENSIONS, PROJECT_TEXT_EXTENSIONS, UPLOAD_CAP, } from './limits.js';
+import { GRAPHIC_MANIFEST_FILE, issue, matchesAny, } from './manifest.js';
+const SKIPPED_NAMES = new Set(['node_modules', 'venv', '__pycache__', '__MACOSX']);
+function toPosix(path) {
+    return path.split(sep).join('/');
+}
+function inside(parent, child) {
+    const rel = relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+export function recipeDirsInside(dir, manifest) {
+    const root = resolve(dir);
+    const dirs = [];
+    for (const media of manifest?.media ?? []) {
+        if (!media.recipe)
+            continue;
+        const abs = resolve(root, media.recipe.dir);
+        if (abs !== root && inside(root, abs))
+            dirs.push(toPosix(relative(root, abs)));
+    }
+    return dirs;
+}
+export function walkProject(dir, manifest) {
+    const root = realpathSync(resolve(dir));
+    const recipeDirs = recipeDirsInside(root, manifest);
+    const files = [];
+    const warnings = [];
+    const visited = new Set();
+    const visit = (abs, rel) => {
+        const real = realpathSync(abs);
+        if (visited.has(real))
+            return;
+        visited.add(real);
+        for (const entry of readdirSync(abs, { withFileTypes: true })) {
+            const name = entry.name;
+            const path = rel ? `${rel}/${name}` : name;
+            if (name.startsWith('.') || SKIPPED_NAMES.has(name) || /\.pyc$/i.test(name))
+                continue;
+            if (/\.(md|txt)$/i.test(name))
+                continue;
+            if (path === GRAPHIC_MANIFEST_FILE)
+                continue;
+            if (matchesAny(path, manifest?.exclude))
+                continue;
+            if (recipeDirs.some(recipe => path === recipe || path.startsWith(`${recipe}/`)))
+                continue;
+            const full = join(abs, name);
+            let isDir = entry.isDirectory();
+            let isFile = entry.isFile();
+            if (entry.isSymbolicLink()) {
+                let target;
+                try {
+                    target = realpathSync(full);
+                }
+                catch {
+                    warnings.push(issue('SYMLINK_SKIPPED', `${path} is a broken symlink.`, 'Remove it or point it at a file in the project.', path, 'warning'));
+                    continue;
+                }
+                if (!inside(root, target)) {
+                    warnings.push(issue('SYMLINK_SKIPPED', `${path} links outside the project and was not sent.`, 'Copy the file into the project instead of linking it.', path, 'warning'));
+                    continue;
+                }
+                const stats = statSync(target);
+                isDir = stats.isDirectory();
+                isFile = stats.isFile();
+            }
+            if (isDir)
+                visit(full, path);
+            else if (isFile)
+                files.push({ path, abs: full, bytes: statSync(full).size });
+        }
+    };
+    visit(root, '');
+    files.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    return { files, warnings };
+}
+const HYPERFRAMES_MARKER = /data-composition-id\s*=|data-root\s*=\s*["']?true|data-clock\s*=/i;
+const WINDOW_FUNCTION = /\bwindow\.(?!on[a-z])[A-Za-z_$][\w$]*\s*=\s*(?:async\s+)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/;
+const CLOCK_ROOT_FIX = 'For a page that draws each frame from its own seek function, put data-composition-id, data-root="true", data-width/height/duration, data-clock="<fn>" (and optionally data-clock-ready) and data-no-timeline on the root element.';
+export function detectDoor(dir, flag, manifest) {
+    if (flag)
+        return { door: flag, reason: '--door' };
+    if (manifest?.door)
+        return { door: manifest.door, reason: GRAPHIC_MANIFEST_FILE };
+    const index = join(dir, 'index.html');
+    if (existsSync(index)) {
+        const html = readFileSync(index, 'utf8');
+        if (HYPERFRAMES_MARKER.test(html))
+            return { door: 'hyperframes', reason: 'index.html has a composition root' };
+        if (WINDOW_FUNCTION.test(html))
+            return {
+                door: 'artifact',
+                reason: 'index.html has no composition root',
+                warning: issue('SEEK_FUNCTION_WITHOUT_ROOT', 'index.html defines a window function but no composition root, so it is pushed as a web page artifact on a virtual clock; nothing calls a seek function there.', `To render it frame by frame from its seek function, add the clock root (see the martini-graphics skill) and push again, or pass --door hyperframes. ${CLOCK_ROOT_FIX}`, 'index.html', 'warning'),
+            };
+        return { door: 'artifact', reason: 'index.html has no composition root' };
+    }
+    if (existsSync(join(dir, 'App.jsx')) || existsSync(join(dir, 'App.tsx')))
+        return { door: 'artifact', reason: 'App.jsx/App.tsx' };
+    return {
+        error: issue('NO_ENTRY', 'The directory has no index.html, App.jsx or App.tsx at its root.', 'Run the push from the Graphic project directory (index.html at its root), or pass that directory.'),
+    };
+}
+function openingTags(html) {
+    return tokenizeHtml(html).map(element => element.tag);
+}
+function rootTag(html) {
+    const tags = openingTags(html);
+    return (tags.find(tag => /\sdata-root\s*=\s*["']?true\b/i.test(tag)) ??
+        tags.find(tag => /\sdata-composition-id\s*=/i.test(tag)));
+}
+function attribute(tag, name) {
+    const match = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, 'i').exec(tag);
+    return match ? (match[1] ?? match[2] ?? match[3]) : undefined;
+}
+function hasAttribute(tag, name) {
+    return new RegExp(`\\s${name}(?=\\s*=|[\\s/>])`, 'i').test(tag);
+}
+const VOID_TAGS = new Set('area base br col embed hr img input link meta param source track wbr'.split(' '));
+const RAW_TEXT_TAGS = new Set(['script', 'style', 'textarea', 'title']);
+function tokenizeHtml(html) {
+    const elements = [];
+    const stack = [];
+    const tags = /<!--[\s\S]*?(?:-->|$)|<![^>]*>|<\/?([a-zA-Z][\w:-]*)(?=[\s/>])(?:"[^"]*"|'[^']*'|[^'">])*>/g;
+    let match;
+    while ((match = tags.exec(html))) {
+        if (!match[1])
+            continue;
+        const tag = match[0];
+        const name = match[1].toLowerCase();
+        if (tag.startsWith('</')) {
+            const top = stack.at(-1);
+            if (top?.name === name) {
+                top.closed = true;
+                top.contentEnd = match.index;
+                top.end = tags.lastIndex;
+                stack.pop();
+            }
+            continue;
+        }
+        const parent = stack.at(-1);
+        const foreign = name === 'svg' || name === 'math' || (parent?.foreign === true && parent.name !== 'foreignobject');
+        const element = {
+            tag,
+            name,
+            start: match.index,
+            end: tags.lastIndex,
+            contentEnd: tags.lastIndex,
+            closed: VOID_TAGS.has(name) || (foreign && /\/\s*>$/.test(tag)),
+            parent,
+            foreign,
+        };
+        elements.push(element);
+        if (VOID_TAGS.has(name) || (foreign && /\/\s*>$/.test(tag)))
+            continue;
+        if (RAW_TEXT_TAGS.has(name)) {
+            const close = new RegExp(`</${name}(?=[\\t\\n\\f\\r />])(?:"[^"]*"|'[^']*'|[^'">])*>`, 'gi');
+            close.lastIndex = tags.lastIndex;
+            const closing = close.exec(html);
+            element.closed = closing !== null;
+            element.contentEnd = closing?.index ?? html.length;
+            element.end = closing ? close.lastIndex : html.length;
+            tags.lastIndex = element.end;
+        }
+        else
+            stack.push(element);
+    }
+    return elements;
+}
+function entryChildren(html) {
+    const elements = tokenizeHtml(html);
+    const rootSpan = elements.find(element => attribute(element.tag, 'data-root') === 'true') ??
+        elements.find(element => hasAttribute(element.tag, 'data-composition-id'));
+    for (const element of elements) {
+        if (element.closed)
+            continue;
+        for (let ancestor = element; ancestor; ancestor = ancestor.parent) {
+            if (ancestor === rootSpan)
+                throw new Error('SPLIT_EXPLICIT_CLOSING_TAGS: Add explicit closing tags to the composition root and every non-void element inside it before splitting.');
+        }
+    }
+    const children = rootSpan ? elements.filter(element => element.parent === rootSpan) : [];
+    const pieces = children.filter(element => element.name !== 'script' && hasAttribute(element.tag, 'data-start'));
+    const allScripts = elements
+        .filter(element => element.name === 'script')
+        .map(element => ({
+        tag: html.slice(element.start, element.end),
+        start: element.start,
+        end: element.end,
+    }));
+    const scripts = children
+        .filter(element => element.name === 'script')
+        .map(element => html.slice(element.start, element.end));
+    return { root: rootSpan?.tag, rootSpan, tags: pieces.map(piece => piece.tag), pieces, scripts, allScripts };
+}
+export function readEntryPieces(indexHtml) {
+    const { root, tags } = entryChildren(indexHtml);
+    const rootDuration = Number(root === undefined ? NaN : attribute(root, 'data-duration'));
+    return tags.map(tag => ({
+        ...(attribute(tag, 'id') !== undefined ? { id: attribute(tag, 'id') } : {}),
+        start: Number(attribute(tag, 'data-start')),
+        duration: Number(attribute(tag, 'data-duration') ?? rootDuration - Number(attribute(tag, 'data-start'))),
+        ...(attribute(tag, 'data-composition-src') !== undefined
+            ? {
+                src: attribute(tag, 'data-composition-src'),
+                path: normalizeProjectPath(attribute(tag, 'data-composition-src')),
+            }
+            : {}),
+        kind: hasAttribute(tag, 'data-composition-src') ? 'sub-composition' : 'other',
+        tag,
+    }));
+}
+export function wrapPieceAsEntry(indexHtml, piece, rootDuration, files = []) {
+    const head = tokenizeHtml(indexHtml).find(element => element.name === 'head');
+    if (!head)
+        throw new Error('SPLIT_NO_HEAD: Add a head element containing the shared styles and GSAP library.');
+    const { root, rootSpan, pieces, scripts, allScripts } = entryChildren(indexHtml);
+    if (!root || !rootSpan || hasAttribute(root, 'data-clock'))
+        throw new Error('SPLIT_NEEDS_GSAP_DOOR: Split requires a HyperFrames root without data-clock.');
+    const warnings = [];
+    const keptScripts = [];
+    const registrations = [];
+    for (const script of allScripts) {
+        const src = attribute(script.tag, 'src');
+        const path = src && !/^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(src) ? normalizeProjectPath(src) : undefined;
+        const file = path ? files.find(file => file.path === path) : undefined;
+        const text = file ? readFileSync(file.abs, 'utf8') : scriptTexts('index.html', script.tag).join('\n');
+        if (/__timelines/.test(text)) {
+            warnings.push(`SPLIT_TIMELINE_SCRIPT_DROPPED: ${path ?? 'inline'} registers the root timeline; the wrapper registers its own.`);
+            registrations.push(script);
+        }
+        else
+            keptScripts.push(script.tag);
+    }
+    const remainingRootScripts = scripts.filter(script => keptScripts.includes(script));
+    if (piece.duration > MAX_DURATION_SECONDS)
+        throw new Error(`SPLIT_PIECE_TOO_LONG: ${piece.id} is ${piece.duration} s; a Graphic holds at most 90 s`);
+    const declaredDuration = Number(attribute(root, 'data-duration'));
+    if (!Number.isFinite(piece.start) ||
+        piece.start < 0 ||
+        !Number.isFinite(piece.duration) ||
+        piece.duration < MIN_DURATION_SECONDS ||
+        piece.duration > MAX_DURATION_SECONDS ||
+        (declaredDuration <= MAX_DURATION_SECONDS &&
+            piece.start + piece.duration > Math.min(rootDuration, declaredDuration)))
+        throw new Error('SPLIT_INVALID_TIMING: Give each piece a finite non-negative start and positive duration within the root duration.');
+    if (remainingRootScripts.some(script => !hasAttribute(script, 'src') && !scriptTexts('index.html', script).some(text => /\bgsap\b/.test(text))))
+        throw new Error('SPLIT_ROOT_SCRIPTS: Move root inline scripts into the sub-compositions; split drops root scripts and replaces the timeline registration.');
+    const opening = /\sdata-duration\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'>]+)/i.test(root)
+        ? root.replace(/(\sdata-duration\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s"'>]+)/i, `$1"${piece.duration}"`)
+        : root.replace(/>$/, ` data-duration="${piece.duration}">`);
+    const gsap = keptScripts.some(tag => /\bgsap\b/i.test(attribute(tag, 'src') ?? scriptTexts('index.html', tag).join('\n')))
+        ? ''
+        : '<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>';
+    const registration = `<script>document.addEventListener('DOMContentLoaded', () => { window.__timelines = window.__timelines || {}; window.__timelines[${JSON.stringify(attribute(root, 'data-composition-id') ?? 'main').replace(/</g, '\\u003c')}] = gsap.timeline({ paused: true }).to({}, { duration: ${piece.duration} }); });</script>`;
+    const edits = [
+        { start: rootSpan.start, end: rootSpan.start + root.length, text: opening },
+    ];
+    for (const child of pieces) {
+        edits.push({
+            start: child.start,
+            end: child.end,
+            text: child.tag === piece.tag
+                ? indexHtml
+                    .slice(child.start, child.end)
+                    .replace(/(\sdata-start\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s"'>]+)/i, '$1"0"')
+                : '',
+        });
+    }
+    let replacedInline = false;
+    for (const script of registrations) {
+        if (pieces.some(child => script.start >= child.start && script.end <= child.end))
+            continue;
+        const inline = !hasAttribute(script.tag, 'src');
+        edits.push({ start: script.start, end: script.end, text: inline ? registration : '' });
+        replacedInline ||= inline;
+    }
+    if (!replacedInline)
+        edits.push({ start: rootSpan.end, end: rootSpan.end, text: gsap + registration });
+    else if (gsap) {
+        const first = edits.find(edit => edit.text === registration);
+        first.text = gsap + first.text;
+    }
+    let html = indexHtml;
+    for (const edit of edits.sort((a, b) => b.start - a.start)) {
+        html = html.slice(0, edit.start) + edit.text + html.slice(edit.end);
+    }
+    return { html, droppedRootScripts: scripts.length, warnings };
+}
+function scriptTexts(path, text) {
+    const ext = extensionOf(path);
+    if (ext === 'js' || ext === 'mjs')
+        return [text];
+    if (ext === 'html' || ext === 'svg')
+        return tokenizeHtml(text)
+            .filter(element => element.name === 'script')
+            .map(element => text.slice(element.start + element.tag.length, element.contentEnd));
+    return [];
+}
+export function compositionRefsOf(path, files, entryHtml) {
+    const byPath = new Map(files.map(file => [file.path, file]));
+    const seen = new Set([path]);
+    const refs = new Set();
+    const entry = byPath.get(path);
+    if (!entry && entryHtml === undefined)
+        return refs;
+    const queue = [{ path, html: entryHtml ?? readFileSync(entry.abs, 'utf8') }];
+    while (queue.length) {
+        const current = queue.shift();
+        for (const tag of openingTags(current.html)) {
+            const src = attribute(tag, 'data-composition-src')?.replace(/[?#].*$/, '');
+            if (!src)
+                continue;
+            const rootPath = src.replace(/^\.?\//, '');
+            const relativePath = posix.normalize(posix.join(posix.dirname(current.path), src));
+            const file = byPath.get(rootPath) ?? byPath.get(relativePath);
+            if (!file || seen.has(file.path) || !/\.html?$/i.test(file.path))
+                continue;
+            seen.add(file.path);
+            refs.add(file.path);
+            queue.push({ path: file.path, html: readFileSync(file.abs, 'utf8') });
+        }
+    }
+    return refs;
+}
+export function normalizeProjectPath(src) {
+    let path = src.replace(/[?#].*$/, '');
+    try {
+        path = decodeURIComponent(path);
+    }
+    catch {
+    }
+    path = posix.normalize(path.replace(/^\.?\//, ''));
+    if (path.startsWith('..') || path === 'index.html')
+        throw new Error(`SPLIT_INVALID_SRC: ${src}; use a project file other than index.html.`);
+    return path;
+}
+export function sceneExclusions(files, pieces, piece) {
+    const candidates = new Set(pieces.map(item => item.path).filter((path) => Boolean(path) && path !== piece.path));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const file of files) {
+            if (file.path === 'index.html' ||
+                candidates.has(file.path) ||
+                !PROJECT_TEXT_EXTENSIONS.has(extensionOf(file.path)))
+                continue;
+            const text = readFileSync(file.abs, 'utf8');
+            for (const candidate of candidates) {
+                if (text.includes(candidate)) {
+                    candidates.delete(candidate);
+                    changed = true;
+                }
+            }
+        }
+    }
+    return candidates;
+}
+const CLOCK_IDENTIFIER = /^[A-Za-z_$][\w$]{0,63}$/;
+const RESERVED_CLOCK_NAME = /^__(?:hf|martini)|^__timelines$/;
+function clockNameProblem(name) {
+    if (name === undefined || !CLOCK_IDENTIFIER.test(name))
+        return 'is not a plain JavaScript identifier';
+    if (RESERVED_CLOCK_NAME.test(name) || name in Object.prototype)
+        return 'is a name Martini or the runtime reserves';
+    return undefined;
+}
+function clockIssues(root, html, files) {
+    const issues = [];
+    const notOnRoot = (path, entry) => issue('clock_not_on_entry_root', 'data-clock and data-clock-ready belong on the root element of index.html only.', entry
+        ? 'Move data-clock (and data-clock-ready) to the root composition element of index.html.'
+        : 'Remove data-clock from the sub-composition; declare the clock once on the root of index.html and draw every part from that function.', path);
+    const clockTag = (tag) => hasAttribute(tag, 'data-clock') || hasAttribute(tag, 'data-clock-ready');
+    if (openingTags(html).some(tag => tag !== root && clockTag(tag)))
+        issues.push(notOnRoot('index.html', true));
+    for (const path of compositionRefsOf('index.html', files, html)) {
+        const file = files.find(file => file.path === path);
+        if (openingTags(readFileSync(file.abs, 'utf8')).some(clockTag))
+            issues.push(notOnRoot(path, false));
+    }
+    const seek = hasAttribute(root, 'data-clock') ? (attribute(root, 'data-clock') ?? '') : undefined;
+    const ready = hasAttribute(root, 'data-clock-ready') ? (attribute(root, 'data-clock-ready') ?? '') : undefined;
+    if (seek === undefined && ready === undefined)
+        return issues;
+    const problems = [
+        seek === undefined ? 'data-clock is missing (data-clock-ready needs it)' : undefined,
+        seek !== undefined && clockNameProblem(seek) ? `data-clock="${seek}" ${clockNameProblem(seek)}` : undefined,
+        ready !== undefined && clockNameProblem(ready)
+            ? `data-clock-ready="${ready}" ${clockNameProblem(ready)}`
+            : undefined,
+    ].filter(Boolean);
+    if (problems.length) {
+        issues.push(issue('invalid_clock', `The root's custom clock is invalid: ${problems.join('; ')}.`, 'Set data-clock to the name of the window function that draws a frame for t seconds, e.g. data-clock="renderAt", and data-clock-ready (optional) to the name of a window promise, e.g. data-clock-ready="ready".', 'index.html'));
+        return issues;
+    }
+    const id = attribute(root, 'data-composition-id');
+    const quoted = id === undefined ? undefined : new RegExp(`(['"\`])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\1`);
+    const scripts = files
+        .filter(file => !file.path.startsWith('_vendor/') && /\.(?:html?|svg|m?js)$/i.test(file.path))
+        .flatMap(file => scriptTexts(file.path, readFileSync(file.abs, 'utf8')));
+    const registersRoot = quoted !== undefined && scripts.some(text => text.includes('__timelines') && quoted.test(text));
+    if (!hasAttribute(root, 'data-no-timeline') && !registersRoot)
+        issues.push(issue('clock_root_needs_no_timeline', 'A root with data-clock and no registered timeline must say so, or the renderer waits for a timeline forever.', 'Add data-no-timeline to the root element; a page driven by its own seek function registers no timeline.', 'index.html'));
+    return issues;
+}
+function hyperframesPathIssue(path) {
+    if (path.length > MAX_PATH_LENGTH)
+        return issue('invalid_path', `The path is longer than ${MAX_PATH_LENGTH} characters.`, 'Shorten the path.', path);
+    if (!isSafeHyperframesPath(path))
+        return issue('invalid_path', 'The file path is not a supported POSIX relative path.', 'Rename each path segment to start with an ASCII letter or digit and contain only letters, digits, dots, underscores or hyphens (no spaces), or add it to exclude in martini.graphic.json.', path);
+    return undefined;
+}
+const ARTIFACT_SAFE_PATH = /^(?:[A-Za-z0-9_-][A-Za-z0-9._ -]*\/)*[A-Za-z0-9_-][A-Za-z0-9._ -]*$/;
+const ARTIFACT_TEXT = new Set(['html', 'htm', 'css', 'js', 'mjs', 'jsx', 'ts', 'tsx', 'json', 'svg']);
+const ARTIFACT_IMAGES = new Set(['png', 'jpg', 'jpeg', 'webp']);
+export function localValidate(door, files, options = {}) {
+    const issues = [];
+    const refCount = options.refCount ?? 0;
+    if (files.length + refCount > MAX_PROJECT_FILES)
+        issues.push(issue('too_many_files', `The project has ${files.length + refCount} files including asset references; the cap is ${MAX_PROJECT_FILES}.`, `Reduce the project to at most ${MAX_PROJECT_FILES} files, or exclude what the composition does not load.`));
+    const unsupported = (path, ext, accepted) => issue('unsupported_file_type', `.${ext || '(none)'} files cannot be part of a Graphic.`, `Add "${path}" (or a glob for it) to exclude in martini.graphic.json, or convert it to one of: ${accepted}.`, path);
+    if (door === 'hyperframes') {
+        if (refCount > MAX_ASSET_REFS)
+            issues.push(issue('too_many_asset_refs', `${refCount} media references; the cap is ${MAX_ASSET_REFS}.`, 'Bundle some media instead of referencing it.'));
+        const index = files.find(file => file.path === 'index.html');
+        if (!index)
+            issues.push(issue('missing_entry', 'The project has no index.html entry.', 'Add index.html at the project root.'));
+        else {
+            const html = options.entryHtml ?? readFileSync(index.abs, 'utf8');
+            const tag = rootTag(html);
+            if (!tag)
+                issues.push(issue('missing_root', 'No top-level composition element was found.', /\sdata-clock\s*=/i.test(html) || WINDOW_FUNCTION.test(html)
+                    ? `Add data-composition-id and data-root="true" to the top-level composition element in index.html. ${CLOCK_ROOT_FIX}`
+                    : 'Add data-composition-id and data-root="true" to the top-level composition element in index.html.', 'index.html'));
+            else {
+                issues.push(...clockIssues(tag, html, files));
+                const width = Number(attribute(tag, 'data-width'));
+                const height = Number(attribute(tag, 'data-height'));
+                const seconds = Number(attribute(tag, 'data-duration'));
+                if (![width, height].every(n => Number.isInteger(n) && n >= MIN_DIMENSION && n <= MAX_DIMENSION && n % 2 === 0))
+                    issues.push(issue('invalid_dimensions', `Root dimensions must be even whole numbers from ${MIN_DIMENSION} to ${MAX_DIMENSION} pixels.`, 'Set data-width and data-height on the root element to the output size, e.g. data-width="1920" data-height="1080".', 'index.html'));
+                if (!(Number.isFinite(seconds) &&
+                    seconds >= MIN_DURATION_SECONDS &&
+                    (options.split || seconds <= MAX_DURATION_SECONDS)))
+                    issues.push(issue('invalid_duration', `Root duration must be ${MIN_DURATION_SECONDS}–${MAX_DURATION_SECONDS} seconds.`, 'Set data-duration on the root element to the total length in seconds.', 'index.html'));
+            }
+        }
+        for (const file of files) {
+            const pathIssue = hyperframesPathIssue(file.path);
+            if (pathIssue)
+                issues.push(pathIssue);
+            const ext = extensionOf(file.path);
+            if (PROJECT_TEXT_EXTENSIONS.has(ext)) {
+                if (file.bytes > MAX_TEXT_FILE_BYTES)
+                    issues.push(issue('file_too_large', 'Text files cannot exceed 2 MB.', 'Reduce the text file to at most 2 MB, or exclude it.', file.path));
+            }
+            else if (!PROJECT_FONT_EXTENSIONS.has(ext) && !mediaTypeOf(file.path))
+                issues.push(unsupported(file.path, ext, 'html, css, js, mjs, json, svg, woff, woff2, ttf, otf, png, jpg, webp, mp4, mov, mp3, wav, m4a, ogg'));
+        }
+        return issues;
+    }
+    const duration = options.durationSeconds;
+    if (duration !== undefined &&
+        !(duration >= ARTIFACT_MIN_DURATION_SECONDS && duration <= ARTIFACT_MAX_DURATION_SECONDS))
+        issues.push(issue('invalid_duration', `An artifact runs ${ARTIFACT_MIN_DURATION_SECONDS}–${ARTIFACT_MAX_DURATION_SECONDS} seconds.`, 'Pass --duration <seconds> within that range.'));
+    if (refCount > 0)
+        issues.push(issue('ARTIFACT_ASSET_REFS', 'A web page artifact cannot reference Martini assets.', 'Remove the assetId bindings from martini.graphic.json, or make the page a HyperFrames project.', GRAPHIC_MANIFEST_FILE));
+    if (!files.some(file => ['index.html', 'App.jsx', 'App.tsx'].includes(file.path)))
+        issues.push(issue('missing_entry', 'An artifact needs index.html, App.jsx or App.tsx at its root.', 'Add the entry file at the project root.'));
+    for (const file of files) {
+        if (!ARTIFACT_SAFE_PATH.test(file.path))
+            issues.push(issue('invalid_path', 'The file path is not a supported relative path.', 'Rename it to letters, digits, spaces, dots, underscores or hyphens.', file.path));
+        const ext = extensionOf(file.path);
+        const media = mediaTypeOf(file.path);
+        if (media && media.kind !== 'image')
+            issues.push(issue('ARTIFACT_MEDIA', `A web page artifact takes images only; ${file.path} is ${media.kind}.`, 'Make the page a HyperFrames project (a composition root in index.html) to use video or audio, or add the file to exclude in martini.graphic.json.', file.path));
+        else if (!ARTIFACT_TEXT.has(ext) && !ARTIFACT_IMAGES.has(ext) && !PROJECT_FONT_EXTENSIONS.has(ext))
+            issues.push(unsupported(file.path, ext, 'html, css, js, jsx, ts, tsx, json, svg, png, jpg, webp, woff, woff2, ttf, otf'));
+    }
+    return issues;
+}
+export function sha256File(abs) {
+    return createHash('sha256').update(readFileSync(abs)).digest('hex');
+}
+export function planMedia(files, manifest, state, options) {
+    const errors = [];
+    const warnings = [];
+    const entries = new Map((manifest?.media ?? []).map(entry => [entry.path, entry]));
+    const local = new Map(files.map(file => [file.path, file]));
+    const bundle = [];
+    const media = [];
+    for (const entry of manifest?.media ?? []) {
+        if (local.has(entry.path))
+            continue;
+        const type = mediaTypeOf(entry.path);
+        if (!type) {
+            errors.push(issue('asset_ref_not_media', `${entry.path} is not an image, video or audio path.`, 'Give the media entry a supported media extension.', entry.path));
+            continue;
+        }
+        if (entry.assetId)
+            media.push({ path: entry.path, kind: type.kind, how: 'ref', assetId: entry.assetId });
+        else
+            errors.push(issue('MEDIA_MISSING', `${entry.path} is listed in martini.graphic.json but is not in the directory and has no assetId.`, entry.recipe
+                ? 'Render it from its recipe into the directory, bind it to a Martini asset with assetId, or remove the entry.'
+                : 'Add the file, bind it to a Martini asset with assetId, or remove the entry.', entry.path));
+    }
+    for (const [path, known] of Object.entries(state?.media ?? {})) {
+        if (local.has(path) || entries.has(path) || options.door === 'artifact')
+            continue;
+        const type = mediaTypeOf(path);
+        if (type)
+            media.push({ path, kind: type.kind, how: 'ref', assetId: known.assetId });
+    }
+    const candidates = [];
+    for (const file of files) {
+        const type = mediaTypeOf(file.path);
+        if (!type || options.door === 'artifact') {
+            bundle.push(file);
+            continue;
+        }
+        const entry = entries.get(file.path);
+        const known = state?.media[file.path];
+        const sha = known ? sha256File(file.abs) : undefined;
+        const planned = { path: file.path, kind: type.kind, how: 'bundled', bytes: file.bytes, abs: file.abs };
+        if (sha)
+            planned.sha256 = sha;
+        if (entry?.upload === 'always')
+            planned.how = 'uploaded';
+        else if (known && sha === known.sha256) {
+            planned.how = 'ref';
+            planned.assetId = known.assetId;
+        }
+        else if (!options.refsRideInBundle &&
+            entry?.upload !== 'never' &&
+            type.kind !== 'image' &&
+            file.bytes > 1024 * 1024)
+            planned.how = 'uploaded';
+        if (entry?.assetId && planned.how === 'bundled')
+            warnings.push(issue('BINDING_SHADOWED', `${file.path} is bound to asset ${entry.assetId} but the directory holds its own copy, which is sent instead.`, 'Delete the local file to use the bound asset, or remove the assetId.', file.path, 'warning'));
+        candidates.push(planned);
+    }
+    const bundledBytes = () => bundle.reduce((sum, file) => sum + file.bytes, 0) +
+        candidates.filter(item => item.how === 'bundled').reduce((sum, item) => sum + (item.bytes ?? 0), 0);
+    if (!options.refsRideInBundle) {
+        const images = candidates.filter(item => item.how === 'bundled' && item.kind === 'image' && entries.get(item.path)?.upload !== 'never');
+        images.sort((a, b) => (b.bytes ?? 0) - (a.bytes ?? 0));
+        for (const image of images) {
+            if (bundledBytes() <= MAX_BUNDLE_FILE_BYTES)
+                break;
+            image.how = 'uploaded';
+        }
+    }
+    for (const item of candidates) {
+        if (item.how === 'bundled')
+            bundle.push(local.get(item.path));
+        media.push(item);
+        if (item.how === 'uploaded' && (item.bytes ?? 0) > UPLOAD_CAP[item.kind])
+            errors.push(issue('FILE_TOO_LARGE', `${item.path} is ${formatMB(item.bytes ?? 0)}; a ${item.kind} upload is capped at ${formatMB(UPLOAD_CAP[item.kind])}.`, item.kind === 'video'
+                ? `Compress it (martini graphics push --compress transcodes it to fit, with ffmpeg), or reference a smaller copy.`
+                : `Reference a compressed copy (e.g. ffmpeg -i ${item.path} -c:a aac -b:a 192k <name>.m4a).`, item.path));
+    }
+    bundle.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    media.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    const riding = options.refsRideInBundle
+        ? media.filter(item => item.how !== 'bundled' && item.bytes !== undefined)
+        : [];
+    const sized = [
+        ...bundle.map(file => ({ path: file.path, bytes: file.bytes })),
+        ...riding.map(item => ({ path: item.path, bytes: item.bytes ?? 0 })),
+    ];
+    const rawBytes = sized.reduce((sum, file) => sum + file.bytes, 0);
+    const encodedBytes = encodedBundleBytes(sized);
+    if (!options.refsRideInBundle) {
+        const mediaBytes = media.reduce((sum, item) => sum + (item.bytes ?? 0), 0);
+        if (!options.split && mediaBytes > MAX_MEDIA_BYTES) {
+            const top = [...media].sort((a, b) => (b.bytes ?? 0) - (a.bytes ?? 0)).slice(0, 3);
+            errors.push(issue('MEDIA_TOO_LARGE', `The Graphic's media totals ${formatMB(mediaBytes)}; one Graphic holds ${formatMB(MAX_MEDIA_BYTES)}. Largest: ${top.map(item => `${item.path} (${formatMB(item.bytes ?? 0)})`).join(', ')}.`, 'Compress the largest clips (ffmpeg), or split the piece into more than one Graphic.'));
+        }
+    }
+    if (!options.split && (rawBytes > MAX_BUNDLE_FILE_BYTES || encodedBytes > MAX_BUNDLE_BYTES)) {
+        const top = [...sized].sort((a, b) => b.bytes - a.bytes).slice(0, 5);
+        errors.push(issue('RENDER_BUNDLE_TOO_LARGE', `The Graphic's files${options.refsRideInBundle ? ' and referenced media' : ''} total ${formatMB(rawBytes)}; one render bundle holds ${formatMB(MAX_BUNDLE_FILE_BYTES)}. Largest: ${top.map(file => `${file.path} (${formatMB(file.bytes)})`).join(', ')}.`, 'Pass --compress to transcode the video to fit (needs ffmpeg), downscale images, or exclude what the composition does not load.'));
+    }
+    return { bundle, media, errors, warnings, rawBytes, encodedBytes };
+}
+export function compressionTargets(plan, options) {
+    const targets = new Map();
+    const videos = plan.media.filter(item => item.kind === 'video' &&
+        item.bytes !== undefined &&
+        /\.(mp4|mov)$/i.test(item.path) &&
+        (item.how === 'bundled' || item.how === 'uploaded' || options.refsRideInBundle));
+    const inBudget = (item) => item.how === 'bundled' || (options.refsRideInBundle && item.bytes !== undefined);
+    const budgeted = videos.filter(inBudget);
+    if (budgeted.length) {
+        const others = [
+            ...plan.bundle
+                .filter(file => !budgeted.some(video => video.path === file.path))
+                .map(file => ({ path: file.path, bytes: file.bytes })),
+            ...(options.refsRideInBundle
+                ? plan.media
+                    .filter(item => item.how !== 'bundled' && item.bytes !== undefined && !budgeted.includes(item))
+                    .map(item => ({ path: item.path, bytes: item.bytes ?? 0 }))
+                : []),
+        ];
+        const otherRaw = others.reduce((sum, file) => sum + file.bytes, 0);
+        const byRaw = MAX_BUNDLE_FILE_BYTES - otherRaw;
+        const byEncoded = Math.floor(((MAX_BUNDLE_BYTES - encodedBundleBytes([...others, ...budgeted.map(item => ({ path: item.path, bytes: 0 }))])) *
+            3) /
+            4);
+        const remaining = Math.min(byRaw, byEncoded);
+        const total = budgeted.reduce((sum, item) => sum + (item.bytes ?? 0), 0);
+        if (total > remaining)
+            for (const item of budgeted) {
+                const share = Math.floor((remaining * (item.bytes ?? 0)) / total);
+                targets.set(item.path, Math.min(share, UPLOAD_CAP.video));
+            }
+    }
+    for (const item of videos)
+        if (!targets.has(item.path) && item.how === 'uploaded' && (item.bytes ?? 0) > UPLOAD_CAP.video)
+            targets.set(item.path, UPLOAD_CAP.video);
+    return targets;
+}
+//# sourceMappingURL=project.js.map