pynect 0.2.6 → 0.2.9

package/scripts/build-native.js

@@ -14,6 +14,12 @@ async function main() {
     pythonPath: process.env.PYNECT_PYTHON,
   });
   const embedding = python.embedding;
+  const stableAbiLibrary = process.platform === 'win32'
+    ? embedding.stableAbiLibraryPath || path.join(embedding.libraryDirectory, 'python3.lib')
+    : '';
+  const linkLibrary = stableAbiLibrary && fs.existsSync(stableAbiLibrary)
+    ? stableAbiLibrary
+    : embedding.libraryPath;
   const nodeGyp = require.resolve('node-gyp/bin/node-gyp.js');
   const mode = process.argv.includes('--debug') ? '--debug' : '--release';
   const args = [nodeGyp, 'rebuild', mode];
@@ -24,8 +30,8 @@ async function main() {
     npm_config_python: python.executable,
     PYTHON: python.executable,
     PYNECT_PYTHON_INCLUDE_DIR: embedding.includeDirectory,
-    PYNECT_PYTHON_LIBRARY: embedding.libraryPath,
-    PYNECT_PYTHON_LIBRARY_DIR: embedding.libraryDirectory,
+    PYNECT_PYTHON_LIBRARY: linkLibrary,
+    PYNECT_PYTHON_LIBRARY_DIR: path.dirname(linkLibrary),
     PATH: [embedding.libraryDirectory, path.dirname(python.executable), process.env.PATH || '']
       .filter(Boolean)
       .join(path.delimiter),
@@ -40,7 +46,7 @@ async function main() {
       schemaVersion: 1,
       pythonExecutable: path.resolve(python.executable),
       pythonVersion: python.version,
-      pythonLibrary: path.resolve(embedding.libraryPath),
+      pythonLibrary: path.resolve(linkLibrary),
       buildType: mode === '--debug' ? 'Debug' : 'Release',
     }, null, 2)}\n`,
   );

package/scripts/ensure-native.js

@@ -7,6 +7,7 @@ const { spawnSync } = require('child_process');
 const ROOT = path.resolve(__dirname, '..');
 const BUILD_DIRECTORY = path.join(ROOT, 'build');
 const METADATA = path.join(BUILD_DIRECTORY, 'pynect-python.json');
+let lastLoadError;
 
 function normalize(value) {
   const resolved = path.resolve(value);
@@ -33,12 +34,14 @@ function matchingAddonPath() {
 }
 
 function loads() {
+  lastLoadError = undefined;
   const addon = matchingAddonPath();
   if (!addon || !fs.existsSync(addon)) return false;
   try {
     require(addon);
     return true;
-  } catch {
+  } catch (error) {
+    lastLoadError = error;
     return false;
   }
 }
@@ -55,7 +58,10 @@ function build() {
   if (result.status !== 0) {
     throw new Error(`Native addon build failed with exit code ${result.status}.`);
   }
-  if (!loads()) throw new Error('Native addon did not load after it was built.');
+  if (!loads()) {
+    const detail = lastLoadError instanceof Error ? ` ${lastLoadError.message}` : '';
+    throw new Error(`Native addon did not load after it was built.${detail}`);
+  }
 }
 
 async function main() {

package/scripts/smoke-python-boundary.js

@@ -1,5 +1,7 @@
 'use strict';
 
+process.env.PYNECT_PREFER_LOCAL ??= '1';
+
 const path = require('path');
 const { ensurePynectEnvironment } = require('./pyfig');
 
@@ -40,6 +42,22 @@ async function main() {
   );
   assertSuccess(inspector, 'codegen inspector');
   JSON.parse(inspector.stdout);
+  const callbackInspection = client.pythonSync(
+    [path.join(ROOT, 'python', 'type_inspector.py'), 'pynect_callback_fixture'],
+    {
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        PYTHONPATH: path.join(ROOT, 'tests', 'fixtures'),
+      },
+    },
+  );
+  assertSuccess(callbackInspection, 'callback type inspector');
+  const inspectedCallback = JSON.parse(callbackInspection.stdout).functions
+    .find(item => item.name === 'invoke')?.parameters?.[0]?.type;
+  if (inspectedCallback !== 'Callable[[Any], Any]') {
+    throw new Error(`Callback annotation was inspected as ${String(inspectedCallback)}.`);
+  }
 
   const worker = client.pythonSync(
     [path.join(ROOT, 'python', 'isolated_worker.py')],
@@ -69,15 +87,67 @@ async function main() {
     projectRoot: ROOT,
     allowUnsafeCode: true,
     logLevel: 'error',
+    pythonPath_extra: [path.join(ROOT, 'tests', 'fixtures')],
+    threadPool: { size: 1 },
+    callbacks: { maxDepth: 2 },
   });
   try {
     const embedded = await pynect.py.eval('__import__("sys").executable');
     assertSamePython(embedded, expected, 'embedded CPython');
+    const fixture = await pynect.importModule('pynect_callback_fixture');
+    await assertRejects(
+      () => fixture.invoke((value) => value, 1),
+      /ctx\.callback\(\)/,
+      'unregistered callback',
+    );
+
+    let disposedCallback;
+    await pynect.withCallbacks(async ctx => {
+      const asyncCallback = ctx.callback(async value => {
+        await Promise.resolve();
+        return value * 3;
+      });
+      if (await fixture.invoke(asyncCallback, 4) !== 12) {
+        throw new Error('Async JavaScript callback returned the wrong value.');
+      }
+
+      const reentrantCallback = ctx.callback(async value => fixture.double(value));
+      if (await fixture.invoke(reentrantCallback, 5) !== 10) {
+        throw new Error('Reentrant JavaScript callback returned the wrong value.');
+      }
+
+      let recursiveCallback;
+      recursiveCallback = ctx.callback(async depth => {
+        if (depth <= 0) return 0;
+        return fixture.invoke(recursiveCallback, depth - 1);
+      });
+      await assertRejects(
+        () => fixture.invoke(recursiveCallback, 2),
+        /recursion depth 3 exceeds the configured maximum of 2/,
+        'callback recursion limit',
+      );
+      disposedCallback = asyncCallback;
+    });
+    await assertRejects(
+      () => fixture.invoke(disposedCallback, 1),
+      /disposed/,
+      'callback context disposal',
+    );
   } finally {
     await pynect.shutdown();
   }
 
-  console.log(`Python boundary verified: ${python.executable}`);
+  console.log(`Python ${python.version} boundary verified: ${python.executable}`);
+}
+
+async function assertRejects(action, pattern, label) {
+  try {
+    await action();
+  } catch (error) {
+    if (pattern.test(String(error?.message || error))) return;
+    throw new Error(`${label} failed with an unexpected error: ${error?.message || error}`);
+  }
+  throw new Error(`${label} did not reject.`);
 }
 
 function assertSuccess(result, label) {

package/src/native/callback_bridge.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <Python.h>
+#include <cstdint>
+
+namespace pynect {
+
+/** Create a Python callable backed by a registered JavaScript callback. */
+PyObject* createPythonCallback(uint32_t callbackId);
+
+} // namespace pynect

package/src/native/native-addon-loader.ts

@@ -18,15 +18,24 @@ export interface NativeAddonBuildOptions {
 export function loadOrBuildNativeAddon(options: NativeAddonBuildOptions): NativeAddon {
   let initialError: unknown = new Error('Native rebuild explicitly requested.');
   if (process.env['PYNECT_FORCE_BUILD'] !== '1') {
+    if (process.env['PYNECT_PREFER_LOCAL'] === '1') {
+      try {
+        return loadMatchingLocalAddon(options);
+      } catch (error) {
+        initialError = error;
+      }
+    }
     try {
       return loadMatchingPrebuild(options);
     } catch (error) {
       initialError = error;
     }
-    try {
-      return loadMatchingLocalAddon(options);
-    } catch (error) {
-      initialError = new AggregateError([initialError, error], 'No compatible native addon loaded.');
+    if (process.env['PYNECT_PREFER_LOCAL'] !== '1') {
+      try {
+        return loadMatchingLocalAddon(options);
+      } catch (error) {
+        initialError = new AggregateError([initialError, error], 'No compatible native addon loaded.');
+      }
     }
   }
 
@@ -72,10 +81,11 @@ interface NativeBuildMetadata {
 }
 
 interface NativePrebuildMetadata {
-  schemaVersion: 1;
+  schemaVersion: 2;
   platform: NodeJS.Platform;
   architecture: string;
-  pythonMajorMinor: string;
+  pythonMinimumVersion: string;
+  pythonAbi: string;
   napi: number;
   glibc?: string;
   pythonLibraryName: string;
@@ -91,17 +101,22 @@ function loadMatchingPrebuild(options: NativeAddonBuildOptions): NativeAddon {
   } catch (error) {
     throw new Error(`Native prebuild metadata is unavailable at ${metadataPath}.`, { cause: error });
   }
-  const pythonMajorMinor = options.pythonVersion.split('.').slice(0, 2).join('.');
+  const pythonVersion = majorMinor(options.pythonVersion);
+  const minimumVersion = typeof metadata.pythonMinimumVersion === 'string'
+    ? majorMinor(metadata.pythonMinimumVersion)
+    : [Number.POSITIVE_INFINITY, 0] as const;
   if (
-    metadata.schemaVersion !== 1 ||
+    metadata.schemaVersion !== 2 ||
     metadata.platform !== process.platform ||
     metadata.architecture !== process.arch ||
-    metadata.pythonMajorMinor !== pythonMajorMinor ||
+    metadata.pythonAbi !== 'cp310-abi3' ||
+    pythonVersion[0] !== 3 ||
+    compareMajorMinor(pythonVersion, minimumVersion) < 0 ||
     metadata.napi > Number(process.versions.napi ?? 0)
   ) {
     throw new Error(
       `Native prebuild does not match ${process.platform}-${process.arch}, ` +
-      `Python ${pythonMajorMinor}, N-API ${process.versions.napi ?? 'unknown'}.`,
+      `Python ${options.pythonVersion}, N-API ${process.versions.napi ?? 'unknown'}.`,
     );
   }
   if (process.platform === 'linux' && metadata.glibc) {
@@ -137,7 +152,7 @@ function materializePortablePrebuild(
     'node_modules',
     '.pynect',
     'native',
-    `${process.platform}-${process.arch}-python${metadata.pythonMajorMinor}-${identity}`,
+    `${process.platform}-${process.arch}-${metadata.pythonAbi}-${identity}`,
   );
   const addon = path.join(directory, 'pynect_addon.node');
   const library = path.join(directory, metadata.pythonLibraryName);
@@ -216,3 +231,16 @@ function compareVersions(left: string, right: string): number {
   }
   return 0;
 }
+
+function majorMinor(version: string): readonly [number, number] {
+  const match = version.match(/^(\d+)\.(\d+)/u);
+  if (!match) throw new Error(`Invalid Python version: ${version}`);
+  return [Number(match[1]), Number(match[2])];
+}
+
+function compareMajorMinor(
+  left: readonly [number, number],
+  right: readonly [number, number],
+): number {
+  return left[0] - right[0] || left[1] - right[1];
+}