@fuzdev/gro 0.192.0

package/dist/esbuild_plugin_sveltekit_local_imports.js

@@ -0,0 +1,30 @@
+import { readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { resolve_specifier } from "./resolve_specifier.js";
+import { EVERYTHING_MATCHER } from "./constants.js";
+/**
+ * Adds support for imports to both `.ts` and `.js`,
+ * as well as imports without extensions that resolve to `.js` or `.ts`.
+ * Prefers `.ts` over any `.js`, and falls back to `.ts` if no file is found.
+ */
+export const esbuild_plugin_sveltekit_local_imports = () => ({
+    name: 'sveltekit_local_imports',
+    setup: (build) => {
+        build.onResolve({ filter: /^(\/|\.)/ }, async (args) => {
+            const { path, importer } = args;
+            if (!importer)
+                return { path };
+            const { path_id, namespace } = await resolve_specifier(path, dirname(importer));
+            return { path: path_id, namespace }; // `namespace` may be `undefined`, but esbuild needs the absolute path for json etc
+        });
+        build.onLoad({ filter: EVERYTHING_MATCHER, namespace: 'sveltekit_local_imports_ts' }, async ({ path }) => ({
+            contents: await readFile(path),
+            loader: 'ts',
+            resolveDir: dirname(path),
+        }));
+        build.onLoad({ filter: EVERYTHING_MATCHER, namespace: 'sveltekit_local_imports_js' }, async ({ path }) => ({
+            contents: await readFile(path),
+            resolveDir: dirname(path),
+        }));
+    },
+});

package/dist/esbuild_plugin_sveltekit_shim_alias.d.ts

@@ -0,0 +1,7 @@
+import type * as esbuild from 'esbuild';
+export interface EsbuildPluginSveltekitShimAliasOptions {
+    dir?: string;
+    alias?: Record<string, string>;
+}
+export declare const esbuild_plugin_sveltekit_shim_alias: ({ dir, alias, }: EsbuildPluginSveltekitShimAliasOptions) => esbuild.Plugin;
+//# sourceMappingURL=esbuild_plugin_sveltekit_shim_alias.d.ts.map

package/dist/esbuild_plugin_sveltekit_shim_alias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild_plugin_sveltekit_shim_alias.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/esbuild_plugin_sveltekit_shim_alias.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,SAAS,CAAC;AAIxC,MAAM,WAAW,sCAAsC;IACtD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,eAAO,MAAM,mCAAmC,GAAI,iBAGjD,sCAAsC,KAAG,OAAO,CAAC,MAclD,CAAC"}

package/dist/esbuild_plugin_sveltekit_shim_alias.js

@@ -0,0 +1,18 @@
+import { escape_regexp } from '@fuzdev/fuz_util/regexp.js';
+import { join } from 'node:path';
+export const esbuild_plugin_sveltekit_shim_alias = ({ dir = process.cwd(), alias, }) => ({
+    name: 'sveltekit_shim_alias',
+    setup: (build) => {
+        const aliases = { $lib: 'src/lib', ...alias };
+        // Create a Go-compatible regexp
+        const filter = new RegExp(`^(?:${Object.keys(aliases).map(escape_regexp).join('|')})`);
+        build.onResolve({ filter }, async (args) => {
+            const { path, ...rest } = args;
+            // Find which alias prefix matches
+            const prefix = Object.keys(aliases).find((key) => path.startsWith(key));
+            if (!prefix)
+                return null;
+            return build.resolve(join(dir, aliases[prefix] + path.substring(prefix.length)), rest);
+        });
+    },
+});

package/dist/esbuild_plugin_sveltekit_shim_app.d.ts

@@ -0,0 +1,9 @@
+import type * as esbuild from 'esbuild';
+import type { ParsedSvelteConfig } from './svelte_config.ts';
+export interface EsbuildPluginSveltekitShimAppOptions {
+    dev: boolean;
+    base_url: ParsedSvelteConfig['base_url'];
+    assets_url: ParsedSvelteConfig['assets_url'];
+}
+export declare const esbuild_plugin_sveltekit_shim_app: ({ dev, base_url, assets_url, }: EsbuildPluginSveltekitShimAppOptions) => esbuild.Plugin;
+//# sourceMappingURL=esbuild_plugin_sveltekit_shim_app.d.ts.map

package/dist/esbuild_plugin_sveltekit_shim_app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild_plugin_sveltekit_shim_app.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/esbuild_plugin_sveltekit_shim_app.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,SAAS,CAAC;AAOxC,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAG3D,MAAM,WAAW,oCAAoC;IACpD,GAAG,EAAE,OAAO,CAAC;IACb,QAAQ,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACzC,UAAU,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC;CAC7C;AAED,eAAO,MAAM,iCAAiC,GAAI,gCAI/C,oCAAoC,KAAG,OAAO,CAAC,MAqBhD,CAAC"}

package/dist/esbuild_plugin_sveltekit_shim_app.js

@@ -0,0 +1,22 @@
+import { render_sveltekit_shim_app_environment, render_sveltekit_shim_app_paths, sveltekit_shim_app_specifiers, } from "./sveltekit_shim_app.js";
+import { EVERYTHING_MATCHER } from "./constants.js";
+export const esbuild_plugin_sveltekit_shim_app = ({ dev, base_url, assets_url, }) => ({
+    name: 'sveltekit_shim_app',
+    setup: (build) => {
+        build.onResolve({ filter: /^\$app\/(forms|navigation|stores)$/ }, ({ path, ...rest }) => build.resolve(sveltekit_shim_app_specifiers.get(path), rest));
+        build.onResolve({ filter: /^\$app\/paths$/ }, ({ path }) => ({
+            path: sveltekit_shim_app_specifiers.get(path),
+            namespace: 'sveltekit_shim_app_paths',
+        }));
+        build.onLoad({ filter: EVERYTHING_MATCHER, namespace: 'sveltekit_shim_app_paths' }, () => ({
+            contents: render_sveltekit_shim_app_paths(base_url, assets_url),
+        }));
+        build.onResolve({ filter: /^\$app\/environment$/ }, ({ path }) => ({
+            path: sveltekit_shim_app_specifiers.get(path),
+            namespace: 'sveltekit_shim_app_environment',
+        }));
+        build.onLoad({ filter: EVERYTHING_MATCHER, namespace: 'sveltekit_shim_app_environment' }, () => ({
+            contents: render_sveltekit_shim_app_environment(dev),
+        }));
+    },
+});

package/dist/esbuild_plugin_sveltekit_shim_env.d.ts

@@ -0,0 +1,11 @@
+import type * as esbuild from 'esbuild';
+export interface EsbuildPluginSveltekitShimEnvOptions {
+    dev: boolean;
+    public_prefix?: string;
+    private_prefix?: string;
+    env_dir?: string;
+    env_files?: Array<string>;
+    ambient_env?: Record<string, string>;
+}
+export declare const esbuild_plugin_sveltekit_shim_env: ({ dev, public_prefix, private_prefix, env_dir, env_files, ambient_env, }: EsbuildPluginSveltekitShimEnvOptions) => esbuild.Plugin;
+//# sourceMappingURL=esbuild_plugin_sveltekit_shim_env.d.ts.map

package/dist/esbuild_plugin_sveltekit_shim_env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild_plugin_sveltekit_shim_env.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/esbuild_plugin_sveltekit_shim_env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,SAAS,CAAC;AAKxC,MAAM,WAAW,oCAAoC;IACpD,GAAG,EAAE,OAAO,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAID,eAAO,MAAM,iCAAiC,GAAI,0EAO/C,oCAAoC,KAAG,OAAO,CAAC,MAuBhD,CAAC"}

package/dist/esbuild_plugin_sveltekit_shim_env.js

@@ -0,0 +1,18 @@
+import { render_env_shim_module } from "./sveltekit_shim_env.js";
+import { SVELTEKIT_ENV_MATCHER, EVERYTHING_MATCHER } from "./constants.js";
+const namespace = 'sveltekit_shim_env';
+export const esbuild_plugin_sveltekit_shim_env = ({ dev, public_prefix, private_prefix, env_dir, env_files, ambient_env, }) => ({
+    name: 'sveltekit_shim_env',
+    setup: (build) => {
+        build.onResolve({ filter: SVELTEKIT_ENV_MATCHER }, ({ path }) => ({ path, namespace }));
+        build.onLoad({ filter: EVERYTHING_MATCHER, namespace }, ({ path }) => {
+            const matches = SVELTEKIT_ENV_MATCHER.exec(path);
+            const mode = matches[1];
+            const visibility = matches[2];
+            return {
+                loader: 'ts',
+                contents: render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env),
+            };
+        });
+    },
+});

package/dist/filer.d.ts

@@ -0,0 +1,33 @@
+import type { OmitStrict } from '@fuzdev/fuz_util/types.js';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { PackageJson } from '@fuzdev/fuz_util/package_json.js';
+import type { FileFilter, PathId } from '@fuzdev/fuz_util/path.js';
+import { watch_dir, type WatcherChange, type WatchDirOptions } from './watch_dir.ts';
+import type { Disknode } from './disknode.ts';
+export type OnFilerChange = (change: WatcherChange, disknode: Disknode) => void;
+export interface FilerOptions {
+    watch_dir?: typeof watch_dir;
+    watch_dir_options?: Partial<OmitStrict<WatchDirOptions, 'on_change'>>;
+    package_json_cache?: Record<string, PackageJson>;
+    log?: Logger;
+}
+export declare class Filer {
+    #private;
+    readonly root_dir: PathId;
+    readonly files: Map<PathId, Disknode>;
+    constructor(options?: FilerOptions);
+    get inited(): boolean;
+    get_by_id: (id: PathId) => Disknode | undefined;
+    get_or_create: (id: PathId) => Disknode;
+    filter(predicate: (disknode: Disknode) => boolean): Array<Disknode> | null;
+    /**
+     * Initialize the filer to populate files without watching.
+     * Safe to call multiple times - subsequent calls are no-ops.
+     * Used by gen files to access the file graph.
+     */
+    init(): Promise<void>;
+    watch(listener: OnFilerChange): Promise<() => void>;
+    close(): Promise<void>;
+}
+export declare const filter_dependents: (disknode: Disknode, get_by_id: (id: PathId) => Disknode | undefined, filter?: FileFilter, results?: Set<PathId>, searched?: Set<PathId>, log?: Logger) => Set<PathId>;
+//# sourceMappingURL=filer.d.ts.map

package/dist/filer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filer.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/filer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2BAA2B,CAAC;AAI1D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAC,UAAU,EAAE,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAGjE,OAAO,EACN,SAAS,EAET,KAAK,aAAa,EAClB,KAAK,eAAe,EAEpB,MAAM,gBAAgB,CAAC;AAOxB,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AAI5C,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;AAEhF,MAAM,WAAW,YAAY;IAC5B,SAAS,CAAC,EAAE,OAAO,SAAS,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC,CAAC;IACtE,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED,qBAAa,KAAK;;IACjB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAG1B,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAa;gBAetC,OAAO,GAAE,YAA2B;IAUhD,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,SAAS,GAAI,IAAI,MAAM,KAAG,QAAQ,GAAG,SAAS,CAE5C;IAEF,aAAa,GAAI,IAAI,MAAM,KAAG,QAAQ,CAqBpC;IAEF,MAAM,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,IAAI;IAU1E;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAsDrB,KAAK,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC;IAmBzD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CA8OtB;AAGD,eAAO,MAAM,iBAAiB,GAC7B,UAAU,QAAQ,EAClB,WAAW,CAAC,EAAE,EAAE,MAAM,KAAK,QAAQ,GAAG,SAAS,EAC/C,SAAS,UAAU,EACnB,UAAS,GAAG,CAAC,MAAM,CAAa,EAChC,WAAU,GAAG,CAAC,MAAM,CAAa,EACjC,MAAM,MAAM,KACV,GAAG,CAAC,MAAM,CAuBZ,CAAC"}

package/dist/filer.js

@@ -0,0 +1,385 @@
+import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.js';
+import { readFile, stat } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { isBuiltin } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { UnreachableError } from '@fuzdev/fuz_util/error.js';
+import { hash_secure } from '@fuzdev/fuz_util/hash.js';
+import { watch_dir, } from "./watch_dir.js";
+import { paths } from "./paths.js";
+import { parse_imports } from "./parse_imports.js";
+import { resolve_specifier } from "./resolve_specifier.js";
+import { default_svelte_config } from "./svelte_config.js";
+import { map_sveltekit_aliases } from "./sveltekit_helpers.js";
+import { SVELTEKIT_GLOBAL_SPECIFIER } from "./constants.js";
+const aliases = Object.entries(default_svelte_config.alias);
+export class Filer {
+    root_dir;
+    // TODO rename everything to `disknode`
+    files = new Map();
+    #watch_dir;
+    #watch_dir_options;
+    #log;
+    #listeners = new Set();
+    #watching;
+    #initing;
+    #closing;
+    #change_queue = [];
+    #processing_promise = null;
+    constructor(options = EMPTY_OBJECT) {
+        this.#watch_dir = options.watch_dir ?? watch_dir;
+        this.#watch_dir_options = options.watch_dir_options ?? EMPTY_OBJECT;
+        this.root_dir = resolve(options.watch_dir_options?.dir ?? paths.source);
+        // TODO for package.json maybe another array of files/dirs to watch to invalidate everything?
+        // or instead of that, think of taking an array of config objects that can specify invalidation rules,
+        // so package.json would be configured differently than ./src, and we could add a default with
+        // package.json/gro.config.ts/tsconfig.json/svelte.config.js/vite.config.ts to invalidate everything
+        this.#log = options.log;
+    }
+    get inited() {
+        return this.#watching !== undefined;
+    }
+    get_by_id = (id) => {
+        return this.files.get(id);
+    };
+    get_or_create = (id) => {
+        const existing = this.get_by_id(id);
+        if (existing)
+            return existing;
+        const file = {
+            id,
+            contents: null,
+            external: this.#is_external(id), // TODO maybe filter externals by default? the user needs to configure the filer then
+            ctime: null,
+            mtime: null,
+            content_hash: null,
+            dependents: new Map(),
+            dependencies: new Map(),
+        };
+        this.files.set(id, file);
+        // Defer external file change notification to avoid reentrancy during queue processing
+        if (file.external) {
+            queueMicrotask(() => {
+                this.#on_change({ type: 'add', path: file.id, is_directory: false });
+            });
+        }
+        return file;
+    };
+    filter(predicate) {
+        let found = null;
+        for (const disknode of this.files.values()) {
+            if (predicate(disknode)) {
+                (found ??= []).push(disknode);
+            }
+        }
+        return found;
+    }
+    /**
+     * Initialize the filer to populate files without watching.
+     * Safe to call multiple times - subsequent calls are no-ops.
+     * Used by gen files to access the file graph.
+     */
+    async init() {
+        // if already initing, return the existing promise
+        if (this.#initing)
+            return this.#initing;
+        // if already initialized, just ensure ready
+        if (this.#watching) {
+            return this.#watching.init();
+        }
+        // start new initialization
+        this.#initing = this.#init();
+        try {
+            await this.#initing;
+        }
+        catch (error) {
+            // use shared cleanup logic
+            this.#cleanup();
+            throw error;
+        }
+        finally {
+            this.#initing = undefined;
+        }
+    }
+    async #init() {
+        const watcher = this.#watch_dir({
+            ...this.#watch_dir_options,
+            dir: this.root_dir,
+            on_change: this.#on_change,
+        });
+        try {
+            await watcher.init();
+            // Wait for any queued changes from init to be processed
+            await this.#drain_queue();
+            // check if close() was called during init
+            if (this.#closing) {
+                await watcher.close();
+                return;
+            }
+            // only set after successful init and not closing
+            this.#watching = watcher;
+        }
+        catch (error) {
+            // clean up watcher on error, but don't let close error mask init error
+            try {
+                await watcher.close();
+            }
+            catch {
+                // ignore close errors - init error is more important
+            }
+            throw error;
+        }
+    }
+    async watch(listener) {
+        await this.#add_listener(listener);
+        return () => {
+            this.#remove_listener(listener);
+        };
+    }
+    /**
+     * Internal cleanup of all state - can be called safely from anywhere
+     */
+    #cleanup() {
+        this.#listeners.clear();
+        this.files.clear();
+        this.#watching = undefined;
+        this.#change_queue = [];
+        this.#processing_promise = null;
+        // #initing is handled in finally block of init()
+    }
+    close() {
+        // if already closing, return existing promise
+        if (this.#closing)
+            return this.#closing;
+        // if already closed and not initing, nothing to do
+        if (!this.#watching && !this.#initing)
+            return Promise.resolve();
+        // start new close operation
+        const closing = this.#close();
+        this.#closing = closing;
+        // Clean up after completion, but don't change the returned promise
+        // Use void to ensure we don't accidentally return the .then() promise
+        void closing.then(() => {
+            this.#closing = undefined;
+        }, () => {
+            this.#closing = undefined;
+        });
+        return this.#closing;
+    }
+    async #close() {
+        // wait for any pending initialization to complete
+        if (this.#initing) {
+            try {
+                await this.#initing;
+            }
+            catch {
+                // ignore errors during close
+            }
+        }
+        // close watcher if it exists
+        if (this.#watching) {
+            await this.#watching.close();
+        }
+        // clean up all state
+        this.#cleanup();
+    }
+    async #update(id) {
+        const file = this.get_or_create(id);
+        let stats = null;
+        let new_contents = null; // TODO need to lazily load contents, probably turn `Disknode` into a class
+        try {
+            [stats, new_contents] = await Promise.all([stat(id), readFile(id, 'utf8')]);
+        }
+        catch (error) {
+            const code = error.code;
+            // Treat file as deleted/inaccessible for common error codes
+            if (code === 'ENOENT' || code === 'EACCES' || code === 'EPERM') {
+                // File doesn't exist or is inaccessible, treat as deleted
+            }
+            else {
+                throw error;
+            }
+        }
+        // Compute hash for new contents
+        const new_hash = new_contents !== null ? await hash_secure(new_contents) : null;
+        file.ctime = stats?.ctimeMs ?? null;
+        file.mtime = stats?.mtimeMs ?? null;
+        // Use hash comparison for change detection (content-based, not mtime-based)
+        if (file.content_hash === new_hash) {
+            return null;
+        }
+        file.contents = new_contents;
+        file.content_hash = new_hash;
+        const dir = dirname(file.id);
+        const dependencies_before = new Set(file.dependencies.keys());
+        const dependencies_removed = new Set(dependencies_before);
+        let imported = [];
+        if (file.contents) {
+            try {
+                imported = parse_imports(file.id, file.contents);
+            }
+            catch (error) {
+                this.#log?.error('[filer] Failed to parse imports', file.id, error);
+            }
+        }
+        for (const specifier of imported) {
+            if (SVELTEKIT_GLOBAL_SPECIFIER.test(specifier))
+                continue;
+            const path = map_sveltekit_aliases(specifier, aliases);
+            let path_id;
+            // TODO can we replace `resolve_specifier` with `import.meta.resolve` completely now outside of esbuild plugins?
+            if (path[0] === '.' || path[0] === '/') {
+                const resolved = await resolve_specifier(path, dir); // eslint-disable-line no-await-in-loop
+                path_id = resolved.path_id;
+            }
+            else {
+                if (isBuiltin(path))
+                    continue;
+                const file_url = pathToFileURL(file.id);
+                try {
+                    path_id = fileURLToPath(import.meta.resolve(path, file_url.href));
+                }
+                catch (error) {
+                    // if resolving fails for any reason, just log and ignore it
+                    this.#log?.error('[filer] failed to resolve path', path, file_url.href, error);
+                    continue;
+                }
+            }
+            dependencies_removed.delete(path_id);
+            if (!dependencies_before.has(path_id)) {
+                const d = this.get_or_create(path_id);
+                file.dependencies.set(d.id, d);
+                d.dependents.set(file.id, file);
+            }
+        }
+        // update any removed dependencies
+        for (const dependency_removed of dependencies_removed) {
+            file.dependencies.delete(dependency_removed);
+            const dependency_removed_file = this.get_or_create(dependency_removed);
+            dependency_removed_file.dependents.delete(file.id);
+        }
+        return file;
+    }
+    #remove(id) {
+        const file = this.get_by_id(id);
+        if (!file)
+            return null; // this is safe because the object would exist if any other file referenced it as a dependency or dependent
+        file.contents = null; // clear contents in case it gets re-added later, we want the change to be detected
+        file.content_hash = null; // clear hash so re-add detects the change
+        file.dependencies.clear();
+        // keep the file in memory if other files still depend on it
+        if (file.dependents.size === 0) {
+            this.files.delete(id);
+        }
+        return file;
+    }
+    #sync_listener_with_files(listener) {
+        for (const disknode of this.files.values()) {
+            try {
+                listener({ type: 'add', path: disknode.id, is_directory: false }, disknode);
+            }
+            catch (error) {
+                this.#log?.error('[filer] Listener error during sync:', error);
+            }
+        }
+    }
+    #notify_change(change, disknode) {
+        for (const listener of this.#listeners) {
+            try {
+                listener(change, disknode);
+            }
+            catch (error) {
+                this.#log?.error('[filer] Listener error during change notification:', error);
+            }
+        }
+    }
+    async #add_listener(listener) {
+        this.#listeners.add(listener);
+        // ensure initialized
+        await this.init();
+        // notify of existing files
+        this.#sync_listener_with_files(listener);
+    }
+    #remove_listener(listener) {
+        this.#listeners.delete(listener);
+        // keep watching active even with no listeners, only close() tears down
+    }
+    async #drain_queue() {
+        // Wait for queue to be empty and no active processing
+        while (this.#change_queue.length > 0 || this.#processing_promise) {
+            await this.#process_queue(); // eslint-disable-line no-await-in-loop
+        }
+    }
+    async #process_queue() {
+        // If already processing, return the existing promise
+        if (this.#processing_promise)
+            return this.#processing_promise;
+        // Create and track the processing promise
+        this.#processing_promise = this.#do_process_queue();
+        try {
+            await this.#processing_promise;
+        }
+        finally {
+            this.#processing_promise = null;
+        }
+    }
+    async #do_process_queue() {
+        while (this.#change_queue.length > 0) {
+            const change = this.#change_queue.shift();
+            if (this.#closing)
+                continue; // ignore changes during close
+            if (change.is_directory)
+                continue; // TODO manage directories?
+            let disknode;
+            switch (change.type) {
+                case 'add':
+                case 'update': {
+                    disknode = await this.#update(change.path); // eslint-disable-line no-await-in-loop
+                    break;
+                }
+                case 'delete': {
+                    disknode = this.#remove(change.path);
+                    break;
+                }
+                default:
+                    throw new UnreachableError(change.type);
+            }
+            if (disknode && this.#listeners.size > 0) {
+                this.#notify_change(change, disknode);
+            }
+        }
+    }
+    #on_change = (change) => {
+        // Enqueue the change (sync callback from chokidar)
+        this.#change_queue.push(change);
+        // Start processing if not already running
+        void this.#process_queue();
+    };
+    #is_external(id) {
+        const { filter } = this.#watch_dir_options;
+        return !id.startsWith(this.root_dir + '/') || (!!filter && !filter(id, false));
+    }
+}
+// TODO maybe `Disknode` class?
+export const filter_dependents = (disknode, get_by_id, filter, results = new Set(), searched = new Set(), log) => {
+    // Use iterative approach to avoid stack overflow on deep dependency trees
+    const stack = [disknode];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        for (const dependent_id of current.dependents.keys()) {
+            if (searched.has(dependent_id))
+                continue;
+            searched.add(dependent_id);
+            if (!filter || filter(dependent_id)) {
+                results.add(dependent_id);
+            }
+            const dependent_disknode = get_by_id(dependent_id);
+            if (!dependent_disknode) {
+                log?.warn(`[filer.filter_dependents] dependent source file ${dependent_id} not found for ${current.id}`);
+                continue;
+            }
+            stack.push(dependent_disknode);
+        }
+    }
+    return results;
+};

package/dist/format.task.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    _: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    check: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=format.task.d.ts.map

package/dist/format.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/format.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAMtB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAE/C,cAAc;AACd,eAAO,MAAM,IAAI;;;kBAMf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAuB3B,CAAC"}

package/dist/format.task.js

@@ -0,0 +1,27 @@
+import { print_spawn_result } from '@fuzdev/fuz_util/process.js';
+import { z } from 'zod';
+import { to_implicit_forwarded_args } from "./args.js";
+import { PRETTIER_CLI_DEFAULT } from "./constants.js";
+import { format_directory } from "./format_directory.js";
+import { paths } from "./paths.js";
+import { TaskError } from "./task.js";
+/** @nodocs */
+export const Args = z.strictObject({
+    _: z.array(z.string()).meta({ description: 'files or directories to format' }).optional(),
+    check: z
+        .boolean()
+        .meta({ description: 'exit with a nonzero code if any files are unformatted' })
+        .default(false),
+});
+/** @nodocs */
+export const task = {
+    summary: 'format source files',
+    Args,
+    run: async ({ args, log, config }) => {
+        const { _: patterns, check } = args;
+        const format_result = await format_directory(log, paths.source, check, undefined, undefined, undefined, config.pm_cli, to_implicit_forwarded_args(PRETTIER_CLI_DEFAULT), patterns);
+        if (!format_result.ok) {
+            throw new TaskError(`Failed ${check ? 'formatting check' : 'to format'}. ${print_spawn_result(format_result)}`);
+        }
+    },
+};

package/dist/format_directory.d.ts

@@ -0,0 +1,13 @@
+import { type Args } from '@fuzdev/fuz_util/args.js';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { SpawnResult } from '@fuzdev/fuz_util/process.js';
+import { type Cli } from './cli.ts';
+/**
+ * Formats files on the filesystem.
+ * When `patterns` is provided, formats those specific files/patterns.
+ * Otherwise formats `dir` with default extensions, plus root files if `dir` is `paths.source`.
+ * This is separated from `./format_file` to avoid importing all of the `prettier` code
+ * inside modules that import this one. (which has a nontrivial cost)
+ */
+export declare const format_directory: (log: Logger, dir: string, check?: boolean, extensions?: string, root_paths?: string, prettier_cli?: string | Cli, pm_cli?: string, additional_args?: Args, patterns?: Array<string>) => Promise<SpawnResult>;
+//# sourceMappingURL=format_directory.d.ts.map

package/dist/format_directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format_directory.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/format_directory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,IAAI,EAAC,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAyB,KAAK,GAAG,EAAC,MAAM,UAAU,CAAC;AAuB1D;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC5B,KAAK,MAAM,EACX,KAAK,MAAM,EACX,eAAa,EACb,mBAA+B,EAC/B,mBAA+B,EAC/B,eAAc,MAAM,GAAG,GAA0B,EACjD,SAAQ,MAAuB,EAC/B,kBAAkB,IAAI,EACtB,WAAW,KAAK,CAAC,MAAM,CAAC,KACtB,OAAO,CAAC,WAAW,CAoBrB,CAAC"}

package/dist/format_directory.js

@@ -0,0 +1,40 @@
+import { args_serialize } from '@fuzdev/fuz_util/args.js';
+import { spawn_cli, to_cli_name } from "./cli.js";
+import { GITHUB_DIRNAME, README_FILENAME, SVELTE_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, GRO_CONFIG_FILENAME, PM_CLI_DEFAULT, PRETTIER_CLI_DEFAULT, } from "./constants.js";
+import { paths } from "./paths.js";
+const EXTENSIONS_DEFAULT = 'ts,js,json,svelte,html,css,md,yml';
+const ROOT_PATHS_DEFAULT = `${[
+    README_FILENAME,
+    GRO_CONFIG_FILENAME,
+    SVELTE_CONFIG_FILENAME,
+    VITE_CONFIG_FILENAME,
+    TSCONFIG_FILENAME,
+    GITHUB_DIRNAME,
+].join(',')}/**/*`;
+/**
+ * Formats files on the filesystem.
+ * When `patterns` is provided, formats those specific files/patterns.
+ * Otherwise formats `dir` with default extensions, plus root files if `dir` is `paths.source`.
+ * This is separated from `./format_file` to avoid importing all of the `prettier` code
+ * inside modules that import this one. (which has a nontrivial cost)
+ */
+export const format_directory = async (log, dir, check = false, extensions = EXTENSIONS_DEFAULT, root_paths = ROOT_PATHS_DEFAULT, prettier_cli = PRETTIER_CLI_DEFAULT, pm_cli = PM_CLI_DEFAULT, additional_args, patterns) => {
+    const forwarded_args = { ...additional_args };
+    if (forwarded_args.check === undefined && forwarded_args.write === undefined) {
+        forwarded_args[check ? 'check' : 'write'] = true;
+    }
+    const serialized_args = args_serialize(forwarded_args);
+    if (patterns?.length) {
+        serialized_args.push(...patterns);
+    }
+    else {
+        serialized_args.push(`${dir}**/*.{${extensions}}`);
+        if (dir === paths.source) {
+            serialized_args.push(`${paths.root}{${root_paths}}`);
+        }
+    }
+    const spawned = await spawn_cli(prettier_cli, serialized_args, log);
+    if (!spawned)
+        throw Error(`failed to find \`${to_cli_name(prettier_cli)}\` CLI locally or globally, do you need to run \`${pm_cli} install\`?`);
+    return spawned;
+};