@anvpx/motion-build 0.0.0-stage → 0.1.0

package/dist/verify.js

@@ -0,0 +1,180 @@
+const EXPECTED_VIDEO_CODEC = "h264";
+const EXPECTED_PIX_FMT = "yuv420p";
+const EXPECTED_AUDIO_CODEC = "aac";
+const FPS_TOLERANCE = 0.01;
+const DURATION_TOLERANCE_SECONDS = 0.1;
+const FRAME_TOLERANCE = 1;
+const ASPECT_TOLERANCE = 0.01;
+const asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : undefined;
+const text = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+const count = (value) => {
+    const n = typeof value === "string" ? Number(value) : value;
+    return typeof n === "number" && Number.isFinite(n) && n >= 0 ? n : undefined;
+};
+const parseRate = (value) => {
+    const match = /^(\d+)\/(\d+)$/.exec(String(value ?? ""));
+    const denominator = Number(match?.[2]);
+    return match && denominator > 0 ? Number(match[1]) / denominator : undefined;
+};
+const videoOf = (stream) => ({
+    ...(text(stream.codec_name) ? { codec: text(stream.codec_name) } : {}),
+    ...(text(stream.pix_fmt) ? { pixFmt: text(stream.pix_fmt) } : {}),
+    ...(count(stream.width) !== undefined ? { width: count(stream.width) } : {}),
+    ...(count(stream.height) !== undefined ? { height: count(stream.height) } : {}),
+    ...(parseRate(stream.r_frame_rate) !== undefined
+        ? { fps: parseRate(stream.r_frame_rate) }
+        : {}),
+    ...(count(stream.nb_frames) !== undefined ? { frames: count(stream.nb_frames) } : {}),
+});
+const readProbe = (probe) => {
+    const root = asRecord(probe);
+    const streams = Array.isArray(root?.streams) ? root.streams.map(asRecord) : [];
+    const videoStream = streams.find((s) => s?.codec_type === "video");
+    const audioStream = streams.find((s) => s?.codec_type === "audio");
+    const duration = count(asRecord(root?.format)?.duration);
+    return {
+        ...(videoStream ? { video: videoOf(videoStream) } : {}),
+        ...(text(audioStream?.codec_name)
+            ? { audioCodec: text(audioStream?.codec_name) }
+            : {}),
+        hasAudio: audioStream !== undefined,
+        ...(duration !== undefined ? { duration } : {}),
+    };
+};
+const sizeOf = (width, height) => `${width ?? "?"}x${height ?? "?"}`;
+function checkCodecs(video, add) {
+    if (video.codec !== undefined && video.codec !== EXPECTED_VIDEO_CODEC) {
+        add("video-codec-unexpected", "fatal", `Video codec is ${video.codec}, expected ${EXPECTED_VIDEO_CODEC}. Re-encode with libx264.`);
+    }
+    if (video.pixFmt !== undefined && video.pixFmt !== EXPECTED_PIX_FMT) {
+        add("pix-fmt-unexpected", "fatal", `Pixel format is ${video.pixFmt}, expected ${EXPECTED_PIX_FMT}. Re-encode with -pix_fmt yuv420p.`);
+    }
+}
+function checkFrame(video, expected, add) {
+    const { width, height, fps } = video;
+    const differs = (actual, wanted) => actual !== undefined && wanted !== undefined && actual !== wanted;
+    if (differs(width, expected.width) || differs(height, expected.height)) {
+        add("resolution-mismatch", "fatal", `Resolution is ${sizeOf(width, height)}, expected ${sizeOf(expected.width, expected.height)}.`);
+    }
+    if (expected.fps !== undefined &&
+        fps !== undefined &&
+        Math.abs(fps - expected.fps) > FPS_TOLERANCE) {
+        add("fps-mismatch", "fatal", `Frame rate is ${fps.toFixed(3)}, expected ${expected.fps}.`);
+    }
+}
+function checkTiming(probed, expected, add) {
+    const { video, duration } = probed;
+    const fps = video?.fps;
+    if (expected.duration !== undefined && duration !== undefined) {
+        const tolerance = Math.max(DURATION_TOLERANCE_SECONDS, fps ? 1 / fps : 0);
+        if (Math.abs(duration - expected.duration) > tolerance) {
+            add("duration-mismatch", "fatal", `Duration is ${duration.toFixed(2)}s, expected ${expected.duration.toFixed(2)}s.`);
+        }
+    }
+    const reference = expected.duration ?? duration;
+    if (video?.frames === undefined || fps === undefined || reference === undefined)
+        return;
+    const wanted = Math.round(reference * fps);
+    if (Math.abs(video.frames - wanted) > FRAME_TOLERANCE) {
+        add("frame-count-mismatch", "fatal", `Frame count is ${video.frames}, expected ${wanted} (duration x fps, 1 frame tolerance).`);
+    }
+}
+function checkAudio(probed, expected, add) {
+    if (expected.audio === true && !probed.hasAudio) {
+        add("audio-stream-missing", "fatal", "No audio stream, but the storyboard expects audio.");
+    }
+    if (expected.audio === false && probed.hasAudio) {
+        add("audio-unexpected", "info", "Audio stream present although none was expected.");
+    }
+    if (probed.audioCodec !== undefined && probed.audioCodec !== EXPECTED_AUDIO_CODEC) {
+        add("audio-codec-unexpected", "warn", `Audio codec is ${probed.audioCodec}, expected ${EXPECTED_AUDIO_CODEC}.`);
+    }
+}
+const isDecidable = (probed, expected) => {
+    const { video, duration } = probed;
+    if (!video)
+        return true;
+    const needsSize = expected.width !== undefined || expected.height !== undefined;
+    const missing = video.codec === undefined ||
+        video.pixFmt === undefined ||
+        video.fps === undefined ||
+        video.frames === undefined ||
+        duration === undefined ||
+        (needsSize && (video.width === undefined || video.height === undefined));
+    return !missing;
+};
+function aspectOf(template) {
+    const [w = 1, h = 1] = template.aspect.split(":").map(Number);
+    return w / h;
+}
+function checkPlatformSize(video, template, add) {
+    const { width, height } = video;
+    if (!width || !height)
+        return;
+    if (Math.abs(width / height - aspectOf(template)) > ASPECT_TOLERANCE) {
+        add("platform-aspect", "fatal", `${sizeOf(width, height)} is not ${template.aspect} as ${template.id} requires.`);
+    }
+    else if (width !== template.width || height !== template.height) {
+        add("platform-resolution", "warn", `${template.id} targets ${template.width}x${template.height}; file is ${sizeOf(width, height)}.`);
+    }
+}
+function checkPlatformFrame(video, template, add) {
+    const id = template.id;
+    checkPlatformSize(video, template, add);
+    if (video.fps !== undefined && video.fps > template.maxFps + FPS_TOLERANCE) {
+        add("platform-fps", "fatal", `Frame rate ${video.fps} exceeds the ${id} maximum ${template.maxFps}.`);
+    }
+    if (video.codec !== undefined && video.codec !== template.codec.video) {
+        add("platform-codec", "fatal", `Video codec ${video.codec} differs from ${id} ${template.codec.video}.`);
+    }
+}
+function checkPlatform(probed, template, add) {
+    const { video, duration } = probed;
+    const id = template.id;
+    if (video)
+        checkPlatformFrame(video, template, add);
+    const cap = template.maxDurationSec;
+    if (cap !== undefined && duration !== undefined && duration > cap) {
+        add("platform-duration", "fatal", `Duration ${duration.toFixed(1)}s exceeds the ${id} cap ${cap}s.`);
+    }
+    if (!template.verified) {
+        add("platform-unverified", "info", `Template ${id} has verified: false; its limits are approximations. Check the platform's current specs.`);
+    }
+}
+const statusOf = (findings, decidable) => {
+    if (findings.some((f) => f.level === "fatal"))
+        return "FAIL";
+    if (!decidable)
+        return "UNKNOWN";
+    return findings.some((f) => f.level === "warn") ? "WARN" : "PASS";
+};
+/** Pure QC over probe JSON: measures and reports; the caller decides what to do with the status. */
+export function verifyMedia(input) {
+    if (!Array.isArray(asRecord(input.probe)?.streams)) {
+        const message = "Probe output has no streams list; result is UNKNOWN.";
+        return { status: "UNKNOWN", findings: [{ code: "probe-incomplete", level: "warn", message }] };
+    }
+    const expected = input.expect ?? {};
+    const probed = readProbe(input.probe);
+    const findings = [];
+    const add = (code, level, message, path) => findings.push({ code, level, message, ...(path === undefined ? {} : { path }) });
+    const { video } = probed;
+    if (video) {
+        checkCodecs(video, add);
+        checkFrame(video, expected, add);
+        checkTiming(probed, expected, add);
+    }
+    else {
+        add("video-stream-missing", "fatal", "No video stream found. Is the file a rendered mp4?");
+    }
+    checkAudio(probed, expected, add);
+    if (input.platform)
+        checkPlatform(probed, input.platform, add);
+    const decidable = isDecidable(probed, expected);
+    if (!decidable) {
+        add("probe-incomplete", "warn", "Probe lacked fields needed to decide; result is UNKNOWN.");
+    }
+    return { status: statusOf(findings, decidable), findings };
+}

package/dist/versions.d.ts

@@ -0,0 +1,26 @@
+/** Turns a package id into a path; injectable so tests need no real package tree. */
+export type PackageResolver = (id: string) => string;
+/**
+ * Where the root manifest may live, in order: the project being run in (a consumer
+ * install has only its own), the workspace root beside these sources, and finally this
+ * package's own manifest, which exists in every installed layout.
+ */
+export declare function rootPackageCandidates(cwd?: string): string[];
+export interface VersionInfo {
+    readonly packages: Readonly<Record<string, string>>;
+    readonly hyperframes: string;
+    readonly node: string;
+}
+/** Overrides for the two resolution paths, so fixtures need no real package tree. */
+export interface VersionSources {
+    /** Resolves `@anvpx/motion-<name>/package.json`; throws when the package is not installed. */
+    readonly resolve?: PackageResolver;
+    /** Base URL of this module, for the workspace-relative fallback. */
+    readonly manifestBase?: string | URL;
+}
+/**
+ * Versions recorded in manifest.json: workspace packages and the pinned renderer.
+ * The root manifest is best-effort provenance, never a render gate: a consumer install
+ * without a repo root yields the unpinned/empty shape instead of throwing.
+ */
+export declare const readVersions: (candidates?: readonly string[], sources?: VersionSources) => VersionInfo;

package/dist/versions.js

@@ -0,0 +1,74 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+const PACKAGES = ["build", "scenes", "schema", "themes"];
+const defaultResolve = (id) => createRequire(import.meta.url).resolve(id);
+/** Reads and parses a manifest; undefined when it is absent or not JSON. */
+const tryReadJson = (path) => {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Where the root manifest may live, in order: the project being run in (a consumer
+ * install has only its own), the workspace root beside these sources, and finally this
+ * package's own manifest, which exists in every installed layout.
+ */
+export function rootPackageCandidates(cwd = process.cwd()) {
+    return [
+        join(cwd, "package.json"),
+        fileURLToPath(new URL("../../../package.json", import.meta.url)),
+        fileURLToPath(new URL("../package.json", import.meta.url)),
+    ];
+}
+/** First candidate that reads and parses; an empty manifest when none does. */
+function readRootPackage(candidates) {
+    for (const path of candidates) {
+        const value = tryReadJson(path);
+        if (value !== undefined)
+            return value;
+    }
+    return {};
+}
+/**
+ * One sibling package's version. Installed layouts name siblings `@anvpx/motion-<name>`,
+ * so the manifest is resolved by package name; the workspace checkout keeps `../../<name>`
+ * as a fallback, and a total miss is `"unknown"` rather than a throw.
+ */
+function packageVersion(name, resolve, base) {
+    try {
+        const installed = tryReadJson(resolve(`@anvpx/motion-${name}/package.json`));
+        if (installed?.version !== undefined)
+            return String(installed.version);
+    }
+    catch {
+        // Not an installed layout: the workspace sibling below still names the version.
+    }
+    const sibling = tryReadJson(fileURLToPath(new URL(`../../${name}/package.json`, base)));
+    return sibling?.version === undefined ? "unknown" : String(sibling.version);
+}
+/**
+ * Versions recorded in manifest.json: workspace packages and the pinned renderer.
+ * The root manifest is best-effort provenance, never a render gate: a consumer install
+ * without a repo root yields the unpinned/empty shape instead of throwing.
+ */
+export const readVersions = (candidates = rootPackageCandidates(), sources = {}) => {
+    const resolve = sources.resolve ?? defaultResolve;
+    const base = sources.manifestBase ?? import.meta.url;
+    const entries = [...PACKAGES]
+        .sort()
+        .map((name) => [
+        `@anvpx/motion-${name}`,
+        packageVersion(name, resolve, base),
+    ]);
+    const root = readRootPackage(candidates);
+    return {
+        packages: Object.fromEntries(entries),
+        hyperframes: root.motionKit?.pins?.hyperframes ?? "unpinned",
+        node: process.versions.node,
+    };
+};

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@anvpx/motion-build",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Storyboard compiler for @anvpx/motion: validation, scene emission and HyperFrames project output.",
+  "license": "MIT",
+  "author": "anvpx",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "motion-kit",
+    "build",
+    "storyboard",
+    "hyperframes",
+    "video"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@fontsource/inter": "5.3.0",
+    "@fontsource/jetbrains-mono": "5.3.0",
+    "@fontsource/source-serif-4": "5.3.1",
+    "@fontsource/space-grotesk": "5.3.0",
+    "@anvpx/motion-scenes": "0.1.0",
+    "@anvpx/motion-schema": "0.1.0",
+    "@anvpx/motion-themes": "0.1.0",
+    "postprocessing": "6.39.5",
+    "three": "0.186.0"
+  },
+  "scripts": {
+    "test:integration": "vitest run --config vitest.integration.config.ts"
+  }
 }