chore: recovery checkpoint - v3.0 API successfully recovered

CRITICAL CHECKPOINT - DO NOT PUSH TO GITHUB

Recovery Status:
- Successfully recovered brainy.ts from compiled JavaScript
- All core v3.0 API methods functional (add, get, update, delete, relate, find, etc.)
- Neural subsystem intact (562KB embedded patterns, NLP working)
- Augmentation pipeline operational (20+ augmentations)
- HNSW clustering system complete
- Triple Intelligence compiled (needs constructor fix)
- Test suite validates functionality

Changes preserved:
- 898 files with changes from last 3 days
- 144,475 insertions
- All augmentation improvements
- All test coverage enhancements
- Complete v3.0 feature set

This is a LOCAL checkpoint only - contains recovered work after corruption incident.
Created backup in .backups/brainy-full-20250910-151314.tar.gz

Branch: recovery-checkpoint-20250910-151433
Date: Wed Sep 10 03:18:04 PM PDT 2025

.recovery-workspace/dist-backup-20250910-141917/universal/crypto.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Universal Crypto implementation
+ * Works in all environments: Browser, Node.js, Serverless
+ */
+/**
+ * Generate random bytes
+ */
+export declare function randomBytes(size: number): Uint8Array;
+/**
+ * Generate random UUID
+ */
+export declare function randomUUID(): string;
+/**
+ * Create hash (simplified interface)
+ */
+export declare function createHash(algorithm: string): {
+    update: (data: string | Uint8Array) => any;
+    digest: (encoding: string) => string;
+};
+/**
+ * Create HMAC
+ */
+export declare function createHmac(algorithm: string, key: string | Uint8Array): {
+    update: (data: string | Uint8Array) => any;
+    digest: (encoding: string) => string;
+};
+/**
+ * PBKDF2 synchronous
+ */
+export declare function pbkdf2Sync(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, digest: string): Uint8Array;
+/**
+ * Scrypt synchronous
+ */
+export declare function scryptSync(password: string | Uint8Array, salt: string | Uint8Array, keylen: number, options?: any): Uint8Array;
+/**
+ * Create cipher
+ */
+export declare function createCipheriv(algorithm: string, key: Uint8Array, iv: Uint8Array): {
+    update: (data: string, inputEncoding?: string, outputEncoding?: string) => string;
+    final: (outputEncoding?: string) => string;
+};
+/**
+ * Create decipher
+ */
+export declare function createDecipheriv(algorithm: string, key: Uint8Array, iv: Uint8Array): {
+    update: (data: string, inputEncoding?: string, outputEncoding?: string) => string;
+    final: (outputEncoding?: string) => string;
+};
+/**
+ * Timing safe equal
+ */
+export declare function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
+declare const _default: {
+    randomBytes: typeof randomBytes;
+    randomUUID: typeof randomUUID;
+    createHash: typeof createHash;
+    createHmac: typeof createHmac;
+    pbkdf2Sync: typeof pbkdf2Sync;
+    scryptSync: typeof scryptSync;
+    createCipheriv: typeof createCipheriv;
+    createDecipheriv: typeof createDecipheriv;
+    timingSafeEqual: typeof timingSafeEqual;
+};
+export default _default;

.recovery-workspace/dist-backup-20250910-141917/universal/crypto.js

@@ -0,0 +1,215 @@
+/**
+ * Universal Crypto implementation
+ * Works in all environments: Browser, Node.js, Serverless
+ */
+import { isBrowser, isNode } from '../utils/environment.js';
+let nodeCrypto = null;
+// Dynamic import for Node.js crypto (only in Node.js environment)
+if (isNode()) {
+    try {
+        nodeCrypto = await import('crypto');
+    }
+    catch {
+        // Ignore import errors in non-Node environments
+    }
+}
+/**
+ * Generate random bytes
+ */
+export function randomBytes(size) {
+    if (isBrowser() || typeof crypto !== 'undefined') {
+        // Use Web Crypto API (available in browsers and modern Node.js)
+        const array = new Uint8Array(size);
+        crypto.getRandomValues(array);
+        return array;
+    }
+    else if (nodeCrypto) {
+        // Use Node.js crypto as fallback
+        return new Uint8Array(nodeCrypto.randomBytes(size));
+    }
+    else {
+        // Fallback for environments without crypto
+        const array = new Uint8Array(size);
+        for (let i = 0; i < size; i++) {
+            array[i] = Math.floor(Math.random() * 256);
+        }
+        return array;
+    }
+}
+/**
+ * Generate random UUID
+ */
+export function randomUUID() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    else if (nodeCrypto && nodeCrypto.randomUUID) {
+        return nodeCrypto.randomUUID();
+    }
+    else {
+        // Fallback UUID generation
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+}
+/**
+ * Create hash (simplified interface)
+ */
+export function createHash(algorithm) {
+    if (nodeCrypto && nodeCrypto.createHash) {
+        return nodeCrypto.createHash(algorithm);
+    }
+    else {
+        // Simple fallback hash for browsers (not cryptographically secure)
+        let hash = 0;
+        const hashObj = {
+            update: (data) => {
+                const text = typeof data === 'string' ? data : new TextDecoder().decode(data);
+                for (let i = 0; i < text.length; i++) {
+                    const char = text.charCodeAt(i);
+                    hash = ((hash << 5) - hash) + char;
+                    hash = hash & hash; // Convert to 32-bit integer
+                }
+                return hashObj;
+            },
+            digest: (encoding) => {
+                return Math.abs(hash).toString(16);
+            }
+        };
+        return hashObj;
+    }
+}
+/**
+ * Create HMAC
+ */
+export function createHmac(algorithm, key) {
+    if (nodeCrypto && nodeCrypto.createHmac) {
+        return nodeCrypto.createHmac(algorithm, key);
+    }
+    else {
+        // Fallback HMAC implementation (simplified)
+        return createHash(algorithm);
+    }
+}
+/**
+ * PBKDF2 synchronous
+ */
+export function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+    if (nodeCrypto && nodeCrypto.pbkdf2Sync) {
+        return new Uint8Array(nodeCrypto.pbkdf2Sync(password, salt, iterations, keylen, digest));
+    }
+    else {
+        // Simplified fallback (not cryptographically secure)
+        const result = new Uint8Array(keylen);
+        const passwordStr = typeof password === 'string' ? password : new TextDecoder().decode(password);
+        const saltStr = typeof salt === 'string' ? salt : new TextDecoder().decode(salt);
+        let hash = 0;
+        const combined = passwordStr + saltStr;
+        for (let i = 0; i < combined.length; i++) {
+            hash = ((hash << 5) - hash) + combined.charCodeAt(i);
+            hash = hash & hash;
+        }
+        for (let i = 0; i < keylen; i++) {
+            result[i] = (Math.abs(hash + i) % 256);
+        }
+        return result;
+    }
+}
+/**
+ * Scrypt synchronous
+ */
+export function scryptSync(password, salt, keylen, options) {
+    if (nodeCrypto && nodeCrypto.scryptSync) {
+        return new Uint8Array(nodeCrypto.scryptSync(password, salt, keylen, options));
+    }
+    else {
+        // Fallback to pbkdf2Sync
+        return pbkdf2Sync(password, salt, 10000, keylen, 'sha256');
+    }
+}
+/**
+ * Create cipher
+ */
+export function createCipheriv(algorithm, key, iv) {
+    if (nodeCrypto && nodeCrypto.createCipheriv) {
+        return nodeCrypto.createCipheriv(algorithm, key, iv);
+    }
+    else {
+        // Fallback encryption (XOR-based, not secure)
+        let encrypted = '';
+        return {
+            update: (data, inputEncoding, outputEncoding) => {
+                for (let i = 0; i < data.length; i++) {
+                    const char = data.charCodeAt(i);
+                    const keyByte = key[i % key.length];
+                    const ivByte = iv[i % iv.length];
+                    encrypted += String.fromCharCode(char ^ keyByte ^ ivByte);
+                }
+                return outputEncoding === 'hex' ? Buffer.from(encrypted, 'binary').toString('hex') : encrypted;
+            },
+            final: (outputEncoding) => {
+                return outputEncoding === 'hex' ? '' : '';
+            }
+        };
+    }
+}
+/**
+ * Create decipher
+ */
+export function createDecipheriv(algorithm, key, iv) {
+    if (nodeCrypto && nodeCrypto.createDecipheriv) {
+        return nodeCrypto.createDecipheriv(algorithm, key, iv);
+    }
+    else {
+        // Fallback decryption (XOR-based, matches createCipheriv)
+        let decrypted = '';
+        return {
+            update: (data, inputEncoding, outputEncoding) => {
+                const input = inputEncoding === 'hex' ? Buffer.from(data, 'hex').toString('binary') : data;
+                for (let i = 0; i < input.length; i++) {
+                    const char = input.charCodeAt(i);
+                    const keyByte = key[i % key.length];
+                    const ivByte = iv[i % iv.length];
+                    decrypted += String.fromCharCode(char ^ keyByte ^ ivByte);
+                }
+                return decrypted;
+            },
+            final: (outputEncoding) => {
+                return '';
+            }
+        };
+    }
+}
+/**
+ * Timing safe equal
+ */
+export function timingSafeEqual(a, b) {
+    if (nodeCrypto && nodeCrypto.timingSafeEqual) {
+        return nodeCrypto.timingSafeEqual(a, b);
+    }
+    else {
+        // Fallback implementation
+        if (a.length !== b.length)
+            return false;
+        let result = 0;
+        for (let i = 0; i < a.length; i++) {
+            result |= a[i] ^ b[i];
+        }
+        return result === 0;
+    }
+}
+export default {
+    randomBytes,
+    randomUUID,
+    createHash,
+    createHmac,
+    pbkdf2Sync,
+    scryptSync,
+    createCipheriv,
+    createDecipheriv,
+    timingSafeEqual
+};
+//# sourceMappingURL=crypto.js.map

.recovery-workspace/dist-backup-20250910-141917/universal/events.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Universal Events implementation
+ * Browser: Uses EventTarget API
+ * Node.js: Uses built-in events module
+ */
+/**
+ * Universal EventEmitter interface
+ */
+export interface UniversalEventEmitter {
+    on(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    emit(event: string, ...args: any[]): boolean;
+    once(event: string, listener: (...args: any[]) => void): this;
+    removeAllListeners(event?: string): this;
+    listenerCount(event: string): number;
+}
+/**
+ * Universal EventEmitter class
+ */
+export declare class EventEmitter implements UniversalEventEmitter {
+    private emitter;
+    constructor();
+    on(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    emit(event: string, ...args: any[]): boolean;
+    once(event: string, listener: (...args: any[]) => void): this;
+    removeAllListeners(event?: string): this;
+    listenerCount(event: string): number;
+}
+export { EventEmitter as default };
+export declare const NodeEventEmitterClass: any;

.recovery-workspace/dist-backup-20250910-141917/universal/events.js

@@ -0,0 +1,156 @@
+/**
+ * Universal Events implementation
+ * Browser: Uses EventTarget API
+ * Node.js: Uses built-in events module
+ */
+import { isBrowser, isNode } from '../utils/environment.js';
+let nodeEvents = null;
+// Dynamic import for Node.js events (only in Node.js environment)
+if (isNode()) {
+    try {
+        nodeEvents = await import('events');
+    }
+    catch {
+        // Ignore import errors in non-Node environments
+    }
+}
+/**
+ * Browser implementation using EventTarget
+ */
+class BrowserEventEmitter extends EventTarget {
+    constructor() {
+        super(...arguments);
+        this.listeners = new Map();
+    }
+    on(event, listener) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(listener);
+        const handler = (e) => {
+            const customEvent = e;
+            listener(...(customEvent.detail || []));
+        };
+        listener.__handler = handler;
+        this.addEventListener(event, handler);
+        return this;
+    }
+    off(event, listener) {
+        const eventListeners = this.listeners.get(event);
+        if (eventListeners) {
+            eventListeners.delete(listener);
+            const handler = listener.__handler;
+            if (handler) {
+                this.removeEventListener(event, handler);
+                delete listener.__handler;
+            }
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const customEvent = new CustomEvent(event, { detail: args });
+        this.dispatchEvent(customEvent);
+        const eventListeners = this.listeners.get(event);
+        return eventListeners ? eventListeners.size > 0 : false;
+    }
+    once(event, listener) {
+        const onceListener = (...args) => {
+            this.off(event, onceListener);
+            listener(...args);
+        };
+        return this.on(event, onceListener);
+    }
+    removeAllListeners(event) {
+        if (event) {
+            const eventListeners = this.listeners.get(event);
+            if (eventListeners) {
+                for (const listener of eventListeners) {
+                    this.off(event, listener);
+                }
+            }
+        }
+        else {
+            for (const [eventName] of this.listeners) {
+                this.removeAllListeners(eventName);
+            }
+        }
+        return this;
+    }
+    listenerCount(event) {
+        const eventListeners = this.listeners.get(event);
+        return eventListeners ? eventListeners.size : 0;
+    }
+}
+/**
+ * Node.js implementation using events.EventEmitter
+ */
+class NodeEventEmitter {
+    constructor() {
+        this.emitter = new nodeEvents.EventEmitter();
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+        return this;
+    }
+    emit(event, ...args) {
+        return this.emitter.emit(event, ...args);
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+        return this;
+    }
+    removeAllListeners(event) {
+        this.emitter.removeAllListeners(event);
+        return this;
+    }
+    listenerCount(event) {
+        return this.emitter.listenerCount(event);
+    }
+}
+/**
+ * Universal EventEmitter class
+ */
+export class EventEmitter {
+    constructor() {
+        if (isBrowser()) {
+            this.emitter = new BrowserEventEmitter();
+        }
+        else if (isNode() && nodeEvents) {
+            this.emitter = new NodeEventEmitter();
+        }
+        else {
+            this.emitter = new BrowserEventEmitter();
+        }
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+        return this;
+    }
+    emit(event, ...args) {
+        return this.emitter.emit(event, ...args);
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+        return this;
+    }
+    removeAllListeners(event) {
+        this.emitter.removeAllListeners(event);
+        return this;
+    }
+    listenerCount(event) {
+        return this.emitter.listenerCount(event);
+    }
+}
+// Named export for compatibility
+export { EventEmitter as default };
+// Re-export Node.js EventEmitter class if available
+export const NodeEventEmitterClass = nodeEvents?.EventEmitter || null;
+//# sourceMappingURL=events.js.map

.recovery-workspace/dist-backup-20250910-141917/universal/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/universal/events.ts"],"names":[],"mappings":"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"}

.recovery-workspace/dist-backup-20250910-141917/universal/fs.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Universal File System implementation
+ * Browser: Uses OPFS (Origin Private File System)
+ * Node.js: Uses built-in fs/promises
+ * Serverless: Uses memory-based fallback
+ */
+/**
+ * Universal file operations interface
+ */
+export interface UniversalFS {
+    readFile(path: string, encoding?: string): Promise<string>;
+    writeFile(path: string, data: string, encoding?: string): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    readdir(path: string): Promise<string[]>;
+    readdir(path: string, options: {
+        withFileTypes: true;
+    }): Promise<{
+        name: string;
+        isDirectory(): boolean;
+        isFile(): boolean;
+    }[]>;
+    unlink(path: string): Promise<void>;
+    stat(path: string): Promise<{
+        isFile(): boolean;
+        isDirectory(): boolean;
+    }>;
+    access(path: string, mode?: number): Promise<void>;
+}
+export declare const readFile: (path: string, encoding?: string) => Promise<string>;
+export declare const writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
+export declare const mkdir: (path: string, options?: {
+    recursive?: boolean;
+}) => Promise<void>;
+export declare const exists: (path: string) => Promise<boolean>;
+export declare const readdir: {
+    (path: string): Promise<string[]>;
+    (path: string, options: {
+        withFileTypes: true;
+    }): Promise<{
+        name: string;
+        isDirectory(): boolean;
+        isFile(): boolean;
+    }[]>;
+};
+export declare const unlink: (path: string) => Promise<void>;
+export declare const stat: (path: string) => Promise<{
+    isFile(): boolean;
+    isDirectory(): boolean;
+}>;
+export declare const access: (path: string, mode?: number) => Promise<void>;
+declare const _default: {
+    readFile: (path: string, encoding?: string) => Promise<string>;
+    writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
+    mkdir: (path: string, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    exists: (path: string) => Promise<boolean>;
+    readdir: {
+        (path: string): Promise<string[]>;
+        (path: string, options: {
+            withFileTypes: true;
+        }): Promise<{
+            name: string;
+            isDirectory(): boolean;
+            isFile(): boolean;
+        }[]>;
+    };
+    unlink: (path: string) => Promise<void>;
+    stat: (path: string) => Promise<{
+        isFile(): boolean;
+        isDirectory(): boolean;
+    }>;
+    access: (path: string, mode?: number) => Promise<void>;
+};
+export default _default;
+export declare const promises: {
+    readFile: (path: string, encoding?: string) => Promise<string>;
+    writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
+    mkdir: (path: string, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    exists: (path: string) => Promise<boolean>;
+    readdir: {
+        (path: string): Promise<string[]>;
+        (path: string, options: {
+            withFileTypes: true;
+        }): Promise<{
+            name: string;
+            isDirectory(): boolean;
+            isFile(): boolean;
+        }[]>;
+    };
+    unlink: (path: string) => Promise<void>;
+    stat: (path: string) => Promise<{
+        isFile(): boolean;
+        isDirectory(): boolean;
+    }>;
+    access: (path: string, mode?: number) => Promise<void>;
+};

.recovery-workspace/dist-backup-20250910-141917/universal/fs.js

@@ -0,0 +1,304 @@
+/**
+ * Universal File System implementation
+ * Browser: Uses OPFS (Origin Private File System)
+ * Node.js: Uses built-in fs/promises
+ * Serverless: Uses memory-based fallback
+ */
+import { isBrowser, isNode } from '../utils/environment.js';
+let nodeFs = null;
+// Dynamic import for Node.js fs (only in Node.js environment)
+if (isNode()) {
+    try {
+        nodeFs = await import('fs/promises');
+    }
+    catch {
+        // Ignore import errors in non-Node environments
+    }
+}
+/**
+ * Browser implementation using OPFS
+ */
+class BrowserFS {
+    async getRoot() {
+        if ('storage' in navigator && 'getDirectory' in navigator.storage) {
+            return await navigator.storage.getDirectory();
+        }
+        throw new Error('OPFS not supported in this browser');
+    }
+    async getFileHandle(path, create = false) {
+        const root = await this.getRoot();
+        const parts = path.split('/').filter(p => p);
+        let dir = root;
+        for (let i = 0; i < parts.length - 1; i++) {
+            dir = await dir.getDirectoryHandle(parts[i], { create });
+        }
+        const fileName = parts[parts.length - 1];
+        return await dir.getFileHandle(fileName, { create });
+    }
+    async getDirHandle(path, create = false) {
+        const root = await this.getRoot();
+        const parts = path.split('/').filter(p => p);
+        let dir = root;
+        for (const part of parts) {
+            dir = await dir.getDirectoryHandle(part, { create });
+        }
+        return dir;
+    }
+    async readFile(path, encoding) {
+        try {
+            const fileHandle = await this.getFileHandle(path);
+            const file = await fileHandle.getFile();
+            return await file.text();
+        }
+        catch (error) {
+            throw new Error(`File not found: ${path}`);
+        }
+    }
+    async writeFile(path, data, encoding) {
+        const fileHandle = await this.getFileHandle(path, true);
+        const writable = await fileHandle.createWritable();
+        await writable.write(data);
+        await writable.close();
+    }
+    async mkdir(path, options = { recursive: true }) {
+        await this.getDirHandle(path, true);
+    }
+    async exists(path) {
+        try {
+            await this.getFileHandle(path);
+            return true;
+        }
+        catch {
+            try {
+                await this.getDirHandle(path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    async readdir(path, options) {
+        const dir = await this.getDirHandle(path);
+        if (options?.withFileTypes) {
+            const entries = [];
+            for await (const [name, handle] of dir.entries()) {
+                entries.push({
+                    name,
+                    isDirectory: () => handle.kind === 'directory',
+                    isFile: () => handle.kind === 'file'
+                });
+            }
+            return entries;
+        }
+        else {
+            const entries = [];
+            for await (const [name] of dir.entries()) {
+                entries.push(name);
+            }
+            return entries;
+        }
+    }
+    async unlink(path) {
+        const parts = path.split('/').filter(p => p);
+        const fileName = parts.pop();
+        const dirPath = parts.join('/');
+        if (dirPath) {
+            const dir = await this.getDirHandle(dirPath);
+            await dir.removeEntry(fileName);
+        }
+        else {
+            const root = await this.getRoot();
+            await root.removeEntry(fileName);
+        }
+    }
+    async stat(path) {
+        try {
+            await this.getFileHandle(path);
+            return { isFile: () => true, isDirectory: () => false };
+        }
+        catch {
+            try {
+                await this.getDirHandle(path);
+                return { isFile: () => false, isDirectory: () => true };
+            }
+            catch {
+                throw new Error(`Path not found: ${path}`);
+            }
+        }
+    }
+    async access(path, mode) {
+        const exists = await this.exists(path);
+        if (!exists) {
+            throw new Error(`ENOENT: no such file or directory, access '${path}'`);
+        }
+    }
+}
+/**
+ * Node.js implementation using fs/promises
+ */
+class NodeFS {
+    async readFile(path, encoding = 'utf-8') {
+        return await nodeFs.readFile(path, encoding);
+    }
+    async writeFile(path, data, encoding = 'utf-8') {
+        await nodeFs.writeFile(path, data, encoding);
+    }
+    async mkdir(path, options = { recursive: true }) {
+        await nodeFs.mkdir(path, options);
+    }
+    async exists(path) {
+        try {
+            await nodeFs.access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async readdir(path, options) {
+        if (options?.withFileTypes) {
+            return await nodeFs.readdir(path, { withFileTypes: true });
+        }
+        return await nodeFs.readdir(path);
+    }
+    async unlink(path) {
+        await nodeFs.unlink(path);
+    }
+    async stat(path) {
+        const stats = await nodeFs.stat(path);
+        return {
+            isFile: () => stats.isFile(),
+            isDirectory: () => stats.isDirectory()
+        };
+    }
+    async access(path, mode) {
+        await nodeFs.access(path, mode);
+    }
+}
+/**
+ * Memory-based fallback for serverless/edge environments
+ */
+class MemoryFS {
+    constructor() {
+        this.files = new Map();
+        this.dirs = new Set();
+    }
+    async readFile(path, encoding) {
+        const content = this.files.get(path);
+        if (content === undefined) {
+            throw new Error(`File not found: ${path}`);
+        }
+        return content;
+    }
+    async writeFile(path, data, encoding) {
+        this.files.set(path, data);
+        // Ensure parent directories exist
+        const parts = path.split('/').slice(0, -1);
+        for (let i = 1; i <= parts.length; i++) {
+            this.dirs.add(parts.slice(0, i).join('/'));
+        }
+    }
+    async mkdir(path, options = { recursive: true }) {
+        this.dirs.add(path);
+        if (options.recursive) {
+            const parts = path.split('/');
+            for (let i = 1; i <= parts.length; i++) {
+                this.dirs.add(parts.slice(0, i).join('/'));
+            }
+        }
+    }
+    async exists(path) {
+        return this.files.has(path) || this.dirs.has(path);
+    }
+    async readdir(path, options) {
+        const entries = new Set();
+        const pathPrefix = path + '/';
+        for (const filePath of this.files.keys()) {
+            if (filePath.startsWith(pathPrefix)) {
+                const relativePath = filePath.slice(pathPrefix.length);
+                const firstSegment = relativePath.split('/')[0];
+                entries.add(firstSegment);
+            }
+        }
+        for (const dirPath of this.dirs) {
+            if (dirPath.startsWith(pathPrefix)) {
+                const relativePath = dirPath.slice(pathPrefix.length);
+                const firstSegment = relativePath.split('/')[0];
+                if (firstSegment)
+                    entries.add(firstSegment);
+            }
+        }
+        if (options?.withFileTypes) {
+            return Array.from(entries).map(name => ({
+                name,
+                isDirectory: () => this.dirs.has(path + '/' + name),
+                isFile: () => this.files.has(path + '/' + name)
+            }));
+        }
+        return Array.from(entries);
+    }
+    async unlink(path) {
+        this.files.delete(path);
+    }
+    async stat(path) {
+        const isFile = this.files.has(path);
+        const isDir = this.dirs.has(path);
+        if (!isFile && !isDir) {
+            throw new Error(`Path not found: ${path}`);
+        }
+        return {
+            isFile: () => isFile,
+            isDirectory: () => isDir
+        };
+    }
+    async access(path, mode) {
+        const exists = await this.exists(path);
+        if (!exists) {
+            throw new Error(`ENOENT: no such file or directory, access '${path}'`);
+        }
+    }
+}
+// Create the appropriate filesystem implementation
+let fsImpl;
+if (isBrowser()) {
+    fsImpl = new BrowserFS();
+}
+else if (isNode() && nodeFs) {
+    fsImpl = new NodeFS();
+}
+else {
+    fsImpl = new MemoryFS();
+}
+// Export the filesystem operations
+export const readFile = fsImpl.readFile.bind(fsImpl);
+export const writeFile = fsImpl.writeFile.bind(fsImpl);
+export const mkdir = fsImpl.mkdir.bind(fsImpl);
+export const exists = fsImpl.exists.bind(fsImpl);
+export const readdir = fsImpl.readdir.bind(fsImpl);
+export const unlink = fsImpl.unlink.bind(fsImpl);
+export const stat = fsImpl.stat.bind(fsImpl);
+export const access = fsImpl.access.bind(fsImpl);
+// Default export with promises namespace compatibility  
+export default {
+    readFile,
+    writeFile,
+    mkdir,
+    exists,
+    readdir,
+    unlink,
+    stat,
+    access
+};
+// Named export for fs/promises compatibility
+export const promises = {
+    readFile,
+    writeFile,
+    mkdir,
+    exists,
+    readdir,
+    unlink,
+    stat,
+    access
+};
+//# sourceMappingURL=fs.js.map

.recovery-workspace/dist-backup-20250910-141917/universal/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Universal adapters for cross-environment compatibility
+ * Provides consistent APIs across Browser, Node.js, and Serverless environments
+ */
+export * from './uuid.js';
+export { default as uuid } from './uuid.js';
+export * from './crypto.js';
+export { default as crypto } from './crypto.js';
+export * from './fs.js';
+export { default as fs } from './fs.js';
+export * from './path.js';
+export { default as path } from './path.js';
+export * from './events.js';
+export { default as events } from './events.js';
+export { v4 as uuidv4 } from './uuid.js';
+export { EventEmitter } from './events.js';

.recovery-workspace/dist-backup-20250910-141917/universal/index.js

@@ -0,0 +1,23 @@
+/**
+ * Universal adapters for cross-environment compatibility
+ * Provides consistent APIs across Browser, Node.js, and Serverless environments
+ */
+// UUID adapter
+export * from './uuid.js';
+export { default as uuid } from './uuid.js';
+// Crypto adapter  
+export * from './crypto.js';
+export { default as crypto } from './crypto.js';
+// File system adapter
+export * from './fs.js';
+export { default as fs } from './fs.js';
+// Path adapter
+export * from './path.js';
+export { default as path } from './path.js';
+// Events adapter
+export * from './events.js';
+export { default as events } from './events.js';
+// Convenience re-exports for common patterns
+export { v4 as uuidv4 } from './uuid.js';
+export { EventEmitter } from './events.js';
+//# sourceMappingURL=index.js.map

.recovery-workspace/dist-backup-20250910-141917/universal/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/universal/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAe;AACf,cAAc,WAAW,CAAA;AACzB,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAA;AAE3C,mBAAmB;AACnB,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,aAAa,CAAA;AAE/C,sBAAsB;AACtB,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,OAAO,IAAI,EAAE,EAAE,MAAM,SAAS,CAAA;AAEvC,eAAe;AACf,cAAc,WAAW,CAAA;AACzB,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAA;AAE3C,iBAAiB;AACjB,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,aAAa,CAAA;AAE/C,6CAA6C;AAC7C,OAAO,EAAE,EAAE,IAAI,MAAM,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA"}

.recovery-workspace/dist-backup-20250910-141917/universal/path.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Universal Path implementation
+ * Browser: Manual path operations
+ * Node.js: Uses built-in path module
+ */
+/**
+ * Universal path operations
+ */
+export declare function join(...paths: string[]): string;
+export declare function dirname(path: string): string;
+export declare function basename(path: string, ext?: string): string;
+export declare function extname(path: string): string;
+export declare function resolve(...paths: string[]): string;
+export declare function relative(from: string, to: string): string;
+export declare function isAbsolute(path: string): boolean;
+export declare const sep = "/";
+export declare const delimiter = ":";
+export declare const posix: {
+    join: typeof join;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    resolve: typeof resolve;
+    relative: typeof relative;
+    isAbsolute: typeof isAbsolute;
+    sep: string;
+    delimiter: string;
+};
+declare const _default: {
+    join: typeof join;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    resolve: typeof resolve;
+    relative: typeof relative;
+    isAbsolute: typeof isAbsolute;
+    sep: string;
+    delimiter: string;
+    posix: {
+        join: typeof join;
+        dirname: typeof dirname;
+        basename: typeof basename;
+        extname: typeof extname;
+        resolve: typeof resolve;
+        relative: typeof relative;
+        isAbsolute: typeof isAbsolute;
+        sep: string;
+        delimiter: string;
+    };
+};
+export default _default;

.recovery-workspace/dist-backup-20250910-141917/universal/path.js

@@ -0,0 +1,161 @@
+/**
+ * Universal Path implementation
+ * Browser: Manual path operations
+ * Node.js: Uses built-in path module
+ */
+import { isNode } from '../utils/environment.js';
+let nodePath = null;
+// Dynamic import for Node.js path (only in Node.js environment)
+if (isNode()) {
+    try {
+        nodePath = await import('path');
+    }
+    catch {
+        // Ignore import errors in non-Node environments
+    }
+}
+/**
+ * Universal path operations
+ */
+export function join(...paths) {
+    if (nodePath) {
+        return nodePath.join(...paths);
+    }
+    // Browser fallback implementation
+    const parts = [];
+    for (const path of paths) {
+        if (path) {
+            parts.push(...path.split('/').filter(p => p));
+        }
+    }
+    return parts.join('/');
+}
+export function dirname(path) {
+    if (nodePath) {
+        return nodePath.dirname(path);
+    }
+    // Browser fallback implementation
+    const parts = path.split('/').filter(p => p);
+    if (parts.length <= 1)
+        return '.';
+    return parts.slice(0, -1).join('/');
+}
+export function basename(path, ext) {
+    if (nodePath) {
+        return nodePath.basename(path, ext);
+    }
+    // Browser fallback implementation
+    const parts = path.split('/');
+    let name = parts[parts.length - 1];
+    if (ext && name.endsWith(ext)) {
+        name = name.slice(0, -ext.length);
+    }
+    return name;
+}
+export function extname(path) {
+    if (nodePath) {
+        return nodePath.extname(path);
+    }
+    // Browser fallback implementation
+    const name = basename(path);
+    const lastDot = name.lastIndexOf('.');
+    return lastDot === -1 ? '' : name.slice(lastDot);
+}
+export function resolve(...paths) {
+    if (nodePath) {
+        return nodePath.resolve(...paths);
+    }
+    // Browser fallback implementation
+    let resolved = '';
+    let resolvedAbsolute = false;
+    for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        const path = i >= 0 ? paths[i] : '/';
+        if (!path)
+            continue;
+        resolved = path + '/' + resolved;
+        resolvedAbsolute = path.charAt(0) === '/';
+    }
+    // Normalize the path
+    resolved = normalizeArray(resolved.split('/').filter(p => p), !resolvedAbsolute).join('/');
+    return (resolvedAbsolute ? '/' : '') + resolved;
+}
+export function relative(from, to) {
+    if (nodePath) {
+        return nodePath.relative(from, to);
+    }
+    // Browser fallback implementation
+    const fromParts = resolve(from).split('/').filter(p => p);
+    const toParts = resolve(to).split('/').filter(p => p);
+    let commonLength = 0;
+    for (let i = 0; i < Math.min(fromParts.length, toParts.length); i++) {
+        if (fromParts[i] === toParts[i]) {
+            commonLength++;
+        }
+        else {
+            break;
+        }
+    }
+    const upCount = fromParts.length - commonLength;
+    const upParts = new Array(upCount).fill('..');
+    const downParts = toParts.slice(commonLength);
+    return [...upParts, ...downParts].join('/');
+}
+export function isAbsolute(path) {
+    if (nodePath) {
+        return nodePath.isAbsolute(path);
+    }
+    // Browser fallback implementation
+    return path.charAt(0) === '/';
+}
+/**
+ * Normalize array helper function
+ */
+function normalizeArray(parts, allowAboveRoot) {
+    const res = [];
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (!p || p === '.')
+            continue;
+        if (p === '..') {
+            if (res.length && res[res.length - 1] !== '..') {
+                res.pop();
+            }
+            else if (allowAboveRoot) {
+                res.push('..');
+            }
+        }
+        else {
+            res.push(p);
+        }
+    }
+    return res;
+}
+// Path separator (always use forward slash for consistency)
+export const sep = '/';
+export const delimiter = ':';
+// POSIX path object for compatibility
+export const posix = {
+    join,
+    dirname,
+    basename,
+    extname,
+    resolve,
+    relative,
+    isAbsolute,
+    sep: '/',
+    delimiter: ':'
+};
+// Default export
+export default {
+    join,
+    dirname,
+    basename,
+    extname,
+    resolve,
+    relative,
+    isAbsolute,
+    sep,
+    delimiter,
+    posix
+};
+//# sourceMappingURL=path.js.map

.recovery-workspace/dist-backup-20250910-141917/universal/path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.js","sourceRoot":"","sources":["../../src/universal/path.ts"],"names":[],"mappings":"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"}

.recovery-workspace/dist-backup-20250910-141917/universal/uuid.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Universal UUID implementation
+ * Works in all environments: Browser, Node.js, Serverless
+ */
+export declare function v4(): string;
+export { v4 as uuidv4 };
+declare const _default: {
+    v4: typeof v4;
+};
+export default _default;

.recovery-workspace/dist-backup-20250910-141917/universal/uuid.js

@@ -0,0 +1,21 @@
+/**
+ * Universal UUID implementation
+ * Works in all environments: Browser, Node.js, Serverless
+ */
+export function v4() {
+    // Use crypto.randomUUID if available (Node.js 19+, modern browsers)
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    // Fallback implementation for older environments
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+// Named export to match uuid package API
+export { v4 as uuidv4 };
+// Default export for convenience
+export default { v4 };
+//# sourceMappingURL=uuid.js.map

.recovery-workspace/dist-backup-20250910-141917/universal/uuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.js","sourceRoot":"","sources":["../../src/universal/uuid.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,UAAU,EAAE;IAChB,oEAAoE;IACpE,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;QACvD,OAAO,MAAM,CAAC,UAAU,EAAE,CAAA;IAC5B,CAAC;IAED,iDAAiD;IACjD,OAAO,sCAAsC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE;QACnE,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;QAChC,MAAM,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,CAAA;QACzC,OAAO,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;IACvB,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,yCAAyC;AACzC,OAAO,EAAE,EAAE,IAAI,MAAM,EAAE,CAAA;AAEvB,iCAAiC;AACjC,eAAe,EAAE,EAAE,EAAE,CAAA"}