@secure-exec/core 0.2.0-rc.2 → 0.2.0

package/dist/index.d.ts

@@ -1,13 +1,18 @@
 export { createKernel } from "./kernel/kernel.js";
-export type { Kernel, KernelOptions, KernelInterface, ExecOptions as KernelExecOptions, ExecResult as KernelExecResult, SpawnOptions as KernelSpawnOptions, ManagedProcess, RuntimeDriver as KernelRuntimeDriver, ProcessContext, DriverProcess, ProcessEntry, ProcessInfo, FDStat, FileDescription, FDEntry, Pipe, PermissionDecision, PermissionCheck, FsAccessRequest, NetworkAccessRequest, ChildProcessAccessRequest, EnvAccessRequest, KernelErrorCode, Termios, TermiosCC, OpenShellOptions, ShellHandle, ConnectTerminalOptions, Permissions, } from "./kernel/types.js";
-export { KernelError, defaultTermios } from "./kernel/types.js";
-export type { VirtualFileSystem, VirtualDirEntry, VirtualStat, } from "./kernel/vfs.js";
+export type { FsMount, Kernel, KernelOptions, KernelInterface, KernelLogger, ExecOptions as KernelExecOptions, ExecResult as KernelExecResult, SpawnOptions as KernelSpawnOptions, ManagedProcess, RuntimeDriver as KernelRuntimeDriver, ProcessContext, DriverProcess, ProcessEntry, ProcessInfo, FDStat, FileDescription, FDEntry, Pipe, PermissionDecision, PermissionCheck, FsAccessRequest, NetworkAccessRequest, ChildProcessAccessRequest, EnvAccessRequest, KernelErrorCode, Termios, TermiosCC, OpenShellOptions, ShellHandle, ConnectTerminalOptions, Permissions, } from "./kernel/types.js";
+export { KernelError, defaultTermios, noopKernelLogger } from "./kernel/types.js";
+export type { VirtualFileSystem, VirtualDirEntry, VirtualDirStatEntry, VirtualStat, } from "./kernel/vfs.js";
 export { FDTableManager, ProcessFDTable } from "./kernel/fd-table.js";
 export { ProcessTable } from "./kernel/process-table.js";
 export { TimerTable } from "./kernel/timer-table.js";
 export type { KernelTimer, TimerTableOptions } from "./kernel/timer-table.js";
+export { createDeviceBackend } from "./kernel/device-backend.js";
 export { createDeviceLayer } from "./kernel/device-layer.js";
+export { MountTable } from "./kernel/mount-table.js";
+export type { MountEntry, MountOptions } from "./kernel/mount-table.js";
 export { createProcLayer, createProcessScopedFileSystem, resolveProcSelfPath, } from "./kernel/proc-layer.js";
+export { createProcBackend } from "./kernel/proc-backend.js";
+export type { ProcBackendOptions } from "./kernel/proc-backend.js";
 export { PipeManager } from "./kernel/pipe-manager.js";
 export { PtyManager } from "./kernel/pty.js";
 export type { LineDisciplineConfig } from "./kernel/pty.js";
@@ -25,7 +30,7 @@ export type { CommandExecutor, NetworkAdapter, NetworkServerAddress, NetworkServ
 export type { DriverRuntimeConfig, NodeRuntimeDriver, NodeRuntimeDriverFactory, PythonRuntimeDriver, PythonRuntimeDriverFactory, ResourceBudgets, RuntimeDriver, RuntimeDriverFactory, RuntimeDriverOptions, SharedRuntimeDriver, SystemDriver, } from "./runtime-driver.js";
 export type { ExecOptions, ExecResult, ExecutionStatus, OSConfig, ProcessConfig, PythonRunOptions, PythonRunResult, RunResult, StdioChannel, StdioEvent, StdioHook, TimingMitigation, } from "./shared/api-types.js";
 export { TIMEOUT_EXIT_CODE, TIMEOUT_ERROR_MESSAGE, } from "./shared/constants.js";
-export { createInMemoryFileSystem, InMemoryFileSystem, } from "./shared/in-memory-fs.js";
+export { createInMemoryFileSystem } from "./shared/in-memory-fs.js";
 export { allowAll, allowAllChildProcess, allowAllEnv, allowAllFs, allowAllNetwork, createCommandExecutorStub, createFsStub, createNetworkStub, envAccessAllowed, filterEnv, wrapCommandExecutor, wrapFileSystem, wrapNetworkAdapter, } from "./shared/permissions.js";
 export type { SystemError } from "./shared/errors.js";
 export { createEaccesError, createEnosysError, createSystemError, } from "./shared/errors.js";
@@ -40,6 +45,14 @@ export { exposeCustomGlobal, exposeGlobalBinding, exposeMutableRuntimeStateGloba
 export type { IsolateRuntimeSourceId } from "./generated/isolate-runtime.js";
 export { getIsolateRuntimeSource, ISOLATE_RUNTIME_SOURCES, } from "./generated/isolate-runtime.js";
 export { POLYFILL_CODE_MAP } from "./generated/polyfills.js";
+export type { InodeType, CreateInodeAttrs, InodeMeta, DentryInfo, DentryStatInfo, FsMetadataStore, FsBlockStore, FsMetadataStoreVersioning, VersionMeta, VersionInfo, RetentionPolicy, } from "./vfs/types.js";
+export { InMemoryMetadataStore } from "./vfs/memory-metadata.js";
+export { InMemoryBlockStore } from "./vfs/memory-block-store.js";
+export { SqliteMetadataStore } from "./vfs/sqlite-metadata.js";
+export type { SqliteMetadataStoreOptions } from "./vfs/sqlite-metadata.js";
+export { createChunkedVfs } from "./vfs/chunked-vfs.js";
+export type { ChunkedVfsOptions, ChunkedVfsVersioning } from "./vfs/chunked-vfs.js";
+export { HostBlockStore } from "./vfs/host-block-store.js";
 export type { DirEntry, StatInfo } from "./fs-helpers.js";
 export { exists, stat, rename, readDirWithTypes, mkdir } from "./fs-helpers.js";
 export { BUILTIN_NAMED_EXPORTS, normalizeBuiltinSpecifier, getPathDir, } from "./module-resolver.js";

package/dist/index.js

@@ -1,12 +1,15 @@
 // Kernel — VFS, process table, FD table, device layer, pipes, PTY, command registry, permissions.
 export { createKernel } from "./kernel/kernel.js";
-export { KernelError, defaultTermios } from "./kernel/types.js";
+export { KernelError, defaultTermios, noopKernelLogger } from "./kernel/types.js";
 // Kernel components.
 export { FDTableManager, ProcessFDTable } from "./kernel/fd-table.js";
 export { ProcessTable } from "./kernel/process-table.js";
 export { TimerTable } from "./kernel/timer-table.js";
+export { createDeviceBackend } from "./kernel/device-backend.js";
 export { createDeviceLayer } from "./kernel/device-layer.js";
+export { MountTable } from "./kernel/mount-table.js";
 export { createProcLayer, createProcessScopedFileSystem, resolveProcSelfPath, } from "./kernel/proc-layer.js";
+export { createProcBackend } from "./kernel/proc-backend.js";
 export { PipeManager } from "./kernel/pipe-manager.js";
 export { PtyManager } from "./kernel/pty.js";
 export { CommandRegistry } from "./kernel/command-registry.js";
@@ -24,7 +27,7 @@ export { encodeExitStatus, encodeSignalStatus, WIFEXITED, WEXITSTATUS, WIFSIGNAL
 // Shared constants.
 export { TIMEOUT_EXIT_CODE, TIMEOUT_ERROR_MESSAGE, } from "./shared/constants.js";
 // Shared utilities.
-export { createInMemoryFileSystem, InMemoryFileSystem, } from "./shared/in-memory-fs.js";
+export { createInMemoryFileSystem } from "./shared/in-memory-fs.js";
 export { allowAll, allowAllChildProcess, allowAllEnv, allowAllFs, allowAllNetwork, createCommandExecutorStub, createFsStub, createNetworkStub, envAccessAllowed, filterEnv, wrapCommandExecutor, wrapFileSystem, wrapNetworkAdapter, } from "./shared/permissions.js";
 export { createEaccesError, createEnosysError, createSystemError, } from "./shared/errors.js";
 export { extractCjsNamedExports, extractDynamicImportSpecifiers, isESM, transformDynamicImport, wrapCJSForESM, wrapCJSForESMWithModulePath, } from "./shared/esm-utils.js";
@@ -35,6 +38,11 @@ export { exposeCustomGlobal, exposeGlobalBinding, exposeMutableRuntimeStateGloba
 export { getIsolateRuntimeSource, ISOLATE_RUNTIME_SOURCES, } from "./generated/isolate-runtime.js";
 // Generated polyfills.
 export { POLYFILL_CODE_MAP } from "./generated/polyfills.js";
+export { InMemoryMetadataStore } from "./vfs/memory-metadata.js";
+export { InMemoryBlockStore } from "./vfs/memory-block-store.js";
+export { SqliteMetadataStore } from "./vfs/sqlite-metadata.js";
+export { createChunkedVfs } from "./vfs/chunked-vfs.js";
+export { HostBlockStore } from "./vfs/host-block-store.js";
 export { exists, stat, rename, readDirWithTypes, mkdir } from "./fs-helpers.js";
 // Module resolution.
 export { BUILTIN_NAMED_EXPORTS, normalizeBuiltinSpecifier, getPathDir, } from "./module-resolver.js";

package/dist/isolate-runtime/require-setup.js

@@ -525,7 +525,7 @@
         return "utf-8";
       }
     });
-    function TextDecoder(label, options) {
+    function TextDecoder2(label, options) {
       var normalizedOptions = options == null ? {} : Object(options);
       this._encoding = _normalizeEncodingLabel(label);
       this._fatal = Boolean(normalizedOptions.fatal);
@@ -533,22 +533,22 @@
       this._pendingBytes = [];
       this._bomSeen = false;
     }
-    Object.defineProperty(TextDecoder.prototype, "encoding", {
+    Object.defineProperty(TextDecoder2.prototype, "encoding", {
       get: function() {
         return this._encoding;
       }
     });
-    Object.defineProperty(TextDecoder.prototype, "fatal", {
+    Object.defineProperty(TextDecoder2.prototype, "fatal", {
       get: function() {
         return this._fatal;
       }
     });
-    Object.defineProperty(TextDecoder.prototype, "ignoreBOM", {
+    Object.defineProperty(TextDecoder2.prototype, "ignoreBOM", {
       get: function() {
         return this._ignoreBOM;
       }
     });
-    TextDecoder.prototype.decode = function decode(input, options) {
+    TextDecoder2.prototype.decode = function decode(input, options) {
       var normalizedOptions = options == null ? {} : Object(options);
       var stream = Boolean(normalizedOptions.stream);
       var incoming = _toUint8Array(input);
@@ -743,7 +743,7 @@
       return !event.defaultPrevented;
     };
     globalThis.TextEncoder = TextEncoder;
-    globalThis.TextDecoder = TextDecoder;
+    globalThis.TextDecoder = TextDecoder2;
     globalThis.Event = Event;
     globalThis.CustomEvent = CustomEvent;
     globalThis.EventTarget = EventTarget;
@@ -3437,9 +3437,137 @@
       MessageChannel: globalThis.MessageChannel,
       MessageEvent: globalThis.MessageEvent
     };
+    const readlineCompat = {
+      createInterface: function createInterface(opts) {
+        const input = opts && opts.input ? opts.input : typeof process !== "undefined" ? process.stdin : null;
+        const output = opts && opts.output ? opts.output : typeof process !== "undefined" ? process.stdout : null;
+        const listeners = {};
+        const rl = {
+          input,
+          output,
+          terminal: false,
+          closed: false,
+          on: function(event, handler) {
+            (listeners[event] = listeners[event] || []).push(handler);
+            return rl;
+          },
+          once: function(event, handler) {
+            const wrapper = function() {
+              rl.off(event, wrapper);
+              handler.apply(this, arguments);
+            };
+            return rl.on(event, wrapper);
+          },
+          off: function(event, handler) {
+            if (listeners[event]) listeners[event] = listeners[event].filter(function(h) {
+              return h !== handler;
+            });
+            return rl;
+          },
+          removeListener: function(event, handler) {
+            return rl.off(event, handler);
+          },
+          emit: function(event) {
+            const args = Array.prototype.slice.call(arguments, 1);
+            (listeners[event] || []).forEach(function(h) {
+              h.apply(null, args);
+            });
+            return rl;
+          },
+          close: function() {
+            if (!rl.closed) {
+              rl.closed = true;
+              rl.emit("close");
+            }
+          },
+          question: function(query, cb) {
+            if (output && output.write) output.write(query);
+            if (input && input.once) {
+              var buf = "";
+              var onData = function(chunk) {
+                buf += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+                var idx = buf.indexOf("\n");
+                if (idx !== -1) {
+                  input.removeListener("data", onData);
+                  cb(buf.slice(0, idx));
+                }
+              };
+              input.on("data", onData);
+            } else {
+              cb("");
+            }
+          },
+          prompt: function() {
+            if (output && output.write) output.write("> ");
+          },
+          setPrompt: function() {
+          },
+          pause: function() {
+            return rl;
+          },
+          resume: function() {
+            return rl;
+          },
+          write: function() {
+          },
+          [Symbol.asyncIterator]: function() {
+            return rl._iterState;
+          }
+        };
+        var _lineBuf = "";
+        var _iterLines = [];
+        var _iterResolve = null;
+        var _iterDone = false;
+        rl._iterState = {
+          next: function() {
+            if (_iterLines.length > 0) return Promise.resolve({ value: _iterLines.shift(), done: false });
+            if (_iterDone) return Promise.resolve({ value: void 0, done: true });
+            return new Promise(function(r) {
+              _iterResolve = r;
+            }).then(function() {
+              if (_iterLines.length > 0) return { value: _iterLines.shift(), done: false };
+              return { value: void 0, done: true };
+            });
+          }
+        };
+        if (input && input.on) {
+          input.on("data", function(chunk) {
+            _lineBuf += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+            var idx;
+            while ((idx = _lineBuf.indexOf("\n")) !== -1) {
+              var line = _lineBuf.slice(0, idx);
+              _lineBuf = _lineBuf.slice(idx + 1);
+              rl.emit("line", line);
+              _iterLines.push(line);
+              if (_iterResolve) {
+                _iterResolve();
+                _iterResolve = null;
+              }
+            }
+          });
+          input.on("end", function() {
+            rl.emit("close");
+            _iterDone = true;
+            if (_iterResolve) {
+              _iterResolve();
+              _iterResolve = null;
+            }
+          });
+          if (input.resume) input.resume();
+        }
+        return rl;
+      },
+      promises: {
+        createInterface: function createInterface(opts) {
+          return readlineCompat.createInterface(opts);
+        }
+      }
+    };
     const moduleCompat = {
       worker_threads: workerThreadsCompat,
-      "node:worker_threads": workerThreadsCompat
+      "node:worker_threads": workerThreadsCompat,
+      readline: readlineCompat,
+      "node:readline": readlineCompat
     };
     let stub = null;
     stub = new Proxy({}, {
@@ -3861,6 +3989,16 @@
       _debugRequire("loaded", name, "diagnostics-channel-special");
       return dcModule;
     }
+    if (name === "path/win32") {
+      var pathMod = _requireFrom("path", fromDir);
+      __internalModuleCache[name] = pathMod.win32 || pathMod;
+      return __internalModuleCache[name];
+    }
+    if (name === "path/posix") {
+      var pathMod2 = _requireFrom("path", fromDir);
+      __internalModuleCache[name] = pathMod2.posix || pathMod2;
+      return __internalModuleCache[name];
+    }
     if (_deferredCoreModules.has(name)) {
       if (__internalModuleCache[name]) return __internalModuleCache[name];
       const deferredStub = _createDeferredModuleStub(name);

package/dist/kernel/device-backend.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Device backend.
+ *
+ * Standalone VirtualFileSystem that handles device nodes.
+ * Receives relative paths (e.g. "null" not "/dev/null").
+ * Designed to be mounted at /dev via MountTable.
+ */
+import type { VirtualFileSystem } from "./vfs.js";
+/**
+ * Create a standalone device backend VFS.
+ * All paths are relative to /dev (e.g. "null", "zero", "pts/0").
+ * Mount at /dev via MountTable.
+ */
+export declare function createDeviceBackend(): VirtualFileSystem;

package/dist/kernel/device-backend.js

@@ -0,0 +1,251 @@
+/**
+ * Device backend.
+ *
+ * Standalone VirtualFileSystem that handles device nodes.
+ * Receives relative paths (e.g. "null" not "/dev/null").
+ * Designed to be mounted at /dev via MountTable.
+ */
+import { KernelError } from "./types.js";
+const DEVICE_NAMES = new Set([
+    "null",
+    "zero",
+    "stdin",
+    "stdout",
+    "stderr",
+    "urandom",
+    "random",
+    "tty",
+    "console",
+    "full",
+    "ptmx",
+]);
+const DEVICE_INO = {
+    null: 0xffff_0001,
+    zero: 0xffff_0002,
+    stdin: 0xffff_0003,
+    stdout: 0xffff_0004,
+    stderr: 0xffff_0005,
+    urandom: 0xffff_0006,
+    random: 0xffff_0007,
+    tty: 0xffff_0008,
+    console: 0xffff_0009,
+    full: 0xffff_000a,
+    ptmx: 0xffff_000b,
+};
+/** Device pseudo-directories that contain dynamic entries. */
+const DEVICE_DIRS = new Set(["fd", "pts", "shm"]);
+function isDeviceName(path) {
+    return (DEVICE_NAMES.has(path) || path.startsWith("fd/") || path.startsWith("pts/"));
+}
+function isDeviceDir(path) {
+    return path === "" || DEVICE_DIRS.has(path);
+}
+function deviceStat(path) {
+    const now = Date.now();
+    return {
+        mode: 0o666,
+        size: 0,
+        isDirectory: false,
+        isSymbolicLink: false,
+        atimeMs: now,
+        mtimeMs: now,
+        ctimeMs: now,
+        birthtimeMs: now,
+        ino: DEVICE_INO[path] ?? 0xffff_0000,
+        nlink: 1,
+        uid: 0,
+        gid: 0,
+    };
+}
+function dirStat(path) {
+    const now = Date.now();
+    return {
+        mode: 0o755,
+        size: 0,
+        isDirectory: true,
+        isSymbolicLink: false,
+        atimeMs: now,
+        mtimeMs: now,
+        ctimeMs: now,
+        birthtimeMs: now,
+        ino: DEVICE_INO[path] ?? 0xffff_0000,
+        nlink: 2,
+        uid: 0,
+        gid: 0,
+    };
+}
+const DEV_DIR_ENTRIES = [
+    { name: "null", isDirectory: false },
+    { name: "zero", isDirectory: false },
+    { name: "stdin", isDirectory: false },
+    { name: "stdout", isDirectory: false },
+    { name: "stderr", isDirectory: false },
+    { name: "urandom", isDirectory: false },
+    { name: "random", isDirectory: false },
+    { name: "tty", isDirectory: false },
+    { name: "console", isDirectory: false },
+    { name: "full", isDirectory: false },
+    { name: "ptmx", isDirectory: false },
+    { name: "fd", isDirectory: true },
+    { name: "pts", isDirectory: true },
+    { name: "shm", isDirectory: true },
+];
+function randomBytes(length) {
+    const buf = new Uint8Array(length);
+    if (typeof globalThis.crypto?.getRandomValues === "function") {
+        globalThis.crypto.getRandomValues(buf);
+    }
+    else {
+        for (let i = 0; i < buf.length; i++) {
+            buf[i] = (Math.random() * 256) | 0;
+        }
+    }
+    return buf;
+}
+function notFound(path) {
+    throw new KernelError("ENOENT", `no such device: ${path}`);
+}
+/**
+ * Create a standalone device backend VFS.
+ * All paths are relative to /dev (e.g. "null", "zero", "pts/0").
+ * Mount at /dev via MountTable.
+ */
+export function createDeviceBackend() {
+    const backend = {
+        async readFile(path) {
+            if (path === "null" || path === "full")
+                return new Uint8Array(0);
+            if (path === "zero")
+                return new Uint8Array(4096);
+            if (path === "urandom" || path === "random")
+                return randomBytes(4096);
+            if (path === "tty" || path === "console" || path === "ptmx")
+                return new Uint8Array(0);
+            if (path === "stdin" || path === "stdout" || path === "stderr")
+                return new Uint8Array(0);
+            notFound(path);
+        },
+        async pread(path, _offset, length) {
+            if (path === "null" || path === "full")
+                return new Uint8Array(0);
+            if (path === "zero")
+                return new Uint8Array(length);
+            if (path === "urandom" || path === "random")
+                return randomBytes(length);
+            if (path === "tty" || path === "console" || path === "ptmx")
+                return new Uint8Array(0);
+            if (path === "stdin" || path === "stdout" || path === "stderr")
+                return new Uint8Array(0);
+            notFound(path);
+        },
+        async readTextFile(path) {
+            const bytes = await this.readFile(path);
+            return new TextDecoder().decode(bytes);
+        },
+        async readDir(path) {
+            if (path === "")
+                return DEV_DIR_ENTRIES.map((e) => e.name);
+            if (DEVICE_DIRS.has(path))
+                return [];
+            notFound(path);
+        },
+        async readDirWithTypes(path) {
+            if (path === "")
+                return DEV_DIR_ENTRIES;
+            if (DEVICE_DIRS.has(path))
+                return [];
+            notFound(path);
+        },
+        async writeFile(path, _content) {
+            if (path === "full")
+                throw new KernelError("ENOSPC", "No space left on device");
+            if (DEVICE_NAMES.has(path) ||
+                path.startsWith("fd/") ||
+                path.startsWith("pts/")) {
+                return;
+            }
+            notFound(path);
+        },
+        async pwrite(path, _offset, _data) {
+            if (path === "full")
+                throw new KernelError("ENOSPC", "No space left on device");
+            if (DEVICE_NAMES.has(path) ||
+                path.startsWith("fd/") ||
+                path.startsWith("pts/")) {
+                return;
+            }
+            notFound(path);
+        },
+        async createDir(path) {
+            if (isDeviceDir(path))
+                return;
+            throw new KernelError("EPERM", "cannot create directory in /dev");
+        },
+        async mkdir(path, _options) {
+            if (isDeviceDir(path))
+                return;
+            throw new KernelError("EPERM", "cannot create directory in /dev");
+        },
+        async exists(path) {
+            return isDeviceName(path) || isDeviceDir(path);
+        },
+        async stat(path) {
+            if (isDeviceName(path))
+                return deviceStat(path);
+            if (isDeviceDir(path))
+                return dirStat(path);
+            notFound(path);
+        },
+        async removeFile(path) {
+            if (isDeviceName(path))
+                throw new KernelError("EPERM", "cannot remove device");
+            notFound(path);
+        },
+        async removeDir(path) {
+            if (isDeviceDir(path))
+                throw new KernelError("EPERM", "cannot remove device directory");
+            notFound(path);
+        },
+        async rename(_oldPath, _newPath) {
+            throw new KernelError("EPERM", "cannot rename device");
+        },
+        async realpath(path) {
+            if (isDeviceName(path) || isDeviceDir(path))
+                return path;
+            notFound(path);
+        },
+        async symlink(_target, _linkPath) {
+            throw new KernelError("EPERM", "cannot create symlink in /dev");
+        },
+        async readlink(path) {
+            notFound(path);
+        },
+        async lstat(path) {
+            return this.stat(path);
+        },
+        async link(_oldPath, _newPath) {
+            throw new KernelError("EPERM", "cannot link device");
+        },
+        async chmod(path, _mode) {
+            if (isDeviceName(path) || isDeviceDir(path))
+                return;
+            notFound(path);
+        },
+        async chown(path, _uid, _gid) {
+            if (isDeviceName(path) || isDeviceDir(path))
+                return;
+            notFound(path);
+        },
+        async utimes(path, _atime, _mtime) {
+            if (isDeviceName(path) || isDeviceDir(path))
+                return;
+            notFound(path);
+        },
+        async truncate(path, _length) {
+            if (isDeviceName(path) || isDeviceDir(path))
+                return;
+            notFound(path);
+        },
+    };
+    return backend;
+}

package/dist/kernel/device-layer.js

@@ -160,6 +160,15 @@ export function createDeviceLayer(vfs) {
                 return;
             return vfs.writeFile(path, content);
         },
+        async pwrite(path, offset, data) {
+            if (path === "/dev/full")
+                throw new KernelError("ENOSPC", "No space left on device");
+            if (path === "/dev/null" || path === "/dev/zero" || path === "/dev/urandom"
+                || path === "/dev/random" || path === "/dev/tty" || path === "/dev/console"
+                || path === "/dev/ptmx")
+                return;
+            return vfs.pwrite(path, offset, data);
+        },
         async createDir(path) {
             if (isDeviceDir(path))
                 return;

package/dist/kernel/index.d.ts

@@ -6,21 +6,21 @@
  * same kernel instance.
  */
 export { createKernel } from "./kernel.js";
-export type { Kernel, KernelOptions, KernelInterface, ExecOptions, ExecResult, SpawnOptions, ManagedProcess, RuntimeDriver, ProcessContext, DriverProcess, ProcessEntry, ProcessInfo, FDStat, FileDescription, FDEntry, Pipe, Permissions, PermissionDecision, PermissionCheck, FsAccessRequest, NetworkAccessRequest, ChildProcessAccessRequest, EnvAccessRequest, KernelErrorCode, SignalDisposition, SignalHandler, ProcessSignalState, Termios, TermiosCC, OpenShellOptions, ShellHandle, ConnectTerminalOptions, } from "./types.js";
-export { KernelError, defaultTermios } from "./types.js";
+export type { FsMount, Kernel, KernelOptions, KernelInterface, KernelLogger, ExecOptions, ExecResult, SpawnOptions, ManagedProcess, RuntimeDriver, ProcessContext, DriverProcess, ProcessEntry, ProcessInfo, FDStat, FileDescription, FDEntry, Pipe, Permissions, PermissionDecision, PermissionCheck, FsAccessRequest, NetworkAccessRequest, ChildProcessAccessRequest, EnvAccessRequest, KernelErrorCode, SignalDisposition, SignalHandler, ProcessSignalState, Termios, TermiosCC, OpenShellOptions, ShellHandle, ConnectTerminalOptions, } from "./types.js";
+export { KernelError, defaultTermios, noopKernelLogger } from "./types.js";
 export type { VirtualFileSystem, VirtualDirEntry, VirtualStat, } from "./vfs.js";
 export { FDTableManager, ProcessFDTable } from "./fd-table.js";
 export { ProcessTable } from "./process-table.js";
 export { createDeviceLayer } from "./device-layer.js";
 export { createProcLayer, createProcessScopedFileSystem, resolveProcSelfPath, } from "./proc-layer.js";
+export { createProcBackend } from "./proc-backend.js";
+export type { ProcBackendOptions } from "./proc-backend.js";
 export { PipeManager } from "./pipe-manager.js";
 export { PtyManager } from "./pty.js";
 export type { LineDisciplineConfig } from "./pty.js";
 export { CommandRegistry } from "./command-registry.js";
 export { FileLockManager, LOCK_SH, LOCK_EX, LOCK_UN, LOCK_NB } from "./file-lock.js";
 export { WaitHandle, WaitQueue } from "./wait.js";
-export { InodeTable } from "./inode-table.js";
-export type { Inode } from "./inode-table.js";
 export { TimerTable } from "./timer-table.js";
 export type { KernelTimer, TimerTableOptions } from "./timer-table.js";
 export { DnsCache } from "./dns-cache.js";

package/dist/kernel/index.js

@@ -7,19 +7,19 @@
  */
 // Kernel factory
 export { createKernel } from "./kernel.js";
-// Structured kernel error and termios defaults
-export { KernelError, defaultTermios } from "./types.js";
+// Structured kernel error, termios defaults, and no-op logger
+export { KernelError, defaultTermios, noopKernelLogger } from "./types.js";
 // Kernel components (for direct use / testing)
 export { FDTableManager, ProcessFDTable } from "./fd-table.js";
 export { ProcessTable } from "./process-table.js";
 export { createDeviceLayer } from "./device-layer.js";
 export { createProcLayer, createProcessScopedFileSystem, resolveProcSelfPath, } from "./proc-layer.js";
+export { createProcBackend } from "./proc-backend.js";
 export { PipeManager } from "./pipe-manager.js";
 export { PtyManager } from "./pty.js";
 export { CommandRegistry } from "./command-registry.js";
 export { FileLockManager, LOCK_SH, LOCK_EX, LOCK_UN, LOCK_NB } from "./file-lock.js";
 export { WaitHandle, WaitQueue } from "./wait.js";
-export { InodeTable } from "./inode-table.js";
 export { TimerTable } from "./timer-table.js";
 export { DnsCache } from "./dns-cache.js";
 export { UserManager } from "./user.js";