@alisio/core 0.5.1 → 0.6.0

package/dist/forge/python/pyodide-manifest.js

@@ -0,0 +1,376 @@
+/**
+ * Pinned Pyodide distribution for the `wasm` Python backend (Python spec §8.1, PD7). A TypeScript
+ * constant, not JSON, because `tsc` does not copy JSON into `dist`. Every file carries its
+ * SHA-256 and size; `alisio analysis setup --wasm` is the only code that fetches them.
+ *
+ * - `pyodide` files come from the official jsDelivr mirror of the 314.0.7 release; the hashes of
+ *   the wheels are the ones of `pyodide-lock.json`, and the core files were checked against the
+ *   mirror (Phase P0, 2026-10-12).
+ * - `pypi` files are pure wheels that the Pyodide lock does not ship; their hashes are the ones
+ *   PyPI publishes. A raw wheel URL does not resolve dependencies, so `depends` lists them.
+ * - `sqlite3` is part of the standard library build and is deliberately not listed.
+ */
+export const PYODIDE_VERSION = "314.0.7";
+export const PYTHON_VERSION = "3.14.2";
+/** Files every profile needs (the runtime itself). */
+export const PYODIDE_CORE_FILES = [
+    {
+        name: "pyodide.mjs",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/pyodide.mjs",
+        sha256: "6f1d60f7bf529beb300f0f47983c921d3982363640ba20af0e38efdddbc66109",
+        size: 17931,
+        source: "pyodide",
+    },
+    {
+        name: "pyodide.asm.mjs",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/pyodide.asm.mjs",
+        sha256: "f7cdc8ece80678ceb712f8e65ebe6d3a83203a180c399865f49612a051693635",
+        size: 1250344,
+        source: "pyodide",
+    },
+    {
+        name: "pyodide.asm.wasm",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/pyodide.asm.wasm",
+        sha256: "cc36e3cab04fdfc9a63ff13eb52eae2b911bf46c025cc7b281f394bd3de1d5e6",
+        size: 9598218,
+        source: "pyodide",
+    },
+    {
+        name: "python_stdlib.zip",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/python_stdlib.zip",
+        sha256: "fa1957e5777068fc4f7437f96d860ae2fbe9c19732ba06c84e004ec16dd7dd7a",
+        size: 2545637,
+        source: "pyodide",
+    },
+    {
+        name: "pyodide-lock.json",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/pyodide-lock.json",
+        sha256: "5dc2fc119108bc148c7457dc86e7675b5c87e1cafd420b9c34c1eaef7b36c010",
+        size: 119077,
+        source: "pyodide",
+    },
+];
+/** Wheels by manifest key (the distribution name, normalized with dashes). */
+export const PYODIDE_PACKAGES = {
+    numpy: {
+        name: "numpy-2.4.6-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/numpy-2.4.6-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "a292c1f5d7d8a2208cd5e94fc467604c131cabcd2fc14fed6eefde121e7fabdf",
+        size: 2960568,
+        source: "pyodide",
+        depends: [],
+    },
+    pandas: {
+        name: "pandas-3.0.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/pandas-3.0.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "45ff57772cc2f366a8582c7d3097cc4e6676342ecd5a3c08184a43462d5a02ae",
+        size: 4177749,
+        source: "pyodide",
+        depends: ["numpy", "python-dateutil", "pytz"],
+    },
+    "python-dateutil": {
+        name: "python_dateutil-2.9.0.post0-py2.py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/python_dateutil-2.9.0.post0-py2.py3-none-any.whl",
+        sha256: "9b13365edf9c188f570baf9c540bbb3029ada2a2dacb9694b3659941693ee9e5",
+        size: 229892,
+        source: "pyodide",
+        depends: ["six"],
+    },
+    pytz: {
+        name: "pytz-2026.1.post1-py2.py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/pytz-2026.1.post1-py2.py3-none-any.whl",
+        sha256: "b8249d6450146e0b61e6d710dc02ebb35a904796c4c2f97fe87d4ac5872db36a",
+        size: 510489,
+        source: "pyodide",
+        depends: [],
+    },
+    six: {
+        name: "six-1.17.0-py2.py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/six-1.17.0-py2.py3-none-any.whl",
+        sha256: "228c50f73aa7addf2c2ccf2979c256802a59ab69cad8152b31b9443cc8140f42",
+        size: 11050,
+        source: "pyodide",
+        depends: [],
+    },
+    matplotlib: {
+        name: "matplotlib-3.10.8-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/matplotlib-3.10.8-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "722857932f8f62eac64f8439af15c94d427f9fb945f9590cd242805c983d2d54",
+        size: 6982033,
+        source: "pyodide",
+        depends: [
+            "contourpy",
+            "cycler",
+            "fonttools",
+            "kiwisolver",
+            "numpy",
+            "packaging",
+            "pillow",
+            "pyparsing",
+            "python-dateutil",
+            "pytz",
+        ],
+    },
+    contourpy: {
+        name: "contourpy-1.3.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/contourpy-1.3.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "0ac15ebf9f820d2d1c3526388aa2818b631cb6c4aae1682efd6b4cc12c1f302c",
+        size: 118874,
+        source: "pyodide",
+        depends: ["numpy"],
+    },
+    cycler: {
+        name: "cycler-0.12.1-py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/cycler-0.12.1-py3-none-any.whl",
+        sha256: "8ee450085f15b47f78b034d60059af6a3649e98fa5dde073363437742cc0b4ea",
+        size: 8321,
+        source: "pyodide",
+        depends: ["six"],
+    },
+    fonttools: {
+        name: "fonttools-4.62.1-py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/fonttools-4.62.1-py3-none-any.whl",
+        sha256: "0d1516e073fd0a8d8e6d9af46417b6a26209a42518024a18f7085e72d2599605",
+        size: 1152647,
+        source: "pyodide",
+        depends: [],
+    },
+    kiwisolver: {
+        name: "kiwisolver-1.5.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/kiwisolver-1.5.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "47781998156721147c128a3c74547d5703e0e3cc454d8203e629339368308a93",
+        size: 36616,
+        source: "pyodide",
+        depends: [],
+    },
+    packaging: {
+        name: "packaging-26.1-py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/packaging-26.1-py3-none-any.whl",
+        sha256: "565acbbea54da30348b6d68b6a54373e6f777987db9f1db6966b4b3a5060d303",
+        size: 95852,
+        source: "pyodide",
+        depends: [],
+    },
+    pillow: {
+        name: "pillow-12.2.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/pillow-12.2.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "e29838b7a756e4ee0f27a9cfa9a387ee0dfa2e9dd44be2dd595130b9f9d93ac3",
+        size: 1037806,
+        source: "pyodide",
+        depends: [],
+    },
+    pyparsing: {
+        name: "pyparsing-3.3.2-py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/pyparsing-3.3.2-py3-none-any.whl",
+        sha256: "f0dd8225b5f8e945980b400bd465b4b90cb0498a2eede0d9dbea98372f6110c5",
+        size: 122781,
+        source: "pyodide",
+        depends: [],
+    },
+    jinja2: {
+        name: "jinja2-3.1.6-py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/jinja2-3.1.6-py3-none-any.whl",
+        sha256: "9330ec9cf2241fb8fc352928ea5e72016bf82de1d3d3b71ffea52a093a3ebab8",
+        size: 134899,
+        source: "pyodide",
+        depends: ["markupsafe"],
+    },
+    markupsafe: {
+        name: "markupsafe-3.0.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/markupsafe-3.0.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "b44c364dc0d19e4210ce68ab77833c2b5d608f78fe6966263add4fc1fa667d97",
+        size: 9986,
+        source: "pyodide",
+        depends: [],
+    },
+    lxml: {
+        name: "lxml-6.1.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/lxml-6.1.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "6a0b98f57a538cb6af4868c3499efec2bb52f7ed59fed94b7fbf195d6e40281f",
+        size: 2145850,
+        source: "pyodide",
+        depends: [],
+    },
+    "typing-extensions": {
+        name: "typing_extensions-4.15.0-py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/typing_extensions-4.15.0-py3-none-any.whl",
+        sha256: "4fec68770a05408e668a4fa53d6bf4f0f684b9dacf820c7c5d6e97d3ad225e29",
+        size: 44613,
+        source: "pyodide",
+        depends: [],
+    },
+    scipy: {
+        name: "scipy-1.18.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/scipy-1.18.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "17ee329a957863516d1bb6a6aaa0c60576fac027e9cd3d43de27f58b5b599b50",
+        size: 14029750,
+        source: "pyodide",
+        depends: ["numpy"],
+    },
+    patsy: {
+        name: "patsy-1.0.2-py2.py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/patsy-1.0.2-py2.py3-none-any.whl",
+        sha256: "64e931013dc7c23d2661327531b04c4370605cd439cdee4bb1a55846c5f41771",
+        size: 121050,
+        source: "pyodide",
+        depends: ["numpy", "six"],
+    },
+    statsmodels: {
+        name: "statsmodels-0.14.6-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/statsmodels-0.14.6-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "8ee50091810f8ac540a4b94eeba777028cfe8200a78bc5367ea01ad2d6a3a951",
+        size: 8162663,
+        source: "pyodide",
+        depends: ["numpy", "scipy", "pandas", "patsy", "packaging"],
+    },
+    joblib: {
+        name: "joblib-1.5.3-py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/joblib-1.5.3-py3-none-any.whl",
+        sha256: "fb2860ff70d0b6b43a3df5e3ce52d3a938ad2fcacd80a3f2f3f37e930843e607",
+        size: 180317,
+        source: "pyodide",
+        depends: [],
+    },
+    threadpoolctl: {
+        name: "threadpoolctl-3.6.0-py3-none-any.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/threadpoolctl-3.6.0-py3-none-any.whl",
+        sha256: "3521783ffb6bf212e03fb67ec1955af206d6ba7ea09ac21f200875077bbbe7c2",
+        size: 18638,
+        source: "pyodide",
+        depends: [],
+    },
+    "scikit-learn": {
+        name: "scikit_learn-1.8.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        url: "https://cdn.jsdelivr.net/pyodide/v314.0.7/full/scikit_learn-1.8.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+        sha256: "432f560f54c5283d13e9d7c11dddc8bdf2f15aec326cc1d7314f600786154181",
+        size: 4449204,
+        source: "pyodide",
+        depends: ["scipy", "joblib", "threadpoolctl"],
+    },
+    openpyxl: {
+        name: "openpyxl-3.1.5-py2.py3-none-any.whl",
+        url: "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl",
+        sha256: "5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2",
+        size: 250910,
+        source: "pypi",
+        depends: ["et-xmlfile"],
+    },
+    "et-xmlfile": {
+        name: "et_xmlfile-2.0.0-py3-none-any.whl",
+        url: "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl",
+        sha256: "7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa",
+        size: 18059,
+        source: "pypi",
+        depends: [],
+    },
+    "python-docx": {
+        name: "python_docx-1.2.0-py3-none-any.whl",
+        url: "https://files.pythonhosted.org/packages/d0/00/1e03a4989fa5795da308cd774f05b704ace555a70f9bf9d3be057b680bcf/python_docx-1.2.0-py3-none-any.whl",
+        sha256: "3fd478f3250fbbbfd3b94fe1e985955737c145627498896a8a6bf81f4baf66c7",
+        size: 252987,
+        source: "pypi",
+        depends: ["lxml", "typing-extensions"],
+    },
+    narwhals: {
+        name: "narwhals-2.27.1-py3-none-any.whl",
+        url: "https://files.pythonhosted.org/packages/d1/89/5d4c86da1130d9059681e5b6cd7645df5c10279a6a079c5c37dcb2cc6f3f/narwhals-2.27.1-py3-none-any.whl",
+        sha256: "d057df13f5852b8e157596e82eb5e955fad267425df5e420e0ee9863da483b31",
+        size: 483211,
+        source: "pypi",
+        depends: [],
+    },
+    plotly: {
+        name: "plotly-7.1.0-py3-none-any.whl",
+        url: "https://files.pythonhosted.org/packages/e5/7d/905a3a3d51087515719058c94cfbda2ff0fc14417c20d557ae3e82d8b250/plotly-7.1.0-py3-none-any.whl",
+        sha256: "dbb7fa18afce40d0a8e80d1bf162eceb3faa0ce5a77fe741ad09a74cf78f53f3",
+        size: 9692368,
+        source: "pypi",
+        depends: ["narwhals", "packaging"],
+    },
+    "charset-normalizer": {
+        name: "charset_normalizer-3.5.2-py3-none-any.whl",
+        url: "https://files.pythonhosted.org/packages/fc/ad/d07d7862a62ffa6d79d68074d14823243dd235a77c45262acbf6adeb28bf/charset_normalizer-3.5.2-py3-none-any.whl",
+        sha256: "b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685",
+        size: 68872,
+        source: "pypi",
+        depends: [],
+    },
+    reportlab: {
+        name: "reportlab-5.0.1-py3-none-any.whl",
+        url: "https://files.pythonhosted.org/packages/db/cb/dacbc268cb68d0428ea2cbd85266195a9ab3e677449589ddae59bd7542ac/reportlab-5.0.1-py3-none-any.whl",
+        sha256: "1c36e6bb0e71780c72331eba60da7f602e8d4389a8723825af71342e49d791e8",
+        size: 1957258,
+        source: "pypi",
+        depends: ["pillow", "charset-normalizer"],
+    },
+};
+/** Explicit dependency closure per profile, in load order. `science` includes `analysis`. */
+export const PYODIDE_PROFILES = {
+    base: [],
+    analysis: [
+        "numpy",
+        "six",
+        "python-dateutil",
+        "pytz",
+        "pandas",
+        "contourpy",
+        "cycler",
+        "fonttools",
+        "kiwisolver",
+        "packaging",
+        "pillow",
+        "pyparsing",
+        "matplotlib",
+        "markupsafe",
+        "jinja2",
+        "et-xmlfile",
+        "openpyxl",
+        "lxml",
+        "typing-extensions",
+        "python-docx",
+        "narwhals",
+        "plotly",
+        "charset-normalizer",
+        "reportlab",
+    ],
+    science: [
+        "numpy",
+        "six",
+        "python-dateutil",
+        "pytz",
+        "pandas",
+        "contourpy",
+        "cycler",
+        "fonttools",
+        "kiwisolver",
+        "packaging",
+        "pillow",
+        "pyparsing",
+        "matplotlib",
+        "markupsafe",
+        "jinja2",
+        "et-xmlfile",
+        "openpyxl",
+        "lxml",
+        "typing-extensions",
+        "python-docx",
+        "narwhals",
+        "plotly",
+        "charset-normalizer",
+        "reportlab",
+        "scipy",
+        "patsy",
+        "statsmodels",
+        "joblib",
+        "threadpoolctl",
+        "scikit-learn",
+    ],
+};
+export const PYODIDE_MANIFEST = {
+    version: PYODIDE_VERSION,
+    python: PYTHON_VERSION,
+    core: PYODIDE_CORE_FILES,
+    packages: PYODIDE_PACKAGES,
+    profiles: PYODIDE_PROFILES,
+};
+export const PYODIDE_PROFILE_ORDER = ["base", "analysis", "science"];

package/dist/forge/python/pyodide-runner-source.d.ts

@@ -0,0 +1,2 @@
+/** The plain-JavaScript runner executed by the child `node` of the wasm Python backend. */
+export declare const PYODIDE_RUNNER_SOURCE: string;

package/dist/forge/python/pyodide-runner-source.js

@@ -0,0 +1,3 @@
+// Generated by scripts/pyodide-runner-source.ts from pyodide-runner.mjs. Do not edit.
+/** The plain-JavaScript runner executed by the child `node` of the wasm Python backend. */
+export const PYODIDE_RUNNER_SOURCE = '// Pyodide runner of the `wasm` Python backend (Python spec §8.2). Plain JavaScript on purpose: it\n// runs in a child `node` started with --permission, outside the Alisio bundle, and ships inside\n// `pyodide-runner-source.ts` (generated by scripts/pyodide-runner-source.ts) because the npm\n// package and the standalone binary carry no loose files.\n//\n// argv[2] is one JSON object: { dist, wheelsDir?, packages, wheels, job: { script, input, work,\n// out, scratch? } }. Environment: ALISIO_EXECUTION_ID, ALISIO_FORGE_NONCE, ALISIO_FORGE_ENGINE.\n// Exit code: the script\'s own (0 = ok, 1 = it raised), 70 when the runner itself failed.\n// The runner holds no secret: Python reaches this JavaScript through the FFI (verified in P0), so\n// everything it can do is bounded by the Permission Model flags the parent chose.\nimport fs from "node:fs";\nimport path from "node:path";\nimport { pathToFileURL } from "node:url";\n\nconst spec = JSON.parse(process.argv[2] ?? "{}");\nconst SCRATCH_CAP_BYTES = 64 * 1024 * 1024;\nconst started = performance.now();\n\n// 1. No network entry points for the script. Not a boundary (node:http is still reachable through\n//    the FFI on Node 22/24); it only closes the obvious doors and keeps Pyodide on node:fs.\nfor (const name of ["fetch", "WebSocket", "XMLHttpRequest", "EventSource", "navigator"]) {\n  try {\n    delete globalThis[name];\n  } catch {\n    /* non-configurable in this runtime */\n  }\n}\n\n// 2. Emscripten\'s NODEFS calls process.binding("constants"), which --permission denies.\nif (process.permission) {\n  process.binding = (name) => {\n    if (name === "constants") return { fs: fs.constants };\n    throw new Error(`process.binding(${name}) is disabled`);\n  };\n}\n\n// 3. process.kill could end the parent or any process of the user; replaced and frozen (D-32).\n//    A mitigation, not a boundary: the OS still lets the child signal its own group.\nconst denied = () => {\n  throw new Error("process.kill is disabled in the Alisio wasm runner");\n};\nfor (const name of ["kill", "_kill"]) {\n  try {\n    Object.defineProperty(process, name, {\n      value: denied,\n      writable: false,\n      configurable: false,\n      enumerable: true,\n    });\n  } catch {\n    /* already frozen */\n  }\n}\n\n// What the runner reports reaches the model: host absolute paths never do. The folders it was\n// given become placeholders; any other absolute path keeps only its last segment.\nconst KNOWN_PATHS = [\n  [spec.dist, "<dist>"],\n  [spec.job?.script, "<job>/script"],\n  [spec.job?.input, "<job>/input"],\n  [spec.job?.work, "<job>/work"],\n  [spec.job?.out, "<job>/out"],\n  [spec.job?.scratch, "<job>/scratch"],\n]\n  .filter(([host]) => typeof host === "string" && host.length > 1)\n  .sort((a, b) => b[0].length - a[0].length);\nconst redact = (text) => {\n  let result = String(text);\n  for (const [host, label] of KNOWN_PATHS) {\n    result = result.split(pathToFileURL(host).href).join(label).split(host).join(label);\n  }\n  return result.replace(\n    /(?<![\\w:.<>~-])(?:file:\\/\\/)?(?:[A-Za-z]:)?[\\\\/](?:[^\\s:()\'"\\\\/]+[\\\\/])+([^\\s:()\'"\\\\/]+)/g,\n    "<host>/$1",\n  );\n};\n\nconst fail = (message, code = 70) => {\n  process.stderr.write(`alisio wasm runner: ${redact(message)}\\n`, () => process.exit(code));\n};\n\n// An error thrown into a Node event handler (a Python callback that raised, say) would otherwise\n// end the process with Node\'s report, which quotes the Emscripten source: keep it to one line.\nconst brief = (error) =>\n  redact(String(error instanceof Error ? error.message : error).split("\\n")[0]);\nprocess.on("uncaughtException", (error) => fail(`uncaught exception: ${brief(error)}`));\nprocess.on("unhandledRejection", (error) => fail(`unhandled rejection: ${brief(error)}`));\n\nconst writeLine = (stream) => (line) => {\n  stream.write(`${line}\\n`);\n};\n\ntry {\n  const { loadPyodide } = await import(pathToFileURL(path.join(spec.dist, "pyodide.mjs")).href);\n  const py = await loadPyodide({\n    indexURL: `${spec.dist}/`,\n    lockFileURL: path.join(spec.dist, "pyodide-lock.json"),\n    packageCacheDir: `${spec.dist}/`,\n    env: {\n      ALISIO_INPUT_DIR: "/job/input",\n      ALISIO_OUTPUT_DIR: "/job/out",\n      ALISIO_WORK_DIR: "/job/work",\n      ALISIO_EXECUTION_ID: process.env.ALISIO_EXECUTION_ID ?? "",\n      ALISIO_FORGE_NONCE: process.env.ALISIO_FORGE_NONCE ?? "",\n      ALISIO_FORGE_ENGINE: process.env.ALISIO_FORGE_ENGINE ?? "python-wasm",\n      ...(spec.job.scratch ? { ALISIO_SCRATCH_DIR: "/job/scratch" } : {}),\n      MPLBACKEND: "Agg",\n      HOME: "/job/work",\n      TMPDIR: "/job/work",\n      PYTHONDONTWRITEBYTECODE: "1",\n    },\n    stdout: writeLine(process.stdout),\n    stderr: writeLine(process.stderr),\n  });\n\n  // 4. Only what the script needs: lock packages by name (their dependencies resolve from the\n  //    lock), then the pure wheels from the local folder, in the manifest\'s dependency order.\n  const messages = (m) => process.stderr.write(`${m}\\n`);\n  if (spec.packages.length)\n    await py.loadPackage(spec.packages, { messageCallback: () => {}, errorCallback: messages });\n  for (const wheel of spec.wheels)\n    await py.loadPackage(pathToFileURL(path.join(spec.dist, wheel)).href, {\n      messageCallback: () => {},\n      errorCallback: messages,\n    });\n\n  // 5. The job lives in Pyodide\'s own file system; only these folders are read from the host.\n  const copyIn = (hostDir, vDir, budget) => {\n    py.FS.mkdirTree(vDir);\n    let used = 0;\n    const walk = (host, virtual) => {\n      for (const entry of fs.readdirSync(host, { withFileTypes: true })) {\n        const from = path.join(host, entry.name);\n        const to = `${virtual}/${entry.name}`;\n        if (entry.isDirectory()) {\n          py.FS.mkdirTree(to);\n          walk(from, to);\n        } else if (entry.isFile()) {\n          const size = fs.statSync(from).size;\n          if (budget !== undefined && used + size > budget) continue;\n          used += size;\n          py.FS.writeFile(to, fs.readFileSync(from));\n        }\n      }\n    };\n    walk(hostDir, vDir);\n  };\n  for (const dir of ["/job", "/job/out"]) py.FS.mkdirTree(dir);\n  copyIn(spec.job.script, "/job/script");\n  copyIn(spec.job.input, "/job/input");\n  copyIn(spec.job.work, "/job/work");\n  if (spec.job.scratch) copyIn(spec.job.scratch, "/job/scratch", SCRATCH_CAP_BYTES);\n  py.FS.chdir("/job/work");\n\n  // The parent times the start from this file (not from a line, which would end up in the\n  // script\'s output and in the logs). Python can write it too; that only skews a metric.\n  fs.mkdirSync(path.join(spec.job.work, ".forge"), { recursive: true });\n  fs.writeFileSync(\n    path.join(spec.job.work, ".forge", "wasm-ready"),\n    String(Math.round(performance.now() - started)),\n  );\n\n  // 6. Run main.py as __main__ in a real module (dataclasses and pickling look it up in\n  //    sys.modules), with top-level await allowed; the exit code follows the script (SystemExit\n  //    included). Pyodide never finalizes the interpreter, so the atexit handlers (Forja\'s final\n  //    value) run here, after the script and also after a failure, as CPython would.\n  py.globals.set("_alisio_main", "/job/script/main.py");\n  const code = await py.runPythonAsync(`\nimport atexit, sys, traceback, types\nfrom pyodide.code import eval_code_async\n\nasync def _alisio_run(path):\n    sys.argv = [path]\n    sys.path.insert(0, "/job/script")\n    module = types.ModuleType("__main__")\n    module.__file__ = path\n    sys.modules["__main__"] = module\n    try:\n        with open(path, encoding="utf-8") as handle:\n            source = handle.read()\n        await eval_code_async(source, module.__dict__, filename=path, return_mode="none")\n        return 0\n    except SystemExit as exit_:\n        value = exit_.code\n        if value is None:\n            return 0\n        if isinstance(value, int):\n            return value & 255\n        print(value, file=sys.stderr)\n        return 1\n    except BaseException as error:\n        tb = error.__traceback__\n        while tb is not None and tb.tb_frame.f_code.co_filename != path:\n            tb = tb.tb_next\n        traceback.print_exception(type(error), error, tb if tb is not None else error.__traceback__)\n        return 1\n    finally:\n        try:\n            atexit._run_exitfuncs()\n            sys.stdout.flush()\n            sys.stderr.flush()\n        except BaseException:\n            traceback.print_exc()\n\nawait _alisio_run(_alisio_main)\n`);\n\n  // 7. Whatever the script left in /job/out goes to the real out folder (symlinks are not followed).\n  const copyOut = (virtual, host) => {\n    for (const name of py.FS.readdir(virtual)) {\n      if (name === "." || name === "..") continue;\n      const from = `${virtual}/${name}`;\n      const to = path.join(host, name);\n      const info = py.FS.lstat(from);\n      if (py.FS.isDir(info.mode)) {\n        fs.mkdirSync(to, { recursive: true });\n        copyOut(from, to);\n      } else if (py.FS.isFile(info.mode)) fs.writeFileSync(to, py.FS.readFile(from));\n    }\n  };\n  copyOut("/job/out", spec.job.out);\n\n  const exitCode = Number(code) | 0;\n  process.stdout.write("", () => process.stderr.write("", () => process.exit(exitCode)));\n} catch (error) {\n  fail(error instanceof Error ? (error.stack ?? error.message) : String(error));\n}\n';

package/dist/forge/python/rss.d.ts

@@ -0,0 +1,2 @@
+export type RssReader = (pid: number) => Promise<number | undefined>;
+export declare const readRssMb: RssReader;

package/dist/forge/python/rss.js

@@ -0,0 +1,33 @@
+/**
+ * Resident memory of a process in MiB, for the `wasm` backend's soft memory limit (PD13). Linux
+ * reads `/proc`; macOS and the BSDs ask `ps`; Windows asks `tasklist`. `undefined` when it cannot
+ * be read (the limit then is not enforced for that sample).
+ */
+import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
+function procRss(pid) {
+    try {
+        const match = /VmRSS:\s+(\d+) kB/.exec(readFileSync(`/proc/${pid}/status`, "utf8"));
+        return match ? Number(match[1]) / 1024 : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function run(command, args) {
+    return new Promise((resolve) => {
+        execFile(command, args, { timeout: 2000, windowsHide: true }, (error, out) => resolve(error ? undefined : String(out)));
+    });
+}
+export const readRssMb = async (pid) => {
+    if (process.platform === "linux")
+        return procRss(pid);
+    if (process.platform === "win32") {
+        const out = await run("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"]);
+        const kb = out ? /"([\d.,\s]+) K"\s*$/m.exec(out)?.[1]?.replace(/[^\d]/g, "") : undefined;
+        return kb ? Number(kb) / 1024 : undefined;
+    }
+    const out = await run("ps", ["-o", "rss=", "-p", String(pid)]);
+    const kb = out ? Number(out.trim()) : Number.NaN;
+    return Number.isFinite(kb) ? kb / 1024 : undefined;
+};

package/dist/forge/python/scratch-copy.d.ts

@@ -0,0 +1,6 @@
+/** Most bytes copied; larger files that do not fit are left out (the runner used the same cap). */
+export declare const SCRATCH_COPY_CAP_BYTES: number;
+export declare function copyScratchNoFollow(source: string, target: string, cap?: number): Promise<{
+    files: number;
+    bytes: number;
+}>;

package/dist/forge/python/scratch-copy.js

@@ -0,0 +1,61 @@
+/**
+ * A private copy of the scratchpad for the `wasm` backend. The Node Permission Model follows
+ * links that already exist, and Python reaches `node:fs` through the FFI, so granting the real
+ * scratchpad would also grant whatever a symbolic link inside it points at. The copy is made by
+ * the parent without ever following a link: links and special files are skipped, regular files
+ * are opened with `O_NOFOLLOW` where the platform has it, relative paths are kept.
+ */
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readdir } from "node:fs/promises";
+import { join } from "node:path";
+/** Most bytes copied; larger files that do not fit are left out (the runner used the same cap). */
+export const SCRATCH_COPY_CAP_BYTES = 64 * 1024 * 1024;
+/** Deepest directory level copied. */
+const MAX_DEPTH = 32;
+export async function copyScratchNoFollow(source, target, cap = SCRATCH_COPY_CAP_BYTES) {
+    await mkdir(target, { recursive: true, mode: 0o700 });
+    let files = 0;
+    let bytes = 0;
+    const walk = async (from, to, depth) => {
+        const entries = await readdir(from, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const src = join(from, entry.name);
+            const dst = join(to, entry.name);
+            const info = await lstat(src).catch(() => undefined);
+            if (!info)
+                continue;
+            if (info.isDirectory()) {
+                if (depth >= MAX_DEPTH)
+                    continue;
+                await mkdir(dst, { mode: 0o700 });
+                await walk(src, dst, depth + 1);
+            }
+            else if (info.isFile() && bytes + info.size <= cap) {
+                const handle = await open(src, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)).catch(() => undefined);
+                if (!handle)
+                    continue;
+                try {
+                    // The entry could have been swapped for something else since the lstat.
+                    const opened = await handle.stat();
+                    if (!opened.isFile() || bytes + opened.size > cap)
+                        continue;
+                    const contents = await handle.readFile();
+                    const out = await open(dst, "wx", 0o600);
+                    try {
+                        await out.writeFile(contents);
+                    }
+                    finally {
+                        await out.close();
+                    }
+                    files++;
+                    bytes += contents.length;
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+        }
+    };
+    await walk(source, target, 0);
+    return { files, bytes };
+}

package/dist/forge/python/settle.d.ts

@@ -0,0 +1,6 @@
+import type { TerminationReport } from "../ports.ts";
+import type { RunningProcess } from "./backend.ts";
+/** How long a stop waits for the process to be reported gone (the kill grace is 5 s). */
+export declare const SETTLE_MS = 12000;
+/** Waits for an aborted process to settle and says whether that was confirmed in time. */
+export declare function settle(process: RunningProcess, method: TerminationReport["method"], started: number): Promise<TerminationReport>;

package/dist/forge/python/settle.js

@@ -0,0 +1,21 @@
+/** How long a stop waits for the process to be reported gone (the kill grace is 5 s). */
+export const SETTLE_MS = 12_000;
+/** Waits for an aborted process to settle and says whether that was confirmed in time. */
+export async function settle(process, method, started) {
+    const done = process.result.then(() => true, () => true);
+    let timer;
+    const confirmed = await Promise.race([
+        done,
+        new Promise((resolve) => {
+            timer = setTimeout(() => resolve(false), SETTLE_MS);
+            timer.unref?.();
+        }),
+    ]);
+    clearTimeout(timer);
+    return {
+        confirmed,
+        method,
+        elapsedMs: Date.now() - started,
+        ...(confirmed ? {} : { settled: done.then(() => undefined) }),
+    };
+}

package/dist/forge/python/status.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The live state of the Python backends for `alisio analysis status`, `alisio forge status` and the
+ * API (Python spec §9.2-9.3). A descriptor says what a backend IS; readiness says whether it can
+ * run now, so the two are merged here: `ready` and `reason` come from `check()`.
+ */
+import type { EngineDescriptor } from "@alisio/sdk";
+import type { PythonBackend, PythonBackendId } from "./backend.ts";
+export declare function describePythonBackends(backends: Partial<Record<PythonBackendId, PythonBackend>>, signal?: AbortSignal): Promise<EngineDescriptor[]>;

package/dist/forge/python/status.js

@@ -0,0 +1,15 @@
+/** Reading order: most isolated first, like `auto`. */
+const ORDER = ["oci", "wasm", "managed"];
+export async function describePythonBackends(backends, signal) {
+    const found = ORDER.flatMap((id) => {
+        const backend = backends[id];
+        return backend ? [backend] : [];
+    });
+    return Promise.all(found.map(async (backend) => {
+        const { reason: _own, ...descriptor } = await backend.describe();
+        const state = await backend.check(signal);
+        return state.ready
+            ? { ...descriptor, ready: true }
+            : { ...descriptor, ready: false, reason: state.reason };
+    }));
+}

package/dist/forge/python/wasm-node.d.ts

@@ -0,0 +1,59 @@
+export declare const MIN_NODE: {
+    readonly major: 22;
+    readonly minor: 22;
+};
+export type NodeResolution = {
+    ok: true;
+    path: string;
+    version: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface NodeEnvironment {
+    /** Running under Bun (the standalone binary): `process.execPath` is not a Node. */
+    isBun: boolean;
+    execPath: string;
+    /** `process.version` of the running Node. */
+    version: string;
+    /** The `PATH` to search under Bun. */
+    pathEnv: string;
+    platform: NodeJS.Platform;
+}
+export declare const currentNodeEnvironment: () => NodeEnvironment;
+/** `v22.22.0` -> true: at least the release of its line that fixed CVE-2025-55130. */
+export declare function isSupportedNode(version: string): boolean;
+/** Finds the node to run Pyodide with; only successes are remembered. */
+export declare function resolveNode(configured: string | null | undefined, environment?: NodeEnvironment): Promise<NodeResolution>;
+/** Clears remembered resolutions and probes (tests, and a changed PATH). */
+export declare function resetNodeCaches(): void;
+/**
+ * The flags of the restricted child: the Permission Model with ONE flag per path (a comma list is
+ * invalid in Node 22), reading only the distribution and the job, writing only `work/` and `out/`.
+ * No `--allow-child-process`, `--allow-worker`, `--allow-addons` or `--allow-wasi`; on Node >= 25
+ * `--allow-net` is likewise left out.
+ */
+export declare function permissionArgs(paths: {
+    read: readonly string[];
+    write: readonly string[];
+}): string[];
+/** Environment of the child: nothing but the job's `ALISIO_*` variables. */
+export declare function childEnv(vars: Record<string, string>, platform?: NodeJS.Platform): Record<string, string>;
+export interface NetworkProbeResult {
+    /**
+     * The Permission Model refused the connection (`ERR_ACCESS_DENIED`). `false` also when the probe
+     * was not conclusive: any other failure (refused, unreachable, no route) says nothing about it.
+     */
+    denied: boolean;
+    detail: string;
+    /** The child gave an answer that settles the question (connected, or refused by the Permission Model). */
+    conclusive?: boolean;
+}
+/**
+ * Starts `node` with the real flags and tries to reach a port of ours. Remembered per binary and
+ * version (the flags do not change what the network flag does). Inconclusive means "not denied".
+ */
+export declare function probeNetwork(node: {
+    path: string;
+    version: string;
+}, args: readonly string[]): Promise<NetworkProbeResult>;