@byfriends/kaos 0.0.1

package/LICENSE

@@ -0,0 +1,28 @@
+BYF PROPRIETARY LICENSE
+
+Copyright (c) 2026-2027 ByronFinn
+
+Permission is hereby granted to copy and redistribute this software in its
+unmodified form, without charge. This permission does not extend to modified
+versions of the software.
+
+Local modification of this software for personal use is permitted, provided
+that such modifications are not distributed to third parties.
+
+Restrictions:
+1. You may NOT redistribute modified versions of this software.
+2. You may NOT use this software for commercial purposes.
+3. You may NOT sublicense, sell, or offer this software as a service.
+
+This software is source-available but NOT open source. The source code is
+made publicly visible for review purposes only.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+For questions about licensing, contact: https://github.com/ByronFinn/byf/issues

package/README.md

@@ -0,0 +1,11 @@
+# @byfriends/kaos
+
+Execution environment abstraction used by BYF.
+
+Part of the [BYF](https://github.com/ByronFinn/byf) monorepo.
+
+See the main repository for documentation, issues, and contribution guidelines.
+
+## License
+
+Proprietary — see the root LICENSE file.

package/dist/index.d.mts

@@ -0,0 +1,344 @@
+
+import { Readable, Writable } from "node:stream";
+
+//#region src/process.d.ts
+/**
+ * A running process spawned by a {@link Kaos} environment.
+ *
+ * Provides access to standard I/O streams, the process ID, and lifecycle
+ * management (wait / kill). The interface is intentionally minimal so it
+ * can be backed by local child processes, SSH sessions, or container runtimes.
+ */
+interface KaosProcess {
+  /** Writable stream connected to the process's standard input. */
+  readonly stdin: Writable;
+  /** Readable stream for the process's standard output. */
+  readonly stdout: Readable;
+  /** Readable stream for the process's standard error. */
+  readonly stderr: Readable;
+  /** Operating-system process ID. */
+  readonly pid: number;
+  /** Exit code if the process has already terminated, otherwise `null`. */
+  readonly exitCode: number | null;
+  /** Wait for the process to exit and return its exit code. */
+  wait(): Promise<number>;
+  /** Send a signal to the process (defaults to `SIGTERM`). */
+  kill(signal?: NodeJS.Signals): Promise<void>;
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * KAOS stat result, mirroring Python's os.stat_result fields.
+ */
+interface StatResult {
+  stMode: number;
+  stIno: number;
+  stDev: number;
+  stNlink: number;
+  stUid: number;
+  stGid: number;
+  stSize: number;
+  stAtime: number;
+  stMtime: number;
+  stCtime: number;
+}
+//#endregion
+//#region src/kaos.d.ts
+/**
+ * Byf Agent Operating System (KAOS) interface.
+ *
+ * This is the core abstraction that allows the agent to interact with
+ * different execution environments (local, SSH, containers, etc.)
+ * through a unified API.
+ */
+interface Kaos {
+  /** Human-readable name for this environment (e.g. `"local"`, `"ssh:host"`). */
+  readonly name: string;
+  /** Return the path style used by this environment. */
+  pathClass(): 'posix' | 'win32';
+  /** Normalize the given path string (resolve `.` / `..` segments). */
+  normpath(path: string): string;
+  /** Return the home directory of the current user. */
+  gethome(): string;
+  /** Return the current working directory. */
+  getcwd(): string;
+  /** Change the working directory to `path`. */
+  chdir(path: string): Promise<void>;
+  /** Return stat metadata for `path`. */
+  stat(path: string, options?: {
+    followSymlinks?: boolean;
+  }): Promise<StatResult>;
+  /** Yield entry names in the directory at `path`. */
+  iterdir(path: string): AsyncGenerator<string>;
+  /** Yield paths matching `pattern` under `path`. */
+  glob(path: string, pattern: string, options?: {
+    caseSensitive?: boolean;
+  }): AsyncGenerator<string>;
+  /** Read up to `n` bytes from `path` (all bytes if `n` is omitted). */
+  readBytes(path: string, n?: number): Promise<Buffer>;
+  /**
+   * Read the file at `path` as a string.
+   *
+   * `errors` controls how decode errors are handled — mirrors Python's
+   * `open(..., errors=)` parameter:
+   * - `'strict'` (default): throw on any invalid byte for the encoding
+   * - `'replace'`: substitute each invalid byte with U+FFFD (REPLACEMENT CHARACTER)
+   * - `'ignore'`: drop invalid bytes silently
+   */
+  readText(path: string, options?: {
+    encoding?: BufferEncoding;
+    errors?: 'strict' | 'replace' | 'ignore';
+  }): Promise<string>;
+  /** Yield lines from the file at `path` one by one. */
+  readLines(path: string, options?: {
+    encoding?: BufferEncoding;
+    errors?: 'strict' | 'replace' | 'ignore';
+  }): AsyncGenerator<string>;
+  /** Write raw bytes to `path`, returning the number of bytes written. */
+  writeBytes(path: string, data: Buffer): Promise<number>;
+  /** Write text to `path`, returning the number of characters written. */
+  writeText(path: string, data: string, options?: {
+    mode?: 'w' | 'a';
+    encoding?: BufferEncoding;
+  }): Promise<number>;
+  /** Create a directory at `path`. */
+  mkdir(path: string, options?: {
+    parents?: boolean;
+    existOk?: boolean;
+  }): Promise<void>;
+  /** Spawn a process with the given arguments. */
+  exec(...args: string[]): Promise<KaosProcess>;
+  /** Spawn a process with explicit environment variables. */
+  execWithEnv(args: string[], env?: Record<string, string>): Promise<KaosProcess>;
+}
+//#endregion
+//#region src/current.d.ts
+/**
+ * Return the {@link Kaos} instance for the current async context.
+ *
+ * If {@link runWithKaos} has bound an instance for this context it is
+ * returned; otherwise a lazily-created {@link LocalKaos} default is used.
+ */
+declare function getCurrentKaos(): Kaos;
+declare function runWithKaos<T>(kaos: Kaos, fn: () => T): T;
+/**
+ * Token returned by setCurrentKaos, used to restore the previous instance.
+ * Mirrors Python's ContextVar Token pattern.
+ */
+interface KaosToken {
+  readonly previousKaos: Kaos | null;
+}
+/**
+ * Set the current kaos instance and return a token for restoring the previous one.
+ *
+ * Unlike a plain module-level global, this binds the override to the current
+ * async context so concurrent tasks do not pollute each other. The returned
+ * token can later be passed to {@link resetCurrentKaos} to restore the
+ * previously-visible instance, mirroring Python's ContextVar token pattern.
+ */
+declare function setCurrentKaos(kaos: Kaos): KaosToken;
+declare function resetCurrentKaos(token: KaosToken): void;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Base error class for the kaos package.
+ */
+declare class KaosError extends Error {
+  constructor(message: string);
+}
+/**
+ * Equivalent to Python's ValueError — indicates an invalid argument was passed.
+ */
+declare class KaosValueError extends KaosError {
+  constructor(message: string);
+}
+/**
+ * Equivalent to Python's FileExistsError — indicates a file or directory already exists.
+ */
+declare class KaosFileExistsError extends KaosError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/path.d.ts
+/**
+ * A path wrapper class that delegates all I/O operations to the current Kaos instance.
+ * The path string is interpreted with the path class active at construction time.
+ */
+declare class KaosPath {
+  private _path;
+  private _pathClass;
+  constructor(...args: string[]);
+  private static _from;
+  private _currentKaos;
+  /** The final component of this path (like Python's Path.name). */
+  get name(): string;
+  /** The logical parent of this path (like Python's Path.parent). */
+  get parent(): KaosPath;
+  isAbsolute(): boolean;
+  joinpath(...other: string[]): KaosPath;
+  /** Division operator equivalent: join with another path segment. */
+  div(other: string | KaosPath): KaosPath;
+  /**
+   * Canonicalize the path without touching the filesystem.
+   * Makes the path absolute (relative to cwd) and resolves '..' segments.
+   */
+  canonical(): KaosPath;
+  /** Compute a relative path from `other` to this path. */
+  relativeTo(other: KaosPath): KaosPath;
+  /** Expand leading ~ to the home directory. */
+  expanduser(): KaosPath;
+  static home(): KaosPath;
+  static cwd(): KaosPath;
+  /** Create a KaosPath from a local filesystem path string. */
+  static fromLocalPath(localPath: string): KaosPath;
+  /** Return the underlying path string for local filesystem use. */
+  toLocalPath(): string;
+  toString(): string;
+  equals(other: KaosPath): boolean;
+  /** Get stat information for this path. */
+  stat(options?: {
+    followSymlinks?: boolean;
+  }): Promise<StatResult>;
+  /** Check if this path exists on the filesystem. */
+  exists(options?: {
+    followSymlinks?: boolean;
+  }): Promise<boolean>;
+  /** Check if this path points to a regular file. */
+  isFile(options?: {
+    followSymlinks?: boolean;
+  }): Promise<boolean>;
+  /** Check if this path points to a directory. */
+  isDir(options?: {
+    followSymlinks?: boolean;
+  }): Promise<boolean>;
+  /** Iterate over entries in this directory. */
+  iterdir(): AsyncGenerator<KaosPath>;
+  /** Glob for entries matching a pattern under this path. */
+  glob(pattern: string, options?: {
+    caseSensitive?: boolean;
+  }): AsyncGenerator<KaosPath>;
+  /** Read the file content as a Buffer. */
+  readBytes(n?: number): Promise<Buffer>;
+  /** Read the file content as a string. */
+  readText(options?: {
+    encoding?: BufferEncoding;
+    errors?: 'strict' | 'replace' | 'ignore';
+  }): Promise<string>;
+  /** Yield lines from the file one by one. */
+  readLines(options?: {
+    encoding?: BufferEncoding;
+    errors?: 'strict' | 'replace' | 'ignore';
+  }): AsyncGenerator<string>;
+  /** Write binary data to this path, return the number of bytes written. */
+  writeBytes(data: Buffer): Promise<number>;
+  /** Write text to this path, return the number of characters written. */
+  writeText(data: string, options?: {
+    mode?: 'w' | 'a';
+    encoding?: BufferEncoding;
+  }): Promise<number>;
+  /** Append text to this path, return the number of characters written. */
+  appendText(data: string, options?: {
+    encoding?: BufferEncoding;
+  }): Promise<number>;
+  /** Create this path as a directory. */
+  mkdir(options?: {
+    parents?: boolean;
+    existOk?: boolean;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/local.d.ts
+/**
+ * A KAOS implementation that directly interacts with the local filesystem.
+ *
+ * Note: LocalKaos maintains its own per-instance working directory (`_cwd`)
+ * rather than mutating `process.cwd()`. This lets multiple LocalKaos instances
+ * coexist with independent cwds (e.g. when switching contexts via
+ * `runWithKaos`) without cross-polluting each other's relative-path resolution.
+ */
+declare class LocalKaos implements Kaos {
+  readonly name: string;
+  private _cwd;
+  constructor();
+  private _resolvePath;
+  pathClass(): 'posix' | 'win32';
+  normpath(path: string): string;
+  gethome(): string;
+  getcwd(): string;
+  /**
+   * Change the working directory of this LocalKaos instance.
+   *
+   * Unlike Python's `os.chdir`, this is instance-scoped and never touches
+   * `process.cwd()`. Child processes spawned via {@link exec} inherit this
+   * instance's `_cwd`; concurrent LocalKaos instances each carry their own
+   * independent cwd. If you need Python-compatible process-global cwd,
+   * call `process.chdir(x)` directly.
+   */
+  chdir(path: string): Promise<void>;
+  stat(path: string, options?: {
+    followSymlinks?: boolean;
+  }): Promise<StatResult>;
+  iterdir(path: string): AsyncGenerator<string>;
+  glob(path: string, pattern: string, options?: {
+    caseSensitive?: boolean;
+  }): AsyncGenerator<string>;
+  private _globWalk;
+  readBytes(path: string, n?: number): Promise<Buffer>;
+  readText(path: string, options?: {
+    encoding?: BufferEncoding;
+    errors?: 'strict' | 'replace' | 'ignore';
+  }): Promise<string>;
+  readLines(path: string, options?: {
+    encoding?: BufferEncoding;
+    errors?: 'strict' | 'replace' | 'ignore';
+  }): AsyncGenerator<string>;
+  writeBytes(path: string, data: Buffer): Promise<number>;
+  writeText(path: string, data: string, options?: {
+    mode?: 'w' | 'a';
+    encoding?: BufferEncoding;
+  }): Promise<number>;
+  mkdir(path: string, options?: {
+    parents?: boolean;
+    existOk?: boolean;
+  }): Promise<void>;
+  exec(...args: string[]): Promise<KaosProcess>;
+  execWithEnv(args: string[], env?: Record<string, string>): Promise<KaosProcess>;
+}
+/** The default local KAOS instance. */
+declare const localKaos: LocalKaos;
+//#endregion
+//#region src/index.d.ts
+declare function readText(path: string, options?: {
+  encoding?: BufferEncoding;
+  errors?: 'strict' | 'replace' | 'ignore';
+}): Promise<string>;
+declare function writeText(path: string, data: string, options?: {
+  mode?: 'w' | 'a';
+  encoding?: BufferEncoding;
+}): Promise<number>;
+declare function readLines(path: string, options?: {
+  encoding?: BufferEncoding;
+  errors?: 'strict' | 'replace' | 'ignore';
+}): AsyncGenerator<string>;
+declare function exec(...args: string[]): Promise<KaosProcess>;
+declare function readBytes(path: string, n?: number): Promise<Buffer>;
+declare function writeBytes(path: string, data: Buffer): Promise<number>;
+declare function stat(path: string, options?: {
+  followSymlinks?: boolean;
+}): Promise<StatResult>;
+declare function mkdir(path: string, options?: {
+  parents?: boolean;
+  existOk?: boolean;
+}): Promise<void>;
+declare function iterdir(path: string): AsyncGenerator<string>;
+declare function glob(path: string, pattern: string, options?: {
+  caseSensitive?: boolean;
+}): AsyncGenerator<string>;
+declare function chdir(path: string): Promise<void>;
+declare function getcwd(): string;
+declare function gethome(): string;
+declare function normpath(path: string): string;
+declare function pathClass(): 'posix' | 'win32';
+declare function execWithEnv(args: string[], env?: Record<string, string>): Promise<KaosProcess>;
+//#endregion
+export { type Kaos, KaosError, KaosFileExistsError, KaosPath, type KaosProcess, type KaosToken, KaosValueError, LocalKaos, type StatResult, chdir, exec, execWithEnv, getCurrentKaos, getcwd, gethome, glob, iterdir, localKaos, mkdir, normpath, pathClass, readBytes, readLines, readText, resetCurrentKaos, runWithKaos, setCurrentKaos, stat, writeBytes, writeText };

package/dist/index.mjs

@@ -0,0 +1,925 @@
+import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
+import { dirname as __cjsShimDirname } from 'node:path';
+const __filename = __cjsShimFileURLToPath(import.meta.url);
+const __dirname = __cjsShimDirname(__filename);
+import { AsyncLocalStorage } from "node:async_hooks";
+import { spawn } from "node:child_process";
+import { appendFile, lstat, mkdir as mkdir$1, open, readFile, readdir, stat as stat$1, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, normalize } from "node:path";
+import { Readable } from "node:stream";
+import * as posixPath from "node:path/posix";
+import * as win32Path from "node:path/win32";
+//#region src/errors.ts
+/**
+* Base error class for the kaos package.
+*/
+var KaosError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "KaosError";
+	}
+};
+/**
+* Equivalent to Python's ValueError — indicates an invalid argument was passed.
+*/
+var KaosValueError = class extends KaosError {
+	constructor(message) {
+		super(message);
+		this.name = "KaosValueError";
+	}
+};
+/**
+* Equivalent to Python's FileExistsError — indicates a file or directory already exists.
+*/
+var KaosFileExistsError = class extends KaosError {
+	constructor(message) {
+		super(message);
+		this.name = "KaosFileExistsError";
+	}
+};
+//#endregion
+//#region src/internal.ts
+function isUtf8Continuation(byte) {
+	return byte >= 128 && byte <= 191;
+}
+function decodeUtf8Ignore(data) {
+	let output = "";
+	let i = 0;
+	while (i < data.length) {
+		const b0 = data[i];
+		if (b0 === void 0) break;
+		if (b0 <= 127) {
+			output += String.fromCodePoint(b0);
+			i += 1;
+			continue;
+		}
+		if (b0 >= 194 && b0 <= 223) {
+			const b1 = data[i + 1];
+			if (b1 !== void 0 && isUtf8Continuation(b1)) {
+				output += String.fromCodePoint((b0 & 31) << 6 | b1 & 63);
+				i += 2;
+				continue;
+			}
+			i += 1;
+			continue;
+		}
+		if (b0 >= 224 && b0 <= 239) {
+			const b1 = data[i + 1];
+			const b2 = data[i + 2];
+			if (b1 !== void 0 && (b0 === 224 && b1 >= 160 && b1 <= 191 || b0 >= 225 && b0 <= 236 && isUtf8Continuation(b1) || b0 === 237 && b1 >= 128 && b1 <= 159 || b0 >= 238 && b0 <= 239 && isUtf8Continuation(b1)) && b2 !== void 0 && isUtf8Continuation(b2)) {
+				output += String.fromCodePoint((b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63);
+				i += 3;
+				continue;
+			}
+			i += 1;
+			continue;
+		}
+		if (b0 >= 240 && b0 <= 244) {
+			const b1 = data[i + 1];
+			const b2 = data[i + 2];
+			const b3 = data[i + 3];
+			if (b1 !== void 0 && (b0 === 240 && b1 >= 144 && b1 <= 191 || b0 >= 241 && b0 <= 243 && isUtf8Continuation(b1) || b0 === 244 && b1 >= 128 && b1 <= 143) && b2 !== void 0 && b3 !== void 0 && isUtf8Continuation(b2) && isUtf8Continuation(b3)) {
+				output += String.fromCodePoint((b0 & 7) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63);
+				i += 4;
+				continue;
+			}
+			i += 1;
+			continue;
+		}
+		i += 1;
+	}
+	return output;
+}
+function decodeUtf16LeIgnore(data) {
+	let output = "";
+	let i = 0;
+	while (i + 1 < data.length) {
+		const first = data[i];
+		const second = data[i + 1];
+		if (first === void 0 || second === void 0) break;
+		const codeUnit = first | second << 8;
+		if (codeUnit >= 55296 && codeUnit <= 56319) {
+			const lowFirst = data[i + 2];
+			const lowSecond = data[i + 3];
+			if (lowFirst !== void 0 && lowSecond !== void 0) {
+				const low = lowFirst | lowSecond << 8;
+				if (low >= 56320 && low <= 57343) {
+					const codePoint = 65536 + (codeUnit - 55296 << 10) + (low - 56320);
+					output += String.fromCodePoint(codePoint);
+					i += 4;
+					continue;
+				}
+			}
+			i += 2;
+			continue;
+		}
+		if (codeUnit >= 56320 && codeUnit <= 57343) {
+			i += 2;
+			continue;
+		}
+		output += String.fromCodePoint(codeUnit);
+		i += 2;
+	}
+	return output;
+}
+/**
+* Decode a Buffer into a string with Python-compatible `errors` handling.
+*
+* - `'strict'` (default): throw on invalid sequences (via TextDecoder `fatal: true`)
+* - `'replace'`: substitute each invalid sequence with U+FFFD (TextDecoder default)
+* - `'ignore'`: drop invalid input sequences while preserving valid U+FFFD characters
+*
+* Falls back to `Buffer.toString(encoding)` for encodings TextDecoder does not
+* support (e.g. `hex`, `base64`, `binary`, `latin1`) — those are lossless
+* byte-to-character mappings so `errors` has no effect.
+* @internal
+*/
+function decodeTextWithErrors(data, encoding, errors = "strict") {
+	let webLabel;
+	switch (encoding) {
+		case "utf-8":
+		case "utf8":
+			webLabel = "utf-8";
+			break;
+		case "utf16le":
+		case "ucs2":
+		case "ucs-2":
+			webLabel = "utf-16le";
+			break;
+		default: webLabel = void 0;
+	}
+	if (webLabel === void 0) return data.toString(encoding);
+	if (errors === "strict") return new TextDecoder(webLabel, { fatal: true }).decode(data);
+	if (errors === "ignore") return webLabel === "utf-8" ? decodeUtf8Ignore(data) : decodeUtf16LeIgnore(data);
+	return new TextDecoder(webLabel, { fatal: false }).decode(data);
+}
+/**
+* Convert a glob pattern segment (e.g. "*.txt", "file?.log") into a RegExp.
+* Mirrors Python pathlib behavior: includes dotfiles, case-sensitive by default.
+* @internal
+*/
+function globPatternToRegex(pattern, caseSensitive) {
+	let regex = "^";
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === void 0) break;
+		switch (ch) {
+			case "*":
+				regex += "[^/]*";
+				break;
+			case "?":
+				regex += "[^/]";
+				break;
+			case "[": {
+				const end = pattern.indexOf("]", i + 1);
+				if (end === -1) regex += "\\[";
+				else {
+					let charClass = pattern.slice(i + 1, end);
+					if (charClass.startsWith("!")) charClass = "^" + charClass.slice(1);
+					else if (charClass.startsWith("^")) charClass = "\\" + charClass;
+					regex += "[" + charClass + "]";
+					i = end;
+				}
+				break;
+			}
+			default: regex += ch.replaceAll(/[{}()+.\\^$|]/g, "\\$&");
+		}
+	}
+	regex += "$";
+	return new RegExp(regex, caseSensitive ? "" : "i");
+}
+/**
+* A Readable wrapper that preserves source backpressure while still allowing
+* consumers to read buffered output after the source has ended.
+* @internal
+*/
+var BufferedReadable = class extends Readable {
+	_source;
+	_ended = false;
+	constructor(source) {
+		super({ highWaterMark: 128 * 1024 });
+		this._source = source;
+		this._source.on("data", this._onData);
+		this._source.on("end", this._onEnd);
+		this._source.on("close", this._onClose);
+		this._source.on("error", this._onError);
+	}
+	_read() {
+		if (!this._ended && !this.destroyed) this._source.resume();
+	}
+	_destroy(error, callback) {
+		this._source.off("data", this._onData);
+		this._source.off("end", this._onEnd);
+		this._source.off("close", this._onClose);
+		this._source.off("error", this._onError);
+		callback(error);
+	}
+	_onData = (chunk) => {
+		if (!this.push(chunk)) this._source.pause();
+	};
+	_onEnd = () => {
+		this._ended = true;
+		this.push(null);
+	};
+	_onClose = () => {
+		if (!this._ended) {
+			this._ended = true;
+			this.push(null);
+		}
+	};
+	_onError = (error) => {
+		this.destroy(error);
+	};
+};
+//#endregion
+//#region src/local.ts
+const isWindows = process.platform === "win32";
+/**
+* Build the `(dev, ino)` cycle-detection key used by `_globWalk`'s
+* visited set. Returns `null` when `ino` is 0, which Node returns on
+* filesystems that don't carry inodes (Windows FAT/exFAT, some SMB/NFS
+* mounts). A null key signals "no reliable identity for this dir" so
+* the caller skips visited tracking for that descent — cycle safety
+* is weakened on those filesystems, but normal walking works instead
+* of every directory colliding on the shared key `"<dev>:0"`.
+*/
+function cycleKey(s) {
+	if (s.ino === 0) return null;
+	return `${String(s.dev)}:${String(s.ino)}`;
+}
+var LocalProcess = class {
+	stdin;
+	stdout;
+	stderr;
+	pid;
+	_child;
+	_exitCode = null;
+	_exitPromise;
+	constructor(child) {
+		if (child.stdin === null || child.stdout === null || child.stderr === null) throw new Error("Process must be created with stdin/stdout/stderr pipes.");
+		this._child = child;
+		this.stdin = child.stdin;
+		this.stdout = new BufferedReadable(child.stdout);
+		this.stderr = new BufferedReadable(child.stderr);
+		this.pid = child.pid ?? -1;
+		this._exitPromise = new Promise((resolve, reject) => {
+			child.on("exit", (code) => {
+				this._exitCode = code ?? -1;
+				resolve(this._exitCode);
+			});
+			child.on("error", (error) => {
+				reject(error);
+			});
+		});
+	}
+	get exitCode() {
+		return this._exitCode;
+	}
+	async wait() {
+		return this._exitPromise;
+	}
+	kill(signal) {
+		if (this.pid <= 0) return Promise.resolve();
+		if (isWindows) {
+			const taskkillArgs = signal === "SIGKILL" ? [
+				"/T",
+				"/F",
+				"/PID",
+				String(this.pid)
+			] : [
+				"/T",
+				"/PID",
+				String(this.pid)
+			];
+			return new Promise((resolve) => {
+				const killer = spawn("taskkill", taskkillArgs, {
+					stdio: "ignore",
+					windowsHide: true
+				});
+				const done = () => {
+					resolve();
+				};
+				killer.once("error", done);
+				killer.once("close", done);
+			});
+		}
+		try {
+			process.kill(-this.pid, signal ?? "SIGTERM");
+		} catch (error) {
+			const err = error;
+			if (err.code === "ESRCH") return Promise.resolve();
+			if (err.code === "EPERM") {
+				try {
+					this._child.kill(signal ?? "SIGTERM");
+				} catch {}
+				return Promise.resolve();
+			}
+			throw error;
+		}
+		return Promise.resolve();
+	}
+};
+/**
+* A KAOS implementation that directly interacts with the local filesystem.
+*
+* Note: LocalKaos maintains its own per-instance working directory (`_cwd`)
+* rather than mutating `process.cwd()`. This lets multiple LocalKaos instances
+* coexist with independent cwds (e.g. when switching contexts via
+* `runWithKaos`) without cross-polluting each other's relative-path resolution.
+*/
+var LocalKaos = class {
+	name = "local";
+	_cwd;
+	constructor() {
+		this._cwd = process.cwd();
+	}
+	_resolvePath(path) {
+		if (isAbsolute(path)) return path;
+		return join(this._cwd, path);
+	}
+	pathClass() {
+		return isWindows ? "win32" : "posix";
+	}
+	normpath(path) {
+		return normalize(path);
+	}
+	gethome() {
+		return homedir();
+	}
+	getcwd() {
+		return this._cwd;
+	}
+	/**
+	* Change the working directory of this LocalKaos instance.
+	*
+	* Unlike Python's `os.chdir`, this is instance-scoped and never touches
+	* `process.cwd()`. Child processes spawned via {@link exec} inherit this
+	* instance's `_cwd`; concurrent LocalKaos instances each carry their own
+	* independent cwd. If you need Python-compatible process-global cwd,
+	* call `process.chdir(x)` directly.
+	*/
+	async chdir(path) {
+		const resolved = this._resolvePath(path);
+		if (!(await stat$1(resolved)).isDirectory()) throw new Error(`Not a directory: ${resolved}`);
+		this._cwd = resolved;
+	}
+	async stat(path, options) {
+		const resolved = this._resolvePath(path);
+		const s = options?.followSymlinks ?? true ? await stat$1(resolved) : await lstat(resolved);
+		return {
+			stMode: s.mode,
+			stIno: s.ino,
+			stDev: s.dev,
+			stNlink: s.nlink,
+			stUid: s.uid,
+			stGid: s.gid,
+			stSize: s.size,
+			stAtime: s.atimeMs / 1e3,
+			stMtime: s.mtimeMs / 1e3,
+			stCtime: isWindows ? s.birthtimeMs / 1e3 : s.ctimeMs / 1e3
+		};
+	}
+	async *iterdir(path) {
+		const resolved = this._resolvePath(path);
+		const entries = await readdir(resolved);
+		for (const entry of entries) yield join(resolved, entry);
+	}
+	async *glob(path, pattern, options) {
+		const resolved = this._resolvePath(path);
+		const caseSensitive = options?.caseSensitive ?? true;
+		const patternParts = pattern.split("/");
+		const initVisited = /* @__PURE__ */ new Set();
+		try {
+			const rootKey = cycleKey(await stat$1(resolved));
+			if (rootKey !== null) initVisited.add(rootKey);
+		} catch {}
+		yield* this._globWalk(resolved, patternParts, caseSensitive, initVisited);
+	}
+	async *_globWalk(basePath, patternParts, caseSensitive, visited) {
+		if (patternParts.length === 0) return;
+		const [currentPattern, ...remainingParts] = patternParts;
+		if (currentPattern === "**") {
+			if (remainingParts.length > 0) yield* this._globWalk(basePath, remainingParts, caseSensitive, visited);
+			else yield basePath;
+			let entries;
+			try {
+				entries = await readdir(basePath);
+			} catch {
+				return;
+			}
+			for (const entry of entries) {
+				const fullPath = join(basePath, entry);
+				let entryStat;
+				try {
+					entryStat = await stat$1(fullPath);
+				} catch {
+					continue;
+				}
+				if (entryStat.isDirectory()) {
+					const key = cycleKey(entryStat);
+					if (key !== null && visited.has(key)) continue;
+					yield* this._globWalk(fullPath, patternParts, caseSensitive, key !== null ? new Set([...visited, key]) : visited);
+				} else if (remainingParts.length === 0) yield fullPath;
+			}
+		} else {
+			const regex = globPatternToRegex(currentPattern ?? "", caseSensitive);
+			let entries;
+			try {
+				entries = await readdir(basePath);
+			} catch {
+				return;
+			}
+			for (const entry of entries) {
+				if (!regex.test(entry)) continue;
+				const fullPath = join(basePath, entry);
+				if (remainingParts.length === 0) yield fullPath;
+				else {
+					let entryStat;
+					try {
+						entryStat = await stat$1(fullPath);
+					} catch {
+						continue;
+					}
+					if (entryStat.isDirectory()) {
+						const key = cycleKey(entryStat);
+						if (key !== null && visited.has(key)) continue;
+						yield* this._globWalk(fullPath, remainingParts, caseSensitive, key !== null ? new Set([...visited, key]) : visited);
+					}
+				}
+			}
+		}
+	}
+	async readBytes(path, n) {
+		const resolved = this._resolvePath(path);
+		if (n === void 0) return Buffer.from(await readFile(resolved));
+		const fh = await open(resolved, "r");
+		try {
+			const buf = Buffer.alloc(n);
+			const { bytesRead } = await fh.read(buf, 0, n, 0);
+			return buf.subarray(0, bytesRead);
+		} finally {
+			await fh.close();
+		}
+	}
+	async readText(path, options) {
+		const resolved = this._resolvePath(path);
+		const encoding = options?.encoding ?? "utf-8";
+		const errors = options?.errors ?? "strict";
+		return decodeTextWithErrors(await readFile(resolved), encoding, errors);
+	}
+	async *readLines(path, options) {
+		const resolved = this._resolvePath(path);
+		const encoding = options?.encoding ?? "utf-8";
+		const errors = options?.errors ?? "strict";
+		const lines = decodeTextWithErrors(await readFile(resolved), encoding, errors).split("\n");
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (line === void 0) continue;
+			if (i < lines.length - 1) yield line + "\n";
+			else if (line !== "") yield line;
+		}
+	}
+	async writeBytes(path, data) {
+		await writeFile(this._resolvePath(path), data);
+		return data.length;
+	}
+	async writeText(path, data, options) {
+		const resolved = this._resolvePath(path);
+		const encoding = options?.encoding ?? "utf-8";
+		if ((options?.mode ?? "w") === "a") await appendFile(resolved, data, encoding);
+		else await writeFile(resolved, data, encoding);
+		return data.length;
+	}
+	async mkdir(path, options) {
+		const resolved = this._resolvePath(path);
+		const parents = options?.parents ?? false;
+		const existOk = options?.existOk ?? false;
+		if (parents) {
+			if (!existOk) try {
+				if ((await stat$1(resolved)).isDirectory()) throw new KaosFileExistsError(`${resolved} already exists`);
+			} catch (error) {
+				if (error instanceof KaosFileExistsError) throw error;
+				if (error.code !== "ENOENT") throw error;
+			}
+			await mkdir$1(resolved, { recursive: true });
+			return;
+		}
+		try {
+			await mkdir$1(resolved);
+		} catch (error) {
+			if (existOk && error instanceof Error && "code" in error && error.code === "EEXIST") {
+				if (!(await stat$1(resolved)).isDirectory()) throw new KaosFileExistsError(`${resolved} already exists but is not a directory`);
+				return;
+			}
+			throw error;
+		}
+	}
+	async exec(...args) {
+		const command = args[0];
+		if (command === void 0) throw new Error("LocalKaos.exec(): at least one argument (the command to run) is required.");
+		const child = spawn(command, args.slice(1), {
+			cwd: this._cwd,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			detached: !isWindows
+		});
+		await waitForSpawn(child);
+		return new LocalProcess(child);
+	}
+	async execWithEnv(args, env) {
+		const command = args[0];
+		if (command === void 0) throw new Error("LocalKaos.execWithEnv(): at least one argument (the command to run) is required.");
+		const child = spawn(command, args.slice(1), {
+			cwd: this._cwd,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			detached: !isWindows,
+			env
+		});
+		await waitForSpawn(child);
+		return new LocalProcess(child);
+	}
+};
+function waitForSpawn(child) {
+	return new Promise((resolve, reject) => {
+		const onSpawn = () => {
+			child.off("error", onError);
+			resolve();
+		};
+		const onError = (err) => {
+			child.off("spawn", onSpawn);
+			reject(err);
+		};
+		child.once("spawn", onSpawn);
+		child.once("error", onError);
+	});
+}
+/** The default local KAOS instance. */
+const localKaos = new LocalKaos();
+//#endregion
+//#region src/current.ts
+const kaosStorage = new AsyncLocalStorage();
+function getDefaultKaos() {
+	return localKaos;
+}
+/**
+* Return the {@link Kaos} instance for the current async context.
+*
+* If {@link runWithKaos} has bound an instance for this context it is
+* returned; otherwise a lazily-created {@link LocalKaos} default is used.
+*/
+function getCurrentKaos() {
+	return kaosStorage.getStore() ?? getDefaultKaos();
+}
+function runWithKaos(kaos, fn) {
+	return kaosStorage.run(kaos, fn);
+}
+/**
+* Set the current kaos instance and return a token for restoring the previous one.
+*
+* Unlike a plain module-level global, this binds the override to the current
+* async context so concurrent tasks do not pollute each other. The returned
+* token can later be passed to {@link resetCurrentKaos} to restore the
+* previously-visible instance, mirroring Python's ContextVar token pattern.
+*/
+function setCurrentKaos(kaos) {
+	const token = { previousKaos: getCurrentKaos() };
+	kaosStorage.enterWith(kaos);
+	return token;
+}
+function resetCurrentKaos(token) {
+	kaosStorage.enterWith(token.previousKaos ?? getDefaultKaos());
+}
+//#endregion
+//#region src/path.ts
+const S_IFMT = 61440;
+const S_IFDIR = 16384;
+const S_IFREG = 32768;
+/**
+* Return the path module matching the current Kaos path class.
+*/
+function getPathMod(pathClass = getCurrentKaos().pathClass()) {
+	return pathClass === "win32" ? win32Path : posixPath;
+}
+function splitPathLexically(pathMod, path) {
+	const root = pathMod.parse(path).root;
+	return {
+		root,
+		parts: (root.length > 0 ? path.slice(root.length) : path).split(pathMod.sep).filter((part) => part.length > 0)
+	};
+}
+function splitPosixPart(path) {
+	const root = path.startsWith("//") && !path.startsWith("///") ? "//" : path.startsWith("/") ? "/" : "";
+	return {
+		root,
+		parts: (root.length > 0 ? path.slice(root.length) : path).split("/").filter((part) => part.length > 0 && part !== ".")
+	};
+}
+function joinPosixPure(parts) {
+	let root = "";
+	let pathParts = [];
+	for (const part of parts) {
+		if (part === "") continue;
+		const parsed = splitPosixPart(part);
+		if (parsed.root !== "") {
+			root = parsed.root;
+			pathParts = parsed.parts;
+		} else pathParts.push(...parsed.parts);
+	}
+	if (root !== "") return pathParts.length === 0 ? root : root + pathParts.join("/");
+	return pathParts.length === 0 ? "." : pathParts.join("/");
+}
+function splitWin32Part(path) {
+	const normalized = path.replaceAll("/", "\\");
+	const parsed = win32Path.parse(normalized);
+	let drive = "";
+	let root = "";
+	if (/^[A-Za-z]:/.test(parsed.root)) {
+		drive = parsed.root.slice(0, 2);
+		root = parsed.root.length > 2 ? "\\" : "";
+	} else if (parsed.root.startsWith("\\\\")) {
+		drive = parsed.root.endsWith("\\") ? parsed.root.slice(0, -1) : parsed.root;
+		root = "\\";
+	} else if (parsed.root === "\\" || parsed.root === "/") root = "\\";
+	const tail = normalized.slice(parsed.root.length);
+	return {
+		drive,
+		root,
+		parts: tail.split("\\").filter((part) => part.length > 0 && part !== ".")
+	};
+}
+function formatWin32Pure(drive, root, parts) {
+	const anchor = drive + root;
+	if (anchor !== "") return parts.length === 0 ? anchor : anchor + parts.join("\\");
+	return parts.length === 0 ? "." : parts.join("\\");
+}
+function joinWin32Pure(parts) {
+	let drive = "";
+	let root = "";
+	let pathParts = [];
+	for (const part of parts) {
+		if (part === "") continue;
+		const parsed = splitWin32Part(part);
+		if (parsed.root !== "") {
+			drive = parsed.drive !== "" ? parsed.drive : drive;
+			root = parsed.root;
+			pathParts = parsed.parts;
+			continue;
+		}
+		if (parsed.drive !== "") {
+			if (drive.toLowerCase() !== parsed.drive.toLowerCase()) {
+				drive = parsed.drive;
+				root = "";
+				pathParts = parsed.parts;
+			} else pathParts.push(...parsed.parts);
+			continue;
+		}
+		pathParts.push(...parsed.parts);
+	}
+	return formatWin32Pure(drive, root, pathParts);
+}
+function joinPure(pathClass, parts) {
+	return pathClass === "win32" ? joinWin32Pure(parts) : joinPosixPure(parts);
+}
+function isWin32DriveRelative(path) {
+	return /^[A-Za-z]:(?:$|[^\\/])/.test(path);
+}
+/**
+* A path wrapper class that delegates all I/O operations to the current Kaos instance.
+* The path string is interpreted with the path class active at construction time.
+*/
+var KaosPath = class KaosPath {
+	_path;
+	_pathClass;
+	constructor(...args) {
+		this._pathClass = getCurrentKaos().pathClass();
+		if (args.length === 0) this._path = ".";
+		else this._path = joinPure(this._pathClass, args);
+	}
+	static _from(path, pathClass) {
+		const ret = new KaosPath();
+		ret._path = path;
+		ret._pathClass = pathClass;
+		return ret;
+	}
+	_currentKaos(operation) {
+		const kaos = getCurrentKaos();
+		const currentPathClass = kaos.pathClass();
+		if (currentPathClass !== this._pathClass) throw new KaosValueError(`Cannot ${operation} ${this._pathClass} path ${this._path} with ${currentPathClass} kaos`);
+		if (this._pathClass === "win32" && isWin32DriveRelative(this._path)) throw new KaosValueError(`Cannot ${operation} drive-relative win32 path ${this._path}; use an absolute path like C:\\\\path or a path relative to cwd`);
+		return kaos;
+	}
+	/** The final component of this path (like Python's Path.name). */
+	get name() {
+		return getPathMod(this._pathClass).basename(this._path);
+	}
+	/** The logical parent of this path (like Python's Path.parent). */
+	get parent() {
+		const dir = getPathMod(this._pathClass).dirname(this._path);
+		return KaosPath._from(dir, this._pathClass);
+	}
+	isAbsolute() {
+		return getPathMod(this._pathClass).isAbsolute(this._path);
+	}
+	joinpath(...other) {
+		return KaosPath._from(joinPure(this._pathClass, [this._path, ...other]), this._pathClass);
+	}
+	/** Division operator equivalent: join with another path segment. */
+	div(other) {
+		if (other instanceof KaosPath && other._pathClass !== this._pathClass) throw new KaosValueError(`Cannot join ${other._pathClass} path to ${this._pathClass} path`);
+		const otherStr = other instanceof KaosPath ? other.toString() : other;
+		return this.joinpath(otherStr);
+	}
+	/**
+	* Canonicalize the path without touching the filesystem.
+	* Makes the path absolute (relative to cwd) and resolves '..' segments.
+	*/
+	canonical() {
+		const kaos = this._currentKaos("canonicalize");
+		const pathMod = getPathMod(this._pathClass);
+		if (pathMod.isAbsolute(this._path)) return KaosPath._from(pathMod.normalize(this._path), this._pathClass);
+		const cwd = kaos.getcwd();
+		if (!pathMod.isAbsolute(cwd)) throw new KaosValueError(`Cannot canonicalize ${this._path} against non-absolute cwd ${cwd}`);
+		const abs = pathMod.resolve(cwd, this._path);
+		return KaosPath._from(pathMod.normalize(abs), this._pathClass);
+	}
+	/** Compute a relative path from `other` to this path. */
+	relativeTo(other) {
+		if (other._pathClass !== this._pathClass) throw new KaosValueError(`${this._path} is not within ${other.toString()}`);
+		const pathMod = getPathMod(this._pathClass);
+		const target = splitPathLexically(pathMod, this._path);
+		const base = splitPathLexically(pathMod, other.toString());
+		if (!(this._pathClass === "win32" ? target.root.toLowerCase() === base.root.toLowerCase() : target.root === base.root)) throw new KaosValueError(`${this._path} is not within ${other.toString()}`);
+		if (base.parts.length > target.parts.length) throw new KaosValueError(`${this._path} is not within ${other.toString()}`);
+		for (let i = 0; i < base.parts.length; i++) {
+			const targetPart = target.parts[i];
+			const basePart = base.parts[i];
+			if (!(this._pathClass === "win32" ? targetPart?.toLowerCase() === basePart?.toLowerCase() : targetPart === basePart)) throw new KaosValueError(`${this._path} is not within ${other.toString()}`);
+		}
+		const relParts = target.parts.slice(base.parts.length);
+		return KaosPath._from(relParts.length === 0 ? "." : relParts.join(pathMod.sep), this._pathClass);
+	}
+	/** Expand leading ~ to the home directory. */
+	expanduser() {
+		if (this._path === "~" || this._path.startsWith("~/") || this._path.startsWith("~\\")) {
+			const home = this._currentKaos("expand").gethome();
+			if (this._path === "~") return KaosPath._from(home, this._pathClass);
+			const rest = this._path.slice(2);
+			return KaosPath._from(joinPure(this._pathClass, [home, rest]), this._pathClass);
+		}
+		return KaosPath._from(this._path, this._pathClass);
+	}
+	static home() {
+		return new KaosPath(getCurrentKaos().gethome());
+	}
+	static cwd() {
+		return new KaosPath(getCurrentKaos().getcwd());
+	}
+	/** Create a KaosPath from a local filesystem path string. */
+	static fromLocalPath(localPath) {
+		return new KaosPath(localPath);
+	}
+	/** Return the underlying path string for local filesystem use. */
+	toLocalPath() {
+		return this._path;
+	}
+	toString() {
+		return this._path;
+	}
+	equals(other) {
+		return this._pathClass === other._pathClass && this._path === other.toString();
+	}
+	/** Get stat information for this path. */
+	async stat(options) {
+		return this._currentKaos("stat").stat(this._path, options);
+	}
+	/** Check if this path exists on the filesystem. */
+	async exists(options) {
+		const kaos = this._currentKaos("check");
+		try {
+			await kaos.stat(this._path, options);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/** Check if this path points to a regular file. */
+	async isFile(options) {
+		const kaos = this._currentKaos("check");
+		try {
+			return ((await kaos.stat(this._path, options)).stMode & S_IFMT) === S_IFREG;
+		} catch {
+			return false;
+		}
+	}
+	/** Check if this path points to a directory. */
+	async isDir(options) {
+		const kaos = this._currentKaos("check");
+		try {
+			return ((await kaos.stat(this._path, options)).stMode & S_IFMT) === S_IFDIR;
+		} catch {
+			return false;
+		}
+	}
+	/** Iterate over entries in this directory. */
+	async *iterdir() {
+		const kaos = this._currentKaos("iterate");
+		for await (const entry of kaos.iterdir(this._path)) yield KaosPath._from(entry, this._pathClass);
+	}
+	/** Glob for entries matching a pattern under this path. */
+	async *glob(pattern, options) {
+		const kaos = this._currentKaos("glob");
+		for await (const match of kaos.glob(this._path, pattern, options)) yield KaosPath._from(match, this._pathClass);
+	}
+	/** Read the file content as a Buffer. */
+	async readBytes(n) {
+		return this._currentKaos("read").readBytes(this._path, n);
+	}
+	/** Read the file content as a string. */
+	async readText(options) {
+		return this._currentKaos("read").readText(this._path, options);
+	}
+	/** Yield lines from the file one by one. */
+	async *readLines(options) {
+		const kaos = this._currentKaos("read");
+		for await (const line of kaos.readLines(this._path, options)) yield line;
+	}
+	/** Write binary data to this path, return the number of bytes written. */
+	async writeBytes(data) {
+		return this._currentKaos("write").writeBytes(this._path, data);
+	}
+	/** Write text to this path, return the number of characters written. */
+	async writeText(data, options) {
+		return this._currentKaos("write").writeText(this._path, data, options);
+	}
+	/** Append text to this path, return the number of characters written. */
+	async appendText(data, options) {
+		const kaos = this._currentKaos("append");
+		const writeOpts = { mode: "a" };
+		if (options?.encoding !== void 0) writeOpts.encoding = options.encoding;
+		return kaos.writeText(this._path, data, writeOpts);
+	}
+	/** Create this path as a directory. */
+	async mkdir(options) {
+		await this._currentKaos("mkdir").mkdir(this._path, options);
+	}
+};
+//#endregion
+//#region src/index.ts
+function readText(path, options) {
+	return getCurrentKaos().readText(path, options);
+}
+function writeText(path, data, options) {
+	return getCurrentKaos().writeText(path, data, options);
+}
+function readLines(path, options) {
+	return getCurrentKaos().readLines(path, options);
+}
+function exec(...args) {
+	return getCurrentKaos().exec(...args);
+}
+function readBytes(path, n) {
+	return getCurrentKaos().readBytes(path, n);
+}
+function writeBytes(path, data) {
+	return getCurrentKaos().writeBytes(path, data);
+}
+function stat(path, options) {
+	return getCurrentKaos().stat(path, options);
+}
+function mkdir(path, options) {
+	return getCurrentKaos().mkdir(path, options);
+}
+function iterdir(path) {
+	return getCurrentKaos().iterdir(path);
+}
+function glob(path, pattern, options) {
+	return getCurrentKaos().glob(path, pattern, options);
+}
+function chdir(path) {
+	return getCurrentKaos().chdir(path);
+}
+function getcwd() {
+	return getCurrentKaos().getcwd();
+}
+function gethome() {
+	return getCurrentKaos().gethome();
+}
+function normpath(path) {
+	return getCurrentKaos().normpath(path);
+}
+function pathClass() {
+	return getCurrentKaos().pathClass();
+}
+function execWithEnv(args, env) {
+	return getCurrentKaos().execWithEnv(args, env);
+}
+//#endregion
+export { KaosError, KaosFileExistsError, KaosPath, KaosValueError, LocalKaos, chdir, exec, execWithEnv, getCurrentKaos, getcwd, gethome, glob, iterdir, localKaos, mkdir, normpath, pathClass, readBytes, readLines, readText, resetCurrentKaos, runWithKaos, setCurrentKaos, stat, writeBytes, writeText };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@byfriends/kaos",
+  "version": "0.0.1",
+  "description": "Execution environment and filesystem/process abstractions for BYF",
+  "license": "Proprietary",
+  "author": "ByronFinn",
+  "homepage": "https://github.com/ByronFinn/byf",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ByronFinn/byf.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ByronFinn/byf/issues"
+  },
+  "keywords": [
+    "byf",
+    "agent",
+    "execution",
+    "sandbox",
+    "process",
+    "filesystem"
+  ],
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "imports": {
+    "#/*": [
+      "./src/*.ts",
+      "./src/*/index.ts"
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ssh2": "^1.17.0"
+  },
+  "devDependencies": {
+    "@types/ssh2": "^1.15.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "clean": "rm -rf dist"
+  }
+}