@secure-exec/core 0.2.1-rc.1 → 0.3.0-rc.1

package/dist/kernel/timer-table.d.ts

@@ -1,54 +0,0 @@
-/**
- * Kernel timer table with per-process ownership and budget enforcement.
- *
- * Tracks active timers (setTimeout/setInterval) per-process. Actual
- * scheduling is delegated to the host via callbacks — the kernel only
- * manages ownership, limits, and cleanup.
- */
-export interface KernelTimer {
-    readonly id: number;
-    readonly pid: number;
-    readonly delayMs: number;
-    readonly repeat: boolean;
-    /** Host-side handle returned by the scheduling function (for cancellation). */
-    hostHandle: ReturnType<typeof setTimeout> | number | undefined;
-    /** User callback to invoke when the timer fires. */
-    callback: () => void;
-    /** True once the timer has been cleared. */
-    cleared: boolean;
-}
-export interface TimerTableOptions {
-    /** Default per-process timer limit. 0 = unlimited. */
-    defaultMaxTimers?: number;
-}
-export declare class TimerTable {
-    private timers;
-    private nextTimerId;
-    private defaultMaxTimers;
-    /** Per-process limit overrides. */
-    private processLimits;
-    constructor(options?: TimerTableOptions);
-    /**
-     * Create a timer owned by `pid`.
-     * Returns the kernel timer ID. The caller must schedule the actual
-     * timeout on the host and set `timer.hostHandle`.
-     */
-    createTimer(pid: number, delayMs: number, repeat: boolean, callback: () => void): number;
-    /** Get a timer by ID. Returns null if not found. */
-    get(timerId: number): KernelTimer | null;
-    /** Clear (cancel) a timer. The caller should also cancel the host-side handle. */
-    clearTimer(timerId: number, pid?: number): void;
-    /** Set per-process timer limit. */
-    setLimit(pid: number, maxTimers: number): void;
-    /** Get the active timer count for a process. */
-    countForProcess(pid: number): number;
-    /** Get all active timers for a process. */
-    getActiveTimers(pid: number): KernelTimer[];
-    /** Clear all timers owned by a process. Called on process exit. */
-    clearAllForProcess(pid: number): void;
-    /** Dispose all timers. Called on kernel shutdown. */
-    disposeAll(): void;
-    /** Number of active timers across all processes. */
-    get size(): number;
-    private getLimit;
-}

package/dist/kernel/timer-table.js

@@ -1,108 +0,0 @@
-/**
- * Kernel timer table with per-process ownership and budget enforcement.
- *
- * Tracks active timers (setTimeout/setInterval) per-process. Actual
- * scheduling is delegated to the host via callbacks — the kernel only
- * manages ownership, limits, and cleanup.
- */
-import { KernelError } from "./types.js";
-export class TimerTable {
-    timers = new Map();
-    nextTimerId = 1;
-    defaultMaxTimers;
-    /** Per-process limit overrides. */
-    processLimits = new Map();
-    constructor(options) {
-        this.defaultMaxTimers = options?.defaultMaxTimers ?? 0;
-    }
-    /**
-     * Create a timer owned by `pid`.
-     * Returns the kernel timer ID. The caller must schedule the actual
-     * timeout on the host and set `timer.hostHandle`.
-     */
-    createTimer(pid, delayMs, repeat, callback) {
-        // Enforce per-process limit
-        const limit = this.getLimit(pid);
-        if (limit > 0) {
-            const count = this.countForProcess(pid);
-            if (count >= limit) {
-                throw new KernelError("EAGAIN", "timer limit exceeded");
-            }
-        }
-        const id = this.nextTimerId++;
-        const timer = {
-            id,
-            pid,
-            delayMs,
-            repeat,
-            hostHandle: undefined,
-            callback,
-            cleared: false,
-        };
-        this.timers.set(id, timer);
-        return id;
-    }
-    /** Get a timer by ID. Returns null if not found. */
-    get(timerId) {
-        return this.timers.get(timerId) ?? null;
-    }
-    /** Clear (cancel) a timer. The caller should also cancel the host-side handle. */
-    clearTimer(timerId, pid) {
-        const timer = this.timers.get(timerId);
-        if (!timer)
-            return; // Clearing a non-existent timer is a no-op (matches POSIX)
-        // Cross-process isolation: if pid is provided, only the owning process can clear
-        if (pid !== undefined && timer.pid !== pid) {
-            throw new KernelError("EACCES", `timer ${timerId} not owned by pid ${pid}`);
-        }
-        timer.cleared = true;
-        this.timers.delete(timerId);
-    }
-    /** Set per-process timer limit. */
-    setLimit(pid, maxTimers) {
-        this.processLimits.set(pid, maxTimers);
-    }
-    /** Get the active timer count for a process. */
-    countForProcess(pid) {
-        let count = 0;
-        for (const timer of this.timers.values()) {
-            if (timer.pid === pid)
-                count++;
-        }
-        return count;
-    }
-    /** Get all active timers for a process. */
-    getActiveTimers(pid) {
-        const result = [];
-        for (const timer of this.timers.values()) {
-            if (timer.pid === pid)
-                result.push(timer);
-        }
-        return result;
-    }
-    /** Clear all timers owned by a process. Called on process exit. */
-    clearAllForProcess(pid) {
-        for (const [id, timer] of this.timers) {
-            if (timer.pid === pid) {
-                timer.cleared = true;
-                this.timers.delete(id);
-            }
-        }
-        this.processLimits.delete(pid);
-    }
-    /** Dispose all timers. Called on kernel shutdown. */
-    disposeAll() {
-        for (const timer of this.timers.values()) {
-            timer.cleared = true;
-        }
-        this.timers.clear();
-        this.processLimits.clear();
-    }
-    /** Number of active timers across all processes. */
-    get size() {
-        return this.timers.size;
-    }
-    getLimit(pid) {
-        return this.processLimits.get(pid) ?? this.defaultMaxTimers;
-    }
-}