@versori/run 0.0.1-alpha.0 → 0.0.1-alpha.2

package/script/deps/jsr.io/@std/log/0.224.14/debug.d.ts

@@ -0,0 +1,105 @@
+import type { GenericFunction } from "./logger.js";
+import "./setup.js";
+/**
+ * Log at the debug level.
+ *
+ * This function is a pass-through to the default logger's `debug` method. By
+ * default, this function is a no-op. To enable debug logging, set call
+ * {@linkcode https://jsr.io/@std/log/doc/setup/~/setup | setup} and set the
+ * default level to `DEBUG`.
+ *
+ * @template T The type of the message to log.
+ * @param msg The message to log.
+ * @param args Arguments to be formatted into the message.
+ * @returns The message that was logged.
+ *
+ * @example Usage without setup
+ * ```ts
+ * import { debug } from "@std/log/debug";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(debug("This is a debug message."), "This is a debug message.");
+ * // Prints: ""
+ *
+ * assertEquals(debug(() => "This is a debug message."), undefined);
+ * // Prints: ""
+ * ```
+ *
+ * @example Usage with setup
+ * ```ts
+ * import { ConsoleHandler, debug, setup } from "@std/log";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * setup({
+ *   handlers: {
+ *     default: new ConsoleHandler("DEBUG"),
+ *   },
+ *   loggers: {
+ *     default: {
+ *       level: "DEBUG",
+ *       handlers: ["default"],
+ *     },
+ *   },
+ * });
+ *
+ * assertEquals(debug("This is a debug message."), "This is a debug message.");
+ *
+ * assertEquals(
+ *   debug(() => "This is a debug message."),
+ *   "This is a debug message.",
+ * );
+ * ```
+ */
+export declare function debug<T>(msg: () => T, ...args: unknown[]): T | undefined;
+/**
+ * Log at the debug level.
+ *
+ * This function is a pass-through to the default logger's `debug` method. By
+ * default, this function is a no-op. To enable debug logging, set call
+ * {@linkcode https://jsr.io/@std/log/doc/setup/~/setup | setup} and set the
+ * default level to `DEBUG`.
+ *
+ * @template T The type of the message to log.
+ * @param msg The message to log.
+ * @param args Arguments to be formatted into the message.
+ * @returns The message that was logged.
+ *
+ * @example Usage without setup
+ * ```ts
+ * import { debug } from "@std/log/debug";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(debug("This is a debug message."), "This is a debug message.");
+ * // Prints: ""
+ *
+ * assertEquals(debug(() => "This is a debug message."), undefined);
+ * // Prints: ""
+ * ```
+ *
+ * @example Usage with setup
+ * ```ts
+ * import { ConsoleHandler, debug, setup } from "@std/log";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * setup({
+ *   handlers: {
+ *     default: new ConsoleHandler("DEBUG"),
+ *   },
+ *   loggers: {
+ *     default: {
+ *       level: "DEBUG",
+ *       handlers: ["default"],
+ *     },
+ *   },
+ * });
+ *
+ * assertEquals(debug("This is a debug message."), "This is a debug message.");
+ *
+ * assertEquals(
+ *   debug(() => "This is a debug message."),
+ *   "This is a debug message.",
+ * );
+ * ```
+ */
+export declare function debug<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+//# sourceMappingURL=debug.d.ts.map

package/script/deps/jsr.io/@std/log/0.224.14/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/debug.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AAC1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}

package/script/deps/jsr.io/@std/log/0.224.14/debug.js

@@ -0,0 +1,14 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = debug;
+const get_logger_js_1 = require("./get_logger.js");
+require("./setup.js");
+function debug(msg, ...args) {
+    // Assist TS compiler with pass-through generic type
+    if (msg instanceof Function) {
+        return (0, get_logger_js_1.getLogger)("default").debug(msg, ...args);
+    }
+    return (0, get_logger_js_1.getLogger)("default").debug(msg, ...args);
+}

package/script/deps/jsr.io/@std/log/0.224.14/error.d.ts

@@ -0,0 +1,53 @@
+import type { GenericFunction } from "./logger.js";
+import "./setup.js";
+/**
+ * Log at the error level.
+ *
+ * This function is a pass-through to the default logger's `error` method. By
+ * default, the default logger is configured to use {@linkcode console.log} and
+ * print in red text.
+ *
+ * @template T The type of the message to log.
+ * @param msg The message to log.
+ * @param args Arguments to be formatted into the message.
+ * @returns The message that was logged.
+ *
+ * @example Usage
+ * ```ts
+ * import { error } from "@std/log/error";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(error("This is an error message."), "This is an error message.");
+ * // Prints: "ERROR This is an error message."
+ *
+ * assertEquals(error(() => "This is an error message."), "This is an error message.");
+ * // Prints: "ERROR This is an error message."
+ * ```
+ */
+export declare function error<T>(msg: () => T, ...args: unknown[]): T | undefined;
+/**
+ * Log at the error level.
+ *
+ * This function is a pass-through to the default logger's `error` method. By
+ * default, the default logger is configured to use {@linkcode console.log} and
+ * print in red text.
+ *
+ * @template T The type of the message to log.
+ * @param msg The message to log.
+ * @param args Arguments to be formatted into the message.
+ * @returns The message that was logged.
+ *
+ * @example Usage
+ * ```ts
+ * import { error } from "@std/log/error";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * assertEquals(error("This is an error message."), "This is an error message.");
+ * // Prints: "ERROR This is an error message."
+ *
+ * assertEquals(error(() => "This is an error message."), "This is an error message.");
+ * // Prints: "ERROR This is an error message."
+ * ```
+ */
+export declare function error<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+//# sourceMappingURL=error.d.ts.map

package/script/deps/jsr.io/@std/log/0.224.14/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/error.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AAC1E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}

package/script/deps/jsr.io/@std/log/0.224.14/error.js

@@ -0,0 +1,14 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = error;
+const get_logger_js_1 = require("./get_logger.js");
+require("./setup.js");
+function error(msg, ...args) {
+    // Assist TS compiler with pass-through generic type
+    if (msg instanceof Function) {
+        return (0, get_logger_js_1.getLogger)("default").error(msg, ...args);
+    }
+    return (0, get_logger_js_1.getLogger)("default").error(msg, ...args);
+}

package/script/deps/jsr.io/@std/log/0.224.14/file_handler.d.ts

@@ -0,0 +1,200 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { type LevelName } from "./levels.js";
+import type { LogRecord } from "./logger.js";
+import { BaseHandler, type BaseHandlerOptions } from "./base_handler.js";
+import { bufSymbol, encoderSymbol, filenameSymbol, fileSymbol, modeSymbol, openOptionsSymbol, pointerSymbol } from "./_file_handler_symbols.js";
+/** Supported log modes for FileHandlerOptions {@linkcode FileHandlerOptions.mode}. */
+export type LogMode = "a" | "w" | "x";
+/** Options for {@linkcode FileHandler}. */
+export interface FileHandlerOptions extends BaseHandlerOptions {
+    /**
+     * The filename to output to.
+     */
+    filename: string;
+    /**
+     * Log mode for the handler. Behavior of the log modes is as follows:
+     *
+     * - `'a'` - Default mode. Appends new log messages to the end of an existing log
+     *   file, or create a new log file if none exists.
+     * - `'w'` - Upon creation of the handler, any existing log file will be removed
+     *   and a new one created.
+     * - `'x'` - This will create a new log file and throw an error if one already
+     *   exists.
+     *
+     * @default {"a"}
+     */
+    mode?: LogMode;
+    /**
+     * Buffer size for writing log messages to file, in bytes.
+     *
+     * @default {4096}
+     */
+    bufferSize?: number;
+}
+/**
+ * A file-based log handler that writes log messages to a specified file with buffering and optional modes.
+ * The logs are buffered for optimized performance, writing to the file only
+ * when the buffer is full, on manual .flush() call, during logging of a critical message or when process ends.
+ * It is important to note that the file can grow indefinitely.
+ *
+ * This handler requires `--allow-write` permission on the log file.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { FileHandler } from "@std/log/file-handler";
+ *
+ * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+ * handler.setup();
+ * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+ * handler.flush(); // Manually flushes the buffer
+ * handler.destroy(); // Closes the file and removes listeners
+ * ```
+ */
+export declare class FileHandler extends BaseHandler {
+    #private;
+    /** Opened file to append logs to.
+     *
+     * @private
+     */
+    [fileSymbol]: dntShim.Deno.FsFile | undefined;
+    /** Buffer used to write to file.
+     *
+     * @private
+     */
+    [bufSymbol]: Uint8Array;
+    /**
+     * Current position for pointer.
+     *
+     * @private
+     */
+    [pointerSymbol]: number;
+    /**
+     * Filename associated with the file being logged.
+     *
+     * @private
+     */
+    [filenameSymbol]: string;
+    /**
+     * Current log mode.
+     *
+     * @private
+     */
+    [modeSymbol]: LogMode;
+    /**
+     * File open options.
+     *
+     * @private
+     */
+    [openOptionsSymbol]: dntShim.Deno.OpenOptions;
+    /**
+     * Text encoder.
+     *
+     * @private
+     */
+    [encoderSymbol]: TextEncoder;
+    /**
+     * Constructs a new FileHandler instance.
+     *
+     * @param levelName The level name to log messages at.
+     * @param options Options for the handler.
+     */
+    constructor(levelName: LevelName, options: FileHandlerOptions);
+    /**
+     * Sets up the file handler by opening the specified file and initializing resources.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup(); // Opens the file and prepares the handler for logging.
+     * handler.destroy();
+     * ```
+     */
+    setup(): void;
+    /**
+     * Handles a log record and flushes the buffer if the log level is higher than error.
+     *
+     * @param logRecord Log record to handle.
+     *
+     * @example Usage
+     * ```ts
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     * import { LogLevels } from "./levels.ts";
+     * import { LogRecord } from "./logger.ts";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup();
+     *
+     * // Flushes the buffer immediately and logs "CRITICAL This log is very critical indeed." into the file.
+     * handler.handle(
+     *   new LogRecord({
+     *     msg: "This log is very critical indeed.",
+     *     args: [],
+     *     level: LogLevels.CRITICAL,
+     *     loggerName: "INFO",
+     *   }),
+     * );
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    handle(logRecord: LogRecord): void;
+    /**
+     * Logs a message by adding it to the buffer, with flushing as needed.
+     *
+     * @param msg The message to log.
+     *
+     * @example Usage
+     * ```ts
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!');
+     * handler.flush();
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    log(msg: string): void;
+    /**
+     * Immediately writes the contents of the buffer to the previously opened file.
+     *
+     * @example Usage
+     * ```ts
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!');
+     * handler.flush(); // Writes buffered log messages to the file immediately.
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    flush(): void;
+    /**
+     * Destroys the handler, performing any cleanup that is required and closes the file handler.
+     *
+     * @example Usage
+     * ```ts
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./_tmp/logs.txt" });
+     * handler.setup();
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=file_handler.d.ts.map

package/script/deps/jsr.io/@std/log/0.224.14/file_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/file_handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAExD,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EACL,SAAS,EACT,aAAa,EACb,cAAc,EACd,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,sFAAsF;AACtF,MAAM,MAAM,OAAO,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAEtC,2CAA2C;AAC3C,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC5D;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,WAAY,SAAQ,WAAW;;IAC1C;;;OAGG;IACH,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;IAC9C;;;OAGG;IACH,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC;IACxB;;;;OAIG;IACH,CAAC,aAAa,CAAC,SAAK;IACpB;;;;OAIG;IACH,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;IAC9C;;;;OAIG;IACH,CAAC,aAAa,CAAC,EAAE,WAAW,CAAqB;IAKjD;;;;;OAKG;gBACS,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,kBAAkB;IAe7D;;;;;;;;;;;OAWG;IACM,KAAK;IAUd;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACM,MAAM,CAAC,SAAS,EAAE,SAAS;IASpC;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM;IAaf;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK;IAgBL;;;;;;;;;;;;;;OAcG;IACM,OAAO;CAMjB"}