@czap/vite 0.1.0

package/dist/html-transform.js

@@ -0,0 +1,54 @@
+/**
+ * HTML transform -- resolves `data-czap="name"` to boundary JSON.
+ *
+ * Scans HTML/Astro source for `data-czap="..."` attributes, resolves
+ * the named boundary via the existing boundary resolution infrastructure,
+ * and replaces with `data-czap-boundary='...'` containing serialized JSON.
+ *
+ * @module
+ */
+import { Diagnostics } from '@czap/core';
+import { resolvePrimitive } from './primitive-resolve.js';
+// Match data-czap="boundaryName" (not data-czap-* which are other attrs)
+const DATA_CZAP_PATTERN = /data-czap="([^"]+)"/g;
+/**
+ * Transform HTML source, replacing `data-czap="name"` with resolved boundary JSON.
+ *
+ * @param source - The HTML/Astro source string
+ * @param fromFile - The file path of the source (for resolution context)
+ * @param projectRoot - The project root directory
+ * @returns The transformed source, or the original if no transforms needed
+ */
+export async function transformHTML(source, fromFile, projectRoot) {
+    const matches = [...source.matchAll(DATA_CZAP_PATTERN)];
+    if (matches.length === 0)
+        return source;
+    let result = source;
+    for (const match of matches) {
+        const fullMatch = match[0];
+        const boundaryName = match[1];
+        const resolution = await resolvePrimitive('boundary', boundaryName, fromFile, projectRoot);
+        if (!resolution) {
+            Diagnostics.warn({
+                source: 'czap/vite.html-transform',
+                code: 'boundary-not-found',
+                message: `Boundary "${boundaryName}" could not be resolved for HTML transform.`,
+                detail: { fromFile },
+            });
+            continue;
+        }
+        const boundary = resolution.primitive;
+        const serialized = JSON.stringify({
+            id: boundary.id,
+            input: boundary.input,
+            thresholds: boundary.thresholds,
+            states: boundary.states,
+            hysteresis: boundary.hysteresis,
+        });
+        // Replace data-czap="name" with data-czap-boundary='...'
+        const replacement = `data-czap-boundary='${serialized.replace(/'/g, ''')}'`;
+        result = result.replace(fullMatch, replacement);
+    }
+    return result;
+}
+//# sourceMappingURL=html-transform.js.map

package/dist/html-transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-transform.js","sourceRoot":"","sources":["../src/html-transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,yEAAyE;AACzE,MAAM,iBAAiB,GAAG,sBAAsB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,MAAc,EAAE,QAAgB,EAAE,WAAmB;IACvF,MAAM,OAAO,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACxD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IAExC,IAAI,MAAM,GAAG,MAAM,CAAC;IAEpB,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;QAC5B,MAAM,YAAY,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;QAE/B,MAAM,UAAU,GAAG,MAAM,gBAAgB,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;QAC3F,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,WAAW,CAAC,IAAI,CAAC;gBACf,MAAM,EAAE,0BAA0B;gBAClC,IAAI,EAAE,oBAAoB;gBAC1B,OAAO,EAAE,aAAa,YAAY,6CAA6C;gBAC/E,MAAM,EAAE,EAAE,QAAQ,EAAE;aACrB,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QAED,MAAM,QAAQ,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC;YAChC,EAAE,EAAE,QAAQ,CAAC,EAAE;YACf,KAAK,EAAE,QAAQ,CAAC,KAAK;YACrB,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;SAChC,CAAC,CAAC;QAEH,yDAAyD;QACzD,MAAM,WAAW,GAAG,uBAAuB,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC;QAChF,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IAClD,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `@czap/vite` — **LiteShip** Vite 8 plugin: turns `@token` / `@theme` /
+ * `@style` / `@quantize` at-rule blocks into native CSS and **rigs** HMR for
+ * `@czap/*` definitions.
+ *
+ * The plugin hooks into Vite's `resolveId`, `load`, `transform`, and
+ * `handleHotUpdate` phases:
+ *
+ * - `resolveId` + `load`: map `virtual:czap/*` specifiers to generated
+ *   modules (device capabilities, WASM URL, ...).
+ * - `transform`: rewrite `@token`, `@theme`, `@style`, and `@quantize`
+ *   at-rule blocks into native CSS (custom properties,
+ *   `html[data-theme]` selectors, scoped `@layer` / `@scope` rules,
+ *   and `@container` queries).
+ * - `handleHotUpdate`: emit surgical HMR payloads so CSS variables,
+ *   shader uniforms, and boundary definitions update without a full
+ *   page reload.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from 'vite';
+ * import { plugin as czap } from '@czap/vite';
+ *
+ * const config = defineConfig({
+ *   plugins: [czap({ themes: ['./themes/default.ts'] })],
+ * });
+ * ```
+ *
+ * @module
+ */
+export type { PluginConfig } from './plugin.js';
+export { plugin } from './plugin.js';
+export { resolveWASM } from './wasm-resolve.js';
+export type { WASMResolution } from './wasm-resolve.js';
+export type { QuantizeBlock } from './css-quantize.js';
+export { parseQuantizeBlocks, compileQuantizeBlock } from './css-quantize.js';
+export type { TokenBlock } from './token-transform.js';
+export { parseTokenBlocks, compileTokenBlock } from './token-transform.js';
+export type { ThemeBlock } from './theme-transform.js';
+export { parseThemeBlocks, compileThemeBlock } from './theme-transform.js';
+export type { StyleBlock } from './style-transform.js';
+export { parseStyleBlocks, compileStyleBlock } from './style-transform.js';
+export { transformHTML } from './html-transform.js';
+export type { VirtualModuleId } from './virtual-modules.js';
+export { resolveVirtualId, isVirtualId, loadVirtualModule } from './virtual-modules.js';
+export type { HMRPayload } from './hmr.js';
+export { handleHMR } from './hmr.js';
+export type { PrimitiveKind, PrimitiveResolution, PrimitiveShape } from './primitive-resolve.js';
+export { resolvePrimitive } from './primitive-resolve.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAG9E,YAAY,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG3E,YAAY,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG3E,YAAY,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAGxF,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAMrC,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACjG,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,43 @@
+/**
+ * `@czap/vite` — **LiteShip** Vite 8 plugin: turns `@token` / `@theme` /
+ * `@style` / `@quantize` at-rule blocks into native CSS and **rigs** HMR for
+ * `@czap/*` definitions.
+ *
+ * The plugin hooks into Vite's `resolveId`, `load`, `transform`, and
+ * `handleHotUpdate` phases:
+ *
+ * - `resolveId` + `load`: map `virtual:czap/*` specifiers to generated
+ *   modules (device capabilities, WASM URL, ...).
+ * - `transform`: rewrite `@token`, `@theme`, `@style`, and `@quantize`
+ *   at-rule blocks into native CSS (custom properties,
+ *   `html[data-theme]` selectors, scoped `@layer` / `@scope` rules,
+ *   and `@container` queries).
+ * - `handleHotUpdate`: emit surgical HMR payloads so CSS variables,
+ *   shader uniforms, and boundary definitions update without a full
+ *   page reload.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from 'vite';
+ * import { plugin as czap } from '@czap/vite';
+ *
+ * const config = defineConfig({
+ *   plugins: [czap({ themes: ['./themes/default.ts'] })],
+ * });
+ * ```
+ *
+ * @module
+ */
+export { plugin } from './plugin.js';
+export { resolveWASM } from './wasm-resolve.js';
+export { parseQuantizeBlocks, compileQuantizeBlock } from './css-quantize.js';
+export { parseTokenBlocks, compileTokenBlock } from './token-transform.js';
+export { parseThemeBlocks, compileThemeBlock } from './theme-transform.js';
+export { parseStyleBlocks, compileStyleBlock } from './style-transform.js';
+// HTML transform
+export { transformHTML } from './html-transform.js';
+export { resolveVirtualId, isVirtualId, loadVirtualModule } from './virtual-modules.js';
+export { handleHMR } from './hmr.js';
+export { resolvePrimitive } from './primitive-resolve.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAI9E,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAI3E,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAI3E,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE3E,iBAAiB;AACjB,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIpD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAIxF,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAOrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/normalize-css-eol.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Normalize CSS newlines to LF for line-based parsing of CSS at-rules.
+ *
+ * @module
+ */
+export declare function normalizeCssLineEndings(css: string): string;
+//# sourceMappingURL=normalize-css-eol.d.ts.map

package/dist/normalize-css-eol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-css-eol.d.ts","sourceRoot":"","sources":["../src/normalize-css-eol.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/normalize-css-eol.js

@@ -0,0 +1,9 @@
+/**
+ * Normalize CSS newlines to LF for line-based parsing of CSS at-rules.
+ *
+ * @module
+ */
+export function normalizeCssLineEndings(css) {
+    return css.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+//# sourceMappingURL=normalize-css-eol.js.map

package/dist/normalize-css-eol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-css-eol.js","sourceRoot":"","sources":["../src/normalize-css-eol.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,GAAW;IACjD,OAAO,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACzD,CAAC"}

package/dist/plugin.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Main Vite 8 plugin for czap -- processes `@token`, `@theme`,
+ * `@style`, and `@quantize` CSS blocks, handles HMR, serves virtual
+ * modules, and configures build environments.
+ *
+ * Transform pipeline order: tokens -- themes -- styles -- quantize.
+ * This ordering ensures themes / styles can reference token custom
+ * properties that were already compiled earlier in the pipeline.
+ *
+ * @module
+ */
+import type { Plugin } from 'vite';
+/**
+ * Configuration options for the {@link plugin} factory. Every field
+ * is optional; omitted values use convention-based defaults.
+ */
+export interface PluginConfig {
+    /** Override source directories for each primitive kind. */
+    readonly dirs?: Partial<Record<'boundary' | 'token' | 'theme' | 'style', string>>;
+    /** Toggle surgical HMR emission (default `true`). */
+    readonly hmr?: boolean;
+    /** Named Vite environments to configure (browser / server / shader). */
+    readonly environments?: readonly ('browser' | 'server' | 'shader')[];
+    /** Opt-in WASM runtime configuration. */
+    readonly wasm?: {
+        readonly enabled?: boolean;
+        readonly path?: string;
+    };
+}
+/**
+ * Create the czap Vite plugin.
+ *
+ * Transforms CSS files containing `@token`, `@theme`, `@style`, and
+ * `@quantize` blocks into native CSS custom properties,
+ * `html[data-theme]` selectors, scoped `@layer` / `@scope` rules, and
+ * `@container` queries respectively. Uses convention-based definition
+ * resolution and provides HMR support for surgical CSS and shader
+ * uniform updates.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { plugin as czap } from '@czap/vite';
+ * const config = { plugins: [czap()] };
+ * ```
+ */
+export declare function plugin(config?: PluginConfig): Plugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAiBnC;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;IAClF,qDAAqD;IACrD,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,wEAAwE;IACxE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,CAAC,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC,EAAE,CAAC;IACrE,yCAAyC;IACzC,QAAQ,CAAC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACxE;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAwTpD"}

package/dist/plugin.js

@@ -0,0 +1,404 @@
+/**
+ * Main Vite 8 plugin for czap -- processes `@token`, `@theme`,
+ * `@style`, and `@quantize` CSS blocks, handles HMR, serves virtual
+ * modules, and configures build environments.
+ *
+ * Transform pipeline order: tokens -- themes -- styles -- quantize.
+ * This ordering ensures themes / styles can reference token custom
+ * properties that were already compiled earlier in the pipeline.
+ *
+ * @module
+ */
+import { readFileSync } from 'node:fs';
+import { parseQuantizeBlocks, compileQuantizeBlock } from './css-quantize.js';
+import { resolvePrimitive } from './primitive-resolve.js';
+import { transformHTML } from './html-transform.js';
+import { parseTokenBlocks, compileTokenBlock } from './token-transform.js';
+import { parseThemeBlocks, compileThemeBlock } from './theme-transform.js';
+import { parseStyleBlocks, compileStyleBlock } from './style-transform.js';
+import { resolveVirtualId, loadVirtualModule } from './virtual-modules.js';
+import { buildEnvironments } from './environments.js';
+import { resolveWASM } from './wasm-resolve.js';
+import { normalizeCssLineEndings } from './normalize-css-eol.js';
+// ---------------------------------------------------------------------------
+// Plugin
+// ---------------------------------------------------------------------------
+/**
+ * Create the czap Vite plugin.
+ *
+ * Transforms CSS files containing `@token`, `@theme`, `@style`, and
+ * `@quantize` blocks into native CSS custom properties,
+ * `html[data-theme]` selectors, scoped `@layer` / `@scope` rules, and
+ * `@container` queries respectively. Uses convention-based definition
+ * resolution and provides HMR support for surgical CSS and shader
+ * uniform updates.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { plugin as czap } from '@czap/vite';
+ * const config = { plugins: [czap()] };
+ * ```
+ */
+export function plugin(config) {
+    const hmrEnabled = config?.hmr !== false;
+    const wasmEnabled = config?.wasm?.enabled === true;
+    let projectRoot = process.cwd();
+    let isBuild = false;
+    let resolvedWasm = null;
+    if (wasmEnabled) {
+        resolvedWasm = resolveWASM(projectRoot, config?.wasm?.path);
+    }
+    let emittedWasmRefId = null;
+    // Caches for resolved definitions to avoid re-importing on every transform
+    const boundaryCache = new Map();
+    const tokenCache = new Map();
+    const themeCache = new Map();
+    const styleCache = new Map();
+    return {
+        name: '@czap/vite',
+        enforce: 'pre',
+        configResolved(resolvedConfig) {
+            projectRoot = resolvedConfig.root;
+            isBuild = resolvedConfig.command === 'build';
+            resolvedWasm = null;
+            if (wasmEnabled) {
+                resolvedWasm = resolveWASM(projectRoot, config?.wasm?.path);
+            }
+        },
+        buildStart() {
+            if (!wasmEnabled) {
+                return;
+            }
+            resolvedWasm = resolveWASM(projectRoot, config?.wasm?.path);
+            if (!resolvedWasm) {
+                this.warn('WASM support was enabled, but no czap-compute binary could be resolved. Runtime will fall back to TypeScript kernels.');
+                return;
+            }
+            if (isBuild) {
+                emittedWasmRefId = this.emitFile({
+                    type: 'asset',
+                    name: 'czap-compute.wasm',
+                    source: readFileSync(resolvedWasm.filePath),
+                });
+            }
+        },
+        // -----------------------------------------------------------------------
+        // HMR client script injection
+        // -----------------------------------------------------------------------
+        transformIndexHtml() {
+            if (!hmrEnabled)
+                return [];
+            return [
+                {
+                    tag: 'script',
+                    attrs: { type: 'module' },
+                    children: `import 'virtual:czap/hmr-client';`,
+                    injectTo: 'head',
+                },
+            ];
+        },
+        // -----------------------------------------------------------------------
+        // Virtual module resolution
+        // -----------------------------------------------------------------------
+        resolveId(id) {
+            return resolveVirtualId(id);
+        },
+        load(id) {
+            if (id === '\0virtual:czap/wasm-url') {
+                if (!wasmEnabled) {
+                    return 'export const wasmUrl = null;';
+                }
+                if (!resolvedWasm) {
+                    return 'export const wasmUrl = null;';
+                }
+                if (isBuild && emittedWasmRefId) {
+                    return `export const wasmUrl = import.meta.ROLLUP_FILE_URL_${emittedWasmRefId};`;
+                }
+                const browserUrl = resolvedWasm.source === 'public' ? '/czap-compute.wasm' : `/@fs/${resolvedWasm.filePath.replace(/\\/g, '/')}`;
+                return `export const wasmUrl = ${JSON.stringify(browserUrl)};`;
+            }
+            return loadVirtualModule(id);
+        },
+        // -----------------------------------------------------------------------
+        // CSS transform pipeline: tokens -> themes -> styles -> quantize
+        // -----------------------------------------------------------------------
+        async transform(code, id) {
+            if (id.endsWith('.html') || id.endsWith('.astro')) {
+                const transformed = await transformHTML(code, id, projectRoot);
+                if (transformed === code) {
+                    return null;
+                }
+                return {
+                    code: transformed,
+                    map: null,
+                };
+            }
+            // Only process CSS files
+            if (!id.endsWith('.css'))
+                return null;
+            // Quick check -- skip files with no @czap at-rules
+            const hasToken = code.includes('@token');
+            const hasTheme = code.includes('@theme');
+            const hasStyle = code.includes('@style');
+            const hasQuantize = code.includes('@quantize');
+            if (!hasToken && !hasTheme && !hasStyle && !hasQuantize)
+                return null;
+            let transformed = normalizeCssLineEndings(code);
+            // ---- Phase 1: @token -> CSS custom properties + @property ----
+            if (hasToken) {
+                const tokenBlocks = parseTokenBlocks(transformed, id);
+                for (const block of tokenBlocks) {
+                    const cacheKey = `${block.tokenName}:${id}`;
+                    let token = tokenCache.get(cacheKey);
+                    if (token === undefined) {
+                        const resolution = await resolvePrimitive('token', block.tokenName, id, projectRoot, config?.dirs?.token);
+                        token = resolution?.primitive ?? null;
+                        tokenCache.set(cacheKey, token);
+                    }
+                    if (token === null) {
+                        this.warn(`Could not resolve token "${block.tokenName}" referenced in ${id}:${block.line}`);
+                        continue;
+                    }
+                    const compiled = compileTokenBlock(block, token);
+                    const blockSpan = findAtRuleBlock(transformed, '@token', block.tokenName);
+                    if (blockSpan) {
+                        transformed = transformed.substring(0, blockSpan.start) + compiled + transformed.substring(blockSpan.end);
+                    }
+                }
+            }
+            // ---- Phase 2: @theme -> html[data-theme] selectors + transitions ----
+            if (hasTheme) {
+                const themeBlocks = parseThemeBlocks(transformed, id);
+                for (const block of themeBlocks) {
+                    const cacheKey = `${block.themeName}:${id}`;
+                    let theme = themeCache.get(cacheKey);
+                    if (theme === undefined) {
+                        const resolution = await resolvePrimitive('theme', block.themeName, id, projectRoot, config?.dirs?.theme);
+                        theme = resolution?.primitive ?? null;
+                        themeCache.set(cacheKey, theme);
+                    }
+                    if (theme === null) {
+                        this.warn(`Could not resolve theme "${block.themeName}" referenced in ${id}:${block.line}`);
+                        continue;
+                    }
+                    const compiled = compileThemeBlock(block, theme);
+                    const blockSpan = findAtRuleBlock(transformed, '@theme', block.themeName);
+                    if (blockSpan) {
+                        transformed = transformed.substring(0, blockSpan.start) + compiled + transformed.substring(blockSpan.end);
+                    }
+                }
+            }
+            // ---- Phase 3: @style -> scoped CSS with @layer/@scope/@starting-style ----
+            if (hasStyle) {
+                const styleBlocks = parseStyleBlocks(transformed, id);
+                for (const block of styleBlocks) {
+                    const cacheKey = `${block.styleName}:${id}`;
+                    let style = styleCache.get(cacheKey);
+                    if (style === undefined) {
+                        const resolution = await resolvePrimitive('style', block.styleName, id, projectRoot, config?.dirs?.style);
+                        style = resolution?.primitive ?? null;
+                        styleCache.set(cacheKey, style);
+                    }
+                    if (style === null) {
+                        this.warn(`Could not resolve style "${block.styleName}" referenced in ${id}:${block.line}`);
+                        continue;
+                    }
+                    const compiled = compileStyleBlock(block, style);
+                    const blockSpan = findAtRuleBlock(transformed, '@style', block.styleName);
+                    if (blockSpan) {
+                        transformed = transformed.substring(0, blockSpan.start) + compiled + transformed.substring(blockSpan.end);
+                    }
+                }
+            }
+            // ---- Phase 4: @quantize -> @container queries (existing) ----
+            if (hasQuantize) {
+                const quantizeBlocks = parseQuantizeBlocks(transformed, id);
+                for (const block of quantizeBlocks) {
+                    const cacheKey = `${block.boundaryName}:${id}`;
+                    let boundary = boundaryCache.get(cacheKey);
+                    if (boundary === undefined) {
+                        const resolution = await resolvePrimitive('boundary', block.boundaryName, id, projectRoot, config?.dirs?.boundary);
+                        boundary = resolution?.primitive ?? null;
+                        boundaryCache.set(cacheKey, boundary);
+                    }
+                    if (boundary === null) {
+                        this.warn(`Could not resolve boundary "${block.boundaryName}" referenced in ${id}:${block.line}`);
+                        continue;
+                    }
+                    const compiled = compileQuantizeBlock(block, boundary);
+                    const blockSpan = findAtRuleBlock(transformed, '@quantize', block.boundaryName);
+                    if (blockSpan) {
+                        transformed = transformed.substring(0, blockSpan.start) + compiled + transformed.substring(blockSpan.end);
+                    }
+                }
+            }
+            if (transformed === code)
+                return null;
+            return {
+                code: transformed,
+                map: null,
+            };
+        },
+        // -----------------------------------------------------------------------
+        // HMR: invalidate caches + re-transform on definition file changes
+        // -----------------------------------------------------------------------
+        hotUpdate(options) {
+            if (!hmrEnabled)
+                return;
+            const file = options.file;
+            // Invalidate definition caches when source files change
+            const isDefFile = file.endsWith('.boundaries.ts') ||
+                file.endsWith('/boundaries.ts') ||
+                file.endsWith('.tokens.ts') ||
+                file.endsWith('/tokens.ts') ||
+                file.endsWith('.themes.ts') ||
+                file.endsWith('/themes.ts') ||
+                file.endsWith('.styles.ts') ||
+                file.endsWith('/styles.ts');
+            if (isDefFile) {
+                // Clear all caches since definitions may cross-reference
+                boundaryCache.clear();
+                tokenCache.clear();
+                themeCache.clear();
+                styleCache.clear();
+                const moduleGraph = this.environment.moduleGraph;
+                const transformModules = Array.from(moduleGraph.idToModuleMap.values()).filter((mod) => {
+                    const moduleId = mod.id;
+                    return (typeof moduleId === 'string' &&
+                        (moduleId.endsWith('.css') || moduleId.endsWith('.astro') || moduleId.endsWith('.html')));
+                });
+                if (transformModules.length > 0) {
+                    return transformModules;
+                }
+            }
+            if (file.endsWith('.css') || file.endsWith('.astro') || file.endsWith('.html')) {
+                const moduleGraph = this.environment.moduleGraph;
+                const mod = moduleGraph.getModuleById(file);
+                if (mod) {
+                    return [mod];
+                }
+            }
+            return;
+        },
+        config() {
+            if (!config?.environments || config.environments.length === 0)
+                return {};
+            const envNames = config.environments;
+            const envs = buildEnvironments(envNames);
+            return {
+                environments: envs,
+            };
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Find the full span of an at-rule block in CSS source.
+ * Returns the start/end character offsets, or null if not found.
+ *
+ * Works for any at-rule pattern: `@token`, `@theme`, `@style`,
+ * `@quantize`. Uses a state machine to correctly skip block comments,
+ * quoted strings, and `url(...)` tokens (which may contain braces in
+ * data URIs) before counting brace depth.
+ */
+function findAtRuleBlock(css, marker, name) {
+    let searchFrom = 0;
+    while (searchFrom < css.length) {
+        const idx = css.indexOf(marker, searchFrom);
+        if (idx === -1)
+            return null;
+        // Verify this at-rule is followed by the target name
+        const afterMarker = css.substring(idx + marker.length).trimStart();
+        if (!afterMarker.startsWith(name)) {
+            searchFrom = idx + marker.length;
+            continue;
+        }
+        // Ensure the name isn't just a prefix of a longer identifier
+        const charAfterName = afterMarker[name.length];
+        if (charAfterName !== undefined && /[a-zA-Z0-9_-]/.test(charAfterName)) {
+            searchFrom = idx + marker.length;
+            continue;
+        }
+        // Find the opening brace
+        const braceStart = css.indexOf('{', idx);
+        /* v8 ignore next — unreachable under real call sites: `findAtRuleBlock` runs only
+           after `parseTokenBlocks`/etc. matched a `@marker name { ... }` block with braces,
+           so the `{` is always still present in the transformed source. Defensive against
+           future multi-phase edits that strip braces between parse and lookup. */
+        if (braceStart === -1)
+            return null;
+        // Walk forward tracking depth with full comment/string/url awareness
+        let depth = 1;
+        let pos = braceStart + 1;
+        while (pos < css.length && depth > 0) {
+            const ch = css[pos];
+            // Skip block comments: /* ... */
+            if (ch === '/' && css[pos + 1] === '*') {
+                pos += 2;
+                while (pos < css.length - 1 && !(css[pos] === '*' && css[pos + 1] === '/')) {
+                    pos++;
+                }
+                pos += 2;
+                continue;
+            }
+            // Skip quoted strings: "..." and '...' (with backslash escapes)
+            if (ch === '"' || ch === "'") {
+                const quote = ch;
+                pos++;
+                while (pos < css.length && css[pos] !== quote) {
+                    if (css[pos] === '\\')
+                        pos++;
+                    pos++;
+                }
+                pos++;
+                continue;
+            }
+            // Skip url(...) tokens: may contain unquoted data URIs with braces
+            if (ch === 'u' && css.slice(pos, pos + 4).toLowerCase() === 'url(') {
+                pos += 4;
+                // url() may use a quoted or unquoted value
+                if (css[pos] === '"' || css[pos] === "'") {
+                    const quote = css[pos];
+                    pos++;
+                    while (pos < css.length && css[pos] !== quote) {
+                        if (css[pos] === '\\')
+                            pos++;
+                        pos++;
+                    }
+                    pos++; // closing quote
+                }
+                else {
+                    // unquoted -- scan until the matching ')'
+                    let parenDepth = 1;
+                    while (pos < css.length && parenDepth > 0) {
+                        if (css[pos] === '(')
+                            parenDepth++;
+                        else if (css[pos] === ')')
+                            parenDepth--;
+                        pos++;
+                    }
+                }
+                continue;
+            }
+            if (ch === '{')
+                depth++;
+            else if (ch === '}')
+                depth--;
+            pos++;
+        }
+        if (depth === 0) {
+            return { start: idx, end: pos };
+        }
+        return null;
+    }
+    /* v8 ignore next — unreachable under real call sites: the inner `while` only runs
+       when `parseTokenBlocks` has already matched a `@marker name { ... }` block, so the
+       first indexOf hit returns either a `{start,end}` span or null inside the loop.
+       This terminal `return null` is a defense against pathological CSS where the
+       marker+name hits but searchFrom exhausts without a `{` match. */
+    return null;
+}
+//# sourceMappingURL=plugin.js.map