@master/css-binding-wasm-engine 0.0.0-stage → 3.0.0

package/dist/index.js

@@ -0,0 +1,193 @@
+import { MasterCSSError } from "@master/css-schema";
+// src/index.ts
+const initializedInputs = /* @__PURE__ */ new WeakMap();
+function sameInput(left, right) {
+	return left === right || String(left) === String(right);
+}
+async function initializeModule(module, input) {
+	const initializedInput = initializedInputs.get(module);
+	if (initializedInput !== void 0) {
+		if (!sameInput(initializedInput, input)) throw new MasterCSSError({
+			code: "WASM_INPUT_CONFLICT",
+			domain: "binding",
+			message: "A Master CSS Wasm module cannot be initialized with two different inputs."
+		});
+		return module;
+	}
+	await module.default({ module_or_path: input });
+	initializedInputs.set(module, input);
+	return module;
+}
+/**
+* Binds the loading and session APIs to one artifact. Entry points own the artifact
+* paths, so a bundler only sees the Wasm its entry can load.
+*/
+function createWasmEngineLoader(artifact) {
+	let defaultModulePromise;
+	const importGeneratedModule = async () => await artifact.load();
+	async function loadWasmEngine(options = {}) {
+		try {
+			if (options.module) return await initializeModule(options.module, options.input ?? artifact.url);
+			if (options.input !== void 0) return await initializeModule(await importGeneratedModule(), options.input);
+			defaultModulePromise ??= importGeneratedModule().then((module) => initializeModule(module, artifact.url)).catch((cause) => {
+				defaultModulePromise = void 0;
+				throw cause;
+			});
+			return await defaultModulePromise;
+		} catch (cause) {
+			if (cause instanceof MasterCSSError) throw cause;
+			throw new MasterCSSError({
+				code: "WASM_LOAD_FAILED",
+				domain: "binding",
+				message: cause instanceof Error ? cause.message : "Cannot load the Master CSS engine Wasm artifact."
+			}, { cause });
+		}
+	}
+	return Object.freeze({
+		url: artifact.url,
+		loadWasmEngine,
+		async createWasmEngineSession(source, sessionOptions = {}, loadOptions = {}) {
+			return engineSession(await loadWasmEngine(loadOptions), source, sessionOptions);
+		},
+		async compileRuntimeProgram(manifestJSON, loadOptions = {}) {
+			return (await loadWasmEngine(loadOptions)).compileRuntimeProgram(manifestJSON);
+		},
+		async createWasmRenderSession(manifestJSON, sessionOptions = {}, loadOptions = {}) {
+			return renderSession(await loadWasmEngine(loadOptions), manifestJSON, sessionOptions);
+		}
+	});
+}
+function emittedGlobalsJSON(options) {
+	return options.emittedGlobals === void 0 ? void 0 : JSON.stringify(options.emittedGlobals);
+}
+const EMITTED_GLOBALS_FIELDS = /* @__PURE__ */ new Set(["variables", "keyframes"]);
+function invalidEmittedGlobals(message) {
+	throw new MasterCSSError({
+		code: "INVALID_INPUT",
+		domain: "binding",
+		message: `Invalid Master CSS emitted globals: ${message}`
+	});
+}
+function counted(field, record) {
+	const entries = Object.entries(record ?? {});
+	for (const [name, count] of entries) if (!Number.isInteger(count) || count < 0 || count > 4294967295) invalidEmittedGlobals(`${field}.${name} must be a count.`);
+	return entries;
+}
+/** Validates what the engine's emitted globals schema accepts, then flattens it. */
+function generatedEmittedGlobals(emittedGlobals = {}) {
+	for (const field of Object.keys(emittedGlobals)) if (!EMITTED_GLOBALS_FIELDS.has(field)) invalidEmittedGlobals(`unknown field ${field}.`);
+	const variables = counted("variables", emittedGlobals.variables);
+	const keyframes = counted("keyframes", emittedGlobals.keyframes);
+	const entries = [...variables, ...keyframes];
+	return [entries.map(([name]) => name), Uint32Array.from([
+		variables.length,
+		keyframes.length,
+		...entries.map(([, count]) => count)
+	])];
+}
+function createGeneratedEngineSession(module, source, sessionOptions) {
+	if (typeof source !== "string") return new module.EngineSession(source, ...generatedEmittedGlobals(sessionOptions.emittedGlobals));
+	return module.EngineSession.fromManifest(source, emittedGlobalsJSON(sessionOptions));
+}
+function engineSession(module, source, sessionOptions) {
+	const session = createGeneratedEngineSession(module, source, sessionOptions);
+	let disposed = false;
+	const assertActive = () => {
+		if (disposed) throw new MasterCSSError({
+			code: "SESSION_DISPOSED",
+			domain: "binding",
+			message: "The Master CSS Wasm engine session has been disposed."
+		});
+	};
+	return Object.freeze({
+		manifestJSON() {
+			assertActive();
+			return session.manifestJSON();
+		},
+		ensureClassRules(classNames) {
+			assertActive();
+			return JSON.parse(session.ensureClassRules(classNames));
+		},
+		deleteClassRules(classNames) {
+			assertActive();
+			return JSON.parse(session.deleteClassRules(classNames));
+		},
+		registerEmittedGlobals(emittedGlobals) {
+			assertActive();
+			return JSON.parse(session.registerEmittedGlobals(...generatedEmittedGlobals(emittedGlobals)));
+		},
+		replaceEmittedGlobals(emittedGlobals) {
+			assertActive();
+			return JSON.parse(session.replaceEmittedGlobals(...generatedEmittedGlobals(emittedGlobals)));
+		},
+		refresh(next, emittedGlobals) {
+			assertActive();
+			if (typeof next === "string") return JSON.parse(session.refreshManifest(next, emittedGlobals === void 0 ? void 0 : JSON.stringify(emittedGlobals)));
+			return JSON.parse(session.refresh(next, ...emittedGlobals === void 0 ? [] : generatedEmittedGlobals(emittedGlobals)));
+		},
+		keyframeDefinitions() {
+			assertActive();
+			return JSON.parse(session.keyframeDefinitions());
+		},
+		snapshot() {
+			assertActive();
+			return JSON.parse(session.snapshot());
+		},
+		executionState(classNames) {
+			assertActive();
+			return JSON.parse(session.executionState(classNames));
+		},
+		inspect(className) {
+			assertActive();
+			return JSON.parse(session.inspect(className));
+		},
+		dispose() {
+			if (disposed) return;
+			session.dispose();
+			disposed = true;
+		}
+	});
+}
+function renderSession(module, manifestJSON, sessionOptions) {
+	const session = new module.RenderSession(manifestJSON, emittedGlobalsJSON(sessionOptions));
+	let disposed = false;
+	const assertActive = () => {
+		if (disposed) throw new MasterCSSError({
+			code: "SESSION_DISPOSED",
+			domain: "binding",
+			message: "The Master CSS Wasm render session has been disposed."
+		});
+	};
+	return Object.freeze({
+		nativeDeclarationCandidates(classNames) {
+			assertActive();
+			return JSON.parse(session.nativeDeclarationCandidates([...classNames]));
+		},
+		ensureClassRules(classNames) {
+			assertActive();
+			session.ensureClasses([...classNames]);
+		},
+		ensureStylesheetResources(nativeCSS) {
+			assertActive();
+			session.ensureStylesheetResources(nativeCSS);
+		},
+		emittedGlobals() {
+			assertActive();
+			return JSON.parse(session.emittedGlobals());
+		},
+		snapshot() {
+			assertActive();
+			return JSON.parse(session.snapshot());
+		},
+		snapshotForClassNames(classNames) {
+			assertActive();
+			return JSON.parse(session.snapshotForClasses([...classNames]));
+		},
+		dispose() {
+			if (disposed) return;
+			session.dispose();
+			disposed = true;
+		}
+	});
+}
+export { createWasmEngineLoader };

package/dist/node.js

@@ -0,0 +1,17 @@
+import { wasmEngine } from "./artifact.js";
+import { readFile } from "node:fs/promises";
+// src/node.ts
+function resolveFileURL(input) {
+	if (input instanceof URL) return input.protocol === "file:" ? input : void 0;
+	if (typeof input !== "string" || !input.startsWith("file:")) return;
+	return new URL(input);
+}
+async function withNodeWasmInput(options) {
+	const fileURL = options.input === void 0 ? wasmEngine.url : resolveFileURL(options.input);
+	if (!fileURL) return options;
+	return {
+		...options,
+		input: new Uint8Array(await readFile(fileURL))
+	};
+}
+export { wasmEngine, withNodeWasmInput };

package/dist/provider-core.js

@@ -0,0 +1,11 @@
+// src/provider-core.ts
+async function createWasmEngineProvider(loader, loadOptions = {}) {
+	const module = await loader.loadWasmEngine(loadOptions);
+	return Object.freeze({
+		info: JSON.parse(module.bindingInfo()),
+		createEngineSession: (source, emittedGlobals) => loader.createWasmEngineSession(source, { emittedGlobals }, loadOptions),
+		createRenderSession: (manifestJSON, emittedGlobalsJSON) => loader.createWasmRenderSession(manifestJSON, emittedGlobalsJSON === void 0 ? {} : { emittedGlobals: JSON.parse(emittedGlobalsJSON) }, loadOptions),
+		compileRuntimeProgram: (manifestJSON) => loader.compileRuntimeProgram(manifestJSON, loadOptions)
+	});
+}
+export { createWasmEngineProvider };

package/dist/provider-node.d.ts

@@ -0,0 +1,3 @@
+import { MasterCSSWasmEngineLoadOptions, MasterCSSWasmEngineLoadOptions as MasterCSSWasmEngineLoadOptions$1 } from "./provider.js";
+declare function createMasterCSSEngineWasmProvider(options?: MasterCSSWasmEngineLoadOptions$1): Promise<object>;
+export { type MasterCSSWasmEngineLoadOptions, createMasterCSSEngineWasmProvider };

package/dist/provider-node.js

@@ -0,0 +1,8 @@
+import { wasmEngine } from "./artifact.js";
+import { createWasmEngineProvider } from "./provider-core.js";
+import { withNodeWasmInput } from "./node.js";
+// src/provider-node.ts
+async function createMasterCSSEngineWasmProvider(options = {}) {
+	return await createWasmEngineProvider(wasmEngine, await withNodeWasmInput(options));
+}
+export { createMasterCSSEngineWasmProvider };

package/dist/provider.d.ts

@@ -0,0 +1,7 @@
+type MasterCSSWasmEngineInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+interface MasterCSSWasmEngineLoadOptions {
+  readonly module?: object;
+  readonly input?: MasterCSSWasmEngineInput;
+}
+declare function createMasterCSSEngineWasmProvider(loadOptions?: MasterCSSWasmEngineLoadOptions): Promise<object>;
+export { MasterCSSWasmEngineInput, MasterCSSWasmEngineLoadOptions, createMasterCSSEngineWasmProvider };

package/dist/provider.js

@@ -0,0 +1,7 @@
+import { wasmEngine } from "./artifact.js";
+import { createWasmEngineProvider } from "./provider-core.js";
+// src/provider.ts
+async function createMasterCSSEngineWasmProvider(loadOptions = {}) {
+	return await createWasmEngineProvider(wasmEngine, loadOptions);
+}
+export { createMasterCSSEngineWasmProvider };

package/package.json

@@ -1,6 +1,47 @@
 {
-  "name": "@master/css-binding-wasm-engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@master/css-binding-wasm-engine",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "scripts": {
+        "build": "bun --bun tsdown --config ../../shared/tsdown-package.config.ts",
+        "build:artifacts": "cargo xtask build-wasm engine",
+        "dev": "bun --bun tsdown --config ../../shared/tsdown-package.config.ts --watch",
+        "test": "bun --bun vitest run",
+        "type-check": "bun --bun tsc -b tsconfig.typecheck.json",
+        "lint": "bun --bun eslint"
+    },
+    "license": "MIT",
+    "description": "Internal Master CSS engine Wasm binding provider.",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/master-co/css.git",
+        "directory": "packages/binding-wasm-engine"
+    },
+    "sideEffects": false,
+    "types": "./dist/provider.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/provider.d.ts",
+            "browser": "./dist/provider.js",
+            "node": "./dist/provider-node.js",
+            "import": "./dist/provider.js",
+            "default": "./dist/provider.js"
+        },
+        "./wasm": "./artifacts/mastercss_binding_wasm_engine_bg.wasm"
+    },
+    "files": [
+        "dist",
+        "artifacts"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "dependencies": {
+        "@master/css-schema": "3.0.0"
+    },
+    "version": "3.0.0",
+    "gitHead": "a5da5f2d73901082314a082d5213fd18e11ad48b"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.