@anvpx/motion-schema 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 anvpx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/data/platforms/facebook.json

@@ -0,0 +1,30 @@
+{
+  "aliases": [],
+  "aspect": "16:9",
+  "audio": {
+    "lufsTarget": -14,
+    "truePeakDb": -1
+  },
+  "codec": {
+    "audio": "aac",
+    "video": "h264"
+  },
+  "height": 1080,
+  "id": "facebook",
+  "maxFps": 30,
+  "notes": "Feed video; 9:16 and 1:1 also accepted. Safe zone is the generic 5% title-safe margin. safe{} is the generic 5% title-safe margin.",
+  "safe": {
+    "bottom": 0.05,
+    "side": 0.05,
+    "top": 0.05
+  },
+  "safeZones": {
+    "bottom": 0.05,
+    "left": 0.05,
+    "right": 0.05,
+    "top": 0.05
+  },
+  "source": "Meta video specs (general guidance); loudness is the common social norm, not a platform-published target",
+  "verified": false,
+  "width": 1920
+}

package/data/platforms/linkedin.json

@@ -0,0 +1,31 @@
+{
+  "aliases": [],
+  "aspect": "16:9",
+  "audio": {
+    "lufsTarget": -14,
+    "truePeakDb": -1
+  },
+  "codec": {
+    "audio": "aac",
+    "video": "h264"
+  },
+  "height": 1080,
+  "id": "linkedin",
+  "maxDurationSec": 600,
+  "maxFps": 30,
+  "notes": "Feed video up to 10 min. Safe zone is the generic 5% title-safe margin. safe{} is the generic 5% title-safe margin.",
+  "safe": {
+    "bottom": 0.05,
+    "side": 0.05,
+    "top": 0.05
+  },
+  "safeZones": {
+    "bottom": 0.05,
+    "left": 0.05,
+    "right": 0.05,
+    "top": 0.05
+  },
+  "source": "LinkedIn video ad/post specs (general guidance); loudness is the common social norm",
+  "verified": false,
+  "width": 1920
+}

package/data/platforms/podcast.json

@@ -0,0 +1,30 @@
+{
+  "aliases": [],
+  "aspect": "1:1",
+  "audio": {
+    "lufsTarget": -16,
+    "truePeakDb": -1
+  },
+  "codec": {
+    "audio": "aac",
+    "video": "h264"
+  },
+  "height": 1080,
+  "id": "podcast",
+  "maxFps": 30,
+  "notes": "Audio-first; the video frame is an optional audiogram/cover. -16 LUFS is the common podcast target. safe{} is the generic 5% title-safe margin.",
+  "safe": {
+    "bottom": 0.05,
+    "side": 0.05,
+    "top": 0.05
+  },
+  "safeZones": {
+    "bottom": 0.05,
+    "left": 0.05,
+    "right": 0.05,
+    "top": 0.05
+  },
+  "source": "Apple/Spotify podcast loudness convention (-16 LUFS stereo); 1:1 frame is a pragmatic default",
+  "verified": false,
+  "width": 1080
+}

package/data/platforms/reels.json

@@ -0,0 +1,31 @@
+{
+  "aliases": ["instagram-reels"],
+  "aspect": "9:16",
+  "audio": {
+    "lufsTarget": -14,
+    "truePeakDb": -1
+  },
+  "codec": {
+    "audio": "aac",
+    "video": "h264"
+  },
+  "height": 1920,
+  "id": "reels",
+  "maxDurationSec": 180,
+  "maxFps": 30,
+  "notes": "Bottom and top bands are covered by caption and profile UI; fractions are approximate. safe{} is the conservative common margin (top 15%, bottom 20%, sides 5%) shared by vertical platforms; not a per-platform measurement.",
+  "safe": {
+    "bottom": 0.2,
+    "side": 0.05,
+    "top": 0.15
+  },
+  "safeZones": {
+    "bottom": 0.2,
+    "left": 0.06,
+    "right": 0.06,
+    "top": 0.14
+  },
+  "source": "Meta Reels specs (1080x1920, 9:16); UI margins and duration cap are approximations",
+  "verified": false,
+  "width": 1080
+}

package/data/platforms/shorts.json

@@ -0,0 +1,31 @@
+{
+  "aliases": ["youtube-shorts"],
+  "aspect": "9:16",
+  "audio": {
+    "lufsTarget": -14,
+    "truePeakDb": -1
+  },
+  "codec": {
+    "audio": "aac",
+    "video": "h264"
+  },
+  "height": 1920,
+  "id": "shorts",
+  "maxDurationSec": 180,
+  "maxFps": 60,
+  "notes": "Right rail holds action buttons; bottom holds title/channel. Fractions are approximate. safe{} is the conservative common margin (top 15%, bottom 20%, sides 5%) shared by vertical platforms; not a per-platform measurement.",
+  "safe": {
+    "bottom": 0.2,
+    "side": 0.05,
+    "top": 0.15
+  },
+  "safeZones": {
+    "bottom": 0.2,
+    "left": 0.05,
+    "right": 0.12,
+    "top": 0.1
+  },
+  "source": "YouTube Shorts specs (9:16, up to 3 min); UI margins approximate",
+  "verified": false,
+  "width": 1080
+}

package/data/platforms/tiktok.json

@@ -0,0 +1,31 @@
+{
+  "aliases": [],
+  "aspect": "9:16",
+  "audio": {
+    "lufsTarget": -14,
+    "truePeakDb": -1
+  },
+  "codec": {
+    "audio": "aac",
+    "video": "h264"
+  },
+  "height": 1920,
+  "id": "tiktok",
+  "maxDurationSec": 600,
+  "maxFps": 60,
+  "notes": "Right rail holds action buttons; bottom holds caption and music bar. Fractions are approximate. safe{} is the conservative common margin (top 15%, bottom 20%, sides 5%) shared by vertical platforms; not a per-platform measurement.",
+  "safe": {
+    "bottom": 0.2,
+    "side": 0.05,
+    "top": 0.15
+  },
+  "safeZones": {
+    "bottom": 0.22,
+    "left": 0.05,
+    "right": 0.12,
+    "top": 0.12
+  },
+  "source": "TikTok video specs (1080x1920, 9:16); duration cap and UI margins are approximations",
+  "verified": false,
+  "width": 1080
+}

package/data/platforms/x.json

@@ -0,0 +1,31 @@
+{
+  "aliases": ["twitter"],
+  "aspect": "16:9",
+  "audio": {
+    "lufsTarget": -14,
+    "truePeakDb": -1
+  },
+  "codec": {
+    "audio": "aac",
+    "video": "h264"
+  },
+  "height": 1080,
+  "id": "x",
+  "maxDurationSec": 140,
+  "maxFps": 60,
+  "notes": "140 s applies to standard accounts; longer for subscribers. Safe zone is the generic 5% title-safe margin. safe{} is the generic 5% title-safe margin.",
+  "safe": {
+    "bottom": 0.05,
+    "side": 0.05,
+    "top": 0.05
+  },
+  "safeZones": {
+    "bottom": 0.05,
+    "left": 0.05,
+    "right": 0.05,
+    "top": 0.05
+  },
+  "source": "X media specs (general guidance); loudness is the common social norm",
+  "verified": false,
+  "width": 1920
+}

package/data/platforms/youtube.json

@@ -0,0 +1,30 @@
+{
+  "aliases": [],
+  "aspect": "16:9",
+  "audio": {
+    "lufsTarget": -14,
+    "truePeakDb": -1
+  },
+  "codec": {
+    "audio": "aac",
+    "video": "h264"
+  },
+  "height": 1080,
+  "id": "youtube",
+  "maxFps": 60,
+  "notes": "YouTube normalises playback to about -14 LUFS. Safe zone is the generic 5% title-safe margin. safe{} is the generic 5% title-safe margin.",
+  "safe": {
+    "bottom": 0.05,
+    "side": 0.05,
+    "top": 0.05
+  },
+  "safeZones": {
+    "bottom": 0.05,
+    "left": 0.05,
+    "right": 0.05,
+    "top": 0.05
+  },
+  "source": "YouTube recommended upload encoding (H.264/AAC, 1080p); -14 LUFS playback normalisation",
+  "verified": true,
+  "width": 1920
+}

package/dist/audio.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+/**
+ * Voice word timings (additive, v1 — no version bump, no migration step).
+ *
+ * Binds `projects/spike-aligner/results/stage2-en-short.json`: words are
+ * `{w, start, end}` on the clip clock (seconds); the aligner emits no
+ * confidence, so it stays optional. Field name `w` matches the spike output
+ * verbatim to avoid a lossy rename at the producer boundary.
+ */
+export declare const WordTimingSchema: z.ZodObject<{
+    w: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** Word lists are sorted by start and non-overlapping (touching edges allowed). */
+export declare const WordTimingsSchema: z.ZodArray<z.ZodObject<{
+    w: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>;
+/** A silence gap on the clip clock (seconds); maps `silence_intervals` pairs. */
+export declare const SilenceIntervalSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+}, z.core.$strict>;
+/**
+ * Aligner output for one audio clip (additive, v1 — no version bump).
+ * `model`/`modelRevision`/`modelLicense` map the spike's
+ * `model`/`model_revision`/`model_license` to repo camelCase. `peaks` are
+ * normalized waveform peaks (0..1) for caption/scroll rendering; all fields
+ * except `words` are optional so partial analyses still parse.
+ */
+export declare const AudioAnalysisSchema: z.ZodObject<{
+    words: z.ZodArray<z.ZodObject<{
+        w: z.ZodString;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    silences: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strict>>>;
+    peaks: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    model: z.ZodOptional<z.ZodString>;
+    modelRevision: z.ZodOptional<z.ZodString>;
+    modelLicense: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type WordTiming = z.output<typeof WordTimingSchema>;
+export type SilenceInterval = z.output<typeof SilenceIntervalSchema>;
+export type AudioAnalysis = z.output<typeof AudioAnalysisSchema>;
+/**
+ * Opt-in user CC0 music bed: an explicit local `.wav` plus an optional
+ * ducked level (audible bed, narration stays ahead). Single source of truth for the
+ * bed guard: `@anvpx/motion-audio` (CLI validation) and `@anvpx/motion-build`
+ * (mix graph) both parse through here, so neither layer carries its own
+ * copy of the rule (constitution 2.1: both packages import schema only).
+ */
+export declare const DEFAULT_MUSIC_VOLUME = 0.5;
+export declare const MusicBedSchema: z.ZodObject<{
+    wav: z.ZodString;
+    volume: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type MusicBedInput = {
+    readonly wav: string;
+    readonly volume?: number;
+};
+export type ValidMusicBed = {
+    readonly wav: string;
+    readonly volume: number;
+};
+export type MusicBedResult = {
+    ok: true;
+    bed: ValidMusicBed;
+} | {
+    ok: false;
+    hint: string;
+};
+/** Parse an explicit user bed; applies the default level, never invents a path. */
+export declare const parseMusicBed: (value: unknown) => MusicBedResult;

package/dist/audio.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+/**
+ * Voice word timings (additive, v1 — no version bump, no migration step).
+ *
+ * Binds `projects/spike-aligner/results/stage2-en-short.json`: words are
+ * `{w, start, end}` on the clip clock (seconds); the aligner emits no
+ * confidence, so it stays optional. Field name `w` matches the spike output
+ * verbatim to avoid a lossy rename at the producer boundary.
+ */
+export const WordTimingSchema = z
+    .strictObject({
+    w: z.string().min(1),
+    start: z.number().min(0),
+    end: z.number().positive(),
+    confidence: z.number().min(0).max(1).optional(),
+})
+    .refine((word) => word.end > word.start, "end must be after start");
+/** Word lists are sorted by start and non-overlapping (touching edges allowed). */
+export const WordTimingsSchema = z.array(WordTimingSchema).superRefine((words, ctx) => {
+    words.forEach((word, index) => {
+        const prev = words[index - 1];
+        if (prev && word.start < prev.end) {
+            ctx.addIssue({
+                code: "custom",
+                path: [index, "start"],
+                message: `word "${word.w}" overlaps "${prev.w}"`,
+            });
+        }
+    });
+});
+/** A silence gap on the clip clock (seconds); maps `silence_intervals` pairs. */
+export const SilenceIntervalSchema = z
+    .strictObject({
+    start: z.number().min(0),
+    end: z.number().positive(),
+})
+    .refine((gap) => gap.end > gap.start, "end must be after start");
+/**
+ * Aligner output for one audio clip (additive, v1 — no version bump).
+ * `model`/`modelRevision`/`modelLicense` map the spike's
+ * `model`/`model_revision`/`model_license` to repo camelCase. `peaks` are
+ * normalized waveform peaks (0..1) for caption/scroll rendering; all fields
+ * except `words` are optional so partial analyses still parse.
+ */
+export const AudioAnalysisSchema = z.strictObject({
+    words: WordTimingsSchema.min(1),
+    silences: z.array(SilenceIntervalSchema).optional(),
+    peaks: z.array(z.number().min(0).max(1)).optional(),
+    model: z.string().min(1).optional(),
+    modelRevision: z.string().min(1).optional(),
+    modelLicense: z.string().min(1).optional(),
+    duration: z.number().positive().optional(),
+});
+/**
+ * Opt-in user CC0 music bed: an explicit local `.wav` plus an optional
+ * ducked level (audible bed, narration stays ahead). Single source of truth for the
+ * bed guard: `@anvpx/motion-audio` (CLI validation) and `@anvpx/motion-build`
+ * (mix graph) both parse through here, so neither layer carries its own
+ * copy of the rule (constitution 2.1: both packages import schema only).
+ */
+export const DEFAULT_MUSIC_VOLUME = 0.5;
+export const MusicBedSchema = z
+    .strictObject({
+    wav: z.string().min(1),
+    volume: z
+        .number()
+        .refine((n) => Number.isFinite(n) && n > 0 && n <= 1, "must be within (0, 1]")
+        .optional(),
+})
+    .refine((bed) => bed.wav.endsWith(".wav") && !bed.wav.includes(".."), {
+    message: "must be a local .wav without traversal",
+    path: ["wav"],
+});
+/** Parse an explicit user bed; applies the default level, never invents a path. */
+export const parseMusicBed = (value) => {
+    const parsed = MusicBedSchema.safeParse(value);
+    if (!parsed.success) {
+        const problems = parsed.error.issues
+            .map((issue) => `${issue.path.join("/")}: ${issue.message}`)
+            .join("; ");
+        return { ok: false, hint: `invalid music bed: ${problems}` };
+    }
+    return {
+        ok: true,
+        bed: { wav: parsed.data.wav, volume: parsed.data.volume ?? DEFAULT_MUSIC_VOLUME },
+    };
+};

package/dist/contract.d.ts

@@ -0,0 +1,2 @@
+/** Deterministic JSON: keys sorted by UTF-16 code unit at every depth, 2-space indent, final newline. */
+export declare const canonicalJson: (value: unknown) => string;

package/dist/contract.js

@@ -0,0 +1,11 @@
+const sortDeep = (value) => {
+    if (Array.isArray(value))
+        return value.map(sortDeep);
+    if (typeof value !== "object" || value === null)
+        return value;
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, sortDeep(Reflect.get(value, key))]));
+};
+/** Deterministic JSON: keys sorted by UTF-16 code unit at every depth, 2-space indent, final newline. */
+export const canonicalJson = (value) => `${JSON.stringify(sortDeep(value), null, 2)}\n`;

package/dist/contracts.d.ts

@@ -0,0 +1,58 @@
+import type { ZodType } from "zod";
+import type { SceneEntry } from "./storyboard.ts";
+import type { ResolvedTheme } from "./theme.ts";
+export interface EmitContext {
+    readonly theme: ResolvedTheme;
+    readonly fps: number;
+    readonly width: number;
+    readonly height: number;
+    /**
+     * Platform UI bands as fractions of the frame (top, right, bottom, left); scene padding is raised to
+     * at least these. Absent: the plain 5 % margin.
+     */
+    readonly insets?: {
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    };
+    /** Scene duration in seconds. */
+    readonly duration: number;
+    /** Absolute placement of this scene on the final timeline (seconds). */
+    readonly timeline?: {
+        readonly start: number;
+        readonly total: number;
+    };
+    assetResolver(ref: string): string;
+}
+/** Catalog documentation of a scene; fields and types are derived from `configSchema`. */
+export interface SceneMeta {
+    /** One line: what the scene is for. */
+    readonly purpose: string;
+    /** Smallest props object that passes `configSchema`. */
+    readonly example: Readonly<Record<string, unknown>>;
+}
+/**
+ * A browser library a scene may import by bare specifier. The build copies the library's ESM entry
+ * into the emitted project under `vendor/` and writes an import map, so `import ... from "three"`
+ * resolves offline with no CDN and no bundler (ADR-0006).
+ */
+export type VendorLib = "three" | "postprocessing";
+export interface ScenePlugin {
+    readonly type: string;
+    /** "overlay" scenes are transparent layers and only valid with `layer: "overlay"`; omitted = base. */
+    readonly layer?: "overlay";
+    readonly configSchema: ZodType;
+    /** Optional catalog documentation (`mk catalog`). */
+    readonly meta?: SceneMeta;
+    /** Vendored browser libraries this scene imports; omitted = none, and no `vendor/` is emitted. */
+    readonly vendor?: readonly VendorLib[];
+    /** Returns output path -> file content. */
+    emit(entry: SceneEntry, ctx: EmitContext): Map<string, string>;
+}
+/** Runtime contract of the `createScene` factory that emitted scenes export. */
+export interface SceneRuntime {
+    seek(t: number): void | Promise<void>;
+    dispose(): void;
+    readonly ready: Promise<void>;
+}

package/dist/contracts.js

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

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+/** Terse, fixable error: JSON pointer path + what is wrong + how to fix it. */
+export interface ValidationError {
+    readonly path: string;
+    readonly message: string;
+    readonly suggestion?: string;
+}
+export type Result<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly errors: readonly ValidationError[];
+};
+/** RFC 6901 pointer; the root document is the empty string. */
+export declare const toJsonPointer: (path: readonly PropertyKey[]) => string;

package/dist/errors.js

@@ -0,0 +1,3 @@
+const escapePointerSegment = (segment) => String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
+/** RFC 6901 pointer; the root document is the empty string. */
+export const toJsonPointer = (path) => path.map((segment) => `/${escapePointerSegment(segment)}`).join("");

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { type AudioAnalysis, AudioAnalysisSchema, DEFAULT_MUSIC_VOLUME, type MusicBedInput, type MusicBedResult, MusicBedSchema, parseMusicBed, type SilenceInterval, SilenceIntervalSchema, type ValidMusicBed, type WordTiming, WordTimingSchema, WordTimingsSchema, } from "./audio.ts";
+export { canonicalJson } from "./contract.ts";
+export type { EmitContext, SceneMeta, ScenePlugin, SceneRuntime, VendorLib, } from "./contracts.ts";
+export { type Result, toJsonPointer, type ValidationError } from "./errors.ts";
+export { storyboardJsonSchema } from "./json-schema.ts";
+export { type AssetLedger, AssetLedgerSchema, type AssetRow, AssetRowSchema, renderAssetsMarkdown, } from "./ledger.ts";
+export { type PlatformPreset, PlatformPresetSchema, type PlatformTemplate, PlatformTemplateSchema, parsePlatformPreset, parsePlatformTemplate, } from "./platform.ts";
+export { forbiddenKeys } from "./reserved-keys.ts";
+export { APPROVALS, type Approval, EASES, LAYERS, MOVES, type SceneEntry, SceneEntryBaseSchema, SHOTS, STORYBOARD_VERSION, type Storyboard, type StoryboardMeta, StoryboardSchema, TRANSITIONS, } from "./storyboard.ts";
+export { type BlueprintDiscover, BlueprintDiscoverSchema, type BlueprintDoc, BlueprintDocSchema, type BlueprintRepeat, BlueprintRepeatSchema, type BlueprintScene, BlueprintSceneSchema, LENGTH_CLASSES, type ManifestDiscover, ManifestDiscoverSchema, type PacingDoc, PacingDocSchema, parseBlueprintDoc, parsePacingDoc, parseStylePreset, parseTemplateManifest, SLOT_TRANSFORMS, type SlotDef, SlotSchema, type StylePreset, StylePresetSchema, TEMPLATE_VERSION, type TemplateManifest, TemplateManifestSchema, templateJsonSchemas, } from "./template.ts";
+export type { ResolvedTheme, TextPair } from "./theme.ts";
+export { TIMING_SOURCES, type TimingManifest, TimingManifestSchema } from "./timing.ts";
+export { validateStoryboard } from "./validate.ts";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { AudioAnalysisSchema, DEFAULT_MUSIC_VOLUME, MusicBedSchema, parseMusicBed, SilenceIntervalSchema, WordTimingSchema, WordTimingsSchema, } from "./audio.js";
+export { canonicalJson } from "./contract.js";
+export { toJsonPointer } from "./errors.js";
+export { storyboardJsonSchema } from "./json-schema.js";
+export { AssetLedgerSchema, AssetRowSchema, renderAssetsMarkdown, } from "./ledger.js";
+export { PlatformPresetSchema, PlatformTemplateSchema, parsePlatformPreset, parsePlatformTemplate, } from "./platform.js";
+export { forbiddenKeys } from "./reserved-keys.js";
+export { APPROVALS, EASES, LAYERS, MOVES, SceneEntryBaseSchema, SHOTS, STORYBOARD_VERSION, StoryboardSchema, TRANSITIONS, } from "./storyboard.js";
+export { BlueprintDiscoverSchema, BlueprintDocSchema, BlueprintRepeatSchema, BlueprintSceneSchema, LENGTH_CLASSES, ManifestDiscoverSchema, PacingDocSchema, parseBlueprintDoc, parsePacingDoc, parseStylePreset, parseTemplateManifest, SLOT_TRANSFORMS, SlotSchema, StylePresetSchema, TEMPLATE_VERSION, TemplateManifestSchema, templateJsonSchemas, } from "./template.js";
+export { TIMING_SOURCES, TimingManifestSchema } from "./timing.js";
+export { validateStoryboard } from "./validate.js";

package/dist/json-schema.d.ts

@@ -0,0 +1,2 @@
+/** Duplicate scene ids are a cross-field rule JSON Schema cannot express; `validateStoryboard` enforces it. */
+export declare const storyboardJsonSchema: () => Record<string, unknown>;

package/dist/json-schema.js

@@ -0,0 +1,4 @@
+import { z } from "zod";
+import { StoryboardSchema } from "./storyboard.js";
+/** Duplicate scene ids are a cross-field rule JSON Schema cannot express; `validateStoryboard` enforces it. */
+export const storyboardJsonSchema = () => z.toJSONSchema(StoryboardSchema, { io: "input" });

package/dist/ledger.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const AssetRowSchema: z.ZodObject<{
+    path: z.ZodString;
+    sourceUrl: z.ZodURL;
+    licence: z.ZodString;
+    attribution: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodString;
+}, z.core.$strict>;
+export declare const AssetLedgerSchema: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    sourceUrl: z.ZodURL;
+    licence: z.ZodString;
+    attribution: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodString;
+}, z.core.$strict>>;
+export type AssetRow = z.output<typeof AssetRowSchema>;
+export type AssetLedger = z.output<typeof AssetLedgerSchema>;
+/** Pure and deterministic: rows sorted by path so output is diff-stable. */
+export declare const renderAssetsMarkdown: (ledger: AssetLedger) => string;

package/dist/ledger.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export const AssetRowSchema = z.strictObject({
+    path: z.string().min(1),
+    sourceUrl: z.url(),
+    licence: z.string().min(1),
+    attribution: z.string().min(1).optional(),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/, "must be 64 lowercase hex characters"),
+});
+export const AssetLedgerSchema = z.array(AssetRowSchema).superRefine((rows, ctx) => {
+    const seen = new Set();
+    rows.forEach((row, index) => {
+        if (seen.has(row.path)) {
+            ctx.addIssue({
+                code: "custom",
+                path: [index, "path"],
+                message: `duplicate ledger path "${row.path}"`,
+            });
+        }
+        seen.add(row.path);
+    });
+});
+/** Locale-independent UTF-16 code-unit order, so output is byte-identical everywhere. */
+const byPath = (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+const escapeCell = (text) => text.replaceAll("|", "\\|");
+const renderRow = (row) => {
+    const cells = [row.path, row.sourceUrl, row.licence, row.attribution ?? "", row.sha256];
+    return `| ${cells.map(escapeCell).join(" | ")} |`;
+};
+/** Pure and deterministic: rows sorted by path so output is diff-stable. */
+export const renderAssetsMarkdown = (ledger) => {
+    const rows = [...ledger].sort(byPath).map(renderRow);
+    return [
+        "# Assets",
+        "",
+        "Generated from `assets.json`. Do not edit.",
+        "",
+        "| Path | Source | Licence | Attribution | SHA-256 |",
+        "| --- | --- | --- | --- | --- |",
+        ...rows,
+        "",
+    ].join("\n");
+};