@veryfront/ext-css-tailwind 0.1.1185 → 0.1.1188

package/README.md

@@ -1,12 +1,14 @@
 # @veryfront/ext-css-tailwind
 
-> **Category:** Build | **Contract:** `CSSProcessor` | **Built-in**
+> **Category:** Build | **Contract:** `CSSProcessor` | **Explicit**
 
-Provides Tailwind CSS v4 compilation for Veryfront. Compiles stylesheets at render time and supports dynamic plugin loading from CDN.
+Provides Tailwind CSS v4 compilation for Veryfront. The extension owns the
+pinned compiler, local base stylesheet, plugin policy, plugin module loading,
+and every third-party import; framework core sees only `CSSProcessor`.
 
 ## Registration
 
-This extension is auto-enabled by core bootstrap. Add it to `veryfront.config.ts` only when you need to override the built-in registration:
+Install and compose the extension explicitly:
 
 ```ts
 import extTailwind from "@veryfront/ext-css-tailwind";
@@ -16,26 +18,54 @@ export default defineConfig({
 });
 ```
 
+Core never discovers or auto-registers this provider. Production pipelines
+that request CSS minification must also explicitly compose a
+`CSSOptimizationEngine` provider such as `@veryfront/ext-css-lightning`.
+If either requested provider is absent, compilation fails instead of returning
+empty or regex-rewritten CSS.
+
 ## Provided contract
 
 `CSSProcessor` — exposes:
 
-- `compile(stylesheet, options)` — delegates to Tailwind's native `compile()` and returns a compiler whose `build(candidates)` emits CSS for the class-name candidates discovered at render time.
+- `defaultStylesheet` — the extension-owned Tailwind import, typography plugin,
+  and dark-mode variant used only when the application supplies no stylesheet;
+- `compile(stylesheet)` — delegates to Tailwind's native `compile()` and returns
+  a compiler whose `build(candidates)` emits CSS for the class-name candidates
+  discovered at render time.
+
+## Plugin isolation
 
-## Plugin shims
+The extension accepts only its audited plugin allowlist and resolves every
+plugin to one exact, extension-owned npm dependency. All five plugin modules are
+statically imported and registered locally; compilation performs no plugin
+download, temporary-module write, source rewriting, or global shim injection.
+Unpinned version overrides and unknown packages are rejected before Tailwind
+receives a plugin value.
 
-On setup the extension installs three `globalThis` shims so that Tailwind plugin bundles loaded at runtime from `esm.sh` bind their `tailwindcss/plugin`, `tailwindcss/defaultTheme`, and `tailwindcss/colors` imports to the same tailwindcss copy this extension ships. Core's `plugin-loader.ts` rewrites plugin bundle code to reference these shims by name; without them, dynamic plugin loading fails.
+The audited local inventory is:
 
-The shims live at:
+- `@tailwindcss/forms@0.5.11`
+- `@tailwindcss/typography@0.5.19`
+- `daisyui@5.5.14`
+- `tailwind-scrollbar-hide@2.0.0`
+- `tailwindcss-animate@1.0.7`
 
-- `globalThis.__tailwindPluginShim`
-- `globalThis.__tailwindDefaultThemeShim`
-- `globalThis.__tailwindColorsShim`
+Stylesheets may use either the bare package name or that exact versioned
+specifier. No other version is accepted.
+
+The complete local plugin inventory and exact versions are bound into the
+processor cache identity. Changing any plugin implementation policy therefore
+invalidates compiled CSS caches deterministically.
 
 ## Capabilities
 
-- **net `esm.sh`:** loading user-declared Tailwind plugins from CDN at runtime.
+- **filesystem read:** reading the pinned package's `index.css`.
+
+The extension requests no network or filesystem-write capability.
 
 ## Configuration
 
-No factory options. The extension reads no environment variables and takes no config.
+No factory options. Inherited configuration, accessors, and unknown keys are
+rejected. The base stylesheet is local and mandatory; there is no CDN or empty
+stylesheet fallback.

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
+declare global {
+    interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** The absolute path of the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
+         * ```
+         */
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
+    }
+}
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;;;;;;;WAcG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;;;;;;;;;;;WAYG;QACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,CAAC;QACtE;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;;;;;;WAYG;QACH,QAAQ,EAAE,MAAM,CAAC;QAEjB;;;;;;;;;;;;WAYG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB;CACF;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,UAAU,0BAA0B;IAClC,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACxD;AACD,UAAU,0BAA0B;IAClC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AACD,UAAU,kBACR,SAAQ,0BAA0B,EAAE,0BAA0B;CAC/D;AAiBD,eAAO,IAAI,6BAA6B,EA2BnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,6BAA6B,EA4DnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,oBAAoB,EAoB1B,kBAAkB,CAAC"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1,127 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+//@ts-ignore
+import { createRequire } from "node:module";
+//@ts-ignore
+import { fileURLToPath, pathToFileURL } from "node:url";
+//@ts-ignore
+import { dirname } from "node:path";
+const defineGlobalPonyfill = (symbolFor, fn) => {
+    if (!Reflect.has(globalThis, Symbol.for(symbolFor))) {
+        Object.defineProperty(globalThis, Symbol.for(symbolFor), {
+            configurable: true,
+            get() {
+                return fn;
+            },
+        });
+    }
+};
+export let import_meta_ponyfill_commonjs = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ??
+    (() => {
+        const moduleImportMetaWM = new WeakMap();
+        return (require, module) => {
+            let importMetaCache = moduleImportMetaWM.get(module);
+            if (importMetaCache == null) {
+                const importMeta = Object.assign(Object.create(null), {
+                    url: pathToFileURL(module.filename).href,
+                    main: require.main == module,
+                    resolve: (specifier, parentURL = importMeta.url) => {
+                        return pathToFileURL((importMeta.url === parentURL
+                            ? require
+                            : createRequire(parentURL))
+                            .resolve(specifier)).href;
+                    },
+                    filename: module.filename,
+                    dirname: module.path,
+                });
+                moduleImportMetaWM.set(module, importMeta);
+                importMetaCache = importMeta;
+            }
+            return importMetaCache;
+        };
+    })());
+defineGlobalPonyfill("import-meta-ponyfill-commonjs", import_meta_ponyfill_commonjs);
+export let import_meta_ponyfill_esmodule = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ??
+    ((importMeta) => {
+        const resolveFunStr = String(importMeta.resolve);
+        const shimWs = new WeakSet();
+        //@ts-ignore
+        const mainUrl = ("file:///" + (process.argv[1] ?? "").replace(/\\/g, "/"))
+            .replace(/\/{3,}/, "///");
+        const commonShim = (importMeta) => {
+            if (typeof importMeta.main !== "boolean") {
+                importMeta.main = importMeta.url === mainUrl;
+            }
+            if (typeof importMeta.filename !== "string") {
+                importMeta.filename = fileURLToPath(importMeta.url);
+                importMeta.dirname = dirname(importMeta.filename);
+            }
+        };
+        if (
+        // v16.2.0+, v14.18.0+: Add support for WHATWG URL object to parentURL parameter.
+        resolveFunStr === "undefined" ||
+            // v20.0.0+, v18.19.0+"" This API now returns a string synchronously instead of a Promise.
+            resolveFunStr.startsWith("async")
+        // enable by --experimental-import-meta-resolve flag
+        ) {
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    const importMetaUrlRequire = {
+                        url: importMeta.url,
+                        require: createRequire(importMeta.url),
+                    };
+                    importMeta.resolve = function resolve(specifier, parentURL = importMeta.url) {
+                        return pathToFileURL((importMetaUrlRequire.url === parentURL
+                            ? importMetaUrlRequire.require
+                            : createRequire(parentURL)).resolve(specifier)).href;
+                    };
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        else {
+            /// native support
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        return import_meta_ponyfill_esmodule(importMeta);
+    }));
+defineGlobalPonyfill("import-meta-ponyfill-esmodule", import_meta_ponyfill_esmodule);
+export let import_meta_ponyfill = ((...args) => {
+    const _MODULE = (() => {
+        if (typeof require === "function" && typeof module === "object") {
+            return "commonjs";
+        }
+        else {
+            // eval("typeof import.meta");
+            return "esmodule";
+        }
+    })();
+    if (_MODULE === "commonjs") {
+        //@ts-ignore
+        import_meta_ponyfill = (r, m) => import_meta_ponyfill_commonjs(r, m);
+    }
+    else {
+        //@ts-ignore
+        import_meta_ponyfill = (im) => import_meta_ponyfill_esmodule(im);
+    }
+    //@ts-ignore
+    return import_meta_ponyfill(...args);
+});

package/esm/deno.d.ts

@@ -0,0 +1,38 @@
+declare namespace _default {
+    let name: string;
+    let version: string;
+    let exports: string;
+    namespace veryfront {
+        let extension: boolean;
+        let activation: string;
+        namespace contracts {
+            let provides: string[];
+        }
+        namespace npm {
+            let runtimeVersionFromManifest: boolean;
+        }
+        let capabilities: {
+            type: string;
+        }[];
+    }
+    let imports: {
+        "@tailwindcss/forms": string;
+        "@tailwindcss/typography": string;
+        daisyui: string;
+        "tailwind-scrollbar-hide": string;
+        tailwindcss: string;
+        "tailwindcss-animate": string;
+        "tailwindcss/index.css": string;
+        "tailwindcss/package.json": string;
+        "@std/assert": string;
+        "@std/testing/bdd": string;
+        "veryfront/extensions": string;
+        "veryfront/extensions/css": string;
+        "veryfront/errors": string;
+    };
+    namespace tasks {
+        let test: string;
+    }
+}
+export default _default;
+//# sourceMappingURL=deno.d.ts.map

package/esm/deno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.d.ts","sourceRoot":"","sources":["../src/deno.js"],"names":[],"mappings":""}

package/esm/deno.js

@@ -0,0 +1,34 @@
+export default {
+    "name": "@veryfront/ext-css-tailwind",
+    "version": "0.1.0",
+    "exports": "./src/index.ts",
+    "veryfront": {
+        "extension": true,
+        "activation": "explicit",
+        "contracts": {
+            "provides": ["CSSProcessor"]
+        },
+        "npm": {
+            "runtimeVersionFromManifest": true
+        },
+        "capabilities": [{ "type": "fs:read" }]
+    },
+    "imports": {
+        "@tailwindcss/forms": "npm:@tailwindcss/forms@0.5.11",
+        "@tailwindcss/typography": "npm:@tailwindcss/typography@0.5.19",
+        "daisyui": "npm:daisyui@5.5.14",
+        "tailwind-scrollbar-hide": "npm:tailwind-scrollbar-hide@2.0.0",
+        "tailwindcss": "npm:tailwindcss@4.2.2",
+        "tailwindcss-animate": "npm:tailwindcss-animate@1.0.7",
+        "tailwindcss/index.css": "npm:tailwindcss@4.2.2/index.css",
+        "tailwindcss/package.json": "npm:tailwindcss@4.2.2/package.json",
+        "@std/assert": "jsr:@std/assert@1.0.19",
+        "@std/testing/bdd": "jsr:@std/testing@1.0.17/bdd",
+        "veryfront/extensions": "../../src/extensions/index.ts",
+        "veryfront/extensions/css": "../../src/extensions/css/index.ts",
+        "veryfront/errors": "../../src/errors/index.ts"
+    },
+    "tasks": {
+        "test": "deno test --frozen --allow-read src/"
+    }
+};

package/esm/src/index.d.ts

@@ -0,0 +1,14 @@
+/** Tailwind CSS implementation of the provider-neutral CSSProcessor contract. */
+import "../_dnt.polyfills.js";
+import type { ExtensionFactory } from "veryfront/extensions";
+import { type CSSCompiler, type CSSProcessor } from "veryfront/extensions/css";
+export declare const TAILWIND_DEFAULT_STYLESHEET = "@import \"tailwindcss\";\n@plugin \"@tailwindcss/typography\";\n@custom-variant dark (&:is(.dark, [data-theme=\"dark\"]) *, &:is(.dark, [data-theme=\"dark\"]));";
+export declare class TailwindCSSProcessor implements CSSProcessor {
+    readonly cacheIdentity: string;
+    readonly defaultStylesheet = "@import \"tailwindcss\";\n@plugin \"@tailwindcss/typography\";\n@custom-variant dark (&:is(.dark, [data-theme=\"dark\"]) *, &:is(.dark, [data-theme=\"dark\"]));";
+    constructor();
+    compile(stylesheet: string): Promise<CSSCompiler>;
+}
+declare const extTailwind: ExtensionFactory;
+export default extTailwind;
+//# sourceMappingURL=index.d.ts.map

package/esm/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,sBAAsB,CAAC;AAO9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAoB,MAAM,0BAA0B,CAAC;AAoBjG,eAAO,MAAM,2BAA2B,qKAEqD,CAAC;AAqD9F,qBAAa,oBAAqB,YAAW,YAAY;IACvD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,iBAAiB,sKAA+B;;IAenD,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;CA2CxD;AAKD,QAAA,MAAM,WAAW,EAAE,gBAYlB,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/esm/src/index.js

@@ -0,0 +1,150 @@
+/** Tailwind CSS implementation of the provider-neutral CSSProcessor contract. */
+import "../_dnt.polyfills.js";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { isProxy as isProxyWithoutHooks } from "node:util/types";
+import { CSSProcessorName } from "veryfront/extensions/css";
+import { IMPORT_RESOLUTION_ERROR } from "veryfront/errors";
+import { compile } from "tailwindcss";
+import extensionPackage from "../deno.js";
+import { exactTailwindVersion } from "./manifest-dependency.js";
+import { loadPlugin } from "./plugin-loader.js";
+import { TAILWIND_PLUGIN_POLICY_IDENTITY } from "./plugin-policy.js";
+const ENGINE_SEMANTICS_VERSION = "veryfront.css-tailwind.v4";
+const apply = Reflect.apply;
+const arrayJoin = Array.prototype.join;
+const freeze = Object.freeze;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+const getPrototypeOf = Object.getPrototypeOf;
+const isArray = Array.isArray;
+const objectPrototype = Object.prototype;
+const ownKeys = Reflect.ownKeys;
+const requireFromExtension = createRequire(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url);
+const tailwindVersion = exactTailwindVersion(extensionPackage.imports.tailwindcss);
+export const TAILWIND_DEFAULT_STYLESHEET = `@import "tailwindcss";
+@plugin "@tailwindcss/typography";
+@custom-variant dark (&:is(.dark, [data-theme="dark"]) *, &:is(.dark, [data-theme="dark"]));`;
+function sha256(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function loadTailwindBaseStylesheet() {
+    let resolved;
+    try {
+        resolved = requireFromExtension.resolve("tailwindcss/index.css");
+    }
+    catch (cause) {
+        throw IMPORT_RESOLUTION_ERROR.create({
+            detail: "ext-css-tailwind could not resolve its pinned base stylesheet",
+            cause,
+        });
+    }
+    try {
+        return readFileSync(resolved, "utf8");
+    }
+    catch (cause) {
+        throw IMPORT_RESOLUTION_ERROR.create({
+            detail: `ext-css-tailwind could not read its pinned base stylesheet: ${resolved}`,
+            cause,
+        });
+    }
+}
+const tailwindBaseStylesheet = loadTailwindBaseStylesheet();
+function assertEmptyConfig(value) {
+    if (value === undefined)
+        return;
+    if (typeof value !== "object" ||
+        value === null ||
+        isArray(value) ||
+        isProxyWithoutHooks(value)) {
+        throw new TypeError("ext-css-tailwind config must be an object");
+    }
+    let prototype;
+    let keys;
+    try {
+        prototype = getPrototypeOf(value);
+        keys = ownKeys(getOwnPropertyDescriptors(value));
+    }
+    catch (cause) {
+        throw new TypeError("ext-css-tailwind config could not be inspected", { cause });
+    }
+    if (prototype !== objectPrototype && prototype !== null) {
+        throw new TypeError("ext-css-tailwind config must not inherit configuration");
+    }
+    if (keys.length !== 0) {
+        throw new TypeError("ext-css-tailwind does not accept configuration properties");
+    }
+}
+export class TailwindCSSProcessor {
+    cacheIdentity;
+    defaultStylesheet = TAILWIND_DEFAULT_STYLESHEET;
+    constructor() {
+        const identityParts = [
+            ENGINE_SEMANTICS_VERSION,
+            `ext-css-tailwind@${extensionPackage.version}`,
+            `tailwindcss@${tailwindVersion}`,
+            `base=${sha256(tailwindBaseStylesheet)}`,
+            `default=${sha256(this.defaultStylesheet)}`,
+            `plugins=${sha256(TAILWIND_PLUGIN_POLICY_IDENTITY)}`,
+        ];
+        this.cacheIdentity = apply(arrayJoin, identityParts, [";"]);
+        freeze(this);
+    }
+    async compile(stylesheet) {
+        if (typeof stylesheet !== "string") {
+            throw new TypeError("ext-css-tailwind stylesheet must be a string");
+        }
+        const native = await compile(stylesheet, {
+            base: "/",
+            loadStylesheet: (id) => {
+                if (id !== "tailwindcss") {
+                    throw IMPORT_RESOLUTION_ERROR.create({
+                        detail: `ext-css-tailwind cannot resolve stylesheet import "${id}"`,
+                    });
+                }
+                return Promise.resolve({
+                    content: tailwindBaseStylesheet,
+                    base: "/",
+                    path: "/tailwindcss/index.css",
+                });
+            },
+            loadModule: (id) => Promise.resolve({
+                // deno-lint-ignore no-explicit-any -- Tailwind's vendor API accepts opaque plugin modules.
+                module: loadPlugin(id),
+                base: "/",
+                path: "/",
+            }),
+        });
+        const buildDescriptor = getOwnPropertyDescriptor(native, "build");
+        if (buildDescriptor === undefined ||
+            !("value" in buildDescriptor) ||
+            typeof buildDescriptor.value !== "function") {
+            throw IMPORT_RESOLUTION_ERROR.create({
+                detail: "ext-css-tailwind compiler did not expose a stable build method",
+            });
+        }
+        const nativeBuild = buildDescriptor.value;
+        return freeze({
+            build(candidates) {
+                return apply(nativeBuild, native, [candidates]);
+            },
+        });
+    }
+}
+freeze(TailwindCSSProcessor.prototype);
+freeze(TailwindCSSProcessor);
+const extTailwind = (config) => {
+    assertEmptyConfig(config);
+    return {
+        name: "ext-css-tailwind",
+        version: extensionPackage.version,
+        contracts: { provides: [CSSProcessorName] },
+        capabilities: [{ type: "fs:read" }],
+        setup(ctx) {
+            ctx.provide(CSSProcessorName, new TailwindCSSProcessor());
+            ctx.logger.debug(`[ext-css-tailwind] ${CSSProcessorName} registered`);
+        },
+    };
+};
+export default extTailwind;

package/esm/src/manifest-dependency.d.ts

@@ -0,0 +1,3 @@
+/** Resolve Tailwind's exact version from this extension's checked-in manifest. */
+export declare function exactTailwindVersion(specifier: unknown): string;
+//# sourceMappingURL=manifest-dependency.d.ts.map

package/esm/src/manifest-dependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-dependency.d.ts","sourceRoot":"","sources":["../../src/src/manifest-dependency.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAMlF,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAc/D"}

package/esm/src/manifest-dependency.js

@@ -0,0 +1,13 @@
+/** Resolve Tailwind's exact version from this extension's checked-in manifest. */
+const TAILWIND_NPM_PREFIX = "npm:tailwindcss@";
+const EXACT_SEMVER_PATTERN = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:(?:0|[1-9]\d*)|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:(?:0|[1-9]\d*)|\d*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+export function exactTailwindVersion(specifier) {
+    if (typeof specifier !== "string" || !specifier.startsWith(TAILWIND_NPM_PREFIX)) {
+        throw new TypeError("ext-css-tailwind imports.tailwindcss must target npm:tailwindcss at an exact semantic version");
+    }
+    const version = specifier.slice(TAILWIND_NPM_PREFIX.length);
+    if (!EXACT_SEMVER_PATTERN.test(version)) {
+        throw new TypeError("ext-css-tailwind imports.tailwindcss must use an exact semantic version without a range or subpath");
+    }
+    return version;
+}

package/esm/src/plugin-loader.d.ts

@@ -0,0 +1,7 @@
+/** Static plugin loading owned entirely by ext-css-tailwind. */
+/**
+ * Resolve an audited plugin from the extension's immutable local registry.
+ * Unknown packages and version overrides fail before Tailwind receives a value.
+ */
+export declare function loadPlugin(id: string): unknown;
+//# sourceMappingURL=plugin-loader.d.ts.map

package/esm/src/plugin-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-loader.d.ts","sourceRoot":"","sources":["../../src/src/plugin-loader.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAsEhE;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAK9C"}

package/esm/src/plugin-loader.js

@@ -0,0 +1,68 @@
+/** Static plugin loading owned entirely by ext-css-tailwind. */
+import forms from "@tailwindcss/forms";
+import typography from "@tailwindcss/typography";
+import daisyui from "daisyui";
+import scrollbarHide from "tailwind-scrollbar-hide";
+import tailwindcssAnimate from "tailwindcss-animate";
+import { IMPORT_RESOLUTION_ERROR, SECURITY_VIOLATION } from "veryfront/errors";
+import { bareName, resolveTailwindPluginPolicy, TAILWIND_PLUGIN_ALLOWLIST, } from "./plugin-policy.js";
+function getStaticPlugin(name) {
+    switch (name) {
+        case "@tailwindcss/forms":
+            return forms;
+        case "@tailwindcss/typography":
+            return typography;
+        case "daisyui":
+            return daisyui;
+        case "tailwind-scrollbar-hide":
+            return scrollbarHide;
+        case "tailwindcss-animate":
+            return tailwindcssAnimate;
+        default:
+            throw IMPORT_RESOLUTION_ERROR.create({
+                detail: `Tailwind plugin "${name}" is absent from the static extension registry`,
+            });
+    }
+}
+function requirePinnedPlugin(specifier) {
+    try {
+        return resolveTailwindPluginPolicy(specifier).name;
+    }
+    catch (cause) {
+        const displayName = typeof specifier === "string" ? bareName(specifier) : "<non-string>";
+        throw SECURITY_VIOLATION.create({
+            detail: `Package "${displayName}" is not an audited ext-css-tailwind plugin`,
+            cause,
+        });
+    }
+}
+function assertStaticPlugin(name, value) {
+    if (typeof value !== "function" &&
+        (typeof value !== "object" || value === null)) {
+        throw IMPORT_RESOLUTION_ERROR.create({
+            detail: `Tailwind plugin "${name}" did not export a plugin value`,
+        });
+    }
+}
+function assertCompleteStaticRegistry() {
+    for (let index = 0; index < TAILWIND_PLUGIN_ALLOWLIST.length; index++) {
+        const name = TAILWIND_PLUGIN_ALLOWLIST[index];
+        if (name === undefined) {
+            throw IMPORT_RESOLUTION_ERROR.create({
+                detail: "ext-css-tailwind plugin policy contains an invalid entry",
+            });
+        }
+        assertStaticPlugin(name, getStaticPlugin(name));
+    }
+}
+assertCompleteStaticRegistry();
+/**
+ * Resolve an audited plugin from the extension's immutable local registry.
+ * Unknown packages and version overrides fail before Tailwind receives a value.
+ */
+export function loadPlugin(id) {
+    const name = requirePinnedPlugin(id);
+    const plugin = getStaticPlugin(name);
+    assertStaticPlugin(name, plugin);
+    return plugin;
+}

package/esm/src/plugin-policy.d.ts

@@ -0,0 +1,24 @@
+/** Audited local plugin policy owned by ext-css-tailwind. */
+export type TailwindPluginPolicyEntry = Readonly<{
+    name: string;
+    version: string;
+    importSpecifier: string;
+    npmSpecifier: string;
+}>;
+/**
+ * Complete immutable inventory of third-party plugin implementations shipped
+ * by this extension. Each entry must have a matching exact import-map target
+ * and a static import in `plugin-loader.ts`.
+ */
+export declare const TAILWIND_PLUGIN_POLICY: readonly Readonly<{
+    name: string;
+    version: string;
+    importSpecifier: string;
+    npmSpecifier: string;
+}>[];
+export declare const PACKAGE_SPEC_RE: Readonly<RegExp>;
+export declare function bareName(specifier: string): string;
+export declare const TAILWIND_PLUGIN_ALLOWLIST: readonly string[];
+export declare function resolveTailwindPluginPolicy(specifier: string): TailwindPluginPolicyEntry;
+export declare const TAILWIND_PLUGIN_POLICY_IDENTITY: string;
+//# sourceMappingURL=plugin-policy.d.ts.map

package/esm/src/plugin-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-policy.d.ts","sourceRoot":"","sources":["../../src/src/plugin-policy.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAE7D,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC,CAAC;AA2BH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;UApC3B,MAAM;aACH,MAAM;qBACE,MAAM;kBACT,MAAM;IAuCpB,CAAC;AAEH,eAAO,MAAM,eAAe,kBAE3B,CAAC;AAEF,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAUlD;AAaD,eAAO,MAAM,yBAAyB,mBAAoB,CAAC;AAE3D,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,GAChB,yBAAyB,CAqB3B;AAsBD,eAAO,MAAM,+BAA+B,EAIrC,MAAM,CAAC"}

package/esm/src/plugin-policy.js

@@ -0,0 +1,86 @@
+/** Audited local plugin policy owned by ext-css-tailwind. */
+const apply = Reflect.apply;
+const MapConstructor = Map;
+const NativeTypeError = TypeError;
+const arrayMap = Array.prototype.map;
+const arraySort = Array.prototype.sort;
+const freeze = Object.freeze;
+const jsonStringify = JSON.stringify;
+const mapGet = Map.prototype.get;
+const regexpExec = RegExp.prototype.exec;
+const stringIndexOf = String.prototype.indexOf;
+const stringSlice = String.prototype.slice;
+const stringStartsWith = String.prototype.startsWith;
+function definePlugin(name, version) {
+    return freeze({
+        name,
+        version,
+        importSpecifier: name,
+        npmSpecifier: `npm:${name}@${version}`,
+    });
+}
+/**
+ * Complete immutable inventory of third-party plugin implementations shipped
+ * by this extension. Each entry must have a matching exact import-map target
+ * and a static import in `plugin-loader.ts`.
+ */
+export const TAILWIND_PLUGIN_POLICY = freeze([
+    definePlugin("tailwindcss-animate", "1.0.7"),
+    definePlugin("@tailwindcss/typography", "0.5.19"),
+    definePlugin("@tailwindcss/forms", "0.5.11"),
+    definePlugin("tailwind-scrollbar-hide", "2.0.0"),
+    definePlugin("daisyui", "5.5.14"),
+]);
+export const PACKAGE_SPEC_RE = freeze(/^(?:@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(?:@[\w.+-]+)?$/);
+export function bareName(specifier) {
+    if (typeof specifier !== "string") {
+        throw new NativeTypeError("Tailwind plugin specifier must be a string");
+    }
+    if (apply(stringStartsWith, specifier, ["@"])) {
+        const index = apply(stringIndexOf, specifier, ["@", 1]);
+        return index === -1 ? specifier : apply(stringSlice, specifier, [0, index]);
+    }
+    const index = apply(stringIndexOf, specifier, ["@"]);
+    return index === -1 ? specifier : apply(stringSlice, specifier, [0, index]);
+}
+const POLICY_BY_NAME = new MapConstructor(apply(arrayMap, TAILWIND_PLUGIN_POLICY, [
+    (entry) => [entry.name, entry],
+]));
+/** Immutable public view of the packages this extension can load. */
+const allowlist = apply(arrayMap, TAILWIND_PLUGIN_POLICY, [
+    (entry) => entry.name,
+]);
+apply(arraySort, allowlist, []);
+export const TAILWIND_PLUGIN_ALLOWLIST = freeze(allowlist);
+export function resolveTailwindPluginPolicy(specifier) {
+    if (typeof specifier !== "string" ||
+        apply(regexpExec, PACKAGE_SPEC_RE, [specifier]) === null) {
+        throw new NativeTypeError(`Invalid Tailwind plugin specifier: ${specifier}`);
+    }
+    const name = bareName(specifier);
+    const policy = apply(mapGet, POLICY_BY_NAME, [name]);
+    if (policy === undefined) {
+        throw new NativeTypeError(`Tailwind plugin is not allowlisted: ${name}`);
+    }
+    const pinnedSpecifier = `${policy.name}@${policy.version}`;
+    if (specifier !== name && specifier !== pinnedSpecifier) {
+        throw new NativeTypeError(`Tailwind plugin ${name} must use the audited version ${pinnedSpecifier}`);
+    }
+    return policy;
+}
+const identityPlugins = apply(arrayMap, TAILWIND_PLUGIN_POLICY, [
+    (entry) => ({
+        name: entry.name,
+        version: entry.version,
+        importSpecifier: entry.importSpecifier,
+        npmSpecifier: entry.npmSpecifier,
+    }),
+]);
+apply(arraySort, identityPlugins, [
+    (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0,
+]);
+export const TAILWIND_PLUGIN_POLICY_IDENTITY = apply(jsonStringify, JSON, [{
+        schema: "veryfront.tailwind-plugin-policy.v3",
+        resolution: "extension-owned-static-npm-imports",
+        plugins: identityPlugins,
+    }]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-css-tailwind",
-  "version": "0.1.1185",
+  "version": "0.1.1188",
   "description": "Veryfront first-party extension package for ext-css-tailwind",
   "keywords": [
     "veryfront",
@@ -18,47 +18,50 @@
   "bugs": {
     "url": "https://github.com/veryfront/veryfront-code/issues"
   },
-  "module": "./esm/index.js",
+  "module": "./esm/src/index.js",
   "exports": {
     ".": {
-      "import": "./esm/index.js",
-      "types": "./esm/index.d.ts"
+      "import": "./esm/src/index.js",
+      "types": "./esm/src/index.d.ts"
     }
   },
   "scripts": {},
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.3.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "veryfront": {
     "extension": true,
+    "activation": "explicit",
     "contracts": {
       "provides": [
         "CSSProcessor"
       ]
     },
+    "npm": {
+      "runtimeVersionFromManifest": true
+    },
     "capabilities": [
       {
-        "type": "net:outbound",
-        "hosts": [
-          "esm.sh"
-        ]
+        "type": "fs:read"
       }
     ]
   },
   "dependencies": {
-    "@deno/shim-deno": "~0.18.0",
-    "@deno/shim-crypto": "~0.3.1",
-    "@deno/shim-timers": "~0.1.0",
-    "tailwindcss": "4.2.2"
+    "@tailwindcss/forms": "0.5.11",
+    "@tailwindcss/typography": "0.5.19",
+    "daisyui": "5.5.14",
+    "tailwind-scrollbar-hide": "2.0.0",
+    "tailwindcss": "4.2.2",
+    "tailwindcss-animate": "1.0.7"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1185"
+    "veryfront": "^0.1.1188"
   },
   "type": "module",
-  "types": "./esm/index.d.ts",
+  "types": "./esm/src/index.d.ts",
   "files": [
     "esm",
     "LICENSE",

package/esm/_dnt.shims.d.ts

@@ -1,11 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
-export { setInterval, setTimeout } from "@deno/shim-timers";
-export declare const dntGlobalThis: Omit<typeof globalThis, "Deno" | "crypto" | "setInterval" | "setTimeout"> & {
-    Deno: typeof Deno;
-    crypto: import("@deno/shim-crypto").Crypto;
-    setInterval: any;
-    setTimeout: any;
-};
-//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAE,KAAK,UAAU,EAAE,KAAK,uBAAuB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,KAAK,qBAAqB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErvB,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQ5D,eAAO,MAAM,aAAa;;;;;CAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -1,68 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-import { crypto } from "@deno/shim-crypto";
-export { crypto } from "@deno/shim-crypto";
-import { setInterval, setTimeout } from "@deno/shim-timers";
-export { setInterval, setTimeout } from "@deno/shim-timers";
-const dntGlobals = {
-    Deno,
-    crypto,
-    setInterval,
-    setTimeout,
-};
-export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-function createMergeProxy(baseObj, extObj) {
-    return new Proxy(baseObj, {
-        get(_target, prop, _receiver) {
-            if (prop in extObj) {
-                return extObj[prop];
-            }
-            else {
-                return baseObj[prop];
-            }
-        },
-        set(_target, prop, value) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            baseObj[prop] = value;
-            return true;
-        },
-        deleteProperty(_target, prop) {
-            let success = false;
-            if (prop in extObj) {
-                delete extObj[prop];
-                success = true;
-            }
-            if (prop in baseObj) {
-                delete baseObj[prop];
-                success = true;
-            }
-            return success;
-        },
-        ownKeys(_target) {
-            const baseKeys = Reflect.ownKeys(baseObj);
-            const extKeys = Reflect.ownKeys(extObj);
-            const extKeysSet = new Set(extKeys);
-            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
-        },
-        defineProperty(_target, prop, desc) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            Reflect.defineProperty(baseObj, prop, desc);
-            return true;
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            if (prop in extObj) {
-                return Reflect.getOwnPropertyDescriptor(extObj, prop);
-            }
-            else {
-                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
-            }
-        },
-        has(_target, prop) {
-            return prop in extObj || prop in baseObj;
-        },
-    });
-}

package/esm/index.d.ts

@@ -1,9 +0,0 @@
-import type { ExtensionFactory } from "veryfront/extensions";
-import type { CSSCompileOptions, CSSCompiler, CSSProcessor } from "veryfront/extensions/css";
-declare class TailwindCSSProcessor implements CSSProcessor {
-    compile(stylesheet: string, options: CSSCompileOptions): Promise<CSSCompiler>;
-}
-declare const extTailwind: ExtensionFactory;
-export default extTailwind;
-export { TailwindCSSProcessor };
-//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAgB7F,cAAM,oBAAqB,YAAW,YAAY;IAC1C,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,CAAC;CAgBpF;AAED,QAAA,MAAM,WAAW,EAAE,gBAsBlB,CAAC;AAEF,eAAe,WAAW,CAAC;AAC3B,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/esm/index.js

@@ -1,71 +0,0 @@
-/**
- * ext-css-tailwind — CSSProcessor implementation backed by Tailwind CSS v4.
- *
- * Provides the `CSSProcessor` contract:
- *  - `compile(stylesheet, options)` — delegates to tailwindcss `compile()`
- *    and returns a compiler whose `build(candidates)` emits CSS for the
- *    class-name candidates discovered at render time.
- *
- * The extension also installs three `globalThis` shims on setup so that
- * Tailwind plugin bundles loaded at runtime from esm.sh can bind their
- * `tailwindcss/plugin`, `tailwindcss/defaultTheme`, and `tailwindcss/colors`
- * imports to the same tailwindcss copy this extension ships. Core's
- * `plugin-loader.ts` rewrites plugin bundle code to reference these shims
- * by name; without the shims installed, dynamic plugin loading fails.
- *
- * @module extensions/ext-css-tailwind
- */
-import * as dntShim from "./_dnt.shims.js";
-import { compile } from "tailwindcss";
-import plugin from "tailwindcss/plugin";
-import defaultTheme from "tailwindcss/defaultTheme";
-import colors from "tailwindcss/colors";
-function installTailwindPluginShims() {
-    const g = dntShim.dntGlobalThis;
-    g.__tailwindPluginShim = { default: plugin, __esModule: true };
-    g.__tailwindDefaultThemeShim = { default: defaultTheme, __esModule: true };
-    g.__tailwindColorsShim = { default: colors, __esModule: true };
-}
-class TailwindCSSProcessor {
-    async compile(stylesheet, options) {
-        const native = await compile(stylesheet, {
-            base: options.base,
-            loadStylesheet: options.loadStylesheet,
-            loadModule: async (id) => {
-                const loaded = await options.loadModule(id);
-                // deno-lint-ignore no-explicit-any -- loaded plugin modules are opaque to the contract
-                return { module: loaded.module, base: loaded.base, path: loaded.path };
-            },
-        });
-        return {
-            build(candidates) {
-                return native.build(candidates);
-            },
-        };
-    }
-}
-const extTailwind = () => {
-    const impl = new TailwindCSSProcessor();
-    return {
-        name: "ext-css-tailwind",
-        version: "0.1.0",
-        contracts: {
-            provides: ["CSSProcessor"],
-        },
-        capabilities: [
-            { type: "net:outbound", hosts: ["esm.sh"] },
-        ],
-        setup(ctx) {
-            installTailwindPluginShims();
-            ctx.provide("CSSProcessor", impl);
-            ctx.logger.debug("[ext-css-tailwind] CSSProcessor registered");
-        },
-        teardown() {
-            // Shims stay installed — removing them could break in-flight plugin
-            // loads. The globalThis pollution is intentional and scoped to keys
-            // with `__tailwind` prefix.
-        },
-    };
-};
-export default extTailwind;
-export { TailwindCSSProcessor };