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

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

@@ -0,0 +1,410 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Logging library with support for terminal and file outputs. Also provides
+ * interfaces for building custom loggers.
+ *
+ * > [!IMPORTANT]
+ * > @std/log is [likely to be removed in the future](https://github.com/denoland/std/issues/6124).
+ * > Consider using [Open Telemetry](https://docs.deno.com/runtime/fundamentals/open_telemetry/).
+ *
+ * ## Loggers
+ *
+ * Loggers are objects that you interact with. When you use a logger method it
+ * constructs a `LogRecord` and passes it down to its handlers for output. To
+ * create custom loggers, specify them in `loggers` when calling `log.setup`.
+ *
+ * ## Custom message format
+ *
+ * If you want to override default format of message you can define `formatter`
+ * option for handler. It can a function that takes `LogRecord`
+ * as argument and outputs string.
+ *
+ * The default log format is `{levelName} {msg}`.
+ *
+ * ### Logging Structured JSON Lines
+ *
+ * To output logs in a structured JSON format you can configure most handlers
+ * with a formatter that produces a JSON string. Either use the premade
+ * `log.formatters.jsonFormatter` or write your own function that takes a
+ * {@linkcode LogRecord} and returns a JSON.stringify'd object.
+ * If you want the log to go to stdout then use {@linkcode ConsoleHandler} with
+ * the configuration `useColors: false` to turn off the ANSI terminal colors.
+ *
+ * ```ts
+ * import * as log from "@std/log";
+ *
+ * log.setup({
+ *   handlers: {
+ *     default: new log.ConsoleHandler("DEBUG", {
+ *       formatter: log.formatters.jsonFormatter,
+ *       useColors: false,
+ *     }),
+ *   },
+ * });
+ * ```
+ *
+ * The first argument passed to a log function is always treated as the
+ * message and will be stringified differently. To have arguments JSON.stringify'd
+ * you must pass them after the first.
+ *
+ * ```ts
+ * import * as log from "@std/log";
+ *
+ * log.info("This is the message", { thisWillBe: "JSON.stringify'd"});
+ * // {"level":"INFO","datetime":1702501580505,"message":"This is the message","args":{"thisWillBe":"JSON.stringify'd"}}
+ *
+ * log.info({ thisWontBe: "JSON.stringify'd"}, "This is an argument");
+ * // {"level":"INFO","datetime":1702501580505,"message":"{\"thisWontBe\":\"JSON.stringify'd\"}","args":"This is an argument"}
+ * ```
+ *
+ * ## Inline Logging
+ *
+ * Log functions return the data passed in the `msg` parameter. Data is returned
+ * regardless if the logger actually logs it.
+ *
+ * ## Lazy Log Evaluation
+ *
+ * Some log statements are expensive to compute. In these cases, you can use
+ * lazy log evaluation to prevent the computation taking place if the logger
+ * won't log the message.
+ *
+ * > NOTE: When using lazy log evaluation, `undefined` will be returned if the
+ * > resolver function is not called because the logger won't log it. It is an
+ * > antipattern use lazy evaluation with inline logging because the return value
+ * > depends on the current log level.
+ *
+ * ## For module authors
+ *
+ * The authors of public modules can let the users display the internal logs of the
+ * module by using a custom logger:
+ *
+ * ```ts
+ * import { getLogger } from "@std/log";
+ *
+ * function logger() {
+ *   return getLogger("my-awesome-module");
+ * }
+ *
+ * function sum(a: number, b: number) {
+ *   logger().debug(`running ${a} + ${b}`);
+ *   return a + b;
+ * }
+ *
+ * function mult(a: number, b: number) {
+ *   logger().debug(`running ${a} * ${b}`);
+ *   return a * b;
+ * }
+ * ```
+ *
+ * The user of the module can then display the internal logs with:
+ *
+ * ```ts, ignore
+ * import * as log from "@std/log";
+ * import { sum } from "<the-awesome-module>/mod.ts";
+ *
+ * log.setup({
+ *   handlers: {
+ *     console: new log.ConsoleHandler("DEBUG"),
+ *   },
+ *
+ *   loggers: {
+ *     "my-awesome-module": {
+ *       level: "DEBUG",
+ *       handlers: ["console"],
+ *     },
+ *   },
+ * });
+ *
+ * sum(1, 2); // prints "running 1 + 2" to the console
+ * ```
+ *
+ * Please note that, due to the order of initialization of the loggers, the
+ * following won't work:
+ *
+ * ```ts
+ * import { getLogger } from "@std/log";
+ *
+ * const logger = getLogger("my-awesome-module");
+ *
+ * function sum(a: number, b: number) {
+ *   logger.debug(`running ${a} + ${b}`); // no message will be logged, because getLogger() was called before log.setup()
+ *   return a + b;
+ * }
+ * ```
+ *
+ * @example
+ * ```ts ignore
+ * import * as log from "@std/log";
+ *
+ * // Simple default logger out of the box. You can customize it
+ * // by overriding logger and handler named "default", or providing
+ * // additional logger configurations. You can log any data type.
+ * log.debug("Hello world");
+ * log.info(123456);
+ * log.warn(true);
+ * log.error({ foo: "bar", fizz: "bazz" });
+ * log.critical("500 Internal server error");
+ *
+ * // custom configuration with 2 loggers (the default and `tasks` loggers).
+ * log.setup({
+ *   handlers: {
+ *     console: new log.ConsoleHandler("DEBUG"),
+ *
+ *     file: new log.FileHandler("WARN", {
+ *       filename: "./log.txt",
+ *       // you can change format of output message using any keys in `LogRecord`.
+ *       formatter: (record) => `${record.levelName} ${record.msg}`,
+ *     }),
+ *   },
+ *
+ *   loggers: {
+ *     // configure default logger available via short-hand methods above.
+ *     default: {
+ *       level: "DEBUG",
+ *       handlers: ["console", "file"],
+ *     },
+ *
+ *     tasks: {
+ *       level: "ERROR",
+ *       handlers: ["console"],
+ *     },
+ *   },
+ * });
+ *
+ * let logger;
+ *
+ * // get default logger.
+ * logger = log.getLogger();
+ * logger.debug("fizz"); // logs to `console`, because `file` handler requires "WARN" level.
+ * logger.warn(41256); // logs to both `console` and `file` handlers.
+ *
+ * // get custom logger
+ * logger = log.getLogger("tasks");
+ * logger.debug("fizz"); // won't get output because this logger has "ERROR" level.
+ * logger.error({ productType: "book", value: "126.11" }); // log to `console`.
+ *
+ * // if you try to use a logger that hasn't been configured
+ * // you're good to go, it gets created automatically with level set to 0
+ * // so no message is logged.
+ * const unknownLogger = log.getLogger("mystery");
+ * unknownLogger.info("foobar"); // no-op
+ * ```
+ *
+ * @example
+ * Custom message format example
+ * ```ts
+ * import * as log from "@std/log";
+ *
+ * log.setup({
+ *   handlers: {
+ *     stringFmt: new log.ConsoleHandler("DEBUG", {
+ *       formatter: (record) => `[${record.levelName}] ${record.msg}`,
+ *     }),
+ *
+ *     functionFmt: new log.ConsoleHandler("DEBUG", {
+ *       formatter: (logRecord) => {
+ *         let msg = `${logRecord.level} ${logRecord.msg}`;
+ *
+ *         logRecord.args.forEach((arg, index) => {
+ *           msg += `, arg${index}: ${arg}`;
+ *         });
+ *
+ *         return msg;
+ *       },
+ *     }),
+ *
+ *     anotherFmt: new log.ConsoleHandler("DEBUG", {
+ *       formatter: (record) => `[${record.loggerName}] - ${record.levelName} ${record.msg}`,
+ *     }),
+ *   },
+ *
+ *   loggers: {
+ *     default: {
+ *       level: "DEBUG",
+ *       handlers: ["stringFmt", "functionFmt"],
+ *     },
+ *     dataLogger: {
+ *       level: "INFO",
+ *       handlers: ["anotherFmt"],
+ *     },
+ *   },
+ * });
+ *
+ * // calling:
+ * log.debug("Hello, world!", 1, "two", [3, 4, 5]);
+ * // results in: [DEBUG] Hello, world!
+ * // output from "stringFmt" handler.
+ * // 10 Hello, world!, arg0: 1, arg1: two, arg3: [3, 4, 5] // output from "functionFmt" formatter.
+ *
+ * // calling:
+ * log.getLogger("dataLogger").error("oh no!");
+ * // results in:
+ * // [dataLogger] - ERROR oh no! // output from anotherFmt handler.
+ * ```
+
+ *
+ * @example
+ * JSON to stdout with no color example
+ * ```ts
+ * import * as log from "@std/log";
+ *
+ * log.setup({
+ *   handlers: {
+ *     jsonStdout: new log.ConsoleHandler("DEBUG", {
+ *       formatter: log.formatters.jsonFormatter,
+ *       useColors: false,
+ *     }),
+ *   },
+ *
+ *   loggers: {
+ *     default: {
+ *       level: "DEBUG",
+ *       handlers: ["jsonStdout"],
+ *     },
+ *   },
+ * });
+ *
+ * // calling:
+ * log.info("Hey");
+ * // results in:
+ * // {"level":"INFO","datetime":1702481922294,"message":"Hey"}
+ *
+ * // calling:
+ * log.info("Hey", { product: "nail" });
+ * // results in:
+ * // {"level":"INFO","datetime":1702484111115,"message":"Hey","args":{"product":"nail"}}
+ *
+ * // calling:
+ * log.info("Hey", 1, "two", [3, 4, 5]);
+ * // results in:
+ * // {"level":"INFO","datetime":1702481922294,"message":"Hey","args":[1,"two",[3,4,5]]}
+ * ```
+ *
+ * @example
+ * Custom JSON example
+ * ```ts
+ * import * as log from "@std/log";
+ *
+ * log.setup({
+ *   handlers: {
+ *     customJsonFmt: new log.ConsoleHandler("DEBUG", {
+ *       formatter: (record) => JSON.stringify({
+ *         lvl: record.level,
+ *         msg: record.msg,
+ *         time: record.datetime.toISOString(),
+ *         name: record.loggerName,
+ *       }),
+ *       useColors: false,
+ *     }),
+ *   },
+ *
+ *   loggers: {
+ *     default: {
+ *       level: "DEBUG",
+ *       handlers: ["customJsonFmt"],
+ *     },
+ *   },
+ * });
+ *
+ * // calling:
+ * log.info("complete");
+ * // results in:
+ * // {"lvl":20,"msg":"complete","time":"2023-12-13T16:38:27.328Z","name":"default"}
+ * ```
+ *
+ * @example
+ * Inline Logging
+ * ```ts
+ * import * as logger from "@std/log";
+ *
+ * const stringData: string = logger.debug("hello world");
+ * const booleanData: boolean = logger.debug(true, 1, "abc");
+ * const fn = (): number => {
+ *   return 123;
+ * };
+ * const resolvedFunctionData: number = logger.debug(fn());
+ * console.log(stringData); // 'hello world'
+ * console.log(booleanData); // true
+ * console.log(resolvedFunctionData); // 123
+ * ```
+ *
+ * @example
+ * Lazy Log Evaluation
+ * ```ts
+ * import * as log from "@std/log";
+ *
+ * log.setup({
+ *   handlers: {
+ *     console: new log.ConsoleHandler("DEBUG"),
+ *   },
+ *
+ *   loggers: {
+ *     tasks: {
+ *       level: "ERROR",
+ *       handlers: ["console"],
+ *     },
+ *   },
+ * });
+ *
+ * function someExpensiveFn(num: number, bool: boolean) {
+ *   // do some expensive computation
+ * }
+ *
+ * // not logged, as debug < error.
+ * const data = log.debug(() => someExpensiveFn(5, true));
+ * console.log(data); // undefined
+ * ```
+ *
+ * Handlers are responsible for actual output of log messages. When a handler is
+ * called by a logger, it firstly checks that {@linkcode LogRecord}'s level is
+ * not lower than level of the handler. If level check passes, handlers formats
+ * log record into string and outputs it to target.
+ *
+ * ## Custom handlers
+ *
+ * Custom handlers can be implemented by subclassing {@linkcode BaseHandler} or
+ * {@linkcode WriterHandler}.
+ *
+ * {@linkcode BaseHandler} is bare-bones handler that has no output logic at all,
+ *
+ * {@linkcode WriterHandler} is an abstract class that supports any target with
+ * `Writer` interface.
+ *
+ * During setup async hooks `setup` and `destroy` are called, you can use them
+ * to open and close file/HTTP connection or any other action you might need.
+ *
+ * For examples check source code of {@linkcode FileHandler}`
+ * and {@linkcode TestHandler}.
+ *
+ * @module
+ */
+__exportStar(require("./base_handler.js"), exports);
+__exportStar(require("./console_handler.js"), exports);
+__exportStar(require("./file_handler.js"), exports);
+__exportStar(require("./rotating_file_handler.js"), exports);
+__exportStar(require("./levels.js"), exports);
+__exportStar(require("./logger.js"), exports);
+__exportStar(require("./formatters.js"), exports);
+__exportStar(require("./critical.js"), exports);
+__exportStar(require("./debug.js"), exports);
+__exportStar(require("./error.js"), exports);
+__exportStar(require("./get_logger.js"), exports);
+__exportStar(require("./info.js"), exports);
+__exportStar(require("./setup.js"), exports);
+__exportStar(require("./warn.js"), exports);

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

@@ -0,0 +1,53 @@
+import type { LevelName } from "./levels.js";
+import { FileHandler, type FileHandlerOptions } from "./file_handler.js";
+interface RotatingFileHandlerOptions extends FileHandlerOptions {
+    maxBytes: number;
+    maxBackupCount: number;
+}
+/**
+ * This handler extends the functionality of the {@linkcode FileHandler} by
+ * "rotating" the log file when it reaches a certain size. `maxBytes` specifies
+ * the maximum size in bytes that the log file can grow to before rolling over
+ * to a new one. If the size of the new log message plus the current log file
+ * size exceeds `maxBytes` then a roll-over is triggered. When a roll-over
+ * occurs, before the log message is written, the log file is renamed and
+ * appended with `.1`. If a `.1` version already existed, it would have been
+ * renamed `.2` first and so on. The maximum number of log files to keep is
+ * specified by `maxBackupCount`. After the renames are complete the log message
+ * is written to the original, now blank, file.
+ *
+ * Example: Given `log.txt`, `log.txt.1`, `log.txt.2` and `log.txt.3`, a
+ * `maxBackupCount` of 3 and a new log message which would cause `log.txt` to
+ * exceed `maxBytes`, then `log.txt.2` would be renamed to `log.txt.3` (thereby
+ * discarding the original contents of `log.txt.3` since 3 is the maximum number
+ * of backups to keep), `log.txt.1` would be renamed to `log.txt.2`, `log.txt`
+ * would be renamed to `log.txt.1` and finally `log.txt` would be created from
+ * scratch where the new log message would be written.
+ *
+ * This handler uses a buffer for writing log messages to file. Logs can be
+ * manually flushed with `fileHandler.flush()`. Log messages with a log level
+ * greater than ERROR are immediately flushed. Logs are also flushed on process
+ * completion.
+ *
+ * Additional notes on `mode` as described above:
+ *
+ * - `'a'` Default mode. As above, this will pick up where the logs left off in
+ *   rotation, or create a new log file if it doesn't exist.
+ * - `'w'` in addition to starting with a clean `filename`, this mode will also
+ *   cause any existing backups (up to `maxBackupCount`) to be deleted on setup
+ *   giving a fully clean slate.
+ * - `'x'` requires that neither `filename`, nor any backups (up to
+ *   `maxBackupCount`), exist before setup.
+ *
+ * This handler requires both `--allow-read` and `--allow-write` permissions on
+ * the log files.
+ */
+export declare class RotatingFileHandler extends FileHandler {
+    #private;
+    constructor(levelName: LevelName, options: RotatingFileHandlerOptions);
+    setup(): void;
+    log(msg: string): void;
+    rotateLogFiles(): void;
+}
+export {};
+//# sourceMappingURL=rotating_file_handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rotating_file_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/rotating_file_handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AASzE,UAAU,0BAA2B,SAAQ,kBAAkB;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;;gBAKtC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B;IAM5D,KAAK;IAyCL,GAAG,CAAC,GAAG,EAAE,MAAM;IAaxB,cAAc;CAkBf"}

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

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RotatingFileHandler_maxBytes, _RotatingFileHandler_maxBackupCount, _RotatingFileHandler_currentFileSize;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotatingFileHandler = void 0;
+// Copyright 2018-2025 the Deno authors. MIT license.
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+const exists_js_1 = require("../../fs/1.0.13/exists.js");
+const file_handler_js_1 = require("./file_handler.js");
+const _file_handler_symbols_js_1 = require("./_file_handler_symbols.js");
+/**
+ * This handler extends the functionality of the {@linkcode FileHandler} by
+ * "rotating" the log file when it reaches a certain size. `maxBytes` specifies
+ * the maximum size in bytes that the log file can grow to before rolling over
+ * to a new one. If the size of the new log message plus the current log file
+ * size exceeds `maxBytes` then a roll-over is triggered. When a roll-over
+ * occurs, before the log message is written, the log file is renamed and
+ * appended with `.1`. If a `.1` version already existed, it would have been
+ * renamed `.2` first and so on. The maximum number of log files to keep is
+ * specified by `maxBackupCount`. After the renames are complete the log message
+ * is written to the original, now blank, file.
+ *
+ * Example: Given `log.txt`, `log.txt.1`, `log.txt.2` and `log.txt.3`, a
+ * `maxBackupCount` of 3 and a new log message which would cause `log.txt` to
+ * exceed `maxBytes`, then `log.txt.2` would be renamed to `log.txt.3` (thereby
+ * discarding the original contents of `log.txt.3` since 3 is the maximum number
+ * of backups to keep), `log.txt.1` would be renamed to `log.txt.2`, `log.txt`
+ * would be renamed to `log.txt.1` and finally `log.txt` would be created from
+ * scratch where the new log message would be written.
+ *
+ * This handler uses a buffer for writing log messages to file. Logs can be
+ * manually flushed with `fileHandler.flush()`. Log messages with a log level
+ * greater than ERROR are immediately flushed. Logs are also flushed on process
+ * completion.
+ *
+ * Additional notes on `mode` as described above:
+ *
+ * - `'a'` Default mode. As above, this will pick up where the logs left off in
+ *   rotation, or create a new log file if it doesn't exist.
+ * - `'w'` in addition to starting with a clean `filename`, this mode will also
+ *   cause any existing backups (up to `maxBackupCount`) to be deleted on setup
+ *   giving a fully clean slate.
+ * - `'x'` requires that neither `filename`, nor any backups (up to
+ *   `maxBackupCount`), exist before setup.
+ *
+ * This handler requires both `--allow-read` and `--allow-write` permissions on
+ * the log files.
+ */
+class RotatingFileHandler extends file_handler_js_1.FileHandler {
+    constructor(levelName, options) {
+        super(levelName, options);
+        _RotatingFileHandler_maxBytes.set(this, void 0);
+        _RotatingFileHandler_maxBackupCount.set(this, void 0);
+        _RotatingFileHandler_currentFileSize.set(this, 0);
+        __classPrivateFieldSet(this, _RotatingFileHandler_maxBytes, options.maxBytes, "f");
+        __classPrivateFieldSet(this, _RotatingFileHandler_maxBackupCount, options.maxBackupCount, "f");
+    }
+    setup() {
+        if (__classPrivateFieldGet(this, _RotatingFileHandler_maxBytes, "f") < 1) {
+            this.destroy();
+            throw new Error(`"maxBytes" must be >= 1: received ${__classPrivateFieldGet(this, _RotatingFileHandler_maxBytes, "f")}`);
+        }
+        if (__classPrivateFieldGet(this, _RotatingFileHandler_maxBackupCount, "f") < 1) {
+            this.destroy();
+            throw new Error(`"maxBackupCount" must be >= 1: received ${__classPrivateFieldGet(this, _RotatingFileHandler_maxBackupCount, "f")}`);
+        }
+        super.setup();
+        if (this[_file_handler_symbols_js_1.modeSymbol] === "w") {
+            // Remove old backups too as it doesn't make sense to start with a clean
+            // log file, but old backups
+            for (let i = 1; i <= __classPrivateFieldGet(this, _RotatingFileHandler_maxBackupCount, "f"); i++) {
+                try {
+                    dntShim.Deno.removeSync(this[_file_handler_symbols_js_1.filenameSymbol] + "." + i);
+                }
+                catch (error) {
+                    if (!(error instanceof dntShim.Deno.errors.NotFound)) {
+                        throw error;
+                    }
+                }
+            }
+        }
+        else if (this[_file_handler_symbols_js_1.modeSymbol] === "x") {
+            // Throw if any backups also exist
+            for (let i = 1; i <= __classPrivateFieldGet(this, _RotatingFileHandler_maxBackupCount, "f"); i++) {
+                if ((0, exists_js_1.existsSync)(this[_file_handler_symbols_js_1.filenameSymbol] + "." + i)) {
+                    this.destroy();
+                    throw new dntShim.Deno.errors.AlreadyExists("Backup log file " + this[_file_handler_symbols_js_1.filenameSymbol] + "." + i +
+                        " already exists");
+                }
+            }
+        }
+        else {
+            __classPrivateFieldSet(this, _RotatingFileHandler_currentFileSize, (dntShim.Deno.statSync(this[_file_handler_symbols_js_1.filenameSymbol])).size, "f");
+        }
+    }
+    log(msg) {
+        const msgByteLength = this[_file_handler_symbols_js_1.encoderSymbol].encode(msg).byteLength + 1;
+        if (__classPrivateFieldGet(this, _RotatingFileHandler_currentFileSize, "f") + msgByteLength > __classPrivateFieldGet(this, _RotatingFileHandler_maxBytes, "f")) {
+            this.rotateLogFiles();
+            __classPrivateFieldSet(this, _RotatingFileHandler_currentFileSize, 0, "f");
+        }
+        super.log(msg);
+        __classPrivateFieldSet(this, _RotatingFileHandler_currentFileSize, __classPrivateFieldGet(this, _RotatingFileHandler_currentFileSize, "f") + msgByteLength, "f");
+    }
+    rotateLogFiles() {
+        this.flush();
+        this[_file_handler_symbols_js_1.fileSymbol].close();
+        for (let i = __classPrivateFieldGet(this, _RotatingFileHandler_maxBackupCount, "f") - 1; i >= 0; i--) {
+            const source = this[_file_handler_symbols_js_1.filenameSymbol] + (i === 0 ? "" : "." + i);
+            const dest = this[_file_handler_symbols_js_1.filenameSymbol] + "." + (i + 1);
+            if ((0, exists_js_1.existsSync)(source)) {
+                dntShim.Deno.renameSync(source, dest);
+            }
+        }
+        this[_file_handler_symbols_js_1.fileSymbol] = dntShim.Deno.openSync(this[_file_handler_symbols_js_1.filenameSymbol], this[_file_handler_symbols_js_1.openOptionsSymbol]);
+    }
+}
+exports.RotatingFileHandler = RotatingFileHandler;
+_RotatingFileHandler_maxBytes = new WeakMap(), _RotatingFileHandler_maxBackupCount = new WeakMap(), _RotatingFileHandler_currentFileSize = new WeakMap();

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

@@ -0,0 +1,4 @@
+import { type LogConfig } from "./logger.js";
+/** Setup logger config. */
+export declare function setup(config: LogConfig): void;
+//# sourceMappingURL=setup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/setup.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,aAAa,CAAC;AAGrD,2BAA2B;AAC3B,wBAAgB,KAAK,CAAC,MAAM,EAAE,SAAS,QAwCtC"}

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

@@ -0,0 +1,44 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = setup;
+const _config_js_1 = require("./_config.js");
+const logger_js_1 = require("./logger.js");
+const _state_js_1 = require("./_state.js");
+/** Setup logger config. */
+function setup(config) {
+    _state_js_1.state.config = {
+        handlers: { ..._config_js_1.DEFAULT_CONFIG.handlers, ...config.handlers },
+        loggers: { ..._config_js_1.DEFAULT_CONFIG.loggers, ...config.loggers },
+    };
+    // tear down existing handlers
+    _state_js_1.state.handlers.forEach((handler) => {
+        handler.destroy();
+    });
+    _state_js_1.state.handlers.clear();
+    // setup handlers
+    const handlers = _state_js_1.state.config.handlers ?? {};
+    for (const [handlerName, handler] of Object.entries(handlers)) {
+        handler.setup();
+        _state_js_1.state.handlers.set(handlerName, handler);
+    }
+    // remove existing loggers
+    _state_js_1.state.loggers.clear();
+    // setup loggers
+    const loggers = _state_js_1.state.config.loggers ?? {};
+    for (const [loggerName, loggerConfig] of Object.entries(loggers)) {
+        const handlerNames = loggerConfig.handlers ?? [];
+        const handlers = [];
+        handlerNames.forEach((handlerName) => {
+            const handler = _state_js_1.state.handlers.get(handlerName);
+            if (handler) {
+                handlers.push(handler);
+            }
+        });
+        const levelName = loggerConfig.level ?? _config_js_1.DEFAULT_LEVEL;
+        const logger = new logger_js_1.Logger(loggerName, levelName, { handlers: handlers });
+        _state_js_1.state.loggers.set(loggerName, logger);
+    }
+}
+setup(_config_js_1.DEFAULT_CONFIG);