@teacss/bun 0.9.3 → 0.10.2

package/README.md

@@ -1,65 +1,41 @@
 # @teacss/bun
 
-Bun Build integration for TeaCSS.
+The `Bun.build` plugin for TeaCSS. It calls the Rust engine (`@teacss/engine`) in process and turns `virtual:teacss.css`, or a CSS entry's `@teacss;`, into the generated CSS. It needs Bun 1.4 or later.
+
+## Install
 
 ```sh
-bun add --dev teacss @teacss/bun
+bun add --dev @teacss/bun
 ```
 
+## Use
+
 ```ts
-import { pluginTeacss } from "@teacss/bun";
+// build.ts, run with `bun build.ts`
+import { teacss } from "@teacss/bun";
 
-await Bun.build({
-  entrypoints: ["./src/index.ts"],
-  outdir: "./dist",
-  plugins: [pluginTeacss()],
-});
+await Bun.build({ entrypoints: ["./src/index.ts"], outdir: "./dist", plugins: [teacss()] });
 ```
 
-Import `virtual:teacss.css` from the application. `pluginTeacss()` is for a
-one-shot build because Bun's plugin API does not expose watch invalidation.
-
-For programmatic watch builds, use `watchTeacssBuild`:
-
-```ts
-import { watchTeacssBuild } from "@teacss/bun";
-
-const session = await watchTeacssBuild(
-  { entrypoints: ["./src/index.ts"], outdir: "./dist" },
-  {
-    configOrPath: "./index.css",
-    onError: (error) => console.error(error),
-  },
-);
+Configuration lives in a CSS entry. Create `index.css` at the project root:
 
-await session.dispose();
+```css
+@presets "standard,icons,official";
+@source "./src/**/*.{js,jsx,ts,tsx,html}";
+@teacss;
 ```
 
-The session exposes the latest successful `result`, current `error`, and
-successful-build `version`. Failed rebuilds preserve the last valid result and
-continue watching configuration, module, entry, and positive `@source` roots.
-`dispose()` waits for active work and is safe to call more than once.
+Import the generated CSS once from the application entry, either as `virtual:teacss.css` or as the entry itself:
 
-Bun versions before 1.3.6 cannot expose extra module-graph inputs through a
-metafile, so watch coverage is limited to entries, TeaCSS configuration, and
-`@source` roots.
+```ts
+// src/index.ts
+import "virtual:teacss.css";
+```
 
-Pre-1.0. Source compile-class transformers are not run by this adapter.
+With `outdir` set, the Standard preset's fonts are written to `teacss-fonts/` beside the CSS. `watch(options, onBuild)` reruns `Bun.build` when a project file changes.
 
-Watch sessions update source-scanned shortcuts and safelists through file and
-source-root creation, removal, and recreation, including external absolute
-sources. Changes during configuration loading or a build cause another build
-before the session settles.
+## Documentation
 
-Glob-matched CSS file symlinks observe their physical file targets through
-filtered shallow parent watches, including recovery after a failed member read.
-A bounded declaration check every 500 ms also recovers changes omitted by native
-callbacks; unchanged declarations do not reload configuration or rebuild.
-Nested source directory symlinks observe physical target changes, including empty
-targets and target deletion or recreation. Missing routes use shallow parent
-observation. Failed reads retain the last accepted configuration. An initial
-failed declaration read also keeps its source routes watched, so repairing the
-source can produce the first build without touching the entry. If native watch
-creation fails with `EACCES`, successful desired watches remain active, including
-shallow recovery sentinels. The original error is reported; repeated failure
-alone does not keep retrying.
+- [Build integrations](https://github.com/teacss/teacss-rs/blob/master/skills/teacss/references/integrations.md) and [their options](https://github.com/teacss/teacss-rs/blob/master/skills/teacss/references/integrations.md#options)
+- [The CSS entry](https://github.com/teacss/teacss-rs/blob/master/skills/teacss/references/setup.md#css-entry)
+- [The TeaCSS skill](https://github.com/teacss/teacss-rs/blob/master/skills/teacss/SKILL.md) for syntax, presets and tooling

package/dist/index.d.ts

@@ -1,50 +1,32 @@
-import { UserConfig, UserConfigDefaults } from "@teacss/core";
-import { BuildConfig, BuildOutput, BunPlugin } from "bun";
-//#region src/index.d.ts
+import { type ShellOptions } from "@teacss/engine";
+import type { BuildConfig, BuildOutput, BunPlugin } from "bun";
+export type { ShellOptions } from "@teacss/engine";
 /**
- * Bun plugin for TeaCSS. Use it with `Bun.build` (or a `bunfig.toml` preload):
- *
- * ```ts
- * import { pluginTeacss } from "@teacss/bun";
- * await Bun.build({ entrypoints: ["./src/index.ts"], plugins: [pluginTeacss()] });
- * ```
- *
- * - `import "virtual:teacss.css"` (or `"teacss.css"`) resolves to the generated
- *   utilities — scanned from the project's content (the CSS entry's `@source`,
- *   else the default globs).
- * - every `.css` gets `@apply` / `@screen` / `theme()` / `icon()` inlined (the
- *   directive transformer fast-bails when none are present).
- *
- * Configuration comes from the CSS entry (`index.css` with `@presets` / `@source`
- * / `@custom`) or an inline `UserConfig` — there is no `teacss.config.*` file.
- * Like `@teacss/rsbuild`, this path does not run source transformers (so the
- * `:css:` compile-class transform is not applied here).
+ * v10.2 §3.4. `import "virtual:teacss.css"` (or `"teacss.css"`) becomes the generated stylesheet; every other
+ * module goes through `project.transform`, and in a CSS file whose top level has `@teacss;` the generated
+ * stylesheet then takes that rule's place. `minify` defaults to false, as teacss-ts's Bun plugin emits the
+ * stylesheet unminified.
  */
-export declare function pluginTeacss(configOrPath?: UserConfig<object> | string, defaults?: UserConfigDefaults): BunPlugin;
-export interface WatchTeacssBuildOptions {
-  /** CSS entry file, discovery root, or inline configuration. */
-  configOrPath?: UserConfig<object> | string;
-  /** Defaults merged below the resolved TeaCSS configuration. */
-  defaults?: UserConfigDefaults;
-  /** Filesystem event coalescing delay. @default 50 */
-  debounce?: number;
-  onBuild?: (result: BuildOutput) => void | Promise<void>;
-  onError?: (error: unknown) => void | Promise<void>;
+export declare function teacss(options?: ShellOptions): BunPlugin;
+export interface WatchOptions {
+    /** The `Bun.build` configuration; a plugin of this package already in `plugins` is replaced. */
+    build: BuildConfig;
+    shell?: ShellOptions;
+    /** Milliseconds between the last file event and the rebuild. Default 200. */
+    debounce?: number;
+    /** Called with a failed build's error or a watcher error. Default `console.error`. */
+    onError?: (error: unknown) => void;
 }
-export interface TeacssBuildWatchSession {
-  /** Latest background rebuild error, cleared by the next successful build. */
-  readonly error: unknown | undefined;
-  /** Latest successful build result, or undefined until the first success. */
-  readonly result: BuildOutput | undefined;
-  /** Number of successful builds. */
-  readonly version: number;
-  /** Stop this session without affecting other watch sessions. */
-  dispose(): Promise<void>;
+export interface WatchSession {
+    /** Successful builds so far, the first one included. */
+    readonly builds: number;
+    close(): void;
 }
 /**
- * Rebuild with Bun when either Bun's module graph or TeaCSS's graph-external
- * config and `@source` inputs change. Bun 1.3's plugin API has no dependency
- * registration or invalidation hook, so watch ownership lives in this helper.
+ * Builds once, then rebuilds whenever a file in a directory of `project.watchFiles()` (or the root) changes,
+ * or a file anywhere under a `@source` glob's directory (`project.sourceDirectories()`), outside `outdir`.
+ * Bun's plugin API has no dependency registration, so the watch owns the file list; it resolves after the
+ * first build has been reported.
  */
-export declare function watchTeacssBuild(buildConfig: BuildConfig, options?: WatchTeacssBuildOptions): Promise<TeacssBuildWatchSession>;
-//#endregion
+export declare function watch(options: WatchOptions, onBuild: (result: BuildOutput) => void | Promise<void>): Promise<WatchSession>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1 +1,188 @@
-import{AsyncLocalStorage as e}from"node:async_hooks";import{existsSync as t,watch as n}from"node:fs";import{mkdir as r,readFile as i,stat as a,writeFile as o}from"node:fs/promises";import{dirname as s,isAbsolute as c,join as l,resolve as u}from"node:path";import d from"node:process";import{entryDiscoveryFiles as f}from"@teacss/config";import{SourceWatchRegistry as p,createSourceDeclarationCheck as m,planSourceWatches as h,probeSourceDeclarations as g,scanSourceFiles as _,sourceDeclarationStateOf as v,sourceDeclarationWatchTargets as y,sourceWatchTargets as b}from"@teacss/config/internal/source-scan";import x from"@teacss/directives";import{applyTransformerPipeline as S,createContext as C,defaultFilesystemGlobs as w}from"@teacss/runtime";import{bundledAssetName as T,rewriteBundledAssets as E}from"@teacss/runtime/internal/bundled-assets";import{enableNodeCompileCache as ee}from"@teacss/runtime/internal/compile-cache";import{DEFAULT_SOURCE_IGNORE as D,generateSources as O}from"@teacss/runtime/source-generation";function te(e,t,n=Bun.version){let r={...e};return delete r.metafile,Bun.semver.satisfies(n,`>=1.3.6`)&&(r.metafile=!0),{...r,plugins:t}}ee();const k=/^(?:virtual:)?teacss\.css$/,A=/\.css$/,j=`teacss`;function ne(e){return e===void 0?{globs:w,ignore:D}:{globs:e,ignore:[]}}function re(e,t={}){return{name:`teacss`,async setup(n){let a=C(e,{...t,transformers:[...t.transformers??[],x()]}),c=n.config.root??d.cwd();await a.updateRoot(c);let u=new Set,f=new Set,p=!0,m=new Map;async function h(e){return n.config.outdir?(await E(e,e=>(m.set(e.digest,e),`./teacss-fonts/${T(e)}`))).toString():e}n.config.outdir&&(n.onResolve({filter:/^\.\/teacss-fonts\/teacss-[a-f0-9]{64}\.woff2$/},e=>{let t=e.path.slice(15);if([...m.values()].some(e=>T(e)===t))return{path:e.path,external:!0}}),n.onEnd(async e=>{if(e.success)for(let t of e.outputs){if(!t.path.endsWith(`.css`))continue;let e=await t.text(),n=l(s(t.path),`teacss-fonts`);for(let t of m.values()){let i=T(t);e.includes(`teacss-fonts/${i}`)&&(await r(n,{recursive:!0}),await o(l(n,i),t.bytes))}}}));function g(){let e=a.getConfigFileList()[0];return e?s(e):c}async function v(e){let t=e();u.add(t);try{return await t}finally{u.delete(t)}}n.onStart(async()=>{if(p){p=!1;return}await Promise.allSettled(u),m.clear();for(let e of f)await a.extract(``,e);f.clear(),await a.reloadConfig()}),n.onResolve({filter:k},()=>({path:`teacss.css`,namespace:j})),n.onLoad({filter:/.*/,namespace:j},()=>v(async()=>{let{globs:e,ignore:t}=ne((await a.getConfig()).content?.filesystem),n=await _(e,{cwd:g(),ignore:t,expandDirectories:!0}),{css:r}=await O(a.generator,n,void 0,{minify:!1});return{contents:await h(r),loader:`css`}})),n.onLoad({filter:A},e=>v(async()=>{let t=await i(e.path,`utf8`);return f.add(e.path),{contents:await h((await S(a,t,e.path))?.code??t),loader:`css`}}))}}}function ie(e){return`${e.mtimeMs}:${e.ctimeMs}:${e.size}:${e.ino}`}async function M(r,i={}){let o=u(r.root??d.cwd()),l=r.entrypoints.map(e=>c(e)?e:u(o,e)),{configOrPath:x,defaults:S={},debounce:T=50,onBuild:E,onError:ee}=i,D=C(x,S),O=new Set,k=!1,A=!1,j,M,N=!1,P,F=!1,I=!1,L=0,R=!1,z=``,B=new Set,V,ae,H=0,U=new Set,oe=new e;function W(){let e=D.getConfigFileList()[0];return e?s(e):o}async function G(){let{globs:e,ignore:t}=ne(D.generator.config.content?.filesystem);return await _(e,{cwd:W(),ignore:t,expandDirectories:!0})}function se(e){let t=e.content?.filesystem;if(!t)return e;let n=W();return{...e,content:{...e.content,filesystem:t.map(e=>e.startsWith(`!`)?`!${u(n,e.slice(1))}`:u(n,e))}}}function K(e,t,n){if(!t)return Promise.resolve();let r={active:!0},i;return i=oe.run(r,()=>Promise.resolve().then(()=>t(n)).catch(t=>console.error(`[@teacss/bun] watch ${e} callback failed:`,t)).finally(()=>{r.active=!1,U.delete(i)})),U.add(i),i}async function ce(){for(;U.size>0;)await Promise.all(U)}function q(e){return A?Promise.resolve():(V=e,K(`error`,ee,e))}function le(e,t=O){let n=[...D.getConfigFileList(),...l,...t,...e].map(e=>({kind:`exact`,path:e}));if(typeof x!=`object`){let e=typeof x==`string`?u(o,x):o;if(e.endsWith(`.css`))n.push({kind:`exact`,path:e});else for(let t of f)n.push({kind:`exact`,path:u(e,t)})}return n.push(...b(D.generator.config.content?.filesystem??w,W(),!0)),n.push(...y(v(D))),n}function J(e,t=O){return new Set([...D.getConfigFileList(),...l,...t,...e])}async function Y(e){let t=new Set(e.flatMap(e=>[...e])),n=new Map(await Promise.all([...t].map(async e=>{try{return[e,`${e}:${ie(await a(e))}`]}catch(t){if(t.code===`ENOENT`)return[e,`${e}:missing`];throw t}})));return e.map(e=>[...e].sort().map(e=>n.get(e)).join(`|`))}async function ue(e,t=O){return(await Y([J(e,t)]))[0]}let de=new p((e,t,r)=>n(e,{recursive:r},t),e=>{if(e!==void 0&&B.has(e)&&L++,!F){I=!0;return}$()},e=>{q(e)});function X(e,t=O){de.reconcile(h(le(e,t))),B=J(e,t)}function fe(e,t,n){return AggregateError([e,t],n)}function pe(e,n){return new Set(Object.keys(e.metafile?.inputs??{}).map(e=>c(e)?e:u(o,e)).filter(e=>!n||t(e)))}let Z,Q;async function me(e,t=O){if(A)return;let n=e,r=[];try{r=await G()}catch(e){n=fe(n,e,`TeaCSS build and source discovery failed`)}if(!A){try{X(r,t);let e=v(D),n=await g(e,!0,Z);Q=n,(await g(e)).signature!==n.signature&&(R=!0,F?N=!0:I=!0)}catch(e){n=fe(n,e,`TeaCSS build and watcher reconciliation failed`)}await q(n)}}async function he(){if(A)return;Z=await g(v(D));let e=L,t=new Set(B),[n]=await Y([t]);if(k?await D.reloadConfig():(k=!0,await D.updateRoot(o)),A)return;let i=await G();if(A||(X(i),A))return;let a=v(D),s=await g(a,!0,Z);Q=s;let c=await g(a),l=s.signature!==c.signature,[u]=await Y([t]),d=n!==u||l,f=await ue(i);if(A)return;let p=R;if(R=!1,!p&&!d&&H>0&&V===void 0&&f===z)return;let m=se(await D.getConfig());if(A)return;let h=[...(r.plugins??[]).filter(e=>e.name!==`teacss`),re(m)],_=await Bun.build(te(r,h));if(A)return;if(!_.success){await me(_,new Set([...O,...pe(_,!1)]));return}let y=pe(_,!0),b=await G();if(A)return;let x=[...y].some(e=>!B.has(e));if(X(b,y),A)return;let[S,C]=await Y([J(b),J(b,y)]);if(A)return;let w=await g(a),T=d||s?.signature!==w?.signature||x||S!==f||L!==e;ae=_,V=void 0,H++,O=y,z=C,await K(`build`,E,_),T&&(R=!0,F?N=!0:I=!0)}async function ge(){try{await he()}catch(e){await me(e)}}async function _e(){do N=!1,await ge();while(N&&!A)}function $(){A||(M&&clearTimeout(M),M=setTimeout(()=>{M=void 0,N=!0,P||=_e().finally(()=>{P=void 0,N&&!A&&$()})},T))}function ve(){A=!0,ye.retire(),M&&clearTimeout(M),M=void 0,de.retire()}await ge(),F=!0;let ye=m(()=>v(D),async e=>{A||M||N||e.signature===Q?.signature||(P?N=!0:$())},q);return I&&$(),{get error(){return V},get result(){return ae},get version(){return H},dispose(){return oe.getStore()?.active?(ve(),Promise.resolve()):(j??=(async()=>{ve(),await ye.close(),await P,await ce()})(),j)}}}export{re as pluginTeacss,M as watchTeacssBuild};
+import { existsSync, watch as watchDirectory } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { createProject, extractBundledFonts, replaceEntry } from "@teacss/engine";
+const PLUGIN = "teacss";
+const VIRTUAL_ENTRY = /^(?:virtual:)?teacss\.css$/;
+const MODULE = /\.(?:[cm]?[jt]sx?|html)$/;
+const CSS = /\.css$/;
+const NODE_MODULES = `${sep}node_modules${sep}`;
+// teacss-ts `rewriteBundledAssets` writes each bundled font as `teacss-fonts/teacss-<sha256>.woff2` beside the CSS.
+const FONT_URL_PREFIX = "./teacss-fonts/teacss-";
+const FONT_URL = /^\.\/teacss-fonts\/teacss-[a-f0-9]{64}\.woff2$/;
+/**
+ * v10.2 §3.4: the tokens of every `@source` file read once and of `inline.content.inline`. `warned` holds the
+ * unmatched-token warnings already printed by earlier builds of the same plugin.
+ */
+function generateCss(project, minify, warned) {
+    const union = project.engine.extractFilesUnion(project.info.sourceFiles);
+    for (const path of project.info.unreadableDirectories)
+        console.warn(`[@teacss/bun] cannot read ${path} (E_IO)`);
+    for (const { path, error } of union.failed)
+        console.warn(`[@teacss/bun] cannot read ${path} (${error})`);
+    const tokens = [...new Set([...union.tokens, ...project.inlineTokens()])];
+    const result = project.engine.generate({ kind: "tokens", tokens }, { minify, css: true });
+    project.reportUnmatched(result, {
+        tokens,
+        warn: (message) => {
+            if (warned.has(message))
+                return;
+            warned.add(message);
+            console.warn(`[@teacss/bun] ${message}`);
+        },
+    });
+    return result.css;
+}
+function externalizeFonts(css, fonts) {
+    const extracted = extractBundledFonts(css, (digest) => `${FONT_URL_PREFIX}${digest}.woff2`);
+    for (const font of extracted.fonts)
+        fonts.set(font.digest, font.bytes);
+    return extracted.css;
+}
+async function writeFonts(result, fonts) {
+    if (!result.success || fonts.size === 0)
+        return;
+    for (const output of result.outputs) {
+        if (!output.path.endsWith(".css"))
+            continue;
+        const css = await output.text();
+        const directory = join(dirname(output.path), "teacss-fonts");
+        for (const [digest, bytes] of fonts) {
+            const name = `teacss-${digest}.woff2`;
+            if (!css.includes(`teacss-fonts/${name}`))
+                continue;
+            await mkdir(directory, { recursive: true });
+            await writeFile(join(directory, name), bytes);
+        }
+    }
+}
+function projectRoot(options, config) {
+    return resolve(options.root ?? config.root ?? process.cwd());
+}
+/**
+ * v10.2 §3.4. `import "virtual:teacss.css"` (or `"teacss.css"`) becomes the generated stylesheet; every other
+ * module goes through `project.transform`, and in a CSS file whose top level has `@teacss;` the generated
+ * stylesheet then takes that rule's place. `minify` defaults to false, as teacss-ts's Bun plugin emits the
+ * stylesheet unminified.
+ */
+export function teacss(options = {}) {
+    // `watch()` runs every build through this one plugin; each build gets a fresh project, so that no module or
+    // compile-class definition of a file deleted or renamed since lingers, and the warnings outlive it here.
+    const warned = new Set();
+    return {
+        name: PLUGIN,
+        setup(build) {
+            const project = createProject({ ...options, root: projectRoot(options, build.config) });
+            const fonts = new Map();
+            const externalize = build.config.outdir ? (css) => externalizeFonts(css, fonts) : (css) => css;
+            const generated = () => externalize(generateCss(project, options.minify ?? false, warned));
+            build.onResolve({ filter: VIRTUAL_ENTRY }, () => ({ path: "teacss.css", namespace: PLUGIN }));
+            // Bun bundles every `url()` of a stylesheet; the fonts exist only after `onEnd` writes them.
+            build.onResolve({ filter: FONT_URL }, (args) => (fonts.has(args.path.slice(FONT_URL_PREFIX.length, -".woff2".length)) ? { path: args.path, external: true } : undefined));
+            build.onLoad({ filter: /.*/, namespace: PLUGIN }, () => ({ contents: generated(), loader: "css" }));
+            build.onLoad({ filter: CSS }, async (args) => {
+                const { code } = project.transform(args.path, await readFile(args.path, "utf8"));
+                return { contents: replaceEntry(code, generated) ?? externalize(code), loader: "css" };
+            });
+            build.onLoad({ filter: MODULE }, async (args) => {
+                const code = await readFile(args.path, "utf8");
+                if (args.path.includes(NODE_MODULES) && !code.includes("@teacss-include"))
+                    return;
+                const result = project.transform(args.path, code);
+                return result.changed ? { contents: result.code, loader: args.loader } : undefined;
+            });
+            build.onEnd(async (result) => {
+                project.dispose();
+                await writeFonts(result, fonts);
+            });
+        },
+    };
+}
+/**
+ * Builds once, then rebuilds whenever a file in a directory of `project.watchFiles()` (or the root) changes,
+ * or a file anywhere under a `@source` glob's directory (`project.sourceDirectories()`), outside `outdir`.
+ * Bun's plugin API has no dependency registration, so the watch owns the file list; it resolves after the
+ * first build has been reported.
+ */
+export async function watch(options, onBuild) {
+    const { build, shell = {}, debounce = 200, onError = console.error } = options;
+    const root = projectRoot(shell, build);
+    const plugins = [...(build.plugins ?? []).filter((plugin) => plugin.name !== PLUGIN), teacss({ ...shell, root })];
+    const project = createProject({ ...shell, root });
+    const outdir = build.outdir === undefined ? undefined : resolve(build.outdir);
+    const watchers = new Map();
+    let timer;
+    let running = false;
+    let queued = false;
+    let closed = false;
+    let builds = 0;
+    function syncWatchers() {
+        project.reload();
+        const wanted = new Map([root, ...project.watchFiles().map((file) => dirname(file))].map((directory) => [directory, false]));
+        for (const { dir } of project.sourceDirectories())
+            if (existsSync(dir))
+                wanted.set(dir, true);
+        for (const [directory, { watcher, recursive }] of watchers) {
+            if (wanted.get(directory) === recursive)
+                continue;
+            watcher.close();
+            watchers.delete(directory);
+        }
+        for (const [directory, recursive] of wanted) {
+            if (watchers.has(directory))
+                continue;
+            const watcher = watchDirectory(directory, { recursive }, (_event, file) => {
+                if (file === null || !isOutput(resolve(directory, file)))
+                    schedule();
+            });
+            watchers.set(directory, { watcher: watcher.on("error", onError), recursive });
+        }
+    }
+    function isOutput(file) {
+        return outdir !== undefined && (file === outdir || file.startsWith(`${outdir}${sep}`));
+    }
+    async function run() {
+        running = true;
+        do {
+            queued = false;
+            try {
+                syncWatchers();
+                const result = await Bun.build({ ...build, plugins });
+                if (!result.success)
+                    throw new AggregateError(result.logs, "[@teacss/bun] build failed");
+                builds++;
+                await onBuild(result);
+            }
+            catch (error) {
+                onError(error);
+            }
+        } while (queued && !closed);
+        running = false;
+    }
+    function schedule() {
+        if (closed)
+            return;
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            if (running)
+                queued = true;
+            else
+                void run();
+        }, debounce);
+    }
+    await run();
+    return {
+        get builds() {
+            return builds;
+        },
+        close() {
+            closed = true;
+            clearTimeout(timer);
+            for (const { watcher } of watchers.values())
+                watcher.close();
+            watchers.clear();
+            project.dispose();
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,44 +1,50 @@
 {
   "name": "@teacss/bun",
-  "version": "0.9.3",
-  "description": "Bun plugin for TeaCSS — generate utilities and inline @apply via Bun.build.",
-  "homepage": "https://css.teasim.com",
-  "funding": "https://github.com/sponsors/billgo",
+  "version": "0.10.2",
+  "description": "Bun.build plugin for TeaCSS: virtual:teacss.css and the entry's @teacss become the CSS the Rust engine generates",
   "license": "MIT",
-  "author": "Billgo <hi@billgo.me>",
-  "sideEffects": false,
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/teacss/teacss-rs.git",
+    "directory": "packages/bun"
+  },
+  "homepage": "https://github.com/teacss/teacss-rs/tree/master/packages/bun#readme",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
     "./package.json": "./package.json"
   },
-  "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "README.md"
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
   ],
-  "scripts": {
-    "build": "bunx tsdown --config tsdown.config.mts",
-    "dev": "tsdown --watch"
+  "sideEffects": false,
+  "engines": {
+    "bun": ">=1.4.0",
+    "node": ">=26"
   },
   "dependencies": {
-    "@teacss/config": "0.9.3",
-    "@teacss/core": "0.9.3",
-    "@teacss/directives": "0.9.3",
-    "@teacss/engine": "0.9.3",
-    "@teacss/runtime": "0.9.3",
-    "tinyglobby": "^0.2.17"
+    "@teacss/engine": "0.10.2"
   },
   "devDependencies": {
-    "@teacss/preset-standard": "0.9.3",
-    "bun-types": "^1.4.1",
-    "consola": "^3.4.2"
+    "@types/bun": "1.4.3",
+    "typescript": "^5.9.3"
   },
-  "engines": {
-    "bun": ">=1.1.0",
-    "node": ">=22.12.0"
+  "scripts": {
+    "build:ts": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "build": "npm run build:ts",
+    "test": "bun test",
+    "check:types": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   }
 }