@csszyx/unplugin 0.9.0 → 0.9.2

package/dist/next-prebuild.mjs

@@ -0,0 +1,131 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { r as readPackageVersion, t as transformNextSource, c as collectNextTransformMetadata, a as createNextSafelistShardFromMetadata } from './shared/unplugin.8er8o6rn.mjs';
+import { c as createNextStateContext, w as writeNextSafelistShard, r as runNextWatcherCycle } from './shared/unplugin.BtQzlC2C.mjs';
+import { r as resolveTransformCacheDir } from './shared/unplugin.BceVw1eW.mjs';
+import '@csszyx/compiler';
+import 'node:os';
+import 'proper-lockfile';
+
+function runNextPrebuild(options) {
+  assertProductionManglingBoundary(options);
+  const csszyxVersion = options.csszyxVersion ?? readPackageVersion("../package.json", import.meta.url);
+  const compilerVersion = options.compilerVersion ?? readPackageVersion("../../compiler/package.json", import.meta.url);
+  const nativeVersion = options.nativeVersion ?? compilerVersion;
+  const nextVersion = options.nextVersion ?? "unknown-next";
+  const context = createNextStateContext({
+    explicitRoot: options.explicitRoot,
+    loaderRootContext: options.loaderRootContext,
+    loaderContext: options.loaderContext,
+    cwd: options.cwd,
+    cacheDir: options.cacheDir,
+    safelistOutputFile: options.safelistOutputFile,
+    config: options.config ?? {},
+    env: options.env ?? process.env,
+    envKeys: options.envKeys,
+    nextVersion,
+    csszyxVersion,
+    nativeVersion,
+    mode: options.mode ?? "production"
+  });
+  const cacheRoot = resolveTransformCacheDir(
+    context.root,
+    path.relative(context.root, context.cacheDir)
+  );
+  const files = [];
+  let scannedCount = 0;
+  let transformedCount = 0;
+  let skippedMissingCount = 0;
+  for (const filename of uniqueFiles(options.files)) {
+    scannedCount++;
+    if (!existsSync(filename)) {
+      skippedMissingCount++;
+      continue;
+    }
+    const source = readFileSync(filename, "utf8");
+    const transform = transformNextSource({
+      source,
+      filename,
+      parserMode: options.parserMode ?? "rust",
+      compilerOptions: options.compilerOptions,
+      cacheRoot,
+      pluginVersion: csszyxVersion,
+      compilerVersion,
+      astBudget: options.astBudget,
+      allowBabelFallback: options.allowBabelFallback
+    });
+    const metadata = collectNextTransformMetadata(transform.result, source, filename);
+    transformedCount++;
+    const shardResult = writeNextSafelistShard(
+      context.safelist.shardsDir,
+      createNextSafelistShardFromMetadata(metadata, createShardCacheKey(context, metadata)),
+      options.writeOptions
+    );
+    files.push({
+      filename,
+      shardPath: shardResult.filePath,
+      classCount: metadata.classes.length,
+      cacheStatus: transform.cacheStatus,
+      producer: transform.producer
+    });
+  }
+  const cycle = runNextWatcherCycle(context, {
+    writeOptions: options.writeOptions,
+    lockOptions: {
+      root: context.root,
+      mode: context.manifestExpectation.mode,
+      command: "csszyx next prebuild"
+    },
+    createdAt: options.createdAt
+  });
+  return {
+    context,
+    scannedCount,
+    transformedCount,
+    skippedMissingCount,
+    classCount: cycle.materialize.classCount,
+    sourceCount: cycle.materialize.sourceCount,
+    manifestPath: context.manifestPath,
+    safelistOutputPath: context.safelist.outputPath,
+    files,
+    cycle
+  };
+}
+function assertProductionManglingBoundary(options) {
+  if (options.allowProductionMangling) {
+    return;
+  }
+  if ((options.mode ?? "production") !== "production") {
+    return;
+  }
+  if (options.compilerOptions?.mangleVars === true || hasEnabledMangleVars(options.config)) {
+    throw new Error(
+      "[csszyx] Next prebuild does not support production CSS variable mangling. Use Next Webpack mode for full csszyx parity."
+    );
+  }
+}
+function hasEnabledMangleVars(config) {
+  if (config === null || typeof config !== "object" || Array.isArray(config)) {
+    return false;
+  }
+  return config.mangleVars === true;
+}
+function uniqueFiles(files) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const file of files) {
+    const resolved = path.resolve(file);
+    if (seen.has(resolved)) {
+      continue;
+    }
+    seen.add(resolved);
+    result.push(resolved);
+  }
+  return result;
+}
+function createShardCacheKey(context, metadata) {
+  return createHash("sha256").update(context.identity.generation).update("\0").update(path.relative(context.root, metadata.sourcePath).replace(/\\/g, "/")).digest("hex");
+}
+
+export { runNextPrebuild };

package/dist/next-turbo-loader.cjs

@@ -0,0 +1,210 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const node_crypto = require('node:crypto');
+const path = require('node:path');
+const nextWatcherCycle = require('./shared/unplugin.s62yJbu1.cjs');
+const nextTransformMetadata = require('./shared/unplugin.B_U4rZvG.cjs');
+const transformCache = require('./shared/unplugin.DUxdYaSG.cjs');
+require('node:fs');
+require('node:os');
+require('proper-lockfile');
+require('@csszyx/compiler');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null);
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+
+const DIRECTIVE_PROLOGUE_PREFIX_RE = /^((?:\s|\/\/[^\n]*\n|\/\*(?:[^*]|\*(?!\/))*\*\/)*)(['"]use (?:client|server)['"];?\s*)/;
+const RUNTIME_HELPER_IMPORT_RE = {
+  _sz: /\{[^}]*\b_sz\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/,
+  _szMerge: /\{[^}]*\b_szMerge\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/,
+  __szColorVar: /\{[^}]*\b__szColorVar\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/
+};
+function injectNextRuntimeImports(code, usage) {
+  const helpers = runtimeHelpersFromUsage(usage);
+  if (helpers.length === 0) {
+    return { code, injected: [] };
+  }
+  const hasRuntimeImport = code.includes("@csszyx/runtime");
+  const missing = hasRuntimeImport ? helpers.filter((helper) => !RUNTIME_HELPER_IMPORT_RE[helper].test(code)) : helpers;
+  if (missing.length === 0) {
+    return { code, injected: [] };
+  }
+  return {
+    code: insertRuntimeImport(
+      code,
+      `import { ${missing.join(", ")} } from '@csszyx/runtime';
+`
+    ),
+    injected: missing
+  };
+}
+function runtimeHelpersFromUsage(usage) {
+  const helpers = [];
+  if (usage.usesRuntime) {
+    helpers.push("_sz");
+  }
+  if (usage.usesMerge) {
+    helpers.push("_szMerge");
+  }
+  if (usage.usesColorVar) {
+    helpers.push("__szColorVar");
+  }
+  return helpers;
+}
+function insertRuntimeImport(code, importStmt) {
+  const directiveMatch = code.match(DIRECTIVE_PROLOGUE_PREFIX_RE);
+  if (!directiveMatch) {
+    return `${importStmt}${code}`;
+  }
+  return code.replace(directiveMatch[0], `${directiveMatch[1]}${directiveMatch[2]}${importStmt}`);
+}
+
+function runNextTurboLoader(source, loaderContext, explicitOptions = {}) {
+  const options = normalizeOptions(loaderContext, explicitOptions);
+  assertTurbopackMangleBoundary(options, loaderContext.resourcePath);
+  const context = nextWatcherCycle.createNextStateContext({
+    explicitRoot: options.root,
+    loaderRootContext: loaderContext.rootContext,
+    loaderContext: loaderContext.context,
+    cacheDir: options.cacheDir,
+    safelistOutputFile: options.safelistOutputFile,
+    config: options.config ?? {},
+    env: options.env ?? process.env,
+    envKeys: options.envKeys,
+    nextVersion: options.nextVersion ?? "unknown-next",
+    csszyxVersion: options.csszyxVersion ?? nextTransformMetadata.readPackageVersion("../package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next-turbo-loader.cjs', document.baseURI).href))),
+    nativeVersion: options.nativeVersion ?? options.compilerVersion ?? nextTransformMetadata.readPackageVersion("../../compiler/package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next-turbo-loader.cjs', document.baseURI).href))),
+    mode: options.mode ?? normalizeMode(loaderContext.mode)
+  });
+  assertProductionManifestReady(context, options);
+  const transform = nextTransformMetadata.transformNextSource({
+    source,
+    filename: loaderContext.resourcePath,
+    parserMode: options.parserMode ?? "rust",
+    compilerOptions: options.compilerOptions,
+    cacheRoot: transformCache.resolveTransformCacheDir(
+      context.root,
+      path__namespace.relative(context.root, context.cacheDir)
+    ),
+    pluginVersion: options.csszyxVersion ?? nextTransformMetadata.readPackageVersion("../package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next-turbo-loader.cjs', document.baseURI).href))),
+    compilerVersion: options.compilerVersion ?? nextTransformMetadata.readPackageVersion("../../compiler/package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next-turbo-loader.cjs', document.baseURI).href))),
+    astBudget: options.astBudget,
+    allowBabelFallback: options.allowBabelFallback
+  });
+  const injected = injectNextRuntimeImports(transform.result.code, transform.result);
+  const metadata = nextTransformMetadata.collectNextTransformMetadata(
+    transform.result,
+    source,
+    loaderContext.resourcePath
+  );
+  let shardPath = null;
+  let materialized = false;
+  const shardResult = nextWatcherCycle.writeNextSafelistShard(
+    context.safelist.shardsDir,
+    nextTransformMetadata.createNextSafelistShardFromMetadata(metadata, createShardCacheKey(context, metadata)),
+    options.writeOptions
+  );
+  shardPath = shardResult.filePath;
+  if (options.materializeSafelist !== false && shardResult.changed) {
+    nextWatcherCycle.runNextWatcherCycle(context, {
+      writeOptions: options.writeOptions,
+      lockOptions: {
+        root: context.root,
+        mode: context.manifestExpectation.mode,
+        command: "csszyx next turbo-loader"
+      }
+    });
+    materialized = true;
+  }
+  return {
+    code: injected.code,
+    context,
+    transform,
+    shardPath,
+    materialized,
+    dependencies: []
+  };
+}
+function nextTurboLoader(source) {
+  try {
+    const result = runNextTurboLoader(source, this);
+    if (this.callback) {
+      this.callback(null, result.code, result.map);
+      return;
+    }
+    return result.code;
+  } catch (error) {
+    if (this.callback) {
+      this.callback(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    throw error;
+  }
+}
+function normalizeOptions(loaderContext, explicitOptions) {
+  const contextOptions = loaderContext.getOptions?.() ?? parseQueryOptions(loaderContext.query);
+  return { ...contextOptions, ...explicitOptions };
+}
+function parseQueryOptions(query) {
+  if (!query || typeof query !== "object" || Array.isArray(query)) {
+    return {};
+  }
+  return query;
+}
+function normalizeMode(mode) {
+  return mode === "production" || process.env.NODE_ENV === "production" ? "production" : "development";
+}
+function assertProductionManifestReady(context, options) {
+  if ((options.mode ?? context.manifestExpectation.mode) !== "production") {
+    return;
+  }
+  const validation = nextWatcherCycle.validateNextGenerationManifest(
+    nextWatcherCycle.readNextGenerationManifest(context.manifestPath),
+    context.manifestExpectation
+  );
+  if (!validation.ok) {
+    throw new Error(
+      `[csszyx] Next Turbopack production cache is not ready for ${context.root}: ${validation.reason}. Run csszyx next prebuild before next build --turbo.`
+    );
+  }
+}
+function assertTurbopackMangleBoundary(options, resourcePath) {
+  if (options.allowProductionMangling) {
+    return;
+  }
+  const productionMode = options.mode === "production" || process.env.NODE_ENV === "production";
+  if (!productionMode) {
+    return;
+  }
+  if (options.compilerOptions?.mangleVars === true || hasEnabledMangleVars(options.config)) {
+    throw new Error(
+      `[csszyx] Next Turbopack does not support production CSS variable mangling for ${resourcePath}. Use Next Webpack mode for full csszyx parity.`
+    );
+  }
+}
+function hasEnabledMangleVars(config) {
+  if (config === null || typeof config !== "object" || Array.isArray(config)) {
+    return false;
+  }
+  return config.mangleVars === true;
+}
+function createShardCacheKey(context, metadata) {
+  return node_crypto.createHash("sha256").update(context.identity.generation).update("\0").update(path__namespace.relative(context.root, metadata.sourcePath).replace(/\\/g, "/")).digest("hex");
+}
+
+exports.default = nextTurboLoader;
+exports.runNextTurboLoader = runNextTurboLoader;

package/dist/next-turbo-loader.d.cts

@@ -0,0 +1,68 @@
+import { TransformSourceCodeOptions } from '@csszyx/compiler';
+import { J as JsonLike, A as AtomicWriteOptions, N as NextStateContext } from './shared/unplugin.CPEWNSA0.cjs';
+import { N as NextSourceParserMode, a as NextSourceTransformOutput } from './shared/unplugin.CScQRdTp.cjs';
+
+/** Serializable options accepted by the Next Turbopack csszyx loader. */
+interface NextTurboLoaderOptions {
+    root?: string;
+    cacheDir?: string;
+    safelistOutputFile?: string;
+    parserMode?: NextSourceParserMode;
+    compilerOptions?: TransformSourceCodeOptions;
+    config?: JsonLike;
+    env?: Record<string, string | undefined>;
+    envKeys?: readonly string[];
+    nextVersion?: string;
+    csszyxVersion?: string;
+    compilerVersion?: string;
+    nativeVersion?: string;
+    mode?: 'development' | 'production';
+    astBudget?: number;
+    allowBabelFallback?: boolean;
+    allowProductionMangling?: boolean;
+    materializeSafelist?: boolean;
+    writeOptions?: AtomicWriteOptions;
+}
+/** Minimal Webpack-compatible loader context used by Turbopack. */
+interface NextTurboLoaderContext {
+    resourcePath: string;
+    rootContext?: string;
+    context?: string;
+    mode?: string;
+    query?: unknown;
+    getOptions?: () => NextTurboLoaderOptions;
+    addDependency?: (file: string) => void;
+    callback?: (error: Error | null, code?: string, map?: unknown) => void;
+}
+/** Testable result produced by the loader core before callback adaptation. */
+interface NextTurboLoaderResult {
+    code: string;
+    map?: unknown;
+    context: NextStateContext;
+    transform: NextSourceTransformOutput;
+    shardPath: string | null;
+    materialized: boolean;
+    dependencies: string[];
+}
+/**
+ * Run the csszyx Next Turbopack loader as a pure, synchronous operation.
+ *
+ * @param source Source module contents.
+ * @param loaderContext Webpack-compatible loader context from Turbopack.
+ * @param explicitOptions Serializable loader options.
+ * @returns Transformed code plus state metadata for tests and diagnostics.
+ */
+declare function runNextTurboLoader(source: string, loaderContext: NextTurboLoaderContext, explicitOptions?: NextTurboLoaderOptions): NextTurboLoaderResult;
+/**
+ * Webpack-compatible loader entry consumed by Next `turbopack.rules`.
+ *
+ * @param this Loader context.
+ * @param source Source module contents.
+ * @returns Transformed source when callback mode is unavailable.
+ */
+declare function nextTurboLoader(this: NextTurboLoaderContext, source: string): string | undefined;
+
+// @ts-ignore
+export = nextTurboLoader;
+export { runNextTurboLoader };
+export type { NextTurboLoaderContext, NextTurboLoaderOptions, NextTurboLoaderResult };

package/dist/next-turbo-loader.d.mts

@@ -0,0 +1,66 @@
+import { TransformSourceCodeOptions } from '@csszyx/compiler';
+import { J as JsonLike, A as AtomicWriteOptions, N as NextStateContext } from './shared/unplugin.CPEWNSA0.mjs';
+import { N as NextSourceParserMode, a as NextSourceTransformOutput } from './shared/unplugin.CScQRdTp.mjs';
+
+/** Serializable options accepted by the Next Turbopack csszyx loader. */
+interface NextTurboLoaderOptions {
+    root?: string;
+    cacheDir?: string;
+    safelistOutputFile?: string;
+    parserMode?: NextSourceParserMode;
+    compilerOptions?: TransformSourceCodeOptions;
+    config?: JsonLike;
+    env?: Record<string, string | undefined>;
+    envKeys?: readonly string[];
+    nextVersion?: string;
+    csszyxVersion?: string;
+    compilerVersion?: string;
+    nativeVersion?: string;
+    mode?: 'development' | 'production';
+    astBudget?: number;
+    allowBabelFallback?: boolean;
+    allowProductionMangling?: boolean;
+    materializeSafelist?: boolean;
+    writeOptions?: AtomicWriteOptions;
+}
+/** Minimal Webpack-compatible loader context used by Turbopack. */
+interface NextTurboLoaderContext {
+    resourcePath: string;
+    rootContext?: string;
+    context?: string;
+    mode?: string;
+    query?: unknown;
+    getOptions?: () => NextTurboLoaderOptions;
+    addDependency?: (file: string) => void;
+    callback?: (error: Error | null, code?: string, map?: unknown) => void;
+}
+/** Testable result produced by the loader core before callback adaptation. */
+interface NextTurboLoaderResult {
+    code: string;
+    map?: unknown;
+    context: NextStateContext;
+    transform: NextSourceTransformOutput;
+    shardPath: string | null;
+    materialized: boolean;
+    dependencies: string[];
+}
+/**
+ * Run the csszyx Next Turbopack loader as a pure, synchronous operation.
+ *
+ * @param source Source module contents.
+ * @param loaderContext Webpack-compatible loader context from Turbopack.
+ * @param explicitOptions Serializable loader options.
+ * @returns Transformed code plus state metadata for tests and diagnostics.
+ */
+declare function runNextTurboLoader(source: string, loaderContext: NextTurboLoaderContext, explicitOptions?: NextTurboLoaderOptions): NextTurboLoaderResult;
+/**
+ * Webpack-compatible loader entry consumed by Next `turbopack.rules`.
+ *
+ * @param this Loader context.
+ * @param source Source module contents.
+ * @returns Transformed source when callback mode is unavailable.
+ */
+declare function nextTurboLoader(this: NextTurboLoaderContext, source: string): string | undefined;
+
+export { nextTurboLoader as default, runNextTurboLoader };
+export type { NextTurboLoaderContext, NextTurboLoaderOptions, NextTurboLoaderResult };

package/dist/next-turbo-loader.mjs

@@ -0,0 +1,190 @@
+import { createHash } from 'node:crypto';
+import * as path from 'node:path';
+import { c as createNextStateContext, w as writeNextSafelistShard, r as runNextWatcherCycle, v as validateNextGenerationManifest, a as readNextGenerationManifest } from './shared/unplugin.BtQzlC2C.mjs';
+import { r as readPackageVersion, t as transformNextSource, c as collectNextTransformMetadata, a as createNextSafelistShardFromMetadata } from './shared/unplugin.8er8o6rn.mjs';
+import { r as resolveTransformCacheDir } from './shared/unplugin.BceVw1eW.mjs';
+import 'node:fs';
+import 'node:os';
+import 'proper-lockfile';
+import '@csszyx/compiler';
+
+const DIRECTIVE_PROLOGUE_PREFIX_RE = /^((?:\s|\/\/[^\n]*\n|\/\*(?:[^*]|\*(?!\/))*\*\/)*)(['"]use (?:client|server)['"];?\s*)/;
+const RUNTIME_HELPER_IMPORT_RE = {
+  _sz: /\{[^}]*\b_sz\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/,
+  _szMerge: /\{[^}]*\b_szMerge\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/,
+  __szColorVar: /\{[^}]*\b__szColorVar\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/
+};
+function injectNextRuntimeImports(code, usage) {
+  const helpers = runtimeHelpersFromUsage(usage);
+  if (helpers.length === 0) {
+    return { code, injected: [] };
+  }
+  const hasRuntimeImport = code.includes("@csszyx/runtime");
+  const missing = hasRuntimeImport ? helpers.filter((helper) => !RUNTIME_HELPER_IMPORT_RE[helper].test(code)) : helpers;
+  if (missing.length === 0) {
+    return { code, injected: [] };
+  }
+  return {
+    code: insertRuntimeImport(
+      code,
+      `import { ${missing.join(", ")} } from '@csszyx/runtime';
+`
+    ),
+    injected: missing
+  };
+}
+function runtimeHelpersFromUsage(usage) {
+  const helpers = [];
+  if (usage.usesRuntime) {
+    helpers.push("_sz");
+  }
+  if (usage.usesMerge) {
+    helpers.push("_szMerge");
+  }
+  if (usage.usesColorVar) {
+    helpers.push("__szColorVar");
+  }
+  return helpers;
+}
+function insertRuntimeImport(code, importStmt) {
+  const directiveMatch = code.match(DIRECTIVE_PROLOGUE_PREFIX_RE);
+  if (!directiveMatch) {
+    return `${importStmt}${code}`;
+  }
+  return code.replace(directiveMatch[0], `${directiveMatch[1]}${directiveMatch[2]}${importStmt}`);
+}
+
+function runNextTurboLoader(source, loaderContext, explicitOptions = {}) {
+  const options = normalizeOptions(loaderContext, explicitOptions);
+  assertTurbopackMangleBoundary(options, loaderContext.resourcePath);
+  const context = createNextStateContext({
+    explicitRoot: options.root,
+    loaderRootContext: loaderContext.rootContext,
+    loaderContext: loaderContext.context,
+    cacheDir: options.cacheDir,
+    safelistOutputFile: options.safelistOutputFile,
+    config: options.config ?? {},
+    env: options.env ?? process.env,
+    envKeys: options.envKeys,
+    nextVersion: options.nextVersion ?? "unknown-next",
+    csszyxVersion: options.csszyxVersion ?? readPackageVersion("../package.json", import.meta.url),
+    nativeVersion: options.nativeVersion ?? options.compilerVersion ?? readPackageVersion("../../compiler/package.json", import.meta.url),
+    mode: options.mode ?? normalizeMode(loaderContext.mode)
+  });
+  assertProductionManifestReady(context, options);
+  const transform = transformNextSource({
+    source,
+    filename: loaderContext.resourcePath,
+    parserMode: options.parserMode ?? "rust",
+    compilerOptions: options.compilerOptions,
+    cacheRoot: resolveTransformCacheDir(
+      context.root,
+      path.relative(context.root, context.cacheDir)
+    ),
+    pluginVersion: options.csszyxVersion ?? readPackageVersion("../package.json", import.meta.url),
+    compilerVersion: options.compilerVersion ?? readPackageVersion("../../compiler/package.json", import.meta.url),
+    astBudget: options.astBudget,
+    allowBabelFallback: options.allowBabelFallback
+  });
+  const injected = injectNextRuntimeImports(transform.result.code, transform.result);
+  const metadata = collectNextTransformMetadata(
+    transform.result,
+    source,
+    loaderContext.resourcePath
+  );
+  let shardPath = null;
+  let materialized = false;
+  const shardResult = writeNextSafelistShard(
+    context.safelist.shardsDir,
+    createNextSafelistShardFromMetadata(metadata, createShardCacheKey(context, metadata)),
+    options.writeOptions
+  );
+  shardPath = shardResult.filePath;
+  if (options.materializeSafelist !== false && shardResult.changed) {
+    runNextWatcherCycle(context, {
+      writeOptions: options.writeOptions,
+      lockOptions: {
+        root: context.root,
+        mode: context.manifestExpectation.mode,
+        command: "csszyx next turbo-loader"
+      }
+    });
+    materialized = true;
+  }
+  return {
+    code: injected.code,
+    context,
+    transform,
+    shardPath,
+    materialized,
+    dependencies: []
+  };
+}
+function nextTurboLoader(source) {
+  try {
+    const result = runNextTurboLoader(source, this);
+    if (this.callback) {
+      this.callback(null, result.code, result.map);
+      return;
+    }
+    return result.code;
+  } catch (error) {
+    if (this.callback) {
+      this.callback(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    throw error;
+  }
+}
+function normalizeOptions(loaderContext, explicitOptions) {
+  const contextOptions = loaderContext.getOptions?.() ?? parseQueryOptions(loaderContext.query);
+  return { ...contextOptions, ...explicitOptions };
+}
+function parseQueryOptions(query) {
+  if (!query || typeof query !== "object" || Array.isArray(query)) {
+    return {};
+  }
+  return query;
+}
+function normalizeMode(mode) {
+  return mode === "production" || process.env.NODE_ENV === "production" ? "production" : "development";
+}
+function assertProductionManifestReady(context, options) {
+  if ((options.mode ?? context.manifestExpectation.mode) !== "production") {
+    return;
+  }
+  const validation = validateNextGenerationManifest(
+    readNextGenerationManifest(context.manifestPath),
+    context.manifestExpectation
+  );
+  if (!validation.ok) {
+    throw new Error(
+      `[csszyx] Next Turbopack production cache is not ready for ${context.root}: ${validation.reason}. Run csszyx next prebuild before next build --turbo.`
+    );
+  }
+}
+function assertTurbopackMangleBoundary(options, resourcePath) {
+  if (options.allowProductionMangling) {
+    return;
+  }
+  const productionMode = options.mode === "production" || process.env.NODE_ENV === "production";
+  if (!productionMode) {
+    return;
+  }
+  if (options.compilerOptions?.mangleVars === true || hasEnabledMangleVars(options.config)) {
+    throw new Error(
+      `[csszyx] Next Turbopack does not support production CSS variable mangling for ${resourcePath}. Use Next Webpack mode for full csszyx parity.`
+    );
+  }
+}
+function hasEnabledMangleVars(config) {
+  if (config === null || typeof config !== "object" || Array.isArray(config)) {
+    return false;
+  }
+  return config.mangleVars === true;
+}
+function createShardCacheKey(context, metadata) {
+  return createHash("sha256").update(context.identity.generation).update("\0").update(path.relative(context.root, metadata.sourcePath).replace(/\\/g, "/")).digest("hex");
+}
+
+export { nextTurboLoader as default, runNextTurboLoader };