@osmo.inc/cli 0.1.18 → 0.1.19

package/node_modules/typescript/package.json

@@ -1,57 +0,0 @@
-{
-  "name": "typescript",
-  "author": "Microsoft Corp.",
-  "homepage": "https://www.typescriptlang.org/",
-  "version": "5.9.3",
-  "license": "Apache-2.0",
-  "description": "TypeScript is a language for application scale JavaScript development",
-  "keywords": [
-    "TypeScript",
-    "Microsoft",
-    "compiler",
-    "language",
-    "javascript"
-  ],
-  "bugs": {
-    "url": "https://github.com/microsoft/TypeScript/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/microsoft/TypeScript.git"
-  },
-  "main": "./lib/typescript.js",
-  "typings": "./lib/typescript.d.ts",
-  "engines": {
-    "node": ">=14.17"
-  },
-  "files": [
-    "bin",
-    "lib",
-    "!lib/enu",
-    "LICENSE.txt",
-    "README.md",
-    "SECURITY.md",
-    "ThirdPartyNoticeText.txt",
-    "!**/.gitattributes"
-  ],
-  "overrides": {
-    "typescript@*": "$typescript"
-  },
-  "browser": {
-    "fs": false,
-    "os": false,
-    "path": false,
-    "crypto": false,
-    "buffer": false,
-    "source-map-support": false,
-    "inspector": false,
-    "perf_hooks": false
-  },
-  "packageManager": "npm@8.19.4",
-  "volta": {
-    "node": "20.1.0",
-    "npm": "8.19.4"
-  },
-  "gitHead": "c63de15a992d37f0d6cec03ac7631872838602cb",
-  "osmoDistributionNote": "Osmo compiler-only distribution: command tools, declarations for the TypeScript API, translated diagnostics and development metadata are removed; compiler JS has whitespace-only minification."
-}

package/runtime/apps/native/tools/compile.mjs

@@ -1,217 +0,0 @@
-import { build } from "esbuild";
-import ts from "typescript";
-import { open, readFile, stat } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-// TSX runs only in this compiler process. The native app consumes a frozen
-// frame snapshot; playback and export require neither a browser nor a JS clock.
-const source = path.resolve(
-	process.argv[2] ?? "packages/scene/examples/focus.tsx",
-);
-const output = process.argv[3];
-if (!output) throw new Error("Usage: node compile.mjs source.tsx output.jsonl");
-// Studio can validate edited source without writing a temporary TSX or changing provenance.
-const sourceInput = process.argv.includes("--source-stdin") || process.argv.includes("--sources-stdin")
-    ? await new Promise((resolve, reject) => {
-        let text = ""; process.stdin.setEncoding("utf8");
-        process.stdin.on("data", chunk => text += chunk);
-        process.stdin.on("end", () => resolve(text)); process.stdin.on("error", reject);
-    }) : undefined;
-const sources = process.argv.includes('--sources-stdin') ? JSON.parse(sourceInput) :
-    sourceInput === undefined ? {} : {[source]: sourceInput};
-const repo = fileURLToPath(new URL("../../../", import.meta.url));
-const api = path.join(repo, "packages/scene/src/index.ts");
-const runtime = path.join(repo, "packages/scene/src/jsx-runtime.ts");
-const result = await build({
-	stdin: {
-		contents: `import scene from ${JSON.stringify(source)}; export {scene}; export {EFFECT_INPUT} from ${JSON.stringify(path.join(repo, "packages/scene/src/effects.ts"))}; export {Scene, Group, evaluateFrame} from ${JSON.stringify(api)}; export {prepareShader} from ${JSON.stringify(path.join(repo, "packages/scene/src/shader.ts"))};`,
-		resolveDir: path.dirname(source),
-	},
-	plugins: [{ name: "effect-source", setup(build) {
-		build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async ({ path: file }) => {
-			const overridden = Object.hasOwn(sources, file);
-			const text = overridden ? sources[file] : await readFile(file, "utf8");
-            const loader = /tsx$/.test(file) ? "tsx" : /jsx$/.test(file) ? "jsx" : /[cm]?ts$/.test(file) ? "ts" : "js";
-            if (!text.includes("defineEffect")) return overridden ? {contents:text,loader} : undefined;
-			const ast = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
-			const names = new Set(), namespaces = new Set();
-			for (const statement of ast.statements) {
-				if (!ts.isImportDeclaration(statement) || statement.moduleSpecifier.text !== "@osmo/scene") continue;
-				const imports = statement.importClause?.namedBindings;
-				if (imports && ts.isNamedImports(imports)) for (const item of imports.elements) {
-					if ((item.propertyName ?? item.name).text === "defineEffect") names.add(item.name.text);
-				}
-				if (imports && ts.isNamespaceImport(imports)) namespaces.add(imports.name.text);
-			}
-			const transformed = ts.transform(ast, [context => root => {
-				const visit = node => {
-					if (ts.isCallExpression(node) && node.arguments.length === 1 &&
-						(ts.isIdentifier(node.expression) && names.has(node.expression.text) ||
-						ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && namespaces.has(node.expression.expression.text) && node.expression.name.text === "defineEffect")) {
-						return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [ts.visitNode(node.arguments[0], visit), ts.factory.createStringLiteral(file)]);
-					}
-					return ts.visitEachChild(node, visit, context);
-				};
-				return ts.visitNode(root, visit);
-			}]);
-			const contents = ts.createPrinter().printFile(transformed.transformed[0]);
-			transformed.dispose();
-			return { contents, loader: /tsx$/.test(file) ? "tsx" : /jsx$/.test(file) ? "jsx" : /[cm]?ts$/.test(file) ? "ts" : "js" };
-		});
-	} }],
-	absWorkingDir: repo,
-	bundle: true,
-	write: false,
-	platform: "node",
-	format: "esm",
-	metafile: true,
-	jsx: "automatic",
-	jsxDev: true,
-	jsxImportSource: "@osmo/scene",
-	alias: {
-		"@osmo/scene/jsx-dev-runtime": runtime,
-		"@osmo/scene/jsx-runtime": runtime,
-		"@osmo/scene": api,
-	},
-});
-const { scene: document, Scene, Group, evaluateFrame, prepareShader, EFFECT_INPUT } = await import(
-	`data:text/javascript;base64,${Buffer.from(result.outputFiles[0].text).toString("base64")}`
-);
-// A standalone Group is previewed inside a host. Its dimensions remain optional
-// in source; board instances and CLI flags supply independent host sizes.
-const isGroup = document.type === Group || document.type === 'group';
-const preview = JSON.parse(process.env.OSMO_GROUP_PREVIEW ?? '{}');
-const scene = isGroup ? Scene({
-    width: preview.width ?? 960, height: preview.height ?? 600,
-    duration: preview.duration ?? document.props.duration ?? 4, fps: preview.fps ?? 30,
-    background: '#000000', children: { ...document, props: {
-        ...document.props, start: 0,
-        width: document.props.width ?? 'fill', height: document.props.height ?? 'fill',
-        ...(preview.values && (document.props.knobs || Object.keys(preview.values).length) ? { values: { ...document.props.values, ...preview.values } } : {}),
-    } },
-}) : document;
-const first = evaluateFrame(scene, 0);
-if (first.width > 8192 || first.height > 8192 || first.totalFrames > 18000) {
-	throw new Error(
-		"Prototype limits: 8192 pixels per side and 18,000 frames per composition",
-	);
-}
-if (!Number.isInteger(first.width) || !Number.isInteger(first.height))
-	throw new Error("Native composition dimensions must be whole pixels");
-const fonts = new Map();
-const dependencies = new Set([
-	source,
-	...Object.keys(result.metafile.inputs)
-		.filter((p) => p !== "<stdin>")
-		.map((p) => path.resolve(repo, p)),
-]);
-const shaders = new Map();
-async function collectEffects(target) {
-	for (const effect of target.effects ?? []) {
-		let key = "effect:" + effect.code;
-		if (effect.src) {
-			effect.src = path.resolve(path.dirname(path.resolve(repo, effect.sourceFile ?? source)), effect.src);
-			dependencies.add(effect.src);
-			key = "effect:" + effect.src;
-		}
-		if (!shaders.has(key)) {
-			if (effect.src && (await stat(effect.src)).size > 1024 * 1024) throw new Error("Effect shader exceeds 1 MB");
-			const code = effect.src ? await readFile(effect.src, "utf8") : effect.code;
-			shaders.set(key, prepareShader("//!effect\n" + EFFECT_INPUT + code));
-		}
-		const shader = shaders.get(key);
-		effect.code = shader.code;
-		effect.uniformData = shader.pack(effect.uniforms);
-	}
-}
-async function collectFonts(nodes) {
-	for (const node of nodes) {
-		await collectEffects(node);
-        if(node.type === "composition") { await collectEffects(node.scene); await collectFonts(node.scene.children); }
-		if (["group","model","surface"].includes(node.type)) await collectFonts(node.children);
-		if (["image", "video", "audio", "model"].includes(node.type)) {
-			node.src = path.resolve(
-				path.dirname(path.resolve(repo, node.sourceFile ?? source)),
-				node.src,
-			);
-			dependencies.add(node.src);
-		}
-		if (node.type === "shader") {
-			node.src = path.resolve(path.dirname(path.resolve(repo, node.sourceFile ?? source)), node.src);
-			dependencies.add(node.src);
-			try {
-				if (!shaders.has(node.src)) {
-					if ((await stat(node.src)).size > 1024 * 1024) throw new Error("Shader source exceeds 1 MB");
-					shaders.set(node.src, prepareShader(await readFile(node.src, "utf8")));
-				}
-				const shader = shaders.get(node.src);
-				node.code = shader.code;
-				node.uniformData = shader.pack(node.uniforms);
-			} catch (error) { throw new Error(`${node.src}: ${error.message}`); }
-		}
-		if (node.type === "text" && node.font !== "Inter") {
-			const font = path.resolve(
-				path.dirname(path.resolve(repo, node.fontSource ?? source)),
-				node.font,
-			);
-			if (!/\.(ttf|otf)$/i.test(font))
-				throw new Error(
-					`Custom fonts must be .ttf or .otf files: ${node.font}`,
-				);
-			node.font = font;
-			fonts.set(font, true);
-			dependencies.add(font);
-		}
-	}
-}
-// Every frame is held in memory by the renderer, so the snapshot is capped.
-// Long or dense scenes can raise it: OSMO_SNAPSHOT_LIMIT_MB=4096.
-const limitMb = Number(process.env.OSMO_SNAPSHOT_LIMIT_MB) > 0 ? Number(process.env.OSMO_SNAPSHOT_LIMIT_MB) : 1024;
-// Source locations resolve asset paths above; the renderer never reads them,
-// and repeated on every node of every frame they were a large share of the file.
-const compact = (key, value) => (key === "sourceFile" || key === "fontSource" ? undefined : value);
-let size = 0;
-const file = await open(output, "wx");
-async function line(value) {
-	const text = JSON.stringify(value, compact) + "\n";
-	size += Buffer.byteLength(text);
-	if (size > limitMb * 1024 * 1024)
-		throw new Error(
-			`Compiled scene exceeds the ${limitMb} MB snapshot limit. Shorten the scene or lower fps, or raise the limit with OSMO_SNAPSHOT_LIMIT_MB.`,
-		);
-	await file.write(text);
-}
-try {
-	await line({
-		version: 1,
-		source,
-		width: first.width,
-		height: first.height,
-		fps: first.fps,
-		totalFrames: first.totalFrames,
-		duration: first.duration,
-	});
-	for (let frame = 0; frame < first.totalFrames; frame++) {
-		const evaluated = frame === 0 ? first : evaluateFrame(scene, frame);
-		await collectEffects(evaluated);
-		await collectFonts(evaluated.children);
-		await line(evaluated);
-	}
-	const assets = [];
-	for (const font of fonts.keys()) {
-		const info = await stat(font);
-		if (info.size > 32 * 1024 * 1024)
-			throw new Error(`Font is too large: ${font}`);
-		assets.push({
-			path: font,
-			bytes: (await readFile(font)).toString("base64"),
-		});
-	}
-	await line({ assets, dependencies: [...dependencies] });
-} finally {
-	await file.close();
-}
-console.log(
-	`Compiled ${first.totalFrames} frames (${(size / 1024).toFixed(0)} KB)`,
-);

package/runtime/packages/scene/scripts/validate-strict.mjs

@@ -1,246 +0,0 @@
-// Static authoring contract, not a security sandbox. Runtime/type validation is separate.
-import fs from 'node:fs';
-import path from 'node:path';
-import ts from 'typescript';
-import {isClipPrimitive} from '../src/clip.mjs';
-import {readGroupLabel, readGroupPlayback, readSceneTracks} from '../src/metadata.mjs';
-export function resolveGroupImport(file, specifier) {
-    if (!specifier.startsWith('./') && !specifier.startsWith('../')) throw new Error('Group imports must use relative local TSX paths');
-    const candidate = path.resolve(path.dirname(file), specifier.endsWith('.tsx') ? specifier : specifier.endsWith('.js') ? specifier.slice(0, -3) + '.tsx' : specifier + '.tsx');
-    if (!candidate.endsWith('.tsx')) throw new Error('Group imports must reference .tsx files');
-    return fs.realpathSync(candidate);
-}
-function projectDirectory(file) {
-    let dir = path.dirname(file);
-    while (true) {
-        if (fs.existsSync(path.join(dir, '.osmo/project.json'))) return dir;
-        const parent = path.dirname(dir);
-        if (parent === dir) return path.dirname(file);
-        dir = parent;
-    }
-}
-export function validate(file, mode, options = {}) {
-    file = fs.realpathSync(file);
-    const root = options.root ?? projectDirectory(file);
-    const stack = options.stack ?? [];
-    if (stack.includes(file)) return { ok:false, errors:[`Cyclic Group import: ${[...stack,file].map(p=>path.basename(p)).join(' → ')}`], bytes:0 };
-    if (stack.length > 32) return {ok:false,errors:['Group import nesting exceeds 32 files'],bytes:0};
-    const text = options.text ?? options.sources?.[file] ?? fs.readFileSync(file, 'utf8');
-    const ast = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-    const errors = [];
-    const fail = (n, msg) => { const p = ast.getLineAndCharacterOfPosition(n.getStart(ast)); errors.push(`${p.line + 1}:${p.character + 1} ${msg}`); };
-    for (const d of ast.parseDiagnostics)
-        errors.push(ts.flattenDiagnosticMessageText(d.messageText, '\n'));
-    const allowed = new Set(['Scene', 'Camera', 'Group', 'Rect', 'Path', 'Text', 'Image', 'Video', 'Audio', 'Model', 'Surface', 'Fragment', 'defineMotion', 'defineKnobs', 'Shader', 'sampleMotion', 'describeMotion', 'blur', 'grain']);
-    allowed.add('defineEffect');
-    const importedGroups = new Set(), sourceIds = new Set(), effects = new Set();
-    const tracks = new Map();
-    const knobSets = new Set();
-    const literal = n => ts.isStringLiteral(n) || ts.isNumericLiteral(n) || [ts.SyntaxKind.TrueKeyword, ts.SyntaxKind.FalseKeyword, ts.SyntaxKind.NullKeyword].includes(n.kind) || ts.isPrefixUnaryExpression(n) && [ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(n.operator) && ts.isNumericLiteral(n.operand);
-    function metadataLiteral(n) {
-        if (n && (ts.isJsxExpression(n) || ts.isParenthesizedExpression(n))) return metadataLiteral(n.expression);
-        if (n && ts.isStringLiteral(n)) return n.text;
-        if (n?.kind === ts.SyntaxKind.TrueKeyword) return true;
-        if (n?.kind === ts.SyntaxKind.FalseKeyword) return false;
-        if (n && ts.isObjectLiteralExpression(n)) return Object.fromEntries(n.properties.map(p => {
-            if (!ts.isPropertyAssignment(p) || ts.isComputedPropertyName(p.name)) throw new Error('Labels require explicit literal properties');
-            return [p.name.text, metadataLiteral(p.initializer)];
-        }));
-        throw new Error('Editor metadata must use static string/boolean literals and literal objects');
-    }
-    function value(n, refs = true) {
-        if (literal(n))
-            return;
-        if (ts.isArrayLiteralExpression(n)) {
-            n.elements.forEach(e => value(e, refs));
-            return;
-        }
-        if (ts.isObjectLiteralExpression(n)) {
-            for (const p of n.properties) {
-                if (!ts.isPropertyAssignment(p) || ts.isComputedPropertyName(p.name))
-                    fail(p, 'Only explicit literal object properties are allowed');
-                else
-                    value(p.initializer, refs);
-            }
-            return;
-        }
-        if (refs && ts.isIdentifier(n) && knobSets.has(n.text)) return;
-        if (refs && ts.isPropertyAccessExpression(n) && ts.isIdentifier(n.expression) && tracks.get(n.expression.text)?.has(n.name.text))
-            return;
-        if (refs && ts.isCallExpression(n) && ts.isIdentifier(n.expression) && (['blur', 'grain'].includes(n.expression.text)||effects.has(n.expression.text)) && n.arguments.length <= 1) {
-            if(n.arguments[0])value(n.arguments[0]);
-            return;
-        }
-        fail(n, 'Strict accepts literals, literal collections, declared motion/knob references, declared effects, blur and grain only');
-    }
-    for (const st of ast.statements) {
-        if (ts.isImportDeclaration(st)) {
-            if (st.moduleSpecifier.text !== '@osmo/scene') {
-                const clause = st.importClause;
-                if (!clause?.name || clause.namedBindings || clause.isTypeOnly) {
-                    fail(st, 'Reusable Groups use a default import from a local TSX file');
-                    continue;
-                }
-                importedGroups.add(clause.name.text);
-                try {
-                    const imported = resolveGroupImport(file, st.moduleSpecifier.text);
-                    const relative = path.relative(root, imported);
-                    if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) throw new Error('Group imports must stay inside the project');
-                    const result = validate(imported, mode, {root, stack:[...stack,file], group:true, sources:options.sources});
-                    for (const error of result.errors) fail(st, `${path.relative(root, imported)}: ${error}`);
-                } catch (error) { fail(st, error.message); }
-                continue;
-            }
-            const b = st.importClause?.namedBindings;
-            if (!b || !ts.isNamedImports(b))
-                fail(st, 'Use named imports');
-            else
-                for (const e of b.elements) {
-                    if (e.propertyName)
-                        fail(e, 'Import aliases are not allowed');
-                    if (!st.importClause.isTypeOnly && !e.isTypeOnly && !allowed.has(e.name.text))
-                        fail(e, `Unsupported import ${e.name.text}`);
-                }
-        }
-        if (mode === 'strict' && ts.isVariableStatement(st)) {
-            if (!(st.declarationList.flags & ts.NodeFlags.Const))
-                fail(st, 'Only const motion/knob/effect declarations are allowed');
-            for (const d of st.declarationList.declarations) {
-                const call = d.initializer;
-                if (!ts.isIdentifier(d.name) || !call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression) || !['defineMotion','defineKnobs','defineEffect'].includes(call.expression.text) || (call.expression.text !== 'defineKnobs' ? call.arguments.length !== 1 : call.arguments.length < 1 || call.arguments.length > 2) || !ts.isObjectLiteralExpression(call.arguments[0])) {
-                    fail(d, 'Variables may only name defineMotion, defineKnobs or defineEffect declarations');
-                    continue;
-                }
-                value(call.arguments[0], false);
-                if(call.expression.text==='defineEffect') {
-                    effects.add(d.name.text);
-                    const src=call.arguments[0].properties.find(p=>p.name?.text==='src')?.initializer;
-                    if(src&&(!ts.isStringLiteral(src)||!src.text.endsWith('.wgsl')||path.isAbsolute(src.text)||/^[a-z]+:/i.test(src.text)))fail(src,'Effect.src must be a static relative local .wgsl path');
-                }
-                if (call.arguments[1]) value(call.arguments[1], false);
-                if (call.expression.text === 'defineKnobs') knobSets.add(d.name.text);
-                if(call.expression.text!=='defineEffect') tracks.set(d.name.text, new Set(call.arguments[0].properties.filter(ts.isPropertyAssignment).map(p => p.name.text)));
-            }
-        }
-        else if (mode === 'strict' && !ts.isImportDeclaration(st) && !ts.isExportAssignment(st) && !ts.isEmptyStatement(st))
-            fail(st, 'Strict permits imports, const defineMotion/defineKnobs/defineEffect declarations, and export default JSX only');
-    }
-    function jsx(n, parent = null) {
-        if (ts.isParenthesizedExpression(n)) {
-            jsx(n.expression, parent);
-            return;
-        }
-        if (ts.isJsxFragment(n)) {
-            n.children.forEach(c => child(c, parent));
-            return;
-        }
-        if (!ts.isJsxElement(n) && !ts.isJsxSelfClosingElement(n)) {
-            fail(n, 'Scene structure must be explicit JSX');
-            return;
-        }
-        const el = ts.isJsxElement(n) ? n.openingElement : n;
-        const tag = el.tagName.getText(ast);
-        const clip = isClipPrimitive(tag) || importedGroups.has(tag);
-        const track = el.attributes.properties.find(a => ts.isJsxAttribute(a) && a.name.text === 'track');
-        if (options.requireTracks && parent === 'Scene' && clip && !track)
-            fail(el, `${tag}: root clips require track. Open Studio in interactive mode to assign tracks to an existing scene.`);
-        if (track) {
-            if (!clip || parent !== 'Scene') fail(track, 'track belongs to root clips only; nested elements use their parent clip');
-            const v = track.initializer && (ts.isJsxExpression(track.initializer) ? track.initializer.expression : track.initializer);
-            const lane = v && ts.isNumericLiteral(v) ? Number(v.text) : NaN;
-            if (!Number.isInteger(lane) || lane < 0 || lane > 99) fail(track, 'track must be a literal integer from 0 to 99');
-        }
-        if ((!allowed.has(tag) && !importedGroups.has(tag)) || ['defineMotion', 'defineKnobs', 'defineEffect', 'sampleMotion', 'describeMotion', 'blur', 'grain'].includes(tag))
-            fail(el, 'Use public visual primitives only');
-        if (importedGroups.has(tag) && ts.isJsxElement(n) && n.children.some(c => !ts.isJsxText(c) || c.text.trim()))
-            fail(n, 'Animation instances cannot replace children; edit the original Group file');
-        for (const a of el.attributes.properties) {
-            if (!ts.isJsxAttribute(a)) {
-                fail(a, 'Spreads are forbidden in Strict');
-                continue;
-            }
-            if (importedGroups.has(tag) && ['knobs', 'children'].includes(a.name.text))
-                fail(a, 'Animation instances customize values, not knob definitions or children');
-            if (a.name.text === 'label' || a.name.text === 'tracks') {
-                try {
-                    if (a.name.text === 'label') {
-                        if (tag !== 'Group' && !importedGroups.has(tag)) throw new Error('label belongs to Groups only');
-                        readGroupLabel(metadataLiteral(a.initializer));
-                    } else {
-                        if (tag !== 'Scene') throw new Error('tracks metadata belongs to Scene only');
-                        readSceneTracks(metadataLiteral(a.initializer));
-                    }
-                } catch (error) { fail(a, error.message); }
-            }
-            if (['hidden', 'solo'].includes(a.name.text)) {
-                try {
-                    if (tag !== 'Group' && !importedGroups.has(tag)) throw new Error('hidden and solo belong to Groups only');
-                    readGroupPlayback({[a.name.text]: a.initializer ? metadataLiteral(a.initializer) : true});
-                } catch (error) { fail(a, error.message); }
-            }
-            if (['id','start','duration','track'].includes(a.name.text) && a.initializer) {
-                const v = ts.isJsxExpression(a.initializer) ? a.initializer.expression : a.initializer;
-                if (v) value(v, false);
-            }
-            if (a.name.text === 'id') {
-                const id = a.initializer && (ts.isJsxExpression(a.initializer) ? a.initializer.expression : a.initializer);
-                if (!id || !ts.isStringLiteral(id) || !id.text.trim()) fail(a, 'id must be a nonempty literal string');
-                else if (sourceIds.has(id.text)) fail(a, 'IDs must be unique within their source file');
-                else sourceIds.add(id.text);
-            }
-            if (tag === 'Shader' && a.name.text === 'src') {
-                const src = a.initializer && (ts.isJsxExpression(a.initializer) ? a.initializer.expression : a.initializer);
-                if (!src || !ts.isStringLiteral(src) || !src.text.trim() || /^[a-z]+:/i.test(src.text) || path.isAbsolute(src.text) || !/\.wgsl$/i.test(src.text))
-                    fail(a, 'Shader.src must be a static relative local .wgsl path');
-            }
-            if (tag === 'Path' && a.name.text === 'd' && a.initializer) {
-                const d = ts.isJsxExpression(a.initializer) ? a.initializer.expression : a.initializer;
-                if (!d || !ts.isStringLiteral(d)) fail(a, 'Path.d must be a static SVG string literal');
-            }
-            if (a.initializer) {
-                if (ts.isJsxExpression(a.initializer)) {
-                    if (a.initializer.expression)
-                        value(a.initializer.expression);
-                }
-                else
-                    value(a.initializer);
-            }
-        }
-        if (ts.isJsxElement(n))
-            n.children.forEach(c => child(c, tag === "Fragment" ? parent : tag));
-    }
-    function child(n, parent) { if (ts.isJsxText(n))
-        return; if (ts.isJsxExpression(n)) {
-        if (n.expression)
-            value(n.expression);
-        return;
-    } jsx(n, parent); }
-    if (mode === 'strict') {
-        const exports = ast.statements.filter(ts.isExportAssignment);
-        if (exports.length !== 1) errors.push('Export exactly one default Scene or Group');
-        for (const st of exports) {
-            let n = st.expression;
-            while (ts.isParenthesizedExpression(n)) n = n.expression;
-            const tag = ts.isJsxElement(n) ? n.openingElement.tagName.getText(ast) : ts.isJsxSelfClosingElement(n) ? n.tagName.getText(ast) : '';
-            if (!options.group && !['Scene','Group'].includes(tag)) fail(st, 'The entry must export a Scene or Group');
-            if (options.group && !['Scene','Group'].includes(tag)) fail(st, 'Reusable files must export a Scene (or legacy Group)');
-            jsx(st.expression);
-        }
-    }
-    function audit(n) {
-        if (ts.isImportEqualsDeclaration(n))
-            fail(n, 'Import-equals is forbidden');
-        if (ts.isCallExpression(n) && n.expression.kind === ts.SyntaxKind.ImportKeyword)
-            fail(n, 'Dynamic imports are forbidden');
-        if (ts.isIdentifier(n) && ['require', 'eval', 'Function', 'process', 'globalThis', 'fetch', 'WebSocket', 'Date'].includes(n.text))
-            fail(n, 'Submitted animation must be deterministic and self-contained');
-        ts.forEachChild(n, audit);
-    }
-    audit(ast);
-    return { ok: errors.length === 0, errors: errors.slice(0, 40), bytes: Buffer.byteLength(text) };
-}
-if (process.argv[1] === new URL(import.meta.url).pathname) {
-    const result = validate(path.resolve(process.argv[2]), process.argv[3] ?? "strict");
-    console.log(JSON.stringify(result));
-    process.exitCode = result.ok ? 0 : 1;
-}

package/runtime/packages/scene/src/clip.d.mts

@@ -1,14 +0,0 @@
-/** @param {{start?: unknown, duration?: unknown, track?: unknown}} props
- * @param {number} parentDuration @param {number} fps @param {string} label */
-export function clipTiming(props: {
-    start?: unknown;
-    duration?: unknown;
-    track?: unknown;
-}, parentDuration: number, fps: number, label: string): {
-    start: number;
-    duration: number;
-    track: number | undefined;
-};
-export const clipPrimitives: readonly string[];
-export const clipFields: readonly string[];
-export function isClipPrimitive(name: string): boolean;

package/runtime/packages/scene/src/clip.mjs

@@ -1,15 +0,0 @@
-// Shared by evaluation, Strict validation, outline inspection and source editing.
-export const clipPrimitives = Object.freeze(['Group', 'Rect', 'Path', 'Text', 'Image', 'Video', 'Audio', 'Shader', 'Model', 'Composition']);
-export const clipFields = Object.freeze(['id', 'track', 'start', 'duration']);
-export const isClipPrimitive = (/** @type {string} */ name) => clipPrimitives.some(tag => tag.toLowerCase() === name.toLowerCase());
-
-/** @param {{start?: unknown, duration?: unknown, track?: unknown}} props
- * @param {number} parentDuration @param {number} fps @param {string} label */
-export function clipTiming(props, parentDuration, fps, label) {
-  const start = props.start ?? 0, duration = props.duration ?? Math.max(parentDuration - Number(start), 1 / fps);
-  if (typeof start !== 'number' || !Number.isFinite(start) || start < 0) throw new Error(`${label}.start: expected a finite nonnegative number`);
-  if (typeof duration !== 'number' || !Number.isFinite(duration) || duration <= 0) throw new Error(`${label}.duration: expected a positive finite number`);
-  const track = props.track;
-  if (track !== undefined && (typeof track !== 'number' || !Number.isInteger(track) || track < 0 || track > 99)) throw new Error(`${label}.track: expected an integer from 0 to 99`);
-  return {start, duration, track};
-}

package/runtime/packages/scene/src/color-value.d.mts

@@ -1,5 +0,0 @@
-/** sRGBA authoring colors. Interpolation is in linear light, premultiplied by alpha. */
-/** @param {unknown} value @returns {readonly [number, number, number, number] | undefined} */
-export function parseColor(value: unknown): readonly [number, number, number, number] | undefined;
-/** @param {string} a @param {string} b @param {number} t */
-export function mixColor(a: string, b: string, t: number): string;

package/runtime/packages/scene/src/color-value.mjs

@@ -1,19 +0,0 @@
-/** sRGBA authoring colors. Interpolation is in linear light, premultiplied by alpha. */
-/** @param {unknown} value @returns {readonly [number, number, number, number] | undefined} */
-export function parseColor(value) {
-	if (value === "transparent") return [0, 0, 0, 0];
-	if (typeof value !== "string" || !/^#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i.test(value)) return;
-	let hex = value.slice(1);
-	if (hex.length <= 4) hex = [...hex].map(c => c + c).join("");
-	if (hex.length === 6) hex += "ff";
-	return /** @type {[number, number, number, number]} */ ([0, 2, 4, 6].map(i => parseInt(hex.slice(i, i + 2), 16) / 255));
-}
-/** @param {string} a @param {string} b @param {number} t */
-export function mixColor(a, b, t) {
-	const x = parseColor(a), y = parseColor(b);
-	const linear = (v) => v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
-	const srgb = (v) => v <= 0.0031308 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - 0.055;
-	const alpha = x[3] + (y[3] - x[3]) * t;
-	const values = [0, 1, 2].map(i => srgb(alpha > 0 ? (linear(x[i]) * x[3] * (1 - t) + linear(y[i]) * y[3] * t) / alpha : 0));
-	return "#" + [...values, alpha].map(v => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("");
-}

package/runtime/packages/scene/src/color.ts

@@ -1 +0,0 @@
-export { parseColor, mixColor } from "./color-value.mjs";