@yahoo/uds-create-loader 1.1.1

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __require };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import transformLoader from "./loader.js";
+import { LoaderTransformOutputSpecs, LoaderTransformResult, RunLoaderTransformOptions, getLoaderTransformOutputSpecs, runLoaderTransform } from "./transform-runner.js";
+import { UdsPluginOptions, udsPlugin } from "./unplugin.js";
+export { type LoaderTransformOutputSpecs, type LoaderTransformResult, type RunLoaderTransformOptions, type UdsPluginOptions, getLoaderTransformOutputSpecs, runLoaderTransform, transformLoader, udsPlugin };

package/dist/index.js

@@ -0,0 +1,4 @@
+import transformLoader from "./loader.js";
+import { getLoaderTransformOutputSpecs, runLoaderTransform } from "./transform-runner.js";
+import { udsPlugin } from "./unplugin.js";
+export { getLoaderTransformOutputSpecs, runLoaderTransform, transformLoader, udsPlugin };

package/dist/inspect-transform.d.ts

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

package/dist/inspect-transform.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { runLoaderTransform } from './transform-runner';
+function readFlag(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return null;
+    const value = process.argv[index + 1];
+    if (!value || value.startsWith('-'))
+        return null;
+    return value;
+}
+function printUsage() {
+    console.error([
+        'Usage:',
+        '  bun run src/inspect-transform.ts --file <path-to-tsx> --config <path-to-uds.config.ts>',
+        '',
+        'Example:',
+        '  bun run --filter @yahoo/uds-create-loader inspect:transform -- --file packages/components/src/accordion.tsx --config apps/docs/uds.config.ts',
+    ].join('\n'));
+    process.exit(1);
+}
+async function loadUdsConfig(configPath) {
+    const resolvedPath = path.resolve(configPath);
+    const configUrl = pathToFileURL(resolvedPath).href;
+    const module = (await import(configUrl));
+    if (module.default !== undefined) {
+        return module.default;
+    }
+    if (module.udsConfig !== undefined) {
+        return module.udsConfig;
+    }
+    return module;
+}
+async function main() {
+    const sourcePath = readFlag('--file');
+    const configPath = readFlag('--config');
+    if (!sourcePath || !configPath) {
+        printUsage();
+    }
+    const sourceAbsolutePath = path.resolve(sourcePath);
+    if (!fs.existsSync(sourceAbsolutePath)) {
+        throw new Error(`Source file not found: ${sourceAbsolutePath}`);
+    }
+    const rawConfig = await loadUdsConfig(configPath);
+    const config = rawConfig.toJSON();
+    const source = fs.readFileSync(sourceAbsolutePath, 'utf8');
+    const result = runLoaderTransform(source, {
+        config,
+        resourcePath: sourceAbsolutePath,
+        isDev: false,
+    });
+    if ('error' in result) {
+        throw new Error(result.error);
+    }
+    process.stdout.write(result.output);
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[inspect-transform] ${message}`);
+    process.exit(1);
+});

package/dist/loader/artifacts.d.ts

@@ -0,0 +1,30 @@
+import type { SerializedConfig } from '@yahoo/uds-create-config';
+export interface LoaderOptions {
+    /** Path to `.uds/manifest.json`. The loader extracts `.config` at the
+     *  read boundary; the manifest's wrapper fields (`catalogMeta`,
+     *  `sourceMap`, …) exist for Studio/MCP and aren't read here. */
+    dataPath: string;
+    isDev: boolean;
+    /** Skip addDependency calls to prevent webpack from watching .uds/ artifacts.
+     *  Use this when the app has its own reload mechanism (e.g., Studio WebSocket). */
+    skipWatchDependencies?: boolean;
+}
+/**
+ * Derived projection of one loaded config — built lazily on first use,
+ * cached by config object identity so subsequent transforms reuse the
+ * same set. Carries the registered-component-name set the loader uses
+ * for the pre-filter and the import-rewrite visitor's eligibility check.
+ */
+export interface LoaderProjection {
+    readonly componentNames: ReadonlySet<string>;
+}
+export declare const loadUdsConfig: (filePath: string, isDev: boolean) => SerializedConfig | null;
+export declare const seedUdsConfig: (filePath: string, config: SerializedConfig) => void;
+/**
+ * Build (or return a cached) projection of the config for the loader's
+ * hot path. Keyed by config object identity. The cache survives across
+ * transforms within one process; reloading `.uds/manifest.json`
+ * produces a fresh object, which transparently invalidates the
+ * projection.
+ */
+export declare function getLoaderProjection(config: SerializedConfig): LoaderProjection;

package/dist/loader/artifacts.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+//#region src/loader/artifacts.ts
+/**
+* `.uds/config.json` IS the serialized config — no envelope. Parse and
+* cache by file mtime so subsequent transforms reuse the same object.
+*/
+function createCachedJsonLoader() {
+	let cached = null;
+	let cachedPath = null;
+	let cachedMtime = 0;
+	return (filePath, isDev) => {
+		try {
+			const mtime = fs.statSync(filePath).mtimeMs;
+			if (cached && cachedPath === filePath && (!isDev || cachedMtime === mtime)) return cached;
+			const content = fs.readFileSync(filePath, "utf-8");
+			cached = JSON.parse(content);
+			cachedPath = filePath;
+			cachedMtime = mtime;
+			return cached;
+		} catch {
+			return null;
+		}
+	};
+}
+function createCachedJsonLoaderWithSeed() {
+	const loader = createCachedJsonLoader();
+	let seededPath = null;
+	let seededData = null;
+	return {
+		load: (filePath, isDev) => {
+			if (seededPath === filePath && seededData) return seededData;
+			return loader(filePath, isDev);
+		},
+		seed: (filePath, config) => {
+			seededPath = filePath;
+			seededData = config;
+		}
+	};
+}
+const configLoader = createCachedJsonLoaderWithSeed();
+const loadUdsConfig = configLoader.load;
+const seedUdsConfig = configLoader.seed;
+const projectionCache = /* @__PURE__ */ new WeakMap();
+/**
+* Build (or return a cached) projection of the config for the loader's
+* hot path. Keyed by config object identity. The cache survives across
+* transforms within one process; reloading `.uds/manifest.json`
+* produces a fresh object, which transparently invalidates the
+* projection.
+*/
+function getLoaderProjection(config) {
+	const cached = projectionCache.get(config);
+	if (cached) return cached;
+	const components = config.components ?? {};
+	const projection = { componentNames: new Set(Object.keys(components)) };
+	projectionCache.set(config, projection);
+	return projection;
+}
+//#endregion
+export { getLoaderProjection, loadUdsConfig, seedUdsConfig };

package/dist/loader/babel-utils.d.ts

@@ -0,0 +1,9 @@
+import * as t from '@babel/types';
+/**
+ * Check whether a callee expression is a compiled JSX call.
+ *
+ * Matches:
+ * - Direct identifiers: `jsx(...)`, `_jsxs(...)`, `jsxDEV(...)`, etc.
+ * - Member expressions: `React.jsx(...)`, `_reactJsxRuntime.jsxs(...)`, etc.
+ */
+export declare function isCompiledJsxCallee(node: t.Expression | t.V8IntrinsicIdentifier | null | undefined): boolean;

package/dist/loader/babel-utils.js

@@ -0,0 +1,29 @@
+import * as t from "@babel/types";
+//#region src/loader/babel-utils.ts
+/** JSX function names used by compiled JSX (React, etc.) */
+const COMPILED_JSX_NAMES = new Set([
+	"jsx",
+	"jsxs",
+	"jsxDEV",
+	"_jsx",
+	"_jsxs",
+	"_jsxDEV"
+]);
+/**
+* Check whether a callee expression is a compiled JSX call.
+*
+* Matches:
+* - Direct identifiers: `jsx(...)`, `_jsxs(...)`, `jsxDEV(...)`, etc.
+* - Member expressions: `React.jsx(...)`, `_reactJsxRuntime.jsxs(...)`, etc.
+*/
+function isCompiledJsxCallee(node) {
+	if (!node) return false;
+	if (t.isIdentifier(node)) return COMPILED_JSX_NAMES.has(node.name);
+	if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+		if (!node.computed && t.isIdentifier(node.property)) return COMPILED_JSX_NAMES.has(node.property.name);
+		if (node.computed && t.isStringLiteral(node.property)) return COMPILED_JSX_NAMES.has(node.property.value);
+	}
+	return false;
+}
+//#endregion
+export { isCompiledJsxCallee };

package/dist/loader.d.ts

@@ -0,0 +1,22 @@
+import { LoaderDefinitionFunction } from "webpack";
+
+//#region src/loader.d.ts
+/**
+ * The UDS loader's only build-time job: rewrite alias-prefixed local
+ * imports of registered UDS components from `@/uds/components/<seg>`
+ * (the authoring file) to `'#uds/components/<seg>'` (the codegen-
+ * emitted per-source-file module at `.uds/components/<seg>.tsx`).
+ *
+ * The authoring file is read only by codegen — production renders the
+ * downleveled FC. Per-file targets keep Next.js Fast Refresh surgical:
+ * editing one authoring source only invalidates that one downleveled
+ * module.
+ *
+ * No JSX-site work: composite / variant / bool / style-prop resolution
+ * and motion wiring are owned by the codegen-emitted FC. The loader
+ * only changes import sources.
+ */
+declare const transformLoader: LoaderDefinitionFunction;
+declare const normal: LoaderDefinitionFunction<{}, {}>;
+//#endregion
+export { transformLoader as default, normal };

package/dist/loader.js

@@ -0,0 +1,87 @@
+import { getLoaderProjection, loadUdsConfig } from "./loader/artifacts.js";
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+//#region src/loader.ts
+const traverse = _traverse.default ?? _traverse;
+/**
+* The UDS loader's only build-time job: rewrite alias-prefixed local
+* imports of registered UDS components from `@/uds/components/<seg>`
+* (the authoring file) to `'#uds/components/<seg>'` (the codegen-
+* emitted per-source-file module at `.uds/components/<seg>.tsx`).
+*
+* The authoring file is read only by codegen — production renders the
+* downleveled FC. Per-file targets keep Next.js Fast Refresh surgical:
+* editing one authoring source only invalidates that one downleveled
+* module.
+*
+* No JSX-site work: composite / variant / bool / style-prop resolution
+* and motion wiring are owned by the codegen-emitted FC. The loader
+* only changes import sources.
+*/
+const transformLoader = function(source) {
+	const loaderContext = this ?? void 0;
+	if (!loaderContext?.getOptions) return source;
+	const { dataPath, isDev, skipWatchDependencies } = loaderContext.getOptions();
+	const resourcePath = loaderContext.resourcePath ?? "";
+	if (resourcePath.includes(".uds/")) return source;
+	if (!skipWatchDependencies) loaderContext.addDependency?.(dataPath);
+	const config = loadUdsConfig(dataPath, isDev);
+	if (!config) return source;
+	const projection = getLoaderProjection(config);
+	let hasComponentReference = false;
+	for (const name of projection.componentNames) if (source.includes(name)) {
+		hasComponentReference = true;
+		break;
+	}
+	if (!hasComponentReference) return source;
+	const isTS = resourcePath?.endsWith(".ts") || resourcePath?.endsWith(".tsx");
+	const isJSX = resourcePath?.endsWith(".tsx") || resourcePath?.endsWith(".jsx");
+	const parserPlugins = [];
+	if (isJSX || !isTS) parserPlugins.push("jsx");
+	if (isTS) parserPlugins.push("typescript");
+	let ast;
+	try {
+		ast = parse(source, {
+			sourceType: "module",
+			plugins: parserPlugins
+		});
+	} catch {
+		return source;
+	}
+	const edits = [];
+	traverse(ast, { ImportDeclaration(nodePath) {
+		const importSource = nodePath.node.source?.value;
+		if (!importSource) return;
+		if (!(!importSource.startsWith(".") && !importSource.startsWith("/"))) return;
+		let shouldRewriteSource = false;
+		for (const specifier of nodePath.node.specifiers) {
+			if (specifier.type !== "ImportSpecifier") continue;
+			const importedName = specifier.imported?.type === "Identifier" ? specifier.imported.name : void 0;
+			if (!importedName) continue;
+			if (projection.componentNames.has(importedName)) shouldRewriteSource = true;
+		}
+		const segmentMatch = importSource.match(/\/uds\/components\/([^/]+)$/);
+		if (!shouldRewriteSource && segmentMatch) {
+			const pascal = segmentMatch[1].split("-").filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+			if (projection.componentNames.has(pascal)) shouldRewriteSource = true;
+		}
+		if (shouldRewriteSource && segmentMatch) {
+			const sourceNode = nodePath.node.source;
+			if (typeof sourceNode.start !== "number" || typeof sourceNode.end !== "number") return;
+			const quote = source[sourceNode.start] ?? "'";
+			edits.push({
+				start: sourceNode.start,
+				end: sourceNode.end,
+				value: `${quote}#uds/components/${segmentMatch[1]}${quote}`
+			});
+		}
+	} });
+	if (edits.length === 0) return source;
+	edits.sort((a, b) => b.start - a.start);
+	let output = source;
+	for (const edit of edits) output = output.slice(0, edit.start) + edit.value + output.slice(edit.end);
+	return output;
+};
+const normal = transformLoader;
+//#endregion
+export { transformLoader as default, normal };

package/dist/next.d.ts

@@ -0,0 +1,16 @@
+import { NextConfig } from "next";
+
+//#region src/next.d.ts
+interface WithUdsOptions {
+  /** Output directory for generated files (default: '.uds') */
+  outputDir?: string;
+  /** Skip addDependency calls to prevent webpack from watching .uds/ artifacts.
+   *  Use this when the app has its own reload mechanism (e.g., Studio WebSocket). */
+  skipWatchDependencies?: boolean;
+}
+type NextConfigFn = (phase: string, ctx: {
+  defaultConfig: NextConfig;
+}) => NextConfig | Promise<NextConfig>;
+declare function withUds(nextConfigOrFn: NextConfig | NextConfigFn, options?: WithUdsOptions): NextConfig | NextConfigFn;
+//#endregion
+export { WithUdsOptions, withUds };

package/dist/next.js

@@ -0,0 +1,77 @@
+import { __require } from "./_virtual/_rolldown/runtime.js";
+import path from "node:path";
+//#region src/next.ts
+function resolveLoaderPath() {
+	return __require.resolve("@yahoo/uds-create-loader/loader");
+}
+function applyUds(nextConfig, options) {
+	const outputDir = options?.outputDir ?? ".uds";
+	const skipWatch = options?.skipWatchDependencies ?? false;
+	const dataPath = path.resolve(process.cwd(), outputDir, "config.json");
+	const loaderPath = resolveLoaderPath();
+	const turbopack = nextConfig.turbopack ?? {};
+	const existingRules = turbopack.rules ?? {};
+	const udsLoader = {
+		loader: loaderPath,
+		options: {
+			dataPath,
+			isDev: true,
+			skipWatchDependencies: skipWatch
+		}
+	};
+	const udsRules = {};
+	for (const ext of [
+		"tsx",
+		"ts",
+		"js"
+	]) {
+		const key = `*.${ext}`;
+		const udsKey = `**/*.${ext}`;
+		if (existingRules[key]) udsRules[udsKey] = { loaders: [udsLoader] };
+		else udsRules[key] = { loaders: [udsLoader] };
+	}
+	return {
+		...nextConfig,
+		turbopack: {
+			...turbopack,
+			rules: {
+				...existingRules,
+				...udsRules
+			}
+		},
+		webpack(config, webpackOptions) {
+			config.module?.rules?.push({
+				test: /\.(tsx|ts|js)$/,
+				use: [{
+					loader: loaderPath,
+					options: {
+						dataPath,
+						isDev: webpackOptions.dev,
+						skipWatchDependencies: skipWatch
+					}
+				}]
+			});
+			if (skipWatch) {
+				const existing = config.watchOptions?.ignored;
+				config.watchOptions = {
+					...config.watchOptions,
+					ignored: [
+						...Array.isArray(existing) ? existing : existing ? [existing] : [],
+						"**/.uds/**",
+						"**/uds.config.ts"
+					]
+				};
+			}
+			if (typeof nextConfig.webpack === "function") return nextConfig.webpack(config, webpackOptions);
+			return config;
+		}
+	};
+}
+function withUds(nextConfigOrFn, options) {
+	if (typeof nextConfigOrFn === "function") return async (phase, ctx) => {
+		return applyUds(await nextConfigOrFn(phase, ctx), options);
+	};
+	return applyUds(nextConfigOrFn, options);
+}
+//#endregion
+export { withUds };

package/dist/transform-runner.d.ts

@@ -0,0 +1,27 @@
+import { SerializedConfig } from "@yahoo/uds-create-config";
+
+//#region src/transform-runner.d.ts
+interface LoaderTransformOutputSpecs {
+  outputGzipBytes: number;
+  classNameAssignments: number;
+  utilityClassTokens: number;
+  uniqueUtilityClassTokens: number;
+  runtimeStyleParserCalls: number;
+}
+interface LoaderTransformSuccess {
+  output: string;
+  specs: LoaderTransformOutputSpecs;
+}
+interface LoaderTransformFailure {
+  error: string;
+}
+type LoaderTransformResult = LoaderTransformSuccess | LoaderTransformFailure;
+interface RunLoaderTransformOptions {
+  config: SerializedConfig;
+  resourcePath?: string;
+  isDev?: boolean;
+}
+declare function getLoaderTransformOutputSpecs(output: string): LoaderTransformOutputSpecs;
+declare function runLoaderTransform(source: string, options: RunLoaderTransformOptions): LoaderTransformResult;
+//#endregion
+export { LoaderTransformOutputSpecs, LoaderTransformResult, RunLoaderTransformOptions, getLoaderTransformOutputSpecs, runLoaderTransform };

package/dist/transform-runner.js

@@ -0,0 +1,200 @@
+import { seedUdsConfig } from "./loader/artifacts.js";
+import transformLoader from "./loader.js";
+import { isCompiledJsxCallee } from "./loader/babel-utils.js";
+import { parse } from "@babel/parser";
+import path from "node:path";
+import { gzipSync } from "node:zlib";
+import * as t from "@babel/types";
+import { VISITOR_KEYS } from "@babel/types";
+//#region src/transform-runner.ts
+function getClassTokens(value) {
+	return value.split(/\s+/).map((token) => token.trim()).filter(Boolean);
+}
+function collectClassTokensFromNode(node, tokens) {
+	if (!node) return;
+	if (t.isStringLiteral(node)) {
+		tokens.push(...getClassTokens(node.value));
+		return;
+	}
+	if (t.isTemplateLiteral(node)) {
+		for (const quasi of node.quasis) tokens.push(...getClassTokens(quasi.value.cooked ?? quasi.value.raw ?? ""));
+		for (const expression of node.expressions) collectClassTokensFromNode(expression, tokens);
+		return;
+	}
+	if (t.isJSXExpressionContainer(node)) {
+		if (!t.isJSXEmptyExpression(node.expression)) collectClassTokensFromNode(node.expression, tokens);
+		return;
+	}
+	if (t.isParenthesizedExpression(node) || t.isTSAsExpression(node) || t.isTSTypeAssertion(node) || t.isTSNonNullExpression(node)) {
+		collectClassTokensFromNode(node.expression, tokens);
+		return;
+	}
+	if (t.isUnaryExpression(node) || t.isUpdateExpression(node)) {
+		collectClassTokensFromNode(node.argument, tokens);
+		return;
+	}
+	if (t.isBinaryExpression(node) || t.isLogicalExpression(node) || t.isAssignmentExpression(node)) {
+		collectClassTokensFromNode(node.left, tokens);
+		collectClassTokensFromNode(node.right, tokens);
+		return;
+	}
+	if (t.isConditionalExpression(node)) {
+		collectClassTokensFromNode(node.test, tokens);
+		collectClassTokensFromNode(node.consequent, tokens);
+		collectClassTokensFromNode(node.alternate, tokens);
+		return;
+	}
+	if (t.isSequenceExpression(node)) {
+		for (const expression of node.expressions) collectClassTokensFromNode(expression, tokens);
+		return;
+	}
+	if (t.isArrayExpression(node)) {
+		for (const element of node.elements) {
+			if (!element) continue;
+			if (t.isSpreadElement(element)) {
+				collectClassTokensFromNode(element.argument, tokens);
+				continue;
+			}
+			collectClassTokensFromNode(element, tokens);
+		}
+		return;
+	}
+	if (t.isObjectExpression(node)) {
+		for (const property of node.properties) {
+			if (t.isSpreadElement(property)) {
+				collectClassTokensFromNode(property.argument, tokens);
+				continue;
+			}
+			if (t.isObjectProperty(property)) collectClassTokensFromNode(property.value, tokens);
+		}
+		return;
+	}
+	if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+		collectClassTokensFromNode(node.callee, tokens);
+		for (const argument of node.arguments) {
+			if (t.isSpreadElement(argument)) {
+				collectClassTokensFromNode(argument.argument, tokens);
+				continue;
+			}
+			collectClassTokensFromNode(argument, tokens);
+		}
+		return;
+	}
+	if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+		collectClassTokensFromNode(node.object, tokens);
+		if (node.computed) collectClassTokensFromNode(node.property, tokens);
+		return;
+	}
+	if (t.isNewExpression(node)) {
+		collectClassTokensFromNode(node.callee, tokens);
+		for (const argument of node.arguments ?? []) {
+			if (t.isSpreadElement(argument)) {
+				collectClassTokensFromNode(argument.argument, tokens);
+				continue;
+			}
+			collectClassTokensFromNode(argument, tokens);
+		}
+	}
+}
+function isClassNameObjectProperty(node) {
+	if (node.computed) return false;
+	return t.isIdentifier(node.key) && node.key.name === "className" || t.isStringLiteral(node.key) && node.key.value === "className";
+}
+function isBabelNode(value) {
+	return typeof value === "object" && value !== null && "type" in value;
+}
+function isClassNamePropOnCompiledJsxCall(node, parent, grandParent) {
+	if (!isClassNameObjectProperty(node)) return false;
+	if (!parent || !t.isObjectExpression(parent)) return false;
+	if (!grandParent || !t.isCallExpression(grandParent)) return false;
+	if (!isCompiledJsxCallee(grandParent.callee)) return false;
+	return grandParent.arguments.some((argument) => argument === parent);
+}
+function getClassTokenStats(output) {
+	try {
+		const ast = parse(output, {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		});
+		const uniqueTokens = /* @__PURE__ */ new Set();
+		let total = 0;
+		let assignments = 0;
+		const addTokens = (node) => {
+			const nextTokens = [];
+			collectClassTokensFromNode(node, nextTokens);
+			total += nextTokens.length;
+			for (const token of nextTokens) uniqueTokens.add(token);
+		};
+		const visit = (node, parent, grandParent) => {
+			if (!node) return;
+			if (t.isJSXAttribute(node) && t.isJSXIdentifier(node.name) && node.name.name === "className") {
+				assignments += 1;
+				addTokens(node.value);
+			} else if (t.isObjectProperty(node)) {
+				if (isClassNamePropOnCompiledJsxCall(node, parent, grandParent)) {
+					assignments += 1;
+					addTokens(node.value);
+				}
+			}
+			const visitorKeys = VISITOR_KEYS[node.type] ?? [];
+			const typedNode = node;
+			for (const key of visitorKeys) {
+				const childValue = typedNode[key];
+				if (Array.isArray(childValue)) {
+					for (const item of childValue) if (isBabelNode(item)) visit(item, node, parent);
+					continue;
+				}
+				if (isBabelNode(childValue)) visit(childValue, node, parent);
+			}
+		};
+		visit(ast.program, null, null);
+		return {
+			total,
+			unique: uniqueTokens.size,
+			assignments
+		};
+	} catch {
+		return {
+			total: 0,
+			unique: 0,
+			assignments: (output.match(/className\s*[:=]/g) ?? []).length
+		};
+	}
+}
+function getRuntimeStyleParserCallCount(output) {
+	return [/extractStyleProps\s*\(/g, /getStyles\s*\(/g].reduce((count, pattern) => count + (output.match(pattern) ?? []).length, 0);
+}
+function getLoaderTransformOutputSpecs(output) {
+	const classTokenStats = getClassTokenStats(output);
+	return {
+		outputGzipBytes: gzipSync(output).byteLength,
+		classNameAssignments: classTokenStats.assignments,
+		utilityClassTokens: classTokenStats.total,
+		uniqueUtilityClassTokens: classTokenStats.unique,
+		runtimeStyleParserCalls: getRuntimeStyleParserCallCount(output)
+	};
+}
+const VIRTUAL_CONFIG_PATH = "/virtual/uds-config.json";
+function runLoaderTransform(source, options) {
+	if (typeof source !== "string") return { error: "`source` must be a string." };
+	seedUdsConfig(VIRTUAL_CONFIG_PATH, options.config);
+	const context = {
+		getOptions: () => ({
+			dataPath: VIRTUAL_CONFIG_PATH,
+			isDev: options.isDev ?? false
+		}),
+		addDependency: () => {},
+		resourcePath: options.resourcePath ?? path.resolve(process.cwd(), "playground-input.tsx")
+	};
+	try {
+		const output = transformLoader.call(context, source);
+		return {
+			output,
+			specs: getLoaderTransformOutputSpecs(output)
+		};
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : "Transform failed unexpectedly." };
+	}
+}
+//#endregion
+export { getLoaderTransformOutputSpecs, runLoaderTransform };