@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/notification.js

@@ -0,0 +1,137 @@
+const keys = [
+    "schema",
+    "eventId",
+    "event",
+    "occurredAt",
+    "projectId",
+    "sourceId",
+    "title",
+    "text"
+];
+const events = new Set([
+    "task.event",
+    "execution.succeeded",
+    "execution.failed",
+    "notification.test"
+]);
+const taskIds = [
+    "evt_type",
+    "task",
+    "taskEvent",
+    "timeline",
+    "timelineTruncated",
+    "timelineThroughSequence"
+];
+export function assertNotificationMessage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("notification must be an object");
+    const message = value;
+    if (Object.keys(message).some((key) => !keys.includes(key) && !taskIds.includes(key)) ||
+        keys.some((key) => typeof message[key] !== "string")) {
+        throw new Error("notification contains missing or unsupported fields");
+    }
+    for (const key of keys) {
+        for (const scalar of message[key]) {
+            const code = scalar.codePointAt(0);
+            if (code >= 0xd800 && code <= 0xdfff)
+                throw new Error("notification contains an unpaired surrogate");
+        }
+    }
+    if (message.schema !== "octo.notification.v2" || !events.has(message.event))
+        throw new Error("unsupported notification schema or event");
+    if (message.event === "task.event") {
+        validateTaskNotification(message);
+    }
+    else if (taskIds.some((key) => key in message)) {
+        throw new Error("task fields require a task event");
+    }
+    for (const [key, max, min] of [
+        ["eventId", 256, 1],
+        ["projectId", 128, 1],
+        ["sourceId", 128, 1],
+        ["title", 256, 1],
+        ["text", 4096, 0]
+    ]) {
+        const length = Array.from(message[key]).length;
+        if (length < min || length > max)
+            throw new Error(`invalid notification ${key}`);
+    }
+    const timestamp = message.occurredAt;
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(timestamp) ||
+        !Number.isFinite(Date.parse(timestamp))) {
+        throw new Error("invalid notification occurredAt");
+    }
+}
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid task notification object");
+    return value;
+}
+function knownFields(value, required, optional = []) {
+    if (required.some((key) => !(key in value)) ||
+        Object.keys(value).some((key) => !required.includes(key) && !optional.includes(key)))
+        throw new Error("invalid task notification fields");
+}
+function eventType(value) {
+    return Number.isInteger(value) && Number(value) >= 101 && Number(value) <= 115;
+}
+function sequence(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0;
+}
+function validateTaskNotification(message) {
+    const task = object(message.task), event = object(message.taskEvent);
+    knownFields(task, ["id", "title", "status", "row_version", "handler_epoch"], ["responsible_party", "current_handler"]);
+    knownFields(event, ["id", "sequence", "evt_type", "actor", "summary", "payload"], ["task_conversation_id", "source_run_id"]);
+    if (task.id !== message.sourceId ||
+        typeof task.title !== "string" ||
+        !["backlog", "todo", "in_progress", "done", "cancelled"].includes(String(task.status)) ||
+        !sequence(task.row_version) ||
+        !sequence(task.handler_epoch))
+        throw new Error("invalid task snapshot");
+    const actor = object(event.actor);
+    if (typeof actor.type !== "string" ||
+        typeof actor.id !== "string" ||
+        typeof event.summary !== "string")
+        throw new Error("invalid event actor or summary");
+    object(event.payload);
+    if (!eventType(message.evt_type) ||
+        message.evt_type !== event.evt_type ||
+        event.id !== message.eventId ||
+        !sequence(event.sequence) ||
+        message.timelineThroughSequence !== event.sequence)
+        throw new Error("invalid task event identity");
+    if (message.timelineTruncated !== undefined && typeof message.timelineTruncated !== "boolean")
+        throw new Error("invalid timeline truncation");
+    if (!Array.isArray(message.timeline) || message.timeline.length > 20)
+        throw new Error("invalid task timeline");
+    let previous = 0;
+    for (const value of message.timeline) {
+        const item = object(value);
+        knownFields(item, ["eventId", "sequence", "evt_type", "summary"]);
+        if (typeof item.eventId !== "string" ||
+            typeof item.summary !== "string" ||
+            !eventType(item.evt_type) ||
+            !sequence(item.sequence) ||
+            Number(item.sequence) <= previous ||
+            Number(item.sequence) > Number(event.sequence))
+            throw new Error("invalid task timeline order");
+        previous = Number(item.sequence);
+    }
+    checkScalars(message);
+}
+function checkScalars(value) {
+    if (typeof value === "string") {
+        for (const char of value) {
+            const code = char.codePointAt(0);
+            if (code >= 0xd800 && code <= 0xdfff)
+                throw new Error("notification contains an unpaired surrogate");
+        }
+    }
+    else if (Array.isArray(value))
+        value.forEach(checkScalars);
+    else if (value && typeof value === "object")
+        for (const [key, item] of Object.entries(value)) {
+            checkScalars(key);
+            checkScalars(item);
+        }
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/run-protocol.d.ts

@@ -0,0 +1,20 @@
+import { type CanonicalEvent } from "./index.js";
+import type { ProtocolMode, RunProtocolErrorCode, HostInvokeOptions, HostRunReceipt, HostFrame, NativeHostFrame, CanonicalHostFrame, ControlHostFrame, HostControl, NativeInteractionResponse, AdapterProtocolSupport } from "./generated/protocol-types.js";
+export type { ProtocolMode, RunProtocolErrorCode, HostInvokeOptions, HostRunReceipt, HostFrame, NativeHostFrame, CanonicalHostFrame, ControlHostFrame, HostControl, NativeInteractionResponse, AdapterProtocolSupport };
+export declare const RUN_PROTOCOL_ERRORS: readonly ["PROTOCOL_MODE_INVALID", "PROTOCOL_MODE_UNSUPPORTED", "EXECUTION_PROTOCOL_MISMATCH", "EXECUTION_IDENTITY_CONFLICT", "NATIVE_METHOD_UNSUPPORTED", "NATIVE_RESPONSE_INVALID", "INTERACTION_NOT_ACTIVE", "HOST_EXECUTION_FAILED", "HOST_ENDED_WITHOUT_TERMINAL", "STREAM_GAP", "STREAM_EXPIRED", "REMOTE_NATIVE_UNSUPPORTED", "HOST_FRAME_INVALID", "HOST_CONTROL_INVALID", "HOST_RECEIPT_INVALID", "PROTOCOL_SUPPORT_INVALID"];
+export declare function protocolError(code: (typeof RUN_PROTOCOL_ERRORS)[number], message?: string): Error & {
+    code: (typeof RUN_PROTOCOL_ERRORS)[number];
+};
+/** Only an omitted mode defaults. A present undefined, null or empty value is invalid. */
+export declare function resolveHostInvokeOptions(value?: unknown): Readonly<Required<Pick<HostInvokeOptions, "protocolMode">> & HostInvokeOptions>;
+export declare function assertAdapterProtocolSupport(value: unknown): asserts value is AdapterProtocolSupport;
+export declare function assertProtocolSupport(support: AdapterProtocolSupport, options: HostInvokeOptions): void;
+export declare function assertNativeInteractionResponse(value: unknown): asserts value is NativeInteractionResponse;
+export declare function assertHostRunReceipt(value: unknown): asserts value is HostRunReceipt;
+export declare function assertHostControl(value: unknown): asserts value is HostControl;
+export declare function assertHostFrame(value: unknown): asserts value is HostFrame;
+/** Subscription identity always comes from admission, never from omitted subscribe options. */
+export declare function assertHostFrameIdentity(frame: HostFrame, receipt: HostRunReceipt): void;
+export declare function isHostTerminal(frame: HostFrame): boolean;
+/** A typed view of the selected canonical stream, never a payload cast or format guess. */
+export declare function canonicalEvents(frames: AsyncIterable<HostFrame>): AsyncGenerator<CanonicalEvent>;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/run-protocol.js

@@ -0,0 +1,241 @@
+import { assertJsonValue } from "./context.js";
+import { assertExecutionEvidence } from "./actmode.js";
+import { assertCanonicalEvent } from "./index.js";
+export const RUN_PROTOCOL_ERRORS = [
+    "PROTOCOL_MODE_INVALID",
+    "PROTOCOL_MODE_UNSUPPORTED",
+    "EXECUTION_PROTOCOL_MISMATCH",
+    "EXECUTION_IDENTITY_CONFLICT",
+    "NATIVE_METHOD_UNSUPPORTED",
+    "NATIVE_RESPONSE_INVALID",
+    "INTERACTION_NOT_ACTIVE",
+    "HOST_EXECUTION_FAILED",
+    "HOST_ENDED_WITHOUT_TERMINAL",
+    "STREAM_GAP",
+    "STREAM_EXPIRED",
+    "REMOTE_NATIVE_UNSUPPORTED",
+    "HOST_FRAME_INVALID",
+    "HOST_CONTROL_INVALID",
+    "HOST_RECEIPT_INVALID",
+    "PROTOCOL_SUPPORT_INVALID"
+];
+export function protocolError(code, message = code) {
+    return Object.assign(new Error(message), { code });
+}
+/** Only an omitted mode defaults. A present undefined, null or empty value is invalid. */
+export function resolveHostInvokeOptions(value = {}) {
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["protocolMode", "protocol"].includes(key)))
+        throw protocolError("PROTOCOL_MODE_INVALID");
+    const mode = Object.hasOwn(value, "protocolMode") ? value.protocolMode : "native";
+    if (mode !== "native" && mode !== "canonical")
+        throw protocolError("PROTOCOL_MODE_INVALID");
+    if (Object.hasOwn(value, "protocol") && !nonemptyString(value.protocol, 128))
+        throw protocolError("EXECUTION_PROTOCOL_MISMATCH");
+    assertProtocolJson(value, "PROTOCOL_MODE_INVALID");
+    return Object.freeze({
+        protocolMode: mode,
+        ...(typeof value.protocol === "string" ? { protocol: value.protocol } : {})
+    });
+}
+export function assertAdapterProtocolSupport(value) {
+    assertProtocolJson(value, "PROTOCOL_SUPPORT_INVALID");
+    if (!isRecord(value) ||
+        !exactKeys(value, ["protocol", "modes", "nativeMethods"]) ||
+        !nonemptyString(value.protocol, 128) ||
+        !Array.isArray(value.modes) ||
+        !value.modes.length ||
+        new Set(value.modes).size !== value.modes.length ||
+        value.modes.some((mode) => mode !== "native" && mode !== "canonical") ||
+        !Array.isArray(value.nativeMethods) ||
+        new Set(value.nativeMethods).size !== value.nativeMethods.length ||
+        value.nativeMethods.some((method) => !nonemptyString(method, 256)))
+        throw protocolError("PROTOCOL_SUPPORT_INVALID");
+    if (!value.modes.includes("native") && value.nativeMethods.length)
+        throw protocolError("PROTOCOL_SUPPORT_INVALID");
+}
+export function assertProtocolSupport(support, options) {
+    assertAdapterProtocolSupport(support);
+    const resolved = resolveHostInvokeOptions(options);
+    if (!support.modes.includes(resolved.protocolMode))
+        throw protocolError("PROTOCOL_MODE_UNSUPPORTED");
+    if (resolved.protocol !== undefined && resolved.protocol !== support.protocol)
+        throw protocolError("EXECUTION_PROTOCOL_MISMATCH");
+}
+export function assertNativeInteractionResponse(value) {
+    assertProtocolJson(value, "NATIVE_RESPONSE_INVALID");
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["requestId", "payload"].includes(key)) ||
+        !requestId(value.requestId) ||
+        !isRecord(value.payload))
+        throw protocolError("NATIVE_RESPONSE_INVALID");
+}
+const IDENTITY_KEYS = [
+    "run_id",
+    "invocation_id",
+    "stream_id",
+    "agent_session_id",
+    "session_generation",
+    "protocol_mode",
+    "protocol"
+];
+export function assertHostRunReceipt(value) {
+    assertProtocolJson(value, "HOST_RECEIPT_INVALID");
+    if (!isRecord(value) || !exactKeys(value, IDENTITY_KEYS) || !validIdentity(value))
+        throw protocolError("HOST_RECEIPT_INVALID");
+}
+export function assertHostControl(value) {
+    assertProtocolJson(value, "HOST_CONTROL_INVALID");
+    if (!isRecord(value))
+        throw protocolError("HOST_CONTROL_INVALID");
+    if (value.type === "evidence" &&
+        value.name === "execution" &&
+        exactKeys(value, ["type", "name", "payload"])) {
+        try {
+            assertExecutionEvidence(value.payload);
+        }
+        catch {
+            throw protocolError("HOST_CONTROL_INVALID");
+        }
+        return;
+    }
+    if (value.type === "evidence" &&
+        exactKeys(value, ["type", "name", "payload"]) &&
+        value.name === "session" &&
+        isRecord(value.payload)) {
+        return;
+    }
+    if (value.type === "state" &&
+        exactKeys(value, ["type", "state"]) &&
+        ["running", "completed", "failed", "cancelled", "lost"].includes(String(value.state)))
+        return;
+    if (value.type === "error" &&
+        exactKeys(value, ["type", "code", "message"]) &&
+        RUN_PROTOCOL_ERRORS.some((code) => code === value.code) &&
+        typeof value.message === "string")
+        return;
+    if (value.type === "interaction" &&
+        exactKeys(value, ["type", "requestId", "status"], ["expiresAt"]) &&
+        requestId(value.requestId) &&
+        ["pending", "resolved", "expired", "invalidated"].includes(String(value.status)) &&
+        (!Object.hasOwn(value, "expiresAt") || safeInteger(value.expiresAt, 1)) &&
+        (value.status !== "pending" || safeInteger(value.expiresAt, 1)))
+        return;
+    if (value.type === "gap" &&
+        exactKeys(value, ["type", "requested_after_seq", "oldest_seq", "latest_seq"]) &&
+        safeInteger(value.requested_after_seq, 0) &&
+        safeInteger(value.oldest_seq, 1) &&
+        safeInteger(value.latest_seq, 0) &&
+        value.requested_after_seq + 1 < value.oldest_seq &&
+        value.oldest_seq <= value.latest_seq + 1)
+        return;
+    throw protocolError("HOST_CONTROL_INVALID");
+}
+export function assertHostFrame(value) {
+    assertProtocolJson(value, "HOST_FRAME_INVALID");
+    if (!isRecord(value) || !validIdentity(value) || !safeInteger(value.seq, 1))
+        throw protocolError("HOST_FRAME_INVALID");
+    const identity = [...IDENTITY_KEYS, "seq", "kind"];
+    if (value.kind === "native" &&
+        value.protocol_mode === "native" &&
+        exactKeys(value, [...identity, "messageKind", "payload"]) &&
+        ["response", "notification", "request", "message"].includes(String(value.messageKind)) &&
+        isRecord(value.payload))
+        return;
+    if (value.kind === "canonical" &&
+        value.protocol_mode === "canonical" &&
+        exactKeys(value, [...identity, "event"])) {
+        if (!isRecord(value.event) || !exactKeys(value.event, ["protocolVersion", "type", "payload"]))
+            throw protocolError("HOST_FRAME_INVALID");
+        try {
+            assertCanonicalEvent(value.event);
+        }
+        catch {
+            throw protocolError("HOST_FRAME_INVALID");
+        }
+        for (const key of ["messageId", "stepId", "role", "status", "text", "reason", "message"]) {
+            if (Object.hasOwn(value.event.payload, key) &&
+                typeof Reflect.get(value.event.payload, key) !== "string")
+                throw protocolError("HOST_FRAME_INVALID", `CanonicalEvent.payload.${key} must be a string`);
+        }
+        return;
+    }
+    if (value.kind === "control" && exactKeys(value, [...identity, "control"])) {
+        assertHostControl(value.control);
+        return;
+    }
+    throw protocolError("HOST_FRAME_INVALID");
+}
+/** Subscription identity always comes from admission, never from omitted subscribe options. */
+export function assertHostFrameIdentity(frame, receipt) {
+    assertHostFrame(frame);
+    assertHostRunReceipt(receipt);
+    if (IDENTITY_KEYS.some((key) => Reflect.get(frame, key) !== Reflect.get(receipt, key)))
+        throw protocolError("EXECUTION_IDENTITY_CONFLICT");
+}
+export function isHostTerminal(frame) {
+    return (frame.kind === "control" &&
+        frame.control.type === "state" &&
+        ["completed", "failed", "cancelled", "lost"].includes(frame.control.state));
+}
+/** A typed view of the selected canonical stream, never a payload cast or format guess. */
+export async function* canonicalEvents(frames) {
+    let identity;
+    let lastSeq;
+    for await (const frame of frames) {
+        assertHostFrame(frame);
+        if (frame.protocol_mode !== "canonical")
+            throw protocolError("EXECUTION_PROTOCOL_MISMATCH");
+        identity ??= {
+            run_id: frame.run_id,
+            invocation_id: frame.invocation_id,
+            stream_id: frame.stream_id,
+            agent_session_id: frame.agent_session_id,
+            session_generation: frame.session_generation,
+            protocol_mode: frame.protocol_mode,
+            protocol: frame.protocol
+        };
+        assertHostFrameIdentity(frame, identity);
+        if (lastSeq !== undefined && frame.seq !== lastSeq + 1)
+            throw protocolError("STREAM_GAP");
+        lastSeq = frame.seq;
+        if (frame.kind === "canonical") {
+            assertCanonicalEvent(frame.event);
+            yield frame.event;
+        }
+        else if (frame.kind === "control" && frame.control.type === "gap")
+            throw protocolError("STREAM_GAP");
+        else if (frame.kind === "control" && frame.control.type === "error")
+            throw Object.assign(new Error(frame.control.message), { code: frame.control.code });
+    }
+}
+function validIdentity(value) {
+    return (["run_id", "invocation_id", "stream_id", "agent_session_id"].every((key) => nonemptyString(value[key], 256)) &&
+        safeInteger(value.session_generation, 0) &&
+        nonemptyString(value.protocol, 128) &&
+        (value.protocol_mode === "native" || value.protocol_mode === "canonical"));
+}
+function assertProtocolJson(value, code) {
+    try {
+        assertJsonValue(value);
+    }
+    catch {
+        throw protocolError(code);
+    }
+}
+function nonemptyString(value, max) {
+    return typeof value === "string" && value.length > 0 && Array.from(value).length <= max;
+}
+function safeInteger(value, min) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= min;
+}
+function requestId(value) {
+    return nonemptyString(value, 256) || (typeof value === "number" && Number.isSafeInteger(value));
+}
+function exactKeys(value, required, optional = []) {
+    return (required.every((key) => Object.hasOwn(value, key)) &&
+        Object.keys(value).every((key) => required.includes(key) || optional.includes(key)));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/runtime-selection.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedRuntimeSelection } from "./generated/protocol-types.js";
+export declare const RUNTIME_SELECTION_SCHEMA: "octo.runtime-selection/v2";
+export declare function assertResolvedRuntimeSelection(value: unknown): asserts value is ResolvedRuntimeSelection;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/runtime-selection.js

@@ -0,0 +1,68 @@
+import { assertJsonValue } from "./context.js";
+export const RUNTIME_SELECTION_SCHEMA = "octo.runtime-selection/v2";
+export function assertResolvedRuntimeSelection(value) {
+    object(value, "RESOLVED_RUNTIME_SELECTION_REQUIRED");
+    assertJsonValue(value);
+    fields(value, [
+        "schema",
+        "selection_mode",
+        "explicit_runtime_id",
+        "authorized_candidates",
+        "offline_behavior",
+        "failover"
+    ]);
+    if (value.schema !== RUNTIME_SELECTION_SCHEMA ||
+        !["explicit", "candidates"].includes(value.selection_mode) ||
+        !["wait", "fail"].includes(value.offline_behavior) ||
+        !["candidates", "none"].includes(value.failover))
+        invalid();
+    if (value.selection_mode === "explicit")
+        text(value.explicit_runtime_id);
+    else if (Object.hasOwn(value, "explicit_runtime_id"))
+        invalid();
+    if (value.selection_mode === "explicit" && value.failover !== "none")
+        invalid();
+    if (!Array.isArray(value.authorized_candidates) ||
+        value.authorized_candidates.length === 0 ||
+        value.authorized_candidates.length > 64)
+        invalid();
+    const runtimeIds = new Set();
+    const priorities = new Set();
+    for (const candidate of value.authorized_candidates) {
+        object(candidate);
+        fields(candidate, ["runtime_id", "priority", "owner_subject_type", "owner_subject_id"]);
+        text(candidate.runtime_id);
+        text(candidate.owner_subject_type);
+        if (candidate.owner_subject_type !== "user" && candidate.owner_subject_type !== "teamspace")
+            invalid();
+        text(candidate.owner_subject_id);
+        positiveInteger(candidate.priority);
+        if (runtimeIds.has(candidate.runtime_id) || priorities.has(candidate.priority))
+            invalid();
+        runtimeIds.add(candidate.runtime_id);
+        priorities.add(candidate.priority);
+    }
+    if (value.selection_mode === "explicit" &&
+        (value.authorized_candidates.length !== 1 ||
+            !runtimeIds.has(value.explicit_runtime_id)))
+        invalid();
+}
+function invalid() {
+    throw new TypeError("RESOLVED_RUNTIME_SELECTION_INVALID");
+}
+function object(value, code = "RESOLVED_RUNTIME_SELECTION_INVALID") {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError(code);
+}
+function fields(value, allowed) {
+    if (Object.keys(value).some((key) => !allowed.includes(key)))
+        invalid();
+}
+function text(value) {
+    if (typeof value !== "string" || value.length === 0 || [...value].length > 191)
+        invalid();
+}
+function positiveInteger(value) {
+    if (!Number.isSafeInteger(value) || value < 1)
+        invalid();
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-protocol",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./browser": "./dist/browser.js",
+    "./notification": "./dist/notification.js"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {}
+}

package/node_modules/@types/debug/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    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

package/node_modules/@types/debug/README.md

@@ -0,0 +1,69 @@
+# Installation
+> `npm install --save @types/debug`
+
+# Summary
+This package contains type definitions for debug (https://github.com/debug-js/debug).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug.
+## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug/index.d.ts)
+````ts
+declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug };
+
+export = debug;
+export as namespace debug;
+
+declare namespace debug {
+    interface Debug {
+        (namespace: string): Debugger;
+        coerce: (val: any) => any;
+        disable: () => string;
+        enable: (namespaces: string) => void;
+        enabled: (namespaces: string) => boolean;
+        formatArgs: (this: Debugger, args: any[]) => void;
+        log: (...args: any[]) => any;
+        selectColor: (namespace: string) => string | number;
+        humanize: typeof import("ms");
+
+        names: string[];
+        skips: string[];
+
+        formatters: Formatters;
+
+        inspectOpts?: {
+            hideDate?: boolean | number | null;
+            colors?: boolean | number | null;
+            depth?: boolean | number | null;
+            showHidden?: boolean | number | null;
+        };
+    }
+
+    type IDebug = Debug;
+
+    interface Formatters {
+        [formatter: string]: (v: any) => string;
+    }
+
+    type IDebugger = Debugger;
+
+    interface Debugger {
+        (formatter: any, ...args: any[]): void;
+
+        color: string;
+        diff: number;
+        enabled: boolean;
+        log: (...args: any[]) => any;
+        namespace: string;
+        destroy: () => boolean;
+        extend: (namespace: string, delimiter?: string) => Debugger;
+    }
+}
+
+````
+
+### Additional Details
+ * Last updated: Thu, 19 Mar 2026 06:47:22 GMT
+ * Dependencies: [@types/ms](https://npmjs.com/package/@types/ms)
+
+# Credits
+These definitions were written by [Seon-Wook Park](https://github.com/swook), [Gal Talmor](https://github.com/galtalmor), [John McLaughlin](https://github.com/zamb3zi), [Brasten Sager](https://github.com/brasten), [Nicolas Penin](https://github.com/npenin), [Kristian Brünn](https://github.com/kristianmitk), and [Caleb Gregory](https://github.com/calebgregory).

package/node_modules/@types/debug/index.d.ts

@@ -0,0 +1,50 @@
+declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug };
+
+export = debug;
+export as namespace debug;
+
+declare namespace debug {
+    interface Debug {
+        (namespace: string): Debugger;
+        coerce: (val: any) => any;
+        disable: () => string;
+        enable: (namespaces: string) => void;
+        enabled: (namespaces: string) => boolean;
+        formatArgs: (this: Debugger, args: any[]) => void;
+        log: (...args: any[]) => any;
+        selectColor: (namespace: string) => string | number;
+        humanize: typeof import("ms");
+
+        names: string[];
+        skips: string[];
+
+        formatters: Formatters;
+
+        inspectOpts?: {
+            hideDate?: boolean | number | null;
+            colors?: boolean | number | null;
+            depth?: boolean | number | null;
+            showHidden?: boolean | number | null;
+        };
+    }
+
+    type IDebug = Debug;
+
+    interface Formatters {
+        [formatter: string]: (v: any) => string;
+    }
+
+    type IDebugger = Debugger;
+
+    interface Debugger {
+        (formatter: any, ...args: any[]): void;
+
+        color: string;
+        diff: number;
+        enabled: boolean;
+        log: (...args: any[]) => any;
+        namespace: string;
+        destroy: () => boolean;
+        extend: (namespace: string, delimiter?: string) => Debugger;
+    }
+}