@osmo.inc/cli 0.1.15

package/node_modules/typescript/package.json

@@ -0,0 +1,57 @@
+{
+  "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/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@osmo.inc/cli",
+  "version": "0.1.15",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "description": "Local Osmo Studio: native rendering, browser preview, and timeline feedback",
+  "type": "module",
+  "bin": {
+    "osmo": "bin/osmo.mjs"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "src/starter",
+    "src/resource-examples",
+    "runtime",
+    "studio",
+    "vendor",
+    "README.md",
+    "DEPLOY.md",
+    "SETUP.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "third-party",
+    "release.json",
+    "RELEASE.md"
+  ],
+  "engines": {
+    "node": ">=22 <23"
+  },
+  "dependencies": {
+    "esbuild": "0.27.4",
+    "fflate": "0.8.3",
+    "typescript": "5.9.3"
+  },
+  "osmo": {
+    "sceneVersion": "0.1.0"
+  },
+  "bundleDependencies": [
+    "esbuild",
+    "fflate",
+    "typescript"
+  ],
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ]
+}

package/release.json

@@ -0,0 +1,136 @@
+{
+  "version": "0.1.15",
+  "platform": "darwin-arm64",
+  "channel": "latest",
+  "defaultCloudOrigin": "https://studio.osmo.inc",
+  "sourceCommit": "0bb14b4541e8e9955714ce24cdbac68869935b02",
+  "sourceDirty": false,
+  "signing": "ad-hoc",
+  "licenseFileIncluded": false,
+  "dependencyCount": 243,
+  "nativeDefaultFeatures": false,
+  "features": {
+    "studio": {
+      "defaultEnabled": false,
+      "env": "OSMO_STUDIO_ENABLED"
+    }
+  },
+  "contents": {
+    "totalBytes": 59066771,
+    "fileCount": 948,
+    "groups": {
+      "vendor": 16948891,
+      "studio": 15935597,
+      "node_modules/@esbuild/darwin-arm64": 10385745,
+      "node_modules/typescript": 9913238,
+      "third-party": 4800129,
+      "src": 375601,
+      "dist": 293069,
+      "node_modules/esbuild": 143795,
+      "runtime": 137478,
+      "node_modules/fflate": 96377,
+      "README.md": 17083,
+      "RELEASE.md": 9545,
+      "DEPLOY.md": 4829,
+      "SETUP.md": 2811,
+      "THIRD_PARTY_NOTICES.md": 1088,
+      "package.json": 951,
+      "bin": 544
+    },
+    "largestFiles": [
+      {
+        "path": "vendor/osmo-lite",
+        "bytes": 16913136
+      },
+      {
+        "path": "studio/src/engine_bg.wasm",
+        "bytes": 10940516
+      },
+      {
+        "path": "node_modules/@esbuild/darwin-arm64/bin/esbuild",
+        "bytes": 10385218
+      },
+      {
+        "path": "node_modules/typescript/lib/typescript.js",
+        "bytes": 6722950
+      },
+      {
+        "path": "studio/src/app.js",
+        "bytes": 4673460
+      },
+      {
+        "path": "node_modules/typescript/lib/lib.dom.d.ts",
+        "bytes": 1874901
+      },
+      {
+        "path": "node_modules/typescript/lib/lib.webworker.d.ts",
+        "bytes": 609557
+      },
+      {
+        "path": "src/resource-examples/example-video/ambient.mp4",
+        "bytes": 370430
+      },
+      {
+        "path": "dist/osmo.js",
+        "bytes": 293069
+      },
+      {
+        "path": "third-party/rust-standard-library/COPYRIGHT-library.html",
+        "bytes": 279302
+      },
+      {
+        "path": "node_modules/typescript/lib/lib.es5.d.ts",
+        "bytes": 218439
+      },
+      {
+        "path": "third-party/npm/mediabunny@1.52.2/source/src/isobmff/isobmff-demuxer.ts",
+        "bytes": 118682
+      },
+      {
+        "path": "third-party/npm/mediabunny@1.52.2/source/src/sample.ts",
+        "bytes": 107841
+      },
+      {
+        "path": "third-party/npm/mediabunny@1.52.2/source/src/media-source.ts",
+        "bytes": 97606
+      },
+      {
+        "path": "third-party/inventory.json",
+        "bytes": 97355
+      },
+      {
+        "path": "node_modules/esbuild/lib/main.js",
+        "bytes": 97186
+      },
+      {
+        "path": "third-party/npm/mediabunny@1.52.2/source/src/codec-data.ts",
+        "bytes": 92683
+      },
+      {
+        "path": "node_modules/fflate/esm/index.mjs",
+        "bytes": 91765
+      },
+      {
+        "path": "third-party/npm/mediabunny@1.52.2/source/src/media-sink.ts",
+        "bytes": 85991
+      },
+      {
+        "path": "studio/src/inter-latin-ext-wght-normal-HA22NDSG.woff2",
+        "bytes": 85068
+      }
+    ]
+  },
+  "hashes": {
+    "dist/osmo.js": "c6e7596e1469131d949c0fea10b18639de29f22c3ae0a5f18248396ad05963db",
+    "vendor/osmo-lite": "33c4b23661d96b1e4b124059233fda15b84a2c928c17eb4502bdd42026f4c589",
+    "studio/src/engine_bg.wasm": "7e1414a348e0e4de6646248f1cba4f08e73f30f5f42c3db3ed8beac2f1513bc4",
+    "studio/src/app.js": "4b1d952844a3ed878c0cdd20ce5d26bab711564e4086abc422ef939f299c70ff",
+    "studio/src/app.css": "42bd8cf182d2e5c9183fe04cddece8a150992180ed7e9bc9e981e376224d96ef",
+    "third-party/inventory.json": "6ff4e90c6583a67ca8bfe95b3f4399cfcdc080d39585dce1314a8dd91ee6fecb"
+  },
+  "lockfiles": {
+    "package-lock.json": "86a27a636faac94ee6a7d93fbfddd5b6f9fff296738eb9f702095e5a73b70f07",
+    "apps/native/Cargo.lock": "cf31d67cf167c5f32438abfeb42159eb50da61d36e4e482bae50ed3d71241373",
+    "packages/render-engine/Cargo.lock": "a1a68051e1eea30ef0fa46bf17cd0685bb2c6a327defed0405e0d63dd61017a7"
+  }
+}

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

@@ -0,0 +1,217 @@
+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)`,
+);