@code-yeongyu/senpi-codemode 2026.10.10 → 2026.10.12

package/src/kernels/jl/runner.jl

@@ -16,6 +16,7 @@ include("prelude.jl")
 const senpi_connection = Dict{String, Any}()
 const senpi_write_lock = ReentrantLock()
 global senpi_current_cell = nothing
+global senpi_memory_cell = nothing
 
 function senpi_escape(text::AbstractString)
     out = IOBuffer()
@@ -290,150 +291,31 @@ function senpi_set_connection(value)
     end
 end
 
-const senpi_memory = Ref{Any}(nothing)
+const SENPI_GLOBALS_INCLUDED = Ref(false)
 
-const SENPI_MEMORY_INTERNALS = Set([:senpi_current_cell, :senpi_memory, :senpi_connection, :senpi_frame_io, :senpi_stdout_capture, :senpi_stderr_capture, :senpi_protocol_stdin])
-
-const SENPI_SIZER_SAMPLE = 1_000
-const SENPI_SIZER_NODE_BUDGET = 5_000
-const SENPI_SIZER_MAX_DEPTH = 64
-const SENPI_SIZER_POINTER = 8
-const SENPI_SIZER_OBJECT = 16
-const SENPI_SIZER_MIN_REPORTED = 1024 * 1024
-
-# Sizes a global with sampling and a node budget per global (leaves count too), so one deep global
-# never hides the ones measured after it and a huge container costs a bounded walk. Only concrete Base
-# containers are iterated; any other AbstractDict or AbstractSet is sized as an opaque struct, so no user
-# length or iterate method runs during a memory report.
-mutable struct SenpiSizer
-    seen::IdDict{Any, Nothing}
-    nodes::Int
-    approximate::Bool
-end
-SenpiSizer() = SenpiSizer(IdDict{Any, Nothing}(), 0, false)
-
-senpi_over_budget(sizer::SenpiSizer) = sizer.nodes >= SENPI_SIZER_NODE_BUDGET
-
-function senpi_size(sizer::SenpiSizer, value, depth::Int)::Int
-    sizer.nodes += 1
-    value isa Type && return 0
-    value isa Union{Number, Char, Bool, Symbol, Nothing} && return isbits(value) ? sizeof(value) : 0
-    value isa String && return SENPI_SIZER_OBJECT + sizeof(value)
-    if ismutable(value)
-        haskey(sizer.seen, value) && return 0
-        sizer.seen[value] = nothing
-    end
-    if depth >= SENPI_SIZER_MAX_DEPTH || senpi_over_budget(sizer)
-        sizer.approximate = true
-        return SENPI_SIZER_OBJECT
-    end
-    if value isa Array
-        isbitstype(eltype(value)) && return SENPI_SIZER_OBJECT + sizeof(value)
-        return SENPI_SIZER_OBJECT + length(value) * SENPI_SIZER_POINTER +
-            senpi_sampled(sizer, length(value), depth) do index
-                isassigned(value, index) ? value[index] : nothing
-            end
-    elseif value isa Union{Dict, IdDict}
-        count = length(value)
-        total = 0
-        taken = 0
-        for (key, item) in value
-            senpi_over_budget(sizer) && break
-            total += senpi_size(sizer, key, depth + 1) + senpi_size(sizer, item, depth + 1)
-            taken += 1
-            taken >= SENPI_SIZER_SAMPLE && break
-        end
-        taken < count && (sizer.approximate = true)
-        return SENPI_SIZER_OBJECT + count * 2 * SENPI_SIZER_POINTER + (taken == 0 ? 0 : div(total * count, taken))
-    elseif value isa Union{Set, Tuple}
-        count = length(value)
-        total = 0
-        taken = 0
-        for item in value
-            senpi_over_budget(sizer) && break
-            total += senpi_size(sizer, item, depth + 1)
-            taken += 1
-            taken >= SENPI_SIZER_SAMPLE && break
-        end
-        taken < count && (sizer.approximate = true)
-        return SENPI_SIZER_OBJECT + count * SENPI_SIZER_POINTER + (taken == 0 ? 0 : div(total * count, taken))
-    end
-    isbits(value) && return sizeof(value)
-    fields = fieldcount(typeof(value))
-    return SENPI_SIZER_OBJECT + fields * SENPI_SIZER_POINTER +
-        senpi_sampled(sizer, fields, depth) do index
-            isdefined(value, index) ? getfield(value, index) : nothing
-        end
-end
-
-# Up to SENPI_SIZER_SAMPLE evenly spaced elements; once the budget runs out part-way, the elements measured
-# so far stand in for the rest.
-function senpi_sampled(at, sizer::SenpiSizer, count::Int, depth::Int)::Int
-    count == 0 && return 0
-    picks = min(count, SENPI_SIZER_SAMPLE)
-    picks < count && (sizer.approximate = true)
-    step = count / picks
-    total = 0
-    measured = 0
-    for sample in 1:picks
-        if senpi_over_budget(sizer)
-            sizer.approximate = true
-            break
+function senpi_memory_globals(limit::Int)
+    if !SENPI_GLOBALS_INCLUDED[]
+        try
+            include(joinpath(@__DIR__, "globals.jl"))
+            SENPI_GLOBALS_INCLUDED[] = true
+        catch
+            return Dict{String, Any}[]
         end
-        total += senpi_size(sizer, at(1 + floor(Int, (sample - 1) * step)), depth + 1)
-        measured += 1
     end
-    return measured == 0 ? 0 : round(Int, total / measured * count)
+    Base.invokelatest(() -> senpi_largest_globals(limit))
 end
 
-function senpi_largest_globals(limit::Int)
-    try
-        sizer = SenpiSizer()
-        candidates = Tuple{String, Int, Bool}[]
-        Base.invokelatest() do
-            for name in names(Main, all = true)
-                name in SENPI_MEMORY_INTERNALS && continue
-                name in (:Main, :Base, :Core, :Ans, :ans) && continue
-                lowered = lowercase(string(name))
-                startswith(lowered, "senpi_") && continue
-                startswith(string(name), "Senpi") && continue
-                startswith(string(name), "#") && continue
-                isdefined(Main, name) || continue
-                value = getfield(Main, name)
-                value isa Module && continue
-                value isa IO && continue
-                value isa Type && continue
-                value isa Function && continue
-                sizer.approximate = false
-                sizer.nodes = 0
-                bytes = try
-                    senpi_size(sizer, value, 0) + SENPI_SIZER_POINTER
-                catch
-                    0
-                end
-                bytes >= SENPI_SIZER_MIN_REPORTED && push!(candidates, (string(name), bytes, sizer.approximate))
-            end
-        end
-        sort!(candidates, by = entry -> entry[2], rev = true)
-        [approximate ? Dict{String, Any}("name" => name, "bytes" => bytes, "approximate" => true) : Dict{String, Any}("name" => name, "bytes" => bytes) for (name, bytes, approximate) in candidates[1:min(limit, end)]]
-    catch
-        Dict{String, Any}[]
-    end
-end
-
-function senpi_memory_report()
-    try
-        senpi_memory[] === nothing && return nothing
-        # The host reads the interpreter's current footprint and decides on the notice; the runner only
-        # names its largest globals, with a bounded walk, so a cell never pays for an unbounded scan.
-        named = senpi_largest_globals(5)
-        # The host replaces liveBytes with the interpreter footprint it reads itself; only globals is used.
-        report = Dict{String, Any}("liveBytes" => 0, "measure" => "footprint")
-        isempty(named) || (report["globals"] = named)
-        report
-    catch
-        nothing
+function senpi_needs_handles(expression)
+    if expression isa Symbol
+        expression in (:handle, :completion, :eval, :include, :getfield, :getglobal, :deserialize) && return true
+        name = string(expression)
+        return startswith(name, "SenpiHandle") || startswith(name, "senpi_handle") ||
+            startswith(name, "senpi_wait") ||
+            (startswith(name, "SENPI_") && (occursin("HANDLE", name) || occursin("WAIT", name)))
     end
+    expression isa QuoteNode && return senpi_needs_handles(expression.value)
+    expression isa Expr && return any(senpi_needs_handles, expression.args)
+    false
 end
 
 function senpi_run_cell(message)
@@ -446,19 +328,23 @@ function senpi_run_cell(message)
         if parsed isa Expr && parsed.head === :error
             error(string(parsed.args[1]))
         end
+        # Install bindings before user functions/type annotations capture their world.
+        !SENPI_HANDLES_INCLUDED[] && senpi_needs_handles(parsed) && senpi_ensure_handles()
         value = Core.eval(Main, parsed)
         flush(stdout)
         flush(stderr)
         yield()
         frame = Dict{String, Any}("type" => "result", "cellId" => cell_id, "ok" => true, "durationMs" => round(Int, (time() - started) * 1000))
-        value !== nothing && senpi_should_display_result(parsed) && (frame["valueRepr"] = senpi_json(value))
-        memory = senpi_memory_report()
-        memory !== nothing && (frame["memory"] = memory)
+        if value !== nothing && senpi_should_display_result(parsed)
+            # Core.eval does not advance this caller's world after a first lazy include.
+            frame["valueRepr"] = SENPI_HANDLES_INCLUDED[] ? Base.invokelatest(senpi_json, value) : senpi_json(value)
+        end
         senpi_emit(frame)
     catch error
         senpi_emit(Dict("type" => "result", "cellId" => cell_id, "ok" => false, "error" => senpi_error(error), "durationMs" => round(Int, (time() - started) * 1000)))
     finally
         global senpi_current_cell = nothing
+        global senpi_memory_cell = cell_id
     end
 end
 
@@ -472,10 +358,16 @@ while !eof(SENPI_ORIGINAL_STDIN)
         if kind == "init"
             senpi_emit(Dict("type" => "status", "event" => Dict("op" => "kernel-startup", "stage" => "host-init")))
             senpi_set_connection(get(message, "connection", nothing))
-            senpi_memory[] = get(message, "memory", nothing)
-            senpi_emit(Dict("type" => "ready"))
+            senpi_emit(Dict("type" => "ready", "memoryGlobals" => true))
         elseif kind == "run"
+            global senpi_memory_cell = nothing
             senpi_run_cell(message)
+        elseif kind == "memory-globals"
+            cell_id = get(message, "cellId", nothing)
+            if cell_id == senpi_memory_cell && senpi_current_cell === nothing
+                senpi_emit(Dict("type" => "memory-globals-result", "cellId" => cell_id, "globals" => senpi_memory_globals(5)))
+                global senpi_memory_cell = nothing
+            end
         elseif kind == "close"
             senpi_emit(Dict("type" => "closed"))
             break

package/src/kernels/js/cell-ownership.js

@@ -0,0 +1,268 @@
+import { currentCell, onReleaseOf, settleWithCell } from "./cell-run-context.js";
+
+// What a cell owns, and how each kind ends when the cell is stopped. Every patch is a no-op outside a cell, refuses
+// (or never starts) new work for a released cell, and registers what a live cell starts so release can end it.
+const RESOURCE_CLOSERS = ["terminate", "destroy", "stop", "close", "end"];
+
+// Some host bindings are read-only (Bun.fetch); those keep their own behaviour and are not owned by cells.
+function replace(owner, name, replacement, patched) {
+	const original = owner[name];
+	try {
+		owner[name] = replacement;
+	} catch {
+		return;
+	}
+	if (owner[name] !== replacement) return;
+	patched.push(() => {
+		owner[name] = original;
+	});
+}
+
+function builtin(name) {
+	return process.getBuiltinModule?.(name);
+}
+
+function closeResource(resource) {
+	for (const method of RESOURCE_CLOSERS) {
+		if (typeof resource?.[method] !== "function") continue;
+		if (method === "stop") resource.stop(true);
+		else resource[method]();
+		return;
+	}
+}
+
+function ownResultsOf(owner, names, patched) {
+	for (const name of names) {
+		const original = owner?.[name];
+		if (typeof original !== "function") continue;
+		const own = function (...args) {
+			const cell = currentCell();
+			if (cell === undefined) return original.apply(this, args);
+			if (cell.released) throw cell.interruption;
+			const result = original.apply(this, args);
+			const register = (resource) => {
+				onReleaseOf(cell, () => closeResource(resource));
+				return resource;
+			};
+			return result instanceof Promise ? result.then(register) : register(result);
+		};
+		Object.assign(own, original);
+		replace(owner, name, own, patched);
+	}
+}
+
+// `globals` is the global scope already patched: a module binding that is the same owned function is left alone.
+function patchTimers(scope, patched, globals = undefined) {
+	for (const [name, clearName] of [
+		["setTimeout", "clearTimeout"],
+		["setInterval", "clearInterval"],
+		["setImmediate", "clearImmediate"],
+	]) {
+		const original = scope?.[name];
+		const clear = scope?.[clearName];
+		if (typeof original !== "function" || typeof clear !== "function") continue;
+		if (globals !== undefined && original === globals[name]) continue;
+		const owned = function (callback, ...rest) {
+			const cell = currentCell();
+			if (cell === undefined || typeof callback !== "function") return original.call(this, callback, ...rest);
+			if (cell.released) {
+				const never = original.call(this, () => {}, ...rest);
+				clear.call(scope, never);
+				return never;
+			}
+			let forget = () => {};
+			const handle = original.call(
+				this,
+				function (...args) {
+					if (name !== "setInterval") forget();
+					return callback.apply(this, args);
+				},
+				...rest,
+			);
+			forget = onReleaseOf(cell, () => clear.call(scope, handle));
+			return handle;
+		};
+		Object.assign(owned, original);
+		replace(scope, name, owned, patched);
+	}
+}
+
+function patchPromiseApi(owner, name, patched) {
+	const original = owner?.[name];
+	if (typeof original !== "function") return;
+	const bound = function (...args) {
+		const cell = currentCell();
+		if (cell === undefined) return original.apply(this, args);
+		if (cell.released) return Promise.reject(cell.interruption);
+		return settleWithCell(cell, original.apply(this, args));
+	};
+	Object.assign(bound, original);
+	replace(owner, name, bound, patched);
+}
+
+function patchTimerPromises(patched) {
+	const timers = builtin("node:timers/promises");
+	if (timers === undefined) return;
+	patchPromiseApi(timers, "setTimeout", patched);
+	patchPromiseApi(timers, "setImmediate", patched);
+	const original = timers.setInterval;
+	if (typeof original !== "function") return;
+	const owned = function (...args) {
+		const cell = currentCell();
+		if (cell?.released) throw cell.interruption;
+		const iterator = original.apply(this, args);
+		if (cell === undefined) return iterator;
+		onReleaseOf(cell, () => void iterator.return?.());
+		return iterator;
+	};
+	replace(timers, "setInterval", owned, patched);
+}
+
+function patchFetch(scope, patched, name = "fetch") {
+	const original = scope[name];
+	if (typeof original !== "function") return;
+	const owned = function (input, init) {
+		const cell = currentCell();
+		if (cell === undefined) return original.call(this, input, init);
+		if (cell.released) return Promise.reject(cell.interruption);
+		const controller = new AbortController();
+		const own = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+		const signal = own === undefined ? controller.signal : AbortSignal.any([own, controller.signal]);
+		const forget = onReleaseOf(cell, () => controller.abort(cell.interruption));
+		return original.call(this, input, { ...init, signal }).finally(forget);
+	};
+	Object.assign(owned, original);
+	replace(scope, name, owned, patched);
+}
+
+// A released cell's code may still be resumed by a short I/O completion; refusing new I/O at that point makes such a
+// loop throw the interruption on its next operation instead of running on in the kept worker.
+function refuseWhenReleased(owner, names, patched) {
+	for (const name of names) {
+		const original = owner?.[name];
+		if (typeof original !== "function") continue;
+		const guarded = function (...args) {
+			const cell = currentCell();
+			if (cell?.released) throw cell.interruption;
+			const result = original.apply(this, args);
+			return cell === undefined ? result : settleWithCell(cell, result);
+		};
+		Object.assign(guarded, original);
+		replace(owner, name, guarded, patched);
+	}
+}
+
+// The callback form: a released cell's operation is never started, so its callback never runs, the same way a timer a
+// released cell sets never fires.
+function neverStartWhenReleased(owner, names, patched) {
+	for (const name of names) {
+		const original = owner?.[name];
+		if (typeof original !== "function") continue;
+		const guarded = function (...args) {
+			if (currentCell()?.released) return undefined;
+			return original.apply(this, args);
+		};
+		Object.assign(guarded, original);
+		replace(owner, name, guarded, patched);
+	}
+}
+
+const FS_OPERATIONS = ["readFile", "writeFile", "appendFile", "readdir", "stat", "lstat", "open", "access", "mkdir", "rm", "unlink", "rename", "copyFile"];
+
+// For ES classes only (Worker, WebSocket, MessageChannel): `instanceof` keeps accepting instances the runtime creates
+// internally from the original class. Node's function-style constructors are owned on activation instead.
+function patchClass(scope, name, close, patched) {
+	const Original = scope?.[name];
+	if (typeof Original !== "function") return;
+	const Owned = class extends Original {
+		constructor(...args) {
+			const cell = currentCell();
+			if (cell?.released) throw cell.interruption;
+			super(...args);
+			if (cell !== undefined) onReleaseOf(cell, () => close(this));
+		}
+		static [Symbol.hasInstance](value) {
+			return value instanceof Original;
+		}
+	};
+	Object.defineProperty(Owned, "name", { value: Original.name });
+	replace(scope, name, Owned, patched);
+}
+
+const NODE_RESOURCE_FACTORIES = {
+	"node:net": ["createConnection", "connect", "createServer"],
+	"node:tls": ["connect", "createServer"],
+	"node:http": ["request", "get", "createServer"],
+	"node:https": ["request", "get", "createServer"],
+	"node:dgram": ["createSocket"],
+	"node:fs": ["createReadStream", "createWriteStream", "watch"],
+	"node:readline": ["createInterface"],
+	"node:readline/promises": ["createInterface"],
+};
+
+// Node's socket and server types are function-style constructors that Node's own subclasses call with `.call(this)`
+// (http.Server calls net.Server), so they cannot be swapped for a class. A socket or server only does anything once it
+// connects, listens or binds, so that call is where a cell takes ownership of it; http, https and tls inherit these.
+const NODE_ACTIVATIONS = {
+	"node:net": { Socket: ["connect"], Server: ["listen"] },
+	"node:dgram": { Socket: ["bind"] },
+};
+
+function ownOnActivation(proto, names, patched) {
+	for (const name of names) {
+		const original = proto?.[name];
+		if (typeof original !== "function") continue;
+		const owned = new WeakSet();
+		const activate = function (...args) {
+			const cell = currentCell();
+			if (cell === undefined) return original.apply(this, args);
+			if (cell.released) throw cell.interruption;
+			if (!owned.has(this)) {
+				owned.add(this);
+				onReleaseOf(cell, () => closeResource(this));
+			}
+			return original.apply(this, args);
+		};
+		replace(proto, name, activate, patched);
+	}
+}
+
+export function installCellOwnership(scope = globalThis) {
+	const patched = [];
+	patchTimers(scope, patched);
+	patchTimers(builtin("node:timers"), patched, scope);
+	patchTimerPromises(patched);
+	patchFetch(scope, patched);
+	patchClass(scope, "WebSocket", (socket) => socket.close(), patched);
+	patchClass(scope, "Worker", (worker) => void worker.terminate(), patched);
+	refuseWhenReleased(builtin("node:fs/promises"), FS_OPERATIONS, patched);
+	neverStartWhenReleased(builtin("node:fs"), FS_OPERATIONS, patched);
+	patchClass(scope, "MessageChannel", (channel) => {
+		channel.port1.close();
+		channel.port2.close();
+	}, patched);
+	patchClass(scope, "BroadcastChannel", (channel) => channel.close(), patched);
+	const bun = scope.Bun;
+	if (bun !== undefined) {
+		patchPromiseApi(bun, "sleep", patched);
+		if (bun.fetch !== scope.fetch) patchFetch(bun, patched, "fetch");
+		refuseWhenReleased(bun, ["file", "write"], patched);
+		ownResultsOf(bun, ["connect", "listen", "serve", "udpSocket"], patched);
+	}
+	for (const [module, factories] of Object.entries(NODE_RESOURCE_FACTORIES)) ownResultsOf(builtin(module), factories, patched);
+	patchClass(builtin("node:worker_threads"), "Worker", (worker) => void worker.terminate(), patched);
+	for (const [module, types] of Object.entries(NODE_ACTIVATIONS)) {
+		for (const [name, methods] of Object.entries(types)) ownOnActivation(builtin(module)?.[name]?.prototype, methods, patched);
+	}
+	// Node hands `import("node:…")` its own ESM namespace; without this sync a cell importing the module gets the
+	// unowned originals.
+	syncBuiltinExports();
+	return () => {
+		for (const undo of patched.reverse()) undo();
+		syncBuiltinExports();
+	};
+}
+
+function syncBuiltinExports() {
+	builtin("node:module")?.syncBuiltinESMExports?.();
+}

package/src/kernels/js/cell-run-context.js

@@ -0,0 +1,89 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// Every continuation a cell creates (awaits, timers, I/O callbacks) runs inside its cell record. Stopping a cell
+// releases it: everything it owns is cleared, rejected or closed (`cell-ownership.js` decides what a cell owns), and
+// anything its code tries to start afterwards is refused, while the kernel and its variables stay.
+const cellRuns = new AsyncLocalStorage();
+const releasedInterruptions = new WeakMap();
+const MAX_CAUSE_DEPTH = 8;
+
+export function runInCell(cell, run) {
+	return cellRuns.run(cell, run);
+}
+
+export function currentCell() {
+	return cellRuns.getStore();
+}
+
+export function releasedCellError() {
+	const cell = cellRuns.getStore();
+	return cell?.released === true ? cell.interruption : undefined;
+}
+
+export function assertCellLive() {
+	const error = releasedCellError();
+	if (error !== undefined) throw error;
+}
+
+export function onCellRelease(close) {
+	const cell = cellRuns.getStore();
+	return cell === undefined ? () => {} : onReleaseOf(cell, close);
+}
+
+export function onReleaseOf(cell, close) {
+	cell.onRelease ??= new Set();
+	cell.onRelease.add(close);
+	return () => cell.onRelease.delete(close);
+}
+
+/**
+ * Releases the cell: every closer runs even when an earlier one throws, and the failures are returned so the caller
+ * can report them; a resource that would not close is a fact the user should see, not something to swallow.
+ */
+export function releaseCell(cell) {
+	cell.released = true;
+	releasedInterruptions.set(cell.interruption, cell);
+	const failures = [];
+	for (const close of cell.onRelease ?? []) {
+		try {
+			close();
+		} catch (error) {
+			failures.push(error);
+		}
+	}
+	cell.onRelease?.clear();
+	return failures;
+}
+
+/**
+ * The cell an unhandled rejection came from: a released cell whose interruption is the reason or sits in its `cause`
+ * chain, or the cell whose async context the rejection runs in (Node exposes it to the handler; Bun does not).
+ */
+export function cellOfRejection(reason) {
+	let current = reason;
+	for (let depth = 0; depth < MAX_CAUSE_DEPTH && typeof current === "object" && current !== null; depth++) {
+		const cell = releasedInterruptions.get(current);
+		if (cell !== undefined) return cell;
+		current = current.cause;
+	}
+	return cellRuns.getStore();
+}
+
+// An operation already in flight when its cell is released rejects with the interruption at once, so the stopped
+// cell's continuation never runs again; a non-promise result is returned as it is.
+export function settleWithCell(cell, result) {
+	if (result === null || typeof result !== "object" || typeof result.then !== "function") return result;
+	return new Promise((resolve, reject) => {
+		const forget = onReleaseOf(cell, () => reject(cell.interruption));
+		result.then(
+			(value) => {
+				forget();
+				resolve(value);
+			},
+			(error) => {
+				forget();
+				reject(error);
+			},
+		);
+	});
+}