@tokamakdev/plugin 0.1.0-beta.116 → 0.1.0-beta.118

package/README.md

@@ -115,8 +115,8 @@ host.emit("ring", event: ["id": alarm.id], timeout: 10) { result in
 
 ```kotlin
 // Blocks, so call it off the main thread.
-val reply = host.emit("ring", JSONObject().put("id", alarm.id).toString(), 10_000)
-// `reply` is the reply's JSON, "null" when no listener replies.
+val reply = host.emit("ring", JSONObject().put("id", alarm.id), 10_000)
+// `reply` is the reply, parsed from JSON, or null when no listener replies.
 ```
 
 `timeout` includes starting the runtime when the app is not running. `emit`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokamakdev/plugin",
-  "version": "0.1.0-beta.116",
+  "version": "0.1.0-beta.118",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mantty/tokamak.git",

package/src/bindings.ts

@@ -74,21 +74,11 @@ export class Bindings {
   /** The elements of the native sequence `member` of `target` returns. Cancelling the stream ends it. */
   stream<T>(target: TokamakContext | NativeObject, member: string, args: readonly unknown[]): ReadableStream<T> {
     const ctx = contextOf(target);
-    const elements = byteStream((next, error, close) => {
-      let stop: (() => void) | undefined;
-      let stopped = false;
-      request(ctx, target, args).then((payload) => {
-        if (stopped) return;
-        stop = ctx[nativeConnection].listen(this.#plugin, member, payload, {
-          next: (value, done) => { if (done) close(); else next(value); },
-          error,
-        });
-      }, error);
-      return () => {
-        stopped = true;
-        stop?.();
-      };
-    });
+    const elements = byteStream(async (next, error, close) =>
+      ctx[nativeConnection].listen(this.#plugin, member, await request(ctx, target, args), {
+        next: (value, done) => { if (done) close(); else next(value); },
+        error,
+      }));
     return elements.pipeThrough(new TransformStream<Uint8Array, T>({
       transform: (element, controller) => { controller.enqueue(this.#decode(ctx, element) as T); },
     }));
@@ -110,14 +100,10 @@ export class Bindings {
     const reference = await NativeReference.acquire(ctx, this.#plugin, protocol, payload, (value) => {
       const { method, arguments: args } = decodeJson<{ method: string; arguments: Wire[] }>(value);
       const classes = this.#classes();
-      try {
-        const handler = Reflect.get(handlers, method) as (...values: unknown[]) => unknown;
-        Promise.resolve(handler.apply(handlers, args.map((arg) => fromWire(arg, ctx, classes)))).catch((error: unknown) => {
-          reportError(error);
-        });
-      } catch (error) {
-        reportError(error);
-      }
+      const handler = Reflect.get(handlers, method) as (...values: unknown[]) => unknown;
+      // The constructor runs the handler now, and rejects with what it throws.
+      new Promise((resolve) => { resolve(handler.apply(handlers, args.map((arg) => fromWire(arg, ctx, classes)))); })
+        .catch((error: unknown) => { reportError(error); });
     });
     return new Protocol(reference);
   }

package/src/index.ts

@@ -1,5 +1,5 @@
-import { capabilitiesOf, nativeConnection, type CallOptions, type NativeConnection, type Overflow, type TokamakContext } from "./context.js";
-import { byteStream, type JsonStream } from "./streams.js";
+import { capabilitiesOf, nativeConnection, type CallOptions, type Overflow, type TokamakContext } from "./context.js";
+import { byteStream, jsonLine, type JsonStream } from "./streams.js";
 import { decodeJson, encodeJson } from "./codec.js";
 import { NativeReference } from "./resources.js";
 
@@ -24,12 +24,8 @@ export async function lifecycleStage(ctx: TokamakContext): Promise<LifecycleStag
 
 /** Native endpoint calls owned by the receiving invocation. */
 export abstract class Plugin {
-  private readonly connection: NativeConnection;
-
-  protected constructor(private readonly ctx: TokamakContext, private readonly pluginId: string) {
-    const connection = Reflect.get(ctx, nativeConnection) as NativeConnection | undefined;
-    if (!connection) throw new TypeError("A Tokamak invocation context is required");
-    this.connection = connection;
+  protected constructor(protected readonly ctx: TokamakContext, private readonly pluginId: string) {
+    if (!Reflect.has(ctx, nativeConnection)) throw new TypeError("A Tokamak invocation context is required");
   }
 
   protected async call<T>(method: string, value: unknown = null, options?: CallOptions): Promise<T> {
@@ -45,7 +41,7 @@ export abstract class Plugin {
   }
 
   protected callBytes(method: string, payload: Uint8Array, options?: CallOptions): Promise<Uint8Array> {
-    return this.connection.call(this.pluginId, method, payload, options);
+    return this.ctx[nativeConnection].call(this.pluginId, method, payload, options);
   }
 
   /** Retains the native object that the subscription `method` holds open, without copying it. */
@@ -63,12 +59,9 @@ export abstract class Plugin {
    * happens to values a slow reader has not taken: ending the stream, or dropping the oldest.
    */
   protected stream<T>(method: string, value: unknown = null, overflow: Overflow = "error"): JsonStream<T> {
-    return byteStream((next, error, close) => this.connection.listen(this.pluginId, method, encodeJson(value), {
+    return byteStream((next, error, close) => this.ctx[nativeConnection].listen(this.pluginId, method, encodeJson(value), {
       next(payload, done) {
-        const line = new Uint8Array(payload.byteLength + 1);
-        line.set(payload);
-        line[payload.byteLength] = 10;
-        next(line);
+        next(jsonLine(payload));
         if (done) close();
       },
       error,

package/src/streams.ts

@@ -1,7 +1,8 @@
 import { encodeJson } from "./codec.js";
 import type { Overflow } from "./context.js";
 
-type Source<T> = (next: (value: T) => void, error: (error: unknown) => void, close: () => void) => () => void;
+/** Starts a push source, returning or resolving to the function that stops it. */
+type Source<T> = (next: (value: T) => void, error: (error: unknown) => void, close: () => void) => (() => void) | Promise<() => void>;
 
 /** A byte stream of newline-delimited JSON values of type `T`, which `decodeValues` reads. */
 export type JsonStream<T> = ReadableStream<Uint8Array> & {
@@ -43,9 +44,9 @@ export function byteStream(subscribe: Source<Uint8Array>, overflow: Overflow = "
     wake();
   };
   return new ReadableStream<Uint8Array>({
-    start() {
+    async start() {
       try {
-        stop = subscribe(push, finish, () => { finish(); });
+        stop = await subscribe(push, finish, () => { finish(); });
         if (end) stop();
       } catch (error) { finish(error); }
     },
@@ -66,15 +67,19 @@ export function byteStream(subscribe: Source<Uint8Array>, overflow: Overflow = "
 export function valueStream<T>(subscribe: Source<T>, overflow: Overflow = "error"): JsonStream<T> {
   return byteStream((next, error, close) => subscribe((value) => {
     try {
-      const payload = encodeJson(value);
-      const line = new Uint8Array(payload.byteLength + 1);
-      line.set(payload);
-      line[payload.byteLength] = 10;
-      next(line);
+      next(jsonLine(encodeJson(value)));
     } catch (failure) { error(failure); }
   }, error, close), overflow);
 }
 
+/** `payload`, one encoded JSON value, as a line of a newline-delimited stream. */
+export function jsonLine(payload: Uint8Array): Uint8Array {
+  const line = new Uint8Array(payload.byteLength + 1);
+  line.set(payload);
+  line[payload.byteLength] = 10;
+  return line;
+}
+
 /** Decodes JSON values; ending iteration cancels the source. */
 export async function* decodeValues<T>(source: JsonStream<T> | Promise<JsonStream<T>>, signal: AbortSignal = new AbortController().signal): AsyncGenerator<T, void, unknown> {
   const reader = (await source).getReader();

package/src/testing.ts

@@ -96,9 +96,7 @@ export class FakeNativeTransport {
 
   /** Replies to the pending request `id`. A reply is the last unless `done` is false. */
   deliver(id: number, { value, error, done = true }: Answer): void {
-    const reply = this.pending.get(id);
-    if (done) this.pending.delete(id);
-    reply?.(encodeJson(value), error && nativeError(error), done);
+    this.reply(id, encodeJson(value), error && nativeError(error), done);
   }
 
   private cancel(id: number): void {
@@ -111,15 +109,24 @@ export class FakeNativeTransport {
   }
 
   respond(reply: { value?: unknown; error?: NativeFailure }, done = true): void {
-    this.respondBytes(encodeJson(reply.value), done, reply.error && nativeError(reply.error));
+    this.deliver(this.last(), { ...reply, done });
   }
 
   respondBytes(payload: Uint8Array, done = true, error?: DOMException): void {
+    this.reply(this.last(), payload.slice(), error, done);
+  }
+
+  /** The ID of the last request sent. */
+  private last(): number {
     const id = this.sent.at(-1)?.id;
     if (id === undefined) throw new Error("No native request is pending");
+    return id;
+  }
+
+  private reply(id: number, payload: Uint8Array, error: DOMException | undefined, done: boolean): void {
     const reply = this.pending.get(id);
     if (done) this.pending.delete(id);
-    reply?.(payload.slice(), error, done);
+    reply?.(payload, error, done);
   }
 }