@master/css-tooling 0.0.0-site.1793659883.g69c9aebcf628

package/dist/scanner/binding-session.js

@@ -0,0 +1,37 @@
+import { createToolingBindingSync } from "@master/css-binding/tooling/node";
+import { createToolingBinding } from "@master/css-binding/tooling";
+// src/scanner/binding-session.ts
+function serializeScannerBlocklist(blocklist = []) {
+	return [...blocklist].map((entry) => typeof entry === "string" ? entry : {
+		source: entry.source,
+		flags: entry.flags
+	});
+}
+function bindScannerSession(binding, session) {
+	return {
+		binding,
+		extractCandidates: (source, content, options) => [...session.extractCandidates(source, content, options)],
+		collectCandidates: (candidates) => [...session.collectCandidates(candidates)],
+		filterCandidates: (candidates, blocklist) => [...session.filterCandidates(candidates, blocklist)],
+		scanCandidates: (source, content, candidates, blocklist, options) => session.scanCandidates(source, content, candidates, blocklist, options),
+		removeSource: (source, options) => session.removeSource(source, options),
+		reconcileSources: (owner, inputs) => session.reconcileSources(owner, inputs),
+		removeOwner: (owner) => session.removeOwner(owner),
+		ensureClasses: (classes) => {
+			session.ensureClassRules(classes);
+		},
+		registerNativeClasses: (owner, classes) => session.registerNativeClassNames(owner, classes),
+		reset: () => session.reset(),
+		state: () => session.snapshot(),
+		dispose: () => session.dispose()
+	};
+}
+function createNativeScannerSession(manifest) {
+	const tooling = createToolingBindingSync();
+	return bindScannerSession(tooling.binding, tooling.createScannerSession(manifest));
+}
+async function createScannerSession(manifest, options = {}) {
+	const tooling = await createToolingBinding(options);
+	return bindScannerSession(tooling.binding, await tooling.createScannerSession(manifest));
+}
+export { createNativeScannerSession, createScannerSession, serializeScannerBlocklist };

package/dist/scanner/core.d.ts

@@ -0,0 +1,130 @@
+import { ScannerSourceInput, ScannerSourceOptions } from "./binding-session.js";
+import { MasterCSSScannerOptions } from "./options/index.js";
+import { EventEmitter } from "node:events";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+interface ScannerResetOptions {
+  emit?: boolean;
+}
+interface MasterCSSScannerSourceResult {
+  readonly changed: boolean;
+  readonly sourceChanged: boolean;
+  /** All candidates extracted from this input, including previously scanned classes. */
+  readonly candidates: readonly string[];
+}
+declare class ScannerCSSView {
+  readonly scanner: MasterCSSScanner;
+  constructor(scanner: MasterCSSScanner);
+  get manifest(): MasterCSSManifest;
+  get text(): string;
+  get utilitiesLayer(): {
+    rules: {
+      className: string;
+      key: string;
+      layer: import("@master/css-schema/manifest").MasterCSSManifestUtilityLayerName;
+      type: import("~/packages/schema/src/utility-type").UtilityType;
+      sortTier: number;
+      priority: import("~/packages/schema/src/hydration-manifest").MasterCSSRulePriority;
+      text: string;
+      nodes?: readonly import("~/packages/schema/src/hydration-manifest").MasterCSSHydrationRuleNode[];
+      selectorText?: string;
+      variableNames?: readonly string[];
+      keyframeNames?: readonly string[];
+      retainAllKeyframes?: boolean;
+      name: string;
+    }[];
+  };
+}
+declare class ScannerStateSetView {
+  private readonly readValues;
+  readonly [Symbol.toStringTag] = "ScannerStateSetView";
+  constructor(readValues: () => readonly string[]);
+  get size(): number;
+  has(value: string): boolean;
+  entries(): SetIterator<[string, string]>;
+  keys(): SetIterator<string>;
+  valuesIterator(): SetIterator<string>;
+  values(): SetIterator<string>;
+  forEach(callbackfn: (value: string, value2: string, set: ScannerStateSetView) => void, thisArg?: unknown): void;
+  [Symbol.iterator](): SetIterator<string>;
+}
+declare class MasterCSSScanner extends EventEmitter implements AsyncDisposable {
+  customOptions: MasterCSSScannerOptions;
+  cwd: string;
+  readonly latentClasses: ScannerStateSetView;
+  readonly validClasses: ScannerStateSetView;
+  readonly invalidClasses: ScannerStateSetView;
+  readonly nativeClassNames: ScannerStateSetView;
+  readonly usedNativeClasses: ScannerStateSetView;
+  /** Current successful source snapshot, including empty and virtual inputs. */
+  get sources(): {
+    source: string;
+    owner: string;
+    parentSource: string | null;
+    kind: import("@master/css-binding/protocol").MasterCSSSourceExtractorKind;
+    extractor: string;
+    candidates: string[];
+  }[];
+  initialized: boolean;
+  initializing?: Promise<this>;
+  resetDependencies: string[];
+  readonly css: ScannerCSSView;
+  private bindingSession?;
+  private bindingState?;
+  private currentManifest;
+  private lifecycleGeneration;
+  private sourcePolicy?;
+  private sourceRevisions;
+  private ownerRevisions;
+  private ownerSnapshots;
+  private sourceParents;
+  private committedSources;
+  private extractionCache;
+  /** Precompiled minimatch patterns for per-module allow/exclude checks. */
+  private sourceMatchers?;
+  private sourceMatcherOptions?;
+  constructor(customOptions: MasterCSSScannerOptions, cwd?: string);
+  init(customOptions?: MasterCSSScannerOptions): Promise<this>;
+  private initInternal;
+  reset(customOptions?: MasterCSSScannerOptions, resetOptions?: ScannerResetOptions): Promise<this>;
+  dispose(): Promise<this>;
+  [Symbol.asyncDispose](): Promise<void>;
+  private insertSafelist;
+  /**
+   * @description Extract source content candidates.
+   * @param source
+   * @param content
+   * @returns Promise<string[]> Latent classes
+   */
+  collectCandidates(source: string, content: string, options?: ScannerSourceOptions): Promise<string[]>;
+  private extractCandidates;
+  scan(source: string, content: string): Promise<boolean>;
+  scanSource(source: string, content: string, options?: ScannerSourceOptions): Promise<MasterCSSScannerSourceResult>;
+  removeSource(source: string, options?: ScannerSourceOptions): MasterCSSScannerSourceResult;
+  private sourceAncestors;
+  reconcileSources(owner: string, inputs: readonly ScannerSourceInput[]): Promise<MasterCSSScannerSourceResult>;
+  private reconcileOwner;
+  removeOwner(owner: string): MasterCSSScannerSourceResult;
+  private applyUpdate;
+  scanModule(source: string, content: string): Promise<boolean>;
+  private resolveSourceAdapter;
+  private getSourceMatchers;
+  isModuleAllowed(source: string): boolean;
+  isSourceAllowed(source: string, options?: {
+    explicit?: boolean;
+  }): boolean;
+  get sourcePolicyDependencies(): string[];
+  registerNativeClasses(owner: string, classNames: string[]): boolean;
+  private getBindingSession;
+  private syncBindingState;
+  get state(): import("@master/css-binding/protocol").MasterCSSScannerState;
+  /**
+   * computed from `options.manifest`
+   */
+  get manifest(): MasterCSSManifest;
+  readonly slotCSSRule = "#master-css-slot{--slot:0}";
+}
+declare function createScanner(options: MasterCSSScannerOptions, cwd?: string): Promise<MasterCSSScanner>;
+interface MasterCSSScanner {
+  options: MasterCSSScannerOptions;
+}
+export { MasterCSSScanner, MasterCSSScannerSourceResult, ScannerCSSView, type ScannerSourceInput, type ScannerSourceOptions, ScannerStateSetView, createScanner };

package/dist/scanner/core.js

@@ -0,0 +1,480 @@
+import { SourcePolicy } from "./source-policy.js";
+import { defaultScannerOptions } from "./options/index.js";
+import { matchesSourceAdapter } from "../source/adapters/types.js";
+import { svelteAdapter } from "../source/adapters/svelte.js";
+import { vueAdapter } from "../source/adapters/vue.js";
+import { createScannerSession, serializeScannerBlocklist } from "./binding-session.js";
+import { Minimatch } from "minimatch";
+import { createConsola } from "consola";
+import { defu } from "defu";
+import { EventEmitter } from "node:events";
+import path from "path";
+// src/scanner/core.ts
+const builtInAdapters = [vueAdapter(), svelteAdapter()];
+const sourceLikeExtensions = /* @__PURE__ */ new Set([
+	".html",
+	".htm",
+	".js",
+	".mjs",
+	".jsx",
+	".cjs",
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".svelte",
+	".astro",
+	".vue",
+	".md",
+	".mdx",
+	".pug",
+	".php"
+]);
+const sourceMatchOptions = { dot: true };
+const logger = createConsola({ level: 3 });
+function createSourceMatchers(patterns) {
+	return (patterns || []).map((pattern) => new Minimatch(String(pattern), sourceMatchOptions));
+}
+function matchesAnySource(sources, matchers) {
+	for (const matcher of matchers) for (const source of sources) if (matcher.match(source)) return true;
+	return false;
+}
+function isStyleModuleRequest(source) {
+	const queryStart = source.indexOf("?");
+	if (queryStart === -1) return false;
+	return new URLSearchParams(source.slice(queryStart + 1)).get("type") === "style";
+}
+function cleanSourceRequest(source) {
+	const queryStart = source.indexOf("?");
+	return queryStart === -1 ? source : source.slice(0, queryStart);
+}
+function isSourceLikeModule(source) {
+	return sourceLikeExtensions.has(path.extname(cleanSourceRequest(source)));
+}
+function toPosixPath(source) {
+	return source.replace(/\\/g, "/");
+}
+function isRelativeToCwd(source) {
+	return source !== "" && !source.startsWith("..") && !path.isAbsolute(source);
+}
+function createSourceMatchCandidates(source, cwd) {
+	const cleanSource = cleanSourceRequest(source);
+	const candidates = [toPosixPath(cleanSource)];
+	if (path.isAbsolute(cleanSource)) {
+		const relativeSource = path.relative(path.resolve(cwd), cleanSource);
+		if (isRelativeToCwd(relativeSource)) {
+			const normalizedRelativeSource = toPosixPath(relativeSource);
+			if (!candidates.includes(normalizedRelativeSource)) candidates.push(normalizedRelativeSource);
+		}
+	}
+	return candidates;
+}
+var ScannerCSSView = class {
+	scanner;
+	constructor(scanner) {
+		this.scanner = scanner;
+	}
+	get manifest() {
+		return this.scanner.manifest;
+	}
+	get text() {
+		return this.scanner.state.engine.text;
+	}
+	get utilitiesLayer() {
+		return { rules: this.scanner.state.engine.rules.filter(({ layer }) => layer === "utilities").map((rule) => ({
+			...rule,
+			name: rule.className
+		})) };
+	}
+};
+var ScannerStateSetView = class {
+	readValues;
+	[Symbol.toStringTag] = "ScannerStateSetView";
+	constructor(readValues) {
+		this.readValues = readValues;
+	}
+	get size() {
+		return this.readValues().length;
+	}
+	has(value) {
+		return this.readValues().includes(value);
+	}
+	entries() {
+		return new Set(this.readValues()).entries();
+	}
+	keys() {
+		return this.readValues()[Symbol.iterator]();
+	}
+	valuesIterator() {
+		return this.keys();
+	}
+	values() {
+		return this.keys();
+	}
+	forEach(callbackfn, thisArg) {
+		for (const value of this.values()) callbackfn.call(thisArg, value, value, this);
+	}
+	[Symbol.iterator]() {
+		return this.keys();
+	}
+};
+var MasterCSSScanner = class extends EventEmitter {
+	customOptions;
+	cwd;
+	latentClasses = new ScannerStateSetView(() => this.state.latentClasses);
+	validClasses = new ScannerStateSetView(() => this.state.validClasses);
+	invalidClasses = new ScannerStateSetView(() => this.state.invalidClasses);
+	nativeClassNames = new ScannerStateSetView(() => this.state.nativeClasses || []);
+	usedNativeClasses = new ScannerStateSetView(() => this.state.usedNativeClasses || []);
+	/** Current successful source snapshot, including empty and virtual inputs. */
+	get sources() {
+		return this.state.sources;
+	}
+	initialized = false;
+	initializing;
+	resetDependencies = [];
+	css = new ScannerCSSView(this);
+	bindingSession;
+	bindingState;
+	currentManifest;
+	lifecycleGeneration = 0;
+	sourcePolicy;
+	sourceRevisions = /* @__PURE__ */ new Map();
+	ownerRevisions = /* @__PURE__ */ new Map();
+	ownerSnapshots = /* @__PURE__ */ new Map();
+	sourceParents = /* @__PURE__ */ new Map();
+	committedSources = /* @__PURE__ */ new Map();
+	extractionCache = /* @__PURE__ */ new Map();
+	/** Precompiled minimatch patterns for per-module allow/exclude checks. */
+	sourceMatchers;
+	sourceMatcherOptions;
+	constructor(customOptions, cwd = process.cwd()) {
+		super();
+		this.customOptions = customOptions;
+		this.cwd = cwd;
+		this.currentManifest = customOptions.manifest;
+	}
+	init(customOptions = this.customOptions) {
+		if (this.initialized) return Promise.resolve(this);
+		if (this.initializing) return this.initializing;
+		const generation = ++this.lifecycleGeneration;
+		let initializing;
+		initializing = this.initInternal(customOptions, generation).finally(() => {
+			if (this.initializing === initializing) this.initializing = void 0;
+		});
+		this.initializing = initializing;
+		return initializing;
+	}
+	async initInternal(customOptions, generation) {
+		if (typeof customOptions !== "object" || customOptions === null || Array.isArray(customOptions)) throw new TypeError("MasterCSSScanner options must be an object.");
+		const options = defu(customOptions, defaultScannerOptions);
+		if (options.verbose && options.verbose > 1) {
+			logger.success("options");
+			logger.log(options);
+			logger.log("");
+		}
+		const bindingSession = await createScannerSession(options.manifest, {
+			binding: options.binding,
+			native: options.native,
+			wasm: options.wasm
+		});
+		if (generation !== this.lifecycleGeneration) {
+			bindingSession.dispose();
+			return this;
+		}
+		this.options = options;
+		this.customOptions = customOptions;
+		this.resetDependencies = [];
+		this.committedSources.clear();
+		this.extractionCache.clear();
+		this.sourceRevisions.clear();
+		this.ownerRevisions.clear();
+		this.ownerSnapshots.clear();
+		this.sourceParents.clear();
+		this.sourceMatchers = void 0;
+		this.sourceMatcherOptions = { exclude: options.exclude };
+		this.getSourceMatchers();
+		this.currentManifest = options.manifest;
+		this.bindingSession = bindingSession;
+		try {
+			this.insertSafelist();
+			this.emit("init", options, this.manifest);
+			if (generation === this.lifecycleGeneration) this.initialized = true;
+		} catch (error) {
+			if (this.bindingSession === bindingSession) {
+				this.bindingSession = void 0;
+				this.bindingState = void 0;
+				this.initialized = false;
+				bindingSession.dispose();
+			}
+			throw error;
+		}
+		return this;
+	}
+	async reset(customOptions = this.customOptions, resetOptions = {}) {
+		this.lifecycleGeneration++;
+		this.bindingSession?.dispose();
+		this.bindingSession = void 0;
+		this.bindingState = void 0;
+		this.resetDependencies = [];
+		this.committedSources.clear();
+		this.extractionCache.clear();
+		this.sourceRevisions.clear();
+		this.ownerRevisions.clear();
+		this.ownerSnapshots.clear();
+		this.sourceParents.clear();
+		this.sourceMatchers = void 0;
+		this.sourceMatcherOptions = void 0;
+		this.initialized = false;
+		this.initializing = void 0;
+		const initializing = this.init(customOptions);
+		const generation = this.lifecycleGeneration;
+		await initializing;
+		if (generation === this.lifecycleGeneration && this.initialized && resetOptions.emit !== false) this.emit("reset");
+		return this;
+	}
+	async dispose() {
+		this.lifecycleGeneration++;
+		const bindingSession = this.bindingSession;
+		this.bindingSession = void 0;
+		this.bindingState = void 0;
+		this.resetDependencies = [];
+		this.committedSources.clear();
+		this.extractionCache.clear();
+		this.sourceRevisions.clear();
+		this.ownerRevisions.clear();
+		this.ownerSnapshots.clear();
+		this.sourceParents.clear();
+		this.sourceMatchers = void 0;
+		this.sourceMatcherOptions = void 0;
+		this.initialized = false;
+		this.initializing = void 0;
+		bindingSession?.dispose();
+		try {
+			this.emit("dispose");
+		} finally {
+			this.removeAllListeners();
+		}
+		return this;
+	}
+	async [Symbol.asyncDispose]() {
+		await this.dispose();
+	}
+	insertSafelist() {
+		if (this.options.safelist?.length) {
+			this.getBindingSession().ensureClasses([...this.options.safelist]);
+			this.bindingState = void 0;
+			if (this.options.verbose) logger.success(`${this.options.safelist.length} fixed classes inserted ${this.options.safelist.join(", ")}`);
+		}
+	}
+	/**
+	* @description Extract source content candidates.
+	* @param source
+	* @param content
+	* @returns Promise<string[]> Latent classes
+	*/
+	async collectCandidates(source, content, options = {}) {
+		return [...await this.extractCandidates(source, content, options)];
+	}
+	async extractCandidates(source, content, options) {
+		const key = JSON.stringify([
+			options.owner ?? "project",
+			source,
+			options.kind ?? "auto",
+			options.extractor ?? ""
+		]);
+		const cached = this.extractionCache.get(key);
+		if (cached?.content === content) return cached.candidates;
+		const adapter = options.kind && options.kind !== "auto" ? void 0 : this.resolveSourceAdapter(source);
+		const candidates = adapter ? await adapter.extract({
+			source,
+			content
+		}) : this.getBindingSession().extractCandidates(source, content, options);
+		this.extractionCache.set(key, {
+			content,
+			candidates
+		});
+		return candidates;
+	}
+	async scan(source, content) {
+		return (await this.scanSource(source, content)).changed;
+	}
+	async scanSource(source, content, options = {}) {
+		this.getBindingSession();
+		const blocklist = serializeScannerBlocklist(this.options.blocklist);
+		const key = JSON.stringify([options.owner ?? "project", source]);
+		const identity = JSON.stringify([
+			content,
+			options,
+			blocklist
+		]);
+		const revision = (this.sourceRevisions.get(key) ?? 0) + 1;
+		this.sourceRevisions.set(key, revision);
+		const owner = options.owner ?? "project";
+		const ancestors = this.sourceAncestors(owner, source, /* @__PURE__ */ new Map([[key, options.parentSource]]));
+		const ownerRevision = this.ownerRevisions.get(owner) ?? 0;
+		const snapshot = this.ownerSnapshots.get(owner);
+		const generation = this.lifecycleGeneration;
+		const candidates = await this.extractCandidates(source, content, options);
+		await snapshot?.catch(() => void 0);
+		if (ancestors.some(([parent, revision]) => (this.sourceRevisions.get(parent) ?? 0) !== revision)) return {
+			changed: false,
+			sourceChanged: false,
+			candidates
+		};
+		if (generation !== this.lifecycleGeneration || revision !== this.sourceRevisions.get(key) || ownerRevision !== (this.ownerRevisions.get(owner) ?? 0)) return {
+			changed: false,
+			sourceChanged: false,
+			candidates
+		};
+		if (this.committedSources.get(key) === identity) return {
+			changed: false,
+			sourceChanged: false,
+			candidates
+		};
+		const update = this.getBindingSession().scanCandidates(source, content, candidates, blocklist, options);
+		if (options.parentSource) this.sourceParents.set(key, options.parentSource);
+		else this.sourceParents.delete(key);
+		const result = this.applyUpdate(update);
+		this.committedSources.set(key, identity);
+		return result;
+	}
+	removeSource(source, options = {}) {
+		const key = JSON.stringify([options.owner ?? "project", source]);
+		this.sourceRevisions.set(key, (this.sourceRevisions.get(key) ?? 0) + 1);
+		this.committedSources.clear();
+		return this.applyUpdate(this.getBindingSession().removeSource(source, options));
+	}
+	sourceAncestors(owner, source, proposed = /* @__PURE__ */ new Map()) {
+		const ancestors = [];
+		const seen = /* @__PURE__ */ new Set();
+		let key = JSON.stringify([owner, source]);
+		while (!seen.has(key)) {
+			seen.add(key);
+			ancestors.push([key, this.sourceRevisions.get(key) ?? 0]);
+			const parent = proposed.has(key) ? proposed.get(key) : this.sourceParents.get(key);
+			if (!parent) break;
+			key = JSON.stringify([owner, parent]);
+		}
+		return ancestors;
+	}
+	reconcileSources(owner, inputs) {
+		const task = this.reconcileOwner(owner, inputs);
+		this.ownerSnapshots.set(owner, task);
+		task.finally(() => {
+			if (this.ownerSnapshots.get(owner) === task) this.ownerSnapshots.delete(owner);
+		}).catch(() => void 0);
+		return task;
+	}
+	async reconcileOwner(owner, inputs) {
+		const revision = (this.ownerRevisions.get(owner) ?? 0) + 1;
+		this.ownerRevisions.set(owner, revision);
+		const generation = this.lifecycleGeneration;
+		const proposed = new Map(inputs.map((input) => [JSON.stringify([owner, input.source]), input.options?.parentSource]));
+		const revisions = new Map(inputs.map((input) => [input.source, this.sourceAncestors(owner, input.source, proposed)]));
+		const prepared = await Promise.all(inputs.map(async (input) => {
+			const options = {
+				...input.options,
+				owner
+			};
+			return {
+				...input,
+				options,
+				candidates: input.candidates ?? await this.extractCandidates(input.source, input.content, options),
+				blocklist: input.blocklist ?? serializeScannerBlocklist(this.options.blocklist)
+			};
+		}));
+		if (generation !== this.lifecycleGeneration || revision !== this.ownerRevisions.get(owner)) return {
+			changed: false,
+			sourceChanged: false,
+			candidates: prepared.flatMap((input) => input.candidates)
+		};
+		const retained = prepared.filter((input) => revisions.get(input.source).every(([key, revision]) => (this.sourceRevisions.get(key) ?? 0) === revision));
+		const update = this.getBindingSession().reconcileSources(owner, retained);
+		this.committedSources.clear();
+		for (const key of this.sourceParents.keys()) if (JSON.parse(key)[0] === owner) this.sourceParents.delete(key);
+		for (const input of retained) if (input.options.parentSource) this.sourceParents.set(JSON.stringify([owner, input.source]), input.options.parentSource);
+		return this.applyUpdate(update);
+	}
+	removeOwner(owner) {
+		this.ownerRevisions.set(owner, (this.ownerRevisions.get(owner) ?? 0) + 1);
+		this.committedSources.clear();
+		return this.applyUpdate(this.getBindingSession().removeOwner(owner));
+	}
+	applyUpdate(update) {
+		this.bindingState = void 0;
+		const inserted = [...update.validClasses, ...update.usedNativeClasses ?? []];
+		if (inserted.length && this.options.verbose) logger.success(`${inserted.length} classes inserted${this.options.verbose > 1 ? " " + inserted.join(", ") : ""}`);
+		if (update.changed) this.emit("change");
+		return {
+			changed: update.changed,
+			sourceChanged: update.sourceChanged,
+			candidates: update.candidates
+		};
+	}
+	async scanModule(source, content) {
+		if (!this.isModuleAllowed(source)) return false;
+		return this.scan(source, content);
+	}
+	resolveSourceAdapter(source) {
+		return builtInAdapters.find((adapter) => matchesSourceAdapter(adapter, source));
+	}
+	getSourceMatchers() {
+		const { exclude } = this.options;
+		if (!this.sourceMatchers || this.sourceMatcherOptions?.exclude !== exclude) {
+			const explicitExclude = this.sourceMatcherOptions?.exclude !== exclude ? exclude : this.customOptions.exclude;
+			this.sourcePolicy = new SourcePolicy(this.cwd, {
+				exclude: explicitExclude,
+				outputDirectories: this.options.outputDirectories
+			});
+			this.sourceMatcherOptions = { exclude };
+			this.sourceMatchers = { exclude: createSourceMatchers(exclude) };
+		}
+		return this.sourceMatchers;
+	}
+	isModuleAllowed(source) {
+		if (!source || source.startsWith("\0")) return false;
+		if (isStyleModuleRequest(source)) return false;
+		if (!isSourceLikeModule(source)) return false;
+		const sources = createSourceMatchCandidates(source, this.cwd);
+		const { exclude } = this.getSourceMatchers();
+		if (exclude.length && matchesAnySource(sources, exclude)) return false;
+		return this.sourcePolicy?.accepts(cleanSourceRequest(source)) ?? false;
+	}
+	isSourceAllowed(source, options = {}) {
+		this.getSourceMatchers();
+		return this.sourcePolicy?.accepts(source, options.explicit) ?? false;
+	}
+	get sourcePolicyDependencies() {
+		return [...this.sourcePolicy?.dependencies ?? []];
+	}
+	registerNativeClasses(owner, classNames) {
+		const changed = this.getBindingSession().registerNativeClasses(owner, classNames);
+		this.bindingState = void 0;
+		if (changed) this.emit("change");
+		return changed;
+	}
+	getBindingSession() {
+		if (!this.bindingSession) throw new Error("MasterCSSScanner must be initialized before use.");
+		return this.bindingSession;
+	}
+	syncBindingState() {
+		const state = this.getBindingSession().state();
+		this.bindingState = state;
+		return state;
+	}
+	get state() {
+		return this.bindingState || this.syncBindingState();
+	}
+	/**
+	* computed from `options.manifest`
+	*/
+	get manifest() {
+		return this.currentManifest;
+	}
+	slotCSSRule = "#master-css-slot{--slot:0}";
+};
+async function createScanner(options, cwd = process.cwd()) {
+	return await new MasterCSSScanner(options, cwd).init();
+}
+export { MasterCSSScanner, ScannerCSSView, ScannerStateSetView, createScanner };

package/dist/scanner/index.d.ts

@@ -0,0 +1,3 @@
+import { MasterCSSScannerConfiguration, MasterCSSScannerOptions, defaultScannerOptions } from "./options/index.js";
+import { MasterCSSScanner, MasterCSSScannerSourceResult, createScanner } from "./core.js";
+export { MasterCSSScanner, type MasterCSSScannerConfiguration, type MasterCSSScannerOptions, type MasterCSSScannerSourceResult, createScanner, defaultScannerOptions };

package/dist/scanner/index.js

@@ -0,0 +1,3 @@
+import { defaultScannerOptions } from "./options/index.js";
+import { MasterCSSScanner, createScanner } from "./core.js";
+export { MasterCSSScanner, createScanner, defaultScannerOptions };

package/dist/scanner/node.d.ts

@@ -0,0 +1,5 @@
+import { ScannerSourceInput, ScannerSourceOptions } from "./binding-session.js";
+import { MasterCSSScannerConfiguration, MasterCSSScannerOptions, defaultScannerOptions } from "./options/index.js";
+import { MasterCSSScanner, MasterCSSScannerSourceResult, createScanner } from "./core.js";
+import { SourcePolicy, SourcePolicyOptions } from "./source-policy.js";
+export { MasterCSSScanner, type MasterCSSScannerConfiguration, type MasterCSSScannerOptions, type MasterCSSScannerSourceResult, type ScannerSourceInput, type ScannerSourceOptions, SourcePolicy, type SourcePolicyOptions, createScanner, defaultScannerOptions };

package/dist/scanner/node.js

@@ -0,0 +1,4 @@
+import { SourcePolicy } from "./source-policy.js";
+import { defaultScannerOptions } from "./options/index.js";
+import { MasterCSSScanner, createScanner } from "./core.js";
+export { MasterCSSScanner, SourcePolicy, createScanner, defaultScannerOptions };

package/dist/scanner/options/index.d.ts

@@ -0,0 +1,16 @@
+import { MasterCSSBindingLoadOptions } from "@master/css-binding/tooling";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+interface MasterCSSScannerConfiguration {
+  verbose?: number;
+  path?: string;
+  /** Actual bundler output directories, always excluded from source input. */
+  outputDirectories?: readonly string[];
+  exclude?: readonly string[];
+  safelist?: readonly string[];
+  blocklist?: readonly (string | RegExp)[];
+}
+interface MasterCSSScannerOptions extends MasterCSSScannerConfiguration, MasterCSSBindingLoadOptions {
+  manifest: MasterCSSManifest;
+}
+declare const defaultScannerOptions: Readonly<MasterCSSScannerConfiguration>;
+export { MasterCSSScannerConfiguration, MasterCSSScannerOptions, defaultScannerOptions };