@fireemu/darwin-arm64 0.13.0 → 0.15.0

package/README.md

@@ -1,7 +1,7 @@
 # @fireemu/darwin-arm64
 
 The [fireemu](https://www.npmjs.com/package/fireemu) daemon built for `darwin-arm64`
-(Rust target `aarch64-apple-darwin`), version 0.13.0.
+(Rust target `aarch64-apple-darwin`), version 0.15.0.
 
 macOS 13 or newer on Apple silicon.
 

package/bin/runner-node/clock.mjs

@@ -0,0 +1,247 @@
+// Opt-in application time. Native event-loop and lifecycle deadlines stay real.
+import timers from 'node:timers';
+import promises from 'node:timers/promises';
+import { syncBuiltinESMExports } from 'node:module';
+import { promisify } from 'node:util';
+
+const NativeDate = Date;
+const dateConstructor = Object.getOwnPropertyDescriptor(NativeDate.prototype, 'constructor');
+const nativeImmediate = timers.setImmediate;
+const native = {
+  setTimeout: timers.setTimeout, clearTimeout: timers.clearTimeout,
+  setInterval: timers.setInterval, clearInterval: timers.clearInterval,
+};
+const nativePromises = { setTimeout: promises.setTimeout, setInterval: promises.setInterval };
+const nanosPerMilli = 1_000_000n;
+const dateLimit = 8_640_000_000_000_000n;
+const maxDrain = 10_000;
+
+function nanos(value, name) {
+  if (typeof value !== 'string' || !/^(?:0|-?[1-9][0-9]*)$/.test(value)) {
+    throw new TypeError(`invalid clock ${name}`);
+  }
+  return BigInt(value);
+}
+
+function milliseconds(instant) {
+  const value = instant >= 0n ? instant / nanosPerMilli : (instant - nanosPerMilli + 1n) / nanosPerMilli;
+  if (value < -dateLimit || value > dateLimit) throw new RangeError('clock outside JavaScript Date range');
+  return Number(value);
+}
+
+function delay(value) {
+  const number = Number(value ?? 1);
+  return !Number.isFinite(number) || number < 1 || number > 2_147_483_647 ? 1 : Math.trunc(number);
+}
+
+function abortError(reason) {
+  const error = new Error('The operation was aborted', {cause:reason});
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  return error;
+}
+
+function options(value) {
+  if (value === null || typeof value !== 'object') throw new TypeError('timer options must be an object');
+  if (value.signal !== undefined && !(value.signal instanceof AbortSignal)) throw new TypeError('invalid AbortSignal');
+  if (value.ref !== undefined && typeof value.ref !== 'boolean') throw new TypeError('timer ref must be boolean');
+  return value;
+}
+
+export function createRuntimeClock({date = 'real', timers: timerPolicy = 'real', instantNanos = '0', elapsedNanos = '0'} = {}) {
+  if (!['real','virtual'].includes(date) || !['real','virtual'].includes(timerPolicy) ||
+      (timerPolicy === 'virtual' && date !== 'virtual')) throw new TypeError('invalid runtime clock policy');
+  let instant = nanos(instantNanos, 'instant');
+  let epochMillis = date === 'virtual' ? milliseconds(instant) : 0;
+  let elapsed = nanos(elapsedNanos, 'elapsed');
+  if (elapsed < 0n) throw new RangeError('negative timer elapsed time');
+  let installed = false;
+  let sequence = 0;
+  let draining = false;
+  const queue = new Map();
+  const handles = new Map();
+
+  class Timer {
+    constructor(callback, duration, args, repeat) {
+      this.id = ++sequence;
+      this.callback = callback;
+      this.duration = BigInt(delay(duration)) * nanosPerMilli;
+      this.args = args;
+      this.repeat = repeat;
+      this.referenced = true;
+      this.cancelled = false;
+      this.refresh();
+    }
+    refresh() {
+      if (!this.cancelled) {
+        this.deadline = elapsed + this.duration;
+        this.order = ++sequence;
+        queue.set(this.id, this);
+        handles.set(this.id, this);
+      }
+      return this;
+    }
+    ref() { this.referenced = true; return this; }
+    unref() { this.referenced = false; return this; }
+    hasRef() { return this.referenced; }
+    close() { cancel(this); return this; }
+    [Symbol.toPrimitive]() { return this.id; }
+    [Symbol.dispose]() { cancel(this); }
+  }
+
+  function schedule(callback, duration, args, repeat) {
+    if (typeof callback !== 'function') throw new TypeError('timer callback must be a function');
+    return new Timer(callback, duration, args, repeat);
+  }
+
+  function cancel(value) {
+    const handle = value instanceof Timer ? value : handles.get(Number(value));
+    if (!handle) return;
+    handle.cancelled = true;
+    queue.delete(handle.id);
+    handles.delete(handle.id);
+  }
+
+  function promiseTimeout(duration, value, config = {}) {
+    try { options(config); } catch (error) { return Promise.reject(error); }
+    if (config.signal?.aborted) return Promise.reject(abortError(config.signal.reason));
+    return new Promise((resolve, reject) => {
+      const complete = () => {
+        config.signal?.removeEventListener('abort', abort);
+        resolve(value);
+      };
+      const handle = schedule(complete, duration, [], false);
+      if (config.ref === false) handle.unref();
+      const abort = () => {
+        cancel(handle);
+        config.signal.removeEventListener('abort', abort);
+        reject(abortError(config.signal.reason));
+      };
+      config.signal?.addEventListener('abort', abort, {once:true});
+    });
+  }
+
+  async function* promiseInterval(duration, value, config = {}) {
+    options(config);
+    if (config.signal?.aborted) throw abortError(config.signal.reason);
+    let count = 0;
+    let wake;
+    let aborted = false;
+    const handle = schedule(() => { count++; wake?.(); }, duration, [], true);
+    if (config.ref === false) handle.unref();
+    const abort = () => { aborted = true; cancel(handle); wake?.(); };
+    config.signal?.addEventListener('abort', abort, {once:true});
+    try {
+      while (!aborted) {
+        if (count === 0) await new Promise(resolve => {wake = resolve;});
+        wake = undefined;
+        if (aborted) break;
+        count--;
+        yield value;
+      }
+      throw abortError(config.signal.reason);
+    } finally {
+      cancel(handle);
+      config.signal?.removeEventListener('abort', abort);
+    }
+  }
+
+  const now = () => epochMillis;
+  const VirtualDate = new Proxy(NativeDate, {
+    apply() { return new NativeDate(epochMillis).toString(); },
+    construct(target, args, newTarget) {
+      return Reflect.construct(target, args.length === 0 ? [epochMillis] : args, newTarget);
+    },
+    get(target, key, receiver) {
+      return key === 'now' ? now : Reflect.get(target, key, receiver);
+    },
+  });
+  const virtual = {
+    setTimeout: (callback, duration, ...args) => schedule(callback, duration, args, false),
+    setInterval: (callback, duration, ...args) => schedule(callback, duration, args, true),
+    clearTimeout: cancel, clearInterval: cancel,
+  };
+  Object.defineProperty(virtual.setTimeout, promisify.custom, {value:promiseTimeout});
+
+  function status() {
+    let due = 0;
+    for (const handle of queue.values()) if (handle.deadline <= elapsed) due++;
+    return {pending:queue.size, due, instantNanos:instant.toString(), elapsedNanos:elapsed.toString()};
+  }
+
+  return {
+    install() {
+      if (installed) return;
+      installed = true;
+      if (date === 'virtual') {
+        globalThis.Date = VirtualDate;
+        Object.defineProperty(NativeDate.prototype, 'constructor', {...dateConstructor, value:VirtualDate});
+      }
+      if (timerPolicy === 'virtual') {
+        Object.assign(globalThis, virtual);
+        Object.assign(timers, virtual);
+        promises.setTimeout = promiseTimeout;
+        promises.setInterval = promiseInterval;
+        syncBuiltinESMExports();
+      }
+    },
+    restore() {
+      if (!installed) return;
+      installed = false;
+      if (date === 'virtual') {
+        globalThis.Date = NativeDate;
+        Object.defineProperty(NativeDate.prototype, 'constructor', dateConstructor);
+      }
+      if (timerPolicy === 'virtual') {
+        Object.assign(globalThis, native);
+        Object.assign(timers, native);
+        Object.assign(promises, nativePromises);
+        syncBuiltinESMExports();
+        queue.clear();
+        handles.clear();
+      }
+    },
+    update(value) {
+      const next = nanos(value.instantNanos, 'instant');
+      const nextMillis = date === 'virtual' ? milliseconds(next) : 0;
+      const nextElapsed = value.elapsedNanos === undefined
+        ? elapsed + (next > instant ? next - instant : 0n)
+        : nanos(value.elapsedNanos, 'elapsed');
+      if (nextElapsed < elapsed) throw new RangeError('timer elapsed time cannot rewind');
+      instant = next;
+      epochMillis = nextMillis;
+      elapsed = nextElapsed;
+      return status();
+    },
+    async runDue(budget = 1000) {
+      if (!Number.isSafeInteger(budget) || budget < 1 || budget > maxDrain) throw new RangeError('invalid timer drain budget');
+      if (draining) throw new Error('timer drain is already running');
+      draining = true;
+      let executed = 0;
+      try {
+        while (executed < budget) {
+          let next;
+          for (const handle of queue.values()) {
+            if (handle.deadline <= elapsed && (!next || handle.deadline < next.deadline ||
+                (handle.deadline === next.deadline && handle.order < next.order))) next = handle;
+          }
+          if (!next) break;
+          queue.delete(next.id);
+          handles.delete(next.id);
+          if (next.repeat) {
+            next.deadline += next.duration;
+            queue.set(next.id, next);
+            handles.set(next.id, next);
+          }
+          executed++;
+          Reflect.apply(next.callback, next, next.args);
+          // Finish Promise and nextTick continuations, without waiting for the callback's
+          // returned promise (which may depend on a future virtual timer).
+          await new Promise(resolve => nativeImmediate(resolve));
+        }
+      } finally { draining = false; }
+      return {executed,...status()};
+    },
+    status,
+  };
+}

package/bin/runner-node/diagnostic-output.mjs

@@ -257,3 +257,5 @@ export function installDiagnosticOutput(stream, options) {
   };
   return writer;
 }
+import timers from 'node:timers';
+const {setTimeout, clearTimeout} = timers;

package/bin/runner-node/index.mjs

@@ -13,6 +13,9 @@ import { pathToFileURL } from "node:url";
 import { existsSync, readFileSync, readlinkSync } from "node:fs";
 import { resolve, join, dirname } from "node:path";
 import { createServer } from "node:http";
+import timers from "node:timers";
+const {setTimeout, clearTimeout} = timers;
+import { createRuntimeClock } from "./clock.mjs";
 import { execFileSync, spawn } from "node:child_process";
 import { url as inspectorUrl } from "node:inspector";
 import { instrumentCallables } from "./callable-app-check.mjs";
@@ -1522,6 +1525,10 @@ async function invoke(functions, manifest, msg) {
 
 
 async function main() {
+  const clockOptions = JSON.parse(process.env.FIREEMU_CLOCK_JSON ?? '{}');
+  const runtimeClock = createRuntimeClock(clockOptions);
+  let clockRevision = BigInt(clockOptions.revision ?? '0');
+  runtimeClock.install();
   let functions;
   let manifest;
   let runnerReady = false;
@@ -1538,6 +1545,25 @@ async function main() {
         finishOutput();
         return false;
       }
+      if (msg.type === 'clock:set' || msg.type === 'clock:runDue') {
+        void (async () => {
+          try {
+            let status;
+            if (msg.type === 'clock:set') {
+              const revision = BigInt(msg.revision);
+              if (revision < clockRevision) throw new Error('stale clock revision');
+              status = runtimeClock.update(msg);
+              clockRevision = revision;
+            } else {
+              status = await runtimeClock.runDue(msg.budget);
+            }
+            send({type:'result',invocationId:msg.invocationId,ok:true,timers:status});
+          } catch (error) {
+            send({type:'result',invocationId:msg.invocationId,ok:false,error:invocationFailure(error).message});
+          }
+        })();
+        return;
+      }
       if (!runnerReady) {
         process.stderr.write('[functions] invocation received before runner hello\n');
         process.exit(2);
@@ -1670,6 +1696,7 @@ async function main() {
   send({
     type: "hello",
     runner: "node",
+    clock: {version:1,date:true,timers:true},
     codebase: args.codebase,
     version: process.version,
     inspectorPort: activeInspectorPort,

package/bin/runner-node/output.mjs

@@ -2,6 +2,8 @@
 // Limits are local resource policies, not Firebase quotas. They count encoded
 // pending frames (including the stream's in-flight write), not process-wide RSS.
 import { performance } from 'node:perf_hooks';
+import timers from 'node:timers';
+const {setTimeout, clearTimeout} = timers;
 import { MAX_FRAME_BYTES } from './protocol.mjs';
 
 export const MAX_PENDING_BYTES = 32 * 1024 * 1024;

package/bin/runner-node/protocol.mjs

@@ -3,7 +3,8 @@
 // This is a trusted local pipe, not an authentication or arbitrary-code sandbox.
 import { TextDecoder } from 'node:util';
 import { performance } from 'node:perf_hooks';
-import { setTimeout, clearTimeout } from 'node:timers';
+import timers from 'node:timers';
+const {setTimeout, clearTimeout} = timers;
 
 export const MAX_FRAME_BYTES = 16 * 1024 * 1024;
 // Local pipe safety policies, not Firebase invocation deadlines or quotas.
@@ -37,6 +38,12 @@ function decodeMessage(payload) {
   }
   if (!object(message)) throw new ProtocolError('message object');
   if (message.type === 'shutdown') return message;
+  const decimal = (value, signed = false) => typeof value === 'string' && value.length <= 40 &&
+    (signed ? /^(?:0|-?[1-9][0-9]*)$/ : /^(?:0|[1-9][0-9]*)$/).test(value);
+  if (message.type === 'clock:set' && text(message.invocationId) &&
+      decimal(message.instantNanos, true) && decimal(message.elapsedNanos) && decimal(message.revision)) return message;
+  if (message.type === 'clock:runDue' && text(message.invocationId) &&
+      (message.budget === undefined || (Number.isSafeInteger(message.budget) && message.budget >= 1 && message.budget <= 10000))) return message;
   if (message.type !== 'invoke' || !text(message.invocationId) ||
       !text(message.function) || !text(message.trigger) || !object(message.event) ||
       (message.entryPoint !== undefined && !text(message.entryPoint))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireemu/darwin-arm64",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "The fireemu daemon for darwin-arm64",
   "homepage": "https://github.com/t-k/fireemu#readme",
   "repository": {