@teacss/engine 0.9.4 → 0.10.2

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@teacss/engine",
-  "version": "0.9.4",
-  "description": "In-process Rust engine for TeaCSS 0.9 (napi-rs binding and 0.8.x-compatible facade)",
+  "version": "0.10.2",
+  "description": "In-process Rust engine for TeaCSS (napi-rs binding, contract types and the project helper the shells share)",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -21,14 +21,6 @@
       "types": "./binding.d.ts",
       "default": "./binding.js"
     },
-    "./facade": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./select": {
-      "types": "./dist/select.d.ts",
-      "default": "./dist/select.js"
-    },
     "./package.json": "./package.json"
   },
   "imports": {
@@ -41,11 +33,12 @@
     "binding-header.d.ts",
     "dist/**/*.js",
     "dist/**/*.d.ts",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "sideEffects": false,
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=26"
   },
   "napi": {
     "binaryName": "teacss-engine",
@@ -59,45 +52,23 @@
       "aarch64-unknown-linux-gnu",
       "aarch64-unknown-linux-musl",
       "x86_64-pc-windows-msvc",
-      "aarch64-pc-windows-msvc",
-      "wasm32-wasip1-threads"
+      "aarch64-pc-windows-msvc"
     ]
   },
-  "engineCompat": {
-    "core": ">=0.8.5 <0.10.0",
-    "defaultMode": "auto",
-    "oracle": {
-      "teacssTs": "0.8.5",
-      "commit": "786b4d40"
-    }
-  },
   "optionalDependencies": {
-    "@teacss/engine-darwin-arm64": "0.9.4",
-    "@teacss/engine-darwin-x64": "0.9.4",
-    "@teacss/engine-linux-arm64-gnu": "0.9.4",
-    "@teacss/engine-linux-arm64-musl": "0.9.4",
-    "@teacss/engine-linux-x64-gnu": "0.9.4",
-    "@teacss/engine-linux-x64-musl": "0.9.4",
-    "@teacss/engine-win32-arm64-msvc": "0.9.4",
-    "@teacss/engine-win32-x64-msvc": "0.9.4"
-  },
-  "peerDependencies": {
-    "@teacss/config": ">=0.8.5 <0.10.0 || >=0.9.0-alpha.0 <0.10.0",
-    "@teacss/core": ">=0.8.5 <0.10.0 || >=0.9.0-alpha.0 <0.10.0"
-  },
-  "peerDependenciesMeta": {
-    "@teacss/core": {
-      "optional": true
-    },
-    "@teacss/config": {
-      "optional": true
-    }
+    "@teacss/engine-darwin-arm64": "0.10.2",
+    "@teacss/engine-darwin-x64": "0.10.2",
+    "@teacss/engine-linux-arm64-gnu": "0.10.2",
+    "@teacss/engine-linux-arm64-musl": "0.10.2",
+    "@teacss/engine-linux-x64-gnu": "0.10.2",
+    "@teacss/engine-linux-x64-musl": "0.10.2",
+    "@teacss/engine-win32-arm64-msvc": "0.10.2",
+    "@teacss/engine-win32-x64-msvc": "0.10.2"
   },
   "devDependencies": {
     "@napi-rs/cli": "3.10.8",
     "@types/node": "^22.20.5",
     "emnapi": "1.11.3",
-    "magic-string": "^0.30.17",
     "typescript": "^5.9.3"
   },
   "scripts": {
@@ -107,12 +78,12 @@
     "artifacts": "napi artifacts --output-dir ../../artifacts --npm-dir npm",
     "create-npm-dirs": "napi create-npm-dirs",
     "prepublishOnly": "npm run build:ts && node build/scripts/check-publish.js",
-    "test": "npm run build:ts && npm run check:types && node --expose-gc --test \"build/test/**/*.test.js\"",
+    "test": "npm run build:ts && npm run check:types && node --expose-gc --test \"build/tests/**/*.test.js\"",
     "check:version": "npm run build:ts && node build/scripts/sync-version.js --check",
     "check:size": "node build/scripts/size-budget.js",
-    "version": "napi version && npm run build:ts && node build/scripts/sync-version.js --write && git add npm/*/package.json package-lock.json ../../Cargo.toml ../../Cargo.lock ../../package-lock.json",
-    "build:ts": "tsc -p tsconfig.json && tsc -p tsconfig.test.json",
-    "check:types": "tsc -p test/consumer/tsconfig.json --noEmit",
+    "version": "napi version && npm run build:ts && node build/scripts/sync-version.js --write && git add -- npm/*/package.json package-lock.json ../*/package.json ../*/npm/*/package.json ../*/package-lock.json ../../Cargo.toml ../../Cargo.lock ../../extensions/zed/Cargo.toml ../../extensions/zed/extension.toml ../../extensions/zed/Cargo.lock ../../package-lock.json",
+    "build:ts": "node -e \"require('fs').rmSync('build',{recursive:true,force:true})\" && tsc -p tsconfig.json && tsc -p tsconfig.test.json",
+    "check:types": "tsc -p tests/consumer/tsconfig.json --noEmit",
     "check:publish": "node build/scripts/check-publish.js",
     "check:tag": "node build/scripts/check-tag.js",
     "inspect-binding": "node build/scripts/inspect-binding.js",
@@ -122,8 +93,7 @@
     "release:evidence": "node build/scripts/release-evidence.js",
     "publish:npm": "node build/scripts/publish.js",
     "dist-tag": "node build/scripts/dist-tag.js",
-    "qualify": "node build/scripts/qualify.js",
-    "setup-wasi-sdk": "node build/scripts/setup-wasi-sdk.js"
+    "qualify": "node build/scripts/qualify.js"
   },
   "publishConfig": {
     "access": "public",

package/dist/config-view.d.ts

@@ -1,36 +0,0 @@
-/** Fields the TypeScript generator provides; reading one before materialize throws `E_TS_REQUIRED`. */
-export declare const TS_ONLY_FIELDS: readonly string[];
-/** Fields copied from the Rust `ResolvedConfigView`. */
-export declare const VIEW_FIELDS: readonly string[];
-export interface ConfigViewArgs {
-    view: Record<string, any>;
-    request: object;
-    presets: object[];
-    /** The merged config (`mergeDefinedConfig(defaults, userConfig)`, config.ts:210) the oracle spreads. */
-    merged: Record<string, unknown>;
-    transformers: object[];
-    host: {
-        core?: {
-            extractorSplit: object;
-        } | undefined;
-    };
-    fallback: {
-        peek(): {
-            config: Record<string, unknown>;
-        } | null;
-    };
-    engine?: {
-        compileClassShortcuts(): unknown[];
-    };
-}
-/**
- * The merged `content.pipeline` of the presets and the config, as `mergeContentOptions`
- * (core/config.ts) builds it: `false` anywhere disables it, otherwise includes and excludes
- * concatenate in source order without duplicates. The runtime builds its module filter from it.
- */
-export declare function mergePipeline(sources: readonly unknown[]): false | {
-    include?: Array<string | RegExp>;
-    exclude?: Array<string | RegExp>;
-} | undefined;
-export declare function createConfigView({ view, presets, merged, transformers, host, fallback, engine }: ConfigViewArgs): Record<string, unknown>;
-//# sourceMappingURL=config-view.d.ts.map

package/dist/config-view.js

@@ -1,135 +0,0 @@
-// The facade's `generator.config`: a plain object whose keys follow the oracle `resolveConfig`
-// (core/config.ts:260-288), which spreads the merged config and then sets its own fields.
-import { tsNotReadyError } from "./errors.js";
-/** Fields the TypeScript generator provides; reading one before materialize throws `E_TS_REQUIRED`. */
-export const TS_ONLY_FIELDS = Object.freeze(["configResolved", "extendTheme", "preprocess", "postprocess", "preflights", "autocomplete", "rules", "rulesDynamic", "rulesStaticMap", "variants"]);
-/** Fields copied from the Rust `ResolvedConfigView`. */
-export const VIEW_FIELDS = Object.freeze(["layers", "theme", "shortcuts", "safelist", "blocklist", "separators", "envMode", "unmatched", "shortcutsLayer", "virtualModulePrefix", "mergeSelectors", "warn", "details", "outputToCssLayers", "rulesSize"]);
-/**
- * The keys `resolveConfig` always sets, in its order (config.ts:262-288); `configResolved`,
- * `extendTheme`, `extractorDefault` and `virtualModulePrefix` appear only through the spread.
- */
-const RESOLVED_KEYS = Object.freeze([
-    "mergeSelectors",
-    "warn",
-    "unmatched",
-    "outputToCssLayers",
-    "sortLayers",
-    "blocklist",
-    "presets",
-    "envMode",
-    "shortcutsLayer",
-    "layers",
-    "theme",
-    "rules",
-    "rulesSize",
-    "rulesDynamic",
-    "rulesStaticMap",
-    "preprocess",
-    "postprocess",
-    "preflights",
-    "autocomplete",
-    "variants",
-    "shortcuts",
-    "extractors",
-    "safelist",
-    "separators",
-    "details",
-    "content",
-    "transformers",
-]);
-const ownValue = (source, key) => (source !== null && typeof source === "object" && Object.hasOwn(source, key) ? source[key] : undefined);
-const flattenPatterns = (patterns) => [...new Set(patterns.flatMap((pattern) => (Array.isArray(pattern) ? pattern : pattern ? [pattern] : [])))];
-/**
- * The merged `content.pipeline` of the presets and the config, as `mergeContentOptions`
- * (core/config.ts) builds it: `false` anywhere disables it, otherwise includes and excludes
- * concatenate in source order without duplicates. The runtime builds its module filter from it.
- */
-export function mergePipeline(sources) {
-    const includes = [];
-    const excludes = [];
-    let configured = false;
-    for (const content of new Set(sources.map((source) => ownValue(source, "content")).filter((content) => content !== undefined && content !== null))) {
-        const pipeline = ownValue(content, "pipeline");
-        if (pipeline === false)
-            return false;
-        if (pipeline === undefined)
-            continue;
-        configured = true;
-        const include = pipeline && ownValue(pipeline, "include");
-        const exclude = pipeline && ownValue(pipeline, "exclude");
-        if (include)
-            includes.push(include);
-        if (exclude)
-            excludes.push(exclude);
-    }
-    if (!configured)
-        return undefined;
-    const merged = {};
-    if (includes.length)
-        merged.include = flattenPatterns(includes);
-    if (excludes.length)
-        merged.exclude = flattenPatterns(excludes);
-    return merged;
-}
-export function createConfigView({ view, presets, merged, transformers, host, fallback, engine }) {
-    const config = {};
-    const data = (key, value) => Object.defineProperty(config, key, { value, enumerable: true, configurable: true, writable: true });
-    const tsOnly = (key) => Object.defineProperty(config, key, {
-        enumerable: true,
-        configurable: true,
-        get() {
-            const ts = fallback.peek();
-            if (!ts)
-                throw tsNotReadyError(`config.${key}`);
-            return ts.config[key];
-        },
-    });
-    const extractors = host.core ? [host.core.extractorSplit] : [{ name: view.extractors?.[0]?.name ?? "@teacss/core/extractor-split" }];
-    const fields = {
-        presets: () => data("presets", presets),
-        content: () => {
-            const pipeline = mergePipeline([...presets, merged]);
-            data("content", pipeline === undefined ? (view.content ?? {}) : { pipeline, ...view.content });
-        },
-        transformers: () => data("transformers", transformers),
-        extractors: () => data("extractors", extractors),
-        extractorDefault: () => data("extractorDefault", extractors[0]),
-        sortLayers: () => data("sortLayers", (layers) => layers),
-    };
-    for (const key of VIEW_FIELDS)
-        fields[key] = () => data(key, view[key]);
-    // config.ts:263. Rust never warns, so its view does not carry the option.
-    fields.warn = () => data("warn", (Object.hasOwn(merged, "warn") ? merged.warn : undefined) ?? true);
-    if (engine) {
-        // compile-class.ts:84-106 pushes each definition onto `config.shortcuts` and splices it out
-        // when its last module drops it; the definitions live in the Engine, so one array is kept in
-        // step on every read.
-        const shortcuts = [...(view.shortcuts ?? [])];
-        const configured = shortcuts.length;
-        fields.shortcuts = () => Object.defineProperty(config, "shortcuts", {
-            enumerable: true,
-            configurable: true,
-            get() {
-                shortcuts.length = configured;
-                shortcuts.push(...engine.compileClassShortcuts());
-                return shortcuts;
-            },
-        });
-    }
-    for (const key of TS_ONLY_FIELDS)
-        fields[key] = () => tsOnly(key);
-    for (const key of Object.keys(merged)) {
-        if (key === "engine")
-            continue;
-        if (Object.hasOwn(fields, key))
-            fields[key]();
-        else
-            data(key, merged[key]);
-    }
-    // Redefining a spread key keeps its position, as the object literal does.
-    for (const key of RESOLVED_KEYS)
-        fields[key]();
-    return config;
-}
-//# sourceMappingURL=config-view.js.map

package/dist/constants.d.ts

@@ -1,22 +0,0 @@
-/** `@teacss/engine`'s own package.json version; the facade `generator.version` without a host. */
-export declare const ENGINE_PACKAGE_VERSION: string;
-/** `package.json#engineCompat` (v02.11 §7.3); without it `core` is unrestricted and `defaultMode` is `"auto"`. */
-export declare const ENGINE_COMPAT: Readonly<{
-    core: string | undefined;
-    defaultMode: "opt-in" | "auto";
-    oracle: {
-        teacssTs: string;
-        commit: string;
-    } | undefined;
-}>;
-export declare const ENGINE_INSTANCE: unique symbol;
-export declare const ENGINE_MATERIALIZE: unique symbol;
-export declare const ENGINE_STATS: unique symbol;
-export declare const PRESET_OPTIONS: Readonly<{
-    standard: symbol;
-    icons: symbol;
-    official: symbol;
-}>;
-export declare const CONFIG_SOURCE_DECLARATIONS: unique symbol;
-export declare const CONFIG_ENTRY_PROVENANCE: unique symbol;
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -1,23 +0,0 @@
-// The facade's symbols and package constants. It imports nothing from the facade, so every
-// facade module can import it without a cycle through `index.ts`.
-import { createRequire } from "node:module";
-const pkg = createRequire(import.meta.url)("../package.json");
-/** `@teacss/engine`'s own package.json version; the facade `generator.version` without a host. */
-export const ENGINE_PACKAGE_VERSION = pkg.version;
-/** `package.json#engineCompat` (v02.11 §7.3); without it `core` is unrestricted and `defaultMode` is `"auto"`. */
-export const ENGINE_COMPAT = Object.freeze({
-    core: pkg.engineCompat?.core,
-    defaultMode: pkg.engineCompat?.defaultMode ?? "auto",
-    oracle: pkg.engineCompat?.oracle,
-});
-export const ENGINE_INSTANCE = Symbol.for("@teacss/engine/instance");
-export const ENGINE_MATERIALIZE = Symbol.for("@teacss/engine/materialize");
-export const ENGINE_STATS = Symbol.for("@teacss/engine/stats");
-export const PRESET_OPTIONS = Object.freeze({
-    standard: Symbol.for("@teacss/preset-standard/options"),
-    icons: Symbol.for("@teacss/preset-icons/options"),
-    official: Symbol.for("@teacss/preset-official/options"),
-});
-export const CONFIG_SOURCE_DECLARATIONS = Symbol.for("@teacss/config/source-declarations");
-export const CONFIG_ENTRY_PROVENANCE = Symbol.for("@teacss/config/entry-provenance");
-//# sourceMappingURL=constants.js.map

package/dist/countable-set.d.ts

@@ -1,57 +0,0 @@
-export declare const MAX_RUNTIME_CACHE_ENTRIES = 10000;
-export declare class CountableSet<K> extends Set<K> {
-    _map: Map<K, number>;
-    constructor(values?: Iterable<K>);
-    add(key: K): this;
-    delete(key: K): boolean;
-    clear(): void;
-    getCount(key: K): number;
-    setCount(key: K, count: number): this;
-}
-export declare function isCountableSet(value: unknown): value is CountableSet<string>;
-export declare function copyCountableSet<K>(input: CountableSet<K>): CountableSet<K>;
-/**
- * Expands the tokens holding a `{…}` group in place; the parts go to the end, and a counted
- * group's count carries over to each part.
- */
-export declare function expandInputGroups<T extends Set<string>>(tokens: T): T;
-/**
- * The part of the oracle `BoundedMap` the facade uses: ordinary keys are evicted oldest first,
- * retained keys never count toward the limit. An entry can be pending (`setPending`,
- * `replaceRetainedPending`): its value is `resolve(token)`, computed on the first read through
- * `get`, `forEach` or iteration and kept in place; `has`, `size`, `delete` and eviction never
- * resolve.
- */
-export declare class BoundedTokenCache<V> extends Map<string, V> {
-    #private;
-    maxEntries: number;
-    retained: Set<string>;
-    /** Ordinary keys in insertion order, the order the native map iterates them. */
-    order: Set<string>;
-    /** The value of a pending entry, called once per entry on its first read. */
-    resolve: (token: string) => V;
-    constructor(maxEntries?: number, resolve?: (token: string) => V);
-    get retainedSize(): number;
-    isRetained(key: string): boolean;
-    get(key: string): V | undefined;
-    entries(): MapIterator<[string, V]>;
-    values(): MapIterator<V>;
-    [Symbol.iterator](): MapIterator<[string, V]>;
-    forEach(callback: (value: V, key: string, map: Map<string, V>) => void, thisArg?: unknown): void;
-    set(key: string, value: V): this;
-    /** Caches `key` with the value `resolve` supplies on its first read. */
-    setPending(key: string): this;
-    delete(key: string): boolean;
-    clear(): void;
-    /** Replaces the retained entries (bounded-cache.ts:188-205 without the revision check). */
-    replaceRetained(entries: Iterable<readonly [string, V]>): void;
-    /** `replaceRetained` with every value pending. */
-    replaceRetainedPending(keys: Iterable<string>): void;
-}
-/** FIFO bounded Set (the oracle `BoundedSet` without its `assumeNoPrototypeBypass` fast path). */
-export declare class BoundedSet extends Set<string> {
-    maxEntries: number;
-    constructor(maxEntries?: number, values?: Iterable<string>);
-    add(value: string): this;
-}
-//# sourceMappingURL=countable-set.d.ts.map