@ccheever/exact-ibex-runtime 0.1.0

package/src/compression/DecompressionStream.ts

@@ -0,0 +1,342 @@
+/**
+ * DecompressionStream - Web Compression API
+ *
+ * Implements the DecompressionStream class that decompresses data using gzip, deflate, deflate-raw, or brotli.
+ * Uses the native __exactInflateSync bridge for actual decompression.
+ */
+
+const g = globalThis as any;
+const trailingDataErrorSymbol = Symbol.for("__exact.decompression.trailing-data-error");
+
+function installTrailingDataUnhandledFilter(): void {
+  if (g.__exactHasDecompressionUnhandledFilter) {
+    return;
+  }
+
+  if (typeof g.addEventListener !== "function") {
+    return;
+  }
+
+  g.__exactHasDecompressionUnhandledFilter = true;
+  g.addEventListener("unhandledrejection", (event: any) => {
+    if (event && event.reason && event.reason[trailingDataErrorSymbol]) {
+      if (typeof event.preventDefault === "function") {
+        event.preventDefault();
+      }
+      if (typeof event.stopImmediatePropagation === "function") {
+        event.stopImmediatePropagation();
+      }
+      if (typeof event.stopPropagation === "function") {
+        event.stopPropagation();
+      }
+    }
+  });
+}
+
+installTrailingDataUnhandledFilter();
+// Retry via microtask in case addEventListener wasn't available at module load time.
+// Use queueMicrotask (no timer ID, doesn't keep event loop alive) instead of setTimeout.
+if (!g.__exactHasDecompressionUnhandledFilter) {
+  if (typeof g.queueMicrotask === "function") {
+    g.queueMicrotask(installTrailingDataUnhandledFilter);
+  } else if (typeof g.setTimeout === "function") {
+    const _h = g.setTimeout(installTrailingDataUnhandledFilter, 0);
+    if (_h && typeof _h === "object" && typeof _h.unref === "function") {
+      _h.unref();
+    }
+  }
+}
+
+export type DecompressionFormat = 'gzip' | 'deflate' | 'deflate-raw' | 'brotli';
+
+function toTypeError(error: unknown): TypeError {
+  if (error instanceof TypeError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    let message = "TypeError";
+    try {
+      message = String(error.message);
+    } catch (_ignored) {
+      message = "TypeError";
+    }
+    return new TypeError(message);
+  }
+  try {
+    return new TypeError(String(error));
+  } catch (_ignored) {
+    return new TypeError("TypeError");
+  }
+}
+
+function isRecoverableIncompleteError(error: TypeError): boolean {
+  return error.message.toLowerCase().includes("incomplete data");
+}
+
+function isTrailingDataError(error: TypeError): boolean {
+  return error.message.toLowerCase().includes("trailing data");
+}
+
+function markTrailingDataError(error: TypeError): TypeError {
+  const flagged = error as unknown as { [key: symbol]: true };
+  flagged[trailingDataErrorSymbol] = true;
+  return error;
+}
+
+export class DecompressionStream {
+  private _format: DecompressionFormat;
+  private _readable: ReadableStream<Uint8Array>;
+  private _writable: WritableStream<Uint8Array>;
+
+  constructor(format: DecompressionFormat) {
+    if (format !== 'gzip' && format !== 'deflate' && format !== 'deflate-raw' && format !== 'brotli') {
+      throw new TypeError(`Unsupported decompression format: '${format}'`);
+    }
+    this._format = format;
+
+    // Native bridge mode: 0 = deflate (zlib header), 1 = gzip, 2 = raw deflate (no header)
+    const mode = format === 'gzip' ? 1 : format === 'deflate-raw' ? 2 : 0;
+
+    const decompressChunk = (chunk: Uint8Array, strict = false): Uint8Array => {
+      const input = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+
+      if (format === 'brotli') {
+        if (typeof g.__exactBrotliDecompressSync !== 'function') {
+          throw new Error('Native decompression bridge (__exactBrotliDecompressSync) not available');
+        }
+
+        try {
+          return g.__exactBrotliDecompressSync(input, strict);
+        } catch (error) {
+          throw toTypeError(error);
+        }
+      }
+
+      if (typeof g.__exactInflateSync !== 'function') {
+        throw new Error('Native decompression bridge (__exactInflateSync) not available');
+      }
+
+      try {
+        return g.__exactInflateSync(input, mode, strict);
+      } catch (error) {
+        throw toTypeError(error);
+      }
+    };
+
+    let streamError: TypeError | null = null;
+    let streamFinished = false;
+    let trailingDataError = false;
+    let writableClosed = false;
+    let readableController: ReadableStreamDefaultController<Uint8Array> | undefined;
+    const isBrotliFormat = format === 'brotli';
+    let streamInput = new Uint8Array(0);
+    let brotliOutputByteLength = 0;
+
+    const appendInput = (chunk: Uint8Array): void => {
+      if (chunk.length === 0) {
+        return;
+      }
+
+      const combined = new Uint8Array(streamInput.length + chunk.length);
+      combined.set(streamInput, 0);
+      combined.set(chunk, streamInput.length);
+      streamInput = combined;
+    };
+
+    const validateChunkCompletion = (): void => {
+      if (streamError || streamFinished) {
+        return;
+      }
+
+      try {
+        decompressChunk(streamInput, false);
+        streamFinished = true;
+      } catch (error) {
+        const decodedError = toTypeError(error);
+        if (isRecoverableIncompleteError(decodedError)) {
+          return;
+        }
+        if (isTrailingDataError(decodedError)) {
+          markTrailingDataError(decodedError);
+          streamError = decodedError;
+          trailingDataError = true;
+          streamFinished = true;
+          return;
+        }
+
+        streamError = decodedError;
+        if (readableController) {
+          readableController.error(streamError);
+        }
+      }
+    };
+
+    const processBrotliChunk = (): void => {
+      if (streamError || !readableController) {
+        return;
+      }
+
+      let output: Uint8Array;
+      try {
+        output = decompressChunk(streamInput);
+      } catch (error) {
+        const decodedError = toTypeError(error);
+        if (isRecoverableIncompleteError(decodedError)) {
+          return;
+        }
+        if (isTrailingDataError(decodedError)) {
+          markTrailingDataError(decodedError);
+          trailingDataError = true;
+        }
+
+        streamError = decodedError;
+        return;
+      }
+
+      if (output.byteLength > brotliOutputByteLength) {
+        readableController.enqueue(output.slice(brotliOutputByteLength));
+        brotliOutputByteLength = output.byteLength;
+      }
+    };
+
+    const readable = new ReadableStream<Uint8Array>({
+      start(controller) {
+        readableController = controller;
+        if (streamError) {
+          controller.error(streamError);
+          return;
+        }
+      },
+      pull(controller) {
+        if (!streamFinished && streamInput.length > 0 && !streamError) {
+          validateChunkCompletion();
+        }
+
+        if (streamError && trailingDataError) {
+          controller.error(streamError);
+          return Promise.resolve();
+        }
+        if (streamError) {
+          controller.error(streamError);
+          return Promise.resolve();
+        }
+        if (writableClosed && streamError === null && !streamFinished) {
+          streamError = new TypeError("Decompression stream failed: incomplete data");
+          controller.error(streamError);
+          return Promise.resolve();
+        }
+        if (writableClosed && readableController && streamError === null) {
+          controller.close();
+          return Promise.resolve();
+        }
+
+        return Promise.resolve();
+      },
+      cancel() {
+        writableClosed = true;
+        return Promise.resolve();
+      },
+    });
+
+    const writable = new WritableStream<Uint8Array>({
+      write(chunk) {
+        try {
+          if (streamError) {
+            throw streamError;
+          }
+
+        if (isBrotliFormat) {
+          if (chunk.length === 0) {
+            return;
+          }
+
+          const output = decompressChunk(chunk);
+          streamFinished = true;
+          if (output.byteLength > 0 && readableController) {
+            readableController.enqueue(output);
+          }
+          return;
+        }
+
+          appendInput(chunk);
+
+          let output: Uint8Array;
+          try {
+            output = decompressChunk(chunk);
+            streamFinished = true;
+          } catch (error) {
+            streamError = toTypeError(error);
+            if (readableController) {
+              readableController.error(streamError);
+            }
+            return;
+          }
+
+          if (output.byteLength > 0 && readableController) {
+            readableController.enqueue(output);
+          }
+        } catch (error) {
+          streamError = toTypeError(error);
+          if (readableController) {
+            readableController.error(streamError);
+          }
+          return;
+        }
+      },
+      async close() {
+        try {
+          writableClosed = true;
+
+          if (streamError) {
+            if (readableController) {
+              readableController.error(streamError);
+            }
+            return;
+          }
+
+          if (!streamFinished && streamInput.length > 0 && !streamError) {
+            validateChunkCompletion();
+          }
+
+          if (streamError === null && !streamFinished) {
+            streamError = new TypeError("Decompression stream failed: incomplete data");
+            if (readableController) {
+              readableController.error(streamError);
+            }
+            return;
+          }
+
+          if (streamError === null && readableController) {
+            readableController.close();
+          }
+        } catch (error) {
+          streamError = streamError || toTypeError(error);
+          if (readableController) {
+            readableController.error(streamError);
+          }
+        }
+      },
+      async abort(reason) {
+        if (streamError === null) {
+          streamError = reason === undefined ? new TypeError("The operation was aborted.") : toTypeError(reason);
+        }
+        writableClosed = true;
+        if (readableController) {
+          readableController.error(streamError);
+        }
+      },
+    });
+
+    this._readable = readable;
+    this._writable = writable;
+    return;
+  }
+
+  get readable(): ReadableStream<Uint8Array> {
+    return this._readable;
+  }
+
+  get writable(): WritableStream<Uint8Array> {
+    return this._writable;
+  }
+}

package/src/compression/index.ts

@@ -0,0 +1,4 @@
+export { CompressionStream } from './CompressionStream';
+export type { CompressionFormat } from './CompressionStream';
+export { DecompressionStream } from './DecompressionStream';
+export type { DecompressionFormat } from './DecompressionStream';

package/src/console/Console.ts

@@ -0,0 +1,341 @@
+/**
+ * Console - Web Standard Console Implementation
+ *
+ * @see https://console.spec.whatwg.org/
+ */
+
+import { inspect } from "../inspect";
+
+export type LogLevel = "log" | "info" | "warn" | "error" | "debug" | "trace";
+
+export interface ConsoleOutput {
+  log(level: LogLevel, args: any[]): void;
+  group?(label: string, collapsed: boolean): void;
+  groupEnd?(): void;
+  clear?(): void;
+}
+
+// Capture the native console BEFORE we overwrite it
+// The native layer (Hermes/JSC) sets up globalThis.console with native logging
+const _nativeConsole = (globalThis as any).console;
+
+// Default output sends to native console
+// Note: We need to look up console dynamically because it might be
+// set up AFTER our module loads but BEFORE our methods are called
+let output: ConsoleOutput = {
+  log: (level, args) => {
+    // First try: use captured native console
+    if (_nativeConsole && typeof _nativeConsole[level] === 'function') {
+      _nativeConsole[level](...args);
+      return;
+    }
+    // Second try: use current global console (might be set up later)
+    const currentConsole = (globalThis as any).console;
+    if (currentConsole && currentConsole !== _nativeConsole && typeof currentConsole[level] === 'function') {
+      currentConsole[level](...args);
+      return;
+    }
+  },
+};
+
+export function setConsoleOutput(newOutput: ConsoleOutput): void {
+  output = newOutput;
+}
+
+// Counters for console.count
+const counters = new Map<string, number>();
+
+// Timers for console.time
+const timers = new Map<string, number>();
+
+// Group depth tracking
+let groupDepth = 0;
+
+/**
+ * Format a single value for output.
+ */
+function formatValue(arg: any): string {
+  if (arg === undefined) return "undefined";
+  if (arg === null) return "null";
+  if (typeof arg === "object") {
+    return inspect(arg, { colors: false });
+  }
+  return String(arg);
+}
+
+/**
+ * Format arguments, supporting printf-style format specifiers.
+ * Supports: %s (string), %d/%i (integer), %f (float), %o/%O (object), %c (CSS - ignored)
+ * 
+ * @see https://console.spec.whatwg.org/#formatter
+ */
+function formatArgs(args: any[]): any[] {
+  if (args.length === 0) return [];
+  
+  const first = args[0];
+  
+  // If first arg is not a string or has no format specifiers, just format all args
+  if (typeof first !== 'string' || !/%[sdifoOc%]/.test(first)) {
+    return args.map(formatValue);
+  }
+  
+  // Process format specifiers
+  let result = '';
+  let argIndex = 1;
+  let i = 0;
+  
+  while (i < first.length) {
+    if (first[i] === '%' && i + 1 < first.length) {
+      const specifier = first[i + 1];
+      
+      switch (specifier) {
+        case 's': // String
+          if (argIndex < args.length) {
+            result += String(args[argIndex++]);
+          } else {
+            result += '%s';
+          }
+          i += 2;
+          break;
+          
+        case 'd': // Integer
+        case 'i':
+          if (argIndex < args.length) {
+            const num = Number(args[argIndex++]);
+            result += isNaN(num) ? 'NaN' : String(Math.trunc(num));
+          } else {
+            result += `%${specifier}`;
+          }
+          i += 2;
+          break;
+          
+        case 'f': // Float
+          if (argIndex < args.length) {
+            const num = Number(args[argIndex++]);
+            result += isNaN(num) ? 'NaN' : String(num);
+          } else {
+            result += '%f';
+          }
+          i += 2;
+          break;
+          
+        case 'o': // Object (compact)
+        case 'O': // Object (verbose)
+          if (argIndex < args.length) {
+            result += inspect(args[argIndex++], {
+              colors: false,
+              compact: specifier === 'o',
+            });
+          } else {
+            result += `%${specifier}`;
+          }
+          i += 2;
+          break;
+          
+        case 'c': // CSS styling (ignored in non-browser environments)
+          // Skip the style argument but don't output anything
+          if (argIndex < args.length) {
+            argIndex++;
+          }
+          i += 2;
+          break;
+          
+        case '%': // Literal %
+          result += '%';
+          i += 2;
+          break;
+          
+        default:
+          // Unknown specifier, output as-is
+          result += first[i];
+          i++;
+      }
+    } else {
+      result += first[i];
+      i++;
+    }
+  }
+  
+  // Append any remaining arguments
+  const remaining = args.slice(argIndex).map(formatValue);
+  
+  if (remaining.length > 0) {
+    return [result, ...remaining];
+  }
+  
+  return [result];
+}
+
+function getIndent(): string {
+  return "  ".repeat(groupDepth);
+}
+
+export class Console {
+  log(...args: any[]): void {
+    output.log("log", formatArgs(args));
+  }
+
+  info(...args: any[]): void {
+    output.log("info", formatArgs(args));
+  }
+
+  warn(...args: any[]): void {
+    output.log("warn", formatArgs(args));
+  }
+
+  error(...args: any[]): void {
+    output.log("error", formatArgs(args));
+  }
+
+  debug(...args: any[]): void {
+    output.log("debug", formatArgs(args));
+  }
+
+  trace(...args: any[]): void {
+    // Create stack trace
+    const err = new Error();
+    const stack = err.stack?.split("\n").slice(2).join("\n") ?? "";
+    output.log("trace", [...formatArgs(args), "\n" + stack]);
+  }
+
+  assert(condition?: boolean, ...args: any[]): void {
+    if (!condition) {
+      const message = args.length > 0 ? formatArgs(args) : ["Assertion failed"];
+      output.log("error", ["Assertion failed:", ...message]);
+    }
+  }
+
+  table(data: any, columns?: string[]): void {
+    if (data === null || data === undefined) {
+      output.log("log", [data]);
+      return;
+    }
+
+    if (typeof data !== "object") {
+      output.log("log", [data]);
+      return;
+    }
+
+    // Simple table implementation
+    const isArray = Array.isArray(data);
+    const entries = isArray
+      ? data.map((item, index) => [index, item])
+      : Object.entries(data);
+
+    if (entries.length === 0) {
+      output.log("log", [isArray ? "[]" : "{}"]);
+      return;
+    }
+
+    // Build table string
+    const header = isArray ? "(index)" : "(key)";
+    let tableStr = `\n${header}\tValue\n`;
+    tableStr += "-".repeat(40) + "\n";
+
+    for (const [key, value] of entries) {
+      const valueStr =
+        typeof value === "object" ? JSON.stringify(value) : String(value);
+      tableStr += `${key}\t${valueStr}\n`;
+    }
+
+    output.log("log", [tableStr]);
+  }
+
+  group(label?: string): void {
+    const groupLabel = label ?? "console.group";
+    if (output.group) {
+      output.group(groupLabel, false);
+    } else {
+      output.log("log", [`${getIndent()}▼ ${groupLabel}`]);
+    }
+    groupDepth++;
+  }
+
+  groupCollapsed(label?: string): void {
+    const groupLabel = label ?? "console.group";
+    if (output.group) {
+      output.group(groupLabel, true);
+    } else {
+      output.log("log", [`${getIndent()}▶ ${groupLabel}`]);
+    }
+    groupDepth++;
+  }
+
+  groupEnd(): void {
+    if (groupDepth > 0) {
+      groupDepth--;
+    }
+    if (output.groupEnd) {
+      output.groupEnd();
+    }
+  }
+
+  count(label?: string): void {
+    const countLabel = label ?? "default";
+    const count = (counters.get(countLabel) ?? 0) + 1;
+    counters.set(countLabel, count);
+    output.log("log", [`${countLabel}: ${count}`]);
+  }
+
+  countReset(label?: string): void {
+    const countLabel = label ?? "default";
+    if (counters.has(countLabel)) {
+      counters.set(countLabel, 0);
+    } else {
+      output.log("warn", [`Count for '${countLabel}' does not exist`]);
+    }
+  }
+
+  time(label?: string): void {
+    const timerLabel = label ?? "default";
+    if (timers.has(timerLabel)) {
+      output.log("warn", [`Timer '${timerLabel}' already exists`]);
+      return;
+    }
+    timers.set(timerLabel, performance?.now?.() ?? Date.now());
+  }
+
+  timeEnd(label?: string): void {
+    const timerLabel = label ?? "default";
+    const startTime = timers.get(timerLabel);
+    if (startTime === undefined) {
+      output.log("warn", [`Timer '${timerLabel}' does not exist`]);
+      return;
+    }
+    const duration = (performance?.now?.() ?? Date.now()) - startTime;
+    timers.delete(timerLabel);
+    output.log("log", [`${timerLabel}: ${duration.toFixed(3)}ms`]);
+  }
+
+  timeLog(label?: string, ...args: any[]): void {
+    const timerLabel = label ?? "default";
+    const startTime = timers.get(timerLabel);
+    if (startTime === undefined) {
+      output.log("warn", [`Timer '${timerLabel}' does not exist`]);
+      return;
+    }
+    const duration = (performance?.now?.() ?? Date.now()) - startTime;
+    output.log("log", [`${timerLabel}: ${duration.toFixed(3)}ms`, ...formatArgs(args)]);
+  }
+
+  clear(): void {
+    if (output.clear) {
+      output.clear();
+    } else {
+      // Output some newlines or clear indicator
+      output.log("log", ["\n".repeat(50) + "--- Console cleared ---"]);
+    }
+  }
+
+  // Aliases
+  dir(obj: any): void {
+    this.log(obj);
+  }
+
+  dirxml(obj: any): void {
+    this.log(obj);
+  }
+}
+
+// Create singleton instance
+export const console = new Console();

package/src/console/index.ts

@@ -0,0 +1,2 @@
+export { Console, console, setConsoleOutput } from "./Console";
+export type { LogLevel, ConsoleOutput } from "./Console";