aegis-bridge 0.1.0

package/dist/events.d.ts

@@ -0,0 +1,133 @@
+/**
+ * events.ts — SSE event emitter for session monitoring.
+ *
+ * Issue #32: Real-time Server-Sent Events for session lifecycle.
+ * Subscribers receive events via an EventEmitter pattern.
+ * The monitor pushes events; the SSE route consumes them.
+ */
+export interface SessionSSEEvent {
+    event: 'status' | 'message' | 'system' | 'approval' | 'ended' | 'heartbeat' | 'stall' | 'dead' | 'hook' | 'subagent_start' | 'subagent_stop' | 'verification' | 'permission_denied';
+    sessionId: string;
+    timestamp: string;
+    data: Record<string, unknown>;
+    /** Issue #87: Unix timestamp (ms) when the event was emitted by Aegis. */
+    emittedAt?: number;
+    /** Issue #308: Incrementing event ID for Last-Event-ID replay. */
+    id?: number;
+}
+export interface VerificationResult {
+    ok: boolean;
+    steps: {
+        name: 'tsc' | 'build' | 'test';
+        ok: boolean;
+        durationMs: number;
+        output?: string;
+        error?: string;
+    }[];
+    totalDurationMs: number;
+    summary: string;
+}
+export interface GlobalSSEEvent {
+    event: 'session_status_change' | 'session_message' | 'session_approval' | 'session_ended' | 'session_created' | 'session_stall' | 'session_dead' | 'session_subagent_start' | 'session_subagent_stop' | 'session_verification';
+    sessionId: string;
+    timestamp: string;
+    data: Record<string, unknown>;
+    /** Issue #301: Incrementing event ID for Last-Event-ID replay. */
+    id?: number;
+}
+interface SessionEventBusOptions {
+    /** Maximum number of per-session replay buffers retained in memory. */
+    maxSessionBuffers?: number;
+}
+/**
+ * Per-session event bus. Subscribers (SSE connections) register here.
+ * The monitor calls emit() when events happen.
+ */
+export declare class SessionEventBus {
+    private emitters;
+    /** #224: Track emitters that are ending so new subscribers get fresh emitters. */
+    private readonly endingEmitters;
+    /** Global incrementing event ID counter. */
+    private nextEventId;
+    /** #589: Allocate next event ID with overflow guard. */
+    private allocateEventId;
+    /** Maximum events to buffer per session for Last-Event-ID replay. */
+    private static readonly BUFFER_SIZE;
+    /** Per-session ring buffer for event replay. */
+    private eventBuffers;
+    /** Last activity time per session buffer for LRU eviction. */
+    private sessionBufferLastTouched;
+    /** Global ring buffer for event replay across all sessions (Issue #301). */
+    private globalEventBuffer;
+    private readonly maxSessionBuffers;
+    constructor(options?: SessionEventBusOptions);
+    private touchSessionBuffer;
+    private pruneSessionBufferMap;
+    /** Get or create the emitter for a session. */
+    private getEmitter;
+    /** Subscribe to events for a session. Returns unsubscribe function. */
+    subscribe(sessionId: string, handler: (event: SessionSSEEvent) => void): () => void;
+    /** Emit an event to all subscribers for a session (and global subscribers). */
+    emit(sessionId: string, event: SessionSSEEvent): void;
+    /** Get events emitted after the given event ID for a session. */
+    getEventsSince(sessionId: string, lastEventId: number): SessionSSEEvent[];
+    /**
+     * Cursor-based replay window for session events.
+     *
+     * - `beforeId` is an exclusive upper bound on event ID.
+     * - If omitted, returns the newest `limit` buffered events.
+     * - Returns events in ascending ID order.
+     */
+    getEventsBefore(sessionId: string, beforeId?: number, limit?: number): {
+        events: SessionSSEEvent[];
+        before_id: number | null;
+        has_more: boolean;
+        oldest_id: number | null;
+        newest_id: number | null;
+    };
+    /** Emit a status change event. */
+    emitStatus(sessionId: string, status: string, detail: string): void;
+    /** Issue #740: Emit a verification result event. */
+    emitVerification(sessionId: string, result: VerificationResult): void;
+    /** Emit a message event. */
+    emitMessage(sessionId: string, role: string, text: string, contentType?: string, toolMeta?: {
+        tool_name?: string;
+        tool_id?: string;
+    }): void;
+    /** Issue #89 L33: Emit a system message event (differentiated from user/assistant messages). */
+    emitSystem(sessionId: string, text: string, contentType?: string): void;
+    /** Emit an approval request event. */
+    emitApproval(sessionId: string, prompt: string): void;
+    /** Emit a session ended event. */
+    emitEnded(sessionId: string, reason: string): void;
+    /** Emit a stall event. */
+    emitStall(sessionId: string, stallType: string, detail: string): void;
+    /** Emit a dead session event. */
+    emitDead(sessionId: string, detail: string): void;
+    /** Emit a Claude Code hook event (e.g. Stop, PreToolUse, etc.). */
+    emitHook(sessionId: string, hookEvent: string, hookData: Record<string, unknown>): void;
+    /** Check if a session has any subscribers. */
+    hasSubscribers(sessionId: string): boolean;
+    /** Get the number of subscribers for a session. */
+    subscriberCount(sessionId: string): number;
+    /** Global emitter for aggregating events across all sessions. */
+    private globalEmitter;
+    /** #689: Pending setImmediate timers for cleanup on destroy. */
+    private pendingTimers;
+    /** #834: Pending setTimeout timers for cleanup on destroy/cleanupSession. */
+    private pendingTimeouts;
+    /** Subscribe to events from ALL sessions (new and existing). Returns unsubscribe function. */
+    subscribeGlobal(handler: (event: GlobalSSEEvent) => void): () => void;
+    /** Emit a session created event to global subscribers. */
+    emitCreated(sessionId: string, name: string, workDir: string): void;
+    /** Get global events emitted after the given event ID (Issue #301). */
+    getGlobalEventsSince(lastEventId: number): Array<{
+        id: number;
+        event: GlobalSSEEvent;
+    }>;
+    /** #398: Clean up per-session state (call when session is killed). */
+    cleanupSession(sessionId: string): void;
+    /** Clean up all emitters. */
+    destroy(): void;
+}
+export {};

package/dist/events.js

@@ -0,0 +1,389 @@
+/**
+ * events.ts — SSE event emitter for session monitoring.
+ *
+ * Issue #32: Real-time Server-Sent Events for session lifecycle.
+ * Subscribers receive events via an EventEmitter pattern.
+ * The monitor pushes events; the SSE route consumes them.
+ */
+import { EventEmitter } from 'node:events';
+import { CircularBuffer } from './utils/circular-buffer.js';
+/** Map per-session event types to global event types. */
+function toGlobalEvent(event) {
+    const typeMap = {
+        status: 'session_status_change',
+        message: 'session_message',
+        system: 'session_message',
+        approval: 'session_approval',
+        ended: 'session_ended',
+        heartbeat: 'session_status_change',
+        verification: 'session_verification',
+        stall: 'session_stall',
+        dead: 'session_dead',
+        subagent_start: 'session_subagent_start',
+        subagent_stop: 'session_subagent_stop',
+        hook: 'session_message',
+    };
+    return {
+        event: typeMap[event.event] || 'session_status_change',
+        sessionId: event.sessionId,
+        timestamp: event.timestamp,
+        data: event.data,
+        id: event.id,
+    };
+}
+/**
+ * Per-session event bus. Subscribers (SSE connections) register here.
+ * The monitor calls emit() when events happen.
+ */
+export class SessionEventBus {
+    emitters = new Map();
+    /** #224: Track emitters that are ending so new subscribers get fresh emitters. */
+    endingEmitters = new WeakSet();
+    /** Global incrementing event ID counter. */
+    nextEventId = 1;
+    /** #589: Allocate next event ID with overflow guard. */
+    allocateEventId() {
+        if (this.nextEventId >= Number.MAX_SAFE_INTEGER) {
+            console.warn('[SessionEventBus] Event ID counter approaching MAX_SAFE_INTEGER, resetting to 1');
+            this.nextEventId = 1;
+        }
+        return this.nextEventId++;
+    }
+    /** Maximum events to buffer per session for Last-Event-ID replay. */
+    static BUFFER_SIZE = 50;
+    /** Per-session ring buffer for event replay. */
+    eventBuffers = new Map();
+    /** Last activity time per session buffer for LRU eviction. */
+    sessionBufferLastTouched = new Map();
+    /** Global ring buffer for event replay across all sessions (Issue #301). */
+    globalEventBuffer = new CircularBuffer(SessionEventBus.BUFFER_SIZE);
+    maxSessionBuffers;
+    constructor(options = {}) {
+        this.maxSessionBuffers = options.maxSessionBuffers ?? 10_000;
+    }
+    touchSessionBuffer(sessionId) {
+        this.sessionBufferLastTouched.set(sessionId, Date.now());
+    }
+    pruneSessionBufferMap(protectedSessionId) {
+        if (this.eventBuffers.size <= this.maxSessionBuffers)
+            return;
+        let oldestSessionId;
+        let oldestTouched = Infinity;
+        for (const [sessionId, touchedAt] of this.sessionBufferLastTouched) {
+            if (sessionId === protectedSessionId)
+                continue;
+            if (!this.eventBuffers.has(sessionId)) {
+                this.sessionBufferLastTouched.delete(sessionId);
+                continue;
+            }
+            const emitter = this.emitters.get(sessionId);
+            if (emitter && emitter.listenerCount('event') > 0) {
+                continue;
+            }
+            if (touchedAt < oldestTouched) {
+                oldestTouched = touchedAt;
+                oldestSessionId = sessionId;
+            }
+        }
+        if (oldestSessionId !== undefined) {
+            this.eventBuffers.delete(oldestSessionId);
+            this.sessionBufferLastTouched.delete(oldestSessionId);
+        }
+    }
+    /** Get or create the emitter for a session. */
+    getEmitter(sessionId) {
+        let emitter = this.emitters.get(sessionId);
+        // #224: If emitter is ending (session ended), create a fresh one
+        if (emitter && this.endingEmitters.has(emitter)) {
+            this.emitters.delete(sessionId);
+            emitter = undefined;
+        }
+        if (!emitter) {
+            emitter = new EventEmitter();
+            emitter.setMaxListeners(50); // Allow many concurrent SSE clients
+            this.emitters.set(sessionId, emitter);
+        }
+        return emitter;
+    }
+    /** Subscribe to events for a session. Returns unsubscribe function. */
+    subscribe(sessionId, handler) {
+        const emitter = this.getEmitter(sessionId);
+        emitter.on('event', handler);
+        return () => {
+            emitter.off('event', handler);
+            // Clean up emitter if no more listeners and not ending
+            if (emitter.listenerCount('event') === 0 && !this.endingEmitters.has(emitter)) {
+                this.emitters.delete(sessionId);
+            }
+        };
+    }
+    /** Emit an event to all subscribers for a session (and global subscribers). */
+    emit(sessionId, event) {
+        // Issue #87: Stamp emittedAt for latency measurement
+        event.emittedAt = Date.now();
+        // Issue #308: Assign incrementing ID for Last-Event-ID replay
+        event.id = this.allocateEventId();
+        // Push to ring buffer
+        let buffer = this.eventBuffers.get(sessionId);
+        if (!buffer) {
+            buffer = new CircularBuffer(SessionEventBus.BUFFER_SIZE);
+            this.eventBuffers.set(sessionId, buffer);
+        }
+        buffer.push({ id: event.id, event });
+        this.touchSessionBuffer(sessionId);
+        this.pruneSessionBufferMap(sessionId);
+        const emitter = this.emitters.get(sessionId);
+        if (emitter) {
+            const imm = setImmediate(() => {
+                this.pendingTimers.delete(imm);
+                emitter.emit('event', event);
+            });
+            this.pendingTimers.add(imm);
+        }
+        // Forward to global subscribers
+        if (this.globalEmitter) {
+            const globalEvent = toGlobalEvent(event);
+            // Issue #301: push to global ring buffer
+            this.globalEventBuffer.push({ id: event.id, event: globalEvent });
+            const imm = setImmediate(() => {
+                this.pendingTimers.delete(imm);
+                this.globalEmitter?.emit('event', globalEvent);
+            });
+            this.pendingTimers.add(imm);
+        }
+    }
+    /** Get events emitted after the given event ID for a session. */
+    getEventsSince(sessionId, lastEventId) {
+        const buffer = this.eventBuffers.get(sessionId);
+        if (!buffer)
+            return [];
+        this.touchSessionBuffer(sessionId);
+        return buffer.toArray().filter(e => e.id > lastEventId).map(e => e.event);
+    }
+    /**
+     * Cursor-based replay window for session events.
+     *
+     * - `beforeId` is an exclusive upper bound on event ID.
+     * - If omitted, returns the newest `limit` buffered events.
+     * - Returns events in ascending ID order.
+     */
+    getEventsBefore(sessionId, beforeId, limit = 50) {
+        const buffer = this.eventBuffers.get(sessionId);
+        if (!buffer) {
+            return {
+                events: [],
+                before_id: null,
+                has_more: false,
+                oldest_id: null,
+                newest_id: null,
+            };
+        }
+        this.touchSessionBuffer(sessionId);
+        const entries = buffer.toArray();
+        const clampedLimit = Math.min(SessionEventBus.BUFFER_SIZE, Math.max(1, limit));
+        const upperExclusive = beforeId !== undefined
+            ? entries.findIndex(e => e.id >= beforeId)
+            : entries.length;
+        const resolvedUpperExclusive = upperExclusive === -1 ? entries.length : upperExclusive;
+        const lowerInclusive = Math.max(0, resolvedUpperExclusive - clampedLimit);
+        const window = entries.slice(lowerInclusive, resolvedUpperExclusive);
+        const events = window.map(e => e.event);
+        const oldestId = window.length > 0 ? window[0].id : null;
+        const newestId = window.length > 0 ? window[window.length - 1].id : null;
+        return {
+            events,
+            before_id: oldestId,
+            has_more: lowerInclusive > 0,
+            oldest_id: oldestId,
+            newest_id: newestId,
+        };
+    }
+    /** Emit a status change event. */
+    emitStatus(sessionId, status, detail) {
+        this.emit(sessionId, {
+            event: 'status',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { status, detail },
+        });
+    }
+    /** Issue #740: Emit a verification result event. */
+    emitVerification(sessionId, result) {
+        this.emit(sessionId, {
+            event: 'verification',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: result,
+        });
+    }
+    /** Emit a message event. */
+    emitMessage(sessionId, role, text, contentType, toolMeta) {
+        this.emit(sessionId, {
+            event: 'message',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { role, text, contentType, ...toolMeta },
+        });
+    }
+    /** Issue #89 L33: Emit a system message event (differentiated from user/assistant messages). */
+    emitSystem(sessionId, text, contentType) {
+        this.emit(sessionId, {
+            event: 'system',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { role: 'system', text, contentType, isSystem: true },
+        });
+    }
+    /** Emit an approval request event. */
+    emitApproval(sessionId, prompt) {
+        this.emit(sessionId, {
+            event: 'approval',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { prompt },
+        });
+    }
+    /** Emit a session ended event. */
+    emitEnded(sessionId, reason) {
+        this.emit(sessionId, {
+            event: 'ended',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { reason },
+        });
+        // #224: Mark emitter as ending so new subscribers don't get silently deleted
+        const emitter = this.emitters.get(sessionId);
+        if (emitter) {
+            this.endingEmitters.add(emitter);
+        }
+        // Clean up after a short delay (let clients receive the event)
+        // Capture reference — only delete if it's still the same emitter
+        // #357: Also delete the per-session event buffer to prevent unbounded map growth
+        // #834: Track the timer so cleanupSession/destroy can cancel it
+        const timeout = setTimeout(() => {
+            this.pendingTimeouts.delete(timeout);
+            if (this.emitters.get(sessionId) === emitter) {
+                this.emitters.delete(sessionId);
+            }
+            this.eventBuffers.delete(sessionId);
+            this.sessionBufferLastTouched.delete(sessionId);
+        }, 1000);
+        this.pendingTimeouts.add(timeout);
+    }
+    /** Emit a stall event. */
+    emitStall(sessionId, stallType, detail) {
+        this.emit(sessionId, {
+            event: 'stall',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { stallType, detail },
+        });
+    }
+    /** Emit a dead session event. */
+    emitDead(sessionId, detail) {
+        this.emit(sessionId, {
+            event: 'dead',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { reason: detail },
+        });
+    }
+    /** Emit a Claude Code hook event (e.g. Stop, PreToolUse, etc.). */
+    emitHook(sessionId, hookEvent, hookData) {
+        this.emit(sessionId, {
+            event: 'hook',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { hookEvent, ...hookData },
+        });
+    }
+    /** Check if a session has any subscribers. */
+    hasSubscribers(sessionId) {
+        const emitter = this.emitters.get(sessionId);
+        return !!emitter && emitter.listenerCount('event') > 0;
+    }
+    /** Get the number of subscribers for a session. */
+    subscriberCount(sessionId) {
+        const emitter = this.emitters.get(sessionId);
+        return emitter ? emitter.listenerCount('event') : 0;
+    }
+    // ── Global (all-session) SSE ──────────────────────────────────────
+    /** Global emitter for aggregating events across all sessions. */
+    globalEmitter = null;
+    /** #689: Pending setImmediate timers for cleanup on destroy. */
+    pendingTimers = new Set();
+    /** #834: Pending setTimeout timers for cleanup on destroy/cleanupSession. */
+    pendingTimeouts = new Set();
+    /** Subscribe to events from ALL sessions (new and existing). Returns unsubscribe function. */
+    subscribeGlobal(handler) {
+        if (!this.globalEmitter) {
+            this.globalEmitter = new EventEmitter();
+            this.globalEmitter.setMaxListeners(50);
+        }
+        this.globalEmitter.on('event', handler);
+        return () => {
+            this.globalEmitter?.off('event', handler);
+            // #689: Nullify globalEmitter when all subscribers leave
+            if (this.globalEmitter && this.globalEmitter.listenerCount('event') === 0) {
+                this.globalEmitter = null;
+            }
+        };
+    }
+    /** Emit a session created event to global subscribers. */
+    emitCreated(sessionId, name, workDir) {
+        if (!this.globalEmitter)
+            return;
+        const id = this.allocateEventId();
+        const globalEvent = {
+            event: 'session_created',
+            sessionId,
+            timestamp: new Date().toISOString(),
+            data: { name, workDir },
+            id,
+        };
+        // Issue #301: buffer global-only events
+        this.globalEventBuffer.push({ id, event: globalEvent });
+        this.globalEmitter.emit('event', globalEvent);
+    }
+    /** Get global events emitted after the given event ID (Issue #301). */
+    getGlobalEventsSince(lastEventId) {
+        return this.globalEventBuffer.toArray().filter(e => e.id > lastEventId);
+    }
+    /** #398: Clean up per-session state (call when session is killed). */
+    cleanupSession(sessionId) {
+        // #834: Clear pending setTimeout for this session's emitEnded cleanup
+        for (const timeout of this.pendingTimeouts) {
+            clearTimeout(timeout);
+            this.pendingTimeouts.delete(timeout);
+        }
+        this.eventBuffers.delete(sessionId);
+        this.sessionBufferLastTouched.delete(sessionId);
+        const emitter = this.emitters.get(sessionId);
+        if (emitter) {
+            emitter.removeAllListeners();
+            this.emitters.delete(sessionId);
+        }
+    }
+    /** Clean up all emitters. */
+    destroy() {
+        // #689: Clear pending setImmediate timers before removing listeners
+        for (const imm of this.pendingTimers) {
+            clearImmediate(imm);
+        }
+        this.pendingTimers.clear();
+        // #834: Clear pending setTimeout timers
+        for (const timeout of this.pendingTimeouts) {
+            clearTimeout(timeout);
+        }
+        this.pendingTimeouts.clear();
+        for (const emitter of this.emitters.values()) {
+            emitter.removeAllListeners();
+        }
+        this.emitters.clear();
+        this.eventBuffers.clear();
+        this.sessionBufferLastTouched.clear();
+        this.globalEventBuffer.clear();
+        this.globalEmitter?.removeAllListeners();
+        this.globalEmitter = null;
+    }
+}

package/dist/fault-injection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * fault-injection.ts — deterministic fault injection harness for integration tests.
+ *
+ * Disabled by default in production. Enable with AEGIS_FAULT_INJECTION=1
+ * or via test helpers.
+ */
+export type FaultMode = 'transient' | 'fatal' | 'delay';
+export interface FaultRule {
+    point: string;
+    mode: FaultMode;
+    every?: number;
+    probability?: number;
+    delayMs?: number;
+    errorMessage?: string;
+}
+export declare class InjectedTransientFaultError extends Error {
+    readonly point: string;
+    constructor(point: string, message?: string);
+}
+export declare class InjectedFatalFaultError extends Error {
+    readonly point: string;
+    constructor(point: string, message?: string);
+}
+export declare function maybeInjectFault(point: string): Promise<void>;
+export declare function resetFaultInjection(): void;
+export declare function clearFaultRules(): void;
+export declare function setFaultInjectionEnabledForTest(enabled: boolean): void;
+export declare function setFaultInjectionSeedForTest(seed: number): void;
+export declare function addFaultRule(rule: FaultRule): void;

package/dist/fault-injection.js

@@ -0,0 +1,115 @@
+/**
+ * fault-injection.ts — deterministic fault injection harness for integration tests.
+ *
+ * Disabled by default in production. Enable with AEGIS_FAULT_INJECTION=1
+ * or via test helpers.
+ */
+export class InjectedTransientFaultError extends Error {
+    point;
+    constructor(point, message) {
+        super(message ?? `Injected transient fault at ${point}`);
+        this.name = 'InjectedTransientFaultError';
+        this.point = point;
+    }
+}
+export class InjectedFatalFaultError extends Error {
+    point;
+    constructor(point, message) {
+        super(message ?? `Injected fatal fault at ${point}`);
+        this.name = 'InjectedFatalFaultError';
+        this.point = point;
+    }
+}
+class FaultInjector {
+    rules = [];
+    hitCounts = new Map();
+    enabledOverride = null;
+    seed = 1;
+    rngState = 1;
+    constructor() {
+        this.reset();
+    }
+    readSeedFromEnv() {
+        const parsed = Number.parseInt(process.env.AEGIS_FAULT_SEED ?? '1', 10);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+    }
+    nextRandom() {
+        // LCG constants from Numerical Recipes, deterministic and fast.
+        this.rngState = (1664525 * this.rngState + 1013904223) >>> 0;
+        return this.rngState / 0x100000000;
+    }
+    isEnabled() {
+        if (this.enabledOverride !== null) {
+            return this.enabledOverride;
+        }
+        return process.env.AEGIS_FAULT_INJECTION === '1';
+    }
+    reset() {
+        this.seed = this.readSeedFromEnv();
+        this.rngState = this.seed;
+        this.hitCounts.clear();
+    }
+    clearRules() {
+        this.rules.length = 0;
+        this.hitCounts.clear();
+    }
+    setEnabledForTest(enabled) {
+        this.enabledOverride = enabled;
+    }
+    setSeedForTest(seed) {
+        this.seed = seed > 0 ? Math.floor(seed) : 1;
+        this.rngState = this.seed;
+    }
+    addRule(rule) {
+        this.rules.push(rule);
+    }
+    async inject(point) {
+        if (!this.isEnabled())
+            return;
+        for (const rule of this.rules) {
+            if (rule.point !== point)
+                continue;
+            const count = (this.hitCounts.get(point) ?? 0) + 1;
+            this.hitCounts.set(point, count);
+            let shouldTrigger = true;
+            if (rule.every && rule.every > 0) {
+                shouldTrigger = count % rule.every === 0;
+            }
+            else if (typeof rule.probability === 'number') {
+                shouldTrigger = this.nextRandom() < Math.max(0, Math.min(1, rule.probability));
+            }
+            if (!shouldTrigger)
+                continue;
+            if (rule.mode === 'delay') {
+                const ms = Math.max(0, rule.delayMs ?? 0);
+                if (ms > 0) {
+                    await new Promise(resolve => setTimeout(resolve, ms));
+                }
+                return;
+            }
+            if (rule.mode === 'transient') {
+                throw new InjectedTransientFaultError(point, rule.errorMessage);
+            }
+            throw new InjectedFatalFaultError(point, rule.errorMessage);
+        }
+    }
+}
+const injector = new FaultInjector();
+export function maybeInjectFault(point) {
+    return injector.inject(point);
+}
+export function resetFaultInjection() {
+    injector.reset();
+}
+export function clearFaultRules() {
+    injector.clearRules();
+}
+export function setFaultInjectionEnabledForTest(enabled) {
+    injector.setEnabledForTest(enabled);
+}
+export function setFaultInjectionSeedForTest(seed) {
+    injector.setSeedForTest(seed);
+}
+export function addFaultRule(rule) {
+    injector.addRule(rule);
+}

package/dist/file-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function buildWindowsIcaclsArgs(filePath: string, account: string): string[];
+export declare function secureFilePermissions(filePath: string, platform?: NodeJS.Platform): Promise<void>;