panel-reactflow 0.4.0b1__tar.gz → 0.5.0a1__tar.gz

{panel_reactflow-0.4.0b1 → panel_reactflow-0.5.0a1}/.github/workflows/build.yml

@@ -11,11 +11,11 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
       - name: Set up pixi
-        uses: prefix-dev/setup-pixi@a0af7a228712d6121d37aba47adf55c1332c9c2e # v0.9.4
+        uses: prefix-dev/setup-pixi@d3f436a425481402e6a95a1d1fc10331c708cd9e # v0.10.2
         with:
           environments: build
       - name: Build project
@@ -23,7 +23,7 @@ jobs:
       - name: Check package
         run: pixi run -e build check-wheel
       - name: Upload package
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: artifact
           path: dist/*
@@ -37,9 +37,9 @@ jobs:
       id-token: write
     environment: pypi
     steps:
-      - uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: artifact
           path: dist
       - name: Publish package on PyPi
-        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2

{panel_reactflow-0.4.0b1 → panel_reactflow-0.5.0a1}/.github/workflows/docs.yml

@@ -43,23 +43,23 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
       - name: Set up Pixi
-        uses: prefix-dev/setup-pixi@a0af7a228712d6121d37aba47adf55c1332c9c2e # v0.9.4
+        uses: prefix-dev/setup-pixi@d3f436a425481402e6a95a1d1fc10331c708cd9e # v0.10.2
         with:
           environments: docs
       - name: Build documentation
         run: pixi run -e docs docs-build
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         if: always()
         with:
           name: docs
           if-no-files-found: error
           path: builtdocs
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v4
+        uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
         with:
           path: ./builtdocs
 
@@ -71,7 +71,7 @@ jobs:
     needs: build
     steps:
       - name: Deploy dev
-        uses: peaceiris/actions-gh-pages@v4
+        uses: peaceiris/actions-gh-pages@84c30a85c19949d7eee79c4ff27748b70285e453 # v4.1.0
         # Dev site built on PRs
         if: |
           (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository) ||
@@ -88,4 +88,4 @@ jobs:
           ((github.event_name == 'workflow_dispatch' && github.event.inputs.target == 'main') ||
           (github.event_name == 'push' && !(contains(steps.vars.outputs.tag, 'a') || contains(steps.vars.outputs.tag, 'b') || contains(steps.vars.outputs.tag, 'rc'))))
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0

{panel_reactflow-0.4.0b1 → panel_reactflow-0.5.0a1}/.github/workflows/test.yml

@@ -20,10 +20,10 @@ jobs:
       code_change: ${{ steps.filter.outputs.code }}
       matrix: ${{ env.MATRIX }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         if: github.event_name != 'pull_request'
       - name: Check for code changes
-        uses: dorny/paths-filter@v3
+        uses: dorny/paths-filter@ceb8a2b8f2d89434be7ff52d3de7ec3738c5cc9d # v4.0.3
         id: filter
         with:
           filters: |
@@ -72,7 +72,7 @@ jobs:
     name: Pixi lock
     runs-on: ubuntu-latest
     steps:
-      - uses: holoviz-dev/holoviz_tasks/pixi_lock@v0
+      - uses: holoviz-dev/holoviz_tasks/pixi-lock@8fb2d0a3e4c70e218d487e0eed3b9c2488997212 # v1.0.6
         with:
           cache: ${{ github.event.inputs.cache == 'true' || github.event.inputs.cache == '' }}
 
@@ -80,15 +80,15 @@ jobs:
     needs: [setup, pixi_lock]
     runs-on: "ubuntu-latest"
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Set up pixi
-        uses: prefix-dev/setup-pixi@v0.9.4
-      - uses: holoviz-dev/holoviz_tasks/pre-commit@v0
-      - uses: pre-commit/action@v3.0.1
+        uses: prefix-dev/setup-pixi@d3f436a425481402e6a95a1d1fc10331c708cd9e # v0.10.2
+      - uses: holoviz-dev/holoviz_tasks/pre-commit@8fb2d0a3e4c70e218d487e0eed3b9c2488997212 # v1.0.6
+      - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1
         if: needs.setup.outputs.img_change == 'true'
         with:
           extra_args: -a --hook-stage manual oxipng || true --
-      - uses: stefanzweifel/git-auto-commit-action@v7
+      - uses: stefanzweifel/git-auto-commit-action@4a55954c782fc1ea30b9056cd3e7a2b40ca8887d # v7.2.0
         if: needs.setup.outputs.img_change == 'true'
         with:
           commit_message: "Optimize PNG images (lossless)"
@@ -111,11 +111,11 @@ jobs:
           - windows-latest
     steps:
       - name: Checkout branch
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
       - name: Set up pixi
-        uses: prefix-dev/setup-pixi@a0af7a228712d6121d37aba47adf55c1332c9c2e # v0.9.4
+        uses: prefix-dev/setup-pixi@d3f436a425481402e6a95a1d1fc10331c708cd9e # v0.10.2
         with:
           environments: ${{ matrix.environment }}
       - name: Install repository
@@ -139,7 +139,7 @@ jobs:
       PANEL_LOG_LEVEL: info
       FAIL: "--screenshot only-on-failure --full-page-screenshot --output ui_screenshots --tracing retain-on-failure"
     steps:
-      - uses: holoviz-dev/holoviz_tasks/pixi_install@v0
+      - uses: holoviz-dev/holoviz_tasks/pixi-install@8fb2d0a3e4c70e218d487e0eed3b9c2488997212 # v1.0.6
         with:
           environments: ${{ matrix.environment }}
           install: false
@@ -151,14 +151,14 @@ jobs:
           echo "[run]\nconcurrency = greenlet" > .uicoveragerc
           pixi run -e ${{ matrix.environment }} test-ui $COV --cov-config=.uicoveragerc $FAIL
       - name: Upload UI Screenshots
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         if: always()
         with:
           name: ui_screenshots_${{ runner.os }}
           path: ./ui_screenshots
           if-no-files-found: ignore
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           slug: panel-extensions/panel-splitjs

{panel_reactflow-0.4.0b1 → panel_reactflow-0.5.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: panel-reactflow
-Version: 0.4.0b1
+Version: 0.5.0a1
 Summary: A Panel wrapper for the Reactflow JS library.
 Project-URL: Homepage, https://github.com/panel-extensions/panel-reactflow
 Project-URL: Source, https://github.com/panel-extensions/panel-reactflow

{panel_reactflow-0.4.0b1 → panel_reactflow-0.5.0a1}/docs/how-to/declare-types.md

@@ -6,6 +6,7 @@ kind of node/edge carries**. A type can provide:
 - a type name (`type`)
 - a display label (`label`)
 - node handles (`inputs` / `outputs`)
+- handle connectivity controls (`input_connectable*` / `output_connectable*`)
 - a schema for the `data` payload (`schema`)
 
 Types are separate from editors. A type defines structure; an editor defines
@@ -237,3 +238,159 @@ flow = ReactFlow(
 
 Types without a schema still work; they just do not get schema-driven
 validation or auto-generated forms.
+
+---
+
+## Handle tooltips
+
+By default, handles are plain connection points. You can add a tooltip (shown
+on hover) by passing a dict with `"id"` and `"label"` instead of a plain string:
+
+```python
+from panel_reactflow import NodeType
+
+node_types = {
+    "transform": NodeType(
+        type="transform",
+        label="Transform",
+        inputs=[{"id": "in", "label": "Data Input"}],
+        outputs=[
+            {"id": "success", "label": "Successful results"},
+            {"id": "error", "label": "Failed records"},
+        ],
+    ),
+}
+```
+
+Plain strings and dicts can be mixed freely in the same list:
+
+```python
+inputs=["simple_port", {"id": "documented_port", "label": "Hover to see this"}]
+```
+
+---
+
+## Control handle connectivity
+
+By default, all handles (inputs and outputs) are fully connectable — users can
+drag edges from or to any handle. Use the `*_connectable*` flags to restrict
+which connections are allowed.
+
+### Common patterns
+
+#### Data source (output only)
+
+A node that produces data but cannot accept incoming connections to its output:
+
+```python
+from panel_reactflow import NodeType
+
+source_type = NodeType(
+    type="data_source",
+    label="Data Source",
+    outputs=["data"],
+    output_connectable_start=True,   # Can drag FROM output
+    output_connectable_end=False,    # Cannot drag TO output
+)
+```
+
+#### Data sink (input only)
+
+A node that consumes data but cannot produce outgoing connections from its input:
+
+```python
+sink_type = NodeType(
+    type="data_sink",
+    label="Data Sink",
+    inputs=["data"],
+    input_connectable_start=False,   # Cannot drag FROM input
+    input_connectable_end=True,      # Can drag TO input
+)
+```
+
+#### Monitor node
+
+A node that accepts input but whose output is status-only (one direction):
+
+```python
+monitor_type = NodeType(
+    type="monitor",
+    label="Monitor",
+    inputs=["in"],
+    outputs=["status"],
+    input_connectable_start=False,   # Cannot start edges from input
+    output_connectable_end=False,    # Cannot end edges at output
+)
+```
+
+### All connectivity flags
+
+| Flag | Default | Controls |
+|------|---------|----------|
+| `input_connectable` | `True` | Whether input handles are connectable at all |
+| `input_connectable_start` | `True` | Whether edges can start from input handles |
+| `input_connectable_end` | `True` | Whether edges can end at input handles |
+| `output_connectable` | `True` | Whether output handles are connectable at all |
+| `output_connectable_start` | `True` | Whether edges can start from output handles |
+| `output_connectable_end` | `True` | Whether edges can end at output handles |
+
+### Complete example
+
+```python
+import panel as pn
+from panel_reactflow import NodeType, NodeSpec, EdgeSpec, ReactFlow
+
+pn.extension("jsoneditor")
+
+# Define node types with different connectivity patterns
+node_types = {
+    "source": NodeType(
+        type="source",
+        label="Data Source",
+        outputs=["data"],
+        output_connectable_start=True,
+        output_connectable_end=False,
+    ),
+    "transform": NodeType(
+        type="transform",
+        label="Transform",
+        inputs=["in"],
+        outputs=["out"],
+        # All connectable flags default to True
+    ),
+    "sink": NodeType(
+        type="sink",
+        label="Data Sink",
+        inputs=["data"],
+        input_connectable_start=False,
+        input_connectable_end=True,
+    ),
+}
+
+# Create a data pipeline
+flow = ReactFlow(
+    nodes=[
+        NodeSpec(id="src", type="source", position={"x": 0, "y": 100}, data={}).to_dict(),
+        NodeSpec(id="tx", type="transform", position={"x": 250, "y": 100}, data={}).to_dict(),
+        NodeSpec(id="snk", type="sink", position={"x": 500, "y": 100}, data={}).to_dict(),
+    ],
+    edges=[
+        EdgeSpec(id="e1", source="src", target="tx").to_dict(),
+        EdgeSpec(id="e2", source="tx", target="snk").to_dict(),
+    ],
+    node_types=node_types,
+    sizing_mode="stretch_both",
+)
+
+flow.servable()
+```
+
+In this example:
+
+- Users can drag from the **source** output to the **transform** input ✓
+- Users cannot drag to the **source** output ✗
+- Users can drag from the **transform** output to the **sink** input ✓
+- Users cannot drag from the **sink** input ✗
+
+The UI prevents invalid connections automatically — non-connectable handles
+show different cursor behavior and won't accept drag operations.

{panel_reactflow-0.4.0b1 → panel_reactflow-0.5.0a1}/docs/how-to/define-nodes-edges.md

@@ -358,26 +358,45 @@ Without `sourceHandle` and `targetHandle`, edges connect to the default (first)
 
 ---
 
-## Update data vs. label
+## Update data vs. presentation
 
-`data` and `label` live in different places and are updated differently:
-
-- **Data** — use `patch_node_data()` or `patch_edge_data()`.  This sends
-  an incremental patch to the frontend without replacing the full list.
-- **Label** — replace the node/edge in `flow.nodes` or `flow.edges`.
+A node or edge has an arbitrary `data` dictionary plus a set of top-level React
+Flow fields (`label`, `style`, `type`, `className`, `position`, ...).  Each has
+its own patch method, and both send an incremental update to the frontend
+instead of replacing the full list:
 
 ```python
 # Patch a data field
 flow.patch_node_data("n1", {"status": "running"})
 flow.patch_edge_data("e1", {"weight": 0.75})
 
-# Update a label
-flow.nodes = [
-    {**node, "label": "Start (running)"} if node["id"] == "n1" else node
-    for node in flow.nodes
-]
+# Patch a top-level field
+flow.patch_node_props("n1", {"label": "Start (running)", "className": "busy"})
+flow.patch_edge_props("e1", {"style": {"stroke": "#ef4444", "strokeWidth": 4}, "type": "step"})
+```
+
+Passing `None` to `patch_node_props()`/`patch_edge_props()` clears the field so
+the element falls back to the CSS/theme default:
+
+```python
+flow.patch_edge_props("e1", {"style": None})
 ```
 
+If you use `Node`/`Edge` subclasses, you rarely need either method: assigning to
+a parameter patches the browser in place.  Parameters you declare on the
+subclass are synced into `data`, the presentational base parameters are synced
+as top-level fields.
+
+```python
+node.label = "Start (running)"                  # top-level label
+edge.style = {"stroke": "#ef4444"}              # top-level style
+edge.weight = 0.75                              # subclass param, goes into data
+```
+
+`position` and `selected` are the exception: the browser owns them while the
+user drags or selects, so assignment does not push them.  Use
+`patch_node_props()` to move or select a node from Python.
+
 ---
 
 ## Add and remove at runtime
@@ -399,3 +418,26 @@ flow.add_edge(EdgeSpec(id="e2", source="n3", target="n4"))
 flow.remove_node("n3")   # also removes connected edges
 flow.remove_edge("e1")
 ```
+
+`remove_node()` and `remove_edge()` also take several ids at once, either as
+separate arguments or as a single sequence. Pass them together rather than
+calling the methods in a loop: a batch assigns `nodes` and `edges` once, so the
+browser renders a single update instead of one per element.
+
+```python
+flow.remove_node("n1", "n2", "n3")   # also removes connected edges
+flow.remove_edge(["e1", "e2"])
+```
+
+More generally, every parameter assignment is synced to the browser on its own
+and the canvas re-renders per sync, so a sequence of updates renders each
+intermediate graph. Wrap any batch of changes in `pn.io.hold()` to combine them
+into a single render:
+
+```python
+import panel as pn
+
+with pn.io.hold():
+    flow.nodes = new_nodes
+    flow.edges = new_edges
+```

{panel_reactflow-0.4.0b1 → panel_reactflow-0.5.0a1}/docs/how-to/react-to-events.md

@@ -30,6 +30,7 @@ the `ReactFlow` instance as a second argument.  You can also listen for
 | `edge_data_changed`  | Edge data is patched (via API, editor patch, or parameter-driven sync). | `edge_id`, `patch` |
 | `selection_changed`  | The active selection changes. | `nodes`, `edges` |
 | `sync`               | A batch sync from the frontend. | *(varies)* |
+| `client_error`       | The graph view hit a rendering error in the browser. See [Recover from Rendering Errors](recover-from-errors.md). | `source`, `message`, `stack`, `component_stack`, `attempt`, `mode` |
 
 ---
 

panel_reactflow-0.5.0a1/docs/how-to/recover-from-errors.md

@@ -0,0 +1,121 @@
+# Recover from Rendering Errors
+
+A React rendering error is unforgiving: when a component throws during
+render, React unmounts the whole subtree.  In a graph editor that means a
+single malformed node can blank the canvas, and because the exception dies
+in the browser console the server never learns about it.  The user is left
+staring at an empty viewport with no way back other than reloading the page,
+even though their graph is still safely held in Python.
+
+Panel-ReactFlow wraps the canvas in an error boundary that catches those
+errors, tries to bring the view back, and reports what happened to the
+server.  This is on by default, controlled by the `error_recovery`
+parameter.
+
+```python
+from panel_reactflow import ReactFlow
+
+flow = ReactFlow(nodes=nodes, edges=edges, error_recovery="auto")
+```
+
+---
+
+## Recovery modes
+
+| Mode       | Behavior |
+|------------|----------|
+| `"auto"`   | *(default)* Remount the canvas once, then remount again in safe mode.  If it still fails, show the recovery panel. |
+| `"manual"` | Report the error and show the recovery panel immediately, without retrying. |
+| `"off"`    | Disable the error boundary entirely so exceptions propagate to the browser.  Useful when debugging a custom node component. |
+
+Each retry budget refills once a remounted canvas has survived for five
+seconds, so a graph that breaks again much later still gets a fresh set of
+attempts rather than going straight to the failure panel.
+
+---
+
+## What safe mode does
+
+On the second attempt the frontend validates the graph before handing it to
+React Flow and either repairs or hides anything it cannot render:
+
+| Issue | Action |
+|-------|--------|
+| `invalid_position` | Position is missing or not finite, so the node is placed at the origin. |
+| `unknown_node_type` | Node type is not registered, so the node falls back to the default renderer. |
+| `unknown_edge_type` | Edge type is not registered, so the type is stripped. |
+| `dangling_edge` | Edge references a node that does not exist, so it is hidden. |
+| `duplicate_node_id` / `duplicate_edge_id` | Later duplicates are hidden. |
+| `missing_node_id` / `missing_edge_id` / `invalid_node` / `invalid_edge` | The element is hidden. |
+
+Safe mode is **view-only**.  It filters what the browser renders and never
+sends a graph mutation back to Python, so `flow.nodes` and `flow.edges` keep
+every element they had before the error.  Once the underlying state is
+repaired on the server, the affected elements reappear.
+
+A banner tells the user what was changed and offers a details list of the
+individual issues:
+
+```text
+Safe mode: repaired 1 element and hid 1 element that could not be rendered.
+Nothing was deleted on the server.
+```
+
+---
+
+## The recovery panel
+
+When retries are exhausted, or in `"manual"` mode, the canvas is replaced by
+a panel that names the error and offers three actions: *Try again*, which
+remounts the canvas, *Reload page*, which rebuilds the session from the
+server-side state, and *Copy details*, which puts a JSON diagnostic blob on
+the clipboard for a bug report.
+
+Because Python holds the canonical graph, reloading is genuinely safe: no
+work is lost.  The panel says so explicitly, which matters when the
+alternative is a user assuming their graph is gone.
+
+---
+
+## Log and handle errors in Python
+
+Every error the frontend catches is reported to the server, logged to the
+`panel.reactflow` logger, and emitted as a `client_error` event.
+
+```python
+import logging
+
+logging.getLogger("panel.reactflow").setLevel(logging.INFO)
+
+def on_client_error(payload, flow):
+    if payload["source"] == "safe_mode":
+        print("hidden or repaired:", payload["issues"])
+    else:
+        print(f"render error on attempt {payload['attempt']}: {payload['message']}")
+
+flow.on("client_error", on_client_error)
+```
+
+Render errors carry `name`, `message`, `stack`, `component_stack`, `attempt`,
+`mode` and `auto_retry`.  Errors raised inside interaction handlers are
+reported with `source="handler"` and the `handler` name, which catches the
+case where a drag or connect silently fails and leaves the canvas showing a
+change that never reached Python.  Safe mode reports arrive with
+`source="safe_mode"` and the list of `issues`.
+
+Use this hook to forward errors to your own telemetry, to snapshot the graph
+for later inspection, or to attempt a server-side repair before the user
+clicks *Try again*.
+
+---
+
+## Tips
+
+- Keep `error_recovery="auto"` in production; switch to `"off"` while
+  developing a custom node component so you see the real stack trace.
+- A `client_error` with `source="safe_mode"` is a strong signal that
+  something upstream produced invalid state.  Treat it as a bug report
+  rather than a warning to be ignored.
+- The error boundary only covers the graph canvas.  Content you pass to
+  `top_panel`, `bottom_panel`, `left_panel` and `right_panel` stays mounted
+  when the canvas fails, so side panels remain usable during recovery.

{panel_reactflow-0.4.0b1 → panel_reactflow-0.5.0a1}/docs/releases.md

@@ -1,5 +1,82 @@
 # Release Notes
 
+## Unreleased
+
+### Bug fixes
+
+- **Progressive re-render when deleting multiple elements** — deleting a
+  multi-node selection removed the nodes one at a time, syncing an
+  intermediate graph to the browser per node so the nodes visibly
+  disappeared one by one. Updates triggered by a frontend message are now
+  held and combined into a single patch, and node/edge deletion assigns
+  `nodes` and `edges` once.
+
+### Enhancements
+
+- **Batch removal** — `remove_node()` and `remove_edge()` now accept
+  several ids, either as separate arguments
+  (`flow.remove_node("n1", "n2")`) or as a sequence
+  (`flow.remove_node(["n1", "n2"])`), and remove them in a single update.
+  For any other batch of changes made from Python, wrap them in
+  `pn.io.hold()` to render them at once.
+
+## Version 0.4.1
+
+A small enhancement release adding viewport zoom controls.
+
+### Enhancements
+
+- **Zoom limits** — new `min_zoom` (default `0.5`) and `max_zoom`
+  (default `2`) parameters constrain how far the canvas can be zoomed
+  out and in, and can be updated at runtime
+  ([#69](https://github.com/panel-extensions/panel-reactflow/pull/69)).
+
+## Version 0.4.0
+
+This release adds new interaction features, edge routing options, and
+handle customization capabilities.
+
+### Highlights
+
+- **Right-click context menu** — nodes and the canvas now support a
+  configurable context menu triggered on right-click, enabling custom
+  actions like delete, duplicate, or copy without toolbar buttons
+  ([#65](https://github.com/panel-extensions/panel-reactflow/pull/65)).
+- **Smart edge routing** — new smart edge types (`smartBezier`,
+  `smartStep`, `smartStraight`) that automatically route around nodes
+  instead of passing through them
+  ([#64](https://github.com/panel-extensions/panel-reactflow/pull/64)).
+- **Handle connectivity controls** — per-type flags
+  (`input_connectable`, `input_connectable_start`,
+  `input_connectable_end`, and their `output_*` counterparts) let you
+  restrict which handles users can drag edges from or to
+  ([#63](https://github.com/panel-extensions/panel-reactflow/pull/63)).
+- **Handle tooltips** — handles can now carry a `label` that appears as
+  an instant tooltip on hover, making port purpose discoverable without
+  cluttering the canvas. Pass `{"id": "port_name", "label": "Description"}`
+  in your `inputs`/`outputs` lists
+  ([#67](https://github.com/panel-extensions/panel-reactflow/pull/67)).
+- **`Node.flow` and `Edge.flow` back-references** — instance-based nodes
+  and edges now hold a `.flow` reference to their parent `ReactFlow`,
+  simplifying imperative graph manipulation from callbacks
+  ([#56](https://github.com/panel-extensions/panel-reactflow/pull/56)).
+- **Delete key support** — selected nodes and edges can now be removed
+  with the Delete key, matching standard graph-editor UX expectations.
+- **Bundle cache-busting** — the frontend bundle URL now includes a
+  content hash, preventing stale cached bundles after upgrades
+  ([#68](https://github.com/panel-extensions/panel-reactflow/pull/68)).
+
+### Bug fixes
+
+- Fixed stale node views not updating and deletion causing flicker
+  ([#60](https://github.com/panel-extensions/panel-reactflow/pull/60)).
+- Fixed `flow` attribute initialization on component creation
+  ([#59](https://github.com/panel-extensions/panel-reactflow/pull/59)).
+- Edge/node add/remove events are now emitted exactly once
+  ([#58](https://github.com/panel-extensions/panel-reactflow/pull/58)).
+- Fixed removing a node when edges are defined as `Edge` instances
+  ([#57](https://github.com/panel-extensions/panel-reactflow/pull/57)).
+
 ## Version 0.3.0
 
 This release focuses on core graph-model capabilities, callback ergonomics,