jssm 5.139.0 → 5.141.1

package/README.md

@@ -18,10 +18,10 @@ Please edit the file it's derived from, instead: `./src/md/readme_base.md`
 
 
 
-* Generated for version 5.139.0 at 5/28/2026, 8:04:13 AM
+* Generated for version 5.141.1 at 6/1/2026, 7:35:45 PM
 
 -->
-# jssm 5.139.0
+# jssm 5.141.1
 
 [**Try the live editor**](https://stonecypher.github.io/jssm-viz-demo/graph_explorer.html) ·
 [Documentation](https://stonecypher.github.io/jssm/docs/) ·
@@ -281,7 +281,7 @@ That decision shows up everywhere downstream:
   or run `npm run benny` against your own machine.
 
 - **More thoroughly tested than any other JavaScript state-machine
-  library.**  6,389 tests at 100.0% line coverage
+  library.**  6,458 tests at 100.0% line coverage
   ([report](https://coveralls.io/github/StoneCypher/jssm)), plus
   fuzz testing via `fast-check`, with parser test data across ten natural
   languages and Emoji.
@@ -414,11 +414,11 @@ If your contribution is missing here, please open an issue.
 
 <br/>
 
-***6,389 tests***, run 57,176 times.
+***6,458 tests***, run 57,245 times.
 
-- 5,876 specs with 100.0% coverage
-- 513 fuzz tests with 3.5% coverage
-- 5,397 TypeScript lines - 1.2 tests per line, 10.6 generated tests per line
+- 5,945 specs with 100.0% coverage
+- 513 fuzz tests with 3.4% coverage
+- 5,555 TypeScript lines - 1.2 tests per line, 10.3 generated tests per line
 
 [![Actions Status](https://github.com/StoneCypher/jssm/workflows/Node%20CI/badge.svg)](https://github.com/StoneCypher/jssm/actions)
 [![NPM version](https://img.shields.io/npm/v/jssm.svg)](https://www.npmjs.com/package/jssm)

package/custom-elements.json

@@ -2,6 +2,191 @@
   "schemaVersion": "1.0.0",
   "readme": "",
   "modules": [
+    {
+      "kind": "javascript-module",
+      "path": "src/ts/wc/jssm_bind_wc.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "walk_path",
+          "return": {
+            "type": {
+              "text": ""
+            }
+          },
+          "parameters": [
+            {
+              "name": "obj",
+              "type": {
+                "text": "unknown"
+              },
+              "description": "The root value to traverse."
+            },
+            {
+              "name": "path",
+              "type": {
+                "text": "string"
+              },
+              "description": "Dotted path of property names, e.g. `\"a.b.c\"`."
+            }
+          ],
+          "description": "Walk a dotted path into a value.  Used by the `data.path.to.field`\r\nvariant of resolve_binding.  Returns `undefined` whenever the\r\ntraversal would dereference a non-object, missing field, or `null` —\r\nmatching the natural \"missing data\" semantics rather than throwing.\r\n\r\n```typescript\r\nwalk_path({ a: { b: 7 } }, 'a.b');     // => 7\r\nwalk_path({ a: { b: 7 } }, 'a.c');     // => undefined\r\nwalk_path({ a: { b: 7 } }, 'a.b.c');   // => undefined (7 is not an object)\r\nwalk_path(undefined,        'a');      // => undefined\r\nwalk_path({ a: null },     'a.b');     // => undefined (null is not an object)\r\nwalk_path({ a: 1 },         '');       // => { a: 1 } (empty path = identity)\r\n```"
+        },
+        {
+          "kind": "function",
+          "name": "resolve_binding",
+          "return": {
+            "type": {
+              "text": ""
+            }
+          },
+          "parameters": [
+            {
+              "name": "m",
+              "type": {
+                "text": "Machine<unknown>"
+              },
+              "description": "The machine whose state/data is being projected."
+            },
+            {
+              "name": "expr",
+              "type": {
+                "text": "string"
+              },
+              "description": "The binding expression text (raw attribute value)."
+            }
+          ],
+          "description": "Resolve a `<jssm-bind>` / `data-jssm-bind` expression against a live\r\nmachine.  Throws on any unknown expression — bindings fail fast at\r\ninstall time rather than silently producing `undefined` strings in the\r\nDOM.\r\n\r\nRecognized expressions:\r\n\r\n| Expression       | Resolves to                                   |\r\n| ---------------- | --------------------------------------------- |\r\n| `data`           | `machine.data()`                              |\r\n| `data.a.b.c`     | dotted-path traversal into `machine.data()`   |\r\n| `state`          | `machine.state()`                             |\r\n| `terminal`       | `machine.is_terminal()`                       |\r\n| `complete`       | `machine.is_complete()`                       |\r\n| `legal-actions`  | `machine.list_exit_actions().join(' ')`       |\r\n\r\n```typescript\r\nresolve_binding(m, 'state');              // current state name\r\nresolve_binding(m, 'data.username');      // typed-data subfield\r\nresolve_binding(m, 'wat');                // throws\r\n```"
+        },
+        {
+          "kind": "function",
+          "name": "set_on_element",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "parameters": [
+            {
+              "name": "el",
+              "type": {
+                "text": "HTMLElement"
+              },
+              "description": "The element to update."
+            },
+            {
+              "name": "target",
+              "type": {
+                "text": "string"
+              },
+              "description": "Target property name, possibly a `data-*` attribute."
+            },
+            {
+              "name": "value",
+              "type": {
+                "text": "unknown"
+              },
+              "description": "The resolved value to assign."
+            }
+          ],
+          "description": "Apply a resolved binding value to an element's target property.  The\r\n`target` selector follows the rules documented in #645:\r\n\r\n- `textContent` (or omitted) sets `el.textContent` to the value coerced\r\n  with `String()`.\r\n- Any string starting with `data-` is treated as an attribute name and\r\n  set via `setAttribute`, value coerced with `String()`.\r\n- Any other string is assigned directly as a property of the element\r\n  (no coercion) — supports `value`, `disabled`, `hidden`, `checked`,\r\n  and the documented power-user escape hatch.\r\n\r\n```typescript\r\nset_on_element(span,   'textContent',     7);            // span.textContent = '7'\r\nset_on_element(input,  'value',           'hi');         // input.value = 'hi'\r\nset_on_element(button, 'disabled',        true);         // button.disabled = true\r\nset_on_element(div,    'data-current',    'red');        // setAttribute('data-current', 'red')\r\n```"
+        },
+        {
+          "kind": "function",
+          "name": "install_bindings",
+          "return": {
+            "type": {
+              "text": ""
+            }
+          },
+          "parameters": [
+            {
+              "name": "host",
+              "type": {
+                "text": "HTMLElement"
+              },
+              "description": "The host element whose descendants carry the bindings."
+            },
+            {
+              "name": "machine",
+              "type": {
+                "text": "Machine<unknown>"
+              },
+              "description": "The machine whose state/data is being projected."
+            }
+          ],
+          "description": "Discover every binding declaration under `host` and install live\r\nsubscriptions that refresh them on every machine transition.  Returns\r\na list of unsubscribe callbacks so the host's `disconnectedCallback`\r\ncan tear them all down.\r\n\r\nTwo surface forms are recognized:\r\n\r\n1. Inline attribute — any descendant with `data-jssm-bind=\"<expr>\"`.\r\n   Optional `data-jssm-bind-to=\"<target>\"` chooses the target property\r\n   (defaults to `textContent`).\r\n\r\n2. Dedicated tag — direct-child `<jssm-bind>` configuration tags with\r\n   `selector=\"<css>\"` and `source=\"<expr>\"` attributes, plus an\r\n   optional `target=\"<target>\"` (also defaulting to `textContent`).\r\n   The `selector` is scoped to `host`'s descendants.\r\n\r\nEach binding is painted once immediately (using the machine's current\r\nstate) and then re-painted on every `transition` event.\r\n\r\n```typescript\r\n// typical install during <jssm-instance>.connectedCallback:\r\nconst unsubs = install_bindings(this, this.machine);\r\nthis._unsubs.push(...unsubs);\r\n```"
+        },
+        {
+          "kind": "class",
+          "description": "`<jssm-bind>` configuration tag.  The element itself is invisible —\r\nit carries `selector`, `source`, and optional `target` attributes\r\nthat the parent `<jssm-instance>` reads during its connection\r\nlifecycle to wire up a machine-to-DOM binding.\r\n\r\nRegistering it as a `LitElement` (rather than leaving it as a generic\r\nunknown tag) gives it a stable upgrade timing, a `display: none`\r\ndefault style, and a proper place in the custom-elements registry so\r\n`customElements.get('jssm-bind')` resolves.",
+          "name": "JssmBind",
+          "members": [],
+          "attributes": [
+            {
+              "description": "CSS selector for the target element(s), scoped to the host.",
+              "name": "selector"
+            },
+            {
+              "description": "Binding expression (see {@link resolve_binding}).",
+              "name": "source"
+            },
+            {
+              "description": "Target property name; defaults to `textContent`.",
+              "name": "target"
+            }
+          ],
+          "superclass": {
+            "name": "LitElement",
+            "package": "lit"
+          },
+          "tagName": "jssm-bind",
+          "customElement": true
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "walk_path",
+          "declaration": {
+            "name": "walk_path",
+            "module": "src/ts/wc/jssm_bind_wc.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "resolve_binding",
+          "declaration": {
+            "name": "resolve_binding",
+            "module": "src/ts/wc/jssm_bind_wc.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "set_on_element",
+          "declaration": {
+            "name": "set_on_element",
+            "module": "src/ts/wc/jssm_bind_wc.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "install_bindings",
+          "declaration": {
+            "name": "install_bindings",
+            "module": "src/ts/wc/jssm_bind_wc.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "JssmBind",
+          "declaration": {
+            "name": "JssmBind",
+            "module": "src/ts/wc/jssm_bind_wc.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/ts/wc/jssm_hook_wc.ts",
@@ -421,6 +606,16 @@
               "default": "undefined",
               "description": "The underlying machine instance, constructed at `connectedCallback`.\r\nExposed raw (not proxied) per the #639/#648 design decision so that\r\nconsumers can use the full Machine API directly.\r\n\r\nMarked optional because Lit will instantiate the element before\r\n`connectedCallback` runs; the instance is guaranteed present after\r\nconnection."
             },
+            {
+              "kind": "field",
+              "name": "_unsubs",
+              "type": {
+                "text": "JssmBindUnsub[]"
+              },
+              "privacy": "private",
+              "default": "[]",
+              "description": "Live unsubscribe callbacks for #645 `<jssm-bind>` / `data-jssm-bind`\r\nprojections.  Every entry must be invoked exactly once during\r\ndisconnectedCallback."
+            },
             {
               "kind": "field",
               "name": "_on_unsubscribes",
@@ -429,7 +624,7 @@
               },
               "privacy": "private",
               "default": "[]",
-              "description": "Unsubscribe callbacks for every `machine.on(...)` / `machine.once(...)`\r\nsubscription installed from a `<jssm-on>` child during\r\n`connectedCallback`.  Walked in `disconnectedCallback` so a removed\r\n`<jssm-instance>` doesn't leave dangling handlers on its (now-orphan)\r\nmachine.  Array (insertion order) rather than Set so cleanup order is\r\ndeterministic and easy to reason about."
+              "description": "Unsubscribe callbacks for every `machine.on(...)` / `machine.once(...)`\r\nsubscription installed from a `<jssm-on>` child during\r\n`connectedCallback`.  Walked in `disconnectedCallback`."
             },
             {
               "kind": "field",
@@ -439,7 +634,7 @@
               },
               "readonly": true,
               "default": "new Map()",
-              "description": "Per-instance registry of named hook handlers consulted before\r\n`globalThis` when resolving `<jssm-hook handler=\"name\">`.\r\n\r\nInitialized to an empty `Map`; consumers may populate it before the\r\nelement connects to provide handlers without polluting global scope —\r\nuseful for module-scoped SPAs where strict CSP blocks inline-body hooks."
+              "description": "Per-instance registry of named hook handlers consulted before\r\n`globalThis` when resolving `<jssm-hook handler=\"name\">`."
             },
             {
               "kind": "field",
@@ -449,7 +644,7 @@
               },
               "privacy": "private",
               "default": "[]",
-              "description": "Descriptors for hooks this WC installed at connect time, used in\r\n`disconnectedCallback` to call `remove_hook` for each so the underlying\r\nmachine doesn't leak handlers when the element is detached.\r\n\r\nCaptured at install time because `remove_hook` matches by descriptor\r\nshape (not handler identity), and we need to record the wrapped handler\r\nwe passed to `set_hook` to undo the registration cleanly.  Stored as\r\n`unknown[]` and cast at the call site because jssm's `HookDescription`\r\nis a discriminated union whose discriminator is only known at runtime."
+              "description": "Descriptors for hooks this WC installed at connect time."
             },
             {
               "kind": "field",
@@ -459,7 +654,7 @@
               },
               "privacy": "private",
               "default": "0",
-              "description": "Counter used to give each compiled inline-body hook a unique debug id\r\nfor its `//# sourceURL=jssm-hook:N` annotation.  Per-instance so that\r\nmultiple `<jssm-instance>` elements on a page don't share numbering."
+              "description": "Counter for compiled inline-body hook debug ids."
             },
             {
               "kind": "field",
@@ -469,7 +664,7 @@
               },
               "privacy": "private",
               "default": "[]",
-              "description": "Records every DOM listener installed by `<jssm-action>` / `data-jssm-action`\r\ndiscovery so disconnectedCallback can remove each one with the\r\nsame handler reference originally passed to `addEventListener`.\r\n\r\nListeners installed via the dedicated `<jssm-action>` tag form may target\r\nelements outside the host (its `selector` is resolved against the host,\r\nbut matching elements live in the document tree), so cleanup must be\r\nexplicit — relying on the host's GC is not sufficient."
+              "description": "DOM listeners installed by `<jssm-action>` / `data-jssm-action` discovery."
             },
             {
               "kind": "field",
@@ -695,7 +890,7 @@
         },
         {
           "kind": "class",
-          "description": "Web component that renders a jssm machine as inline SVG.",
+          "description": "Web component that renders a jssm machine as inline SVG.\r\n\r\nTwo operating modes:\r\n\r\n  1. **Standalone** (no parent `<jssm-instance>` ancestor): render from\r\n     the element's own `fsl=\"\"` attribute / property.  Re-renders on\r\n     attribute change.\r\n  2. **Nested** (inside a `<jssm-instance>` ancestor, found via\r\n     `closest('jssm-instance')` at `connectedCallback`): bind to the\r\n     parent's machine and re-render on every `transition` event.  The\r\n     element's own `fsl` attribute is ignored in this mode; supplying it\r\n     emits a `console.warn` for developer feedback.",
           "name": "JssmViz",
           "cssProperties": [
             {
@@ -734,6 +929,37 @@
               "privacy": "private",
               "default": "''"
             },
+            {
+              "kind": "field",
+              "name": "_parent_host",
+              "type": {
+                "text": "JssmInstanceHost | null"
+              },
+              "privacy": "private",
+              "default": "null",
+              "description": "Parent `<jssm-instance>` host reference, set in `connectedCallback`\r\nwhen a parent is found.  When non-null the viz is in nested mode and\r\nrenders the parent's machine instead of its own `fsl` attribute."
+            },
+            {
+              "kind": "field",
+              "name": "_parent_sub",
+              "type": {
+                "text": "(() => void) | null"
+              },
+              "privacy": "private",
+              "default": "null",
+              "description": "Unsubscribe callback returned from `host.machine.on('transition', ...)`.\r\nHeld so `disconnectedCallback` can release the subscription."
+            },
+            {
+              "kind": "method",
+              "name": "_rerenderFromHostMachine",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Nested-mode render path.  Renders the bound parent's machine via the\r\nmachine_to_svg_string pipeline and commits the result to\r\n`_svg`.  On failure emits a `viz-error` `CustomEvent` and clears the\r\nSVG."
+            },
             {
               "kind": "method",
               "name": "_renderSvg",

package/dist/cdn/instance.js

@@ -21327,7 +21327,7 @@ var constants = /*#__PURE__*/Object.freeze({
  *  Useful for runtime diagnostics and for embedding in serialized machine
  *  snapshots so that deserializers can detect version-skew.
  */
-const version = "5.139.0";
+const version = "5.141.1";
 
 // whargarbl lots of these return arrays could/should be sets
 const { state_name_chars, state_name_first_chars, action_label_chars } = constants;
@@ -25070,6 +25070,222 @@ function abstract_everything_hook_step(maybe_hook, hook_args) {
     }
 }
 
+/**
+ * Walk a dotted path into a value.  Used by the `data.path.to.field`
+ * variant of {@link resolve_binding}.  Returns `undefined` whenever the
+ * traversal would dereference a non-object, missing field, or `null` —
+ * matching the natural "missing data" semantics rather than throwing.
+ *
+ * ```typescript
+ * walk_path({ a: { b: 7 } }, 'a.b');     // => 7
+ * walk_path({ a: { b: 7 } }, 'a.c');     // => undefined
+ * walk_path({ a: { b: 7 } }, 'a.b.c');   // => undefined (7 is not an object)
+ * walk_path(undefined,        'a');      // => undefined
+ * walk_path({ a: null },     'a.b');     // => undefined (null is not an object)
+ * walk_path({ a: 1 },         '');       // => { a: 1 } (empty path = identity)
+ * ```
+ *
+ * @param obj  - The root value to traverse.
+ * @param path - Dotted path of property names, e.g. `"a.b.c"`.
+ * @returns The terminal value, or `undefined` if any step fails.
+ */
+function walk_path(obj, path) {
+    if (path.length === 0) {
+        return obj;
+    }
+    let cur = obj;
+    for (const part of path.split('.')) {
+        if (cur === null || typeof cur !== 'object') {
+            return undefined;
+        }
+        cur = cur[part];
+    }
+    return cur;
+}
+/**
+ * Resolve a `<jssm-bind>` / `data-jssm-bind` expression against a live
+ * machine.  Throws on any unknown expression — bindings fail fast at
+ * install time rather than silently producing `undefined` strings in the
+ * DOM.
+ *
+ * Recognized expressions:
+ *
+ * | Expression       | Resolves to                                   |
+ * | ---------------- | --------------------------------------------- |
+ * | `data`           | `machine.data()`                              |
+ * | `data.a.b.c`     | dotted-path traversal into `machine.data()`   |
+ * | `state`          | `machine.state()`                             |
+ * | `terminal`       | `machine.is_terminal()`                       |
+ * | `complete`       | `machine.is_complete()`                       |
+ * | `legal-actions`  | `machine.list_exit_actions().join(' ')`       |
+ *
+ * ```typescript
+ * resolve_binding(m, 'state');              // current state name
+ * resolve_binding(m, 'data.username');      // typed-data subfield
+ * resolve_binding(m, 'wat');                // throws
+ * ```
+ *
+ * @param m    - The machine whose state/data is being projected.
+ * @param expr - The binding expression text (raw attribute value).
+ * @returns The resolved value, typed `unknown` since each expression
+ *          yields a different shape.
+ *
+ * @throws Error - When `expr` is not a recognized binding form.
+ */
+function resolve_binding(m, expr) {
+    switch (expr) {
+        case 'state': return m.state();
+        case 'terminal': return m.is_terminal();
+        case 'complete': return m.is_complete();
+        case 'legal-actions': return m.list_exit_actions().map(a => String(a)).join(' ');
+        case 'data': return m.data();
+        default:
+            if (expr.startsWith('data.')) {
+                return walk_path(m.data(), expr.slice(5));
+            }
+            throw new Error(`<jssm-bind>: unknown binding expression "${expr}"`);
+    }
+}
+/**
+ * Apply a resolved binding value to an element's target property.  The
+ * `target` selector follows the rules documented in #645:
+ *
+ * - `textContent` (or omitted) sets `el.textContent` to the value coerced
+ *   with `String()`.
+ * - Any string starting with `data-` is treated as an attribute name and
+ *   set via `setAttribute`, value coerced with `String()`.
+ * - Any other string is assigned directly as a property of the element
+ *   (no coercion) — supports `value`, `disabled`, `hidden`, `checked`,
+ *   and the documented power-user escape hatch.
+ *
+ * ```typescript
+ * set_on_element(span,   'textContent',     7);            // span.textContent = '7'
+ * set_on_element(input,  'value',           'hi');         // input.value = 'hi'
+ * set_on_element(button, 'disabled',        true);         // button.disabled = true
+ * set_on_element(div,    'data-current',    'red');        // setAttribute('data-current', 'red')
+ * ```
+ *
+ * @param el     - The element to update.
+ * @param target - Target property name, possibly a `data-*` attribute.
+ * @param value  - The resolved value to assign.
+ */
+function set_on_element(el, target, value) {
+    if (target.startsWith('data-')) {
+        el.setAttribute(target, String(value));
+    }
+    else if (target === 'textContent') {
+        el.textContent = String(value);
+    }
+    else {
+        // Power-user escape hatch — assigns value as-is so booleans hit
+        // properties like `disabled`/`hidden`/`checked` with the correct
+        // semantics rather than being coerced to a string.
+        el[target] = value;
+    }
+}
+/**
+ * Discover every binding declaration under `host` and install live
+ * subscriptions that refresh them on every machine transition.  Returns
+ * a list of unsubscribe callbacks so the host's `disconnectedCallback`
+ * can tear them all down.
+ *
+ * Two surface forms are recognized:
+ *
+ * 1. Inline attribute — any descendant with `data-jssm-bind="<expr>"`.
+ *    Optional `data-jssm-bind-to="<target>"` chooses the target property
+ *    (defaults to `textContent`).
+ *
+ * 2. Dedicated tag — direct-child `<jssm-bind>` configuration tags with
+ *    `selector="<css>"` and `source="<expr>"` attributes, plus an
+ *    optional `target="<target>"` (also defaulting to `textContent`).
+ *    The `selector` is scoped to `host`'s descendants.
+ *
+ * Each binding is painted once immediately (using the machine's current
+ * state) and then re-painted on every `transition` event.
+ *
+ * ```typescript
+ * // typical install during <jssm-instance>.connectedCallback:
+ * const unsubs = install_bindings(this, this.machine);
+ * this._unsubs.push(...unsubs);
+ * ```
+ *
+ * @param host    - The host element whose descendants carry the bindings.
+ * @param machine - The machine whose state/data is being projected.
+ * @returns A flat array of unsubscribe callbacks, one per installed
+ *          subscription.
+ *
+ * @throws Error - When any binding expression is unrecognized
+ *                 (propagated from {@link resolve_binding}).
+ * @throws Error - When a `<jssm-bind>` tag is missing its `selector`
+ *                 or `source` attribute.
+ */
+function install_bindings(host, machine) {
+    var _a, _b;
+    const unsubs = [];
+    // Form 1: inline `data-jssm-bind` on descendants.
+    const inline_nodes = host.querySelectorAll('[data-jssm-bind]');
+    for (const el of Array.from(inline_nodes)) {
+        const expr = el.dataset.jssmBind;
+        const target = (_a = el.dataset.jssmBindTo) !== null && _a !== void 0 ? _a : 'textContent';
+        const apply = () => {
+            set_on_element(el, target, resolve_binding(machine, expr));
+        };
+        apply();
+        unsubs.push(machine.on('transition', apply));
+    }
+    // Form 2: dedicated `<jssm-bind>` configuration tags.  Only direct
+    // children are considered configuration tags for THIS host — nested
+    // `<jssm-instance>` children would have their own bindings handled by
+    // their own component.
+    const config_tags = host.querySelectorAll(':scope > jssm-bind');
+    for (const tag of Array.from(config_tags)) {
+        const selector = tag.getAttribute('selector');
+        const expr = tag.getAttribute('source');
+        const target = (_b = tag.getAttribute('target')) !== null && _b !== void 0 ? _b : 'textContent';
+        if (selector === null || selector.length === 0) {
+            throw new Error('<jssm-bind>: missing required "selector" attribute');
+        }
+        if (expr === null || expr.length === 0) {
+            throw new Error('<jssm-bind>: missing required "source" attribute');
+        }
+        const targets = host.querySelectorAll(selector);
+        for (const el of Array.from(targets)) {
+            const apply = () => {
+                set_on_element(el, target, resolve_binding(machine, expr));
+            };
+            apply();
+            unsubs.push(machine.on('transition', apply));
+        }
+    }
+    return unsubs;
+}
+/**
+ * `<jssm-bind>` configuration tag.  The element itself is invisible —
+ * it carries `selector`, `source`, and optional `target` attributes
+ * that the parent `<jssm-instance>` reads during its connection
+ * lifecycle to wire up a machine-to-DOM binding.
+ *
+ * Registering it as a `LitElement` (rather than leaving it as a generic
+ * unknown tag) gives it a stable upgrade timing, a `display: none`
+ * default style, and a proper place in the custom-elements registry so
+ * `customElements.get('jssm-bind')` resolves.
+ *
+ * @element jssm-bind
+ * @attribute selector - CSS selector for the target element(s), scoped to the host.
+ * @attribute source - Binding expression (see {@link resolve_binding}).
+ * @attribute target - Target property name; defaults to `textContent`.
+ */
+class JssmBind extends i {
+    /**
+     * No-op render.  The tag's purpose is purely declarative
+     * configuration; it must not contribute any DOM to the page.
+     */
+    render() {
+        return null;
+    }
+}
+JssmBind.styles = i$3 `:host { display: none; }`;
+
 const VALID_KINDS = new Set([
     'hook',
     'named',
@@ -25558,53 +25774,33 @@ class JssmInstance extends i {
          * connection.
          */
         this._machine = undefined;
+        /**
+         * Live unsubscribe callbacks for #645 `<jssm-bind>` / `data-jssm-bind`
+         * projections.  Every entry must be invoked exactly once during
+         * {@link disconnectedCallback}.
+         */
+        this._unsubs = [];
         /**
          * Unsubscribe callbacks for every `machine.on(...)` / `machine.once(...)`
          * subscription installed from a `<jssm-on>` child during
-         * `connectedCallback`.  Walked in `disconnectedCallback` so a removed
-         * `<jssm-instance>` doesn't leave dangling handlers on its (now-orphan)
-         * machine.  Array (insertion order) rather than Set so cleanup order is
-         * deterministic and easy to reason about.
+         * `connectedCallback`.  Walked in `disconnectedCallback`.
          */
         this._on_unsubscribes = [];
         /**
          * Per-instance registry of named hook handlers consulted before
          * `globalThis` when resolving `<jssm-hook handler="name">`.
-         *
-         * Initialized to an empty `Map`; consumers may populate it before the
-         * element connects to provide handlers without polluting global scope —
-         * useful for module-scoped SPAs where strict CSP blocks inline-body hooks.
-         *
-         * @see {@link parse_hook_element}
          */
         this.registry = new Map();
         /**
-         * Descriptors for hooks this WC installed at connect time, used in
-         * `disconnectedCallback` to call `remove_hook` for each so the underlying
-         * machine doesn't leak handlers when the element is detached.
-         *
-         * Captured at install time because `remove_hook` matches by descriptor
-         * shape (not handler identity), and we need to record the wrapped handler
-         * we passed to `set_hook` to undo the registration cleanly.  Stored as
-         * `unknown[]` and cast at the call site because jssm's `HookDescription`
-         * is a discriminated union whose discriminator is only known at runtime.
+         * Descriptors for hooks this WC installed at connect time.
          */
         this._installed_hooks = [];
         /**
-         * Counter used to give each compiled inline-body hook a unique debug id
-         * for its `//# sourceURL=jssm-hook:N` annotation.  Per-instance so that
-         * multiple `<jssm-instance>` elements on a page don't share numbering.
+         * Counter for compiled inline-body hook debug ids.
          */
         this._hook_debug_counter = 0;
         /**
-         * Records every DOM listener installed by `<jssm-action>` / `data-jssm-action`
-         * discovery so {@link disconnectedCallback} can remove each one with the
-         * same handler reference originally passed to `addEventListener`.
-         *
-         * Listeners installed via the dedicated `<jssm-action>` tag form may target
-         * elements outside the host (its `selector` is resolved against the host,
-         * but matching elements live in the document tree), so cleanup must be
-         * explicit — relying on the host's GC is not sufficient.
+         * DOM listeners installed by `<jssm-action>` / `data-jssm-action` discovery.
          */
         this._action_listeners = [];
     }
@@ -25675,7 +25871,9 @@ class JssmInstance extends i {
         this._install_declarative_hooks();
         // #643: <jssm-on> declarative event observation.
         this._install_jssm_on_children();
-        // TODO #645: <jssm-bind> discovery happens here.
+        // #645: discover <jssm-bind> tags and `data-jssm-bind` descendants,
+        // install live machine-to-DOM projections.
+        this._unsubs.push(...install_bindings(this, this._machine));
         // #640: <jssm-action> DOM event → machine action wiring.
         this._discover_jssm_actions();
     }
@@ -25771,7 +25969,11 @@ class JssmInstance extends i {
             catch ( /* swallow — cleanup must not throw past us */_a) { /* swallow — cleanup must not throw past us */ }
         }
         this._on_unsubscribes = [];
-        // TODO #645: remove installed bindings.
+        // #645: tear down every live binding.
+        for (const off of this._unsubs) {
+            off();
+        }
+        this._unsubs = [];
         // #640: remove DOM listeners installed via <jssm-action> / data-jssm-action.
         for (const entry of this._action_listeners) {
             entry.target.removeEventListener(entry.event, entry.handler);