@scriptc/compiler 0.0.35 → 0.1.1

package/dist/backend/llvm/lib-shared.js

@@ -0,0 +1,687 @@
+import { f64Lit } from "./common.js";
+/** Emit a validation-ladder call that always throws, preserving the typed
+ * dummy-result ownership shape until the pending check unwinds it. */
+export function emitAlwaysThrowLibCall(host, e, sym) {
+    const args = e.args.map((a) => host.emitExpr(a));
+    host.declare(`declare void @${sym}(${args.map(() => "ptr").join(", ")})`);
+    host.B.line(`call void @${sym}(${args.map((a) => `ptr ${a.name}`).join(", ")})`);
+    const ty = host.llType(e.type);
+    if (ty === "void") {
+        host.emitPendingCheck();
+        return { name: "", type: e.type };
+    }
+    const dummy = ty === "double" ? f64Lit(0) : ty === "i1" ? "false" : "null";
+    const out = host.own({ name: dummy, type: e.type });
+    host.emitPendingCheck();
+    return out;
+}
+export const LIB_FN_SYMS = {
+    "util.parseArgs": "scr_util_parse_args",
+    "math.maxArr": "scr_math_max_arr",
+    "math.minArr": "scr_math_min_arr",
+    "math.min": "scr_math_min",
+    "math.max": "scr_math_max",
+    "math.random": "scr_math_random",
+    "num.parseInt": "scr_parse_int",
+    "num.parseFloat": "scr_parse_float",
+    "num.fromString": "scr_string_to_number",
+    "math.round": "scr_math_round",
+    // decodeUriComponent is NOT here: it throws (MAY_THROW_LIB_FNS), so it
+    // refuses by name like the rest of the throwing tier.
+    "str.encodeUriComponent": "scr_str_encode_uri_component",
+    // DOMException: construction and the read surface never throw; the
+    // WebIDL clone's option validation throws (may-throw pending check).
+    "error.newDom": "scr_domex_new",
+    "error.domCode": "scr_domex_code",
+    "error.domHasCause": "scr_domex_has_cause",
+    "error.domCause": "scr_domex_cause",
+    "error.domClone": "scr_domex_clone",
+    "dyn.errInstanceof": "scr_dyn_err_instanceof",
+    "num.toExponential": "scr_num_to_exponential",
+    "num.toFixed0": "scr_num_to_fixed0",
+    "num.toFixed": "scr_num_to_fixed",
+    "num.sameValue": "scr_num_same_value",
+    "intl.numFormatEnUs": "scr_intl_num_format_en_us",
+    "number.isFinite": "scr_num_is_finite",
+    "number.isNaN": "scr_num_is_nan",
+    "number.isInteger": "scr_num_is_integer",
+    "number.isSafeInteger": "scr_num_is_safe_integer",
+    "string.lastIndexOf": "scr_str_last_index_of",
+    "string.raw": "scr_str_raw",
+    "path.join": "scr_path_join",
+    "path.resolve": "scr_path_resolve",
+    "path.normalize": "scr_path_normalize",
+    "path.dirname": "scr_path_dirname",
+    "path.basename": "scr_path_basename",
+    "path.extname": "scr_path_extname",
+    "path.isAbsolute": "scr_path_is_absolute",
+    "path.relative": "scr_path_relative",
+    "path.toNamespacedPath": "scr_path_to_namespaced_path",
+    "path.win32Join": "scr_path_win32_join",
+    "path.win32Resolve": "scr_path_win32_resolve",
+    "path.win32Normalize": "scr_path_win32_normalize",
+    "path.win32Dirname": "scr_path_win32_dirname",
+    "path.win32Basename": "scr_path_win32_basename",
+    "path.win32Extname": "scr_path_win32_extname",
+    "path.win32IsAbsolute": "scr_path_win32_is_absolute",
+    "path.win32Relative": "scr_path_win32_relative",
+    "path.win32ToNamespacedPath": "scr_path_win32_to_namespaced_path",
+    "os.homedir": "scr_os_homedir",
+    "os.type": "scr_os_type",
+    "os.totalmem": "scr_os_totalmem",
+    "os.release": "scr_os_release",
+    "os.userName": "scr_os_user_name",
+    "os.userShell": "scr_os_user_shell",
+    "os.userHomedir": "scr_os_user_homedir",
+    "os.tmpdir": "scr_os_tmpdir",
+    "process.argv": "scr_process_argv",
+    "process.platform": "scr_process_platform",
+    "process.cwd": "scr_process_cwd",
+    "process.pid": "scr_process_pid",
+    "process.getuid": "scr_process_getuid",
+    "process.getgid": "scr_process_getgid",
+    "process.execPath": "scr_process_exec_path",
+    "process.arch": "scr_process_arch",
+    "process.versionsNode": "scr_process_versions_node",
+    "process.versionsOpenssl": "scr_process_versions_openssl",
+    "process.umask": "scr_process_umask",
+    "process.uptime": "scr_process_uptime",
+    "perf.now": "scr_perf_now",
+    "process.availableMemory": "scr_available_memory",
+    "process.constrainedMemory": "scr_constrained_memory",
+    "process.cpuUser": "scr_cpu_user",
+    "process.cpuSystem": "scr_cpu_system",
+    "process.cpuUserDiff": "scr_cpu_user_diff",
+    "process.cpuSystemDiff": "scr_cpu_system_diff",
+    "process.threadCpuUser": "scr_thread_cpu_user",
+    "process.threadCpuSystem": "scr_thread_cpu_system",
+    "process.threadCpuUserDiff": "scr_thread_cpu_user_diff",
+    "process.threadCpuSystemDiff": "scr_thread_cpu_system_diff",
+    "process.rusage": "scr_process_rusage",
+    "process.activeResources": "scr_active_resources",
+    "process.exiting": "scr_process_exiting",
+    "process.exit": "scr_process_exit",
+    "process.envSet": "scr_env_set",
+    "process.envUnset": "scr_env_unset",
+    "process.envPairs": "scr_env_pairs",
+    "process.stdoutWrite": "scr_process_stdout_write",
+    "process.stderrWrite": "scr_process_stderr_write",
+    "process.isTTY": "scr_process_is_tty",
+    "date.now": "scr_date_now",
+    "date.newNow": "scr_date_now",
+    "date.newMs": "scr_date_new_ms",
+    "date.newString": "scr_date_parse_get_time",
+    "date.getTime": "scr_date_get_time",
+    "date.valueOf": "scr_date_get_time",
+    "date.parseGetTime": "scr_date_parse_get_time",
+    "date.utc": "scr_date_utc",
+    "date.getFullYear": "scr_date_get_full_year_local",
+    "date.getUTCFullYear": "scr_date_get_full_year_utc",
+    "date.getMonth": "scr_date_get_month_local",
+    "date.getUTCMonth": "scr_date_get_month_utc",
+    "date.getDate": "scr_date_get_date_local",
+    "date.getUTCDate": "scr_date_get_date_utc",
+    "date.getDay": "scr_date_get_day_local",
+    "date.getUTCDay": "scr_date_get_day_utc",
+    "date.getHours": "scr_date_get_hours_local",
+    "date.getUTCHours": "scr_date_get_hours_utc",
+    "date.getMinutes": "scr_date_get_minutes_local",
+    "date.getUTCMinutes": "scr_date_get_minutes_utc",
+    "date.getSeconds": "scr_date_get_seconds_local",
+    "date.getUTCSeconds": "scr_date_get_seconds_utc",
+    "date.getMilliseconds": "scr_date_get_milliseconds",
+    "date.getUTCMilliseconds": "scr_date_get_milliseconds",
+    "date.getTimezoneOffset": "scr_date_get_timezone_offset",
+    "fs.existsSync": "scr_fs_exists",
+    // ── the throwing slice (MAY_THROW_LIB_FNS members): the generic path
+    // emits the standard pending check after each — exprs.ts's finish.
+    "process.cpuPrevValidate": "scr_cpu_prev_validate",
+    "date.toISOString": "scr_date_to_iso",
+    "date.toISOStringValue": "scr_date_to_iso",
+    "process.chdir": "scr_process_chdir",
+    "fs.writeFileSync": "scr_fs_write_file",
+    "fs.appendFileSync": "scr_fs_append_file",
+    "fs.mkdirSync": "scr_fs_mkdir",
+    "fs.mkdirRecursiveSync": "scr_fs_mkdir_recursive",
+    "fs.mkdtempSync": "scr_fs_mkdtemp",
+    "fs.rmSync": "scr_fs_rm",
+    "fs.rmOptsSync": "scr_fs_rm_opts",
+    "fs.rmRetrySync": "scr_fs_rm_opts_retry",
+    "fs.rmdirSync": "scr_fs_rmdir",
+    "fs.readdirSync": "scr_fs_readdir",
+    "fs.realpathSync": "scr_fs_realpath",
+    "fs.unlinkSync": "scr_fs_unlink",
+    "fs.chmodSync": "scr_fs_chmod",
+    "fs.copyFileSync": "scr_fs_copyfile",
+    "fs.renameSync": "scr_fs_rename",
+    "fs.accessSync": "scr_fs_access",
+    // node:assert (scr_assert.c): all args borrowed; failures throw the
+    // catchable AssertionError. The never-throwing members ride along.
+    "assert.ok": "scr_assert_ok",
+    "assert.eqF64": "scr_assert_eq_f64",
+    "assert.eqStr": "scr_assert_eq_str",
+    "assert.eqBool": "scr_assert_eq_bool",
+    "assert.eqSym": "scr_assert_eq_sym",
+    "assert.eqDyn": "scr_assert_eq_dyn",
+    "assert.deepResult": "scr_assert_deep_result",
+    "assert.sameValue": "scr_assert_same_value_f64",
+    "assert.deqEnter": "scr_assert_deq_enter",
+    "assert.deqLeave": "scr_assert_deq_leave",
+    "assert.match": "scr_assert_match",
+    "assert.throwsNone": "scr_assert_throws_none",
+    "assert.throwsMismatch": "scr_assert_throws_mismatch",
+    "assert.throwsRegex": "scr_assert_throws_regex",
+    "assert.shapeBegin": "scr_assert_shape_begin",
+    // shapeStr/shapeRe take an int key — special-cased (fptosi), not generic.
+    "assert.shapeEnd": "scr_assert_shape_end",
+    "assert.regexErrTest": "scr_assert_regex_err_test",
+    "assert.unwantedRejection": "scr_assert_unwanted_rejection",
+    "assert.ifErrorErr": "scr_assert_iferror_err",
+    "assert.ifErrorF64": "scr_assert_iferror_f64",
+    "assert.ifErrorStr": "scr_assert_iferror_str",
+    "assert.ifErrorBool": "scr_assert_iferror_bool",
+    "assert.ifErrorDyn": "scr_assert_iferror_dyn",
+    "assert.refEqFn": "scr_assert_ref_eq_fn",
+    "assert.refEqBytes": "scr_assert_ref_eq_bytes",
+    "assert.bytesDeepEq": "scr_assert_bytes_deep_eq",
+    // The Buffer statics and bytes-adjacent members (scr_bytes.c /
+    // scr_bytes_io.c / scr_zlib.c / scr_crypto): fromStr decodes Node-
+    // leniently (never throws), concat copies its borrowed list; the sync
+    // fs Buffer pair and zlib.inflateSync ride the may-throw check.
+    "buffer.fromStr": "scr_bytes_from_str",
+    "buffer.concat": "scr_bytes_concat",
+    "buffer.concatLen": "scr_bytes_concat_len",
+    "buffer.byteLenStr": "scr_bytes_byte_length_str",
+    "buffer.isEncoding": "scr_bytes_is_encoding",
+    // The checked-dynamic compare/equals validators (scr_bytes_io.c):
+    // Node's argument ladders throw catchably (MAY_THROW_LIB_FNS).
+    "dyn.toStringCoerce": "scr_dyn_string_coerce_js",
+    "buffer.compareChk": "scr_buffer_compare_chk",
+    "bytes.equalsChk": "scr_bytes_equals_chk",
+    "bytes.compareChk": "scr_bytes_compare_chk",
+    "buffer.newStringFail": "scr_buffer_new_string_fail",
+    "fs.toUnixTimestamp": "scr_fs_to_unix_timestamp",
+    "fs.existsChk": "scr_fs_exists_async",
+    "fs.mkdtempSyncChk": "scr_fs_mkdtemp_sync_chk",
+    "net.connectAttempt": "scr_net_connect_attempt",
+    "fs.lchmodSyncChk": "scr_fs_lchmod_sync_chk",
+    "fsp.lchmodChk": "scr_fsp_lchmod_chk",
+    "fs.readFileSyncBuf": "scr_fs_read_file_bytes",
+    "fs.readFileSyncBytes": "scr_fs_read_file_bytes",
+    "fs.writeFileSyncBytes": "scr_fs_write_file_bytes",
+    "fs.readFdSyncBytes": "scr_fs_read_fd_bytes",
+    // Stats snapshots (scr_lib.c): statSync/lstatSync throw like the other
+    // sync fs calls; the getters are pure reads.
+    "fs.statSync": "scr_fs_stat",
+    "fs.lstatSync": "scr_fs_lstat",
+    "fs.openSync": "scr_fs_open",
+    "fs.readSync": "scr_fs_read_sync",
+    "fs.writeSync": "scr_fs_write_sync",
+    "fs.writeStrSync": "scr_fs_write_str_sync",
+    "fs.closeSync": "scr_fs_close",
+    // string_decoder (scr_bytes.c): stateless helpers over (enc, pending,
+    // chunk) — never throw.
+    "strdec.write": "scr_strdec_write",
+    "strdec.next": "scr_strdec_next",
+    "strdec.end": "scr_strdec_end",
+    "stats.isFile": "scr_stats_is_file",
+    "stats.isDirectory": "scr_stats_is_dir",
+    "stats.isSymbolicLink": "scr_stats_is_symlink",
+    "stats.size": "scr_stats_size",
+    "stats.blocks": "scr_stats_blocks",
+    "stats.nlink": "scr_stats_nlink",
+    "stats.atimeMs": "scr_stats_atime_ms",
+    "stats.mtimeMs": "scr_stats_mtime_ms",
+    "text.decode": "scr_text_decode",
+    "text.decodeLegacy": "scr_text_decode_legacy",
+    "zlib.deflateSync": "scr_zlib_deflate",
+    "zlib.inflateSync": "scr_zlib_inflate",
+    // The CA-store unit. get/set throw (an unknown type name, a
+    // certificate-free set) and take the generic path's pending check.
+    "tlsca.root": "scr_tls_ca_root",
+    "tlsca.get": "scr_tls_ca_get",
+    "tlsca.set": "scr_tls_ca_set_default",
+    "crypto.randomBytes": "scr_crypto_random_bytes",
+    "crypto.randomBytesToString": "scr_crypto_random_string",
+    "crypto.randomUUID": "scr_crypto_random_uuid",
+    "crypto.hashDigestStr": "scr_crypto_hash_digest_str",
+    "crypto.hashDigestBytes": "scr_crypto_hash_digest_bytes",
+    "process.stdoutWriteBytes": "scr_process_stdout_write_bytes",
+    "process.stderrWriteBytes": "scr_process_stderr_write_bytes",
+    "insp.buffer": "scr_insp_buffer",
+    // util.inspect (scr_inspect.c): all args borrowed; string results +1;
+    // the begin/entry/key/moreItems/end accumulator drives the emitted
+    // container walks. None of these throw.
+    "insp.f64": "scr_insp_f64",
+    "insp.str": "scr_insp_str",
+    "insp.regex": "scr_insp_regex",
+    "insp.error": "scr_insp_error",
+    "insp.begin": "scr_insp_begin",
+    "insp.entry": "scr_insp_entry",
+    "insp.key": "scr_insp_key",
+    "insp.moreItems": "scr_insp_more_items",
+    "insp.end": "scr_insp_end",
+    // Circular references over cycle-capable composites (Node's
+    // seen/circular machinery — none of these throw; refWrap borrows its
+    // string and answers +1).
+    "insp.circCheck": "scr_insp_circ_check",
+    "insp.seenPush": "scr_insp_seen_push",
+    "insp.refWrap": "scr_insp_ref_wrap",
+    "insp.circular": "scr_insp_circular",
+    // WHATWG URL + URLSearchParams (scr_url.c / scr_url_params.c):
+    // constructions +1; url.new, the fileURLToPath pair, the win32
+    // pathToFileURL flavor, and sp.fromPairs throw catchably (may-throw).
+    "url.new": "scr_url_new",
+    "url.protocol": "scr_url_protocol",
+    "url.host": "scr_url_host",
+    "url.hostname": "scr_url_hostname",
+    "url.pathname": "scr_url_pathname",
+    "url.href": "scr_url_href",
+    "url.search": "scr_url_search",
+    "url.searchParams": "scr_url_search_params",
+    "url.fileURLToPathUrl": "scr_url_to_path",
+    "url.fileURLToPathStr": "scr_url_str_to_path",
+    "url.pathToFileURL": "scr_url_from_path",
+    "url.pathToFileURLWin32": "scr_url_from_path",
+    "sp.new": "scr_sp_new",
+    "sp.parse": "scr_sp_parse",
+    "sp.copy": "scr_sp_copy",
+    "sp.fromPairs": "scr_sp_from_pairs",
+    "sp.with": "scr_sp_with",
+    "sp.getAll": "scr_sp_get_all",
+    "sp.append": "scr_sp_append",
+    "sp.set": "scr_sp_set",
+    "sp.delete": "scr_sp_delete",
+    "sp.deleteValue": "scr_sp_delete_value",
+    "sp.has": "scr_sp_has",
+    "sp.hasValue": "scr_sp_has_value",
+    "sp.sort": "scr_sp_sort",
+    "sp.size": "scr_sp_size",
+    "sp.toString": "scr_sp_to_string",
+    "sp.keyAt": "scr_sp_key_at",
+    "sp.valAt": "scr_sp_val_at",
+    // node:querystring (scr_qs.c): unescape/stringify are plain generic
+    // calls (never throw; string results +1), and escape IS the component
+    // encoder (Node's qsEscape set equals encodeURIComponent's) so it emits
+    // the always-linked codec. qs.parse is special-cased in emitLibCall
+    // (the result dictionary's construction).
+    "qs.escape": "scr_str_encode_uri_component",
+    "qs.unescape": "scr_qs_unescape",
+    "qs.stringify": "scr_qs_stringify",
+    // Timer handle bookkeeping (never throws; the comma-shaped chaining
+    // forms are special-cased in emitLibCall).
+    "timers.hasRef": "scr_timer_has_ref",
+    "timers.immediateHasRef": "scr_immediate_has_ref",
+    "timers.clearImmediate": "scr_clear_immediate",
+    // Process event removals (borrowed callbacks: removal is by pointer
+    // identity); registration is special-cased above (ownership moves).
+    "process.offSignal": "scr_signal_off",
+    "process.offExit": "scr_process_off_exit",
+    // child_process (scr_child.c): spawnSync/exec forms are synchronous
+    // (execSync/execCapture throw — the may-throw check); handle getters
+    // are pure reads. Registration forms are special-cased (moves + per-
+    // shape adapters); spawn itself is special-cased for usesTimers.
+    "cp.spawnSync": "scr_spawn_sync",
+    "cp.spawnSyncOpts": "scr_spawn_sync_opts",
+    "cp.spawnSyncStdioStr": "scr_spawn_sync_stdio_str",
+    "cp.execSync": "scr_exec_sync",
+    "cp.execCapture": "scr_exec_capture",
+    "spawnRes.stdout": "scr_spawn_res_stdout",
+    "spawnRes.stderr": "scr_spawn_res_stderr",
+    "child.killed": "scr_child_killed",
+    "child.kill": "scr_child_kill",
+    "child.killNum": "scr_child_kill_num",
+    "child.unref": "scr_child_unref",
+    "procStream.write": "scr_proc_stream_write",
+    "process.kill": "scr_process_kill_named",
+    "process.killNum": "scr_process_kill",
+    // fs.promises (scr_bytes_io.c / scr_lib.c): the promise forms settle
+    // instead of throwing — plain generic calls answering a +1 promise.
+    // fsp.readFile is NOT here: it carries the ignored encoding argument,
+    // so it is special-cased in emitLibCall (the fs.readFileSync pattern).
+    "fsp.readFileBytes": "scr_fsp_read_file_bytes",
+    "fsp.writeFile": "scr_fsp_write_file",
+    "fsp.writeFileMode": "scr_fsp_write_file_mode",
+    "fsp.mkdir": "scr_fsp_mkdir",
+    "fsp.mkdirMode": "scr_fsp_mkdir_mode",
+    "fsp.mkdirRecursive": "scr_fsp_mkdir_recursive",
+    "fsp.mkdirRecursiveMode": "scr_fsp_mkdir_recursive_mode",
+    "fsp.unlink": "scr_fsp_unlink",
+    "fsp.chmod": "scr_fsp_chmod",
+    "fsp.rename": "scr_fsp_rename",
+    "fsp.readdir": "scr_fsp_readdir",
+    "fsp.rm": "scr_fsp_rm",
+    "fsp.stat": "scr_fsp_stat",
+    "fsp.open": "scr_fsp_open",
+    "fileHandle.fd": "scr_file_handle_fd",
+    "fileHandle.close": "scr_file_handle_close_promise",
+    "fileHandle.readFile": "scr_file_handle_read_file_promise",
+    "fileHandle.readFileBytes": "scr_file_handle_read_file_bytes_promise",
+    "fileHandle.writeFile": "scr_file_handle_write_file_promise",
+    "fileHandle.writeFileBytes": "scr_file_handle_write_file_bytes_promise",
+    "fileHandle.stat": "scr_file_handle_stat_promise",
+    "sym.new": "scr_sym_new",
+    "sym.for": "scr_sym_for",
+    "sym.toString": "scr_sym_to_string",
+    "error.toString": "scr_error_to_string",
+    "class.name": "scr_classobj_name",
+    // The dyn (ScrDyn dyn) surface (scr_json.c / scr_dyn_invoke.c):
+    // json.parse throws the catchable SyntaxError; keySet/toString/
+    // defineProps throw Node's TypeErrors (all in the may-throw seed set —
+    // the generic path emits the standard pending check). typeof and the
+    // ambient-this read never throw. The fs dyn read is the sync-fs story.
+    "fetch.start": "scr_fetch_static",
+    "fetch.responseNew": "scr_fetch_response_new",
+    "fetch.responseJson": "scr_fetch_response_json",
+    "fetch.responseText": "scr_fetch_response_text",
+    "fetch.responseBytes": "scr_fetch_response_bytes",
+    "fetch.abortControllerNew": "scr_fetch_abort_controller_new",
+    "fetch.abortTimeout": "scr_fetch_abort_timeout",
+    "fetch.abortNow": "scr_fetch_abort_now",
+    "fetch.abortAny": "scr_fetch_abort_any",
+    "fetch.streamNew": "scr_fetch_stream_new",
+    "fetch.streamFrom": "scr_fetch_stream_from",
+    "fetch.readerRead": "scr_fetch_reader_read",
+    "json.parse": "scr_json_parse",
+    "dyn.keySet": "scr_dyn_key_set",
+    "dyn.iterPack": "scr_dyn_iter_pack",
+    "dyn.arrLen": "scr_dyn_arr_len",
+    "dyn.arrAt": "scr_dyn_arr_at",
+    "dyn.hasKey": "scr_dyn_has_key",
+    "dyn.defineProps": "scr_dyn_define_props",
+    "dyn.typeof": "scr_dyn_typeof",
+    "dyn.toString": "scr_dyn_to_string_method",
+    "dyn.this": "scr_dyn_this_get",
+    "insp.dyn": "scr_insp_dyn",
+    "insp.dynS": "scr_insp_dyn_s",
+    "fs.readFileSyncDyn": "scr_fs_read_file_sync_dyn",
+    // Loose generic-shaped stragglers the burn-down surfaced alongside the
+    // dyn head: the x509 PEM walks and stdin raw-mode throw catchably (the
+    // may-throw seed set); the mode-carrying fs sync forms are the plain
+    // sync-fs story; stdinDestroy is a deliberate no-op; atomics.wait is
+    // the static sleep.
+    "crypto.x509Fingerprint": "scr_crypto_x509_fingerprint",
+    "crypto.x509FingerprintStr": "scr_crypto_x509_fingerprint_str",
+    "crypto.x509ValidFrom": "scr_crypto_x509_valid_from",
+    "crypto.x509ValidFromStr": "scr_crypto_x509_valid_from_str",
+    "crypto.x509ValidTo": "scr_crypto_x509_valid_to",
+    "crypto.x509ValidToStr": "scr_crypto_x509_valid_to_str",
+    "fs.writeFileModeSync": "scr_fs_write_file_mode",
+    "fs.chownSync": "scr_fs_chown",
+    "fs.mkdirModeSync": "scr_fs_mkdir_mode",
+    "fs.mkdirRecursiveModeSync": "scr_fs_mkdir_recursive_mode",
+    "atomics.wait": "scr_atomics_wait",
+    "process.stdinDestroy": "scr_process_stdin_destroy",
+    "process.stdinSetRawMode": "scr_process_stdin_set_raw_mode",
+    // node:events EventEmitter (scr_events_emitter.c): receivers borrowed,
+    // chaining forms answer the receiver +1 (Node's `return this`). The
+    // registration/removal family and emitError are may-throw (meta
+    // listeners run inside; unhandled 'error' throws its payload) — the
+    // generic path's pending check covers them. on/onDyn and the emit
+    // family have non-generic shapes (adapter/variadic) — special-cased in
+    // emitLibCall.
+    "emitter.new": "scr_emitter_new",
+    "emitter.ctor": "scr_emitter_init",
+    "emitter.off": "scr_emitter_off",
+    "emitter.offDyn": "scr_emitter_off_dyn",
+    "emitter.checkListener": "scr_emitter_check_listener",
+    "emitter.removeAll": "scr_emitter_remove_all",
+    "emitter.emitError": "scr_emitter_emit_error",
+    "emitter.count": "scr_emitter_listener_count",
+    "emitter.countFn": "scr_emitter_listener_count_fn",
+    "emitter.names": "scr_emitter_event_names",
+    "emitter.listeners": "scr_emitter_listeners",
+    "emitter.setMax": "scr_emitter_set_max",
+    "emitter.setMaxChk": "scr_emitter_set_max_chk",
+    "emitter.setDefaultMaxChk": "scr_emitter_set_default_max_chk",
+    "emitter.getMax": "scr_emitter_get_max",
+    "emitter.setDefaultMax": "scr_emitter_set_default_max",
+    "emitter.getDefaultMax": "scr_emitter_get_default_max",
+    // node:stream (scr_stream.c): receivers borrowed, chunks borrowed,
+    // chaining forms answer the receiver +1. The throwing members
+    // (listeners and option callbacks run synchronously inside) ride the
+    // generic pending check; loop liveness rides USES_TIMERS_LIB_FNS.
+    "readable.push": "scr_stream_push",
+    "readable.pushStr": "scr_stream_push_str",
+    "readable.pushStrEnc": "scr_stream_push_str_enc",
+    "readable.pushEncoding": "scr_stream_set_push_encoding",
+    "readable.pushNull": "scr_stream_push_null",
+    "readable.pushDyn": "scr_stream_push_dyn",
+    "readable.unshift": "scr_stream_unshift",
+    "readable.unshiftStr": "scr_stream_unshift_str",
+    "readable.pause": "scr_stream_pause",
+    "readable.resume": "scr_stream_resume",
+    "readable.isPaused": "scr_stream_is_paused",
+    "readable.setEncoding": "scr_stream_set_encoding",
+    "readable.nextChunk": "scr_stream_next_chunk",
+    "readable.nextChunkDyn": "scr_stream_next_chunk_dyn",
+    "readable.fromArr": "scr_stream_from_arr",
+    "readable.pipe": "scr_stream_pipe",
+    "writable.cork": "scr_stream_cork",
+    "writable.uncork": "scr_stream_uncork",
+    "stream.destroyErr": "scr_stream_destroy",
+    "readable.newDyn": "scr_stream_new_readable_dyn",
+    "writable.newDyn": "scr_stream_new_writable_dyn",
+    "duplex.newDyn": "scr_stream_new_duplex_dyn",
+    "transform.newDyn": "scr_stream_new_transform_dyn",
+    "passthrough.newDyn": "scr_stream_new_passthrough_dyn",
+    // node:net + node:http (scr_net.c / scr_http.c): receivers borrowed;
+    // writes borrow their payloads; the *Dyn chunk forms and setEncoding
+    // are may-throw (generic pending check). Listener registrations and
+    // the client request forms have non-generic shapes — special-cased.
+    "net.serverPort": "scr_net_server_port",
+    "net.sockWrite": "scr_net_sock_write_str",
+    "net.sockWriteBytes": "scr_net_sock_write_bytes",
+    "net.sockEnd": "scr_net_sock_end",
+    "net.sockEndStr": "scr_net_sock_end_str",
+    "net.sockEndBytes": "scr_net_sock_end_bytes",
+    "net.sockWriteDyn": "scr_net_sock_write_dynv",
+    "net.sockEndDyn": "scr_net_sock_end_dynv",
+    "net.sockDestroy": "scr_net_sock_destroy",
+    "net.sockPipe": "scr_net_sock_pipe",
+    "net.sockDestroyed": "scr_net_sock_destroyed",
+    "net.sockWritable": "scr_net_sock_writable",
+    "net.sockSetEncoding": "scr_net_sock_set_encoding",
+    "net.sockSetTimeout": "scr_net_sock_set_timeout",
+    "net.sockUnshift": "scr_net_sock_unshift_bytes",
+    "net.sockPause": "scr_net_sock_pause",
+    "net.sockResume": "scr_net_sock_resume",
+    "net.sockSetNoDelay": "scr_net_sock_set_nodelay",
+    "net.sockDestroySoon": "scr_net_sock_destroy_soon",
+    "net.sockBytesWritten": "scr_net_sock_bytes_written",
+    "net.sockReadable": "scr_net_sock_readable",
+    "net.sockPipeRes": "scr_http_sock_pipe_res",
+    "net.serverEmitConnection": "scr_net_server_emit_connection",
+    "net.getAutoSelTimeout": "scr_net_get_autosel_timeout",
+    "net.setAutoSelTimeout": "scr_net_set_autosel_timeout",
+    "http.reqUrl": "scr_http_req_url",
+    "http.reqMethod": "scr_http_req_method",
+    "http.reqSocket": "scr_http_req_socket",
+    "http.reqRawHeaders": "scr_http_req_raw_headers",
+    "http.reqHeaderPairs": "scr_http_req_header_pairs",
+    "http.reqPipeRes": "scr_http_req_pipe_res",
+    "http.reqPipeClient": "scr_http_req_pipe_client",
+    "http.reqPipeSock": "scr_http_req_pipe_sock",
+    "http.reqResume": "scr_http_req_resume",
+    "http.reqDestroy": "scr_http_req_destroy",
+    "http.reqSetEncoding": "scr_http_req_set_encoding",
+    "http.resSetHeader": "scr_http_res_set_header",
+    "http.resWriteHead": "scr_http_res_write_head",
+    "http.resWriteHeadN": "scr_http_res_write_head_n",
+    "http.resWrite": "scr_http_res_write_str",
+    "http.resWriteBytes": "scr_http_res_write_bytes",
+    "http.resEnd": "scr_http_res_end",
+    "http.resEndStr": "scr_http_res_end_str",
+    "http.resEndBytes": "scr_http_res_end_bytes",
+    "http.resWriteDyn": "scr_http_res_write_dynv",
+    "http.resEndDyn": "scr_http_res_end_dynv",
+    "http.resHeadersSent": "scr_http_res_headers_sent",
+    "http.resDestroy": "scr_http_res_destroy",
+    "http.resStatusGet": "scr_http_res_status_get",
+    "http.resStatusSet": "scr_http_res_status_set",
+    "http.resStatusMsgGet": "scr_http_res_status_msg_get",
+    "http.resStatusMsgSet": "scr_http_res_status_msg_set",
+    "http.resHasHeader": "scr_http_res_has_header_named",
+    "http.resRemoveHeader": "scr_http_res_remove_header",
+    "http.resWriteHeadPairs": "scr_http_res_write_head_pairs",
+    "http.resWriteHeadDyn": "scr_http_res_write_head_dyn",
+    "http.serverJoinDupHeaders": "scr_http_server_join_duplicate_headers",
+    "http.serverTimeoutGet": "scr_net_server_timeout_get",
+    "http.serverTimeoutSet": "scr_net_server_timeout_set",
+    "http.serverTimeoutOptionSet": "scr_net_server_timeout_option_set",
+    "http.clientWrite": "scr_http_client_write_str",
+    "http.clientWriteBytes": "scr_http_client_write_bytes",
+    "http.clientEnd": "scr_http_client_end",
+    "http.clientEndStr": "scr_http_client_end_str",
+    "http.clientEndBytes": "scr_http_client_end_bytes",
+    "http.clientWriteDyn": "scr_http_client_write_dynv",
+    "http.clientEndDyn": "scr_http_client_end_dynv",
+    "http.clientDestroy": "scr_http_client_destroy",
+    "http.clientDestroyed": "scr_http_client_destroyed",
+    "http2.streamUndefCall": "scr_http2_stream_undef_call",
+    "http.agentNew": "scr_http_agent_new",
+    // The island surface (--dynamic): eval/import bridge catchably (the
+    // may-throw seed's pending check); importDyn answers an engine promise
+    // and never throws itself. insp.jsval throws on composite island
+    // values (engine JSON.stringify inside).
+    "island.eval": "scr_island_eval",
+    "island.import": "scr_jsval_import",
+    "island.importDyn": "scr_jsval_import_dyn",
+    "insp.jsval": "scr_insp_jsval",
+    // timers/promises (+1 promises; the await parks a fiber, so the async
+    // loop gate already runs) and diagnostics_channel (scr_dc.c): all
+    // generic shapes; the throwing members ride the pending check.
+    "tp.setTimeout": "scr_tp_set_timeout",
+    "tp.setImmediate": "scr_tp_set_immediate",
+    // stream/promises' finished form (+1 promise; may-throw pending check;
+    // the pipeline form needs the stream-array compound and emits below).
+    "sp.finished": "scr_sp_finished",
+    // stream/consumers' promise consumers (+1 promises; may-throw pending
+    // check — the 'newListener' meta emit can run user code).
+    "sc.text": "scr_sc_text",
+    "sc.json": "scr_sc_json",
+    "sc.buffer": "scr_sc_buffer",
+    "dc.channel": "scr_dc_channel",
+    "dc.subscribe": "scr_dc_subscribe",
+    "dc.unsubscribe": "scr_dc_unsubscribe",
+    "dc.hasSubscribers": "scr_dc_has_subscribers",
+    "dc.publish": "scr_dc_publish",
+    "dc.chanSubscribe": "scr_dc_chan_subscribe",
+    "dc.chanUnsubscribe": "scr_dc_chan_unsubscribe",
+    "dc.chanHasSubscribers": "scr_dc_chan_has_subscribers",
+    "dc.chanName": "scr_dc_chan_name",
+    "str.decodeUriComponent": "scr_str_decode_uri_component",
+    // TracingChannel (scr_dc.c): registry handles are plain doubles; the
+    // subscribe/trace forms ride the may-throw pending check, and
+    // tcTracePromise marks the loop live (USES_TIMERS_LIB_FNS — the
+    // reaction fiber needs the loop to drain it).
+    "dc.tracingChannel": "scr_dc_tracing_channel",
+    "dc.tracingChannelOf": "scr_dc_tracing_channel_of",
+    "dc.tcChannel": "scr_dc_tc_channel",
+    "dc.tcHasSubscribers": "scr_dc_tc_has_subscribers",
+    "dc.tcSubscribe": "scr_dc_tc_subscribe",
+    "dc.tcUnsubscribe": "scr_dc_tc_unsubscribe",
+    "dc.tcTraceSync": "scr_dc_tc_trace_sync",
+    "dc.tcTraceCallback": "scr_dc_tc_trace_callback",
+    "dc.tcTracePromise": "scr_dc_tc_trace_promise",
+    // AsyncLocalStorage (scr_async_dyn.c): store ids are doubles, values
+    // ride the checked-dynamic tree; run/exitRun dispatch user callbacks (may-throw).
+    // The dc bind-store trio shares the als id space.
+    "als.new": "scr_als_new",
+    "als.get": "scr_als_get",
+    "als.run": "scr_als_run",
+    "als.exitRun": "scr_als_exit_run",
+    "als.enterWith": "scr_als_enter_with",
+    "als.disable": "scr_als_disable",
+    "dc.chanBindStore": "scr_dc_chan_bind_store",
+    "dc.chanUnbindStore": "scr_dc_chan_unbind_store",
+    "dc.chanRunStores": "scr_dc_chan_run_stores",
+    // process warning/rejection events (scr_lib.c / scr_async_dyn.c):
+    // dyn listeners are borrowed (the runtime retains its copy);
+    // onUnhandledRejection marks the loop live (the checkpoint report
+    // dispatches the listeners).
+    "process.onWarning": "scr_process_on_warning",
+    "process.offWarning": "scr_process_off_warning",
+    "process.emitWarning": "scr_process_emit_warning",
+    "process.onUnhandledRejection": "scr_process_on_unhandled_rejection",
+    "process.offUnhandledRejection": "scr_process_off_unhandled_rejection",
+    "process.onRejectionHandled": "scr_process_on_rejection_handled",
+    "process.offRejectionHandled": "scr_process_off_rejection_handled",
+    // The await lowering's loop hop and the dyn await (both park the
+    // current fiber — USES_TIMERS_LIB_FNS marks the loop live).
+    "async.hop": "scr_await_hop",
+    "async.awaitDyn": "scr_await_dyn_value",
+    // encodeURI never throws; the WHATWG base64 globals throw the
+    // catchable DOMException InvalidCharacterError (may-throw), and the
+    // zero-argument form always throws ERR_MISSING_ARGS.
+    "str.encodeUri": "scr_encode_uri",
+    "str.atob": "scr_atob",
+    "str.btoa": "scr_btoa",
+    "str.b64Missing": "scr_b64_missing_arg",
+    "regexp.escape": "scr_regexp_escape",
+    // The dyn Object walks (throw on nullish receivers), structuredClone
+    // (option/DataClone/cycle errors), and new RegExp's eager compile
+    // (catchable SyntaxError) — all may-throw generics over the checked-dynamic tree.
+    "dyn.objKeys": "scr_dyn_obj_keys",
+    "dyn.hasOwn": "scr_dyn_has_own",
+    "dyn.assign": "scr_dyn_assign",
+    // variadic Object.assign: the source pack (push never throws; the
+    // spread flatten throws V8's spread-call TypeErrors) and the final
+    // left-to-right copy (ToObject TypeError on a nullish target).
+    "dyn.packPush": "scr_dyn_pack_push",
+    "dyn.packPushSpread": "scr_dyn_pack_push_spread",
+    "dyn.packPushSpreadIter": "scr_dyn_pack_push_spread_iter",
+    "dyn.assignAll": "scr_dyn_assign_all",
+    "dyn.objCreateNullProto": "scr_dyn_new_obj_null_proto",
+    "dyn.objValues": "scr_dyn_obj_values",
+    "dyn.objEntries": "scr_dyn_obj_entries",
+    "dyn.structuredClone": "scr_structured_clone",
+    "dyn.cloneMissing": "scr_structured_clone_missing",
+    "dyn.cloneTransferFail": "scr_structured_clone_transfer_fail",
+    "regex.new": "scr_regex_new",
+    // queueMicrotask's checked-dynamic form (borrowed dyn; a non-function
+    // throws synchronously), the minted setImmediate value, and the
+    // timers/promises immediate — all mark the loop live.
+    "timers.queueMicrotaskDyn": "scr_queue_microtask_dyn",
+    "timers.setImmediateFnValue": "scr_set_immediate_dyn_value",
+    "timers.immediatePromise": "scr_immediate_promise",
+};
+export const USES_TIMERS_LIB_FNS = new Set([
+    "fetch.start",
+    "fetch.abortTimeout", "fetch.streamNew", "fetch.streamFrom",
+    "readable.new", "writable.new", "duplex.new", "transform.new", "passthrough.new",
+    "readable.init", "writable.init", "duplex.init", "transform.init", "passthrough.init",
+    "readable.newDyn", "writable.newDyn", "duplex.newDyn", "transform.newDyn", "passthrough.newDyn",
+    "readable.initDyn", "writable.initDyn", "duplex.initDyn", "transform.initDyn", "passthrough.initDyn",
+    "readable.push", "readable.pushStr", "readable.pushStrEnc", "readable.pushEncoding",
+    "readable.pushNull", "readable.pushU", "readable.pushDyn",
+    "readable.unshift", "readable.unshiftStr", "readable.read", "readable.setEncoding",
+    "readable.nextChunk", "readable.nextChunkDyn", "readable.fromArr", "readable.resume",
+    "readable.pipe", "readable.unpipe",
+    "writable.write", "writable.writeStr", "writable.writeU", "writable.writeDyn",
+    "writable.end", "writable.uncork",
+    "stream.destroy", "stream.destroyErr",
+    "stream.setRead", "stream.setWrite", "stream.setFinal", "stream.setDestroy",
+    "stream.setTransform", "stream.setFlush",
+    "process.activeResources",
+    "stream.finished", "stream.finishedDyn", "stream.pipeline", "stream.pipelineDyn",
+    "sp.finished", "sp.pipeline",
+    "sc.text", "sc.json", "sc.buffer",
+    "net.listen", "net.listenCb", "net.listenOpts", "net.listenOptsCb",
+    "net.listenOptsReusePort", "net.listenOptsReusePortCb",
+    "net.connect", "net.connectCb", "net.connectLookup", "net.connectAttempt",
+    "fs.existsChk",
+    "http.createServer", "http.createServerEmpty",
+    "http.request", "http.requestCb", "http.requestUrl", "http.requestUrlCb",
+    "https.request", "https.requestCb", "https.requestUrl", "https.requestUrlCb",
+    "http.requestConn", "http.requestConnCb",
+    "http.agentNew", "http.requestAgent", "http.requestAgentCb",
+    // The dyn-async slice (exprs.ts's markings): fiber parks, the
+    // microtask/immediate mints, the tracing-promise reaction fiber, and
+    // the checkpoint unhandled-rejection report.
+    "async.hop", "async.awaitDyn",
+    "dc.tcTracePromise",
+    "process.onUnhandledRejection", "process.onRejectionHandled",
+    "timers.queueMicrotaskDyn", "timers.setImmediateFnValue", "timers.immediatePromise",
+]);
+//# sourceMappingURL=lib-shared.js.map