@ccheever/exact-ibex-runtime 0.1.0

package/src/react-native/index.ts

@@ -0,0 +1,388 @@
+import { detectPlatform } from '../internal/detect';
+import { window as exactWindow } from '../window';
+
+type AppStateStatus = 'active' | 'background' | 'inactive' | 'unknown';
+type ColorSchemeName = 'light' | 'dark' | null | undefined;
+type PlatformOS =
+  | 'ios'
+  | 'android'
+  | 'macos'
+  | 'windows'
+  | 'linux'
+  | 'web'
+  | 'native'
+  | 'unknown';
+
+interface EmitterSubscription {
+  remove(): void;
+}
+
+interface ScaledSize {
+  width: number;
+  height: number;
+  scale: number;
+  fontScale: number;
+}
+
+interface DimensionsValue {
+  window: ScaledSize;
+  screen: ScaledSize;
+}
+
+interface DimensionsChangePayload {
+  window: ScaledSize;
+  screen: ScaledSize;
+}
+
+interface AppearancePreferences {
+  colorScheme: ColorSchemeName;
+}
+
+interface AppearanceChangePayload {
+  colorScheme: ColorSchemeName;
+}
+
+interface LinkingUrlEvent {
+  url: string;
+}
+
+type DimensionsChangeHandler = (payload: DimensionsChangePayload) => void;
+type AppearanceChangeHandler = (payload: AppearanceChangePayload) => void;
+type AppStateChangeHandler = (state: AppStateStatus) => void;
+type AppStateEventHandler = () => void;
+type LinkingUrlHandler = (event: LinkingUrlEvent) => void;
+
+type PlatformSelectSpec<T> = Partial<Record<PlatformOS | 'default', T>>;
+
+declare global {
+  var __exactInitialURL: string | null | undefined;
+  var __exactOpenURL:
+    | ((url: string) => boolean | void | Promise<boolean | void>)
+    | undefined;
+  var __exactCanOpenURL:
+    | ((url: string) => boolean | Promise<boolean>)
+    | undefined;
+  var __exactReactNativeNotifyURL:
+    | ((url: string) => void)
+    | undefined;
+  var __exactReactNativeNotifyAppState:
+    | ((state: AppStateStatus) => void)
+    | undefined;
+  var __exactReactNativeNotifyMemoryWarning:
+    | (() => void)
+    | undefined;
+  var __exactReactNativeNotifyDimensionsChange:
+    | ((next?: Partial<DimensionsValue>) => void)
+    | undefined;
+  var __exactAppState: AppStateStatus | undefined;
+}
+
+function normalizePlatform(value: string): PlatformOS {
+  const normalized = value.toLowerCase();
+  if (normalized === 'darwin' || normalized === 'mac') {
+    return 'macos';
+  }
+  if (normalized === 'win32') {
+    return 'windows';
+  }
+  if (
+    normalized === 'ios' ||
+    normalized === 'android' ||
+    normalized === 'macos' ||
+    normalized === 'windows' ||
+    normalized === 'linux' ||
+    normalized === 'web' ||
+    normalized === 'native'
+  ) {
+    return normalized;
+  }
+  return 'unknown';
+}
+
+function currentPlatform(): PlatformOS {
+  return normalizePlatform(detectPlatform());
+}
+
+function screenInfo(): ScaledSize {
+  const nativeInfo =
+    typeof globalThis.__exactGetScreenInfo === 'function'
+      ? globalThis.__exactGetScreenInfo()
+      : null;
+
+  return {
+    width: nativeInfo?.width ?? exactWindow.innerWidth,
+    height: nativeInfo?.height ?? exactWindow.innerHeight,
+    scale: nativeInfo?.scale ?? exactWindow.devicePixelRatio,
+    fontScale: nativeInfo?.fontScale ?? 1,
+  };
+}
+
+function currentDimensions(): DimensionsValue {
+  const current = screenInfo();
+  return {
+    window: { ...current },
+    screen: { ...current },
+  };
+}
+
+function normalizeDimensions(next?: Partial<DimensionsValue>): DimensionsValue {
+  const fallback = currentDimensions();
+  return {
+    window: { ...fallback.window, ...next?.window },
+    screen: { ...fallback.screen, ...next?.screen },
+  };
+}
+
+const dimensionsListeners = new Set<DimensionsChangeHandler>();
+let lastDimensions = currentDimensions();
+
+function notifyDimensions(next?: Partial<DimensionsValue>): void {
+  lastDimensions = normalizeDimensions(next);
+  const payload: DimensionsChangePayload = {
+    window: { ...lastDimensions.window },
+    screen: { ...lastDimensions.screen },
+  };
+  for (const listener of [...dimensionsListeners]) {
+    listener(payload);
+  }
+}
+
+globalThis.__exactReactNativeNotifyDimensionsChange = notifyDimensions;
+
+export const Dimensions = {
+  get(dimension: 'window' | 'screen'): ScaledSize {
+    const dimensions = currentDimensions();
+    return { ...dimensions[dimension] };
+  },
+  addEventListener(
+    eventType: 'change',
+    handler: DimensionsChangeHandler,
+  ): EmitterSubscription {
+    if (eventType !== 'change') {
+      return { remove() {} };
+    }
+    dimensionsListeners.add(handler);
+    return {
+      remove() {
+        dimensionsListeners.delete(handler);
+      },
+    };
+  },
+  removeEventListener(
+    eventType: 'change',
+    handler: DimensionsChangeHandler,
+  ): void {
+    if (eventType === 'change') {
+      dimensionsListeners.delete(handler);
+    }
+  },
+};
+
+export const Platform = {
+  get OS(): PlatformOS {
+    return currentPlatform();
+  },
+  get Version(): string {
+    const runtime = globalThis as { __exactPlatformVersion?: unknown };
+    return typeof runtime.__exactPlatformVersion === 'string'
+      ? runtime.__exactPlatformVersion
+      : '0';
+  },
+  get isPad(): boolean {
+    const dimensions = Dimensions.get('screen');
+    return Platform.OS === 'ios' && Math.min(dimensions.width, dimensions.height) >= 768;
+  },
+  get isTV(): boolean {
+    return false;
+  },
+  get isTesting(): boolean {
+    return Boolean((globalThis as { __exactIsTesting?: unknown }).__exactIsTesting);
+  },
+  select<T>(spec: PlatformSelectSpec<T>): T | undefined {
+    const os = Platform.OS;
+    return spec[os] ?? spec.default;
+  },
+};
+
+function currentColorScheme(): ColorSchemeName {
+  const state = globalThis.__exactAppearanceState;
+  return state?.colorScheme === 'dark' ? 'dark' : 'light';
+}
+
+const appearanceListeners = new Set<AppearanceChangeHandler>();
+const previousAppearanceNotifier = globalThis.__exactWindowNotifyMediaChange;
+
+function notifyAppearance(next: AppearancePreferences): void {
+  previousAppearanceNotifier?.({
+    colorScheme: next.colorScheme === 'dark' ? 'dark' : 'light',
+  });
+  const payload = { colorScheme: currentColorScheme() };
+  for (const listener of [...appearanceListeners]) {
+    listener(payload);
+  }
+}
+
+globalThis.__exactWindowNotifyMediaChange = (next) => {
+  previousAppearanceNotifier?.(next);
+  const payload = { colorScheme: currentColorScheme() };
+  for (const listener of [...appearanceListeners]) {
+    listener(payload);
+  }
+};
+
+export const Appearance = {
+  getColorScheme(): ColorSchemeName {
+    return currentColorScheme();
+  },
+  addChangeListener(listener: AppearanceChangeHandler): EmitterSubscription {
+    appearanceListeners.add(listener);
+    return {
+      remove() {
+        appearanceListeners.delete(listener);
+      },
+    };
+  },
+  removeChangeListener(listener: AppearanceChangeHandler): void {
+    appearanceListeners.delete(listener);
+  },
+  setColorScheme(colorScheme: ColorSchemeName): void {
+    notifyAppearance({ colorScheme });
+  },
+};
+
+const appStateChangeListeners = new Set<AppStateChangeHandler>();
+const appStateFocusListeners = new Set<AppStateEventHandler>();
+const appStateBlurListeners = new Set<AppStateEventHandler>();
+const appStateMemoryWarningListeners = new Set<AppStateEventHandler>();
+
+function normalizeAppState(state: unknown): AppStateStatus {
+  return state === 'active' || state === 'background' || state === 'inactive'
+    ? state
+    : 'unknown';
+}
+
+let currentAppState: AppStateStatus = normalizeAppState(globalThis.__exactAppState) === 'unknown'
+  ? 'active'
+  : normalizeAppState(globalThis.__exactAppState);
+
+function notifyAppState(state: AppStateStatus): void {
+  const previous = currentAppState;
+  currentAppState = normalizeAppState(state);
+  globalThis.__exactAppState = currentAppState;
+
+  if (previous !== currentAppState) {
+    for (const listener of [...appStateChangeListeners]) {
+      listener(currentAppState);
+    }
+  }
+  if (currentAppState === 'active' && previous !== 'active') {
+    for (const listener of [...appStateFocusListeners]) {
+      listener();
+    }
+  }
+  if (currentAppState !== 'active' && previous === 'active') {
+    for (const listener of [...appStateBlurListeners]) {
+      listener();
+    }
+  }
+}
+
+globalThis.__exactReactNativeNotifyAppState = notifyAppState;
+globalThis.__exactReactNativeNotifyMemoryWarning = () => {
+  for (const listener of [...appStateMemoryWarningListeners]) {
+    listener();
+  }
+};
+
+export const AppState = {
+  get currentState(): AppStateStatus {
+    return currentAppState;
+  },
+  addEventListener(
+    type: 'change' | 'focus' | 'blur' | 'memoryWarning',
+    listener: AppStateChangeHandler | AppStateEventHandler,
+  ): EmitterSubscription {
+    const target =
+      type === 'change'
+        ? appStateChangeListeners
+        : type === 'focus'
+          ? appStateFocusListeners
+          : type === 'blur'
+            ? appStateBlurListeners
+            : appStateMemoryWarningListeners;
+    target.add(listener as never);
+    return {
+      remove() {
+        target.delete(listener as never);
+      },
+    };
+  },
+};
+
+const linkingListeners = new Set<LinkingUrlHandler>();
+
+function notifyURL(url: string): void {
+  for (const listener of [...linkingListeners]) {
+    listener({ url });
+  }
+}
+
+globalThis.__exactReactNativeNotifyURL = notifyURL;
+
+function normalizeURL(url: string): string {
+  if (url.length === 0) {
+    return exactWindow.location.href;
+  }
+  try {
+    return new URL(url, exactWindow.location.href).href;
+  } catch {
+    return url;
+  }
+}
+
+export const Linking = {
+  async canOpenURL(url: string): Promise<boolean> {
+    if (typeof globalThis.__exactCanOpenURL === 'function') {
+      return Boolean(await globalThis.__exactCanOpenURL(url));
+    }
+    return /^(exact|https?|mailto|tel|sms):/i.test(url);
+  },
+  async openURL(url: string): Promise<void> {
+    if (typeof globalThis.__exactOpenURL === 'function') {
+      await globalThis.__exactOpenURL(url);
+    } else {
+      exactWindow.location.assign(normalizeURL(url));
+    }
+    notifyURL(normalizeURL(url));
+  },
+  async getInitialURL(): Promise<string | null> {
+    return globalThis.__exactInitialURL ?? null;
+  },
+  addEventListener(
+    type: 'url',
+    handler: LinkingUrlHandler,
+  ): EmitterSubscription {
+    if (type !== 'url') {
+      return { remove() {} };
+    }
+    linkingListeners.add(handler);
+    return {
+      remove() {
+        linkingListeners.delete(handler);
+      },
+    };
+  },
+  removeEventListener(type: 'url', handler: LinkingUrlHandler): void {
+    if (type === 'url') {
+      linkingListeners.delete(handler);
+    }
+  },
+};
+
+export default {
+  AppState,
+  Appearance,
+  Dimensions,
+  Linking,
+  Platform,
+};

package/src/runtime-entry.ts

@@ -0,0 +1,55 @@
+/**
+ * Ibex Runtime Entry Point
+ *
+ * This file is the entry point for building the standalone runtime bundle.
+ * It installs all web-standard globals and exposes runtime utilities.
+ *
+ * Build: vite build --config vite.config.runtime.ts
+ * Output: dist/runtime.js -> hermesc -> dist/runtime.hbc
+ */
+
+import { installGlobals, areGlobalsInstalled, getRuntimeVersion, detectEngine, detectPlatform, runtimeInfo } from './bootstrap.js';
+
+// Agent runtime is loaded on demand (when EXACT_AGENT_BOOT=1), not during
+// core runtime startup.  Importing it here pulled in the renderer/inspector
+// module graph (React, Solid, Vue, etc.) and inflated the runtime bundle
+// from ~100 KB to >2 MB, adding >10 ms of HBC evaluation on every startup.
+// The agent bootstrap is now loaded lazily by the CLI when agent mode is
+// explicitly requested.
+// import '../agent/runtime-bootstrap.js';
+
+// Install globals immediately when the runtime loads
+installGlobals();
+
+// Mark the runtime as installed with version info
+(globalThis as any).__exactRuntime = {
+  version: getRuntimeVersion(),
+  installed: true,
+  installedAt: Date.now(),
+  engine: detectEngine(),
+  platform: detectPlatform(),
+};
+
+// Expose runtime utilities on the exact global (created by native layer)
+const g = globalThis as any;
+if (!g.exact) {
+  g.exact = {};
+}
+
+g.exact.runtime = {
+  version: getRuntimeVersion(),
+  info: runtimeInfo,
+  isInstalled: areGlobalsInstalled,
+  detectEngine,
+  detectPlatform,
+};
+
+// Log that the runtime was installed (will be visible if console is set up)
+// Using try-catch in case console isn't ready yet
+try {
+  if (!(globalThis as any).__exactSuppressRuntimeBanner) {
+    console.log(`[Ibex Runtime v${getRuntimeVersion()}] Installed (${detectEngine()})`);
+  }
+} catch {
+  // Console not ready yet, that's fine
+}

package/src/scheduling/AnimationFrame.ts

@@ -0,0 +1,105 @@
+/**
+ * requestAnimationFrame / cancelAnimationFrame implementation for Ibex runtime
+ * 
+ * Schedules callbacks to run before the next repaint.
+ * @see https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#dom-animationframeprovider-requestanimationframe
+ */
+
+import { getNativeModule } from '../native/NativeModules.js';
+import {
+  trackAnimationFrameCancelled,
+  trackAnimationFrameExecuted,
+  trackAnimationFrameRequested,
+} from '../core/agent-state.js';
+
+export type FrameRequestCallback = (time: DOMHighResTimeStamp) => void;
+type DOMHighResTimeStamp = number;
+
+// Callback storage
+const callbacks = new Map<number, FrameRequestCallback>();
+let nextId = 1;
+let isScheduled = false;
+
+// Target ~60fps = 16.67ms for runtimes that are not already display-linked.
+const FRAME_TIME = 16;
+
+/**
+ * Requests that a callback be called before the next repaint.
+ * Returns an ID that can be used to cancel the request.
+ */
+export function requestAnimationFrame(callback: FrameRequestCallback): number {
+  if (typeof callback !== 'function') {
+    throw new TypeError('Failed to execute \'requestAnimationFrame\': parameter 1 is not of type \'Function\'.');
+  }
+
+  const id = nextId++;
+  callbacks.set(id, callback);
+  trackAnimationFrameRequested(id);
+
+  // Check for native implementation
+  const nativeScheduling = getNativeModule('scheduling');
+  if (nativeScheduling?.requestAnimationFrame) {
+    // Use native RAF which is tied to the display refresh rate
+    if (!isScheduled) {
+      isScheduled = true;
+      nativeScheduling.requestAnimationFrame(() => {
+        isScheduled = false;
+        runCallbacks();
+      });
+    }
+    return id;
+  }
+
+  // Fallback: use setTimeout to approximate 60fps
+  if (!isScheduled) {
+    isScheduled = true;
+    setTimeout(() => {
+      isScheduled = false;
+      runCallbacks();
+    }, fallbackFrameDelayMs());
+  }
+
+  return id;
+}
+
+/**
+ * Cancels a previously scheduled animation frame request.
+ */
+export function cancelAnimationFrame(id: number): void {
+  if (callbacks.delete(id)) {
+    trackAnimationFrameCancelled(id);
+  }
+}
+
+/**
+ * Run all pending callbacks with the current timestamp.
+ */
+function runCallbacks(): void {
+  // Get current time
+  const timestamp = typeof performance !== 'undefined' && performance.now
+    ? performance.now()
+    : Date.now();
+
+  // Copy callbacks to allow adding new ones during iteration
+  const pending = new Map(callbacks);
+  callbacks.clear();
+  trackAnimationFrameExecuted(Array.from(pending.keys()));
+
+  for (const [, callback] of pending) {
+    try {
+      callback(timestamp);
+    } catch (error) {
+      // Report error but continue with other callbacks
+      console.error('Error in requestAnimationFrame callback:', error);
+    }
+  }
+}
+
+function fallbackFrameDelayMs(): number {
+  return (globalThis as { __exactDisplayLinkedEventLoop?: boolean })
+    .__exactDisplayLinkedEventLoop === true
+    ? 0
+    : FRAME_TIME;
+}
+
+export default { requestAnimationFrame, cancelAnimationFrame };

package/src/scheduling/IdleCallback.ts

@@ -0,0 +1,167 @@
+/**
+ * requestIdleCallback / cancelIdleCallback implementation for Ibex runtime
+ * 
+ * Schedules callbacks to run during idle periods.
+ * @see https://w3c.github.io/requestidlecallback/
+ */
+
+import { getNativeModule } from '../native/NativeModules';
+
+export interface IdleRequestOptions {
+  timeout?: number;
+}
+
+export interface IdleDeadline {
+  readonly didTimeout: boolean;
+  timeRemaining(): number;
+}
+
+export type IdleRequestCallback = (deadline: IdleDeadline) => void;
+
+// Callback storage
+interface PendingCallback {
+  callback: IdleRequestCallback;
+  timeout?: number;
+  scheduledTime: number;
+}
+
+const callbacks = new Map<number, PendingCallback>();
+let nextId = 1;
+let isScheduled = false;
+
+// Idle period is typically 50ms max per spec recommendation
+const MAX_IDLE_PERIOD = 50;
+// How often to check for idle time
+const IDLE_CHECK_INTERVAL = 100;
+
+/**
+ * Requests that a callback be called during an idle period.
+ * Returns an ID that can be used to cancel the request.
+ */
+export function requestIdleCallback(
+  callback: IdleRequestCallback,
+  options?: IdleRequestOptions
+): number {
+  if (typeof callback !== 'function') {
+    throw new TypeError('Failed to execute \'requestIdleCallback\': parameter 1 is not of type \'Function\'.');
+  }
+
+  const id = nextId++;
+  const timeout = options?.timeout;
+  const scheduledTime = performance?.now?.() ?? Date.now();
+
+  callbacks.set(id, {
+    callback,
+    timeout,
+    scheduledTime,
+  });
+
+  // Check for native implementation
+  const nativeScheduling = getNativeModule('scheduling');
+  if (nativeScheduling?.requestIdleCallback) {
+    nativeScheduling.requestIdleCallback((deadline: IdleDeadline) => {
+      runCallback(id, deadline);
+    }, options);
+    return id;
+  }
+
+  // Fallback: simulate idle callback using setTimeout
+  scheduleIdleCheck();
+
+  // If timeout is specified, ensure callback runs within that time
+  if (timeout !== undefined && timeout > 0) {
+    setTimeout(() => {
+      const pending = callbacks.get(id);
+      if (pending) {
+        runCallback(id, createDeadline(true, 0));
+      }
+    }, timeout);
+  }
+
+  return id;
+}
+
+/**
+ * Cancels a previously scheduled idle callback.
+ */
+export function cancelIdleCallback(id: number): void {
+  callbacks.delete(id);
+}
+
+/**
+ * Schedule a check for idle time.
+ */
+function scheduleIdleCheck(): void {
+  if (isScheduled || callbacks.size === 0) {
+    return;
+  }
+
+  isScheduled = true;
+
+  // Use setTimeout as a simple idle heuristic
+  // In practice, if we're running this callback, the main thread is likely idle
+  setTimeout(() => {
+    isScheduled = false;
+    runIdleCallbacks();
+  }, IDLE_CHECK_INTERVAL);
+}
+
+/**
+ * Run callbacks that can fit in the current idle period.
+ */
+function runIdleCallbacks(): void {
+  const now = performance?.now?.() ?? Date.now();
+  const idleDeadline = now + MAX_IDLE_PERIOD;
+
+  // Process callbacks until we run out of time or callbacks
+  for (const [id, pending] of callbacks) {
+    const remaining = idleDeadline - (performance?.now?.() ?? Date.now());
+    
+    if (remaining <= 0) {
+      // No more idle time, schedule another check
+      scheduleIdleCheck();
+      break;
+    }
+
+    // Check if this callback has timed out
+    const elapsed = now - pending.scheduledTime;
+    const didTimeout = pending.timeout !== undefined && elapsed >= pending.timeout;
+
+    runCallback(id, createDeadline(didTimeout, remaining));
+  }
+}
+
+/**
+ * Run a specific callback and remove it from the pending set.
+ */
+function runCallback(id: number, deadline: IdleDeadline): void {
+  const pending = callbacks.get(id);
+  if (!pending) {
+    return;
+  }
+
+  callbacks.delete(id);
+
+  try {
+    pending.callback(deadline);
+  } catch (error) {
+    console.error('Error in requestIdleCallback:', error);
+  }
+}
+
+/**
+ * Create an IdleDeadline object.
+ */
+function createDeadline(didTimeout: boolean, remainingTime: number): IdleDeadline {
+  const deadlineEnd = (performance?.now?.() ?? Date.now()) + remainingTime;
+
+  return {
+    didTimeout,
+    timeRemaining(): number {
+      const now = performance?.now?.() ?? Date.now();
+      return Math.max(0, deadlineEnd - now);
+    },
+  };
+}
+
+export default { requestIdleCallback, cancelIdleCallback };