keri-ts 0.1.0

package/esm/db/core/path-manager.js

@@ -0,0 +1,450 @@
+/**
+ * PathManager - File and directory path management
+ *
+ * Manages file directories and files for KERI installation resources like databases.
+ * Uses composition pattern instead of inheritance.
+ */
+import * as dntShim from "../../_dnt.shims.js";
+import { action } from "effection";
+import { InvalidPathNameError, PathError } from "../../core/errors.js";
+export const PATH_DEFAULTS = {
+    headDirPath: "/usr/local/var",
+    tailDirPath: "keri/db",
+    cleanTailDirPath: "keri/clean/db",
+    altHeadDirPath: "~",
+    altTailDirPath: ".keri/db",
+    altCleanTailDirPath: ".keri/clean/db",
+    tempHeadDir: "/tmp",
+    tempPrefix: "keri_lmdb_",
+    tempSuffix: "_test",
+    perm: 0o1700, // sticky + owner rwx
+    mode: "r+",
+    fext: "text",
+};
+/**
+ * PathManager manages file and directory paths
+ */
+export class PathManager {
+    constructor(options = {}, defaults) {
+        // name of the path, dir or file name
+        Object.defineProperty(this, "_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // base directory path
+        Object.defineProperty(this, "base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // temporary directory flag
+        Object.defineProperty(this, "temp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // head directory path
+        Object.defineProperty(this, "headDirPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // path to the directory or file
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "perm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "filed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extensioned", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fext", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "opened", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaults", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.defaults = { ...PATH_DEFAULTS, ...defaults };
+        this._name = options.name || "main";
+        this.base = options.base || "";
+        this.temp = options.temp || false;
+        this.headDirPath = options.headDirPath || this.defaults.headDirPath;
+        this.perm = options.perm ?? this.defaults.perm;
+        this.path = null;
+        this.filed = options.filed || false;
+        this.extensioned = options.extensioned || false;
+        this.mode = options.mode || this.defaults.mode;
+        this.fext = options.fext || this.defaults.fext;
+        this.opened = false;
+        // Note: Constructor cannot be async/generator, so reopen must be called explicitly
+        // if options.reopen is true. This is handled by callers (e.g., LMDBer).
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        // Check if path is absolute
+        if (value.startsWith("/") || value.includes(":")) {
+            throw new InvalidPathNameError(`Not relative name=${value} path.`, { name: value });
+        }
+        this._name = value;
+    }
+    _getTempPath() {
+        const tempDir = dntShim.Deno.env.get("TMPDIR") || dntShim.Deno.env.get("TMP") ||
+            dntShim.Deno.env.get("TEMP") || "/tmp";
+        const tempName = `${this.defaults.tempPrefix}${this.name}${this.defaults.tempSuffix}`;
+        return `${tempDir}/${tempName}`;
+    }
+    _pathExpandTilde(path) {
+        if (path === "~" || path.startsWith("~/")) {
+            const home = dntShim.Deno.env.get("HOME") || "~";
+            return path === "~" ? home : path.replace("~", home);
+        }
+        return path;
+    }
+    _getPrimaryPath(headDirPath, clean) {
+        // head / tail / base / name
+        // Expand ~ to HOME directory
+        let head = headDirPath;
+        head = this._pathExpandTilde(head);
+        let tail;
+        if (clean) {
+            tail = this.defaults.cleanTailDirPath;
+        }
+        else {
+            tail = this.defaults.tailDirPath;
+        }
+        const parts = [head, tail];
+        if (this.base)
+            parts.push(this.base);
+        parts.push(this.name);
+        const path = parts.join("/");
+        return path;
+    }
+    _getAltPath(clean) {
+        // HOME or ~ / tail / base / name
+        let head = dntShim.Deno.env.get("HOME") || "~";
+        head = this._pathExpandTilde(head);
+        let tail;
+        if (clean) {
+            tail = this.defaults.altCleanTailDirPath;
+        }
+        else {
+            tail = this.defaults.altTailDirPath;
+        }
+        const altParts = [head, tail];
+        if (this.base)
+            altParts.push(this.base);
+        altParts.push(this.name);
+        const path = altParts.join("/");
+        return path;
+    }
+    /*
+     * Creates a file path based on head, tail, base, and name. Ensure path is created and optionally reuse it.
+     * @param options path creation options
+     * @returns File path to a persistent file or directory
+     */
+    _getPersistentPaths(options = {}) {
+        const headDirPath = options.headDirPath ?? this.headDirPath;
+        const clean = options.clean || false;
+        const primary = this._getPrimaryPath(headDirPath, clean);
+        const alt = this._getAltPath(clean);
+        return [primary, alt];
+    }
+    _getPaths(options = {}) {
+        const [primary, alt] = this._getPersistentPaths(options);
+        const tempPath = this._getTempPath();
+        return [primary, alt, tempPath];
+    }
+    /**
+     * Helper: Convert Promise-based file system operations to Effection operations
+     * This ensures proper structured concurrency and cancellation support
+     */
+    *_statOp(path) {
+        return yield* action((resolve, reject) => {
+            dntShim.Deno.stat(path)
+                .then(() => resolve(true))
+                .catch((error) => {
+                if (error instanceof dntShim.Deno.errors.NotFound) {
+                    resolve(false);
+                }
+                else {
+                    reject(error);
+                }
+            });
+            return () => { };
+        });
+    }
+    *_accessOp(path) {
+        return yield* action((resolve, reject) => {
+            // In Deno, we check access by stating or trying to read/write.
+            // Simplified to checking existence and relying on OS permissions for now
+            dntShim.Deno.stat(path)
+                .then(() => resolve(true))
+                .catch(() => resolve(false));
+            return () => { };
+        });
+    }
+    *_mkdirOp(path, perm) {
+        return yield* action((resolve, reject) => {
+            dntShim.Deno.mkdir(path, { recursive: true, mode: perm })
+                .then(() => resolve(true))
+                .catch((error) => {
+                if (error instanceof dntShim.Deno.errors.PermissionDenied) {
+                    resolve(false);
+                }
+                else {
+                    reject(error);
+                }
+            });
+            return () => { };
+        });
+    }
+    *_rmOp(path) {
+        return yield* action((resolve, reject) => {
+            dntShim.Deno.remove(path, { recursive: true })
+                .then(() => resolve(undefined))
+                .catch((error) => {
+                if (error instanceof dntShim.Deno.errors.NotFound) {
+                    resolve(undefined);
+                }
+                else {
+                    reject(error);
+                }
+            });
+            return () => { };
+        });
+    }
+    *_statFileOp(path) {
+        return yield* action((resolve, reject) => {
+            dntShim.Deno.stat(path)
+                .then((stats) => {
+                resolve({
+                    isDirectory: stats.isDirectory,
+                    isFile: stats.isFile,
+                });
+            })
+                .catch((error) => {
+                if (error instanceof dntShim.Deno.errors.NotFound) {
+                    resolve({
+                        isDirectory: false,
+                        isFile: false,
+                    });
+                }
+                else {
+                    reject(error);
+                }
+            });
+            return () => { };
+        });
+    }
+    /**
+     * Reopen/create the directory or file path
+     * Replicates KERIpy/HIO Filer.remake logic:
+     * - Tries primary path (/usr/local/var/keri/*) first
+     * - Falls back to alt path (~/.keri/*) on OS errors or access issues
+     *
+     * Uses Effection for structured concurrency:
+     * - All file system operations are cancellable
+     * - No dangling promises - operations tracked in Effection task tree
+     * - Automatic cleanup if parent operation is halted
+     */
+    *reopen(options = {}) {
+        const temp = options.temp ?? this.temp;
+        let headDirPath = options.headDirPath ?? this.headDirPath;
+        const perm = options.perm ?? this.perm;
+        const clear = options.clear || false;
+        const reuse = options.reuse || false;
+        const clean = options.clean || false;
+        const mode = options.mode ?? this.mode;
+        const fext = options.fext ?? this.fext;
+        this.temp = temp;
+        this.perm = perm;
+        this.mode = mode;
+        this.fext = fext;
+        let path;
+        const [primary, alt, tempPath] = this._getPaths({
+            ...options,
+            headDirPath,
+            clean,
+        });
+        if (temp) {
+            // Use temporary directory
+            path = tempPath;
+        }
+        else {
+            // Use persistent directory - try primary first, fall back to alt on error
+            path = primary;
+            let useAltPath = false;
+            // Only attempt fallback if using default headDirPath (not a custom one)
+            const usingDefaultHeadDir = headDirPath === this.defaults.headDirPath;
+            if (!reuse && usingDefaultHeadDir) {
+                // Check if path exists using Effection operation
+                const pathExists = yield* this._statOp(path);
+                if (!pathExists) {
+                    // Path doesn't exist, try to create it
+                    console.log(`Creating directory at ${path}`);
+                    const created = yield* this._mkdirOp(path, perm);
+                    if (!created) {
+                        // Creation failed (e.g., EACCES) - fall back to alt path
+                        console.log(`Failed to create primary path, falling back to alt path`);
+                        useAltPath = true;
+                        path = alt;
+                        headDirPath = this.defaults.altHeadDirPath;
+                    }
+                }
+                // If we're using alt path, ensure it exists
+                if (useAltPath) {
+                    const altPathExists = yield* this._statOp(path);
+                    if (!altPathExists) {
+                        // Alt path doesn't exist, create it
+                        console.log(`Creating alt directory at ${path}`);
+                        const created = yield* this._mkdirOp(path, perm);
+                        if (!created) {
+                            // Even alt path creation failed - this is unexpected, but we'll continue
+                            console.error(`Error: Failed to create alt directory at ${path}`);
+                            throw new PathError(`Failed to create alt directory at ${path}`, { path });
+                        }
+                    }
+                    else {
+                        // Path exists, verify access
+                        const altHasAccess = yield* this._accessOp(path);
+                        if (!altHasAccess) {
+                            // Path exists but no access - this shouldn't happen for alt path, but log it
+                            console.error(`Error: Alt path exists but is not accessible: ${path}`);
+                            throw new PathError(`Alt path exists but is not accessible: ${path}`, { path });
+                        }
+                    }
+                }
+            }
+            else if (reuse) {
+                // Reuse mode - just verify the path exists and is accessible
+                const pathExists = yield* this._statOp(path);
+                const hasAccess = pathExists ? yield* this._accessOp(path) : false;
+                if (!pathExists || !hasAccess) {
+                    // If reuse path doesn't work and we're using default, try alt
+                    if (usingDefaultHeadDir) {
+                        console.log(`Reuse path not accessible, trying alt path`);
+                        path = alt;
+                        headDirPath = this.defaults.altHeadDirPath;
+                        const altPathExists = yield* this._statOp(path);
+                        const altHasAccess = altPathExists
+                            ? yield* this._accessOp(path)
+                            : false;
+                        if (!altPathExists) {
+                            // Alt path doesn't exist, create it
+                            console.log(`Creating alt directory at ${path}`);
+                            const created = yield* this._mkdirOp(path, perm);
+                            if (!created) {
+                                console.warn(`Warning: Failed to create alt directory at ${path}`);
+                            }
+                        }
+                        else if (!altHasAccess) {
+                            // Alt path exists but not accessible - unexpected but continue
+                            console.warn(`Warning: Alt path exists but is not accessible: ${path}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Update headDirPath if we fell back to alt
+        this.headDirPath = headDirPath;
+        // Clear if requested
+        if (clear) {
+            const pathStat = yield* this._statFileOp(path);
+            if (pathStat && (pathStat.isDirectory || pathStat.isFile)) {
+                yield* this._rmOp(path);
+            }
+        }
+        // Create directory if it doesn't exist (final check)
+        if (!this.filed) {
+            const pathExists = yield* this._statOp(path);
+            if (!pathExists) {
+                // Path doesn't exist, create it
+                console.log(`Creating directory at ${path}`);
+                const created = yield* this._mkdirOp(path, perm);
+                if (!created) {
+                    // Creation failed - this is unexpected at this point, but log it
+                    console.warn(`Warning: Failed to create directory at ${path}`);
+                }
+            }
+            else {
+                // Path exists, verify we can access it
+                const hasAccess = yield* this._accessOp(path);
+                if (!hasAccess) {
+                    // Path exists but not accessible - unexpected but continue
+                    console.warn(`Warning: Path exists but is not accessible: ${path}`);
+                }
+            }
+        }
+        this.path = path;
+        this.opened = true;
+        return this.opened;
+    }
+    /**
+     * Close the path manager
+     * If clear is true, removes the directory/file
+     * Uses Effection for structured concurrency
+     */
+    *close(clear = false) {
+        if (clear && this.path) {
+            yield* this._rmOp(this.path);
+        }
+        this.path = null;
+        this.opened = false;
+        return true;
+    }
+    /**
+     * Check if database files exist in the path directory
+     * LMDB creates data.mdb and lock.mdb files
+     * Returns true if data.mdb exists (lock.mdb might not exist if no active transactions)
+     * Uses Effection for structured concurrency
+     */
+    *databaseFilesExist() {
+        if (!this.path) {
+            return false;
+        }
+        const dataMdbPath = `${this.path}/data.mdb`;
+        const pathStat = yield* this._statFileOp(dataMdbPath);
+        return pathStat.isFile ?? false;
+    }
+}

package/esm/db/index.js

@@ -0,0 +1,4 @@
+/**
+ * Database module exports
+ */
+export * from "./basing.js";

package/esm/npm/index.js

@@ -0,0 +1,4 @@
+import "../_dnt.polyfills.js";
+export * from "../core/index.js";
+export * from "../db/index.js";
+export { kli } from "../app/cli/cli.js";

package/esm/package.json

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

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "keri-ts",
+  "version": "0.1.0",
+  "description": "KERI TypeScript package with database primitives and CLI runtime",
+  "homepage": "https://github.com/kentbull/keri-ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kentbull/keri-ts.git"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/kentbull/keri-ts/issues"
+  },
+  "main": "./esm/npm/index.js",
+  "module": "./esm/npm/index.js",
+  "types": "./types/npm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/npm/index.js",
+      "types": "./types/npm/index.d.ts"
+    },
+    "./src/app/cli/cli-node.js": {
+      "import": {
+        "types": "./types/app/cli/cli-node.d.ts",
+        "default": "./esm/app/cli/cli-node.js"
+      }
+    }
+  },
+  "scripts": {
+    "prepublishOnly": "npm run test",
+    "test": "node --version"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "bin": {
+    "kli": "./esm/app/cli/cli-node.js"
+  },
+  "files": [
+    "esm",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^10.0.1",
+    "effection": "^3.6.0",
+    "lmdb": "^3.4.4",
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/types/_dnt.polyfills.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
+declare global {
+    interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** The absolute path of the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
+         * ```
+         */
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
+    }
+}
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;;;;;;;WAcG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;;;;;;;;;;;WAYG;QACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,CAAC;QACtE;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;;;;;;WAYG;QACH,QAAQ,EAAE,MAAM,CAAC;QAEjB;;;;;;;;;;;;WAYG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB;CACF;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,UAAU,0BAA0B;IAClC,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACxD;AACD,UAAU,0BAA0B;IAClC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AACD,UAAU,kBACR,SAAQ,0BAA0B,EAAE,0BAA0B;CAC/D;AAiBD,eAAO,IAAI,6BAA6B,EA2BnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,6BAA6B,EA4DnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,oBAAoB,EAoB1B,kBAAkB,CAAC"}

package/types/_dnt.shims.d.ts

@@ -0,0 +1,6 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/types/app/cli/agent.d.ts

@@ -0,0 +1,9 @@
+import { type Operation } from "effection";
+/**
+ * Agent command operation - starts the HTTP server
+ *
+ * @param args - Command arguments including optional port
+ * @returns Operation that runs the server until shutdown
+ */
+export declare function agentCommand(args: Record<string, unknown>): Operation<void>;
+//# sourceMappingURL=agent.d.ts.map

package/types/app/cli/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/app/cli/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAuB3C;;;;;GAKG;AACH,wBAAiB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,CAoB5E"}

package/types/app/cli/cli-node.d.ts

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

package/types/app/cli/cli-node.d.ts.map

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

package/types/app/cli/cli.d.ts

@@ -0,0 +1,7 @@
+import { type Operation } from "effection";
+/**
+ * Main CLI operation - runs within Effection's structured concurrency
+ * This is the outermost runtime, not JavaScript's event loop
+ */
+export declare function kli(args?: string[]): Operation<void>;
+//# sourceMappingURL=cli.d.ts.map

package/types/app/cli/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/app/cli/cli.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAuMnD;;;GAGG;AACH,wBAAiB,GAAG,CAAC,IAAI,GAAE,MAAM,EAAO,GAAG,SAAS,CAAC,IAAI,CAAC,CAkDzD"}