@animus-ui/layergate 0.0.0-stage → 0.1.35

package/dist/webpack-state-DwltSkQq.mjs

@@ -0,0 +1,44 @@
+import { dirname, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/webpack-state.ts
+/**
+* What the webpack plugin and its loader share. webpack loads the loader
+* from its own file, a module instance apart from the plugin's, so the
+* state is kept on `globalThis`, by plugin id.
+*/
+/** CSS resolution as css-loader resolves an `@import`: the `style`
+*  condition alone, its fields, CSS files only, relative first. */
+const CSS_RESOLVE = {
+	conditionNames: ["style"],
+	mainFields: [
+		"css",
+		"style",
+		"main",
+		"..."
+	],
+	mainFiles: ["index", "..."],
+	extensions: [".css"],
+	restrictions: [/\.css$/i],
+	preferRelative: true
+};
+const KEY = Symbol.for("@animus-ui/layergate/webpack");
+function registry() {
+	const global = globalThis;
+	return global[KEY] ??= {
+		states: /* @__PURE__ */ new Map(),
+		made: 0
+	};
+}
+const here = dirname(fileURLToPath(import.meta.url));
+/** The loader's file: the built one beside this module, or the source in
+*  the workspace. */
+function loaderPath() {
+	for (const built of ["webpack-loader.cjs", "webpack-loader.mjs"]) {
+		const path = resolve(here, built);
+		if (existsSync(path)) return path;
+	}
+	return resolve(here, "webpack-loader.ts");
+}
+//#endregion
+export { loaderPath as n, registry as r, CSS_RESOLVE as t };

package/dist/webpack.cjs

@@ -0,0 +1,161 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_plan = require("./plan-hvk04qzh.cjs");
+const require_host = require("./host-C4ZaMdkx.cjs");
+const require_webpack_state = require("./webpack-state-BtmtzsWZ.cjs");
+//#region src/webpack.ts
+/**
+* The webpack adapter. The plugin inserts layergate's loader into every
+* existing global-CSS loader chain (one with a css-loader that is not a
+* CSS Modules one), so it runs on each stylesheet before PostCSS and
+* css-loader, imported ones too: css-loader's `importLoaders` is raised by
+* one, on a copy of its options. No rule is added. For an owned graph the
+* loader resolves and inlines every `@import` itself and returns finished
+* CSS with no local import, so css-loader has nothing left to resolve and
+* a `layer()` condition never reaches its import parser.
+*/
+const NAME = "layergate";
+const CSS_LOADER = /(?:^|[\\/])css-loader(?:[\\/]|$)/;
+const POSTCSS_LOADER = /(?:^|[\\/])postcss-loader(?:[\\/]|$)/;
+const LIGHTNINGCSS_LOADER = /lightningcss-loader/;
+const NEXT_FONT_LOADER = /next-font/;
+const loaderOf = (entry) => entry instanceof Object ? entry.loader ?? "" : entry;
+/** Whether css-loader with `options` reads every stylesheet as a CSS
+*  Module or ICSS sheet: `modules` true, a mode name, or an object
+*  without `auto`; or `icss: true`. */
+function allModules({ modules, icss }) {
+	if (icss === true || modules === true) return true;
+	if (Object.prototype.toString.call(modules) === "[object String]") return true;
+	return modules instanceof Object && !(modules instanceof Function) && !("auto" in modules && modules.auto !== void 0);
+}
+/**
+* Inserts `entry` into every loader chain of `rules` whose css-loader is
+* explicitly global (`modules: false`, as Next's global chains are): just
+* before PostCSS runs (after it in `use`), or before css-loader without
+* PostCSS. A chain whose css-loader decides per file whether a stylesheet
+* is a CSS Module (`modules` unset or `auto`) is left alone, and reported:
+* layergate never predicts that decision.
+*/
+function insertLoader(rules, entry, prefix = "module.rules") {
+	const coverage = {
+		wrapped: 0,
+		skipped: []
+	};
+	for (const [index, candidate] of rules.entries()) {
+		if (!(candidate instanceof Object)) continue;
+		const rule = candidate;
+		const place = `${prefix}[${index}]`;
+		for (const [key, nested] of [["oneOf", rule.oneOf], ["rules", rule.rules]]) {
+			if (!Array.isArray(nested)) continue;
+			const counts = insertLoader(nested, entry, `${place}.${key}`);
+			coverage.wrapped += counts.wrapped;
+			coverage.skipped.push(...counts.skipped);
+		}
+		if (!Array.isArray(rule.use)) continue;
+		const use = rule.use;
+		const loaders = use.map(loaderOf);
+		if (loaders.includes(entry.loader)) continue;
+		if (loaders.some((loader) => NEXT_FONT_LOADER.test(loader))) continue;
+		const css = loaders.findIndex((loader) => CSS_LOADER.test(loader));
+		if (css === -1) {
+			if (loaders.some((loader) => LIGHTNINGCSS_LOADER.test(loader))) coverage.skipped.push(`${place} is not layered: it uses Lightning CSS, not css-loader`);
+			continue;
+		}
+		const cssEntry = use[css];
+		const options = cssEntry instanceof Object ? cssEntry.options ?? {} : {};
+		if (allModules(options)) continue;
+		if (options.modules !== false) {
+			coverage.skipped.push(`${place} is not layered: its css-loader is not \`modules: false\`. Give global CSS a rule with \`modules: false\`, or opt out`);
+			continue;
+		}
+		const postcss = loaders.findIndex((loader) => POSTCSS_LOADER.test(loader));
+		const at = (postcss === -1 ? css : postcss) + 1;
+		rule.use = [
+			...use.slice(0, css),
+			{
+				loader: loaderOf(cssEntry),
+				options: {
+					...options,
+					importLoaders: (options.importLoaders ?? 0) + 1
+				}
+			},
+			...use.slice(css + 1, at),
+			entry,
+			...use.slice(at)
+		];
+		coverage.wrapped += 1;
+	}
+	return coverage;
+}
+/** What `specifier` resolves to from `context`, as webpack resolves it
+*  (by realpath unless `resolve.symlinks` is false), or null. */
+const resolveOne = (resolver, context, specifier) => new Promise((done) => resolver.resolve({}, context, specifier, {}, (error, result) => done(error || !result ? null : require_host.slashes(result))));
+var LayergatePlugin = class {
+	id;
+	state;
+	watchIgnored;
+	constructor(options = {}) {
+		const shared = require_webpack_state.registry();
+		this.id = `layergate-${process.pid}-${shared.made++}`;
+		this.watchIgnored = options.watchIgnored !== false;
+		const plan = require_plan.resolvePlan(options);
+		this.state = {
+			plan,
+			owner: require_host.ownership(plan),
+			optedOut: /* @__PURE__ */ new Set(),
+			declaredBy: options.declaredBy ? require_host.real(options.declaredBy) : null,
+			roots: [],
+			units: new require_host.Units()
+		};
+		shared.states.set(this.id, this.state);
+	}
+	/** Whether `path` is a file a finished stylesheet read: one the watcher
+	*  must see, wherever it lies. The watcher asks of every path it scans,
+	*  so this reads no file system: webpack watches the resolved paths the
+	*  loader reported. */
+	watches(path) {
+		return this.state.units.reads(require_host.slashes(path));
+	}
+	apply(compiler) {
+		const { wrapped, skipped } = insertLoader(compiler.options.module.rules, {
+			loader: require_webpack_state.loaderPath(),
+			options: { id: this.id }
+		});
+		compiler.hooks.thisCompilation.tap(NAME, (compilation) => {
+			for (const reason of skipped) compilation.warnings.push(/* @__PURE__ */ new Error(`[layergate] ${reason} [layergate.coverage]`));
+			if (wrapped === 0 && skipped.length === 0 && this.state.owner.owning()) compilation.warnings.push(/* @__PURE__ */ new Error("[layergate] no CSS loader chain with a css-loader was found: nothing is layered [layergate.coverage]"));
+		});
+		if (this.watchIgnored) this.watchOwned(compiler);
+		const prepare = async () => {
+			const resolver = compiler.resolverFactory.get("normal", require_webpack_state.CSS_RESOLVE);
+			const resolve = (specifier) => resolveOne(resolver, compiler.context, specifier);
+			const { sheets, optOut } = this.state.plan;
+			const [declared, optedOut] = await Promise.all([require_host.resolveEach(sheets, "sheets", compiler.context, resolve), require_host.resolveEach(optOut, "optOut", compiler.context, resolve)]);
+			this.state.roots = declared;
+			this.state.owner.reset(compiler.context, declared.map(require_host.real));
+			this.state.optedOut = new Set(optedOut.map(require_host.real));
+		};
+		compiler.hooks.beforeRun.tapPromise(NAME, prepare);
+		compiler.hooks.watchRun.tapPromise(NAME, async () => {
+			for (const path of compiler.modifiedFiles ?? []) this.state.units.changed(require_host.slashes(path));
+			for (const path of compiler.removedFiles ?? []) this.state.units.changed(require_host.slashes(path));
+			await prepare();
+		});
+		compiler.hooks.shutdown.tap(NAME, () => require_webpack_state.registry().states.delete(this.id));
+	}
+	/** Makes the host's `watchOptions.ignored` watch every file a finished
+	*  stylesheet read. */
+	watchOwned(compiler) {
+		const watchOptions = compiler.options.watchOptions ??= {};
+		const ignored = watchOptions.ignored;
+		const ignores = ignored instanceof RegExp ? (path) => ignored.test(path) : ignored instanceof Function ? (path) => Boolean(ignored(path)) : null;
+		if (!ignores) return;
+		watchOptions.ignored = (path) => ignores(path) && !this.watches(path);
+	}
+};
+//#endregion
+exports.LayergatePlugin = LayergatePlugin;
+exports.default = LayergatePlugin;
+exports.insertLoader = insertLoader;

package/dist/webpack.d.cts

@@ -0,0 +1,98 @@
+import { n as LayergateOptions } from "./plan-w-y0limy.cjs";
+import { t as CSS_RESOLVE } from "./webpack-state-BpF2PPjA.cjs";
+//#region src/webpack.d.ts
+export interface LayergateWebpackOptions extends LayergateOptions {
+  /** A stylesheet (a file path) whose head delivers the declared sheets,
+   *  finished, in order; a module's own import of a declared sheet then
+   *  loads nothing, so each arrives once. Without one, a declared sheet
+   *  is owned wherever it is imported. */
+  declaredBy?: string;
+  /** Whether the plugin makes `watchOptions.ignored` (a RegExp or a
+   *  function) watch the owned files it reads, those under node_modules
+   *  too. A host that owns the watcher passes false and asks `watches`.
+   *  Default true. */
+  watchIgnored?: boolean;
+}
+/** The loader entry the plugin inserts. */
+export interface LoaderEntry {
+  loader: string;
+  options: {
+    id: string;
+  };
+}
+/** How many loader chains `insertLoader` wrapped, and why it left each
+ *  chain it could not wrap, by the chain's place in the rules. */
+export interface Coverage {
+  wrapped: number;
+  skipped: string[];
+}
+/** What webpack's resolver is handed besides the request: nothing the
+ *  plugin sets. */
+type ResolveContext = Record<string, never>;
+interface Resolver {
+  resolve(context: ResolveContext, path: string, request: string, resolveContext: ResolveContext, callback: (error: Error | null, result?: string | false) => void): void;
+}
+/** A compilation, as far as the plugin reads it. */
+interface Compilation {
+  warnings: Error[];
+  errors: Error[];
+}
+/** The compiler, as far as the plugin reads it. */
+export interface Compiler {
+  context: string;
+  /** What changed since the last compile, in watch mode. */
+  modifiedFiles?: ReadonlySet<string>;
+  removedFiles?: ReadonlySet<string>;
+  options: {
+    module: {
+      rules: unknown[];
+    };
+    watchOptions?: {
+      ignored?: unknown;
+    };
+  };
+  resolverFactory: {
+    get(type: string, options: typeof CSS_RESOLVE): Resolver;
+  };
+  hooks: {
+    beforeRun: {
+      tapPromise(name: string, run: () => Promise<void>): void;
+    };
+    watchRun: {
+      tapPromise(name: string, run: () => Promise<void>): void;
+    };
+    thisCompilation: {
+      tap(name: string, run: (compilation: Compilation) => void): void;
+    };
+    shutdown: {
+      tap(name: string, run: () => void): void;
+    };
+  };
+}
+/**
+ * Inserts `entry` into every loader chain of `rules` whose css-loader is
+ * explicitly global (`modules: false`, as Next's global chains are): just
+ * before PostCSS runs (after it in `use`), or before css-loader without
+ * PostCSS. A chain whose css-loader decides per file whether a stylesheet
+ * is a CSS Module (`modules` unset or `auto`) is left alone, and reported:
+ * layergate never predicts that decision.
+ */
+export declare function insertLoader(rules: unknown[], entry: LoaderEntry, prefix?: string): Coverage;
+export declare class LayergatePlugin {
+  readonly id: string;
+  private readonly state;
+  private readonly watchIgnored;
+  constructor(options?: LayergateWebpackOptions);
+  /** Whether `path` is a file a finished stylesheet read: one the watcher
+   *  must see, wherever it lies. The watcher asks of every path it scans,
+   *  so this reads no file system: webpack watches the resolved paths the
+   *  loader reported. */
+  watches(path: string): boolean;
+  apply(compiler: Compiler): void;
+  /** Makes the host's `watchOptions.ignored` watch every file a finished
+   *  stylesheet read. */
+  private watchOwned;
+}
+//#endregion
+export { type LayergateOptions, LayergatePlugin as default };
+//# sourceMappingURL=webpack.d.cts.map

package/dist/webpack.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.d.cts","names":[],"sources":["../src/webpack.ts"],"mappings":";;;iBAmBiB,gCAAgC;;;;;EAK/C;;;;;EAKA;;;iBAOe;EACf;EACA;IAAW;;;;;iBAoBI;EACf;EACA;;;;KAKG,iBAAiB;UAEZ;EACR,QACE,SAAS,gBACT,cACA,iBACA,gBAAgB,gBAChB,WAAW,OAAO,cAAc;;;UAK1B;EACR,UAAU;EACV,QAAQ;;;iBAIO;EACf;;EAEA,gBAAgB;EAChB,eAAe;EACf;IACE;MAAU;;IACV;MAAiB;;;EAEnB;IACE,IAAI,cAAc,gBAAgB,cAAc;;EAElD;IACE;MACE,WAAW,cAAc,WAAW;;IAEtC;MACE,WAAW,cAAc,WAAW;;IAEtC;MACE,IAAI,cAAc,MAAM,aAAa;;IAEvC;MACE,IAAI,cAAc;;;;;;;;;;;;wBAqCR,aACd,kBACA,OAAO,aACP,kBACC;qBAwEU;WACF;mBACQ;mBACA;EAEjB,YAAY,UAAS;;;;;EAoBrB,QAAQ;EAIR,MAAM,UAAU;;;UAuDR"}

package/dist/webpack.d.mts

@@ -0,0 +1,98 @@
+import { n as LayergateOptions } from "./plan-w-y0limy.mjs";
+import { t as CSS_RESOLVE } from "./webpack-state-CXoQQ7XR.mjs";
+//#region src/webpack.d.ts
+export interface LayergateWebpackOptions extends LayergateOptions {
+  /** A stylesheet (a file path) whose head delivers the declared sheets,
+   *  finished, in order; a module's own import of a declared sheet then
+   *  loads nothing, so each arrives once. Without one, a declared sheet
+   *  is owned wherever it is imported. */
+  declaredBy?: string;
+  /** Whether the plugin makes `watchOptions.ignored` (a RegExp or a
+   *  function) watch the owned files it reads, those under node_modules
+   *  too. A host that owns the watcher passes false and asks `watches`.
+   *  Default true. */
+  watchIgnored?: boolean;
+}
+/** The loader entry the plugin inserts. */
+export interface LoaderEntry {
+  loader: string;
+  options: {
+    id: string;
+  };
+}
+/** How many loader chains `insertLoader` wrapped, and why it left each
+ *  chain it could not wrap, by the chain's place in the rules. */
+export interface Coverage {
+  wrapped: number;
+  skipped: string[];
+}
+/** What webpack's resolver is handed besides the request: nothing the
+ *  plugin sets. */
+type ResolveContext = Record<string, never>;
+interface Resolver {
+  resolve(context: ResolveContext, path: string, request: string, resolveContext: ResolveContext, callback: (error: Error | null, result?: string | false) => void): void;
+}
+/** A compilation, as far as the plugin reads it. */
+interface Compilation {
+  warnings: Error[];
+  errors: Error[];
+}
+/** The compiler, as far as the plugin reads it. */
+export interface Compiler {
+  context: string;
+  /** What changed since the last compile, in watch mode. */
+  modifiedFiles?: ReadonlySet<string>;
+  removedFiles?: ReadonlySet<string>;
+  options: {
+    module: {
+      rules: unknown[];
+    };
+    watchOptions?: {
+      ignored?: unknown;
+    };
+  };
+  resolverFactory: {
+    get(type: string, options: typeof CSS_RESOLVE): Resolver;
+  };
+  hooks: {
+    beforeRun: {
+      tapPromise(name: string, run: () => Promise<void>): void;
+    };
+    watchRun: {
+      tapPromise(name: string, run: () => Promise<void>): void;
+    };
+    thisCompilation: {
+      tap(name: string, run: (compilation: Compilation) => void): void;
+    };
+    shutdown: {
+      tap(name: string, run: () => void): void;
+    };
+  };
+}
+/**
+ * Inserts `entry` into every loader chain of `rules` whose css-loader is
+ * explicitly global (`modules: false`, as Next's global chains are): just
+ * before PostCSS runs (after it in `use`), or before css-loader without
+ * PostCSS. A chain whose css-loader decides per file whether a stylesheet
+ * is a CSS Module (`modules` unset or `auto`) is left alone, and reported:
+ * layergate never predicts that decision.
+ */
+export declare function insertLoader(rules: unknown[], entry: LoaderEntry, prefix?: string): Coverage;
+export declare class LayergatePlugin {
+  readonly id: string;
+  private readonly state;
+  private readonly watchIgnored;
+  constructor(options?: LayergateWebpackOptions);
+  /** Whether `path` is a file a finished stylesheet read: one the watcher
+   *  must see, wherever it lies. The watcher asks of every path it scans,
+   *  so this reads no file system: webpack watches the resolved paths the
+   *  loader reported. */
+  watches(path: string): boolean;
+  apply(compiler: Compiler): void;
+  /** Makes the host's `watchOptions.ignored` watch every file a finished
+   *  stylesheet read. */
+  private watchOwned;
+}
+//#endregion
+export { type LayergateOptions, LayergatePlugin as default };
+//# sourceMappingURL=webpack.d.mts.map

package/dist/webpack.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.d.mts","names":[],"sources":["../src/webpack.ts"],"mappings":";;;iBAmBiB,gCAAgC;;;;;EAK/C;;;;;EAKA;;;iBAOe;EACf;EACA;IAAW;;;;;iBAoBI;EACf;EACA;;;;KAKG,iBAAiB;UAEZ;EACR,QACE,SAAS,gBACT,cACA,iBACA,gBAAgB,gBAChB,WAAW,OAAO,cAAc;;;UAK1B;EACR,UAAU;EACV,QAAQ;;;iBAIO;EACf;;EAEA,gBAAgB;EAChB,eAAe;EACf;IACE;MAAU;;IACV;MAAiB;;;EAEnB;IACE,IAAI,cAAc,gBAAgB,cAAc;;EAElD;IACE;MACE,WAAW,cAAc,WAAW;;IAEtC;MACE,WAAW,cAAc,WAAW;;IAEtC;MACE,IAAI,cAAc,MAAM,aAAa;;IAEvC;MACE,IAAI,cAAc;;;;;;;;;;;;wBAqCR,aACd,kBACA,OAAO,aACP,kBACC;qBAwEU;WACF;mBACQ;mBACA;EAEjB,YAAY,UAAS;;;;;EAoBrB,QAAQ;EAIR,MAAM,UAAU;;;UAuDR"}

package/dist/webpack.mjs

@@ -0,0 +1,155 @@
+import { n as resolvePlan } from "./plan-Bsn_yxS9.mjs";
+import { a as real, i as ownership, o as resolveEach, s as slashes, t as Units } from "./host-BGcb1rMJ.mjs";
+import { n as loaderPath, r as registry, t as CSS_RESOLVE } from "./webpack-state-DwltSkQq.mjs";
+//#region src/webpack.ts
+/**
+* The webpack adapter. The plugin inserts layergate's loader into every
+* existing global-CSS loader chain (one with a css-loader that is not a
+* CSS Modules one), so it runs on each stylesheet before PostCSS and
+* css-loader, imported ones too: css-loader's `importLoaders` is raised by
+* one, on a copy of its options. No rule is added. For an owned graph the
+* loader resolves and inlines every `@import` itself and returns finished
+* CSS with no local import, so css-loader has nothing left to resolve and
+* a `layer()` condition never reaches its import parser.
+*/
+const NAME = "layergate";
+const CSS_LOADER = /(?:^|[\\/])css-loader(?:[\\/]|$)/;
+const POSTCSS_LOADER = /(?:^|[\\/])postcss-loader(?:[\\/]|$)/;
+const LIGHTNINGCSS_LOADER = /lightningcss-loader/;
+const NEXT_FONT_LOADER = /next-font/;
+const loaderOf = (entry) => entry instanceof Object ? entry.loader ?? "" : entry;
+/** Whether css-loader with `options` reads every stylesheet as a CSS
+*  Module or ICSS sheet: `modules` true, a mode name, or an object
+*  without `auto`; or `icss: true`. */
+function allModules({ modules, icss }) {
+	if (icss === true || modules === true) return true;
+	if (Object.prototype.toString.call(modules) === "[object String]") return true;
+	return modules instanceof Object && !(modules instanceof Function) && !("auto" in modules && modules.auto !== void 0);
+}
+/**
+* Inserts `entry` into every loader chain of `rules` whose css-loader is
+* explicitly global (`modules: false`, as Next's global chains are): just
+* before PostCSS runs (after it in `use`), or before css-loader without
+* PostCSS. A chain whose css-loader decides per file whether a stylesheet
+* is a CSS Module (`modules` unset or `auto`) is left alone, and reported:
+* layergate never predicts that decision.
+*/
+function insertLoader(rules, entry, prefix = "module.rules") {
+	const coverage = {
+		wrapped: 0,
+		skipped: []
+	};
+	for (const [index, candidate] of rules.entries()) {
+		if (!(candidate instanceof Object)) continue;
+		const rule = candidate;
+		const place = `${prefix}[${index}]`;
+		for (const [key, nested] of [["oneOf", rule.oneOf], ["rules", rule.rules]]) {
+			if (!Array.isArray(nested)) continue;
+			const counts = insertLoader(nested, entry, `${place}.${key}`);
+			coverage.wrapped += counts.wrapped;
+			coverage.skipped.push(...counts.skipped);
+		}
+		if (!Array.isArray(rule.use)) continue;
+		const use = rule.use;
+		const loaders = use.map(loaderOf);
+		if (loaders.includes(entry.loader)) continue;
+		if (loaders.some((loader) => NEXT_FONT_LOADER.test(loader))) continue;
+		const css = loaders.findIndex((loader) => CSS_LOADER.test(loader));
+		if (css === -1) {
+			if (loaders.some((loader) => LIGHTNINGCSS_LOADER.test(loader))) coverage.skipped.push(`${place} is not layered: it uses Lightning CSS, not css-loader`);
+			continue;
+		}
+		const cssEntry = use[css];
+		const options = cssEntry instanceof Object ? cssEntry.options ?? {} : {};
+		if (allModules(options)) continue;
+		if (options.modules !== false) {
+			coverage.skipped.push(`${place} is not layered: its css-loader is not \`modules: false\`. Give global CSS a rule with \`modules: false\`, or opt out`);
+			continue;
+		}
+		const postcss = loaders.findIndex((loader) => POSTCSS_LOADER.test(loader));
+		const at = (postcss === -1 ? css : postcss) + 1;
+		rule.use = [
+			...use.slice(0, css),
+			{
+				loader: loaderOf(cssEntry),
+				options: {
+					...options,
+					importLoaders: (options.importLoaders ?? 0) + 1
+				}
+			},
+			...use.slice(css + 1, at),
+			entry,
+			...use.slice(at)
+		];
+		coverage.wrapped += 1;
+	}
+	return coverage;
+}
+/** What `specifier` resolves to from `context`, as webpack resolves it
+*  (by realpath unless `resolve.symlinks` is false), or null. */
+const resolveOne = (resolver, context, specifier) => new Promise((done) => resolver.resolve({}, context, specifier, {}, (error, result) => done(error || !result ? null : slashes(result))));
+var LayergatePlugin = class {
+	id;
+	state;
+	watchIgnored;
+	constructor(options = {}) {
+		const shared = registry();
+		this.id = `layergate-${process.pid}-${shared.made++}`;
+		this.watchIgnored = options.watchIgnored !== false;
+		const plan = resolvePlan(options);
+		this.state = {
+			plan,
+			owner: ownership(plan),
+			optedOut: /* @__PURE__ */ new Set(),
+			declaredBy: options.declaredBy ? real(options.declaredBy) : null,
+			roots: [],
+			units: new Units()
+		};
+		shared.states.set(this.id, this.state);
+	}
+	/** Whether `path` is a file a finished stylesheet read: one the watcher
+	*  must see, wherever it lies. The watcher asks of every path it scans,
+	*  so this reads no file system: webpack watches the resolved paths the
+	*  loader reported. */
+	watches(path) {
+		return this.state.units.reads(slashes(path));
+	}
+	apply(compiler) {
+		const { wrapped, skipped } = insertLoader(compiler.options.module.rules, {
+			loader: loaderPath(),
+			options: { id: this.id }
+		});
+		compiler.hooks.thisCompilation.tap(NAME, (compilation) => {
+			for (const reason of skipped) compilation.warnings.push(/* @__PURE__ */ new Error(`[layergate] ${reason} [layergate.coverage]`));
+			if (wrapped === 0 && skipped.length === 0 && this.state.owner.owning()) compilation.warnings.push(/* @__PURE__ */ new Error("[layergate] no CSS loader chain with a css-loader was found: nothing is layered [layergate.coverage]"));
+		});
+		if (this.watchIgnored) this.watchOwned(compiler);
+		const prepare = async () => {
+			const resolver = compiler.resolverFactory.get("normal", CSS_RESOLVE);
+			const resolve = (specifier) => resolveOne(resolver, compiler.context, specifier);
+			const { sheets, optOut } = this.state.plan;
+			const [declared, optedOut] = await Promise.all([resolveEach(sheets, "sheets", compiler.context, resolve), resolveEach(optOut, "optOut", compiler.context, resolve)]);
+			this.state.roots = declared;
+			this.state.owner.reset(compiler.context, declared.map(real));
+			this.state.optedOut = new Set(optedOut.map(real));
+		};
+		compiler.hooks.beforeRun.tapPromise(NAME, prepare);
+		compiler.hooks.watchRun.tapPromise(NAME, async () => {
+			for (const path of compiler.modifiedFiles ?? []) this.state.units.changed(slashes(path));
+			for (const path of compiler.removedFiles ?? []) this.state.units.changed(slashes(path));
+			await prepare();
+		});
+		compiler.hooks.shutdown.tap(NAME, () => registry().states.delete(this.id));
+	}
+	/** Makes the host's `watchOptions.ignored` watch every file a finished
+	*  stylesheet read. */
+	watchOwned(compiler) {
+		const watchOptions = compiler.options.watchOptions ??= {};
+		const ignored = watchOptions.ignored;
+		const ignores = ignored instanceof RegExp ? (path) => ignored.test(path) : ignored instanceof Function ? (path) => Boolean(ignored(path)) : null;
+		if (!ignores) return;
+		watchOptions.ignored = (path) => ignores(path) && !this.watches(path);
+	}
+};
+//#endregion
+export { LayergatePlugin, LayergatePlugin as default, insertLoader };

package/package.json

@@ -1,6 +1,92 @@
 {
   "name": "@animus-ui/layergate",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.35",
+  "description": "Load third-party stylesheets into a cascade layer, per file, with their imports inlined and their URLs kept working",
+  "keywords": [
+    "cascade-layers",
+    "css",
+    "layer",
+    "nextjs",
+    "vendor",
+    "vite",
+    "vite-plugin",
+    "webpack"
+  ],
+  "homepage": "https://github.com/codecaaron/animus/tree/main/packages/layergate#readme",
+  "license": "MIT",
+  "author": "codecaaron <airrobb@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codecaaron/animus",
+    "directory": "packages/layergate"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./vite": {
+      "import": {
+        "types": "./dist/vite.d.mts",
+        "default": "./dist/vite.mjs"
+      },
+      "require": {
+        "types": "./dist/vite.d.cts",
+        "default": "./dist/vite.cjs"
+      }
+    },
+    "./webpack": {
+      "import": {
+        "types": "./dist/webpack.d.mts",
+        "default": "./dist/webpack.mjs"
+      },
+      "require": {
+        "types": "./dist/webpack.d.cts",
+        "default": "./dist/webpack.cjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun run build:ts",
+    "build:ts": "tsdown",
+    "compile": "bun check"
+  },
+  "dependencies": {
+    "magic-string": "^0.30.21"
+  },
+  "devDependencies": {
+    "vite": "8.3.4"
+  },
+  "peerDependencies": {
+    "vite": ">=8 <9",
+    "webpack": ">=5 <6"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    },
+    "webpack": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  }
+}