@decohere/devkit 0.0.1-dev.126 → 0.0.1-dev.5

package/es6/src/io/watch.js

@@ -1,238 +0,0 @@
-import { watch as nativeWatch, readdirSync, statSync } from "node:fs";
-import path from "node:path";
-import picomatch from "picomatch";
-import { FileEx } from "@decohere/core/io";
-export const WatchEvents = {
-    add: "add",
-    change: "change",
-    addDir: "addDir",
-    unlink: "unlink",
-    unlinkDir: "unlinkDir"
-};
-export function watch(directory, options = {
-    cwd: "."
-}) {
-    const { include, ignore, ignoreInitial = false } = options;
-    const changeCoalesceMs = 25;
-    const handlers = {
-        ready: new Set(),
-        add: new Set(),
-        change: new Set(),
-        addDir: new Set(),
-        unlink: new Set(),
-        unlinkDir: new Set()
-    };
-    let resolveReady;
-    const ready = new Promise((resolve)=>{
-        resolveReady = resolve;
-    });
-    const snapshot = buildSnapshot(directory);
-    const isFiltered = (relativePath)=>{
-        const posixRelativePath = toPosixPath(relativePath);
-        const posixFullPath = toPosixPath(path.resolve(directory, relativePath));
-        const matchesEitherPath = (patterns)=>picomatch.isMatch(posixRelativePath, patterns) || picomatch.isMatch(posixFullPath, patterns);
-        if (include && include.length > 0) {
-            return !matchesEitherPath(include);
-        }
-        if (ignore && ignore.length > 0) {
-            return matchesEitherPath(ignore);
-        }
-        return false;
-    };
-    const emit = (event, relativePath)=>{
-        if (isFiltered(relativePath)) {
-            return;
-        }
-        const fullPath = path.resolve(directory, relativePath);
-        for (const handler of handlers[event]){
-            handler(new FileEx({
-                fullPath,
-                relativePath
-            }));
-        }
-    };
-    const pendingChangeTimers = new Map();
-    const emitChange = (relativePath)=>{
-        const existing = pendingChangeTimers.get(relativePath);
-        if (existing != null) {
-            clearTimeout(existing);
-        }
-        const timer = setTimeout(()=>{
-            pendingChangeTimers.delete(relativePath);
-            emit("change", relativePath);
-        }, changeCoalesceMs);
-        pendingChangeTimers.set(relativePath, timer);
-    };
-    const emitReady = ()=>{
-        for (const handler of handlers.ready){
-            handler();
-        }
-    };
-    queueMicrotask(()=>{
-        if (!ignoreInitial) {
-            for (const [relativePath, entry] of snapshot){
-                emit(entry.isDirectory ? "addDir" : "add", relativePath);
-            }
-        }
-        emitReady();
-        resolveReady?.();
-        resolveReady = undefined;
-    });
-    // One non-recursive watcher per directory. Node's recursive mode on Linux tracks files
-    // individually and goes silent for a file once an editor replaces it with an atomic save
-    // (write temp file, rename over the original); directory watchers keep seeing it.
-    const directoryWatchers = new Map();
-    const watchDirectory = (relativeDir)=>{
-        if (directoryWatchers.has(relativeDir)) {
-            return;
-        }
-        try {
-            const watcher = nativeWatch(path.resolve(directory, relativeDir), (_eventType, fileName)=>{
-                if (fileName != null) {
-                    onFsEvent(path.posix.join(relativeDir, toPosixPath(fileName.toString())));
-                }
-            });
-            watcher.on("error", ()=>unwatchDirectory(relativeDir));
-            directoryWatchers.set(relativeDir, watcher);
-        } catch  {
-        // The directory vanished before we could watch it; its unlink event covers it.
-        }
-    };
-    const unwatchDirectory = (relativeDir)=>{
-        for (const [watchedDir, watcher] of directoryWatchers){
-            if (watchedDir === relativeDir || watchedDir.startsWith(`${relativeDir}/`)) {
-                watcher.close();
-                directoryWatchers.delete(watchedDir);
-            }
-        }
-    };
-    /** A directory appeared: watch it, and report what was created in it before we were watching. */ const addDirectory = (relativeDir)=>{
-        watchDirectory(relativeDir);
-        const found = new Map();
-        try {
-            collectSnapshotEntries(directory, path.resolve(directory, relativeDir), found);
-        } catch  {
-            return;
-        }
-        for (const [relativePath, entry] of found){
-            if (snapshot.has(relativePath)) continue;
-            snapshot.set(relativePath, entry);
-            if (entry.isDirectory) watchDirectory(relativePath);
-            emit(entry.isDirectory ? "addDir" : "add", relativePath);
-        }
-    };
-    /** A directory went away: stop watching it and forget everything that was under it. */ const removeDirectoryContents = (relativeDir)=>{
-        unwatchDirectory(relativeDir);
-        // oxlint-disable-next-line unicorn/no-useless-spread -- iterate a copy: the loop deletes from the snapshot
-        for (const [relativePath, entry] of [
-            ...snapshot
-        ]){
-            if (relativePath.startsWith(`${relativeDir}/`)) {
-                snapshot.delete(relativePath);
-                emit(entry.isDirectory ? "unlinkDir" : "unlink", relativePath);
-            }
-        }
-    };
-    const onFsEvent = (eventPath)=>{
-        const relativePath = eventPath === "." ? "" : eventPath;
-        if (relativePath.length === 0) {
-            return;
-        }
-        const fullPath = path.resolve(directory, relativePath);
-        const previous = snapshot.get(relativePath);
-        try {
-            const stat = statSync(fullPath);
-            const current = toSnapshotEntry(stat);
-            snapshot.set(relativePath, current);
-            if (previous == null) {
-                emit(current.isDirectory ? "addDir" : "add", relativePath);
-                if (current.isDirectory) addDirectory(relativePath);
-                return;
-            }
-            if (previous.isDirectory !== current.isDirectory) {
-                if (previous.isDirectory) removeDirectoryContents(relativePath);
-                emit(previous.isDirectory ? "unlinkDir" : "unlink", relativePath);
-                emit(current.isDirectory ? "addDir" : "add", relativePath);
-                return;
-            }
-            if (!current.isDirectory && previous.fingerprint !== current.fingerprint) {
-                emitChange(relativePath);
-            }
-        } catch  {
-            if (previous == null) {
-                return;
-            }
-            snapshot.delete(relativePath);
-            const pending = pendingChangeTimers.get(relativePath);
-            if (pending != null) {
-                clearTimeout(pending);
-                pendingChangeTimers.delete(relativePath);
-            }
-            emit(previous.isDirectory ? "unlinkDir" : "unlink", relativePath);
-        }
-    };
-    watchDirectory("");
-    for (const [relativePath, entry] of snapshot){
-        if (entry.isDirectory) watchDirectory(relativePath);
-    }
-    const watchApi = {
-        ready,
-        on (event, handler) {
-            if (event === "ready") {
-                handlers.ready.add(handler);
-                return watchApi;
-            }
-            handlers[event].add(handler);
-            return watchApi;
-        },
-        close: ()=>{
-            for (const pending of pendingChangeTimers.values()){
-                clearTimeout(pending);
-            }
-            pendingChangeTimers.clear();
-            for (const watcher of directoryWatchers.values()){
-                watcher.close();
-            }
-            directoryWatchers.clear();
-        }
-    };
-    return watchApi;
-}
-function buildSnapshot(directoryPath) {
-    const snapshot = new Map();
-    collectSnapshotEntries(directoryPath, directoryPath, snapshot);
-    return snapshot;
-}
-/** Never source, and huge: watching every folder inside them could exhaust OS watch limits. */ const UNWATCHED_DIRECTORIES = new Set([
-    "node_modules",
-    ".git"
-]);
-function collectSnapshotEntries(rootDirectoryPath, currentDirectoryPath, snapshot) {
-    for (const entry of readdirSync(currentDirectoryPath, {
-        encoding: "utf8"
-    })){
-        const name = typeof entry === "string" ? entry : String(entry);
-        const fullPath = path.join(currentDirectoryPath, name);
-        if (UNWATCHED_DIRECTORIES.has(name)) {
-            continue;
-        }
-        const relativePath = toPosixPath(path.relative(rootDirectoryPath, fullPath));
-        const stat = statSync(fullPath);
-        const snapshotEntry = toSnapshotEntry(stat);
-        snapshot.set(relativePath, snapshotEntry);
-        if (!snapshotEntry.isDirectory) {
-            continue;
-        }
-        collectSnapshotEntries(rootDirectoryPath, fullPath, snapshot);
-    }
-}
-function toSnapshotEntry(stat) {
-    const isDirectory = stat.isDirectory();
-    return {
-        isDirectory,
-        fingerprint: isDirectory ? `dir:${stat.mtimeMs}` : `file:${stat.mtimeMs}:${stat.size}`
-    };
-}
-function toPosixPath(filePath) {
-    return filePath.split(path.sep).join(path.posix.sep);
-}

package/types/src/cli/action.d.ts

@@ -1,36 +0,0 @@
-import type { Constructable } from "@decohere/core/reflection";
-import type { UnionToIntersection } from "@decohere/core/system";
-export declare const ActionMap: unique symbol;
-export type ActionClassMap = Record<string, Constructable<Action>>;
-export interface ResultStatus {
-    succeeded: boolean;
-    error?: string;
-}
-export interface Result {
-    readonly name: string;
-    readonly succeeded: boolean;
-    readonly skipped: boolean;
-    readonly message: string;
-}
-export declare class ActionResponse<TData = unknown> implements Result {
-    static Success<TData>(name: string, data?: TData[]): ActionResponse<TData>;
-    static Skipped(name: string): ActionResponse<unknown>;
-    static Blocking(name: string): ActionResponse<unknown>;
-    static Error<TData = unknown>(name: string, message: string): ActionResponse<TData>;
-    static Error<TData extends ResultStatus>(name: string, data: TData[]): ActionResponse<TData>;
-    constructor(data: Partial<ActionResponse<TData>>);
-    readonly name: string;
-    readonly succeeded: boolean;
-    readonly skipped: boolean;
-    readonly blocking: boolean;
-    readonly message: string;
-    readonly data: TData[];
-}
-export interface Action<T extends object = object> {
-    run(options: T): Promise<ActionResponse>;
-}
-export type Actions = Record<string, Action>;
-export type ActionOptions<A extends Action> = A extends Action<infer T> ? T : never;
-export type MergeOptions<TActions extends Record<string, Action>> = UnionToIntersection<{
-    [K in keyof TActions]: ActionOptions<TActions[K]>;
-}[keyof TActions]>;

package/types/src/cli/command.d.ts

@@ -1,34 +0,0 @@
-import { Command as CommanderType, type OptionValues } from "commander";
-import type { Constructable } from "@decohere/core/reflection";
-import type { ActionResponse, Actions } from "./action.js";
-export type CommandType = Constructable<DecohereCommand>;
-export type CommandHandler = (opts: OptionValues, cmd: DecohereCommand) => Promise<void>;
-export type CommandResponse<TActions extends Actions = Actions> = {
-    [ActionName in keyof TActions]?: ActionResponse;
-};
-export declare const CommandResponse: {
-    success<T extends Actions>(_ctx: unknown, responses: CommandResponse<T>): CommandResponse<T>;
-    help<T extends Actions = Actions>(): CommandResponse<T>;
-    fromAction(name: string, response: ActionResponse): CommandResponse;
-};
-/** Thrown when a command execution fails due to action errors. */
-export declare class CommandError extends Error {
-}
-export declare class DecohereCommand<TActions extends Actions = Actions> extends CommanderType {
-    get actions(): readonly Constructable<import("./action.js").Action>[];
-    constructor(name?: string | Constructable | Record<string, CommandType>, handler?: CommandHandler);
-    /**
-     * Whether the command, with these options, runs until it is stopped (`flux serve`,
-     * `forge build --watch`). The CLI then listens for SIGINT and SIGTERM from the moment it
-     * starts, so a stop during start-up still shuts down cleanly; other commands keep Node's
-     * default, where Ctrl+C ends them at once.
-     */
-    runsUntilStopped(_options: OptionValues): boolean;
-    run(actions: TActions, options: OptionValues): Promise<CommandResponse<TActions>>;
-    registerSubcommand(command: CommandType, onAction?: CommandHandler): void;
-    registerSubcommand(commands: Record<string, DecohereCommand | CommandType>, onAction?: CommandHandler): void;
-    protected runActions(actions: TActions, options: OptionValues): Promise<CommandResponse<TActions>>;
-    protected getSelectedActions(actions: TActions): Array<[keyof TActions, TActions[keyof TActions]]>;
-    protected throwOnErrors(responses: CommandResponse<TActions>): void;
-    private parseCommandName;
-}

package/types/src/cli/index.d.ts

@@ -1,7 +0,0 @@
-export type { Action, ActionClassMap, ActionOptions, Actions, MergeOptions, Result, ResultStatus, } from "./action.js";
-export { ActionMap, ActionResponse } from "./action.js";
-export type { CommandHandler, CommandType } from "./command.js";
-export { CommandError, CommandResponse, DecohereCommand } from "./command.js";
-export type { ApplicationModule, CommandMap as CommandClassMap, ModuleConfig, WorkspaceFactoryOptions, } from "./module.type.js";
-export { ModuleManifest } from "./module.type.js";
-export { ConfigFileOption, ConfigurationOption, DryRunOption, EnvFileIfExistsOption, EnvFileOption, LogLevelOption, NoBuildOptions, NoCleanOptions, ProjectOption, } from "./options.js";

package/types/src/cli/module.type.d.ts

@@ -1,36 +0,0 @@
-import type { ContainerBuilder } from "@decohere/core/composition";
-import type { ActionClassMap } from "./action.js";
-import type { CommandType, DecohereCommand } from "./command.js";
-export type CommandMap = Record<string, CommandType>;
-export type WorkspaceFactoryOptions = {
-    configFile?: string;
-    rootDir?: string;
-};
-export interface ApplicationModule {
-    id: string;
-    dispose?(): void;
-    asyncDispose?(): Promise<void>;
-    command: DecohereCommand;
-}
-export type ModuleConfig = {
-    actions?: ActionClassMap;
-    commands?: CommandMap;
-};
-/**
- * Simple declaration interface for a CLI module.
- * Extend this and implement the four abstract members.
- */
-export declare abstract class ModuleManifest {
-    /** Unique module identifier, used as the root command name. */
-    abstract readonly id: string;
-    /** Sub-command classes this module contributes. */
-    readonly commands: CommandMap;
-    /** Action classes this module contributes. */
-    readonly actions: ActionClassMap;
-    /** The root command class for this module. */
-    abstract readonly command: CommandType;
-    /** Register infrastructure services into the DI container. */
-    registerServices(_builder: ContainerBuilder): void;
-    /** Lazily create a workspace instance. Return null if this module does not use a workspace. */
-    createWorkspace(_options: WorkspaceFactoryOptions): Promise<object | null>;
-}

package/types/src/cli/options.d.ts

@@ -1,28 +0,0 @@
-import { Option } from "commander";
-export declare class ConfigurationOption extends Option {
-    constructor(defaultValue: string);
-}
-export declare class ConfigFileOption extends Option {
-    constructor(defaultValue?: string);
-}
-export declare class LogLevelOption extends Option {
-    constructor();
-}
-export declare class EnvFileOption extends Option {
-    constructor();
-}
-export declare class EnvFileIfExistsOption extends Option {
-    constructor();
-}
-export declare class NoCleanOptions extends Option {
-    constructor(defaultValue: boolean);
-}
-export declare class NoBuildOptions extends Option {
-    constructor(defaultValue: boolean);
-}
-export declare class DryRunOption extends Option {
-    constructor(description: string, defaultValue?: boolean);
-}
-export declare class ProjectOption extends Option {
-    constructor();
-}

package/types/src/diagnostics/index.d.ts

@@ -1 +0,0 @@
-export { Trace, timed, trace } from "./trace.js";

package/types/src/diagnostics/trace.d.ts

@@ -1,10 +0,0 @@
-export declare function trace(target: object, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
-/**
- * Always-on method timing. Logs duration at `info` regardless of `FORGE_TRACE`.
- * Use this to time a specific method without raising the process log level.
- */
-export declare function timed(target: object, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
-export declare function Trace(constructor: {
-    name: string;
-    prototype: object;
-}): void;

package/types/src/interop/docker/docker.d.ts

@@ -1,19 +0,0 @@
-import { Shell } from "../shell/shell.js";
-export type DockerBuildOptions = {
-    cwd?: string;
-    dockerfile?: string;
-    tags?: string[];
-    buildArgs?: Record<string, string>;
-    secrets?: Record<string, string>;
-    noCache?: boolean;
-    pull?: boolean;
-};
-export type DockerPushOptions = {
-    cwd?: string;
-};
-export declare class Docker extends Shell {
-    readonly name: "docker";
-    protected program: string;
-    build(contextDir: string, options?: DockerBuildOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    push(tag: string, options?: DockerPushOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-}

package/types/src/interop/errors/interop.error.d.ts

@@ -1,2 +0,0 @@
-export declare class InteropError extends Error {
-}

package/types/src/interop/git/git.d.ts

@@ -1,16 +0,0 @@
-import { Shell } from "../shell/shell.js";
-import type { ShellResponse } from "../shell/shell.types.js";
-import type { CommitOptions, GitOptions, PushOptions, StageOptions } from "./git.types.js";
-export declare class Git extends Shell {
-    protected program: string;
-    getModifiedFiles(options?: GitOptions): Promise<string[]>;
-    getBranchName(options?: GitOptions): Promise<string>;
-    tag(tag: string, options?: GitOptions): Promise<ShellResponse>;
-    pushTag(tag: string, options?: GitOptions & {
-        remote?: string;
-    }): Promise<ShellResponse>;
-    commit(message: string, options: CommitOptions): Promise<ShellResponse>;
-    push(branch: string, options?: PushOptions): Promise<ShellResponse>;
-    pull(branch: string, options?: GitOptions): Promise<ShellResponse>;
-    stage(options: StageOptions): Promise<void>;
-}

package/types/src/interop/index.d.ts

@@ -1,14 +0,0 @@
-export * from "./docker/docker.js";
-export * from "./git/git.js";
-export * as git from "./git/git.types.js";
-export * from "./node/node.js";
-export * from "./npm/npm.js";
-export * as npm from "./npm/npm.types.js";
-export * from "./pnpm/pnpm.js";
-export * as pnpm from "./pnpm/pnpm.types.js";
-export * from "./shell/shell.js";
-export * as shell from "./shell/shell.types.js";
-export * from "./types/detect-package-manager.js";
-export * from "./types/package-manager.js";
-export * from "./yarn/yarn.js";
-export * as yarn from "./yarn/yarn.types.js";

package/types/src/interop/node/index.d.ts

@@ -1 +0,0 @@
-export * from "./node.js";

package/types/src/interop/node/node.d.ts

@@ -1,5 +0,0 @@
-import { Shell } from "../shell/shell.js";
-export declare class Node extends Shell {
-    protected program: string;
-    runScript(script: string, ...args: string[]): Promise<unknown>;
-}

package/types/src/interop/npm/npm.d.ts

@@ -1,29 +0,0 @@
-import { Shell } from "../shell/shell.js";
-import type { PackageManager } from "../types/package-manager.js";
-import type { NpmOptions, PublishOptions, VersionOptions, VersionType } from "./npm.types.js";
-export declare class Npm extends Shell implements PackageManager {
-    readonly name: "npm";
-    protected program: string;
-    publish(directory: string, options?: PublishOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    /**
-     * @description Runs in the directory of the package
-     * @param options
-     * @returns
-     */
-    version(versionType: VersionType, options: VersionOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    link(directory: string, options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    install(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    /**
-     * Install only `dependencies` as real folders: `--omit=dev` skips devDependencies and
-     * `--no-bin-links` skips the `.bin` symlinks, so the result holds no symlinks at all.
-     */
-    installProduction(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    syncLockFile(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    /**
-     * True when package@version exists on the registry.
-     * Uses ambient npm config (cwd `.npmrc`); do not pass tokens on argv.
-     */
-    private isPublished;
-    private createTempUserConfig;
-    private removeTempUserConfig;
-}

package/types/src/interop/npm/npm.types.d.ts

@@ -1,24 +0,0 @@
-export type NpmOptions = {
-    cwd?: string;
-};
-export type PublishOptions = {
-    dryRun?: boolean;
-    skipIfPublished?: boolean;
-    authToken?: string;
-    otp?: string;
-    provenance?: boolean;
-    /** @deprecated use channel */
-    versionType?: VersionType;
-    channel?: string;
-} & NpmOptions;
-export type VersionType = "major" | "minor" | "patch" | "prerelease";
-export declare const VersionTypes: {
-    major: "major";
-    minor: "minor";
-    patch: "patch";
-    prerelease: "prerelease";
-};
-export type VersionOptions = {
-    preid?: string;
-    noTag?: boolean;
-} & NpmOptions;

package/types/src/interop/pnpm/pnpm.d.ts

@@ -1,9 +0,0 @@
-import { Shell } from "../shell/shell.js";
-import type { PackageManager } from "../types/package-manager.js";
-import type { PnpmOptions } from "./pnpm.types.js";
-export declare class Pnpm extends Shell implements PackageManager {
-    readonly name: "pnpm";
-    protected program: string;
-    install(options?: PnpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    syncLockFile(options?: PnpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-}

package/types/src/interop/shell/shell.argv.d.ts

@@ -1,5 +0,0 @@
-declare function fields(args: string[]): Record<string, string | boolean | string[]>;
-export declare const shellArgv: {
-    fields: typeof fields;
-};
-export {};

package/types/src/interop/shell/shell.d.ts

@@ -1,6 +0,0 @@
-import type { ShellOptions, ShellResponse } from "./shell.types.js";
-export declare abstract class Shell {
-    protected abstract program: string;
-    protected run(options: ShellOptions, ...args: string[]): Promise<ShellResponse>;
-    private parseStream;
-}

package/types/src/interop/shell/shell.types.d.ts

@@ -1,9 +0,0 @@
-export type ShellResponse = {
-    message: string;
-    data: string[];
-};
-export interface ShellOptions {
-    cwd?: string;
-    /** Spawn env. Defaults to `process.env`. Not written to logs. */
-    env?: NodeJS.ProcessEnv;
-}

package/types/src/interop/types/detect-package-manager.d.ts

@@ -1,4 +0,0 @@
-import type { PackageManager } from "./package-manager.js";
-export declare function detectPackageManager(cwd: string): PackageManager | undefined;
-export declare function packageManagerFromString(name: string): PackageManager;
-export declare function promptForPackageManager(): Promise<PackageManager>;

package/types/src/interop/types/package-manager.d.ts

@@ -1,10 +0,0 @@
-import type { ShellResponse } from "../shell/shell.types.js";
-export interface PackageManager {
-    readonly name: "npm" | "pnpm" | "yarn";
-    install(options?: {
-        cwd?: string;
-    }): Promise<ShellResponse>;
-    syncLockFile(options?: {
-        cwd?: string;
-    }): Promise<ShellResponse>;
-}

package/types/src/interop/yarn/yarn.d.ts

@@ -1,9 +0,0 @@
-import { Shell } from "../shell/shell.js";
-import type { PackageManager } from "../types/package-manager.js";
-import type { YarnOptions } from "./yarn.types.js";
-export declare class Yarn extends Shell implements PackageManager {
-    readonly name: "yarn";
-    protected program: string;
-    install(options?: YarnOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-    syncLockFile(options?: YarnOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
-}

package/types/src/io/find-directories.d.ts

@@ -1,2 +0,0 @@
-import type { Directory } from "@decohere/core/io";
-export declare function findDirectories(...pattern: string[]): Promise<Directory[]>;

package/types/src/io/find-file.d.ts

@@ -1,9 +0,0 @@
-import { FileEx } from "@decohere/core/io";
-export type FindFileOptions = {
-    cwd: string;
-    ignore?: string | string[];
-};
-export declare function findFile(pattern: string): Promise<{
-    relativePath: string;
-}>;
-export declare function findFiles(patterns: string[], options?: FindFileOptions): Promise<FileEx[]>;

package/types/src/io/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./find-directories.js";
-export * from "./find-file.js";
-export * from "./watch.js";

package/types/src/io/watch.d.ts

@@ -1,16 +0,0 @@
-import { type Watcher } from "@decohere/core/io";
-export type WatchOptions = {
-    include?: string[];
-    ignore?: string[];
-    cwd?: string;
-    ignoreInitial?: boolean;
-};
-export type WatchEventName = "add" | "change" | "addDir" | "unlink" | "unlinkDir";
-export declare const WatchEvents: {
-    add: "add";
-    change: "change";
-    addDir: "addDir";
-    unlink: "unlink";
-    unlinkDir: "unlinkDir";
-};
-export declare function watch(directory: string, options?: WatchOptions): Watcher;