@ccheever/exact-ibex-runtime 0.1.0

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@ccheever/exact-ibex-runtime",
+  "version": "0.1.0",
+  "description": "JavaScript runtime and polyfill layer for Ibex",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    },
+    "./bootstrap": {
+      "import": "./src/bootstrap.ts",
+      "types": "./src/bootstrap.ts"
+    },
+    "./camera": {
+      "import": "./src/camera/index.ts",
+      "types": "./src/camera/index.ts"
+    },
+    "./events": {
+      "import": "./src/events/index.ts",
+      "types": "./src/events/index.ts"
+    },
+    "./fetch": {
+      "import": "./src/fetch/index.ts",
+      "types": "./src/fetch/index.ts"
+    },
+    "./fetch/native-bridge": {
+      "import": "./src/fetch/native-bridge.ts",
+      "types": "./src/fetch/native-bridge.ts"
+    },
+    "./http-server": {
+      "import": "./src/http-server/index.js",
+      "types": "./src/http-server/index.ts"
+    },
+    "./internal/detect": {
+      "import": "./src/internal/detect.ts",
+      "types": "./src/internal/detect.ts"
+    },
+    "./location": {
+      "import": "./src/location/index.ts",
+      "types": "./src/location/index.ts"
+    },
+    "./react-native": {
+      "import": "./src/react-native/index.ts",
+      "types": "./src/react-native/index.ts"
+    },
+    "./runtime-entry": {
+      "import": "./src/runtime-entry.ts",
+      "types": "./src/runtime-entry.ts"
+    },
+    "./security": {
+      "import": "./src/security/index.ts",
+      "types": "./src/security/index.ts"
+    },
+    "./security/Permissions": {
+      "import": "./src/security/Permissions.ts",
+      "types": "./src/security/Permissions.ts"
+    }
+  },
+  "dependencies": {}
+}

package/src/abort/AbortController.ts

@@ -0,0 +1,23 @@
+/**
+ * AbortController - Web Standard AbortController Implementation
+ *
+ * @see https://dom.spec.whatwg.org/#interface-abortcontroller
+ */
+
+import { AbortSignal } from "./AbortSignal";
+
+export class AbortController {
+  private _signal: AbortSignal;
+
+  constructor() {
+    this._signal = new AbortSignal();
+  }
+
+  get signal(): AbortSignal {
+    return this._signal;
+  }
+
+  abort(reason?: any): void {
+    (this._signal as any)._abort(reason);
+  }
+}

package/src/abort/AbortSignal.ts

@@ -0,0 +1,152 @@
+/**
+ * AbortSignal - Web Standard AbortSignal Implementation
+ *
+ * @see https://dom.spec.whatwg.org/#interface-abortsignal
+ */
+
+import { Event, EventTarget } from "../events";
+import { DOMException } from "../events";
+
+const ABORT_SIGNAL_BRAND = Symbol.for("@exact/AbortSignal");
+
+export function isAbortSignal(value: unknown): value is AbortSignal {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  if ((value as { [ABORT_SIGNAL_BRAND]?: true })[ABORT_SIGNAL_BRAND] === true) {
+    return true;
+  }
+
+  try {
+    return (
+      typeof (value as { aborted?: unknown }).aborted === "boolean" &&
+      "reason" in (value as object) &&
+      typeof (value as { addEventListener?: unknown }).addEventListener === "function" &&
+      typeof (value as { removeEventListener?: unknown }).removeEventListener === "function"
+    );
+  } catch {
+    return false;
+  }
+}
+
+export class AbortSignal extends EventTarget {
+  private [ABORT_SIGNAL_BRAND] = true;
+
+  private _aborted: boolean = false;
+  private _reason: any = undefined;
+
+  // Event handler property
+  onabort: ((this: AbortSignal, ev: Event) => any) | null = null;
+
+  constructor() {
+    super();
+    // Private constructor - use static methods or AbortController
+  }
+
+  get aborted(): boolean {
+    return this._aborted;
+  }
+
+  get reason(): any {
+    return this._reason;
+  }
+
+  throwIfAborted(): void {
+    if (this._aborted) {
+      throw this._reason;
+    }
+  }
+
+  /**
+   * Abort the signal
+   * @internal - Called by AbortController
+   */
+  _abort(reason?: any): void {
+    if (this._aborted) return;
+
+    this._aborted = true;
+    this._reason =
+      reason === undefined
+        ? new DOMException("The operation was aborted.", "AbortError")
+        : reason;
+
+    // Dispatch abort event
+    const event = new Event("abort");
+    
+    // Call handler property
+    if (this.onabort) {
+      try {
+        this.onabort.call(this, event);
+      } catch (e) {
+        console.error("Error in onabort handler:", e);
+      }
+    }
+
+    // Dispatch to listeners
+    this.dispatchEvent(event);
+  }
+
+  /**
+   * Create an already-aborted signal
+   */
+  static abort(reason?: any): AbortSignal {
+    const signal = new AbortSignal();
+    signal._abort(reason);
+    return signal;
+  }
+
+  /**
+   * Create a signal that aborts after a timeout
+   */
+  static timeout(milliseconds: number): AbortSignal {
+    const signal = new AbortSignal();
+
+    setTimeout(() => {
+      signal._abort(new DOMException("The operation timed out.", "TimeoutError"));
+    }, milliseconds);
+
+    return signal;
+  }
+
+  /**
+   * Create a signal that aborts when any of the given signals abort
+   */
+  static any(signals: AbortSignal[]): AbortSignal {
+    const signal = new AbortSignal();
+
+    // Check if any signal is already aborted
+    for (const s of signals) {
+      if (s.aborted) {
+        signal._abort(s.reason);
+        return signal;
+      }
+    }
+
+    // Listen for abort on all signals
+    const listeners = new Map<AbortSignal, () => void>();
+    const cleanup = () => {
+      for (const [source, listener] of listeners) {
+        source.removeEventListener("abort", listener);
+      }
+      listeners.clear();
+    };
+
+    const onAbort = () => {
+      for (const s of signals) {
+        if (s.aborted) {
+          cleanup();
+          signal._abort(s.reason);
+          break;
+        }
+      }
+    };
+
+    for (const s of signals) {
+      listeners.set(s, onAbort);
+      s.addEventListener("abort", onAbort, { once: true });
+    }
+
+    return signal;
+  }
+}

package/src/abort/index.ts

@@ -0,0 +1,2 @@
+export { AbortController } from "./AbortController";
+export { AbortSignal } from "./AbortSignal";

package/src/accessibility.ts

@@ -0,0 +1,12 @@
+export {
+  _resetExactAccessibilityForTests,
+  announceForAccessibility,
+  focusElementForAccessibility,
+  getExactAccessibilitySnapshot,
+  installExactAccessibilityGlobal,
+  refreshExactAccessibility,
+  subscribeExactAccessibilityChanges,
+  type AccessibilityInfoEvent,
+  type AccessibilityInfoKey,
+  type ExactAccessibilitySnapshot,
+} from "./core/accessibility.js";

package/src/arraybuffer-detach.ts

@@ -0,0 +1,109 @@
+const DETACHED_ARRAY_BUFFERS = Symbol.for("exact.detachedArrayBuffers");
+const NON_TRANSFERABLE_ARRAY_BUFFERS = Symbol.for("exact.nonTransferableArrayBuffers");
+const PATCHED_ARRAY_BUFFER_BYTE_LENGTH = Symbol.for("exact.patchedArrayBufferByteLength");
+
+function getDetachedArrayBuffers(): WeakSet<ArrayBuffer> | null {
+  if (typeof WeakSet !== "function") {
+    return null;
+  }
+  const globalObject = globalThis as any;
+  let detached = globalObject[DETACHED_ARRAY_BUFFERS] as WeakSet<ArrayBuffer> | undefined;
+  if (!detached) {
+    detached = new WeakSet<ArrayBuffer>();
+    globalObject[DETACHED_ARRAY_BUFFERS] = detached;
+  }
+  return detached;
+}
+
+function getNonTransferableArrayBuffers(): WeakSet<ArrayBuffer> | null {
+  if (typeof WeakSet !== "function") {
+    return null;
+  }
+  const globalObject = globalThis as any;
+  let buffers = globalObject[NON_TRANSFERABLE_ARRAY_BUFFERS] as WeakSet<ArrayBuffer> | undefined;
+  if (!buffers) {
+    buffers = new WeakSet<ArrayBuffer>();
+    globalObject[NON_TRANSFERABLE_ARRAY_BUFFERS] = buffers;
+  }
+  return buffers;
+}
+
+function installDetachedArrayBufferByteLengthPatch(): void {
+  const proto = ArrayBuffer.prototype as ArrayBuffer & {
+    [PATCHED_ARRAY_BUFFER_BYTE_LENGTH]?: boolean;
+  };
+  if (proto[PATCHED_ARRAY_BUFFER_BYTE_LENGTH]) {
+    return;
+  }
+
+  const descriptor = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength");
+  if (!descriptor?.get) {
+    return;
+  }
+
+  try {
+    Object.defineProperty(ArrayBuffer.prototype, "byteLength", {
+      get: function byteLength(this: ArrayBuffer): number {
+        if (getDetachedArrayBuffers()?.has(this)) {
+          return 0;
+        }
+        return descriptor.get!.call(this);
+      },
+      enumerable: descriptor.enumerable ?? false,
+      configurable: descriptor.configurable ?? true,
+    });
+    Object.defineProperty(proto, PATCHED_ARRAY_BUFFER_BYTE_LENGTH, {
+      value: true,
+      configurable: true,
+    });
+  } catch (_error) {
+    // Environments that refuse to patch the prototype will continue to rely
+    // on the WeakSet-based detached tracking.
+  }
+}
+
+installDetachedArrayBufferByteLengthPatch();
+
+export function isDetachedArrayBuffer(buffer: ArrayBuffer): boolean {
+  const detached = getDetachedArrayBuffers();
+  if (detached?.has(buffer)) {
+    return true;
+  }
+  if (buffer.byteLength !== 0) {
+    return false;
+  }
+  try {
+    new Uint8Array(buffer);
+    return false;
+  } catch (_error) {
+    return true;
+  }
+}
+
+export function markDetachedArrayBuffer(buffer: ArrayBuffer): void {
+  const byteLength = buffer.byteLength;
+  if (byteLength > 0) {
+    new Uint8Array(buffer).fill(0);
+  }
+  const detached = getDetachedArrayBuffers();
+  detached?.add(buffer);
+  try {
+    Object.defineProperty(buffer, "byteLength", {
+      value: 0,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+    });
+  } catch (_error) {
+    // Fall back to the WeakSet-based detached tracking when ArrayBuffer
+    // instances reject own-property shadowing for byteLength.
+  }
+}
+
+export function isNonTransferableArrayBuffer(buffer: ArrayBuffer): boolean {
+  return getNonTransferableArrayBuffers()?.has(buffer) ?? false;
+}
+
+export function markNonTransferableArrayBuffer(buffer: ArrayBuffer): void {
+  getNonTransferableArrayBuffers()?.add(buffer);
+}

package/src/base64/base64.ts

@@ -0,0 +1,168 @@
+/**
+ * Base64 Encoding - atob/btoa
+ *
+ * @see https://html.spec.whatwg.org/multipage/webappapis.html#atob
+ *
+ * Note: These only handle Latin-1 (bytes 0-255).
+ * For Unicode, use TextEncoder first.
+ */
+
+// Base64 character set
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+// Reverse lookup table
+const BASE64_LOOKUP = new Uint8Array(256);
+for (let i = 0; i < BASE64_CHARS.length; i++) {
+  BASE64_LOOKUP[BASE64_CHARS.charCodeAt(i)] = i;
+}
+BASE64_LOOKUP["=".charCodeAt(0)] = 0; // Padding
+
+/**
+ * btoa - Encode a binary string to Base64
+ *
+ * @param data Binary string (each char code must be 0-255)
+ * @returns Base64 encoded string
+ * @throws DOMException if string contains characters outside Latin-1
+ */
+export function btoa(data: string): string {
+  if (data === undefined || data === null) {
+    data = "undefined";
+  }
+
+  const str = String(data);
+  const bytes: number[] = [];
+
+  for (let i = 0; i < str.length; i++) {
+    const charCode = str.charCodeAt(i);
+    if (charCode > 255) {
+      throw new DOMException(
+        "The string to be encoded contains characters outside of the Latin1 range.",
+        "InvalidCharacterError"
+      );
+    }
+    bytes.push(charCode);
+  }
+
+  // Encode to Base64
+  let result = "";
+  let i = 0;
+
+  while (i < bytes.length) {
+    const b1 = bytes[i++] ?? 0;
+    const b2 = bytes[i++];
+    const b3 = bytes[i++];
+
+    result += BASE64_CHARS[b1 >> 2];
+    result += BASE64_CHARS[((b1 & 0x03) << 4) | ((b2 ?? 0) >> 4)];
+
+    if (b2 !== undefined) {
+      result += BASE64_CHARS[((b2 & 0x0f) << 2) | ((b3 ?? 0) >> 6)];
+    } else {
+      result += "=";
+    }
+
+    if (b3 !== undefined) {
+      result += BASE64_CHARS[b3 & 0x3f];
+    } else {
+      result += "=";
+    }
+  }
+
+  return result;
+}
+
+/**
+ * atob - Decode a Base64 string to binary
+ *
+ * @param data Base64 encoded string
+ * @returns Decoded binary string
+ * @throws DOMException if string is not valid Base64
+ */
+export function atob(data: string): string {
+  if (data === undefined || data === null) {
+    throw new DOMException(
+      "The string to be decoded is not correctly encoded.",
+      "InvalidCharacterError"
+    );
+  }
+
+  // Step 1: Strip ASCII whitespace (0x09, 0x0A, 0x0C, 0x0D, 0x20)
+  let str = "";
+  const raw = String(data);
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw.charCodeAt(i);
+    if (c !== 0x09 && c !== 0x0a && c !== 0x0c && c !== 0x0d && c !== 0x20) {
+      str += raw[i];
+    }
+  }
+
+  if (str.length === 0) {
+    return "";
+  }
+
+  // Step 2: If length mod 4 === 0, strip up to 2 trailing '='
+  let len = str.length;
+  if (len % 4 === 0) {
+    if (str[len - 1] === "=") { len--; }
+    if (str[len - 1] === "=") { len--; }
+    str = str.slice(0, len);
+  }
+
+  // Step 3: If remaining length mod 4 === 1, throw
+  if (str.length % 4 === 1) {
+    throw new DOMException(
+      "The string to be decoded is not correctly encoded.",
+      "InvalidCharacterError"
+    );
+  }
+
+  // Step 4: Validate characters - only [A-Za-z0-9+/] allowed (no '=' at this point)
+  for (let i = 0; i < str.length; i++) {
+    if (!BASE64_CHARS.includes(str[i])) {
+      throw new DOMException(
+        "The string to be decoded is not correctly encoded.",
+        "InvalidCharacterError"
+      );
+    }
+  }
+
+  // Step 5: Pad with '=' to make length a multiple of 4
+  const remainder = str.length % 4;
+  if (remainder === 2) {
+    str += "==";
+  } else if (remainder === 3) {
+    str += "=";
+  }
+
+  // Decode
+  const result: number[] = [];
+  let i = 0;
+
+  while (i < str.length) {
+    const c1 = BASE64_LOOKUP[str.charCodeAt(i++)];
+    const c2 = BASE64_LOOKUP[str.charCodeAt(i++)];
+    const c3 = BASE64_LOOKUP[str.charCodeAt(i++)];
+    const c4 = BASE64_LOOKUP[str.charCodeAt(i++)];
+
+    result.push((c1 << 2) | (c2 >> 4));
+
+    if (str[i - 2] !== "=") {
+      result.push(((c2 & 0x0f) << 4) | (c3 >> 2));
+    }
+
+    if (str[i - 1] !== "=") {
+      result.push(((c3 & 0x03) << 6) | c4);
+    }
+  }
+
+  return String.fromCharCode(...result);
+}
+
+// DOMException for this module (avoid circular dependency)
+class DOMException extends Error {
+  readonly code: number = 0;
+  constructor(message: string, name: string) {
+    super(message);
+    this.name = name;
+  }
+}

package/src/base64/index.ts

@@ -0,0 +1 @@
+export { atob, btoa } from "./base64";