@standardagents/code-web 0.14.3-canary.6cc75f → 0.14.4-branch.9e48e914.ee06ef

package/dist/plugins/host/world.js

@@ -0,0 +1,172 @@
+// Instantiating a plugin's core module against the `ui-plugin` world with
+// glue our own build produced (docs/plugin-runtime.md, "The browser
+// runtime").
+//
+// jco's glue for a component is JavaScript generated from that component:
+// its trampolines depend on which imports the component uses and how its
+// core modules are wired. Running a plugin author's glue, or glue generated
+// in the page from the author's component, would run JavaScript the viewer's
+// build did not produce, which the Worker policy (`script-src 'self'`)
+// forbids. So the build transpiles a *reference* component instead: a dummy
+// core module wit-component makes from `wit/standard-plugin` alone that
+// imports every function of the world and exports every export. Its glue
+// (`ui.js`, and `ui-jspi.js` for JSPI) and its two small wit-component
+// shim modules (`ui.core2.wasm`, `ui.core3.wasm`: the indirect-call table
+// and its fix-up) are fixed files of the viewer's bundle.
+//
+// A plugin contributes exactly one core module: the one of its component
+// that exports the world (`selectMain`). `instantiatePlugin` hands the glue
+// that module in place of the reference one, translating import and export
+// names between the legacy wit-component names our SDK emits
+// (`standard:plugin/surface@2.0.0` / `attach`, `activate`, `cabi_realloc`,
+// `cabi_post_frame`) and the standard names the reference module uses
+// (`cm32p2|standard:plugin/surface@2` / `attach`, `cm32p2||activate`,
+// `cm32p2_realloc`, `cm32p2||frame_post`). The canonical ABI makes both
+// sides' core signatures a function of the WIT alone, and the wasm engine
+// type-checks every import that links to a shim export, so a module that
+// imports anything outside the world, or a world function at another type,
+// fails at instantiation and runs nothing.
+
+/** The world's exports, in the plugin's (legacy) spelling. */
+export const WORLD_EXPORTS = ['activate', 'frame', 'event', 'deactivate']
+
+/** Imports that wait for the account: async under JSPI, answered from the
+ *  Worker's mirror (or refused) without it. jco's `asyncImports` names. */
+export const ACCOUNT_IMPORTS = [
+  'standard:plugin/values@2.0.0#get',
+  'standard:plugin/values@2.0.0#set',
+  'standard:plugin/values@2.0.0#delete',
+  'standard:plugin/values@2.0.0#keys',
+  'standard:plugin/live@2.0.0#publish',
+  'standard:plugin/live@2.0.0#delete',
+  'standard:plugin/live@2.0.0#subscribe',
+  'standard:plugin/live@2.0.0#unsubscribe',
+  'standard:plugin/events@2.0.0#emit',
+  'standard:plugin/events@2.0.0#on',
+  'standard:plugin/events@2.0.0#off',
+  'standard:plugin/calls@2.0.0#call',
+  'standard:plugin/claims@2.0.0#claim',
+  'standard:plugin/secrets@2.0.0#get',
+]
+
+/** The reference component's file names (`name: 'ui'` at build time). */
+export const REFERENCE = { main: 'ui.core.wasm', shims: ['ui.core2.wasm', 'ui.core3.wasm'] }
+
+const STANDARD = 'cm32p2|'
+
+/** A semver's canonical form in standard names: `2.0.0` -> `2`,
+ *  `0.3.1` -> `0.3`, `0.0.4` -> `0.0.4`. */
+function canonicalVersion(version) {
+  const [major, minor, patch] = version.split('.').map(part => Number.parseInt(part, 10))
+  if (major) return `${major}`
+  if (minor) return `0.${minor}`
+  return `0.0.${patch}`
+}
+
+/** An import module name in the standard spelling. */
+export function standardModule(name) {
+  if (name.startsWith(STANDARD)) return name
+  const at = name.lastIndexOf('@')
+  if (at < 0) return `${STANDARD}${name}`
+  return `${STANDARD}${name.slice(0, at)}@${canonicalVersion(name.slice(at + 1))}`
+}
+
+function exportNames(module) {
+  return new Set(WebAssembly.Module.exports(module).map(entry => entry.name))
+}
+
+/** Whether a core module exports the whole world, in either spelling. */
+function exportsWorld(names) {
+  const legacy = names.has('memory') && names.has('cabi_realloc') && WORLD_EXPORTS.every(name => names.has(name))
+  const standard = names.has(`${STANDARD.slice(0, -1)}_memory`) && names.has(`${STANDARD.slice(0, -1)}_realloc`)
+    && WORLD_EXPORTS.every(name => names.has(`${STANDARD}|${name}`))
+  return legacy || standard
+}
+
+/** The one core module of a component that exports the world. */
+export function selectMain(modules) {
+  const found = modules.filter(module => exportsWorld(exportNames(module)))
+  if (found.length !== 1) {
+    throw new Error(`the component has ${found.length} core modules that export the ui-plugin world; exactly one must`)
+  }
+  return found[0]
+}
+
+/**
+ * Refuses a main module that imports anything the world does not provide.
+ * `provided` is the standard-named import object the reference glue builds
+ * (or any object with the same keys).
+ */
+export function checkImports(main, provided) {
+  for (const entry of WebAssembly.Module.imports(main)) {
+    const module = standardModule(entry.module)
+    if (entry.kind !== 'function' || typeof provided[module]?.[entry.name] !== 'function') {
+      throw new Error(`the plugin imports ${entry.module}#${entry.name}, which is outside the ui-plugin world`)
+    }
+  }
+}
+
+/** The world's import names, as the reference glue provides them. */
+export function worldImportNames(referenceMain) {
+  const provided = {}
+  for (const entry of WebAssembly.Module.imports(referenceMain)) {
+    ;(provided[entry.module] ??= {})[entry.name] = () => {}
+  }
+  return provided
+}
+
+/** The main module's exports as the reference glue reads them. */
+function standardExports(exports) {
+  if (exports[`${STANDARD.slice(0, -1)}_memory`]) {
+    const out = { ...exports }
+    out.cm32p2_initialize ??= () => {}
+    for (const name of WORLD_EXPORTS) out[`${STANDARD}|${name}_post`] ??= () => {}
+    return out
+  }
+  const out = {
+    cm32p2_memory: exports.memory,
+    cm32p2_realloc: exports.cabi_realloc,
+    // wit-component calls `_initialize` when a module has one.
+    cm32p2_initialize: exports._initialize ?? (() => {}),
+  }
+  for (const name of WORLD_EXPORTS) {
+    out[`${STANDARD}|${name}`] = exports[name]
+    // A module without a post-return function needs none: nothing the
+    // export returns was allocated for the caller.
+    out[`${STANDARD}|${name}_post`] = exports[`cabi_post_${name}`] ?? (() => {})
+  }
+  return out
+}
+
+/**
+ * Instantiates `main` (the plugin's core module) through the reference
+ * glue. `glue` is `ui.js` or `ui-jspi.js`; `shims` maps the reference shim
+ * file names to their compiled modules; `imports` is the host import object
+ * (runtime.js's `PluginHost.imports()`). `wrap(module, name, fn)` may wrap
+ * one core import (the Worker records `attach`'s region address). Returns
+ * the component's exports and the plugin's linear memory.
+ */
+export function instantiatePlugin({ glue, shims, main, imports, wrap = (_module, _name, fn) => fn }) {
+  const reference = {}
+  let memory = null
+  const instance = glue.instantiate((name) => {
+    if (name === REFERENCE.main) return reference
+    const module = shims[name]
+    if (!module) throw new Error(`the world glue asked for an unknown core module ${name}`)
+    return module
+  }, imports, (module, importObject) => {
+    if (module !== reference) return new WebAssembly.Instance(module, importObject)
+    checkImports(main, importObject)
+    const linked = {}
+    for (const entry of WebAssembly.Module.imports(main)) {
+      const standard = standardModule(entry.module)
+      const fn = importObject[standard][entry.name]
+      ;(linked[entry.module] ??= {})[entry.name] = wrap(standard, entry.name, fn)
+    }
+    const exports = new WebAssembly.Instance(main, linked).exports
+    memory = exports.memory ?? exports.cm32p2_memory
+    return { exports: standardExports(exports) }
+  })
+  if (instance instanceof Promise) throw new Error('the world glue instantiated asynchronously')
+  return { instance, memory: () => memory }
+}

package/dist/plugins/jco/cli.js

@@ -0,0 +1,141 @@
+import { inputStreamCreate, outputStreamCreate, pollableCreate, } from "./io.js";
+export { _setEnv, _setArgs, environment } from "./environment.js";
+export { _setCwd } from "./config.js";
+const symbolDispose = Symbol.dispose ?? Symbol.for("dispose");
+class ComponentExit extends Error {
+    exitError = true;
+    code;
+    constructor(code) {
+        super(`Component exited ${code === 0 ? "successfully" : "with error"}`);
+        this.code = code;
+    }
+}
+export const exit = {
+    exit(status) {
+        throw new ComponentExit(status.tag === "err" ? 1 : 0);
+    },
+    // @ts-expect-error - Available only wasi-cli v0.2.12
+    exitWithCode(code) {
+        throw new ComponentExit(code);
+    },
+};
+export function _setStdin(handler) {
+    stdinStream.handler = handler;
+}
+export function _setStderr(handler) {
+    stderrStream.handler = handler;
+}
+export function _setStdout(handler) {
+    stdoutStream.handler = handler;
+}
+const stdinStream = inputStreamCreate({
+    blockingRead() {
+        throw { tag: "closed" };
+    },
+    subscribe() {
+        return pollableCreate();
+    },
+    [symbolDispose]() { },
+});
+function consoleStream(writeLine) {
+    const decoder = new TextDecoder();
+    let pending = "";
+    const emitCompleteLines = () => {
+        const lines = pending.split("\n");
+        pending = lines.pop();
+        for (const line of lines) {
+            writeLine(line.endsWith("\r") ? line.slice(0, -1) : line);
+        }
+    };
+    return {
+        write(contents) {
+            pending += decoder.decode(contents, { stream: true });
+            emitCompleteLines();
+        },
+        flush() {
+            pending += decoder.decode();
+            if (pending) {
+                writeLine(pending);
+            }
+            pending = "";
+        },
+        blockingFlush() {
+            this.flush?.();
+        },
+        drop() {
+            this.flush?.();
+        },
+    };
+}
+const stdoutStream = outputStreamCreate(consoleStream((line) => console.log(line)));
+const stderrStream = outputStreamCreate(consoleStream((line) => console.error(line)));
+export const stdin = {
+    getStdin() {
+        return stdinStream;
+    },
+};
+export const stdout = {
+    getStdout() {
+        return stdoutStream;
+    },
+};
+export const stderr = {
+    getStderr() {
+        return stderrStream;
+    },
+};
+class TerminalInput {
+}
+class TerminalOutput {
+}
+export const terminalInput = {
+    TerminalInput,
+};
+export const terminalOutput = {
+    TerminalOutput,
+};
+export const terminalStderr = {
+    getTerminalStderr() {
+        return undefined;
+    },
+};
+export const terminalStdin = {
+    getTerminalStdin() {
+        return undefined;
+    },
+};
+export const terminalStdout = {
+    getTerminalStdout() {
+        return undefined;
+    },
+};
+/** Create isolated browser CLI interfaces without changing compatibility globals. */
+export function createCli(config = {}) {
+    const stdinInstance = inputStreamCreate(config.stdin ?? {
+        blockingRead() {
+            throw { tag: "closed" };
+        },
+        subscribe: () => pollableCreate(),
+    });
+    const stdoutInstance = outputStreamCreate(config.stdout ?? consoleStream((line) => console.log(line)));
+    const stderrInstance = outputStreamCreate(config.stderr ?? consoleStream((line) => console.error(line)));
+    const env = Object.entries(config.environment ?? {});
+    const args = [...(config.arguments ?? [])];
+    const cwd = config.initialCwd ?? "/";
+    return {
+        environment: {
+            getEnvironment: () => env.map(([key, value]) => [key, value]),
+            getArguments: () => [...args],
+            initialCwd: () => cwd,
+        },
+        exit,
+        stdin: { getStdin: () => stdinInstance },
+        stdout: { getStdout: () => stdoutInstance },
+        stderr: { getStderr: () => stderrInstance },
+        terminalInput,
+        terminalOutput,
+        terminalStdin,
+        terminalStdout,
+        terminalStderr,
+    };
+}

package/dist/plugins/jco/common.js

@@ -0,0 +1,16 @@
+export const MAX_U64 = (1n << 64n) - 1n;
+/** Validate and return a WebAssembly u64 value. */
+export function checkedU64(value, name) {
+    if (typeof value !== "bigint" || value < 0n || value > MAX_U64) {
+        throw new TypeError(`${name} must be a valid u64`);
+    }
+    return value;
+}
+/** Convert a WebAssembly u64 value to a lossless JavaScript number. */
+export function checkedU64AsNumber(value, name) {
+    checkedU64(value, name);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new RangeError(`${name} exceeds JavaScript's safe integer range`);
+    }
+    return Number(value);
+}

package/dist/plugins/jco/config.js

@@ -0,0 +1,7 @@
+let _cwd = "/";
+export function _setCwd(cwd) {
+    _cwd = cwd;
+}
+export function _getCwd() {
+    return _cwd;
+}

package/dist/plugins/jco/environment.js

@@ -0,0 +1,24 @@
+import { _setCwd as fsSetCwd } from "./config.js";
+let _env = [];
+let _args = [];
+let _cwd = "/";
+export function _setEnv(envObj) {
+    _env = Object.entries(envObj);
+}
+export function _setArgs(args) {
+    _args = args;
+}
+export function _setCwd(cwd) {
+    fsSetCwd((_cwd = cwd));
+}
+export const environment = {
+    getEnvironment() {
+        return _env;
+    },
+    getArguments() {
+        return _args;
+    },
+    initialCwd() {
+        return _cwd;
+    },
+};

package/dist/plugins/jco/filesystem.js

@@ -0,0 +1,339 @@
+import { environment } from "./environment.js";
+import { InMemoryFilesystemAdapter } from "./in-memory-filesystem.js";
+import { _setCwd } from "./config.js";
+export { _setCwd } from "./config.js";
+export { InMemoryFilesystemAdapter } from "./in-memory-filesystem.js";
+export { OpfsFilesystemAdapter, loadOpfsCapability } from "./opfs-filesystem.js";
+class DirectoryEntryStream {
+    #implementation;
+    static _create(implementation) {
+        const stream = new DirectoryEntryStream();
+        stream.#implementation = implementation;
+        return stream;
+    }
+    readDirectoryEntry() {
+        return this.#implementation.readDirectoryEntry();
+    }
+}
+const directoryEntryStreamCreate = DirectoryEntryStream._create;
+// @ts-expect-error - Deleting static method
+delete DirectoryEntryStream._create;
+class Descriptor {
+    #implementation;
+    _getImplementation(descriptor) {
+        return descriptor.#implementation;
+    }
+    static _create(implementation) {
+        const descriptor = new Descriptor();
+        descriptor.#implementation = implementation;
+        return descriptor;
+    }
+    readViaStream(offset) {
+        return this.#implementation.readViaStream(offset);
+    }
+    writeViaStream(offset) {
+        return this.#implementation.writeViaStream(offset);
+    }
+    appendViaStream() {
+        return this.#implementation.appendViaStream();
+    }
+    advise(offset, length, advice) {
+        return this.#implementation.advise(offset, length, advice);
+    }
+    syncData() {
+        return this.#implementation.syncData();
+    }
+    getFlags() {
+        return this.#implementation.getFlags();
+    }
+    getType() {
+        return this.#implementation.getType();
+    }
+    setSize(size) {
+        return this.#implementation.setSize(size);
+    }
+    setTimes(dataAccessTimestamp, dataModificationTimestamp) {
+        return this.#implementation.setTimes(dataAccessTimestamp, dataModificationTimestamp);
+    }
+    read(length, offset) {
+        return this.#implementation.read(length, offset);
+    }
+    write(buffer, offset) {
+        return this.#implementation.write(buffer, offset);
+    }
+    readDirectory() {
+        return directoryEntryStreamCreate(this.#implementation.readDirectory());
+    }
+    sync() {
+        return this.#implementation.sync();
+    }
+    createDirectoryAt(path) {
+        return this.#implementation.createDirectoryAt(path);
+    }
+    stat() {
+        return this.#implementation.stat();
+    }
+    statAt(pathFlags, path) {
+        return this.#implementation.statAt(pathFlags, path);
+    }
+    setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp) {
+        return this.#implementation.setTimesAt(pathFlags, path, dataAccessTimestamp, dataModificationTimestamp);
+    }
+    linkAt(oldPathFlags, oldPath, newDescriptor, newPath) {
+        return this.#implementation.linkAt(oldPathFlags, oldPath, descriptorGetImplementation(newDescriptor), newPath);
+    }
+    openAt(pathFlags, path, openFlags, flags) {
+        return descriptorCreate(this.#implementation.openAt(pathFlags, path, openFlags, flags));
+    }
+    readlinkAt(path) {
+        return this.#implementation.readlinkAt(path);
+    }
+    removeDirectoryAt(path) {
+        return this.#implementation.removeDirectoryAt(path);
+    }
+    renameAt(oldPath, newDescriptor, newPath) {
+        return this.#implementation.renameAt(oldPath, descriptorGetImplementation(newDescriptor), newPath);
+    }
+    symlinkAt(oldPath, newPath) {
+        return this.#implementation.symlinkAt(oldPath, newPath);
+    }
+    unlinkFileAt(path) {
+        return this.#implementation.unlinkFileAt(path);
+    }
+    isSameObject(other) {
+        return this.#implementation.isSameObject(descriptorGetImplementation(other));
+    }
+    metadataHash() {
+        return this.#implementation.metadataHash();
+    }
+    metadataHashAt(pathFlags, path) {
+        return this.#implementation.metadataHashAt(pathFlags, path);
+    }
+    lockShared() {
+        return this.#implementation.lockShared?.();
+    }
+    lockExclusive() {
+        return this.#implementation.lockExclusive?.();
+    }
+    tryLockShared() {
+        return this.#implementation.tryLockShared?.() ?? false;
+    }
+    tryLockExclusive() {
+        return this.#implementation.tryLockExclusive?.() ?? false;
+    }
+    unlock() {
+        return this.#implementation.unlock?.();
+    }
+}
+const descriptorGetImplementation = Descriptor.prototype._getImplementation;
+// @ts-expect-error - Deleting prototype method
+delete Descriptor.prototype._getImplementation;
+const descriptorCreate = Descriptor._create;
+// @ts-expect-error - Deleting static method
+delete Descriptor._create;
+const defaultAdapter = new InMemoryFilesystemAdapter();
+let _fileData = { dir: {} };
+let _preopens = [];
+let _rootPreopen = null;
+export const preopens = {
+    getDirectories() {
+        return _preopens;
+    },
+};
+/** Create isolated filesystem namespaces backed by an application-selected adapter. */
+export function createFilesystem({ adapter, preopens: configuredPreopens, }) {
+    const entries = Object.entries(configuredPreopens).map(([guestPath, capability]) => [descriptorCreate(adapter.getRoot(capability)), guestPath]);
+    let disposed = false;
+    return {
+        types,
+        preopens: {
+            getDirectories() {
+                if (disposed) {
+                    throw new Error("filesystem adapter has been disposed");
+                }
+                return [...entries];
+            },
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            adapter.dispose?.();
+        },
+    };
+}
+export function _setFileData(fileData) {
+    _fileData = fileData;
+    if (_rootPreopen) {
+        _rootPreopen[0] = descriptorCreate(defaultAdapter.getRoot(fileData));
+    }
+    else {
+        _setPreopens({ "/": fileData });
+    }
+    const cwd = environment.initialCwd();
+    _setCwd(cwd || "/");
+}
+export function _getFileData() {
+    return JSON.stringify(_fileData);
+}
+/**
+ * Replace all preopens with the given set.
+ * @param preopensConfig - Map of virtual paths to file data entries
+ */
+export function _setPreopens(preopensConfig) {
+    _preopens = [];
+    _rootPreopen = null;
+    for (const [virtualPath, fileData] of Object.entries(preopensConfig)) {
+        _addPreopen(virtualPath, fileData);
+    }
+}
+/**
+ * Add a single preopen mapping.
+ * @param virtualPath - The virtual path visible to the guest
+ * @param fileData - The file data object representing the directory
+ */
+export function _addPreopen(virtualPath, fileData) {
+    const descriptor = descriptorCreate(defaultAdapter.getRoot(fileData));
+    const entry = [descriptor, virtualPath];
+    _preopens.push(entry);
+    if (virtualPath === "/") {
+        _rootPreopen = entry;
+    }
+}
+/**
+ * Add a single preopen backed by a custom adapter (e.g. `OpfsFilesystemAdapter`) instead of the
+ * default in-memory one. Lets a host wire an alternative `BrowserFilesystemAdapter` into the
+ * top-level `wasi:filesystem/preopens` singleton that transpiled components import statically.
+ * @param virtualPath - The virtual path visible to the guest
+ * @param adapter - The adapter that will back this preopen
+ * @param capability - The adapter-specific capability to load as the preopen's root
+ */
+export function _addPreopenWithAdapter(virtualPath, adapter, capability) {
+    const descriptor = descriptorCreate(adapter.getRoot(capability));
+    const entry = [descriptor, virtualPath];
+    _preopens.push(entry);
+    if (virtualPath === "/") {
+        _rootPreopen = entry;
+    }
+}
+/** Clear all preopens, giving the guest no filesystem access. */
+export function _clearPreopens() {
+    _preopens = [];
+    _rootPreopen = null;
+}
+/** Get current preopens configuration. */
+export function _getPreopens() {
+    return [..._preopens];
+}
+/** Reject host paths because browser filesystems require explicit capabilities. */
+export function _createPreopenDescriptor(hostPreopen) {
+    throw new TypeError(`browser preopen ${JSON.stringify(hostPreopen)} is a host path; configure browser file data or an adapter instead`);
+}
+export const types = {
+    Descriptor,
+    DirectoryEntryStream,
+    filesystemErrorCode: (err) => {
+        let message;
+        if ("payload" in err) {
+            message = err.payload;
+        }
+        else if ("message" in err) {
+            message = err.message;
+        }
+        return convertFsError(message);
+    },
+};
+function convertFsError(e) {
+    switch (e.code) {
+        case "EACCES":
+            return "access";
+        case "EAGAIN":
+        case "EWOULDBLOCK":
+            return "would-block";
+        case "EALREADY":
+            return "already";
+        case "EBADF":
+            return "bad-descriptor";
+        case "EBUSY":
+            return "busy";
+        case "EDEADLK":
+            return "deadlock";
+        case "EDQUOT":
+            return "quota";
+        case "EEXIST":
+            return "exist";
+        case "EFBIG":
+            return "file-too-large";
+        case "EILSEQ":
+            return "illegal-byte-sequence";
+        case "EINPROGRESS":
+            return "in-progress";
+        case "EINTR":
+            return "interrupted";
+        case "EINVAL":
+            return "invalid";
+        case "EIO":
+            return "io";
+        case "EISDIR":
+            return "is-directory";
+        case "ELOOP":
+            return "loop";
+        case "EMLINK":
+            return "too-many-links";
+        case "EMSGSIZE":
+            return "message-size";
+        case "ENAMETOOLONG":
+            return "name-too-long";
+        case "ENODEV":
+            return "no-device";
+        case "ENOENT":
+            return "no-entry";
+        case "ENOLCK":
+            return "no-lock";
+        case "ENOMEM":
+            return "insufficient-memory";
+        case "ENOSPC":
+            return "insufficient-space";
+        case "ENOTDIR":
+        case "ERR_FS_EISDIR":
+            return "not-directory";
+        case "ENOTEMPTY":
+            return "not-empty";
+        case "ENOTRECOVERABLE":
+            return "not-recoverable";
+        case "ENOTSUP":
+            return "unsupported";
+        case "ENOTTY":
+            return "no-tty";
+        // windows gives this error for badly structured `//` reads
+        // this seems like a slightly better error than unknown given
+        // that it's a common footgun
+        case -4094:
+        case "ENXIO":
+            return "no-such-device";
+        case "EOVERFLOW":
+            return "overflow";
+        case "EPERM":
+            return "not-permitted";
+        case "EPIPE":
+            return "pipe";
+        case "EROFS":
+            return "read-only";
+        case "ESPIPE":
+            return "invalid-seek";
+        case "ETXTBSY":
+            return "text-file-busy";
+        case "EXDEV":
+            return "cross-device";
+        case "UNKNOWN":
+            switch (e.errno) {
+                case -4094:
+                    return "no-such-device";
+                default:
+                    throw e;
+            }
+        default:
+            throw e;
+    }
+}