@blastlauncher/engine 0.0.0-stage → 3.0.0-alpha.1

package/dist/bundle.js

@@ -0,0 +1,620 @@
+import { context, transform } from "esbuild";
+import { execFileSync } from "node:child_process";
+import { access, chmod, copyFile, mkdir, mkdtemp, readFile, readdir, realpath, rm, stat, symlink, writeFile, } from "node:fs/promises";
+import { builtinModules } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { checkExtensionDependencies } from "./install-dependencies.js";
+import { loadSharedDependencies, } from "./dependencies.js";
+import { loadTsconfigAliases } from "./tsconfig-paths.js";
+// Bundles run in Node even when Bun runs the host. Bun's built-in list also
+// includes npm packages such as undici and ws, which must be bundled for Node.
+const nodeBuiltins = new Set(process.versions.bun
+    ? JSON.parse(execFileSync("node", ["-p", "JSON.stringify(require('node:module').builtinModules)"], {
+        encoding: "utf8",
+    }))
+    : builtinModules);
+function isNodeBuiltin(specifier) {
+    return (nodeBuiltins.has(specifier) ||
+        (specifier.startsWith("node:") && nodeBuiltins.has(specifier.slice(5))));
+}
+export class MissingDependencyError extends Error {
+    code = "MISSING_DEPENDENCY";
+    packages;
+    constructor(packages) {
+        const names = [...new Set(packages)].toSorted();
+        super(`Missing dependencies: ${names.join(", ")}. Run blast deps <extensionDir> to install declared dependencies, or install @blastlauncher/shared-deps for the shared fallback.`);
+        this.name = "MissingDependencyError";
+        this.packages = names;
+    }
+}
+export class NativeModuleError extends Error {
+    code = "NATIVE_MODULE";
+    modules;
+    constructor(modules) {
+        const names = [...new Set(modules)].toSorted();
+        super(`Native modules are not supported in Blast: ${names.join(", ")}`);
+        this.name = "NativeModuleError";
+        this.modules = names;
+    }
+}
+export class BundleTimeoutError extends Error {
+    code = "BUNDLE_TIMEOUT";
+    extension;
+    command;
+    timeoutMs;
+    constructor(extension, command, timeoutMs) {
+        super(`Bundling ${extension}/${command} timed out after ${timeoutMs} ms`);
+        this.name = "BundleTimeoutError";
+        this.extension = extension;
+        this.command = command;
+        this.timeoutMs = timeoutMs;
+    }
+}
+export class BundleContainmentError extends Error {
+    code = "BUNDLE_OUTSIDE_ROOT";
+    specifier;
+    constructor(specifier) {
+        super(`Import ${JSON.stringify(specifier)} resolves outside the extension and dependency roots`);
+        this.name = "BundleContainmentError";
+        this.specifier = specifier;
+    }
+}
+/** Stop awaiting host work when cancelled, without leaving an abort listener behind. */
+async function abortable(work, signal) {
+    if (signal.aborted)
+        return Promise.race([work, Promise.reject(signal.reason)]);
+    let abort;
+    try {
+        return await Promise.race([
+            work,
+            new Promise((_, reject) => {
+                abort = () => reject(signal.reason);
+                signal.addEventListener("abort", abort, { once: true });
+            }),
+        ]);
+    }
+    finally {
+        if (abort)
+            signal.removeEventListener("abort", abort);
+    }
+}
+function contained(root, path) {
+    const remainder = relative(root, path);
+    return remainder === "" || (!remainder.startsWith("..") && !isAbsolute(remainder));
+}
+async function packageRoot(path) {
+    const fallback = dirname(path);
+    let current = fallback;
+    while (true) {
+        if (await access(join(current, "package.json")).then(() => true, () => false))
+            return realpath(current);
+        const parent = dirname(current);
+        if (parent === current)
+            return fallback;
+        current = parent;
+    }
+}
+class BundleContainment {
+    roots = new Set();
+    sharedNodeModules = new Set();
+    sharedStores = new Set();
+    constructor(extensionDir, installed) {
+        this.roots.add(extensionDir);
+        if (installed)
+            this.roots.add(installed);
+    }
+    async registerInstalled(directory) {
+        const modules = join(directory, "node_modules");
+        const entries = await readdir(modules, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const candidates = entry.name.startsWith("@")
+                ? await readdir(join(modules, entry.name), { withFileTypes: true }).catch(() => [])
+                : [entry];
+            for (const candidate of candidates) {
+                const path = join(modules, entry.name, entry.name.startsWith("@") ? candidate.name : "");
+                const target = await realpath(path).catch(() => undefined);
+                if (target)
+                    this.roots.add(target);
+            }
+        }
+    }
+    async registerShared(path) {
+        // Shared resolvers may return extensionless package subpaths (for example
+        // lodash/get) that esbuild completes during its own resolution step.
+        const resolved = await realpath(path).catch(() => resolve(path));
+        const root = await packageRoot(resolved);
+        this.roots.add(root);
+        let current = root;
+        while (current !== dirname(current)) {
+            if (current.endsWith("/node_modules")) {
+                this.sharedNodeModules.add(current);
+            }
+            if (current.endsWith("/.bun"))
+                this.sharedStores.add(current);
+            current = dirname(current);
+        }
+    }
+    async assert(path, specifier) {
+        const resolved = await realpath(path);
+        if ([...this.roots, ...this.sharedNodeModules, ...this.sharedStores].some((root) => contained(root, resolved)))
+            return;
+        throw new BundleContainmentError(specifier);
+    }
+}
+function dependencyPolicy(missing, nativeModules, shared, installed, installedPackages = new Set(), aliases, containment) {
+    const dependencyFiles = new Set();
+    return {
+        name: "blast-dependencies",
+        setup(builder) {
+            builder.onResolve({ filter: /.*/ }, async (args) => {
+                if (args.pluginData === "blast-resolving")
+                    return;
+                const specifier = args.path;
+                if (specifier === "@raycast/api" || /^react(?:\/|$)/.test(specifier))
+                    return { path: specifier, external: true };
+                if (isNodeBuiltin(specifier))
+                    return { path: specifier, external: true };
+                const bare = !specifier.startsWith(".") && !isAbsolute(specifier);
+                if (bare && /^(?:swift|rust):/.test(specifier)) {
+                    nativeModules.add(specifier);
+                    return { errors: [{ text: `Blast does not provide native module ${specifier}` }] };
+                }
+                // Relative and absolute imports are resolved here before esbuild reads
+                // them. This keeps an extension from smuggling an arbitrary file into
+                // the bundle through a default loader (including data/text loaders).
+                if (!bare) {
+                    const result = await builder.resolve(specifier, {
+                        resolveDir: args.resolveDir,
+                        kind: args.kind,
+                        pluginData: "blast-resolving",
+                    });
+                    if (!result.errors.length && result.path && !result.external) {
+                        await containment?.assert(result.path, specifier);
+                        if (dependencyFiles.has(args.importer))
+                            dependencyFiles.add(result.path);
+                        return result;
+                    }
+                    return;
+                }
+                const inDependencyGraph = dependencyFiles.has(args.importer);
+                // The extension's tsconfig `paths`/`baseUrl` win over packages, as
+                // tsc resolves them: a specifier that maps into the extension is the
+                // extension's own module, never a missing dependency. Imports from
+                // dependency graphs keep package resolution.
+                if (aliases && bare && !inDependencyGraph && args.kind !== "entry-point") {
+                    const alias = await aliases.resolve(specifier);
+                    if (alias) {
+                        await containment?.assert(alias, specifier);
+                        return { path: alias };
+                    }
+                }
+                if (installed && bare && !inDependencyGraph && args.kind !== "entry-point") {
+                    const name = specifier.startsWith("@")
+                        ? specifier.split("/").slice(0, 2).join("/")
+                        : specifier.split("/")[0];
+                    // Do not let esbuild walk up into unrelated ancestor node_modules.
+                    const present = await access(join(installed, "node_modules", name)).then(() => true, () => false);
+                    if (present) {
+                        const result = await builder.resolve(specifier, {
+                            resolveDir: installed,
+                            kind: args.kind,
+                            pluginData: "blast-resolving",
+                        });
+                        if (!result.errors.length && result.path) {
+                            if (!result.external)
+                                await containment?.assert(result.path, specifier);
+                            if (!result.external)
+                                dependencyFiles.add(result.path);
+                            installedPackages.add(name);
+                            return result;
+                        }
+                    }
+                }
+                const provided = !inDependencyGraph && bare
+                    ? shared?.resolveShared(specifier, args.kind === "require-call" || args.kind === "require-resolve"
+                        ? "require"
+                        : "import")
+                    : undefined;
+                // Installed and shared dependency graphs get normal transitive resolution.
+                if (provided || inDependencyGraph) {
+                    if (provided)
+                        await containment?.registerShared(provided);
+                    const result = await builder.resolve(provided ?? specifier, {
+                        resolveDir: args.resolveDir,
+                        kind: args.kind,
+                        pluginData: "blast-resolving",
+                    });
+                    // Let esbuild handle unresolved optional requires inside try/catch.
+                    // Returning plugin errors here would make those optional imports fatal.
+                    if (result.errors.length && inDependencyGraph)
+                        return;
+                    if (result.path && !result.external) {
+                        await containment?.assert(result.path, specifier);
+                        dependencyFiles.add(result.path);
+                    }
+                    return result;
+                }
+                if (args.kind === "entry-point" || specifier.startsWith(".") || isAbsolute(specifier))
+                    return;
+                const name = specifier.startsWith("@")
+                    ? specifier.split("/").slice(0, 2).join("/")
+                    : specifier.split("/")[0];
+                // `#imports` and other Node subpath aliases are not npm packages;
+                // report the bundler's ordinary unresolved-import error instead of a
+                // misleading "missing dependencies: #" result.
+                if (specifier.startsWith("#"))
+                    return;
+                missing.add(name);
+                return { errors: [{ text: `Blast does not provide dependency ${name}` }] };
+            });
+        },
+    };
+}
+/**
+ * Raycast bundles extensions as CommonJS, so extensions freely use
+ * `__filename`, `__dirname` and `require`. Blast emits ESM, so the bundle
+ * banner defines the globals instead: paths derive from `import.meta.url` and
+ * `require` is `createRequire` restricted to Node built-ins and the
+ * runtime-supplied externals (`@raycast/api`, `react`, `react/*`), which the
+ * runtime's resolve hook maps for require() too: CommonJS packages such as
+ * `@raycast/utils` 1.x require React. Anything else is a missing dependency
+ * (docs/decisions/0002), not a silent resolution from the host filesystem.
+ */
+const CJS_GLOBALS_BANNER = `
+import { createRequire as __blastCreateRequire, isBuiltin as __blastIsBuiltin } from "node:module";
+import { dirname as __blastDirname } from "node:path";
+import { fileURLToPath as __blastFileURLToPath } from "node:url";
+const __filename = __blastFileURLToPath(import.meta.url);
+const __dirname = __blastDirname(__blastFileURLToPath(import.meta.url));
+const __blastNodeRequire = __blastCreateRequire(import.meta.url);
+function require(specifier) {
+  if (!__blastIsBuiltin(specifier) && specifier !== "@raycast/api" && !/^react(?:\\/|$)/.test(specifier)) {
+    const error = new Error(
+      'Cannot require "' + specifier + '": Blast only provides Node built-ins to require() (MISSING_DEPENDENCY)',
+    );
+    error.code = "MISSING_DEPENDENCY";
+    throw error;
+  }
+  return __blastNodeRequire(specifier);
+}
+`.trim();
+/** The preference types Raycast's manifest schema defines. */
+const PREFERENCE_TYPES = [
+    "appPicker",
+    "checkbox",
+    "dropdown",
+    "password",
+    "textfield",
+    "file",
+    "directory",
+];
+/** Shared manifest parsing for bundling defaults and client preference forms. */
+export function parsePreferences(value, at = "Preferences") {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error(`${at} must be an array`);
+    return value.map((item, index) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item))
+            throw new Error(`${at} entry ${index + 1} must be an object`);
+        const { name, type, default: fallback, description } = item;
+        if (typeof name !== "string" || !name)
+            throw new Error(`${at} entry ${index + 1} needs a name`);
+        if (typeof type !== "string" || !PREFERENCE_TYPES.includes(type))
+            throw new Error(`Preference ${JSON.stringify(name)} has an unknown type ${JSON.stringify(type)}`);
+        if (fallback !== undefined &&
+            typeof fallback !== "string" &&
+            typeof fallback !== "boolean" &&
+            !(typeof fallback === "number" && Number.isFinite(fallback)))
+            throw new Error(`Preference ${JSON.stringify(name)} needs a scalar "default"`);
+        if (description !== undefined && typeof description !== "string")
+            throw new Error(`Preference ${JSON.stringify(name)} needs a string "description"`);
+        return {
+            name,
+            type,
+            title: (type === "checkbox" ? item.label : item.title) || name,
+            required: item.required === true,
+            data: Array.isArray(item.data)
+                ? item.data.filter((option) => typeof option.value === "string" && typeof option.title === "string")
+                : [],
+            ...(typeof description === "string" ? { description } : {}),
+            ...(fallback === undefined ? {} : { default: fallback }),
+        };
+    });
+}
+function parsePreferenceDefaults(value, at) {
+    return Object.fromEntries(parsePreferences(value, at)
+        .filter((p) => p.default !== undefined)
+        .map((p) => [p.name, p.default]));
+}
+/** The argument types Raycast's manifest schema defines. */
+const ARGUMENT_TYPES = ["text", "password", "dropdown"];
+/**
+ * Reads `commands[].arguments`. Unknown per-argument fields (`data` on a
+ * dropdown) are ignored: Raycast's manifest is the extension author's, and new
+ * optional fields must not make an existing extension unloadable.
+ */
+function parseCommandArguments(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error("Command arguments must be an array");
+    const names = new Set();
+    return value.map((item, index) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            throw new Error(`Argument ${index + 1} must be an object`);
+        }
+        const declared = item;
+        const name = declared["name"];
+        if (typeof name !== "string" || name === "")
+            throw new Error(`Argument ${index + 1} needs a name`);
+        if (names.has(name))
+            throw new Error(`Duplicate argument name ${JSON.stringify(name)}`);
+        names.add(name);
+        const type = declared["type"];
+        if (typeof type !== "string" || !ARGUMENT_TYPES.includes(type)) {
+            throw new Error(`Argument ${JSON.stringify(name)} has an unknown type ${JSON.stringify(type)}`);
+        }
+        const argument = { name, type };
+        const required = declared["required"];
+        if (required !== undefined) {
+            if (typeof required !== "boolean")
+                throw new Error(`Argument ${JSON.stringify(name)} needs a boolean "required"`);
+            argument.required = required;
+        }
+        const placeholder = declared["placeholder"];
+        if (placeholder !== undefined) {
+            if (typeof placeholder !== "string")
+                throw new Error(`Argument ${JSON.stringify(name)} needs a string "placeholder"`);
+            argument.placeholder = placeholder;
+        }
+        return argument;
+    });
+}
+/** Cap for the copy fallback, so a large assets directory cannot fill the disk. */
+const MAX_COPIED_ASSETS_BYTES = 64 * 1024 * 1024;
+async function totalAssetsSize(dir) {
+    let total = 0;
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+        // A link inside assets could point anywhere; the copy fallback reads files only.
+        if (entry.isSymbolicLink())
+            continue;
+        const path = join(dir, entry.name);
+        if (entry.isDirectory())
+            total += await totalAssetsSize(path);
+        else if (entry.isFile())
+            total += (await stat(path)).size;
+    }
+    return total;
+}
+async function copyAssets(source, target) {
+    const size = await totalAssetsSize(source);
+    if (size > MAX_COPIED_ASSETS_BYTES) {
+        throw new Error(`Assets are ${size} bytes; the copy fallback caps at ${MAX_COPIED_ASSETS_BYTES}`);
+    }
+    await mkdir(target, { recursive: true });
+    for (const entry of await readdir(source, { withFileTypes: true })) {
+        if (entry.isSymbolicLink())
+            continue;
+        const from = join(source, entry.name);
+        const to = join(target, entry.name);
+        if (entry.isDirectory())
+            await copyAssets(from, to);
+        else if (entry.isFile()) {
+            await copyFile(from, to);
+            // Read-only: the copy stands in for assets the extension owns, not
+            // something the bundled command may rewrite.
+            await chmod(to, 0o444);
+        }
+    }
+}
+/**
+ * The build directory mirrors Raycast's layout: `assets/` sits next to the
+ * bundle, so `environment.assetsPath` and `path.join(__dirname, "assets", …)`
+ * both resolve to the extension's real assets. The link is a symlink; where
+ * the platform refuses symlinks, a read-only copy with a size cap is used.
+ * Nothing is ever written to the extension directory.
+ */
+export async function linkAssets(outDir, extensionDir, link = symlink) {
+    const assets = join(extensionDir, "assets");
+    const source = await stat(assets).catch(() => undefined);
+    if (!source?.isDirectory())
+        return;
+    const target = join(outDir, "assets");
+    // `rm` removes a symlink itself, never its target, so re-bundling into a
+    // used output directory cannot touch the extension.
+    await rm(target, { recursive: true, force: true });
+    try {
+        await link(assets, target, "dir");
+    }
+    catch {
+        await copyAssets(assets, target);
+    }
+}
+/** The caller owns the output directory and may remove it once the session exits. */
+async function bundleEntry(options) {
+    const started = performance.now();
+    const timeoutMs = options.timeoutMs ?? 60_000;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 2_147_483_647)
+        throw new RangeError("timeoutMs must be an integer between 0 and 2147483647");
+    const controller = new AbortController();
+    const abort = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", abort, { once: true });
+    if (options.signal?.aborted)
+        abort();
+    let extension = options.extensionDir;
+    const timer = timeoutMs === 0
+        ? undefined
+        : setTimeout(() => {
+            controller.abort(new BundleTimeoutError(extension, options.command, timeoutMs));
+        }, timeoutMs);
+    try {
+        const bundled = await bundleEntryWithSignal(options, controller.signal, (name) => {
+            extension = name;
+        });
+        return { ...bundled, bundleMs: performance.now() - started };
+    }
+    catch (error) {
+        if (error instanceof BundleTimeoutError)
+            throw new BundleTimeoutError(extension, options.command, timeoutMs);
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", abort);
+    }
+}
+async function bundleEntryWithSignal(options, signal, setExtension) {
+    signal.throwIfAborted();
+    const extensionDir = resolve(options.extensionDir);
+    const manifest = JSON.parse(await readFile(join(extensionDir, "package.json"), "utf8"));
+    const command = options.modelProvider
+        ? { name: manifest.ai?.modelProvider, mode: "model-provider" }
+        : manifest.commands?.find((item) => item.name === options.command);
+    if (typeof manifest.name !== "string" || !command)
+        throw new Error("Unknown extension command");
+    setExtension(manifest.name);
+    signal.throwIfAborted();
+    const entryName = options.modelProvider ? command.name : options.command;
+    if (typeof entryName !== "string" || !/^[\w-]+$/.test(entryName))
+        throw new Error("Invalid command name");
+    if (!options.modelProvider && !["view", "no-view", "menu-bar"].includes(command.mode))
+        throw new Error("Invalid command mode");
+    const commandArguments = parseCommandArguments(command.arguments);
+    let source;
+    for (const suffix of ["tsx", "ts", "jsx", "js"]) {
+        const candidate = join(extensionDir, "src", `${entryName}.${suffix}`);
+        try {
+            await access(candidate);
+            source = candidate;
+            break;
+        }
+        catch {
+            // Try the next supported source extension.
+        }
+    }
+    if (!source)
+        throw new Error(`Missing source for ${entryName}: no src/${entryName}.{tsx,ts,jsx,js} in ${extensionDir}` +
+            " (a sparse checkout that only has package.json? fetch the whole extension directory)");
+    const shared = await abortable(loadSharedDependencies(options.sharedDependencies), signal);
+    const aliases = await loadTsconfigAliases(extensionDir);
+    for (const warning of aliases?.warnings ?? [])
+        console.warn(warning);
+    const install = options.installedDependencies === false ? undefined : await checkExtensionDependencies(options);
+    const base = join(tmpdir(), "blast", "builds");
+    if (!options.outDir)
+        await mkdir(base, { recursive: true });
+    const outDir = options.outDir ? resolve(options.outDir) : await mkdtemp(join(base, "command-"));
+    const entry = join(outDir, `${entryName}.mjs`);
+    const missing = new Set();
+    const nativeModules = new Set();
+    const installedPackages = new Set();
+    const containment = new BundleContainment(await realpath(extensionDir), install && !install.needed ? await realpath(install.directory) : undefined);
+    if (install && !install.needed)
+        await containment.registerInstalled(install.directory);
+    try {
+        signal.throwIfAborted();
+        const builder = await context({
+            absWorkingDir: extensionDir,
+            entryPoints: [source],
+            outfile: entry,
+            bundle: true,
+            metafile: true,
+            write: false,
+            format: "esm",
+            platform: "node",
+            target: "node24",
+            jsx: "automatic",
+            banner: { js: CJS_GLOBALS_BANNER },
+            plugins: [
+                dependencyPolicy(missing, nativeModules, shared, install && !install.needed ? install.directory : undefined, installedPackages, aliases, containment),
+            ],
+            logLevel: "silent",
+        });
+        let bundled;
+        try {
+            signal.throwIfAborted();
+            bundled = await abortable(builder.rebuild(), signal);
+        }
+        finally {
+            // cancel stops esbuild's graph walk; dispose releases the service context.
+            if (signal.aborted)
+                await builder.cancel();
+            await builder.dispose();
+        }
+        signal.throwIfAborted();
+        // Optional imports in provided graphs can escape esbuild's resolver.
+        // Optional require calls use the banner's MISSING_DEPENDENCY guard instead.
+        for (const output of Object.values(bundled.metafile.outputs)) {
+            for (const imported of output.imports) {
+                if (imported.external &&
+                    imported.kind !== "require-call" &&
+                    imported.path !== "@raycast/api" &&
+                    !/^react(?:\/|$)/.test(imported.path) &&
+                    !isNodeBuiltin(imported.path)) {
+                    const name = imported.path.startsWith("@")
+                        ? imported.path.split("/").slice(0, 2).join("/")
+                        : imported.path.split("/")[0];
+                    if (!imported.path.startsWith("#"))
+                        missing.add(name);
+                }
+            }
+        }
+        if (nativeModules.size)
+            throw new NativeModuleError(nativeModules);
+        if (missing.size)
+            throw new MissingDependencyError(missing);
+        // After tree shaking utils' monolithic entry, remove unused named imports
+        // so Node does not try to link shim symbols the command never uses.
+        const output = await transform(bundled.outputFiles[0].text, {
+            format: "esm",
+            target: "node24",
+            minifySyntax: true,
+        });
+        signal.throwIfAborted();
+        await mkdir(outDir, { recursive: true });
+        await writeFile(entry, output.code);
+        await linkAssets(outDir, extensionDir);
+        signal.throwIfAborted();
+    }
+    catch (error) {
+        if (!options.outDir)
+            await rm(outDir, { recursive: true, force: true });
+        signal.throwIfAborted();
+        if (nativeModules.size)
+            throw new NativeModuleError(nativeModules);
+        if (missing.size)
+            throw new MissingDependencyError(missing);
+        throw error;
+    }
+    return {
+        entry,
+        dependencyWarnings: shared?.dependencyWarnings(Object.fromEntries(Object.entries(manifest.dependencies ?? {}).filter(([name]) => !installedPackages.has(name)))) ?? [],
+        extensionName: manifest.name,
+        commandName: command.name,
+        // Raycast reports the owner when a manifest has one, else the author.
+        ownerOrAuthorName: typeof manifest.owner === "string"
+            ? manifest.owner
+            : typeof manifest.author === "string"
+                ? manifest.author
+                : "",
+        mode: command.mode,
+        arguments: commandArguments,
+        // Command preferences shadow extension preferences with the same name.
+        preferenceDefaults: {
+            ...parsePreferenceDefaults(manifest.preferences, "Extension preferences"),
+            ...parsePreferenceDefaults(command.preferences, `Command ${command.name} preferences`),
+        },
+        assetsPath: join(outDir, "assets"),
+        ...(manifest.ai?.modelProvider && !options.modelProvider
+            ? { modelProviderDir: extensionDir }
+            : {}),
+    };
+}
+export function bundleModelProvider(options) {
+    return bundleEntry({ ...options, command: "model-provider", modelProvider: true });
+}
+export function bundleCommand(options) {
+    return bundleEntry(options);
+}

package/dist/client.d.ts

@@ -0,0 +1,6 @@
+import { type CapabilityHandler } from "./broker.js";
+import { type StorageOptions } from "./storage.js";
+/** Session-owned handlers always win over client grants and defaults. */
+export declare function createSessionBroker(storage: StorageOptions, options?: {
+    handlers?: Record<string, CapabilityHandler>;
+}): import("./broker.js").Broker;

package/dist/client.js

@@ -0,0 +1,11 @@
+import { createBroker } from "./broker.js";
+import { createStorageHandlers } from "./storage.js";
+import { createOAuthHandlers } from "./oauth.js";
+/** Session-owned handlers always win over client grants and defaults. */
+export function createSessionBroker(storage, options = {}) {
+    return createBroker({
+        ...options.handlers,
+        ...createStorageHandlers(storage),
+        ...createOAuthHandlers(storage),
+    });
+}

package/dist/dependencies.d.ts

@@ -0,0 +1,7 @@
+/** Optional fallback supplied by @blastlauncher/shared-deps. */
+export type SharedDependencies = {
+    resolveShared(specifier: string, kind?: "import" | "require"): string | undefined;
+    dependencyWarnings(declarations?: Record<string, unknown>): string[];
+};
+export type SharedDependencyLoader = () => Promise<SharedDependencies>;
+export declare function loadSharedDependencies(load?: SharedDependencyLoader): Promise<SharedDependencies | undefined>;

package/dist/dependencies.js

@@ -0,0 +1,11 @@
+export async function loadSharedDependencies(load = () => import("@blastlauncher/shared-deps")) {
+    try {
+        return await load();
+    }
+    catch (error) {
+        if (error.code === "ERR_MODULE_NOT_FOUND" &&
+            /Cannot find (?:package|module) ['"]@blastlauncher\/shared-deps['"]/.test(error.message))
+            return undefined;
+        throw error;
+    }
+}