@blastlauncher/web 0.0.0-stage → 3.0.0-alpha.0

package/dist/browser-bundle.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Browser bundling has deliberately no filesystem fallback. The caller owns
+ * both maps, which makes this module usable with esbuild-wasm as well as the
+ * native esbuild used by the tests.
+ */
+export type BrowserBundleFile = string | Uint8Array;
+export type BrowserEsbuild = {
+    build(options: object): Promise<{
+        outputFiles: Array<{
+            text: string;
+            contents: Uint8Array;
+        }> | undefined;
+        warnings: Array<{
+            text: string;
+        }> | undefined;
+    }>;
+};
+export type BrowserBundleOptions = {
+    esbuild: BrowserEsbuild;
+    files: Map<string, BrowserBundleFile>;
+    packages: Map<string, BrowserBundleFile>;
+    /** In-memory path to the extension command module. */
+    command: string;
+    /** In-memory path to the runtime browser entry. */
+    runtimeEntry: string;
+    /** Explicit specifier-to-file aliases for supplied runtime modules. */
+    aliases?: Record<string, string>;
+    sharedRuntime?: boolean;
+    sharedModules?: string[];
+    entryCode?: string;
+};
+export type BrowserBundle = {
+    code: string;
+    warnings: string[];
+    bytes: number;
+};
+export declare class BrowserMissingFileError extends Error {
+    readonly code = "BROWSER_MISSING_FILE";
+    readonly path: string;
+    constructor(path: string);
+}
+export declare class BrowserMissingDependencyError extends Error {
+    readonly code = "BROWSER_MISSING_DEPENDENCY";
+    readonly packages: string[];
+    constructor(packages: Iterable<string>);
+}
+export declare class BrowserNativeModuleError extends Error {
+    readonly code = "BROWSER_NATIVE_MODULE";
+    readonly modules: string[];
+    constructor(modules: Iterable<string>);
+}
+export declare const browserBuiltinModules: readonly ["_http_agent", "_http_client", "_http_common", "_http_incoming", "_http_outgoing", "_http_server", "_stream_duplex", "_stream_passthrough", "_stream_readable", "_stream_transform", "_stream_wrap", "_stream_writable", "_tls_common", "_tls_wrap", "assert", "assert/strict", "async_hooks", "buffer", "child_process", "cluster", "console", "constants", "crypto", "dgram", "diagnostics_channel", "dns", "dns/promises", "domain", "events", "fs", "fs/promises", "http", "http2", "https", "inspector", "inspector/promises", "module", "net", "os", "path", "path/posix", "path/win32", "perf_hooks", "process", "punycode", "querystring", "readline", "readline/promises", "repl", "stream", "stream/consumers", "stream/promises", "stream/web", "string_decoder", "sys", "timers", "timers/promises", "tls", "trace_events", "tty", "url", "util", "util/types", "v8", "vm", "wasi", "worker_threads", "zlib", "node:sea", "node:sqlite", "node:test", "node:test/reporters"];
+/** Bundle an in-memory command and browser runtime with an injected esbuild. */
+export declare function bundleForBrowser(options: BrowserBundleOptions): Promise<BrowserBundle>;

package/dist/browser-bundle.js

@@ -0,0 +1,441 @@
+/**
+ * Browser bundling has deliberately no filesystem fallback. The caller owns
+ * both maps, which makes this module usable with esbuild-wasm as well as the
+ * native esbuild used by the tests.
+ */
+export class BrowserMissingFileError extends Error {
+    code = "BROWSER_MISSING_FILE";
+    path;
+    constructor(path) {
+        super(`Browser bundle file is missing: ${path}`);
+        this.name = "BrowserMissingFileError";
+        this.path = path;
+    }
+}
+export class BrowserMissingDependencyError extends Error {
+    code = "BROWSER_MISSING_DEPENDENCY";
+    packages;
+    constructor(packages) {
+        const names = [...new Set(packages)].toSorted();
+        super(`Browser bundle dependencies are missing: ${names.join(", ")}`);
+        this.name = "BrowserMissingDependencyError";
+        this.packages = names;
+    }
+}
+export class BrowserNativeModuleError extends Error {
+    code = "BROWSER_NATIVE_MODULE";
+    modules;
+    constructor(modules) {
+        const names = [...new Set(modules)].toSorted();
+        super(`Native modules are not supported in a browser bundle: ${names.join(", ")}`);
+        this.name = "BrowserNativeModuleError";
+        this.modules = names;
+    }
+}
+const extensions = [".tsx", ".ts", ".jsx", ".js", ".json"];
+// Keep this list in sync with Node 24's module.builtinModules. The browser
+// resolver cannot import node:module to discover it at runtime.
+export const browserBuiltinModules = [
+    "_http_agent",
+    "_http_client",
+    "_http_common",
+    "_http_incoming",
+    "_http_outgoing",
+    "_http_server",
+    "_stream_duplex",
+    "_stream_passthrough",
+    "_stream_readable",
+    "_stream_transform",
+    "_stream_wrap",
+    "_stream_writable",
+    "_tls_common",
+    "_tls_wrap",
+    "assert",
+    "assert/strict",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "dns",
+    "dns/promises",
+    "domain",
+    "events",
+    "fs",
+    "fs/promises",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "inspector/promises",
+    "module",
+    "net",
+    "os",
+    "path",
+    "path/posix",
+    "path/win32",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "readline/promises",
+    "repl",
+    "stream",
+    "stream/consumers",
+    "stream/promises",
+    "stream/web",
+    "string_decoder",
+    "sys",
+    "timers",
+    "timers/promises",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "util/types",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib",
+    "node:sea",
+    "node:sqlite",
+    "node:test",
+    "node:test/reporters",
+];
+const builtin = new Set(browserBuiltinModules);
+const nativePackages = new Set([
+    "better-sqlite3",
+    "canvas",
+    "fsevents",
+    "keytar",
+    "node-gyp-build",
+    "sharp",
+    "sqlite3",
+]);
+function clean(path) {
+    const parts = [];
+    for (const part of path.replaceAll("\\", "/").split("/")) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..")
+            parts.pop();
+        else
+            parts.push(part);
+    }
+    return `/${parts.join("/")}`;
+}
+function packageName(specifier) {
+    return specifier.startsWith("@")
+        ? specifier.split("/").slice(0, 2).join("/")
+        : specifier.split("/")[0];
+}
+function isBuiltin(specifier) {
+    return specifier.startsWith("node:") || builtin.has(specifier);
+}
+function loader(path) {
+    const extension = extensions.find((item) => path.endsWith(item));
+    if (extension === ".tsx")
+        return "tsx";
+    if (extension === ".ts")
+        return "ts";
+    if (extension === ".jsx")
+        return "jsx";
+    if (extension === ".json")
+        return "json";
+    return "js";
+}
+function asText(value) {
+    return value;
+}
+function text(value) {
+    return typeof value === "string" ? value : new TextDecoder().decode(value);
+}
+function findFile(map, path) {
+    const base = clean(path);
+    // TypeScript source is commonly imported with the emitted `.js` extension;
+    // try the source extensions in its place, as TypeScript's own resolver does.
+    const sourceBase = base.replace(/\.[cm]?jsx?$/, "");
+    const candidates = [
+        base,
+        ...(sourceBase === base ? [] : extensions.map((extension) => `${sourceBase}${extension}`)),
+        ...extensions.map((extension) => `${base}${extension}`),
+        `${base}/index.ts`,
+        `${base}/index.tsx`,
+        `${base}/index.js`,
+        `${base}/index.json`,
+    ];
+    for (const candidate of candidates) {
+        if (map.has(candidate))
+            return candidate;
+        const withoutLeading = candidate.slice(1);
+        if (map.has(withoutLeading))
+            return withoutLeading;
+    }
+    return undefined;
+}
+function packageJson(map, root) {
+    const key = findFile(map, `${root}/package.json`);
+    if (!key)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text(map.get(key)));
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function packageRoots(map, importer, name) {
+    const roots = [];
+    let dir = clean(importer.slice(0, importer.lastIndexOf("/")) || "/");
+    while (true) {
+        const root = clean(`${dir}/node_modules/${name}`);
+        if (map.has(root) ||
+            map.has(root.slice(1)) ||
+            [...map.keys()].some((key) => clean(key).startsWith(`${root}/`))) {
+            roots.push(root);
+        }
+        if (dir === "/")
+            break;
+        dir = clean(`${dir}/..`);
+    }
+    const direct = `/${name}`;
+    if (map.has(direct) ||
+        map.has(name) ||
+        [...map.keys()].some((key) => clean(key).startsWith(`${direct}/`)))
+        roots.push(direct);
+    return [...new Set(roots)];
+}
+function exportTarget(value, subpath) {
+    if (typeof value === "string")
+        return value;
+    if (value === null || value === false)
+        return false;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const resolved = exportTarget(item, subpath);
+            if (resolved !== undefined && resolved !== false)
+                return resolved;
+        }
+        return undefined;
+    }
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const subkeys = Object.keys(record).filter((key) => key.startsWith("."));
+    if (subkeys.length) {
+        const exact = record[subpath];
+        if (exact !== undefined)
+            return exportTarget(exact, subpath);
+        const pattern = subkeys
+            .filter((key) => key.endsWith("*") && subpath.startsWith(key.slice(0, -1)))
+            .toSorted((a, b) => b.length - a.length)[0];
+        if (pattern) {
+            const resolved = exportTarget(record[pattern], subpath);
+            return typeof resolved === "string"
+                ? resolved.replaceAll("*", subpath.slice(pattern.length - 1))
+                : resolved;
+        }
+        return undefined;
+    }
+    for (const condition of ["browser", "import", "module", "require", "default"]) {
+        if (record[condition] !== undefined) {
+            const resolved = exportTarget(record[condition], subpath);
+            if (resolved !== undefined)
+                return resolved;
+        }
+    }
+    return undefined;
+}
+function packageCandidates(map, specifier, importer) {
+    const name = packageName(specifier);
+    const subpath = specifier.slice(name.length).replace(/^\//, "");
+    for (const root of packageRoots(map, importer, name)) {
+        const metadata = packageJson(map, root);
+        const requested = subpath ? `./${subpath}` : ".";
+        if (metadata?.exports !== undefined) {
+            const target = exportTarget(metadata.exports, requested);
+            // Once the nearest package has an exports map, unexported subpaths are
+            // blocked; Node does not fall through to a parent node_modules copy.
+            if (target === false || target === undefined)
+                return [];
+            const candidate = findFile(map, clean(`${root}/${target}`));
+            return candidate ? [candidate] : [];
+        }
+        const base = subpath ? clean(`${root}/${subpath}`) : undefined;
+        if (base) {
+            const candidate = findFile(map, base);
+            if (candidate)
+                return [candidate];
+            continue;
+        }
+        const browser = metadata?.browser;
+        if (typeof browser === "string") {
+            const candidate = findFile(map, clean(`${root}/${browser}`));
+            if (candidate)
+                return [candidate];
+        }
+        const candidates = [];
+        const main = typeof metadata?.module === "string"
+            ? metadata.module
+            : typeof metadata?.main === "string"
+                ? metadata.main
+                : "index";
+        if (typeof browser === "object" && browser) {
+            const mapped = browser[`./${main}`] ??
+                browser["."];
+            if (typeof mapped === "string")
+                candidates.push(clean(`${root}/${mapped}`));
+        }
+        candidates.push(clean(`${root}/${main}`));
+        if (typeof metadata?.main === "string" && typeof metadata?.module === "string")
+            candidates.push(clean(`${root}/${metadata.main}`));
+        candidates.push(clean(`${root}/index`));
+        for (const candidate of candidates) {
+            const found = findFile(map, candidate);
+            if (found)
+                return [found];
+        }
+    }
+    return [];
+}
+/** Bundle an in-memory command and browser runtime with an injected esbuild. */
+export async function bundleForBrowser(options) {
+    const files = new Map([...options.files, ...options.packages]);
+    const command = findFile(files, options.command);
+    const runtimeEntry = findFile(files, options.runtimeEntry);
+    if (!command)
+        throw new BrowserMissingFileError(options.command);
+    if (!runtimeEntry)
+        throw new BrowserMissingFileError(options.runtimeEntry);
+    const missing = new Set();
+    const native = new Set();
+    const missingFiles = new Set();
+    const virtualEntry = "/__blast_browser_bundle_entry__.js";
+    const plugin = {
+        name: "blast-browser-memory",
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, (args) => {
+                const specifier = args.path;
+                if (args.kind === "entry-point") {
+                    if (specifier === virtualEntry)
+                        return { path: virtualEntry };
+                    const entry = findFile(files, specifier);
+                    return entry ? { path: entry } : undefined;
+                }
+                if (options.sharedRuntime && options.sharedModules?.includes(specifier))
+                    return { path: `/__blast_shared_${specifier.replaceAll("/", "_")}` };
+                const alias = options.aliases?.[specifier];
+                if (alias)
+                    return { path: findFile(files, alias) ?? alias };
+                if (isBuiltin(specifier))
+                    return { path: specifier, external: true };
+                if (specifier.endsWith(".node")) {
+                    native.add(specifier);
+                    return { errors: [{ text: `Native module ${specifier} is not supported` }] };
+                }
+                if (!specifier.startsWith(".") &&
+                    !specifier.startsWith("/") &&
+                    nativePackages.has(packageName(specifier))) {
+                    native.add(packageName(specifier));
+                    return {
+                        errors: [{ text: `Native package ${packageName(specifier)} is not supported` }],
+                    };
+                }
+                if (specifier === "@blastlauncher/command")
+                    return { path: command };
+                const relative = specifier.startsWith(".") || specifier.startsWith("/");
+                const candidate = relative
+                    ? findFile(files, clean(`${args.importer.slice(0, args.importer.lastIndexOf("/"))}/${specifier}`))
+                    : alias
+                        ? findFile(files, alias)
+                        : packageCandidates(files, specifier, args.importer)
+                            .map((path) => findFile(files, path))
+                            .find(Boolean);
+                if (candidate)
+                    return { path: candidate.startsWith("/") ? candidate : `/${candidate}` };
+                if (!relative) {
+                    missing.add(packageName(specifier));
+                    return { errors: [{ text: `Missing browser dependency ${packageName(specifier)}` }] };
+                }
+                missingFiles.add(specifier);
+                return { errors: [{ text: `Missing browser file ${specifier}` }] };
+            });
+            build.onLoad({ filter: /.*/ }, (args) => {
+                if (args.path === virtualEntry) {
+                    return {
+                        contents: options.entryCode
+                            ? options.entryCode
+                            : options.sharedRuntime
+                                ? `const __blastRuntime = globalThis.__blastRuntime;\nif (typeof __blastRuntime?.start === "function") __blastRuntime.start(async () => { const __blastCommand = await import(${JSON.stringify(command)}); return { ...__blastCommand, default: __blastCommand.default ?? __blastCommand }; });`
+                                : `import * as __blastRuntime from ${JSON.stringify(runtimeEntry)};\nif (typeof __blastRuntime.start === "function") __blastRuntime.start(async () => { const __blastCommand = await import(${JSON.stringify(command)}); return { ...__blastCommand, default: __blastCommand.default ?? __blastCommand }; });`,
+                        loader: "js",
+                        resolveDir: "/",
+                    };
+                }
+                if (args.path.startsWith("/__blast_shared_")) {
+                    const specifier = args.path.slice("/__blast_shared_".length).replaceAll("_", "/");
+                    return {
+                        contents: `module.exports = globalThis.__blastModules[${JSON.stringify(specifier)}];`,
+                        loader: "js",
+                    };
+                }
+                const key = findFile(files, args.path);
+                if (!key)
+                    return { errors: [{ text: `Missing browser file ${args.path}` }] };
+                return {
+                    contents: asText(files.get(key)),
+                    loader: loader(key),
+                    resolveDir: clean(key.slice(0, key.lastIndexOf("/"))),
+                };
+            });
+        },
+    };
+    const result = await options.esbuild
+        .build({
+        absWorkingDir: "/",
+        entryPoints: [virtualEntry],
+        bundle: true,
+        write: false,
+        format: "cjs",
+        platform: "browser",
+        target: "es2020",
+        minify: true,
+        legalComments: "none",
+        // Raycast extensions use the automatic JSX runtime, as bundleCommand does;
+        // esbuild's default classic transform needs React in scope.
+        jsx: "automatic",
+        plugins: [plugin],
+        logLevel: "silent",
+    })
+        .catch((error) => {
+        if (native.size)
+            throw new BrowserNativeModuleError(native);
+        if (missing.size)
+            throw new BrowserMissingDependencyError(missing);
+        if (missingFiles.size)
+            throw new BrowserMissingFileError([...missingFiles].toSorted()[0]);
+        throw error;
+    });
+    if (native.size)
+        throw new BrowserNativeModuleError(native);
+    if (missing.size)
+        throw new BrowserMissingDependencyError(missing);
+    if (missingFiles.size)
+        throw new BrowserMissingFileError([...missingFiles].toSorted()[0]);
+    const output = result.outputFiles?.[0];
+    if (!output)
+        throw new Error("esbuild returned no browser bundle");
+    return {
+        code: output.text,
+        warnings: (result.warnings ?? []).map((warning) => warning.text),
+        bytes: output.contents.byteLength,
+    };
+}

package/dist/browser-install.d.ts

@@ -0,0 +1,66 @@
+export type BrowserFetch = (input: string, init?: RequestInit) => Promise<Response>;
+export type BrowserManifest = {
+    name?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    [key: string]: unknown;
+};
+export type BrowserLockfile = {
+    packages?: Record<string, {
+        version?: string;
+        dependencies?: Record<string, string>;
+    }>;
+    dependencies?: Record<string, {
+        version?: string;
+        dependencies?: Record<string, unknown>;
+    }>;
+    [key: string]: unknown;
+};
+export type BrowserInstallOptions = {
+    fetch: BrowserFetch;
+    manifest: BrowserManifest;
+    lockfile?: BrowserLockfile | string;
+    maxBytes?: number;
+    maxPackages?: number;
+    registry?: string;
+};
+export type BrowserPackageFile = string | Uint8Array;
+export type BrowserInstallResult = {
+    packages: Map<string, BrowserPackageFile>;
+    versions: Map<string, string>;
+    bytes: number;
+};
+export declare class BrowserInstallError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class BrowserIntegrityError extends BrowserInstallError {
+    readonly packageName: string;
+    readonly expected: string;
+    readonly actual: string;
+    constructor(packageName: string, expected: string, actual: string);
+}
+export declare class BrowserSizeLimitError extends BrowserInstallError {
+    readonly limit: number;
+    readonly actual: number;
+    constructor(limit: number, actual: number);
+}
+export declare class BrowserPackageLimitError extends BrowserInstallError {
+    readonly limit: number;
+    constructor(limit: number);
+}
+export declare class BrowserNativePackageError extends BrowserInstallError {
+    readonly packageName: string;
+    constructor(packageName: string);
+}
+export declare class BrowserResolutionError extends BrowserInstallError {
+    readonly packageName: string;
+    constructor(packageName: string, range: string);
+}
+export declare class BrowserTarPathError extends BrowserInstallError {
+    readonly path: string;
+    constructor(path: string);
+}
+/** Parses the small subset of POSIX tar needed for npm archives, including pax and ustar names. */
+export declare function unpackTar(archive: Uint8Array): Map<string, Uint8Array>;
+export declare function installForBrowser(options: BrowserInstallOptions): Promise<BrowserInstallResult>;