@hyperfixi/reactivity 2.4.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/signals.ts","../src/caret-var.ts","../src/live.ts","../src/when.ts","../src/bind.ts","../src/index.ts"],"sourcesContent":["/**\n * Signal/effect reactive core.\n *\n * Models three dependency kinds for v1:\n *   - `global`  — `$name` variables in `context.globals`\n *   - `element` — `^name` DOM-scoped variables (per-element storage)\n *   - `dom`     — DOM properties read via `input`/`change` listeners\n *\n * Inspired by upstream _hyperscript 0.9.91's `src/core/runtime/reactivity.js`\n * but reimplemented in TypeScript against hyperfixi's types. Batched via\n * `queueMicrotask` so synchronous writes coalesce into a single flush. Cycle\n * detection halts at >100 consecutive triggers (matching upstream).\n *\n * External packages never see `Effect` or `Reactive` directly — they hold\n * the disposer returned by `createEffect()` and call it when the owning\n * element is cleaned up.\n */\n\nexport type DepKind = 'global' | 'element' | 'dom';\n\n/**\n * Whether reactive debug logging is enabled. Mirrors the core convention:\n * `localStorage.setItem('hyperfixi:debug', '*')` enables, anything else (or no\n * `localStorage`) disables. Cheap call — no caching, since users toggle this\n * interactively in the console.\n */\nfunction debugEnabled(): boolean {\n  try {\n    return typeof localStorage !== 'undefined' && localStorage.getItem('hyperfixi:debug') !== null;\n  } catch {\n    return false;\n  }\n}\n\nfunction debugWarn(message: string, err: unknown): void {\n  if (!debugEnabled()) return;\n  if (typeof console === 'undefined') return;\n  console.warn(`[@hyperfixi/reactivity] ${message}`, err);\n}\n\nexport interface Dep {\n  readonly key: string;\n  readonly kind: DepKind;\n  readonly name: string;\n  readonly element: Element | null;\n}\n\nconst globalDepKey = (name: string): string => `global:${name}`;\nconst elementDepKey = (el: Element, name: string): string => `element:${reactiveIdFor(el)}:${name}`;\nconst domDepKey = (el: Element, prop: string): string => `dom:${reactiveIdFor(el)}:${prop}`;\n\n// WeakMap-based id assignment so we don't monkey-patch DOM nodes. Ids are\n// per-process and only used to construct stable string keys for an effect's\n// per-effect dependency dedup map.\nconst _reactiveIds = new WeakMap<Element, number>();\nlet _idCounter = 0;\nfunction reactiveIdFor(el: Element): number {\n  const existing = _reactiveIds.get(el);\n  if (existing !== undefined) return existing;\n  const id = ++_idCounter;\n  _reactiveIds.set(el, id);\n  return id;\n}\n\nexport class Effect {\n  readonly dependencies = new Map<string, Dep>();\n  private lastValue: unknown = undefined;\n  private _stopped = false;\n  private _consecutiveTriggers = 0;\n\n  constructor(\n    private readonly r: Reactive,\n    readonly expression: () => unknown | Promise<unknown>,\n    readonly handler: (value: unknown) => void | Promise<void>,\n    readonly element: Element | null\n  ) {}\n\n  get stopped(): boolean {\n    return this._stopped;\n  }\n\n  /**\n   * Run the effect for the first time: collect dependencies, subscribe, call\n   * handler with the initial value. Errors in expression evaluation are caught\n   * and silently swallowed (matches upstream's tolerance).\n   */\n  async initialize(): Promise<void> {\n    if (this._stopped) return;\n    try {\n      const value = await this.r._runWithEffect(this, this.expression);\n      this.lastValue = value;\n      if (value !== undefined && value !== null) {\n        await this.handler(value);\n      }\n    } catch (err) {\n      // Swallow — expression evaluation failed during initial read. Surface\n      // via debug log so users diagnosing \"my effect never fires\" can see why.\n      debugWarn('effect.initialize failed', err);\n    }\n  }\n\n  /**\n   * Re-run the effect after a notify. Cycle-detects (halts at 101 consecutive\n   * triggers). If the new value is Object.is-equal to the last, the handler\n   * is skipped. If the owning element has disconnected, the effect stops\n   * itself and returns.\n   */\n  async run(): Promise<void> {\n    if (this._stopped) return;\n    if (this.element && !this.element.isConnected) {\n      this.stop();\n      return;\n    }\n    this._consecutiveTriggers++;\n    if (this._consecutiveTriggers > 100) {\n      if (typeof console !== 'undefined') {\n        console.error(\n          '[@hyperfixi/reactivity] Effect halted: > 100 consecutive triggers (cycle detected).'\n        );\n      }\n      this.stop();\n      return;\n    }\n    try {\n      const value = await this.r._runWithEffect(this, this.expression);\n      if (Object.is(value, this.lastValue)) return;\n      this.lastValue = value;\n      await this.handler(value);\n    } catch (err) {\n      // Swallow — expression/handler errors don't break the microtask flush.\n      debugWarn('effect.run failed', err);\n    }\n  }\n\n  resetTriggerCount(): void {\n    this._consecutiveTriggers = 0;\n  }\n\n  /**\n   * Stop the effect and remove it from all dependency subscriptions. Safe to\n   * call multiple times.\n   */\n  stop(): void {\n    if (this._stopped) return;\n    this._stopped = true;\n    this.r._unsubscribeEffect(this);\n    this.dependencies.clear();\n  }\n}\n\ninterface ElementState {\n  symbolSubs: Map<string, Set<Effect>>;\n  caretVars: Map<string, unknown>;\n  domHandlers: Map<string, DomHandler>;\n  effects: Set<Effect>;\n}\n\ninterface DomHandler {\n  subs: Set<Effect>;\n  detach: () => void;\n}\n\nexport class Reactive {\n  private currentEffect: Effect | null = null;\n  private pending = new Set<Effect>();\n  private scheduled = false;\n\n  private globalSubs = new Map<string, Set<Effect>>();\n  private elementState = new WeakMap<Element, ElementState>();\n\n  private getElementState(el: Element): ElementState {\n    let s = this.elementState.get(el);\n    if (!s) {\n      s = {\n        symbolSubs: new Map(),\n        caretVars: new Map(),\n        domHandlers: new Map(),\n        effects: new Set(),\n      };\n      this.elementState.set(el, s);\n    }\n    return s;\n  }\n\n  /**\n   * Internal helper invoked by Effect — installs `this` as the current effect,\n   * runs the expression, then restores the previous current-effect pointer.\n   * Track* methods (called from read-paths) consult `currentEffect` to know\n   * which effect to subscribe.\n   */\n  async _runWithEffect(e: Effect, fn: () => unknown | Promise<unknown>): Promise<unknown> {\n    const prev = this.currentEffect;\n    this.currentEffect = e;\n    // Unsubscribe from previous deps before re-running. The expression will\n    // re-record whatever it actually reads this time, avoiding stale subs.\n    this._unsubscribeEffect(e);\n    e.dependencies.clear();\n    try {\n      return await fn();\n    } finally {\n      this.currentEffect = prev;\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Track (read-path) — invoked from interceptors / evaluators.\n  // ---------------------------------------------------------------------------\n\n  trackGlobal(name: string): void {\n    const e = this.currentEffect;\n    if (!e) return;\n    const key = globalDepKey(name);\n    if (e.dependencies.has(key)) return;\n    e.dependencies.set(key, { key, kind: 'global', name, element: null });\n    let subs = this.globalSubs.get(name);\n    if (!subs) {\n      subs = new Set();\n      this.globalSubs.set(name, subs);\n    }\n    subs.add(e);\n  }\n\n  trackElement(el: Element, name: string): void {\n    const e = this.currentEffect;\n    if (!e) return;\n    const key = elementDepKey(el, name);\n    if (e.dependencies.has(key)) return;\n    e.dependencies.set(key, { key, kind: 'element', name, element: el });\n    const state = this.getElementState(el);\n    let subs = state.symbolSubs.get(name);\n    if (!subs) {\n      subs = new Set();\n      state.symbolSubs.set(name, subs);\n    }\n    subs.add(e);\n    state.effects.add(e);\n  }\n\n  trackDomProperty(el: Element, prop: string): void {\n    const e = this.currentEffect;\n    if (!e) return;\n    const key = domDepKey(el, prop);\n    if (e.dependencies.has(key)) return;\n    e.dependencies.set(key, { key, kind: 'dom', name: prop, element: el });\n    const state = this.getElementState(el);\n    let handler = state.domHandlers.get(prop);\n    if (!handler) {\n      const subs = new Set<Effect>();\n      const listener = (): void => {\n        for (const effect of subs) this.schedule(effect);\n      };\n      // Use both input and change to cover radios/selects which don't fire input.\n      el.addEventListener('input', listener);\n      el.addEventListener('change', listener);\n      handler = {\n        subs,\n        detach: () => {\n          el.removeEventListener('input', listener);\n          el.removeEventListener('change', listener);\n        },\n      };\n      state.domHandlers.set(prop, handler);\n    }\n    handler.subs.add(e);\n    state.effects.add(e);\n  }\n\n  // ---------------------------------------------------------------------------\n  // Notify (write-path) — schedules dependent effects for re-run.\n  // ---------------------------------------------------------------------------\n\n  notifyGlobal(name: string): void {\n    const subs = this.globalSubs.get(name);\n    if (!subs) return;\n    for (const e of subs) this.schedule(e);\n  }\n\n  notifyElement(el: Element, name: string): void {\n    const state = this.elementState.get(el);\n    if (!state) return;\n    const subs = state.symbolSubs.get(name);\n    if (!subs) return;\n    for (const e of subs) this.schedule(e);\n  }\n\n  // ---------------------------------------------------------------------------\n  // Effect lifecycle.\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Create + initialize an effect. Returns a disposer that stops the effect.\n   * Callers are expected to register the disposer with the core runtime's\n   * cleanup registry so it fires on element removal.\n   */\n  createEffect(\n    expression: () => unknown | Promise<unknown>,\n    handler: (value: unknown) => void | Promise<void>,\n    owner: Element | null\n  ): () => void {\n    const e = new Effect(this, expression, handler, owner);\n    if (owner) this.getElementState(owner).effects.add(e);\n    // Fire initialize asynchronously so the caller can set up cleanup registration\n    // before the first run touches the DOM.\n    queueMicrotask(() => {\n      void e.initialize();\n    });\n    return () => e.stop();\n  }\n\n  /**\n   * Stop all effects owned by an element. Called by the reactivity plugin's\n   * cleanup hook registered via `runtime.getCleanupRegistry()`.\n   */\n  stopElementEffects(el: Element): void {\n    const state = this.elementState.get(el);\n    if (!state) return;\n    for (const e of Array.from(state.effects)) e.stop();\n    state.effects.clear();\n  }\n\n  /**\n   * Internal: remove an effect's entries from all subscriber sets. Called by\n   * `Effect.stop()`.\n   */\n  _unsubscribeEffect(e: Effect): void {\n    for (const dep of e.dependencies.values()) {\n      if (dep.kind === 'global') {\n        const subs = this.globalSubs.get(dep.name);\n        subs?.delete(e);\n      } else if (dep.kind === 'element' && dep.element) {\n        const state = this.elementState.get(dep.element);\n        const subs = state?.symbolSubs.get(dep.name);\n        subs?.delete(e);\n        state?.effects.delete(e);\n      } else if (dep.kind === 'dom' && dep.element) {\n        const state = this.elementState.get(dep.element);\n        const handler = state?.domHandlers.get(dep.name);\n        handler?.subs.delete(e);\n        if (handler && handler.subs.size === 0) {\n          handler.detach();\n          state?.domHandlers.delete(dep.name);\n        }\n        state?.effects.delete(e);\n      }\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Caret-variable storage — `^name` reads/writes.\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Whether `el` is a `dom-scope=\"isolated\"` boundary. Walks of `^var`\n   * lookups stop at boundary elements that don't define the var, so nested\n   * components don't accidentally read or write each other's state.\n   */\n  private isIsolationBoundary(el: Element): boolean {\n    return typeof el.getAttribute === 'function' && el.getAttribute('dom-scope') === 'isolated';\n  }\n\n  /**\n   * Walk up the DOM tree from `lookupRoot`, returning the first element whose\n   * state has `name` defined. Stops at any `dom-scope=\"isolated\"` boundary\n   * that doesn't itself define the var. Returns `null` if no owner is found.\n   */\n  private findCaretOwner(lookupRoot: Element, name: string): Element | null {\n    let el: Element | null = lookupRoot;\n    while (el) {\n      const state = this.elementState.get(el);\n      if (state && state.caretVars.has(name)) return el;\n      if (this.isIsolationBoundary(el)) return null;\n      el = el.parentElement;\n    }\n    return null;\n  }\n\n  /**\n   * Read a DOM-scoped variable. Walks up from `lookupRoot`, tracking each\n   * element visited as an `element` dep (so writes at any ancestor notify\n   * dependent effects). Stops at any `dom-scope=\"isolated\"` boundary that\n   * doesn't itself define the var.\n   */\n  readCaret(lookupRoot: Element, name: string): unknown {\n    let el: Element | null = lookupRoot;\n    while (el) {\n      this.trackElement(el, name);\n      const state = this.elementState.get(el);\n      if (state && state.caretVars.has(name)) {\n        return state.caretVars.get(name);\n      }\n      if (this.isIsolationBoundary(el)) return undefined;\n      el = el.parentElement;\n    }\n    return undefined;\n  }\n\n  /**\n   * Write a DOM-scoped variable. If `target` is provided, writes there\n   * directly; otherwise walks up from `lookupRoot` to find the existing owner,\n   * falling back to `lookupRoot` itself if no owner exists.\n   */\n  writeCaret(lookupRoot: Element, name: string, value: unknown, target?: Element): void {\n    const owner = target ?? this.findCaretOwner(lookupRoot, name) ?? lookupRoot;\n    const state = this.getElementState(owner);\n    state.caretVars.set(name, value);\n    this.notifyElement(owner, name);\n  }\n\n  // ---------------------------------------------------------------------------\n  // Scheduler — microtask-batched flush.\n  // ---------------------------------------------------------------------------\n\n  private schedule(e: Effect): void {\n    if (e.stopped) return;\n    this.pending.add(e);\n    if (this.scheduled) return;\n    this.scheduled = true;\n    queueMicrotask(() => void this.flush());\n  }\n\n  private async flush(): Promise<void> {\n    try {\n      while (this.pending.size > 0) {\n        const batch = Array.from(this.pending);\n        this.pending.clear();\n        for (const e of batch) {\n          if (e.stopped) continue;\n          await e.run();\n          // If the effect's run did not synchronously re-schedule itself, its\n          // trigger count is reset. Self-rescheduling (a real cycle) keeps the\n          // counter climbing toward the 100 cap. Long-lived effects that fire\n          // sporadically (e.g. user-input bindings) stay alive forever.\n          if (!this.pending.has(e)) e.resetTriggerCount();\n        }\n      }\n    } finally {\n      this.scheduled = false;\n    }\n  }\n}\n\n// Module singleton. One reactive graph per process; mirrors upstream's\n// `runtime.reactivity` pattern.\nexport const reactive = new Reactive();\n","/**\n * `^name` — DOM-scoped inherited variable.\n *\n * Upstream syntax:\n *   ^counter              → read from nearest ancestor that has `counter` set\n *   ^counter on #target   → read from (or near) #target\n *   set ^counter to 42    → write to owner (or lookupRoot if not yet defined)\n *\n * Parse side: register `^` as a Pratt prefix operator. The handler consumes\n * the identifier token and an optional `on <target>` clause, emitting a\n * `caretVar` AST node.\n *\n * Eval side: `caretVar` node evaluator calls `reactive.readCaret(anchor,\n * name)` which walks the DOM tree for the owner and records deps as it goes.\n */\n\nimport type { ASTNode, ExecutionContext } from './types';\nimport { reactive } from './signals';\n\nexport interface CaretVarNode extends ASTNode {\n  type: 'caretVar';\n  name: string;\n  onTarget: ASTNode | null;\n}\n\ninterface CaretVarRuntime {\n  execute(node: ASTNode, ctx: ExecutionContext): Promise<unknown>;\n}\n\n/**\n * Coerce a runtime-evaluated `on <target>` result to a single Element.\n * Selector expressions resolve to an array of matched elements; bare\n * `me`/`it`/`you`/identifier references resolve to single Elements. Take the\n * first element of an array, or the value itself if it's already an Element.\n */\nfunction coerceToElement(value: unknown): Element | null {\n  if (value instanceof Element) return value;\n  if (Array.isArray(value) && value[0] instanceof Element) return value[0];\n  return null;\n}\n\n/**\n * Pratt prefix handler for `^`. Consumes the following identifier token and\n * an optional `on <expr>` clause.\n */\nexport function parseCaretPrefix(token: unknown, ctx: unknown): ASTNode {\n  // `ctx` is hyperfixi's PrattContext: { peek, advance, parseExpr, isStopToken, atEnd }.\n  const pctx = ctx as {\n    peek(): { value?: string; kind?: string } | undefined;\n    advance(): { value: string; kind?: string };\n    parseExpr(minBp: number): ASTNode;\n  };\n  const ident = pctx.advance();\n  if (!ident || !ident.value) {\n    throw new Error(\"Expected identifier after '^'\");\n  }\n  let onTarget: ASTNode | null = null;\n  const next = pctx.peek();\n  if (next && next.value === 'on') {\n    pctx.advance(); // consume 'on'\n    // Binding power 86 — higher than standard comparisons so `^x on me` doesn't\n    // over-consume into surrounding expressions.\n    onTarget = pctx.parseExpr(86);\n  }\n  const startTok = token as { start?: number; end?: number; line?: number; column?: number };\n  return {\n    type: 'caretVar',\n    name: ident.value,\n    onTarget,\n    start: startTok?.start ?? 0,\n    end: startTok?.end ?? 0,\n    line: startTok?.line,\n    column: startTok?.column,\n  } as CaretVarNode;\n}\n\n/**\n * Build a node evaluator for `caretVar` bound to a specific runtime. The\n * evaluator walks up from the resolved anchor element, tracking every element\n * visited so writes at any ancestor notify dependent effects.\n *\n * Capturing `runtime` via a factory closure (matching live/when/bind) keeps\n * the evaluator independent of any module-scope state.\n */\nexport function makeEvaluateCaretVar(\n  runtime: CaretVarRuntime\n): (node: ASTNode, ctx: unknown) => Promise<unknown> {\n  return async function evaluateCaretVar(node, ctx) {\n    const n = node as CaretVarNode;\n    const context = ctx as ExecutionContext;\n    let anchor: Element | null = (context.me as Element | null) ?? null;\n\n    if (n.onTarget) {\n      const resolved = await runtime.execute(n.onTarget, context);\n      const el = coerceToElement(resolved);\n      if (el) anchor = el;\n    }\n\n    if (!anchor) return undefined;\n    return reactive.readCaret(anchor, n.name);\n  };\n}\n\n/**\n * Build a node writer for `caretVar` bound to a specific runtime. Used by the\n * core `set` command via `parserExtensions.registerNodeWriter`.\n */\nexport function makeWriteCaretVar(\n  runtime: CaretVarRuntime\n): (node: ASTNode, value: unknown, ctx: unknown) => Promise<void> {\n  return async function writeCaretVar(node, value, ctx) {\n    const n = node as CaretVarNode;\n    const context = ctx as ExecutionContext;\n    const anchor: Element | null = (context.me as Element | null) ?? null;\n    if (!anchor) return;\n\n    let target: Element | undefined;\n    if (n.onTarget) {\n      const resolved = await runtime.execute(n.onTarget, context);\n      const el = coerceToElement(resolved);\n      if (el) target = el;\n    }\n    reactive.writeCaret(anchor, n.name, value, target);\n  };\n}\n","/**\n * `live ... end` — reactive block. Body re-runs whenever any dependency read\n * during its execution changes.\n *\n * Upstream syntax:\n *   live [commandList] end\n *\n * Each command in the body is re-executed as a single effect. The entire\n * body shares one effect instance; its dependency set is the union of every\n * read performed during body execution.\n */\n\nimport type { ASTNode, ExecutionContext, FeatureParserCtx } from './types';\nimport { reactive } from './signals';\n\nexport interface LiveFeatureNode extends ASTNode {\n  type: 'liveFeature';\n  body: ASTNode[];\n}\n\n/**\n * Parse `live ... end`. The `live` keyword has already been consumed by the\n * parser dispatcher; we parse the body and expect a trailing `end`.\n */\nexport function parseLiveFeature(ctx: unknown, token: unknown): ASTNode {\n  const pctx = ctx as FeatureParserCtx;\n  const body = pctx.parseCommandListUntilEnd();\n  // parseCommandListUntilEnd stops when it sees `end` (but doesn't consume it).\n  if (!pctx.isAtEnd() && pctx.check('end')) pctx.match('end');\n  const tok = token as { start?: number; end?: number; line?: number; column?: number };\n  return {\n    type: 'liveFeature',\n    body,\n    start: tok?.start ?? 0,\n    end: pctx.getPosition().end,\n    line: tok?.line,\n    column: tok?.column,\n  } as LiveFeatureNode;\n}\n\n/**\n * Create an evaluator bound to a runtime reference. The plugin captures\n * `runtime` at install time and passes it in so effect re-runs can dispatch\n * the body commands without going through module-scope state.\n */\nexport function makeEvaluateLiveFeature(runtime: {\n  execute(node: ASTNode, ctx: ExecutionContext): Promise<unknown>;\n}): (node: ASTNode, ctx: unknown) => unknown | Promise<unknown> {\n  return async function evaluateLiveFeature(node, ctx) {\n    const context = ctx as ExecutionContext;\n    const owner = (context.me as Element) ?? document.body;\n    const n = node as LiveFeatureNode;\n\n    const stop = reactive.createEffect(\n      async () => {\n        for (const cmd of n.body) {\n          await runtime.execute(cmd, context);\n        }\n      },\n      () => {\n        /* no-op — side effects happened inside the expression */\n      },\n      owner\n    );\n    context.registerCleanup?.(owner, stop, 'live-effect');\n    return undefined;\n  };\n}\n","/**\n * `when <expr> [or <expr>]* changes [commandList] end` — observer feature.\n *\n * Runs the body when any watched expression's value changes (Object.is\n * semantics). One effect is created per watched expression so writes to a\n * given dep only re-run that watcher.\n */\n\nimport type { ASTNode, ExecutionContext, FeatureParserCtx } from './types';\nimport { reactive } from './signals';\n\nexport interface WhenFeatureNode extends ASTNode {\n  type: 'whenFeature';\n  watched: ASTNode[];\n  body: ASTNode[];\n}\n\nexport function parseWhenFeature(ctx: unknown, token: unknown): ASTNode {\n  const pctx = ctx as FeatureParserCtx;\n  const watched: ASTNode[] = [pctx.parseExpression()];\n  while (pctx.match('or')) {\n    watched.push(pctx.parseExpression());\n  }\n  pctx.consume('changes', \"Expected 'changes' after when expression list\");\n  const body = pctx.parseCommandListUntilEnd();\n  if (!pctx.isAtEnd() && pctx.check('end')) pctx.match('end');\n  const tok = token as { start?: number; end?: number; line?: number; column?: number };\n  return {\n    type: 'whenFeature',\n    watched,\n    body,\n    start: tok?.start ?? 0,\n    end: pctx.getPosition().end,\n    line: tok?.line,\n    column: tok?.column,\n  } as WhenFeatureNode;\n}\n\nexport function makeEvaluateWhenFeature(runtime: {\n  execute(node: ASTNode, ctx: ExecutionContext): Promise<unknown>;\n  evaluateExpressionWithResult?: (\n    node: ASTNode,\n    ctx: ExecutionContext\n  ) => Promise<{ value: unknown }>;\n}): (node: ASTNode, ctx: unknown) => unknown | Promise<unknown> {\n  return async function evaluateWhenFeature(node, ctx) {\n    const context = ctx as ExecutionContext;\n    const owner = (context.me as Element) ?? document.body;\n    const n = node as WhenFeatureNode;\n\n    for (const watchedExpr of n.watched) {\n      const stop = reactive.createEffect(\n        async () => {\n          // Evaluate the watched expression as a regular expression through the\n          // runtime so that trackGlobal/trackElement fire via the global-write\n          // hook and caret-var reads.\n          return await runtime.execute(watchedExpr, context);\n        },\n        async newValue => {\n          // Fire the body with `it` / `result` bound to the new value.\n          const subCtx: ExecutionContext = { ...context, it: newValue, result: newValue };\n          for (const cmd of n.body) {\n            await runtime.execute(cmd, subCtx);\n          }\n        },\n        owner\n      );\n      context.registerCleanup?.(owner, stop, 'when-effect');\n    }\n    return undefined;\n  };\n}\n","/**\n * `bind X [to|and|with] Y` — two-way binding.\n *\n * Creates two effects (registration order is load-bearing — both initialize\n * via `queueMicrotask` and run in registration order):\n *   1. DOM → var: read DOM, write var. DOM \"wins\" on init.\n *   2. var → DOM: read var, write DOM. Fires on programmatic var writes\n *      after init. On its own initial run, var === DOM (Effect 1 just synced\n *      them), so the write is a no-op.\n *\n * Two binding forms:\n *\n *   1. Auto-detected (DOM side is a bare element expression):\n *\n *        bind $name to #input          -- detects `value`\n *        bind $checked to me           -- detects `checked` on a checkbox\n *\n *      Auto-detected property by element type:\n *        - INPUT[type=checkbox|radio]      → `checked`\n *        - INPUT[type=number|range]        → `valueAsNumber`\n *        - INPUT|TEXTAREA|SELECT           → `value`\n *        - contenteditable=\"true\"          → `textContent`\n *        - Custom elements with own `value` → `value`\n *\n *   2. Explicit property (DOM side is a member or possessive expression):\n *\n *        bind $color to #picker's value    -- possessive (preferred — reads in any language)\n *        bind $color to #picker.value      -- dot (JS-style alternative)\n *        bind $text to #div's textContent  -- non-form properties: var→DOM only\n *\n *      For form-like elements, both directions work. For non-form elements\n *      (e.g., binding a div's `textContent`), only var→DOM fires — there are\n *      no input/change events to drive DOM→var, so user mutations of the\n *      property via devtools won't propagate back.\n */\n\nimport type { ASTNode, ExecutionContext, FeatureParserCtx } from './types';\nimport { reactive } from './signals';\n\nexport interface BindFeatureNode extends ASTNode {\n  type: 'bindFeature';\n  left: ASTNode;\n  right: ASTNode;\n}\n\nexport function parseBindFeature(ctx: unknown, token: unknown): ASTNode {\n  const pctx = ctx as FeatureParserCtx;\n  const left = pctx.parseExpression();\n  // Accept any of `to` / `and` / `with` as the separator.\n  if (!(pctx.match('to') || pctx.match('and') || pctx.match('with'))) {\n    throw new Error(\"bind requires 'to', 'and', or 'with' between the two sides\");\n  }\n  const right = pctx.parseExpression();\n  // Optional `end` terminator (matches upstream which allows both forms).\n  if (pctx.check('end')) pctx.match('end');\n  const tok = token as { start?: number; end?: number; line?: number; column?: number };\n  return {\n    type: 'bindFeature',\n    left,\n    right,\n    start: tok?.start ?? 0,\n    end: pctx.getPosition().end,\n    line: tok?.line,\n    column: tok?.column,\n  } as BindFeatureNode;\n}\n\n/**\n * Auto-detect the DOM property to bind by element type. Returns null if the\n * target isn't a recognized form/editable element.\n */\nfunction detectProperty(el: Element): string | null {\n  const tag = el.tagName;\n  if (tag === 'INPUT') {\n    const type = (el as HTMLInputElement).type;\n    if (type === 'checkbox' || type === 'radio') return 'checked';\n    if (type === 'number' || type === 'range') return 'valueAsNumber';\n    return 'value';\n  }\n  if (tag === 'TEXTAREA' || tag === 'SELECT') return 'value';\n  const ce = (el as HTMLElement).contentEditable;\n  if (ce === 'true') return 'textContent';\n  // Custom elements with own `value` prop.\n  if ('value' in el) return 'value';\n  return null;\n}\n\n/**\n * If `node` is a `memberExpression` or `possessiveExpression` with a static\n * identifier property (`#el.value` or `#el's value`), return the inner element\n * expression and the property name. Returns null for anything else.\n *\n * Computed member access (`#el[prop]`) is intentionally rejected — we'd have to\n * evaluate the index dynamically and the binding direction would be unclear.\n * Chained property access (`#el.dataset.value`) is also not unpacked — we only\n * peel one level. Multi-level support is a future arc.\n */\nfunction unwrapExplicitProperty(node: ASTNode): { element: ASTNode; propertyName: string } | null {\n  if (!node || (node.type !== 'memberExpression' && node.type !== 'possessiveExpression')) {\n    return null;\n  }\n  if (node.type === 'memberExpression' && node.computed === true) return null;\n  const property = node.property as ASTNode | undefined;\n  const object = node.object as ASTNode | undefined;\n  if (!property || !object || property.type !== 'identifier') return null;\n  const name = (property.name as string) ?? '';\n  if (!name) return null;\n  return { element: object, propertyName: name };\n}\n\n/**\n * Detect a chained property access on the bind RHS — e.g.\n * `me.style.backgroundColor` or `#el's dataset's value`.\n *\n * After `unwrapExplicitProperty` peels the outermost member, the returned\n * `element` is the object of that member. If that object is itself a\n * member/possessive expression, we have a multi-level chain that v1 of\n * bind doesn't support. Used only for the error path; the parsed AST is\n * left intact.\n */\nfunction isChainedMember(node: ASTNode | undefined): boolean {\n  if (!node) return false;\n  return node.type === 'memberExpression' || node.type === 'possessiveExpression';\n}\n\n/**\n * Whether the input/change listener installed by `trackDomProperty` would\n * actually fire for this element. Used to decide whether to wire up the\n * DOM→var direction when an explicit property is given.\n */\nfunction isFormLikeElement(el: Element): boolean {\n  const tag = el.tagName;\n  if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return true;\n  if ((el as HTMLElement).contentEditable === 'true') return true;\n  return false;\n}\n\n/**\n * Whether debug logging is enabled. Mirrors signals.ts — keeps a single\n * convention for the package.\n */\nfunction debugEnabled(): boolean {\n  try {\n    return typeof localStorage !== 'undefined' && localStorage.getItem('hyperfixi:debug') !== null;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Create the bind evaluator. Because `bind` has unusual parse shape (AST\n * nodes for left/right that may be identifiers, `$name` references, or DOM\n * element lookups), we rely on the runtime to evaluate them.\n */\nexport function makeEvaluateBindFeature(runtime: {\n  execute(node: ASTNode, ctx: ExecutionContext): Promise<unknown>;\n}): (node: ASTNode, ctx: unknown) => unknown | Promise<unknown> {\n  return async function evaluateBindFeature(node, ctx) {\n    const context = ctx as ExecutionContext;\n    const owner = (context.me as Element) ?? document.body;\n    const n = node as BindFeatureNode;\n\n    // Resolve sides. One is a var reference (read/write a symbol), the other\n    // a DOM target (read/write a property). Determine direction from node shape.\n    const leftIsVar = isVarRef(n.left);\n    const rightIsVar = isVarRef(n.right);\n\n    // We need a DOM-side descriptor (element + property) and a var-side name.\n    let varSide: { name: string; isGlobal: boolean } | null = null;\n    let domSide: { exprNode: ASTNode } | null = null;\n\n    if (leftIsVar && !rightIsVar) {\n      varSide = varRefInfo(n.left);\n      domSide = { exprNode: n.right };\n    } else if (rightIsVar && !leftIsVar) {\n      varSide = varRefInfo(n.right);\n      domSide = { exprNode: n.left };\n    } else if (leftIsVar && rightIsVar) {\n      // var-to-var binding not supported in v1 (no DOM side).\n      throw new Error('bind: cannot bind two symbols together (need a DOM side)');\n    } else {\n      throw new Error('bind: could not identify a symbol side');\n    }\n\n    // Unwrap explicit property syntax: `#el.value` or `#el's value` becomes\n    // (element-expression, propertyName). Otherwise, evaluate the whole side\n    // and rely on auto-detection.\n    const explicit = unwrapExplicitProperty(domSide.exprNode);\n    // Multi-level property access (`#el.style.background`, `me's dataset's id`)\n    // is not supported in v1. Surface that diagnosis up front; otherwise the\n    // user gets the generic \"did not resolve to an element\" message and no\n    // hint that the chain is the problem.\n    if (explicit && isChainedMember(explicit.element)) {\n      throw new Error(\n        'bind: multi-level property access (e.g., `#el.a.b`) is not supported in v1 — restructure to a single property write or pass the element directly for auto-detection (e.g., `bind $x to #el`).'\n      );\n    }\n    const elementExpr = explicit ? explicit.element : domSide.exprNode;\n    const domValue = await runtime.execute(elementExpr, context);\n    if (!(domValue instanceof Element)) {\n      const valueType =\n        domValue === null ? 'null' : domValue === undefined ? 'undefined' : typeof domValue;\n      const snippet =\n        domValue !== null && domValue !== undefined ? ` \"${String(domValue).slice(0, 40)}\"` : '';\n      const suggestion = explicit\n        ? ''\n        : \" If you meant to write to a property, use the explicit form: `<selector>'s <property>`.\";\n      throw new Error(\n        `bind: right-hand side did not resolve to an element (got ${valueType}${snippet}).${suggestion}`\n      );\n    }\n    const el = domValue;\n    // Explicit property bypasses auto-detect; the user takes responsibility for\n    // picking something readable from the element. For DOM→var to work without\n    // explicit property, fall back to auto-detect.\n    const prop = explicit ? explicit.propertyName : detectProperty(el);\n    if (!prop) {\n      throw new Error(\n        `bind: could not auto-detect property for <${el.tagName.toLowerCase()}> — use explicit \\`<expr>'s <property>\\` form`\n      );\n    }\n    // For explicit-property mode on non-form elements, DOM→var can't sync via\n    // input/change events. Skip the listener install; only var→DOM runs.\n    const installDomToVar = !explicit || isFormLikeElement(el);\n    if (explicit && !installDomToVar && debugEnabled() && typeof console !== 'undefined') {\n      console.warn(\n        `[@hyperfixi/reactivity] bind: DOM→var skipped for <${el.tagName.toLowerCase()}>.${prop} — no input/change event source.`\n      );\n    }\n\n    // Initial sync: DOM → var.\n    const readDom = (): unknown => {\n      if (prop === 'valueAsNumber') return (el as HTMLInputElement).valueAsNumber;\n      if (prop === 'checked') return (el as HTMLInputElement).checked;\n      if (prop === 'textContent') return el.textContent ?? '';\n      return (el as any)[prop];\n    };\n    const writeDom = (value: unknown): void => {\n      if (prop === 'valueAsNumber') {\n        const n = Number(value);\n        (el as HTMLInputElement).valueAsNumber = Number.isNaN(n) ? (null as never) : n;\n      } else if (prop === 'checked') {\n        (el as HTMLInputElement).checked = Boolean(value);\n      } else if (prop === 'textContent') {\n        el.textContent = value == null ? '' : String(value);\n      } else {\n        (el as any)[prop] = value;\n      }\n    };\n    const readVar = (): unknown => {\n      if (varSide!.isGlobal) return context.globals?.get(varSide!.name);\n      return context.locals?.get(varSide!.name);\n    };\n    const writeVar = (value: unknown): void => {\n      if (varSide!.isGlobal) {\n        context.globals?.set(varSide!.name, value);\n        // Bypass the global-write hook (we're touching the Map directly), so\n        // notify the reactive graph manually for the var→DOM effect.\n        reactive.notifyGlobal(varSide!.name);\n      } else {\n        context.locals?.set(varSide!.name, value);\n        // Same rationale for locals — direct Map write skips the localWriteHook,\n        // so we notify the element-scoped subscription set directly.\n        reactive.notifyElement(owner, varSide!.name);\n      }\n    };\n\n    // Effect 1: DOM → var (fires on user input). Skipped for explicit-property\n    // bindings on non-form elements — no input/change events would drive it.\n    let stopDomToVar: (() => void) | null = null;\n    if (installDomToVar) {\n      stopDomToVar = reactive.createEffect(\n        () => {\n          reactive.trackDomProperty(el, prop);\n          return readDom();\n        },\n        newValue => {\n          writeVar(newValue);\n        },\n        owner\n      );\n    }\n\n    // Effect 2: var → DOM (fires on programmatic var writes — for globals\n    // via the core's globalWriteHook, for locals via the localWriteHook the\n    // reactivity plugin registers).\n    const stopVarToDom = reactive.createEffect(\n      () => {\n        if (varSide!.isGlobal) reactive.trackGlobal(varSide!.name);\n        else reactive.trackElement(owner, varSide!.name);\n        return readVar();\n      },\n      newValue => {\n        if (newValue === undefined) return;\n        writeDom(newValue);\n      },\n      owner\n    );\n\n    if (stopDomToVar) context.registerCleanup?.(owner, stopDomToVar, 'bind-dom-to-var');\n    context.registerCleanup?.(owner, stopVarToDom, 'bind-var-to-dom');\n    return undefined;\n  };\n}\n\n/**\n * Is this AST node a var reference we can bind to?\n *\n * The hyperfixi parser emits `identifier` nodes for both globals and locals,\n * but with different shapes:\n *   - `$foo` → `{ type: 'identifier', name: '$foo' }` (no scope field)\n *   - `:foo` → `{ type: 'identifier', name: 'foo', scope: 'local' }`\n *   - `::foo` → `{ type: 'identifier', name: 'foo', scope: 'global' }`\n *\n * We accept all three. The legacy `$`-prefix sniff stays as a fallback because\n * `parseExpression` doesn't always set `scope`.\n */\nfunction isVarRef(node: ASTNode): boolean {\n  if (!node) return false;\n  if (node.type !== 'identifier') return false;\n  const scope = node.scope as string | undefined;\n  if (scope === 'local' || scope === 'global') return true;\n  const name = (node.name as string) ?? '';\n  return name.startsWith('$') || name.startsWith(':');\n}\n\nfunction varRefInfo(node: ASTNode): { name: string; isGlobal: boolean } {\n  const rawName = (node.name as string) ?? '';\n  const scope = node.scope as string | undefined;\n  // Prefer the parser-emitted scope marker. Fall back to prefix sniffing for\n  // shapes where scope isn't set (e.g. `$foo` arriving as bare identifier\n  // with name '$foo').\n  let isGlobal: boolean;\n  let name: string;\n  if (scope === 'global') {\n    isGlobal = true;\n    name = rawName;\n  } else if (scope === 'local') {\n    isGlobal = false;\n    name = rawName;\n  } else if (rawName.startsWith('$')) {\n    isGlobal = true;\n    name = rawName.slice(1);\n  } else if (rawName.startsWith(':')) {\n    isGlobal = false;\n    name = rawName.slice(1);\n  } else {\n    isGlobal = false;\n    name = rawName;\n  }\n  if (!name) {\n    throw new Error('bind: variable reference has empty name');\n  }\n  return { name, isGlobal };\n}\n","/**\n * @hyperfixi/reactivity — signal-based reactive features for hyperfixi.\n *\n * Adds four constructs from upstream _hyperscript 0.9.90:\n *\n *   live [commandList] end                       reactive block — body re-runs\n *                                                when tracked reads change.\n *\n *   when <expr> [or <expr>]* changes             observer — body runs when any\n *     [commandList] end                          watched expression changes.\n *\n *   bind <var> to <element>                      two-way DOM ⇄ var binding.\n *\n *   ^name [on <target>]                          DOM-scoped inherited variable\n *                                                (read + write with `^`).\n *\n * Install:\n *\n * ```ts\n * import { createRuntime, installPlugin } from '@hyperfixi/core';\n * import { reactivityPlugin } from '@hyperfixi/reactivity';\n *\n * const runtime = createRuntime();\n * installPlugin(runtime, reactivityPlugin);\n * ```\n */\n\nimport type { HyperfixiPlugin, HyperfixiPluginContext } from '@hyperfixi/core';\nimport { reactive } from './signals';\nimport { parseCaretPrefix, makeEvaluateCaretVar, makeWriteCaretVar } from './caret-var';\nimport { parseLiveFeature, makeEvaluateLiveFeature } from './live';\nimport { parseWhenFeature, makeEvaluateWhenFeature } from './when';\nimport { parseBindFeature, makeEvaluateBindFeature } from './bind';\n\nexport { reactive } from './signals';\nexport type { CaretVarNode } from './caret-var';\nexport type { LiveFeatureNode } from './live';\nexport type { WhenFeatureNode } from './when';\nexport type { BindFeatureNode } from './bind';\n\n/**\n * The plugin object. Install once at app startup; re-installing is idempotent\n * (guarded via a `parserExtensions.hasFeature('live')` check).\n *\n * Registers:\n *   - Features: `live`, `when`, `bind` (top-level features with `end` bodies)\n *   - Prefix op: `^` (primary expression for DOM-scoped vars)\n *   - Node evaluators: `liveFeature`, `whenFeature`, `bindFeature`, `caretVar`\n *   - A node writer for `caretVar` so `set ^X to Y` flows through `reactive.writeCaret`\n *   - Global read/write hooks so `$name` reads track and writes notify\n *\n * Effect cleanup: each effect-creating evaluator calls\n * `context.registerCleanup(owner, stop, ...)` so the core runtime tears effects\n * down when their owning element is cleaned up. There is no separate plugin-level\n * cleanup hook; `reactive.stopElementEffects(el)` is exposed for explicit teardown\n * by tests and consumers that manage element lifecycle outside the runtime.\n */\nexport const reactivityPlugin: HyperfixiPlugin & { version: string } = {\n  name: '@hyperfixi/reactivity',\n  version: '2.3.1',\n  install(ctx: HyperfixiPluginContext) {\n    const { parserExtensions, runtime } = ctx;\n\n    // Idempotency: the parser-extension registry is process-singleton, so\n    // re-installing into a fresh runtime would otherwise stack additional\n    // global read/write hooks on every call. `snapshot()`/`restore()` clears\n    // the feature registry — when tests roll back the registry, this guard\n    // re-enables a fresh install.\n    if (parserExtensions.hasFeature('live')) return;\n\n    // Parser hooks — three block features plus a primary-expression caret.\n    parserExtensions.registerFeature('live', parseLiveFeature as never);\n    parserExtensions.registerFeature('when', parseWhenFeature as never);\n    parserExtensions.registerFeature('bind', parseBindFeature as never);\n    parserExtensions.registerPrefixOperator('^', 85, parseCaretPrefix as never);\n\n    // Runtime evaluators. Features capture `runtime` so effect re-runs can\n    // dispatch body commands without going through module-scope state.\n    parserExtensions.registerNodeEvaluator(\n      'liveFeature',\n      makeEvaluateLiveFeature(runtime as never) as never\n    );\n    parserExtensions.registerNodeEvaluator(\n      'whenFeature',\n      makeEvaluateWhenFeature(runtime as never) as never\n    );\n    parserExtensions.registerNodeEvaluator(\n      'bindFeature',\n      makeEvaluateBindFeature(runtime as never) as never\n    );\n    parserExtensions.registerNodeEvaluator(\n      'caretVar',\n      makeEvaluateCaretVar(runtime as never) as never\n    );\n\n    // Caret-var write: lets the core `set` command dispatch `set ^X to Y`\n    // through `reactive.writeCaret`. Resolves `on <target>` via the captured\n    // runtime — no global-scope indirection.\n    parserExtensions.registerNodeWriter('caretVar', makeWriteCaretVar(runtime as never) as never);\n\n    // Global-write hook: notify the reactive graph whenever `$name` is set.\n    // The returned disposer is intentionally discarded — the install-time\n    // idempotency guard above is the sole gate against double-registration.\n    parserExtensions.registerGlobalWriteHook((name: string, _value: unknown, _context: unknown) => {\n      reactive.notifyGlobal(name);\n    });\n\n    // Global-read hook: track the read against the current effect (if any)\n    // so effects re-run when the global changes.\n    parserExtensions.registerGlobalReadHook((name: string, _context: unknown) => {\n      reactive.trackGlobal(name);\n    });\n\n    // Local hooks — analogous to globals, but keyed by `context.me` so each\n    // element holds independent state. A `set :foo to ...` running in a\n    // handler with `me=button1` notifies effects subscribed to (button1, 'foo');\n    // a `set :foo` in a different `me` won't reach them. This matches how\n    // locals already work — they're never cross-context — and lets two\n    // components hold independent `:foo` state without interference.\n    parserExtensions.registerLocalWriteHook((name: string, _value: unknown, context) => {\n      const owner = (context as { me?: Element | null }).me ?? null;\n      if (owner) reactive.notifyElement(owner, name);\n    });\n\n    parserExtensions.registerLocalReadHook((name: string, context) => {\n      const owner = (context as { me?: Element | null }).me ?? null;\n      if (owner) reactive.trackElement(owner, name);\n    });\n  },\n};\n\nexport default reactivityPlugin;\n"],"mappings":"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","names":["debugEnabled","n"]}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@hyperfixi/reactivity",
+  "version": "2.4.0",
+  "description": "Reactive features for hyperfixi — adds `live`, `bind`, `when X changes`, and `^name` DOM-scoped vars (upstream _hyperscript 0.9.90).",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:check": "vitest run --reporter=dot 2>&1 | tail -5",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@hyperfixi/core": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "happy-dom": "^20.9.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.5"
+  },
+  "files": [
+    "dist",
+    "src",
+    "LICENSE"
+  ],
+  "keywords": [
+    "hyperfixi",
+    "hyperscript",
+    "reactivity",
+    "reactive",
+    "signals",
+    "plugin",
+    "_hyperscript",
+    "v0.9.90"
+  ],
+  "author": "LokaScript Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codetalcott/hyperfixi.git",
+    "directory": "packages/reactivity"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/bind.ts

@@ -0,0 +1,355 @@
+/**
+ * `bind X [to|and|with] Y` — two-way binding.
+ *
+ * Creates two effects (registration order is load-bearing — both initialize
+ * via `queueMicrotask` and run in registration order):
+ *   1. DOM → var: read DOM, write var. DOM "wins" on init.
+ *   2. var → DOM: read var, write DOM. Fires on programmatic var writes
+ *      after init. On its own initial run, var === DOM (Effect 1 just synced
+ *      them), so the write is a no-op.
+ *
+ * Two binding forms:
+ *
+ *   1. Auto-detected (DOM side is a bare element expression):
+ *
+ *        bind $name to #input          -- detects `value`
+ *        bind $checked to me           -- detects `checked` on a checkbox
+ *
+ *      Auto-detected property by element type:
+ *        - INPUT[type=checkbox|radio]      → `checked`
+ *        - INPUT[type=number|range]        → `valueAsNumber`
+ *        - INPUT|TEXTAREA|SELECT           → `value`
+ *        - contenteditable="true"          → `textContent`
+ *        - Custom elements with own `value` → `value`
+ *
+ *   2. Explicit property (DOM side is a member or possessive expression):
+ *
+ *        bind $color to #picker's value    -- possessive (preferred — reads in any language)
+ *        bind $color to #picker.value      -- dot (JS-style alternative)
+ *        bind $text to #div's textContent  -- non-form properties: var→DOM only
+ *
+ *      For form-like elements, both directions work. For non-form elements
+ *      (e.g., binding a div's `textContent`), only var→DOM fires — there are
+ *      no input/change events to drive DOM→var, so user mutations of the
+ *      property via devtools won't propagate back.
+ */
+
+import type { ASTNode, ExecutionContext, FeatureParserCtx } from './types';
+import { reactive } from './signals';
+
+export interface BindFeatureNode extends ASTNode {
+  type: 'bindFeature';
+  left: ASTNode;
+  right: ASTNode;
+}
+
+export function parseBindFeature(ctx: unknown, token: unknown): ASTNode {
+  const pctx = ctx as FeatureParserCtx;
+  const left = pctx.parseExpression();
+  // Accept any of `to` / `and` / `with` as the separator.
+  if (!(pctx.match('to') || pctx.match('and') || pctx.match('with'))) {
+    throw new Error("bind requires 'to', 'and', or 'with' between the two sides");
+  }
+  const right = pctx.parseExpression();
+  // Optional `end` terminator (matches upstream which allows both forms).
+  if (pctx.check('end')) pctx.match('end');
+  const tok = token as { start?: number; end?: number; line?: number; column?: number };
+  return {
+    type: 'bindFeature',
+    left,
+    right,
+    start: tok?.start ?? 0,
+    end: pctx.getPosition().end,
+    line: tok?.line,
+    column: tok?.column,
+  } as BindFeatureNode;
+}
+
+/**
+ * Auto-detect the DOM property to bind by element type. Returns null if the
+ * target isn't a recognized form/editable element.
+ */
+function detectProperty(el: Element): string | null {
+  const tag = el.tagName;
+  if (tag === 'INPUT') {
+    const type = (el as HTMLInputElement).type;
+    if (type === 'checkbox' || type === 'radio') return 'checked';
+    if (type === 'number' || type === 'range') return 'valueAsNumber';
+    return 'value';
+  }
+  if (tag === 'TEXTAREA' || tag === 'SELECT') return 'value';
+  const ce = (el as HTMLElement).contentEditable;
+  if (ce === 'true') return 'textContent';
+  // Custom elements with own `value` prop.
+  if ('value' in el) return 'value';
+  return null;
+}
+
+/**
+ * If `node` is a `memberExpression` or `possessiveExpression` with a static
+ * identifier property (`#el.value` or `#el's value`), return the inner element
+ * expression and the property name. Returns null for anything else.
+ *
+ * Computed member access (`#el[prop]`) is intentionally rejected — we'd have to
+ * evaluate the index dynamically and the binding direction would be unclear.
+ * Chained property access (`#el.dataset.value`) is also not unpacked — we only
+ * peel one level. Multi-level support is a future arc.
+ */
+function unwrapExplicitProperty(node: ASTNode): { element: ASTNode; propertyName: string } | null {
+  if (!node || (node.type !== 'memberExpression' && node.type !== 'possessiveExpression')) {
+    return null;
+  }
+  if (node.type === 'memberExpression' && node.computed === true) return null;
+  const property = node.property as ASTNode | undefined;
+  const object = node.object as ASTNode | undefined;
+  if (!property || !object || property.type !== 'identifier') return null;
+  const name = (property.name as string) ?? '';
+  if (!name) return null;
+  return { element: object, propertyName: name };
+}
+
+/**
+ * Detect a chained property access on the bind RHS — e.g.
+ * `me.style.backgroundColor` or `#el's dataset's value`.
+ *
+ * After `unwrapExplicitProperty` peels the outermost member, the returned
+ * `element` is the object of that member. If that object is itself a
+ * member/possessive expression, we have a multi-level chain that v1 of
+ * bind doesn't support. Used only for the error path; the parsed AST is
+ * left intact.
+ */
+function isChainedMember(node: ASTNode | undefined): boolean {
+  if (!node) return false;
+  return node.type === 'memberExpression' || node.type === 'possessiveExpression';
+}
+
+/**
+ * Whether the input/change listener installed by `trackDomProperty` would
+ * actually fire for this element. Used to decide whether to wire up the
+ * DOM→var direction when an explicit property is given.
+ */
+function isFormLikeElement(el: Element): boolean {
+  const tag = el.tagName;
+  if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return true;
+  if ((el as HTMLElement).contentEditable === 'true') return true;
+  return false;
+}
+
+/**
+ * Whether debug logging is enabled. Mirrors signals.ts — keeps a single
+ * convention for the package.
+ */
+function debugEnabled(): boolean {
+  try {
+    return typeof localStorage !== 'undefined' && localStorage.getItem('hyperfixi:debug') !== null;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create the bind evaluator. Because `bind` has unusual parse shape (AST
+ * nodes for left/right that may be identifiers, `$name` references, or DOM
+ * element lookups), we rely on the runtime to evaluate them.
+ */
+export function makeEvaluateBindFeature(runtime: {
+  execute(node: ASTNode, ctx: ExecutionContext): Promise<unknown>;
+}): (node: ASTNode, ctx: unknown) => unknown | Promise<unknown> {
+  return async function evaluateBindFeature(node, ctx) {
+    const context = ctx as ExecutionContext;
+    const owner = (context.me as Element) ?? document.body;
+    const n = node as BindFeatureNode;
+
+    // Resolve sides. One is a var reference (read/write a symbol), the other
+    // a DOM target (read/write a property). Determine direction from node shape.
+    const leftIsVar = isVarRef(n.left);
+    const rightIsVar = isVarRef(n.right);
+
+    // We need a DOM-side descriptor (element + property) and a var-side name.
+    let varSide: { name: string; isGlobal: boolean } | null = null;
+    let domSide: { exprNode: ASTNode } | null = null;
+
+    if (leftIsVar && !rightIsVar) {
+      varSide = varRefInfo(n.left);
+      domSide = { exprNode: n.right };
+    } else if (rightIsVar && !leftIsVar) {
+      varSide = varRefInfo(n.right);
+      domSide = { exprNode: n.left };
+    } else if (leftIsVar && rightIsVar) {
+      // var-to-var binding not supported in v1 (no DOM side).
+      throw new Error('bind: cannot bind two symbols together (need a DOM side)');
+    } else {
+      throw new Error('bind: could not identify a symbol side');
+    }
+
+    // Unwrap explicit property syntax: `#el.value` or `#el's value` becomes
+    // (element-expression, propertyName). Otherwise, evaluate the whole side
+    // and rely on auto-detection.
+    const explicit = unwrapExplicitProperty(domSide.exprNode);
+    // Multi-level property access (`#el.style.background`, `me's dataset's id`)
+    // is not supported in v1. Surface that diagnosis up front; otherwise the
+    // user gets the generic "did not resolve to an element" message and no
+    // hint that the chain is the problem.
+    if (explicit && isChainedMember(explicit.element)) {
+      throw new Error(
+        'bind: multi-level property access (e.g., `#el.a.b`) is not supported in v1 — restructure to a single property write or pass the element directly for auto-detection (e.g., `bind $x to #el`).'
+      );
+    }
+    const elementExpr = explicit ? explicit.element : domSide.exprNode;
+    const domValue = await runtime.execute(elementExpr, context);
+    if (!(domValue instanceof Element)) {
+      const valueType =
+        domValue === null ? 'null' : domValue === undefined ? 'undefined' : typeof domValue;
+      const snippet =
+        domValue !== null && domValue !== undefined ? ` "${String(domValue).slice(0, 40)}"` : '';
+      const suggestion = explicit
+        ? ''
+        : " If you meant to write to a property, use the explicit form: `<selector>'s <property>`.";
+      throw new Error(
+        `bind: right-hand side did not resolve to an element (got ${valueType}${snippet}).${suggestion}`
+      );
+    }
+    const el = domValue;
+    // Explicit property bypasses auto-detect; the user takes responsibility for
+    // picking something readable from the element. For DOM→var to work without
+    // explicit property, fall back to auto-detect.
+    const prop = explicit ? explicit.propertyName : detectProperty(el);
+    if (!prop) {
+      throw new Error(
+        `bind: could not auto-detect property for <${el.tagName.toLowerCase()}> — use explicit \`<expr>'s <property>\` form`
+      );
+    }
+    // For explicit-property mode on non-form elements, DOM→var can't sync via
+    // input/change events. Skip the listener install; only var→DOM runs.
+    const installDomToVar = !explicit || isFormLikeElement(el);
+    if (explicit && !installDomToVar && debugEnabled() && typeof console !== 'undefined') {
+      console.warn(
+        `[@hyperfixi/reactivity] bind: DOM→var skipped for <${el.tagName.toLowerCase()}>.${prop} — no input/change event source.`
+      );
+    }
+
+    // Initial sync: DOM → var.
+    const readDom = (): unknown => {
+      if (prop === 'valueAsNumber') return (el as HTMLInputElement).valueAsNumber;
+      if (prop === 'checked') return (el as HTMLInputElement).checked;
+      if (prop === 'textContent') return el.textContent ?? '';
+      return (el as any)[prop];
+    };
+    const writeDom = (value: unknown): void => {
+      if (prop === 'valueAsNumber') {
+        const n = Number(value);
+        (el as HTMLInputElement).valueAsNumber = Number.isNaN(n) ? (null as never) : n;
+      } else if (prop === 'checked') {
+        (el as HTMLInputElement).checked = Boolean(value);
+      } else if (prop === 'textContent') {
+        el.textContent = value == null ? '' : String(value);
+      } else {
+        (el as any)[prop] = value;
+      }
+    };
+    const readVar = (): unknown => {
+      if (varSide!.isGlobal) return context.globals?.get(varSide!.name);
+      return context.locals?.get(varSide!.name);
+    };
+    const writeVar = (value: unknown): void => {
+      if (varSide!.isGlobal) {
+        context.globals?.set(varSide!.name, value);
+        // Bypass the global-write hook (we're touching the Map directly), so
+        // notify the reactive graph manually for the var→DOM effect.
+        reactive.notifyGlobal(varSide!.name);
+      } else {
+        context.locals?.set(varSide!.name, value);
+        // Same rationale for locals — direct Map write skips the localWriteHook,
+        // so we notify the element-scoped subscription set directly.
+        reactive.notifyElement(owner, varSide!.name);
+      }
+    };
+
+    // Effect 1: DOM → var (fires on user input). Skipped for explicit-property
+    // bindings on non-form elements — no input/change events would drive it.
+    let stopDomToVar: (() => void) | null = null;
+    if (installDomToVar) {
+      stopDomToVar = reactive.createEffect(
+        () => {
+          reactive.trackDomProperty(el, prop);
+          return readDom();
+        },
+        newValue => {
+          writeVar(newValue);
+        },
+        owner
+      );
+    }
+
+    // Effect 2: var → DOM (fires on programmatic var writes — for globals
+    // via the core's globalWriteHook, for locals via the localWriteHook the
+    // reactivity plugin registers).
+    const stopVarToDom = reactive.createEffect(
+      () => {
+        if (varSide!.isGlobal) reactive.trackGlobal(varSide!.name);
+        else reactive.trackElement(owner, varSide!.name);
+        return readVar();
+      },
+      newValue => {
+        if (newValue === undefined) return;
+        writeDom(newValue);
+      },
+      owner
+    );
+
+    if (stopDomToVar) context.registerCleanup?.(owner, stopDomToVar, 'bind-dom-to-var');
+    context.registerCleanup?.(owner, stopVarToDom, 'bind-var-to-dom');
+    return undefined;
+  };
+}
+
+/**
+ * Is this AST node a var reference we can bind to?
+ *
+ * The hyperfixi parser emits `identifier` nodes for both globals and locals,
+ * but with different shapes:
+ *   - `$foo` → `{ type: 'identifier', name: '$foo' }` (no scope field)
+ *   - `:foo` → `{ type: 'identifier', name: 'foo', scope: 'local' }`
+ *   - `::foo` → `{ type: 'identifier', name: 'foo', scope: 'global' }`
+ *
+ * We accept all three. The legacy `$`-prefix sniff stays as a fallback because
+ * `parseExpression` doesn't always set `scope`.
+ */
+function isVarRef(node: ASTNode): boolean {
+  if (!node) return false;
+  if (node.type !== 'identifier') return false;
+  const scope = node.scope as string | undefined;
+  if (scope === 'local' || scope === 'global') return true;
+  const name = (node.name as string) ?? '';
+  return name.startsWith('$') || name.startsWith(':');
+}
+
+function varRefInfo(node: ASTNode): { name: string; isGlobal: boolean } {
+  const rawName = (node.name as string) ?? '';
+  const scope = node.scope as string | undefined;
+  // Prefer the parser-emitted scope marker. Fall back to prefix sniffing for
+  // shapes where scope isn't set (e.g. `$foo` arriving as bare identifier
+  // with name '$foo').
+  let isGlobal: boolean;
+  let name: string;
+  if (scope === 'global') {
+    isGlobal = true;
+    name = rawName;
+  } else if (scope === 'local') {
+    isGlobal = false;
+    name = rawName;
+  } else if (rawName.startsWith('$')) {
+    isGlobal = true;
+    name = rawName.slice(1);
+  } else if (rawName.startsWith(':')) {
+    isGlobal = false;
+    name = rawName.slice(1);
+  } else {
+    isGlobal = false;
+    name = rawName;
+  }
+  if (!name) {
+    throw new Error('bind: variable reference has empty name');
+  }
+  return { name, isGlobal };
+}