@gmb/bitmark-parser 6.0.1 → 6.1.0

package/dist/index.d.ts

@@ -22,8 +22,16 @@ interface ParseOptions {
     /** JSON output mode (default: `"optimized"`). */
     mode?: OutputMode;
 }
+/** Input format selector (adds auto-detection). */
+type InputFormat = "auto" | "bitmark" | "json";
+/** Concrete output format. */
+type OutputFormat = "bitmark" | "json";
 /** Options for the {@link convert} function. */
 interface ConvertOptions {
+    /** Input format (default: `"auto"`). */
+    inputFormat?: InputFormat;
+    /** Output format (default: `"auto"` — the opposite of the input). */
+    outputFormat?: OutputFormat | "auto";
     /** JSON output mode (default: `"optimized"`). */
     mode?: OutputMode;
     /** Include validation warnings in `parser.warnings` output (default: `false`). */
@@ -34,6 +42,104 @@ interface ConvertOptions {
     pretty?: boolean;
     /** Indent size for pretty-printing (default: `2`). */
     indent?: number;
+    /** Spaces around tag values in bitmark output, `0..=10` (default: `1`). */
+    spacesAroundValues?: number;
+}
+/** Options for the {@link optimize}, {@link fullize}, and {@link canonicalize} functions. */
+interface NormalizeOptions {
+    /** Output mode — used by {@link canonicalize} only (default: `"optimized"`). */
+    mode?: OutputMode;
+    /** Prettify JSON output (default: `false`). */
+    pretty?: boolean;
+    /** Indent size for pretty-printing (default: `2`). */
+    indent?: number;
+    /** Spaces around tag values in bitmark output, `0..=10` (default: `1`). */
+    spacesAroundValues?: number;
+}
+/** A patch operation. */
+type PatchOp = "set" | "create" | "delete" | "append";
+/**
+ * A patch entry. Either the verbose form `{ path, op, value? }` or the
+ * shorthand single-key object `{ "<path>": value }` (which means `set`).
+ *
+ * `path` addresses the bit JSON directly (e.g. `id`,
+ * `cards[2].question.instruction`, `id[-1]`). To modify bitmark, convert to
+ * JSON, patch, then convert back — `transform` does this when the output
+ * format is bitmark.
+ */
+type PatchEntry = {
+    path: string;
+    op: PatchOp;
+    value?: unknown;
+} | Record<string, unknown>;
+/** One bit's source slice within a bitmark document (from {@link splitBits}). */
+interface BitSlice {
+    index: number;
+    byteStart: number;
+    byteEnd: number;
+    source: string;
+}
+/**
+ * What a {@link PreHook} / {@link PostHook} sees for one bit, in its source
+ * format. `index` is the bit's 0-based position; `total` is the bit count.
+ */
+type BitView = {
+    format: "bitmark";
+    index: number;
+    total: number;
+    source: string;
+} | {
+    format: "json";
+    index: number;
+    total: number;
+    bit: unknown;
+};
+/**
+ * What a {@link PreHook} may return for a bit. All fields are optional; an
+ * empty result (or `void`) makes the hook a pure observer.
+ */
+interface PreHookResult {
+    /** Patches to apply to this bit, after any static `patch`. */
+    patches?: PatchEntry[];
+    /** Override the output format for this bit only. */
+    outputFormat?: OutputFormat;
+    /** Drop the bit from the output entirely. */
+    drop?: boolean;
+}
+/** Pre-processing hook: inspect a bit, optionally return modifications. */
+type PreHook = (view: BitView) => PreHookResult | void;
+/** Post-processing hook: observe a bit's input view and rendered output. */
+type PostHook = (view: BitView, output: string) => void;
+/** Options for the {@link transform} function. */
+interface TransformOptions {
+    /** Input format (default: `"auto"`). */
+    inputFormat?: InputFormat;
+    /** Output format (default: `"json"`). */
+    outputFormat?: OutputFormat;
+    /** Output mode (default: `"optimized"`). */
+    mode?: OutputMode;
+    /** A static patch applied to every bit (array of entries, or a JSON string). */
+    patch?: PatchEntry[] | string;
+    /**
+     * Per-bit pre-hook, run on the calling thread. Returns patches (applied
+     * after the static `patch`), an output-format override, or `drop`. Providing
+     * a `preHook` or `postHook` switches `transform` to the per-bit path; with
+     * neither, the whole document is transformed in a single pass.
+     */
+    preHook?: PreHook;
+    /** Per-bit post-hook, run on the calling thread after each bit is rendered. */
+    postHook?: PostHook;
+    /**
+     * Worker-thread count for {@link transformParallel} (Node only; default `4`).
+     * Ignored by the synchronous {@link transform}.
+     */
+    workers?: number;
+    /** Prettify JSON output (default: `false`). */
+    pretty?: boolean;
+    /** Indent size for pretty-printing (default: `2`). */
+    indent?: number;
+    /** Spaces around tag values in bitmark output, `0..=10` (default: `1`). */
+    spacesAroundValues?: number;
 }
 /** Text format for breakscape / unbreakscape operations. */
 type TextFormat = "bitmark++" | "plainText";
@@ -97,6 +203,60 @@ declare function parse(input: string, options?: ParseOptions): string;
  * array of structured parsed entries (`bit`, `parser`, `bitmark`).
  */
 declare function convert(input: string, options?: ConvertOptions): string;
+/**
+ * Re-emit input in its own (auto-detected) format at optimized mode.
+ *
+ * @param input - Bitmark or JSON input text.
+ * @returns Optimized output in the same format as the input.
+ */
+declare function optimize(input: string, options?: NormalizeOptions): string;
+/**
+ * Re-emit input in its own (auto-detected) format at full mode (all keys).
+ * Aliased as {@link expand}.
+ */
+declare function fullize(input: string, options?: NormalizeOptions): string;
+/** Alias of {@link fullize}. */
+declare const expand: typeof fullize;
+/**
+ * Re-emit input in its own (auto-detected) format in canonical form.
+ */
+declare function canonicalize(input: string, options?: NormalizeOptions): string;
+/**
+ * Count the bits in `input`, auto-detecting bitmark vs JSON.
+ *
+ * @throws If the input cannot be parsed.
+ */
+declare function countBits(input: string): number;
+/**
+ * Split a bitmark document into per-bit source slices.
+ *
+ * @returns Array of `{ index, byteStart, byteEnd, source }`.
+ */
+declare function splitBits(input: string): BitSlice[];
+/**
+ * Transform a document bit-by-bit: apply an optional static `patch` and/or
+ * per-bit `preHook`/`postHook`, then re-emit.
+ *
+ * With neither hook, the whole document is transformed in a single WASM pass
+ * (the fast path). When a `preHook` or `postHook` is supplied, `transform`
+ * drives the bits one at a time on the calling thread — the hook inspects each
+ * bit, may return patches / an output-format override / `drop`, and only data
+ * crosses into WASM. The patch may be an array of entries or a JSON string.
+ *
+ * @returns The transformed document, or an `error:`-prefixed string on failure.
+ */
+declare function transform(input: string, options?: TransformOptions): string;
+/**
+ * Parallel counterpart of {@link transform} (Node only). Fans the per-bit WASM
+ * compute across a `worker_threads` pool (`options.workers`, default `4`),
+ * while `preHook`/`postHook` still run on the calling thread. Output is
+ * identical to {@link transform}; this trades startup cost for throughput on
+ * large documents.
+ *
+ * @returns A Promise of the transformed document, or an `error:`-prefixed
+ * string on failure.
+ */
+declare function transformParallel(input: string, options?: TransformOptions): Promise<string>;
 /**
  * Breakscape text (escape bitmark special characters).
  *
@@ -123,9 +283,12 @@ declare function info(options?: InfoOptions): string;
 /**
  * Generate bitmark text from a JSON AST.
  *
- * @param _json - JSON string of the AST.
- * @throws Always throws — not yet implemented.
+ * The reverse pipeline: `JSON → json_to_ast → AST → ast_to_bitmark`.
+ *
+ * @param input - JSON string of the parsed bit entries (forward output shape).
+ * @param options - Generate options (e.g. `{ mode: "full" }`).
+ * @returns Bitmark text. On failure, an `error:`-prefixed string.
  */
-declare function generate(_json: string): string;
+declare function generate(input: string, options?: ParseOptions): string;
 
-export { type BreakscapeOptions, type ConvertOptions, type InfoFormat, type InfoOptions, type InfoType, type LexOptions, type LexStage, type OutputMode, type ParseOptions, type TextFormat, type TextLocation, breakscapeText, convert, generate, info, lex, parse, unbreakscapeText, version };
+export { type BitSlice, type BitView, type BreakscapeOptions, type ConvertOptions, type InfoFormat, type InfoOptions, type InfoType, type InputFormat, type LexOptions, type LexStage, type NormalizeOptions, type OutputFormat, type OutputMode, type ParseOptions, type PatchEntry, type PatchOp, type PostHook, type PreHook, type PreHookResult, type TextFormat, type TextLocation, type TransformOptions, breakscapeText, canonicalize, convert, countBits, expand, fullize, generate, info, lex, optimize, parse, splitBits, transform, transformParallel, unbreakscapeText, version };

package/dist/index.js

@@ -4,12 +4,206 @@ import { createRequire } from "module";
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "author": "Get More Brain Ltd <info@getmorebrain.com>",
   "license": "ISC",
   "description": "A parser for bitmark text, powered by WebAssembly."
 };
 
+// src/core/hooked-transform.ts
+function isError(s) {
+  return s.startsWith("error:");
+}
+function errorString(e) {
+  const m = e instanceof Error ? e.message : String(e);
+  return m.startsWith("error:") ? m : `error: ${m}`;
+}
+function stripArray(doc) {
+  const t = doc.trim();
+  return t.startsWith("[") && t.endsWith("]") ? t.slice(1, -1) : doc;
+}
+function normalisePatch(patch) {
+  if (patch === void 0) return [];
+  if (typeof patch === "string") {
+    const trimmed = patch.trim();
+    return trimmed === "" ? [] : JSON.parse(trimmed);
+  }
+  return patch;
+}
+function buildUnits(wasm2, input, inputIsBitmark) {
+  if (inputIsBitmark) {
+    const out2 = wasm2.split_bits(input);
+    if (isError(out2)) throw new Error(out2);
+    const slices = JSON.parse(out2);
+    return slices.map((s) => ({
+      view: { format: "bitmark", index: s.index, total: slices.length, source: s.source },
+      source: s.source
+    }));
+  }
+  const out = wasm2.split_json_bits(input);
+  if (isError(out)) throw new Error(out);
+  const envelopes = JSON.parse(out);
+  return envelopes.map((env, index) => ({
+    view: { format: "json", index, total: envelopes.length, bit: env.bit },
+    // Per-bit transform consumes a one-bit JSON document.
+    source: JSON.stringify([env])
+  }));
+}
+function planTransform(wasm2, input, options) {
+  const mode = options.mode ?? "optimized";
+  const output = options.outputFormat ?? "json";
+  const spacesAroundValues = options.spacesAroundValues ?? 1;
+  const indent = options.indent ?? 2;
+  const pretty = options.pretty ?? false;
+  const sel = options.inputFormat ?? "auto";
+  const inputIsBitmark = sel === "bitmark" || sel !== "json" && wasm2.is_bitmark(input);
+  const inputFormat = inputIsBitmark ? "bitmark" : "json";
+  const staticPatch = normalisePatch(options.patch);
+  const units = buildUnits(wasm2, input, inputIsBitmark);
+  const total = units.length;
+  const jobs = [];
+  const views = [];
+  for (let index = 0; index < total; index++) {
+    const { view, source } = units[index];
+    view.index = index;
+    view.total = total;
+    const result = options.preHook ? options.preHook(view) || {} : {};
+    if (result.drop) continue;
+    const patches = result.patches ? [...staticPatch, ...result.patches] : staticPatch;
+    jobs.push({
+      index,
+      source,
+      inputFormat,
+      outputFormat: result.outputFormat ?? output,
+      mode,
+      patchJson: JSON.stringify(patches),
+      spacesAroundValues
+    });
+    views.push(view);
+  }
+  return { jobs, views, output, pretty, indent };
+}
+function computeBit(wasm2, job) {
+  const out = wasm2.transform(
+    job.source,
+    job.inputFormat,
+    job.outputFormat,
+    job.mode,
+    job.patchJson,
+    false,
+    2,
+    job.spacesAroundValues
+  );
+  if (isError(out)) return out;
+  return job.outputFormat === "json" ? stripArray(out) : out;
+}
+function recombine(wasm2, elements, output, pretty, indent) {
+  if (output === "bitmark") return elements.join("\n");
+  const arr = `[${elements.join(",")}]`;
+  return pretty ? wasm2.prettify(arr, indent) : arr;
+}
+function runHookedTransform(wasm2, input, options) {
+  let plan;
+  try {
+    plan = planTransform(wasm2, input, options);
+  } catch (e) {
+    return errorString(e);
+  }
+  const rendered = [];
+  for (let i = 0; i < plan.jobs.length; i++) {
+    const element = computeBit(wasm2, plan.jobs[i]);
+    if (isError(element)) return element;
+    options.postHook?.(plan.views[i], element);
+    rendered.push(element);
+  }
+  return recombine(wasm2, rendered, plan.output, plan.pretty, plan.indent);
+}
+
+// src/core/parallel.ts
+async function orchestrateParallel(wasm2, input, options, runJobs) {
+  let plan;
+  try {
+    plan = planTransform(wasm2, input, options);
+  } catch (e) {
+    return errorString(e);
+  }
+  let elements;
+  try {
+    elements = await runJobs(plan.jobs, options.workers ?? 4);
+  } catch (e) {
+    return errorString(e);
+  }
+  for (let i = 0; i < elements.length; i++) {
+    if (isError(elements[i])) return elements[i];
+    options.postHook?.(plan.views[i], elements[i]);
+  }
+  return recombine(wasm2, elements, plan.output, plan.pretty, plan.indent);
+}
+
+// src/node/pool.ts
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
+function workerPath() {
+  return fileURLToPath(new URL("./worker-entry.cjs", import.meta.url));
+}
+function runJobsParallel(jobs, workers) {
+  if (jobs.length === 0) return Promise.resolve([]);
+  const poolSize = Math.max(1, Math.min(workers, jobs.length));
+  const path = workerPath();
+  return new Promise((resolve, reject) => {
+    const results = new Array(jobs.length);
+    let next = 0;
+    let settled = 0;
+    let done = false;
+    const pool = [];
+    const shutdown = () => {
+      for (const w of pool) void w.terminate();
+    };
+    const fail = (err) => {
+      if (done) return;
+      done = true;
+      shutdown();
+      reject(err);
+    };
+    const dispatch = (w) => {
+      if (done) return;
+      if (next >= jobs.length) return;
+      const id = next++;
+      w.postMessage({ id, job: jobs[id] });
+    };
+    for (let i = 0; i < poolSize; i++) {
+      const w = new Worker(path);
+      pool.push(w);
+      w.on("message", (res) => {
+        if (done) return;
+        if (!res.ok) {
+          fail(new Error(res.error ?? "worker job failed"));
+          return;
+        }
+        results[res.id] = res.element;
+        settled++;
+        if (settled === jobs.length) {
+          done = true;
+          shutdown();
+          resolve(results);
+          return;
+        }
+        dispatch(w);
+      });
+      w.on("error", fail);
+      w.on("exit", (code) => {
+        if (!done && code !== 0) fail(new Error(`worker exited with code ${code}`));
+      });
+    }
+    for (const w of pool) dispatch(w);
+  });
+}
+
+// src/node/transform-parallel.ts
+function runParallelTransform(wasm2, input, options) {
+  return orchestrateParallel(wasm2, input, options, runJobsParallel);
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var wasm = require2("../wasm/bitmark_wasm.js");
@@ -23,7 +217,58 @@ function parse(input, options = {}) {
   return wasm.parse(input, options.mode ?? "optimized");
 }
 function convert(input, options = {}) {
-  return wasm.convert(input, options.mode ?? "optimized", options.warnings ?? false, options.plainText ?? false, options.pretty ?? false, options.indent ?? 2);
+  return wasm.convert(
+    input,
+    options.inputFormat ?? "auto",
+    options.outputFormat ?? "auto",
+    options.mode ?? "optimized",
+    options.pretty ?? false,
+    options.indent ?? 2,
+    options.spacesAroundValues ?? 1
+  );
+}
+function optimize(input, options = {}) {
+  return wasm.optimize(input, options.pretty ?? false, options.indent ?? 2);
+}
+function fullize(input, options = {}) {
+  return wasm.fullize(input, options.pretty ?? false, options.indent ?? 2);
+}
+var expand = fullize;
+function canonicalize(input, options = {}) {
+  return wasm.canonicalize(
+    input,
+    options.mode ?? "optimized",
+    options.pretty ?? false,
+    options.indent ?? 2,
+    options.spacesAroundValues ?? 1
+  );
+}
+function countBits(input) {
+  const out = wasm.count_bits(input);
+  if (out.startsWith("error:")) throw new Error(out);
+  return Number.parseInt(out, 10);
+}
+function splitBits(input) {
+  return JSON.parse(wasm.split_bits(input));
+}
+function transform(input, options = {}) {
+  if (options.preHook || options.postHook) {
+    return runHookedTransform(wasm, input, options);
+  }
+  const patchJson = options.patch === void 0 ? "" : typeof options.patch === "string" ? options.patch : JSON.stringify(options.patch);
+  return wasm.transform(
+    input,
+    options.inputFormat ?? "auto",
+    options.outputFormat ?? "json",
+    options.mode ?? "optimized",
+    patchJson,
+    options.pretty ?? false,
+    options.indent ?? 2,
+    options.spacesAroundValues ?? 1
+  );
+}
+function transformParallel(input, options = {}) {
+  return runParallelTransform(wasm, input, options);
 }
 function breakscapeText(input, options = {}) {
   const format = options.format ?? "bitmark++";
@@ -43,16 +288,24 @@ function info(options = {}) {
   const indent = options.indent ?? 2;
   return wasm.info(infoType, format, bit, pretty, indent);
 }
-function generate(_json) {
-  throw new Error("generate is not yet implemented");
+function generate(input, options = {}) {
+  return wasm.convert(input, "json", "bitmark", options.mode ?? "optimized", false, 2, 1);
 }
 export {
   breakscapeText,
+  canonicalize,
   convert,
+  countBits,
+  expand,
+  fullize,
   generate,
   info,
   lex,
+  optimize,
   parse,
+  splitBits,
+  transform,
+  transformParallel,
   unbreakscapeText,
   version
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/generated/package_info.ts"],"sourcesContent":["// @zen-component: WASM-TSBindings\n\nimport { createRequire } from \"node:module\";\nimport { PACKAGE_INFO } from \"./generated/package_info.js\";\nimport type { LexOptions, ParseOptions, ConvertOptions, BreakscapeOptions, InfoOptions } from \"./types.js\";\nconst require = createRequire(import.meta.url);\nconst wasm = require(\"../wasm/bitmark_wasm.js\") as typeof import(\"../wasm/bitmark_wasm.js\");\n\nexport type { LexOptions, LexStage, ParseOptions, ConvertOptions, OutputMode, BreakscapeOptions, TextFormat, TextLocation, InfoOptions, InfoType, InfoFormat } from \"./types.js\";\n\n/**\n * Get the version of the @gmb/bitmark-parser library.\n *\n * @returns Version string (e.g. \"3.0.0\").\n */\nexport function version(): string {\n  return PACKAGE_INFO.version;\n}\n\n/**\n * Lex bitmark input text, returning one line per token.\n *\n * @param input  - The bitmark source text.\n * @param options - Lex options (e.g. `{ stage: \"lex\" }`).\n * @returns Token dump string (one token per line).\n */\nexport function lex(input: string, options: LexOptions = {}): string {\n  return wasm.lex(input, options.stage ?? \"lex\");\n}\n\n/**\n * Parse bitmark input text and return structured JSON entries.\n *\n * Each entry contains `bit`, `parser`, and `bitmark` fields.\n *\n * @param input - The bitmark source text.\n * @param options - Parse options (e.g. `{ mode: \"full\" }`).\n * @returns JSON string array of structured parsed entries.\n */\nexport function parse(input: string, options: ParseOptions = {}): string {\n  return wasm.parse(input, options.mode ?? \"optimized\");\n}\n\n/**\n * Auto-detect input format and convert between bitmark and JSON.\n *\n * @param input - Bitmark or JSON input text.\n * @param options - Convert options (e.g. `{ mode: \"full\", warnings: true }`).\n * @returns Converted output string. For bitmark input, this is a JSON string\n * array of structured parsed entries (`bit`, `parser`, `bitmark`).\n */\nexport function convert(input: string, options: ConvertOptions = {}): string {\n  return wasm.convert(input, options.mode ?? \"optimized\", options.warnings ?? false, options.plainText ?? false, options.pretty ?? false, options.indent ?? 2);\n}\n\n/**\n * Breakscape text (escape bitmark special characters).\n *\n * @param input - The text to breakscape.\n * @param options - Breakscape options (e.g. `{ format: \"plainText\", location: \"tag\" }`).\n * @returns Breakscaped text.\n */\nexport function breakscapeText(input: string, options: BreakscapeOptions = {}): string {\n  const format = options.format ?? \"bitmark++\";\n  const location = options.location ?? \"body\";\n  return wasm.breakscape_text(input, format, location);\n}\n\n/**\n * Unbreakscape text (unescape bitmark special characters).\n *\n * @param input - The text to unbreakscape.\n * @param options - Unbreakscape options (e.g. `{ format: \"plainText\", location: \"tag\" }`).\n * @returns Unbreakscaped text.\n */\nexport function unbreakscapeText(input: string, options: BreakscapeOptions = {}): string {\n  const format = options.format ?? \"bitmark++\";\n  const location = options.location ?? \"body\";\n  return wasm.unbreakscape_text(input, format, location);\n}\n\n/**\n * Query information about supported bit types.\n *\n * @param options - Info options (e.g. `{ infoType: \"bit\", format: \"json\", bit: \"cloze\" }`).\n * @returns Information string.\n */\nexport function info(options: InfoOptions = {}): string {\n  const infoType = options.infoType ?? \"list\";\n  const format = options.format ?? \"text\";\n  const bit = options.bit ?? \"\";\n  const pretty = options.pretty ?? false;\n  const indent = options.indent ?? 2;\n  return wasm.info(infoType, format, bit, pretty, indent);\n}\n\n/**\n * Generate bitmark text from a JSON AST.\n *\n * @param _json - JSON string of the AST.\n * @throws Always throws — not yet implemented.\n */\nexport function generate(_json: string): string {\n  throw new Error(\"generate is not yet implemented\");\n}\n","// This file is automatically generated. DO NOT EDIT.\n\n/* eslint-disable */\n\nexport const PACKAGE_INFO = {\n  \"name\": \"@gmb/bitmark-parser\",\n  \"version\": \"6.0.1\",\n  \"author\": \"Get More Brain Ltd <info@getmorebrain.com>\",\n  \"license\": \"ISC\",\n  \"description\": \"A parser for bitmark text, powered by WebAssembly.\"\n};\n"],"mappings":";AAEA,SAAS,qBAAqB;;;ACEvB,IAAM,eAAe;AAAA,EAC1B,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,UAAU;AAAA,EACV,WAAW;AAAA,EACX,eAAe;AACjB;;;ADLA,IAAMA,WAAU,cAAc,YAAY,GAAG;AAC7C,IAAM,OAAOA,SAAQ,yBAAyB;AASvC,SAAS,UAAkB;AAChC,SAAO,aAAa;AACtB;AASO,SAAS,IAAI,OAAe,UAAsB,CAAC,GAAW;AACnE,SAAO,KAAK,IAAI,OAAO,QAAQ,SAAS,KAAK;AAC/C;AAWO,SAAS,MAAM,OAAe,UAAwB,CAAC,GAAW;AACvE,SAAO,KAAK,MAAM,OAAO,QAAQ,QAAQ,WAAW;AACtD;AAUO,SAAS,QAAQ,OAAe,UAA0B,CAAC,GAAW;AAC3E,SAAO,KAAK,QAAQ,OAAO,QAAQ,QAAQ,aAAa,QAAQ,YAAY,OAAO,QAAQ,aAAa,OAAO,QAAQ,UAAU,OAAO,QAAQ,UAAU,CAAC;AAC7J;AASO,SAAS,eAAe,OAAe,UAA6B,CAAC,GAAW;AACrF,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,WAAW,QAAQ,YAAY;AACrC,SAAO,KAAK,gBAAgB,OAAO,QAAQ,QAAQ;AACrD;AASO,SAAS,iBAAiB,OAAe,UAA6B,CAAC,GAAW;AACvF,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,WAAW,QAAQ,YAAY;AACrC,SAAO,KAAK,kBAAkB,OAAO,QAAQ,QAAQ;AACvD;AAQO,SAAS,KAAK,UAAuB,CAAC,GAAW;AACtD,QAAM,WAAW,QAAQ,YAAY;AACrC,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,MAAM,QAAQ,OAAO;AAC3B,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,SAAS,QAAQ,UAAU;AACjC,SAAO,KAAK,KAAK,UAAU,QAAQ,KAAK,QAAQ,MAAM;AACxD;AAQO,SAAS,SAAS,OAAuB;AAC9C,QAAM,IAAI,MAAM,iCAAiC;AACnD;","names":["require"]}
+{"version":3,"sources":["../src/index.ts","../src/generated/package_info.ts","../src/core/hooked-transform.ts","../src/core/parallel.ts","../src/node/pool.ts","../src/node/transform-parallel.ts"],"sourcesContent":["// @zen-component: WASM-TSBindings\n\nimport { createRequire } from \"node:module\";\nimport { PACKAGE_INFO } from \"./generated/package_info.js\";\nimport { runHookedTransform, type HookedWasm } from \"./core/hooked-transform.js\";\nimport { runParallelTransform } from \"./node/transform-parallel.js\";\nimport type { LexOptions, ParseOptions, ConvertOptions, BreakscapeOptions, InfoOptions, NormalizeOptions, TransformOptions, BitSlice } from \"./types.js\";\nconst require = createRequire(import.meta.url);\nconst wasm = require(\"../wasm/bitmark_wasm.js\") as typeof import(\"../wasm/bitmark_wasm.js\");\n\nexport type { LexOptions, LexStage, ParseOptions, ConvertOptions, OutputMode, BreakscapeOptions, TextFormat, TextLocation, InfoOptions, InfoType, InfoFormat, InputFormat, OutputFormat, NormalizeOptions, TransformOptions, PatchOp, PatchEntry, BitSlice, BitView, PreHook, PostHook, PreHookResult } from \"./types.js\";\n\n/**\n * Get the version of the @gmb/bitmark-parser library.\n *\n * @returns Version string (e.g. \"3.0.0\").\n */\nexport function version(): string {\n  return PACKAGE_INFO.version;\n}\n\n/**\n * Lex bitmark input text, returning one line per token.\n *\n * @param input  - The bitmark source text.\n * @param options - Lex options (e.g. `{ stage: \"lex\" }`).\n * @returns Token dump string (one token per line).\n */\nexport function lex(input: string, options: LexOptions = {}): string {\n  return wasm.lex(input, options.stage ?? \"lex\");\n}\n\n/**\n * Parse bitmark input text and return structured JSON entries.\n *\n * Each entry contains `bit`, `parser`, and `bitmark` fields.\n *\n * @param input - The bitmark source text.\n * @param options - Parse options (e.g. `{ mode: \"full\" }`).\n * @returns JSON string array of structured parsed entries.\n */\nexport function parse(input: string, options: ParseOptions = {}): string {\n  return wasm.parse(input, options.mode ?? \"optimized\");\n}\n\n/**\n * Auto-detect input format and convert between bitmark and JSON.\n *\n * @param input - Bitmark or JSON input text.\n * @param options - Convert options (e.g. `{ mode: \"full\", warnings: true }`).\n * @returns Converted output string. For bitmark input, this is a JSON string\n * array of structured parsed entries (`bit`, `parser`, `bitmark`).\n */\nexport function convert(input: string, options: ConvertOptions = {}): string {\n  return wasm.convert(\n    input,\n    options.inputFormat ?? \"auto\",\n    options.outputFormat ?? \"auto\",\n    options.mode ?? \"optimized\",\n    options.pretty ?? false,\n    options.indent ?? 2,\n    options.spacesAroundValues ?? 1,\n  );\n}\n\n/**\n * Re-emit input in its own (auto-detected) format at optimized mode.\n *\n * @param input - Bitmark or JSON input text.\n * @returns Optimized output in the same format as the input.\n */\nexport function optimize(input: string, options: NormalizeOptions = {}): string {\n  return wasm.optimize(input, options.pretty ?? false, options.indent ?? 2);\n}\n\n/**\n * Re-emit input in its own (auto-detected) format at full mode (all keys).\n * Aliased as {@link expand}.\n */\nexport function fullize(input: string, options: NormalizeOptions = {}): string {\n  return wasm.fullize(input, options.pretty ?? false, options.indent ?? 2);\n}\n\n/** Alias of {@link fullize}. */\nexport const expand = fullize;\n\n/**\n * Re-emit input in its own (auto-detected) format in canonical form.\n */\nexport function canonicalize(input: string, options: NormalizeOptions = {}): string {\n  return wasm.canonicalize(\n    input,\n    options.mode ?? \"optimized\",\n    options.pretty ?? false,\n    options.indent ?? 2,\n    options.spacesAroundValues ?? 1,\n  );\n}\n\n/**\n * Count the bits in `input`, auto-detecting bitmark vs JSON.\n *\n * @throws If the input cannot be parsed.\n */\nexport function countBits(input: string): number {\n  const out = wasm.count_bits(input);\n  if (out.startsWith(\"error:\")) throw new Error(out);\n  return Number.parseInt(out, 10);\n}\n\n/**\n * Split a bitmark document into per-bit source slices.\n *\n * @returns Array of `{ index, byteStart, byteEnd, source }`.\n */\nexport function splitBits(input: string): BitSlice[] {\n  return JSON.parse(wasm.split_bits(input)) as BitSlice[];\n}\n\n/**\n * Transform a document bit-by-bit: apply an optional static `patch` and/or\n * per-bit `preHook`/`postHook`, then re-emit.\n *\n * With neither hook, the whole document is transformed in a single WASM pass\n * (the fast path). When a `preHook` or `postHook` is supplied, `transform`\n * drives the bits one at a time on the calling thread — the hook inspects each\n * bit, may return patches / an output-format override / `drop`, and only data\n * crosses into WASM. The patch may be an array of entries or a JSON string.\n *\n * @returns The transformed document, or an `error:`-prefixed string on failure.\n */\nexport function transform(input: string, options: TransformOptions = {}): string {\n  if (options.preHook || options.postHook) {\n    return runHookedTransform(wasm as unknown as HookedWasm, input, options);\n  }\n  const patchJson =\n    options.patch === undefined\n      ? \"\"\n      : typeof options.patch === \"string\"\n        ? options.patch\n        : JSON.stringify(options.patch);\n  return wasm.transform(\n    input,\n    options.inputFormat ?? \"auto\",\n    options.outputFormat ?? \"json\",\n    options.mode ?? \"optimized\",\n    patchJson,\n    options.pretty ?? false,\n    options.indent ?? 2,\n    options.spacesAroundValues ?? 1,\n  );\n}\n\n/**\n * Parallel counterpart of {@link transform} (Node only). Fans the per-bit WASM\n * compute across a `worker_threads` pool (`options.workers`, default `4`),\n * while `preHook`/`postHook` still run on the calling thread. Output is\n * identical to {@link transform}; this trades startup cost for throughput on\n * large documents.\n *\n * @returns A Promise of the transformed document, or an `error:`-prefixed\n * string on failure.\n */\nexport function transformParallel(input: string, options: TransformOptions = {}): Promise<string> {\n  return runParallelTransform(wasm as unknown as HookedWasm, input, options);\n}\n\n/**\n * Breakscape text (escape bitmark special characters).\n *\n * @param input - The text to breakscape.\n * @param options - Breakscape options (e.g. `{ format: \"plainText\", location: \"tag\" }`).\n * @returns Breakscaped text.\n */\nexport function breakscapeText(input: string, options: BreakscapeOptions = {}): string {\n  const format = options.format ?? \"bitmark++\";\n  const location = options.location ?? \"body\";\n  return wasm.breakscape_text(input, format, location);\n}\n\n/**\n * Unbreakscape text (unescape bitmark special characters).\n *\n * @param input - The text to unbreakscape.\n * @param options - Unbreakscape options (e.g. `{ format: \"plainText\", location: \"tag\" }`).\n * @returns Unbreakscaped text.\n */\nexport function unbreakscapeText(input: string, options: BreakscapeOptions = {}): string {\n  const format = options.format ?? \"bitmark++\";\n  const location = options.location ?? \"body\";\n  return wasm.unbreakscape_text(input, format, location);\n}\n\n/**\n * Query information about supported bit types.\n *\n * @param options - Info options (e.g. `{ infoType: \"bit\", format: \"json\", bit: \"cloze\" }`).\n * @returns Information string.\n */\nexport function info(options: InfoOptions = {}): string {\n  const infoType = options.infoType ?? \"list\";\n  const format = options.format ?? \"text\";\n  const bit = options.bit ?? \"\";\n  const pretty = options.pretty ?? false;\n  const indent = options.indent ?? 2;\n  return wasm.info(infoType, format, bit, pretty, indent);\n}\n\n/**\n * Generate bitmark text from a JSON AST.\n *\n * The reverse pipeline: `JSON → json_to_ast → AST → ast_to_bitmark`.\n *\n * @param input - JSON string of the parsed bit entries (forward output shape).\n * @param options - Generate options (e.g. `{ mode: \"full\" }`).\n * @returns Bitmark text. On failure, an `error:`-prefixed string.\n */\nexport function generate(input: string, options: ParseOptions = {}): string {\n  return wasm.convert(input, \"json\", \"bitmark\", options.mode ?? \"optimized\", false, 2, 1);\n}\n","// This file is automatically generated. DO NOT EDIT.\n\n/* eslint-disable */\n\nexport const PACKAGE_INFO = {\n  \"name\": \"@gmb/bitmark-parser\",\n  \"version\": \"6.1.0\",\n  \"author\": \"Get More Brain Ltd <info@getmorebrain.com>\",\n  \"license\": \"ISC\",\n  \"description\": \"A parser for bitmark text, powered by WebAssembly.\"\n};\n","// @zen-component: TS-HookedTransform\n\nimport type { BitView, OutputFormat, PatchEntry, TransformOptions } from \"../types.js\";\n\n/**\n * The minimal WASM surface the per-bit hook driver needs. Both the Node and\n * browser entry points satisfy this with their loaded module.\n */\nexport interface HookedWasm {\n  is_bitmark(input: string): boolean;\n  split_bits(input: string): string;\n  split_json_bits(input: string): string;\n  prettify(json: string, indent: number): string;\n  transform(\n    input: string,\n    inputFormat: string,\n    outputFormat: string,\n    mode: string,\n    patchJson: string,\n    pretty: boolean,\n    indent: number,\n    spacesAroundValues: number,\n  ): string;\n}\n\n/** A single bit's compute job: data only, safe to ship to a worker thread. */\nexport interface BitJob {\n  index: number;\n  source: string;\n  inputFormat: \"bitmark\" | \"json\";\n  outputFormat: OutputFormat;\n  mode: string;\n  patchJson: string;\n  spacesAroundValues: number;\n}\n\n/**\n * The result of running `preHook` over a document's bits: the compute `jobs`\n * for the bits that survived (in document order) and the matching `views`\n * (so `postHook` can be called per surviving bit), plus the document-level\n * recombination settings.\n */\nexport interface TransformPlan {\n  jobs: BitJob[];\n  views: BitView[];\n  output: OutputFormat;\n  pretty: boolean;\n  indent: number;\n}\n\nexport function isError(s: string): boolean {\n  return s.startsWith(\"error:\");\n}\n\n/**\n * Normalise a thrown value to an `error:`-prefixed string, without\n * double-prefixing a message that already carries the prefix (split helpers\n * surface WASM `error:` strings as thrown `Error`s).\n */\nexport function errorString(e: unknown): string {\n  const m = e instanceof Error ? e.message : String(e);\n  return m.startsWith(\"error:\") ? m : `error: ${m}`;\n}\n\n/** Strip the outer `[ … ]` of a compact one-element JSON array. */\nexport function stripArray(doc: string): string {\n  const t = doc.trim();\n  return t.startsWith(\"[\") && t.endsWith(\"]\") ? t.slice(1, -1) : doc;\n}\n\nfunction normalisePatch(patch: TransformOptions[\"patch\"]): PatchEntry[] {\n  if (patch === undefined) return [];\n  if (typeof patch === \"string\") {\n    const trimmed = patch.trim();\n    return trimmed === \"\" ? [] : (JSON.parse(trimmed) as PatchEntry[]);\n  }\n  return patch;\n}\n\nfunction buildUnits(\n  wasm: HookedWasm,\n  input: string,\n  inputIsBitmark: boolean,\n): { view: BitView; source: string }[] {\n  if (inputIsBitmark) {\n    const out = wasm.split_bits(input);\n    if (isError(out)) throw new Error(out);\n    const slices = JSON.parse(out) as { index: number; source: string }[];\n    return slices.map((s) => ({\n      view: { format: \"bitmark\", index: s.index, total: slices.length, source: s.source },\n      source: s.source,\n    }));\n  }\n  const out = wasm.split_json_bits(input);\n  if (isError(out)) throw new Error(out);\n  const envelopes = JSON.parse(out) as { bit?: unknown }[];\n  return envelopes.map((env, index) => ({\n    view: { format: \"json\", index, total: envelopes.length, bit: env.bit },\n    // Per-bit transform consumes a one-bit JSON document.\n    source: JSON.stringify([env]),\n  }));\n}\n\n/**\n * Split the document and run `preHook` (on the calling thread) for each bit,\n * producing the surviving compute jobs + their views. This is the main-thread\n * half shared by the sync and worker-pool drivers — only the resulting\n * data-only {@link BitJob}s ever cross to a worker.\n */\nexport function planTransform(\n  wasm: HookedWasm,\n  input: string,\n  options: TransformOptions,\n): TransformPlan {\n  const mode = options.mode ?? \"optimized\";\n  const output: OutputFormat = options.outputFormat ?? \"json\";\n  const spacesAroundValues = options.spacesAroundValues ?? 1;\n  const indent = options.indent ?? 2;\n  const pretty = options.pretty ?? false;\n\n  const sel = options.inputFormat ?? \"auto\";\n  const inputIsBitmark = sel === \"bitmark\" || (sel !== \"json\" && wasm.is_bitmark(input));\n  const inputFormat = inputIsBitmark ? \"bitmark\" : \"json\";\n\n  const staticPatch = normalisePatch(options.patch);\n  const units = buildUnits(wasm, input, inputIsBitmark);\n  const total = units.length;\n\n  const jobs: BitJob[] = [];\n  const views: BitView[] = [];\n  for (let index = 0; index < total; index++) {\n    const { view, source } = units[index];\n    view.index = index;\n    view.total = total;\n\n    const result = options.preHook ? options.preHook(view) || {} : {};\n    if (result.drop) continue;\n\n    const patches = result.patches ? [...staticPatch, ...result.patches] : staticPatch;\n    jobs.push({\n      index,\n      source,\n      inputFormat,\n      outputFormat: result.outputFormat ?? output,\n      mode,\n      patchJson: JSON.stringify(patches),\n      spacesAroundValues,\n    });\n    views.push(view);\n  }\n  return { jobs, views, output, pretty, indent };\n}\n\n/**\n * Compute one bit's rendered element synchronously via WASM. The per-bit\n * element is always compact JSON (the document is prettified once on\n * recombination). Returns an `error:`-prefixed string on failure.\n */\nexport function computeBit(wasm: HookedWasm, job: BitJob): string {\n  const out = wasm.transform(\n    job.source,\n    job.inputFormat,\n    job.outputFormat,\n    job.mode,\n    job.patchJson,\n    false,\n    2,\n    job.spacesAroundValues,\n  );\n  if (isError(out)) return out;\n  return job.outputFormat === \"json\" ? stripArray(out) : out;\n}\n\n/** Recombine per-bit elements into the final document, in document order. */\nexport function recombine(\n  wasm: HookedWasm,\n  elements: string[],\n  output: OutputFormat,\n  pretty: boolean,\n  indent: number,\n): string {\n  if (output === \"bitmark\") return elements.join(\"\\n\");\n  const arr = `[${elements.join(\",\")}]`;\n  return pretty ? wasm.prettify(arr, indent) : arr;\n}\n\n/**\n * Per-bit transform driver (synchronous, in-process): split the document, run\n * `preHook` for each bit on the calling thread, apply the static patch + any\n * hook patches, re-emit the bit, run `postHook`, then recombine in document\n * order.\n *\n * Hooks run synchronously on the calling thread; only data crosses into WASM.\n * Used when a `preHook`/`postHook` is supplied; the hookless path stays a\n * single `wasm.transform` call. Returns the document, or an `error:`-prefixed\n * string on failure.\n */\nexport function runHookedTransform(\n  wasm: HookedWasm,\n  input: string,\n  options: TransformOptions,\n): string {\n  let plan: TransformPlan;\n  try {\n    plan = planTransform(wasm, input, options);\n  } catch (e) {\n    return errorString(e);\n  }\n\n  const rendered: string[] = [];\n  for (let i = 0; i < plan.jobs.length; i++) {\n    const element = computeBit(wasm, plan.jobs[i]);\n    if (isError(element)) return element;\n    options.postHook?.(plan.views[i], element);\n    rendered.push(element);\n  }\n  return recombine(wasm, rendered, plan.output, plan.pretty, plan.indent);\n}\n","// @zen-component: TS-ParallelOrchestrator\n\nimport type { TransformOptions } from \"../types.js\";\nimport { type BitJob, errorString, type HookedWasm, isError, planTransform, recombine } from \"./hooked-transform.js\";\n\n/**\n * A platform pool: compute `jobs` across up to `workers` workers, returning the\n * rendered element per job in submission order. Node and browser supply their\n * own (worker_threads / Worker); the orchestration around it is shared.\n */\nexport type RunJobs = (jobs: BitJob[], workers: number) => Promise<string[]>;\n\n/**\n * Shared parallel transform orchestration. The main-thread half — split +\n * `preHook` + recombine + `postHook` — is identical to the sync driver; only\n * the data-only per-bit jobs cross to `runJobs` (the platform pool). Closures\n * (`preHook`/`postHook`) never leave the calling thread.\n *\n * Returns the document, or an `error:`-prefixed string on failure.\n */\nexport async function orchestrateParallel(\n  wasm: HookedWasm,\n  input: string,\n  options: TransformOptions,\n  runJobs: RunJobs,\n): Promise<string> {\n  let plan;\n  try {\n    plan = planTransform(wasm, input, options);\n  } catch (e) {\n    return errorString(e);\n  }\n\n  let elements: string[];\n  try {\n    elements = await runJobs(plan.jobs, options.workers ?? 4);\n  } catch (e) {\n    return errorString(e);\n  }\n\n  for (let i = 0; i < elements.length; i++) {\n    if (isError(elements[i])) return elements[i];\n    options.postHook?.(plan.views[i], elements[i]);\n  }\n  return recombine(wasm, elements, plan.output, plan.pretty, plan.indent);\n}\n","// @zen-component: TS-WorkerPool\n//\n// A fixed-size Node worker_threads pool that computes per-bit transform jobs in\n// parallel. Jobs are dispatched to idle workers; results are matched by id and\n// returned in submission order. The pool is short-lived (created per\n// transformParallel call) and terminated when all jobs settle.\n\nimport { fileURLToPath } from \"node:url\";\nimport { Worker } from \"node:worker_threads\";\nimport type { BitJob } from \"../core/hooked-transform.js\";\n\ninterface JobResult {\n  ok: boolean;\n  element?: string;\n  error?: string;\n}\n\n// The worker entry is emitted as a sibling CJS file in dist/ (see tsup config),\n// so a CJS-format worker runs regardless of how the package itself was loaded.\nfunction workerPath(): string {\n  return fileURLToPath(new URL(\"./worker-entry.cjs\", import.meta.url));\n}\n\n/**\n * Run `jobs` across up to `workers` worker threads, returning the rendered\n * element for each job in the **same order** as `jobs`. Rejects on the first\n * worker error or job error.\n */\nexport function runJobsParallel(jobs: BitJob[], workers: number): Promise<string[]> {\n  if (jobs.length === 0) return Promise.resolve([]);\n  const poolSize = Math.max(1, Math.min(workers, jobs.length));\n  const path = workerPath();\n\n  return new Promise<string[]>((resolve, reject) => {\n    const results = new Array<string>(jobs.length);\n    let next = 0;\n    let settled = 0;\n    let done = false;\n    const pool: Worker[] = [];\n\n    const shutdown = () => {\n      for (const w of pool) void w.terminate();\n    };\n    const fail = (err: Error) => {\n      if (done) return;\n      done = true;\n      shutdown();\n      reject(err);\n    };\n\n    const dispatch = (w: Worker) => {\n      if (done) return;\n      if (next >= jobs.length) return; // no more work for this worker\n      const id = next++;\n      w.postMessage({ id, job: jobs[id] });\n    };\n\n    for (let i = 0; i < poolSize; i++) {\n      const w = new Worker(path);\n      pool.push(w);\n      w.on(\"message\", (res: JobResult & { id: number }) => {\n        if (done) return;\n        if (!res.ok) {\n          fail(new Error(res.error ?? \"worker job failed\"));\n          return;\n        }\n        results[res.id] = res.element as string;\n        settled++;\n        if (settled === jobs.length) {\n          done = true;\n          shutdown();\n          resolve(results);\n          return;\n        }\n        dispatch(w);\n      });\n      w.on(\"error\", fail);\n      w.on(\"exit\", (code) => {\n        if (!done && code !== 0) fail(new Error(`worker exited with code ${code}`));\n      });\n    }\n\n    // Prime each worker with one job.\n    for (const w of pool) dispatch(w);\n  });\n}\n","// @zen-component: TS-TransformParallel\n//\n// Node-only parallel transform: the main-thread half (split + preHook +\n// recombine + postHook) is shared with the synchronous driver and the browser\n// pool via orchestrateParallel; only the per-bit WASM compute is fanned out\n// across a worker_threads pool.\n\nimport { orchestrateParallel } from \"../core/parallel.js\";\nimport type { HookedWasm } from \"../core/hooked-transform.js\";\nimport type { TransformOptions } from \"../types.js\";\nimport { runJobsParallel } from \"./pool.js\";\n\n/**\n * Parallel counterpart of `transform` on Node. `preHook`/`postHook` run on the\n * calling thread; only data-only jobs cross to the worker_threads pool.\n */\nexport function runParallelTransform(\n  wasm: HookedWasm,\n  input: string,\n  options: TransformOptions,\n): Promise<string> {\n  return orchestrateParallel(wasm, input, options, runJobsParallel);\n}\n"],"mappings":"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","names":["wasm","out","wasm","wasm","require"]}

package/dist/worker-entry.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var module$1 = require('module');
+var worker_threads = require('worker_threads');
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+var require2 = module$1.createRequire(importMetaUrl);
+var wasm = require2("../wasm/bitmark_wasm.js");
+function stripArray(doc) {
+  const t = doc.trim();
+  return t.startsWith("[") && t.endsWith("]") ? t.slice(1, -1) : doc;
+}
+worker_threads.parentPort?.on("message", (msg) => {
+  const { id, job } = msg;
+  try {
+    const out = wasm.transform(
+      job.source,
+      job.inputFormat,
+      job.outputFormat,
+      job.mode,
+      job.patchJson,
+      false,
+      2,
+      job.spacesAroundValues
+    );
+    if (out.startsWith("error:")) {
+      worker_threads.parentPort?.postMessage({ id, ok: false, error: out });
+      return;
+    }
+    const element = job.outputFormat === "json" ? stripArray(out) : out;
+    worker_threads.parentPort?.postMessage({ id, ok: true, element });
+  } catch (e) {
+    worker_threads.parentPort?.postMessage({ id, ok: false, error: `error: ${String(e)}` });
+  }
+});
+//# sourceMappingURL=worker-entry.cjs.map
+//# sourceMappingURL=worker-entry.cjs.map

package/dist/worker-entry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../node_modules/tsup/assets/cjs_shims.js","../src/node/worker-entry.ts"],"names":["require","createRequire","parentPort"],"mappings":";;;;;;AAKA,IAAM,gBAAA,GAAmB,MACvB,OAAO,QAAA,KAAa,WAAA,GAChB,IAAI,GAAA,CAAI,CAAA,KAAA,EAAQ,UAAU,CAAA,CAAE,CAAA,CAAE,IAAA,GAC7B,QAAA,CAAS,aAAA,IAAiB,QAAA,CAAS,aAAA,CAAc,OAAA,CAAQ,WAAA,EAAY,KAAM,QAAA,GAC1E,QAAA,CAAS,aAAA,CAAc,GAAA,GACvB,IAAI,GAAA,CAAI,SAAA,EAAW,QAAA,CAAS,OAAO,CAAA,CAAE,IAAA;AAEtC,IAAM,gCAAgC,gBAAA,EAAiB;ACD9D,IAAMA,QAAAA,GAAUC,uBAAc,aAAe,CAAA;AAE7C,IAAM,IAAA,GAAOD,SAAQ,yBAAyB,CAAA;AAkB9C,SAAS,WAAW,GAAA,EAAqB;AACvC,EAAA,MAAM,CAAA,GAAI,IAAI,IAAA,EAAK;AACnB,EAAA,OAAO,CAAA,CAAE,UAAA,CAAW,GAAG,CAAA,IAAK,CAAA,CAAE,QAAA,CAAS,GAAG,CAAA,GAAI,CAAA,CAAE,KAAA,CAAM,CAAA,EAAG,EAAE,CAAA,GAAI,GAAA;AACjE;AAEAE,yBAAA,EAAY,EAAA,CAAG,SAAA,EAAW,CAAC,GAAA,KAAoB;AAC7C,EAAA,MAAM,EAAE,EAAA,EAAI,GAAA,EAAI,GAAI,GAAA;AACpB,EAAA,IAAI;AACF,IAAA,MAAM,MAAM,IAAA,CAAK,SAAA;AAAA,MACf,GAAA,CAAI,MAAA;AAAA,MACJ,GAAA,CAAI,WAAA;AAAA,MACJ,GAAA,CAAI,YAAA;AAAA,MACJ,GAAA,CAAI,IAAA;AAAA,MACJ,GAAA,CAAI,SAAA;AAAA,MACJ,KAAA;AAAA,MACA,CAAA;AAAA,MACA,GAAA,CAAI;AAAA,KACN;AACA,IAAA,IAAI,GAAA,CAAI,UAAA,CAAW,QAAQ,CAAA,EAAG;AAC5B,MAAAA,yBAAA,EAAY,YAAY,EAAE,EAAA,EAAI,IAAI,KAAA,EAAO,KAAA,EAAO,KAAK,CAAA;AACrD,MAAA;AAAA,IACF;AACA,IAAA,MAAM,UAAU,GAAA,CAAI,YAAA,KAAiB,MAAA,GAAS,UAAA,CAAW,GAAG,CAAA,GAAI,GAAA;AAChE,IAAAA,yBAAA,EAAY,YAAY,EAAE,EAAA,EAAI,EAAA,EAAI,IAAA,EAAM,SAAS,CAAA;AAAA,EACnD,SAAS,CAAA,EAAG;AACV,IAAAA,yBAAA,EAAY,WAAA,CAAY,EAAE,EAAA,EAAI,EAAA,EAAI,KAAA,EAAO,KAAA,EAAO,CAAA,OAAA,EAAU,MAAA,CAAO,CAAC,CAAC,CAAA,CAAA,EAAI,CAAA;AAAA,EACzE;AACF,CAAC,CAAA","file":"worker-entry.cjs","sourcesContent":["// Shim globals in cjs bundle\n// There's a weird bug that esbuild will always inject importMetaUrl\n// if we export it as `const importMetaUrl = ... __filename ...`\n// But using a function will not cause this issue\n\nconst getImportMetaUrl = () => \n  typeof document === \"undefined\" \n    ? new URL(`file:${__filename}`).href \n    : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT') \n      ? document.currentScript.src \n      : new URL(\"main.js\", document.baseURI).href;\n\nexport const importMetaUrl = /* @__PURE__ */ getImportMetaUrl()\n","// @zen-component: TS-WorkerEntry\n//\n// Node worker_threads entry for the parallel transform pool. Each worker loads\n// its own WASM instance and computes one bit at a time: it receives a data-only\n// job ({ source, formats, patches }) and returns the rendered element. Hooks\n// (JS closures) never reach here — they run on the main thread.\n\nimport { createRequire } from \"node:module\";\nimport { parentPort } from \"node:worker_threads\";\nimport type { BitJob } from \"../core/hooked-transform.js\";\n\nconst require = createRequire(import.meta.url);\n// Bundled to dist/worker-entry.cjs; the wasm glue sits at <pkg>/wasm/.\nconst wasm = require(\"../wasm/bitmark_wasm.js\") as {\n  transform(\n    input: string,\n    inputFormat: string,\n    outputFormat: string,\n    mode: string,\n    patchJson: string,\n    pretty: boolean,\n    indent: number,\n    spacesAroundValues: number,\n  ): string;\n};\n\ninterface JobMessage {\n  id: number;\n  job: BitJob;\n}\n\nfunction stripArray(doc: string): string {\n  const t = doc.trim();\n  return t.startsWith(\"[\") && t.endsWith(\"]\") ? t.slice(1, -1) : doc;\n}\n\nparentPort?.on(\"message\", (msg: JobMessage) => {\n  const { id, job } = msg;\n  try {\n    const out = wasm.transform(\n      job.source,\n      job.inputFormat,\n      job.outputFormat,\n      job.mode,\n      job.patchJson,\n      false,\n      2,\n      job.spacesAroundValues,\n    );\n    if (out.startsWith(\"error:\")) {\n      parentPort?.postMessage({ id, ok: false, error: out });\n      return;\n    }\n    const element = job.outputFormat === \"json\" ? stripArray(out) : out;\n    parentPort?.postMessage({ id, ok: true, element });\n  } catch (e) {\n    parentPort?.postMessage({ id, ok: false, error: `error: ${String(e)}` });\n  }\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmb/bitmark-parser",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "description": "A parser for bitmark text, powered by WebAssembly.",
   "author": "Get More Brain Ltd <info@getmorebrain.com>",
   "license": "ISC",
@@ -56,7 +56,8 @@
     "build:wasm": "bash scripts/build-wasm.sh",
     "build:ts": "npm run init && tsup",
     "build": "npm run version:check && npm run build:wasm && npm run build:ts",
-    "test": "node test/smoke.mjs && node --test test/cross-validate.mjs && node --test test/cli.test.mjs",
+    "test": "node test/smoke.mjs && node --test test/cross-validate.mjs && node --test test/cli.test.mjs && node --test test/unified.test.mjs && node --test test/parallel.test.mjs",
+    "test:browser": "bash scripts/run-browser-tests.sh",
     "test:browser-smoke": "bash scripts/launch-browser-smoke.sh",
     "test:browser-perf": "bash scripts/launch-browser-perf.sh",
     "test:cli-perf": "bash scripts/launch-cli-perf.sh",