@pyscript/core 0.2.10 → 0.3.1

package/dist/error-96hMSEw8.js

@@ -0,0 +1,2 @@
+import{hooks as e}from"./core.js";function o(e){const o=document.createElement("div");o.className="py-error",o.textContent=e,o.style.cssText="\n    border: 1px solid red;\n    background: #ffdddd;\n    color: black;\n    font-family: courier, monospace;\n    white-space: pre;\n    overflow-x: auto;\n    padding: 8px;\n    margin-top: 8px;\n  ",document.body.append(o)}e.main.onReady.add((function n(r){e.main.onReady.delete(n);const{stderr:t}=r.io;r.io.stderr=(e,...n)=>(o(e.message||e),t(e,...n)),addEventListener("error",(({message:e})=>{e.startsWith("Uncaught PythonError")&&o(e)}))}));export{o as notify};
+//# sourceMappingURL=error-96hMSEw8.js.map

package/dist/error-96hMSEw8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-96hMSEw8.js","sources":["../src/plugins/error.js"],"sourcesContent":["// PyScript Error Plugin\nimport { hooks } from \"../core.js\";\n\nhooks.main.onReady.add(function override(pyScript) {\n    // be sure this override happens only once\n    hooks.main.onReady.delete(override);\n\n    // trap generic `stderr` to propagate to it regardless\n    const { stderr } = pyScript.io;\n\n    // override it with our own logic\n    pyScript.io.stderr = (error, ...rest) => {\n        notify(error.message || error);\n        // let other plugins or stderr hook, if any, do the rest\n        return stderr(error, ...rest);\n    };\n\n    // be sure uncaught Python errors are also visible\n    addEventListener(\"error\", ({ message }) => {\n        if (message.startsWith(\"Uncaught PythonError\")) notify(message);\n    });\n});\n\n// Error hook utilities\n\n// Custom function to show notifications\n\n/**\n * Add a banner to the top of the page, notifying the user of an error\n * @param {string} message\n */\nexport function notify(message) {\n    const div = document.createElement(\"div\");\n    div.className = \"py-error\";\n    div.textContent = message;\n    div.style.cssText = `\n    border: 1px solid red;\n    background: #ffdddd;\n    color: black;\n    font-family: courier, monospace;\n    white-space: pre;\n    overflow-x: auto;\n    padding: 8px;\n    margin-top: 8px;\n  `;\n    document.body.append(div);\n}\n"],"names":["notify","message","div","document","createElement","className","textContent","style","cssText","body","append","hooks","main","onReady","add","override","pyScript","delete","stderr","io","error","rest","addEventListener","startsWith"],"mappings":"kCA+BO,SAASA,EAAOC,GACnB,MAAMC,EAAMC,SAASC,cAAc,OACnCF,EAAIG,UAAY,WAChBH,EAAII,YAAcL,EAClBC,EAAIK,MAAMC,QAAU,6MAUpBL,SAASM,KAAKC,OAAOR,EACzB,CA3CAS,EAAMC,KAAKC,QAAQC,KAAI,SAASC,EAASC,GAErCL,EAAMC,KAAKC,QAAQI,OAAOF,GAG1B,MAAMG,OAAEA,GAAWF,EAASG,GAG5BH,EAASG,GAAGD,OAAS,CAACE,KAAUC,KAC5BrB,EAAOoB,EAAMnB,SAAWmB,GAEjBF,EAAOE,KAAUC,IAI5BC,iBAAiB,SAAS,EAAGrB,cACrBA,EAAQsB,WAAW,yBAAyBvB,EAAOC,EAAQ,GAEvE"}

package/dist/py-terminal-nF9DKGa8.js

@@ -0,0 +1,2 @@
+import{TYPES as e,hooks as t}from"./core.js";const r="https://cdn.jsdelivr.net/npm/xterm",n="5.3.0",o=[...e.keys()].map((e=>`script[type="${e}"][terminal],${e}-script[terminal]`)).join(","),i=async()=>{const e=document.querySelectorAll(o);if(!e.length)return;e.length>1&&console.warn("Unable to satisfy multiple terminals"),s.disconnect();const[i]=e;if(i.matches('script[type="mpy"],mpy-script'))throw new Error("Unsupported terminal");document.querySelector(`link[href^="${r}"]`)||document.head.append(Object.assign(document.createElement("link"),{rel:"stylesheet",href:`${r}@${n}/css/xterm.min.css`}));const[{Terminal:d},{Readline:a}]=await Promise.all([import(`${r}@${n}/+esm`),import(`${r}-readline@1.1.1/+esm`)]),c=new a,l=e=>{let t=i;const r=i.getAttribute("target");if(r){if(t=document.getElementById(r)||document.querySelector(r),!t)throw new Error(`Unknown target ${r}`)}else t=document.createElement(`${i.type}-terminal`),t.style.display="block",i.after(t);const n=new d({theme:{background:"#191A19",foreground:"#F5F2E7"},...e});n.loadAddon(c),n.open(t),n.focus()};if(i.hasAttribute("worker")){const e=({interpreter:e},{sync:t})=>{t.pyterminal_drop_hooks();const r=new TextDecoder,n={isatty:!0,write:e=>(t.pyterminal_write(r.decode(e)),e.length)};e.setStdout(n),e.setStderr(n)},r="\n            import builtins\n            from pyscript import sync as _sync\n\n            builtins.input = lambda prompt: _sync.pyterminal_read(prompt)\n        ",n="\n            import code as _code\n            _code.interact()\n        ";t.main.onWorker.add((function o(i,s){t.main.onWorker.delete(o),l({disableStdin:!1,cursorBlink:!0,cursorStyle:"block"}),s.sync.pyterminal_read=c.read.bind(c),s.sync.pyterminal_write=c.write.bind(c),s.sync.pyterminal_drop_hooks=()=>{t.worker.onReady.delete(e),t.worker.codeBeforeRun.delete(r),t.worker.codeAfterRun.delete(n)}})),t.worker.onReady.add(e),t.worker.codeBeforeRun.add(r),t.worker.codeAfterRun.add(n)}else t.main.onReady.add((function e({io:r}){console.warn("py-terminal is read only on main thread"),t.main.onReady.delete(e),l({disableStdin:!0,cursorBlink:!1,cursorStyle:"underline"}),r.stdout=e=>{c.write(`${e}\n`)},r.stderr=e=>{c.write(`${e.message||e}\n`)}}))},s=new MutationObserver(i);s.observe(document,{childList:!0,subtree:!0});var d=i();export{d as default};
+//# sourceMappingURL=py-terminal-nF9DKGa8.js.map

package/dist/py-terminal-nF9DKGa8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"py-terminal-nF9DKGa8.js","sources":["../src/plugins/py-terminal.js"],"sourcesContent":["// PyScript py-terminal plugin\nimport { TYPES, hooks } from \"../core.js\";\n\nconst CDN = \"https://cdn.jsdelivr.net/npm/xterm\";\nconst XTERM = \"5.3.0\";\nconst XTERM_READLINE = \"1.1.1\";\nconst SELECTOR = [...TYPES.keys()]\n    .map((type) => `script[type=\"${type}\"][terminal],${type}-script[terminal]`)\n    .join(\",\");\n\nconst pyTerminal = async () => {\n    const terminals = document.querySelectorAll(SELECTOR);\n\n    // no results will look further for runtime nodes\n    if (!terminals.length) return;\n\n    // we currently support only one terminal as in \"classic\"\n    if (terminals.length > 1)\n        console.warn(\"Unable to satisfy multiple terminals\");\n\n    // if we arrived this far, let's drop the MutationObserver\n    mo.disconnect();\n\n    const [element] = terminals;\n    // hopefully to be removed in the near future!\n    if (element.matches('script[type=\"mpy\"],mpy-script'))\n        throw new Error(\"Unsupported terminal\");\n\n    // import styles once and lazily (only on valid terminal)\n    if (!document.querySelector(`link[href^=\"${CDN}\"]`)) {\n        document.head.append(\n            Object.assign(document.createElement(\"link\"), {\n                rel: \"stylesheet\",\n                href: `${CDN}@${XTERM}/css/xterm.min.css`,\n            }),\n        );\n    }\n\n    // lazy load these only when a valid terminal is found\n    const [{ Terminal }, { Readline }] = await Promise.all([\n        import(/* webpackIgnore: true */ `${CDN}@${XTERM}/+esm`),\n        import(\n            /* webpackIgnore: true */ `${CDN}-readline@${XTERM_READLINE}/+esm`\n        ),\n    ]);\n\n    const readline = new Readline();\n\n    // common main thread initialization for both worker\n    // or main case, bootstrapping the terminal on its target\n    const init = (options) => {\n        let target = element;\n        const selector = element.getAttribute(\"target\");\n        if (selector) {\n            target =\n                document.getElementById(selector) ||\n                document.querySelector(selector);\n            if (!target) throw new Error(`Unknown target ${selector}`);\n        } else {\n            target = document.createElement(`${element.type}-terminal`);\n            target.style.display = \"block\";\n            element.after(target);\n        }\n        const terminal = new Terminal({\n            theme: {\n                background: \"#191A19\",\n                foreground: \"#F5F2E7\",\n            },\n            ...options,\n        });\n        terminal.loadAddon(readline);\n        terminal.open(target);\n        terminal.focus();\n    };\n\n    // branch logic for the worker\n    if (element.hasAttribute(\"worker\")) {\n        // when the remote thread onReady triggers:\n        // setup the interpreter stdout and stderr\n        const workerReady = ({ interpreter }, { sync }) => {\n            sync.pyterminal_drop_hooks();\n            const decoder = new TextDecoder();\n            const generic = {\n                isatty: true,\n                write(buffer) {\n                    sync.pyterminal_write(decoder.decode(buffer));\n                    return buffer.length;\n                },\n            };\n            interpreter.setStdout(generic);\n            interpreter.setStderr(generic);\n        };\n\n        // run in python code able to replace builtins.input\n        // using the xworker.sync non blocking prompt\n        const codeBefore = `\n            import builtins\n            from pyscript import sync as _sync\n\n            builtins.input = lambda prompt: _sync.pyterminal_read(prompt)\n        `;\n\n        // at the end of the code, make the terminal interactive\n        const codeAfter = `\n            import code as _code\n            _code.interact()\n        `;\n\n        // add a hook on the main thread to setup all sync helpers\n        // also bootstrapping the XTerm target on main\n        hooks.main.onWorker.add(function worker(_, xworker) {\n            hooks.main.onWorker.delete(worker);\n            init({\n                disableStdin: false,\n                cursorBlink: true,\n                cursorStyle: \"block\",\n            });\n            xworker.sync.pyterminal_read = readline.read.bind(readline);\n            xworker.sync.pyterminal_write = readline.write.bind(readline);\n            // allow a worker to drop main thread hooks ASAP\n            xworker.sync.pyterminal_drop_hooks = () => {\n                hooks.worker.onReady.delete(workerReady);\n                hooks.worker.codeBeforeRun.delete(codeBefore);\n                hooks.worker.codeAfterRun.delete(codeAfter);\n            };\n        });\n\n        // setup remote thread JS/Python code for whenever the\n        // worker is ready to become a terminal\n        hooks.worker.onReady.add(workerReady);\n        hooks.worker.codeBeforeRun.add(codeBefore);\n        hooks.worker.codeAfterRun.add(codeAfter);\n    } else {\n        // in the main case, just bootstrap XTerm without\n        // allowing any input as that's not possible / awkward\n        hooks.main.onReady.add(function main({ io }) {\n            console.warn(\"py-terminal is read only on main thread\");\n            hooks.main.onReady.delete(main);\n            init({\n                disableStdin: true,\n                cursorBlink: false,\n                cursorStyle: \"underline\",\n            });\n            io.stdout = (value) => {\n                readline.write(`${value}\\n`);\n            };\n            io.stderr = (error) => {\n                readline.write(`${error.message || error}\\n`);\n            };\n        });\n    }\n};\n\nconst mo = new MutationObserver(pyTerminal);\nmo.observe(document, { childList: true, subtree: true });\n\n// try to check the current document ASAP\nexport default pyTerminal();\n"],"names":["CDN","XTERM","SELECTOR","TYPES","keys","map","type","join","pyTerminal","async","terminals","document","querySelectorAll","length","console","warn","mo","disconnect","element","matches","Error","querySelector","head","append","Object","assign","createElement","rel","href","Terminal","Readline","Promise","all","import","readline","init","options","target","selector","getAttribute","getElementById","style","display","after","terminal","theme","background","foreground","loadAddon","open","focus","hasAttribute","workerReady","interpreter","sync","pyterminal_drop_hooks","decoder","TextDecoder","generic","isatty","write","buffer","pyterminal_write","decode","setStdout","setStderr","codeBefore","codeAfter","hooks","main","onWorker","add","worker","_","xworker","delete","disableStdin","cursorBlink","cursorStyle","pyterminal_read","read","bind","onReady","codeBeforeRun","codeAfterRun","io","stdout","value","stderr","error","message","MutationObserver","observe","childList","subtree","pyTerminal$1"],"mappings":"6CAGA,MAAMA,EAAM,qCACNC,EAAQ,QAERC,EAAW,IAAIC,EAAMC,QACtBC,KAAKC,GAAS,gBAAgBA,iBAAoBA,uBAClDC,KAAK,KAEJC,EAAaC,UACf,MAAMC,EAAYC,SAASC,iBAAiBV,GAG5C,IAAKQ,EAAUG,OAAQ,OAGnBH,EAAUG,OAAS,GACnBC,QAAQC,KAAK,wCAGjBC,EAAGC,aAEH,MAAOC,GAAWR,EAElB,GAAIQ,EAAQC,QAAQ,iCAChB,MAAM,IAAIC,MAAM,wBAGfT,SAASU,cAAc,eAAerB,QACvCW,SAASW,KAAKC,OACVC,OAAOC,OAAOd,SAASe,cAAc,QAAS,CAC1CC,IAAK,aACLC,KAAM,GAAG5B,KAAOC,yBAM5B,OAAO4B,SAAEA,IAAYC,SAAEA,UAAoBC,QAAQC,IAAI,CACnDC,OAAiC,GAAGjC,KAAOC,UAC3CgC,OAC8B,GAAGjC,2BAI/BkC,EAAW,IAAIJ,EAIfK,EAAQC,IACV,IAAIC,EAASnB,EACb,MAAMoB,EAAWpB,EAAQqB,aAAa,UACtC,GAAID,GAIA,GAHAD,EACI1B,SAAS6B,eAAeF,IACxB3B,SAASU,cAAciB,IACtBD,EAAQ,MAAM,IAAIjB,MAAM,kBAAkBkB,UAE/CD,EAAS1B,SAASe,cAAc,GAAGR,EAAQZ,iBAC3C+B,EAAOI,MAAMC,QAAU,QACvBxB,EAAQyB,MAAMN,GAElB,MAAMO,EAAW,IAAIf,EAAS,CAC1BgB,MAAO,CACHC,WAAY,UACZC,WAAY,cAEbX,IAEPQ,EAASI,UAAUd,GACnBU,EAASK,KAAKZ,GACdO,EAASM,OAAO,EAIpB,GAAIhC,EAAQiC,aAAa,UAAW,CAGhC,MAAMC,EAAc,EAAGC,gBAAiBC,WACpCA,EAAKC,wBACL,MAAMC,EAAU,IAAIC,YACdC,EAAU,CACZC,QAAQ,EACRC,MAAMC,IACFP,EAAKQ,iBAAiBN,EAAQO,OAAOF,IAC9BA,EAAOhD,SAGtBwC,EAAYW,UAAUN,GACtBL,EAAYY,UAAUP,EAAQ,EAK5BQ,EAAa,uKAQbC,EAAY,6EAOlBC,EAAMC,KAAKC,SAASC,KAAI,SAASC,EAAOC,EAAGC,GACvCN,EAAMC,KAAKC,SAASK,OAAOH,GAC3BrC,EAAK,CACDyC,cAAc,EACdC,aAAa,EACbC,YAAa,UAEjBJ,EAAQpB,KAAKyB,gBAAkB7C,EAAS8C,KAAKC,KAAK/C,GAClDwC,EAAQpB,KAAKQ,iBAAmB5B,EAAS0B,MAAMqB,KAAK/C,GAEpDwC,EAAQpB,KAAKC,sBAAwB,KACjCa,EAAMI,OAAOU,QAAQP,OAAOvB,GAC5BgB,EAAMI,OAAOW,cAAcR,OAAOT,GAClCE,EAAMI,OAAOY,aAAaT,OAAOR,EAAU,CAE3D,IAIQC,EAAMI,OAAOU,QAAQX,IAAInB,GACzBgB,EAAMI,OAAOW,cAAcZ,IAAIL,GAC/BE,EAAMI,OAAOY,aAAab,IAAIJ,EACtC,MAGQC,EAAMC,KAAKa,QAAQX,KAAI,SAASF,GAAKgB,GAAEA,IACnCvE,QAAQC,KAAK,2CACbqD,EAAMC,KAAKa,QAAQP,OAAON,GAC1BlC,EAAK,CACDyC,cAAc,EACdC,aAAa,EACbC,YAAa,cAEjBO,EAAGC,OAAUC,IACTrD,EAAS0B,MAAM,GAAG2B,MAAU,EAEhCF,EAAGG,OAAUC,IACTvD,EAAS0B,MAAM,GAAG6B,EAAMC,SAAWD,MAAU,CAE7D,GACK,EAGCzE,EAAK,IAAI2E,iBAAiBnF,GAChCQ,EAAG4E,QAAQjF,SAAU,CAAEkF,WAAW,EAAMC,SAAS,IAGjD,IAAAC,EAAevF"}

package/docs/README.md

@@ -159,7 +159,7 @@ The commonly shared utilities are:
   * **display** in both main and worker, refers to the good old `display` utility except:
     * in the *main* it automatically uses the current script `target` to display content
     * in the *worker* it still needs to know *where* to display content using the `target="dom-id"` named argument, as workers don't get a default target attached
-    * in both main and worker, the `append=False` is the *default* behavior, which is a breaking change compared to classic PyScript, but because there is no `Element` with its `write(content)` utility, which would have used that `append=False` behind the scene, we've decided that `false` as append default is more desired, specially after porting most examples in *PyScript Next*, where `append=True` is the exception, not the norm.
+    * in both main and worker, the `append=True` is the *default* behavior, which is inherited from the classic PyScript.
 
 #### Extra main-only features
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pyscript/core",
-    "version": "0.2.10",
+    "version": "0.3.1",
     "type": "module",
     "description": "PyScript",
     "module": "./index.js",
@@ -20,9 +20,17 @@
     },
     "scripts": {
         "server": "npx static-handler --coi .",
-        "build": "node rollup/toml.cjs && node rollup/stdlib.cjs && node rollup/plugins.cjs && rm -rf dist && rollup --config rollup/core.config.js && eslint src/ && npm run ts",
+        "build": "npm run build:toml && npm run build:stdlib && npm run build:plugins && npm run build:core && eslint src/ && npm run ts && npm run test:mpy",
+        "build:core": "rm -rf dist && rollup --config rollup/core.config.js",
+        "build:plugins": "node rollup/plugins.cjs",
+        "build:stdlib": "node rollup/stdlib.cjs",
+        "build:toml": "node rollup/toml.cjs",
+        "test:mpy": "static-handler --coi . 2>/dev/null & SH_PID=$!; EXIT_CODE=0; playwright test --fully-parallel test/ || EXIT_CODE=$?; kill $SH_PID 2>/dev/null; exit $EXIT_CODE",
+        "dev": "node dev.cjs",
+        "release": "npm run build && npm run zip",
         "size": "echo -e \"\\033[1mdist/*.js file size\\033[0m\"; for js in $(ls dist/*.js); do echo -e \"\\033[2m$js:\\033[0m $(cat $js | brotli | wc -c) bytes\"; done",
-        "ts": "tsc -p ."
+        "ts": "tsc -p .",
+        "zip": "zip -r dist.zip ./dist"
     },
     "keywords": [
         "pyscript",
@@ -33,16 +41,19 @@
     "dependencies": {
         "@ungap/with-resolvers": "^0.1.0",
         "basic-devtools": "^0.1.6",
-        "polyscript": "^0.4.20",
+        "polyscript": "^0.5.6",
         "sticky-module": "^0.1.0",
+        "to-json-callback": "^0.1.1",
         "type-checked-collections": "^0.1.7"
     },
     "devDependencies": {
+        "@playwright/test": "^1.39.0",
         "@rollup/plugin-node-resolve": "^15.2.3",
         "@rollup/plugin-terser": "^0.4.4",
         "@webreflection/toml-j0.4": "^1.1.3",
-        "eslint": "^8.51.0",
-        "rollup": "^4.1.4",
+        "chokidar": "^3.5.3",
+        "eslint": "^8.52.0",
+        "rollup": "^4.2.0",
         "rollup-plugin-postcss": "^4.0.2",
         "rollup-plugin-string": "^3.0.0",
         "static-handler": "^0.4.3",

package/src/config.js

@@ -113,7 +113,7 @@ for (const [TYPE] of TYPES) {
                 value().then(({ notify }) => notify(error.message));
             }
         } else if (!parsed?.plugins?.includes(`!${key}`)) {
-            toBeAwaited.push(value());
+            toBeAwaited.push(value().then(({ default: p }) => p));
         }
     }
 

package/src/core.js

@@ -14,16 +14,17 @@ import {
     dispatch,
     queryTarget,
     unescape,
+    whenDefined,
 } from "polyscript/exports";
 
 import "./all-done.js";
 import TYPES from "./types.js";
 import configs from "./config.js";
-import hooks from "./hooks.js";
 import sync from "./sync.js";
-import stdlib from "./stdlib.js";
+import bootstrapNodeAndPlugins from "./plugins-helper.js";
 import { ErrorCode } from "./exceptions.js";
 import { robustFetch as fetch, getText } from "./fetch.js";
+import { hooks, main, worker, codeFor, createFunction } from "./hooks.js";
 
 // allows lazy element features on code evaluation
 let currentElement;
@@ -31,25 +32,6 @@ let currentElement;
 // generic helper to disambiguate between custom element and script
 const isScript = ({ tagName }) => tagName === "SCRIPT";
 
-// helper for all script[type="py"] out there
-const before = (script) => {
-    defineProperty(document, "currentScript", {
-        configurable: true,
-        get: () => script,
-    });
-};
-
-const after = () => {
-    delete document.currentScript;
-};
-
-// common life-cycle handlers for any node
-const bootstrapNodeAndPlugins = (wrap, element, callback, hook) => {
-    // make it possible to reach the current target node via Python
-    callback(element);
-    for (const fn of hooks[hook]) fn(wrap, element);
-};
-
 let shouldRegister = true;
 const registerModule = ({ XWorker: $XWorker, interpreter, io }) => {
     // automatically use the pyscript stderr (when/if defined)
@@ -69,19 +51,6 @@ const registerModule = ({ XWorker: $XWorker, interpreter, io }) => {
                 : currentElement.id;
         },
     });
-
-    interpreter.runPython(stdlib, { globals: interpreter.runPython("{}") });
-};
-
-const workerHooks = {
-    codeBeforeRunWorker: () =>
-        [stdlib, ...hooks.codeBeforeRunWorker].map(dedent).join("\n"),
-    codeBeforeRunWorkerAsync: () =>
-        [stdlib, ...hooks.codeBeforeRunWorkerAsync].map(dedent).join("\n"),
-    codeAfterRunWorker: () =>
-        [...hooks.codeAfterRunWorker].map(dedent).join("\n"),
-    codeAfterRunWorkerAsync: () =>
-        [...hooks.codeAfterRunWorkerAsync].map(dedent).join("\n"),
 };
 
 // avoid multiple initialization of the same library
@@ -90,16 +59,26 @@ const [
         PyWorker: exportedPyWorker,
         hooks: exportedHooks,
         config: exportedConfig,
+        whenDefined: exportedWhenDefined,
     },
     alreadyLive,
-] = stickyModule("@pyscript/core", { PyWorker, hooks, config: {} });
+] = stickyModule("@pyscript/core", {
+    PyWorker,
+    hooks,
+    config: {},
+    whenDefined,
+});
 
 export {
+    TYPES,
     exportedPyWorker as PyWorker,
     exportedHooks as hooks,
     exportedConfig as config,
+    exportedWhenDefined as whenDefined,
 };
 
+const hooked = new Map();
+
 for (const [TYPE, interpreter] of TYPES) {
     // avoid any dance if the module already landed
     if (alreadyLive) break;
@@ -149,107 +128,141 @@ for (const [TYPE, interpreter] of TYPES) {
             // possible early errors sent by polyscript
             const errors = new Map();
 
+            // specific main and worker hooks
+            const hooks = {
+                main: {
+                    ...codeFor(main),
+                    async onReady(wrap, element) {
+                        if (shouldRegister) {
+                            shouldRegister = false;
+                            registerModule(wrap);
+                        }
+
+                        // allows plugins to do whatever they want with the element
+                        // before regular stuff happens in here
+                        for (const callback of main("onReady"))
+                            await callback(wrap, element);
+
+                        // now that all possible plugins are configured,
+                        // bail out if polyscript encountered an error
+                        if (errors.has(element)) {
+                            let { message } = errors.get(element);
+                            errors.delete(element);
+                            const clone = message === INVALID_CONTENT;
+                            message = `(${ErrorCode.CONFLICTING_CODE}) ${message} for `;
+                            message += element.cloneNode(clone).outerHTML;
+                            wrap.io.stderr(message);
+                            return;
+                        }
+
+                        if (isScript(element)) {
+                            const {
+                                attributes: { async: isAsync, target },
+                            } = element;
+                            const hasTarget = !!target?.value;
+                            const show = hasTarget
+                                ? queryTarget(element, target.value)
+                                : document.createElement("script-py");
+
+                            if (!hasTarget) {
+                                const { head, body } = document;
+                                if (head.contains(element)) body.append(show);
+                                else element.after(show);
+                            }
+                            if (!show.id) show.id = getID();
+
+                            // allows the code to retrieve the target element via
+                            // document.currentScript.target if needed
+                            defineProperty(element, "target", { value: show });
+
+                            // notify before the code runs
+                            dispatch(element, TYPE, "ready");
+                            dispatchDone(
+                                element,
+                                isAsync,
+                                wrap[`run${isAsync ? "Async" : ""}`](
+                                    await fetchSource(element, wrap.io, true),
+                                ),
+                            );
+                        } else {
+                            // resolve PyScriptElement to allow connectedCallback
+                            element._wrap.resolve(wrap);
+                        }
+                        console.debug("[pyscript/main] PyScript Ready");
+                    },
+                    onWorker(_, xworker) {
+                        assign(xworker.sync, sync);
+                        for (const callback of main("onWorker"))
+                            callback(_, xworker);
+                    },
+                    onBeforeRun(wrap, element) {
+                        currentElement = element;
+                        bootstrapNodeAndPlugins(
+                            main,
+                            wrap,
+                            element,
+                            "onBeforeRun",
+                        );
+                    },
+                    onBeforeRunAsync(wrap, element) {
+                        currentElement = element;
+                        return bootstrapNodeAndPlugins(
+                            main,
+                            wrap,
+                            element,
+                            "onBeforeRunAsync",
+                        );
+                    },
+                    onAfterRun(wrap, element) {
+                        bootstrapNodeAndPlugins(
+                            main,
+                            wrap,
+                            element,
+                            "onAfterRun",
+                        );
+                    },
+                    onAfterRunAsync(wrap, element) {
+                        return bootstrapNodeAndPlugins(
+                            main,
+                            wrap,
+                            element,
+                            "onAfterRunAsync",
+                        );
+                    },
+                },
+                worker: {
+                    ...codeFor(worker),
+                    // these are lazy getters that returns a composition
+                    // of the current hooks or undefined, if no hook is present
+                    get onReady() {
+                        return createFunction(this, "onReady", true);
+                    },
+                    get onBeforeRun() {
+                        return createFunction(this, "onBeforeRun", false);
+                    },
+                    get onBeforeRunAsync() {
+                        return createFunction(this, "onBeforeRunAsync", true);
+                    },
+                    get onAfterRun() {
+                        return createFunction(this, "onAfterRun", false);
+                    },
+                    get onAfterRunAsync() {
+                        return createFunction(this, "onAfterRunAsync", true);
+                    },
+                },
+            };
+
+            hooked.set(TYPE, hooks);
+
             define(TYPE, {
                 config,
                 interpreter,
+                hooks,
                 env: `${TYPE}-script`,
                 version: config?.interpreter,
                 onerror(error, element) {
                     errors.set(element, error);
                 },
-                ...workerHooks,
-                onWorkerReady(_, xworker) {
-                    assign(xworker.sync, sync);
-                    for (const callback of hooks.onWorkerReady)
-                        callback(_, xworker);
-                },
-                onBeforeRun(wrap, element) {
-                    currentElement = element;
-                    bootstrapNodeAndPlugins(
-                        wrap,
-                        element,
-                        before,
-                        "onBeforeRun",
-                    );
-                },
-                onBeforeRunAsync(wrap, element) {
-                    currentElement = element;
-                    bootstrapNodeAndPlugins(
-                        wrap,
-                        element,
-                        before,
-                        "onBeforeRunAsync",
-                    );
-                },
-                onAfterRun(wrap, element) {
-                    bootstrapNodeAndPlugins(wrap, element, after, "onAfterRun");
-                },
-                onAfterRunAsync(wrap, element) {
-                    bootstrapNodeAndPlugins(
-                        wrap,
-                        element,
-                        after,
-                        "onAfterRunAsync",
-                    );
-                },
-                async onInterpreterReady(wrap, element) {
-                    if (shouldRegister) {
-                        shouldRegister = false;
-                        registerModule(wrap);
-                    }
-
-                    // allows plugins to do whatever they want with the element
-                    // before regular stuff happens in here
-                    for (const callback of hooks.onInterpreterReady)
-                        callback(wrap, element);
-
-                    // now that all possible plugins are configured,
-                    // bail out if polyscript encountered an error
-                    if (errors.has(element)) {
-                        let { message } = errors.get(element);
-                        errors.delete(element);
-                        const clone = message === INVALID_CONTENT;
-                        message = `(${ErrorCode.CONFLICTING_CODE}) ${message} for `;
-                        message += element.cloneNode(clone).outerHTML;
-                        wrap.io.stderr(message);
-                        return;
-                    }
-
-                    if (isScript(element)) {
-                        const {
-                            attributes: { async: isAsync, target },
-                        } = element;
-                        const hasTarget = !!target?.value;
-                        const show = hasTarget
-                            ? queryTarget(element, target.value)
-                            : document.createElement("script-py");
-
-                        if (!hasTarget) {
-                            const { head, body } = document;
-                            if (head.contains(element)) body.append(show);
-                            else element.after(show);
-                        }
-                        if (!show.id) show.id = getID();
-
-                        // allows the code to retrieve the target element via
-                        // document.currentScript.target if needed
-                        defineProperty(element, "target", { value: show });
-
-                        // notify before the code runs
-                        dispatch(element, TYPE, "ready");
-                        dispatchDone(
-                            element,
-                            isAsync,
-                            wrap[`run${isAsync ? "Async" : ""}`](
-                                await fetchSource(element, wrap.io, true),
-                            ),
-                        );
-                    } else {
-                        // resolve PyScriptElement to allow connectedCallback
-                        element._wrap.resolve(wrap);
-                    }
-                    console.debug("[pyscript/main] PyScript Ready");
-                },
             });
 
             customElements.define(
@@ -305,12 +318,13 @@ for (const [TYPE, interpreter] of TYPES) {
  * @returns {Worker & {sync: ProxyHandler<object>}}
  */
 function PyWorker(file, options) {
+    const hooks = hooked.get("py");
     // this propagates pyscript worker hooks without needing a pyscript
     // bootstrap + it passes arguments and enforces `pyodide`
     // as the interpreter to use in the worker, as all hooks assume that
     // and as `pyodide` is the only default interpreter that can deal with
     // all the features we need to deliver pyscript out there.
-    const xworker = XWorker.call(new Hook(null, workerHooks), file, {
+    const xworker = XWorker.call(new Hook(null, hooks), file, {
         type: "pyodide",
         ...options,
     });

package/src/hooks.js

@@ -1,28 +1,91 @@
 import { typedSet } from "type-checked-collections";
+import { dedent } from "polyscript/exports";
+import toJSONCallback from "to-json-callback";
+
+import stdlib from "./stdlib.js";
+
+export const main = (name) => hooks.main[name];
+export const worker = (name) => hooks.worker[name];
+
+const code = (hooks, branch, key, lib) => {
+    hooks[key] = () => {
+        const arr = lib ? [lib] : [];
+        arr.push(...branch(key));
+        return arr.map(dedent).join("\n");
+    };
+};
+
+export const codeFor = (branch) => {
+    const hooks = {};
+    code(hooks, branch, `codeBeforeRun`, stdlib);
+    code(hooks, branch, `codeBeforeRunAsync`, stdlib);
+    code(hooks, branch, `codeAfterRun`);
+    code(hooks, branch, `codeAfterRunAsync`);
+    return hooks;
+};
+
+export const createFunction = (self, name) => {
+    const cbs = [...worker(name)];
+    if (cbs.length) {
+        const cb = toJSONCallback(
+            self[`_${name}`] ||
+                (name.endsWith("Async")
+                    ? async (wrap, xworker, ...cbs) => {
+                          for (const cb of cbs) await cb(wrap, xworker);
+                      }
+                    : (wrap, xworker, ...cbs) => {
+                          for (const cb of cbs) cb(wrap, xworker);
+                      }),
+        );
+        const a = cbs.map(toJSONCallback).join(", ");
+        return Function(`return(w,x)=>(${cb})(w,x,...[${a}])`)();
+    }
+};
 
 const SetFunction = typedSet({ typeof: "function" });
 const SetString = typedSet({ typeof: "string" });
 
-export default {
-    /** @type {Set<function>} */
-    onInterpreterReady: new SetFunction(),
-    /** @type {Set<function>} */
-    onBeforeRun: new SetFunction(),
-    /** @type {Set<function>} */
-    onBeforeRunAsync: new SetFunction(),
-    /** @type {Set<function>} */
-    onAfterRun: new SetFunction(),
-    /** @type {Set<function>} */
-    onAfterRunAsync: new SetFunction(),
-
-    /** @type {Set<function>} */
-    onWorkerReady: new SetFunction(),
-    /** @type {Set<string>} */
-    codeBeforeRunWorker: new SetString(),
-    /** @type {Set<string>} */
-    codeBeforeRunWorkerAsync: new SetString(),
-    /** @type {Set<string>} */
-    codeAfterRunWorker: new SetString(),
-    /** @type {Set<string>} */
-    codeAfterRunWorkerAsync: new SetString(),
+export const hooks = {
+    main: {
+        /** @type {Set<function>} */
+        onWorker: new SetFunction(),
+        /** @type {Set<function>} */
+        onReady: new SetFunction(),
+        /** @type {Set<function>} */
+        onBeforeRun: new SetFunction(),
+        /** @type {Set<function>} */
+        onBeforeRunAsync: new SetFunction(),
+        /** @type {Set<function>} */
+        onAfterRun: new SetFunction(),
+        /** @type {Set<function>} */
+        onAfterRunAsync: new SetFunction(),
+        /** @type {Set<string>} */
+        codeBeforeRun: new SetString(),
+        /** @type {Set<string>} */
+        codeBeforeRunAsync: new SetString(),
+        /** @type {Set<string>} */
+        codeAfterRun: new SetString(),
+        /** @type {Set<string>} */
+        codeAfterRunAsync: new SetString(),
+    },
+    worker: {
+        /** @type {Set<function>} */
+        onReady: new SetFunction(),
+        /** @type {Set<function>} */
+        onBeforeRun: new SetFunction(),
+        /** @type {Set<function>} */
+        onBeforeRunAsync: new SetFunction(),
+        /** @type {Set<function>} */
+        onAfterRun: new SetFunction(),
+        /** @type {Set<function>} */
+        onAfterRunAsync: new SetFunction(),
+        /** @type {Set<string>} */
+        codeBeforeRun: new SetString(),
+        /** @type {Set<string>} */
+        codeBeforeRunAsync: new SetString(),
+        /** @type {Set<string>} */
+        codeAfterRun: new SetString(),
+        /** @type {Set<string>} */
+        codeAfterRunAsync: new SetString(),
+    },
 };

package/src/plugins/error.js

@@ -1,9 +1,9 @@
 // PyScript Error Plugin
 import { hooks } from "../core.js";
 
-hooks.onInterpreterReady.add(function override(pyScript) {
+hooks.main.onReady.add(function override(pyScript) {
     // be sure this override happens only once
-    hooks.onInterpreterReady.delete(override);
+    hooks.main.onReady.delete(override);
 
     // trap generic `stderr` to propagate to it regardless
     const { stderr } = pyScript.io;