brookmd 0.22.0

package/dist/worker-core.js

@@ -0,0 +1,155 @@
+class WorkerCore {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  // One parser per stream id; WASM is loaded once and shared by all of them.
+  parsers = /* @__PURE__ */ new Map();
+  config = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  totalAppended = /* @__PURE__ */ new Map();
+  finalizePending = /* @__PURE__ */ new Set();
+  // Per-stream generation, echoed on emitted patches so the client can drop a
+  // patch produced before a reset (see FromWorker.epoch). A microtask flush
+  // drains `pending` between messages, so the epoch at emit time is always the
+  // epoch the buffered input was appended under.
+  epochs = /* @__PURE__ */ new Map();
+  flushScheduled = false;
+  ready = false;
+  /** Handle one message from the main thread (append/finalize/reset/dispose). */
+  handle(msg) {
+    const id = msg.streamId;
+    if ((msg.type === "append" || msg.type === "finalize") && msg.config) {
+      this.config.set(id, msg.config);
+    }
+    if (msg.type !== "dispose" && msg.epoch !== void 0) {
+      this.epochs.set(id, msg.epoch);
+    }
+    switch (msg.type) {
+      case "append":
+        this.pending.set(id, (this.pending.get(id) ?? "") + msg.chunk);
+        this.scheduleFlush();
+        break;
+      case "finalize":
+        if (!this.ready) this.finalizePending.add(id);
+        else this.doFinalize(id);
+        break;
+      case "reset":
+        this.safeFree(id);
+        this.parsers.delete(id);
+        this.pending.delete(id);
+        this.finalizePending.delete(id);
+        this.totalAppended.delete(id);
+        break;
+      case "dispose":
+        this.dispose(id);
+        break;
+    }
+  }
+  /** Called once WASM init resolves: open the gate and drain what was buffered. */
+  markReady() {
+    this.ready = true;
+    this.deps.post({ type: "ready" });
+    if (this.pending.size > 0) this.flush();
+    if (this.finalizePending.size > 0) {
+      for (const id of this.finalizePending) this.doFinalize(id);
+      this.finalizePending.clear();
+    }
+  }
+  getOrCreate(streamId) {
+    let p = this.parsers.get(streamId);
+    if (!p) {
+      p = this.deps.makeParser(this.config.get(streamId));
+      this.parsers.set(streamId, p);
+    }
+    return p;
+  }
+  dispose(streamId) {
+    this.safeFree(streamId);
+    this.parsers.delete(streamId);
+    this.config.delete(streamId);
+    this.pending.delete(streamId);
+    this.finalizePending.delete(streamId);
+    this.totalAppended.delete(streamId);
+    this.epochs.delete(streamId);
+  }
+  /** free() a stream's parser, swallowing a throw from a poisoned WASM instance
+   *  so teardown can never escape the message loop. */
+  safeFree(streamId) {
+    try {
+      this.parsers.get(streamId)?.free();
+    } catch {
+    }
+  }
+  emitPatch(streamId, patch, parser, parseMicros, final) {
+    this.deps.post({
+      type: "patch",
+      streamId,
+      patch,
+      appendedBytes: this.totalAppended.get(streamId) ?? 0,
+      parseMicros,
+      retainedBytes: parser.retainedBytes(),
+      wasmMemoryBytes: this.deps.memBytes(),
+      final,
+      epoch: this.epochs.get(streamId)
+    });
+  }
+  scheduleFlush() {
+    if (this.flushScheduled || !this.ready) return;
+    this.flushScheduled = true;
+    this.deps.schedule(() => this.flush());
+  }
+  flush() {
+    this.flushScheduled = false;
+    if (!this.ready || this.pending.size === 0) return;
+    for (const [streamId, chunk] of this.pending) {
+      this.pending.delete(streamId);
+      if (chunk.length === 0) continue;
+      const t0 = performance.now();
+      try {
+        const parser = this.getOrCreate(streamId);
+        const patch = parser.append(chunk);
+        const dt = (performance.now() - t0) * 1e3;
+        this.totalAppended.set(streamId, (this.totalAppended.get(streamId) ?? 0) + chunk.length);
+        this.emitPatch(streamId, patch, parser, dt, false);
+      } catch (e) {
+        this.postParseError(streamId, e);
+      }
+    }
+  }
+  // Drain a stream's buffered input (if any), then finalize its parser. Shared by
+  // the `finalize` message path and markReady()'s post-ready drain.
+  doFinalize(streamId) {
+    const buffered = this.pending.get(streamId);
+    this.pending.delete(streamId);
+    try {
+      const parser = this.getOrCreate(streamId);
+      if (buffered && buffered.length > 0) {
+        const drained = parser.append(buffered);
+        this.totalAppended.set(streamId, (this.totalAppended.get(streamId) ?? 0) + buffered.length);
+        this.emitPatch(streamId, drained, parser, 0, false);
+      }
+      const patch = parser.finalize();
+      this.emitPatch(streamId, patch, parser, 0, true);
+    } catch (e) {
+      this.postParseError(streamId, e);
+    }
+  }
+  // A WASM trap (stack overflow / unreachable / OOM) throws a
+  // WebAssembly.RuntimeError and POISONS the singleton instance shared by every
+  // stream on this worker — so it is escalated to `fatal`, which the pool treats
+  // as a worker-level failure (eviction + terminate). A plain Error (e.g. a
+  // parser-construction failure) stays a recoverable per-stream error.
+  postParseError(streamId, e) {
+    const fatal = typeof WebAssembly !== "undefined" && typeof WebAssembly.RuntimeError === "function" && e instanceof WebAssembly.RuntimeError;
+    this.deps.post({
+      type: "error",
+      streamId,
+      message: e instanceof Error ? e.message : String(e),
+      fatal
+    });
+  }
+}
+export {
+  WorkerCore
+};

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker.js

@@ -0,0 +1,49 @@
+import init, { BrookParser } from "./wasm/brook_md_core.js";
+import { WorkerCore } from "./worker-core.js";
+const wasmUrl = new URL("./wasm/brook_md_core_bg.wasm", import.meta.url);
+const ctx = self;
+let wasmExports = null;
+const core = new WorkerCore({
+  // Create + configure a parser for a stream. Omitted config fields fall back to
+  // the library defaults — autolinks + alerts on (LLM output is full of bare
+  // URLs and `> [!NOTE]` blocks), raw HTML escaped, footnotes/math off.
+  makeParser(c) {
+    const p = new BrookParser();
+    p.setGfmAutolinks(c?.gfmAutolinks ?? true);
+    p.setGfmAlerts(c?.gfmAlerts ?? true);
+    p.setGfmTagfilter(c?.gfmTagfilter ?? false);
+    p.setGfmFootnotes(c?.gfmFootnotes ?? false);
+    p.setGfmMath(c?.gfmMath ?? false);
+    p.setDirAuto(c?.dirAuto ?? false);
+    p.setA11y(c?.a11y ?? false);
+    p.setUnsafeHtml(c?.unsafeHtml ?? false);
+    p.setComponentTags(c?.componentTags ?? []);
+    p.setInlineComponentTags(c?.inlineComponentTags ?? []);
+    p.setHtmlSanitize(
+      c?.htmlAllowlist !== void 0 || c?.dropHtmlTags !== void 0,
+      c?.htmlAllowlist ?? [],
+      c?.dropHtmlTags ?? []
+    );
+    p.setBlockData(c?.blockData ?? false);
+    return p;
+  },
+  post: (msg) => ctx.postMessage(msg),
+  memBytes: () => {
+    try {
+      return wasmExports?.memory?.buffer?.byteLength ?? 0;
+    } catch {
+      return 0;
+    }
+  },
+  schedule: (fn) => queueMicrotask(fn)
+});
+ctx.addEventListener("message", (ev) => core.handle(ev.data));
+async function setup() {
+  try {
+    wasmExports = await init({ module_or_path: wasmUrl });
+    core.markReady();
+  } catch (e) {
+    ctx.postMessage({ type: "error", streamId: -1, message: e instanceof Error ? e.message : String(e), fatal: true });
+  }
+}
+setup();

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "brookmd",
+  "version": "0.22.0",
+  "description": "Zero-dep streaming markdown for the browser. Rust→WASM core, Web Worker per stream, incremental parse with speculative closure.",
+  "type": "module",
+  "sideEffects": ["./dist/worker.js", "./dist/styles.css"],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
+    "./client": { "types": "./dist/client.d.ts", "import": "./dist/client.js" },
+    "./react": { "types": "./dist/react.d.ts", "import": "./dist/react.js" },
+    "./server": { "types": "./dist/server.d.ts", "import": "./dist/server.js" },
+    "./server/react": { "types": "./dist/server-react.d.ts", "import": "./dist/server-react.js" },
+    "./dom": { "types": "./dist/dom.d.ts", "import": "./dist/dom.js" },
+    "./element": { "types": "./dist/element.d.ts", "import": "./dist/element.js" },
+    "./vue": { "types": "./dist/vue.d.ts", "import": "./dist/vue.js" },
+    "./svelte": { "types": "./dist/svelte.d.ts", "import": "./dist/svelte.js" },
+    "./solid": { "types": "./dist/solid.d.ts", "import": "./dist/solid.js" },
+    "./highlight": { "types": "./dist/hi.d.ts", "import": "./dist/hi.js" },
+    "./html-to-react": { "types": "./dist/html-to-react.d.ts", "import": "./dist/html-to-react.js" },
+    "./block-props": { "types": "./dist/block-props.d.ts", "import": "./dist/block-props.js" },
+    "./worker-core": { "types": "./dist/worker-core.d.ts", "import": "./dist/worker-core.js" },
+    "./types": { "types": "./dist/types.d.ts", "import": "./dist/types.js" },
+    "./styles.css": "./dist/styles.css",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "peerDependencies": {
+    "react": ">=18",
+    "vue": ">=3",
+    "svelte": ">=4",
+    "solid-js": "^1.8.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "esbuild": "^0.28.1",
+    "happy-dom": "^15.11.6",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "solid-js": "^1.8.0",
+    "svelte": "^4.2.0",
+    "typescript": "^5.6.3",
+    "vue": "^3.4.0"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "bun test",
+    "test:ssr-cold": "bun test/ssr-cold.mjs",
+    "test:consumer-smoke": "bash test/consumer-smoke/run.sh",
+    "typecheck:test": "tsc --noEmit -p tsconfig.test.json",
+    "prepublishOnly": "cd ../.. && bun run build:wasm && cd packages/brookmd && node scripts/build.mjs"
+  },
+  "keywords": ["markdown", "streaming", "wasm", "rust", "react", "vue", "svelte", "solid", "web-component", "custom-element", "incremental", "llm", "ai", "math", "katex", "latex", "bidi", "rtl"],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/siinghd/brookmd.git"
+  },
+  "homepage": "https://md.hsingh.app",
+  "bugs": {
+    "url": "https://github.com/siinghd/brookmd/issues"
+  }
+}