@code-yeongyu/senpi-codemode 2026.7.25-2

package/src/kernels/py/process.ts

@@ -0,0 +1,119 @@
+import { spawn } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+
+export interface KernelChild {
+	readonly stdin: Writable;
+	readonly stdout: Readable;
+	readonly stderr: Readable;
+	readonly pid?: number;
+	readonly killed: boolean;
+	kill(signal?: NodeJS.Signals): boolean;
+	on(event: string, listener: (...args: unknown[]) => void): this;
+	once(event: string, listener: (...args: unknown[]) => void): this;
+	off(event: string, listener: (...args: unknown[]) => void): this;
+}
+
+export interface KernelSpawnOptions {
+	readonly command: string;
+	readonly args: readonly string[];
+	readonly cwd: string;
+	readonly env: NodeJS.ProcessEnv;
+}
+
+export type KernelSpawnProcess = (options: KernelSpawnOptions) => KernelChild;
+
+export class PythonKernelRetirementError extends Error {
+	constructor(pid: number | undefined) {
+		super(`Python kernel process${pid === undefined ? "" : ` ${pid}`} did not exit after SIGKILL`);
+		this.name = "PythonKernelRetirementError";
+	}
+}
+
+export function defaultSpawn(options: KernelSpawnOptions): KernelChild {
+	return spawn(options.command, [...options.args], {
+		cwd: options.cwd,
+		env: options.env,
+		stdio: "pipe",
+		detached: process.platform !== "win32",
+		windowsHide: true,
+	});
+}
+
+export function splitCommand(commandLine: string): { readonly command: string; readonly args: readonly string[] } {
+	const [command, ...args] = commandLine.split(" ").filter(Boolean);
+	if (!command) throw new Error("Python interpreter path is empty");
+	return { command, args };
+}
+
+export function numberOrNull(value: unknown): number | null {
+	return typeof value === "number" ? value : null;
+}
+
+export function signalOrNull(value: unknown): string | null {
+	return typeof value === "string" ? value : null;
+}
+
+export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
+	let timer: NodeJS.Timeout | undefined;
+	const timeout = new Promise<never>((_, reject) => {
+		timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+	});
+	try {
+		return await Promise.race([promise, timeout]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+
+export async function waitForExit(child: KernelChild, timeoutMs: number): Promise<boolean> {
+	return await new Promise<boolean>((resolve) => {
+		let timer: NodeJS.Timeout | undefined;
+		const settle = (exited: boolean) => {
+			child.off("exit", onExit);
+			if (timer) clearTimeout(timer);
+			resolve(exited);
+		};
+		const onExit = () => settle(true);
+		child.on("exit", onExit);
+		timer = setTimeout(() => settle(false), timeoutMs);
+		timer.unref?.();
+	});
+}
+
+export async function hardKill(child: KernelChild, timeoutMs: number): Promise<void> {
+	await new Promise<void>((resolve, reject) => {
+		let timer: NodeJS.Timeout | undefined;
+		let settled = false;
+		const settle = (error?: Error) => {
+			if (settled) return;
+			settled = true;
+			child.off("exit", onExit);
+			if (timer) clearTimeout(timer);
+			if (error) reject(error);
+			else resolve();
+		};
+		const onExit = () => settle();
+		child.on("exit", onExit);
+		let signalDelivered = true;
+		if (child.pid !== undefined && process.platform !== "win32") {
+			try {
+				process.kill(-child.pid, "SIGKILL");
+			} catch (error) {
+				if (!(error instanceof Error)) {
+					settle(new Error(String(error)));
+					return;
+				}
+				signalDelivered = child.kill("SIGKILL");
+			}
+		} else {
+			signalDelivered = child.kill("SIGKILL");
+		}
+		if (!signalDelivered) {
+			settle();
+			return;
+		}
+		if (settled) return;
+		timer = setTimeout(() => settle(new PythonKernelRetirementError(child.pid)), timeoutMs);
+		timer.unref?.();
+	});
+}

package/src/kernels/py/transport.ts

@@ -0,0 +1,237 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	type BridgeConnectionConfig,
+	decodeBridgeFrame,
+	encodeBridgeFrame,
+	type HostToKernelMessage,
+	isKernelToHostMessage,
+	type KernelToHostMessage,
+} from "../../bridge/protocol.ts";
+import {
+	defaultSpawn,
+	hardKill,
+	type KernelChild,
+	type KernelSpawnOptions,
+	type KernelSpawnProcess,
+	numberOrNull,
+	signalOrNull,
+	splitCommand,
+	waitForExit,
+	withTimeout,
+} from "./process.ts";
+
+export type PythonTransportResult = Extract<KernelToHostMessage, { type: "result" }>;
+
+export interface PythonTransportRunInput {
+	readonly cellId: string;
+	readonly code: string;
+	readonly timeoutMs?: number;
+}
+
+export interface PythonTransportOptions {
+	readonly interpreterPath: string;
+	readonly sessionId: string;
+	readonly cwd: string;
+	readonly connection: BridgeConnectionConfig;
+	readonly env?: NodeJS.ProcessEnv;
+	readonly startupTimeoutMs: number;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
+	readonly spawnProcess?: KernelSpawnProcess;
+	readonly isOwned: () => boolean;
+	readonly onRetirementFailure: (transport: PythonKernelTransport, error: Error) => void;
+	readonly onResult: (transport: PythonKernelTransport, result: PythonTransportResult) => void;
+	readonly onError: (transport: PythonKernelTransport, error: Error) => void;
+	readonly onExit: (transport: PythonKernelTransport, error: Error) => void;
+}
+
+const hardKillWaitMs = 500;
+
+export class PythonKernelTransport {
+	readonly #options: PythonTransportOptions;
+	readonly #child: KernelChild;
+	#stdoutBuffer = "";
+	#stderrTail = "";
+	#settleReady: ((error?: Error) => void) | null = null;
+	#detachChildListeners: (() => void) | null = null;
+	#active = true;
+	#exited = false;
+	#retirement: Promise<void> | null = null;
+
+	private constructor(options: PythonTransportOptions, child: KernelChild) {
+		this.#options = options;
+		this.#child = child;
+	}
+
+	static async start(options: PythonTransportOptions): Promise<PythonKernelTransport> {
+		const scriptPath = join(dirname(fileURLToPath(import.meta.url)), "prelude.py");
+		const invocation = splitCommand(options.interpreterPath);
+		const spawnOptions: KernelSpawnOptions = {
+			command: invocation.command,
+			args: [...invocation.args, "-u", scriptPath],
+			cwd: options.cwd,
+			env: { ...process.env, ...options.env, PYTHONUNBUFFERED: "1", PYTHONIOENCODING: "utf-8" },
+		};
+		const child = (options.spawnProcess ?? defaultSpawn)(spawnOptions);
+		const transport = new PythonKernelTransport(options, child);
+		try {
+			await transport.#initialize();
+			if (!transport.#active) throw new Error("Python kernel exited during startup");
+			if (!options.isOwned()) throw new Error("Python kernel startup was superseded");
+		} catch (error) {
+			try {
+				await transport.retire();
+			} catch (retirementError) {
+				options.onRetirementFailure(
+					transport,
+					retirementError instanceof Error ? retirementError : new Error(String(retirementError)),
+				);
+			}
+			throw error;
+		}
+		return transport;
+	}
+
+	run(input: PythonTransportRunInput): void {
+		this.#write({ type: "run", cellId: input.cellId, code: input.code, timeoutMs: input.timeoutMs });
+	}
+
+	interrupt(reason: string): void {
+		try {
+			this.#write({ type: "interrupt", reason });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.#stderrTail = `${this.#stderrTail}Python interrupt frame write failed: ${message}\n`.slice(-4_000);
+		}
+		if (process.platform === "win32") this.#child.kill();
+		else this.#child.kill("SIGINT");
+	}
+
+	async close(): Promise<void> {
+		if (this.#exited) return;
+		if (this.#retirement) {
+			await this.#retirement;
+			return;
+		}
+		if (!this.#active) {
+			await hardKill(this.#child, hardKillWaitMs);
+			return;
+		}
+		this.#active = false;
+		const exited = waitForExit(this.#child, hardKillWaitMs);
+		try {
+			this.#write({ type: "close" });
+		} catch (error) {
+			if (!(error instanceof Error)) throw error;
+		}
+		if (!(await exited)) await hardKill(this.#child, hardKillWaitMs);
+	}
+
+	retire(): Promise<void> {
+		if (this.#exited) return Promise.resolve();
+		if (this.#retirement) return this.#retirement;
+		this.#active = false;
+		const retirement = hardKill(this.#child, hardKillWaitMs).finally(() => {
+			this.#detachListeners();
+			if (this.#retirement === retirement) this.#retirement = null;
+		});
+		this.#retirement = retirement;
+		return retirement;
+	}
+
+	async #initialize(): Promise<void> {
+		const ready = new Promise<void>((resolve, reject) => {
+			this.#settleReady = (error) => (error ? reject(error) : resolve());
+		});
+		const onStdout = (chunk: unknown) => this.#onStdout(String(chunk));
+		const onStderr = (chunk: unknown) => this.#onStderr(String(chunk));
+		const onError = (error: unknown) => this.#onError(error instanceof Error ? error : new Error(String(error)));
+		const onExit = (code: unknown, signal: unknown) => this.#onExit(numberOrNull(code), signalOrNull(signal));
+		this.#detachChildListeners = () => {
+			this.#child.stdout.off("data", onStdout);
+			this.#child.stderr.off("data", onStderr);
+			this.#child.off("error", onError);
+			this.#child.off("exit", onExit);
+		};
+		this.#child.stdout.on("data", onStdout);
+		this.#child.stderr.on("data", onStderr);
+		this.#child.on("error", onError);
+		this.#child.on("exit", onExit);
+		this.#write({ type: "init", sessionId: this.#options.sessionId, connection: this.#options.connection });
+		await withTimeout(ready, this.#options.startupTimeoutMs, "Python kernel did not become ready");
+	}
+
+	#write(message: HostToKernelMessage): void {
+		this.#child.stdin.write(encodeBridgeFrame(message));
+	}
+
+	#onStdout(chunk: string): void {
+		if (!this.#active) return;
+		this.#stdoutBuffer += chunk;
+		let newline = this.#stdoutBuffer.indexOf("\n");
+		while (newline >= 0) {
+			const line = this.#stdoutBuffer.slice(0, newline + 1);
+			this.#stdoutBuffer = this.#stdoutBuffer.slice(newline + 1);
+			this.#handleLine(line);
+			newline = this.#stdoutBuffer.indexOf("\n");
+		}
+	}
+
+	#onStderr(chunk: string): void {
+		if (!this.#active) return;
+		this.#stderrTail = `${this.#stderrTail}${chunk}`.slice(-4_000);
+		this.#options.onMessage?.({ type: "text", stream: "stderr", data: chunk });
+	}
+
+	#handleLine(line: string): void {
+		const decoded = decodeBridgeFrame(line);
+		if (!decoded.ok) {
+			this.#options.onMessage?.({ type: "text", stream: "stderr", data: `${decoded.error.message}\n` });
+			return;
+		}
+		if (!isKernelToHostMessage(decoded.message)) return;
+		const message = decoded.message;
+		if (message.type === "ready") this.#settleStartup();
+		else if (message.type === "init-failed") this.#settleStartup(new Error(message.error.message));
+		else if (message.type === "result") this.#options.onResult(this, message);
+		this.#options.onMessage?.(message);
+	}
+
+	#onExit(code: number | null, signal: string | null): void {
+		if (this.#exited) return;
+		this.#exited = true;
+		const active = this.#active;
+		this.#active = false;
+		const error = new Error(this.#stderrTail.trim() || `Python kernel exited (${code ?? signal ?? "unknown"})`);
+		this.#detachListeners();
+		if (!active) return;
+		if (!this.#settleStartup(error)) this.#options.onExit(this, error);
+	}
+
+	#onError(error: Error): void {
+		if (this.#exited || !this.#active) return;
+		this.#active = false;
+		if (!this.#settleStartup(error)) this.#options.onError(this, error);
+	}
+
+	#detachListeners(): void {
+		const detach = this.#detachChildListeners;
+		if (!detach) return;
+		this.#detachChildListeners = null;
+		detach();
+		this.#stdoutBuffer = "";
+		this.#stderrTail = "";
+	}
+
+	#settleStartup(error?: Error): boolean {
+		const settle = this.#settleReady;
+		if (!settle) return false;
+		this.#settleReady = null;
+		settle(error);
+		return true;
+	}
+}
+
+export function failedPythonResult(cellId: string, message: string, stack?: string): PythonTransportResult {
+	return { type: "result", cellId, ok: false, error: stack ? { message, stack } : { message }, durationMs: 0 };
+}

package/src/kernels/rb/kernel.ts

@@ -0,0 +1,26 @@
+import { join } from "node:path";
+import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { SubprocessKernel, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
+
+export interface RubyKernelStartOptions {
+	readonly cwd: string;
+	readonly sessionId: string;
+	readonly connection: BridgeConnectionConfig;
+	readonly command?: string;
+	readonly spawn?: SubprocessSpawn;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
+}
+
+export class RubyKernel extends SubprocessKernel {
+	static start(options: RubyKernelStartOptions): RubyKernel {
+		return new RubyKernel({
+			command: options.command ?? "ruby",
+			args: [join(import.meta.dirname, "runner.rb")],
+			cwd: options.cwd,
+			sessionId: options.sessionId,
+			connection: options.connection,
+			spawn: options.spawn,
+			onMessage: options.onMessage,
+		});
+	}
+}

package/src/kernels/rb/prelude.rb

@@ -0,0 +1,270 @@
+require "base64"
+require "fileutils"
+require "json"
+require "uri"
+
+SENPI_RESERVED_AGENT_TOOL = "__agent__"
+SENPI_RESERVED_OUTPUT_TOOL = "__output__"
+SENPI_INTERNAL_URL = Regexp.new("\\A([a-z][a-z0-9+.\\-]*)://(.*)\\z", Regexp::IGNORECASE)
+
+def __senpi_status_enabled?
+  connection = $__senpi_connection
+  return true unless connection.is_a?(Hash)
+  connection["statusEvents"] != false
+end
+
+def __senpi_emit_status(op, fields = {}, force: false)
+  return unless force || __senpi_status_enabled?
+  __senpi_emit({ "type" => "status", "event" => { "op" => op }.merge(fields.transform_keys(&:to_s)) })
+end
+
+def __senpi_resolve_path(value)
+  raw = value.to_s
+  match = SENPI_INTERNAL_URL.match(raw)
+  return File.expand_path(raw) unless match
+
+  scheme = match[1].downcase
+  roots = $__senpi_connection.is_a?(Hash) ? $__senpi_connection["localRoots"] : nil
+  root = roots[scheme] if roots.is_a?(Hash)
+  raise "Protocol paths are not supported by this helper: #{raw}" unless root.is_a?(String) && !root.empty?
+
+  relative = URI::DEFAULT_PARSER.unescape(match[2].tr("\\", "/"))
+  root_path = File.expand_path(root)
+  return root_path if relative.empty?
+  if relative.start_with?("/") || relative.split("/").include?("..")
+    raise "Unsafe #{scheme}:// path (absolute or traversal): #{raw}"
+  end
+
+  resolved = File.expand_path(relative, root_path)
+  unless resolved == root_path || resolved.start_with?(root_path + File::SEPARATOR)
+    raise "#{scheme}:// path escapes its root: #{raw}"
+  end
+  resolved
+end
+
+def __senpi_display_payload(value)
+  if value.is_a?(Hash)
+    kind = value["type"] || value[:type]
+    text_value = value["text"] || value[:text]
+    return ["text/markdown", text_value.to_s] if kind == "markdown" && !text_value.nil?
+    return ["image/png", value["data"].to_s] if kind == "image" && value["mimeType"] == "image/png"
+    return ["image/jpeg", value["data"].to_s] if kind == "image" && value["mimeType"] == "image/jpeg"
+    return ["application/json", JSON.generate(value)]
+  end
+  return ["application/json", JSON.generate(value)] if value.is_a?(Array)
+  ["text/plain", value.to_s]
+end
+
+def display(value)
+  mime_type, payload = __senpi_display_payload(value)
+  data_base64 = mime_type.start_with?("image/") ? payload : Base64.strict_encode64(payload)
+  __senpi_emit({ "type" => "display", "mimeType" => mime_type, "dataBase64" => data_base64 })
+  nil
+end
+
+def display_image(base64, mime_type: "image/png")
+  __senpi_emit({ "type" => "display", "mimeType" => mime_type.to_s, "dataBase64" => base64.to_s })
+  nil
+end
+
+def text(data)
+  __senpi_emit({ "type" => "text", "stream" => "stdout", "data" => data.to_s })
+  nil
+end
+
+def print(*values)
+  text(values.join)
+end
+
+def read(path, offset = 1, limit = nil)
+  resolved = __senpi_resolve_path(path)
+  data = File.read(resolved, encoding: Encoding::UTF_8)
+  if offset > 1 || !limit.nil?
+    lines = data.lines
+    start = [offset.to_i - 1, 0].max
+    data = lines[start, limit || lines.length].to_a.join
+  end
+  __senpi_emit_status("read", { "path" => resolved, "chars" => data.length, "preview" => data[0, 500].to_s })
+  data
+end
+
+def write(path, content)
+  resolved = __senpi_resolve_path(path)
+  FileUtils.mkdir_p(File.dirname(resolved))
+  data = content.to_s
+  File.write(resolved, data)
+  __senpi_emit_status("write", { "path" => resolved, "chars" => data.length })
+  resolved
+end
+
+def env(key = nil, value = nil)
+  if key.nil?
+    entries = ENV.to_h.sort.to_h
+    __senpi_emit_status("env", { "count" => entries.length, "keys" => entries.keys.first(20) })
+    return entries
+  end
+
+  name = key.to_s
+  if value.nil?
+    resolved = ENV[name]
+    __senpi_emit_status("env", { "key" => name, "value" => resolved, "action" => "get" })
+    return resolved
+  end
+
+  resolved = value.to_s
+  ENV[name] = resolved
+  __senpi_emit_status("env", { "key" => name, "value" => resolved, "action" => "set" })
+  resolved
+end
+
+def __senpi_bridge_request(path, payload)
+  connection = $__senpi_connection
+  raise "Ruby tool bridge is not initialized" unless connection.is_a?(Hash)
+  port = connection["port"]
+  token = connection["token"]
+  raise "Ruby tool bridge is not initialized" unless port.is_a?(Integer) && token.is_a?(String)
+
+  uri = URI("http://127.0.0.1:#{port}#{path}")
+  request = Net::HTTP::Post.new(uri)
+  request["authorization"] = "Bearer #{token}"
+  request["content-type"] = "application/json"
+  request.body = JSON.generate(payload)
+  __senpi_emit_status("timeout-pause", force: true)
+  begin
+    response = Net::HTTP.start(uri.hostname, uri.port, open_timeout: 10, read_timeout: 60) { |http| http.request(request) }
+  ensure
+    __senpi_emit_status("timeout-resume", force: true)
+  end
+  body = JSON.parse(response.body.to_s)
+  return body["value"] if body.is_a?(Hash) && body["ok"] == true
+
+  error = body.is_a?(Hash) ? body["error"] : body
+  raise(error.is_a?(Hash) ? error["message"].to_s : error.to_s)
+end
+
+def __senpi_call_tool(name, args)
+  __senpi_bridge_request("/call", { "callId" => "rb-#{Process.pid}-#{rand(1_000_000)}", "toolName" => name, "args" => args })
+end
+
+class SenpiToolCallable
+  def initialize(name)
+    @name = name
+  end
+
+  def call(args = nil, **kwargs)
+    merged = args.nil? ? {} : args.is_a?(Hash) ? args.transform_keys(&:to_s) : raise(ArgumentError, "tool.#{@name}(...) expects a Hash of arguments")
+    kwargs.each { |key, value| merged[key.to_s] = value }
+    __senpi_call_tool(@name, merged)
+  end
+end
+
+class SenpiToolProxy < BasicObject
+  def method_missing(name, args = nil, **kwargs)
+    ::SenpiToolCallable.new(name.to_s).call(args, **kwargs)
+  end
+
+  def [](name)
+    ::SenpiToolCallable.new(name.to_s)
+  end
+
+  def respond_to_missing?(_name, _private = false)
+    true
+  end
+end
+
+def tool
+  $__senpi_tool_proxy ||= SenpiToolProxy.new
+end
+
+def completion(prompt, model: "default", system: nil, schema: nil, **kwargs)
+  options = { "model" => model }.merge(kwargs.transform_keys(&:to_s))
+  options["system"] = system unless system.nil?
+  options["schema"] = schema unless schema.nil?
+  result = __senpi_bridge_request("/completion", { "prompt" => prompt.to_s, "opts" => options })
+  return result unless result.is_a?(Hash)
+  return result["value"] if result.key?("value")
+
+  result.fetch("text", result)
+end
+
+def output(*ids, format: "raw", offset: nil, limit: nil)
+  raise ArgumentError, "At least one output ID is required" if ids.empty?
+  raise ArgumentError, "output() format must be 'raw' or 'tail'" unless ["raw", "tail"].include?(format)
+  args = { "ids" => ids.map(&:to_s), "format" => format }
+  args["offset"] = offset unless offset.nil?
+  args["limit"] = limit unless limit.nil?
+  __senpi_call_tool(SENPI_RESERVED_OUTPUT_TOOL, args)
+end
+
+def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, isolated: nil, apply: nil, merge: nil, handle: false)
+  args = { "prompt" => prompt.to_s, "agent" => agent }
+  { "model" => model, "label" => label, "schema" => schema, "isolated" => isolated, "apply" => apply, "merge" => merge }.each do |key, value|
+    args[key] = value unless value.nil?
+  end
+  args["handle"] = true if handle
+  response = __senpi_call_tool(SENPI_RESERVED_AGENT_TOOL, args)
+  record = response.is_a?(Hash) ? response : {}
+  text_value = record.fetch("text", response)
+  result = schema.nil? ? text_value : record.key?("data") ? record["data"] : JSON.parse(text_value.to_s)
+  return result unless handle
+  { "text" => text_value, "output" => text_value, "handle" => record["handle"] || (record["id"] && "agent://#{record["id"]}"), "id" => record["id"], "agent" => record.fetch("agent", agent) }.tap do |node|
+    node["data"] = result unless schema.nil?
+  end
+end
+
+def __senpi_pool_map(items)
+  values = items.to_a
+  return [] if values.empty?
+  connection = $__senpi_connection
+  configured_width = connection.is_a?(Hash) ? connection["parallelPoolWidth"] : nil
+  width = configured_width.is_a?(Numeric) ? configured_width.to_i : 4
+  workers = [[width, 1].max, values.length].min
+  results = Array.new(values.length)
+  failures = {}
+  failure_mutex = Mutex.new
+  queue = Queue.new
+  values.each_index { |index| queue << index }
+  threads = workers.times.map do
+    Thread.new do
+      loop do
+        index = queue.pop(true) rescue nil
+        break if index.nil?
+        begin
+          results[index] = yield(values[index])
+        rescue Exception => error
+          failure_mutex.synchronize { failures[index] = error }
+        end
+      end
+    end
+  end
+  threads.each(&:join)
+  raise failures[failures.keys.min] unless failures.empty?
+  results
+end
+
+def parallel(thunks)
+  values = thunks.to_a
+  values.each do |thunk|
+    raise TypeError, "parallel() expects an iterable of zero-arg callables" unless thunk.respond_to?(:call)
+  end
+  __senpi_pool_map(values) { |thunk| thunk.call }
+end
+
+def pipeline(items, *stages)
+  values = items.to_a
+  stages.each do |stage|
+    raise TypeError, "pipeline() stages must be callables" unless stage.respond_to?(:call)
+    values = __senpi_pool_map(values) { |value| stage.call(value) }
+  end
+  values
+end
+
+def log(message)
+  __senpi_emit({ "type" => "log", "message" => message.to_s })
+  nil
+end
+
+def phase(title)
+  __senpi_emit({ "type" => "phase", "title" => title.to_s })
+  nil
+end