@dormer/renderer-bridge 0.0.0-stage → 0.1.0

package/package.json

@@ -1,6 +1,18 @@
 {
   "name": "@dormer/renderer-bridge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The script the host injects into every page at document start (dependency-free IIFE)",
+  "type": "module",
+  "license": "Apache-2.0 OR MIT",
+  "files": [
+    "src/bridge.js"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/veerareddyvishal144/dormer.git",
+    "directory": "runtime/renderer-bridge"
+  }
+}

package/src/bridge.js

@@ -0,0 +1,164 @@
+// Dormer renderer bridge, injected by the host at document start (main frame only).
+// Placeholders are substituted by the host before injection:
+//   __DORMER_ROUTE__       window route id (number)
+//   __DORMER_STREAM_BASE__ base URL for pull-based stream chunks, e.g. dormer://ipc/stream
+//   __DORMER_IPC_BASE__    origin of the bulk path, e.g. dormer://ipc (POST <base>/call/<channel>)
+//   __DORMER_KEY__         per-window random key sent with custom-scheme requests
+//   __DORMER_PLATFORM__    "darwin" | "win32" | "linux"
+// Security model (ADR-0005): identity is stamped by the host from the delivering webview; nothing in
+// this script is trusted by the host. Everything here is captured in a closure before page code runs.
+(() => {
+  "use strict";
+  if (Object.prototype.hasOwnProperty.call(window, "dormer")) return;
+  const w = window;
+  // Capture the platform primitive directly (independent of other init scripts' ordering):
+  // WebKit: window.webkit.messageHandlers.ipc (registered by the host); WebView2: chrome.webview.
+  function resolvePost() {
+    try {
+      const h = w.webkit && w.webkit.messageHandlers && w.webkit.messageHandlers.ipc;
+      if (h && typeof h.postMessage === "function") return h.postMessage.bind(h);
+    } catch {}
+    try { if (w.chrome && w.chrome.webview && typeof w.chrome.webview.postMessage === "function") return w.chrome.webview.postMessage.bind(w.chrome.webview); } catch {}
+    try { if (w.ipc && typeof w.ipc.postMessage === "function") return w.ipc.postMessage.bind(w.ipc); } catch {}
+    return null;
+  }
+  const postRaw = resolvePost();
+  const JSONstringify = JSON.stringify, JSONparse = JSON.parse;
+  const Fetch = w.fetch.bind(w), PromiseCtor = w.Promise, MapCtor = w.Map, ReadableStreamCtor = w.ReadableStream;
+  const freeze = Object.freeze, defineProperty = Object.defineProperty;
+  const route = __DORMER_ROUTE__;
+  const streamBase = "__DORMER_STREAM_BASE__";
+  const ipcBase = "__DORMER_IPC_BASE__";
+  const key = "__DORMER_KEY__";
+  // Bulk path limits (ADR-0005 §3, PROTOCOL.md §8): one POST body stays under the 16 MiB frame cap;
+  // larger uploads are split into sequential calls carrying a trailing {__dormerChunk} argument.
+  const MAX_BULK_BODY = 16 * 1024 * 1024 - 4096;
+  const BULK_CHUNK = 8 * 1024 * 1024;
+  const encodeURI = w.encodeURIComponent;
+  const platform = "__DORMER_PLATFORM__";
+
+  const T = { REQ: 2, RES: 3, ERR: 4, EVT: 5, SUB: 6, UNSUB: 7, CANCEL: 11 };
+  const pending = new MapCtor();   // id -> {resolve, reject}
+  const listeners = new MapCtor(); // channel -> Set<fn>
+  let nextId = 1;                  // odd ids: renderer-initiated
+
+  class DormerError extends Error {
+    constructor(code, message, data, retry) { super(message); this.name = "DormerError"; this.code = code; this.data = data; this.retry = !!retry; }
+  }
+
+  function post(t, i, p) {
+    if (!postRaw) throw new DormerError("ENOTSUP", "bridge transport unavailable");
+    postRaw(JSONstringify({ t, i, p }));
+  }
+  function request(method, args, opts) {
+    return new PromiseCtor((resolve, reject) => {
+      const id = nextId; nextId = (nextId + 2) >>> 0 || 1;
+      pending.set(id, { resolve, reject });
+      const signal = opts && opts.signal;
+      if (signal) {
+        if (signal.aborted) { pending.delete(id); reject(new DormerError("ECANCELED", "aborted")); return; }
+        signal.addEventListener("abort", () => { if (pending.has(id)) { pending.delete(id); post(T.CANCEL, id); reject(new DormerError("ECANCELED", "aborted")); } }, { once: true });
+      }
+      try { post(T.REQ, id, { m: method, a: args }); } catch (e) { pending.delete(id); reject(e); }
+    });
+  }
+
+  function invoke(channel, ...args) { return request("ipc:" + channel, args); }
+  function invokeWith(opts, channel, ...args) { return request("ipc:" + channel, args, opts); }
+  function send(channel, ...args) { post(T.EVT, 0, { ch: "send:" + channel, data: args }); }
+  function on(channel, fn) {
+    let set = listeners.get(channel);
+    if (!set) { set = new Set(); listeners.set(channel, set); }
+    set.add(fn);
+    return () => { set.delete(fn); };
+  }
+  function once(channel, fn) { const off = on(channel, (...a) => { off(); fn(...a); }); return off; }
+  function off(channel, fn) { const set = listeners.get(channel); if (set) set.delete(fn); }
+
+  // Pull-based streaming: the host answers each chunk request with the next bytes from Node.
+  function stream(channel, ...args) {
+    let streamId = null, seq = 0, done = false;
+    const opened = request("ipc:" + channel, args).then((r) => {
+      if (!r || typeof r.__dormerStream !== "number") throw new DormerError("EINVAL", "handler is not a stream handler");
+      streamId = r.__dormerStream;
+    });
+    return new ReadableStreamCtor({
+      async pull(controller) {
+        await opened;
+        if (done) return;
+        const res = await Fetch(streamBase + "/" + streamId + "/" + (seq++) + "?k=" + key, { cache: "no-store" });
+        if (res.status === 204) { done = true; controller.close(); return; }
+        if (!res.ok) { done = true; const txt = await res.text(); controller.error(new DormerError(res.headers.get("x-dormer-code") || "EINTERNAL", txt || res.statusText)); return; }
+        const buf = new Uint8Array(await res.arrayBuffer());
+        if (buf.byteLength) controller.enqueue(buf);
+        if (res.headers.get("x-dormer-more") === "0") { done = true; controller.close(); }
+      },
+      cancel() { done = true; if (streamId !== null) post(T.CANCEL, streamId); },
+    }, { highWaterMark: 2 });
+  }
+
+  // Bulk/binary upload (ADR-0005 §3): POST the bytes to the host's custom scheme; the host forwards
+  // them to Node as the first argument (a Buffer) of `ipcMain.handle(channel, (e, bytes, ...args))`.
+  // The response is a Uint8Array when the handler returns a Buffer/Uint8Array, else the JSON value.
+  // Bodies above MAX_BULK_BODY are sent as sequential chunk calls; each call then receives an extra
+  // trailing argument {__dormerChunk: {upload, chunk, of, total}} and the result of the last call
+  // is returned. Handlers that accept large uploads must reassemble by `upload` id.
+  function toBytes(data) {
+    if (data instanceof Uint8Array) return data;
+    if (data instanceof ArrayBuffer) return new Uint8Array(data);
+    if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    throw new DormerError("EINVAL", "invokeBinary expects a Uint8Array or ArrayBuffer");
+  }
+  async function postBulk(channel, bytes, args, signal) {
+    const url = ipcBase + "/call/" + encodeURI("" + channel) + "?a=" + encodeURI(JSONstringify(args)) + "&k=" + key;
+    let res;
+    try { res = await Fetch(url, { method: "POST", body: bytes, cache: "no-store", signal }); }
+    catch (e) { if (e && e.name === "AbortError") throw new DormerError("ECANCELED", "aborted"); throw new DormerError("ECONNRESET", "bulk transport failed: " + (e && e.message || e)); }
+    if (!res.ok) {
+      let body = null; try { body = await res.json(); } catch {}
+      throw new DormerError(res.headers.get("x-dormer-code") || (body && body.c) || "EINTERNAL", (body && body.msg) || res.statusText || "error", body && body.data, body && body.retry);
+    }
+    const ct = res.headers.get("content-type") || "";
+    if (ct.indexOf("application/octet-stream") === 0) return new Uint8Array(await res.arrayBuffer());
+    const text = await res.text();
+    return text === "" ? null : JSONparse(text);
+  }
+  async function invokeBinaryWith(opts, channel, data, ...args) {
+    const bytes = toBytes(data);
+    const signal = opts && opts.signal;
+    if (bytes.byteLength <= MAX_BULK_BODY) return postBulk(channel, bytes, args, signal);
+    const of = Math.ceil(bytes.byteLength / BULK_CHUNK);
+    const upload = key.slice(0, 8) + "-" + Date.now().toString(36) + "-" + Math.floor(Math.random() * 1e9).toString(36);
+    let result = null;
+    for (let i = 0; i < of; i++) {
+      const part = bytes.subarray(i * BULK_CHUNK, Math.min(bytes.byteLength, (i + 1) * BULK_CHUNK));
+      result = await postBulk(channel, part, args.concat([{ __dormerChunk: { upload, chunk: i, of, total: bytes.byteLength } }]), signal);
+    }
+    return result;
+  }
+  function invokeBinary(channel, data, ...args) { return invokeBinaryWith(null, channel, data, ...args); }
+
+  // The backend died (host:app.backend-crashed): every pending request belongs to a process that is
+  // gone, so fail them now instead of hanging until the page reloads.
+  function failPending(code, message) {
+    const entries = [...pending.values()]; pending.clear();
+    for (const pr of entries) { try { pr.reject(new DormerError(code, message, undefined, true)); } catch {} }
+  }
+
+  // Host -> page entry point. Only ever called by the host with a JSON literal it produced.
+  function dispatch(json) {
+    let f; try { f = typeof json === "string" ? JSONparse(json) : json; } catch { return; }
+    if (!f || typeof f !== "object") return;
+    const p = f.p || {};
+    if (f.t === T.RES) { const pr = pending.get(f.i); if (pr) { pending.delete(f.i); pr.resolve(p.r); } }
+    else if (f.t === T.ERR) { const pr = pending.get(f.i); if (pr) { pending.delete(f.i); pr.reject(new DormerError(p.c || "EINTERNAL", p.msg || "error", p.data, p.retry)); } }
+    else if (f.t === T.EVT) {
+      if (p.ch === "host:app.backend-crashed") failPending("ECONNRESET", "backend crashed");
+      const set = listeners.get(p.ch); if (set) { const args = Array.isArray(p.data) ? p.data : [p.data]; for (const fn of [...set]) { try { fn(...args); } catch (e) { console.error("[dormer] listener threw", e); } } }
+    }
+  }
+
+  const api = freeze({ invoke, invokeWith, invokeBinary, invokeBinaryWith, send, on, once, off, stream, windowId: route, platform, DormerError, version: 1 });
+  defineProperty(w, "dormer", { value: api, writable: false, configurable: false, enumerable: false });
+  defineProperty(w, "__dormer", { value: freeze({ dispatch }), writable: false, configurable: false, enumerable: false });
+})();

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.