asciidoctor-ldl 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20802d92a457bdb984de019c20d9d44f26a325c0c511704c2d574e5f201fa4c3
-  data.tar.gz: 2572f3ff4960d43f228854f35005877f5cd28e6f6f57c621746b8fa3750f905d
+  metadata.gz: 153d82aa52e632c7db31b8a00b17330ce4a84b4c8fc29dfc8f1f88c90f9a041c
+  data.tar.gz: 92fe7029769a85ed463e99cdc6f9941fcfe38acac98bb379bf3bbe18d53971a3
 SHA512:
-  metadata.gz: 0cb60bae5692c098502337f8cc4aaec5c69ada73b6df5b9d5a614a32b3a0a4653e39b60e78ca03101f68bf45778c0a322aa4eb9299fa1726d943b43c34a8a5c8
-  data.tar.gz: a4b1228d7ce234a33fd7b18b48a54739791de5d2089736d70d5b84e184b8ccd355f7e9b34195824d1e177fdc4a353e49d6cc24254721df6a4b6a1c5ec2162020
+  metadata.gz: e959fecda528aad3d8f430cf560b5e5b254f726f802dc62417cb43e1b08bba92c8839b1f99a0abe61ddf3511edbe150d08bf163587782d1822e8430a67d5abde
+  data.tar.gz: 5827fc98af7d978bc4a66652203a556e3606319ac418e710a033a1f820c65c00f707d9caf5738319605b4793da18a29e94346112c979298d5c0064afd13527cc

data/CHANGELOG.md

@@ -6,6 +6,43 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-07-23
+
+### Changed
+
+- First release published from CI via trusted publishing for **both** the gem
+  (RubyGems) and the npm package. No functional changes since 0.2.0 (which was
+  the initial, manually published npm release; the gem's first release carrying
+  the 0.2.0 changes is this one).
+- The npm release workflow now skips publishing a version already on the
+  registry, so a re-triggered tag still attaches release assets without failing.
+
+## [0.2.0] - 2026-07-23
+
+### Added
+
+- **Asciidoctor.js extension**, published to npm as
+  `@openpowershift/asciidoctor-ldl`. It registers the same `[ldl]` block and
+  `ldl::` macro, honours the same attributes, and emits the same roles as the
+  Ruby gem. In Node it writes SVG/PNG files with identical content-hash names;
+  in the browser it embeds SVG inline. Ships as a single bundled JS file
+  (Node ESM + CJS and a browser build) with TypeScript declarations.
+- A shared, environment-agnostic rendering core (`render-core.mjs`) used by both
+  the gem's Node helper and the npm extension, so Ruby and JavaScript produce
+  **byte-identical** SVG and identical file names. A parity test suite asserts
+  this across formats, scale, theme, labels and font options.
+- A **standalone single-file build** (`@openpowershift/asciidoctor-ldl/standalone`,
+  and attached to each GitHub release as `asciidoctor-ldl-standalone.js`) with
+  the renderer bundled in. It renders SVG inline and synchronously — drop it into
+  Asciidoctor VS Code's `.asciidoctor/lib` with no `npm install` required.
+
+### Changed
+
+- The content-hash used for output file names now uses a canonical, cross-tool
+  serialization (this changes generated file names from earlier versions; output
+  content is unchanged aside from the name).
+- Gem and npm package versions are released in lockstep from a single tag.
+
 ## [0.1.2] - 2026-07-23
 
 ### Added
@@ -46,7 +83,9 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - Content-addressed caching with a digest sidecar so unchanged diagrams are not
   re-rendered.
 
-[Unreleased]: https://github.com/OpenPowerShift/asciidoctor-ldl/compare/v0.1.2...HEAD
+[Unreleased]: https://github.com/OpenPowerShift/asciidoctor-ldl/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/OpenPowerShift/asciidoctor-ldl/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/OpenPowerShift/asciidoctor-ldl/compare/v0.1.2...v0.2.0
 [0.1.2]: https://github.com/OpenPowerShift/asciidoctor-ldl/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/OpenPowerShift/asciidoctor-ldl/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/OpenPowerShift/asciidoctor-ldl/releases/tag/v0.1.0

data/README.adoc

@@ -25,6 +25,15 @@ TRIP = OVERCURRENT AND NOT BLOCK
 ....
 ----
 
+It ships in two forms that share a single rendering core, so a diagram and its
+options produce *byte-identical output* either way:
+
+* a *Ruby gem*, `asciidoctor-ldl` (the default examples below), and
+* an *Asciidoctor.js extension*, `@openpowershift/asciidoctor-ldl` on npm — see
+  <<use-with-asciidoctor-js>>.
+
+Both accept the same <<attributes,attributes>> and emit the same roles.
+
 toc::[]
 
 == How it works
@@ -144,6 +153,109 @@ the document):
 ldl::diagrams/trip-matrix.ldl[format=png,scale=2]
 ----
 
+[[use-with-asciidoctor-js]]
+== Use with Asciidoctor.js
+
+The extension is also published to npm as `@openpowershift/asciidoctor-ldl`, for
+https://docs.asciidoctor.org/asciidoctor.js/latest/[Asciidoctor.js] 4. It shares
+the same rendering core as the gem, so the same diagram and options yield
+byte-identical SVG and the same generated file names. It ships as a single
+bundled file (Node ESM + CommonJS, plus a browser build) with TypeScript types.
+
+[source,console]
+----
+$ npm install @openpowershift/asciidoctor-ldl @openpowershift/logic-diagram-language
+$ npm install @resvg/resvg-js        # only needed for format=png
+----
+
+The renderer (`@openpowershift/logic-diagram-language`) is a runtime dependency;
+`@resvg/resvg-js` is optional and only used for PNG.
+
+=== Programmatic use (Node)
+
+Rendering is asynchronous, so `convert` returns a promise — always `await` it.
+
+[source,js]
+----
+import { Extensions, convert } from '@asciidoctor/core'
+import ldl from '@openpowershift/asciidoctor-ldl'
+
+const registry = Extensions.create()
+ldl.register(registry)                 // or: ldl.register(registry, { packageDir })
+
+const html = await convert(source, {
+  extension_registry: registry,
+  safe: 'safe',
+})
+----
+
+Images are written under `imagesdir` (or `imagesoutdir`) exactly as the gem
+does, with identical content-hash file names and digest-sidecar caching.
+
+=== Command line
+
+[source,console]
+----
+$ npx asciidoctor -r @openpowershift/asciidoctor-ldl document.adoc
+----
+
+=== Browser
+
+A browser build is exported at `@openpowershift/asciidoctor-ldl/browser`. It
+renders *SVG only* (PNG needs a native rasteriser) and embeds the diagram
+*inline*; your bundler or import map must provide
+`@openpowershift/logic-diagram-language`.
+
+[source,js]
+----
+import { Extensions, convert } from '@asciidoctor/core'
+import ldl from '@openpowershift/asciidoctor-ldl/browser'
+
+const registry = Extensions.create()
+ldl.register(registry)
+const html = await convert(source, { extension_registry: registry })
+----
+
+=== Asciidoctor VS Code
+
+The https://marketplace.visualstudio.com/items?itemName=asciidoctor.asciidoctor-vscode[AsciiDoc]
+extension loads Asciidoctor.js extensions from `.asciidoctor/lib/**/*.js` in the
+workspace: it `require`s each file and calls its `register(registry)`. Enable
+*Enable Asciidoctor.js extensions registration*
+(`asciidoc.extensions.registerWorkspaceExtensions`) and trust the workspace when
+prompted. Diagrams render as inline SVG in the preview (PNG is not available
+there).
+
+*Option A — zero install (recommended).* Download
+`asciidoctor-ldl-standalone.js` from the
+https://github.com/OpenPowerShift/asciidoctor-ldl/releases[latest release] and
+save it as `<workspace>/.asciidoctor/lib/ldl.js`. It is a single self-contained
+file with the renderer bundled in — nothing to `npm install`, which is ideal
+when you cannot add packages. Reload the window; `[ldl]` blocks and `ldl::`
+macros render.
+
+*Option B — via npm.* Install into the workspace and point a loader file at the
+bundled *standalone* entry:
+
+[source,console]
+----
+$ npm install @openpowershift/asciidoctor-ldl @openpowershift/logic-diagram-language
+----
+
+[source,js]
+.<workspace>/.asciidoctor/lib/ldl.js
+----
+module.exports = require('@openpowershift/asciidoctor-ldl/standalone')
+----
+
+Use the `/standalone` subpath: it renders synchronously and inline, so it works
+regardless of which Asciidoctor.js version the editor bundles. (The default
+entry uses asynchronous rendering, which older bundled engines may not await.)
+
+NOTE: If your workspace `package.json` sets `"type": "module"`, also drop a
+`.asciidoctor/lib/package.json` containing `{ "type": "commonjs" }` so the `.js`
+loader file is treated as CommonJS.
+
 == Attributes
 
 Every option can be set on the individual block/macro, or document-wide using
@@ -379,26 +491,42 @@ $ asciidoctor-pdf  -r asciidoctor-ldl protection-scheme.adoc
 
 == Development
 
+The repository holds both implementations, sharing one rendering core
+(`lib/asciidoctor/ldl/js/render-core.mjs`):
+
+* the Ruby gem (`lib/`, `test/`), and
+* the Asciidoctor.js extension (`js/`, TypeScript, bundled with esbuild).
+
 [source,console]
 ----
+# Ruby gem
 $ bundle install
 $ (cd test/js && npm install)     # LDL package + resvg for the test suite
 $ bundle exec rake test           # Ruby unit + end-to-end tests
 $ bundle exec rake jstest         # Node helper tests
+
+# Asciidoctor.js extension
+$ (cd js && npm install)
+$ (cd js && npm run build)        # single bundled file per target → js/dist
+$ (cd js && npm test)             # extension + Ruby↔JS parity tests
 ----
 
-The Ruby end-to-end tests convert real AsciiDoc through Asciidoctor and assert on
-the generated files, roles and markup. They resolve the npm package from
-`test/js` (or `LDL_PACKAGE_DIR`) and skip cleanly if Node or the package is
-unavailable.
+The parity suite (`js/test/parity.test.mjs`) renders identical LDL through the
+Ruby CLI and the JS extension and asserts the generated files are byte-identical;
+it self-skips when the Ruby toolchain is absent.
 
 == Releasing
 
-Releases publish to RubyGems via https://guides.rubygems.org/trusted-publishing/[Trusted
-Publishing] (OIDC) — no API key is stored in the repository. Push a version tag
-(`git tag v0.1.0 && git push origin v0.1.0`) and the `Release` workflow builds,
-tests and publishes the gem. Configure the trusted publisher once on RubyGems to
-match `.github/workflows/release.yml`.
+Gem and npm package are versioned in *lockstep*: one `v<x.y.z>` tag releases both.
+
+* *RubyGems* via https://guides.rubygems.org/trusted-publishing/[Trusted
+  Publishing] (OIDC) — `.github/workflows/release.yml`.
+* *npm* (`@openpowershift/asciidoctor-ldl`) via npm Trusted Publishing (OIDC,
+  with provenance) — `.github/workflows/release-npm.yml`.
+
+Push a version tag (`git tag v0.2.0 && git push origin v0.2.0`) and both
+workflows build, test and publish. Configure the trusted publisher once on each
+of RubyGems and npm to match the respective workflow filename.
 
 == License
 

data/lib/asciidoctor/ldl/js/ldl_render.mjs

@@ -1,70 +1,26 @@
 #!/usr/bin/env node
-// ldl_render.mjs — render LDL source to SVG or PNG for the asciidoctor-ldl gem.
+// ldl_render.mjs — CLI wrapper the Ruby gem shells out to. It is a thin adapter
+// over the shared render core (render-core.mjs) and Node loader
+// (node-loader.mjs); the Asciidoctor.js extension uses the very same core, so
+// both integrations emit byte-identical output.
 //
-// Contract (kept deliberately small so the Ruby side is easy to drive):
+// Contract (driven by lib/asciidoctor/ldl/renderer.rb):
 //   * LDL source is read from stdin.
-//   * Options come from CLI flags (see parseArgs below).
+//   * Options come from CLI flags (see parseArgs).
 //   * The rendered artifact is written to the path given by --out.
-//   * On success nothing is written to stdout; a one-line JSON summary
-//     ({"format","width","height","out"}) is written to stderr for logging.
-//   * On failure a human-readable message is written to stderr and the
-//     process exits non-zero.
-//
-// SVG rendering is isomorphic (only needs @openpowershift/logic-diagram-language).
-// PNG rendering additionally needs @resvg/resvg-js, resolved lazily so an
-// SVG-only install never has to have it present.
+//   * On success a one-line JSON summary is written to stderr; on failure a
+//     human-readable message is written to stderr and the process exits non-zero.
 
 import { readFileSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { dirname, join, resolve, isAbsolute } from 'node:path';
-
-const PACKAGE = '@openpowershift/logic-diagram-language';
-
-// Resolve an installed package's ESM entry point from a base directory,
-// without relying on a `require` export condition (the LDL package is
-// ESM-only, so `require.resolve(pkg)` throws ERR_PACKAGE_PATH_NOT_EXPORTED).
-// The `./package.json` subpath *is* exported, so resolve that and read the
-// declared entry ourselves. Returns a file:// URL string, or null.
-function resolveEntryFrom(base, pkg) {
-  let pkgJsonPath;
-  try {
-    const req = createRequire(pathToFileURL(join(base, 'package.json')).href);
-    pkgJsonPath = req.resolve(`${pkg}/package.json`);
-  } catch (_) {
-    return null;
-  }
-  const meta = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
-  const dot = meta.exports && meta.exports['.'];
-  const entry =
-    (dot && typeof dot === 'object' && (dot.import || dot.default)) ||
-    (typeof dot === 'string' ? dot : null) ||
-    meta.module ||
-    meta.main ||
-    'index.js';
-  return pathToFileURL(resolve(dirname(pkgJsonPath), entry)).href;
-}
-
-// Candidate base directories to search, in priority order.
-function candidateBases(packageDir) {
-  const bases = [];
-  if (packageDir) bases.push(packageDir);
-  if (process.env.LDL_PACKAGE_DIR) bases.push(process.env.LDL_PACKAGE_DIR);
-  bases.push(process.cwd());
-  bases.push(dirname(fileURLToPath(import.meta.url)));
-  return bases;
-}
+import { isAbsolute, join } from 'node:path';
+import { renderSvg, renderBaseSvg, normalizeScale } from './render-core.mjs';
+import { loadLibrary, rasterisePng } from './node-loader.mjs';
 
 function parseArgs(argv) {
   const opts = {
-    format: 'svg',
-    scale: 1,
-    theme: 'light',
-    showIds: false,
-    showLabels: true,
-    out: null,
-    packageDir: null,
-    fontFamily: null,
+    format: 'svg', scale: 1, theme: 'light',
+    showIds: false, showLabels: true,
+    fontFamily: null, out: null, packageDir: null,
   };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -77,153 +33,38 @@ function parseArgs(argv) {
       case '--no-show-ids': opts.showIds = false; break;
       case '--show-labels': opts.showLabels = true; break;
       case '--no-show-labels': opts.showLabels = false; break;
+      case '--font-family': opts.fontFamily = next(); break;
       case '--out': opts.out = next(); break;
       case '--package-dir': opts.packageDir = next(); break;
-      case '--font-family': opts.fontFamily = next(); break;
-      default:
-        throw new Error(`unknown argument: ${arg}`);
+      default: throw new Error(`unknown argument: ${arg}`);
     }
   }
   if (!opts.out) throw new Error('missing required --out <path>');
-  if (!Number.isFinite(opts.scale) || opts.scale <= 0) {
-    throw new Error(`invalid --scale: ${opts.scale}`);
-  }
+  normalizeScale(opts.scale); // validates
   if (opts.format !== 'svg' && opts.format !== 'png') {
     throw new Error(`unsupported --format: ${opts.format} (expected svg or png)`);
   }
   return opts;
 }
 
-// Resolve the LDL package from a set of candidate base directories, so it can
-// live in the user's project, a globally installed location, or a checkout
-// pointed at by --package-dir / LDL_PACKAGE_DIR.
-async function loadLibrary(packageDir) {
-  const tried = [];
-  for (const base of candidateBases(packageDir)) {
-    // Allow a base that points straight at a package checkout (…/lib/index.js).
-    for (const direct of [join(base, 'lib', 'index.js'), join(base, 'index.js')]) {
-      try {
-        return await import(pathToFileURL(direct).href);
-      } catch (e) { tried.push(`${direct} (${e.code || 'error'})`); }
-    }
-    // Otherwise resolve it as an installed dependency from that base.
-    const entry = resolveEntryFrom(base, PACKAGE);
-    if (entry) {
-      try {
-        return await import(entry);
-      } catch (e) { tried.push(`${entry} (${e.code || 'error'})`); }
-    } else {
-      tried.push(`${base}:${PACKAGE} (not found)`);
-    }
-  }
-  throw new Error(
-    `could not resolve ${PACKAGE}.\n` +
-    `Install it where your document is built, e.g.\n` +
-    `  npm install ${PACKAGE}\n` +
-    `or point the ldl-package-dir attribute / LDL_PACKAGE_DIR env var at it.\n` +
-    `Searched:\n  ${tried.join('\n  ')}`);
-}
-
-async function loadResvg(packageDir) {
-  for (const base of candidateBases(packageDir)) {
-    try {
-      const req = createRequire(pathToFileURL(join(base, 'package.json')).href);
-      return await import(pathToFileURL(req.resolve('@resvg/resvg-js')).href);
-    } catch (_) { /* try next */ }
-    const entry = resolveEntryFrom(base, '@resvg/resvg-js');
-    if (entry) {
-      try { return await import(entry); } catch (_) { /* try next */ }
-    }
-  }
-  throw new Error(
-    'PNG output needs @resvg/resvg-js, which was not found.\n' +
-    'Install it alongside the LDL package:\n' +
-    '  npm install @resvg/resvg-js\n' +
-    'or use format=svg (the default), which needs no extra dependency and is\n' +
-    'ideal for asciidoctor-pdf (vector, scalable, compact).');
-}
-
-// The renderer emits <svg viewBox="0 0 W H" …> with no intrinsic width/height.
-// Add them (scaled) so downstream consumers — prawn-svg in asciidoctor-pdf,
-// browsers, resvg — get a concrete size and the scale attribute is honoured.
-function sizeFromViewBox(svg) {
-  const m = svg.match(/viewBox="0 0 ([\d.]+) ([\d.]+)"/);
-  if (!m) return null;
-  return { width: parseFloat(m[1]), height: parseFloat(m[2]) };
-}
-
-// The renderer tags diagram text with font-family="sans-serif". Some consumers
-// map that generic family to a glyph-poor built-in font (e.g. prawn-svg in
-// asciidoctor-pdf uses Helvetica, which lacks − U+2212 and ≥ U+2265). Rewriting
-// it to a named font that the consumer has registered fixes those glyphs.
-function applyFontFamily(svg, family) {
-  if (!family) return svg;
-  const q = family.replace(/"/g, '&quot;');
-  return svg
-    .replace(/font-family="sans-serif"/g, `font-family="${q}"`)
-    .replace(/font-family:\s*sans-serif/g, `font-family:${family}`);
-}
-
-function applySvgScale(svg, scale) {
-  const size = sizeFromViewBox(svg);
-  if (!size) return { svg, size };
-  const w = size.width * scale;
-  const h = size.height * scale;
-  // Insert width/height right after "<svg"; drop the max-width/height clamp so
-  // an explicit size actually takes effect when embedded as an image.
-  const scaled = svg
-    .replace(/<svg/, `<svg width="${w}" height="${h}"`)
-    .replace(/\s*max-width:100%;max-height:100%;/, '');
-  return { svg: scaled, size: { width: w, height: h } };
-}
-
 async function main() {
   const opts = parseArgs(process.argv.slice(2));
   const source = readFileSync(0, 'utf8'); // fd 0 = stdin
-
   const lib = await loadLibrary(opts.packageDir);
-  const { parse, renderDiagram, resolveOptions, LIGHT_DIAGRAM, DARK_DIAGRAM } = lib;
-
-  const { diagram, errors } = parse(source);
-  if (errors && errors.length) {
-    const lines = errors.map((e) => {
-      const pos = e.position ? ` (line ${e.position.line}, col ${e.position.column})` : '';
-      return `  ${e.message}${pos}`;
-    });
-    throw new Error(`LDL parse error:\n${lines.join('\n')}`);
-  }
-
-  const renderOptions = resolveOptions(diagram.options);
-  renderOptions.showIds = opts.showIds;
-  renderOptions.showLabels = opts.showLabels;
-  const theme = opts.theme === 'dark' ? DARK_DIAGRAM : LIGHT_DIAGRAM;
-
-  let svg = applyFontFamily(renderDiagram(diagram, renderOptions, theme), opts.fontFamily);
-  const scaled = applySvgScale(svg, opts.scale);
-  svg = scaled.svg;
-  const size = scaled.size || { width: 0, height: 0 };
-
   const outPath = isAbsolute(opts.out) ? opts.out : join(process.cwd(), opts.out);
 
   if (opts.format === 'svg') {
+    const { svg, width, height } = renderSvg(lib, { ...opts, source });
     writeFileSync(outPath, svg, 'utf8');
-    process.stderr.write(JSON.stringify({ format: 'svg', width: size.width, height: size.height, out: outPath }) + '\n');
+    process.stderr.write(JSON.stringify({ format: 'svg', width, height, out: outPath }) + '\n');
     return;
   }
 
-  // PNG
-  const { Resvg } = await loadResvg(opts.packageDir);
-  // Rasterise from the *unscaled* viewBox using resvg's own zoom, so the scale
-  // multiplies device pixels crisply rather than baking a size into the SVG.
-  const base = applyFontFamily(renderDiagram(diagram, renderOptions, theme), opts.fontFamily);
-  const resvg = new Resvg(base, {
-    fitTo: { mode: 'zoom', value: opts.scale },
-    background: 'white',
-  });
-  const rendered = resvg.render();
-  const png = rendered.asPng();
-  writeFileSync(outPath, png);
-  process.stderr.write(JSON.stringify({ format: 'png', width: rendered.width, height: rendered.height, out: outPath }) + '\n');
+  // PNG: rasterise the unscaled base SVG with resvg's zoom.
+  const base = renderBaseSvg(lib, { ...opts, source });
+  const { data, width, height } = await rasterisePng(base, normalizeScale(opts.scale), opts.packageDir);
+  writeFileSync(outPath, data);
+  process.stderr.write(JSON.stringify({ format: 'png', width, height, out: outPath }) + '\n');
 }
 
 main().catch((err) => {

data/lib/asciidoctor/ldl/js/node-loader.mjs

@@ -0,0 +1,111 @@
+// node-loader.mjs — Node-only concerns for the LDL render core: resolving the
+// LDL library and @resvg/resvg-js from a set of candidate directories, and
+// rasterising SVG to PNG. Kept separate from render-core.mjs so the core stays
+// environment-agnostic (usable in the browser).
+
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+
+const PACKAGE = '@openpowershift/logic-diagram-language';
+
+// Resolve an installed package's ESM entry point from a base directory, without
+// relying on a `require` export condition (the LDL package is ESM-only, so
+// `require.resolve(pkg)` throws ERR_PACKAGE_PATH_NOT_EXPORTED). The
+// `./package.json` subpath *is* exported, so resolve that and read the declared
+// entry ourselves. Returns a file:// URL string, or null.
+function resolveEntryFrom(base, pkg) {
+  let pkgJsonPath;
+  try {
+    const req = createRequire(pathToFileURL(join(base, 'package.json')).href);
+    pkgJsonPath = req.resolve(`${pkg}/package.json`);
+  } catch (_) {
+    return null;
+  }
+  const meta = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+  const dot = meta.exports && meta.exports['.'];
+  const entry =
+    (dot && typeof dot === 'object' && (dot.import || dot.default)) ||
+    (typeof dot === 'string' ? dot : null) ||
+    meta.module ||
+    meta.main ||
+    'index.js';
+  return pathToFileURL(resolve(dirname(pkgJsonPath), entry)).href;
+}
+
+// The directory of this module, or null when unavailable (e.g. bundled into a
+// CommonJS file where import.meta.url is empty).
+function moduleDir() {
+  try {
+    return dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return null;
+  }
+}
+
+function candidateBases(packageDir) {
+  const bases = [];
+  if (packageDir) bases.push(packageDir);
+  if (process.env.LDL_PACKAGE_DIR) bases.push(process.env.LDL_PACKAGE_DIR);
+  bases.push(process.cwd());
+  const md = moduleDir();
+  if (md) bases.push(md);
+  return bases;
+}
+
+export async function loadLibrary(packageDir) {
+  const tried = [];
+  for (const base of candidateBases(packageDir)) {
+    for (const direct of [join(base, 'lib', 'index.js'), join(base, 'index.js')]) {
+      try {
+        return await import(pathToFileURL(direct).href);
+      } catch (e) { tried.push(`${direct} (${e.code || 'error'})`); }
+    }
+    const entry = resolveEntryFrom(base, PACKAGE);
+    if (entry) {
+      try {
+        return await import(entry);
+      } catch (e) { tried.push(`${entry} (${e.code || 'error'})`); }
+    } else {
+      tried.push(`${base}:${PACKAGE} (not found)`);
+    }
+  }
+  throw new Error(
+    `could not resolve ${PACKAGE}.\n` +
+    `Install it where your document is built, e.g.\n` +
+    `  npm install ${PACKAGE}\n` +
+    `or point the ldl-package-dir attribute / LDL_PACKAGE_DIR env var at it.\n` +
+    `Searched:\n  ${tried.join('\n  ')}`);
+}
+
+export async function loadResvg(packageDir) {
+  for (const base of candidateBases(packageDir)) {
+    try {
+      const req = createRequire(pathToFileURL(join(base, 'package.json')).href);
+      return await import(pathToFileURL(req.resolve('@resvg/resvg-js')).href);
+    } catch (_) { /* try next */ }
+    const entry = resolveEntryFrom(base, '@resvg/resvg-js');
+    if (entry) {
+      try { return await import(entry); } catch (_) { /* try next */ }
+    }
+  }
+  throw new Error(
+    'PNG output needs @resvg/resvg-js, which was not found.\n' +
+    'Install it alongside the LDL package:\n' +
+    '  npm install @resvg/resvg-js\n' +
+    'or use format=svg (the default), which needs no extra dependency and is\n' +
+    'ideal for asciidoctor-pdf (vector, scalable, compact).');
+}
+
+// Rasterise an SVG string to a PNG Buffer at `scale`× using resvg's zoom, so the
+// scale multiplies device pixels crisply. Returns { data, width, height }.
+export async function rasterisePng(baseSvg, scale, packageDir) {
+  const { Resvg } = await loadResvg(packageDir);
+  const resvg = new Resvg(baseSvg, {
+    fitTo: { mode: 'zoom', value: scale },
+    background: 'white',
+  });
+  const rendered = resvg.render();
+  return { data: rendered.asPng(), width: rendered.width, height: rendered.height };
+}

data/lib/asciidoctor/ldl/js/render-core.mjs

@@ -0,0 +1,123 @@
+// render-core.mjs — the environment-agnostic rendering core shared by the Ruby
+// gem's Node helper, the Asciidoctor.js extension (Node), and the browser build.
+//
+// It has NO Node-specific imports on purpose, so the exact same code runs in
+// every environment and both the Ruby and JavaScript integrations produce
+// byte-identical SVG. Anything that needs the filesystem or module resolution
+// lives in node-loader.mjs instead.
+//
+// The functions here take the *already-loaded* LDL library module
+// (`@openpowershift/logic-diagram-language`) as their first argument, so this
+// file never has to resolve or import it.
+
+// Keep this in lockstep with the Ruby DEFAULT_FONT_FAMILY (renderer.rb) and the
+// npm/gem version policy — see docs. Named real fonts first, ending in the
+// generic so browsers/resvg still resolve it; deliberately omits the PDF
+// built-ins so prawn-svg only uses one when it is actually registered.
+export const DEFAULT_FONT_FAMILY =
+  'DejaVu Sans, Bitstream Vera Sans, Liberation Sans, Arial, sans-serif';
+
+export class LdlParseError extends Error {}
+
+// The renderer tags diagram text font-family="sans-serif". Rewrite it to a named
+// family so consumers that map the generic family to a glyph-poor font (e.g.
+// prawn-svg → Helvetica, which lacks − U+2212 and ≥ U+2265) render correctly.
+export function applyFontFamily(svg, family) {
+  if (!family) return svg;
+  const q = String(family).replace(/"/g, '"');
+  return svg
+    .replace(/font-family="sans-serif"/g, `font-family="${q}"`)
+    .replace(/font-family:\s*sans-serif/g, `font-family:${family}`);
+}
+
+export function sizeFromViewBox(svg) {
+  const m = svg.match(/viewBox="0 0 ([\d.]+) ([\d.]+)"/);
+  if (!m) return null;
+  return { width: parseFloat(m[1]), height: parseFloat(m[2]) };
+}
+
+// Add explicit width/height (scaled from the viewBox) and drop the max-width
+// clamp, so an embedded image honours the size while the viewBox keeps it crisp.
+export function applySvgScale(svg, scale) {
+  const size = sizeFromViewBox(svg);
+  if (!size) return { svg, width: 0, height: 0 };
+  const width = size.width * scale;
+  const height = size.height * scale;
+  const scaled = svg
+    .replace(/<svg/, `<svg width="${width}" height="${height}"`)
+    .replace(/\s*max-width:100%;max-height:100%;/, '');
+  return { svg: scaled, width, height };
+}
+
+// Render LDL source to an SVG string at the diagram's intrinsic size (no scale
+// applied), with the font family rewritten. This is the single rendering path;
+// SVG output scales this, PNG output rasterises it.
+export function renderBaseSvg(lib, opts) {
+  const { parse, renderDiagram, resolveOptions, LIGHT_DIAGRAM, DARK_DIAGRAM } = lib;
+  const { source, theme = 'light', showIds = false, showLabels = true, fontFamily = null } = opts;
+
+  const { diagram, errors } = parse(source);
+  if (errors && errors.length) {
+    const lines = errors.map((e) => {
+      const pos = e.position ? ` (line ${e.position.line}, col ${e.position.column})` : '';
+      return `  ${e.message}${pos}`;
+    });
+    throw new LdlParseError(`LDL parse error:\n${lines.join('\n')}`);
+  }
+
+  const renderOptions = resolveOptions(diagram.options);
+  renderOptions.showIds = showIds;
+  renderOptions.showLabels = showLabels;
+  const themeObj = String(theme).toLowerCase() === 'dark' ? DARK_DIAGRAM : LIGHT_DIAGRAM;
+
+  return applyFontFamily(renderDiagram(diagram, renderOptions, themeObj), fontFamily);
+}
+
+// Render to a final SVG string (scaled). Returns { svg, width, height }.
+export function renderSvg(lib, opts) {
+  const scale = normalizeScale(opts.scale);
+  return applySvgScale(renderBaseSvg(lib, opts), scale);
+}
+
+// --- shared option / identity helpers (must match the Ruby side) ------------
+
+export function normalizeScale(scale) {
+  const n = Number(scale == null || scale === '' ? 1 : scale);
+  if (!Number.isFinite(n) || n <= 0) throw new Error(`invalid scale: ${scale}`);
+  return n;
+}
+
+// Canonical %g-style number, matching Ruby's sprintf('%g', n) for the value
+// ranges scales take (no exponent for normal magnitudes): trailing zeros are
+// dropped. Used in the content digest so filenames match across Ruby and JS.
+export function canonicalScale(scale) {
+  const n = normalizeScale(scale);
+  if (Number.isInteger(n)) return String(n);
+  // Round like %g's 6 significant digits, then strip trailing zeros.
+  return parseFloat(n.toPrecision(6)).toString();
+}
+
+export function normalizeFontFamily(value) {
+  if (value == null) return DEFAULT_FONT_FAMILY;
+  const family = String(value).trim();
+  if (family === '' || family.toLowerCase() === 'none' || family.toLowerCase() === 'sans-serif') {
+    return null;
+  }
+  return family;
+}
+
+// The canonical material hashed to name the output file. MUST be identical to
+// the Ruby Renderer#digest input so a given diagram+options yields the same
+// file name whether rendered by the gem or the npm package.
+export function digestMaterial(opts) {
+  return [
+    opts.source,
+    opts.format,
+    canonicalScale(opts.scale),
+    String(opts.theme || 'light').toLowerCase(),
+    opts.showIds ? 'true' : 'false',
+    opts.showLabels ? 'true' : 'false',
+    opts.fontFamily || '',
+    opts.version,
+  ].join('\n');
+}

data/lib/asciidoctor/ldl/version.rb

@@ -2,6 +2,6 @@
 
 module Asciidoctor
   module Ldl
-    VERSION = '0.1.2'
+    VERSION = '0.2.1'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciidoctor-ldl
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Daniel Mulholland
@@ -78,6 +78,8 @@ files:
 - lib/asciidoctor/ldl.rb
 - lib/asciidoctor/ldl/extension.rb
 - lib/asciidoctor/ldl/js/ldl_render.mjs
+- lib/asciidoctor/ldl/js/node-loader.mjs
+- lib/asciidoctor/ldl/js/render-core.mjs
 - lib/asciidoctor/ldl/renderer.rb
 - lib/asciidoctor/ldl/version.rb
 homepage: https://github.com/OpenPowerShift/asciidoctor-ldl