@teacss/engine 0.9.3 → 0.10.2

package/dist/entry.js

@@ -0,0 +1,279 @@
+// Statement-form entry directives the engine consumed from the entry file; the Rust side
+// (`teacss-transform/src/entry_strip.rs`) leaves an entry that carries `@teacss;` to its shell.
+const ENTRY_STATEMENTS = new Set(["presets", "source", "shortcut", "safelist", "primary", "neutral", "success", "warning", "failure", "general"]);
+function skipComment(css, index) {
+    const close = css.indexOf("*/", index + 2);
+    return close < 0 ? css.length : close + 2;
+}
+function skipString(css, index) {
+    const quote = css[index];
+    for (let cursor = index + 1; cursor < css.length;) {
+        if (css[cursor] === "\\")
+            cursor += 2;
+        else if (css[cursor] === quote)
+            return cursor + 1;
+        else
+            cursor++;
+    }
+    return css.length;
+}
+/** The index after the comment, string or backslash escape that starts at `index`, or `index` when none does. */
+function skipOpaque(css, index) {
+    if (css.startsWith("/*", index))
+        return skipComment(css, index);
+    const char = css[index];
+    if (char === '"' || char === "'")
+        return skipString(css, index);
+    if (char === "\\")
+        return Math.min(index + 2, css.length);
+    return index;
+}
+function findClosingBrace(css, open) {
+    let depth = 1;
+    for (let cursor = open + 1; cursor < css.length;) {
+        const skipped = skipOpaque(css, cursor);
+        if (skipped !== cursor) {
+            cursor = skipped;
+            continue;
+        }
+        if (css[cursor] === "{")
+            depth++;
+        else if (css[cursor] === "}" && --depth === 0)
+            return cursor;
+        cursor++;
+    }
+    return null;
+}
+/** The prelude text with each comment read as one space and strings kept as written, trimmed. */
+function cleanPrelude(css, start, end) {
+    let out = "";
+    let segment = start;
+    for (let cursor = start; cursor < end;) {
+        if (css.startsWith("/*", cursor) && cursor + 1 < end) {
+            out += `${css.slice(segment, cursor)} `;
+            cursor = Math.min(skipComment(css, cursor), end);
+            segment = cursor;
+        }
+        else if (css[cursor] === '"' || css[cursor] === "'") {
+            cursor = Math.min(skipString(css, cursor), end);
+        }
+        else
+            cursor++;
+    }
+    return (out + css.slice(segment, end)).trim();
+}
+function atRuleAt(css, start, name) {
+    const nameEnd = start + 1 + name.length;
+    const closers = [];
+    for (let cursor = nameEnd; cursor < css.length;) {
+        const skipped = skipOpaque(css, cursor);
+        if (skipped !== cursor) {
+            cursor = skipped;
+            continue;
+        }
+        const char = css[cursor];
+        if (closers.length === 0 && char === "{") {
+            const close = findClosingBrace(css, cursor);
+            if (close !== null)
+                return { name, prelude: cleanPrelude(css, nameEnd, cursor), start, end: close + 1, block: true };
+        }
+        if (char === "(")
+            closers.push(")");
+        else if (char === "[")
+            closers.push("]");
+        else if (char === "{")
+            closers.push("}");
+        else if (closers.at(-1) === char)
+            closers.pop();
+        if (closers.length === 0 && char === ";")
+            return { name, prelude: cleanPrelude(css, nameEnd, cursor), start, end: cursor + 1, block: false };
+        cursor++;
+    }
+    return { name, prelude: cleanPrelude(css, nameEnd, css.length), start, end: css.length, block: false };
+}
+/**
+ * Top-level at-rules exactly as `teacss-config`'s `scan_top_level_at_rules` finds them: comments, strings and
+ * backslash escapes skipped, nested rules ignored, comments in a prelude read as a space.
+ */
+function topLevelAtRules(css) {
+    const rules = [];
+    let depth = 0;
+    for (let index = 0; index < css.length;) {
+        const skipped = skipOpaque(css, index);
+        if (skipped !== index) {
+            index = skipped;
+            continue;
+        }
+        const char = css[index];
+        if (char === "{")
+            depth++;
+        else if (char === "}")
+            depth = Math.max(0, depth - 1);
+        else if (char === "@" && depth === 0) {
+            const name = /^[\w-]+/.exec(css.slice(index + 1))?.[0];
+            if (name) {
+                const rule = atRuleAt(css, index, name);
+                rules.push(rule);
+                index = rule.end;
+                continue;
+            }
+        }
+        index++;
+    }
+    return rules;
+}
+function entryPieces(css, generate) {
+    const rules = topLevelAtRules(css);
+    const entry = rules.find((rule) => rule.name === "teacss" && !rule.block && rule.prelude === "");
+    if (!entry)
+        return null;
+    const pieces = [];
+    let cursor = 0;
+    for (const rule of rules) {
+        const remove = rule.name === "teacss" || rule.name === "custom" || (ENTRY_STATEMENTS.has(rule.name) && !rule.block);
+        if (!remove)
+            continue;
+        pieces.push({ from: cursor, to: rule.start });
+        if (rule === entry)
+            pieces.push({ generated: generate(), at: rule.start });
+        cursor = rule.end;
+    }
+    pieces.push({ from: cursor, to: css.length });
+    return pieces;
+}
+/** `css` with its first top-level `@teacss;` replaced by `generate()` and the entry directives removed; null when it has no `@teacss;`. */
+export function replaceEntry(css, generate) {
+    const pieces = entryPieces(css, generate);
+    return pieces && pieces.map((piece) => ("generated" in piece ? piece.generated : css.slice(piece.from, piece.to))).join("");
+}
+/**
+ * `replaceEntry` with a source map back to `source.original`: hand-written CSS keeps its original lines and
+ * columns, and every line of the generated CSS maps to the `@teacss;` it replaced.
+ */
+export function replaceEntryWithMap(css, generate, source) {
+    const pieces = entryPieces(css, generate);
+    if (!pieces)
+        return null;
+    const points = source.map ? decodePoints(css, source.map.mappings) : identityPoints(css);
+    const out = [];
+    let code = "";
+    for (const piece of pieces) {
+        if ("generated" in piece) {
+            const original = originalAt(css, points, piece.at);
+            for (const start of lineStarts(piece.generated))
+                out.push({ offset: code.length + start, original });
+            code += piece.generated;
+            continue;
+        }
+        if (piece.from === piece.to)
+            continue;
+        out.push({ offset: code.length, original: originalAt(css, points, piece.from) });
+        for (const point of points) {
+            if (point.offset > piece.from && point.offset < piece.to)
+                out.push({ offset: point.offset - piece.from + code.length, original: point.original });
+        }
+        code += css.slice(piece.from, piece.to);
+    }
+    const map = { version: 3, file: source.map?.file ?? null, sources: [source.id], sourcesContent: [source.original], names: [], mappings: encodePoints(code, out) };
+    return { code, map };
+}
+function lineStarts(text) {
+    const starts = [0];
+    for (let index = text.indexOf("\n"); index >= 0; index = text.indexOf("\n", index + 1))
+        starts.push(index + 1);
+    return starts;
+}
+function identityPoints(css) {
+    return lineStarts(css).map((offset, line) => ({ offset, original: [line, 0] }));
+}
+/** Where `offset` came from: the last point at or before it on the same line, moved by the columns between them. */
+function originalAt(css, points, offset) {
+    let last;
+    for (const point of points) {
+        if (point.offset > offset)
+            break;
+        last = point;
+    }
+    if (!last?.original || css.slice(last.offset, offset).includes("\n"))
+        return null;
+    return [last.original[0], last.original[1] + offset - last.offset];
+}
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function decodeVlq(segment) {
+    const values = [];
+    let value = 0;
+    let shift = 0;
+    for (const char of segment) {
+        const digit = BASE64.indexOf(char);
+        value += (digit & 31) << shift;
+        if (digit & 32)
+            shift += 5;
+        else {
+            values.push(value & 1 ? -(value >>> 1) : value >>> 1);
+            value = 0;
+            shift = 0;
+        }
+    }
+    return values;
+}
+function encodeVlq(value) {
+    let rest = value < 0 ? (-value << 1) | 1 : value << 1;
+    let out = "";
+    do {
+        const digit = rest & 31;
+        rest >>>= 5;
+        out += BASE64[rest > 0 ? digit | 32 : digit];
+    } while (rest > 0);
+    return out;
+}
+/** The points of a single-source map's `mappings` over `generated`, in order. */
+function decodePoints(generated, mappings) {
+    const starts = lineStarts(generated);
+    const points = [];
+    let line = 0;
+    let column = 0;
+    for (const [index, group] of mappings.split(";").entries()) {
+        let generatedColumn = 0;
+        for (const segment of group.split(",")) {
+            if (segment === "")
+                continue;
+            const [deltaColumn = 0, , deltaLine, deltaOriginalColumn] = decodeVlq(segment);
+            generatedColumn += deltaColumn;
+            let original = null;
+            if (deltaLine !== undefined && deltaOriginalColumn !== undefined) {
+                line += deltaLine;
+                column += deltaOriginalColumn;
+                original = [line, column];
+            }
+            points.push({ offset: (starts[index] ?? generated.length) + generatedColumn, original });
+        }
+    }
+    return points;
+}
+function encodePoints(code, points) {
+    const starts = lineStarts(code);
+    const lines = starts.map(() => []);
+    const kept = points.filter((point, index) => points[index + 1]?.offset !== point.offset);
+    let line = 0;
+    let previousColumn = 0;
+    let previousLine = 0;
+    let previousOriginalColumn = 0;
+    for (const point of kept) {
+        while (line + 1 < starts.length && starts[line + 1] <= point.offset) {
+            line++;
+            previousColumn = 0;
+        }
+        const column = point.offset - starts[line];
+        let segment = encodeVlq(column - previousColumn);
+        previousColumn = column;
+        if (point.original) {
+            const [originalLine, originalColumn] = point.original;
+            segment += encodeVlq(0) + encodeVlq(originalLine - previousLine) + encodeVlq(originalColumn - previousOriginalColumn);
+            previousLine = originalLine;
+            previousOriginalColumn = originalColumn;
+        }
+        lines[line]?.push(segment);
+    }
+    return lines.map((segments) => segments.join(",")).join(";");
+}
+//# sourceMappingURL=entry.js.map

package/dist/errors.d.ts

@@ -1,13 +1,7 @@
-/** Errors the facade raises itself; an `Error` from napi (code `E_*`) passes through unwrapped. */
+/** Errors the TypeScript side raises itself; an `Error` from napi (code `E_*`) passes through unwrapped. */
 export declare class TeacssEngineError extends Error {
     code: string;
     details: Record<string, unknown>;
     constructor(code: string, message: string, details?: Record<string, unknown>);
 }
-/** v02.9 §2.1: the member needs `@teacss/core`, which is not installed. */
-export declare function tsRequiredError(member: string): TeacssEngineError;
-/** The generator was disposed; the native Engine reports the same code after its own `dispose()`. */
-export declare function disposedError(member: string): TeacssEngineError;
-/** v02.9 §3.3: the member needs the TypeScript engine, which has not been materialized. */
-export declare function tsNotReadyError(member: string): TeacssEngineError;
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -1,4 +1,4 @@
-/** Errors the facade raises itself; an `Error` from napi (code `E_*`) passes through unwrapped. */
+/** Errors the TypeScript side raises itself; an `Error` from napi (code `E_*`) passes through unwrapped. */
 export class TeacssEngineError extends Error {
     constructor(code, message, details = {}) {
         super(message);
@@ -7,16 +7,4 @@ export class TeacssEngineError extends Error {
         this.details = details;
     }
 }
-/** v02.9 §2.1: the member needs `@teacss/core`, which is not installed. */
-export function tsRequiredError(member) {
-    return new TeacssEngineError("E_TS_REQUIRED", `[@teacss/engine] ${member} requires @teacss/core (optional peer) to be installed`, { member });
-}
-/** The generator was disposed; the native Engine reports the same code after its own `dispose()`. */
-export function disposedError(member) {
-    return new TeacssEngineError("E_DISPOSED", `[@teacss/engine] ${member} called after dispose()`);
-}
-/** v02.9 §3.3: the member needs the TypeScript engine, which has not been materialized. */
-export function tsNotReadyError(member) {
-    return new TeacssEngineError("E_TS_REQUIRED", `[@teacss/engine] ${member} needs the TypeScript engine; await generator[Symbol.for('@teacss/engine/materialize')]() first or set engine: 'ts'`, { member });
-}
 //# sourceMappingURL=errors.js.map

package/dist/fonts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The Standard preset's preflight inlines its fonts as data URLs branded with the sha256 of the bytes
+ * (`crates/teacss-standard/src/preflight_fonts.rs`); only TeaCSS writes this URL. Groups: quote, digest, base64.
+ */
+export declare const BUNDLED_FONT_URL: RegExp;
+export interface BundledFont {
+    digest: string;
+    bytes: Uint8Array;
+    /** What `pathFor` returned for the digest: the URL every `url()` of this font now carries. */
+    path: string;
+}
+/**
+ * Moves every bundled font out of `css`: each distinct digest is decoded once, checked against its bytes
+ * (a mismatch is `E_INVALID_ARGUMENT`) and handed to `pathFor`, whose result replaces the data URL.
+ * CSS without a bundled font comes back as the same string with no fonts.
+ */
+export declare function extractBundledFonts(css: string, pathFor: (digest: string, bytes: Uint8Array) => string): {
+    css: string;
+    fonts: BundledFont[];
+};
+//# sourceMappingURL=fonts.d.ts.map

package/dist/fonts.js

@@ -0,0 +1,32 @@
+import { createHash } from "node:crypto";
+import { TeacssEngineError } from "./errors.js";
+/**
+ * The Standard preset's preflight inlines its fonts as data URLs branded with the sha256 of the bytes
+ * (`crates/teacss-standard/src/preflight_fonts.rs`); only TeaCSS writes this URL. Groups: quote, digest, base64.
+ */
+export const BUNDLED_FONT_URL = /url\(\s*(["']?)data:font\/woff2;teacss=v1-([a-f0-9]{64});base64,([A-Za-z0-9+/]*={0,2})\1\s*\)/g;
+/**
+ * Moves every bundled font out of `css`: each distinct digest is decoded once, checked against its bytes
+ * (a mismatch is `E_INVALID_ARGUMENT`) and handed to `pathFor`, whose result replaces the data URL.
+ * CSS without a bundled font comes back as the same string with no fonts.
+ */
+export function extractBundledFonts(css, pathFor) {
+    if (!css.includes(";teacss=v1-"))
+        return { css, fonts: [] };
+    const fonts = new Map();
+    const out = css.replace(BUNDLED_FONT_URL, (_, _quote, digest, base64) => {
+        let font = fonts.get(digest);
+        if (font === undefined) {
+            const bytes = Buffer.from(base64, "base64");
+            const actual = createHash("sha256").update(bytes).digest("hex");
+            if (actual !== digest) {
+                throw new TeacssEngineError("E_INVALID_ARGUMENT", `[@teacss/engine] bundled font ${digest} does not match its bytes (sha256 ${actual})`, { path: `teacss=v1-${digest}`, expected: digest, actual });
+            }
+            font = { digest, bytes, path: pathFor(digest, bytes) };
+            fonts.set(digest, font);
+        }
+        return `url(${JSON.stringify(font.path)})`;
+    });
+    return { css: out, fonts: [...fonts.values()] };
+}
+//# sourceMappingURL=fonts.js.map

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 export * from "../binding.js";
 export type * from "../contract.js";
-export { CONFIG_ENTRY_PROVENANCE, CONFIG_SOURCE_DECLARATIONS, ENGINE_COMPAT, ENGINE_INSTANCE, ENGINE_MATERIALIZE, ENGINE_PACKAGE_VERSION, ENGINE_STATS, PRESET_OPTIONS, } from "./constants.js";
+export { type EntrySource, replaceEntry, replaceEntryWithMap } from "./entry.js";
 export { TeacssEngineError } from "./errors.js";
-export { createGenerator, engineStats, type FacadeCreateResult, FacadeGenerator, type FacadeHost, reportFallback } from "./generator.js";
-export { selectEngineRequest, type TranslateResult, translateConfig } from "./select.js";
-export { createCompileClassTransformer } from "./transformer.js";
+export { BUNDLED_FONT_URL, type BundledFont, extractBundledFonts } from "./fonts.js";
+export { CSS_PLACEHOLDER, createProject, type Edit, isCssId, type Project, replayEdits, type ShellOptions, type SourceDirectory, type UnmatchedReport } from "./project.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,10 +1,7 @@
-// Facade modules import `Engine`, `expandClassGroups`, `splitClassTokens` and `version` from
-// `../binding.js`, never from `index.js`, which re-exports them (a cycle otherwise).
-// This file imports no peer (`@teacss/core`, `@teacss/config`).
+// The package has no runtime dependency beyond the binding.
 export * from "../binding.js";
-export { CONFIG_ENTRY_PROVENANCE, CONFIG_SOURCE_DECLARATIONS, ENGINE_COMPAT, ENGINE_INSTANCE, ENGINE_MATERIALIZE, ENGINE_PACKAGE_VERSION, ENGINE_STATS, PRESET_OPTIONS, } from "./constants.js";
+export { replaceEntry, replaceEntryWithMap } from "./entry.js";
 export { TeacssEngineError } from "./errors.js";
-export { createGenerator, engineStats, FacadeGenerator, reportFallback } from "./generator.js";
-export { selectEngineRequest, translateConfig } from "./select.js";
-export { createCompileClassTransformer } from "./transformer.js";
+export { BUNDLED_FONT_URL, extractBundledFonts } from "./fonts.js";
+export { CSS_PLACEHOLDER, createProject, isCssId, replayEdits } from "./project.js";
 //# sourceMappingURL=index.js.map

package/dist/project.d.ts

@@ -0,0 +1,80 @@
+import { Engine } from "../binding.js";
+import type { GenerateResult, LoadProjectFromRootResult, OutputToCssLayersOptions, PresetIconsOptions, PresetStandardOptions, SourceMap, StaticConfig, TransformResult } from "../contract.js";
+/** v10.2 §2.1: a shell's static options. Every field but `minify` maps 1:1 onto `LoadProjectFromRootRequest`. */
+export interface ShellOptions {
+    /** Default `process.cwd()`. */
+    root?: string;
+    entry?: string;
+    inline?: StaticConfig;
+    /** Default "build". */
+    envMode?: "dev" | "build";
+    /** Default "warn". */
+    unmatched?: "warn" | "error" | "off";
+    outputToCssLayers?: boolean | OutputToCssLayersOptions;
+    shortcutsLayer?: string;
+    presetOptions?: {
+        standard?: PresetStandardOptions;
+        icons?: PresetIconsOptions;
+    };
+    /** Default for `Project.css()`: `envMode === "build"`. */
+    minify?: boolean;
+}
+export type Edit = TransformResult["edits"][number];
+export interface SourceDirectory {
+    /** Absolute path. */
+    dir: string;
+    /** The rest of the `@source` glob, relative to `dir`. */
+    glob: string;
+}
+export interface UnmatchedReport {
+    /** The tokens `result` was generated from; default `engine.allTokens()`, what `css()` generates. */
+    tokens?: readonly string[];
+    /** The host's warning logger. */
+    warn(message: string): void;
+}
+/** v10.2 §2.2: what the shells share on top of the binding. */
+export interface Project {
+    readonly engine: Engine;
+    readonly root: string;
+    /** The latest `loadProjectFromRoot` result; `entryPath` is null when the root has no entry. */
+    readonly info: LoadProjectFromRootResult;
+    /** Runs `loadProjectFromRoot` again; returns whether the programKey changed. */
+    reload(): boolean;
+    /** `configFiles()` plus `info.sourceFiles`, sorted and deduplicated. */
+    watchFiles(): string[];
+    /**
+     * Where each included `@source` glob can match a file that does not exist yet: the directory before its
+     * first glob segment, with the rest of the glob. Sorted by directory; hosts watch these for new files.
+     */
+    sourceDirectories(): SourceDirectory[];
+    /** The tokens of `inline.content.inline`, each item extracted under its id (default `inline:<index>`). */
+    inlineTokens(): string[];
+    /** `transformStylesheet` for a CSS id, otherwise `transformSource` then `updateModule`. */
+    transform(id: string, code: string): {
+        code: string;
+        map: SourceMap | null;
+        changed: boolean;
+    };
+    /** Ids registered through `transform`, in first-seen order. */
+    modules(): string[];
+    /** Forgets a module `transform` registered (`engine.removeModule`); returns whether its tokens or definitions changed. */
+    removeModule(id: string): boolean;
+    /** `generate({ kind: "all" })` with `minify` defaulting to the option; `extendedInfo` fills `matchedInfo`. */
+    css(options?: {
+        minify?: boolean;
+        extendedInfo?: boolean;
+    }): GenerateResult;
+    /**
+     * Applies the `unmatched` option to `result`: the near-miss tokens `diagnoseUnmatched` keeps are
+     * warned about once per project with "warn" (and with "error" in dev), and throw `E_UNMATCHED`
+     * with "error" in a build. "off" reports nothing.
+     */
+    reportUnmatched(result: GenerateResult, report: UnmatchedReport): void;
+    dispose(): void;
+}
+export declare function createProject(options: ShellOptions): Project;
+/** Splices v02.2 §3 edits (UTF-16 offsets, ascending, non-overlapping) into `code`. */
+export declare function replayEdits(code: string, edits: readonly Edit[]): string;
+export declare const CSS_PLACEHOLDER: string;
+export declare function isCssId(id: string): boolean;
+//# sourceMappingURL=project.d.ts.map

package/dist/project.js

@@ -0,0 +1,136 @@
+import { dirname, isAbsolute, resolve } from "node:path";
+import { Engine, markers } from "../binding.js";
+import { TeacssEngineError } from "./errors.js";
+class ShellProject {
+    engine = new Engine();
+    root;
+    #request;
+    #minify;
+    #modules = new Set();
+    #warnedUnmatched = new Set();
+    #info;
+    constructor(options) {
+        const { minify, root = process.cwd(), envMode = "build", unmatched = "warn", ...rest } = options;
+        this.root = root;
+        this.#request = { ...rest, root, envMode, unmatched };
+        this.#minify = minify ?? envMode === "build";
+        this.#info = this.engine.loadProjectFromRoot(this.#request);
+    }
+    get info() {
+        return this.#info;
+    }
+    reload() {
+        this.#info = this.engine.loadProjectFromRoot(this.#request);
+        return this.#info.changed;
+    }
+    watchFiles() {
+        return [...new Set([...this.engine.configFiles(), ...this.#info.sourceFiles])].sort();
+    }
+    sourceDirectories() {
+        const { entryPath } = this.#info;
+        if (entryPath === null)
+            return [];
+        const { sources } = this.engine.inspectEntry({ root: this.root, entryPath });
+        return sources
+            .filter((source) => !source.startsWith("!"))
+            .map((source) => splitGlob(this.root, source))
+            .sort((a, b) => (a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0));
+    }
+    inlineTokens() {
+        const tokens = new Set();
+        for (const [index, item] of (this.#request.inline?.content?.inline ?? []).entries()) {
+            const { code, id } = typeof item === "string" ? { code: item, id: null } : item;
+            for (const token of this.engine.extract(code, id ?? `inline:${index}`))
+                tokens.add(token);
+        }
+        return [...tokens];
+    }
+    transform(id, code) {
+        if (isCssId(id)) {
+            const result = this.engine.transformStylesheet(id, code);
+            return result ? { code: result.code, map: result.map, changed: result.edits.length > 0 } : { code, map: null, changed: false };
+        }
+        const result = this.engine.transformSource(id, code);
+        const next = result?.code ?? code;
+        const update = this.engine.updateModule(id, next);
+        this.#modules.add(id);
+        return { code: next, map: result?.map ?? null, changed: (result?.edits.length ?? 0) > 0 || update.changed };
+    }
+    modules() {
+        return [...this.#modules];
+    }
+    removeModule(id) {
+        this.#modules.delete(id);
+        return this.engine.removeModule(id);
+    }
+    css(options) {
+        return this.engine.generate({ kind: "all" }, { minify: options?.minify ?? this.#minify, extendedInfo: options?.extendedInfo, css: true });
+    }
+    reportUnmatched(result, report) {
+        const { unmatched, envMode } = this.#request;
+        if (unmatched === "off")
+            return;
+        const matched = new Set(result.matched === "" ? [] : result.matched.split("\0"));
+        const tokens = report.tokens ?? this.engine.allTokens();
+        const diagnosed = this.engine.diagnoseUnmatched(tokens.filter((token) => !matched.has(token)));
+        if (diagnosed.length === 0)
+            return;
+        if (unmatched === "error" && envMode === "build") {
+            const plural = diagnosed.length === 1 ? "" : "s";
+            throw new TeacssEngineError("E_UNMATCHED", `[@teacss/engine] ${diagnosed.length} token${plural} matched no rule: ${diagnosed.map(describeUnmatched).join("; ")}`, { diagnostics: diagnosed });
+        }
+        for (const diagnostic of diagnosed) {
+            if (this.#warnedUnmatched.has(diagnostic.token))
+                continue;
+            this.#warnedUnmatched.add(diagnostic.token);
+            report.warn(`unmatched token ${describeUnmatched(diagnostic)}`);
+        }
+    }
+    dispose() {
+        this.engine.dispose();
+    }
+}
+/** The text of `teacss build --unmatched error`: `"token"`, plus `(did you mean "a", "b"?)` when there are suggestions. */
+function describeUnmatched({ token, suggestions }) {
+    const quoted = `"${token}"`;
+    return suggestions.length === 0 ? quoted : `${quoted} (did you mean ${suggestions.map((suggestion) => `"${suggestion}"`).join(", ")}?)`;
+}
+const GLOB_SEGMENT = /[*?[\]{}\\]/;
+/**
+ * `glob` (relative to `root`, or absolute) split before its first segment with glob syntax; a plain path splits before its file name.
+ * As the engine's `static_base`: an absolute base at the filesystem root is clamped to `root`, the tree the engine scans instead.
+ */
+function splitGlob(root, glob) {
+    const segments = glob.split("/");
+    const first = segments.findIndex((segment) => GLOB_SEGMENT.test(segment));
+    const at = first === -1 ? segments.length - 1 : first;
+    const rest = segments.slice(at).join("/");
+    const base = segments.slice(0, at).join("/");
+    if (!isAbsolute(glob))
+        return { dir: resolve(root, base), glob: rest };
+    const dir = resolve(base || "/");
+    return { dir: dirname(dir) === dir ? root : dir, glob: rest };
+}
+export function createProject(options) {
+    return new ShellProject(options);
+}
+/** Splices v02.2 §3 edits (UTF-16 offsets, ascending, non-overlapping) into `code`. */
+export function replayEdits(code, edits) {
+    let out = "";
+    let cursor = 0;
+    for (const [index, { start, end, text }] of edits.entries()) {
+        if (start < cursor || end < start || end > code.length) {
+            throw new TeacssEngineError("E_INVALID_ARGUMENT", `[@teacss/engine] replayEdits: edits[${index}] (${start}, ${end}) overlaps the previous edit or leaves the code (length ${code.length})`, { path: `edits[${index}]`, start, end });
+        }
+        out += code.slice(cursor, start) + text;
+        cursor = end;
+    }
+    return out + code.slice(cursor);
+}
+export const CSS_PLACEHOLDER = markers().cssPlaceholder;
+// same as teacss-ts core isCssId
+const cssIdMatcher = /\.(css|postcss|sass|scss|less|stylus|styl)($|\?)/;
+export function isCssId(id) {
+    return cssIdMatcher.test(id);
+}
+//# sourceMappingURL=project.js.map