@code-yeongyu/senpi-codemode 2026.10.4 → 2026.10.6

package/src/extension/session-manager.ts

@@ -2,21 +2,22 @@ import { join } from "node:path";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import { type BridgeServerHandle, startBridgeServer } from "../bridge/http-server.ts";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
-import { isReservedToolName, runReservedTool } from "../bridges/reserved-dispatch.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 import { resolveKernelMemoryThresholds } from "../config/memory-settings.ts";
-import { defaultCodemodeSettings } from "../config/settings.ts";
 import { collectOrphanedChildren } from "../host-sdk.ts";
 import { JavaScriptKernel } from "../kernels/js/context-manager.ts";
-import { marshalToolResult } from "../tool/image.ts";
+import type { KernelLifecycle } from "../kernels/shared/kernel-death.ts";
 import type { EvalKernel, EvalLanguage } from "../tool/types.ts";
+import { type BridgeToolCallRequest, routeBridgeToolCall } from "./bridge-tool-call.ts";
+import { parkWhenIdle } from "./idle-parking-kernel.ts";
 import {
 	javaScriptKernelMemory,
-	registerKernel,
+	SessionKernelRegistrations,
 	type StartedKernel,
 	startSubprocessKernel,
 } from "./kernel-registration.ts";
-import { kernelRegistry } from "./kernel-registry.ts";
+import type { RegisteredKernelSource } from "./kernel-registry.ts";
+import { ReplaceableKernel } from "./kernel-replacement.ts";
 import { assertSessionCwdAvailable } from "./session-cwd.ts";
 import type {
 	BridgeEndpoint,
@@ -59,7 +60,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 	readonly #options: CreateCodemodeSessionManagerOptions;
 	#bridge: BridgeServerHandle | undefined;
 	#kernels = new Map<EvalLanguage, EvalKernel>();
-	readonly #registrations = new Map<EvalLanguage, string>();
+	readonly #registrations: SessionKernelRegistrations;
 	#kernelCreations = new Map<EvalLanguage, Promise<EvalKernel>>();
 	#onMessageRefs = new Map<EvalLanguage, (message: KernelToHostMessage) => void>();
 	#context: ExtensionContext | undefined;
@@ -68,6 +69,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 
 	constructor(options: CreateCodemodeSessionManagerOptions) {
 		this.#options = options;
+		this.#registrations = new SessionKernelRegistrations(options.ownerSessionId ?? options.sessionId);
 	}
 
 	async start(): Promise<void> {
@@ -79,29 +81,8 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		});
 	}
 
-	// Subprocess kernels (py/rb/jl) reach the host only through this route, so every reply
-	// must match the in-process JS path in tool/cell-handler.ts: reserved helper names dispatch
-	// through runReservedTool (forwarding them made agent() fail with "Unknown tool __agent__"),
-	// and ordinary tool results are marshalled to { text, images, details, hasError } — the raw
-	// { content } shape left python cells unable to reach tool.read image blocks.
-	async #call(request: { toolName: string; args: unknown; callId: string; signal: AbortSignal }): Promise<unknown> {
-		if (!isReservedToolName(request.toolName)) {
-			return marshalToolResult(
-				await this.#options.executeTool(request.toolName, request.args, { signal: request.signal }),
-			);
-		}
-		const taskTools = this.#options.settings.taskTools ?? defaultCodemodeSettings.taskTools;
-		return await runReservedTool(request.toolName, {
-			callId: request.callId,
-			args: request.args,
-			executeTool: this.#options.executeTool,
-			taskToolName: taskTools.task,
-			taskOutputToolName: taskTools.output,
-			listTools: this.#options.listTools,
-			signal: request.signal,
-			emitStatus: () => {},
-			marshalToolResult,
-		});
+	async #call(request: BridgeToolCallRequest): Promise<unknown> {
+		return await routeBridgeToolCall(this.#options, request);
 	}
 
 	async getKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
@@ -168,7 +149,6 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		const kernels = [...this.#kernels.values()];
 		const bridge = this.#bridge;
 		this.#kernels.clear();
-		for (const id of this.#registrations.values()) kernelRegistry.unregister(id);
 		this.#registrations.clear();
 		this.#onMessageRefs.clear();
 		this.#bridge = undefined;
@@ -192,27 +172,57 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		generation: number,
 	): Promise<EvalKernel> {
 		await assertSessionCwdAvailable(this.#options.cwd);
-		const { kernel, memory } = await this.#createKernel(language, onMessage);
+		const started = await this.#startLanguageKernel(language, onMessage);
+		const idleParkMinutes = this.#options.settings.memory?.idleParkMinutes ?? 0;
+		const resolvedKernel = parkWhenIdle(
+			language,
+			idleParkMinutes,
+			started.kernel,
+			async () => {
+				const restarted = await this.#startLanguageKernel(language, onMessage);
+				if (generation !== this.#generation) {
+					await restarted.kernel.close();
+					throw new CodemodeSessionDisposedError();
+				}
+				this.#registrations.register(language, restarted.memory);
+				return restarted.kernel;
+			},
+			() => this.#registrations.unregister(language),
+		);
 		if (generation !== this.#generation) {
-			await kernel.close();
+			await resolvedKernel.close();
 			throw new CodemodeSessionDisposedError();
 		}
-		this.#kernels.set(language, kernel);
-		this.#registrations.set(
-			language,
-			registerKernel(this.#options.ownerSessionId ?? this.#options.sessionId, language, memory),
-		);
+		this.#kernels.set(language, resolvedKernel);
+		this.#registrations.register(language, started.memory);
 		// The directory can vanish while the interpreter starts; every caller sharing this creation
 		// must see that, not only the next one. The kernel stays stored and dispose still closes it.
 		await assertSessionCwdAvailable(this.#options.cwd);
 		// A dispose that started during the check above already owns this stored kernel.
 		if (generation !== this.#generation) throw new CodemodeSessionDisposedError();
-		return kernel;
+		return resolvedKernel;
+	}
+
+	// py/rb/jl instances can die; the session holds one replaceable kernel per language so every
+	// cell that kept a reference to it survives the death (JS heals its own worker).
+	async #startLanguageKernel(
+		language: EvalLanguage,
+		onMessage: (message: KernelToHostMessage) => void,
+	): Promise<{ readonly kernel: EvalKernel; readonly memory: RegisteredKernelSource | undefined }> {
+		if (language === "js") return await this.#createKernel(language, onMessage);
+		let memory: RegisteredKernelSource | undefined;
+		const kernel = await ReplaceableKernel.create(language, async (lifecycle) => {
+			const created = await this.#createKernel(language, onMessage, lifecycle);
+			memory ??= created.memory;
+			return created.kernel;
+		});
+		return { kernel, memory };
 	}
 
 	async #createKernel(
 		language: EvalLanguage,
 		onMessage: (message: KernelToHostMessage) => void,
+		lifecycle: KernelLifecycle = {},
 	): Promise<StartedKernel> {
 		const bridge = this.#bridge;
 		if (!bridge) throw new Error("codemode bridge server is not running");
@@ -255,6 +265,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 			...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 			connection,
 			onMessage,
+			...lifecycle,
 		};
 		const memory = resolveKernelMemoryThresholds(this.#options.settings.memory);
 		return await startSubprocessKernel({ language, interpreterPath: detected.path, memory, shared });

package/src/kernels/jl/kernel.ts

@@ -1,10 +1,12 @@
 import { join } from "node:path";
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { SessionEnvironment } from "../session-env.ts";
+import type { KernelLifecycle } from "../shared/kernel-death.ts";
+import { readProcessGroupCpuTime } from "../shared/process-group-cpu.ts";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { SubprocessKernel, type SubprocessKernelMemory, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
 
-export interface JuliaKernelStartOptions {
+export interface JuliaKernelStartOptions extends KernelLifecycle {
 	readonly cwd: string;
 	readonly sessionId: string;
 	readonly connection: BridgeConnectionConfig;
@@ -13,7 +15,7 @@ export interface JuliaKernelStartOptions {
 	readonly command?: string;
 	readonly spawn?: SubprocessSpawn;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
-	/** Ceiling-only memory management (no notice or globals list: the runner reports no memory). */
+	/** Memory management: the runner reports its largest globals and the host reads the interpreter footprint for the ceiling. */
 	readonly memory?: SubprocessKernelMemory;
 }
 
@@ -52,6 +54,8 @@ export class JuliaKernel extends SubprocessKernel {
 			spawn: options.spawn,
 			onMessage: options.onMessage,
 			memory: options.memory && { language: "jl", ...options.memory },
+			onDeath: options.onDeath,
+			startup: { label: "Julia", readGroupCpuTime: readProcessGroupCpuTime },
 		});
 	}
 }

package/src/kernels/jl/runner.jl

@@ -1,4 +1,6 @@
 # allow: SIZE_OK — parser, stream capture, bridge calls, and the persistent execution loop share Main globals.
+write(stdout, "{\"type\":\"status\",\"event\":{\"op\":\"kernel-startup\",\"stage\":\"stdlib-imports\"}}\n")
+flush(stdout)
 using Sockets
 
 const SENPI_ORIGINAL_STDOUT = stdout
@@ -7,6 +9,8 @@ out_read, out_write = redirect_stdout()
 err_read, err_write = redirect_stderr()
 redirect_stdin(devnull)
 
+write(SENPI_ORIGINAL_STDOUT, "{\"type\":\"status\",\"event\":{\"op\":\"kernel-startup\",\"stage\":\"runtime-init\"}}\n")
+flush(SENPI_ORIGINAL_STDOUT)
 include("prelude.jl")
 
 const senpi_connection = Dict{String, Any}()
@@ -281,6 +285,152 @@ function senpi_set_connection(value)
     end
 end
 
+const senpi_memory = Ref{Any}(nothing)
+
+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
+        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)
+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
+    end
+end
+
 function senpi_run_cell(message)
     cell_id = string(get(message, "cellId", ""))
     code = string(get(message, "code", ""))
@@ -297,6 +447,8 @@ function senpi_run_cell(message)
         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)
         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)))
@@ -313,7 +465,9 @@ while !eof(SENPI_ORIGINAL_STDIN)
         message isa AbstractDict || error("Bridge frame must be an object")
         kind = get(message, "type", nothing)
         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"))
         elseif kind == "run"
             senpi_run_cell(message)

package/src/kernels/js/context-manager.ts

@@ -1,6 +1,7 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { CHILD_LIFECYCLE_OP, INTERRUPT_ACK_OP } from "../../bridge/reserved.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
+import { KernelToolHostPump } from "../shared/kernel-tools-pump.ts";
 import { ActiveCellControl } from "./active-cell-control.ts";
 import { DEFAULT_INTERRUPT_BOUNDS, type WorkerRetirement } from "./interrupt-bounds.ts";
 import {
@@ -14,7 +15,6 @@ import {
 } from "./kernel-contract.ts";
 import { type JavaScriptMemoryReading, KernelMemoryBridge } from "./kernel-memory-bridge.ts";
 import { kernelToolError } from "./kernel-tools-errors.ts";
-import { KernelToolHostPump } from "./kernel-tools-host.ts";
 import type {
 	KernelToolsDescribeResult,
 	KernelToolsInvokeOptions,

package/src/kernels/js/kernel-tools-types.ts

@@ -1,4 +1,5 @@
 import type { ExtensionKernelTools, KernelToolInvokeOptions, KernelToolInvokeScope } from "@code-yeongyu/senpi";
+import type { EvalLanguage } from "../../tool/types.ts";
 import type { KernelToolErrorCode, KernelToolHostDenial, KernelToolHostDenialReason } from "./kernel-tools-errors.ts";
 
 export type { KernelToolErrorCode, KernelToolHostDenial, KernelToolHostDenialReason };
@@ -7,7 +8,7 @@ export type KernelToolDescriptor = {
 	readonly name: string;
 	readonly description: string;
 	readonly input_schema: unknown;
-	readonly language: "js";
+	readonly language: EvalLanguage;
 	readonly kernel_generation: number;
 	readonly definition_revision: number;
 };

package/src/kernels/js/worker-core.js

@@ -24,6 +24,7 @@ const SESSION_ENVIRONMENT_KEYS = [
 	"PI_PROVIDER",
 	"PI_MODEL",
 	"PI_REASONING_LEVEL",
+	"OMO_BROWSER_ENGINE",
 ];
 
 export function createWorkerCore(transport, options) {

package/src/kernels/js/worker-global-sizes.js

@@ -9,6 +9,54 @@ const FUNCTION_BYTES = 64;
 const INTERNAL_GLOBAL_PREFIX = "__senpi";
 const MIN_REPORTED_BYTES = 1024 * 1024;
 
+function intrinsicGetter(prototype, name) {
+	return Object.getOwnPropertyDescriptor(prototype, name)?.get;
+}
+
+// Built-in getters captured at load: a user subclass that overrides `byteLength` or `size` is never called.
+const TYPED_ARRAY_BYTE_LENGTH = intrinsicGetter(Object.getPrototypeOf(Uint8Array.prototype), "byteLength");
+const DATA_VIEW_BYTE_LENGTH = intrinsicGetter(DataView.prototype, "byteLength");
+const ARRAY_BUFFER_BYTE_LENGTH = intrinsicGetter(ArrayBuffer.prototype, "byteLength");
+const SHARED_ARRAY_BUFFER_BYTE_LENGTH =
+	typeof SharedArrayBuffer === "function" ? intrinsicGetter(SharedArrayBuffer.prototype, "byteLength") : undefined;
+const MAP_SIZE = intrinsicGetter(Map.prototype, "size");
+const SET_SIZE = intrinsicGetter(Set.prototype, "size");
+const BLOB_SIZE = typeof Blob === "function" ? intrinsicGetter(Blob.prototype, "size") : undefined;
+// Iteration captured at load too: a user who replaces Map.prototype.entries or an iterator's next() is never called.
+const MAP_ENTRIES = Map.prototype.entries;
+const SET_VALUES = Set.prototype.values;
+const MAP_ITERATOR_NEXT = Object.getPrototypeOf(new Map().entries()).next;
+const SET_ITERATOR_NEXT = Object.getPrototypeOf(new Set().values()).next;
+
+function read(getter, value) {
+	return Reflect.apply(getter, value, []);
+}
+
+const GET_PROTOTYPE_OF = Object.getPrototypeOf;
+const BLOB_PROTOTYPE = typeof Blob === "function" ? Blob.prototype : undefined;
+
+function inheritsFromBlob(value) {
+	for (let prototype = GET_PROTOTYPE_OF(value); prototype !== null; prototype = GET_PROTOTYPE_OF(prototype)) {
+		// A Proxy in the chain would run its getPrototypeOf trap on the next step.
+		if (types.isProxy(prototype)) return false;
+		if (prototype === BLOB_PROTOTYPE) return true;
+	}
+	return false;
+}
+
+// The Blob brand: a cheap prototype-chain pre-check (no user hook; proxies never reach here) so ordinary
+// objects skip the try, then the size getter as the proof, which throws on a forged look-alike.
+// instanceof would call a user-redefinable Symbol.hasInstance.
+function isBlob(value) {
+	if (BLOB_SIZE === undefined || !inheritsFromBlob(value)) return false;
+	try {
+		read(BLOB_SIZE, value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 export function captureGlobalBaseline() {
 	return new Set(Object.getOwnPropertyNames(globalThis));
 }
@@ -55,11 +103,12 @@ function createSizer() {
 		return (total / SAMPLED_ELEMENTS) * length;
 	}
 
-	function entriesOf(iterable, count, depth, sizeOf) {
+	function entriesOf(iterator, next, count, depth, sizeOf) {
 		const taken = [];
-		for (const entry of iterable) {
-			taken.push(entry);
-			if (taken.length >= SAMPLED_ELEMENTS) break;
+		while (taken.length < SAMPLED_ELEMENTS) {
+			const step = Reflect.apply(next, iterator, []);
+			if (step.done) break;
+			taken.push(step.value);
 		}
 		if (taken.length < count) approximate = true;
 		let total = 0;
@@ -67,21 +116,42 @@ function createSizer() {
 		return total * (count / Math.max(1, taken.length));
 	}
 
+	// An own data element, never a getter: an accessor is left unsized and makes the estimate approximate.
+	function elementOf(array, index) {
+		const descriptor = Object.getOwnPropertyDescriptor(array, index);
+		if (descriptor === undefined) return undefined;
+		if ("value" in descriptor) return descriptor.value;
+		approximate = true;
+		return undefined;
+	}
+
 	function objectSize(value, depth) {
 		if (types.isProxy(value)) return OBJECT_BYTES;
-		if (ArrayBuffer.isView(value)) return value.byteLength;
-		if (types.isAnyArrayBuffer(value)) return value.byteLength;
-		if (typeof Blob === "function" && value instanceof Blob) return value.size;
-		if (Array.isArray(value)) return OBJECT_BYTES + value.length * POINTER_BYTES + sampled(value.length, (index) => value[index], depth);
-		if (value instanceof Map) {
-			const entries = Map.prototype.entries.call(value);
-			return OBJECT_BYTES + value.size * 2 * POINTER_BYTES + entriesOf(entries, value.size, depth, ([key, item], at) => size(key, at) + size(item, at));
+		if (types.isTypedArray(value)) return read(TYPED_ARRAY_BYTE_LENGTH, value);
+		if (types.isDataView(value)) return read(DATA_VIEW_BYTE_LENGTH, value);
+		if (types.isArrayBuffer(value)) return read(ARRAY_BUFFER_BYTE_LENGTH, value);
+		if (types.isSharedArrayBuffer(value) && SHARED_ARRAY_BUFFER_BYTE_LENGTH) return read(SHARED_ARRAY_BUFFER_BYTE_LENGTH, value);
+		if (isBlob(value)) return read(BLOB_SIZE, value);
+		if (Array.isArray(value)) {
+			const length = value.length;
+			return OBJECT_BYTES + length * POINTER_BYTES + sampled(length, (index) => elementOf(value, index), depth);
+		}
+		if (types.isMap(value)) {
+			const count = read(MAP_SIZE, value);
+			const entries = Reflect.apply(MAP_ENTRIES, value, []);
+			return OBJECT_BYTES + count * 2 * POINTER_BYTES + entriesOf(entries, MAP_ITERATOR_NEXT, count, depth, ([key, item], at) => size(key, at) + size(item, at));
+		}
+		if (types.isSet(value)) {
+			const count = read(SET_SIZE, value);
+			return OBJECT_BYTES + count * POINTER_BYTES + entriesOf(Reflect.apply(SET_VALUES, value, []), SET_ITERATOR_NEXT, count, depth, size);
 		}
-		if (value instanceof Set) return OBJECT_BYTES + value.size * POINTER_BYTES + entriesOf(Set.prototype.values.call(value), value.size, depth, size);
 		const keys = Object.keys(value);
 		const propertyValue = (index) => {
 			const descriptor = Object.getOwnPropertyDescriptor(value, keys[index]);
-			return descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+			if (descriptor === undefined) return undefined;
+			if ("value" in descriptor) return descriptor.value;
+			approximate = true;
+			return undefined;
 		};
 		return OBJECT_BYTES + keys.length * POINTER_BYTES + sampled(keys.length, propertyValue, depth);
 	}
@@ -114,7 +184,7 @@ function createSizer() {
 			try {
 				return { bytes: POINTER_BYTES + size(value, 0), approximate };
 			} catch (error) {
-				// A user value can still throw from an exotic element read (an index getter); it is left unsized.
+				// A forged built-in look-alike (a Blob-prototype object without its slot) throws from the intrinsic getter; it is left unsized.
 				if (error instanceof Error) return undefined;
 				throw error;
 			}

package/src/kernels/py/kernel-contract.ts

@@ -2,11 +2,12 @@ import type { KernelMemoryThresholds } from "../../bridge/memory-protocol.ts";
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { EvalKernelRunInput } from "../../tool/types.ts";
 import type { SessionEnvironment } from "../session-env.ts";
+import type { KernelLifecycle } from "../shared/kernel-death.ts";
 import type { KernelSpawnProcess } from "./process.ts";
 import type { PythonStartupStage } from "./startup.ts";
 import type { PythonTransportResult } from "./transport.ts";
 
-export interface PythonKernelStartOptions {
+export interface PythonKernelStartOptions extends KernelLifecycle {
 	readonly interpreterPath: string;
 	readonly sessionId: string;
 	readonly cwd: string;