@qvac/sdk 0.14.0 → 0.14.1

package/dist/commands/bundle/entry-gen.d.ts

@@ -1,2 +1,2 @@
-export declare function generateWorkerEntry(pluginSpecifiers: string[], sdkName: string): string;
+export declare function generateWorkerEntry(pluginSpecifiers: string[], sdkName: string, resolveImport?: (specifier: string) => string): string;
 //# sourceMappingURL=entry-gen.d.ts.map

package/dist/commands/bundle/entry-gen.js

@@ -1,17 +1,17 @@
 import { parseBuiltinSpecifier } from "./plugins.js";
-export function generateWorkerEntry(pluginSpecifiers, sdkName) {
+export function generateWorkerEntry(pluginSpecifiers, sdkName, resolveImport = (specifier) => specifier) {
     const imports = [];
     const registrations = [];
     let varIndex = 0;
     for (const specifier of pluginSpecifiers) {
         const builtin = parseBuiltinSpecifier(specifier, sdkName);
         if (builtin) {
-            imports.push(`import { ${builtin.exportName} } from "${sdkName}/${builtin.suffix}/plugin";`);
+            imports.push(`import { ${builtin.exportName} } from "${resolveImport(`${sdkName}/${builtin.suffix}/plugin`)}";`);
             registrations.push(`registerPlugin(${builtin.exportName});`);
         }
         else {
             const varName = `customPlugin${varIndex++}`;
-            imports.push(`import ${varName} from "${specifier}";`);
+            imports.push(`import ${varName} from "${resolveImport(specifier)}";`);
             registrations.push(`registerPlugin(${varName});`);
         }
     }
@@ -26,9 +26,9 @@ export function generateWorkerEntry(pluginSpecifiers, sdkName) {
 ${pluginsList}
  */
 
-import { initializeWorkerCore, ensureRPCSetup } from "${sdkName}/worker-core";
-import { registerPlugin } from "${sdkName}/plugins";
-import { getServerLogger } from "${sdkName}/logging";
+import { initializeWorkerCore, ensureRPCSetup } from "${resolveImport(`${sdkName}/worker-core`)}";
+import { registerPlugin } from "${resolveImport(`${sdkName}/plugins`)}";
+import { getServerLogger } from "${resolveImport(`${sdkName}/logging`)}";
 
 ${importsStr}
 

package/dist/commands/bundle/index.js

@@ -9,6 +9,7 @@ import { resolvePluginSpecifiers, parseBuiltinSpecifier, } from "./plugins.js";
 import { generateWorkerEntry } from "./entry-gen.js";
 import { runBarePack } from "./bare-pack.js";
 import { generateAddonsManifest } from "./manifest.js";
+import { createSdkImportResolver } from "./resolve-sdk-import.js";
 const require = createRequire(import.meta.url);
 function resolveSdkPath(projectRoot, explicitSdkPath) {
     if (explicitSdkPath) {
@@ -93,7 +94,8 @@ export async function bundleSdk(options = {}) {
     const deferModules = options.defer ?? [];
     await fsp.mkdir(outputDir, { recursive: true });
     logger.info("\n📝 Generating worker entry...");
-    const workerEntry = generateWorkerEntry(pluginSpecifiers, sdkName);
+    const resolveSdkImport = createSdkImportResolver(sdkPath, sdkName);
+    const workerEntry = generateWorkerEntry(pluginSpecifiers, sdkName, resolveSdkImport);
     await fsp.writeFile(entryPath, workerEntry, "utf8");
     logger.info(`   Created: ${path.relative(projectRoot, entryPath)}`);
     logger.info(`   Using: ${path.relative(projectRoot, importsMapPath)}`);

package/dist/commands/bundle/resolve-sdk-import.d.ts

@@ -0,0 +1,6 @@
+export type SdkExportEntry = string | {
+    [condition: string]: SdkExportEntry;
+};
+export declare function selectExportTarget(entry: SdkExportEntry | undefined): string | null;
+export declare function createSdkImportResolver(sdkPath: string, sdkName: string): (specifier: string) => string;
+//# sourceMappingURL=resolve-sdk-import.d.ts.map

package/dist/commands/bundle/resolve-sdk-import.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const SDK_EXPORT_CONDITIONS = [
+    "bare",
+    "import",
+    "module",
+    "default",
+    "node",
+    "require",
+];
+export function selectExportTarget(entry) {
+    if (entry == null)
+        return null;
+    if (typeof entry === "string")
+        return entry;
+    for (const condition of SDK_EXPORT_CONDITIONS) {
+        const resolved = selectExportTarget(entry[condition]);
+        if (resolved)
+            return resolved;
+    }
+    return null;
+}
+function readSdkExports(sdkPath) {
+    try {
+        const raw = fs.readFileSync(path.join(sdkPath, "package.json"), "utf8");
+        const pkg = JSON.parse(raw);
+        return pkg.exports ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+// bare-pack rewrites the worker's Node builtins to their bare-* equivalents
+// (os -> bare-os, fs -> bare-fs, ...) and resolves them relative to wherever
+// the generated entry imports the SDK from. A bare specifier resolves against
+// the consumer project, so a hoisted/symlinked SDK (pnpm, workspaces) whose
+// bare-* deps live in a parent node_modules becomes unreachable. Importing each
+// SDK subpath via its resolved file under the SDK's realpath anchors that
+// resolution next to the bare-* deps instead.
+export function createSdkImportResolver(sdkPath, sdkName) {
+    let resolvedSdkPath = sdkPath;
+    try {
+        resolvedSdkPath = fs.realpathSync(sdkPath);
+    }
+    catch {
+        // Keep sdkPath as-is if it cannot be canonicalized.
+    }
+    const exportsMap = readSdkExports(resolvedSdkPath);
+    const prefix = `${sdkName}/`;
+    return (specifier) => {
+        if (!specifier.startsWith(prefix))
+            return specifier;
+        const subpath = `./${specifier.slice(prefix.length)}`;
+        const target = selectExportTarget(exportsMap[subpath]);
+        if (!target)
+            return specifier;
+        return pathToFileURL(path.join(resolvedSdkPath, target)).href;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",