@effectionx/watch 0.1.1

package/esm/deps/jsr.io/@std/path/1.1.2/windows/to_namespaced_path.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK, } from "../_common/constants.js";
+import { isWindowsDeviceRoot } from "./_util.js";
+import { resolve } from "./resolve.js";
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+export function toNamespacedPath(path) {
+    // Note: this will *probably* throw somewhere.
+    if (typeof path !== "string")
+        return path;
+    if (path.length === 0)
+        return "";
+    const resolvedPath = resolve(path);
+    if (resolvedPath.length >= 3) {
+        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
+            // Possible UNC root
+            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
+                const code = resolvedPath.charCodeAt(2);
+                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
+                    // Matched non-long UNC root, convert the path to a long UNC path
+                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
+            // Possible device root
+            if (resolvedPath.charCodeAt(1) === CHAR_COLON &&
+                resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
+                // Matched device root, convert the path to a long UNC path
+                return `\\\\?\\${resolvedPath}`;
+            }
+        }
+    }
+    return path;
+}

package/esm/main.d.ts

@@ -0,0 +1,2 @@
+import "./_dnt.polyfills.js";
+//# sourceMappingURL=main.d.ts.map

package/esm/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC"}

package/esm/main.js

@@ -0,0 +1,71 @@
+import "./_dnt.polyfills.js";
+import { each, exit, main, scoped, spawn } from "effection";
+import { watch } from "./watch.js";
+import { parser } from "zod-opts";
+import { z } from "zod";
+import process from "node:process";
+import denoJson from "./deno.js";
+const builtins = ["-h", "--help", "-V", "--version"];
+main(function* (argv) {
+    let { args, rest } = extract(argv);
+    parser()
+        .name("watch")
+        .description("run a command, and restart it every time a source file in a directory changes")
+        .args([
+        {
+            name: "command",
+            type: z.array(z.string()).optional(),
+        },
+    ])
+        .version(denoJson.version)
+        .parse(args);
+    if (rest.length === 0) {
+        yield* exit(5, "no command specified to watch");
+    }
+    let command = rest.join(" ");
+    let watcher = watch({
+        path: process.cwd(),
+        cmd: command,
+    });
+    for (let start of yield* each(watcher)) {
+        process.stdout.write(`${command}\n`);
+        yield* scoped(function* () {
+            let { result } = start;
+            if (result.ok) {
+                let proc = result.value;
+                yield* spawn(function* () {
+                    for (let chunk of yield* each(proc.stdout)) {
+                        process.stdout.write(chunk);
+                        yield* each.next();
+                    }
+                });
+                yield* spawn(function* () {
+                    for (let chunk of yield* each(proc.stderr)) {
+                        process.stderr.write(chunk);
+                        yield* each.next();
+                    }
+                });
+            }
+            else {
+                console.error(`failed to start: ${result.error}`);
+            }
+            yield* start.restarting;
+            process.stdout.write(`--> restarting....\n`);
+            yield* each.next();
+        });
+    }
+});
+function extract(argv) {
+    let args = [];
+    let rest = argv.slice();
+    for (let arg = rest.shift(); arg; arg = rest.shift()) {
+        if (builtins.includes(arg)) {
+            args.push(arg);
+        }
+        else {
+            rest.unshift(arg);
+            break;
+        }
+    }
+    return { args, rest };
+}

package/esm/mod.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Start and restart a process whenever contents of a directory changes
+ */
+import "./_dnt.polyfills.js";
+export * from "./watch.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,qBAAqB,CAAC;AAE7B,cAAc,YAAY,CAAC"}

package/esm/mod.js

@@ -0,0 +1,5 @@
+/**
+ * Start and restart a process whenever contents of a directory changes
+ */
+import "./_dnt.polyfills.js";
+export * from "./watch.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/stream-helpers.d.ts

@@ -0,0 +1,4 @@
+import { type Stream } from "effection";
+export declare function debounce<T, R>(ms: number): (stream: Stream<T, R>) => Stream<T, R>;
+export declare function filter<T, R>(predicate: (item: T) => boolean): (stream: Stream<T, R>) => Stream<T, R>;
+//# sourceMappingURL=stream-helpers.d.ts.map

package/esm/stream-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-helpers.d.ts","sourceRoot":"","sources":["../src/stream-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAErD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,EAAE,EAAE,MAAM,GACT,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAmBxC;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAexC"}

package/esm/stream-helpers.js

@@ -0,0 +1,38 @@
+import { race, sleep } from "effection";
+export function debounce(ms) {
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            let subscription = yield* stream;
+            return {
+                *next() {
+                    let next = yield* subscription.next();
+                    while (true) {
+                        let result = yield* race([sleep(ms), subscription.next()]);
+                        if (!result) {
+                            return next;
+                        }
+                        else {
+                            next = result;
+                        }
+                    }
+                },
+            };
+        },
+    });
+}
+export function filter(predicate) {
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            let subscription = yield* stream;
+            return {
+                *next() {
+                    let next = yield* subscription.next();
+                    while (!next.done && !predicate(next.value)) {
+                        next = yield* subscription.next();
+                    }
+                    return next;
+                },
+            };
+        },
+    });
+}

package/esm/watch.d.ts

@@ -0,0 +1,76 @@
+import { type Operation, type Result, type Stream } from "effection";
+import { type ExecOptions, type Process } from "@effectionx/process";
+/**
+ * Represents a single start of the specified command
+ */
+export interface Start {
+    /**
+     * A result containing the {Process} on a successful start, or
+     * an error otherwise.
+     */
+    result: Result<Process>;
+    /**
+     * An operation that resolves when the current start begins its
+     * shutdown.
+     */
+    restarting: Operation<void>;
+}
+/**
+ * A watch is a strema of process starts that happen in reaction
+ * to some source file changing on the file system.
+ */
+export interface Watch extends Stream<Result<Process>, never> {
+}
+/**
+ * Options available to configure what is watched
+ */
+export interface WatchOptions {
+    /**
+     * The directory to watch
+     */
+    path: string;
+    /**
+     * The command to run (and re-run every time a change is detected)
+     */
+    cmd: string;
+    /**
+     * @ignore
+     */
+    event?: "all" | "change";
+    /**
+     * Options passed to process exec
+     */
+    execOptions?: ExecOptions;
+}
+/**
+ * Create a watch configuration that observes file system changes and executes a command
+ * when changes are detected. The watch can be consumed as a stream of process starts.
+ *
+ * @example
+ * ```ts
+ * const watcher = yield* watch({
+ *  path: './src',
+ *  cmd: 'npm test'
+ * });
+ * ```
+ *
+ * @param options - Configuration options for the watch
+ * @param options.path - The directory path to watch for changes
+ * @param options.cmd - The command to execute when changes are detected
+ * @param options.event - The type of event to watch for ('all' or 'change', defaults to 'all')
+ *
+ * @returns A Stream that emits `Result<Process>` for each command execution
+ *
+ * @remarks
+ * - Uses chokidar for file system watching
+ * - Respects .gitignore patterns if present
+ * - Implements debouncing to prevent rapid successive executions
+ * - Filters out stale events using the fresh() function
+ *
+ * @throws Will throw an error if the process execution fails
+ *
+ * @see {@link WatchOptions} for configuration options
+ * @see {@link Process} for process execution details
+ */
+export declare function watch(options: WatchOptions): Stream<Start, never>;
+//# sourceMappingURL=watch.d.ts.map

package/esm/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../src/watch.ts"],"names":[],"mappings":"AAGA,OAAO,EAML,KAAK,SAAS,EAEd,KAAK,MAAM,EAEX,KAAK,MAAM,EAGZ,MAAM,WAAW,CAAC;AAInB,OAAO,EAAQ,KAAK,WAAW,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAI3E;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACxB;;;OAGG;IACH,UAAU,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,KAAM,SAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC;CAAG;AAEhE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC;IAEzB;;OAEG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CA0DjE"}

package/esm/watch.js

@@ -0,0 +1,119 @@
+import { exists } from "./deps/jsr.io/@std/fs/1.0.19/mod.js";
+import { join, relative } from "./deps/jsr.io/@std/path/1.1.2/mod.js";
+import chokidar from "chokidar";
+import { call, createChannel, createSignal, Err, Ok, resource, spawn, until, withResolvers, } from "effection";
+import { default as createIgnore } from "ignore";
+import { pipe } from "./deps/jsr.io/@gordonb/pipe/0.1.0/pipe.js";
+import { readFile } from "node:fs/promises";
+import { exec } from "@effectionx/process";
+import { debounce } from "./stream-helpers.js";
+/**
+ * Create a watch configuration that observes file system changes and executes a command
+ * when changes are detected. The watch can be consumed as a stream of process starts.
+ *
+ * @example
+ * ```ts
+ * const watcher = yield* watch({
+ *  path: './src',
+ *  cmd: 'npm test'
+ * });
+ * ```
+ *
+ * @param options - Configuration options for the watch
+ * @param options.path - The directory path to watch for changes
+ * @param options.cmd - The command to execute when changes are detected
+ * @param options.event - The type of event to watch for ('all' or 'change', defaults to 'all')
+ *
+ * @returns A Stream that emits `Result<Process>` for each command execution
+ *
+ * @remarks
+ * - Uses chokidar for file system watching
+ * - Respects .gitignore patterns if present
+ * - Implements debouncing to prevent rapid successive executions
+ * - Filters out stale events using the fresh() function
+ *
+ * @throws Will throw an error if the process execution fails
+ *
+ * @see {@link WatchOptions} for configuration options
+ * @see {@link Process} for process execution details
+ */
+export function watch(options) {
+    return resource(function* (provide) {
+        let starts = createChannel();
+        let input = createSignal();
+        let gitignored = yield* findIgnores(options.path);
+        let watcher = chokidar.watch(options.path, {
+            ignored: (path) => {
+                let relpath = relative(options.path, path);
+                let isGit = relpath === ".git" || relpath.startsWith(".git");
+                return isGit || gitignored(path);
+            },
+            ignoreInitial: true,
+        });
+        let { event = "all" } = options;
+        watcher.on(event, (...args) => {
+            if (event !== "all") {
+                args.unshift(event);
+            }
+            let [, path] = args;
+            if (fresh(500)(args) && !gitignored(path)) {
+                input.send(args);
+            }
+        });
+        let changes = yield* pipe(input, debounce(100));
+        let subscription = yield* starts;
+        yield* spawn(function* () {
+            while (true) {
+                let task = yield* spawn(function* () {
+                    let restarting = withResolvers();
+                    try {
+                        let process = yield* exec(options.cmd, options.execOptions);
+                        yield* starts.send({
+                            result: Ok(process),
+                            restarting: restarting.operation,
+                        });
+                    }
+                    catch (error) {
+                        yield* starts.send({
+                            result: Err(error),
+                            restarting: restarting.operation,
+                        });
+                    }
+                    yield* changes.next();
+                    restarting.resolve();
+                });
+                yield* task;
+            }
+        });
+        try {
+            yield* provide(subscription);
+        }
+        finally {
+            yield* until(watcher.close());
+        }
+    });
+}
+/**
+ * locate a `.gitignore` file if it exists and use it to filter
+ * out any change events against paths that are matched by it
+ */
+function* findIgnores(path) {
+    let gitignore = join(path, ".gitignore");
+    if (yield* call(() => exists(gitignore))) {
+        let ignores = createIgnore();
+        let buffer = yield* call(() => readFile(gitignore));
+        ignores.add(buffer.toString());
+        return (pathname) => {
+            let relativePathname = relative(path, pathname).trim();
+            return relativePathname !== "" && ignores.ignores(relativePathname);
+        };
+    }
+    else {
+        return () => false;
+    }
+}
+function fresh(staletime) {
+    return ([, , stats]) => {
+        return !stats || Date.now() - stats.mtimeMs < staletime;
+    };
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@effectionx/watch",
+  "version": "0.1.1",
+  "author": "engineering@frontside.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thefrontside/effectionx.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thefrontside/effectionx/issues"
+  },
+  "main": "./script/main.js",
+  "module": "./esm/main.js",
+  "exports": {
+    ".": {
+      "import": "./esm/main.js",
+      "require": "./script/main.js"
+    },
+    "./lib": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">= 16"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@effectionx/process": "0.5.0",
+    "chokidar": "^4.0.3",
+    "effection": "^3",
+    "ignore": "^7.0.3",
+    "zod": "^3.20.2",
+    "zod-opts": "0.1.8"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_dnt.polyfills.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    interface ArrayConstructor {
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | Promise<T>> | ArrayLike<T | Promise<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+    }
+}
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/script/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,gBAAgB;QACxB,SAAS,CAAC,CAAC,EACP,mBAAmB,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAC7F,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;QAEhB,SAAS,CAAC,CAAC,EAAE,CAAC,EACV,mBAAmB,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,EAClE,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,EAC/B,OAAO,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;KAC1B;CACF;AAoID,OAAO,EAAE,CAAC"}

package/script/_dnt.polyfills.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// From https://github.com/es-shims/array-from-async/blob/4a5ff83947b861f35b380d5d4f20da2f07698638/index.mjs
+// Tried to have dnt depend on the package instead, but it distributes as an
+// ES module, so doesn't work with CommonJS.
+//
+// Code below:
+//
+// Copyright 2021 J. S. Choi
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// **This software is provided by the copyright holders and contributors
+// "as is" and any express or implied warranties, including, but not
+// limited to, the implied warranties of merchantability and fitness for a
+// particular purpose are disclaimed. In no event shall the copyright
+// holder or contributors be liable for any direct, indirect, incidental,
+// special, exemplary, or consequential damages (including, but not limited
+// to, procurement of substitute goods or services; loss of use, data, or
+// profits; or business interruption) however caused and on any theory of
+// liability, whether in contract, strict liability, or tort (including
+// negligence or otherwise) arising in any way out of the use of this
+// software, even if advised of the possibility of such damage.**
+const { MAX_SAFE_INTEGER } = Number;
+const iteratorSymbol = Symbol.iterator;
+const asyncIteratorSymbol = Symbol.asyncIterator;
+const IntrinsicArray = Array;
+const tooLongErrorMessage = 'Input is too long and exceeded Number.MAX_SAFE_INTEGER times.';
+function isConstructor(obj) {
+    if (obj != null) {
+        const prox = new Proxy(obj, {
+            construct() {
+                return prox;
+            },
+        });
+        try {
+            new prox;
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+}
+async function fromAsync(items, mapfn, thisArg) {
+    const itemsAreIterable = (asyncIteratorSymbol in items ||
+        iteratorSymbol in items);
+    if (itemsAreIterable) {
+        const result = isConstructor(this)
+            ? new this
+            : IntrinsicArray(0);
+        let i = 0;
+        for await (const v of items) {
+            if (i > MAX_SAFE_INTEGER) {
+                throw TypeError(tooLongErrorMessage);
+            }
+            else if (mapfn) {
+                result[i] = await mapfn.call(thisArg, v, i);
+            }
+            else {
+                result[i] = v;
+            }
+            i++;
+        }
+        result.length = i;
+        return result;
+    }
+    else {
+        // In this case, the items are assumed to be an arraylike object with
+        // a length property and integer properties for each element.
+        const { length } = items;
+        const result = isConstructor(this)
+            ? new this(length)
+            : IntrinsicArray(length);
+        let i = 0;
+        while (i < length) {
+            if (i > MAX_SAFE_INTEGER) {
+                throw TypeError(tooLongErrorMessage);
+            }
+            const v = await items[i];
+            if (mapfn) {
+                result[i] = await mapfn.call(thisArg, v, i);
+            }
+            else {
+                result[i] = v;
+            }
+            i++;
+        }
+        result.length = i;
+        return result;
+    }
+}
+if (!Array.fromAsync) {
+    Array.fromAsync = fromAsync;
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = void 0;
+const dntGlobals = {};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/deno.d.ts

@@ -0,0 +1,36 @@
+declare namespace _default {
+    let name: string;
+    let version: string;
+    let license: string;
+    let exports: {
+        ".": string;
+        "./lib": string;
+    };
+    let imports: {
+        effection: string;
+        ignore: string;
+        "@std/expect": string;
+        "@std/assert": string;
+        "@gordonb/pipe": string;
+        "@std/fs": string;
+        "@std/path": string;
+        chokidar: string;
+        zod: string;
+        "zod-opts": string;
+        "@effectionx/bdd": string;
+        "@effectionx/process": string;
+        "@effectionx/stream-helpers": string;
+        "@effectionx/signals": string;
+    };
+    namespace lint {
+        namespace rules {
+            let exclude: string[];
+        }
+    }
+    namespace tasks {
+        let compile: string;
+        let dev: string;
+    }
+}
+export default _default;
+//# sourceMappingURL=deno.d.ts.map

package/script/deno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.d.ts","sourceRoot":"","sources":["../src/deno.js"],"names":[],"mappings":""}