@lucent-lang/lucent 0.0.4 → 0.1.0

package/lib/sdk/core.d.ts

@@ -21,3 +21,204 @@ export declare function utf8Decode(bytes: Uint8Array): string;
 
 /** Milliseconds from a monotonic clock, for measuring durations. */
 export declare function now(): number;
+
+/**
+ * A promise of what a callback API reports once, such as a native listener.
+ * `register` starts listening, at once, and may return the cleanup that
+ * stops it:
+ *
+ * ```ts
+ * fromCallback<string>((resolve, reject) => {
+ *   const subscription = source.listen(resolve, reject);
+ *   return () => subscription.cancel();
+ * }, signal);
+ * ```
+ *
+ * The first of `resolve`, `reject` and the signal aborting settles the
+ * promise; later calls do nothing. The cleanup runs exactly once, as soon as
+ * the promise settles, or right after `register` returns if it settled
+ * during registration. A throw from `register` rejects the promise. With an
+ * aborted signal, the promise rejects with the signal's reason and
+ * `register` is not called. A cleanup that throws is reported as uncaught;
+ * the promise keeps its outcome. `resolve` takes a value, not a promise.
+ *
+ * Called from another thread (a `main` block, say), `resolve` and `reject`
+ * take effect on the thread `fromCallback` was called on, in the order
+ * they were called.
+ */
+export declare function fromCallback<T>(
+  register: (resolve: (value: T) => void, reject: (reason: Error) => void) => (() => void) | void,
+  signal?: AbortSignal,
+): Promise<T>;
+
+/**
+ * Passes what a listener reports to `onValue` until the subscription ends,
+ * and resolves when it does. `register` starts listening, at once, and may
+ * return the cleanup that stops it.
+ *
+ * `next(value)` calls `onValue(value)` while the subscription is open, and
+ * does nothing after. The first of `end()`, `fail(error)`, `onValue`
+ * throwing and the signal aborting ends it: the promise resolves (`end`) or
+ * rejects (with the error, or the signal's reason), and the cleanup runs
+ * exactly once. Registration, an aborted signal, a throwing cleanup and
+ * calls from other threads behave as in `fromCallback`.
+ */
+export declare function subscribe<T>(
+  register: (
+    next: (value: T) => void,
+    end: () => void,
+    fail: (error: Error) => void,
+  ) => (() => void) | void,
+  onValue: (value: T) => void,
+  signal?: AbortSignal,
+): Promise<void>;
+
+/** How a compute task runs. */
+export interface ComputeOptions {
+  /** Aborting it cancels the task: the promise rejects with its reason at once. */
+  signal?: AbortSignal;
+}
+
+/**
+ * Runs `task(input)` on a pool of worker threads and resolves with its
+ * result, on the thread that called `compute`. `task` is a function declared
+ * at the top level of a module, taking one parameter: the compiler checks
+ * everything it runs can run on a worker (no module state, no main-thread
+ * or unknown-thread native code, nothing asynchronous) and that `input` and
+ * its result are data.
+ *
+ * `input` is copied when `compute` is called: later changes by the caller
+ * do not reach the task. Objects reached twice are copied once, and cycles
+ * survive. The result comes back as it is.
+ *
+ * A task that throws rejects the promise with its error. With `signal`,
+ * aborting it rejects the promise at once with the signal's reason: a
+ * queued task never starts, and a running one stops at the next iteration
+ * of a loop in the task or in a module function it calls. Loops in
+ * closures, methods and generic functions, and native calls, run to their
+ * end first; the result is then dropped. The pool
+ * holds a bounded number of waiting tasks; beyond that, `compute` rejects
+ * with a QuotaExceededError.
+ *
+ * ```ts
+ * function edgePositions(bytes: Uint8Array): number[] {
+ *   const positions: number[] = [];
+ *   for (let i = 1; i < bytes.length; i++)
+ *     if (Math.abs(bytes[i]! - bytes[i - 1]!) > 40) positions.push(i);
+ *   return positions;
+ * }
+ *
+ * export async function edges(bytes: Uint8Array, signal: AbortSignal): Promise<number[]> {
+ *   return await compute(edgePositions, bytes, { signal });
+ * }
+ * ```
+ */
+export declare function compute<T, R>(
+  task: (input: T) => R,
+  input: T,
+  options?: ComputeOptions,
+): Promise<Awaited<R>>;
+
+/**
+ * Bytes native code owns, handed to compute tasks and JavaScript without
+ * copying them. A `Uint8Array` is copied whenever it crosses; a
+ * NativeBuffer moves.
+ *
+ * The bytes are reached through a borrow, for the length of one call:
+ * `withRead` lends them to its callback as a `ByteSpan`, `withWrite` as a
+ * `MutableByteSpan`. Reads share the buffer; a write needs it to itself.
+ * A borrow that would conflict with one in progress (a write inside a
+ * read, a close or transfer inside either) throws an InvalidStateError at
+ * once. The compiler keeps a span inside its callback: it cannot be
+ * returned, stored, captured by a closure that outlives the call, passed
+ * to code that keeps it, or held across `await`.
+ *
+ * `transfer()` moves the bytes to a new buffer, uncopied: every reference
+ * to the old one then refuses them. Passing a buffer to `compute`, alone
+ * or inside the input, moves it the same way, and a task's buffer comes
+ * back as it is. Copies are explicit: `NativeBuffer.from(bytes)` and
+ * `toUint8Array()`, which `NativeBuffer.stats()` counts.
+ *
+ * ```ts
+ * function scan(buffer: NativeBuffer): number {
+ *   using owned = buffer;
+ *   return owned.withRead((bytes) => {
+ *     let total = 0;
+ *     for (let i = 0; i < bytes.length; i++) total += bytes[i]!;
+ *     return total;
+ *   });
+ * }
+ *
+ * export async function sample(): Promise<number> {
+ *   const buffer = NativeBuffer.allocate(4096);
+ *   buffer.withWrite((bytes) => bytes.fill(7));
+ *   return await compute(scan, buffer.transfer());
+ * }
+ * ```
+ *
+ * JavaScript sees a buffer as an opaque object with the same methods; its
+ * borrows lend it a copy of the bytes (copied back after `withWrite`), so
+ * JavaScript never holds memory a worker may be writing.
+ */
+export declare class NativeBuffer {
+  private constructor();
+
+  /** A buffer of `size` zeroed bytes: a RangeError unless `size` is a whole number from 0. */
+  static allocate(size: number): NativeBuffer;
+
+  /** A new buffer holding a copy of `bytes`. */
+  static from(bytes: Uint8Array): NativeBuffer;
+
+  /** What every buffer has done since the app started. */
+  static stats(): NativeBufferStats;
+
+  /** How many bytes it holds: 0 once closed or transferred. */
+  readonly byteLength: number;
+
+  /** Calls `read` with the bytes, while no one writes them, and returns what it returns. */
+  withRead<R>(read: (bytes: ByteSpan) => R): R;
+
+  /** Calls `write` with the bytes, while nothing else borrows them, and returns what it returns. */
+  withWrite<R>(write: (bytes: MutableByteSpan) => R): R;
+
+  /** A copy of the bytes, independent of the buffer from then on. */
+  toUint8Array(): Uint8Array;
+
+  /** Moves the bytes, uncopied, to a new buffer: every reference to this one refuses them from now on. */
+  transfer(): NativeBuffer;
+
+  /** Releases the bytes. Closing a closed or transferred buffer does nothing. */
+  close(): void;
+
+  [Symbol.dispose](): void;
+}
+
+/** The bytes `withRead` lends, read like a `Uint8Array`'s: `bytes[i]` is undefined out of range. */
+export interface ByteSpan {
+  readonly length: number;
+  readonly [index: number]: number;
+}
+
+/** The bytes `withWrite` lends, written like a `Uint8Array`'s: values wrap to 0–255, writes out of range do nothing. */
+export interface MutableByteSpan extends ByteSpan {
+  [index: number]: number;
+
+  /** Sets the bytes from `start` to `end` (counted from the end when negative) to `value`. */
+  fill(value: number, start?: number, end?: number): void;
+
+  /** Copies `source` in at `offset`: a RangeError if it does not fit. */
+  set(source: Uint8Array, offset?: number): void;
+}
+
+/** Counts of what native buffers have done, for checking that a path does not copy. */
+export interface NativeBufferStats {
+  /** Buffers allocated, including those `from` made. */
+  readonly allocated: number;
+  /** Buffers native code handed over with its own memory. */
+  readonly adopted: number;
+  /** Moves of a buffer's bytes to a new buffer: `transfer()` and handoffs to tasks. */
+  readonly transfers: number;
+  /** Copies in and out (`from`, `toUint8Array`, and JavaScript's borrows), and their bytes. */
+  readonly copies: number;
+  readonly bytesCopied: number;
+}

package/lib/sdk/ios.d.ts

@@ -1,5 +1,7 @@
 // lucent:ios — iOS helpers for platform code.
 
+import type { UIViewController } from "lucent:ios/UIKit";
+
 /** Whether the OS is at least `major.minor` (Swift's `#available`). */
 export declare function available(platform: "ios", major: number, minor?: number): boolean;
 
@@ -26,8 +28,79 @@ export declare function asData(value: NSObject | null): Uint8Array | null;
 /** Swift's `as? Date`. */
 export declare function asDate(value: NSObject | null): Date | null;
 
-/** An out-parameter of a C function (`CFTypeRef *`): pass it, then read `value`. */
+/**
+ * What a method writes through a pointer (`CGFloat *`, `NSRange *`,
+ * `NSDate **`, `CFTypeRef *`): pass it, then read `value`. For a pointer the
+ * method also reads (a number or a struct), set `value` first.
+ */
 export declare class Out<T> {
   constructor();
-  readonly value: T | null;
+  value: T | null;
 }
+
+/**
+ * UIApplication's lifecycle notifications, by name: `"didBecomeActive"` is
+ * `UIApplication.didBecomeActiveNotification`.
+ */
+export type AppEvent =
+  | "didBecomeActive"
+  | "willResignActive"
+  | "didEnterBackground"
+  | "willEnterForeground"
+  | "didReceiveMemoryWarning"
+  | "willTerminate";
+
+/**
+ * UIScene's lifecycle notifications, by name: `"willConnect"` is
+ * `UIScene.willConnectNotification`.
+ */
+export type SceneEvent =
+  | "willConnect"
+  | "didDisconnect"
+  | "didActivate"
+  | "willDeactivate"
+  | "willEnterForeground"
+  | "didEnterBackground";
+
+/**
+ * Calls `listener` each time the app posts `event`, until the returned
+ * function is called or `signal` aborts. It runs on the main thread, as
+ * UIKit posts it, so main-thread APIs work there without `main()`. Lucent
+ * observes the notifications: the app's delegate, and other modules', stay
+ * as they are. What `listener` throws is logged; the app goes on.
+ */
+export declare function onAppEvent(
+  event: AppEvent,
+  listener: () => void,
+  signal?: AbortSignal,
+): () => void;
+
+/**
+ * Like `onAppEvent`, for each scene's `event`: `listener` gets the scene's
+ * session's `persistentIdentifier`.
+ */
+export declare function onSceneEvent(
+  event: SceneEvent,
+  listener: (scene: string) => void,
+  signal?: AbortSignal,
+): () => void;
+
+/**
+ * Presents the view controller `build` returns from the scene the person is
+ * using (the top view controller of its key window), and resolves with the
+ * value given to `resolve`, or rejects with the error given to `reject`.
+ * `build` runs on the main thread, like `main()`'s function: make the view
+ * controller there, and call `resolve` or `reject` from its delegate or
+ * completion handler.
+ *
+ * It settles once, and whatever settles it dismisses the view controller if
+ * it is still shown. It rejects with an `AbortError` when `signal` aborts,
+ * when the person dismisses the view controller (swiping a sheet down), when
+ * the view controller goes before settling, or when its scene disconnects;
+ * with an `InvalidStateError` when no scene is in the foreground or UIKit
+ * does not present it.
+ */
+export declare function present<T>(
+  build: (resolve: (value: T) => void, reject: (reason: Error) => void) => UIViewController,
+  signal?: AbortSignal,
+): Promise<T>;

package/lib/sdk/ui.d.ts

@@ -0,0 +1,129 @@
+/**
+ * lucent:ui — the helpers a component's setup uses.
+ *
+ * Experimental and internal: this module resolves only when the
+ * LUCENT_VIEWS environment variable is `fabric`, and changes without notice
+ * until Lucent's views are public.
+ *
+ * A component's setup runs once per mount, on the main thread: it makes
+ * the native objects the component shows and owns directly
+ * (`const label = new UILabel()`), and the mount releases them when it
+ * ends. Its props are read where they are used (`props.value`): inside
+ * `effect`, a read tracks the prop, and the effect runs again when a
+ * commit changes it.
+ *
+ * @experimental
+ */
+
+/**
+ * Runs `run` now, and again after a prop or signal it read changes. Before
+ * it runs again, and when the view goes, what it registered with
+ * `onDispose` runs.
+ */
+export declare function effect(run: () => void): void;
+
+/** A value of the view's own, which effects track like props. */
+export interface Signal<T> {
+  /** The value; inside an effect, the effect runs again when it changes. */
+  get(): T;
+  /** The value, without tracking it. */
+  peek(): T;
+  /** Changes it, unless `value` is the same (Object.is), running what read it. */
+  set(value: T): void;
+}
+
+export declare function signal<T>(initial: T): Signal<T>;
+
+/**
+ * A signal given to a view of a toolkit body that changes it: SwiftUI's
+ * Binding, or Compose's value and its change callback. The view shows the
+ * signal's value, and a change the user makes sets the signal (which may
+ * keep another value: the view shows what it keeps).
+ */
+export interface Bound<T> {
+  readonly __lucentBound: T;
+}
+
+/** `signal`, bound to the view of a body it is given to: only there. */
+export declare function bind<T>(signal: Signal<T>): Bound<T>;
+
+/**
+ * The numbers from `from` to `to`, both included, given to a view of a
+ * toolkit body that takes a range (a slider's, a stepper's bounds):
+ * SwiftUI's `from ... to`. Written where the view takes it, as
+ * bind(signal) is.
+ */
+export interface ClosedRange<T> {
+  readonly __lucentRange: T;
+}
+
+/** The closed range from `from` to `to`, for the view of a body it is given to: only there. */
+export declare function range(from: number, to: number): ClosedRange<number>;
+
+/**
+ * Gives the component's React ref `commands`: called once, at the top of
+ * setup, with an object literal of functions. A command returning nothing
+ * runs on the main thread; one returning a value (or a promise) answers
+ * JavaScript's promise.
+ */
+export declare function expose<T extends object>(commands: T): void;
+
+/**
+ * Runs `cleanup` when the view goes; inside an effect, before the effect
+ * runs again.
+ */
+export declare function onDispose(cleanup: () => void): void;
+
+/**
+ * The type of a component's `children` prop: the React elements
+ * JavaScript nests in it, which React Native mounts in the view `slot`
+ * gives setup. Setup never reads them.
+ */
+export interface Children {
+  readonly __lucentChildren: never;
+}
+
+/**
+ * The view a component's React children are mounted in, for a component
+ * whose props declare `children: Children`: called once, in a `const` at
+ * the top of setup, with the platform's container class
+ * (`slot<UIView>()` on iOS, `slot<ViewGroup>()` on Android).
+ *
+ * Put it in the view setup returns, where the children belong: it fills
+ * the view it is added to unless setup sizes it. React lays the children
+ * out in the component's own coordinates, wherever the slot is, and they
+ * show within the slot's bounds. React Native adds, moves and removes
+ * them: setup never changes the slot's subviews.
+ */
+export declare function slot<T extends object>(): T;
+
+/**
+ * Has the view measured again, once the main thread's current work ends:
+ * for a change to its native content its host would not hear of. The host
+ * hears of every function setup makes running (an effect, a native
+ * callback, a command), since their code may change the view; code after
+ * an `await` runs in none of them.
+ */
+export declare function invalidateSize(): void;
+
+declare const delivery: unique symbol;
+
+/**
+ * Marks an event prop's callback type: JavaScript hears each of its
+ * events at a lower priority than a discrete one (a tap), so React may
+ * batch what they update. For events that come often: a drag, a timer.
+ * An unmarked event is discrete.
+ */
+export type Continuous<F extends (...args: never[]) => void> = F & {
+  readonly [delivery]?: "continuous";
+};
+
+/**
+ * Marks an event prop's callback type: continuous, and while the view's
+ * latest event waiting for JavaScript is one of this type, a new one
+ * replaces it, so JavaScript hears the latest value. For events whose
+ * latest value is all that counts: a scroll position, a level.
+ */
+export type Coalesced<F extends (...args: never[]) => void> = F & {
+  readonly [delivery]?: "coalesced";
+};

package/metro/transformer.cjs

@@ -27,9 +27,18 @@ function moduleName(filename) {
   return base(path.basename(filename));
 }
 
+/**
+ * The native package whose proxies Metro bundles: the project's
+ * .lucent/native, or the one LUCENT_OUT names (as `lucent build --out`,
+ * relative to the project).
+ */
+function nativePackage(projectRoot) {
+  return path.resolve(projectRoot, process.env.LUCENT_OUT || path.join(".lucent", "native"));
+}
+
 function proxyFor(filename, projectRoot) {
   const name = moduleName(filename);
-  const generated = path.join(projectRoot, ".lucent", "native", "js", `${name}.js`);
+  const generated = path.join(nativePackage(projectRoot), "js", `${name}.js`);
   if (fs.existsSync(generated))
     return rebase(fs.readFileSync(generated, "utf8"), generated, filename);
   return `throw new Error(${JSON.stringify(`Lucent: ${path.basename(filename)} has not been compiled. Run \`lucent build\` and rebuild the app.`)});\n`;
@@ -63,7 +72,7 @@ module.exports = {
   getCacheKey(...args) {
     const base = typeof upstream.getCacheKey === "function" ? upstream.getCacheKey(...args) : "";
     // Proxies change when `lucent build` runs: include the manifest in the key.
-    const manifest = path.join(process.cwd(), ".lucent", "native", "manifest.json");
+    const manifest = path.join(nativePackage(process.cwd()), "manifest.json");
     const stamp = fs.existsSync(manifest) ? fs.readFileSync(manifest, "utf8") : "";
     return crypto.createHash("sha1").update(base).update(stamp).update("lucent-1").digest("hex");
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucent-lang/lucent",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Write native React Native modules in TypeScript: the Lucent compiler, CLI, Metro integration, Expo config plugin and editor plugin",
   "homepage": "https://lucent-lang.dev",
   "bugs": "https://github.com/Fausto95/lucent/issues",
@@ -54,6 +54,7 @@
     "ajv": "^8",
     "ink-testing-library": "^4.0.0",
     "@lucent-lang/bindgen": "0.0.3",
+    "@lucent-lang/codegen": "0.0.3",
     "@lucent-lang/compiler": "0.0.3",
     "@lucent-lang/runtime": "0.0.3"
   },

package/runtime/cpp/lucent/abort.cpp

@@ -1,26 +1,51 @@
 #include "abort.h"
 
-#include <cstdio>
 #include <exception>
+#include <memory>
 
+#include "report.h"
 #include "scheduler.h"
 
 namespace lucent {
 
+namespace {
+
+/// Like an event listener: what it throws is reported, and the rest run.
+void runListener(const std::function<void()>& f) {
+  try {
+    f();
+  } catch (...) {
+    reportUncaught(std::current_exception(), "abort listener");
+  }
+}
+
+}  // namespace
+
+bool AbortSignalObject::onOwner() const {
+  return owner_ ? owner_->isCurrent() : Scheduler::lock().heldByCurrentThread();
+}
+
+void AbortSignalObject::toOwner(std::function<void(AbortSignalObject&)> change) {
+  auto self = std::static_pointer_cast<AbortSignalObject>(shared_from_this());
+
+  ExecutionContext::of(owner_).post([self, change = std::move(change)] { change(*self); });
+}
+
 void AbortSignalObject::abort(Error why) {
+  if (!onOwner()) {
+    toOwner([why = std::move(why)](AbortSignalObject& s) { s.abort(why); });
+    return;
+  }
+
   if (aborted.load()) return;
+
   reason = std::move(why);
   aborted.store(true);
+
   auto listeners = std::move(listeners_);
   listeners_.clear();
-  for (auto& [id, f] : listeners) {
-    // Like an event listener: a throwing listener does not stop the others.
-    try {
-      f();
-    } catch (const std::exception& e) {
-      std::fprintf(stderr, "[lucent] uncaught exception in abort listener: %s\n", e.what());
-    }
-  }
+
+  for (auto& [id, f] : listeners) runListener(f);
 }
 
 void AbortSignalObject::throwIfAborted() const {
@@ -28,12 +53,35 @@ void AbortSignalObject::throwIfAborted() const {
 }
 
 uint64_t AbortSignalObject::add(std::function<void()> f) {
+  if (onOwner()) {
+    if (aborted.load()) return 0;
+
+    uint64_t id = nextId_++;
+    listeners_.emplace_back(id, std::move(f));
+    return id;
+  }
+
   uint64_t id = nextId_++;
-  if (!aborted.load()) listeners_.emplace_back(id, std::move(f));
+  toOwner([id, f = std::move(f)](AbortSignalObject& s) mutable { s.join(id, std::move(f)); });
   return id;
 }
 
+void AbortSignalObject::join(uint64_t id, std::function<void()> f) {
+  // Added before this context could see the abort: it happened first.
+  if (aborted.load()) {
+    runListener(f);
+    return;
+  }
+
+  listeners_.emplace_back(id, std::move(f));
+}
+
 void AbortSignalObject::remove(uint64_t id) {
+  if (!onOwner()) {
+    toOwner([id](AbortSignalObject& s) { s.remove(id); });
+    return;
+  }
+
   std::erase_if(listeners_, [id](const auto& l) { return l.first == id; });
 }
 
@@ -51,7 +99,7 @@ Promise<void> delay(double ms, Opt<AbortSignal> signal) {
   if (s->aborted.load()) return Promise<void>::rejected(s->reason);
   Promise<void> p;
   uint64_t id = s->add([p, s] { p.reject(s->reason); });
-  Scheduler::instance().postDelayed(ms, [p, s, id] {
+  ExecutionContext::of(ExecutionContext::currentRef()).postDelayed(ms, [p, s, id] {
     s->remove(id);
     p.resolve(undefined);
   });

package/runtime/cpp/lucent/abort.h

@@ -1,8 +1,11 @@
 // Lucent runtime — AbortController and AbortSignal.
 //
-// `aborted` may be read from any thread. Everything else, including abort
-// itself, runs under the Lucent lock. A signal that came from JavaScript is
-// aborted from the JS thread by a listener on the JS signal (lucent/jsi).
+// A signal belongs to the execution context it was made in. Any thread may
+// read `aborted` (then `reason`), abort it, or add and remove listeners;
+// from another context, abort and listener changes are posted to the owner,
+// where the listeners run. A signal that came from JavaScript is aborted
+// from the JS thread, in the legacy module context, by a listener on the JS
+// signal (lucent/jsi).
 #pragma once
 
 #include <atomic>
@@ -20,20 +23,30 @@ namespace lucent {
 class AbortSignalObject : public Object {
  public:
   std::atomic<bool> aborted{false};
-  /// Set once, when the signal aborts.
+  /// Set once, when the signal aborts, before `aborted`.
   Error reason;
 
   /// Aborts once: records `why` and runs the listeners in the order they
-  /// were added, synchronously, like dispatching the `abort` event.
+  /// were added, synchronously on the owner, like dispatching the `abort`
+  /// event. From another context, posted there. A listener's error is
+  /// reported and the others still run.
   void abort(Error why);
   void throwIfAborted() const;
   /// `addEventListener("abort", f)`.
   void addEventListener(std::function<void()> f) { add(std::move(f)); }
+  /// On the owner: 0, and `f` dropped, if the signal has aborted (it would
+  /// never run). From another context, `f` joins on the owner, and runs
+  /// there at once if the signal aborted before it arrived.
   uint64_t add(std::function<void()> f);
   void remove(uint64_t id);
 
  private:
-  uint64_t nextId_ = 1;
+  bool onOwner() const;
+  void toOwner(std::function<void(AbortSignalObject&)> change);
+  void join(uint64_t id, std::function<void()> f);
+
+  const ContextRef owner_ = ExecutionContext::currentRef();
+  std::atomic<uint64_t> nextId_{1};
   std::vector<std::pair<uint64_t, std::function<void()>>> listeners_;
 };
 using AbortSignal = Ref<AbortSignalObject>;
@@ -45,6 +58,9 @@ struct AbortControllerObject : Object {
 };
 using AbortController = Ref<AbortControllerObject>;
 
+inline String toJsString(const AbortSignal&) { return String::fromLatin1("[object AbortSignal]"); }
+inline String toJsString(const AbortController&) { return String::fromLatin1("[object AbortController]"); }
+
 /// The default abort reason.
 Error abortError();
 

package/runtime/cpp/lucent/array.h

@@ -385,8 +385,6 @@ class Array {
   }
 
   const void* identity() const { return d_.get(); }
-  friend bool strictEquals(const Array& a, const Array& b) { return a.d_ == b.d_; }
-  friend String toJsString(const Array& a) { return a.join(); }
 
   /// Raw storage, for the JSI boundary and for-of loops.
   const std::vector<Elem>& items() const { return *d_; }
@@ -421,6 +419,18 @@ class Array {
   std::shared_ptr<std::vector<Elem>> d_;
 };
 
+/// String(array): its elements joined with ",".
+template <class T>
+String toJsString(const Array<T>& a) {
+  return a.join();
+}
+
+/// `===`: the same array.
+template <class T>
+bool strictEquals(const Array<T>& a, const Array<T>& b) {
+  return a.identity() == b.identity();
+}
+
 template <class T>
 struct IsArray : std::false_type {};
 template <class T>