@dbx-tools/projen 0.9.51 → 0.9.54

package/src/workspace-lock.ts

@@ -4,6 +4,7 @@ import * as fileLock from "@dbx-tools/core/file-lock";
 import { log } from "@dbx-tools/shared-core";
 
 const MUTATION_LOCK_SCOPE = "dbx-tools-workspace-mutation";
+const WAIT_LOG_INTERVAL_MS = 5_000;
 const logger = log.logger("projen:workspace-lock");
 
 /** Optional preflight used before and after acquiring the workspace mutation lock. */
@@ -33,17 +34,34 @@ export async function withWorkspaceMutationLock<T>(
   if (check && !(await check())) {
     return undefined;
   }
-  return fileLock.withFileLock(
-    [MUTATION_LOCK_SCOPE, repository],
-    async () => {
-      if (check && !(await check())) {
-        return undefined;
-      }
-      return callback();
-    },
-    {
-      backends: process.platform === "win32" ? ["file"] : ["flock", "file"],
-      onWait: () => logger.info("waiting for workspace mutation lock", { repository }),
-    },
-  );
+  let waitLogTimer: ReturnType<typeof setInterval> | undefined;
+  try {
+    return await fileLock.withFileLock(
+      [MUTATION_LOCK_SCOPE, repository],
+      async () => {
+        if (check && !(await check())) {
+          return undefined;
+        }
+        return callback();
+      },
+      {
+        backends: process.platform === "win32" ? ["file"] : ["flock", "file"],
+        onWait: () => {
+          if (waitLogTimer) return;
+          const startedAt = Date.now();
+          waitLogTimer = setInterval(
+            () =>
+              logger.info("waiting for workspace mutation lock", {
+                repository,
+                elapsedMs: Date.now() - startedAt,
+              }),
+            WAIT_LOG_INTERVAL_MS,
+          );
+          waitLogTimer.unref?.();
+        },
+      },
+    );
+  } finally {
+    if (waitLogTimer) clearInterval(waitLogTimer);
+  }
 }

package/tasks/publish-python.ts

@@ -79,11 +79,9 @@ export function publishPythonProjects(options: {
   readonly root: string;
   readonly version: string;
 }): void {
-  const root = resolve(options.root);
-  const workspace = projectUtils.root(root) ?? dirname(root);
-  const output = mkdtempSync(join(workspace, ".projen-python-publish-"));
+  const output = mkdtempSync(join(tmpdir(), "projen-python-publish-"));
   try {
-    buildPythonProjects({ ...options, output });
+    buildPythonProjectsInternal({ ...options, output }, true);
     runTaskCommand(
       process.cwd(),
       "uvx",
@@ -101,7 +99,7 @@ export function publishPythonProjects(options: {
       { env: { ...process.env, UV_DEFAULT_INDEX: options.indexUrl } },
     );
   } finally {
-    rmSync(output, { recursive: true, force: true });
+    removeTemporaryTree(output);
   }
 }
 
@@ -115,11 +113,21 @@ export function buildPythonProjects(options: {
   readonly root: string;
   readonly version: string;
 }): void {
+  buildPythonProjectsInternal(options, false);
+}
+
+function buildPythonProjectsInternal(
+  options: Parameters<typeof buildPythonProjects>[0],
+  allowOutputOutsideWorkspace: boolean,
+): void {
   const root = resolve(options.root);
   const output = resolve(options.output);
   const workspace = projectUtils.root(root) ?? dirname(root);
   const outputPath = relative(workspace, output);
-  if (!outputPath || outputPath.startsWith("..") || isAbsolute(outputPath)) {
+  if (
+    !allowOutputOutsideWorkspace &&
+    (!outputPath || outputPath.startsWith("..") || isAbsolute(outputPath))
+  ) {
     throw new Error("Python release output must be a non-root directory inside the workspace");
   }
   rmSync(output, { recursive: true, force: true });

package/tasks/python-localize-imports.py

@@ -0,0 +1,188 @@
+"""Rewrite absolute imports of synchronized upstream modules to their generated package.
+
+Usage: python-localize-imports.py ROOT TARGET SOURCE [MODULE ...]
+
+ROOT holds the synchronized ``.py`` tree and is importable as the dotted package
+TARGET. SOURCE is the dotted path ROOT had upstream (empty when it has none), so
+upstream may import a synchronized module either bare (``config.schema``) or under
+SOURCE (``graphiti_core.driver.postgraph``). MODULE names the upstream modules to
+rewrite; without any, every top-level module in ROOT is rewritten in both forms.
+
+Covers ``import``, ``from ... import``, and constant-string ``__import__`` /
+``importlib.import_module`` calls. Prints a JSON object mapping each MODULE to the
+number of references rewritten.
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+import re
+import sys
+from pathlib import Path
+
+FROM_MODULE = re.compile(r"from\s+([^\W\d]\w*(?:\s*\.\s*[^\W\d]\w*)*)")
+DYNAMIC_IMPORTS = {"__import__", "import_module"}
+
+
+class Localizer:
+    def __init__(self, root: Path, target: str, source: str, modules: list[str]) -> None:
+        self.target = target
+        self.source = source
+        local = local_modules(root)
+        if modules:
+            self.modules = modules
+            for module in modules:
+                if self.local_name(module).split(".", 1)[0] not in local:
+                    raise SystemExit(f"localize_imports module {module!r} is not synchronized")
+        else:
+            shadowed = sorted(local & set(sys.stdlib_module_names))
+            if shadowed:
+                raise SystemExit(
+                    f"synchronized modules shadow the standard library: {', '.join(shadowed)}; "
+                    "list localize_imports modules explicitly"
+                )
+            self.modules = sorted(local) + (
+                [f"{source}.{name}" for name in sorted(local)] if source else []
+            )
+        # Longest first, so a nested entry owns its imports over its parent.
+        self.ordered = sorted(self.modules, key=len, reverse=True)
+        self.counts = dict.fromkeys(self.modules, 0)
+
+    def local_name(self, name: str) -> str:
+        if self.source and name.startswith(f"{self.source}."):
+            return name[len(self.source) + 1 :]
+        return name
+
+    def owner(self, name: str) -> str | None:
+        return next(
+            (module for module in self.ordered if name == module or name.startswith(f"{module}.")),
+            None,
+        )
+
+    def rewrite(self, name: str) -> str | None:
+        module = self.owner(name)
+        if module is None:
+            return None
+        self.counts[module] += 1
+        return f"{self.target}.{self.local_name(name)}"
+
+    def localize(self, path: Path) -> None:
+        data = path.read_bytes()
+        tree = ast.parse(data, filename=str(path))
+        starts = [0]
+        for line in data.splitlines(keepends=True):
+            starts.append(starts[-1] + len(line))
+
+        def span(node: ast.AST) -> tuple[int, int]:
+            # AST columns are UTF-8 byte offsets within their line.
+            return (
+                starts[node.lineno - 1] + node.col_offset,
+                starts[node.end_lineno - 1] + node.end_col_offset,
+            )
+
+        edits: list[tuple[int, int, bytes]] = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom):
+                if node.level or not node.module:
+                    continue
+                local = self.rewrite(node.module)
+                if local is None:
+                    continue
+                start, end = span(node)
+                text = data[start:end].decode()
+                found = FROM_MODULE.match(text)
+                if not found or re.sub(r"\s", "", found[1]) != node.module:
+                    raise SystemExit(f"{path}:{node.lineno}: cannot locate module in {text!r}")
+                edits.append(
+                    (
+                        start + len(text[: found.start(1)].encode()),
+                        start + len(text[: found.end(1)].encode()),
+                        local.encode(),
+                    )
+                )
+            elif isinstance(node, ast.Import):
+                if not any(self.owner(alias.name) for alias in node.names):
+                    continue
+                statements = [self.import_statement(path, node, alias) for alias in node.names]
+                start, end = span(node)
+                edits.append((start, end, "; ".join(statements).encode()))
+            elif isinstance(node, ast.Call) and self.is_dynamic_import(node):
+                argument = node.args[0]
+                local = self.rewrite(argument.value)
+                if local is None:
+                    continue
+                if self.returns_top_level(node):
+                    # Without a fromlist, `__import__` returns the top-level package.
+                    raise SystemExit(
+                        f"{path}:{node.lineno}: pass a fromlist to localize __import__"
+                    )
+                start, end = span(argument)
+                text = data[start:end].decode()
+                if argument.value not in text:
+                    raise SystemExit(f"{path}:{node.lineno}: cannot rewrite escaped {text!r}")
+                edits.append((start, end, text.replace(argument.value, local, 1).encode()))
+        if not edits:
+            return
+        for start, end, replacement in sorted(edits, reverse=True):
+            data = data[:start] + replacement + data[end:]
+        ast.parse(data, filename=str(path))
+        path.write_bytes(data)
+
+    def import_statement(self, path: Path, node: ast.Import, alias: ast.alias) -> str:
+        local = self.rewrite(alias.name)
+        if local is None:
+            return f"import {alias.name}" + (f" as {alias.asname}" if alias.asname else "")
+        if alias.asname:
+            return f"import {local} as {alias.asname}"
+        binding, _, submodule = self.local_name(alias.name).partition(".")
+        if binding != alias.name.split(".", 1)[0]:
+            # `import pkg.sub` binds `pkg`, which no longer names the synchronized tree.
+            raise SystemExit(f"{path}:{node.lineno}: alias `import {alias.name}` to localize it")
+        if not submodule:
+            return f"from {self.target} import {binding}"
+        return f"import {local}; from {self.target} import {binding}"
+
+    @staticmethod
+    def is_dynamic_import(node: ast.Call) -> bool:
+        function = node.func
+        name = function.id if isinstance(function, ast.Name) else getattr(function, "attr", None)
+        return (
+            name in DYNAMIC_IMPORTS
+            and bool(node.args)
+            and isinstance(node.args[0], ast.Constant)
+            and isinstance(node.args[0].value, str)
+            and not node.args[0].value.startswith(".")
+        )
+
+    @staticmethod
+    def returns_top_level(node: ast.Call) -> bool:
+        if not isinstance(node.func, ast.Name) or node.func.id != "__import__":
+            return False
+        return len(node.args) < 4 and not any(
+            keyword.arg == "fromlist" for keyword in node.keywords
+        )
+
+
+def local_modules(root: Path) -> set[str]:
+    names = set()
+    for path in root.rglob("*.py"):
+        parts = path.relative_to(root).parts
+        name = parts[0] if len(parts) > 1 else path.stem
+        if name.isidentifier() and name != "__init__":
+            names.add(name)
+    return names
+
+
+def main(argv: list[str]) -> None:
+    if len(argv) < 3:
+        raise SystemExit(__doc__)
+    root, target, source, *modules = argv
+    localizer = Localizer(Path(root), target, source, modules)
+    for path in sorted(Path(root).rglob("*.py")):
+        localizer.localize(path)
+    print(json.dumps(localizer.counts))
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

package/tasks/python-node-bindings-watch.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env -S bun
+/** Keep every configured Python Node bridge current with one repository watcher. */
+import { dirname, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { log } from "@dbx-tools/shared-core";
+import { runTaskCommand } from "../src/_task-command.ts";
+import { repoRoot } from "../src/packages.ts";
+import {
+  affectedPythonNodeBindingProjects,
+  generatePythonNodeBindings,
+  pythonNodeBindingWatchInputs,
+  resolveAllPythonNodeBindings,
+  type ResolvedPythonNodeBindings,
+} from "../src/python-node-bindings.ts";
+import { watchLoop, watchRoots } from "../src/watch.ts";
+import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
+
+const logger = log.logger("projen:python-node-bindings-watch");
+const generator = fileURLToPath(new URL("./python-node-bindings.ts", import.meta.url));
+
+function generate(project: string): void {
+  runTaskCommand(repoRoot, "bun", [generator, "--root", repoRoot, "--project", project]);
+}
+
+function containsPath(parent: string, candidate: string): boolean {
+  const resolvedParent = resolve(parent);
+  const resolvedCandidate = resolve(candidate);
+  return (
+    resolvedCandidate === resolvedParent || resolvedCandidate.startsWith(`${resolvedParent}${sep}`)
+  );
+}
+
+/**
+ * Watch broad package roots, each configured Python workspace root, and only
+ * exceptional inputs such as function overrides that live outside those roots.
+ */
+function watchPaths(configs: readonly ResolvedPythonNodeBindings[]): string[] {
+  const roots = watchRoots();
+  const pythonRoots = configs.map(({ projectDirectory }) => dirname(projectDirectory));
+  const covered = [...roots, ...pythonRoots];
+  const explicitInputs = configs
+    .flatMap(pythonNodeBindingWatchInputs)
+    .filter((input) => !covered.some((root) => containsPath(root, input)));
+  return [...new Set([...covered, ...explicitInputs])].sort();
+}
+
+function selection(
+  previous: readonly ResolvedPythonNodeBindings[],
+  changed: readonly string[],
+): {
+  readonly all: boolean;
+  readonly configs: ResolvedPythonNodeBindings[];
+  readonly projects: string[];
+} {
+  const configs = resolveAllPythonNodeBindings(repoRoot);
+  const manifests = new Set([...previous, ...configs].map(({ pyproject }) => resolve(pyproject)));
+  const all = changed.some((path) => manifests.has(resolve(path)));
+  return {
+    all,
+    configs,
+    projects: all ? [] : affectedPythonNodeBindingProjects(repoRoot, configs, changed),
+  };
+}
+
+/** Generate once, then rebuild only bridges affected by each debounced change batch. */
+export async function main(): Promise<void> {
+  let configs = resolveAllPythonNodeBindings(repoRoot);
+  await withWorkspaceMutationLock(repoRoot, () => generatePythonNodeBindings(repoRoot));
+  logger.success("generated all Python Node bindings");
+
+  watchLoop(
+    "python-node-bindings",
+    watchPaths(configs),
+    (changed) => {
+      const next = selection(configs, changed);
+      configs = next.configs;
+      if (next.all) {
+        generatePythonNodeBindings(repoRoot);
+        logger.success("regenerated all Python Node bindings");
+        return;
+      }
+      for (const project of next.projects) {
+        generate(project);
+        logger.success(`regenerated ${project} Node bindings`);
+      }
+    },
+    {
+      check: (changed) => {
+        const next = selection(configs, changed);
+        return next.all || next.projects.length > 0;
+      },
+    },
+  );
+}
+
+if (import.meta.main) await main();

package/tasks/python-node-bindings.ts

@@ -13,12 +13,14 @@ import stdLibBrowser from "node-stdlib-browser";
 import ts from "typescript";
 import { header, makeReadonly, makeWritable } from "../src/generated.ts";
 import { publicFunctionExports, publicNamespaceExports } from "../src/module-exports.ts";
+import { resolveRepoRoot } from "../src/packages.ts";
 import {
-  PYTHON_NODE_SHIM_ROOT,
+  generatePythonNodeBindings,
   resolvePythonNodeBindings,
   type ResolvedPythonNodeBindings,
   type ResolvedPythonNodeFunctionOverride,
 } from "../src/python-node-bindings.ts";
+import { PYTHON_NODE_RUNTIME_MODULE } from "../src/python-node-runtime.ts";
 
 const logger = log.logger("projen:python-node-bindings");
 
@@ -81,11 +83,15 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
       root: { type: "string" },
     },
   });
-  if (!values.project) throw new Error("Expected --project <python-project-directory>");
+  const root = values.root ? resolve(values.root) : resolveRepoRoot();
+  if (!values.project) {
+    if (values.binding !== undefined || values.module !== undefined) {
+      throw new Error("--binding and --module require --project");
+    }
+    generatePythonNodeBindings(root, { check: values.check });
+    return;
+  }
 
-  const root = values.root
-    ? resolve(values.root)
-    : resolve(dirname(fileURLToPath(import.meta.url)), "../..");
   const configs = resolvePythonNodeBindings(root, values.project).map(discoverBindingModules);
   if (configs.length > 1 && configs.some(({ modules }) => modules.length === 0)) {
     throw new Error(
@@ -161,21 +167,21 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
     functionsByPythonName.set(functionName.pythonName, functionName.javascriptName);
   }
 
-  const shimRoot = PYTHON_NODE_SHIM_ROOT;
   const overridesByModule = groupOverrides(
     configs.flatMap(({ functionOverrides }) => functionOverrides),
   );
   const shimEntry = "dbx-tools:python-entry";
   const functionOverrideNamespace = "dbx-tools-function-override";
-  const shimAliases = new Map([
-    ["child_process", resolve(shimRoot, "child-process.ts")],
-    ["crypto", resolve(shimRoot, "crypto.ts")],
-    ["fs", resolve(shimRoot, "fs.ts")],
-    ["fs/promises", resolve(shimRoot, "fs-promises.ts")],
-    ["os", resolve(shimRoot, "os.ts")],
-    ["process", resolve(shimRoot, "process.ts")],
-    ["readline", resolve(shimRoot, "readline.ts")],
+  const runtimeBuiltins = new Set([
+    "child_process",
+    "crypto",
+    "fs",
+    "fs/promises",
+    "os",
+    "process",
+    "readline",
   ]);
+  const runtimeBuiltinNamespace = "dbx-tools-node-runtime-builtin";
   const bridgeSource = [
     "export const __pythonGet = (target, name) => target[name];",
     "export const __pythonInvokePositioned = (fn, entries) => {",
@@ -240,12 +246,18 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
         namespace: "dbx-tools-python",
       }));
       build.onLoad({ filter: /.*/, namespace: "dbx-tools-python" }, () => ({
+        contents: [bridgeSource, ...runtimeExports].join("\n"),
+        loader: "ts",
+      }));
+      build.onLoad({ filter: /.*/, namespace: runtimeBuiltinNamespace }, ({ path }) => ({
         contents: [
-          `import ${JSON.stringify(resolve(shimRoot, "bootstrap.ts"))};`,
-          bridgeSource,
-          ...runtimeExports,
+          'const runtime = globalThis[Symbol.for("@dbx-tools/node-runtime/runtime")];',
+          "if (!runtime) throw new Error('dbx-tools-node-runtime was not loaded before its generated bundle');",
+          `const builtin = runtime.modules[${JSON.stringify(`node:${path}`)}] ?? runtime.modules[${JSON.stringify(path)}];`,
+          `if (!builtin) throw new Error(${JSON.stringify(`dbx-tools-node-runtime does not provide ${path}`)});`,
+          "module.exports = builtin;",
         ].join("\n"),
-        loader: "ts",
+        loader: "js",
       }));
       build.onLoad({ filter: /.*/, namespace: functionOverrideNamespace }, ({ path }) => {
         const overrides = overridesByModule.get(path);
@@ -272,8 +284,9 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
           return { path, namespace: functionOverrideNamespace };
         }
         const moduleName = path.replace(/^node:/, "");
-        const shim = shimAliases.get(moduleName) ?? shimAliases.get(path);
-        if (shim) return { path: shim };
+        if (runtimeBuiltins.has(moduleName)) {
+          return { path: moduleName, namespace: runtimeBuiltinNamespace };
+        }
         const standard = standardAliases[moduleName];
         return standard
           ? { path: Bun.resolveSync(standard, dirname(fileURLToPath(import.meta.url))) }
@@ -1172,125 +1185,27 @@ function pythonRuntimeLoader(source: string): string {
     "",
     "from __future__ import annotations",
     "",
-    "import asyncio",
-    "import inspect",
-    "from dataclasses import fields, is_dataclass",
     "from pathlib import Path",
-    "from threading import Lock",
     "from typing import Any",
     "",
-    "import pythonmonkey as pm",
-    "import pythonmonkey.require",
+    `from ${PYTHON_NODE_RUNTIME_MODULE} import MISSING, RuntimeBundle, load_bundle`,
     "",
-    "_RUNTIME: Any | None = None",
-    "_LOCK = Lock()",
-    "MISSING = object()",
+    "_RUNTIME: RuntimeBundle | None = None",
     "",
     "",
-    "def _load_runtime() -> Any:",
-    "    try:",
-    "        asyncio.get_running_loop()",
-    "    except RuntimeError:",
-    "        async def load() -> Any:",
-    '            return pm.require(str(Path(__file__).with_name("_runtime.js")))',
-    "",
-    "        return asyncio.run(load())",
-    '    return pm.require(str(Path(__file__).with_name("_runtime.js")))',
-    "",
-    "",
-    "def get_runtime() -> Any:",
+    "def get_runtime() -> RuntimeBundle:",
     "    global _RUNTIME",
     "    if _RUNTIME is None:",
-    "        with _LOCK:",
-    "            if _RUNTIME is None:",
-    "                _RUNTIME = _load_runtime()",
+    '        _RUNTIME = load_bundle(Path(__file__).with_name("_runtime.js"), bundle_id=__name__)',
     "    return _RUNTIME",
     "",
     "",
-    "def _module(name: str) -> Any:",
-    '    return get_runtime()["__pythonModule"](name)',
-    "",
-    "",
-    "def _snake_to_camel(name: str) -> str:",
-    '    head, *tail = name.split("_")',
-    '    return head + "".join(part[:1].upper() + part[1:] for part in tail)',
-    "",
-    "",
-    "def _to_javascript(value: Any) -> Any:",
-    "    if isinstance(value, _NodeObject):",
-    "        return value._target",
-    "    if is_dataclass(value) and not isinstance(value, type):",
-    "        return {",
-    '            item.metadata.get("javascript_name", item.name): _to_javascript(field_value)',
-    "            for item in fields(value)",
-    "            if (field_value := getattr(value, item.name)) is not None",
-    "        }",
-    "    if isinstance(value, dict):",
-    "        return {key: _to_javascript(item) for key, item in value.items()}",
-    "    if isinstance(value, (list, tuple)):",
-    "        return [_to_javascript(item) for item in value]",
-    "    return value",
-    "",
-    "",
-    "def _from_javascript(value: Any) -> Any:",
-    "    if isinstance(value, str):",
-    '        return value.encode("utf-8").decode("utf-8")',
-    "    if value is None or isinstance(value, (int, float, bool)):",
-    "        return value",
-    '    kind = get_runtime()["__pythonKind"](value)',
-    '    if kind == "instance":',
-    "        return _NodeObject(value)",
-    '    if kind == "array":',
-    "        return [_from_javascript(item) for item in value]",
-    '    if kind == "record":',
-    "        return {str(key): _from_javascript(item) for key, item in value.items()}",
-    "    return value",
-    "",
-    "",
-    "async def _resolve(value: Any) -> Any:",
-    "    if inspect.isawaitable(value):",
-    "        value = await value",
-    "    return _from_javascript(value)",
-    "",
-    "",
-    "class _NodeObject:",
-    "    def __init__(self, target: Any) -> None:",
-    "        self._target = target",
-    "",
-    "    def __getattr__(self, name: str) -> Any:",
-    "        javascript_name = _snake_to_camel(name)",
-    '        value = get_runtime()["__pythonGet"](self._target, javascript_name)',
-    "        if not callable(value):",
-    "            return _from_javascript(value)",
-    "",
-    "        async def invoke(*args: Any) -> Any:",
-    '            result = await get_runtime()["__pythonInvokeMethod"](',
-    "                self._target,",
-    "                javascript_name,",
-    "                [_to_javascript(arg) for arg in args],",
-    "            )",
-    '            if result["ok"]:',
-    '                return _from_javascript(result["value"])',
-    '            error = result["error"]',
-    "            message = f\"{error['name']}: {error['message']}\"",
-    '            if error.get("stack"):',
-    "                message = f\"{message}\\n{error['stack']}\"",
-    "            raise RuntimeError(message)",
-    "",
-    "        return invoke",
-    "",
-    "",
     "async def invoke_positioned(",
     "    module: str,",
     "    name: str,",
     "    arguments: list[tuple[int, Any]],",
     ") -> Any:",
-    "    return await _resolve(",
-    '        get_runtime()["__pythonInvokePositioned"](',
-    "            _module(module)[name],",
-    "            [[index, _to_javascript(value)] for index, value in arguments],",
-    "        ),",
-    "    )",
+    "    return await get_runtime().invoke_positioned(module, name, arguments)",
     "",
     "",
     "def invoke_positioned_sync(",
@@ -1298,12 +1213,7 @@ function pythonRuntimeLoader(source: string): string {
     "    name: str,",
     "    arguments: list[tuple[int, Any]],",
     ") -> Any:",
-    "    return _from_javascript(",
-    '        get_runtime()["__pythonInvokePositioned"](',
-    "            _module(module)[name],",
-    "            [[index, _to_javascript(value)] for index, value in arguments],",
-    "        ),",
-    "    )",
+    "    return get_runtime().invoke_positioned_sync(module, name, arguments)",
     "",
   ].join("\n");
 }

package/tasks/python-node-runtime-watch.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env -S bun
+/** Keep the one package-owned PythonMonkey shim runtime current. */
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { log } from "@dbx-tools/shared-core";
+import { runTaskCommand } from "../src/_task-command.ts";
+import { repoRoot } from "../src/packages.ts";
+import { watchLoop } from "../src/watch.ts";
+import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
+
+const logger = log.logger("projen:python-node-runtime-watch");
+
+export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
+  const { values } = parseArgs({
+    args,
+    options: { project: { type: "string" } },
+    strict: true,
+  });
+  const project = values.project?.trim();
+  if (!project) throw new Error("--project is required");
+
+  const projectDirectory = resolve(repoRoot, project);
+  const buildScript = resolve(projectDirectory, "build-runtime.ts");
+  const shimDirectory = resolve(projectDirectory, "shims");
+  for (const path of [buildScript, shimDirectory]) {
+    if (!existsSync(path)) throw new Error(`Node runtime input does not exist: ${path}`);
+  }
+
+  const build = (): void => runTaskCommand(repoRoot, "bun", [buildScript]);
+  await withWorkspaceMutationLock(repoRoot, build);
+  logger.success("built shared Python Node runtime");
+
+  watchLoop("python-node-runtime", [buildScript, shimDirectory], () => {
+    build();
+    logger.success("rebuilt shared Python Node runtime");
+  });
+}
+
+if (import.meta.main) await main();