@elizaos/agent 2.0.0-alpha.526 → 2.0.0-alpha.535

package/packages/app-core/src/services/local-inference/registry.js

@@ -0,0 +1,108 @@
+/**
+ * On-disk registry of installed models.
+ *
+ * Two sources feed the registry:
+ *   1. Eliza-owned downloads (source: "eliza-download") — written on
+ *      successful completion by the downloader.
+ *   2. External scans (source: "external-scan") — merged in at read time
+ *      from `scanExternalModels()`. These are never persisted to the
+ *      registry file; a rescan runs whenever we read.
+ *
+ * The JSON file only holds Eliza-owned entries. That way, if a user
+ * cleans up LM Studio models we don't show stale ghosts.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { scanExternalModels } from "./external-scanner";
+import { isWithinElizaRoot, localInferenceRoot, registryPath } from "./paths";
+async function ensureRootDir() {
+    await fs.mkdir(localInferenceRoot(), { recursive: true });
+}
+async function readElizaOwned() {
+    try {
+        const raw = await fs.readFile(registryPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.models)) {
+            return [];
+        }
+        return parsed.models.filter((m) => m && typeof m === "object" && m.source === "eliza-download");
+    }
+    catch {
+        return [];
+    }
+}
+async function writeElizaOwned(models) {
+    await ensureRootDir();
+    const tmp = `${registryPath()}.tmp`;
+    const payload = { version: 1, models };
+    await fs.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+    await fs.rename(tmp, registryPath());
+}
+/**
+ * Return all models currently usable: persisted Eliza downloads plus a
+ * fresh external-tool scan. External duplicates of Eliza-owned files are
+ * filtered out by path.
+ */
+export async function listInstalledModels() {
+    const [owned, external] = await Promise.all([
+        readElizaOwned(),
+        scanExternalModels(),
+    ]);
+    // Filter out Eliza-owned files that also survived a reboot of the local
+    // file and got re-detected by the scanner.
+    const ownedPaths = new Set(owned.map((m) => path.resolve(m.path)));
+    const dedupedExternal = external.filter((m) => !ownedPaths.has(path.resolve(m.path)));
+    return [...owned, ...dedupedExternal];
+}
+/** Add or update a Eliza-owned entry. External entries are rejected. */
+export async function upsertElizaModel(model) {
+    if (model.source !== "eliza-download") {
+        throw new Error("[local-inference] registry only accepts Eliza-owned models");
+    }
+    if (!isWithinElizaRoot(model.path)) {
+        throw new Error("[local-inference] Eliza-owned models must live under the local-inference root");
+    }
+    const owned = await readElizaOwned();
+    const withoutCurrent = owned.filter((m) => m.id !== model.id);
+    withoutCurrent.push(model);
+    await writeElizaOwned(withoutCurrent);
+}
+/** Mark an existing Eliza-owned model as most-recently-used. */
+export async function touchElizaModel(id) {
+    const owned = await readElizaOwned();
+    const target = owned.find((m) => m.id === id);
+    if (!target)
+        return;
+    target.lastUsedAt = new Date().toISOString();
+    await writeElizaOwned(owned);
+}
+/**
+ * Delete a Eliza-owned model from the registry and from disk.
+ *
+ * Refuses if the model was discovered from another tool — Eliza must not
+ * touch files it doesn't own. Callers surface that refusal as a 4xx.
+ */
+export async function removeElizaModel(id) {
+    const owned = await readElizaOwned();
+    const target = owned.find((m) => m.id === id);
+    if (!target) {
+        // Check whether it's a known external entry so we can return a
+        // helpful error message instead of 404.
+        const external = await scanExternalModels();
+        if (external.some((m) => m.id === id)) {
+            return { removed: false, reason: "external" };
+        }
+        return { removed: false, reason: "not-found" };
+    }
+    if (!isWithinElizaRoot(target.path)) {
+        return { removed: false, reason: "external" };
+    }
+    try {
+        await fs.rm(target.path, { force: true });
+    }
+    catch {
+        // If the file was already gone we still want to clear the registry entry.
+    }
+    await writeElizaOwned(owned.filter((m) => m.id !== id));
+    return { removed: true };
+}

package/packages/app-core/src/services/local-inference/routing-preferences.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Per-model-type user override: "for TEXT_LARGE, prefer this provider".
+ *
+ * Persisted to `$STATE_DIR/local-inference/routing.json` and read by the
+ * router-handler (see `router-handler.ts`) to pick a provider at dispatch
+ * time. When a slot has no override, the runtime's native priority order
+ * wins — i.e. this is layered over the existing registration priority
+ * rather than replacing it.
+ */
+import type { AgentModelSlot } from "./types";
+export type RoutingPolicy = "manual" | "cheapest" | "fastest" | "prefer-local" | "round-robin";
+export declare const DEFAULT_ROUTING_POLICY: RoutingPolicy;
+export interface RoutingPreferences {
+    /**
+     * Explicit provider override per agent slot. Empty record = no overrides,
+     * runtime picks the highest-priority registered handler.
+     */
+    preferredProvider: Partial<Record<AgentModelSlot, string>>;
+    /**
+     * Per-slot policy. "manual" honours `preferredProvider` verbatim;
+     * everything else lets the router-handler compute a winner from the
+     * policy rule set. Absent = "prefer-local" so local models and
+     * subscriptions are tried before direct paid APIs and managed cloud.
+     */
+    policy: Partial<Record<AgentModelSlot, RoutingPolicy>>;
+}
+export declare function readRoutingPreferences(): Promise<RoutingPreferences>;
+export declare function writeRoutingPreferences(prefs: RoutingPreferences): Promise<void>;
+export declare function setPreferredProvider(slot: AgentModelSlot, provider: string | null): Promise<RoutingPreferences>;
+export declare function setPolicy(slot: AgentModelSlot, policy: RoutingPolicy | null): Promise<RoutingPreferences>;
+//# sourceMappingURL=routing-preferences.d.ts.map

package/packages/app-core/src/services/local-inference/routing-preferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-preferences.d.ts","sourceRoot":"","sources":["../../../../../../../app-core/src/services/local-inference/routing-preferences.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,UAAU,GACV,SAAS,GACT,cAAc,GACd,aAAa,CAAC;AAElB,eAAO,MAAM,sBAAsB,EAAE,aAA8B,CAAC;AAEpE,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,iBAAiB,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3D;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC,CAAC;CACxD;AAiBD,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAY1E;AAED,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,IAAI,CAAC,CAMf;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,GACtB,OAAO,CAAC,kBAAkB,CAAC,CAa7B;AAED,wBAAsB,SAAS,CAC7B,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,aAAa,GAAG,IAAI,GAC3B,OAAO,CAAC,kBAAkB,CAAC,CAa7B"}

package/packages/app-core/src/services/local-inference/routing-preferences.js

@@ -0,0 +1,72 @@
+/**
+ * Per-model-type user override: "for TEXT_LARGE, prefer this provider".
+ *
+ * Persisted to `$STATE_DIR/local-inference/routing.json` and read by the
+ * router-handler (see `router-handler.ts`) to pick a provider at dispatch
+ * time. When a slot has no override, the runtime's native priority order
+ * wins — i.e. this is layered over the existing registration priority
+ * rather than replacing it.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { localInferenceRoot } from "./paths";
+export const DEFAULT_ROUTING_POLICY = "prefer-local";
+const EMPTY = { preferredProvider: {}, policy: {} };
+function routingPath() {
+    return path.join(localInferenceRoot(), "routing.json");
+}
+async function ensureRoot() {
+    await fs.mkdir(localInferenceRoot(), { recursive: true });
+}
+export async function readRoutingPreferences() {
+    try {
+        const raw = await fs.readFile(routingPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || parsed.version !== 1 || !parsed.preferences)
+            return EMPTY;
+        return {
+            preferredProvider: parsed.preferences.preferredProvider ?? {},
+            policy: parsed.preferences.policy ?? {},
+        };
+    }
+    catch {
+        return EMPTY;
+    }
+}
+export async function writeRoutingPreferences(prefs) {
+    await ensureRoot();
+    const payload = { version: 1, preferences: prefs };
+    const tmp = `${routingPath()}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+    await fs.rename(tmp, routingPath());
+}
+export async function setPreferredProvider(slot, provider) {
+    const current = await readRoutingPreferences();
+    const next = {
+        preferredProvider: { ...current.preferredProvider },
+        policy: { ...current.policy },
+    };
+    if (provider) {
+        next.preferredProvider[slot] = provider;
+    }
+    else {
+        delete next.preferredProvider[slot];
+    }
+    await writeRoutingPreferences(next);
+    return next;
+}
+export async function setPolicy(slot, policy) {
+    const current = await readRoutingPreferences();
+    const next = {
+        preferredProvider: { ...current.preferredProvider },
+        policy: { ...current.policy },
+    };
+    if (policy) {
+        next.policy[slot] = policy;
+    }
+    else {
+        delete next.policy[slot];
+    }
+    await writeRoutingPreferences(next);
+    return next;
+}

package/packages/app-core/src/services/local-inference/types.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Local inference model-management types.
+ *
+ * Shared across the service layer, API routes, and renderer.
+ * The catalog is Eliza-curated; installed models are tracked locally in a
+ * JSON registry under the state dir.
+ */
+export type ModelBucket = "small" | "mid" | "large" | "xl";
+export type ModelCategory = "chat" | "code" | "tools" | "tiny" | "reasoning";
+export interface CatalogModel {
+    /** Stable Eliza id — used as the primary key. */
+    id: string;
+    displayName: string;
+    /** HuggingFace repo slug, e.g. "bartowski/Llama-3.2-3B-Instruct-GGUF". */
+    hfRepo: string;
+    /** Exact GGUF filename in the repo. */
+    ggufFile: string;
+    params: "360M" | "1B" | "1.7B" | "3B" | "7B" | "8B" | "9B" | "14B" | "16B" | "22B" | "24B" | "27B" | "32B" | "70B";
+    quant: string;
+    sizeGb: number;
+    /** Minimum system RAM (GB) we recommend before offering this model. */
+    minRamGb: number;
+    category: ModelCategory;
+    bucket: ModelBucket;
+    blurb: string;
+}
+export type HardwareFitLevel = "fits" | "tight" | "wontfit";
+export interface HardwareProbe {
+    totalRamGb: number;
+    freeRamGb: number;
+    /** Null when no supported GPU is available (CPU-only). */
+    gpu: {
+        backend: "cuda" | "metal" | "vulkan";
+        totalVramGb: number;
+        freeVramGb: number;
+    } | null;
+    cpuCores: number;
+    platform: NodeJS.Platform;
+    arch: NodeJS.Architecture;
+    /** True on Apple Silicon (shared memory — large models are viable on 16GB+). */
+    appleSilicon: boolean;
+    /** Recommended default bucket based on available memory. */
+    recommendedBucket: ModelBucket;
+    /** Source of the probe; "node-llama-cpp" when GPU values come from the binding. */
+    source: "node-llama-cpp" | "os-fallback";
+}
+export interface InstalledModel {
+    /** Matches CatalogModel.id when installed from the curated catalog. */
+    id: string;
+    displayName: string;
+    /** Absolute path to the GGUF file on disk. */
+    path: string;
+    sizeBytes: number;
+    /** HF repo this came from, when known. */
+    hfRepo?: string;
+    /** ISO timestamp of install completion. */
+    installedAt: string;
+    /** ISO timestamp of last activation (null if never loaded). */
+    lastUsedAt: string | null;
+    /** Where we got this model from. Determines whether Eliza owns the file. */
+    source: "eliza-download" | "external-scan";
+    /**
+     * When source === "external-scan", which tool the file belonged to.
+     * Prevents Eliza from deleting files other apps own.
+     */
+    externalOrigin?: "lm-studio" | "jan" | "ollama" | "huggingface" | "text-gen-webui";
+    /** SHA256 of the GGUF file recorded at install time. Optional for legacy entries. */
+    sha256?: string;
+    /** ISO timestamp of the last successful re-verification. Absent = never verified since install. */
+    lastVerifiedAt?: string;
+}
+export type DownloadState = "queued" | "downloading" | "completed" | "failed" | "cancelled";
+export interface DownloadJob {
+    jobId: string;
+    modelId: string;
+    state: DownloadState;
+    /** Bytes transferred so far. */
+    received: number;
+    /** Total bytes expected (from Content-Length or HEAD). */
+    total: number;
+    /** Moving-average bytes/sec over the last few seconds. */
+    bytesPerSec: number;
+    /** Milliseconds remaining based on current rate. Null when unknown. */
+    etaMs: number | null;
+    startedAt: string;
+    updatedAt: string;
+    /** Set when state === "failed". */
+    error?: string;
+}
+export interface ActiveModelState {
+    modelId: string | null;
+    loadedAt: string | null;
+    /**
+     * Human-readable load status. "idle" means nothing loaded.
+     * "loading" is set while we're swapping models.
+     */
+    status: "idle" | "loading" | "ready" | "error";
+    error?: string;
+}
+export interface DownloadEvent {
+    type: "progress" | "completed" | "failed" | "cancelled";
+    job: DownloadJob;
+}
+/**
+ * Agent model-type slots Eliza lets the user wire to local models. These
+ * match the `ModelType` enum in `@elizaos/core` — kept as string literals
+ * here so the types file stays framework-free.
+ */
+export type AgentModelSlot = "TEXT_SMALL" | "TEXT_LARGE" | "TEXT_EMBEDDING" | "OBJECT_SMALL" | "OBJECT_LARGE";
+export declare const AGENT_MODEL_SLOTS: AgentModelSlot[];
+/** User-configured mapping of agent model slots → installed model ids. */
+export type ModelAssignments = Partial<Record<AgentModelSlot, string>>;
+export interface ModelHubSnapshot {
+    catalog: CatalogModel[];
+    installed: InstalledModel[];
+    active: ActiveModelState;
+    downloads: DownloadJob[];
+    hardware: HardwareProbe;
+    assignments: ModelAssignments;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/app-core/src/services/local-inference/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../app-core/src/services/local-inference/types.ts"],"names":[],"mappings":"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"}

package/packages/app-core/src/services/local-inference/types.js

@@ -0,0 +1,14 @@
+/**
+ * Local inference model-management types.
+ *
+ * Shared across the service layer, API routes, and renderer.
+ * The catalog is Eliza-curated; installed models are tracked locally in a
+ * JSON registry under the state dir.
+ */
+export const AGENT_MODEL_SLOTS = [
+    "TEXT_SMALL",
+    "TEXT_LARGE",
+    "TEXT_EMBEDDING",
+    "OBJECT_SMALL",
+    "OBJECT_LARGE",
+];

package/packages/app-core/src/services/local-inference/verify.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Model-file integrity verification.
+ *
+ * GGUF files are large (0.8 – 20 GB). Corrupted files surface as cryptic
+ * llama.cpp errors much later, so we verify at install time and expose a
+ * manual verify button for users who want to re-check after a system
+ * event (crash, disk fill, external tool edited the file, etc).
+ *
+ * We don't require SHA256 from HuggingFace — HF doesn't publish per-file
+ * hashes in the standard API, and hand-curating them in the catalog would
+ * drift. Instead, after a successful download we compute the SHA256
+ * ourselves and stash it on the InstalledModel. Re-verify compares the
+ * file's current hash against the stashed one. A mismatch means the file
+ * changed on disk since we installed it — user can redownload.
+ *
+ * For GGUF specifically we also do a cheap structural header check
+ * (the file starts with the magic bytes "GGUF") so obvious truncations
+ * flag instantly without having to hash a 10GB file.
+ */
+import type { InstalledModel } from "./types";
+export type VerifyState = "unknown" | "ok" | "mismatch" | "missing" | "truncated";
+export interface VerifyResult {
+    state: VerifyState;
+    /** SHA256 hex of the file as it exists now. Absent when file missing. */
+    currentSha256: string | null;
+    /** Hash from the registry, when available. */
+    expectedSha256: string | null;
+    /** Size read from the filesystem. */
+    currentBytes: number | null;
+}
+export declare function hashFile(path: string): Promise<string>;
+/**
+ * Run the full verification pipeline on a model. Returns the state and
+ * the freshly computed hash so the caller can persist it to the registry.
+ */
+export declare function verifyInstalledModel(model: InstalledModel): Promise<VerifyResult>;
+/** Helper for tests — no runtime use. */
+export declare function __registryPathForTests(): string;
+//# sourceMappingURL=verify.d.ts.map

package/packages/app-core/src/services/local-inference/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../../../../../app-core/src/services/local-inference/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,MAAM,WAAW,GACnB,SAAS,GACT,IAAI,GACJ,UAAU,GACV,SAAS,GACT,WAAW,CAAC;AAEhB,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,WAAW,CAAC;IACnB,yEAAyE;IACzE,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,8CAA8C;IAC9C,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,qCAAqC;IACrC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AA4BD,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAU5D;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,cAAc,GACpB,OAAO,CAAC,YAAY,CAAC,CAmCvB;AAED,yCAAyC;AACzC,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C"}

package/packages/app-core/src/services/local-inference/verify.js

@@ -0,0 +1,104 @@
+/**
+ * Model-file integrity verification.
+ *
+ * GGUF files are large (0.8 – 20 GB). Corrupted files surface as cryptic
+ * llama.cpp errors much later, so we verify at install time and expose a
+ * manual verify button for users who want to re-check after a system
+ * event (crash, disk fill, external tool edited the file, etc).
+ *
+ * We don't require SHA256 from HuggingFace — HF doesn't publish per-file
+ * hashes in the standard API, and hand-curating them in the catalog would
+ * drift. Instead, after a successful download we compute the SHA256
+ * ourselves and stash it on the InstalledModel. Re-verify compares the
+ * file's current hash against the stashed one. A mismatch means the file
+ * changed on disk since we installed it — user can redownload.
+ *
+ * For GGUF specifically we also do a cheap structural header check
+ * (the file starts with the magic bytes "GGUF") so obvious truncations
+ * flag instantly without having to hash a 10GB file.
+ */
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import { registryPath } from "./paths";
+const GGUF_MAGIC = Buffer.from("GGUF", "ascii");
+async function fileExists(path) {
+    try {
+        const stat = await fsp.stat(path);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function isGgufHeader(path) {
+    try {
+        const fd = await fsp.open(path, "r");
+        try {
+            const buf = Buffer.alloc(4);
+            await fd.read(buf, 0, 4, 0);
+            return buf.equals(GGUF_MAGIC);
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    catch {
+        return false;
+    }
+}
+export async function hashFile(path) {
+    return new Promise((resolve, reject) => {
+        const hasher = createHash("sha256");
+        const stream = fs.createReadStream(path, { highWaterMark: 1 << 20 });
+        stream.on("data", (chunk) => {
+            hasher.update(chunk);
+        });
+        stream.on("end", () => resolve(hasher.digest("hex")));
+        stream.on("error", reject);
+    });
+}
+/**
+ * Run the full verification pipeline on a model. Returns the state and
+ * the freshly computed hash so the caller can persist it to the registry.
+ */
+export async function verifyInstalledModel(model) {
+    if (!(await fileExists(model.path))) {
+        return {
+            state: "missing",
+            currentSha256: null,
+            expectedSha256: model.sha256 ?? null,
+            currentBytes: null,
+        };
+    }
+    const stat = await fsp.stat(model.path);
+    if (!(await isGgufHeader(model.path))) {
+        return {
+            state: "truncated",
+            currentSha256: null,
+            expectedSha256: model.sha256 ?? null,
+            currentBytes: stat.size,
+        };
+    }
+    const currentSha256 = await hashFile(model.path);
+    if (!model.sha256) {
+        // First-time verification — no baseline to compare against. Caller
+        // decides whether to treat this as "ok" and persist the hash.
+        return {
+            state: "unknown",
+            currentSha256,
+            expectedSha256: null,
+            currentBytes: stat.size,
+        };
+    }
+    return {
+        state: currentSha256 === model.sha256 ? "ok" : "mismatch",
+        currentSha256,
+        expectedSha256: model.sha256,
+        currentBytes: stat.size,
+    };
+}
+/** Helper for tests — no runtime use. */
+export function __registryPathForTests() {
+    return registryPath();
+}

package/packages/app-core/src/services/vault-bootstrap.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Boot-time secret hydration: walk known plaintext sources, push sensitive
+ * values to the shared vault, and rewrite the on-disk plaintext to
+ * `vault://<KEY>` sentinels.
+ *
+ * Sources (in order):
+ *   1. eliza.json `env[KEY]` and `env.vars[KEY]`
+ *   2. `<stateDir>/config.env`
+ *   3. eliza.json `plugins.entries[<id>].config[KEY]`
+ *   4. `process.env[KEY]` for keys flagged sensitive in any registered plugin
+ *      (does not mutate process.env — only mirrors to the vault).
+ *
+ * Idempotent: a hydration marker at `<stateDir>/.vault-hydrated.json`
+ * keeps re-runs cheap once a clean migration has completed. Per-key
+ * failures are isolated; if every write fails the function throws.
+ */
+import type { Vault } from "@elizaos/vault";
+export interface VaultBootstrapResult {
+    migrated: number;
+    alreadyHydrated: number;
+    failed: string[];
+}
+interface VaultBootstrapOptions {
+    configPath?: string;
+    stateDir?: string;
+    /** Test seam — defaults to `sharedVault()`. */
+    vault?: Vault;
+}
+export declare function runVaultBootstrap(opts?: VaultBootstrapOptions): Promise<VaultBootstrapResult>;
+export {};
+//# sourceMappingURL=vault-bootstrap.d.ts.map

package/packages/app-core/src/services/vault-bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault-bootstrap.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/services/vault-bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAgBH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAe5C,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,UAAU,qBAAqB;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AA+MD,wBAAsB,iBAAiB,CACrC,IAAI,GAAE,qBAA0B,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAgE/B"}