@askrjs/askr 0.0.1 → 0.0.2

package/dist/chunk-L7RL4LYV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/dev/invariant.ts","../src/dev/logger.ts","../src/runtime/scheduler.ts","../src/runtime/fastlane.ts","../src/runtime/context.ts","../src/renderer/dom.ts","../src/runtime/component.ts","../src/router/route.ts","../src/router/match.ts"],"sourcesContent":["/**\n * Invariant assertion utilities for correctness checking\n * Production-safe: invariants are enforced at build-time or with minimal overhead\n *\n * Core principle: fail fast when invariants are violated\n * All functions throw descriptive errors for debugging\n */\n\n/**\n * Assert a condition; throw with context if false\n * @internal\n */\nexport function invariant(\n  condition: boolean,\n  message: string,\n  context?: Record<string, unknown>\n): asserts condition {\n  if (!condition) {\n    const contextStr = context ? '\\n' + JSON.stringify(context, null, 2) : '';\n    throw new Error(`[Askr Invariant] ${message}${contextStr}`);\n  }\n}\n\n/**\n * Assert object property exists and has correct type\n * @internal\n */\nexport function assertProperty<T extends object, K extends keyof T>(\n  obj: T,\n  prop: K,\n  expectedType?: string\n): asserts obj is T & Required<Pick<T, K>> {\n  invariant(prop in obj, `Object missing required property '${String(prop)}'`, {\n    object: obj,\n  });\n\n  if (expectedType) {\n    const actualType = typeof obj[prop];\n    invariant(\n      actualType === expectedType,\n      `Property '${String(prop)}' has type '${actualType}', expected '${expectedType}'`,\n      { value: obj[prop], expectedType }\n    );\n  }\n}\n\n/**\n * Assert a reference is not null/undefined\n * @internal\n */\nexport function assertDefined<T>(\n  value: T | null | undefined,\n  message: string\n): asserts value is T {\n  invariant(value !== null && value !== undefined, message, { value });\n}\n\n/**\n * Assert a task runs exactly once atomically\n * Useful for verifying lifecycle events fire precisely when expected\n * @internal\n */\nexport class Once {\n  private called = false;\n  private calledAt: number | null = null;\n  readonly name: string;\n\n  constructor(name: string) {\n    this.name = name;\n  }\n\n  check(): boolean {\n    return this.called;\n  }\n\n  mark(): void {\n    invariant(\n      !this.called,\n      `${this.name} called multiple times (previously at ${this.calledAt}ms)`,\n      { now: Date.now() }\n    );\n    this.called = true;\n    this.calledAt = Date.now();\n  }\n\n  reset(): void {\n    this.called = false;\n    this.calledAt = null;\n  }\n}\n\n/**\n * Assert a value falls in an enumerated set\n * @internal\n */\nexport function assertEnum<T extends readonly unknown[]>(\n  value: unknown,\n  allowedValues: T,\n  fieldName: string\n): asserts value is T[number] {\n  invariant(\n    allowedValues.includes(value),\n    `${fieldName} must be one of [${allowedValues.join(', ')}], got ${JSON.stringify(value)}`,\n    { value, allowed: allowedValues }\n  );\n}\n\n/**\n * Assert execution context (scheduler, component, etc)\n * @internal\n */\nexport function assertContext(\n  actual: unknown,\n  expected: unknown,\n  contextName: string\n): asserts actual is typeof expected {\n  invariant(\n    actual === expected,\n    `Invalid ${contextName} context. Expected ${expected}, got ${actual}`,\n    { expected, actual }\n  );\n}\n\n/**\n * Assert scheduling precondition (not reentering, not during render, etc)\n * @internal\n */\nexport function assertSchedulingPrecondition(\n  condition: boolean,\n  violationMessage: string\n): asserts condition {\n  invariant(condition, `[Scheduler Precondition] ${violationMessage}`);\n}\n\n/**\n * Assert state precondition\n * @internal\n */\nexport function assertStatePrecondition(\n  condition: boolean,\n  violationMessage: string\n): asserts condition {\n  invariant(condition, `[State Precondition] ${violationMessage}`);\n}\n\n/**\n * Verify AbortController lifecycle\n * @internal\n */\nexport function assertAbortControllerState(\n  signal: AbortSignal,\n  expectedAborted: boolean,\n  context: string\n): void {\n  invariant(\n    signal.aborted === expectedAborted,\n    `AbortSignal ${expectedAborted ? 'should be' : 'should not be'} aborted in ${context}`,\n    { actual: signal.aborted, expected: expectedAborted }\n  );\n}\n\n/**\n * Guard: throw if callback is null when it shouldn't be\n * Used for notifyUpdate, event handlers, etc.\n * @internal\n */\nexport function assertCallbackAvailable<\n  T extends (...args: unknown[]) => unknown,\n>(callback: T | null | undefined, callbackName: string): asserts callback is T {\n  invariant(\n    callback !== null && callback !== undefined,\n    `${callbackName} callback is required but not available`,\n    { callback }\n  );\n}\n\n/**\n * Verify evaluation generation prevents stale evaluations\n * @internal\n */\nexport function assertEvaluationGeneration(\n  current: number,\n  latest: number,\n  context: string\n): void {\n  invariant(\n    current === latest,\n    `Stale evaluation generation in ${context}: current ${current}, latest ${latest}`,\n    { current, latest }\n  );\n}\n\n/**\n * Verify mounted flag state\n * @internal\n */\nexport function assertMountedState(\n  mounted: boolean,\n  expectedMounted: boolean,\n  context: string\n): void {\n  invariant(\n    mounted === expectedMounted,\n    `Invalid mounted state in ${context}: expected ${expectedMounted}, got ${mounted}`,\n    { mounted, expected: expectedMounted }\n  );\n}\n\n/**\n * Verify no null target when rendering\n * @internal\n */\nexport function assertRenderTarget(\n  target: Element | null,\n  context: string\n): asserts target is Element {\n  invariant(target !== null, `Cannot render in ${context}: target is null`, {\n    target,\n  });\n}\n","/**\n * Centralized logger interface\n * - Keeps production builds silent for debug/warn/info messages\n * - Ensures consistent behavior across the codebase\n * - Protects against missing `console` in some environments\n */\n\nfunction callConsole(method: string, args: unknown[]): void {\n  const c = typeof console !== 'undefined' ? (console as unknown) : undefined;\n  if (!c) return;\n  const fn = (c as Record<string, unknown>)[method];\n  if (typeof fn === 'function') {\n    try {\n      (fn as (...a: unknown[]) => unknown).apply(console, args as unknown[]);\n    } catch {\n      // ignore logging errors\n    }\n  }\n}\n\nexport const logger = {\n  debug: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('debug', args);\n  },\n\n  info: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('info', args);\n  },\n\n  warn: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('warn', args);\n  },\n\n  error: (...args: unknown[]) => {\n    callConsole('error', args);\n  },\n};\n","/**\n * Serialized update scheduler — safer design (no inline execution, explicit flush)\n *\n * Key ideas:\n * - Never execute a task inline from `enqueue`.\n * - `flush()` is explicit and non-reentrant.\n * - `runWithSyncProgress()` allows enqueues temporarily but does not run tasks\n *   inline; it runs `fn` and then does an explicit `flush()`.\n * - `waitForFlush()` is race-free with a monotonic `flushVersion`.\n */\n\nimport { assertSchedulingPrecondition, invariant } from '../dev/invariant';\nimport { logger } from '../dev/logger';\n\nconst MAX_FLUSH_DEPTH = 50;\n\ntype Task = () => void;\n\nfunction isBulkCommitActive(): boolean {\n  try {\n    const fb = (\n      globalThis as unknown as {\n        __ASKR_FASTLANE?: { isBulkCommitActive?: () => boolean };\n      }\n    ).__ASKR_FASTLANE;\n    return typeof fb?.isBulkCommitActive === 'function'\n      ? !!fb.isBulkCommitActive()\n      : false;\n  } catch (e) {\n    void e;\n    return false;\n  }\n}\n\nexport class Scheduler {\n  private q: Task[] = [];\n  private head = 0;\n\n  private running = false;\n  private inHandler = false;\n  private depth = 0;\n  private executionDepth = 0; // for compat with existing diagnostics\n\n  // Monotonic flush version increments at end of each flush\n  private flushVersion = 0;\n\n  // Best-effort microtask kick scheduling\n  private kickScheduled = false;\n\n  // Escape hatch flag for runWithSyncProgress\n  private allowSyncProgress = false;\n\n  // Waiters waiting for flushVersion >= target\n  private waiters: Array<{\n    target: number;\n    resolve: () => void;\n    reject: (err: unknown) => void;\n    timer?: ReturnType<typeof setTimeout>;\n  }> = [];\n\n  // Keep a lightweight taskCount for compatibility/diagnostics\n  private taskCount = 0;\n\n  enqueue(task: Task): void {\n    assertSchedulingPrecondition(\n      typeof task === 'function',\n      'enqueue() requires a function'\n    );\n\n    // Strict rule: during bulk commit, only allow enqueues if runWithSyncProgress enabled\n    if (isBulkCommitActive() && !this.allowSyncProgress) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error(\n          '[Scheduler] enqueue() during bulk commit (not allowed)'\n        );\n      }\n      return;\n    }\n\n    // Enqueue task and account counts\n    this.q.push(task);\n    this.taskCount++;\n\n    // Microtask kick: best-effort, but avoid if we are in handler or running or bulk commit\n    if (\n      !this.running &&\n      !this.kickScheduled &&\n      !this.inHandler &&\n      !isBulkCommitActive()\n    ) {\n      this.kickScheduled = true;\n      queueMicrotask(() => {\n        this.kickScheduled = false;\n        if (this.running) return;\n        if (isBulkCommitActive()) return;\n        try {\n          this.flush();\n        } catch (err) {\n          setTimeout(() => {\n            throw err;\n          });\n        }\n      });\n    }\n  }\n\n  flush(): void {\n    invariant(\n      !this.running,\n      '[Scheduler] flush() called while already running'\n    );\n\n    // Dev-only guard: disallow flush during bulk commit unless allowed\n    if (process.env.NODE_ENV !== 'production') {\n      if (isBulkCommitActive() && !this.allowSyncProgress) {\n        throw new Error(\n          '[Scheduler] flush() started during bulk commit (not allowed)'\n        );\n      }\n    }\n\n    this.running = true;\n    this.depth = 0;\n    let fatal: unknown = null;\n\n    try {\n      while (this.head < this.q.length) {\n        this.depth++;\n        if (\n          process.env.NODE_ENV !== 'production' &&\n          this.depth > MAX_FLUSH_DEPTH\n        ) {\n          throw new Error(\n            `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`\n          );\n        }\n\n        const task = this.q[this.head++];\n        try {\n          this.executionDepth++;\n          task();\n          this.executionDepth--;\n        } catch (err) {\n          // ensure executionDepth stays balanced\n          if (this.executionDepth > 0) this.executionDepth = 0;\n          fatal = err;\n          break;\n        }\n\n        // Account for executed task in taskCount\n        if (this.taskCount > 0) this.taskCount--;\n      }\n    } finally {\n      this.running = false;\n      this.depth = 0;\n      this.executionDepth = 0;\n\n      // Compact queue\n      if (this.head >= this.q.length) {\n        this.q.length = 0;\n        this.head = 0;\n      } else if (this.head > 0) {\n        const remaining = this.q.length - this.head;\n        if (this.head > 1024 || this.head > remaining) {\n          this.q = this.q.slice(this.head);\n        } else {\n          for (let i = 0; i < remaining; i++) {\n            this.q[i] = this.q[this.head + i];\n          }\n          this.q.length = remaining;\n        }\n        this.head = 0;\n      }\n\n      // Advance flush epoch and resolve waiters\n      this.flushVersion++;\n      this.resolveWaiters();\n    }\n\n    if (fatal) throw fatal;\n  }\n\n  runWithSyncProgress<T>(fn: () => T): T {\n    const prev = this.allowSyncProgress;\n    this.allowSyncProgress = true;\n\n    const g = globalThis as unknown as {\n      queueMicrotask?: (...args: unknown[]) => void;\n      setTimeout?: (...args: unknown[]) => unknown;\n    };\n    const origQueueMicrotask = g.queueMicrotask;\n    const origSetTimeout = g.setTimeout;\n\n    if (process.env.NODE_ENV !== 'production') {\n      g.queueMicrotask = () => {\n        throw new Error(\n          '[Scheduler] queueMicrotask not allowed during runWithSyncProgress'\n        );\n      };\n      g.setTimeout = () => {\n        throw new Error(\n          '[Scheduler] setTimeout not allowed during runWithSyncProgress'\n        );\n      };\n    }\n\n    // Snapshot flushVersion so we can ensure we always complete an epoch\n    const startVersion = this.flushVersion;\n\n    try {\n      const res = fn();\n\n      // Flush deterministically if tasks were enqueued (and we're not already running)\n      if (!this.running && this.q.length - this.head > 0) {\n        this.flush();\n      }\n\n      if (process.env.NODE_ENV !== 'production') {\n        if (this.q.length - this.head > 0) {\n          throw new Error(\n            '[Scheduler] tasks remain after runWithSyncProgress flush'\n          );\n        }\n      }\n\n      return res;\n    } finally {\n      // Restore guarded globals\n      if (process.env.NODE_ENV !== 'production') {\n        g.queueMicrotask = origQueueMicrotask;\n        g.setTimeout = origSetTimeout;\n      }\n\n      // If no flush happened during the protected window, complete an epoch so\n      // observers (tests) see progress even when fast-lane did synchronous work\n      // without enqueuing tasks.\n      try {\n        if (this.flushVersion === startVersion) {\n          this.flushVersion++;\n          this.resolveWaiters();\n        }\n      } catch (e) {\n        void e;\n      }\n\n      this.allowSyncProgress = prev;\n    }\n  }\n\n  waitForFlush(targetVersion?: number, timeoutMs = 2000): Promise<void> {\n    const target =\n      typeof targetVersion === 'number' ? targetVersion : this.flushVersion + 1;\n    if (this.flushVersion >= target) return Promise.resolve();\n\n    return new Promise((resolve, reject) => {\n      const timer = setTimeout(() => {\n        const diag = {\n          flushVersion: this.flushVersion,\n          queueLen: this.q.length - this.head,\n          running: this.running,\n          inHandler: this.inHandler,\n          bulk: isBulkCommitActive(),\n          globals: {\n            __ASKR_LAST_FASTPATH_STATS: (\n              globalThis as unknown as Record<string, unknown>\n            ).__ASKR_LAST_FASTPATH_STATS,\n            __ASKR_LAST_BULK_TEXT_FASTPATH_STATS: (\n              globalThis as unknown as Record<string, unknown>\n            ).__ASKR_LAST_BULK_TEXT_FASTPATH_STATS,\n            __ASKR_FASTPATH_COUNTERS: (\n              globalThis as unknown as Record<string, unknown>\n            ).__ASKR_FASTPATH_COUNTERS,\n          },\n        };\n        reject(\n          new Error(\n            `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`\n          )\n        );\n      }, timeoutMs);\n\n      this.waiters.push({ target, resolve, reject, timer });\n    });\n  }\n\n  getState() {\n    // Provide the compatibility shape expected by diagnostics/tests\n    return {\n      queueLength: this.q.length - this.head,\n      running: this.running,\n      depth: this.depth,\n      executionDepth: this.executionDepth,\n      taskCount: this.taskCount,\n      flushVersion: this.flushVersion,\n      // New fields for optional inspection\n      inHandler: this.inHandler,\n      allowSyncProgress: this.allowSyncProgress,\n    };\n  }\n\n  setInHandler(v: boolean) {\n    this.inHandler = v;\n  }\n\n  isInHandler(): boolean {\n    return this.inHandler;\n  }\n\n  isExecuting(): boolean {\n    return this.running || this.executionDepth > 0;\n  }\n\n  // Clear pending synchronous tasks (used by fastlane enter/exit)\n  clearPendingSyncTasks(): number {\n    const remaining = this.q.length - this.head;\n    if (remaining <= 0) return 0;\n\n    if (this.running) {\n      this.q.length = this.head;\n      this.taskCount = Math.max(0, this.taskCount - remaining);\n      queueMicrotask(() => {\n        try {\n          this.flushVersion++;\n          this.resolveWaiters();\n        } catch (e) {\n          void e;\n        }\n      });\n      return remaining;\n    }\n\n    this.q.length = 0;\n    this.head = 0;\n    this.taskCount = Math.max(0, this.taskCount - remaining);\n    this.flushVersion++;\n    this.resolveWaiters();\n    return remaining;\n  }\n\n  private resolveWaiters() {\n    if (this.waiters.length === 0) return;\n    const ready: Array<() => void> = [];\n    const remaining: typeof this.waiters = [];\n\n    for (const w of this.waiters) {\n      if (this.flushVersion >= w.target) {\n        if (w.timer) clearTimeout(w.timer);\n        ready.push(w.resolve);\n      } else {\n        remaining.push(w);\n      }\n    }\n\n    this.waiters = remaining;\n    for (const r of ready) r();\n  }\n}\n\nexport const globalScheduler = new Scheduler();\n\nexport function isSchedulerExecuting(): boolean {\n  return globalScheduler.isExecuting();\n}\n\nexport function scheduleEventHandler(handler: EventListener): EventListener {\n  return (event: Event) => {\n    globalScheduler.setInHandler(true);\n    try {\n      handler.call(null, event);\n    } catch (error) {\n      logger.error('[Askr] Event handler error:', error);\n    } finally {\n      globalScheduler.setInHandler(false);\n      // If the handler enqueued tasks while we disallowed microtask kicks,\n      // ensure we schedule a microtask to flush them now that the handler\n      // has completed. This avoids tests timing out waiting for flush.\n      const state = globalScheduler.getState();\n      if ((state.queueLength ?? 0) > 0 && !state.running) {\n        queueMicrotask(() => {\n          try {\n            if (!globalScheduler.isExecuting()) globalScheduler.flush();\n          } catch (err) {\n            setTimeout(() => {\n              throw err;\n            });\n          }\n        });\n      }\n    }\n  };\n}\n","import { globalScheduler } from './scheduler';\nimport { logger } from '../dev/logger';\nimport {\n  getKeyMapForElement,\n  isKeyedReorderFastPathEligible,\n} from '../renderer/dom';\nimport type { ComponentInstance } from './component';\n\nlet _bulkCommitActive = false;\nlet _appliedParents: WeakSet<Element> | null = null;\n\nexport function enterBulkCommit(): void {\n  _bulkCommitActive = true;\n  // Initialize registry of parents that had fast-path applied during this bulk commit\n  _appliedParents = new WeakSet<Element>();\n\n  // Clear any previously scheduled synchronous scheduler tasks so they don't\n  // retrigger evaluations during the committed fast-path. This is a safety\n  // barrier to enforce quiescence for bulk commits.\n  try {\n    const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;\n    if (process.env.NODE_ENV !== 'production') {\n      const _g = globalThis as unknown as Record<string, unknown>;\n      _g.__ASKR_FASTLANE_CLEARED_TASKS = cleared;\n    }\n  } catch (err) {\n    // In the unlikely event clearing fails in production, ignore it; in dev rethrow\n    if (process.env.NODE_ENV !== 'production') throw err;\n  }\n}\n\nexport function exitBulkCommit(): void {\n  _bulkCommitActive = false;\n  // Clear registry to avoid leaking across commits\n  _appliedParents = null;\n}\n\nexport function isBulkCommitActive(): boolean {\n  return _bulkCommitActive;\n}\n\n// Mark that a fast-path was applied on a parent element during the active\n// bulk commit. No-op if there is no active bulk commit.\nexport function markFastPathApplied(parent: Element): void {\n  if (!_appliedParents) return;\n  try {\n    _appliedParents.add(parent);\n  } catch (e) {\n    void e;\n  }\n}\n\nexport function isFastPathApplied(parent: Element): boolean {\n  return !!(_appliedParents && _appliedParents.has(parent));\n}\n\n/**\n * Attempt to execute a runtime fast-lane for a single component's synchronous\n * render result. Returns true if the fast-lane was used and commit was done.\n *\n * Preconditions (checked conservatively):\n * - The render result is an intrinsic element root with keyed children\n * - The renderer's fast-path heuristics indicate to use the fast-path\n * - No mount operations are pending on the component instance\n * - No child vnodes are component functions (avoid async/component mounts)\n */\nexport function classifyUpdate(instance: ComponentInstance, result: unknown) {\n  // Returns a classification describing whether this update is eligible for\n  // the reorder-only fast-lane. The classifier mirrors renderer-level\n  // heuristics and performs runtime-level checks (mounts, effects, component\n  // children) that the renderer cannot reason about.\n  if (!result || typeof result !== 'object' || !('type' in result))\n    return { useFastPath: false, reason: 'not-vnode' };\n  const vnode = result as {\n    type: unknown;\n    children?: unknown;\n    props?: { children?: unknown };\n  };\n  if (vnode == null || typeof vnode.type !== 'string')\n    return { useFastPath: false, reason: 'not-intrinsic' };\n\n  const parent = instance.target;\n  if (!parent) return { useFastPath: false, reason: 'no-root' };\n\n  const firstChild = parent.children[0] as Element | undefined;\n  if (!firstChild) return { useFastPath: false, reason: 'no-first-child' };\n  if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase())\n    return { useFastPath: false, reason: 'root-tag-mismatch' };\n\n  const children =\n    (vnode as { children?: unknown; props?: { children?: unknown } })\n      .children ||\n    (vnode as { props?: { children?: unknown } }).props?.children;\n  if (!Array.isArray(children))\n    return { useFastPath: false, reason: 'no-children-array' };\n\n  // Avoid component child vnodes (they may mount/unmount or trigger async)\n  for (let i = 0; i < children.length; i++) {\n    const c = children[i];\n    if (\n      typeof c === 'object' &&\n      c !== null &&\n      'type' in c &&\n      typeof (c as { type?: unknown }).type === 'function'\n    ) {\n      return { useFastPath: false, reason: 'component-child-present' };\n    }\n  }\n\n  if (instance.mountOperations.length > 0)\n    return { useFastPath: false, reason: 'pending-mounts' };\n\n  // Ask renderer for keyed reorder eligibility (prop differences & heuristics)\n  const oldKeyMap = getKeyMapForElement(firstChild);\n  const decision = isKeyedReorderFastPathEligible(\n    firstChild,\n    children,\n    oldKeyMap\n  );\n\n  if (!decision.useFastPath || decision.totalKeyed < 128)\n    return { ...decision, useFastPath: false, reason: 'renderer-declined' };\n\n  return { ...decision, useFastPath: true } as const;\n}\n\nexport function commitReorderOnly(\n  instance: ComponentInstance,\n  result: unknown\n) {\n  // Performs the minimal, synchronous reorder-only commit. Sets dev-only\n  // diagnostic fields on globalThis for test assertions and verifies\n  // invariants (no mounts, no effects, single DOM commit).\n  const evaluate = (\n    globalThis as unknown as {\n      __ASKR_RENDERER?: {\n        evaluate?: (node: unknown, target: Element | null) => void;\n      };\n    }\n  ).__ASKR_RENDERER?.evaluate;\n  if (typeof evaluate !== 'function') {\n    logger.warn(\n      '[Tempo][FASTPATH][DEV] renderer.evaluate not available; declining fast-lane'\n    );\n    return false;\n  }\n\n  const schedBefore =\n    process.env.NODE_ENV !== 'production' ? globalScheduler.getState() : null;\n\n  enterBulkCommit();\n\n  try {\n    // Execute the renderer synchronously inside a controlled scheduler\n    // escape hatch that allows deterministic synchronous scheduler progress\n    // while still preserving bulk-commit semantics (no async tasks, single DOM\n    // mutation, and rollback safety).\n    globalScheduler.runWithSyncProgress(() => {\n      evaluate(result, instance.target);\n\n      // Ensure runtime bookkeeping (read subscriptions / tokens) is finalized\n      // even when we bypass the normal scheduler-driven commit path.\n      try {\n        // Import function dynamically to avoid circular import at module top-level\n        // (component module defines finalizeReadSubscriptions).\n        // eslint-disable-next-line @typescript-eslint/no-require-imports -- circular import; require used intentionally to perform a synchronous call\n        const comp = require('./component') as typeof import('./component');\n        if (typeof comp?.finalizeReadSubscriptions === 'function') {\n          try {\n            comp.finalizeReadSubscriptions(instance);\n          } catch (e) {\n            // Surface in dev, ignore in prod\n            if (process.env.NODE_ENV !== 'production') throw e;\n          }\n        }\n      } catch (e) {\n        void e;\n      }\n    });\n\n    // Safety: clear any synchronous tasks that were scheduled during the commit\n    // but did not get executed due to flush reentrancy or microtask timing. This\n    // ensures final quiescence for bulk commits.\n    try {\n      const clearedAfter = globalScheduler.clearPendingSyncTasks?.() ?? 0;\n      if (process.env.NODE_ENV !== 'production') {\n        const _g = globalThis as unknown as Record<string, unknown>;\n        _g.__ASKR_FASTLANE_CLEARED_AFTER = clearedAfter;\n      }\n    } catch (err) {\n      if (process.env.NODE_ENV !== 'production') throw err;\n    }\n\n    // Dev-only invariant checks and diagnostics\n    if (process.env.NODE_ENV !== 'production') {\n      // Commit count recorded by renderer (set by fast-path code)\n      const _g = globalThis as unknown as Record<string, unknown>;\n      const commitCount =\n        (_g.__ASKR_LAST_FASTPATH_COMMIT_COUNT as number | undefined) ?? 0;\n      const invariants = {\n        commitCount,\n        mountOps: instance.mountOperations.length,\n        cleanupFns: instance.cleanupFns.length,\n      } as const;\n      _g.__ASKR_LAST_FASTLANE_INVARIANTS = invariants;\n\n      if (commitCount !== 1) {\n        throw new Error(\n          'Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit'\n        );\n      }\n      if (invariants.mountOps > 0) {\n        throw new Error(\n          'Fast-lane invariant violated: mount operations were registered during bulk commit'\n        );\n      }\n      if (invariants.cleanupFns > 0) {\n        throw new Error(\n          'Fast-lane invariant violated: cleanup functions were added during bulk commit'\n        );\n      }\n\n      const schedAfter = globalScheduler.getState();\n      if (\n        schedBefore &&\n        schedAfter &&\n        // Only fail if outstanding tasks increased — consuming existing tasks is allowed\n        schedAfter.taskCount > schedBefore.taskCount\n      ) {\n        try {\n          console.error(\n            '[FASTLANE] schedBefore, schedAfter',\n            schedBefore,\n            schedAfter\n          );\n\n          console.error(\n            '[FASTLANE] enqueue logs',\n            (globalThis as unknown as Record<string, unknown>)\n              .__ASKR_ENQUEUE_LOGS\n          );\n        } catch (e) {\n          void e;\n        }\n        throw new Error(\n          'Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit'\n        );\n      }\n\n      // Final quiescence assertion: ensure scheduler has no pending sync tasks\n      let finalState = globalScheduler.getState();\n      // Adjust expected task count by subtracting the currently executing task\n      // (we're inside that task at the time of this check). The goal is to\n      // ensure there are no *other* pending tasks beyond the active execution.\n      const executing = globalScheduler.isExecuting();\n      const outstandingAfter = Math.max(\n        0,\n        finalState.taskCount - (executing ? 1 : 0)\n      );\n\n      if (outstandingAfter !== 0) {\n        // Attempt to clear newly enqueued synchronous tasks that may have\n        // been scheduled in microtasks or during remaining flush operations.\n        // This loop is conservative and only runs in dev to help catch\n        // flaky microtask timing windows; in prod we prefer to fail-safe by\n        // dropping such tasks earlier.\n        if (process.env.NODE_ENV !== 'production') {\n          let attempts = 0;\n          while (attempts < 5) {\n            const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;\n            if (cleared === 0) break;\n            attempts++;\n          }\n          finalState = globalScheduler.getState();\n          const outstandingAfter2 = Math.max(\n            0,\n            finalState.taskCount - (globalScheduler.isExecuting() ? 1 : 0)\n          );\n          if (outstandingAfter2 !== 0) {\n            try {\n              const _g = globalThis as unknown as Record<string, unknown>;\n\n              console.error(\n                '[FASTLANE] Post-commit enqueue logs:',\n                _g.__ASKR_ENQUEUE_LOGS\n              );\n\n              console.error(\n                '[FASTLANE] Cleared counts:',\n                _g.__ASKR_FASTLANE_CLEARED_TASKS,\n                _g.__ASKR_FASTLANE_CLEARED_AFTER\n              );\n            } catch (err) {\n              void err;\n            }\n            throw new Error(\n              `Fast-lane invariant violated: scheduler has ${finalState.taskCount} pending task(s) after commit`\n            );\n          }\n        } else {\n          // In production, silently drop remaining synchronous tasks to preserve\n          // atomicity and avoid leaving the system in a non-quiescent state.\n          globalScheduler.clearPendingSyncTasks?.();\n        }\n      }\n    }\n\n    return true;\n  } finally {\n    exitBulkCommit();\n\n    // Dev-time: ensure the bulk commit flag was cleared by the end of the operation\n    // NOTE: avoid throwing inside `finally` (no-unsafe-finally). Capture the\n    // failure and rethrow after the finally block.\n    // We set a flag on `globalThis` to check after the finally, which will be\n    // handled below.\n    if (process.env.NODE_ENV !== 'production') {\n      try {\n        const _g = globalThis as unknown as Record<string, unknown>;\n        _g.__ASKR_FASTLANE_BULK_FLAG_CHECK = isBulkCommitActive();\n      } catch (e) {\n        void e;\n      }\n    }\n  }\n\n  // Re-check the captured assertion outside of finally and throw if needed\n  if (process.env.NODE_ENV !== 'production') {\n    const _g = globalThis as unknown as Record<string, unknown>;\n    if (_g.__ASKR_FASTLANE_BULK_FLAG_CHECK) {\n      delete _g.__ASKR_FASTLANE_BULK_FLAG_CHECK;\n      throw new Error(\n        'Fast-lane invariant violated: bulk commit flag still set after commit'\n      );\n    }\n  }\n}\n\nexport function tryRuntimeFastLaneSync(\n  instance: ComponentInstance,\n  result: unknown\n): boolean {\n  const cls = classifyUpdate(instance, result);\n  if (!cls.useFastPath) return false;\n\n  try {\n    return commitReorderOnly(instance, result);\n  } catch (err) {\n    // Surface dev-only invariant failures, otherwise decline silently\n    if (process.env.NODE_ENV !== 'production') throw err;\n    return false;\n  }\n}\n\n// Expose fastlane bridge on globalThis for environments/tests that access it\n// synchronously without using ES module dynamic imports.\nif (typeof globalThis !== 'undefined') {\n  const _g = globalThis as unknown as Record<string, unknown>;\n  _g.__ASKR_FASTLANE = {\n    isBulkCommitActive,\n    enterBulkCommit,\n    exitBulkCommit,\n    tryRuntimeFastLaneSync,\n    markFastPathApplied,\n    isFastPathApplied,\n  };\n}\n","/**\n * Context system: lexical scope + render-time snapshots\n *\n * CORE SEMANTIC (Option A — Snapshot-Based):\n * ============================================\n * An async resource observes the context of the render that created it.\n * Context changes only take effect via re-render, not magically mid-await.\n *\n * This ensures:\n * - Deterministic behavior\n * - Concurrency safety\n * - Replayable execution\n * - Debuggability\n *\n * INVARIANTS:\n * - readContext() only works during component render (has currentContextFrame)\n * - Each render captures a context snapshot\n * - Async continuations see the snapshot from render start (frozen)\n * - Provider (Scope) creates a new frame that shadows parent\n * - Context updates require re-render to take effect\n */\n\nimport type { JSXElement } from '../jsx/types';\nimport type { Props } from '../shared/types';\nimport { getCurrentComponentInstance } from './component';\n\nexport type ContextKey = symbol;\n\n// Lightweight VNode definition used for JSX typing in this module\ntype VNode = {\n  type: string;\n  props?: Record<string, unknown>;\n  children?: (string | VNode | null | undefined | false)[];\n};\n\n// Union of allowed render return values (text, vnode, JSX element, etc.)\ntype Renderable =\n  | JSXElement\n  | VNode\n  | string\n  | number\n  | null\n  | undefined\n  | false;\n\nexport interface Context<T> {\n  readonly key: ContextKey;\n  readonly defaultValue: T;\n  // A Scope is a JSX-style element factory returning a JSXElement (component invocation)\n  readonly Scope: (props: { value: T; children?: unknown }) => JSXElement;\n}\n\nexport interface ContextFrame {\n  parent: ContextFrame | null;\n  // Lazily allocate `values` Map only when a provider sets values or a read occurs.\n  values: Map<ContextKey, unknown> | null;\n}\n\n// Symbol to mark vnodes that need frame restoration\nexport const CONTEXT_FRAME_SYMBOL = Symbol('__tempoContextFrame__');\n\n// Global context frame stack (maintained during render)\n// INVARIANT: Must NEVER be non-null across an await boundary\nlet currentContextFrame: ContextFrame | null = null;\n\n// Async resource frame (maintained during async resource execution)\n// INVARIANT: Set only for synchronous execution steps, cleared in finally\n// This allows async resources to access their frozen render-time snapshot\nlet currentAsyncResourceFrame: ContextFrame | null = null;\n\n/**\n * Execute a function within a specific context frame.\n *\n * CORE PRIMITIVE for context restoration:\n * - Saves the current context\n * - Sets the provided frame as current\n * - Executes the function\n * - Restores the previous context in finally\n *\n * This ensures no context frame remains globally active across await.\n */\nexport function withContext<T>(frame: ContextFrame | null, fn: () => T): T {\n  const oldFrame = currentContextFrame;\n  currentContextFrame = frame;\n  try {\n    return fn();\n  } finally {\n    currentContextFrame = oldFrame;\n  }\n}\n\n/**\n * Execute an async resource step within its frozen context snapshot.\n *\n * CRITICAL: This wrapper is applied only to synchronous execution steps of\n * an async resource (the initial call). We intentionally DO NOT restore\n * the resource frame for post-await continuations — continuations must not\n * observe or rely on a live resource frame. This keeps semantics simple and\n * deterministic: async resources see only their creation-time snapshot.\n */\nexport function withAsyncResourceContext<T>(\n  frame: ContextFrame | null,\n  fn: () => T\n): T {\n  const oldFrame = currentAsyncResourceFrame;\n  // Only set the frame for the synchronous execution step\n  currentAsyncResourceFrame = frame;\n  try {\n    return fn();\n  } finally {\n    // Clear the frame to avoid exposing it across await boundaries\n    currentAsyncResourceFrame = oldFrame;\n  }\n}\n\nexport function defineContext<T>(defaultValue: T): Context<T> {\n  const key = Symbol('AskrContext');\n\n  return {\n    key,\n    defaultValue,\n    Scope: (props: { value: T; children?: unknown }): JSXElement => {\n      // Scope component: creates a new frame and renders children within it\n      return {\n        type: ContextScopeComponent,\n        props: { key, value: props.value, children: props.children },\n      } as unknown as JSXElement;\n    },\n  };\n}\n\nexport function readContext<T>(context: Context<T>): T {\n  // Check render frame first (components), then async resource frame (resources)\n  const frame = currentContextFrame || currentAsyncResourceFrame;\n\n  if (!frame) {\n    throw new Error(\n      'readContext() can only be called during component render or async resource execution. ' +\n        'Ensure you are calling this from inside your component or resource function.'\n    );\n  }\n\n  let current: ContextFrame | null = frame;\n  while (current) {\n    // `values` may be null when no provider has created it yet — treat as empty\n    const values = current.values;\n    if (values && values.has(context.key)) {\n      return values.get(context.key) as T;\n    }\n    current = current.parent;\n  }\n  return context.defaultValue;\n}\n\n/**\n * Internal component that manages context frame\n * Used by Context.Scope to provide shadowed value to children\n */\nfunction ContextScopeComponent(props: Props): Renderable {\n  // Extract expected properties (we accept a loose shape so this can be used as a component type)\n  const key = props['key'] as ContextKey;\n  const value = props['value'];\n  const children = props['children'] as Renderable;\n\n  // Create a new frame with this value\n  const instance = getCurrentComponentInstance();\n  const parentFrame: ContextFrame | null = (() => {\n    // Prefer the live render frame.\n    // Note: the runtime executes component functions inside an empty \"render frame\"\n    // whose parent points at the nearest provider chain. Even if this frame has no\n    // values, it must still be used to preserve the parent linkage.\n    if (currentContextFrame) return currentContextFrame;\n\n    // If there is no live render frame (should be rare), fall back to the\n    // instance's owner frame.\n    if (instance && instance.ownerFrame) return instance.ownerFrame;\n\n    // Do NOT fall back to the async snapshot stack here: that stack represents\n    // unrelated async continuations and must not affect lexical provider chaining.\n    return null;\n  })();\n\n  const newFrame: ContextFrame = {\n    parent: parentFrame,\n    values: new Map([[key, value]]),\n  };\n\n  // The renderer will set ownerFrame on child component instances when they're created.\n  // We mark vnodes with the frame so the renderer knows which frame to assign.\n  if (Array.isArray(children)) {\n    // Mark array elements with the frame. If an element is a function-child,\n    // convert it into a lazy invoker so it's executed later inside the frame.\n    return children.map((child) => {\n      if (typeof child === 'function') {\n        return {\n          type: ContextFunctionChildInvoker,\n          props: {\n            fn: child as () => Renderable,\n            __frame: newFrame,\n            __owner: getCurrentComponentInstance(),\n          },\n        } as unknown as Renderable;\n      }\n      return markWithFrame(child, newFrame);\n    }) as unknown as Renderable;\n  } else if (typeof children === 'function') {\n    // If children is a function (render callback), do NOT execute it eagerly\n    // during the parent render. Instead, return a small internal component\n    // that will execute the function later (when it itself is rendered) and\n    // will execute it within the provider frame so any reads performed during\n    // that execution observe the provider's frame.\n    return {\n      type: ContextFunctionChildInvoker,\n      props: {\n        fn: children as () => Renderable,\n        __frame: newFrame,\n        __owner: getCurrentComponentInstance(),\n      },\n    } as unknown as Renderable;\n  } else if (children) {\n    return markWithFrame(children, newFrame);\n  }\n\n  return null;\n}\n\n/**\n * Internal: Mark a vnode with a context frame\n * The renderer will restore this frame before executing component functions\n */\nfunction markWithFrame(node: Renderable, frame: ContextFrame): Renderable {\n  // Recursively mark node and its subtree so nested provider/component\n  // executions will restore the correct frame when they are rendered.\n  if (typeof node === 'object' && node !== null) {\n    const obj = node as Record<string | symbol, unknown>;\n    obj[CONTEXT_FRAME_SYMBOL] = frame;\n\n    // If the node is a VNode with children, recursively mark its children\n    const children = obj.children as unknown;\n    if (Array.isArray(children)) {\n      for (let i = 0; i < children.length; i++) {\n        const child = children[i] as Renderable;\n        if (child) {\n          children[i] = markWithFrame(child, frame) as Renderable;\n        }\n      }\n    } else if (children) {\n      obj.children = markWithFrame(children as Renderable, frame) as Renderable;\n    }\n  }\n  return node;\n}\n\n/**\n * Internal helper component: executes a function-child lazily inside the\n * provided frame and marks the returned subtree with that frame so later\n * component executions will restore the correct context frame.\n *\n * SNAPSHOT SEMANTIC: The frame passed here is the snapshot captured at render\n * time. Any resources created during this execution will observe this frozen\n * snapshot, ensuring deterministic behavior.\n */\nfunction ContextFunctionChildInvoker(props: {\n  fn: () => Renderable;\n  __frame: ContextFrame;\n}): Renderable {\n  const { fn, __frame } = props;\n\n  // Execute the function-child within the provider frame.\n  // The owner's ownerFrame is already set by the renderer when the component was created.\n  // Any resources started during this execution will capture this frame as their\n  // snapshot, ensuring they see the context values from this render, not future renders.\n  const res = withContext(__frame, () => fn());\n\n  // Mark the result so the renderer knows to set ownerFrame on child instances\n  if (res) return markWithFrame(res, __frame);\n  return null;\n}\n\n/**\n * Push a new context frame (for render entry)\n * Called by component runtime when render starts\n */\nexport function pushContextFrame(): ContextFrame {\n  // Lazily allocate the `values` map to avoid per-render allocations when\n  // components do not use context. The map will be created when a provider\n  // sets a value or when a read discovers no map and needs to behave as empty.\n  const frame: ContextFrame = {\n    parent: currentContextFrame,\n    values: null,\n  };\n  currentContextFrame = frame;\n  return frame;\n}\n\n/**\n * Pop context frame (for render exit)\n * Called by component runtime when render ends\n */\nexport function popContextFrame(): void {\n  if (currentContextFrame) {\n    currentContextFrame = currentContextFrame.parent;\n  }\n}\n\n/**\n * Get the current context frame for inspection (used by tests/diagnostics only)\n */\nexport function getCurrentContextFrame(): ContextFrame | null {\n  return currentContextFrame;\n}\n\n/**\n * Get the top of the context snapshot stack (used by runtime when deciding\n * how to link snapshots for async continuations). Returns null if stack empty.\n */\nexport function getTopContextSnapshot(): ContextFrame | null {\n  return currentContextFrame;\n}\n\n/**\n * Deprecated aliases for backward compatibility\n * These should not be used in new code\n */\nexport function executeWithinFrame<T>(\n  frame: ContextFrame | null,\n  fn: () => T\n): T {\n  return withContext(frame, fn);\n}\n","/**\n * DOM mounting and updates\n * Direct DOM manipulation, no VDOM - heavily optimized for speed\n */\n\nimport { globalScheduler, isSchedulerExecuting } from '../runtime/scheduler';\nimport {\n  isBulkCommitActive,\n  markFastPathApplied,\n  isFastPathApplied,\n} from '../runtime/fastlane';\nimport { logger } from '../dev/logger';\nimport type { Props } from '../shared/types';\nimport { Fragment } from '../jsx/jsx-runtime';\nimport {\n  CONTEXT_FRAME_SYMBOL,\n  type ContextFrame,\n  withContext,\n  getCurrentContextFrame,\n} from '../runtime/context';\nimport {\n  createComponentInstance,\n  renderComponentInline,\n  mountInstanceInline,\n  cleanupComponent,\n} from '../runtime/component';\nimport type {\n  ComponentFunction,\n  ComponentInstance,\n} from '../runtime/component';\n\ntype InstanceHost = Element & { __ASKR_INSTANCE?: ComponentInstance };\n\n// Helpers to clean up component instances when their host DOM nodes are removed\nfunction cleanupInstanceIfPresent(node: Node | null): void {\n  if (!node) return;\n  if (!(node instanceof Element)) return;\n  try {\n    const inst = (node as InstanceHost).__ASKR_INSTANCE;\n    if (inst) {\n      cleanupComponent(inst);\n      try {\n        delete (node as InstanceHost).__ASKR_INSTANCE;\n      } catch (e) {\n        void e;\n      }\n    }\n  } catch (err) {\n    // Swallow cleanup errors but keep a reference to avoid empty-block lint error\n    void err;\n  }\n\n  // Also attempt to clean up any nested instances that may be attached\n  // on descendants (defensive: some components may attach to deeper nodes)\n  try {\n    const descendants = node.querySelectorAll('*');\n    for (const d of Array.from(descendants)) {\n      try {\n        const inst = (d as InstanceHost).__ASKR_INSTANCE;\n        if (inst) {\n          cleanupComponent(inst);\n          try {\n            delete (d as InstanceHost).__ASKR_INSTANCE;\n          } catch (e) {\n            void e;\n          }\n        }\n      } catch (err) {\n        void err;\n      }\n    }\n  } catch (err) {\n    void err;\n  }\n}\n\ninterface DOMElement {\n  type: string | ((props: Props) => unknown);\n  props?: Props;\n  children?: VNode[];\n  key?: string | number;\n}\n\n// Type for virtual DOM nodes\nexport type VNode = DOMElement | string | number | boolean | null | undefined;\n\n// Type for elements that have context frames attached\ninterface ElementWithContext extends DOMElement {\n  [CONTEXT_FRAME_SYMBOL]?: ContextFrame;\n}\n\nfunction _isDOMElement(node: unknown): node is DOMElement {\n  return typeof node === 'object' && node !== null && 'type' in node;\n}\n\n/**\n * Internal marker for component-owned DOM ranges\n * Allows efficient partial DOM updates instead of clearing entire target\n */\ninterface DOMRange {\n  start: Node; // Start marker (comment node)\n  end: Node; // End marker (comment node)\n}\n\nconst domRanges = new WeakMap<object, DOMRange>();\n\n// Track listeners so we can remove them on cleanup\ninterface ListenerMapEntry {\n  handler: EventListener;\n  original: EventListener;\n}\nconst elementListeners = new WeakMap<Element, Map<string, ListenerMapEntry>>();\n\n// Track keyed elements for reconciliation\ninterface _KeyedChild {\n  key: string | number;\n  vnode: unknown;\n}\nconst keyedElements = new WeakMap<Element, Map<string | number, Element>>();\n\n// Exported for runtime use: retrieve existing keyed map for a parent element\nexport function getKeyMapForElement(el: Element) {\n  return keyedElements.get(el);\n}\n\n// Track which parents had the reconciler record fast-path stats during the\n// current evaluation, so we can preserve diagnostics across additional\n// reconciliations within the same render pass without leaking between runs.\nconst _reconcilerRecordedParents = new WeakSet<Element>();\n\nexport function removeElementListeners(element: Element): void {\n  const map = elementListeners.get(element);\n  if (map) {\n    for (const [eventName, entry] of map) {\n      element.removeEventListener(eventName, entry.handler);\n    }\n    elementListeners.delete(element);\n  }\n}\n\nexport function removeAllListeners(root: Element | null): void {\n  if (!root) return;\n\n  // Remove listeners from root\n  removeElementListeners(root);\n\n  // Recursively remove from all children\n  const children = root.querySelectorAll('*');\n  for (let i = 0; i < children.length; i++) {\n    removeElementListeners(children[i]);\n  }\n}\n\nexport function evaluate(\n  node: unknown,\n  target: Element | null,\n  context?: object\n): void {\n  if (!target) return;\n  // Debug tracing to help understand why initial mounts sometimes don't\n  // result in DOM mutations during tests.\n\n  // If context provided, use component-owned DOM range (only replace that range)\n  if (context && domRanges.has(context)) {\n    const range = domRanges.get(context)!;\n    // Remove all nodes between start and end markers\n    let current = range.start.nextSibling;\n    while (current && current !== range.end) {\n      const next = current.nextSibling;\n      current.remove();\n      current = next;\n    }\n    // Append new DOM before end marker\n    const dom = createDOMNode(node);\n    if (dom) {\n      target.insertBefore(dom, range.end);\n    }\n  } else if (context) {\n    // First render with context: create range markers\n    const start = document.createComment('component-start');\n    const end = document.createComment('component-end');\n    target.appendChild(start);\n    target.appendChild(end);\n    domRanges.set(context, { start, end });\n    // Render into the range\n    const dom = createDOMNode(node);\n    if (dom) {\n      target.insertBefore(dom, end);\n    }\n  } else {\n    // Root render (no context): smart update strategy\n    // If target has exactly one child of the same element type as the vnode,\n    // reuse the element and just update its content.\n    // This preserves the element reference and event handlers across renders.\n\n    const vnode = node;\n    const firstChild = target.children[0] as Element | undefined;\n\n    if (\n      firstChild &&\n      _isDOMElement(vnode) &&\n      typeof vnode.type === 'string' &&\n      firstChild.tagName.toLowerCase() === vnode.type.toLowerCase()\n    ) {\n      // Reuse the existing element - it's the same type\n\n      // Smart child update: if the only child is a single text node and vnode only has text children,\n      // update the text node in place instead of replacing\n      const vnodeChildren = vnode.children || vnode.props?.children;\n\n      // Determine if this should be a simple text update\n      let isSimpleTextVNode = false;\n      let textContent: string | undefined;\n\n      if (!Array.isArray(vnodeChildren)) {\n        if (\n          typeof vnodeChildren === 'string' ||\n          typeof vnodeChildren === 'number'\n        ) {\n          isSimpleTextVNode = true;\n          textContent = String(vnodeChildren);\n        }\n      } else if (vnodeChildren.length === 1) {\n        // Array with single element - check if it's text\n        const child = vnodeChildren[0];\n        if (typeof child === 'string' || typeof child === 'number') {\n          isSimpleTextVNode = true;\n          textContent = String(child);\n        }\n      }\n\n      if (\n        isSimpleTextVNode &&\n        firstChild.childNodes.length === 1 &&\n        firstChild.firstChild?.nodeType === 3\n      ) {\n        // Update existing text node in place\n        (firstChild.firstChild as Text).data = textContent!;\n      } else {\n        // Clear and repopulate children\n        if (vnodeChildren) {\n          if (Array.isArray(vnodeChildren)) {\n            // Check if any children have keys - if so, use keyed reconciliation\n            const hasKeys = vnodeChildren.some(\n              (child) =>\n                typeof child === 'object' && child !== null && 'key' in child\n            );\n\n            if (hasKeys) {\n              // Get existing key map or create new one\n              let oldKeyMap = keyedElements.get(firstChild);\n              if (!oldKeyMap) {\n                oldKeyMap = new Map();\n              }\n\n              // Optional forced positional bulk path for large keyed lists\n              try {\n                if (process.env.ASKR_FORCE_BULK_POSREUSE === '1') {\n                  try {\n                    const keyedVnodes: Array<{\n                      key: string | number;\n                      vnode: VNode;\n                    }> = [];\n                    for (\n                      let i = 0;\n                      i < (vnodeChildren as VNode[]).length;\n                      i++\n                    ) {\n                      const c = (vnodeChildren as VNode[])[i];\n                      if (\n                        _isDOMElement(c) &&\n                        (c as DOMElement).key !== undefined\n                      ) {\n                        keyedVnodes.push({\n                          key: (c as DOMElement).key as string | number,\n                          vnode: c,\n                        });\n                      }\n                    }\n                    // Only apply when all children are keyed and count matches\n                    if (\n                      keyedVnodes.length > 0 &&\n                      keyedVnodes.length === (vnodeChildren as VNode[]).length\n                    ) {\n                      logger.warn(\n                        '[Askr][FASTPATH] forced positional bulk keyed reuse (evaluate-level)'\n                      );\n                      const stats = performBulkPositionalKeyedTextUpdate(\n                        firstChild,\n                        keyedVnodes\n                      );\n                      if (\n                        process.env.NODE_ENV !== 'production' ||\n                        process.env.ASKR_FASTPATH_DEBUG === '1'\n                      ) {\n                        try {\n                          const gl = globalThis as unknown as {\n                            __ASKR_LAST_FASTPATH_STATS?: unknown;\n                            __ASKR_LAST_FASTPATH_COMMIT_COUNT?:\n                              | number\n                              | undefined;\n                            __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n                          };\n                          (gl.__ASKR_LAST_FASTPATH_STATS as unknown) = stats;\n                          // Mark a single logical commit for dev diagnostics so\n                          // runtime fast-lane invariants can validate commit counts.\n                          gl.__ASKR_LAST_FASTPATH_COMMIT_COUNT = 1;\n                          const counters =\n                            (gl.__ASKR_FASTPATH_COUNTERS as Record<\n                              string,\n                              number\n                            >) || {};\n                          counters.bulkKeyedPositionalForced =\n                            (counters.bulkKeyedPositionalForced || 0) + 1;\n                          gl.__ASKR_FASTPATH_COUNTERS = counters;\n                        } catch (e) {\n                          void e;\n                        }\n                      }\n                      // Rebuild keyed map\n                      try {\n                        const map = new Map<string | number, Element>();\n                        const children = Array.from(firstChild.children);\n                        for (let i = 0; i < children.length; i++) {\n                          const el = children[i] as Element;\n                          const k = el.getAttribute('data-key');\n                          if (k !== null) {\n                            map.set(k, el);\n                            const n = Number(k);\n                            if (!Number.isNaN(n)) map.set(n, el);\n                          }\n                        }\n                        keyedElements.set(firstChild, map);\n                      } catch (e) {\n                        void e;\n                      }\n                    } else {\n                      // Fall back to normal reconciliation below\n                      const newKeyMap = reconcileKeyedChildren(\n                        firstChild,\n                        vnodeChildren,\n                        oldKeyMap\n                      );\n                      keyedElements.set(firstChild, newKeyMap);\n                    }\n                  } catch (err) {\n                    logger.warn(\n                      '[Askr][FASTPATH] forced bulk path failed, falling back',\n                      err\n                    );\n                    const newKeyMap = reconcileKeyedChildren(\n                      firstChild,\n                      vnodeChildren,\n                      oldKeyMap\n                    );\n                    keyedElements.set(firstChild, newKeyMap);\n                  }\n                } else {\n                  // Do reconciliation - this will reuse existing keyed elements\n                  const newKeyMap = reconcileKeyedChildren(\n                    firstChild,\n                    vnodeChildren,\n                    oldKeyMap\n                  );\n                  keyedElements.set(firstChild, newKeyMap);\n                }\n              } catch (e) {\n                void e; // suppress unused variable lint\n                // Fall back to normal reconciliation on error\n                const newKeyMap = reconcileKeyedChildren(\n                  firstChild,\n                  vnodeChildren,\n                  oldKeyMap\n                );\n                keyedElements.set(firstChild, newKeyMap);\n              }\n            } else {\n              // Unkeyed - consider bulk text fast-path for large text-dominant updates\n              if (isBulkTextFastPathEligible(firstChild, vnodeChildren)) {\n                const stats = performBulkTextReplace(firstChild, vnodeChildren);\n                // Dev-only instrumentation counters\n                if (process.env.NODE_ENV !== 'production') {\n                  try {\n                    const gl = globalThis as unknown as {\n                      __ASKR_LAST_BULK_TEXT_FASTPATH_STATS?: unknown;\n                      __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n                    };\n                    (gl.__ASKR_LAST_BULK_TEXT_FASTPATH_STATS as unknown) =\n                      stats;\n                    const counters =\n                      (gl.__ASKR_FASTPATH_COUNTERS as Record<string, number>) ||\n                      {};\n                    counters.bulkTextHits = (counters.bulkTextHits || 0) + 1;\n                    gl.__ASKR_FASTPATH_COUNTERS = counters;\n                  } catch (e) {\n                    void e;\n                  }\n                }\n              } else {\n                if (process.env.NODE_ENV !== 'production') {\n                  try {\n                    const gl = globalThis as unknown as {\n                      __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n                    };\n                    const counters =\n                      (gl.__ASKR_FASTPATH_COUNTERS as Record<string, number>) ||\n                      {};\n                    counters.bulkTextMisses =\n                      (counters.bulkTextMisses || 0) + 1;\n                    gl.__ASKR_FASTPATH_COUNTERS = counters;\n                  } catch (e) {\n                    void e;\n                  }\n                }\n                // Fall back to existing per-node updates\n                updateUnkeyedChildren(firstChild, vnodeChildren);\n                keyedElements.delete(firstChild);\n              }\n            }\n          } else {\n            // Non-array children\n            firstChild.textContent = '';\n            const dom = createDOMNode(vnodeChildren);\n            if (dom) firstChild.appendChild(dom);\n            keyedElements.delete(firstChild);\n          }\n        } else {\n          // No children\n          firstChild.textContent = '';\n          keyedElements.delete(firstChild);\n        }\n      }\n\n      // Update attributes and event listeners\n      updateElementFromVnode(firstChild, vnode, false);\n    } else {\n      // Clear and rebuild (first render or structure changed)\n      target.textContent = '';\n\n      // Check if this is an element with keyed children even on first render\n      if (_isDOMElement(vnode) && typeof vnode.type === 'string') {\n        const children = vnode.children;\n        if (\n          Array.isArray(children) &&\n          children.some(\n            (child) =>\n              typeof child === 'object' && child !== null && 'key' in child\n          )\n        ) {\n          // Create the element first\n          const el = document.createElement(vnode.type);\n          target.appendChild(el);\n\n          // Apply attributes\n          const props = vnode.props || {};\n          for (const [key, value] of Object.entries(props)) {\n            if (key === 'children' || key === 'key') continue;\n            if (value === undefined || value === null || value === false)\n              continue;\n            if (key.startsWith('on') && key.length > 2) {\n              const eventName =\n                key.slice(2).charAt(0).toLowerCase() +\n                key.slice(3).toLowerCase();\n              // Note: DOM event handlers run synchronously, but while in the\n              // handler we mark the scheduler as \"in handler\" to defer any scheduled\n              // flushes until the handler completes. This preserves synchronous\n              // handler semantics (immediate reads observe state changes), while\n              // keeping commits atomic and serialized.\n              const wrappedHandler = (event: Event) => {\n                globalScheduler.setInHandler(true);\n                try {\n                  (value as EventListener)(event);\n                } catch (error) {\n                  logger.error('[Askr] Event handler error:', error);\n                } finally {\n                  globalScheduler.setInHandler(false);\n                }\n                // After handler completes, flush any pending tasks\n                // globalScheduler.flush(); // Defer flush to manual control for testing\n              };\n\n              el.addEventListener(eventName, wrappedHandler);\n              if (!elementListeners.has(el)) {\n                elementListeners.set(el, new Map());\n              }\n              elementListeners.get(el)!.set(eventName, {\n                handler: wrappedHandler,\n                original: value as EventListener,\n              });\n              continue;\n            }\n            if (key === 'class' || key === 'className') {\n              el.className = String(value);\n            } else if (key === 'value' || key === 'checked') {\n              (el as HTMLElement & Props)[key] = value;\n            } else {\n              el.setAttribute(key, String(value));\n            }\n          }\n\n          // Use keyed reconciliation for children\n          const newKeyMap = reconcileKeyedChildren(el, children, undefined);\n          keyedElements.set(el, newKeyMap);\n          return;\n          return;\n        }\n      }\n\n      // Default: create whole tree\n      const dom = createDOMNode(vnode);\n      if (dom) {\n        target.appendChild(dom);\n      }\n    }\n  }\n}\n\nexport function clearDOMRange(context: object): void {\n  domRanges.delete(context);\n}\n\n/**\n * Reconcile children with keys, efficiently reusing existing elements\n */\n\n// Helper exported so the runtime can decide whether to activate a higher-level\n// runtime fast-lane before doing full render bookkeeping. Returns detailed\n// decision metadata for dev-mode diagnostics.\nexport function isKeyedReorderFastPathEligible(\n  parent: Element,\n  newChildren: VNode[],\n  oldKeyMap: Map<string | number, Element> | undefined\n) {\n  const keyedVnodes: Array<{ key: string | number; vnode: VNode }> = [];\n  for (let i = 0; i < newChildren.length; i++) {\n    const child = newChildren[i];\n    if (_isDOMElement(child) && child.key !== undefined) {\n      keyedVnodes.push({ key: child.key, vnode: child });\n    }\n  }\n\n  const totalKeyed = keyedVnodes.length;\n  const newKeyOrder = keyedVnodes.map((kv) => kv.key);\n  const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];\n\n  let moveCount = 0;\n  for (let i = 0; i < newKeyOrder.length; i++) {\n    const k = newKeyOrder[i];\n    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k || !oldKeyMap?.has(k)) {\n      moveCount++;\n    }\n  }\n\n  const FAST_MOVE_THRESHOLD_ABS = 64;\n  const FAST_MOVE_THRESHOLD_REL = 0.1; // 10%\n  const cheapMoveTrigger =\n    totalKeyed >= 128 &&\n    oldKeyOrder.length > 0 &&\n    moveCount >\n      Math.max(\n        FAST_MOVE_THRESHOLD_ABS,\n        Math.floor(totalKeyed * FAST_MOVE_THRESHOLD_REL)\n      );\n\n  let lisTrigger = false;\n  let lisLen = 0;\n  if (totalKeyed >= 128) {\n    const parentChildren = Array.from(parent.children);\n    const positions: number[] = new Array(keyedVnodes.length).fill(-1);\n    for (let i = 0; i < keyedVnodes.length; i++) {\n      const key = keyedVnodes[i].key;\n      const el = oldKeyMap?.get(key);\n      if (el && el.parentElement === parent) {\n        positions[i] = parentChildren.indexOf(el);\n      }\n    }\n\n    const tails: number[] = [];\n    for (let i = 0; i < positions.length; i++) {\n      const pos = positions[i];\n      if (pos === -1) continue;\n      let lo = 0;\n      let hi = tails.length;\n      while (lo < hi) {\n        const mid = (lo + hi) >> 1;\n        if (tails[mid] < pos) lo = mid + 1;\n        else hi = mid;\n      }\n      if (lo === tails.length) tails.push(pos);\n      else tails[lo] = pos;\n    }\n    lisLen = tails.length;\n    lisTrigger = lisLen < Math.floor(totalKeyed * 0.5);\n  }\n\n  // Conservative rule: if any keyed vnode declares non-trivial props\n  // (excluding event handlers), decline the fast-path. This prevents edge\n  // cases where props exist but match current DOM; the runtime fast-lane is\n  // only for pure reorder-only updates.\n  let hasPropsPresent = false;\n  for (let i = 0; i < keyedVnodes.length; i++) {\n    const vnode = keyedVnodes[i].vnode;\n    if (!_isDOMElement(vnode)) continue;\n    const props = vnode.props || {};\n    for (const k of Object.keys(props)) {\n      if (k === 'children' || k === 'key') continue;\n      if (k.startsWith('on') && k.length > 2) continue; // ignore event handlers\n      if (k.startsWith('data-')) continue; // allow data-* attrs (keys/materialization)\n      hasPropsPresent = true;\n      break;\n    }\n    if (hasPropsPresent) break;\n  }\n\n  // Check for conservative prop differences on existing elements\n  let hasPropChanges = false;\n  for (let i = 0; i < keyedVnodes.length; i++) {\n    const { key, vnode } = keyedVnodes[i];\n    const el = oldKeyMap?.get(key);\n    if (!el || !_isDOMElement(vnode)) continue;\n    const props = vnode.props || {};\n    for (const k of Object.keys(props)) {\n      if (k === 'children' || k === 'key') continue;\n      if (k.startsWith('on') && k.length > 2) continue;\n      if (k.startsWith('data-')) continue; // ignore data-* attrs (e.g. data-key)\n      const v = (props as Record<string, unknown>)[k];\n      try {\n        if (k === 'class' || k === 'className') {\n          if (el.className !== String(v)) {\n            hasPropChanges = true;\n            break;\n          }\n        } else if (k === 'value' || k === 'checked') {\n          if ((el as HTMLElement & Record<string, unknown>)[k] !== v) {\n            hasPropChanges = true;\n            break;\n          }\n        } else {\n          const attr = el.getAttribute(k);\n          if (v === undefined || v === null || v === false) {\n            if (attr !== null) {\n              hasPropChanges = true;\n              break;\n            }\n          } else if (String(v) !== attr) {\n            hasPropChanges = true;\n            break;\n          }\n        }\n      } catch {\n        hasPropChanges = true;\n        break;\n      }\n    }\n    if (hasPropChanges) break;\n  }\n\n  const useFastPath =\n    (cheapMoveTrigger || lisTrigger) && !hasPropChanges && !hasPropsPresent;\n\n  return {\n    useFastPath,\n    totalKeyed,\n    moveCount,\n    lisLen,\n    hasPropChanges,\n  } as const;\n}\n\nfunction reconcileKeyedChildren(\n  parent: Element,\n  newChildren: VNode[],\n  oldKeyMap: Map<string | number, Element> | undefined\n): Map<string | number, Element> {\n  const newKeyMap = new Map<string | number, Element>();\n\n  // First pass: collect all keyed vnodes and match to existing elements\n  const keyedVnodes: Array<{ key: string | number; vnode: VNode }> = [];\n  const unkeyedVnodes: VNode[] = [];\n\n  for (let i = 0; i < newChildren.length; i++) {\n    const child = newChildren[i];\n    if (_isDOMElement(child) && child.key !== undefined) {\n      keyedVnodes.push({ key: child.key, vnode: child });\n    } else {\n      unkeyedVnodes.push(child);\n    }\n  }\n\n  // Decide whether to use the fast-path. We use two heuristics:\n  //  - cheap move heuristic: positional mismatches in-memory (no DOM reads)\n  //  - LIS-based heuristic: compute Longest Increasing Subsequence on the\n  //    parent's current children order (requires reading current DOM order)\n  // Additionally, the fast-path is only valid if there are NO prop/event\n  // changes to existing keyed elements; it's strictly a bulk reorder escape.\n  const totalKeyed = keyedVnodes.length;\n  const newKeyOrder = keyedVnodes.map((kv) => kv.key);\n  const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];\n\n  // Conservative mismatch count: positional differences or new insertions\n  // count as moves. This intentionally avoids any DOM traversal.\n  let moveCount = 0;\n  for (let i = 0; i < newKeyOrder.length; i++) {\n    const k = newKeyOrder[i];\n    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k || !oldKeyMap?.has(k)) {\n      moveCount++;\n    }\n  }\n\n  // Fast-path eligibility is computed by `isKeyedReorderFastPathEligible`.\n  // We intentionally avoid duplicating the heuristic computation here to keep\n  // the logic centralized and prevent unused-variable lint errors.\n  // Check for prop / event-handler changes on existing nodes. If any keyed vnode\n  // introduces attribute/event handler changes compared to the current element\n  // state, decline the fast-path to preserve correctness (we will do fine-grained updates).\n  let hasPropChanges = false;\n  for (let i = 0; i < keyedVnodes.length; i++) {\n    const { key, vnode } = keyedVnodes[i];\n    const el = oldKeyMap?.get(key);\n    if (!el || !_isDOMElement(vnode)) continue;\n    const props = vnode.props || {};\n    // If vnode declares event handlers, bail (we don't want to reattach handlers in bulk)\n    for (const k of Object.keys(props)) {\n      if (k === 'children' || k === 'key') continue;\n      if (k.startsWith('on') && k.length > 2) {\n        // Ignore event handlers for fast-path activation: the fast-path\n        // preserves existing element listeners (we do not reattach on each\n        // reorder). Treat presence of a handler as non-blocking for fast-path.\n        continue;\n      }\n      // Check `class`, `value`, `checked`, attribute differences conservatively\n      const v = (props as Record<string, unknown>)[k];\n      try {\n        if (k === 'class' || k === 'className') {\n          if (el.className !== String(v)) {\n            logger.warn('[Askr][FASTPATH][DEV] prop mismatch', {\n              key,\n              prop: k,\n              expected: String(v),\n              actual: el.className,\n            });\n            hasPropChanges = true;\n            break;\n          }\n        } else if (k === 'value' || k === 'checked') {\n          if ((el as HTMLElement & Record<string, unknown>)[k] !== v) {\n            logger.warn('[Askr][FASTPATH][DEV] prop mismatch', {\n              key,\n              prop: k,\n              expected: v,\n              actual: (el as HTMLElement & Record<string, unknown>)[k],\n            });\n            hasPropChanges = true;\n            break;\n          }\n        } else {\n          // Attribute check: presence/absence or string difference\n          const attr = el.getAttribute(k);\n          if (v === undefined || v === null || v === false) {\n            if (attr !== null) {\n              logger.warn(\n                '[Askr][FASTPATH][DEV] prop mismatch (missing attr)',\n                {\n                  key,\n                  prop: k,\n                  expected: v,\n                  actual: attr,\n                }\n              );\n              hasPropChanges = true;\n              break;\n            }\n          } else if (String(v) !== attr) {\n            logger.warn('[Askr][FASTPATH][DEV] prop mismatch (attr diff)', {\n              key,\n              prop: k,\n              expected: String(v),\n              actual: attr,\n            });\n            hasPropChanges = true;\n            break;\n          }\n        }\n      } catch {\n        // If any DOM read fails, be conservative and disable the fast path\n        hasPropChanges = true;\n        break;\n      }\n    }\n    if (hasPropChanges) break;\n  }\n\n  const decision = isKeyedReorderFastPathEligible(\n    parent,\n    newChildren,\n    oldKeyMap\n  );\n  const useFastPath = decision.useFastPath;\n\n  // Dev debug: explain why we chose (or declined) fast-path for this update\n  logger.warn('[Askr][FASTPATH][DEV] decision', decision);\n\n  // Aggressive fallback for huge keyed lists that are text-dominant.\n  // If the renderer declined the keyed fast-path but the list is extremely\n  // large and each vnode is a simple intrinsic element with a single\n  // primitive child (text), apply a positional bulk update to avoid\n  // per-node reconciliation overhead.\n  try {\n    const hugeThreshold = Number(process.env.ASKR_BULK_HUGE_THRESHOLD) || 2048;\n    if (!useFastPath && keyedVnodes.length >= hugeThreshold) {\n      let allSimple = true;\n      for (let i = 0; i < keyedVnodes.length; i++) {\n        const vnode = keyedVnodes[i].vnode;\n        if (!_isDOMElement(vnode)) {\n          allSimple = false;\n          break;\n        }\n        const dv = vnode as DOMElement;\n        if (typeof dv.type !== 'string') {\n          allSimple = false;\n          break;\n        }\n        const ch = dv.children || dv.props?.children;\n        if (ch === undefined) continue;\n        if (Array.isArray(ch)) {\n          if (\n            ch.length !== 1 ||\n            (typeof ch[0] !== 'string' && typeof ch[0] !== 'number')\n          ) {\n            allSimple = false;\n            break;\n          }\n        } else if (typeof ch !== 'string' && typeof ch !== 'number') {\n          allSimple = false;\n          break;\n        }\n      }\n\n      if (allSimple) {\n        logger.warn('[Askr][FASTPATH] applying huge-list positional fallback');\n        try {\n          if (isBulkCommitActive()) markFastPathApplied(parent);\n        } catch (e) {\n          void e;\n        }\n        const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);\n        if (\n          process.env.NODE_ENV !== 'production' ||\n          process.env.ASKR_FASTPATH_DEBUG === '1'\n        ) {\n          try {\n            const gl = globalThis as unknown as {\n              __ASKR_LAST_FASTPATH_STATS?: unknown;\n              __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n              __ASKR_BULK_DIAG?: unknown;\n            };\n            (gl.__ASKR_LAST_FASTPATH_STATS as unknown) = stats;\n            const counters =\n              (gl.__ASKR_FASTPATH_COUNTERS as Record<string, number>) || {};\n            counters.bulkKeyedHugeFallback =\n              (counters.bulkKeyedHugeFallback || 0) + 1;\n            gl.__ASKR_FASTPATH_COUNTERS = counters;\n            (gl.__ASKR_BULK_DIAG as unknown) = {\n              phase: 'bulk-keyed-huge-fallback',\n              stats,\n            };\n          } catch (e) {\n            void e;\n          }\n        }\n        return newKeyMap;\n      }\n    }\n  } catch (e) {\n    void e;\n  }\n  if (\n    process.env.NODE_ENV !== 'production' ||\n    process.env.ASKR_FASTPATH_DEBUG === '1'\n  ) {\n    try {\n      const gl = globalThis as unknown as { __ASKR_BULK_DIAG?: unknown };\n      (gl.__ASKR_BULK_DIAG as unknown) = {\n        phase: 'keyed-decision',\n        decision,\n        totalKeyed,\n        oldKeyMapSize: oldKeyMap?.size ?? 0,\n      };\n    } catch (e) {\n      void e;\n    }\n  }\n\n  // Heuristic: if many incoming keys are missing from the old key map (i.e.\n  // keys changed en-masse) and all children are simple text, prefer the\n  // positional bulk text fast-path rather than the keyed map fast-path which\n  // would allocate many new elements.\n  let allSimpleText = false;\n  try {\n    if (\n      keyedVnodes.length >=\n      (Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024)\n    ) {\n      let missing = 0;\n      try {\n        const present = new Set<string | number>();\n        const parentChildren = Array.from(parent.children);\n        for (let i = 0; i < parentChildren.length; i++) {\n          const attr = parentChildren[i].getAttribute('data-key');\n          if (attr !== null) {\n            present.add(attr);\n            const n = Number(attr);\n            if (!Number.isNaN(n)) present.add(n);\n          }\n        }\n        for (let i = 0; i < keyedVnodes.length; i++) {\n          const k = keyedVnodes[i].key;\n          if (!present.has(k)) missing++;\n        }\n      } catch {\n        // If DOM reads fail, be conservative and set missing low\n        missing = 0;\n      }\n\n      // Determine whether all keyed vnodes are \"simple text\" candidates.\n      // Moved here to ensure the predicate is available where it's needed.\n      // Declare variable in outer scope so it can be referenced later in file\n      // (some heuristics need this predicate after this try block).\n      allSimpleText =\n        keyedVnodes.length > 0 &&\n        keyedVnodes.every(({ vnode }) => {\n          if (!_isDOMElement(vnode)) return false;\n          const dv = vnode as DOMElement;\n          if (typeof dv.type !== 'string') return false;\n          const ch = dv.children || dv.props?.children;\n          if (ch === undefined) return true;\n          if (Array.isArray(ch)) {\n            return (\n              ch.length === 1 &&\n              (typeof ch[0] === 'string' || typeof ch[0] === 'number')\n            );\n          }\n          return typeof ch === 'string' || typeof ch === 'number';\n        });\n\n      // Conservative: do not apply positional bulk keyed fast-path when any\n      // child vnode declares non-data props (class, value, etc). Such props\n      // may require per-node updates and the bulk path assumes text-only\n      // changes. Compute presence of non-data props here.\n      let hasPropsPresent = false;\n      for (let i = 0; i < keyedVnodes.length; i++) {\n        const vnode = keyedVnodes[i].vnode;\n        if (!_isDOMElement(vnode)) continue;\n        const props = vnode.props || {};\n        for (const k of Object.keys(props)) {\n          if (k === 'children' || k === 'key') continue;\n          if (k.startsWith('on') && k.length > 2) continue; // ignore event handlers\n          if (k.startsWith('data-')) continue; // ignore data-* attributes\n          hasPropsPresent = true;\n          break;\n        }\n        if (hasPropsPresent) break;\n      }\n\n      const missingRatio = missing / Math.max(1, keyedVnodes.length);\n      if (missingRatio > 0.5 && allSimpleText && !hasPropsPresent) {\n        logger.warn(\n          '[Askr][FASTPATH] switching to positional bulk keyed fast-path due to missing keys ratio',\n          missingRatio\n        );\n        try {\n          if (isBulkCommitActive()) markFastPathApplied(parent);\n        } catch (e) {\n          void e;\n        }\n        const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);\n        if (process.env.NODE_ENV !== 'production') {\n          try {\n            const gl = globalThis as unknown as {\n              __ASKR_LAST_FASTPATH_STATS?: unknown;\n              __ASKR_LAST_FASTPATH_COMMIT_COUNT?: number | undefined;\n              __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n            };\n            (gl.__ASKR_LAST_FASTPATH_STATS as unknown) = stats;\n            // Mark that reconciler recorded stats for this parent during this\n            // render pass; this allows subsequent reconciliations in the same\n            // pass to preserve the diagnostic fields instead of clearing them.\n            try {\n              _reconcilerRecordedParents.add(parent);\n            } catch (e) {\n              void e;\n            }\n            // Record a logical commit for diagnostics (even though the\n            // reconciler performed in-place updates, treat it as a single\n            // fast-path commit for runtime invariant checks).\n            gl.__ASKR_LAST_FASTPATH_COMMIT_COUNT = 1;\n            const counters =\n              (gl.__ASKR_FASTPATH_COUNTERS as Record<string, number>) || {};\n            counters.bulkKeyedPositionalHits =\n              (counters.bulkKeyedPositionalHits || 0) + 1;\n            gl.__ASKR_FASTPATH_COUNTERS = counters;\n          } catch (e) {\n            void e;\n          }\n        }\n        return newKeyMap;\n      }\n    }\n  } catch (e) {\n    void e;\n  }\n\n  // Clear previous fast-path stats when we decline the fast-path to avoid\n  // leaking prior run data across updates (tests rely on this behavior).\n  // However, if a fast-path was applied synchronously for this parent in the\n  // same render pass, preserve the recorded stats (they may be set by the\n  // reconciler even when the runtime fast-lane was not taken).\n  if (!useFastPath && typeof globalThis !== 'undefined') {\n    try {\n      let parentFastpathApplied = false;\n      try {\n        parentFastpathApplied = isFastPathApplied(parent);\n      } catch {\n        parentFastpathApplied = false;\n      }\n      if (!parentFastpathApplied) {\n        const gl = globalThis as unknown as {\n          __ASKR_LAST_FASTPATH_STATS?: unknown;\n          __ASKR_LAST_FASTPATH_REUSED?: unknown;\n        };\n        // If the reconciler recorded stats for this parent in the current\n        // render pass, preserve them and remove the transient marker so that\n        // subsequent independent renders will not inherit the flag.\n        try {\n          if (_reconcilerRecordedParents.has(parent)) {\n            _reconcilerRecordedParents.delete(parent);\n          } else {\n            delete gl.__ASKR_LAST_FASTPATH_STATS;\n            delete gl.__ASKR_LAST_FASTPATH_REUSED;\n          }\n        } catch {\n          // On any failure, clear diagnostics conservatively\n          delete gl.__ASKR_LAST_FASTPATH_STATS;\n          delete gl.__ASKR_LAST_FASTPATH_REUSED;\n        }\n      }\n    } catch (e) {\n      void e;\n    }\n  }\n\n  // Heuristic: if keys changed but the new children are the same element tag\n  // and only their text content differs, reuse existing elements by **position**\n  // (positional reuse). This avoids allocating a new Element/Node per update\n  // when the structure is stable and only textual content changes.\n  // Conditions:\n  //  - oldKeyMap is missing or provides no matching keys\n  //  - parent has same number of children as keyed vnodes\n  //  - each keyed vnode is an intrinsic element (string type) whose children\n  //    are a single primitive (string/number)\n  let _triedPositionalReuse = false;\n\n  // New heuristic: bulk keyed text update fast-path\n  // If there are many keyed elements (large lists) and **no moves** (stable key order)\n  // and all keyed vnodes are simple intrinsic elements with a single primitive\n  // child (text), we can build a DocumentFragment by reusing the existing\n  // Element nodes and updating their text content in-memory, then perform a\n  // single atomic `replaceChildren` to avoid per-node reconciliation overhead.\n  // This preserves element identity and listeners while dramatically reducing\n  // JS overhead for pure text churn.\n  try {\n    const bulkTextThreshold =\n      Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024; // `allSimpleText` computed earlier near missing-ratio check\n\n    if (\n      !useFastPath &&\n      keyedVnodes.length >= bulkTextThreshold &&\n      allSimpleText &&\n      !hasPropChanges\n    ) {\n      // If bulk fast-path was already applied synchronously on this parent in\n      // this commit, avoid reapplying another structural fast-path which could\n      // replace nodes again and inadvertently remove listeners. This marker\n      // is cleared on the next tick.\n      try {\n        // Avoid reapplying a fast-path on the same parent during the same bulk\n        // commit. Use runtime registry rather than DOM attributes to avoid\n        // introducing async cleanup and to keep this logic synchronous.\n        if (isFastPathApplied(parent)) {\n          logger.warn(\n            '[Askr][FASTPATH] fast-path already applied on parent; skipping'\n          );\n          return newKeyMap;\n        }\n      } catch (e) {\n        void e;\n      }\n      // Two bulk behaviors:\n      // 1) Stable keys & order: reuse elements from oldKeyMap by key and do an\n      //    atomic replaceChildren after updating text content (preserves identity).\n      // 2) Keys changed en-masse but structure is stable: positional reuse - reuse\n      //    elements by position, update their text, and remap data-key attributes.\n      let stable = true;\n      try {\n        const parentChildren = Array.from(parent.children);\n\n        // If the parent and new children have identical length and all\n        // keyed vnodes are simple text elements, we can apply the positional\n        // bulk update. Allow a forced env var to bypass conservative checks\n        // for benching/debugging scenarios where we know structure is stable.\n        if (parentChildren.length === keyedVnodes.length) {\n          const allSimple = keyedVnodes.every(({ vnode }) => {\n            if (!_isDOMElement(vnode)) return false;\n            const dv = vnode as DOMElement;\n            if (typeof dv.type !== 'string') return false;\n            const ch = dv.children || dv.props?.children;\n            if (ch === undefined) return true;\n            if (Array.isArray(ch)) {\n              return (\n                ch.length === 1 &&\n                (typeof ch[0] === 'string' || typeof ch[0] === 'number')\n              );\n            }\n            return typeof ch === 'string' || typeof ch === 'number';\n          });\n\n          if (allSimple || process.env.ASKR_FORCE_BULK_POSREUSE === '1') {\n            logger.warn(\n              '[Askr][FASTPATH] len-match heuristic triggered (positional bulk)'\n            );\n            if (\n              process.env.NODE_ENV !== 'production' ||\n              process.env.ASKR_FASTPATH_DEBUG === '1'\n            ) {\n              try {\n                const gl = globalThis as unknown as {\n                  __ASKR_BULK_DIAG?: unknown;\n                };\n                (gl.__ASKR_BULK_DIAG as unknown) = {\n                  phase: 'bulk-keyed-positional-trigger-lenmatch-early',\n                  totalKeyed: keyedVnodes.length,\n                  allSimple,\n                  forced: process.env.ASKR_FORCE_BULK_POSREUSE === '1',\n                };\n              } catch (e) {\n                void e;\n              }\n            }\n            try {\n              if (isBulkCommitActive()) markFastPathApplied(parent);\n            } catch (e) {\n              void e;\n            }\n\n            const stats = performBulkPositionalKeyedTextUpdate(\n              parent,\n              keyedVnodes\n            );\n            if (\n              process.env.NODE_ENV !== 'production' ||\n              process.env.ASKR_FASTPATH_DEBUG === '1'\n            ) {\n              try {\n                const gl = globalThis as unknown as {\n                  __ASKR_LAST_FASTPATH_STATS?: unknown;\n                  __ASKR_BULK_DIAG?: unknown;\n                  __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n                };\n                (gl.__ASKR_LAST_FASTPATH_STATS as unknown) = stats;\n                (gl.__ASKR_BULK_DIAG as unknown) = {\n                  phase: 'bulk-keyed-positional-applied',\n                  stats,\n                };\n                const counters =\n                  (gl.__ASKR_FASTPATH_COUNTERS as Record<string, number>) || {};\n                counters.bulkKeyedPositionalHits =\n                  (counters.bulkKeyedPositionalHits || 0) + 1;\n                if (process.env.ASKR_FORCE_BULK_POSREUSE === '1')\n                  counters.bulkKeyedPositionalForced =\n                    (counters.bulkKeyedPositionalForced || 0) + 1;\n                gl.__ASKR_FASTPATH_COUNTERS = counters;\n              } catch (e) {\n                void e;\n              }\n            }\n            return newKeyMap;\n          }\n        }\n\n        if (parentChildren.length !== keyedVnodes.length) stable = false;\n        else {\n          // Check if keys match positions (stable-key case) and collect mismatch count\n          let keyMismatches = 0;\n          for (let i = 0; i < keyedVnodes.length; i++) {\n            const k = keyedVnodes[i].key;\n            const ch = parentChildren[i] as Element | undefined;\n            if (!ch) {\n              stable = false;\n              break;\n            }\n            const attr = ch.getAttribute('data-key');\n            if (attr === null) {\n              stable = false;\n              break;\n            }\n            if (String(k) !== attr && String(Number(attr)) !== String(k)) {\n              keyMismatches++;\n            }\n          }\n\n          if (stable) {\n            if (keyMismatches === 0) {\n              // Perfectly aligned - treat as stable keyed fast-path\n              logger.warn(\n                '[Askr][FASTPATH] applying bulk keyed text fast-path (stable keys)'\n              );\n              if (\n                process.env.NODE_ENV !== 'production' ||\n                process.env.ASKR_FASTPATH_DEBUG === '1'\n              ) {\n                try {\n                  const gl = globalThis as unknown as {\n                    __ASKR_BULK_DIAG?: unknown;\n                  };\n                  (gl.__ASKR_BULK_DIAG as unknown) = {\n                    phase: 'bulk-keyed-stable-trigger',\n                    totalKeyed: keyedVnodes.length,\n                    hasPropChanges,\n                  };\n                } catch (e) {\n                  void e;\n                }\n              }\n              try {\n                if (isBulkCommitActive()) markFastPathApplied(parent);\n              } catch (e) {\n                void e;\n              }\n\n              const stats = performBulkKeyedTextReplace(\n                parent,\n                keyedVnodes,\n                oldKeyMap\n              );\n              if (\n                process.env.NODE_ENV !== 'production' ||\n                process.env.ASKR_FASTPATH_DEBUG === '1'\n              ) {\n                try {\n                  const gl = globalThis as unknown as {\n                    __ASKR_LAST_FASTPATH_STATS?: unknown;\n                    __ASKR_BULK_DIAG?: unknown;\n                    __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n                  };\n                  (gl.__ASKR_LAST_FASTPATH_STATS as unknown) = stats;\n                  (gl.__ASKR_BULK_DIAG as unknown) = {\n                    phase: 'bulk-keyed-applied',\n                    stats,\n                  };\n                  const counters =\n                    (gl.__ASKR_FASTPATH_COUNTERS as Record<string, number>) ||\n                    {};\n                  counters.bulkKeyedTextHits =\n                    (counters.bulkKeyedTextHits || 0) + 1;\n                  gl.__ASKR_FASTPATH_COUNTERS = counters;\n                } catch (e) {\n                  void e;\n                }\n              }\n              return newKeyMap;\n            }\n\n            // If the parent shape (number of children) matches, prefer a\n            // positional bulk update for large lists of simple text. This is a\n            // conservative but practical heuristic: for very large lists the\n            // per-node insert/move/update overhead dominates and a single\n            // DocumentFragment-based positional update is much cheaper while\n            // preserving identity and listeners.\n            if (parentChildren.length === keyedVnodes.length) {\n              logger.warn(\n                '[Askr][FASTPATH] applying bulk keyed positional text fast-path (len-match)'\n              );\n              if (\n                process.env.NODE_ENV !== 'production' ||\n                process.env.ASKR_FASTPATH_DEBUG === '1'\n              ) {\n                try {\n                  const gl = globalThis as unknown as {\n                    __ASKR_BULK_DIAG?: unknown;\n                  };\n                  (gl.__ASKR_BULK_DIAG as unknown) = {\n                    phase: 'bulk-keyed-positional-trigger-lenmatch',\n                    totalKeyed: keyedVnodes.length,\n                    keyMismatches: keyMismatches,\n                  };\n                } catch (e) {\n                  void e;\n                }\n              }\n              try {\n                if (isBulkCommitActive()) markFastPathApplied(parent);\n              } catch (e) {\n                void e;\n              }\n\n              const stats = performBulkPositionalKeyedTextUpdate(\n                parent,\n                keyedVnodes\n              );\n              if (\n                process.env.NODE_ENV !== 'production' ||\n                process.env.ASKR_FASTPATH_DEBUG === '1'\n              ) {\n                try {\n                  const gl = globalThis as unknown as {\n                    __ASKR_LAST_FASTPATH_STATS?: unknown;\n                    __ASKR_BULK_DIAG?: unknown;\n                    __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n                  };\n                  gl.__ASKR_LAST_FASTPATH_STATS = stats;\n                  gl.__ASKR_BULK_DIAG = {\n                    phase: 'bulk-keyed-positional-applied',\n                    stats,\n                  };\n                  const counters =\n                    (gl.__ASKR_FASTPATH_COUNTERS as Record<string, number>) ||\n                    {};\n                  counters.bulkKeyedPositionalHits =\n                    (counters.bulkKeyedPositionalHits || 0) + 1;\n                  gl.__ASKR_FASTPATH_COUNTERS = counters;\n                } catch (e) {\n                  void e;\n                }\n              }\n              return newKeyMap;\n            }\n\n            // If many mismatches but structural shape is identical and all children\n            // are simple text, attempt positional bulk keyed replace to avoid\n            // alloc/move churn. This reuses elements by position, updates text,\n            // and remaps the `data-key` attribute to the new key.\n            const mismatchRatio = keyMismatches / keyedVnodes.length;\n            const POSITIONAL_THRESHOLD = 0.5; // if >50% mismatched, use positional path\n            if (mismatchRatio > POSITIONAL_THRESHOLD) {\n              logger.warn(\n                '[Askr][FASTPATH] applying bulk keyed positional text fast-path'\n              );\n              if (\n                process.env.NODE_ENV !== 'production' ||\n                process.env.ASKR_FASTPATH_DEBUG === '1'\n              ) {\n                try {\n                  (\n                    globalThis as unknown as { __ASKR_BULK_DIAG?: unknown }\n                  ).__ASKR_BULK_DIAG = {\n                    phase: 'bulk-keyed-positional-trigger',\n                    totalKeyed: keyedVnodes.length,\n                    keyMismatches: keyMismatches,\n                  };\n                } catch (e) {\n                  void e;\n                }\n              }\n              try {\n                if (isBulkCommitActive()) markFastPathApplied(parent);\n              } catch (e) {\n                void e;\n              }\n\n              const stats = performBulkPositionalKeyedTextUpdate(\n                parent,\n                keyedVnodes\n              );\n              if (\n                process.env.NODE_ENV !== 'production' ||\n                process.env.ASKR_FASTPATH_DEBUG === '1'\n              ) {\n                try {\n                  const gl = globalThis as unknown as {\n                    __ASKR_LAST_FASTPATH_STATS?: unknown;\n                    __ASKR_BULK_DIAG?: unknown;\n                    __ASKR_FASTPATH_COUNTERS?: Record<string, number>;\n                  };\n                  gl.__ASKR_LAST_FASTPATH_STATS = stats;\n                  gl.__ASKR_BULK_DIAG = {\n                    phase: 'bulk-keyed-positional-applied',\n                    stats,\n                  };\n                  const counters =\n                    (gl.__ASKR_FASTPATH_COUNTERS as Record<string, number>) ||\n                    {};\n                  counters.bulkKeyedPositionalHits =\n                    (counters.bulkKeyedPositionalHits || 0) + 1;\n                  gl.__ASKR_FASTPATH_COUNTERS = counters;\n                } catch (e) {\n                  void e;\n                }\n              }\n              return newKeyMap;\n            }\n          }\n        }\n      } catch {\n        stable = false;\n      }\n    }\n  } catch (e) {\n    void e;\n  }\n  if (!useFastPath) {\n    const totalKeyed = keyedVnodes.length;\n    // Aggressive positional reuse heuristic for small lists where all\n    // keyed vnodes are simple intrinsic elements with a single primitive\n    // child (text or number). This handles cases where keys change each\n    // update but structure is stable (common in bulk text updates).\n    // Evaluate candidates from the raw newChildren array (handles both keyed and unkeyed)\n    const candidates = newChildren.filter(\n      (c) => _isDOMElement(c) && typeof (c as DOMElement).type === 'string'\n    ) as DOMElement[];\n    const smallListPositionalReuseEligible =\n      candidates.length > 0 &&\n      candidates.length <= 64 &&\n      parent.children.length === candidates.length &&\n      candidates.every((vnode) => {\n        const children =\n          (vnode as DOMElement).children ||\n          (vnode as DOMElement).props?.children;\n        if (Array.isArray(children)) {\n          return (\n            children.length === 1 &&\n            (typeof children[0] === 'string' || typeof children[0] === 'number')\n          );\n        }\n        return (\n          children === undefined ||\n          typeof children === 'string' ||\n          typeof children === 'number'\n        );\n      });\n\n    try {\n      if (smallListPositionalReuseEligible) {\n        let eligible = true;\n        for (let i = 0; i < totalKeyed; i++) {\n          const vnode = keyedVnodes[i].vnode;\n          if (\n            !_isDOMElement(vnode) ||\n            typeof (vnode as DOMElement).type !== 'string'\n          ) {\n            eligible = false;\n            break;\n          }\n          const children =\n            (vnode as DOMElement).children ||\n            (vnode as DOMElement).props?.children;\n          // Accept a single string/number child or no children\n          if (Array.isArray(children)) {\n            if (children.length !== 1) {\n              eligible = false;\n              break;\n            }\n            const c = children[0];\n            if (typeof c !== 'string' && typeof c !== 'number') {\n              eligible = false;\n              break;\n            }\n          } else if (\n            children !== undefined &&\n            typeof children !== 'string' &&\n            typeof children !== 'number'\n          ) {\n            eligible = false;\n            break;\n          }\n        }\n\n        // Safety guard: do not apply positional reuse when existing DOM keys match\n        // incoming vnode keys. That indicates this is a keyed list reorder, and\n        // identity must be preserved by key rather than by position.\n        const anyKeyMatches =\n          !!oldKeyMap && keyedVnodes.some((kv) => oldKeyMap!.has(kv.key));\n        if (anyKeyMatches) {\n          eligible = false;\n        }\n\n        if (eligible || process.env.ASKR_FORCE_POSREUSE === '1') {\n          _triedPositionalReuse = true;\n          if (process.env.ASKR_FORCE_POSREUSE === '1') {\n            logger.warn(\n              '[Askr][POSREUSE][FORCED] forcing positional reuse path for testing'\n            );\n          } else {\n            logger.warn('[Askr][POSREUSE] positional reuse heuristic applied');\n          }\n\n          // Perform positional update in-place\n          const existingChildren = parent.children;\n          for (let i = 0; i < totalKeyed; i++) {\n            const { key, vnode } = keyedVnodes[i];\n            const current = existingChildren[i] as Element | undefined;\n            if (current && _isDOMElement(vnode)) {\n              const vnodeType = (vnode as DOMElement).type as string;\n              if (current.tagName.toLowerCase() === vnodeType.toLowerCase()) {\n                // Update attributes and children in-place\n                updateElementFromVnode(current, vnode as VNode);\n                newKeyMap.set(key, current);\n                continue;\n              }\n            }\n            // Fall back: create a new node and replace\n            const newEl = createDOMNode(vnode);\n            if (newEl instanceof Element) {\n              if (current) {\n                // Clean up any component instance that owned the existing node\n                cleanupInstanceIfPresent(current);\n                parent.replaceChild(newEl, current);\n              } else parent.appendChild(newEl);\n              newKeyMap.set(key, newEl);\n            }\n          }\n          // Add unkeyed nodes (should be none in this heuristic)\n          for (const vnode of unkeyedVnodes) {\n            const newEl = createDOMNode(vnode);\n            if (newEl) parent.appendChild(newEl as Node);\n          }\n          // Positional reuse done; return new key map\n          return newKeyMap;\n        }\n      }\n    } catch {\n      // If any DOM read/write here fails, fall back to normal code path below\n    }\n  }\n\n  if (useFastPath) {\n    // Dev invariant: ensure we are executing inside the scheduler/commit flush\n    if (!isSchedulerExecuting()) {\n      logger.warn(\n        '[Askr][FASTPATH][DEV] Fast-path reconciliation invoked outside scheduler execution'\n      );\n    }\n\n    // Build either a small linear scan cache or a map depending on size.\n    // For small keyed lists (<= 20) we prefer linear scans to avoid Map\n    // allocations and HashTable churn — O(N^2) is acceptable for small N.\n    let parentChildrenArr: Element[] | undefined;\n    let localOldKeyMap: Map<string | number, Element> | undefined;\n\n    if (totalKeyed <= 20) {\n      try {\n        const pc = parent.children;\n        parentChildrenArr = new Array(pc.length);\n        for (let i = 0; i < pc.length; i++)\n          parentChildrenArr[i] = pc[i] as Element;\n      } catch {\n        parentChildrenArr = undefined;\n      }\n    } else {\n      localOldKeyMap = new Map<string | number, Element>();\n      try {\n        const parentChildren = Array.from(parent.children);\n        for (let i = 0; i < parentChildren.length; i++) {\n          const ch = parentChildren[i] as Element;\n          const k = ch.getAttribute('data-key');\n          if (k !== null) {\n            localOldKeyMap.set(k, ch);\n            // also store numeric form for numeric keys\n            const n = Number(k);\n            if (!Number.isNaN(n)) localOldKeyMap.set(n, ch);\n          }\n        }\n      } catch {\n        // ignore DOM read failures; we'll fall back to creation\n        localOldKeyMap = undefined;\n      }\n    }\n\n    logger.warn(\n      '[Askr][FASTPATH] oldKeyMap size:',\n      oldKeyMap?.size ?? 0,\n      'localOldKeyMap size:',\n      localOldKeyMap?.size\n    );\n\n    // Build the final node array WITHOUT touching the DOM. For existing\n    // elements we reuse the `oldKeyMap` or `localOldKeyMap` references; for\n    // new vnodes we create detached nodes via `createDOMNode`.\n    const tLookupStart =\n      typeof performance !== 'undefined' && performance.now\n        ? performance.now()\n        : Date.now();\n    const finalNodes: Node[] = [];\n    let mapLookups = 0;\n    let createdNodes = 0;\n    let reusedCount = 0;\n\n    for (let i = 0; i < keyedVnodes.length; i++) {\n      const { key, vnode } = keyedVnodes[i];\n      mapLookups++;\n\n      let el: Element | undefined;\n      if (totalKeyed <= 20 && parentChildrenArr) {\n        // Linear scan lookup for small lists (avoid Map allocation)\n        const ks = String(key);\n        for (let j = 0; j < parentChildrenArr.length; j++) {\n          const ch = parentChildrenArr[j];\n          const k = ch.getAttribute('data-key');\n          if (k !== null && (k === ks || Number(k) === (key as number))) {\n            el = ch;\n            break;\n          }\n        }\n        // Fallback to cached map if present\n        if (!el) el = oldKeyMap?.get(key);\n      } else {\n        el = localOldKeyMap?.get(key as string | number) ?? oldKeyMap?.get(key);\n      }\n\n      if (el) {\n        finalNodes.push(el);\n        reusedCount++;\n      } else {\n        const newEl = createDOMNode(vnode);\n        if (newEl) {\n          finalNodes.push(newEl);\n          createdNodes++;\n        }\n      }\n    }\n\n    // Add unkeyed nodes (detached as well)\n    for (const vnode of unkeyedVnodes) {\n      const newEl = createDOMNode(vnode);\n      if (newEl) {\n        finalNodes.push(newEl);\n        createdNodes++;\n      }\n    }\n    const t_lookup =\n      typeof performance !== 'undefined' && performance.now\n        ? performance.now() - tLookupStart\n        : 0;\n\n    // Dev-only guard disabled for minimal fast-path to avoid prototype\n    // monkey-patching during the tight commit. The fast-path now performs a\n    // single DocumentFragment-based commit and is validated via micro-bench\n    // instrumentation instead of dynamic API wrapping.\n    if (process.env.ASKR_FASTPATH_GUARD === '1') {\n      const replaceChildrenCount = 0;\n      const otherMutationCount = 0;\n\n      const orig: Record<string, unknown> = {};\n      // Only wrap methods that exist in the current environment\n      const elProto = Element.prototype as unknown as Record<string, unknown>;\n      const nodeProto = Node.prototype as unknown as Record<string, unknown>;\n      // Detect existence of `remove()` on nodes without referencing the\n      // `ChildNode` type (which is a TS-only interface in some lib targets).\n      const removeFn = (() => {\n        if (\n          typeof document === 'undefined' ||\n          typeof document.createElement !== 'function'\n        )\n          return undefined;\n        try {\n          const el = document.createElement('div') as unknown as {\n            remove?: () => void;\n          };\n          return typeof el.remove === 'function' ? el.remove : undefined;\n        } catch {\n          return undefined;\n        }\n      })();\n\n      if (elProto.replaceChildren)\n        orig.replaceChildren = elProto.replaceChildren;\n      if (nodeProto.appendChild) orig.appendChild = nodeProto.appendChild;\n      if (nodeProto.insertBefore) orig.insertBefore = nodeProto.insertBefore;\n      if (nodeProto.removeChild) orig.removeChild = nodeProto.removeChild;\n      if (nodeProto.replaceChild) orig.replaceChild = nodeProto.replaceChild;\n      if (removeFn) orig.remove = removeFn;\n\n      let violation = false;\n      try {\n        const fragment = document.createDocumentFragment();\n        for (let i = 0; i < finalNodes.length; i++)\n          fragment.appendChild(finalNodes[i]);\n        // Count commits explicitly in code (no prototype monkey-patching)\n        let commitCount = 0;\n        commitCount++;\n        parent.replaceChildren(fragment);\n        // Export commit count for dev diagnostics\n        if (typeof globalThis !== 'undefined') {\n          (globalThis as unknown as Record<string, unknown>)[\n            '__ASKR_LAST_FASTPATH_COMMIT_COUNT'\n          ] = commitCount;\n        }\n      } finally {\n        // Restore parent's original\n\n        // Restore originals (only those we replaced)\n\n        // Assert invariants: no other structural mutation APIs were called\n        // during the fast-path. We accept >=1 replaceChildren calls because\n        // tests may install instance-level spies that wrap the call once.\n        violation =\n          (otherMutationCount as number) !== 0 ||\n          (replaceChildrenCount as number) < 1;\n      }\n      if (violation) {\n        logger.error(\n          '[Askr][DEV] Fast-path structural mutation invariant violated:',\n          {\n            replaceChildrenCount,\n            otherMutationCount,\n          }\n        );\n        // Fail hard in dev so regressions are caught early\n        throw new Error(\n          'Fast-path must perform a single structural replacement (replaceChildren) and no other structural mutations'\n        );\n      }\n    } else {\n      // Production: single atomic commit (measure phases if tracing)\n\n      const tFragmentStart = Date.now();\n      const fragment = document.createDocumentFragment();\n      let fragmentAppendCount = 0;\n      for (let i = 0; i < finalNodes.length; i++) {\n        fragment.appendChild(finalNodes[i]);\n        fragmentAppendCount++;\n      }\n      const t_fragment = Date.now() - tFragmentStart;\n\n      // Dev: capture scheduler state so we can assert no tasks were enqueued\n      // during the fast-path commit. This ensures we didn't accidentally\n      // invoke per-node scheduling work.\n      const schedBefore =\n        process.env.NODE_ENV !== 'production'\n          ? globalScheduler.getState()\n          : null;\n      const wasExecuting =\n        process.env.NODE_ENV !== 'production' ? isSchedulerExecuting() : false;\n\n      const tCommitStart = Date.now();\n      if (process.env.NODE_ENV !== 'production') {\n        // Extra debug to help tests detect the structural change and to aid\n        // diagnosing spy/observer mismatches in test harnesses.\n      }\n      // Count commits explicitly in code (no prototype monkey-patching)\n      let commitCount = 0;\n      commitCount++;\n      // Clean up any mounted component instances that will be removed by\n      // the atomic replaceChildren commit to avoid leaking subscriptions.\n      try {\n        const existing = Array.from(parent.childNodes);\n        for (const n of existing) cleanupInstanceIfPresent(n);\n      } catch (e) {\n        void e;\n      }\n      // Clean up any mounted component instances that will be removed by\n      // the atomic replaceChildren commit to avoid leaking subscriptions.\n      try {\n        const existing = Array.from(parent.childNodes);\n        for (const n of existing) cleanupInstanceIfPresent(n);\n      } catch (e) {\n        void e;\n      }\n      parent.replaceChildren(fragment);\n      // Export commit count for dev diagnostics\n      if (typeof globalThis !== 'undefined') {\n        (globalThis as unknown as Record<string, unknown>)[\n          '__ASKR_LAST_FASTPATH_COMMIT_COUNT'\n        ] = commitCount;\n      }\n      const t_commit = Date.now() - tCommitStart;\n\n      // Dev assertions: validate scheduler state and final DOM structure\n      if (process.env.NODE_ENV !== 'production') {\n        const schedAfter = globalScheduler.getState();\n        if (!wasExecuting) {\n          logger.warn(\n            '[Askr][FASTPATH][DEV] Fast-path commit invoked outside scheduler execution'\n          );\n        }\n        if (schedBefore && schedAfter) {\n          if (schedBefore.taskCount !== schedAfter.taskCount) {\n            logger.error(\n              '[Askr][FASTPATH][DEV] Scheduler tasks were enqueued during fast-path commit',\n              {\n                before: schedBefore,\n                after: schedAfter,\n              }\n            );\n            throw new Error('Fast-path must not enqueue scheduler tasks');\n          }\n        }\n\n        // Assert that the parent's children exactly match the final nodes\n        // (single atomic replacement). If this fails, the fast-path violated\n        // the single-commit invariant.\n        const parentNodes = Array.from(parent.childNodes);\n        if (parentNodes.length !== finalNodes.length) {\n          logger.error('[Askr][FASTPATH][DEV] Parent child count mismatch', {\n            parentCount: parentNodes.length,\n            expected: finalNodes.length,\n          });\n          throw new Error(\n            'Fast-path must perform a single structural replacement'\n          );\n        }\n        for (let i = 0; i < finalNodes.length; i++) {\n          if (parentNodes[i] !== finalNodes[i]) {\n            logger.error(\n              '[Askr][FASTPATH][DEV] Final DOM order mismatch at index',\n              i,\n              {\n                expected: finalNodes[i],\n                found: parentNodes[i],\n              }\n            );\n            throw new Error(\n              'Fast-path final DOM order does not match expected nodes'\n            );\n          }\n        }\n      }\n\n      // Phase: minimal bookkeeping - populate newKeyMap\n      const tBookkeepingStart = Date.now();\n      for (let i = 0; i < keyedVnodes.length; i++) {\n        const key = keyedVnodes[i].key;\n        const node = finalNodes[i];\n        if (node instanceof Element) newKeyMap.set(key, node as Element);\n      }\n      const t_bookkeeping = Date.now() - tBookkeepingStart;\n\n      // Emit tracing stats in dev if requested\n      if (\n        process.env.ASKR_FASTPATH_TRACE === '1' ||\n        process.env.NODE_ENV !== 'production'\n      ) {\n        const stats = {\n          n: totalKeyed,\n          moves: moveCount,\n          lisLen: 0,\n          t_lookup,\n          t_fragment,\n          t_commit,\n          t_bookkeeping,\n          fragmentAppendCount,\n          mapLookups,\n          createdNodes,\n          reusedCount,\n        } as const;\n        if (typeof globalThis !== 'undefined') {\n          const _g = globalThis as unknown as Record<string, unknown>;\n          _g['__ASKR_LAST_FASTPATH_STATS'] = stats;\n          _g['__ASKR_LAST_FASTPATH_REUSED'] = reusedCount > 0;\n          // Maintain a simple history for tooling/tests so we can assert\n          // that fast-path was used at least once during a series of updates\n          // even if subsequent non-fast-path updates clear the most recent\n          // diagnostic fields. Use a typed temporary for the history array to\n          // avoid explicit `any` in typings.\n          const historyKey = '__ASKR_LAST_FASTPATH_HISTORY';\n          let hist = _g[historyKey] as unknown[] | undefined;\n          if (!hist) {\n            hist = [];\n            _g[historyKey] = hist;\n          }\n          hist.push(stats as unknown);\n        }\n        logger.warn('[Askr][FASTPATH]', JSON.stringify(stats));\n      }\n    }\n\n    return newKeyMap;\n  }\n\n  // Fallback: Rebuild with minimal moves: insert before `anchor` as we go\n  // Compute indices of existing keyed elements in parent's current order\n  const parentChildren = Array.from(parent.children);\n  const positions: number[] = new Array(keyedVnodes.length).fill(-1);\n  for (let i = 0; i < keyedVnodes.length; i++) {\n    const key = keyedVnodes[i].key;\n    const el = oldKeyMap?.get(key);\n    if (el && el.parentElement === parent) {\n      positions[i] = parentChildren.indexOf(el);\n    }\n  }\n\n  // Compute Longest Increasing Subsequence (LIS) of positions to\n  // determine which existing elements are already in correct order\n  // and can be left in place (minimizes moves).\n  const tailsStart =\n    typeof performance !== 'undefined' && performance.now\n      ? performance.now()\n      : Date.now();\n  const keepSet = new Set<number>();\n  const tails: number[] = [];\n  const tailsIdx: number[] = [];\n  const prev: number[] = new Array(positions.length).fill(-1);\n\n  for (let i = 0; i < positions.length; i++) {\n    const pos = positions[i];\n    if (pos === -1) continue;\n    // binary search for insertion point\n    let lo = 0;\n    let hi = tails.length;\n    while (lo < hi) {\n      const mid = (lo + hi) >> 1;\n      if (tails[mid] < pos) lo = mid + 1;\n      else hi = mid;\n    }\n    if (lo === tails.length) {\n      tails.push(pos);\n      tailsIdx.push(i);\n    } else {\n      tails[lo] = pos;\n      tailsIdx[lo] = i;\n    }\n    prev[i] = lo > 0 ? tailsIdx[lo - 1] : -1;\n  }\n\n  // Reconstruct LIS indices into keepSet\n  let k = tailsIdx.length ? tailsIdx[tailsIdx.length - 1] : -1;\n  while (k !== -1) {\n    keepSet.add(k);\n    k = prev[k];\n  }\n  const tLIS =\n    (typeof performance !== 'undefined' && performance.now\n      ? performance.now()\n      : Date.now()) - tailsStart;\n\n  if (\n    process.env.NODE_ENV !== 'production' ||\n    process.env.ASKR_FASTPATH_DEBUG === '1'\n  ) {\n    try {\n      const prev = (\n        globalThis as unknown as { __ASKR_BULK_DIAG?: { decision?: unknown } }\n      ).__ASKR_BULK_DIAG;\n      (\n        globalThis as unknown as { __ASKR_BULK_DIAG?: unknown }\n      ).__ASKR_BULK_DIAG = {\n        phase: 'keyed-fallback-lis',\n        positionsFound: positions.filter((p) => p !== -1).length,\n        keepCount: keepSet.size,\n        tLIS,\n        previousDecision: prev?.decision,\n      };\n    } catch (e) {\n      void e;\n    }\n  }\n\n  let anchor: Node | null = parent.firstChild;\n\n  for (let i = 0; i < keyedVnodes.length; i++) {\n    const { key, vnode } = keyedVnodes[i];\n    const el = oldKeyMap?.get(key);\n\n    if (el && el.parentElement === parent) {\n      if (keepSet.has(i)) {\n        // This element can stay; ensure anchor advances past it\n        if (anchor === el) {\n          anchor = el.nextSibling;\n        }\n        updateElementFromVnode(el, vnode);\n        newKeyMap.set(key, el);\n      } else {\n        // Move existing element into place before anchor\n        parent.insertBefore(el, anchor);\n        updateElementFromVnode(el, vnode);\n        newKeyMap.set(key, el);\n        anchor = el.nextSibling;\n      }\n    } else {\n      // New element - insert before anchor\n      const newEl = createDOMNode(vnode);\n      if (newEl instanceof Element) {\n        parent.insertBefore(newEl, anchor);\n        newKeyMap.set(key, newEl);\n        anchor = newEl.nextSibling;\n      }\n    }\n  }\n\n  // Add unkeyed children at the end\n  for (const vnode of unkeyedVnodes) {\n    const newEl = createDOMNode(vnode);\n    if (newEl) {\n      parent.appendChild(newEl);\n    }\n  }\n\n  return newKeyMap;\n}\n\n/**\n * Variant of bulk replace specialized for keyed lists where elements are\n * intrinsic elements whose only child is a primitive (text/number).\n * Reuses existing Element nodes (preserves identity/listeners) and updates\n * their text content before assembling a DocumentFragment and doing a\n * single atomic replacement.\n */\nfunction performBulkKeyedTextReplace(\n  parent: Element,\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>,\n  oldKeyMap?: Map<string | number, Element>\n) {\n  const total = keyedVnodes.length;\n  const finalNodes: Node[] = [];\n  let reused = 0;\n  let created = 0;\n  const t0 =\n    typeof performance !== 'undefined' && performance.now\n      ? performance.now()\n      : Date.now();\n\n  for (let i = 0; i < total; i++) {\n    const { key, vnode } = keyedVnodes[i];\n    const el = oldKeyMap?.get(key);\n    if (\n      el &&\n      _isDOMElement(vnode) &&\n      typeof (vnode as DOMElement).type === 'string'\n    ) {\n      const children =\n        (vnode as DOMElement).children || (vnode as DOMElement).props?.children;\n      // Update text content in-place when possible\n      if (typeof children === 'string' || typeof children === 'number') {\n        if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {\n          (el.firstChild as Text).data = String(children);\n        } else {\n          el.textContent = String(children);\n        }\n      } else if (\n        Array.isArray(children) &&\n        children.length === 1 &&\n        (typeof children[0] === 'string' || typeof children[0] === 'number')\n      ) {\n        if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {\n          (el.firstChild as Text).data = String(children[0]);\n        } else {\n          el.textContent = String(children[0]);\n        }\n      } else {\n        // Fallback to normal element update\n        updateElementFromVnode(el, vnode as VNode);\n      }\n      finalNodes.push(el);\n      reused++;\n    } else {\n      const dom = createDOMNode(vnode);\n      if (dom) {\n        finalNodes.push(dom);\n        created++;\n      }\n    }\n  }\n\n  // Remove instances that won't be in final set\n  try {\n    const toRemove = Array.from(parent.childNodes).filter(\n      (n) => !finalNodes.includes(n)\n    );\n    for (const n of toRemove) cleanupInstanceIfPresent(n);\n  } catch (e) {\n    void e;\n  }\n\n  // Prepare to transfer listeners for positions where nodes are replaced\n  const existingChildren = Array.from(parent.children);\n  const listenerSnapshots: Array<Map<string, ListenerMapEntry> | undefined> =\n    new Array(existingChildren.length).fill(undefined);\n  try {\n    for (let i = 0; i < existingChildren.length; i++) {\n      const ch = existingChildren[i] as Element | undefined;\n      if (ch) {\n        const map = elementListeners.get(ch);\n        if (map && map.size > 0) {\n          // Clone the map entries to avoid mutation during transfer\n          const clone = new Map<string, ListenerMapEntry>();\n          for (const [k, v] of map) clone.set(k, v);\n          listenerSnapshots[i] = clone;\n        }\n      }\n    }\n  } catch (e) {\n    void e;\n  }\n\n  // Atomic replace using fragment\n  const fragment = document.createDocumentFragment();\n  for (let i = 0; i < finalNodes.length; i++)\n    fragment.appendChild(finalNodes[i]);\n  parent.replaceChildren(fragment);\n\n  // Transfer listeners where nodes were replaced (preserve user handlers)\n  try {\n    for (let i = 0; i < finalNodes.length; i++) {\n      const newNode = finalNodes[i];\n      const snapshot = listenerSnapshots[i];\n      if (snapshot && newNode instanceof Element) {\n        // Reattach handlers to newNode\n        for (const [eventName, entry] of snapshot) {\n          // If newNode already has a listener with the same original, skip\n          const existing = elementListeners.get(newNode)?.get(eventName);\n          if (existing && existing.original === entry.original) continue;\n          newNode.addEventListener(eventName, entry.handler);\n          if (!elementListeners.has(newNode))\n            elementListeners.set(newNode, new Map());\n          elementListeners.get(newNode)!.set(eventName, entry);\n        }\n      }\n    }\n  } catch (e) {\n    void e;\n  }\n\n  // Rebuild keyed map\n  try {\n    keyedElements.delete(parent);\n  } catch (e) {\n    void e;\n  }\n\n  const t =\n    typeof performance !== 'undefined' && performance.now\n      ? performance.now() - t0\n      : 0;\n  const stats = {\n    n: total,\n    reused,\n    created,\n    t,\n  } as const;\n  return stats;\n}\n\n/**\n * Positional update for keyed lists where keys changed en-masse but structure\n * (element tags and simple text children) remains identical. This updates\n * text content in-place and remaps the `data-key` attribute to the new key so\n * subsequent updates can find elements by their data-key.\n */\nfunction performBulkPositionalKeyedTextUpdate(\n  parent: Element,\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>\n) {\n  const total = keyedVnodes.length;\n  let reused = 0;\n  let updatedKeys = 0;\n  const t0 =\n    typeof performance !== 'undefined' && performance.now\n      ? performance.now()\n      : Date.now();\n\n  for (let i = 0; i < total; i++) {\n    const { key, vnode } = keyedVnodes[i];\n    const ch = parent.children[i] as Element | undefined;\n    if (\n      ch &&\n      _isDOMElement(vnode) &&\n      typeof (vnode as DOMElement).type === 'string'\n    ) {\n      const vnodeType = (vnode as DOMElement).type as string;\n      if (ch.tagName.toLowerCase() === vnodeType.toLowerCase()) {\n        const children =\n          (vnode as DOMElement).children ||\n          (vnode as DOMElement).props?.children;\n        if (typeof children === 'string' || typeof children === 'number') {\n          if (ch.childNodes.length === 1 && ch.firstChild?.nodeType === 3) {\n            (ch.firstChild as Text).data = String(children);\n          } else {\n            ch.textContent = String(children);\n          }\n        } else if (\n          Array.isArray(children) &&\n          children.length === 1 &&\n          (typeof children[0] === 'string' || typeof children[0] === 'number')\n        ) {\n          if (ch.childNodes.length === 1 && ch.firstChild?.nodeType === 3) {\n            (ch.firstChild as Text).data = String(children[0]);\n          } else {\n            ch.textContent = String(children[0]);\n          }\n        } else {\n          updateElementFromVnode(ch, vnode as VNode);\n        }\n        // Update data-key attribute to reflect new key mapping\n        try {\n          ch.setAttribute('data-key', String(key));\n          updatedKeys++;\n        } catch (e) {\n          void e;\n        }\n        reused++;\n        continue;\n      }\n    }\n    // Fallback: replace the node at position i\n    const dom = createDOMNode(vnode);\n    if (dom) {\n      const existing = parent.children[i];\n      if (existing) {\n        cleanupInstanceIfPresent(existing);\n        parent.replaceChild(dom, existing);\n      } else parent.appendChild(dom);\n    }\n  }\n\n  const t =\n    typeof performance !== 'undefined' && performance.now\n      ? performance.now() - t0\n      : 0;\n\n  // Rebuild keyed map to reflect new keys -> element mapping\n  try {\n    const newKeyMap = new Map<string | number, Element>();\n    for (let i = 0; i < total; i++) {\n      const k = keyedVnodes[i].key;\n      const ch = parent.children[i] as Element | undefined;\n      if (ch) newKeyMap.set(k, ch);\n    }\n    keyedElements.set(parent, newKeyMap);\n  } catch (e) {\n    void e;\n  }\n\n  const stats = {\n    n: total,\n    reused,\n    updatedKeys,\n    t,\n  } as const;\n  return stats;\n}\n\n/**\n * Heuristic to detect large bulk text-dominant updates eligible for fast-path.\n * Conditions:\n *  - total children >= threshold\n *  - majority of children are simple text (string/number) or intrinsic elements\n *    with a single primitive child\n *  - conservative: avoid when component children or complex shapes present\n */\nfunction isBulkTextFastPathEligible(parent: Element, newChildren: VNode[]) {\n  const threshold = Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024;\n  const requiredFraction = 0.8; // 80% of children should be simple text\n\n  const total = Array.isArray(newChildren) ? newChildren.length : 0;\n  if (total < threshold) {\n    if (\n      process.env.NODE_ENV !== 'production' ||\n      process.env.ASKR_FASTPATH_DEBUG === '1'\n    ) {\n      try {\n        (\n          globalThis as unknown as { __ASKR_BULK_DIAG?: unknown }\n        ).__ASKR_BULK_DIAG = {\n          phase: 'bulk-unkeyed-eligible',\n          reason: 'too-small',\n          total,\n          threshold,\n        };\n      } catch (e) {\n        void e;\n      }\n    }\n    return false;\n  }\n\n  let simple = 0;\n  for (let i = 0; i < newChildren.length; i++) {\n    const c = newChildren[i];\n    if (typeof c === 'string' || typeof c === 'number') {\n      simple++;\n      continue;\n    }\n    if (typeof c === 'object' && c !== null && 'type' in c) {\n      const dv = c as DOMElement;\n      if (typeof dv.type === 'function') {\n        if (\n          process.env.NODE_ENV !== 'production' ||\n          process.env.ASKR_FASTPATH_DEBUG === '1'\n        ) {\n          try {\n            (\n              globalThis as unknown as { __ASKR_BULK_DIAG?: unknown }\n            ).__ASKR_BULK_DIAG = {\n              phase: 'bulk-unkeyed-eligible',\n              reason: 'component-child',\n              index: i,\n            };\n          } catch (e) {\n            void e;\n          }\n        }\n        return false; // component child - decline\n      }\n      if (typeof dv.type === 'string') {\n        const children = dv.children || dv.props?.children;\n        if (!children) {\n          // empty element - treat as simple\n          simple++;\n          continue;\n        }\n        if (Array.isArray(children)) {\n          if (\n            children.length === 1 &&\n            (typeof children[0] === 'string' || typeof children[0] === 'number')\n          ) {\n            simple++;\n            continue;\n          }\n        } else if (\n          typeof children === 'string' ||\n          typeof children === 'number'\n        ) {\n          simple++;\n          continue;\n        }\n      }\n    }\n    // complex child - not simple\n  }\n\n  const fraction = simple / total;\n  const eligible =\n    fraction >= requiredFraction && parent.childNodes.length >= total;\n  if (\n    process.env.NODE_ENV !== 'production' ||\n    process.env.ASKR_FASTPATH_DEBUG === '1'\n  ) {\n    try {\n      (\n        globalThis as unknown as { __ASKR_BULK_DIAG?: unknown }\n      ).__ASKR_BULK_DIAG = {\n        phase: 'bulk-unkeyed-eligible',\n        total,\n        simple,\n        fraction,\n        requiredFraction,\n        eligible,\n      };\n    } catch (e) {\n      void e;\n    }\n  }\n\n  return eligible;\n}\n\n/**\n * Perform a bulk replace using DocumentFragment while reusing existing nodes\n * where possible to preserve identity and listeners. We avoid per-node DOM\n * insert/remove churn and perform a single atomic replaceChildren.\n */\nfunction performBulkTextReplace(parent: Element, newChildren: VNode[]) {\n  const t0 =\n    typeof performance !== 'undefined' && performance.now\n      ? performance.now()\n      : Date.now();\n  const existing = Array.from(parent.childNodes);\n  const finalNodes: Node[] = [];\n  let reused = 0;\n  let created = 0;\n\n  for (let i = 0; i < newChildren.length; i++) {\n    const vnode = newChildren[i];\n    const existingNode = existing[i];\n\n    if (typeof vnode === 'string' || typeof vnode === 'number') {\n      const text = String(vnode);\n      if (existingNode && existingNode.nodeType === 3) {\n        // Reuse existing text node\n        (existingNode as Text).data = text;\n        finalNodes.push(existingNode);\n        reused++;\n      } else {\n        // Create detached text node\n        finalNodes.push(document.createTextNode(text));\n        created++;\n      }\n      continue;\n    }\n\n    if (typeof vnode === 'object' && vnode !== null && 'type' in vnode) {\n      if (typeof (vnode as DOMElement).type === 'string') {\n        const vtype = (vnode as DOMElement).type as string;\n        if (\n          existingNode &&\n          existingNode.nodeType === 1 &&\n          (existingNode as Element).tagName.toLowerCase() ===\n            vtype.toLowerCase()\n        ) {\n          // Reuse existing element node and update its text content (simple case)\n          const el = existingNode as Element;\n          const children =\n            (vnode as DOMElement).children ||\n            (vnode as DOMElement).props?.children;\n          if (typeof children === 'string' || typeof children === 'number') {\n            if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {\n              (el.firstChild as Text).data = String(children);\n            } else {\n              el.textContent = String(children);\n            }\n          } else if (\n            Array.isArray(children) &&\n            children.length === 1 &&\n            (typeof children[0] === 'string' || typeof children[0] === 'number')\n          ) {\n            if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {\n              (el.firstChild as Text).data = String(children[0]);\n            } else {\n              el.textContent = String(children[0]);\n            }\n          } else {\n            // For slightly more complex children, fallback to existing update routine\n            updateElementFromVnode(el, vnode as VNode);\n          }\n          finalNodes.push(el);\n          reused++;\n          continue;\n        }\n\n        // Not reusable - create detached DOM node\n        const dom = createDOMNode(vnode);\n        if (dom) {\n          finalNodes.push(dom);\n          created++;\n        }\n        continue;\n      }\n    }\n\n    // Fallback for anything else: create node\n    const dom = createDOMNode(vnode);\n    if (dom) {\n      finalNodes.push(dom);\n      created++;\n    }\n  }\n\n  const tBuild =\n    typeof performance !== 'undefined' && performance.now\n      ? performance.now() - t0\n      : 0;\n\n  // Clean up instances that will be removed\n  try {\n    const toRemove = Array.from(parent.childNodes).filter(\n      (n) => !finalNodes.includes(n)\n    );\n    for (const n of toRemove) cleanupInstanceIfPresent(n);\n  } catch (e) {\n    void e;\n  }\n\n  const fragStart = Date.now();\n  const fragment = document.createDocumentFragment();\n  for (let i = 0; i < finalNodes.length; i++)\n    fragment.appendChild(finalNodes[i]);\n  // Atomic replacement\n  parent.replaceChildren(fragment);\n  const tCommit = Date.now() - fragStart;\n\n  // Clear keyed map for unkeyed path\n  keyedElements.delete(parent);\n\n  const stats = {\n    n: newChildren.length,\n    reused,\n    created,\n    tBuild,\n    tCommit,\n  } as const;\n\n  return stats;\n}\n\n/**\n * Update an existing element's attributes and children from vnode\n */\nfunction updateElementFromVnode(\n  el: Element,\n  vnode: VNode,\n  updateChildren = true\n): void {\n  if (!_isDOMElement(vnode)) {\n    return;\n  }\n\n  const props = vnode.props || {};\n\n  // Ensure key is materialized on existing elements so DOM-based scans succeed\n  if ((vnode as DOMElement).key !== undefined) {\n    el.setAttribute('data-key', String((vnode as DOMElement).key));\n  }\n\n  // Diff and update event listeners and other attributes\n  const existingListeners = elementListeners.get(el);\n  const desiredEventNames = new Set<string>();\n\n  for (const key in props) {\n    const value = (props as Record<string, unknown>)[key];\n    if (key === 'children' || key === 'key') continue;\n\n    // Handle removal cases\n    if (value === undefined || value === null || value === false) {\n      if (key === 'class' || key === 'className') {\n        el.className = '';\n      } else if (key.startsWith('on') && key.length > 2) {\n        const eventName =\n          key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();\n        if (existingListeners && existingListeners.has(eventName)) {\n          const entry = existingListeners.get(eventName)!;\n          el.removeEventListener(eventName, entry.handler);\n          existingListeners.delete(eventName);\n        }\n        continue;\n      } else {\n        el.removeAttribute(key);\n      }\n      continue;\n    }\n\n    if (key === 'class' || key === 'className') {\n      el.className = String(value);\n    } else if (key === 'value' || key === 'checked') {\n      (el as HTMLElement & Record<string, unknown>)[key] = value;\n    } else if (key.startsWith('on') && key.length > 2) {\n      const eventName =\n        key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();\n\n      desiredEventNames.add(eventName);\n\n      const existing = existingListeners?.get(eventName);\n      // If the handler reference is unchanged, keep existing wrapped handler\n      if (existing && existing.original === value) {\n        continue;\n      }\n\n      // Remove old handler if present\n      if (existing) {\n        el.removeEventListener(eventName, existing.handler);\n      }\n\n      const wrappedHandler = (event: Event) => {\n        globalScheduler.setInHandler(true);\n        try {\n          (value as EventListener)(event);\n        } catch (error) {\n          logger.error('[Askr] Event handler error:', error);\n        } finally {\n          globalScheduler.setInHandler(false);\n        }\n      };\n\n      el.addEventListener(eventName, wrappedHandler);\n      if (!elementListeners.has(el)) {\n        elementListeners.set(el, new Map());\n      }\n      elementListeners.get(el)!.set(eventName, {\n        handler: wrappedHandler,\n        original: value as EventListener,\n      });\n    } else {\n      el.setAttribute(key, String(value));\n    }\n  }\n\n  // Remove any remaining listeners not desired by current props\n  if (existingListeners) {\n    // Iterate over keys to avoid allocating a transient array via Array.from\n    for (const eventName of existingListeners.keys()) {\n      const entry = existingListeners.get(eventName)!;\n      if (!desiredEventNames.has(eventName)) {\n        el.removeEventListener(eventName, entry.handler);\n        existingListeners.delete(eventName);\n      }\n    }\n    if (existingListeners.size === 0) elementListeners.delete(el);\n  }\n\n  // Update children\n  if (updateChildren) {\n    const children =\n      vnode.children || (props.children as VNode | VNode[] | undefined);\n    updateElementChildren(el, children);\n  }\n}\n\n/**\n * Update an existing element's children\n */\nfunction updateElementChildren(\n  el: Element,\n  children: VNode | VNode[] | undefined\n): void {\n  if (!children) {\n    el.textContent = '';\n    return;\n  }\n\n  // Handle simple text case\n  if (\n    !Array.isArray(children) &&\n    (typeof children === 'string' || typeof children === 'number')\n  ) {\n    if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {\n      // Update existing text node\n      (el.firstChild as Text).data = String(children);\n    } else {\n      el.textContent = String(children);\n    }\n    return;\n  }\n\n  // For array children, update in-place to preserve positional identity\n  if (Array.isArray(children)) {\n    updateUnkeyedChildren(el, children);\n    return;\n  }\n\n  // Fallback: clear and rebuild\n  el.textContent = '';\n  const dom = createDOMNode(children);\n  if (dom) el.appendChild(dom);\n}\n\n/**\n * Update unkeyed children by position, preserving element identity when tags match.\n */\nfunction updateUnkeyedChildren(parent: Element, newChildren: unknown[]): void {\n  const existing = Array.from(parent.children);\n  // If there are only text nodes (no element children), clear before updating\n  if (existing.length === 0 && parent.childNodes.length > 0) {\n    parent.textContent = '';\n  }\n  const max = Math.max(existing.length, newChildren.length);\n\n  for (let i = 0; i < max; i++) {\n    const current = existing[i];\n    const next = newChildren[i];\n\n    // Remove extra existing children\n    if (next === undefined && current) {\n      // Clean up any component instance mounted on this node\n      cleanupInstanceIfPresent(current);\n      current.remove();\n      continue;\n    }\n\n    // Append new children beyond existing length\n    if (!current && next !== undefined) {\n      const dom = createDOMNode(next);\n      if (dom) parent.appendChild(dom);\n      continue;\n    }\n\n    if (!current || next === undefined) continue;\n\n    // Update existing element based on next vnode/primitive\n    if (typeof next === 'string' || typeof next === 'number') {\n      current.textContent = String(next);\n    } else if (_isDOMElement(next)) {\n      if (typeof next.type === 'string') {\n        // If element type matches, update in place; otherwise replace\n        if (current.tagName.toLowerCase() === next.type.toLowerCase()) {\n          updateElementFromVnode(current, next);\n        } else {\n          const dom = createDOMNode(next);\n          if (dom) {\n            cleanupInstanceIfPresent(current);\n            parent.replaceChild(dom, current);\n          }\n        }\n      } else {\n        // Non-string types: replace conservatively\n        const dom = createDOMNode(next);\n        if (dom) {\n          cleanupInstanceIfPresent(current);\n          parent.replaceChild(dom, current);\n        }\n      }\n    } else {\n      // Fallback for other types: replace\n      const dom = createDOMNode(next);\n      if (dom) {\n        cleanupInstanceIfPresent(current);\n        parent.replaceChild(dom, current);\n      }\n    }\n  }\n}\n\nexport function createDOMNode(node: unknown): Node | null {\n  // Fast paths for primitives (most common)\n  if (typeof node === 'string') {\n    return document.createTextNode(node);\n  }\n  if (typeof node === 'number') {\n    return document.createTextNode(String(node));\n  }\n\n  // Null/undefined/false\n  if (!node) {\n    return null;\n  }\n\n  // Array (fragment) - batch all at once\n  if (Array.isArray(node)) {\n    const fragment = document.createDocumentFragment();\n    for (let i = 0; i < node.length; i++) {\n      const dom = createDOMNode(node[i]);\n      if (dom) fragment.appendChild(dom);\n    }\n    return fragment;\n  }\n\n  // Element or Component\n  if (typeof node === 'object' && node !== null && 'type' in node) {\n    const type = (node as DOMElement).type;\n    const props = (node as DOMElement).props || {};\n\n    // Intrinsic element (string type)\n    if (typeof type === 'string') {\n      const el = document.createElement(type);\n\n      // Set attributes and event handlers in single pass (allocation-free)\n      for (const key in props) {\n        const value = (props as Record<string, unknown>)[key];\n        // Skip special keys\n        if (key === 'children' || key === 'key') continue;\n        if (value === undefined || value === null || value === false) continue;\n\n        if (key.startsWith('on') && key.length > 2) {\n          const eventName =\n            key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();\n          const wrappedHandler = (event: Event) => {\n            globalScheduler.setInHandler(true);\n            try {\n              (value as EventListener)(event);\n            } catch (error) {\n              logger.error('[Askr] Event handler error:', error);\n            } finally {\n              globalScheduler.setInHandler(false);\n              // If the handler enqueued tasks while we disallowed microtask kicks,\n              // ensure we schedule a microtask to flush them now that the handler\n              // has completed. This mirrors the behavior in scheduleEventHandler.\n              const state = globalScheduler.getState();\n              if ((state.queueLength ?? 0) > 0 && !state.running) {\n                queueMicrotask(() => {\n                  try {\n                    if (!globalScheduler.isExecuting()) globalScheduler.flush();\n                  } catch (err) {\n                    setTimeout(() => {\n                      throw err;\n                    });\n                  }\n                });\n              }\n            }\n          };\n\n          el.addEventListener(eventName, wrappedHandler);\n          if (!elementListeners.has(el)) {\n            elementListeners.set(el, new Map());\n          }\n          elementListeners.get(el)!.set(eventName, {\n            handler: wrappedHandler,\n            original: value as EventListener,\n          });\n        } else if (key === 'class' || key === 'className') {\n          el.className = String(value);\n        } else if (key === 'value' || key === 'checked') {\n          (el as HTMLElement & Props)[key] = value;\n          el.setAttribute(key, String(value));\n        } else {\n          el.setAttribute(key, String(value));\n        }\n      }\n\n      // Materialize key on created element so DOM-based fast-path can find it\n      const vnodeKey = (node as DOMElement).key;\n      if (vnodeKey !== undefined) {\n        el.setAttribute('data-key', String(vnodeKey));\n      }\n\n      // Add children - batch append\n      const children = props.children || (node as DOMElement).children;\n      if (children) {\n        if (Array.isArray(children)) {\n          // Check for missing keys on dynamic lists in dev mode\n          if (process.env.NODE_ENV !== 'production') {\n            let hasElements = false;\n            let hasKeys = false;\n            for (let i = 0; i < children.length; i++) {\n              const item = children[i];\n              if (typeof item === 'object' && item !== null && 'type' in item) {\n                hasElements = true;\n                const itemProps = (item as DOMElement).props || {};\n                if ('key' in itemProps) {\n                  hasKeys = true;\n                  break;\n                }\n              }\n            }\n            if (hasElements && !hasKeys) {\n              if (typeof console !== 'undefined') {\n                logger.warn(\n                  'Missing keys on dynamic lists. Each child in a list should have a unique \"key\" prop.'\n                );\n              }\n            }\n          }\n\n          for (let i = 0; i < children.length; i++) {\n            const dom = createDOMNode(children[i]);\n            if (dom) el.appendChild(dom);\n          }\n        } else {\n          const dom = createDOMNode(children);\n          if (dom) el.appendChild(dom);\n        }\n      }\n\n      return el;\n    }\n\n    // Component (function type) - inline execution\n    if (typeof type === 'function') {\n      // Check if this vnode has a marked context frame\n      const frame = (node as ElementWithContext)[CONTEXT_FRAME_SYMBOL];\n\n      // Capture context snapshot for this component's render\n      // If the vnode was not explicitly marked, fall back to the current\n      // ambient frame so the component's returned subtree inherits lexical\n      // provider context.\n      const snapshot = frame || getCurrentContextFrame();\n\n      // Components must be synchronous. Async components are not supported.\n      // Use `resource()` for async work — it provides explicit pending/value/error\n      // semantics, generation-based staleness, and lifecycle-bound cancellation.\n      const componentFn = type as (props: Props) => unknown;\n      const isAsync = componentFn.constructor.name === 'AsyncFunction';\n\n      if (isAsync) {\n        throw new Error(\n          'Async components are not supported. Use resource() for async work.'\n        );\n      }\n\n      // Ensure there is a persistent instance object attached to this vnode\n      const vnodeAny = node as ElementWithContext & {\n        __instance?: ComponentInstance;\n      };\n      let childInstance = vnodeAny.__instance;\n      if (!childInstance) {\n        // Create a new instance for this component so it can own hooks and mount ops\n        childInstance = createComponentInstance(\n          `comp-${Math.random().toString(36).slice(2, 7)}`,\n          componentFn as ComponentFunction,\n          props || {},\n          null\n        );\n        vnodeAny.__instance = childInstance;\n      }\n\n      // If this vnode was marked with a context frame, record it on the\n      // instance as its incoming provider frame so future re-renders and\n      // async operations (resources) can reference the correct provider chain.\n      if (snapshot) {\n        childInstance.ownerFrame = snapshot;\n      }\n\n      // Render the component inline using the instance so hooks register correctly.\n      // IMPORTANT: also keep the snapshot active while materializing the returned\n      // subtree so nested providers can chain to the correct parent frame.\n      const result = withContext(snapshot, () =>\n        renderComponentInline(childInstance)\n      );\n\n      if (result instanceof Promise) {\n        // Defensive: disallow components that return a Promise\n        throw new Error(\n          'Async components are not supported. Components must return synchronously.'\n        );\n      }\n\n      // Create DOM subtree for the component result (under the same snapshot)\n      const dom = withContext(snapshot, () => createDOMNode(result));\n\n      // Mount the instance inline now that its DOM is materialized\n      if (dom instanceof Element) {\n        mountInstanceInline(childInstance, dom);\n      } else {\n        // For non-element results (fragments or text nodes) create a host\n        // element to serve as the instance target. This host is not attached\n        // to the document; it only provides a stable element for mount ops.\n        const host = document.createElement('div');\n        mountInstanceInline(childInstance, host);\n      }\n\n      return dom;\n    }\n\n    // Fragment support: render children without wrapper element\n    // Uses Askr's Fragment symbol\n    if (\n      typeof type === 'symbol' &&\n      (type === Fragment || String(type) === 'Symbol(Fragment)')\n    ) {\n      const fragment = document.createDocumentFragment();\n      const children = props.children || (node as DOMElement).children;\n      if (children) {\n        if (Array.isArray(children)) {\n          for (let i = 0; i < children.length; i++) {\n            const dom = createDOMNode(children[i]);\n            if (dom) fragment.appendChild(dom);\n          }\n        } else {\n          const dom = createDOMNode(children);\n          if (dom) fragment.appendChild(dom);\n        }\n      }\n      return fragment;\n    }\n  }\n\n  return null;\n}\n\n// Expose minimal renderer bridge for runtime fast-lane to call `evaluate`\nif (typeof globalThis !== 'undefined') {\n  const _g = globalThis as unknown as Record<string, unknown>;\n  _g.__ASKR_RENDERER = {\n    evaluate,\n    isKeyedReorderFastPathEligible,\n    getKeyMapForElement,\n  };\n}\n","/**\n * Component instance lifecycle management\n * Internal only — users never see this\n */\n\nimport { type State } from './state';\nimport { evaluate } from '../renderer/dom';\nimport { globalScheduler } from './scheduler';\nimport type { JSXElement } from '../jsx/types';\nimport type { Props } from '../shared/types';\nimport {\n  // withContext is the sole primitive for context restoration\n  withContext,\n  type ContextFrame,\n} from './context';\nimport { logger } from '../dev/logger';\n\nexport type ComponentFunction = (\n  props: Props,\n  context?: { signal: AbortSignal }\n) => JSXElement | VNode | string | number | null;\n\ntype VNode = {\n  type: string;\n  props?: Props;\n  children?: (string | VNode | null | undefined | false)[];\n};\n\nexport interface ComponentInstance {\n  id: string;\n  fn: ComponentFunction;\n  props: Props;\n  target: Element | null;\n  mounted: boolean;\n  abortController: AbortController; // Per-component abort lifecycle\n  ssr?: boolean; // Set to true for SSR temporary instances\n  stateValues: State<unknown>[]; // Persistent state storage across renders\n  evaluationGeneration: number; // Prevents stale async evaluation completions\n  notifyUpdate: (() => void) | null; // Callback for state updates (persisted on instance)\n  // Internal: prebound helpers to avoid per-update closures (allocation hot-path)\n  _pendingFlushTask?: () => void; // Clears hasPendingUpdate and triggers notifyUpdate\n  _pendingRunTask?: () => void; // Clears hasPendingUpdate and runs component\n  _enqueueRun?: () => void; // Batches run requests and enqueues _pendingRunTask\n  stateIndexCheck: number; // Track state indices to catch conditional calls\n  expectedStateIndices: number[]; // Expected sequence of state indices (frozen after first render)\n  firstRenderComplete: boolean; // Flag to detect transition from first to subsequent renders\n  mountOperations: Array<\n    () => void | (() => void) | Promise<void | (() => void)>\n  >; // Operations to run when component mounts\n  cleanupFns: Array<() => void>; // Cleanup functions to run on unmount\n  hasPendingUpdate: boolean; // Flag to batch state updates (coalescing)\n  ownerFrame: ContextFrame | null; // Provider chain for this component (set by Scope, never overwritten)\n  isRoot?: boolean;\n\n  // Render-tracking for precise subscriptions (internal)\n  _currentRenderToken?: number; // Token for the in-progress render (set before render)\n  lastRenderToken?: number; // Token of the last *committed* render\n  _pendingReadStates?: Set<State<unknown>>; // States read during the in-progress render\n  _lastReadStates?: Set<State<unknown>>; // States read during the last committed render\n}\n\nexport function createComponentInstance(\n  id: string,\n  fn: ComponentFunction,\n  props: Props,\n  target: Element | null\n): ComponentInstance {\n  const instance: ComponentInstance = {\n    id,\n    fn,\n    props,\n    target,\n    mounted: false,\n    abortController: new AbortController(), // Create per-component\n    stateValues: [],\n    evaluationGeneration: 0,\n    notifyUpdate: null,\n    // Prebound helpers (initialized below) to avoid per-update allocations\n    _pendingFlushTask: undefined,\n    _pendingRunTask: undefined,\n    _enqueueRun: undefined,\n    stateIndexCheck: -1,\n    expectedStateIndices: [],\n    firstRenderComplete: false,\n    mountOperations: [],\n    cleanupFns: [],\n    hasPendingUpdate: false,\n    ownerFrame: null, // Will be set by renderer when vnode is marked\n    ssr: false,\n    isRoot: false,\n\n    // Render-tracking (for precise state subscriptions)\n    _currentRenderToken: undefined,\n    lastRenderToken: 0,\n    _pendingReadStates: new Set(),\n    _lastReadStates: new Set(),\n  };\n\n  // Initialize prebound helper tasks once per instance to avoid allocations\n  instance._pendingRunTask = () => {\n    // Clear pending flag when the run task executes\n    instance.hasPendingUpdate = false;\n    // Execute component run (will set up notifyUpdate before render)\n    runComponent(instance);\n  };\n\n  instance._enqueueRun = () => {\n    if (!instance.hasPendingUpdate) {\n      instance.hasPendingUpdate = true;\n      // Enqueue single run task (coalesces multiple writes)\n      globalScheduler.enqueue(instance._pendingRunTask!);\n    }\n  };\n\n  instance._pendingFlushTask = () => {\n    // Called by state.set() when we want to flush a pending update\n    instance.hasPendingUpdate = false;\n    // Trigger a run via enqueue helper — this will schedule the component run\n    instance._enqueueRun?.();\n  };\n\n  return instance;\n}\n\nlet currentInstance: ComponentInstance | null = null;\nlet stateIndex = 0;\n\n// Export for state.ts to access\nexport function getCurrentComponentInstance(): ComponentInstance | null {\n  return currentInstance;\n}\n\n// Export for SSR to set temporary instance\nexport function setCurrentComponentInstance(\n  instance: ComponentInstance | null\n): void {\n  currentInstance = instance;\n}\n\n/**\n * Register a mount operation that will run after the component is mounted\n * Used by operations (task, on, timer, etc) to execute after render completes\n */\nimport { isBulkCommitActive } from './fastlane';\n\nexport function registerMountOperation(\n  operation: () => void | (() => void) | Promise<void | (() => void)>\n): void {\n  const instance = getCurrentComponentInstance();\n  if (instance) {\n    // If we're in bulk-commit fast lane, registering mount operations is a\n    // violation of the fast-lane preconditions. Throw in dev, otherwise ignore\n    // silently in production (we must avoid scheduling work during bulk commit).\n    if (isBulkCommitActive()) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error(\n          'registerMountOperation called during bulk commit fast-lane'\n        );\n      }\n      return;\n    }\n    instance.mountOperations.push(operation);\n  }\n}\n\n/**\n * Execute all mount operations for a component\n * These run after the component is rendered and mounted to the DOM\n */\nfunction executeMountOperations(instance: ComponentInstance): void {\n  // Only execute mount operations for root app instance. Child component\n  // operations are currently registered but should not be executed (per\n  // contract tests). They remain registered for cleanup purposes.\n  if (!instance.isRoot) return;\n\n  for (const operation of instance.mountOperations) {\n    const result = operation();\n    if (result instanceof Promise) {\n      result.then((cleanup) => {\n        if (typeof cleanup === 'function') {\n          instance.cleanupFns.push(cleanup);\n        }\n      });\n    } else if (typeof result === 'function') {\n      instance.cleanupFns.push(result);\n    }\n  }\n  // Clear the operations array so they don't run again on subsequent renders\n  instance.mountOperations = [];\n}\n\nexport function mountInstanceInline(\n  instance: ComponentInstance,\n  target: Element | null\n): void {\n  instance.target = target;\n  // Record backref on host element so renderer can clean up when the\n  // node is removed. Avoids leaks if the node is detached or replaced.\n  try {\n    if (target instanceof Element)\n      (\n        target as Element & { __ASKR_INSTANCE?: ComponentInstance }\n      ).__ASKR_INSTANCE = instance;\n  } catch (err) {\n    void err;\n  }\n\n  // Ensure notifyUpdate is available for async resource completions that may\n  // try to trigger re-render. This mirrors the setup in executeComponent().\n  // Use prebound enqueue helper to avoid allocating a new closure\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  const wasFirstMount = !instance.mounted;\n  instance.mounted = true;\n  if (wasFirstMount && instance.mountOperations.length > 0) {\n    executeMountOperations(instance);\n  }\n}\n\n/**\n * Run a component synchronously: execute function, handle result\n * This is the internal workhorse that manages async continuations and generation tracking.\n * Must always be called through the scheduler.\n *\n * ACTOR INVARIANT: This function is enqueued as a task, never called directly.\n */\nlet _globalRenderCounter = 0;\n\nfunction runComponent(instance: ComponentInstance): void {\n  // CRITICAL: Ensure notifyUpdate is available for state.set() calls during this render.\n  // This must be set before executeComponentSync() runs, not after.\n  // Use prebound enqueue helper to avoid allocating per-render closures\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  // Assign a token for this in-progress render and start a fresh pending-read set\n  instance._currentRenderToken = ++_globalRenderCounter;\n  instance._pendingReadStates = new Set();\n\n  // Atomic rendering: capture DOM state for rollback on error\n  const domSnapshot = instance.target ? instance.target.innerHTML : '';\n\n  const result = executeComponentSync(instance);\n  if (result instanceof Promise) {\n    // Async components are not supported. Components must be synchronous and\n    // must not return a Promise from their render function.\n    throw new Error(\n      'Async components are not supported. Components must be synchronous.'\n    );\n  } else {\n    // Try runtime fast-lane synchronously; if it activates we do not enqueue\n    // follow-up work and the commit happens atomically in this task.\n    // (Runtime fast-lane has conservative preconditions.)\n    const fastlaneBridge = (\n      globalThis as unknown as {\n        __ASKR_FASTLANE?: {\n          tryRuntimeFastLaneSync?: (\n            instance: unknown,\n            result: unknown\n          ) => boolean;\n        };\n      }\n    ).__ASKR_FASTLANE;\n    try {\n      const used = fastlaneBridge?.tryRuntimeFastLaneSync?.(instance, result);\n      if (used) return;\n    } catch (err) {\n      // If invariant check failed in dev, surface the error; otherwise fall back\n      if (process.env.NODE_ENV !== 'production') throw err;\n    }\n\n    // Fallback: enqueue the render/commit normally\n    globalScheduler.enqueue(() => {\n      if (instance.target) {\n        try {\n          const wasFirstMount = !instance.mounted;\n          // Ensure nested component executions during evaluation have access to\n          // the current component instance. This allows nested components to\n          // call `state()`, `resource()`, and other runtime helpers which\n          // rely on `getCurrentComponentInstance()` being available.\n          const oldInstance = currentInstance;\n          currentInstance = instance;\n          try {\n            evaluate(result, instance.target);\n          } finally {\n            currentInstance = oldInstance;\n          }\n\n          // Commit succeeded — finalize recorded state reads so subscriptions reflect\n          // the last *committed* render. This updates per-state reader maps\n          // deterministically and synchronously with the commit.\n          finalizeReadSubscriptions(instance);\n\n          instance.mounted = true;\n          // Execute mount operations after first mount (do NOT run these with\n          // currentInstance set - they may perform state mutations/registrations)\n          if (wasFirstMount && instance.mountOperations.length > 0) {\n            executeMountOperations(instance);\n          }\n        } catch (renderError) {\n          // Atomic rendering: rollback on render error\n          instance.target.innerHTML = domSnapshot;\n          throw renderError;\n        }\n      }\n    });\n  }\n}\n\n/**\n * Execute a component's render function synchronously.\n * Returns either a vnode/promise immediately (does NOT render).\n * Rendering happens separately through runComponent.\n */\nexport function renderComponentInline(\n  instance: ComponentInstance\n): unknown | Promise<unknown> {\n  // Ensure inline executions (rendered during parent's evaluate) still\n  // receive a render token and have their state reads finalized so\n  // subscriptions are correctly recorded. If this function is called\n  // as part of a scheduled run, the token will already be set by\n  // runComponent and we should not overwrite it.\n  const hadToken = instance._currentRenderToken !== undefined;\n  if (!hadToken) {\n    instance._currentRenderToken = ++_globalRenderCounter;\n    instance._pendingReadStates = new Set();\n  }\n\n  try {\n    const result = executeComponentSync(instance);\n    // If we set the token for inline execution, finalize subscriptions now\n    // because the component is effectively committed as part of the parent's\n    // synchronous evaluation.\n    if (!hadToken) {\n      finalizeReadSubscriptions(instance);\n    }\n    return result;\n  } finally {\n    if (!hadToken) {\n      instance._pendingReadStates = new Set();\n      instance._currentRenderToken = undefined;\n    }\n  }\n}\n\nfunction executeComponentSync(\n  instance: ComponentInstance\n): unknown | Promise<unknown> {\n  // Reset state index tracking for this render\n  instance.stateIndexCheck = -1;\n\n  // Reset read tracking for all existing state\n  for (const state of instance.stateValues) {\n    if (state) {\n      state._hasBeenRead = false;\n    }\n  }\n\n  // Prepare pending read set for this render (reads will be finalized on commit)\n  instance._pendingReadStates = new Set();\n\n  currentInstance = instance;\n  stateIndex = 0;\n\n  try {\n    // Track render time in dev mode\n    const renderStartTime =\n      process.env.NODE_ENV !== 'production' ? Date.now() : 0;\n\n    // Create context object with abort signal\n    const context = {\n      signal: instance.abortController.signal,\n    };\n\n    // Execute component within its owner frame (provider chain).\n    // This ensures all context reads see the correct provider values.\n    // We create a new execution frame whose parent is the ownerFrame. The\n    // `values` map is lazily allocated to avoid per-render Map allocations\n    // for components that do not use context.\n    const executionFrame: ContextFrame = {\n      parent: instance.ownerFrame,\n      values: null,\n    };\n    const result = withContext(executionFrame, () =>\n      instance.fn(instance.props, context)\n    );\n\n    // Check render time in dev mode\n    if (process.env.NODE_ENV !== 'production') {\n      const renderTime = Date.now() - renderStartTime;\n      if (renderTime > 5) {\n        // Warn if render takes more than 5ms\n        logger.warn(\n          `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`\n        );\n      }\n    }\n\n    // Mark first render complete after successful execution\n    // This enables hook order validation on subsequent renders\n    if (!instance.firstRenderComplete) {\n      instance.firstRenderComplete = true;\n    }\n\n    // Check for unused state in dev mode\n    if (process.env.NODE_ENV !== 'production') {\n      for (let i = 0; i < instance.stateValues.length; i++) {\n        const state = instance.stateValues[i];\n        if (state && !state._hasBeenRead) {\n          logger.warn(\n            `[askr] Unused state variable detected. State should be read during render or removed.`\n          );\n        }\n      }\n    }\n\n    return result;\n  } finally {\n    // Synchronous path: we did not push a fresh frame, so nothing to pop here.\n    currentInstance = null;\n  }\n}\n\n/**\n * Public entry point: Execute component with full lifecycle (execute + render)\n * Handles both initial mount and re-execution. Always enqueues through scheduler.\n * Single entry point to avoid lifecycle divergence.\n */\nexport function executeComponent(instance: ComponentInstance): void {\n  // Create a fresh abort controller on mount to allow remounting\n  // (old one may have been aborted during previous cleanup)\n  instance.abortController = new AbortController();\n\n  // Setup notifyUpdate callback using prebound helper to avoid per-call closures\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  // Enqueue the initial component run\n  globalScheduler.enqueue(() => runComponent(instance));\n}\n\nexport function getCurrentInstance(): ComponentInstance | null {\n  return currentInstance;\n}\n\n/**\n * Get the abort signal for the current component\n * Used to cancel async operations on unmount/navigation\n *\n * The signal is guaranteed to be aborted when:\n * - Component unmounts\n * - Navigation occurs (different route)\n * - Parent is destroyed\n *\n * IMPORTANT: getSignal() must be called during component render execution.\n * It captures the current component instance from context.\n *\n * @returns AbortSignal that will be aborted when component unmounts\n * @throws Error if called outside component execution\n *\n * @example\n * ```ts\n * // ✅ Correct: called during render, used in async operation\n * export async function UserPage({ id }: { id: string }) {\n *   const signal = getSignal();\n *   const user = await fetch(`/api/users/${id}`, { signal });\n *   return <div>{user.name}</div>;\n * }\n *\n * // ✅ Correct: passed to event handler\n * export function Button() {\n *   const signal = getSignal();\n *   return {\n *     type: 'button',\n *     props: {\n *       onClick: async () => {\n *         const data = await fetch(url, { signal });\n *       }\n *     }\n *   };\n * }\n *\n * // ❌ Wrong: called outside component context\n * const signal = getSignal(); // Error: not in component\n * ```\n */\nexport function getSignal(): AbortSignal {\n  if (!currentInstance) {\n    throw new Error(\n      'getSignal() can only be called during component render execution. ' +\n        'Ensure you are calling this from inside your component function.'\n    );\n  }\n  return currentInstance.abortController.signal;\n}\n\n/**\n * Finalize read subscriptions for an instance after a successful commit.\n * - Update per-state readers map to point to this instance's last committed token\n * - Remove this instance from states it no longer reads\n * This is deterministic and runs synchronously with commit to ensure\n * subscribers are only notified when they actually read a state in their\n * last committed render.\n */\nexport function finalizeReadSubscriptions(instance: ComponentInstance): void {\n  const newSet = instance._pendingReadStates ?? new Set();\n  const oldSet = instance._lastReadStates ?? new Set();\n  const token = instance._currentRenderToken;\n\n  if (token === undefined) return;\n\n  // Remove subscriptions for states that were read previously but not in this render\n  for (const s of oldSet) {\n    if (!newSet.has(s)) {\n      const readers = (\n        s as unknown as { _readers?: Map<ComponentInstance, number> }\n      )?._readers;\n      if (readers) readers.delete(instance);\n    }\n  }\n\n  // Commit token becomes the authoritative token for this instance's last render\n  instance.lastRenderToken = token;\n\n  // Record subscriptions for states read during this render\n  for (const s of newSet) {\n    let readers = (\n      s as unknown as { _readers?: Map<ComponentInstance, number> }\n    )?._readers;\n    if (!readers) {\n      readers = new Map();\n      // s is a State object; assign its _readers map\n      (s as State<unknown>)._readers = readers;\n    }\n    readers.set(instance, instance.lastRenderToken ?? 0);\n  }\n\n  instance._lastReadStates = newSet;\n  instance._pendingReadStates = new Set();\n  instance._currentRenderToken = undefined;\n}\n\nexport function getNextStateIndex(): number {\n  return stateIndex++;\n}\n\n/**\n * Mount a component instance.\n * This is just an alias to executeComponent() to maintain API compatibility.\n * All lifecycle logic is unified in executeComponent().\n */\nexport function mountComponent(instance: ComponentInstance): void {\n  executeComponent(instance);\n}\n\n/**\n * Clean up component — abort pending operations\n * Called on unmount or route change\n */\nexport function cleanupComponent(instance: ComponentInstance): void {\n  // Execute cleanup functions (from mount effects)\n  for (const cleanup of instance.cleanupFns) {\n    cleanup();\n  }\n  instance.cleanupFns = [];\n\n  // Remove deterministic state subscriptions for this instance\n  if (instance._lastReadStates) {\n    for (const s of instance._lastReadStates) {\n      const readers = (\n        s as unknown as { _readers?: Map<ComponentInstance, number> }\n      )?._readers;\n      if (readers) readers.delete(instance);\n    }\n    instance._lastReadStates = new Set();\n  }\n\n  // Abort all pending operations\n  instance.abortController.abort();\n}\n","/**\n * Route definition and matching\n * Supports dynamic route registration for micro frontends\n *\n * Optimization: Index by depth but maintain insertion order within each depth\n */\n\nimport { match as matchPath } from './match';\nimport { getCurrentComponentInstance } from '../runtime/component';\n\nexport interface RouteHandler {\n  (params: Record<string, string>, context?: { signal: AbortSignal }): unknown;\n}\n\nexport interface Route {\n  path: string;\n  handler: RouteHandler;\n  namespace?: string;\n}\n\nexport interface ResolvedRoute {\n  handler: RouteHandler;\n  params: Record<string, string>;\n}\n\nconst routes: Route[] = [];\nconst namespaces = new Set<string>();\n\n// Route index by depth - maintains insertion order\nconst routesByDepth = new Map<number, Route[]>();\n\n/**\n * Parse route path depth\n */\nfunction getDepth(path: string): number {\n  const normalized =\n    path.endsWith('/') && path !== '/' ? path.slice(0, -1) : path;\n  return normalized === '/' ? 0 : normalized.split('/').filter(Boolean).length;\n}\n\n/**\n * Calculate route specificity for priority matching\n * Higher score = more specific\n * - Literal segments: 3 points each\n * - Parameter segments ({id}): 2 points each\n * - Wildcard segments (*): 1 point each\n * - Catch-all (/*): 0 points\n */\nfunction getSpecificity(path: string): number {\n  const normalized =\n    path.endsWith('/') && path !== '/' ? path.slice(0, -1) : path;\n\n  // Special case: catch-all pattern\n  if (normalized === '/*') {\n    return 0;\n  }\n\n  const segments = normalized.split('/').filter(Boolean);\n  let score = 0;\n\n  for (const segment of segments) {\n    if (segment.startsWith('{') && segment.endsWith('}')) {\n      score += 2; // Parameter\n    } else if (segment === '*') {\n      score += 1; // Wildcard\n    } else {\n      score += 3; // Literal\n    }\n  }\n\n  return score;\n}\n\n/**\n * RouteMatch, RouteQuery, RouteSnapshot\n * These describe the read-only snapshot returned by the render-time route() accessor\n */\nexport interface RouteMatch {\n  path: string;\n  params: Readonly<Record<string, string>>;\n  name?: string;\n  namespace?: string;\n}\n\nexport interface RouteQuery {\n  get(key: string): string | null;\n  getAll(key: string): string[];\n  has(key: string): boolean;\n  toJSON(): Record<string, string | string[]>;\n}\n\nexport interface RouteSnapshot {\n  path: string;\n  params: Readonly<Record<string, string>>;\n  query: Readonly<RouteQuery>;\n  hash: string | null;\n\n  name?: string;\n  namespace?: string;\n  matches: readonly RouteMatch[];\n}\n\n// SSR helper: when rendering on the server, callers may set a location so that\n// render-time route() returns deterministic server values that match client\n// hydration. This is deliberately an opt-in escape for SSR and tests.\nlet serverLocation: string | null = null;\n\nexport function setServerLocation(url: string | null): void {\n  serverLocation = url;\n}\n\n// Helper: parse a URL string into components\nfunction parseLocation(url: string) {\n  try {\n    const u = new URL(url, 'http://localhost');\n    return { pathname: u.pathname, search: u.search, hash: u.hash };\n  } catch {\n    return { pathname: '/', search: '', hash: '' };\n  }\n}\n\n// Deep freeze utility for small objects\nfunction deepFreeze<T>(obj: T): T {\n  if (obj && typeof obj === 'object' && !Object.isFrozen(obj)) {\n    Object.freeze(obj as unknown as Record<string, unknown>);\n    for (const key of Object.keys(obj as Record<string, unknown>)) {\n      const value = (obj as unknown as Record<string, unknown>)[key];\n      if (value && typeof value === 'object') deepFreeze(value);\n    }\n  }\n  return obj;\n}\n\n// Build an immutable query helper from a search string\nfunction makeQuery(search: string): RouteQuery {\n  const usp = new URLSearchParams(search || '');\n  const mapping = new Map<string, string[]>();\n  for (const [k, v] of usp.entries()) {\n    const existing = mapping.get(k);\n    if (existing) existing.push(v);\n    else mapping.set(k, [v]);\n  }\n\n  const obj: RouteQuery = {\n    get(key: string) {\n      const arr = mapping.get(key);\n      return arr ? arr[0] : null;\n    },\n    getAll(key: string) {\n      const arr = mapping.get(key);\n      return arr ? [...arr] : [];\n    },\n    has(key: string) {\n      return mapping.has(key);\n    },\n    toJSON() {\n      const out: Record<string, string | string[]> = {};\n      for (const [k, arr] of mapping.entries()) {\n        out[k] = arr.length > 1 ? [...arr] : arr[0];\n      }\n      return out;\n    },\n  };\n\n  return deepFreeze(obj);\n}\n\n// Compute matches by scanning registered routes (public API: getRoutes)\nfunction computeMatches(pathname: string): RouteMatch[] {\n  const routesList = getRoutes();\n  const matches: Array<{\n    pattern: string;\n    params: Record<string, string>;\n    name?: string;\n    namespace?: string;\n    specificity: number;\n  }> = [];\n\n  function getSpecificity(path: string) {\n    // Reuse same heuristic as above\n    const normalized =\n      path.endsWith('/') && path !== '/' ? path.slice(0, -1) : path;\n    if (normalized === '/*') return 0;\n    const segments = normalized.split('/').filter(Boolean);\n    let score = 0;\n    for (const segment of segments) {\n      if (segment.startsWith('{') && segment.endsWith('}')) score += 2;\n      else if (segment === '*') score += 1;\n      else score += 3;\n    }\n    return score;\n  }\n\n  for (const r of routesList) {\n    const result = matchPath(pathname, r.path);\n    if (result.matched) {\n      matches.push({\n        pattern: r.path,\n        params: result.params,\n        name: (r as { name?: string }).name,\n        namespace: r.namespace,\n        specificity: getSpecificity(r.path),\n      });\n    }\n  }\n\n  matches.sort((a, b) => b.specificity - a.specificity);\n\n  return matches.map((m) => ({\n    path: m.pattern,\n    params: deepFreeze({ ...m.params }),\n    name: m.name,\n    namespace: m.namespace,\n  }));\n}\n\n/**\n * Dual-purpose `route` function:\n * - route() → returns a read-only, deeply frozen RouteSnapshot (render-time)\n * - route(path, handler, namespace?) → registers a route handler (existing semantics)\n */\n// Prevent runtime registrations after the app has started\nlet registrationLocked = false;\n\nexport function lockRouteRegistration(): void {\n  registrationLocked = true;\n}\n\n// Internal test helpers\nexport function _lockRouteRegistrationForTests(): void {\n  registrationLocked = true;\n}\n\nexport function _unlockRouteRegistrationForTests(): void {\n  registrationLocked = false;\n}\n\nexport function route(\n  path?: string,\n  handler?: RouteHandler,\n  namespace?: string\n): void | RouteSnapshot {\n  // If called with no args, act as render-time accessor\n  if (typeof path === 'undefined') {\n    // Access the current component instance to ensure route() is only\n    // called during render.\n    const instance = getCurrentComponentInstance();\n    if (!instance) {\n      throw new Error(\n        'route() can only be called during component render execution. ' +\n          'Call route() from inside your component function.'\n      );\n    }\n\n    // Determine location source: client window if present; otherwise SSR override\n    let pathname = '/';\n    let search = '';\n    let hash = '';\n\n    if (typeof window !== 'undefined' && window.location) {\n      pathname = window.location.pathname || '/';\n      search = window.location.search || '';\n      hash = window.location.hash || '';\n    } else if (serverLocation) {\n      const parsed = parseLocation(serverLocation);\n      pathname = parsed.pathname;\n      search = parsed.search;\n      hash = parsed.hash;\n    }\n\n    const params = deepFreeze({\n      ...((instance.props as Record<string, string>) || {}),\n    });\n    const query = makeQuery(search);\n    const matches = computeMatches(pathname);\n\n    const snapshot: RouteSnapshot = Object.freeze({\n      path: pathname,\n      params,\n      query,\n      hash: hash || null,\n      matches: Object.freeze(matches),\n    });\n\n    return snapshot;\n  }\n\n  // Disallow route registration during SSR render\n  const currentInst = getCurrentComponentInstance();\n  if (currentInst && currentInst.ssr) {\n    throw new Error(\n      'route() cannot be called during SSR rendering. Register routes at module load time instead.'\n    );\n  }\n\n  // Disallow registrations after app startup\n  if (registrationLocked) {\n    throw new Error(\n      'Route registration is locked after app startup. Register routes at module load time before calling createApp().'\n    );\n  }\n\n  // Otherwise register a route (backwards compatible behavior)\n  if (typeof handler !== 'function') {\n    throw new Error(\n      'route(path, handler) requires a function handler that returns a VNode (e.g. () => <Page />). ' +\n        'Passing JSX elements or VNodes directly is not supported.'\n    );\n  }\n\n  const routeObj: Route = { path, handler: handler as RouteHandler, namespace };\n  routes.push(routeObj);\n\n  // Index by depth (maintains insertion order within depth)\n  const depth = getDepth(path);\n\n  let depthRoutes = routesByDepth.get(depth);\n  if (!depthRoutes) {\n    depthRoutes = [];\n    routesByDepth.set(depth, depthRoutes);\n  }\n\n  depthRoutes.push(routeObj);\n\n  if (namespace) {\n    namespaces.add(namespace);\n  }\n}\n\n/**\n * Get all registered routes\n */\nexport function getRoutes(): Route[] {\n  return [...routes];\n}\n\n/**\n * Get routes for a specific namespace\n */\nexport function getNamespaceRoutes(namespace: string): Route[] {\n  return routes.filter((r) => r.namespace === namespace);\n}\n\n/**\n * Unload all routes from a namespace (for MFE unmounting)\n */\nexport function unloadNamespace(namespace: string): number {\n  const before = routes.length;\n\n  // Remove from main array\n  for (let i = routes.length - 1; i >= 0; i--) {\n    if (routes[i].namespace === namespace) {\n      const removed = routes[i];\n      routes.splice(i, 1);\n\n      // Remove from depth index\n      const depth = getDepth(removed.path);\n      const depthRoutes = routesByDepth.get(depth);\n      if (depthRoutes) {\n        const idx = depthRoutes.indexOf(removed);\n        if (idx >= 0) {\n          depthRoutes.splice(idx, 1);\n        }\n      }\n    }\n  }\n\n  namespaces.delete(namespace);\n  return before - routes.length;\n}\n\n/**\n * Clear all registered routes (mainly for testing)\n */\nexport function clearRoutes(): void {\n  routes.length = 0;\n  namespaces.clear();\n  routesByDepth.clear();\n}\n\n/**\n * RouteDescriptor type — used by `registerRoute` for nested descriptors.\n *\n * Note: `registerRouteTree` helper was removed; prefer explicit `route()` registrations.\n */\nexport type RouteDescriptor = {\n  path: string;\n  handler?: RouteHandler | unknown;\n  children?: RouteDescriptor[];\n  _isDescriptor?: true;\n};\n\n// `registerRouteTree` was removed — register explicit absolute paths with `route(path, handler)` instead.\n// If you need a helper to register descriptor trees, add a small wrapper in userland that\n// calls `route()` recursively.\n\n// Helper: normalize common handler shapes\n// NOTE: Only function handlers are accepted — passing raw JSX/VNodes at register\n// time is not allowed. This keeps registration data-only and avoids surprising\n// semantics between module-load-time and render-time.\nfunction normalizeHandler(handler: unknown): RouteHandler | undefined {\n  if (handler == null) return undefined;\n  if (typeof handler === 'function') {\n    // Accept both (params) => ... handlers and component functions that take no args / props\n    return (params: Record<string, string>, ctx?: { signal?: AbortSignal }) => {\n      // Call with params and ctx; component functions can ignore them\n      // Allow handler to return JSX element, VNode, Promise, etc.\n      // If the function expects only props, passing params is safe (extra args ignored)\n      try {\n        return handler(params, ctx);\n      } catch {\n        return handler(params);\n      }\n    };\n  }\n  return undefined;\n}\n\n// Register route with flexible handler shapes and optional nested descriptors.\n// Usage patterns supported:\n// - Absolute flat registration: registerRoute('/pages', () => List())\n// - Nested descriptors: registerRoute('/', () => Home(), registerRoute('pages', () => List(), registerRoute('{id}', () => Detail())))\n//   Note: child descriptors should use relative paths (no leading '/').\nexport function registerRoute(\n  path: string,\n  handler?: unknown,\n  ...children: Array<RouteDescriptor | undefined>\n): RouteDescriptor {\n  const isRelative = !path.startsWith('/');\n\n  // Build descriptor that can be used for nesting\n  const descriptor: RouteDescriptor = {\n    path,\n    handler,\n    children: children.filter(Boolean) as RouteDescriptor[],\n    _isDescriptor: true,\n  };\n\n  // If path is absolute, perform registration immediately and recurse into children\n  if (!isRelative) {\n    const normalized = normalizeHandler(handler);\n    if (handler != null && !normalized) {\n      throw new Error(\n        'registerRoute(path, handler) requires a function handler. Passing JSX elements or VNodes directly is not supported.'\n      );\n    }\n    if (normalized) route(path, normalized);\n\n    for (const child of descriptor.children || []) {\n      // Compute child full path\n      const base = path === '/' ? '' : path.replace(/\\/$/, '');\n      const childPath = `${base}/${child.path.replace(/^\\//, '')}`.replace(\n        /\\/\\//g,\n        '/'\n      );\n      // Recurse: if child.handler is provided, register it\n      if (child.handler) {\n        const childNormalized = normalizeHandler(child.handler);\n        if (!childNormalized) {\n          throw new Error(\n            'registerRoute child handler must be a function. Passing JSX elements directly is not supported.'\n          );\n        }\n        if (childNormalized) route(childPath, childNormalized);\n      }\n      // Recurse into grandchildren\n      if (child.children && child.children.length) {\n        // Convert child.children into descriptors and register them\n        // Use registerRoute recursively with absolute childPath\n        registerRoute(\n          childPath,\n          null,\n          ...(child.children as RouteDescriptor[])\n        );\n      }\n    }\n\n    return descriptor;\n  }\n\n  // If relative, return descriptor for nesting (do not register yet)\n  return descriptor;\n}\n\n/**\n * Get all loaded namespaces (MFE identifiers)\n */\nexport function getLoadedNamespaces(): string[] {\n  return Array.from(namespaces);\n}\n\n/**\n * Resolve a path to a route handler with optimized lookup\n * Routes are matched by specificity: literals > parameters > wildcards > catch-all\n */\nexport function resolveRoute(pathname: string): ResolvedRoute | null {\n  const normalized =\n    pathname.endsWith('/') && pathname !== '/'\n      ? pathname.slice(0, -1)\n      : pathname;\n  const depth =\n    normalized === '/' ? 0 : normalized.split('/').filter(Boolean).length;\n\n  // Collect all matching routes with their specificity\n  const candidates: Array<{\n    route: Route;\n    specificity: number;\n    params: Record<string, string>;\n  }> = [];\n\n  // Try routes at this depth first (most likely match)\n  const depthRoutes = routesByDepth.get(depth);\n  if (depthRoutes) {\n    for (const r of depthRoutes) {\n      const result = matchPath(pathname, r.path);\n      if (result.matched) {\n        candidates.push({\n          route: r,\n          specificity: getSpecificity(r.path),\n          params: result.params,\n        });\n      }\n    }\n  }\n\n  // Fallback: scan all routes for different depths\n  // (handles edge cases like wildcard routes)\n  for (const r of routes) {\n    // Skip if already checked in depth routes\n    if (depthRoutes?.includes(r)) continue;\n\n    const result = matchPath(pathname, r.path);\n    if (result.matched) {\n      candidates.push({\n        route: r,\n        specificity: getSpecificity(r.path),\n        params: result.params,\n      });\n    }\n  }\n\n  // Sort by specificity (highest first)\n  candidates.sort((a, b) => b.specificity - a.specificity);\n\n  // Return most specific match\n  if (candidates.length > 0) {\n    const best = candidates[0];\n    return { handler: best.route.handler, params: best.params };\n  }\n\n  return null;\n}\n","/**\n * Path matching and parameter extraction\n */\n\nexport interface MatchResult {\n  matched: boolean;\n  params: Record<string, string>;\n}\n\n/**\n * Match a path against a route pattern and extract params\n *\n * @example\n * match('/users/123', '/users/{id}')\n * // → { matched: true, params: { id: '123' } }\n *\n * match('/posts/hello-world/edit', '/posts/{slug}/{action}')\n * // → { matched: true, params: { slug: 'hello-world', action: 'edit' } }\n *\n * match('/users', '/posts/{id}')\n * // → { matched: false, params: {} }\n */\nexport function match(path: string, pattern: string): MatchResult {\n  // Normalize trailing slashes\n  const normalizedPath =\n    path.endsWith('/') && path !== '/' ? path.slice(0, -1) : path;\n  const normalizedPattern =\n    pattern.endsWith('/') && pattern !== '/' ? pattern.slice(0, -1) : pattern;\n\n  // Split into segments\n  const pathSegments = normalizedPath.split('/').filter(Boolean);\n  const patternSegments = normalizedPattern.split('/').filter(Boolean);\n\n  // Support catch-all route: /* matches any path at any depth\n  if (patternSegments.length === 1 && patternSegments[0] === '*') {\n    // For multi-segment paths, preserve the leading slash\n    // For single-segment paths, return just the segment\n    return {\n      matched: true,\n      params: {\n        '*': pathSegments.length > 1 ? normalizedPath : pathSegments[0],\n      },\n    };\n  }\n\n  // Check if lengths match (wildcard segments still need to match one segment)\n  if (pathSegments.length !== patternSegments.length) {\n    return { matched: false, params: {} };\n  }\n\n  const params: Record<string, string> = {};\n\n  // Match each segment\n  for (let i = 0; i < patternSegments.length; i++) {\n    const patternSegment = patternSegments[i];\n    const pathSegment = pathSegments[i];\n\n    // Parameter: {paramName}\n    if (patternSegment.startsWith('{') && patternSegment.endsWith('}')) {\n      const paramName = patternSegment.slice(1, -1);\n      params[paramName] = decodeURIComponent(pathSegment);\n    } else if (patternSegment === '*') {\n      // Wildcard: match single segment\n      params['*'] = pathSegment;\n    } else if (patternSegment !== pathSegment) {\n      // Literal segment mismatch\n      return { matched: false, params: {} };\n    }\n  }\n\n  return { matched: true, params };\n}\n"],"mappings":"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","names":["isBulkCommitActive","evaluate","_g","k","isBulkCommitActive","parentChildren","totalKeyed","prev","dom","isBulkCommitActive","getSpecificity"]}