@simplysm/core-node 13.0.76 → 13.0.77

package/README.md

@@ -23,73 +23,382 @@ pnpm add @simplysm/core-node
 
 ## Filesystem Utilities
 
-[Full documentation: docs/fs.md](docs/fs.md)
-
-Wraps the built-in `fs` module with recursive directory creation, retry logic, glob support, and consistent error wrapping via `SdError`. Both synchronous (`Sync` suffix) and asynchronous variants are provided for all operations.
-
-| Function | Description |
-|----------|-------------|
-| `fsExistsSync` / `fsExists` | Check if a path exists |
-| `fsMkdirSync` / `fsMkdir` | Create directory recursively |
-| `fsRmSync` / `fsRm` | Delete file or directory recursively (async retries on lock) |
-| `fsCopySync` / `fsCopy` | Copy file or directory with optional filter |
-| `fsReadSync` / `fsRead` | Read file as UTF-8 string |
-| `fsReadBufferSync` / `fsReadBuffer` | Read file as `Buffer` |
-| `fsReadJsonSync` / `fsReadJson` | Read and parse a JSON file |
-| `fsWriteSync` / `fsWrite` | Write string or `Uint8Array` to file (auto-creates parent dirs) |
-| `fsWriteJsonSync` / `fsWriteJson` | Serialize and write JSON to file |
-| `fsReaddirSync` / `fsReaddir` | List directory entries |
-| `fsStatSync` / `fsStat` | Get `fs.Stats` following symlinks |
-| `fsLstatSync` / `fsLstat` | Get `fs.Stats` without following symlinks |
-| `fsGlobSync` / `fsGlob` | Find files by glob pattern (returns absolute paths) |
-| `fsClearEmptyDirectory` | Recursively delete empty directories |
-| `fsFindAllParentChildPathsSync` / `fsFindAllParentChildPaths` | Find matching paths by traversing parent directories |
+Import as a namespace:
+
+```ts
+import { fsx } from "@simplysm/core-node";
+```
+
+Wraps the built-in `fs` module with recursive directory creation, retry logic, glob support, and consistent error wrapping via `SdError`. Both synchronous (`Sync` suffix) and asynchronous variants are provided for most operations.
+
+### Existence Check
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.existsSync` | `(targetPath: string) => boolean` | Check if a path exists (synchronous) |
+| `fsx.exists` | `(targetPath: string) => Promise<boolean>` | Check if a path exists (asynchronous) |
+
+```ts
+if (await fsx.exists("/some/file.txt")) { /* ... */ }
+if (fsx.existsSync("/some/file.txt")) { /* ... */ }
+```
+
+### Create Directory
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.mkdirSync` | `(targetPath: string) => void` | Create directory recursively (synchronous) |
+| `fsx.mkdir` | `(targetPath: string) => Promise<void>` | Create directory recursively (asynchronous) |
+
+```ts
+await fsx.mkdir("/some/deep/dir");
+fsx.mkdirSync("/some/deep/dir");
+```
+
+### Delete
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.rmSync` | `(targetPath: string) => void` | Delete file or directory recursively (synchronous, no retry) |
+| `fsx.rm` | `(targetPath: string) => Promise<void>` | Delete file or directory recursively (asynchronous, retries up to 6 times at 500ms intervals on transient errors) |
+
+```ts
+await fsx.rm("/some/dir");
+fsx.rmSync("/some/file.txt");
+```
+
+### Copy
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.copySync` | `(sourcePath: string, targetPath: string, filter?: (absolutePath: string) => boolean) => void` | Copy file or directory (synchronous) |
+| `fsx.copy` | `(sourcePath: string, targetPath: string, filter?: (absolutePath: string) => boolean) => Promise<void>` | Copy file or directory (asynchronous) |
+
+If `sourcePath` does not exist, the function returns without error. The `filter` callback receives the absolute path of each child item; returning `false` excludes that item and its descendants. The top-level `sourcePath` is never filtered.
+
+```ts
+await fsx.copy("/src", "/dest", (p) => !p.includes("node_modules"));
+fsx.copySync("/src", "/dest");
+```
+
+### Read File
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.readSync` | `(targetPath: string) => string` | Read file as UTF-8 string (synchronous) |
+| `fsx.read` | `(targetPath: string) => Promise<string>` | Read file as UTF-8 string (asynchronous) |
+| `fsx.readBufferSync` | `(targetPath: string) => Buffer` | Read file as `Buffer` (synchronous) |
+| `fsx.readBuffer` | `(targetPath: string) => Promise<Buffer>` | Read file as `Buffer` (asynchronous) |
+| `fsx.readJsonSync` | `<TData = unknown>(targetPath: string) => TData` | Read and parse a JSON file (synchronous) |
+| `fsx.readJson` | `<TData = unknown>(targetPath: string) => Promise<TData>` | Read and parse a JSON file (asynchronous) |
+
+```ts
+const text = await fsx.read("/config.txt");
+const buf = fsx.readBufferSync("/image.png");
+const config = await fsx.readJson<Config>("/config.json");
+```
+
+### Write File
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.writeSync` | `(targetPath: string, data: string \| Uint8Array) => void` | Write to file, auto-creating parent directories (synchronous) |
+| `fsx.write` | `(targetPath: string, data: string \| Uint8Array) => Promise<void>` | Write to file, auto-creating parent directories (asynchronous) |
+| `fsx.writeJsonSync` | `(targetPath: string, data: unknown, options?: { replacer?: ..., space?: string \| number }) => void` | Serialize and write JSON to file (synchronous) |
+| `fsx.writeJson` | `(targetPath: string, data: unknown, options?: { replacer?: ..., space?: string \| number }) => Promise<void>` | Serialize and write JSON to file (asynchronous) |
+
+The `writeJsonSync`/`writeJson` `options` parameter:
+- `replacer?: (this: unknown, key: string | undefined, value: unknown) => unknown` — custom JSON replacer function
+- `space?: string | number` — indentation (passed to `JSON.stringify`)
+
+```ts
+await fsx.write("/output.txt", "hello");
+fsx.writeSync("/output.bin", new Uint8Array([1, 2, 3]));
+await fsx.writeJson("/config.json", { key: "value" }, { space: 2 });
+fsx.writeJsonSync("/config.json", { key: "value" });
+```
+
+### Read Directory
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.readdirSync` | `(targetPath: string) => string[]` | List directory entries (synchronous) |
+| `fsx.readdir` | `(targetPath: string) => Promise<string[]>` | List directory entries (asynchronous) |
+
+```ts
+const entries = await fsx.readdir("/some/dir");
+```
+
+### File Information
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.statSync` | `(targetPath: string) => fs.Stats` | Get `fs.Stats` following symlinks (synchronous) |
+| `fsx.stat` | `(targetPath: string) => Promise<fs.Stats>` | Get `fs.Stats` following symlinks (asynchronous) |
+| `fsx.lstatSync` | `(targetPath: string) => fs.Stats` | Get `fs.Stats` without following symlinks (synchronous) |
+| `fsx.lstat` | `(targetPath: string) => Promise<fs.Stats>` | Get `fs.Stats` without following symlinks (asynchronous) |
+
+```ts
+const stats = await fsx.stat("/some/file.txt");
+console.log(stats.size);
+```
+
+### Glob
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.globSync` | `(pattern: string, options?: GlobOptions) => string[]` | Find files by glob pattern, returns absolute paths (synchronous) |
+| `fsx.glob` | `(pattern: string, options?: GlobOptions) => Promise<string[]>` | Find files by glob pattern, returns absolute paths (asynchronous) |
+
+```ts
+const files = await fsx.glob("src/**/*.ts");
+const configs = fsx.globSync("**/tsconfig.json", { dot: true });
+```
+
+### Utilities
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `fsx.clearEmptyDirectory` | `(dirPath: string) => Promise<void>` | Recursively delete all empty directories under `dirPath`; if all children of a parent are removed, the parent is also deleted |
+| `fsx.findAllParentChildPathsSync` | `(childGlob: string, fromPath: string, rootPath?: string) => string[]` | Find matching paths by traversing parent directories toward the root (synchronous) |
+| `fsx.findAllParentChildPaths` | `(childGlob: string, fromPath: string, rootPath?: string) => Promise<string[]>` | Find matching paths by traversing parent directories toward the root (asynchronous) |
+
+`findAllParentChildPathsSync` / `findAllParentChildPaths` walk from `fromPath` up to `rootPath` (or the filesystem root if omitted), collecting all paths that match `childGlob` in each directory. `fromPath` must be a child of `rootPath`; otherwise the search goes to the filesystem root.
+
+```ts
+await fsx.clearEmptyDirectory("/build");
+
+const configs = fsx.findAllParentChildPathsSync("tsconfig.json", "/project/src", "/project");
+// → ["/project/src/tsconfig.json", "/project/tsconfig.json"]
+
+const pkgFiles = await fsx.findAllParentChildPaths("package.json", process.cwd());
+```
 
 ---
 
 ## Path Utilities
 
-[Full documentation: docs/path.md](docs/path.md)
+Import as a namespace:
+
+```ts
+import { pathx } from "@simplysm/core-node";
+```
 
 Complements the built-in `path` module with normalization, POSIX conversion, and filtering helpers.
 
-| Export | Description |
-|--------|-------------|
-| `NormPath` (type) | Branded string type for normalized absolute paths |
-| `pathNorm` | Resolve segments to an absolute `NormPath` |
-| `pathPosix` | Join and convert to forward-slash POSIX path |
-| `pathChangeFileDirectory` | Re-root a file path to a different base directory |
-| `pathBasenameWithoutExt` | Get filename without extension |
-| `pathIsChildPath` | Check if one path is strictly inside another |
-| `pathFilterByTargets` | Filter absolute paths by a list of relative targets |
+### Types
+
+| Type | Description |
+|------|-------------|
+| `pathx.NormPath` | Branded `string` type for normalized absolute paths. Can only be produced by `pathx.norm()`. |
+
+### Functions
+
+| Function | Signature | Description |
+|----------|-----------|-------------|
+| `pathx.norm` | `(...paths: string[]) => NormPath` | Resolve segments to an absolute `NormPath` using `path.resolve` |
+| `pathx.posix` | `(...args: string[]) => string` | Join segments and convert backslashes to forward slashes |
+| `pathx.changeFileDirectory` | `(filePath: string, fromDirectory: string, toDirectory: string) => string` | Re-root a file path to a different base directory; throws if `filePath` is not inside `fromDirectory` |
+| `pathx.basenameWithoutExt` | `(filePath: string) => string` | Get filename without its last extension |
+| `pathx.isChildPath` | `(childPath: string, parentPath: string) => boolean` | Return `true` if `childPath` is strictly inside `parentPath` (same path returns `false`) |
+| `pathx.filterByTargets` | `(files: string[], targets: string[], cwd: string) => string[]` | Filter absolute paths to only those matching or under any entry in `targets` (relative to `cwd`); returns `files` unchanged when `targets` is empty |
+
+```ts
+import { pathx } from "@simplysm/core-node";
+
+// norm
+const abs: pathx.NormPath = pathx.norm("relative", "path");
+
+// posix
+pathx.posix("C:\\Users\\test");         // "C:/Users/test"
+pathx.posix("src", "index.ts");         // "src/index.ts"
+
+// changeFileDirectory
+pathx.changeFileDirectory("/a/b/c.txt", "/a", "/x");  // "/x/b/c.txt"
+
+// basenameWithoutExt
+pathx.basenameWithoutExt("file.spec.ts");  // "file.spec"
+
+// isChildPath
+pathx.isChildPath("/a/b/c", "/a/b");  // true
+pathx.isChildPath("/a/b", "/a/b");    // false
+
+// filterByTargets
+const files = ["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts"];
+pathx.filterByTargets(files, ["src"], "/proj");
+// → ["/proj/src/a.ts", "/proj/src/b.ts"]
+```
 
 ---
 
 ## File System Watcher
 
-[Full documentation: docs/watcher.md](docs/watcher.md)
+```ts
+import { FsWatcher } from "@simplysm/core-node";
+import type { FsWatcherEvent, FsWatcherChangeInfo } from "@simplysm/core-node";
+```
+
+A chokidar-based watcher that debounces rapid events and delivers them as a single batched array to a callback. Glob patterns are supported in the `paths` array and are matched using minimatch.
+
+**Note:** `ignoreInitial` is always set to `true` internally. If you pass `options.ignoreInitial: false`, the callback is invoked once with an empty array on the first `onChange` call, but the actual initial file list is not included.
 
-A chokidar-based watcher that debounces rapid events and delivers them as a single batched array to a callback.
+### API
 
 | API | Description |
 |-----|-------------|
-| `FsWatcher.watch(paths, options?)` | Start watching; returns a ready `FsWatcher` instance |
-| `watcher.onChange(opt, cb)` | Register a debounced batch-change handler |
-| `watcher.close()` | Stop watching and dispose resources |
+| `FsWatcher.watch(paths, options?)` | Static method. Start watching and wait until the watcher is ready. Returns `Promise<FsWatcher>`. |
+| `watcher.onChange(opt, cb)` | Register a debounced batch-change handler. `opt.delay` sets the debounce window in ms. Returns `this` for chaining. |
+| `watcher.close()` | Stop watching and dispose all resources. Returns `Promise<void>`. |
 
-Related types: `FsWatcherEvent`, `FsWatcherChangeInfo`
+**`FsWatcher.watch` parameters:**
+- `paths: string[]` — file/directory paths or glob patterns to watch
+- `options?: ChokidarOptions` — passed to chokidar (except `ignoreInitial`, which is always overridden to `true`)
+
+**`onChange` parameters:**
+- `opt: { delay?: number }` — debounce delay in milliseconds
+- `cb: (changeInfos: FsWatcherChangeInfo[]) => void | Promise<void>` — called with the merged batch of changes
+
+**Event merging rules applied within a debounce window:**
+- `add` then `change` → `add`
+- `add` then `unlink` → removed (no change emitted)
+- `unlink` then `add` or `change` → `add`
+- `unlinkDir` then `addDir` → `addDir`
+- Otherwise the latest event wins.
+
+### Types
+
+```ts
+type FsWatcherEvent = "add" | "addDir" | "change" | "unlink" | "unlinkDir";
+
+interface FsWatcherChangeInfo {
+  event: FsWatcherEvent;
+  path: NormPath;  // normalized absolute path
+}
+```
+
+### Example
+
+```ts
+import { FsWatcher } from "@simplysm/core-node";
+
+const watcher = await FsWatcher.watch(["src/**/*.ts", "public"]);
+
+watcher.onChange({ delay: 300 }, async (changes) => {
+  for (const { event, path } of changes) {
+    console.log(`${event}: ${path}`);
+  }
+});
+
+// Later:
+await watcher.close();
+```
 
 ---
 
 ## Worker Thread Abstraction
 
-[Full documentation: docs/worker.md](docs/worker.md)
+```ts
+import { createWorker, Worker } from "@simplysm/core-node";
+import type {
+  WorkerModule,
+  WorkerProxy,
+  PromisifyMethods,
+  WorkerRequest,
+  WorkerResponse,
+} from "@simplysm/core-node";
+```
 
-Type-safe RPC bridge over Node.js `worker_threads`. Define methods in a worker file and call them from the main thread with full TypeScript inference.
+Type-safe RPC bridge over Node.js `worker_threads`. Define methods in a worker file and call them from the main thread with full TypeScript inference. In development (`.ts` files), workers are executed via `tsx`; in production (`.js` files), workers are executed directly.
 
-| API | Description |
-|-----|-------------|
-| `createWorker(methods)` | Register RPC methods inside a worker file |
-| `Worker.create(filePath, opt?)` | Create a typed proxy to the worker from the main thread |
+### `createWorker`
+
+Used inside a worker file to register RPC methods and optionally declare typed events.
+
+```ts
+function createWorker<
+  TMethods extends Record<string, (...args: any[]) => unknown>,
+  TEvents extends Record<string, unknown> = Record<string, never>,
+>(
+  methods: TMethods,
+): {
+  send<TEventName extends keyof TEvents & string>(event: TEventName, data?: TEvents[TEventName]): void;
+  __methods: TMethods;
+  __events: TEvents;
+}
+```
+
+- `methods` — object mapping method names to their implementations
+- Returns an object with a `send(event, data?)` method for emitting typed events to the main thread
+- The `__methods` and `__events` fields carry type information used by `Worker.create`
+
+```ts
+// worker.ts
+import { createWorker } from "@simplysm/core-node";
+
+interface MyEvents { progress: number; }
+
+const methods = {
+  add: (a: number, b: number) => a + b,
+  calc: (x: number) => {
+    sender.send("progress", 50);
+    return x * 2;
+  },
+};
+
+const sender = createWorker<typeof methods, MyEvents>(methods);
+export default sender;
+```
+
+### `Worker.create`
+
+Used in the main thread to create a typed proxy to a worker file.
 
-Related types: `WorkerModule`, `WorkerProxy`, `PromisifyMethods`, `WorkerRequest`, `WorkerResponse`
+```ts
+Worker.create<TModule extends WorkerModule>(
+  filePath: string,
+  opt?: Omit<WorkerOptions, "stdout" | "stderr">,
+): WorkerProxy<TModule>
+```
+
+- `filePath` — absolute path or `file://` URL to the worker file (`.ts` in development, `.js` in production)
+- `opt` — standard `worker_threads` `WorkerOptions` (excluding `stdout`/`stderr`, which are always piped)
+- Returns a `WorkerProxy` with all worker methods promisified, plus `on()`, `off()`, and `terminate()`
+
+```ts
+// main.ts
+import { Worker } from "@simplysm/core-node";
+
+const worker = Worker.create<typeof import("./worker")>("./worker.ts");
+
+worker.on("progress", (value) => console.log("progress:", value));
+
+const result = await worker.add(10, 20);  // 30
+await worker.terminate();
+```
+
+### Types
+
+| Type | Description |
+|------|-------------|
+| `WorkerModule` | Shape constraint for the module returned by `createWorker()`. Used as the type parameter of `Worker.create`. |
+| `WorkerProxy<TModule>` | Proxy type returned by `Worker.create()`. Provides promisified methods plus `on(event, listener)`, `off(event, listener)`, and `terminate()`. |
+| `PromisifyMethods<TMethods>` | Maps each method's return type to `Promise<Awaited<R>>`. |
+| `WorkerRequest` | Internal RPC request message shape: `{ id: string, method: string, params: unknown[] }`. |
+| `WorkerResponse` | Internal RPC response message — a discriminated union of `"return"`, `"error"`, `"event"`, and `"log"` variants. |
+
+### `WorkerProxy` interface detail
+
+```ts
+type WorkerProxy<TModule extends WorkerModule> =
+  PromisifyMethods<TModule["default"]["__methods"]> & {
+    on<TEventName extends keyof TModule["default"]["__events"] & string>(
+      event: TEventName,
+      listener: (data: TModule["default"]["__events"][TEventName]) => void,
+    ): void;
+    off<TEventName extends keyof TModule["default"]["__events"] & string>(
+      event: TEventName,
+      listener: (data: TModule["default"]["__events"][TEventName]) => void,
+    ): void;
+    terminate(): Promise<void>;
+  };
+```

package/dist/features/fs-watcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-watcher.d.ts","sourceRoot":"","sources":["..\\..\\src\\features\\fs-watcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAKrC,OAAO,EAAE,KAAK,QAAQ,EAAY,MAAM,eAAe,CAAC;AAyBxD;;GAEG;AACH,QAAA,MAAM,iBAAiB,6DAA8D,CAAC;AAEtF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,wBAAwB;IACxB,KAAK,EAAE,cAAc,CAAC;IACtB,+CAA+C;IAC/C,IAAI,EAAE,QAAQ,CAAC;CAChB;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,SAAS;IACpB;;;;;;OAMG;WACU,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC;IAU3F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAuB;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IAEjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAE5D,OAAO;IA6BP;;;;;;OAMG;IACH,QAAQ,CACN,GAAG,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,EACvB,EAAE,EAAE,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAC/D,IAAI;IA2EP;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAO7B"}
+{"version":3,"file":"fs-watcher.d.ts","sourceRoot":"","sources":["..\\..\\src\\features\\fs-watcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAKrC,OAAO,EAAE,KAAK,QAAQ,EAAQ,MAAM,eAAe,CAAC;AAyBpD;;GAEG;AACH,QAAA,MAAM,iBAAiB,6DAA8D,CAAC;AAEtF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,wBAAwB;IACxB,KAAK,EAAE,cAAc,CAAC;IACtB,+CAA+C;IAC/C,IAAI,EAAE,QAAQ,CAAC;CAChB;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,SAAS;IACpB;;;;;;OAMG;WACU,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC;IAU3F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAuB;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IAEjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAE5D,OAAO;IA6BP;;;;;;OAMG;IACH,QAAQ,CACN,GAAG,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,EACvB,EAAE,EAAE,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAC/D,IAAI;IA2EP;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAO7B"}

package/dist/features/fs-watcher.js

@@ -3,7 +3,7 @@ import * as chokidar from "chokidar";
 import consola from "consola";
 import { Minimatch } from "minimatch";
 import path from "path";
-import { pathNorm } from "../utils/path.js";
+import { norm } from "../utils/path.js";
 const GLOB_CHARS_RE = /[*?{[\]]/;
 function extractGlobBase(globPath) {
   const segments = globPath.split(/[/\\]/);
@@ -102,7 +102,7 @@ class FsWatcher {
         changeInfoMap = /* @__PURE__ */ new Map();
         const changeInfos = Array.from(currChangeInfoMap.entries()).map(
           ([changedPath, evt]) => ({
-            path: pathNorm(changedPath),
+            path: norm(changedPath),
             event: evt
           })
         );

package/dist/features/fs-watcher.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../src/features/fs-watcher.ts"],
-  "mappings": "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",
+  "mappings": "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",
   "names": []
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./utils/fs";
-export * from "./utils/path";
+export * as fsx from "./utils/fs";
+export * as pathx from "./utils/path";
 export * from "./features/fs-watcher";
 export * from "./worker/types";
 export * from "./worker/worker";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["..\\src\\index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAG7B,cAAc,uBAAuB,CAAC;AAGtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["..\\src\\index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,YAAY,CAAC;AAClC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,7 +1,11 @@
-export * from "./utils/fs.js";
-export * from "./utils/path.js";
+import * as fsx from "./utils/fs.js";
+import * as pathx from "./utils/path.js";
 export * from "./features/fs-watcher.js";
 export * from "./worker/types.js";
 export * from "./worker/worker.js";
 export * from "./worker/create-worker.js";
+export {
+  fsx,
+  pathx
+};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "mappings": "AACA,cAAc;AACd,cAAc;AAGd,cAAc;AAGd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "mappings": "AACA,YAAY,SAAS;AACrB,YAAY,WAAW;AAGvB,cAAc;AAGd,cAAc;AACd,cAAc;AACd,cAAc;",
   "names": []
 }