@anvpx/motion-build 0.0.0-stage → 0.1.0

package/dist/templates/load.js

@@ -0,0 +1,122 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseBlueprintDoc, parsePacingDoc, parseStylePreset, parseTemplateManifest, } from "@anvpx/motion-schema";
+export const MANIFEST_FILE = "template.json";
+/** A theme `file` starting with this prefix is read from the shared themes folder. */
+export const SHARED_PREFIX = "@shared/";
+const fail = (file, message, suggestion) => ({
+    ok: false,
+    errors: [
+        suggestion === undefined ? { path: file, message } : { path: file, message, suggestion },
+    ],
+});
+const readRaw = (dir, file) => {
+    let text;
+    try {
+        text = readFileSync(join(dir, file), "utf8");
+    }
+    catch {
+        return fail(file, "file not found", "create it or fix the path in template.json");
+    }
+    try {
+        return { ok: true, value: { text, json: JSON.parse(text) } };
+    }
+    catch (error) {
+        return fail(file, `invalid JSON: ${error.message}`);
+    }
+};
+/** Reads one shared file; errors name the `@shared/...` ref the manifest used. */
+const readShared = (sharedDir, ref, name) => {
+    const read = readRaw(sharedDir, name);
+    return read.ok ? read : fail(ref, "shared theme not found", "add it under shared/themes");
+};
+const inFile = (file, errors) => errors.map((error) => ({ ...error, path: `${file}#${error.path}` }));
+const readParsed = (dir, file, parse) => {
+    const raw = readRaw(dir, file);
+    if (!raw.ok)
+        return raw;
+    const parsed = parse(raw.value.json);
+    return parsed.ok ? parsed : { ok: false, errors: inFile(file, parsed.errors) };
+};
+/** Reads and parses one referenced document; its own `id` must match the manifest entry. */
+const readDoc = (dir, ref, parse) => {
+    const parsed = readParsed(dir, ref.file, parse);
+    if (!parsed.ok)
+        return parsed;
+    if (parsed.value.id !== ref.id) {
+        return fail(ref.file, `id "${parsed.value.id}" does not match manifest id "${ref.id}"`);
+    }
+    return parsed;
+};
+const collect = (results) => {
+    const errors = results.flatMap((result) => (result.ok ? [] : result.errors));
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return { ok: true, value: results.flatMap((result) => (result.ok ? [result.value] : [])) };
+};
+const byId = (items) => new Map(items.map((item) => [item.id, item]));
+/** Where a theme ref is read from: the template folder, or (for `@shared/<name>`) the shared folder. */
+export const resolveThemeFile = (file, sharedThemesDir) => {
+    if (!file.startsWith(SHARED_PREFIX))
+        return { ok: true, value: { shared: false, file } };
+    const name = file.slice(SHARED_PREFIX.length);
+    if (name === "" || name.includes("/")) {
+        return fail(file, "shared theme must be a plain file name", "use @shared/<name>.json");
+    }
+    if (sharedThemesDir === undefined) {
+        return fail(file, "shared themes are not available here", "load through the CLI or pass sharedThemesDir");
+    }
+    return { ok: true, value: { shared: true, file: name } };
+};
+const readTheme = (dir, ref, options) => {
+    const target = resolveThemeFile(ref.file, options.sharedThemesDir);
+    if (!target.ok)
+        return target;
+    const raw = target.value.shared
+        ? readShared(options.sharedThemesDir ?? "", ref.file, target.value.file)
+        : readRaw(dir, ref.file);
+    if (!raw.ok)
+        return raw;
+    const { id, file, mode, pair } = ref;
+    const theme = { id, file, mode, text: raw.value.text, doc: raw.value.json };
+    return { ok: true, value: pair === undefined ? theme : { ...theme, pair } };
+};
+const readText = (dir, file) => {
+    try {
+        return { ok: true, value: readFileSync(join(dir, file), "utf8") };
+    }
+    catch {
+        return fail(file, "file not found", "create it or fix the path in template.json");
+    }
+};
+/** Reads a template folder: manifest, themes, styles, blueprints, pacing and copy guide. */
+export const loadTemplate = (dir, options = {}) => {
+    const raw = readRaw(dir, MANIFEST_FILE);
+    if (!raw.ok)
+        return raw;
+    const parsed = parseTemplateManifest(raw.value.json);
+    if (!parsed.ok)
+        return { ok: false, errors: inFile(MANIFEST_FILE, parsed.errors) };
+    const manifest = parsed.value;
+    const themes = collect(manifest.themes.map((ref) => readTheme(dir, ref, options)));
+    const styles = collect(manifest.styles.map((ref) => readDoc(dir, ref, parseStylePreset)));
+    const blueprints = collect(manifest.blueprints.map((ref) => readDoc(dir, ref, parseBlueprintDoc)));
+    const pacing = readParsed(dir, manifest.pacing, parsePacingDoc);
+    const copy = readText(dir, manifest.copy);
+    const failures = [themes, styles, blueprints, pacing, copy].flatMap((result) => result.ok ? [] : result.errors);
+    if (failures.length > 0 || !themes.ok || !styles.ok || !blueprints.ok || !pacing.ok || !copy.ok) {
+        return { ok: false, errors: failures };
+    }
+    return {
+        ok: true,
+        value: {
+            dir,
+            manifest,
+            themes: byId(themes.value),
+            styles: byId(styles.value),
+            blueprints: byId(blueprints.value),
+            pacing: pacing.value,
+            copy: copy.value,
+        },
+    };
+};

package/dist/templates/pacing.d.ts

@@ -0,0 +1,21 @@
+import type { LENGTH_CLASSES, PacingDoc, Result } from "@anvpx/motion-schema";
+import type { LintFinding } from "../lint/index.ts";
+export type LengthClass = (typeof LENGTH_CLASSES)[number];
+interface PacedScene {
+    readonly type: string;
+    readonly props: Record<string, unknown>;
+    readonly id?: string | undefined;
+    readonly layer?: string | undefined;
+    readonly over?: string | undefined;
+    readonly offset?: number | undefined;
+    readonly duration?: number | undefined;
+    readonly narration?: string | undefined;
+}
+/**
+ * Base scenes without a duration get the pacing table's seconds: the table is a floor that is raised to
+ * fit the on-screen text and any narration at `wordsPerSecond`.
+ */
+export declare const applyPacing: <S extends PacedScene>(scenes: readonly S[], pacing: PacingDoc, length: LengthClass) => Result<S[]>;
+/** Length-class targets are advice: out-of-range scene counts or runtimes are warnings. */
+export declare const pacingWarnings: (pacing: PacingDoc, length: LengthClass, sceneCount: number, totalSec: number) => LintFinding[];
+export {};

package/dist/templates/pacing.js

@@ -0,0 +1,61 @@
+import { sceneWords } from "@anvpx/motion-scenes";
+const round1 = (value) => Math.round(value * 10) / 10;
+const narrationSeconds = (narration, wordsPerSecond) => round1(narration.split(/\s+/).filter(Boolean).length / wordsPerSecond);
+/** Comfortable reading time of the on-screen text, in half-second steps. */
+const readingSeconds = (props, type, wordsPerSecond) => Math.ceil((sceneWords(props, type) / wordsPerSecond) * 2) / 2;
+/** An overlay without a duration spans its base scene from its offset to the scene end. */
+const spanOverlays = (scenes) => scenes.map((scene) => {
+    if (scene.layer !== "overlay" || scene.duration !== undefined)
+        return scene;
+    const base = scenes.find((other) => other.layer !== "overlay" && other.id === scene.over);
+    if (base?.duration === undefined)
+        return scene;
+    return { ...scene, duration: round1(Math.max(base.duration - (scene.offset ?? 0), 0.1)) };
+});
+/**
+ * Base scenes without a duration get the pacing table's seconds: the table is a floor that is raised to
+ * fit the on-screen text and any narration at `wordsPerSecond`.
+ */
+export const applyPacing = (scenes, pacing, length) => {
+    const errors = [];
+    const paced = scenes.map((scene, index) => {
+        if (scene.duration !== undefined || scene.layer === "overlay")
+            return scene;
+        const seconds = pacing.sceneSeconds[scene.type]?.[length];
+        if (seconds === undefined) {
+            errors.push({
+                path: `/scenes/${index}/type`,
+                message: `pacing has no seconds for scene type "${scene.type}"`,
+                suggestion: `add sceneSeconds.${scene.type} to pacing.json or set duration`,
+            });
+            return scene;
+        }
+        const spoken = scene.narration === undefined ? 0 : narrationSeconds(scene.narration, pacing.wordsPerSecond);
+        const read = readingSeconds(scene.props, scene.type, pacing.wordsPerSecond);
+        return { ...scene, duration: Math.max(seconds, spoken, read) };
+    });
+    return errors.length > 0 ? { ok: false, errors } : { ok: true, value: spanOverlays(paced) };
+};
+const outside = (value, [low, high]) => value < low || value > high;
+/** Length-class targets are advice: out-of-range scene counts or runtimes are warnings. */
+export const pacingWarnings = (pacing, length, sceneCount, totalSec) => {
+    const target = pacing.lengths[length];
+    const warnings = [];
+    if (outside(sceneCount, target.scenes)) {
+        warnings.push({
+            severity: "warning",
+            path: "/scenes",
+            message: `${sceneCount} scenes; "${length}" targets ${target.scenes[0]}-${target.scenes[1]}`,
+            suggestion: "change the length class or the slot item counts",
+        });
+    }
+    if (outside(totalSec, target.totalSec)) {
+        warnings.push({
+            severity: "warning",
+            path: "/scenes",
+            message: `${totalSec}s total; "${length}" targets ${target.totalSec[0]}-${target.totalSec[1]}s`,
+            suggestion: "change the length class or trim content",
+        });
+    }
+    return warnings;
+};

package/dist/templates/search.d.ts

@@ -0,0 +1,64 @@
+import type { LoadedTemplate } from "./types.ts";
+/** One blueprint flattened with the template data it inherits; the unit that is filtered and ranked. */
+export interface BlueprintEntry {
+    readonly template: string;
+    readonly blueprint: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly purpose: string;
+    readonly useCases: readonly string[];
+    readonly goodFor: string;
+    readonly notFor: string;
+    readonly audience: readonly string[];
+    /** Blueprint tags. */
+    readonly tags: readonly string[];
+    /** Template-level tags, inherited at a lower weight. */
+    readonly templateTags: readonly string[];
+    readonly aspects: readonly string[];
+    /** Seconds; absent when the blueprint declares none. */
+    readonly lengths?: {
+        readonly min: number;
+        readonly max: number;
+    };
+}
+export interface SearchFilters {
+    /** Every tag must be present on the blueprint or its template (exact slugs). */
+    readonly tags?: readonly string[];
+    readonly aspect?: string;
+    /** Keeps blueprints whose `lengths` contain this many seconds. */
+    readonly sec?: number;
+}
+export interface Hit {
+    readonly entry: BlueprintEntry;
+    readonly score: number;
+    readonly tagScore: number;
+    /** A query token appears in `notFor`; the hit sinks below the others. */
+    readonly notFor: boolean;
+    /** Up to three query tokens that earned the score, strongest first. */
+    readonly why: readonly string[];
+}
+export declare const WEIGHTS: {
+    readonly tag: 3;
+    readonly audience: 2;
+    readonly text: 1;
+    readonly title: 1;
+    readonly templateTag: 1;
+    readonly notFor: -3;
+};
+/** Default stopword list; the CLI passes the store stopword file instead (a store test keeps them equal). */
+export declare const DEFAULT_STOPWORDS: readonly string[];
+/** Lowercase, split on non-alphanumerics, drop stopwords, strip one plural suffix; order kept, no duplicates. */
+export declare const tokenize: (text: string, stopwords?: readonly string[]) => string[];
+/** Template lengths are derived (min of mins, max of maxes), never stored. */
+export declare const templateLengths: (template: LoadedTemplate) => {
+    min: number;
+    max: number;
+} | undefined;
+export declare const entriesOf: (templates: readonly LoadedTemplate[]) => BlueprintEntry[];
+/** Hard filters (AND); result sorted by `template/blueprint` id. */
+export declare const filterEntries: (entries: readonly BlueprintEntry[], filters: SearchFilters) => BlueprintEntry[];
+/**
+ * Deterministic ranking of `entries` for a free-text query: hits with a NOT-FOR match sink below the
+ * rest, then higher score, higher tag score, then id order. Entries with no positive match are dropped.
+ */
+export declare const rankEntries: (entries: readonly BlueprintEntry[], query: string, stopwords?: readonly string[]) => Hit[];

package/dist/templates/search.js

@@ -0,0 +1,129 @@
+export const WEIGHTS = {
+    tag: 3,
+    audience: 2,
+    text: 1,
+    title: 1,
+    templateTag: 1,
+    notFor: -3,
+};
+const MAX_WHY = 3;
+/** Default stopword list; the CLI passes the store stopword file instead (a store test keeps them equal). */
+export const DEFAULT_STOPWORDS = ("a an and are as at be but by for from has have how i in into is it its of on or our so that the " +
+    "their them then there these they this to up us use using was we what when where which who why will " +
+    "with you your about can do does make need needs want video videos short quick").split(" ");
+const stem = (word) => {
+    if (word.length <= 3)
+        return word;
+    if (word.endsWith("ies"))
+        return `${word.slice(0, -3)}y`;
+    if (/(?:ss|x|z|ch|sh)es$/.test(word))
+        return word.slice(0, -2);
+    if (word.endsWith("ss") || !word.endsWith("s"))
+        return word;
+    return word.slice(0, -1);
+};
+/** Lowercase, split on non-alphanumerics, drop stopwords, strip one plural suffix; order kept, no duplicates. */
+export const tokenize = (text, stopwords = DEFAULT_STOPWORDS) => {
+    const dropped = new Set(stopwords);
+    const words = text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((word) => word !== "" && !dropped.has(word))
+        .map(stem);
+    return [...new Set(words)];
+};
+const tokenSetOf = (stopwords) => (...texts) => new Set(texts.flatMap((text) => tokenize(text, stopwords)));
+/** Template lengths are derived (min of mins, max of maxes), never stored. */
+export const templateLengths = (template) => {
+    const all = [...template.blueprints.values()].flatMap((bp) => bp.discover?.lengths ?? []);
+    if (all.length === 0)
+        return undefined;
+    return { min: Math.min(...all.map((l) => l.min)), max: Math.max(...all.map((l) => l.max)) };
+};
+export const entriesOf = (templates) => templates.flatMap((template) => {
+    const { manifest } = template;
+    return [...template.blueprints.values()].map((bp) => {
+        const own = bp.discover;
+        const inherited = manifest.discover;
+        return {
+            template: manifest.id,
+            blueprint: bp.id,
+            title: manifest.title,
+            summary: manifest.summary,
+            purpose: bp.purpose,
+            useCases: own?.useCases ?? [],
+            goodFor: own?.goodFor ?? "",
+            notFor: own?.notFor ?? "",
+            audience: own?.audience ?? inherited?.audience ?? [],
+            tags: own?.tags ?? [],
+            templateTags: inherited?.tags ?? [],
+            aspects: own?.aspects ?? inherited?.aspects ?? [],
+            ...(own?.lengths === undefined ? {} : { lengths: own.lengths }),
+        };
+    });
+});
+const idOf = (entry) => `${entry.template}/${entry.blueprint}`;
+const matches = (entry, filters) => {
+    const present = new Set([...entry.tags, ...entry.templateTags]);
+    if (!(filters.tags ?? []).every((tag) => present.has(tag)))
+        return false;
+    if (filters.aspect !== undefined && !entry.aspects.includes(filters.aspect))
+        return false;
+    const { sec } = filters;
+    if (sec !== undefined) {
+        if (entry.lengths === undefined)
+            return false;
+        if (sec < entry.lengths.min || sec > entry.lengths.max)
+            return false;
+    }
+    return true;
+};
+/** Hard filters (AND); result sorted by `template/blueprint` id. */
+export const filterEntries = (entries, filters) => entries.filter((entry) => matches(entry, filters)).sort((a, b) => idOf(a).localeCompare(idOf(b)));
+const scoreToken = (token, sets) => {
+    const tag = sets.tags.has(token) ? WEIGHTS.tag : 0;
+    const gain = tag +
+        (sets.audience.has(token) ? WEIGHTS.audience : 0) +
+        (sets.text.has(token) ? WEIGHTS.text : 0) +
+        (sets.title.has(token) ? WEIGHTS.title : 0) +
+        (!sets.tags.has(token) && sets.templateTags.has(token) ? WEIGHTS.templateTag : 0);
+    return { token, gain, tag, notFor: sets.notFor.has(token) };
+};
+const scoreEntry = (entry, query, stopwords) => {
+    const tokenSet = tokenSetOf(stopwords);
+    const sets = {
+        tags: tokenSet(...entry.tags),
+        templateTags: tokenSet(...entry.templateTags),
+        audience: tokenSet(...entry.audience),
+        text: tokenSet(...entry.useCases, entry.goodFor, entry.purpose),
+        title: tokenSet(entry.title, entry.summary, entry.blueprint),
+        notFor: tokenSet(entry.notFor),
+    };
+    const scored = query.map((token) => scoreToken(token, sets));
+    const positive = scored.filter((s) => s.gain > 0);
+    const penalty = scored.filter((s) => s.notFor).length * WEIGHTS.notFor;
+    return {
+        entry,
+        score: positive.reduce((sum, s) => sum + s.gain, 0) + penalty,
+        tagScore: positive.reduce((sum, s) => sum + s.tag, 0),
+        notFor: penalty < 0,
+        why: [...positive]
+            .sort((a, b) => b.gain - a.gain)
+            .slice(0, MAX_WHY)
+            .map((s) => s.token),
+    };
+};
+/**
+ * Deterministic ranking of `entries` for a free-text query: hits with a NOT-FOR match sink below the
+ * rest, then higher score, higher tag score, then id order. Entries with no positive match are dropped.
+ */
+export const rankEntries = (entries, query, stopwords = DEFAULT_STOPWORDS) => {
+    const tokens = tokenize(query, stopwords);
+    return entries
+        .map((entry) => scoreEntry(entry, tokens, stopwords))
+        .filter((hit) => hit.why.length > 0)
+        .sort((a, b) => Number(a.notFor) - Number(b.notFor) ||
+        b.score - a.score ||
+        b.tagScore - a.tagScore ||
+        idOf(a.entry).localeCompare(idOf(b.entry)));
+};

package/dist/templates/semver.d.ts

@@ -0,0 +1,2 @@
+/** Negative when `a` < `b`, 0 when equal, positive when `a` > `b`; plain `x.y.z` versions only. */
+export declare const compareSemver: (a: string, b: string) => number;

package/dist/templates/semver.js

@@ -0,0 +1,12 @@
+const parts = (version) => version.split(".").map(Number);
+/** Negative when `a` < `b`, 0 when equal, positive when `a` > `b`; plain `x.y.z` versions only. */
+export const compareSemver = (a, b) => {
+    const left = parts(a);
+    const right = parts(b);
+    for (let index = 0; index < 3; index++) {
+        const diff = (left[index] ?? 0) - (right[index] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+};

package/dist/templates/slots.d.ts

@@ -0,0 +1,8 @@
+import type { Result, SlotDef } from "@anvpx/motion-schema";
+export type SlotValues = Readonly<Record<string, unknown>>;
+type Defs = Readonly<Record<string, SlotDef>>;
+/** A slot counts as set when it holds something: non-empty text/list, any number or object. */
+export declare const isSet: (value: unknown) => boolean;
+/** Checks slot values against the blueprint's slot definitions and fills in defaults. */
+export declare const resolveSlots: (defs: Defs, input: unknown) => Result<SlotValues>;
+export {};

package/dist/templates/slots.js

@@ -0,0 +1,116 @@
+import { toJsonPointer } from "@anvpx/motion-schema";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A slot counts as set when it holds something: non-empty text/list, any number or object. */
+export const isSet = (value) => value !== undefined &&
+    value !== null &&
+    value !== "" &&
+    !(Array.isArray(value) && value.length === 0);
+const problem = (path, message, suggestion) => {
+    const base = { path: toJsonPointer(["slots", ...path]), message };
+    return suggestion === undefined ? base : { ...base, suggestion };
+};
+const textErrors = (value, path, min, max) => {
+    if (typeof value !== "string")
+        return [problem(path, "must be text")];
+    if (max !== undefined && value.length > max) {
+        return [problem(path, `${value.length} chars, max ${max}`, `shorten to <= ${max} chars`)];
+    }
+    if (min !== undefined && value.length < min) {
+        return [problem(path, `${value.length} chars, min ${min}`, `use >= ${min} chars`)];
+    }
+    return [];
+};
+const numberErrors = (value, path, rules) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return [problem(path, "must be a number")];
+    }
+    if (rules.int === true && !Number.isInteger(value))
+        return [problem(path, "must be an integer")];
+    if (rules.min !== undefined && value < rules.min) {
+        return [problem(path, `${value} is below min ${rules.min}`)];
+    }
+    if (rules.max !== undefined && value > rules.max) {
+        return [problem(path, `${value} is above max ${rules.max}`)];
+    }
+    return [];
+};
+const countErrors = (list, path, min, max) => {
+    if (max !== undefined && list.length > max) {
+        return [problem(path, `${list.length} items, max ${max}`, `keep at most ${max}`)];
+    }
+    if (min !== undefined && list.length < min) {
+        return [problem(path, `${list.length} items, min ${min}`, `give at least ${min}`)];
+    }
+    return [];
+};
+const objectErrors = (value, path, fields) => {
+    if (!isRecord(value))
+        return [problem(path, "must be an object")];
+    const unknown = Object.keys(value).filter((key) => !Object.hasOwn(fields, key));
+    const extra = unknown.map((key) => problem([...path, key], "unknown field", `use: ${Object.keys(fields).join("|")}`));
+    const own = Object.entries(fields).flatMap(([key, type]) => type === "text"
+        ? textErrors(value[key], [...path, key])
+        : numberErrors(value[key], [...path, key], {}));
+    return [...extra, ...own];
+};
+const slotErrors = (def, value, path) => {
+    switch (def.type) {
+        case "text":
+            return textErrors(value, path, def.min, def.max);
+        case "number":
+            return numberErrors(value, path, def);
+        case "enum":
+            return def.values.includes(String(value))
+                ? []
+                : [
+                    problem(path, `${JSON.stringify(value)} invalid`, `use one of: ${def.values.join("|")}`),
+                ];
+        case "text[]": {
+            if (!Array.isArray(value))
+                return [problem(path, "must be a list of text")];
+            return [
+                ...countErrors(value, path, def.min, def.max),
+                ...value.flatMap((item, index) => textErrors(item, [...path, index], undefined, def.itemMax)),
+            ];
+        }
+        case "object": {
+            if (def.list !== true)
+                return objectErrors(value, path, def.fields);
+            if (!Array.isArray(value))
+                return [problem(path, "must be a list of objects")];
+            return [
+                ...countErrors(value, path, def.min, def.max),
+                ...value.flatMap((item, index) => objectErrors(item, [...path, index], def.fields)),
+            ];
+        }
+    }
+};
+const defaultOf = (def) => def.type === "text" || def.type === "number" || def.type === "enum" ? def.default : undefined;
+const isRequired = (def) => (def.type === "text" ||
+    def.type === "text[]" ||
+    def.type === "number" ||
+    def.type === "object") &&
+    def.required === true;
+const entryErrors = (name, def, value) => {
+    if (isSet(value))
+        return slotErrors(def, value, [name]);
+    return isRequired(def) ? [problem([name], "required", `set slot "${name}"`)] : [];
+};
+/** Checks slot values against the blueprint's slot definitions and fills in defaults. */
+export const resolveSlots = (defs, input) => {
+    if (input !== undefined && !isRecord(input)) {
+        return { ok: false, errors: [problem([], "slots must be an object")] };
+    }
+    const given = input ?? {};
+    const errors = Object.keys(given)
+        .filter((name) => !Object.hasOwn(defs, name))
+        .map((name) => problem([name], "unknown slot", `use: ${Object.keys(defs).join("|")}`));
+    const values = {};
+    for (const [name, def] of Object.entries(defs)) {
+        const value = isSet(given[name]) ? given[name] : defaultOf(def);
+        errors.push(...entryErrors(name, def, value));
+        if (isSet(value))
+            values[name] = value;
+    }
+    return errors.length > 0 ? { ok: false, errors } : { ok: true, value: values };
+};

package/dist/templates/style.d.ts

@@ -0,0 +1,25 @@
+import type { Result, StylePreset } from "@anvpx/motion-schema";
+import type { PlatformLookup } from "./types.ts";
+export declare const DEFAULT_FRAME: {
+    readonly width: 1920;
+    readonly height: 1080;
+    readonly fps: 30;
+};
+export interface Frame {
+    readonly width: number;
+    readonly height: number;
+    readonly fps: number;
+}
+interface StyledScene {
+    readonly type: string;
+    readonly layer?: string | undefined;
+    readonly props: Record<string, unknown>;
+    readonly [key: string]: unknown;
+}
+export interface Styled<S> {
+    readonly frame: Frame;
+    readonly scenes: readonly S[];
+}
+/** Applies frame, direction defaults and prop defaults; values the blueprint sets always win. */
+export declare const applyStyle: <S extends StyledScene>(scenes: readonly S[], style: StylePreset, platforms: PlatformLookup | undefined, platform?: string) => Result<Styled<S>>;
+export {};

package/dist/templates/style.js

@@ -0,0 +1,56 @@
+export const DEFAULT_FRAME = { width: 1920, height: 1080, fps: 30 };
+const platformFrame = (id, platforms, path) => {
+    const found = platforms?.(id);
+    if (found === undefined) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path,
+                    message: `unknown platform "${id}"`,
+                    suggestion: "use a platform id printed by mk template list",
+                },
+            ],
+        };
+    }
+    const { width, height, maxFps } = found;
+    return { ok: true, value: { width, height, fps: Math.min(DEFAULT_FRAME.fps, maxFps) } };
+};
+/** A chosen `platform` slot wins over the style frame; otherwise the style frame, else 16:9. */
+const frameOf = (style, platforms, platform) => {
+    if (platform !== undefined)
+        return platformFrame(platform, platforms, "/slots/platform");
+    const frame = style.frame;
+    if (frame === undefined)
+        return { ok: true, value: DEFAULT_FRAME };
+    if (!("platform" in frame))
+        return { ok: true, value: frame };
+    return platformFrame(frame.platform, platforms, "/frame/platform");
+};
+/** Direction defaults for one scene; overlays take none, and the first base scene has no transition in. */
+const directionOf = (style, overlay, first) => {
+    const { shot, move, ease, transition } = style.direction ?? {};
+    if (overlay)
+        return {};
+    return { shot, move, ease, ...(first ? {} : { transition }) };
+};
+const withoutUndefined = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+const styleScene = (scene, style, first) => {
+    const direction = directionOf(style, scene.layer === "overlay", first);
+    const props = { ...style.props?.[scene.type], ...scene.props };
+    return withoutUndefined({ ...direction, ...withoutUndefined(scene), props });
+};
+/** Applies frame, direction defaults and prop defaults; values the blueprint sets always win. */
+export const applyStyle = (scenes, style, platforms, platform) => {
+    const frame = frameOf(style, platforms, platform);
+    if (!frame.ok)
+        return frame;
+    const firstBase = scenes.findIndex((scene) => scene.layer !== "overlay");
+    return {
+        ok: true,
+        value: {
+            frame: frame.value,
+            scenes: scenes.map((scene, index) => styleScene(scene, style, index === firstBase)),
+        },
+    };
+};

package/dist/templates/types.d.ts

@@ -0,0 +1,29 @@
+import type { BlueprintDoc, PacingDoc, StylePreset, TemplateManifest } from "@anvpx/motion-schema";
+import type { PlatformMargins } from "../lint/index.ts";
+export interface ThemeFile {
+    readonly id: string;
+    /** Path inside the template folder, e.g. `themes/explain-light.json`. */
+    readonly file: string;
+    readonly mode: "light" | "dark";
+    readonly pair?: string;
+    /** Raw file text; vendored byte-for-byte into projects. */
+    readonly text: string;
+    readonly doc: unknown;
+}
+/** A template folder read and parsed; nothing here touches the filesystem again. */
+export interface LoadedTemplate {
+    readonly dir: string;
+    readonly manifest: TemplateManifest;
+    readonly themes: ReadonlyMap<string, ThemeFile>;
+    readonly styles: ReadonlyMap<string, StylePreset>;
+    readonly blueprints: ReadonlyMap<string, BlueprintDoc>;
+    readonly pacing: PacingDoc;
+    readonly copy: string;
+}
+/** Frame size of a delivery platform; supplied by the caller (the platform data lives in schema). */
+export interface PlatformFrame extends PlatformMargins {
+    readonly width: number;
+    readonly height: number;
+    readonly maxFps: number;
+}
+export type PlatformLookup = (id: string) => PlatformFrame | undefined;

package/dist/templates/types.js

@@ -0,0 +1 @@
+export {};