@elizaos/app-core 2.0.0-beta.3 → 2.0.11-beta.5

package/runtime/mobile-safe-runtime.js

@@ -1,3 +1,4 @@
+import { formatError } from "@elizaos/shared";
 export function detectMobileSafeRuntimeFeatures(probe = {}) {
     const globals = probe.globals ?? globalThisAsRecord();
     const env = probe.env ?? {};
@@ -7,10 +8,38 @@ export function detectMobileSafeRuntimeFeatures(probe = {}) {
     const supportsSharedArrayBuffer = typeof globals.SharedArrayBuffer === "function";
     const hasNodeRuntime = typeof globals.process === "object";
     const hasBunRuntime = typeof globals.Bun === "object";
+    const androidAvfMicrodroid = resolveAndroidAvfMicrodroidStatus(platform, probe, env, globals);
+    const androidIsolatedProcessAvailable = probe.androidIsolatedProcessAvailable === true ||
+        env.ELIZA_ANDROID_ISOLATED_PROCESS_AVAILABLE === "1" ||
+        readBooleanGlobal(globals.AndroidIsolatedProcess, "available") === true ||
+        readBooleanGlobal(globals.MobileSafeRuntimeService, "available") === true;
+    const iosJavaScriptCoreAvailable = probe.iosJavaScriptCoreAvailable === true ||
+        env.ELIZA_IOS_JAVASCRIPTCORE_AVAILABLE === "1" ||
+        readBooleanGlobal(globals.CapacitorJsc, "available") === true ||
+        readBooleanGlobal(globals.JavaScriptCoreBoundary, "available") === true;
+    const iosQuickJsAvailable = probe.iosQuickJsAvailable === true ||
+        env.ELIZA_IOS_QUICKJS_AVAILABLE === "1" ||
+        readBooleanGlobal(globals.CapacitorQuickJs, "available") === true ||
+        readBooleanGlobal(globals.QuickJsBoundary, "available") === true;
+    const safeJsAppletAllowed = probe.allowInProcessSafeJsApplet === true ||
+        env.ELIZA_MOBILE_SAFE_JS_APPLET_DEV === "1";
     const unavailableProviders = {};
     const availableProviders = [];
     if (platform === "ios") {
-        availableProviders.push("javascriptcore", "quickjs");
+        if (iosJavaScriptCoreAvailable) {
+            availableProviders.push("javascriptcore");
+        }
+        else {
+            unavailableProviders.javascriptcore =
+                "iOS JavaScriptCore boundary is not attached in this app shell";
+        }
+        if (iosQuickJsAvailable) {
+            availableProviders.push("quickjs");
+        }
+        else {
+            unavailableProviders.quickjs =
+                "iOS QuickJS boundary is not attached in this app shell";
+        }
     }
     else {
         unavailableProviders.javascriptcore =
@@ -19,9 +48,25 @@ export function detectMobileSafeRuntimeFeatures(probe = {}) {
             "QuickJS host boundary is only available in the iOS app shell";
     }
     if (platform === "android") {
-        availableProviders.push("android-isolated-process");
+        if (androidAvfMicrodroid.available) {
+            availableProviders.push("android-avf-microdroid");
+        }
+        else {
+            unavailableProviders["android-avf-microdroid"] =
+                androidAvfMicrodroid.reason ??
+                    "Android AVF/Microdroid boundary is not available on this device/build";
+        }
+        if (androidIsolatedProcessAvailable) {
+            availableProviders.push("android-isolated-process");
+        }
+        else {
+            unavailableProviders["android-isolated-process"] =
+                "Android isolated-process boundary is not attached in this app shell";
+        }
     }
     else {
+        unavailableProviders["android-avf-microdroid"] =
+            "Android AVF/Microdroid boundary is only available in supported Android app shells";
         unavailableProviders["android-isolated-process"] =
             "Android isolated-process boundary is only available in the Android app shell";
     }
@@ -32,6 +77,14 @@ export function detectMobileSafeRuntimeFeatures(probe = {}) {
         unavailableProviders.wasm =
             "WebAssembly is not exposed by this host runtime";
     }
+    if (safeJsAppletAllowed && typeof globals.Function === "function") {
+        availableProviders.push("safe-js-applet");
+    }
+    else {
+        unavailableProviders["safe-js-applet"] = safeJsAppletAllowed
+            ? "This host runtime does not expose JavaScript evaluation for applet fallback"
+            : "In-process safe-js applet fallback is dev-only and is not a hard sandbox";
+    }
     return {
         platform,
         supportsWebAssembly,
@@ -41,6 +94,53 @@ export function detectMobileSafeRuntimeFeatures(probe = {}) {
         hasBunRuntime,
         availableProviders,
         unavailableProviders,
+        androidAvfMicrodroid,
+    };
+}
+export function createAndroidAvfMicrodroidProvider(boundary) {
+    if (!boundary) {
+        return createUnavailableMobileSafeRuntimeProvider("android-avf-microdroid", "Android AVF/Microdroid boundary is not attached");
+    }
+    if (boundary.capabilityState !== undefined &&
+        boundary.capabilityState !== "ready") {
+        return createUnavailableMobileSafeRuntimeProvider("android-avf-microdroid", boundary.reason ?? androidAvfMicrodroidReason(boundary.capabilityState));
+    }
+    return {
+        kind: "android-avf-microdroid",
+        displayName: "Android AVF/Microdroid",
+        supported: true,
+        async execute(input) {
+            const response = await boundary.request({
+                id: cryptoRequestId(),
+                capability: capabilityForExecuteMode(input.mode),
+                operation: "execute",
+                args: {
+                    code: input.code,
+                    entrypoint: input.entrypoint,
+                    env: input.env ?? {},
+                    mode: input.mode ?? "evaluate",
+                    applet: input.applet ?? {},
+                    virtualFileSystem: {
+                        attached: Boolean(input.files),
+                        transport: input.broker
+                            ? "mobile-safe-capability-broker"
+                            : input.files
+                                ? "host-vfs"
+                                : "none",
+                    },
+                },
+            });
+            if (response.ok === true)
+                return { ok: true, value: response.result };
+            return {
+                ok: false,
+                error: {
+                    code: response.error.code,
+                    message: response.error.message,
+                    provider: "android-avf-microdroid",
+                },
+            };
+        },
     };
 }
 export function createUnavailableMobileSafeRuntimeProvider(kind, reason) {
@@ -100,6 +200,156 @@ export function createIosQuickJsProvider(boundary) {
         },
     };
 }
+export function createInProcessSafeJsAppletProvider(options = {}) {
+    return {
+        kind: "safe-js-applet",
+        displayName: "In-process safe JS applet",
+        supported: typeof Function === "function",
+        reason: typeof Function === "function"
+            ? undefined
+            : "This host runtime does not expose JavaScript evaluation",
+        async execute(input) {
+            try {
+                if (input.mode === "shell") {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "MOBILE_SAFE_SHELL_UNSUPPORTED",
+                            message: "The in-process applet provider never executes host shell commands",
+                            provider: "safe-js-applet",
+                        },
+                    };
+                }
+                if (input.mode === "compile-app") {
+                    if (!input.files) {
+                        return {
+                            ok: false,
+                            error: {
+                                code: "MOBILE_SAFE_APPLET_VFS_REQUIRED",
+                                message: "compile-app requires a mobile-safe VFS",
+                                provider: "safe-js-applet",
+                            },
+                        };
+                    }
+                    const manifest = input.code.trim().length > 0
+                        ? parseMobileSafeAppletManifest(input.code)
+                        : undefined;
+                    const compiled = await compileMobileSafeApplet({
+                        files: input.files,
+                        manifest,
+                        manifestPath: input.applet?.manifestPath,
+                        appRoot: input.applet?.appRoot,
+                        outputPath: input.applet?.bundlePath,
+                    });
+                    return { ok: true, value: compiled };
+                }
+                if (input.mode === "load-app") {
+                    if (!input.files) {
+                        return {
+                            ok: false,
+                            error: {
+                                code: "MOBILE_SAFE_APPLET_VFS_REQUIRED",
+                                message: "load-app requires a mobile-safe VFS",
+                                provider: "safe-js-applet",
+                            },
+                        };
+                    }
+                    return {
+                        ok: true,
+                        value: await loadMobileSafeApplet({
+                            files: input.files,
+                            manifestPath: input.applet?.manifestPath,
+                        }),
+                    };
+                }
+                const logs = [];
+                const bundle = input.mode === "run-app" && input.files && input.applet?.manifestPath
+                    ? (await loadMobileSafeApplet({
+                        files: input.files,
+                        manifestPath: input.applet.manifestPath,
+                    })).bundle
+                    : input.code;
+                assertMobileSafeAppletSource(bundle, "bundle");
+                const api = await createSafeAppletApi({
+                    files: input.files,
+                    broker: input.broker,
+                    env: input.env,
+                    logs,
+                    now: options.now,
+                });
+                const runner = new Function("input", "api", "globalThis", "window", "self", "process", "Bun", "Deno", "require", "module", "exports", `"use strict";\n${bundle}\nreturn __mobileSafeApplet(input, api);`);
+                const value = await runner(input.applet?.input, api, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+                return { ok: true, value, logs };
+            }
+            catch (error) {
+                return {
+                    ...providerFailure("safe-js-applet", error),
+                    logs: [],
+                };
+            }
+        },
+    };
+}
+export async function writeMobileSafeAppletManifest(files, manifest, manifestPath = "/app/mobile-safe-applet.json") {
+    const normalizedManifest = normalizeMobileSafeAppletManifest(manifest);
+    await files.writeFile(manifestPath, new TextEncoder().encode(JSON.stringify(normalizedManifest, null, 2)));
+    return normalizedManifest;
+}
+export async function readMobileSafeAppletManifest(files, manifestPath = "/app/mobile-safe-applet.json") {
+    return normalizeMobileSafeAppletManifest(parseMobileSafeAppletManifest(new TextDecoder().decode(await files.readFile(manifestPath))));
+}
+export async function compileMobileSafeApplet(options) {
+    const appRoot = normalizeMobileSafePath(options.appRoot ?? "/app");
+    const manifestPath = normalizeMobileSafePath(options.manifestPath ?? "/app/mobile-safe-applet.json");
+    const manifest = normalizeMobileSafeAppletManifest(options.manifest ??
+        (await readMobileSafeAppletManifest(options.files, manifestPath)));
+    const appFiles = normalizeMobileSafeAppletFiles(manifest, appRoot);
+    const modules = [];
+    for (const filePath of appFiles) {
+        const source = new TextDecoder().decode(await options.files.readFile(filePath));
+        const compiledSource = manifest.moduleFormat === "typescript" || filePath.endsWith(".ts")
+            ? stripMobileSafeTypeScript(source)
+            : source;
+        assertMobileSafeAppletSource(compiledSource, filePath);
+        modules.push({
+            path: filePath,
+            source: compiledSource,
+        });
+    }
+    const sourceHash = mobileSafeStableHash(modules.map((module) => `${module.path}\n${module.source}`).join("\n---\n"));
+    const bundlePath = normalizeMobileSafePath(options.outputPath ?? `${appRoot}/.mobile-safe/${manifest.id}.bundle.js`);
+    const compiledManifest = {
+        ...manifest,
+        runtime: "mobile-safe-js",
+        compiled: {
+            bundlePath,
+            compiledAt: Date.now(),
+            sourceHash,
+            files: appFiles,
+        },
+    };
+    const bundle = createMobileSafeAppletBundle(compiledManifest, modules);
+    await options.files.mkdir(parentPath(bundlePath));
+    await options.files.writeFile(bundlePath, new TextEncoder().encode(bundle));
+    await writeMobileSafeAppletManifest(options.files, compiledManifest, manifestPath);
+    return {
+        manifestPath,
+        bundlePath,
+        manifest: compiledManifest,
+        sourceHash,
+        files: appFiles,
+    };
+}
+export async function loadMobileSafeApplet(options) {
+    const manifestPath = normalizeMobileSafePath(options.manifestPath ?? "/app/mobile-safe-applet.json");
+    const manifest = await readMobileSafeAppletManifest(options.files, manifestPath);
+    const bundlePath = manifest.compiled?.bundlePath
+        ? normalizeMobileSafePath(manifest.compiled.bundlePath)
+        : normalizeMobileSafePath(`${parentPath(manifestPath)}/.mobile-safe/${manifest.id}.bundle.js`);
+    const bundle = new TextDecoder().decode(await options.files.readFile(bundlePath));
+    assertMobileSafeAppletSource(bundle, bundlePath);
+    return { manifestPath, bundlePath, manifest, bundle };
+}
 export function createAndroidIsolatedProcessHook(options = {}) {
     return {
         serviceName: options.serviceName ?? "ai.elizaos.app.MobileSafeRuntimeService",
@@ -121,7 +371,7 @@ export function createAndroidIsolatedProcessProvider(boundary) {
         async execute(input) {
             const response = await boundary.request({
                 id: cryptoRequestId(),
-                capability: "model.inference",
+                capability: capabilityForExecuteMode(input.mode),
                 operation: "execute",
                 args: {
                     code: input.code,
@@ -129,7 +379,7 @@ export function createAndroidIsolatedProcessProvider(boundary) {
                     env: input.env ?? {},
                 },
             });
-            if (response.ok)
+            if (response.ok === true)
                 return { ok: true, value: response.result };
             return {
                 ok: false,
@@ -155,7 +405,7 @@ export function createMobileSafeCapabilityBroker(handler) {
                     ok: false,
                     error: {
                         code: "MOBILE_SAFE_CAPABILITY_FAILED",
-                        message: error instanceof Error ? error.message : String(error),
+                        message: formatError(error),
                         retryable: false,
                     },
                 };
@@ -163,23 +413,213 @@ export function createMobileSafeCapabilityBroker(handler) {
         },
     };
 }
+export function createMobileSafeVirtualFileSystemBroker(files) {
+    return createMobileSafeCapabilityBroker(async (request) => {
+        const path = typeof request.args.path === "string"
+            ? request.args.path
+            : typeof request.args.target === "string"
+                ? request.args.target
+                : "/";
+        switch (request.capability) {
+            case "fs.read":
+                return {
+                    id: request.id,
+                    ok: true,
+                    result: await files.readFile(path),
+                };
+            case "fs.write": {
+                const raw = request.args.data ?? request.args.content;
+                const data = raw instanceof Uint8Array
+                    ? raw
+                    : new TextEncoder().encode(typeof raw === "string" ? raw : JSON.stringify(raw ?? ""));
+                await files.writeFile(path, data);
+                return { id: request.id, ok: true, result: { path } };
+            }
+            case "fs.delete":
+                await files.delete(path);
+                return { id: request.id, ok: true, result: { path } };
+            case "fs.mkdir":
+                await files.mkdir(path);
+                return { id: request.id, ok: true, result: { path } };
+            case "fs.stat":
+                return { id: request.id, ok: true, result: await files.stat(path) };
+            case "fs.list":
+                return { id: request.id, ok: true, result: await files.list(path) };
+            case "fs.snapshot":
+                if (!files.createSnapshot) {
+                    return unsupportedCapability(request, "VFS snapshots are unavailable");
+                }
+                return {
+                    id: request.id,
+                    ok: true,
+                    result: await files.createSnapshot(typeof request.args.note === "string"
+                        ? request.args.note
+                        : undefined),
+                };
+            case "fs.diff":
+                if (!files.diffCurrent) {
+                    return unsupportedCapability(request, "VFS diffs are unavailable");
+                }
+                if (typeof request.args.snapshotId !== "string") {
+                    return unsupportedCapability(request, "snapshotId is required");
+                }
+                return {
+                    id: request.id,
+                    ok: true,
+                    result: await files.diffCurrent(request.args.snapshotId),
+                };
+            case "fs.rollback":
+                if (!files.rollback) {
+                    return unsupportedCapability(request, "VFS rollback is unavailable");
+                }
+                if (typeof request.args.snapshotId !== "string") {
+                    return unsupportedCapability(request, "snapshotId is required");
+                }
+                await files.rollback(request.args.snapshotId);
+                return { id: request.id, ok: true, result: { rolledBack: true } };
+            case "fs.quota":
+                if (!files.quota) {
+                    return unsupportedCapability(request, "VFS quota is unavailable");
+                }
+                return { id: request.id, ok: true, result: await files.quota() };
+            default:
+                return unsupportedCapability(request, `Unsupported mobile-safe VFS capability: ${request.capability}`);
+        }
+    });
+}
+export function createMobileSafeVirtualFileSystemAdapter(vfs) {
+    return {
+        async readFile(path) {
+            if (vfs.readFileBytes) {
+                return new Uint8Array(await vfs.readFileBytes(path));
+            }
+            if (vfs.readFile) {
+                return new TextEncoder().encode(await vfs.readFile(path));
+            }
+            throw new Error("Wrapped VFS does not support readFile");
+        },
+        async writeFile(path, data) {
+            await vfs.writeFile(path, data);
+        },
+        async delete(path) {
+            if (!vfs.delete)
+                throw new Error("Wrapped VFS does not support delete");
+            await vfs.delete(path, { recursive: true });
+        },
+        async mkdir(_path) {
+            // The agent VFS creates parent directories on write and intentionally does
+            // not expose empty directory creation as a primitive.
+        },
+        async stat(path) {
+            if (!vfs.list)
+                return null;
+            if (normalizeMobileSafePath(path) === "/") {
+                return { path: "/", kind: "directory", size: 0 };
+            }
+            const parent = parentPath(path);
+            const entries = await vfs.list(parent === "/" ? "." : parent);
+            const normalized = normalizeMobileSafePath(path);
+            const match = entries.find((entry) => normalizeMobileSafePath(entry.path) === normalized);
+            return match ? toMobileSafeFileInfo(match) : null;
+        },
+        async list(path) {
+            if (!vfs.list)
+                return [];
+            const entries = await vfs.list(path === "/" ? "." : path);
+            return entries.map(toMobileSafeFileInfo);
+        },
+        createSnapshot: vfs.createSnapshot
+            ? async (note) => toMobileSafeSnapshot(await vfs.createSnapshot?.(note))
+            : undefined,
+        diffCurrent: vfs.diffCurrent
+            ? async (snapshotId) => (await vfs.diffCurrent?.(snapshotId))?.map((entry) => ({
+                path: normalizeMobileSafePath(entry.path),
+                status: entry.status,
+                ...(entry.before
+                    ? { before: toMobileSafeFileInfo(entry.before) }
+                    : {}),
+                ...(entry.after
+                    ? { after: toMobileSafeFileInfo(entry.after) }
+                    : {}),
+            })) ?? []
+            : undefined,
+        rollback: vfs.rollback
+            ? async (snapshotId) => {
+                await vfs.rollback?.(snapshotId);
+            }
+            : undefined,
+        quota: async () => {
+            if (vfs.quota) {
+                return vfs.quota();
+            }
+            if (vfs.list) {
+                const entries = await vfs.list(".", { recursive: true });
+                const files = entries.filter((entry) => (entry.kind ?? entry.type) === "file");
+                return {
+                    usedBytes: files.reduce((sum, entry) => sum + entry.size, 0),
+                    fileCount: files.length,
+                    ...(typeof vfs.quotaBytes === "number"
+                        ? { quotaBytes: vfs.quotaBytes }
+                        : {}),
+                    ...(typeof vfs.maxFileBytes === "number"
+                        ? { maxFileBytes: vfs.maxFileBytes }
+                        : {}),
+                };
+            }
+            return {
+                usedBytes: 0,
+                fileCount: 0,
+                ...(typeof vfs.quotaBytes === "number"
+                    ? { quotaBytes: vfs.quotaBytes }
+                    : {}),
+                ...(typeof vfs.maxFileBytes === "number"
+                    ? { maxFileBytes: vfs.maxFileBytes }
+                    : {}),
+            };
+        },
+    };
+}
+export function selectMobileSafeRuntimeProvider(options) {
+    const order = options.preferredOrder ??
+        defaultProviderOrderForPlatform(options.features.platform);
+    const available = new Set(options.features.availableProviders);
+    for (const kind of order) {
+        const provider = options.providers[kind];
+        if (provider?.supported && available.has(kind)) {
+            return provider;
+        }
+    }
+    return createUnavailableMobileSafeRuntimeProvider(order[0] ?? "wasm", "No supported mobile-safe runtime provider is attached");
+}
 export function normalizeMobileSafePath(path) {
+    if (typeof path !== "string" || path.includes("\0")) {
+        throw new Error("Invalid mobile-safe VFS path");
+    }
+    const rawParts = path.replaceAll("\\", "/").split("/");
+    if (rawParts.some((part) => part === "..")) {
+        throw new Error("Path traversal segments are not allowed");
+    }
     const normalized = path
         .replaceAll("\\", "/")
         .split("/")
         .filter((part) => part.length > 0 && part !== ".")
         .reduce((parts, part) => {
-        if (part === "..")
-            parts.pop();
-        else
-            parts.push(part);
+        parts.push(part);
         return parts;
     }, []);
     return `/${normalized.join("/")}`;
 }
 export class MemoryMobileSafeVirtualFileSystem {
+    quotaBytes;
+    maxFileBytes;
     files = new Map();
     directories = new Set(["/"]);
+    snapshots = new Map();
+    snapshotCounter = 0;
+    constructor(options = {}) {
+        this.quotaBytes = options.quotaBytes;
+        this.maxFileBytes = options.maxFileBytes;
+    }
     async readFile(path) {
         const entry = this.files.get(normalizeMobileSafePath(path));
         if (!entry)
@@ -188,7 +628,18 @@ export class MemoryMobileSafeVirtualFileSystem {
     }
     async writeFile(path, data) {
         const normalized = normalizeMobileSafePath(path);
-        this.directories.add(parentPath(normalized));
+        if (typeof this.maxFileBytes === "number" &&
+            data.byteLength > this.maxFileBytes) {
+            throw new Error(`Mobile-safe VFS file exceeds max file size of ${this.maxFileBytes} bytes`);
+        }
+        const existing = this.files.get(normalized)?.data.byteLength ?? 0;
+        const current = await this.usedBytes();
+        const nextUsedBytes = current - existing + data.byteLength;
+        if (typeof this.quotaBytes === "number" &&
+            nextUsedBytes > this.quotaBytes) {
+            throw new Error(`Mobile-safe VFS quota exceeded: ${nextUsedBytes}/${this.quotaBytes} bytes`);
+        }
+        this.ensureDirectoryPath(parentPath(normalized));
         this.files.set(normalized, {
             data: new Uint8Array(data),
             updatedAt: Date.now(),
@@ -196,11 +647,27 @@ export class MemoryMobileSafeVirtualFileSystem {
     }
     async delete(path) {
         const normalized = normalizeMobileSafePath(path);
+        if (normalized === "/") {
+            this.files.clear();
+            this.directories.clear();
+            this.directories.add("/");
+            return;
+        }
         this.files.delete(normalized);
+        for (const filePath of [...this.files.keys()]) {
+            if (filePath.startsWith(`${normalized}/`)) {
+                this.files.delete(filePath);
+            }
+        }
         this.directories.delete(normalized);
+        for (const directory of [...this.directories]) {
+            if (directory.startsWith(`${normalized}/`)) {
+                this.directories.delete(directory);
+            }
+        }
     }
     async mkdir(path) {
-        this.directories.add(normalizeMobileSafePath(path));
+        this.ensureDirectoryPath(normalizeMobileSafePath(path));
     }
     async stat(path) {
         const normalized = normalizeMobileSafePath(path);
@@ -238,6 +705,386 @@ export class MemoryMobileSafeVirtualFileSystem {
         }
         return entries.sort((left, right) => left.path.localeCompare(right.path));
     }
+    async createSnapshot(note) {
+        const { usedBytes, fileCount } = await this.quota();
+        const id = `mobile-safe-${Date.now()}-${++this.snapshotCounter}`;
+        const meta = {
+            id,
+            createdAt: Date.now(),
+            ...(note ? { note } : {}),
+            filesBytes: usedBytes,
+            fileCount,
+        };
+        const files = new Map();
+        for (const [filePath, entry] of this.files) {
+            files.set(filePath, {
+                data: new Uint8Array(entry.data),
+                updatedAt: entry.updatedAt,
+            });
+        }
+        this.snapshots.set(id, {
+            meta,
+            files,
+            directories: new Set(this.directories),
+        });
+        return meta;
+    }
+    async diffCurrent(snapshotId) {
+        const snapshot = this.snapshots.get(snapshotId);
+        if (!snapshot)
+            throw new Error(`Snapshot not found: ${snapshotId}`);
+        return diffFileMaps(snapshot.files, this.files);
+    }
+    async rollback(snapshotId) {
+        const snapshot = this.snapshots.get(snapshotId);
+        if (!snapshot)
+            throw new Error(`Snapshot not found: ${snapshotId}`);
+        this.files.clear();
+        for (const [filePath, entry] of snapshot.files) {
+            this.files.set(filePath, {
+                data: new Uint8Array(entry.data),
+                updatedAt: entry.updatedAt,
+            });
+        }
+        this.directories.clear();
+        for (const directory of snapshot.directories) {
+            this.directories.add(directory);
+        }
+    }
+    async quota() {
+        return {
+            usedBytes: await this.usedBytes(),
+            fileCount: this.files.size,
+            ...(typeof this.quotaBytes === "number"
+                ? { quotaBytes: this.quotaBytes }
+                : {}),
+            ...(typeof this.maxFileBytes === "number"
+                ? { maxFileBytes: this.maxFileBytes }
+                : {}),
+        };
+    }
+    async usedBytes() {
+        let usedBytes = 0;
+        for (const entry of this.files.values()) {
+            usedBytes += entry.data.byteLength;
+        }
+        return usedBytes;
+    }
+    ensureDirectoryPath(path) {
+        const normalized = normalizeMobileSafePath(path);
+        if (normalized === "/") {
+            this.directories.add("/");
+            return;
+        }
+        const parts = normalized.slice(1).split("/");
+        let current = "";
+        for (const part of parts) {
+            current = `${current}/${part}`;
+            this.directories.add(current);
+        }
+    }
+}
+function diffFileMaps(before, after) {
+    const paths = new Set([...before.keys(), ...after.keys()]);
+    const entries = [];
+    for (const filePath of [...paths].sort((left, right) => left.localeCompare(right))) {
+        const beforeEntry = before.get(filePath);
+        const afterEntry = after.get(filePath);
+        if (!beforeEntry && afterEntry) {
+            entries.push({
+                path: filePath,
+                status: "added",
+                after: fileInfo(filePath, afterEntry),
+            });
+            continue;
+        }
+        if (beforeEntry && !afterEntry) {
+            entries.push({
+                path: filePath,
+                status: "deleted",
+                before: fileInfo(filePath, beforeEntry),
+            });
+            continue;
+        }
+        if (beforeEntry &&
+            afterEntry &&
+            !sameBytes(beforeEntry.data, afterEntry.data)) {
+            entries.push({
+                path: filePath,
+                status: "modified",
+                before: fileInfo(filePath, beforeEntry),
+                after: fileInfo(filePath, afterEntry),
+            });
+        }
+    }
+    return entries;
+}
+function fileInfo(path, entry) {
+    return {
+        path,
+        kind: "file",
+        size: entry.data.byteLength,
+        updatedAt: entry.updatedAt,
+    };
+}
+function toMobileSafeFileInfo(entry) {
+    return {
+        path: normalizeMobileSafePath(entry.path),
+        kind: entry.kind ?? entry.type ?? "file",
+        size: entry.size,
+        updatedAt: entry.updatedAt ?? entry.mtimeMs,
+    };
+}
+function toMobileSafeSnapshot(snapshot) {
+    if (!snapshot)
+        throw new Error("Wrapped VFS did not return a snapshot");
+    const createdAt = typeof snapshot.createdAt === "string"
+        ? Date.parse(snapshot.createdAt)
+        : snapshot.createdAt;
+    return {
+        id: snapshot.id,
+        createdAt: Number.isFinite(createdAt) ? Number(createdAt) : Date.now(),
+        ...(snapshot.note ? { note: snapshot.note } : {}),
+        filesBytes: snapshot.filesBytes,
+        fileCount: snapshot.fileCount,
+    };
+}
+function parseMobileSafeAppletManifest(raw) {
+    const parsed = JSON.parse(raw);
+    return normalizeMobileSafeAppletManifest(parsed);
+}
+function normalizeMobileSafeAppletManifest(manifest) {
+    if (!manifest || typeof manifest !== "object") {
+        throw new Error("Mobile-safe applet manifest is required");
+    }
+    if (typeof manifest.id !== "string" ||
+        !/^[A-Za-z0-9_.:-]{1,96}$/.test(manifest.id)) {
+        throw new Error("Mobile-safe applet manifest id is invalid");
+    }
+    if (typeof manifest.version !== "string" || manifest.version.length === 0) {
+        throw new Error("Mobile-safe applet manifest version is required");
+    }
+    if (typeof manifest.entrypoint !== "string" ||
+        manifest.entrypoint.length === 0) {
+        throw new Error("Mobile-safe applet manifest entrypoint is required");
+    }
+    if (manifest.runtime && manifest.runtime !== "mobile-safe-js") {
+        throw new Error("Only mobile-safe-js applet manifests are supported");
+    }
+    if (manifest.moduleFormat &&
+        manifest.moduleFormat !== "javascript" &&
+        manifest.moduleFormat !== "typescript") {
+        throw new Error("Unsupported mobile-safe applet module format");
+    }
+    for (const permission of manifest.permissions ?? []) {
+        if (permission === "shell.exec") {
+            throw new Error("Mobile-safe applets cannot request shell.exec");
+        }
+    }
+    return {
+        ...manifest,
+        runtime: manifest.runtime ?? "mobile-safe-js",
+        moduleFormat: manifest.moduleFormat ?? "javascript",
+        entrypoint: normalizeMobileSafePath(manifest.entrypoint),
+        files: manifest.files?.map(normalizeMobileSafePath),
+        permissions: [...(manifest.permissions ?? [])],
+        env: { ...(manifest.env ?? {}) },
+        ...(manifest.compiled
+            ? {
+                compiled: {
+                    bundlePath: normalizeMobileSafePath(manifest.compiled.bundlePath),
+                    compiledAt: manifest.compiled.compiledAt,
+                    sourceHash: manifest.compiled.sourceHash,
+                    files: manifest.compiled.files.map(normalizeMobileSafePath),
+                },
+            }
+            : {}),
+    };
+}
+function normalizeMobileSafeAppletFiles(manifest, appRoot) {
+    const entrypoint = resolveMobileSafeAppletPath(appRoot, manifest.entrypoint);
+    const paths = new Set([entrypoint]);
+    for (const filePath of manifest.files ?? []) {
+        paths.add(resolveMobileSafeAppletPath(appRoot, filePath));
+    }
+    return [...paths].sort((left, right) => {
+        if (left === entrypoint)
+            return -1;
+        if (right === entrypoint)
+            return 1;
+        return left.localeCompare(right);
+    });
+}
+function resolveMobileSafeAppletPath(appRoot, path) {
+    const normalized = normalizeMobileSafePath(path);
+    if (normalized === appRoot || normalized.startsWith(`${appRoot}/`)) {
+        return normalized;
+    }
+    return normalizeMobileSafePath(`${appRoot}/${normalized.slice(1)}`);
+}
+function createMobileSafeAppletBundle(manifest, modules) {
+    const entrypoint = manifest.compiled?.files[0] ?? manifest.entrypoint;
+    const module = modules.find((candidate) => candidate.path === entrypoint);
+    if (!module) {
+        throw new Error(`Applet entrypoint not found in bundle: ${entrypoint}`);
+    }
+    const transformedSource = transformMobileSafeAppletModule(module.source);
+    return [
+        "async function __mobileSafeApplet(input, api) {",
+        `  const manifest = ${JSON.stringify(manifest)};`,
+        "  const exports = {};",
+        "  const module = { exports };",
+        "  const console = api.console;",
+        "  const crypto = api.crypto;",
+        "  const env = api.env;",
+        "  const fs = api.fs;",
+        "  const applet = { manifest, input, api };",
+        transformedSource
+            .split("\n")
+            .map((line) => `  ${line}`)
+            .join("\n"),
+        "  const resolvedExports = module.exports === exports ? exports : module.exports;",
+        "  const main = resolvedExports.default ?? resolvedExports.main ?? resolvedExports.run;",
+        "  if (typeof main === 'function') return await main(input, api);",
+        "  if (main !== undefined) return main;",
+        "  return resolvedExports;",
+        "}",
+        "",
+    ].join("\n");
+}
+function transformMobileSafeAppletModule(source) {
+    const exportedBindings = [];
+    let output = source
+        .replace(/\bexport\s+default\s+async\s+function\s+([A-Za-z_$][\w$]*)?\s*\(/g, (_match, name) => `exports.default = async function${name ? ` ${name}` : ""}(`)
+        .replace(/\bexport\s+default\s+function\s+([A-Za-z_$][\w$]*)?\s*\(/g, (_match, name) => `exports.default = function${name ? ` ${name}` : ""}(`)
+        .replace(/\bexport\s+default\s+/g, "exports.default = ")
+        .replace(/\bexport\s+async\s+function\s+([A-Za-z_$][\w$]*)\s*\(/g, "exports.$1 = async function $1(")
+        .replace(/\bexport\s+function\s+([A-Za-z_$][\w$]*)\s*\(/g, "exports.$1 = function $1(");
+    output = output.replace(/\bexport\s+(const|let|var)\s+([A-Za-z_$][\w$]*)/g, (_match, declaration, name) => {
+        exportedBindings.push(name);
+        return `${declaration} ${name}`;
+    });
+    if (exportedBindings.length > 0) {
+        output += `\n${exportedBindings
+            .map((name) => `exports.${name} = ${name};`)
+            .join("\n")}`;
+    }
+    return output;
+}
+function assertMobileSafeAppletSource(source, label) {
+    const deniedPatterns = [
+        [/\bimport\s*\(/, "dynamic import"],
+        [/^\s*import\s+/m, "static import"],
+        [/\bexport\s+[^;\n]+from\s+["']/, "re-export"],
+        [/\brequire\s*\(/, "CommonJS require"],
+        [/\beval\s*\(/, "eval"],
+        [/\bFunction\s*\(/, "Function constructor"],
+        [/\bWebAssembly\b/, "WebAssembly"],
+        [/\bprocess\b/, "process global"],
+        [/\bBun\b/, "Bun global"],
+        [/\bDeno\b/, "Deno global"],
+        [/\bchild_process\b/, "child_process"],
+        [/\bnode:/, "node: builtin import"],
+        [/\bshell\b/i, "shell access"],
+        [/\bconstructor\b/, "constructor escape"],
+        [/\b__proto__\b/, "__proto__ escape"],
+    ];
+    for (const [pattern, reason] of deniedPatterns) {
+        if (pattern.test(source)) {
+            throw new Error(`Mobile-safe applet ${label} uses denied ${reason}`);
+        }
+    }
+}
+function stripMobileSafeTypeScript(source) {
+    return source
+        .replace(/^\s*import\s+type\s+[^;]+;\s*$/gm, "")
+        .replace(/^\s*export\s+type\s+[^;]+;\s*$/gm, "")
+        .replace(/^\s*type\s+[A-Za-z_$][\w$]*\s*=\s*[^;]+;\s*$/gm, "")
+        .replace(/^\s*interface\s+[A-Za-z_$][\w$]*\s*\{[^}]*\}\s*$/gm, "")
+        .replace(/:\s*(?:\{[^{}]*\}|[A-Za-z_$][\w$]*(?:<[^;=(){}]+>)?(?:\[\])?)(?=\s*[,)=;{])/g, "")
+        .replace(/\s+as\s+const\b/g, "");
+}
+async function createSafeAppletApi(options) {
+    const textEncoder = new TextEncoder();
+    const textDecoder = new TextDecoder();
+    return deepFreeze({
+        env: Object.freeze({ ...(options.env ?? {}) }),
+        now: options.now?.() ?? Date.now(),
+        console: Object.freeze({
+            log: (...values) => {
+                options.logs.push(values.map(String).join(" "));
+            },
+            warn: (...values) => {
+                options.logs.push(values.map(String).join(" "));
+            },
+            error: (...values) => {
+                options.logs.push(values.map(String).join(" "));
+            },
+        }),
+        crypto: Object.freeze({
+            randomUUID: () => cryptoRequestId(),
+        }),
+        fs: Object.freeze({
+            readText: async (path) => {
+                if (!options.files)
+                    throw new Error("Applet VFS is unavailable");
+                return textDecoder.decode(await options.files.readFile(path));
+            },
+            writeText: async (path, content) => {
+                if (!options.files)
+                    throw new Error("Applet VFS is unavailable");
+                await options.files.writeFile(path, textEncoder.encode(content));
+            },
+            list: async (path) => {
+                if (!options.files)
+                    throw new Error("Applet VFS is unavailable");
+                return options.files.list(path);
+            },
+            stat: async (path) => {
+                if (!options.files)
+                    throw new Error("Applet VFS is unavailable");
+                return options.files.stat(path);
+            },
+        }),
+        broker: options.broker
+            ? Object.freeze({
+                call: async (request) => {
+                    if (request.capability === "shell.exec") {
+                        return unsupportedCapability(request, "Applet broker calls cannot request shell.exec");
+                    }
+                    return options.broker?.call(request);
+                },
+            })
+            : undefined,
+    });
+}
+function deepFreeze(value) {
+    if (value && typeof value === "object") {
+        Object.freeze(value);
+        for (const child of Object.values(value)) {
+            if (child && typeof child === "object" && !Object.isFrozen(child)) {
+                deepFreeze(child);
+            }
+        }
+    }
+    return value;
+}
+function mobileSafeStableHash(input) {
+    let hash = 2166136261;
+    for (let index = 0; index < input.length; index += 1) {
+        hash ^= input.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function sameBytes(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        if (left[index] !== right[index])
+            return false;
+    }
+    return true;
 }
 function resolveMobileSafeRuntimePlatform(explicit, env, globals) {
     if (explicit)
@@ -254,24 +1101,164 @@ function resolveMobileSafeRuntimePlatform(explicit, env, globals) {
     }
     return "unknown";
 }
+function resolveAndroidAvfMicrodroidStatus(platform, probe, env, globals) {
+    const virtualization = objectGlobal(globals.AndroidVirtualization);
+    const explicitState = probe.androidAvfCapabilityState ??
+        parseAndroidAvfCapabilityState(env.ELIZA_ANDROID_AVF_MICRODROID_STATE ??
+            readStringGlobal(virtualization, "state"));
+    const capabilities = readStringArrayGlobal(virtualization, "capabilities");
+    const reason = readStringGlobal(virtualization, "reason");
+    if (platform !== "android") {
+        return {
+            state: "unsupported-platform",
+            available: false,
+            avfAvailable: false,
+            microdroidAvailable: false,
+            payloadAvailable: false,
+            capabilities,
+            reason: "Android AVF/Microdroid boundary is only available in supported Android app shells",
+        };
+    }
+    const avfAvailable = probe.androidAvfAvailable === true ||
+        env.ELIZA_ANDROID_AVF_AVAILABLE === "1" ||
+        readBooleanGlobal(virtualization, "avfAvailable") === true ||
+        readBooleanGlobal(virtualization, "frameworkAvailable") === true ||
+        readBooleanGlobal(virtualization, "hasVirtualizationService") === true;
+    const microdroidAvailable = probe.androidMicrodroidAvailable === true ||
+        env.ELIZA_ANDROID_MICRODROID_AVAILABLE === "1" ||
+        readBooleanGlobal(virtualization, "microdroidAvailable") === true;
+    const payloadAvailable = probe.androidAvfPayloadAvailable === true ||
+        env.ELIZA_ANDROID_MICRODROID_PAYLOAD_READY === "1" ||
+        readBooleanGlobal(virtualization, "payloadAvailable") === true ||
+        explicitState === "ready";
+    const legacyAvailable = readBooleanGlobal(virtualization, "available") === true;
+    const state = explicitState ??
+        (payloadAvailable &&
+            (avfAvailable || microdroidAvailable || legacyAvailable)
+            ? "ready"
+            : avfAvailable || microdroidAvailable || legacyAvailable
+                ? "payload-missing"
+                : "framework-unavailable");
+    return {
+        state,
+        available: state === "ready" && payloadAvailable,
+        avfAvailable: avfAvailable ||
+            microdroidAvailable ||
+            legacyAvailable ||
+            state === "ready" ||
+            state === "payload-missing",
+        microdroidAvailable: microdroidAvailable || legacyAvailable || state === "ready",
+        payloadAvailable,
+        capabilities,
+        reason: reason ?? androidAvfMicrodroidReason(state),
+    };
+}
+function parseAndroidAvfCapabilityState(value) {
+    switch (value) {
+        case "unsupported-platform":
+        case "unsupported-api":
+        case "framework-unavailable":
+        case "permission-denied":
+        case "service-unavailable":
+        case "payload-missing":
+        case "ready":
+            return value;
+        default:
+            return undefined;
+    }
+}
+function androidAvfMicrodroidReason(state) {
+    switch (state) {
+        case "ready":
+            return "Android AVF/Microdroid payload boundary is ready";
+        case "unsupported-platform":
+            return "Android AVF/Microdroid boundary is only available in supported Android app shells";
+        case "unsupported-api":
+            return "Android AVF/Microdroid requires API 34+";
+        case "framework-unavailable":
+            return "Device image does not expose Android AVF/Microdroid virtualization framework";
+        case "permission-denied":
+            return "MANAGE_VIRTUAL_MACHINE is not declared or granted";
+        case "service-unavailable":
+            return "VirtualMachineManager service unavailable";
+        case "payload-missing":
+            return "Android AVF/Microdroid framework is present, but no Microdroid payload boundary is packaged for this build";
+    }
+}
+function objectGlobal(value) {
+    return value && typeof value === "object"
+        ? value
+        : undefined;
+}
 function displayNameForProvider(kind) {
     switch (kind) {
+        case "android-avf-microdroid":
+            return "Android AVF/Microdroid";
         case "android-isolated-process":
             return "Android isolated process";
+        case "safe-js-applet":
+            return "In-process safe JS applet";
         case "javascriptcore":
             return "iOS JavaScriptCore";
         case "quickjs":
             return "iOS QuickJS";
         case "wasm":
             return "WebAssembly";
+        default:
+            return kind;
     }
 }
+function defaultProviderOrderForPlatform(platform) {
+    switch (platform) {
+        case "android":
+            return [
+                "android-avf-microdroid",
+                "android-isolated-process",
+                "safe-js-applet",
+                "wasm",
+            ];
+        case "ios":
+            return ["quickjs", "javascriptcore", "safe-js-applet", "wasm"];
+        case "web":
+            return ["safe-js-applet", "wasm"];
+        default:
+            return ["safe-js-applet", "wasm"];
+    }
+}
+function capabilityForExecuteMode(mode) {
+    switch (mode) {
+        case "shell":
+            return "shell.exec";
+        case "compile-app":
+            return "app.compile";
+        case "load-app":
+            return "app.load";
+        case "run-app":
+            return "app.run";
+        case "evaluate":
+        case undefined:
+            return "model.inference";
+        default:
+            return mode;
+    }
+}
+function unsupportedCapability(request, message) {
+    return {
+        id: request.id,
+        ok: false,
+        error: {
+            code: "MOBILE_SAFE_UNSUPPORTED_CAPABILITY",
+            message,
+            retryable: false,
+        },
+    };
+}
 function providerFailure(provider, error) {
     return {
         ok: false,
         error: {
             code: "MOBILE_SAFE_RUNTIME_EXECUTE_FAILED",
-            message: error instanceof Error ? error.message : String(error),
+            message: formatError(error),
             provider,
         },
     };
@@ -279,6 +1266,26 @@ function providerFailure(provider, error) {
 function globalThisAsRecord() {
     return globalThis;
 }
+function readBooleanGlobal(value, key) {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const raw = value[key];
+    return typeof raw === "boolean" ? raw : undefined;
+}
+function readStringGlobal(value, key) {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const raw = value[key];
+    return typeof raw === "string" && raw.length > 0 ? raw : undefined;
+}
+function readStringArrayGlobal(value, key) {
+    if (value === null || typeof value !== "object")
+        return [];
+    const raw = value[key];
+    return Array.isArray(raw)
+        ? raw.filter((item) => typeof item === "string")
+        : [];
+}
 function parentPath(path) {
     const normalized = normalizeMobileSafePath(path);
     const index = normalized.lastIndexOf("/");