@ccheever/exact-ibex-runtime 0.1.0

package/src/fetch/index.ts

@@ -0,0 +1,101 @@
+/**
+ * Fetch API
+ *
+ * Web-standard Fetch API implementation for the Ibex runtime.
+ * Follows the WHATWG Fetch Standard with native platform integration.
+ *
+ * @see https://fetch.spec.whatwg.org/
+ *
+ * @example
+ * ```typescript
+ * import { fetch, Headers, Request, Response } from '@exact/runtime/fetch';
+ *
+ * // Simple GET request
+ * const response = await fetch('https://api.example.com/data');
+ * const data = await response.json();
+ *
+ * // POST with JSON body
+ * const response = await fetch('https://api.example.com/users', {
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: JSON.stringify({ name: 'John' }),
+ * });
+ *
+ * // With AbortController
+ * const controller = new AbortController();
+ * setTimeout(() => controller.abort(), 5000);
+ * const response = await fetch('https://api.example.com/slow', {
+ *   signal: controller.signal,
+ * });
+ * ```
+ */
+
+// Core fetch function
+export { fetch, fetchPolyfill, setNativeFetchModule, isNativeFetchModuleInitialized, installFetchGlobals } from './fetch.js';
+
+// Native bridge
+export {
+  isNativeFetchAvailable,
+  createNativeFetchModule,
+  initializeNativeFetch,
+} from './native-bridge.js';
+
+// Classes
+export { Headers } from './Headers.js';
+export { Request, type RequestInput } from './Request.js';
+export { Response } from './Response.js';
+
+// Cookie jar
+export { cookieJar, CookieJar, setRuntimeOrigin, getRuntimeOrigin } from './cookie-jar.js';
+export type { StoredCookie } from './cookie-jar.js';
+
+// Errors
+export { FetchError, AbortError, NetworkError, URLError, BodyConsumedError } from './errors.js';
+
+// Types
+export type {
+  // Request types
+  RequestInit,
+  RequestMethod,
+  RequestMode,
+  RequestCredentials,
+  RequestCache,
+  RequestRedirect,
+  ReferrerPolicy,
+  RequestDuplex,
+
+  // Response types
+  ResponseInit,
+  ResponseType,
+
+  // Headers types
+  HeadersInit,
+
+  // Body types
+  BodyInit,
+  BufferSource,
+
+  // Native bridge types
+  NativeRequestInit,
+  NativeResponse,
+  NativeStreamingResponse,
+  NativeFetchModule,
+} from './types.js';
+
+// Body utilities (for advanced usage)
+export {
+  bodyToUint8Array,
+  readableStreamToUint8Array,
+  concatUint8Arrays,
+  parseJson,
+  parseText,
+  parseMultipartFormData,
+  extractBoundary,
+  isBlob,
+  isFormData,
+  isArrayBuffer,
+  isArrayBufferView,
+} from './body.js';
+
+// Stream utilities
+export { isReadableStream } from '../streams/index.js';

package/src/fetch/native-bridge.ts

@@ -0,0 +1,65 @@
+/**
+ * Native Fetch Bridge
+ *
+ * Bridges the C++ __nativeFetch function to the TypeScript NativeFetchModule interface.
+ * This allows the TypeScript fetch implementation to use the native HTTP layer.
+ */
+
+import type { NativeFetchModule, NativeRequestInit, NativeResponse } from './types.js';
+import { setNativeFetchModule } from './fetch.js';
+
+// Declare the global __nativeFetch function installed by C++
+declare global {
+  /**
+   * Native fetch function installed by ExactHermesBridge.cpp
+   * @param url - Request URL
+   * @param init - Native request init object
+   * @param body - Request body as Uint8Array or null
+   * @returns Promise resolving to NativeResponse
+   */
+  function __nativeFetch(
+    url: string,
+    init: NativeRequestInit,
+    body: Uint8Array | null
+  ): Promise<NativeResponse>;
+}
+
+/**
+ * Check if the native fetch bridge is available
+ */
+export function isNativeFetchAvailable(): boolean {
+  return typeof __nativeFetch === 'function';
+}
+
+/**
+ * Create a NativeFetchModule that wraps the C++ __nativeFetch function
+ */
+export function createNativeFetchModule(): NativeFetchModule | null {
+  if (!isNativeFetchAvailable()) {
+    return null;
+  }
+
+  return {
+    __exactNativeBridge: true,
+    fetch: (
+      url: string,
+      init: NativeRequestInit,
+      body: Uint8Array | null
+    ): Promise<NativeResponse> => {
+      return __nativeFetch(url, init, body);
+    },
+  };
+}
+
+/**
+ * Auto-initialize the native fetch module if available.
+ * Call this during runtime bootstrap.
+ */
+export function initializeNativeFetch(): boolean {
+  const module = createNativeFetchModule();
+  if (module) {
+    setNativeFetchModule(module);
+    return true;
+  }
+  return false;
+}

package/src/fetch/types.ts

@@ -0,0 +1,258 @@
+/**
+ * Fetch API Type Definitions
+ *
+ * Based on the WHATWG Fetch Standard with extensions for Ibex runtime.
+ * @see https://fetch.spec.whatwg.org/
+ */
+
+// =============================================================================
+// Request Types
+// =============================================================================
+
+export type RequestMethod =
+  | 'GET'
+  | 'POST'
+  | 'PUT'
+  | 'DELETE'
+  | 'PATCH'
+  | 'HEAD'
+  | 'OPTIONS'
+  | 'CONNECT'
+  | 'TRACE';
+
+export type RequestMode = 'cors' | 'no-cors' | 'same-origin' | 'navigate';
+
+export type RequestCredentials = 'omit' | 'same-origin' | 'include';
+
+export type RequestCache =
+  | 'default'
+  | 'no-store'
+  | 'reload'
+  | 'no-cache'
+  | 'force-cache'
+  | 'only-if-cached';
+
+export type RequestRedirect = 'follow' | 'error' | 'manual';
+
+export type ReferrerPolicy =
+  | ''
+  | 'no-referrer'
+  | 'no-referrer-when-downgrade'
+  | 'same-origin'
+  | 'origin'
+  | 'strict-origin'
+  | 'origin-when-cross-origin'
+  | 'strict-origin-when-cross-origin'
+  | 'unsafe-url';
+
+export type RequestDuplex = 'half';
+export type TlsCertificateSource = string | ArrayBufferView | Array<string | ArrayBufferView>;
+
+export interface FetchTlsOptions {
+  ca?: TlsCertificateSource;
+  cert?: TlsCertificateSource;
+  key?: TlsCertificateSource;
+  pfx?: TlsCertificateSource;
+  passphrase?: string;
+  servername?: string;
+  rejectUnauthorized?: boolean;
+  checkServerIdentity?: (hostname: string, cert: unknown) => Error | null | undefined;
+  [key: string]: unknown;
+}
+
+/**
+ * Request initialization options.
+ */
+export interface RequestInit {
+  /** HTTP method (GET, POST, etc.) */
+  method?: string;
+  /** Request headers */
+  headers?: HeadersInit;
+  /** Request body */
+  body?: BodyInit | null;
+  /** Request mode for CORS */
+  mode?: RequestMode;
+  /** Credentials mode */
+  credentials?: RequestCredentials;
+  /** Cache mode */
+  cache?: RequestCache;
+  /** Redirect handling mode */
+  redirect?: RequestRedirect;
+  /** Referrer URL */
+  referrer?: string;
+  /** Referrer policy */
+  referrerPolicy?: ReferrerPolicy;
+  /** Subresource integrity hash */
+  integrity?: string;
+  /** Abort signal for cancellation */
+  signal?: AbortSignal | null;
+  /** Abort the request after this many milliseconds. Set to 0 to disable the default timeout. */
+  timeout?: number;
+  /** Required for streaming uploads */
+  duplex?: RequestDuplex;
+  /** Keep connection alive after page unloads (not supported) */
+  keepalive?: boolean;
+  /** Disable automatic content decoding and suppress Accept-Encoding injection */
+  decompress?: boolean;
+  /** Connect over a Unix domain socket instead of TCP. Bun compatibility extension. */
+  unix?: string;
+  /** Configure TLS certificate validation for HTTPS requests. Bun compatibility extension. */
+  tls?: FetchTlsOptions;
+}
+
+// =============================================================================
+// Response Types
+// =============================================================================
+
+export type ResponseType =
+  | 'basic'
+  | 'cors'
+  | 'default'
+  | 'error'
+  | 'opaque'
+  | 'opaqueredirect';
+
+/**
+ * Response initialization options.
+ */
+export interface ResponseInit {
+  /** HTTP status code */
+  status?: number;
+  /** HTTP status text */
+  statusText?: string;
+  /** Response headers */
+  headers?: HeadersInit;
+}
+
+// =============================================================================
+// Headers Types
+// =============================================================================
+
+export type HeadersInit =
+  | Headers
+  | Record<string, string>
+  | Iterable<[string, string]>
+  | [string, string][];
+
+// =============================================================================
+// Body Types
+// =============================================================================
+
+export type BodyInit =
+  | Blob
+  | BufferSource
+  | FormData
+  | URLSearchParams
+  | ReadableStream<Uint8Array>
+  | string;
+
+export type BufferSource = ArrayBuffer | ArrayBufferView;
+
+// =============================================================================
+// Native Bridge Types
+// =============================================================================
+
+/**
+ * Native request initialization passed to the native layer.
+ */
+export interface NativeRequestInit {
+  method: string;
+  headers: [string, string][];
+  credentials: RequestCredentials;
+  redirect: RequestRedirect;
+  decompress?: boolean;
+  signal?: AbortSignal | null;
+}
+
+/**
+ * Native response data returned from the native layer.
+ */
+export interface NativeResponse {
+  status: number;
+  statusText: string;
+  headers: [string, string][];
+  url: string;
+  redirected: boolean;
+  body: ArrayBuffer | null;
+}
+
+/**
+ * Native streaming response data.
+ */
+export interface NativeStreamingResponse {
+  status: number;
+  statusText: string;
+  headers: [string, string][];
+  url: string;
+  redirected: boolean;
+}
+
+/**
+ * Interface for the native fetch module.
+ * This will be implemented by the native layer (Swift/Kotlin/Rust).
+ */
+export interface NativeFetchModule {
+  /** Internal marker for the real native bridge implementation. */
+  __exactNativeBridge?: boolean;
+  /**
+   * Perform a fetch request.
+   * @param url The request URL
+   * @param init Request options
+   * @param body Request body as Uint8Array (if any)
+   * @returns Promise resolving to native response
+   */
+  fetch(
+    url: string,
+    init: NativeRequestInit,
+    body: Uint8Array | null
+  ): Promise<NativeResponse>;
+
+  /**
+   * Perform a streaming fetch request.
+   * @param url The request URL
+   * @param init Request options
+   * @param body Request body as Uint8Array (if any)
+   * @param onHeaders Callback when headers are received
+   * @param onData Callback when data chunk is received
+   * @param onComplete Callback when response is complete
+   * @param onError Callback when error occurs
+   * @returns Function to cancel the request
+   */
+  fetchStreaming?(
+    url: string,
+    init: NativeRequestInit,
+    body: Uint8Array | null,
+    onHeaders: (response: NativeStreamingResponse) => void,
+    onData: (chunk: Uint8Array) => void,
+    onComplete: () => void,
+    onError: (error: Error) => void
+  ): () => void;
+
+  /**
+   * Perform a fetch request with a streaming upload body.
+   * The native layer calls onBodyChunk repeatedly to pull body chunks,
+   * receiving null when the body is fully sent.
+   *
+   * Per spec (half-duplex): the request body is fully sent before
+   * the response starts streaming.
+   *
+   * @param url The request URL
+   * @param init Request options
+   * @param onBodyChunk Async callback that returns the next body chunk,
+   *   or null when the body is complete
+   * @param onHeaders Callback when response headers are received
+   * @param onData Callback when response data chunk is received
+   * @param onComplete Callback when response is complete
+   * @param onError Callback when error occurs
+   * @returns Function to cancel the request
+   */
+  fetchStreamingUpload?(
+    url: string,
+    init: NativeRequestInit,
+    onBodyChunk: () => Promise<Uint8Array | null>,
+    onHeaders: (response: NativeStreamingResponse) => void,
+    onData: (chunk: Uint8Array) => void,
+    onComplete: () => void,
+    onError: (error: Error) => void
+  ): () => void;
+}

package/src/filereader/FileReader.ts

@@ -0,0 +1,236 @@
+// @ts-nocheck
+/**
+ * FileReader implementation for Ibex runtime (Legacy API)
+ * 
+ * @see https://w3c.github.io/FileAPI/#dfn-filereader
+ * 
+ * Note: Modern code should use Blob.arrayBuffer(), Blob.text(), etc.
+ * This is provided for compatibility with legacy libraries.
+ */
+
+import { EventTarget } from '../events/EventTarget';
+import { Event } from '../events/Event';
+import { ProgressEvent } from '../events/ProgressEvent';
+import { DOMException, createInvalidStateError, createNotSupportedError } from '../events/DOMException';
+import { Blob } from '../blob/Blob';
+
+// FileReader states
+const EMPTY = 0;
+const LOADING = 1;
+const DONE = 2;
+
+/**
+ * FileReader enables asynchronous reading of file or blob contents.
+ */
+export class FileReader extends EventTarget {
+  static readonly EMPTY = EMPTY;
+  static readonly LOADING = LOADING;
+  static readonly DONE = DONE;
+
+  readonly EMPTY = EMPTY;
+  readonly LOADING = LOADING;
+  readonly DONE = DONE;
+
+  #readyState: number = EMPTY;
+  #result: string | ArrayBuffer | null = null;
+  #error: DOMException | null = null;
+  #aborted = false;
+
+  // Event handlers
+  onloadstart: ((this: FileReader, ev: ProgressEvent) => any) | null = null;
+  onprogress: ((this: FileReader, ev: ProgressEvent) => any) | null = null;
+  onload: ((this: FileReader, ev: ProgressEvent) => any) | null = null;
+  onabort: ((this: FileReader, ev: ProgressEvent) => any) | null = null;
+  onerror: ((this: FileReader, ev: ProgressEvent) => any) | null = null;
+  onloadend: ((this: FileReader, ev: ProgressEvent) => any) | null = null;
+
+  get readyState(): number {
+    return this.#readyState;
+  }
+
+  get result(): string | ArrayBuffer | null {
+    return this.#result;
+  }
+
+  get error(): DOMException | null {
+    return this.#error;
+  }
+
+  /**
+   * Check if reader is ready to start a new read operation.
+   * Throws InvalidStateError if already loading.
+   */
+  #checkReadyState(): void {
+    if (this.#readyState === LOADING) {
+      throw createInvalidStateError('FileReader is already loading');
+    }
+  }
+
+  /**
+   * Read blob as ArrayBuffer.
+   */
+  readAsArrayBuffer(blob: Blob): void {
+    this.#checkReadyState();
+    this.#read(blob, 'arraybuffer');
+  }
+
+  /**
+   * Read blob as binary string.
+   * @deprecated Use readAsArrayBuffer instead.
+   */
+  readAsBinaryString(blob: Blob): void {
+    this.#checkReadyState();
+    this.#read(blob, 'binarystring');
+  }
+
+  /**
+   * Read blob as text.
+   */
+  readAsText(blob: Blob, encoding?: string): void {
+    this.#checkReadyState();
+    this.#read(blob, 'text', encoding);
+  }
+
+  /**
+   * Read blob as data URL.
+   */
+  readAsDataURL(blob: Blob): void {
+    this.#checkReadyState();
+    this.#read(blob, 'dataurl');
+  }
+
+  /**
+   * Abort the read operation.
+   */
+  abort(): void {
+    if (this.#readyState === EMPTY || this.#readyState === DONE) {
+      this.#result = null;
+      return;
+    }
+
+    if (this.#readyState === LOADING) {
+      this.#readyState = DONE;
+      this.#result = null;
+      this.#aborted = true;
+
+      this.#fireEvent('abort');
+      this.#fireEvent('loadend');
+    }
+  }
+
+  /**
+   * Internal read implementation.
+   */
+  async #read(blob: Blob, format: 'arraybuffer' | 'binarystring' | 'text' | 'dataurl', encoding?: string): Promise<void> {
+    // State check is done in #checkReadyState() before calling this method
+    this.#readyState = LOADING;
+    this.#result = null;
+    this.#error = null;
+    this.#aborted = false;
+
+    this.#fireProgressEvent('loadstart', 0, blob.size);
+
+    try {
+      // Read the blob data
+      const buffer = await blob.arrayBuffer();
+      
+      if (this.#aborted) {
+        return;
+      }
+
+      // Fire progress event
+      this.#fireProgressEvent('progress', buffer.byteLength, blob.size);
+
+      // Convert to requested format
+      switch (format) {
+        case 'arraybuffer':
+          this.#result = buffer;
+          break;
+
+        case 'binarystring': {
+          const bytes = new Uint8Array(buffer);
+          let result = '';
+          for (let i = 0; i < bytes.length; i++) {
+            result += String.fromCharCode(bytes[i]);
+          }
+          this.#result = result;
+          break;
+        }
+
+        case 'text': {
+          const decoder = new TextDecoder(encoding || 'utf-8');
+          this.#result = decoder.decode(buffer);
+          break;
+        }
+
+        case 'dataurl': {
+          const bytes = new Uint8Array(buffer);
+          let binary = '';
+          for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          const base64 = btoa(binary);
+          const mimeType = blob.type || 'application/octet-stream';
+          this.#result = `data:${mimeType};base64,${base64}`;
+          break;
+        }
+      }
+
+      this.#readyState = DONE;
+      this.#fireProgressEvent('load', buffer.byteLength, blob.size);
+      this.#fireProgressEvent('loadend', buffer.byteLength, blob.size);
+
+    } catch (err) {
+      if (this.#aborted) {
+        return;
+      }
+
+      this.#readyState = DONE;
+      this.#error = new DOMException(
+        err instanceof Error ? err.message : 'Read failed',
+        'NotReadableError'
+      );
+      
+      this.#fireProgressEvent('error', 0, blob.size);
+      this.#fireProgressEvent('loadend', 0, blob.size);
+    }
+  }
+
+  /**
+   * Fire a simple event.
+   */
+  #fireEvent(type: string): void {
+    const event = new Event(type);
+    
+    const handler = (this as any)[`on${type}`];
+    if (handler) {
+      handler.call(this, event);
+    }
+    
+    this.dispatchEvent(event);
+  }
+
+  /**
+   * Fire a progress event.
+   */
+  #fireProgressEvent(type: string, loaded: number, total: number): void {
+    const event = new ProgressEvent(type, {
+      lengthComputable: total > 0,
+      loaded,
+      total,
+    });
+
+    const handler = (this as any)[`on${type}`];
+    if (handler) {
+      handler.call(this, event);
+    }
+
+    this.dispatchEvent(event);
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'FileReader';
+  }
+}
+
+export default FileReader;

package/src/filereader/index.ts

@@ -0,0 +1 @@
+export { FileReader } from './FileReader';

package/src/fs/Dirent.ts

@@ -0,0 +1,39 @@
+import { Stats } from './Stats';
+
+export class Dirent {
+  readonly name: string;
+  private readonly stats: Stats;
+
+  constructor(name: string, stats: Stats) {
+    this.name = name;
+    this.stats = stats;
+  }
+
+  isFile(): boolean {
+    return this.stats.isFile();
+  }
+
+  isDirectory(): boolean {
+    return this.stats.isDirectory();
+  }
+
+  isBlockDevice(): boolean {
+    return this.stats.isBlockDevice();
+  }
+
+  isCharacterDevice(): boolean {
+    return this.stats.isCharacterDevice();
+  }
+
+  isSymbolicLink(): boolean {
+    return this.stats.isSymbolicLink();
+  }
+
+  isFIFO(): boolean {
+    return this.stats.isFIFO();
+  }
+
+  isSocket(): boolean {
+    return this.stats.isSocket();
+  }
+}