v0.4.6

Fixed

• Define the cargo-dist [profile.dist] build profile so the prebuilt-binary /
  Homebrew release pipeline (added in 0.4.5) actually builds. 0.4.6 is the first
  release to publish kymo binaries and a populated Homebrew formula.

v0.4.5

Added

• Homebrew install for the kymo CLI. Prebuilt binaries (macOS arm64/x86_64,
  Linux x86_64/arm64) are now built on each release via cargo-dist and published
  as a formula in this repo:

  brew tap kymostudio/brew https://github.com/kymostudio/kymostudio
  brew install kymostudio        # the command stays `kymo`

v0.4.4

Changed

• New slogan across every package description and README: "Prompt it. See it
  appear. Watch it animate." (replaces "Type it. …").

Added

• Pure-Rust flowchart SVG rendering + D2 / DOT importers — the core's first
  flowchart renderer. kymostudio-core gains importers for D2 (crate::d2)
  and Graphviz DOT (crate::dot) — the inverses of the d2/dot emitters: they parse
  each language's flowchart subset (direction, node shapes, edges with labels/dash,
  containers → subgraphs) into the shared flowchart IR — and a pure-Rust flowchart
  SVG renderer (crate::flowchart_svg — outline shapes with interior labels,
  anchor-routed orthogonal edges, cluster regions). Together: d2_to_svg,
  dot_to_svg and mermaid_to_svg render entirely in Rust (no external d2 /
  dot binary) — the Rust CLI can now render flowcharts, not just convert. Also
  d2_to_kymojson / dot_to_kymojson (D2/DOT as kymo import sources). Surfaced on
  the kymo CLI (kymo flow.d2 / kymo flow.dot → flow.svg; kymo flow.mmd flow.svg) and via PyO3 + wasm (d2ToSvg / dotToSvg / mermaidToSvg + the
  *ToKymoJson importers). Output is the core's own flowchart look (not
  byte-identical to the Python/JS renderers). Validated by rasterizing through resvg.
• draw.io export (Diagram → mxGraph XML), a source-agnostic encoder. A new
  kymostudio-core encoder (drawio::to_drawio) turns any resolved diagram into a
  draw.io document that opens directly in app.diagrams.net — shaped (rectangle /
  ellipse / rhombus / hexagon / cylinder / stadium), laid-out, subgraph-clustered,
  edges auto-routed (dashed / no-arrow honoured). Per RES-PIPELINE-001 this is a
  pure encoder (it consumes only the positioned Diagram). Two entry points:
  mermaid_to_drawio (kymo flow.mmd flow.drawio) and drawio_from_kymojson
  (any .kymo.json model). Reaches every source via a --drawio flag on the
  Python CLI and a .drawio output on the JS CLI, both delegating to the one Rust
  encoder — so draw.io output is byte-identical across Python and JS. PyO3 + wasm
  bindings; non-flowchart shapes (icons / BPMN / AWS) degrade to a labelled
  rectangle. The Rust kymo CLI's converter dispatch is now a small {ext → fn}
  registry (a first step toward RES-PIPELINE-001's "registry, not if/elif").
• Native flowchart [DIR] { … } DSL block. Author a flowchart inline in a
  .kymo file — the block body is Mermaid flowchart syntax, laid out by the core
  (mirrors the bpmn { } block). Direction is optional (flowchart LR { … },
  default TD). Implemented in both Python (dsl.py) and JS (dsl.ts); see the
  KYMO-DSL grammar §6.11.
• Flowchart transpilation: mmd → {Mermaid, D2, DOT}. The core's flowchart
  parse model was lifted into a format-neutral flowchart IR (crate::flowchart)
  — a positionless node/edge/subgraph hub. New text emitters convert a Mermaid
  flowchart to D2, Graphviz DOT, or Mermaid (round-trip / normalize);
  each target lays the graph out itself, so no geometry is involved. Surfaced as
  Rust APIs (mermaid_to_d2 / mermaid_to_dot / mermaid_to_mermaid), the kymo
  CLI (output extension picks the target: kymo flow.mmd flow.d2 / flow.dot /
  norm.mmd), and PyO3 + wasm bindings (Python kymo._core.mermaid_to_d2 …; JS
  mermaidToD2 / mermaidToDot / normalizeMermaid). Golden + round-trip-fixpoint
  • determinism tests; DOT output validated against Graphviz.

v0.4.3

Added

• Mermaid rendering + CLI parity (Python/JS). The Phase-1 Mermaid importer
  is now usable end-to-end from both front-ends. The Python and JS renderers
  gain a diamond glyph and an icon-less flowchart-node path
  (box/circle/cylinder/badge/hex/diamond drawn with the label inside);
  flowchart CSS is injected conditionally so existing output stays byte-identical.
  kymo foo.mmd now renders in the Python CLI (cli.py → _core.import_mermaid)
  and JS CLI (render-cli.mjs → parseMermaid), and the vscode-extension
  previews/exports .mmd/.mermaid. The core's mermaid_to_kymojson binding
  ships in this release.
• Mermaid flowchart import (Rust core). kymostudio-core gains a Mermaid
  importer — the first parser/model/layout subsystem to live in the Rust engine
  (rather than being duplicated in Python and JS like BPMN). It parses Mermaid
  graph / flowchart source (directions TD/TB/BT/LR/RL; node shapes
  [] () ([]) [[]] [()] (()) {} {{}}; edges --> --- -.->
==> with |labels|; subgraph … end) and emits the resolved model as
  .kymo.json (the interchange format Python/JS already load). A layered
  (Sugiyama) layout — ported from bpmn_layout.py — positions the
  coordinate-less graph deterministically. Decision nodes ({}) introduce a new
  diamond shape. Exposed as a Rust API (mermaid_to_kymojson), the kymo CLI
  (kymo flow.mmd → flow.kymo.json), PyO3 (mermaid_to_kymojson) and wasm
  (mermaidToKymoJson). The output is byte-conformant with to_kymojson.
  Rendering it to SVG (the diamond glyph + icon-less flowchart nodes in the
  Python/JS renderers, and .mmd CLI dispatch) is a follow-up parity phase. See
  docs/specs/mermaid/ (FEAT-MERMAID-001) and docs/formats/mermaid/mermaid-mapping.md
  (MERMAID-MAP-001); samples samples/pipeline.mmd, samples/approval.mmd.

v0.4.2

Changed

• BPMN is now a single source of truth in kymostudio-core (Rust). Python and
  JS no longer carry their own BPMN ports — import, export, layout and rendering
  all delegate to the core (the wheel for Python, the wasm build for JS). The core
  gains BPMN bindings (bpmn_import / bpmn_export / bpmn_layout / bpmn_render,
  and the wasm bpmnImport / bpmnExport / bpmnLayout / bpmnRender) plus a
  model-JSON → Diagram deserializer. BPMN output is byte-identical across Python,
  JS and Rust.

Notes

• The JS library's synchronous BPMN entry points (parseBpmn / toBpmn /
  bpmnLayout, and parseDiagram on a bpmn { } source) now require the wasm core
  to be initialized once: await init() (browser) or initSync(bytes) (Node).
  renderSVG auto-initializes; the kymo CLI and the VS Code extension do it for
  you. The kymostudio-core dependency requirement is unchanged (^0.4).

v0.4.1

Changed

• Python & JS now require kymostudio-core ^0.4 (>=0.4,<0.5 / ^0.4),
  up from ^0.3. This activates the kymo … out.pdf SVG → vector PDF path in
  the Python and JS CLIs (it calls the core's svg_to_pdf, new in 0.4.0). The
  floor raise lands one release after 0.4.0 so the floor always points at an
  already-published core (docs/RELEASING.md); 0.4.0 published the core, so CI
  and installs now resolve it cleanly. No API changes.

v0.4.0

Added

• SVG → vector PDF. New svg_to_pdf in kymostudio-core (built on
  svg2pdf) converts an SVG to a one-page vector PDF — crisp at any zoom,
  selectable text, no --scale. CSS-class-aware like the PNG path. svg2pdf
  brings its own usvg 0.45, kept behind a pdf cargo feature alongside the
  resvg 0.47 PNG path (native only; the wasm build also enables it for the JS
  CLI). Exposed to Python (PyO3 svg_to_pdf) and JS (wasm svgToPdf).
• kymo <input> out.pdf in all three CLIs. The output format follows the
  output extension (.pdf → vector PDF, otherwise PNG). An existing .svg
  converts directly; a .kymo/.bpmn/.kymo.json source is rendered then
  converted. Live now in the Rust kymo CLI (it depends on the 0.4 core).
  The Python and JS CLIs ship the .pdf path here too, but it activates once
  they run on a 0.4 core — their kymostudio-core floor is raised to ^0.4 in
  0.4.1 (until then kymo … out.pdf prints a "needs kymostudio-core ≥ 0.4"
  hint). See docs/RELEASING.md for why the floor lags one release.

v0.3.6

Added

• kymo <input> [output.png] [--scale N] SVG → PNG CLI in all three impls.
  An existing .svg rasterizes directly; a .kymo/.bpmn/.kymo.json source
  is rendered then rasterized (Python + JS). All three route through the one
  resvg engine in kymostudio-core, producing byte-identical PNG output.
• New packages/rust/kymostudio crate — the kymo CLI binary now lives in
  its own crate (published as kymostudio on crates.io → cargo install kymostudio); kymostudio-core is now a pure library. release-crate.yml
  gained a publish-cli job (publishes the CLI after the core, with retry for
  crates.io index lag).

Changed

• Python now depends only on kymostudio-core — dropped cairosvg; SVG→PNG
  (CLI + Excalidraw icon embedding) goes through the shared resvg engine.
• JS adds kymostudio-core (wasm) as its sole runtime dependency for the
  kymo CLI's PNG output; the library itself remains dependency-free.

Fixed

• PyPI kymostudio-core was stuck at 0.3.3. pyproject.toml pinned the
  version statically, so maturin rebuilt 0.3.3 every release. The version is now
  sourced dynamically from Cargo.toml (one source of truth), so each release
  publishes the correct wheel.

v0.3.5

Fixed

• release-crate.yml macOS wheel build — the macos-13 (Intel) runner was
  retired by GitHub on 2025-12-08, so that job queued forever and blocked the
  PyPI publish for kymostudio-core 0.3.4. Switched to macos-latest (arm64) +
  macos-15-intel (x86_64), matching linebender/resvg's CI. This release lands
  kymostudio-core on PyPI for the first time.

v0.3.4

Added

• New packages/rust/kymostudio-core — a pure-Rust SVG → PNG rasterizer
  built on resvg (no browser, no C deps). One core crate compiled to three
  targets via feature flags: the native kymo CLI, a Python extension (abi3
  wheel, _kymostudio_core), and a wasm package for browser + Node. Published
  to crates.io, PyPI, and npm as kymostudio-core. CI build matrix in
  .github/workflows/rust.yml; release via release-crate.yml.

Changed

• packages/python to_webp.py now prefers the in-repo _kymostudio_core
  rasterizer when installed, falling back to resvg-py — same engine, no
  behavior change.