@qvac/sdk 0.10.2 → 0.12.0

package/dist/client/config-loader/resolve-config.node.js

@@ -6,9 +6,16 @@ import { promises as fs } from "fs";
 import path from "path";
 import { pathToFileURL } from "url";
 import { validateConfig, parseJsonConfig, } from "./config-utils.js";
-import { ConfigFileParseFailedError } from "../../utils/errors-client.js";
+import { ConfigFileInvalidError, ConfigFileParseFailedError, } from "../../utils/errors-client.js";
 import { getClientLogger } from "../../logging/index.js";
 const logger = getClientLogger();
+/** Config filenames searched under a project root (bundle/verify/commands). */
+export const CONFIG_CANDIDATES = [
+    "qvac.config.ts",
+    "qvac.config.mjs",
+    "qvac.config.js",
+    "qvac.config.json",
+];
 async function findProjectRoot() {
     try {
         let currentDir = path.resolve(process.cwd());
@@ -65,20 +72,76 @@ async function loadJsConfig(filePath) {
         throw new ConfigFileParseFailedError(filePath, error instanceof Error ? error.message : String(error), error);
     }
 }
-async function findConfigFile(searchDir) {
-    const configFiles = [
-        { name: "qvac.config.ts", type: "ts" },
-        { name: "qvac.config.js", type: "js" },
-        { name: "qvac.config.json", type: "json" },
-    ];
-    for (const { name, type } of configFiles) {
+async function loadTsConfig(filePath) {
+    let tsxApiPath;
+    try {
+        const { createRequire } = await import("node:module");
+        const require = createRequire(import.meta.url);
+        tsxApiPath = require.resolve("tsx/esm/api");
+    }
+    catch (error) {
+        throw new ConfigFileInvalidError(filePath, "Loading a TypeScript qvac.config.ts requires the optional peer dependency `tsx`. Install it as a devDependency, or use qvac.config.mjs / qvac.config.js / qvac.config.json instead.", error);
+    }
+    try {
+        const tsxModule = (await import(tsxApiPath));
+        const mod = await tsxModule.tsImport(filePath, import.meta.url);
+        return validateConfig(mod.default ?? mod);
+    }
+    catch (error) {
+        throw new ConfigFileParseFailedError(filePath, error instanceof Error ? error.message : String(error), error);
+    }
+}
+/** Load and validate a config file at an explicit path (used by RPC init and commands). */
+export async function loadConfigFromPath(configPath) {
+    const ext = path.extname(configPath).toLowerCase();
+    if (ext === ".json") {
+        return loadJsonConfig(configPath);
+    }
+    if (ext === ".js" || ext === ".mjs") {
+        return loadJsConfig(configPath);
+    }
+    if (ext === ".ts") {
+        return loadTsConfig(configPath);
+    }
+    throw new ConfigFileInvalidError(configPath, `Unsupported config format: ${ext}. Use .json, .js, .mjs, or .ts`);
+}
+async function findConfigFileInDir(searchDir) {
+    for (const name of CONFIG_CANDIDATES) {
         const filePath = path.resolve(searchDir, name);
         if (await fileExists(filePath)) {
-            return { path: filePath, type };
+            return filePath;
         }
     }
     return undefined;
 }
+/**
+ * Resolve a config file path under `projectRoot` (or an explicit relative/absolute path).
+ * Used by `bundleSdk` / `verifyBundle` when the caller supplies `projectRoot`.
+ */
+export async function resolveConfigFileInProject(projectRoot, explicitPath) {
+    if (explicitPath) {
+        const absPath = path.isAbsolute(explicitPath)
+            ? explicitPath
+            : path.join(projectRoot, explicitPath);
+        if (await fileExists(absPath)) {
+            return absPath;
+        }
+        throw new ConfigFileInvalidError(absPath, "Config file not found at explicit path");
+    }
+    const found = await findConfigFileInDir(projectRoot);
+    return found ?? null;
+}
+/**
+ * Load `qvac.config.*` for a known project directory (commands tooling API).
+ */
+export async function resolveConfigForProject(projectRoot, explicitPath) {
+    const configPath = await resolveConfigFileInProject(projectRoot, explicitPath);
+    if (!configPath) {
+        return { configPath: null, config: {} };
+    }
+    const config = await loadConfigFromPath(configPath);
+    return { configPath, config };
+}
 function getResourcesPath() {
     const { resourcesPath } = process;
     return typeof resourcesPath === "string" ? resourcesPath : undefined;
@@ -111,14 +174,7 @@ export async function resolveConfig() {
     if (configPath) {
         const normalizedPath = path.resolve(configPath);
         if (await fileExists(normalizedPath)) {
-            const ext = normalizedPath.endsWith(".json")
-                ? "json"
-                : normalizedPath.endsWith(".ts")
-                    ? "ts"
-                    : "js";
-            const config = ext === "json"
-                ? await loadJsonConfig(normalizedPath)
-                : await loadJsConfig(normalizedPath);
+            const config = await loadConfigFromPath(normalizedPath);
             logger.info(`✅ Loaded config from: ${normalizedPath}`);
             return config;
         }
@@ -131,12 +187,10 @@ export async function resolveConfig() {
     }
     const projectRoot = await findProjectRoot();
     if (projectRoot) {
-        const configFile = await findConfigFile(projectRoot);
-        if (configFile) {
-            const config = configFile.type === "json"
-                ? await loadJsonConfig(configFile.path)
-                : await loadJsConfig(configFile.path);
-            logger.info(`✅ Loaded config from: ${configFile.path}`);
+        const configFilePath = await findConfigFileInDir(projectRoot);
+        if (configFilePath) {
+            const config = await loadConfigFromPath(configFilePath);
+            logger.info(`✅ Loaded config from: ${configFilePath}`);
             return config;
         }
     }

package/dist/client/plugins-factory.d.ts

@@ -0,0 +1,8 @@
+import * as hostApi from "./api/index";
+import type { QvacPlugin } from "../schemas/plugin";
+/**
+ * Register plugins and return the client host API. Designed for
+ * @qvac/bare-sdk consumers assembling explicit plugin subsets.
+ */
+export declare function plugins(pluginList: readonly QvacPlugin[]): typeof hostApi;
+//# sourceMappingURL=plugins-factory.d.ts.map

package/dist/client/plugins-factory.js

@@ -0,0 +1,10 @@
+import { registerPlugins } from "../server/plugins/index.js";
+import * as hostApi from "./api/index.js";
+/**
+ * Register plugins and return the client host API. Designed for
+ * @qvac/bare-sdk consumers assembling explicit plugin subsets.
+ */
+export function plugins(pluginList) {
+    registerPlugins(pluginList);
+    return hostApi;
+}

package/dist/client/rpc/bare-client.js

@@ -1,59 +1,27 @@
-import { normalizeModelType } from "../../schemas/index.js";
+import { normalizeModelType, PROFILING_KEY } from "../../schemas/index.js";
 import os from "bare-os";
-import { handlers } from "../../server/rpc/handlers/index.js";
 import { registry } from "../../server/rpc/handler-registry.js";
+import { handlerSupportsProgress, selectHandler, } from "../../server/rpc/handler-selection.js";
 import { createErrorResponse } from "../../schemas/index.js";
-import { PearWorkerEntryRequiredError, RPCNoHandlerError, RPCRequestNotSentError, } from "../../utils/errors-client.js";
+import { RPCNoHandlerError, RPCRequestNotSentError, } from "../../utils/errors-client.js";
 import { initializeConfig } from "../init-hooks.js";
 import { setSDKConfig } from "../../server/bare/registry/config-registry.js";
 import { setRuntimeContext } from "../../server/bare/registry/runtime-context-registry.js";
 import { resolveModelConfig } from "../../server/bare/registry/model-config-registry.js";
 import { resolveConfig } from "../config-loader/resolve-config.bare.js";
-import { getClientLogger } from "../../logging/index.js";
-import { getAllPlugins } from "../../server/plugins/index.js";
 import { initializeWorkerCore, shutdownBareDirectWorker, cleanupForTerminate, } from "../../server/worker-core.js";
 import { assertLifecycleAllowed } from "../../server/bare/runtime-lifecycle.js";
-const logger = getClientLogger();
-/**
- * Load worker entry to register plugins before any SDK calls.
- *
- * If plugins are already registered (e.g., by a Pear worker bootstrap),
- * skip loading the default worker but still initialize worker core.
- *
- * NOTE: For Pear apps, the fallback (loading default worker) cannot work.
- *
- * The default worker is intentionally excluded from `pear stage --compact`
- * to enable tree-shaking of unused built-in plugins. When a Pear app tries
- * to dynamically import it at runtime, the path resolves to a pear:// URL.
- * The default worker imports built-in plugins, which load native addons
- * (.bare files). Native addons cannot be loaded from pear:// URLs, causing
- * UNSUPPORTED_PROTOCOL errors.
- *
- * Instead, we detect Pear runtime and throw a clear error directing users
- * to use the generated worker entry (qvac/worker.pear.entry.mjs).
- *
- * The fallback only works in non-Pear environments.
- */
-async function loadWorkerEntry() {
+import { ensurePluginsRegistered } from "./ensure-worker-ready.js";
+async function ensureWorkerReady() {
     initializeWorkerCore();
-    if (getAllPlugins().length > 0) {
-        logger.info("📦 Plugins already registered, worker core initialized");
-        return;
-    }
-    const { isPear } = await import("which-runtime");
-    if (isPear) {
-        throw new PearWorkerEntryRequiredError("qvac/worker.pear.entry.mjs");
-    }
-    // Fallback: load default worker (all built-in plugins)
-    logger.info("📦 Loading default worker (all built-in plugins)");
-    const workerPath = "../../server/" + "worker.js";
-    await import(workerPath);
+    await ensurePluginsRegistered();
 }
-let workerEntryLoaded = false;
-// Get the handler for a request type
-function getHandler(type) {
-    const handler = handlers[type];
-    return typeof handler === "function" ? handler : undefined;
+function getHandlerEntry(type) {
+    const entry = registry[type];
+    if (!entry) {
+        throw new RPCNoHandlerError(type);
+    }
+    return entry;
 }
 function applyDeviceDefaultsToLoadModel(request) {
     if (request.type !== "loadModel" || !("modelSrc" in request)) {
@@ -70,16 +38,49 @@ function applyDeviceDefaultsToLoadModel(request) {
     const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
     return { ...request, modelConfig: configWithDefaults };
 }
-function supportsProgressStreaming(request) {
-    return ("withProgress" in request &&
-        request.withProgress &&
-        ["loadModel", "downloadAsset", "rag", "finetune"].includes(request.type));
+function getProfilingMetaFromRequest(request) {
+    if (PROFILING_KEY in request) {
+        return request[PROFILING_KEY];
+    }
+    return undefined;
+}
+function createDelegatedOptions(request, progressCallback) {
+    const profilingMeta = getProfilingMetaFromRequest(request);
+    if (!profilingMeta && !progressCallback) {
+        return undefined;
+    }
+    const options = {};
+    if (progressCallback) {
+        options.progressCallback = progressCallback;
+    }
+    if (profilingMeta) {
+        options.profilingMeta = profilingMeta;
+    }
+    return options;
+}
+function executeDirectHandler(request, handler, isDelegated) {
+    const directHandler = handler;
+    if (isDelegated) {
+        return directHandler(request, createDelegatedOptions(request));
+    }
+    return directHandler(request);
+}
+function isAsyncGenerator(result) {
+    return (typeof result === "object" &&
+        result !== null &&
+        Symbol.asyncIterator in result);
 }
-async function* streamWithProgress(request, handler) {
+async function* streamWithProgress(request, handler, isDelegated) {
     const queue = [];
     const errors = [];
     let done = false;
-    handler(request, (update) => queue.push(update))
+    function progressCallback(update) {
+        queue.push(update);
+    }
+    const directHandler = handler;
+    Promise.resolve(directHandler(request, isDelegated
+        ? createDelegatedOptions(request, progressCallback)
+        : progressCallback))
         .then((final) => {
         queue.push(final);
         done = true;
@@ -103,25 +104,23 @@ async function* streamWithProgress(request, handler) {
 }
 export async function send(request) {
     assertLifecycleAllowed(request);
-    const handler = getHandler(request.type);
-    if (!handler)
-        throw new RPCNoHandlerError(request.type);
     const processedRequest = applyDeviceDefaultsToLoadModel(request);
-    return (await handler(processedRequest));
+    const entry = getHandlerEntry(processedRequest.type);
+    const { handler, isDelegated } = selectHandler(entry, processedRequest);
+    return (await executeDirectHandler(processedRequest, handler, isDelegated));
 }
 async function* stream(request) {
     assertLifecycleAllowed(request);
-    const handler = getHandler(request.type);
-    if (!handler)
-        throw new RPCNoHandlerError(request.type);
-    if (supportsProgressStreaming(request)) {
-        const processedRequest = applyDeviceDefaultsToLoadModel(request);
-        yield* streamWithProgress(processedRequest, handler);
+    const processedRequest = applyDeviceDefaultsToLoadModel(request);
+    const entry = getHandlerEntry(processedRequest.type);
+    const { handler, isDelegated } = selectHandler(entry, processedRequest);
+    if (handlerSupportsProgress(entry, processedRequest)) {
+        yield* streamWithProgress(processedRequest, handler, isDelegated);
     }
     else {
-        const result = handler(request);
+        const result = executeDirectHandler(processedRequest, handler, isDelegated);
         // Check if the handler returns a Promise or AsyncGenerator
-        if (Symbol.asyncIterator in result) {
+        if (isAsyncGenerator(result)) {
             // It's an AsyncGenerator
             yield* result;
         }
@@ -195,10 +194,7 @@ function createMockRPCRequest() {
 }
 let configInitialized = false;
 export async function getRPC() {
-    if (!workerEntryLoaded) {
-        await loadWorkerEntry();
-        workerEntryLoaded = true;
-    }
+    await ensureWorkerReady();
     const mockRPC = {
         request() {
             return createMockRPCRequest();

package/dist/client/rpc/ensure-worker-ready.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Throw if no plugins are registered before an SDK call. On Pear,
+ * point at the generated worker entry; otherwise raise a generic
+ * registration error. `isPear` is overridable for tests.
+ */
+export declare function ensurePluginsRegistered(opts?: {
+    isPear?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=ensure-worker-ready.d.ts.map

package/dist/client/rpc/ensure-worker-ready.js

@@ -0,0 +1,17 @@
+import { getAllPlugins } from "../../server/plugins/index.js";
+import { PearWorkerEntryRequiredError, WorkerPluginsNotRegisteredError, } from "../../utils/errors-client.js";
+const PEAR_WORKER_ENTRY_PATH = "qvac/worker.pear.entry.mjs";
+/**
+ * Throw if no plugins are registered before an SDK call. On Pear,
+ * point at the generated worker entry; otherwise raise a generic
+ * registration error. `isPear` is overridable for tests.
+ */
+export async function ensurePluginsRegistered(opts) {
+    if (getAllPlugins().length > 0)
+        return;
+    const isPear = opts?.isPear ?? (await import("which-runtime")).isPear;
+    if (isPear) {
+        throw new PearWorkerEntryRequiredError(PEAR_WORKER_ENTRY_PATH);
+    }
+    throw new WorkerPluginsNotRegisteredError();
+}

package/dist/client/rpc/expo-rpc-client.js

@@ -195,6 +195,7 @@ export async function createDuplexSession(payload, commandId) {
     const req = rpc.request(commandId);
     const requestStream = req.createRequestStream();
     const responseStream = req.createResponseStream({ encoding: "utf-8" });
-    requestStream.write(payload, "utf-8");
+    // Pre-encode payload — RN/Hermes lacks a global `Buffer`, so `write(string, "utf-8")` would throw.
+    requestStream.write(new TextEncoder().encode(payload));
     return { requestStream, responseStream };
 }

package/dist/client/rpc/node-rpc-client.js

@@ -13,8 +13,6 @@ import { getClientLogger } from "../../logging/index.js";
 import { RPCInitTimeoutError } from "../../utils/errors-client.js";
 const RPC_INIT_TIMEOUT_MS = 30_000;
 const logger = getClientLogger();
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
 let rpcInstance = null;
 let rpcPromise = null;
 let bareWorkerProc = null;
@@ -56,14 +54,27 @@ function resolvePackagedWorkerPath() {
     return undefined;
 }
 /**
- * Get default worker path from SDK dist
+ * Resolve the SDK's default worker entry via bundler-visible asset references.
+ *
+ * `path.resolve(__dirname, ...)` is invisible to static analysis, so packaged
+ * consumers ship without worker.js. We use `import.meta.asset(<literal>)` on
+ * Bare (detected by bare-module-lexer) and fall back to
+ * `new URL(<literal>, import.meta.url)` elsewhere. Specs must be string
+ * literals at the call site.
  */
 function getDefaultWorkerPath() {
-    const packagedWorker = path.resolve(__dirname, "../../server/worker.js");
-    if (fs.existsSync(packagedWorker))
-        return packagedWorker;
+    const hasAsset = typeof import.meta.asset === "function";
+    const packagedUrl = hasAsset
+        ? new URL(import.meta.asset("../../server/worker.js"))
+        : new URL("../../server/worker.js", import.meta.url);
+    const packaged = fileURLToPath(packagedUrl);
+    if (fs.existsSync(packaged))
+        return packaged;
     // Dev/source layout fallback
-    return path.resolve(__dirname, "../../dist/server/worker.js");
+    const devUrl = hasAsset
+        ? new URL(import.meta.asset("../../dist/server/worker.js"))
+        : new URL("../../dist/server/worker.js", import.meta.url);
+    return fileURLToPath(devUrl);
 }
 /**
  * Resolve worker path with priority:
@@ -208,7 +219,10 @@ async function ensureRPC() {
                     WORKER_PATH,
                     JSON.stringify({
                         QVAC_IPC_SOCKET_PATH: socketPath,
-                        HOME_DIR: os.homedir(),
+                        // Snap's HOME can be revision-scoped; SNAP_USER_COMMON is stable.
+                        HOME_DIR: process.env["SNAP_USER_COMMON"]
+                            ? String(process.env["SNAP_USER_COMMON"])
+                            : os.homedir(),
                     }),
                 ],
                 stdio: ["inherit", "inherit", "inherit"],

package/dist/client/rpc/rpc-client.d.ts

@@ -3,11 +3,11 @@ import { type Request, type Response, type RPCOptions } from "../../schemas/inde
 export declare function send<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): Promise<Response>;
 export declare function stream<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): AsyncGenerator<Response>;
 export interface DuplexWritable {
-    write(chunk: Buffer): void;
+    write(chunk: Uint8Array): void;
     end(): void;
     destroy(): void;
 }
-export interface DuplexReadable extends AsyncIterable<Buffer> {
+export interface DuplexReadable extends AsyncIterable<Buffer | string> {
     destroy(): void;
 }
 export interface DuplexSession {

package/dist/client/rpc/rpc-client.js

@@ -1,5 +1,5 @@
 import { requestSchema, responseSchema, PROFILING_TRAILER_KEY, } from "../../schemas/index.js";
-import { RPCError } from "./rpc-error.js";
+import { reconstructError } from "./rpc-error.js";
 import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
 import { getClientLogger, summarizeRequest } from "../../logging/index.js";
 import { getRPC, close as closeRPC, createDuplexSession } from "#rpc";
@@ -15,7 +15,12 @@ function getNextCommandId() {
 }
 function checkAndThrowError(response) {
     if (response.type === "error") {
-        throw new RPCError(response);
+        // Use the typed-error reconstructor map in `rpc-error.ts` so the
+        // original class (e.g. `RequestRejectedByPolicyError`) survives
+        // the RPC boundary intact and `err instanceof <Class>` works in
+        // consumer `catch` blocks. Unknown error names fall back to a
+        // plain `RPCError` wrapper inside `reconstructError`.
+        throw reconstructError(response);
     }
 }
 async function getRPCInstance() {
@@ -311,12 +316,13 @@ async function duplexProfiled(request, options = {}) {
                 }
                 if (outputParts.length > 0) {
                     timings.chunkCount += outputParts.length;
-                    yield Buffer.from(outputParts.join("\n") + "\n");
+                    // Yield strings (not Buffer) — RN/Hermes has no global `Buffer`; consumers call `.toString()` either way.
+                    yield outputParts.join("\n") + "\n";
                 }
             }
             if (lineBuffer.trim()) {
                 timings.chunkCount++;
-                yield Buffer.from(lineBuffer + "\n");
+                yield lineBuffer + "\n";
             }
         }
         catch (error) {

package/dist/client/rpc/rpc-error.d.ts

@@ -16,4 +16,13 @@ export declare class RPCError extends Error {
         isQvacError: boolean;
     };
 }
+/**
+ * Rebuild the original server-thrown typed error from its serialised
+ * envelope so consumer code can do
+ * `if (err instanceof RequestRejectedByPolicyError) { ... }` across
+ * the RPC boundary. Unknown error names fall through to the legacy
+ * `RPCError` wrapper, which preserves `name`/`code`/`message` for
+ * code-based predicates.
+ */
+export declare function reconstructError(response: ErrorResponse): Error;
 //# sourceMappingURL=rpc-error.d.ts.map

package/dist/client/rpc/rpc-error.js

@@ -1,3 +1,4 @@
+import { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, } from "../../utils/errors-server.js";
 export class RPCError extends Error {
     timestamp;
     remoteStack;
@@ -37,3 +38,107 @@ export class RPCError extends Error {
         };
     }
 }
+/**
+ * Attach the remote stack onto a reconstructed typed error so the
+ * client-side trace points at the consumer call site and the worker-
+ * side trace is preserved for debugging. Mirrors the behaviour
+ * `RPCError`'s constructor applies in the fall-through path.
+ */
+function attachRemoteContext(err, response) {
+    if (response.stack) {
+        err.remoteStack = response.stack;
+        err.stack = `${err.stack}\n--- Worker Stack ---\n${response.stack}`;
+    }
+    if (response.timestamp) {
+        err.timestamp = response.timestamp;
+    }
+    return err;
+}
+/** Read a string field from the `typedFields` envelope, defaulting to `fallback` if missing or non-string. */
+function readStringField(fields, key, fallback) {
+    const value = fields?.[key];
+    return typeof value === "string" ? value : fallback;
+}
+/** Read a number field from the `typedFields` envelope, returning `undefined` if missing or non-number. */
+function readOptionalNumberField(fields, key) {
+    const value = fields?.[key];
+    return typeof value === "number" ? value : undefined;
+}
+/** Read a string field, returning `undefined` (not a fallback string) if missing. */
+function readOptionalStringField(fields, key) {
+    const value = fields?.[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/**
+ * Map of server-thrown `QvacErrorBase` subclasses that need to survive
+ * the RPC boundary as their original class — `err instanceof
+ * RequestRejectedByPolicyError` on the consumer side must match the
+ * class re-exported from `@qvac/sdk`.
+ *
+ * **Key shape.** The key is the `name` value `QvacErrorBase` sets at
+ * construction time, which `createErrorResponse` forwards onto
+ * `response.name`. That value is the SCREAMING_SNAKE_CASE error-code
+ * name from `sdk-errors-server.ts` (`"REQUEST_REJECTED_BY_POLICY"`),
+ * **not** the JS class name (`"RequestRejectedByPolicyError"`). The
+ * mismatch was a 0.11.0 bring-up bug fixed alongside the reconstructor
+ * unit tests in `rpc-error-reconstruct.test.ts`.
+ *
+ * **Maintenance contract.** Every new cross-RPC server-thrown typed
+ * error class added in `errors-server.ts` adds a row here in the same
+ * PR, keyed by its `SDK_SERVER_ERROR_CODES.<NAME>` constant. The
+ * class must (a) implement `toErrorResponseFields(): Record<…>` so
+ * the wire envelope carries its named constructor arguments and (b)
+ * be re-exported from `@qvac/sdk` so consumers can `import` it.
+ * Forgetting either side means `instanceof` regresses for that class.
+ *
+ * Client-constructed typed errors (e.g. `InferenceCancelledError`
+ * built in `client/api/completion-stream.ts` from the aggregated
+ * partial state) are NOT registered here — they never round-trip the
+ * envelope, and adding a reconstructor for one would create a
+ * parallel construction path that fires whenever the server happens
+ * to throw the same class name.
+ */
+const RECONSTRUCTORS = {
+    REQUEST_ID_CONFLICT: (response) => {
+        return new RequestIdConflictError(readStringField(response.typedFields, "requestId", ""), response.cause);
+    },
+    REQUEST_NOT_FOUND: (response) => {
+        return new RequestNotFoundError(readStringField(response.typedFields, "requestId", ""), response.cause);
+    },
+    REQUEST_REJECTED_BY_POLICY: (response) => {
+        return new RequestRejectedByPolicyError(readStringField(response.typedFields, "requestId", ""), readStringField(response.typedFields, "kind", ""), readStringField(response.typedFields, "modelId", ""), readStringField(response.typedFields, "reason", response.message), response.cause);
+    },
+    CONTEXT_OVERFLOW: (response) => {
+        return new ContextOverflowError(readOptionalNumberField(response.typedFields, "promptTokens"), readOptionalNumberField(response.typedFields, "ctxSize"), readOptionalStringField(response.typedFields, "modelId"), response.cause);
+    },
+};
+/**
+ * Rebuild the original server-thrown typed error from its serialised
+ * envelope so consumer code can do
+ * `if (err instanceof RequestRejectedByPolicyError) { ... }` across
+ * the RPC boundary. Unknown error names fall through to the legacy
+ * `RPCError` wrapper, which preserves `name`/`code`/`message` for
+ * code-based predicates.
+ */
+export function reconstructError(response) {
+    const reconstructor = response.name
+        ? RECONSTRUCTORS[response.name]
+        : undefined;
+    if (!reconstructor) {
+        return new RPCError(response);
+    }
+    try {
+        return attachRemoteContext(reconstructor(response), response);
+    }
+    catch {
+        // Defensive fall-through: if a reconstructor throws (e.g. a
+        // future class adds a required constructor field and an older
+        // server doesn't ship `typedFields`), surface the original error
+        // via `RPCError` so consumers never see "couldn't reconstruct
+        // error" obscuring the real one. The reconstructors here are
+        // intentionally written to coerce missing fields to defensible
+        // defaults (`String(x ?? "")`), so reaching this branch is the
+        // edge case, not the norm.
+        return new RPCError(response);
+    }
+}

package/dist/commands/bundle/bare-pack.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from "../../logging/types";
+interface RunBarePackOptions {
+    entryPath: string;
+    outputPath: string;
+    hosts: string[];
+    importsMapPath: string;
+    deferModules: string[];
+    quiet: boolean;
+    logger: Logger;
+}
+export declare function runBarePack(options: RunBarePackOptions): Promise<void>;
+export {};
+//# sourceMappingURL=bare-pack.d.ts.map