@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/bin.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// Static import: Bun.build must include the AOSP loader in the mobile bundle.
+// We pin it to globalThis to prevent tree-shaking — the only consumer is a
+// dynamic import in cli/index.ts, which is enough for resolution but not
+// inclusion. Without this guard the symbol silently disappears from the bundle.
+import * as _earlyFs from "node:fs";
+import { enableCompileCache } from "node:module";
+import { homedir as _earlyHomedir } from "node:os";
+// Enable Node 22.8+'s persistent V8 compile cache before any heavy import so
+// the 2nd+ cold boot skips recompiling the ~70k LOC of transpiled plugin
+// source. Anchored to <stateDir>/cache/node-compile — the SAME dir the dev
+// orchestrator pins via NODE_COMPILE_CACHE (dev-ui.mjs) — so the packaged CLI
+// path and the dev path share one warm cache instead of two.
+//
+// When NODE_COMPILE_CACHE is already set (dev path), Node enables the cache
+// from the env var before any user code runs, so we skip — calling it again
+// would be redundant. Wrapped defensively: a missing API (older Node) or any
+// failure must never break boot.
+(() => {
+    try {
+        if (typeof enableCompileCache !== "function" ||
+            process.env.NODE_COMPILE_CACHE?.trim()) {
+            return;
+        }
+        const xdgStateHome = process.env.XDG_STATE_HOME?.trim();
+        // `process.env.HOME` is unset on Windows; `os.homedir()` returns
+        // `%USERPROFILE%` there and `$HOME` on POSIX, so this cache anchors
+        // identically to the rest of the codebase (see state-dir.ts).
+        const home = process.env.HOME?.trim() || _earlyHomedir();
+        const resolvedStateDir = process.env.ELIZA_STATE_DIR?.trim() ||
+            (xdgStateHome
+                ? `${xdgStateHome}/eliza`
+                : home
+                    ? `${home}/.local/state/eliza`
+                    : undefined);
+        if (resolvedStateDir) {
+            enableCompileCache(`${resolvedStateDir}/cache/node-compile`);
+        }
+        else {
+            enableCompileCache();
+        }
+    }
+    catch {
+        // V8 compile cache is a pure boot-time optimization; ignore any failure.
+    }
+})();
+import { runAutonomousCli } from "./cli/index.js";
+import { configureMobileDnsIfNeeded } from "./runtime/mobile-dns.js";
+// Early diagnostic logger for Android: captures errors before the fs shim runs.
+// Uses raw node:fs so the shim can't interfere. Writes to $ELIZA_STATE_DIR/bin-debug.log.
+const _binDebugLog = process.env.ELIZA_PLATFORM === "android"
+    ? (() => {
+        const xdgStateHome = process.env.XDG_STATE_HOME ??
+            `${process.env.HOME ?? "/data/local/tmp"}/.local/state`;
+        const stateDir = process.env.ELIZA_STATE_DIR || `${xdgStateHome}/eliza`;
+        const logPath = `${stateDir}/bin-debug.log`;
+        try {
+            _earlyFs.mkdirSync(stateDir, { recursive: true });
+        }
+        catch {
+            /* ignore */
+        }
+        return (msg) => {
+            try {
+                _earlyFs.appendFileSync(logPath, `${new Date().toISOString()} ${msg}\n`);
+            }
+            catch {
+                /* ignore */
+            }
+        };
+    })()
+    : () => { };
+_binDebugLog(`[bin.ts] started ELIZA_PLATFORM=${process.env.ELIZA_PLATFORM ?? "(unset)"} ELIZA_STATE_DIR=${process.env.ELIZA_STATE_DIR ?? "(unset)"}`);
+// Mobile devices ship no /etc/resolv.conf, so the musl bun agent can't resolve
+// DNS — every outbound fetch (cloud, model catalog, connectors) fails until we
+// point the resolver at public nameservers. No-op off-device. Runs at module
+// eval, before the runtime boots or any fetch fires.
+configureMobileDnsIfNeeded();
+async function bootstrapMobileEntrypoint() {
+    if (process.env.ELIZA_PLATFORM === "android") {
+        _binDebugLog("[bin.ts] entering android block");
+        try {
+            const { registerAospLlamaLoader, ensureAospLocalInferenceHandlers } = await import(/* @vite-ignore */ "@elizaos/plugin-aosp-local-inference");
+            globalThis.__elizaAospLlamaLoader = registerAospLlamaLoader;
+            globalThis.__elizaAospLocalInferenceBootstrap = ensureAospLocalInferenceHandlers;
+        }
+        catch (e) {
+            // Android-only local inference is optional outside the privileged AOSP build.
+            _binDebugLog(`[bin.ts] aosp-local-inference init error (ok): ${e instanceof Error ? e.message : String(e)}`);
+        }
+        try {
+            await import("./runtime/android-app-plugins.js");
+            _binDebugLog("[bin.ts] android-app-plugins loaded ok");
+        }
+        catch (e) {
+            // Android-only app plugins not bundled in this build; plugin-resolver.ts
+            // returns null for these IDs and the rest of the runtime is unaffected.
+            _binDebugLog(`[bin.ts] android-app-plugins init error (ok): ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    if (process.env.ELIZA_DEVICE_BRIDGE_ENABLED === "1") {
+        try {
+            const { ensureMobileDeviceBridgeInferenceHandlers } = await import("@elizaos/plugin-capacitor-bridge/mobile-device-bridge-bootstrap");
+            globalThis.__elizaMobileDeviceBridgeBootstrap =
+                ensureMobileDeviceBridgeInferenceHandlers;
+        }
+        catch {
+            // Device bridge is explicitly opt-in; absence just leaves cloud/local-model
+            // provider selection to the runtime.
+        }
+    }
+    _binDebugLog("[bin.ts] pre-runAutonomousCli");
+    await runAutonomousCli();
+}
+bootstrapMobileEntrypoint().catch((error) => {
+    const msg = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    _binDebugLog(`[bin.ts] FATAL runAutonomousCli threw: ${msg}`);
+    console.error("[eliza-autonomous] Failed to start:", msg);
+    process.exit(1);
+});

package/cli/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../src/cli/benchmark.ts"],"names":[],"mappings":"AAqTA,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,IAAI,CAAC,CA2Ef"}

package/cli/benchmark.js

@@ -0,0 +1,305 @@
+/**
+ * CLI subcommand for headless benchmark execution.
+ *
+ * Accepts a task as JSON (from --task <file> or stdin), boots the runtime
+ * in headless mode, sends the prompt through handleMessage (the real agent
+ * loop including action selection), captures the response, and writes a
+ * JSON result to stdout.
+ *
+ * Task prompts are augmented with type-aware instructions so the agent
+ * produces thorough, structured responses through its normal flow.
+ *
+ * Server mode (--server) keeps the runtime alive and reads line-delimited
+ * JSON from stdin, writing one result line per task.
+ */
+import crypto from "node:crypto";
+import { readFileSync } from "node:fs";
+import process from "node:process";
+import * as readline from "node:readline";
+import { ChannelType, createMessageMemory, logger, stringToUuid, } from "@elizaos/core";
+// ---------------------------------------------------------------------------
+// Prompt augmentation — steers the agent via the normal message flow
+// ---------------------------------------------------------------------------
+const RESEARCH_AUGMENTATION = "\n\nPlease give a thorough, structured answer with ## headings, bullet points, and a conclusion. Be detailed and comprehensive.";
+const CODING_AUGMENTATION = "\n\nPlease write the complete code implementation directly in your response using ```typescript blocks. Include all imports, types, and error handling. Do not delegate — write the code yourself.";
+const DEFAULT_AUGMENTATION = "\n\nPlease give a detailed, structured answer with headings and bullet points.";
+function detectTaskType(task) {
+    if (task.type)
+        return task.type;
+    if (/\b(implement|build|create|write|code|function|class|module|component|api|endpoint|cli|test suite|refactor|debug|fix.*bug)\b/i.test(task.prompt)) {
+        return "coding";
+    }
+    return "research";
+}
+function augmentPrompt(task) {
+    const taskType = detectTaskType(task);
+    switch (taskType) {
+        case "research":
+            return task.prompt + RESEARCH_AUGMENTATION;
+        case "coding":
+            return task.prompt + CODING_AUGMENTATION;
+        default:
+            return task.prompt + DEFAULT_AUGMENTATION;
+    }
+}
+// ---------------------------------------------------------------------------
+// Task execution — uses handleMessage (the real agent loop)
+// ---------------------------------------------------------------------------
+async function runTask(runtime, task, timeoutMs) {
+    const start = performance.now();
+    const taskType = detectTaskType(task);
+    const userId = crypto.randomUUID();
+    const roomId = stringToUuid(`benchmark-${task.id}`);
+    const worldId = stringToUuid(`benchmark-world-${task.id}`);
+    const messageServerId = stringToUuid(`benchmark-server-${task.id}`);
+    try {
+        await runtime.ensureConnection({
+            entityId: userId,
+            roomId,
+            worldId,
+            userName: "Benchmark",
+            source: "benchmark",
+            channelId: `benchmark-${task.id}`,
+            type: ChannelType.DM,
+            messageServerId,
+            metadata: { ownership: { ownerId: userId } },
+        });
+        const augmentedPrompt = augmentPrompt(task);
+        const message = createMessageMemory({
+            id: crypto.randomUUID(),
+            entityId: userId,
+            roomId,
+            content: {
+                text: augmentedPrompt,
+                source: "benchmark",
+                channelType: ChannelType.DM,
+            },
+        });
+        if (!runtime.messageService) {
+            return {
+                id: task.id,
+                response: "",
+                task_type: taskType,
+                actions_taken: [],
+                duration_ms: Math.round(performance.now() - start),
+                success: false,
+                error: "runtime.messageService is not available",
+            };
+        }
+        let callbackText = "";
+        let streamText = "";
+        const actionsTaken = [];
+        // Race message handling against the timeout.
+        // Text can arrive via three channels:
+        //   1. callback — action handler results
+        //   2. onStreamChunk — streamed LLM tokens
+        //   3. result.responseContent — final composed response
+        // We capture all three and deduplicate.
+        let timeoutHandle;
+        const result = (await Promise.race([
+            (async () => {
+                const handleResult = await runtime.messageService?.handleMessage(runtime, message, async (content) => {
+                    if (content.text) {
+                        callbackText += content.text;
+                    }
+                    // Track actions taken
+                    const action = content?.action;
+                    if (typeof action === "string" && !actionsTaken.includes(action)) {
+                        actionsTaken.push(action);
+                    }
+                    return [];
+                }, {
+                    onStreamChunk: async (chunk) => {
+                        if (chunk)
+                            streamText += chunk;
+                    },
+                });
+                return handleResult;
+            })(),
+            new Promise((resolve) => {
+                timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
+            }),
+        ]).finally(() => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+        }));
+        if (result === "timeout") {
+            const responseText = streamText || callbackText;
+            return {
+                id: task.id,
+                response: responseText,
+                task_type: taskType,
+                actions_taken: actionsTaken,
+                duration_ms: Math.round(performance.now() - start),
+                success: false,
+                error: `Timeout after ${timeoutMs}ms`,
+            };
+        }
+        // Extract text from all channels, preferring the richest source.
+        // result.responseContent has the final composed text from the LLM.
+        const resultRecord = typeof result === "object" && result !== null
+            ? result
+            : null;
+        const responseContent = resultRecord?.responseContent &&
+            typeof resultRecord.responseContent === "object"
+            ? resultRecord.responseContent
+            : null;
+        const resultText = responseContent && typeof responseContent.text === "string"
+            ? responseContent.text
+            : "";
+        // Also check responseMessages for additional text
+        const responseMessages = Array.isArray(resultRecord?.responseMessages)
+            ? resultRecord.responseMessages
+            : [];
+        const messagesText = responseMessages
+            .map((m) => m.content?.text ?? "")
+            .filter(Boolean)
+            .join("\n");
+        // Pick the best source — longest non-empty wins, since the same
+        // text may appear in multiple channels.
+        const candidates = [
+            resultText,
+            messagesText,
+            streamText,
+            callbackText,
+        ].filter(Boolean);
+        const responseText = candidates.sort((a, b) => b.length - a.length)[0] ?? "";
+        return {
+            id: task.id,
+            response: responseText,
+            task_type: taskType,
+            actions_taken: actionsTaken,
+            duration_ms: Math.round(performance.now() - start),
+            success: true,
+        };
+    }
+    catch (err) {
+        return {
+            id: task.id,
+            response: "",
+            task_type: taskType,
+            actions_taken: [],
+            duration_ms: Math.round(performance.now() - start),
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/** Parse a JSON string into a BenchmarkTask, throwing on invalid input. */
+function parseTask(raw) {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !("id" in parsed) ||
+        !("prompt" in parsed)) {
+        throw new Error('Invalid task JSON: must contain at minimum "id" and "prompt" fields');
+    }
+    return parsed;
+}
+/** Write a result as a single JSON line to stdout. */
+function writeResult(result) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+/**
+ * Server mode: read line-delimited JSON tasks from stdin, process each
+ * against the running runtime, and write results to stdout.
+ */
+async function runServerMode(runtime, timeoutMs) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const task = parseTask(trimmed);
+            const result = await runTask(runtime, task, timeoutMs);
+            writeResult(result);
+        }
+        catch (err) {
+            const errorResult = {
+                id: "unknown",
+                response: "",
+                task_type: "",
+                actions_taken: [],
+                duration_ms: 0,
+                success: false,
+                error: `Failed to parse task: ${err instanceof Error ? err.message : String(err)}`,
+            };
+            writeResult(errorResult);
+        }
+    }
+}
+/**
+ * Entry point for the `benchmark` CLI subcommand.
+ */
+export async function runBenchmark(opts) {
+    const timeoutMs = Number.parseInt(opts.timeout, 10);
+    if (Number.isNaN(timeoutMs) || timeoutMs <= 0) {
+        console.error("[benchmark] Invalid timeout value");
+        process.exit(2);
+    }
+    // Suppress noisy runtime logs — benchmark output must be clean JSON on stdout
+    if (!process.env.LOG_LEVEL) {
+        process.env.LOG_LEVEL = "error";
+    }
+    process.env.ELIZA_HEADLESS = "1";
+    const { bootElizaRuntime } = await import("../runtime/eliza.js");
+    let runtime;
+    try {
+        runtime = await bootElizaRuntime();
+    }
+    catch (err) {
+        const errorResult = {
+            id: opts.task ? "file" : "stdin",
+            response: "",
+            task_type: "",
+            actions_taken: [],
+            duration_ms: 0,
+            success: false,
+            error: `Runtime boot failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+        writeResult(errorResult);
+        process.exit(1);
+    }
+    if (opts.server) {
+        await runServerMode(runtime, timeoutMs);
+        logger.info("[benchmark] EOF on stdin, shutting down");
+        process.exit(0);
+    }
+    // Single-task mode
+    let taskJson;
+    if (opts.task) {
+        try {
+            taskJson = readFileSync(opts.task, "utf-8");
+        }
+        catch (err) {
+            console.error(`[benchmark] Failed to read task file: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(2);
+        }
+    }
+    else {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        taskJson = Buffer.concat(chunks).toString("utf-8").trim();
+        if (!taskJson) {
+            console.error("[benchmark] No task provided. Use --task <file> or pipe JSON to stdin.");
+            process.exit(2);
+        }
+    }
+    let task;
+    try {
+        task = parseTask(taskJson);
+    }
+    catch (err) {
+        console.error(`[benchmark] Invalid task JSON: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(2);
+    }
+    const result = await runTask(runtime, task, timeoutMs);
+    writeResult(result);
+    process.exit(result.success ? 0 : 1);
+}

package/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AA+EA,wBAAsB,gBAAgB,CACpC,IAAI,GAAE,MAAM,EAAiB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAgIf"}

package/cli/index.js

@@ -0,0 +1,174 @@
+import { createRequire } from "node:module";
+import process from "node:process";
+function printHelp() {
+    console.log(`eliza-autonomous
+
+Usage:
+  eliza-autonomous serve
+  eliza-autonomous tui
+  eliza-autonomous tui-smoke [--api <url>]
+  eliza-autonomous runtime
+  eliza-autonomous ios-bridge --stdio
+  eliza-autonomous android-bridge
+  eliza-autonomous benchmark [options]
+
+Commands:
+  serve          Start the autonomous backend in server-only mode
+  tui            Start the terminal TUI against an already-running backend
+  tui-smoke      Start the terminal TUI once, print a readiness marker, and exit
+  runtime        Boot the runtime without entering the API/CLI wrapper
+  ios-bridge     Run the iOS full-engine stdio bridge
+  android-bridge Boot the Android local-backend (HTTP server on 127.0.0.1:31337)
+  benchmark      Run a benchmark task headlessly against the agent
+
+Benchmark options:
+  --task <path>    Path to task JSON file
+  --server         Keep runtime alive and accept tasks via stdin (line-delimited JSON)
+  --timeout <ms>   Timeout per task in milliseconds (default: 120000)
+`);
+}
+class SmokeTerminal {
+    writes = [];
+    start(_onInput, _onResize) { }
+    stop() { }
+    async drainInput() { }
+    write(data) {
+        this.writes.push(data);
+    }
+    get columns() {
+        return 100;
+    }
+    get rows() {
+        return 28;
+    }
+    get kittyProtocolActive() {
+        return true;
+    }
+    moveBy(_lines) { }
+    hideCursor() { }
+    showCursor() { }
+    clearLine() { }
+    clearFromCursor() { }
+    clearScreen() { }
+    setTitle(_title) { }
+    text() {
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: strips ANSI escape sequences from the captured TUI frame
+        return this.writes.join("").replace(/\u001b\[[0-9;?]*[A-Za-z]/g, "");
+    }
+}
+function optionValue(argv, name) {
+    const index = argv.indexOf(name);
+    return index >= 0 ? argv[index + 1] : undefined;
+}
+function printVersion() {
+    const require = createRequire(import.meta.url);
+    const pkg = require("../../package.json");
+    console.log(pkg.version);
+}
+export async function runAutonomousCli(argv = process.argv) {
+    const command = argv[2] ?? "serve";
+    if (command === "--version" || command === "-v" || command === "version") {
+        printVersion();
+        return;
+    }
+    if (command === "--help" || command === "-h" || command === "help") {
+        printHelp();
+        return;
+    }
+    if (command === "runtime") {
+        const { bootElizaRuntime } = await import("../runtime/index.js");
+        await bootElizaRuntime();
+        return;
+    }
+    if (command === "ios-bridge") {
+        const { runIosBridgeCli } = await import("@elizaos/plugin-capacitor-bridge/ios/bridge");
+        await runIosBridgeCli(argv);
+        return;
+    }
+    if (command === "serve" || command === "start") {
+        const keepAlive = setInterval(() => { }, 1 << 30);
+        const { startEliza } = await import("../runtime/index.js");
+        const runtime = await startEliza({ serverOnly: true }).catch((error) => {
+            clearInterval(keepAlive);
+            throw error;
+        });
+        // AOSP-only post-boot wiring. The upstream `startEliza` does not
+        // register local-inference handlers — that lives in the
+        // `@elizaos/app-core` runtime wrapper, which the mobile agent
+        // bundle cannot import (would create an `agent → app-core →
+        // agent` workspace cycle). Bootstrapping the AOSP llama loader
+        // and ModelType handlers here keeps the registration in the
+        // agent package and out of the bundler's cycle path. Skipped when
+        // `ELIZA_LOCAL_LLAMA !== "1"`.
+        if (runtime && process.env.ELIZA_LOCAL_LLAMA?.trim() === "1") {
+            const { ensureAospLocalInferenceHandlers } = await import("@elizaos/plugin-aosp-local-inference");
+            await ensureAospLocalInferenceHandlers(runtime);
+        }
+        else if (runtime &&
+            process.env.ELIZA_DEVICE_BRIDGE_ENABLED?.trim() === "1") {
+            const { ensureMobileDeviceBridgeInferenceHandlers } = await import("@elizaos/plugin-capacitor-bridge/mobile-device-bridge-bootstrap");
+            await ensureMobileDeviceBridgeInferenceHandlers(runtime);
+        }
+        // Only load the TUI when a terminal is actually attached. The cloud
+        // image runs server-only with no TTY and may not bundle @elizaos/tui;
+        // importing agent-terminal-tui there crashes an otherwise-healthy server.
+        const { isTerminalTuiEnabled } = await import("../tui/tui-enabled.js");
+        if (isTerminalTuiEnabled()) {
+            const { startAgentTerminalTui } = await import("../tui/agent-terminal-tui.js");
+            startAgentTerminalTui();
+        }
+        return;
+    }
+    if (command === "tui" || command === "tui-smoke") {
+        const apiBaseUrl = optionValue(argv, "--api") ??
+            process.env.ELIZA_AGENT_URL ??
+            process.env.ELIZA_API_URL;
+        const { startAgentTerminalTui } = await import("../tui/agent-terminal-tui.js");
+        if (command === "tui-smoke") {
+            const terminal = new SmokeTerminal();
+            const handle = startAgentTerminalTui({ apiBaseUrl, terminal });
+            if (!handle)
+                throw new Error("terminal TUI did not start");
+            await handle.ready;
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            console.log(terminal.text());
+            console.log(`elizaos-tui-ready api=${apiBaseUrl ?? "default"}`);
+            handle.stop();
+            return;
+        }
+        const handle = startAgentTerminalTui({ apiBaseUrl });
+        if (!handle)
+            throw new Error("terminal TUI is disabled; set ELIZA_TERMINAL_TUI=1");
+        await handle.ready;
+        console.log(`elizaos-tui-ready api=${apiBaseUrl ?? "default"}`);
+        return;
+    }
+    if (command === "android-bridge") {
+        const { runAndroidBridgeCli } = await import("@elizaos/plugin-capacitor-bridge/android/bridge");
+        await runAndroidBridgeCli();
+        return;
+    }
+    if (command === "benchmark") {
+        const { runBenchmark } = await import("./benchmark.js");
+        // Parse benchmark-specific flags from argv
+        const opts = {
+            task: undefined,
+            server: false,
+            timeout: "120000",
+        };
+        for (let i = 3; i < argv.length; i++) {
+            if (argv[i] === "--task" && argv[i + 1]) {
+                opts.task = argv[++i];
+            }
+            else if (argv[i] === "--server") {
+                opts.server = true;
+            }
+            else if (argv[i] === "--timeout" && argv[i + 1]) {
+                opts.timeout = argv[++i];
+            }
+        }
+        await runBenchmark(opts);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}

package/config/character-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-schema.d.ts","sourceRoot":"","sources":["../../src/config/character-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+BxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;kBAYjB,CAAC"}

package/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAoBnD,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA6EnD,wBAAgB,eAAe,IAAI,WAAW,CAsH7C;AAwDD,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CA8EzD;AAED,wBAAgB,gBAAgB,IAAI,OAAO,CAQ1C"}