@anvpx/motion-build 0.0.0-stage → 0.1.1

package/dist/lint/safe-zone-9x16.js

@@ -0,0 +1,101 @@
+import { estimateContentHeight, progressHeight } from "./layout-estimate.js";
+/** Frames at least this tall relative to their width count as 9:16 (16/9 = 1.78; 4:5 = 1.25 is excluded). */
+const TALL_RATIO = 1.5;
+/** The scenes' own margin (define-scene SAFE_MARGIN): padding is never smaller than this. */
+const BASE_MARGIN = 0.05;
+const SLACK_PX = 2;
+const px = (value) => Math.round(value);
+const geometryOf = (meta, margins, theme) => {
+    const safe = margins?.safe;
+    if (meta.platform === undefined || safe === undefined)
+        return undefined;
+    const zones = margins?.safeZones;
+    const frac = (zone) => Math.max(BASE_MARGIN, zone ?? 0);
+    const pad = {
+        top: frac(zones?.top) * meta.height,
+        bottom: frac(zones?.bottom) * meta.height,
+        left: frac(zones?.left) * meta.width,
+        right: frac(zones?.right) * meta.width,
+    };
+    return {
+        platform: meta.platform,
+        height: meta.height,
+        pad,
+        limits: {
+            top: safe.top * meta.height,
+            bottom: meta.height * (1 - safe.bottom),
+            side: safe.side * meta.width,
+        },
+        metrics: { width: meta.width - pad.left - pad.right, theme },
+    };
+};
+const sideFinding = (g) => {
+    const side = Math.min(g.pad.left, g.pad.right);
+    if (side >= g.limits.side - SLACK_PX)
+        return [];
+    return [
+        {
+            severity: "warning",
+            path: "/meta/platform",
+            message: `side padding ${px(side)}px is under the ${px(g.limits.side)}px side margin of ${g.platform}`,
+            suggestion: "widen the side margin of the scenes",
+        },
+    ];
+};
+/** The progress bar sits at the bottom edge of the padded frame. */
+const overlayFinding = (g, scene, index) => {
+    if (scene.type !== "progress")
+        return [];
+    const bottom = g.height - g.pad.bottom;
+    if (bottom <= g.limits.bottom + SLACK_PX)
+        return [];
+    const top = bottom - progressHeight(scene.props, g.metrics);
+    return [
+        {
+            severity: "warning",
+            path: `/scenes/${index}/props`,
+            message: `progress bar spans y=${px(top)}-${px(bottom)}px, below the ${g.platform} bottom safe line at y=${px(g.limits.bottom)}px`,
+            suggestion: "raise the bottom margin of the platform or drop the overlay",
+        },
+    ];
+};
+/** Base content is centred vertically in the padded frame. */
+const baseFinding = (g, scene, index) => {
+    const height = estimateContentHeight(scene.type, scene.props, g.metrics);
+    if (height === undefined)
+        return [];
+    const area = g.height - g.pad.top - g.pad.bottom;
+    const top = g.pad.top + (area - height) / 2;
+    const bottom = top + height;
+    if (top >= g.limits.top - SLACK_PX && bottom <= g.limits.bottom + SLACK_PX)
+        return [];
+    return [
+        {
+            severity: "warning",
+            path: `/scenes/${index}/props`,
+            message: `${scene.type} content (est. ${px(height)}px) spans y=${px(top)}-${px(bottom)}px; ${g.platform} keeps y=${px(g.limits.top)}-${px(g.limits.bottom)}px clear`,
+            suggestion: "shorten the text or use fewer items",
+        },
+    ];
+};
+/**
+ * Platform-tagged 9:16 frames: warns when the estimated content block of a base scene (or the progress
+ * overlay) reaches into the platform's `safe{top,bottom,side}` margins.
+ *
+ * Estimate, not a measurement: heights come from `layout-estimate.ts` (scene CSS + a generous glyph-width
+ * model, roughly +-20 %), content is assumed vertically centred in the padded frame as the scenes lay it
+ * out, and the `bug` overlay and scene types without an estimator are not checked. Always a warning: the
+ * numbers in the platform data are unverified approximations.
+ */
+export const safeZone9x16Rule = ({ storyboard, theme, platforms }) => {
+    const { meta } = storyboard;
+    if (theme === undefined || platforms === undefined || meta.platform === undefined)
+        return [];
+    if (meta.height / meta.width < TALL_RATIO)
+        return [];
+    const g = geometryOf(meta, platforms(meta.platform), theme);
+    if (g === undefined)
+        return [];
+    const scenes = storyboard.scenes.flatMap((scene, index) => scene.layer === "overlay" ? overlayFinding(g, scene, index) : baseFinding(g, scene, index));
+    return [...sideFinding(g), ...scenes];
+};

package/dist/lint/text-floor.d.ts

@@ -0,0 +1,8 @@
+import type { LintRule } from "./types.ts";
+/** Body text floor as a fraction of frame width: 24 px @1920 (16:9), 32 px @1080 (9:16). */
+export declare const BODY_FLOOR_LANDSCAPE = 0.0125;
+export declare const BODY_FLOOR_PORTRAIT = 0.0296;
+/** Captions and labels may be this share of the body floor. */
+export declare const LABEL_FLOOR_RATIO = 0.8;
+/** Theme text sizes stay above the readable floor of the frame; inert without `input.theme`. */
+export declare const textFloorRule: LintRule;

package/dist/lint/text-floor.js

@@ -0,0 +1,34 @@
+import { isPortrait } from "./frame.js";
+/** Body text floor as a fraction of frame width: 24 px @1920 (16:9), 32 px @1080 (9:16). */
+export const BODY_FLOOR_LANDSCAPE = 0.0125;
+export const BODY_FLOOR_PORTRAIT = 0.0296;
+/** Captions and labels may be this share of the body floor. */
+export const LABEL_FLOOR_RATIO = 0.8;
+/** Theme type-scale steps checked as body text and as labels. */
+const BODY_STEPS = ["md", "lg"];
+const LABEL_STEPS = ["sm"];
+/** Theme text sizes stay above the readable floor of the frame; inert without `input.theme`. */
+export const textFloorRule = ({ storyboard, theme }) => {
+    if (theme === undefined)
+        return [];
+    const { meta } = storyboard;
+    const body = meta.width * (isPortrait(meta) ? BODY_FLOOR_PORTRAIT : BODY_FLOOR_LANDSCAPE);
+    const check = (steps, floor, severity, role) => steps.flatMap((step) => {
+        const px = theme.fontSizes[step];
+        if (px === undefined || px >= floor)
+            return [];
+        const need = Math.ceil(floor);
+        return [
+            {
+                severity,
+                path: `/meta/theme/fontSize/${step}`,
+                message: `${role} text ${px}px is under ${need}px for a ${meta.width}px-wide frame`,
+                suggestion: `raise theme fontSize.${step} to >= ${need}px`,
+            },
+        ];
+    });
+    return [
+        ...check(BODY_STEPS, body, "error", "body"),
+        ...check(LABEL_STEPS, body * LABEL_FLOOR_RATIO, "warning", "label"),
+    ];
+};

package/dist/lint/transition-implemented.d.ts

@@ -0,0 +1,3 @@
+import type { LintRule } from "./types.ts";
+/** Cut, crossfade, push, wipe and zoom-through render as themselves; anything else falls back to cut. */
+export declare const transitionImplementedRule: LintRule;

package/dist/lint/transition-implemented.js

@@ -0,0 +1,15 @@
+import { IMPLEMENTED_TRANSITIONS } from "../timing.js";
+/** Cut, crossfade, push, wipe and zoom-through render as themselves; anything else falls back to cut. */
+export const transitionImplementedRule = ({ storyboard }) => storyboard.scenes.flatMap((scene, index) => {
+    const name = scene.transition;
+    if (index === 0 || name === undefined || IMPLEMENTED_TRANSITIONS.includes(name))
+        return [];
+    return [
+        {
+            severity: "warning",
+            path: `/scenes/${index}/transition`,
+            message: `transition ${name} not implemented, using cut`,
+            suggestion: `use one of: ${IMPLEMENTED_TRANSITIONS.join("|")}`,
+        },
+    ];
+});

package/dist/lint/transition-length.d.ts

@@ -0,0 +1,4 @@
+import type { LintRule } from "./types.ts";
+export declare const MAX_TRANSITION_SECONDS = 0.8;
+/** A transition (scene overlap) is at most 0.8 s. */
+export declare const transitionLengthRule: LintRule;

package/dist/lint/transition-length.js

@@ -0,0 +1,10 @@
+export const MAX_TRANSITION_SECONDS = 0.8;
+/** A transition (scene overlap) is at most 0.8 s. */
+export const transitionLengthRule = ({ timeline }) => timeline.scenes
+    .filter((scene) => scene.overlap > MAX_TRANSITION_SECONDS)
+    .map((scene) => ({
+    severity: "error",
+    path: `/scenes/${scene.index}/transition`,
+    message: `transition ${scene.overlap}s exceeds ${MAX_TRANSITION_SECONDS}s`,
+    suggestion: `keep transitions <= ${MAX_TRANSITION_SECONDS}s or use cut`,
+}));

package/dist/lint/type-grid.d.ts

@@ -0,0 +1,30 @@
+import type { LintRule } from "./types.ts";
+/** More than five items in one list crowds the grid. */
+export declare const MAX_LIST_ITEMS = 5;
+/** A single typeset line stays at or under 60 characters. */
+export declare const MAX_LINE_CHARS = 60;
+/** Type must sit on the 4pt grid. */
+export declare const SPACING_GRID = 4;
+/**
+ * Six or more items in one list crowd the frame. Empty lists and scenes
+ * without an items array belong to other rules; data scenes are unmeasurable
+ * prose and stay silent.
+ */
+export declare const typeDensityRule: LintRule;
+/**
+ * A title line past 60 characters overflows the grid estimate. Captions are
+ * timed speech, not grid type; overlays and data scenes stay silent. The rule
+ * is frame-agnostic on purpose (no safe-zone coupling).
+ */
+export declare const lineLengthRule: LintRule;
+/**
+ * Numeric spacing must sit on the 4pt grid. Token spacing (xs, sm, md, ...)
+ * resolves in the theme and stays silent; overlays never advance the grid.
+ */
+export declare const offGridSpacingRule: LintRule;
+/**
+ * One accent per idea: the same `[x]` twice in a scene, or the same accent in
+ * two consecutive base scenes, reads as shouting. Captions are timed speech
+ * and never count; overlays are skipped without breaking the chain.
+ */
+export declare const duplicatedEmphasisRule: LintRule;

package/dist/lint/type-grid.js

@@ -0,0 +1,147 @@
+/** Scenes whose text is data, not prose: density and line length do not apply. */
+const DATA_EXEMPT_TYPES = new Set(["chart", "code", "table", "kpi-grid"]);
+/** More than five items in one list crowds the grid. */
+export const MAX_LIST_ITEMS = 5;
+/** A single typeset line stays at or under 60 characters. */
+export const MAX_LINE_CHARS = 60;
+/** Type must sit on the 4pt grid. */
+export const SPACING_GRID = 4;
+/** Display-text keys checked for line length and emphasis (caption has its own timing). */
+const TEXT_KEYS = ["title", "headline", "heading", "text", "value", "label"];
+const ACCENT_PATTERN = /\[([^[\]]+)\]/g;
+const accentsInString = (value) => {
+    const found = [];
+    for (const match of value.matchAll(ACCENT_PATTERN)) {
+        if (match[1] !== undefined)
+            found.push(match[1]);
+    }
+    return found;
+};
+const accentsInValue = (value) => {
+    if (typeof value === "string")
+        return accentsInString(value);
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string").flatMap(accentsInString);
+};
+const accentsOf = (props) => Object.entries(props)
+    .filter(([key]) => key !== "caption")
+    .flatMap(([, value]) => accentsInValue(value));
+/**
+ * Six or more items in one list crowd the frame. Empty lists and scenes
+ * without an items array belong to other rules; data scenes are unmeasurable
+ * prose and stay silent.
+ */
+export const typeDensityRule = ({ storyboard }) => storyboard.scenes.flatMap((scene, index) => {
+    if (scene.layer === "overlay" || DATA_EXEMPT_TYPES.has(scene.type))
+        return [];
+    const items = scene.props.items;
+    if (!Array.isArray(items) || items.length <= MAX_LIST_ITEMS)
+        return [];
+    return [
+        {
+            severity: "warning",
+            path: `/scenes/${index}/props/items`,
+            message: `scene "${scene.id}" lists ${items.length} items; dense lists crowd the grid (max ${MAX_LIST_ITEMS})`,
+            suggestion: "split into two scenes or use fewer items",
+        },
+    ];
+});
+const longestLine = (value) => value.split("\n").reduce((max, line) => Math.max(max, line.length), 0);
+const longLineKey = (props) => {
+    for (const key of TEXT_KEYS) {
+        const value = props[key];
+        if (typeof value !== "string" || value.trim() === "")
+            continue;
+        const width = longestLine(value);
+        if (width > MAX_LINE_CHARS)
+            return { key, width };
+    }
+    return undefined;
+};
+/**
+ * A title line past 60 characters overflows the grid estimate. Captions are
+ * timed speech, not grid type; overlays and data scenes stay silent. The rule
+ * is frame-agnostic on purpose (no safe-zone coupling).
+ */
+export const lineLengthRule = ({ storyboard }) => storyboard.scenes.flatMap((scene, index) => {
+    if (scene.layer === "overlay" || DATA_EXEMPT_TYPES.has(scene.type))
+        return [];
+    const hit = longLineKey(scene.props);
+    if (hit === undefined)
+        return [];
+    return [
+        {
+            severity: "warning",
+            path: `/scenes/${index}/props/${hit.key}`,
+            message: `${hit.key} line has ${hit.width} chars; keep lines <= ${MAX_LINE_CHARS}`,
+            suggestion: "split the line or shorten the text",
+        },
+    ];
+});
+/**
+ * Numeric spacing must sit on the 4pt grid. Token spacing (xs, sm, md, ...)
+ * resolves in the theme and stays silent; overlays never advance the grid.
+ */
+export const offGridSpacingRule = ({ storyboard }) => storyboard.scenes.flatMap((scene, index) => {
+    if (scene.layer === "overlay")
+        return [];
+    const spacing = scene.props.spacing;
+    if (typeof spacing !== "number" || spacing % SPACING_GRID === 0)
+        return [];
+    return [
+        {
+            severity: "warning",
+            path: `/scenes/${index}/props/spacing`,
+            message: `spacing ${spacing} is off the ${SPACING_GRID}pt grid`,
+            suggestion: `use a multiple of ${SPACING_GRID} for grid spacing`,
+        },
+    ];
+});
+const duplicateWithin = (accents) => {
+    const seen = new Set();
+    for (const accent of accents) {
+        if (seen.has(accent))
+            return accent;
+        seen.add(accent);
+    }
+    return undefined;
+};
+/**
+ * One accent per idea: the same `[x]` twice in a scene, or the same accent in
+ * two consecutive base scenes, reads as shouting. Captions are timed speech
+ * and never count; overlays are skipped without breaking the chain.
+ */
+export const duplicatedEmphasisRule = ({ storyboard }) => {
+    const findings = [];
+    let previous = new Set();
+    let hasPrevious = false;
+    storyboard.scenes.forEach((scene, index) => {
+        if (scene.layer === "overlay")
+            return;
+        const accents = accentsOf(scene.props);
+        const within = duplicateWithin(accents);
+        if (within !== undefined) {
+            findings.push({
+                severity: "warning",
+                path: `/scenes/${index}/props`,
+                message: `accent "${within}" appears twice; duplicated emphasis crowds the beat`,
+                suggestion: "keep one accent and drop the repeat",
+            });
+        }
+        else if (hasPrevious) {
+            const repeat = accents.find((accent) => previous.has(accent));
+            if (repeat !== undefined) {
+                findings.push({
+                    severity: "warning",
+                    path: `/scenes/${index}/props`,
+                    message: `accent "${repeat}" repeats the previous scene; duplicated emphasis`,
+                    suggestion: "keep one accent per idea and drop the repeat",
+                });
+            }
+        }
+        previous = new Set(accents);
+        hasPrevious = true;
+    });
+    return findings;
+};

package/dist/lint/types.d.ts

@@ -0,0 +1,41 @@
+import type { ResolvedTheme, Storyboard } from "@anvpx/motion-schema";
+import type { Timeline } from "../timing.ts";
+export interface LintFinding {
+    readonly severity: "error" | "warning";
+    readonly path: string;
+    readonly message: string;
+    readonly suggestion?: string;
+}
+/** Platform margins as fractions of the frame; supplied by the caller (the data lives in schema). */
+export interface PlatformMargins {
+    /** Conservative margins that content must stay outside; `side` applies left and right. */
+    readonly safe?: {
+        readonly top: number;
+        readonly bottom: number;
+        readonly side: number;
+    };
+    /** Platform UI bands; scene padding is raised to at least these. */
+    readonly safeZones?: {
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    };
+}
+export type PlatformMarginLookup = (id: string) => PlatformMargins | undefined;
+export interface LintInput {
+    readonly storyboard: Storyboard;
+    readonly timeline: Timeline;
+    /** On-screen words per scene, same order as `storyboard.scenes`. */
+    readonly words: readonly number[];
+    /** Resolved theme; theme-dependent rules (text-floor) are inert without it. */
+    readonly theme?: ResolvedTheme;
+    /** Platform margins by id; `safe-zone-9x16` is inert without it. */
+    readonly platforms?: PlatformMarginLookup;
+}
+/** A rule is a pure function from the resolved storyboard to findings. */
+export type LintRule = (input: LintInput) => LintFinding[];
+export interface LintResult {
+    readonly errors: readonly LintFinding[];
+    readonly warnings: readonly LintFinding[];
+}

package/dist/lint/types.js

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

package/dist/lint/words-on-screen.d.ts

@@ -0,0 +1,5 @@
+import type { LintRule } from "./types.ts";
+/** Approved by the user until measured (research says 15/8, UNVERIFIED). */
+export declare const MAX_WORDS_LANDSCAPE = 25;
+export declare const MAX_WORDS_PORTRAIT = 14;
+export declare const wordsOnScreenRule: LintRule;

package/dist/lint/words-on-screen.js

@@ -0,0 +1,24 @@
+import { isPortrait } from "./frame.js";
+/** Approved by the user until measured (research says 15/8, UNVERIFIED). */
+export const MAX_WORDS_LANDSCAPE = 25;
+export const MAX_WORDS_PORTRAIT = 14;
+/** Scenes whose text is data, not prose. */
+const EXEMPT_TYPES = new Set(["chart", "table", "kpi-grid", "code"]);
+export const wordsOnScreenRule = ({ storyboard, words }) => {
+    const max = isPortrait(storyboard.meta) ? MAX_WORDS_PORTRAIT : MAX_WORDS_LANDSCAPE;
+    return storyboard.scenes.flatMap((scene, index) => {
+        if (scene.layer === "overlay" || EXEMPT_TYPES.has(scene.type))
+            return [];
+        const count = words[index] ?? 0;
+        if (count <= max)
+            return [];
+        return [
+            {
+                severity: "warning",
+                path: `/scenes/${index}/props`,
+                message: `scene "${scene.id}" shows ${count} words; keep ${max} or fewer`,
+                suggestion: `cut to ${max} words or split the scene`,
+            },
+        ];
+    });
+};

package/dist/manifest.d.ts

@@ -0,0 +1,53 @@
+import type { VersionInfo } from "./versions.ts";
+export interface BuildManifest {
+    readonly storyboardSha256: string;
+    readonly themeHash: string;
+    /** Hash of the asset ledger the build was given; null when none was supplied. */
+    readonly ledgerSha256: string | null;
+    /** Scene types used -> version of the package that provides the plugin. */
+    readonly scenePlugins: Readonly<Record<string, string>>;
+    readonly motionKit: Readonly<Record<string, string>>;
+    readonly hyperframes: string;
+    readonly node: string;
+    readonly files: Readonly<Record<string, string>>;
+    /** Distinct Lucide icons inlined into the scenes, sorted; omitted when none. */
+    readonly icons?: readonly string[];
+    /** Absolute windows of overlays, in declared order; omitted when the storyboard has none. */
+    readonly overlays?: readonly OverlayWindow[];
+}
+export interface OverlayWindow {
+    readonly id: string;
+    readonly over: string;
+    readonly start: number;
+    readonly end: number;
+}
+export type ProjectFiles = ReadonlyMap<string, string | Uint8Array>;
+/** Build inputs that are not files of the project but still determine its bytes. */
+export interface Provenance {
+    readonly themeHash: string;
+    readonly ledgerSha256: string | null;
+    /** Scene types used by the storyboard (duplicates allowed). */
+    readonly sceneTypes: readonly string[];
+    /** Icon names the scenes drew (duplicates allowed). */
+    readonly icons?: readonly string[];
+    readonly overlays?: readonly OverlayWindow[];
+}
+/** Reproducibility manifest; no timestamps or machine paths, so identical input gives identical bytes. */
+export declare const createManifest: (storyboardJson: string, files: ProjectFiles, versions: VersionInfo, provenance: Provenance) => BuildManifest;
+/** Sorted keys at every depth, two-space indent, trailing newline. */
+export declare const renderManifest: (manifest: BuildManifest) => string;
+/** One approval-bound media byte: project-relative output path plus content hash. */
+export interface CompiledAssetView {
+    readonly path: string;
+    readonly sha256: string;
+}
+/**
+ * RA-01: compare the media the build actually copied (`assets/*` entries of
+ * the compiled manifest) with the approval. Every copied byte must be
+ * approval-bound with the identical hash, and every approved byte must be
+ * present in the build, or the media must not publish. Non-media outputs
+ * (html, fonts, licences) are out of scope and ignored; storyboard, theme
+ * and ledger drift is caught by the source re-resolve at the same boundary.
+ * Sorted for deterministic diagnostics.
+ */
+export declare const compiledAssetMismatches: (files: Readonly<Record<string, string>>, approved: readonly CompiledAssetView[]) => readonly string[];

package/dist/manifest.js

@@ -0,0 +1,55 @@
+import { canonicalJson } from "@anvpx/motion-schema";
+import { sha256Of } from "./assets.js";
+const SCENES_PACKAGE = "@anvpx/motion-scenes";
+/** Reproducibility manifest; no timestamps or machine paths, so identical input gives identical bytes. */
+export const createManifest = (storyboardJson, files, versions, provenance) => {
+    const iconNames = [...new Set(provenance.icons ?? [])].sort();
+    return {
+        storyboardSha256: sha256Of(storyboardJson),
+        themeHash: provenance.themeHash,
+        ledgerSha256: provenance.ledgerSha256,
+        scenePlugins: Object.fromEntries([...new Set(provenance.sceneTypes)]
+            .sort()
+            .map((type) => [type, versions.packages[SCENES_PACKAGE] ?? "unknown"])),
+        motionKit: versions.packages,
+        hyperframes: versions.hyperframes,
+        node: versions.node,
+        files: Object.fromEntries([...files].sort(([a], [b]) => (a < b ? -1 : 1)).map(([path, data]) => [path, sha256Of(data)])),
+        ...(iconNames.length > 0 ? { icons: iconNames } : {}),
+        ...(provenance.overlays && provenance.overlays.length > 0
+            ? { overlays: provenance.overlays }
+            : {}),
+    };
+};
+/** Sorted keys at every depth, two-space indent, trailing newline. */
+export const renderManifest = (manifest) => canonicalJson(manifest);
+/**
+ * RA-01: compare the media the build actually copied (`assets/*` entries of
+ * the compiled manifest) with the approval. Every copied byte must be
+ * approval-bound with the identical hash, and every approved byte must be
+ * present in the build, or the media must not publish. Non-media outputs
+ * (html, fonts, licences) are out of scope and ignored; storyboard, theme
+ * and ledger drift is caught by the source re-resolve at the same boundary.
+ * Sorted for deterministic diagnostics.
+ */
+export const compiledAssetMismatches = (files, approved) => {
+    const want = new Map(approved.map((entry) => [entry.path, entry.sha256]));
+    const mismatches = [];
+    for (const [path, sha] of Object.entries(files)) {
+        if (!path.startsWith("assets/"))
+            continue;
+        const approvedSha = want.get(path);
+        if (approvedSha === undefined) {
+            mismatches.push(`"${path}" was copied into the build but is not in the approval`);
+        }
+        else if (approvedSha !== sha) {
+            mismatches.push(`"${path}" sha differs from the approval`);
+        }
+    }
+    for (const entry of approved) {
+        if (files[entry.path] === undefined) {
+            mismatches.push(`approved "${entry.path}" is missing from the build`);
+        }
+    }
+    return mismatches.sort();
+};

package/dist/render-manifest.d.ts

@@ -0,0 +1,21 @@
+import type { VerifyStatus } from "./verify.ts";
+export interface RenderManifestInput {
+    readonly kind: "draft" | "final";
+    /** sha256 of the deterministic `manifest.json` of the project that was rendered. */
+    readonly manifestSha256: string;
+    /** Basename and hash of the rendered file; no directory, so the record is machine independent. */
+    readonly output: {
+        readonly file: string;
+        readonly sha256: string;
+    };
+    readonly params: Readonly<Record<string, string | number | boolean>>;
+    /** Versions of the tools that ran; "unknown" when they could not be detected. */
+    readonly tools: Readonly<Record<string, string>>;
+    readonly verify: VerifyStatus | "not-run";
+}
+export interface RenderManifest extends RenderManifestInput {
+    readonly schema: 1;
+}
+/** Render-time provenance, written next to the mp4; kept apart from the deterministic build manifest. */
+export declare const createRenderManifest: (input: RenderManifestInput) => RenderManifest;
+export declare const renderRenderManifest: (manifest: RenderManifest) => string;

package/dist/render-manifest.js

@@ -0,0 +1,7 @@
+import { canonicalJson } from "@anvpx/motion-schema";
+/** Render-time provenance, written next to the mp4; kept apart from the deterministic build manifest. */
+export const createRenderManifest = (input) => ({
+    schema: 1,
+    ...input,
+});
+export const renderRenderManifest = (manifest) => canonicalJson(manifest);

package/dist/review/review.d.ts

@@ -0,0 +1,15 @@
+import { type GradeName } from "@anvpx/motion-themes";
+/** Output path of the auto-emitted grade review sheet (no new CLI command). */
+export declare const GRADE_REVIEW_PATH = "review/grade.html";
+export interface GradeReviewInput {
+    readonly themeName: string;
+    readonly themeCss: string;
+    readonly gradeCss: string;
+    readonly grades: Readonly<Record<GradeName, string>>;
+}
+/**
+ * Per-grade stills grid (CSS-gradient stills with the grade preview filter).
+ * Pure and deterministic: no timestamps, no network, no inline script.
+ * SDR only: tone maps are HDR-prepare selections, never an HDR output claim.
+ */
+export declare const renderGradeReview: (input: GradeReviewInput) => string;

package/dist/review/review.js

@@ -0,0 +1,56 @@
+import { esc } from "@anvpx/motion-scenes";
+import { GRADE_NAMES, gradeFilter, gradeLutFile, gradeToneMap, } from "@anvpx/motion-themes";
+/** Output path of the auto-emitted grade review sheet (no new CLI command). */
+export const GRADE_REVIEW_PATH = "review/grade.html";
+const cardSwatch = (grade, colour) => {
+    const filter = gradeFilter(grade);
+    const style = `background: linear-gradient(135deg, ${colour} 0%, #808080 55%, #101010 100%);` +
+        (filter === "none" ? "" : ` filter: ${filter};`);
+    return `<div class="mk-grade-swatch" style="${esc(style)}" aria-hidden="true"></div>`;
+};
+const cardOf = (grade, colour) => {
+    const lut = gradeLutFile(grade) ?? "none";
+    const tone = gradeToneMap(grade);
+    const filter = gradeFilter(grade);
+    return [
+        `<article class="mk-grade-card" data-grade="${esc(grade)}">`,
+        `  <h2>${esc(grade)}</h2>`,
+        `  ${cardSwatch(grade, colour)}`,
+        `  <dl>`,
+        `    <dt>colour</dt><dd><code>${esc(colour)}</code></dd>`,
+        `    <dt>lut</dt><dd><code>${esc(lut)}</code></dd>`,
+        `    <dt>tone map (HDR prepare)</dt><dd><code>${esc(tone)}</code></dd>`,
+        `    <dt>preview filter</dt><dd><code>${esc(filter)}</code></dd>`,
+        `  </dl>`,
+        `</article>`,
+    ].join("\n");
+};
+/**
+ * Per-grade stills grid (CSS-gradient stills with the grade preview filter).
+ * Pure and deterministic: no timestamps, no network, no inline script.
+ * SDR only: tone maps are HDR-prepare selections, never an HDR output claim.
+ */
+export const renderGradeReview = (input) => {
+    const cards = GRADE_NAMES.map((grade) => cardOf(grade, input.grades[grade])).join("\n");
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=1280" />
+    <title>${esc(`Grade review — ${input.themeName}`)}</title>
+    <style>
+${input.themeCss}${input.gradeCss}    .mk-grade-grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 24px; padding: 24px; }
+    .mk-grade-card { border: 1px solid var(--mk-color-divider, #ccc); border-radius: 12px; padding: 16px; }
+    .mk-grade-swatch { width: 100%; height: 180px; border-radius: 8px; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Grade review — ${esc(input.themeName)} (SDR)</h1>
+      <p>Curated grades: ${esc(GRADE_NAMES.join(", "))}. LUTs ship as CC0-1.0 data; tone maps are HDR-prepare selections only.</p>
+${cards}
+    </main>
+  </body>
+</html>
+`;
+};