@askrjs/askr 0.0.50 → 0.0.52

package/dist/runtime/component-commit.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-commit.js","names":[],"sources":["../../src/runtime/component-commit.ts"],"sourcesContent":["import { isDevelopmentEnvironment } from '../common/env';\nimport { isPromiseLike } from '../common/promise';\nimport { logger } from '../dev/logger';\nimport { enqueueRuntimeTask, getRuntimeRenderer } from './access';\nimport {\n  beginLifecycleCommitBatch,\n  discardCommitOperations,\n  discardLifecycleCommitBatch,\n  executeCommittedLifecycleOperations,\n  flushLifecycleCommitBatch,\n} from './component-lifecycle';\nimport {\n  beginRenderTracking,\n  enterDomCommitScope,\n  restoreDomCommitScope,\n} from './component-scope';\nimport type { ContextFrame } from './context';\nimport { withContext } from './context';\nimport { incDevCounter, setDevValue } from './dev-namespace';\nimport { tryRuntimeFastLaneSync } from './fastlane';\nimport type { ComponentInstance } from './component-internal';\n\nexport interface ScheduledComponentCommitHost {\n  execute(instance: ComponentInstance): unknown | Promise<unknown>;\n  finalizeReadSubscriptions(instance: ComponentInstance): void;\n  warnUnusedStateReads(instance: ComponentInstance): void;\n  commitRenderedComponent(instance: ComponentInstance): void;\n}\n\nexport function runScheduledComponent(\n  instance: ComponentInstance,\n  host: ScheduledComponentCommitHost\n): void {\n  instance.notifyUpdate = instance._enqueueRun!;\n  beginRenderTracking(instance);\n  const domSnapshot = instance.target ? instance.target.innerHTML : '';\n\n  let result: unknown | Promise<unknown>;\n  try {\n    result = host.execute(instance);\n  } catch (err) {\n    discardCommitOperations(instance);\n    throw err;\n  }\n\n  if (isPromiseLike(result)) {\n    throw new Error(\n      'Async components are not supported. Components must be synchronous.'\n    );\n  }\n\n  try {\n    const used = tryRuntimeFastLaneSync(instance, result);\n    if (used) {\n      host.warnUnusedStateReads(instance);\n      return;\n    }\n  } catch (err) {\n    if (isDevelopmentEnvironment()) throw err;\n  }\n\n  enqueueRuntimeTask(() => {\n    if (!instance.target && instance._placeholder) {\n      commitPlaceholderReplacement(instance, result, host);\n      return;\n    }\n\n    if (instance.target) {\n      commitToTarget(instance, result, domSnapshot, host);\n    }\n  });\n}\n\nfunction commitPlaceholderReplacement(\n  instance: ComponentInstance,\n  result: unknown,\n  host: ScheduledComponentCommitHost\n): void {\n  if (result === null || result === undefined) {\n    host.finalizeReadSubscriptions(instance);\n    host.warnUnusedStateReads(instance);\n    host.commitRenderedComponent(instance);\n    return;\n  }\n\n  const placeholder = instance._placeholder!;\n  const parent = placeholder.parentNode;\n  if (!parent) {\n    logger.warn('[Askr] placeholder no longer in DOM, cannot render component');\n    return;\n  }\n\n  const renderer = getRuntimeRenderer();\n  const hostElement = document.createElement('div');\n  const executionFrame: ContextFrame = {\n    parent: instance.ownerFrame,\n    values: null,\n  };\n\n  const oldInstance = enterDomCommitScope(instance);\n  const lifecycleBatch = beginLifecycleCommitBatch();\n  try {\n    try {\n      withContext(executionFrame, () => {\n        renderer.evaluate(result, hostElement);\n      });\n      parent.replaceChild(hostElement, placeholder);\n    } catch (err) {\n      discardLifecycleCommitBatch(lifecycleBatch);\n      throw err;\n    }\n\n    instance.target = hostElement;\n    instance._placeholder = undefined;\n    (\n      hostElement as Element & {\n        __ASKR_INSTANCE?: ComponentInstance;\n      }\n    ).__ASKR_INSTANCE = instance;\n\n    flushLifecycleCommitBatch(lifecycleBatch);\n    host.finalizeReadSubscriptions(instance);\n    host.warnUnusedStateReads(instance);\n    host.commitRenderedComponent(instance);\n  } finally {\n    restoreDomCommitScope(oldInstance);\n  }\n}\n\nfunction commitToTarget(\n  instance: ComponentInstance,\n  result: unknown,\n  domSnapshot: string,\n  host: ScheduledComponentCommitHost\n): void {\n  const renderer = getRuntimeRenderer();\n  const target = instance.target!;\n  let oldChildren: Node[] = [];\n  let restoredOldChildren = false;\n\n  try {\n    const wasFirstMount = !instance.mounted;\n    const oldInstance = enterDomCommitScope(instance);\n    const executionFrame: ContextFrame = {\n      parent: instance.ownerFrame,\n      values: null,\n    };\n    oldChildren = Array.from(target.childNodes);\n\n    const lifecycleBatch = beginLifecycleCommitBatch();\n    try {\n      try {\n        withContext(executionFrame, () => {\n          renderer.evaluate(result, target, undefined, instance);\n        });\n      } catch (err) {\n        discardLifecycleCommitBatch(lifecycleBatch);\n        throw err;\n      }\n    } catch (err) {\n      cleanupFailedCommitChildren(renderer, target, oldChildren);\n      try {\n        incDevCounter('__DOM_REPLACE_COUNT');\n        setDevValue(\n          '__LAST_DOM_REPLACE_STACK_COMPONENT_RESTORE',\n          new Error().stack\n        );\n      } catch (devErr) {\n        void devErr;\n      }\n      target.replaceChildren(...oldChildren);\n      restoredOldChildren = true;\n      throw err;\n    } finally {\n      restoreDomCommitScope(oldInstance);\n    }\n\n    flushLifecycleCommitBatch(lifecycleBatch);\n    host.finalizeReadSubscriptions(instance);\n    host.warnUnusedStateReads(instance);\n    instance.mounted = true;\n    executeCommittedLifecycleOperations(instance, wasFirstMount);\n  } catch (renderError) {\n    discardCommitOperations(instance);\n    cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren);\n\n    try {\n      incDevCounter('__DOM_REPLACE_COUNT');\n      setDevValue(\n        '__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK',\n        new Error().stack\n      );\n      target.replaceChildren(...oldChildren);\n    } catch {\n      target.innerHTML = domSnapshot;\n    }\n\n    throw renderError;\n  }\n}\n\nfunction cleanupFailedCommitChildren(\n  renderer: ReturnType<typeof getRuntimeRenderer>,\n  target: Element,\n  oldChildren: Node[]\n): void {\n  try {\n    const newChildren = Array.from(target.childNodes);\n    const preservedChildren = new Set(oldChildren);\n    for (const node of newChildren) {\n      if (preservedChildren.has(node)) {\n        continue;\n      }\n      try {\n        renderer.cleanupInstancesUnder(node);\n      } catch (err) {\n        logger.warn('[Askr] error cleaning up failed commit children:', err);\n      }\n    }\n  } catch (err) {\n    void err;\n  }\n}\n\nfunction cleanupRollbackChildren(\n  renderer: ReturnType<typeof getRuntimeRenderer>,\n  target: Element,\n  oldChildren: Node[],\n  restoredOldChildren: boolean\n): void {\n  try {\n    const currentChildren = Array.from(target.childNodes);\n    const preservedChildren = restoredOldChildren ? new Set(oldChildren) : null;\n    for (const node of currentChildren) {\n      if (preservedChildren?.has(node)) {\n        continue;\n      }\n      try {\n        renderer.cleanupInstancesUnder(node);\n      } catch (err) {\n        logger.warn(\n          '[Askr] error cleaning up partial children during rollback:',\n          err\n        );\n      }\n    }\n  } catch (err) {\n    void err;\n  }\n}\n"],"mappings":"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"}

package/dist/runtime/component-contracts.js

@@ -1,5 +0,0 @@
-import { getCurrentInstance } from "./component-scope.js";
-import { cleanupComponent } from "./component-cleanup.js";
-import { captureInlineRenderSnapshot, createComponentInstance, mountInstanceInline, renderComponentInline, warnUnusedStateReads } from "./component-internal.js";
-import "./component.js";
-export { captureInlineRenderSnapshot, cleanupComponent, createComponentInstance, getCurrentInstance, mountInstanceInline, renderComponentInline, warnUnusedStateReads };

package/dist/runtime/component-internal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-internal.d.ts","names":[],"sources":["../../src/runtime/component-internal.ts"],"mappings":";;;;;;;;;UA2DiB,iBAAA;EACf,EAAA;EACA,EAAA,EAAI,iBAAA;EACJ,KAAA,EAAO,KAAA;EACP,MAAA,EAAQ,OAAA;EACR,cAAA,EAAgB,iBAAA;EAChB,WAAA;EACA,OAAA;EACA,eAAA,EAAiB,eAAA;EACjB,GAAA;EAEA,aAAA;EACA,WAAA,EAAa,KAAA;EACb,oBAAA;EACA,YAAA;EAEA,iBAAA;EACA,eAAA;EACA,WAAA;EACA,eAAA;EACA,oBAAA;EACA,mBAAA;EACA,eAAA,EAAiB,KAAA,6BACa,WAAA;EAE9B,gBAAA,EAAkB,KAAA,6BACY,WAAA;EAE9B,UAAA,EAAY,KAAA;EACZ,cAAA;EACA,mBAAA;EACA,gBAAA;EACA,UAAA,EAAY,YAAA;EACZ,MAAA;EAGA,mBAAA;EACA,eAAA;EACA,mBAAA,GAAsB,GAAA,CAAI,cAAA;EAC1B,0BAAA,GAA6B,GAAA,CAAI,cAAA;EACjC,gBAAA,GAAmB,GAAA,CAAI,cAAA;EACvB,kBAAA,GAAqB,GAAA;EAIrB,YAAA,GAAe,OAAA;EACf,iBAAA,GAAoB,GAAA,CAAI,eAAA;EACxB,kBAAA;IACE,KAAA;IACA,QAAA;IACA,QAAA;EAAA;AAAA;AAAA,iBAIY,uBAAA,CACd,EAAA,UACA,EAAA,EAAI,iBAAA,EACJ,KAAA,EAAO,KAAA,EACP,MAAA,EAAQ,OAAA,UACP,iBAAA;;;;;iBA6Ea,2BAAA,CAA4B,QAA2B,EAAjB,iBAAiB;AAAA,iBAIvD,sBAAA,CAAuB,SAA6B,EAAlB,kBAAkB;AAAA,iBAIpD,uBAAA,CAAwB,SAA6B,EAAlB,kBAAkB;AAAA,iBAIrD,uBAAA,CAAwB,QAA2B,EAAjB,iBAAiB;AAAA,iBAInD,mBAAA,CACd,QAAA,EAAU,iBAAA,EACV,MAAA,EAAQ,OAAO;;;;;;;;iBAuCD,qBAAA,IACd,QAAA,EAAU,iBAAA,EACV,eAAA,UACA,MAAA,QAAc,CAAA,GACb,CAAA;;;;;;iBA6Ba,qBAAA,CACd,QAAA,EAAU,iBAAA,aACC,OAAO;AAAA,iBAwCJ,oBAAA,CAAqB,QAA2B,EAAjB,iBAAiB;;;;;;iBAmGhD,gBAAA,CAAiB,QAA2B,EAAjB,iBAAiB;;;;;;;;;iBAmB5C,yBAAA,CAA0B,QAA2B,EAAjB,iBAAiB;;;;AAhVzD;AAIZ;iBAqVgB,cAAA,CAAe,QAA2B,EAAjB,iBAAiB"}

package/dist/runtime/component-internal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-internal.js","names":[],"sources":["../../src/runtime/component-internal.ts"],"sourcesContent":["/**\n * Component instance lifecycle management\n * Internal only — users never see this\n */\n\nimport { type State } from './state';\nimport { enqueueRuntimeTask } from './access';\nimport type { Props } from '../common/props';\nimport type { ComponentFunction } from '../common/component';\nimport {\n  // withContext is the sole primitive for context restoration\n  withContext,\n  type ContextFrame,\n} from './context';\nimport { type ReadableSource, finalizeReadableSubscriptions } from './readable';\nimport {\n  isDevelopmentEnvironment,\n  isProductionEnvironment,\n} from '../common/env';\nimport { logger } from '../dev/logger';\nimport { incDevCounter } from './dev-namespace';\nimport {\n  cleanupComponent,\n  registerOwnedChildScope,\n  unregisterOwnedChildScope,\n  type OwnedChildScope,\n} from './component-cleanup';\nimport { runScheduledComponent } from './component-commit';\nimport {\n  captureInlineRenderSnapshot as captureLifecycleInlineRenderSnapshot,\n  commitLifecycleForInstance,\n  commitRenderedComponent as commitRenderedLifecycleComponent,\n  discardCommitOperations,\n  finalizeInlineReadSubscriptions,\n  registerCommitOperationForInstance,\n  registerMountOperationForInstance,\n  type LifecycleOperation,\n} from './component-lifecycle';\nimport {\n  beginRenderTracking,\n  captureInlineComponentScope,\n  captureInlineRenderTracking,\n  clearRenderTracking,\n  enterComponentExecutionScope,\n  enterRenderScopedComponent,\n  exitComponentExecutionScope,\n  getCurrentComponentInstance,\n  getCurrentInstance,\n  getCurrentPortalScope,\n  getSignalForInstance,\n  resetRenderState,\n  restoreInlineComponentScope,\n  restoreInlineRenderTracking,\n  restoreRenderScopedComponent,\n} from './component-scope';\n\nexport type { ComponentFunction } from '../common/component';\nexport { cleanupComponent, registerOwnedChildScope, unregisterOwnedChildScope };\n\nexport interface ComponentInstance {\n  id: string;\n  fn: ComponentFunction;\n  props: Props;\n  target: Element | null;\n  parentInstance: ComponentInstance | null;\n  portalScope: object | null;\n  mounted: boolean;\n  abortController: AbortController | null; // Lazily created per-component abort lifecycle\n  ssr?: boolean; // Set to true for SSR temporary instances\n  // Opt-in strict cleanup mode: when true cleanup errors are aggregated and re-thrown\n  cleanupStrict?: boolean;\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 render-scoped hook indices (frozen after first render)\n  firstRenderComplete: boolean; // Flag to detect transition from first to subsequent renders\n  mountOperations: Array<\n    () => void | (() => void) | PromiseLike<void | (() => void)>\n  >; // Operations to run when component mounts\n  commitOperations: Array<\n    () => void | (() => void) | PromiseLike<void | (() => void)>\n  >; // Operations to run after a successful committed render\n  cleanupFns: Array<() => void>; // Cleanup functions to run on unmount\n  lifecycleSlots: unknown[]; // Render-scoped lifecycle primitive storage\n  lifecycleGeneration: number; // Invalidates async mount-operation settlement after disposal\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  _pendingReadSources?: Set<ReadableSource<unknown>>; // Readables read during the in-progress render\n  _pendingReadSourceVersions?: Map<ReadableSource<unknown>, number>; // Source versions captured during the in-progress render\n  _lastReadSources?: Set<ReadableSource<unknown>>; // Readables read during the last committed render\n  devWarningsEmitted?: Set<string>; // Dev-only warning dedupe for this instance\n\n  // Placeholder for null-returning components. When a component initially returns\n  // null, we create a comment placeholder so updates can replace it with content.\n  _placeholder?: Comment;\n  _ownedChildScopes?: Set<OwnedChildScope>;\n  errorBoundaryState?: {\n    error: unknown | null;\n    resetKey: unknown;\n    notified: boolean;\n  };\n}\n\nexport function createComponentInstance(\n  id: string,\n  fn: ComponentFunction,\n  props: Props,\n  target: Element | null\n): ComponentInstance {\n  const parentInstance = getCurrentInstance();\n  const portalScope = parentInstance?.portalScope ?? getCurrentPortalScope();\n  const instance: ComponentInstance = {\n    id,\n    fn,\n    props,\n    target,\n    parentInstance,\n    portalScope: portalScope ?? null,\n    mounted: false,\n    abortController: null,\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    commitOperations: [],\n    cleanupFns: [],\n    lifecycleSlots: [],\n    lifecycleGeneration: 0,\n    hasPendingUpdate: false,\n    ownerFrame: null, // Will be set by renderer when vnode is marked\n    ssr: false,\n    cleanupStrict: false,\n    isRoot: false,\n\n    // Render-tracking (for precise state subscriptions)\n    _currentRenderToken: undefined,\n    lastRenderToken: 0,\n    _pendingReadSources: undefined,\n    _pendingReadSourceVersions: undefined,\n    _lastReadSources: undefined,\n    devWarningsEmitted: undefined,\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    if (instance.notifyUpdate === null) {\n      return;\n    }\n    // Execute component run (will set up notifyUpdate before render)\n    runScheduledComponent(instance, {\n      execute: executeComponentSync,\n      finalizeReadSubscriptions,\n      warnUnusedStateReads,\n      commitRenderedComponent,\n    });\n  };\n\n  instance._enqueueRun = () => {\n    if (!instance.hasPendingUpdate) {\n      instance.hasPendingUpdate = true;\n      // Enqueue single run task (coalesces multiple writes)\n      enqueueRuntimeTask(instance._pendingRunTask!);\n    }\n  };\n\n  // Default state-driven updates enqueue the run task directly. Specialized\n  // runtimes (for example `For` item instances) can still override this hook.\n  instance._pendingFlushTask = instance._pendingRunTask;\n\n  return 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 */\nexport function captureInlineRenderSnapshot(instance: ComponentInstance): void {\n  captureLifecycleInlineRenderSnapshot(instance);\n}\n\nexport function registerMountOperation(operation: LifecycleOperation): void {\n  registerMountOperationForInstance(getCurrentComponentInstance(), operation);\n}\n\nexport function registerCommitOperation(operation: LifecycleOperation): void {\n  registerCommitOperationForInstance(getCurrentComponentInstance(), operation);\n}\n\nexport function commitRenderedComponent(instance: ComponentInstance): void {\n  commitRenderedLifecycleComponent(instance);\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      const host = target as Element & {\n        __ASKR_INSTANCE?: ComponentInstance;\n        __ASKR_INSTANCES?: ComponentInstance[];\n      };\n      const instances = host.__ASKR_INSTANCES ?? [];\n      const nextInstances = instances.filter((entry) => entry !== instance);\n      nextInstances.push(instance);\n      host.__ASKR_INSTANCES = nextInstances;\n      host.__ASKR_INSTANCE = nextInstances[0] ?? instance;\n    }\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  commitLifecycleForInstance(instance, wasFirstMount);\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 */\n\nexport function renderScopedComponent<T>(\n  instance: ComponentInstance,\n  startStateIndex: number,\n  render: () => T\n): T {\n  instance.notifyUpdate = instance._enqueueRun!;\n  resetRenderState(instance);\n  beginRenderTracking(instance);\n  const savedScope = enterRenderScopedComponent(instance, startStateIndex);\n\n  let didComplete = false;\n\n  try {\n    const executionFrame: ContextFrame = {\n      parent: instance.ownerFrame,\n      values: null,\n    };\n    const result = withContext(executionFrame, render);\n    didComplete = true;\n    return result;\n  } finally {\n    if (!didComplete) {\n      clearRenderTracking(instance);\n    }\n    restoreRenderScopedComponent(savedScope);\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 the scheduled commit helper.\n */\nexport function renderComponentInline(\n  instance: ComponentInstance\n): unknown | Promise<unknown> {\n  // Reused inline instances can cross renderer cleanup boundaries while their\n  // host node is retained. Make sure state writes still enqueue this instance.\n  instance.notifyUpdate = instance._enqueueRun!;\n\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 trackingSnapshot = captureInlineRenderTracking(instance);\n  const scopeSnapshot = captureInlineComponentScope();\n  const hadToken = trackingSnapshot.currentRenderToken !== undefined;\n\n  if (!hadToken) {\n    beginRenderTracking(instance);\n  }\n\n  try {\n    const result = executeComponentSync(instance);\n    // If we set the token for inline execution, finalize subscriptions now\n    // unless the parent DOM commit is still provisional. Renderer commit\n    // batches flush these reads only after DOM evaluation succeeds.\n    if (!hadToken) {\n      finalizeInlineReadSubscriptions(\n        instance,\n        instance._currentRenderToken!,\n        instance._pendingReadSources,\n        instance._pendingReadSourceVersions\n      );\n    }\n    commitRenderedComponent(instance);\n    return result;\n  } finally {\n    // Restore previous token/read states for nested inline render scenarios\n    restoreInlineRenderTracking(instance, trackingSnapshot);\n    restoreInlineComponentScope(scopeSnapshot);\n  }\n}\n\nexport function warnUnusedStateReads(instance: ComponentInstance): void {\n  for (let i = 0; i < instance.stateValues.length; i++) {\n    const state = instance.stateValues[i];\n    const hasCommittedUsage =\n      (state?._readers?.size ?? 0) > 0 ||\n      ((state as { _derivedSubscribers?: Set<unknown> } | undefined)\n        ?._derivedSubscribers?.size ?? 0) > 0;\n\n    if (\n      state &&\n      !state._hasBeenRead &&\n      !state._hasEverBeenRead &&\n      !hasCommittedUsage\n    ) {\n      try {\n        const name = instance.fn?.name || '<anonymous>';\n        warnInstanceOnce(\n          instance,\n          `unused-state:${i}`,\n          `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`\n        );\n      } catch {\n        warnInstanceOnce(\n          instance,\n          `unused-state:${i}`,\n          `[askr] Unused state variable detected. State should be read during render or removed.`\n        );\n      }\n    }\n  }\n}\n\nfunction executeComponentSync(\n  instance: ComponentInstance\n): unknown | Promise<unknown> {\n  resetRenderState(instance);\n  incDevCounter('componentRuns');\n  incDevCounter('componentReruns');\n\n  const savedPortalScope = enterComponentExecutionScope(instance);\n\n  let didComplete = false;\n\n  try {\n    // Track render time in dev mode\n    const renderStartTime = isDevelopmentEnvironment() ? Date.now() : 0;\n\n    // Create context object with abort signal\n    const context = {\n      get signal(): AbortSignal {\n        return getSignalForInstance(instance);\n      },\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\n    const renderTime = Date.now() - renderStartTime;\n    if (renderTime > 5) {\n      warnInstanceOnce(\n        instance,\n        'slow-render',\n        `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`\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    didComplete = true;\n    return result;\n  } finally {\n    if (!didComplete) {\n      discardCommitOperations(instance);\n    }\n    // Synchronous path: we did not push a fresh frame, so nothing to pop here.\n    exitComponentExecutionScope(savedPortalScope);\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  // Lazily recreate abort controller only when signal is actually requested.\n  instance.abortController = null;\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  enqueueRuntimeTask(instance._pendingRunTask!);\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  finalizeReadableSubscriptions(instance);\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\nfunction warnInstanceOnce(\n  instance: ComponentInstance,\n  key: string,\n  message: string\n): void {\n  if (isProductionEnvironment()) return;\n  const warnings = (instance.devWarningsEmitted ??= new Set());\n  if (warnings.has(key)) return;\n  warnings.add(key);\n  logger.warn(message);\n}\n"],"mappings":"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"}

package/dist/runtime/component-lifecycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-lifecycle.d.ts","names":[],"sources":["../../src/runtime/component-lifecycle.ts"],"mappings":";;;;;;KAYY,kBAAA,+BAGR,WAAW;AAAA,KAEV,yBAAA;EACH,QAAA,EAAU,iBAAiB;EAC3B,aAAA;AAAA;AAAA,KAGG,sBAAA;EACH,QAAA,EAAU,iBAAA;EACV,KAAA;EACA,kBAAA,EAAoB,GAAA,CAAI,cAAA;EACxB,yBAAA,EAA2B,GAAA,CAAI,cAAA;AAAA;AAAA,KAG5B,oBAAA;EACH,QAAA,EAAU,iBAAA;EACV,KAAA,EAAO,KAAA;EACP,UAAA,EAAY,YAAA;EACZ,WAAA;EACA,cAAA,EAAgB,iBAAA;EAChB,MAAA;AAAA;AAAA,KAGU,oBAAA;EACV,MAAA,EAAQ,oBAAA;EACR,OAAA,EAAS,yBAAA;EACT,iBAAA,EAAmB,GAAA,CAAI,iBAAA,EAAmB,yBAAA;EAC1C,WAAA,EAAa,sBAAA;EACb,qBAAA,EAAuB,GAAA,CAAI,iBAAA,EAAmB,sBAAA;EAC9C,eAAA,EAAiB,oBAAA;EACjB,yBAAA,EAA2B,GAAA,CAAI,iBAAA,EAAmB,oBAAA;EAClD,MAAA;AAAA;AAAA,iBAKc,yBAAA,IAA6B,oBAAoB;AAAA,iBAkFjD,2BAAA,CAA4B,QAA2B,EAAjB,iBAAiB;AAAA,iBAevD,+BAAA,CACd,QAAA,EAAU,iBAAA,EACV,KAAA,UACA,kBAAA,EAAoB,GAAA,CAAI,cAAA,wBACxB,yBAAA,EAA2B,GAAA,CAAI,cAAA;AAAA,iBAqBjB,yBAAA,CAA0B,KAA2B,EAApB,oBAAoB;AAAA,iBAsCrD,2BAAA,CAA4B,KAA2B,EAApB,oBAAoB;AAAA,iBAsBvD,iCAAA,CACd,QAAA,EAAU,iBAAA,SACV,SAAA,EAAW,kBAAkB;AAAA,iBAkBf,kCAAA,CACd,QAAA,EAAU,iBAAA,SACV,SAAA,EAAW,kBAAkB;AAAA,iBA6Ef,uBAAA,CAAwB,QAA2B,EAAjB,iBAAiB;AAAA,iBAInD,mCAAA,CACd,QAAA,EAAU,iBAAiB,EAC3B,aAAA;AAAA,iBAUc,0BAAA,CACd,QAAA,EAAU,iBAAiB,EAC3B,aAAA;AAAA,iBAcc,uBAAA,CAAwB,QAA2B,EAAjB,iBAAiB"}

package/dist/runtime/component-lifecycle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-lifecycle.js","names":[],"sources":["../../src/runtime/component-lifecycle.ts"],"sourcesContent":["import { isDevelopmentEnvironment } from '../common/env';\nimport { isPromiseLike } from '../common/promise';\nimport type { Props } from '../common/props';\nimport { logger } from '../dev/logger';\nimport type { ContextFrame } from './context';\nimport type { ComponentInstance } from './component-internal';\nimport { isBulkCommitActive } from './fastlane';\nimport {\n  type ReadableSource,\n  finalizeReadableSubscriptionsFromSnapshot,\n} from './readable';\n\nexport type LifecycleOperation = () =>\n  | void\n  | (() => void)\n  | PromiseLike<void | (() => void)>;\n\ntype LifecycleCommitBatchEntry = {\n  instance: ComponentInstance;\n  wasFirstMount: boolean;\n};\n\ntype ReadSubscriptionCommit = {\n  instance: ComponentInstance;\n  token: number;\n  pendingReadSources: Set<ReadableSource<unknown>> | undefined;\n  pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined;\n};\n\ntype InlineRenderSnapshot = {\n  instance: ComponentInstance;\n  props: Props;\n  ownerFrame: ContextFrame | null;\n  portalScope: object | null;\n  parentInstance: ComponentInstance | null;\n  isRoot: boolean | undefined;\n};\n\nexport type LifecycleCommitBatch = {\n  parent: LifecycleCommitBatch | null;\n  entries: LifecycleCommitBatchEntry[];\n  entriesByInstance: Map<ComponentInstance, LifecycleCommitBatchEntry>;\n  readCommits: ReadSubscriptionCommit[];\n  readCommitsByInstance: Map<ComponentInstance, ReadSubscriptionCommit>;\n  renderSnapshots: InlineRenderSnapshot[];\n  renderSnapshotsByInstance: Map<ComponentInstance, InlineRenderSnapshot>;\n  active: boolean;\n};\n\nlet currentLifecycleCommitBatch: LifecycleCommitBatch | null = null;\n\nexport function beginLifecycleCommitBatch(): LifecycleCommitBatch {\n  const batch: LifecycleCommitBatch = {\n    parent: currentLifecycleCommitBatch,\n    entries: [],\n    entriesByInstance: new Map(),\n    readCommits: [],\n    readCommitsByInstance: new Map(),\n    renderSnapshots: [],\n    renderSnapshotsByInstance: new Map(),\n    active: true,\n  };\n  currentLifecycleCommitBatch = batch;\n  return batch;\n}\n\nfunction closeLifecycleCommitBatch(batch: LifecycleCommitBatch): boolean {\n  if (!batch.active) {\n    return false;\n  }\n\n  batch.active = false;\n  currentLifecycleCommitBatch = batch.parent;\n  return true;\n}\n\nfunction enqueueLifecycleCommit(\n  batch: LifecycleCommitBatch,\n  instance: ComponentInstance,\n  wasFirstMount: boolean\n): void {\n  const existing = batch.entriesByInstance.get(instance);\n  if (existing) {\n    existing.wasFirstMount = existing.wasFirstMount || wasFirstMount;\n    return;\n  }\n\n  const entry = { instance, wasFirstMount };\n  batch.entriesByInstance.set(instance, entry);\n  batch.entries.push(entry);\n}\n\nfunction enqueueReadSubscriptionCommit(\n  batch: LifecycleCommitBatch,\n  instance: ComponentInstance,\n  token: number,\n  pendingReadSources: Set<ReadableSource<unknown>> | undefined,\n  pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined\n): void {\n  const existing = batch.readCommitsByInstance.get(instance);\n  const commit = existing ?? {\n    instance,\n    token,\n    pendingReadSources,\n    pendingReadSourceVersions,\n  };\n\n  commit.token = token;\n  commit.pendingReadSources = pendingReadSources\n    ? new Set(pendingReadSources)\n    : undefined;\n  commit.pendingReadSourceVersions = pendingReadSourceVersions\n    ? new Map(pendingReadSourceVersions)\n    : undefined;\n\n  if (!existing) {\n    batch.readCommitsByInstance.set(instance, commit);\n    batch.readCommits.push(commit);\n  }\n}\n\nfunction enqueueInlineRenderSnapshot(\n  batch: LifecycleCommitBatch,\n  snapshot: InlineRenderSnapshot\n): void {\n  if (batch.renderSnapshotsByInstance.has(snapshot.instance)) {\n    return;\n  }\n\n  batch.renderSnapshotsByInstance.set(snapshot.instance, snapshot);\n  batch.renderSnapshots.push(snapshot);\n}\n\nexport function captureInlineRenderSnapshot(instance: ComponentInstance): void {\n  if (!currentLifecycleCommitBatch?.active) {\n    return;\n  }\n\n  enqueueInlineRenderSnapshot(currentLifecycleCommitBatch, {\n    instance,\n    props: instance.props,\n    ownerFrame: instance.ownerFrame,\n    portalScope: instance.portalScope,\n    parentInstance: instance.parentInstance,\n    isRoot: instance.isRoot,\n  });\n}\n\nexport function finalizeInlineReadSubscriptions(\n  instance: ComponentInstance,\n  token: number,\n  pendingReadSources: Set<ReadableSource<unknown>> | undefined,\n  pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined\n): void {\n  if (currentLifecycleCommitBatch?.active) {\n    enqueueReadSubscriptionCommit(\n      currentLifecycleCommitBatch,\n      instance,\n      token,\n      pendingReadSources,\n      pendingReadSourceVersions\n    );\n    return;\n  }\n\n  finalizeReadableSubscriptionsFromSnapshot(\n    instance,\n    token,\n    pendingReadSources,\n    pendingReadSourceVersions\n  );\n}\n\nexport function flushLifecycleCommitBatch(batch: LifecycleCommitBatch): void {\n  if (!closeLifecycleCommitBatch(batch)) {\n    return;\n  }\n\n  if (batch.parent?.active) {\n    for (const snapshot of batch.renderSnapshots) {\n      enqueueInlineRenderSnapshot(batch.parent, snapshot);\n    }\n    for (const commit of batch.readCommits) {\n      enqueueReadSubscriptionCommit(\n        batch.parent,\n        commit.instance,\n        commit.token,\n        commit.pendingReadSources,\n        commit.pendingReadSourceVersions\n      );\n    }\n    for (const entry of batch.entries) {\n      enqueueLifecycleCommit(batch.parent, entry.instance, entry.wasFirstMount);\n    }\n    return;\n  }\n\n  for (const commit of batch.readCommits) {\n    finalizeReadableSubscriptionsFromSnapshot(\n      commit.instance,\n      commit.token,\n      commit.pendingReadSources,\n      commit.pendingReadSourceVersions\n    );\n  }\n\n  for (const entry of batch.entries) {\n    executeCommittedLifecycleOperations(entry.instance, entry.wasFirstMount);\n  }\n}\n\nexport function discardLifecycleCommitBatch(batch: LifecycleCommitBatch): void {\n  if (!closeLifecycleCommitBatch(batch)) {\n    return;\n  }\n\n  for (let index = batch.renderSnapshots.length - 1; index >= 0; index -= 1) {\n    const snapshot = batch.renderSnapshots[index]!;\n    snapshot.instance.props = snapshot.props;\n    snapshot.instance.ownerFrame = snapshot.ownerFrame;\n    snapshot.instance.portalScope = snapshot.portalScope;\n    snapshot.instance.parentInstance = snapshot.parentInstance;\n    snapshot.instance.isRoot = snapshot.isRoot;\n  }\n\n  for (const entry of batch.entries) {\n    if (entry.wasFirstMount) {\n      entry.instance.mountOperations = [];\n    }\n    discardCommitOperations(entry.instance);\n  }\n}\n\nexport function registerMountOperationForInstance(\n  instance: ComponentInstance | null,\n  operation: LifecycleOperation\n): void {\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 (isDevelopmentEnvironment()) {\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\nexport function registerCommitOperationForInstance(\n  instance: ComponentInstance | null,\n  operation: LifecycleOperation\n): void {\n  if (instance) {\n    if (isBulkCommitActive()) {\n      if (isDevelopmentEnvironment()) {\n        throw new Error(\n          'registerCommitOperation called during bulk commit fast-lane'\n        );\n      }\n      return;\n    }\n    instance.commitOperations.push(operation);\n  }\n}\n\nfunction settleLifecycleOperationResult(\n  instance: ComponentInstance,\n  lifecycleGeneration: number,\n  result: void | (() => void) | PromiseLike<void | (() => void)>\n): void {\n  if (isPromiseLike(result)) {\n    Promise.resolve(result).then(\n      (cleanup) => {\n        if (typeof cleanup === 'function') {\n          if (\n            instance.lifecycleGeneration === lifecycleGeneration &&\n            instance.mounted\n          ) {\n            instance.cleanupFns.push(cleanup);\n            return;\n          }\n\n          try {\n            cleanup();\n          } catch (err) {\n            logger.error('[Askr] async mount cleanup failed:', err);\n          }\n        }\n      },\n      (err) => {\n        logger.error('[Askr] async mount operation failed:', err);\n      }\n    );\n  } else if (typeof result === 'function') {\n    instance.cleanupFns.push(result);\n  }\n}\n\nfunction executeMountOperations(instance: ComponentInstance): void {\n  const mountOperations = instance.mountOperations;\n  if (mountOperations.length === 0) {\n    return;\n  }\n\n  const lifecycleGeneration = instance.lifecycleGeneration;\n\n  for (const operation of mountOperations) {\n    settleLifecycleOperationResult(instance, lifecycleGeneration, operation());\n  }\n  // Clear the operations array so they don't run again on subsequent renders\n  instance.mountOperations = [];\n}\n\nfunction executeCommitOperations(instance: ComponentInstance): void {\n  const commitOperations = instance.commitOperations;\n  if (commitOperations.length === 0) {\n    return;\n  }\n\n  instance.commitOperations = [];\n  const lifecycleGeneration = instance.lifecycleGeneration;\n\n  for (const operation of commitOperations) {\n    settleLifecycleOperationResult(instance, lifecycleGeneration, operation());\n  }\n}\n\nexport function discardCommitOperations(instance: ComponentInstance): void {\n  instance.commitOperations = [];\n}\n\nexport function executeCommittedLifecycleOperations(\n  instance: ComponentInstance,\n  wasFirstMount: boolean\n): void {\n  if (wasFirstMount && instance.mountOperations.length > 0) {\n    executeMountOperations(instance);\n  }\n  if (instance.commitOperations.length > 0) {\n    executeCommitOperations(instance);\n  }\n}\n\nexport function commitLifecycleForInstance(\n  instance: ComponentInstance,\n  wasFirstMount: boolean\n): void {\n  if (currentLifecycleCommitBatch) {\n    enqueueLifecycleCommit(\n      currentLifecycleCommitBatch,\n      instance,\n      wasFirstMount\n    );\n    return;\n  }\n\n  executeCommittedLifecycleOperations(instance, wasFirstMount);\n}\n\nexport function commitRenderedComponent(instance: ComponentInstance): void {\n  if (instance.mounted && instance.commitOperations.length > 0) {\n    commitLifecycleForInstance(instance, false);\n  }\n}\n"],"mappings":"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"}

package/dist/runtime/component-scope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-scope.d.ts","names":[],"sources":["../../src/runtime/component-scope.ts"],"mappings":";;;;KASK,sBAAA;EACH,QAAA,EAAU,iBAAiB;EAC3B,WAAA;EACA,UAAA;AAAA;AAAA,KAGG,2BAAA;EACH,QAAA,EAAU,iBAAiB;EAC3B,WAAA;AAAA;AAAA,KAGG,4BAAA;EACH,kBAAA;EACA,kBAAA,EAAoB,GAAA,CAAI,cAAA;EACxB,yBAAA,EAA2B,GAAA,CAAI,cAAA;AAAA;AAAA,iBA0CjB,2BAAA,IAA+B,iBAAiB;AAAA,iBAIhD,kBAAA,IAAsB,iBAAiB;AAAA,iBAIvC,2BAAA,CACd,QAAkC,EAAxB,iBAAiB;AAAA,iBAMb,qBAAA;AAAA,iBAIA,oBAAA,CAAqB,QAAA,EAAU,iBAAA,GAAoB,WAAW;;;;;;;;;iBAY9D,SAAA,IAAa,WAAW;AAAA,iBAUxB,gBAAA,CAAiB,QAA2B,EAAjB,iBAAiB;AAAA,iBAa5C,mBAAA,CAAoB,QAA2B,EAAjB,iBAAiB;AAAA,iBAM/C,mBAAA,CAAoB,QAA2B,EAAjB,iBAAiB;AAAA,iBAM/C,2BAAA,CACd,QAAA,EAAU,iBAAA,GACT,4BAA4B;AAAA,iBAQf,2BAAA,CACd,QAAA,EAAU,iBAAA,EACV,QAAA,EAAU,4BAA4B;AAAA,iBAOxB,0BAAA,CACd,QAAA,EAAU,iBAAA,EACV,eAAA,WACC,sBAAsB;AAAA,iBAQT,4BAAA,CACd,QAAgC,EAAtB,sBAAsB;AAAA,iBAKlB,2BAAA,IAA+B,2BAA2B;AAAA,iBAI1D,2BAAA,CACd,QAAqC,EAA3B,2BAA2B;AAAA,iBAMvB,4BAAA,CACd,QAA2B,EAAjB,iBAAiB;AAAA,iBASb,2BAAA,CACd,gBAA+B;AAAA,iBAMjB,mBAAA,CACd,QAAA,EAAU,iBAAA,GACT,iBAAiB;AAAA,iBAMJ,qBAAA,CACd,gBAA0C,EAAxB,iBAAiB;AAAA,iBAKrB,0BAAA,IAA8B,sBAAsB;AAAA,iBAOpD,4BAAA,CACd,QAAgC,EAAtB,sBAAsB;AAAA,iBAKlB,iBAAA;AAAA,iBAIA,cAAA,CACd,QAAA,EAAU,iBAAiB,EAC3B,QAAA;AAAA,iBAgCc,oBAAA;AAAA,iBAIA,eAAA;AAAA,iBAIA,aAAA,CAAc,KAAa"}

package/dist/runtime/component-scope.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-scope.js","names":[],"sources":["../../src/runtime/component-scope.ts"],"sourcesContent":["/**\n * Component render scope and hook cursor ownership.\n * Internal helpers in this module intentionally keep mutable render-scope\n * state out of component execution and cleanup orchestration.\n */\n\nimport type { ReadableSource } from './readable';\nimport type { ComponentInstance } from './component-internal';\n\ntype ComponentScopeSnapshot = {\n  instance: ComponentInstance | null;\n  portalScope: object | null;\n  stateIndex: number;\n};\n\ntype InstancePortalScopeSnapshot = {\n  instance: ComponentInstance | null;\n  portalScope: object | null;\n};\n\ntype InlineRenderTrackingSnapshot = {\n  currentRenderToken: number | undefined;\n  pendingReadSources: Set<ReadableSource<unknown>> | undefined;\n  pendingReadSourceVersions: Map<ReadableSource<unknown>, number> | undefined;\n};\n\nlet currentInstance: ComponentInstance | null = null;\nlet currentPortalScope: object | null = null;\nlet stateIndex = 0;\nlet globalRenderCounter = 0;\n\nfunction ensureAbortController(instance: ComponentInstance): AbortController {\n  let controller = instance.abortController;\n  if (!controller || controller.signal.aborted) {\n    controller = new AbortController();\n    instance.abortController = controller;\n  }\n  return controller;\n}\n\nfunction nextRenderToken(): number {\n  return ++globalRenderCounter;\n}\n\nfunction captureScope(): ComponentScopeSnapshot {\n  return {\n    instance: currentInstance,\n    portalScope: currentPortalScope,\n    stateIndex,\n  };\n}\n\nfunction restoreScope(snapshot: ComponentScopeSnapshot): void {\n  currentInstance = snapshot.instance;\n  currentPortalScope = snapshot.portalScope;\n  stateIndex = snapshot.stateIndex;\n}\n\nfunction captureInstancePortalScope(): InstancePortalScopeSnapshot {\n  return {\n    instance: currentInstance,\n    portalScope: currentPortalScope,\n  };\n}\n\nexport function getCurrentComponentInstance(): ComponentInstance | null {\n  return currentInstance;\n}\n\nexport function getCurrentInstance(): ComponentInstance | null {\n  return currentInstance;\n}\n\nexport function setCurrentComponentInstance(\n  instance: ComponentInstance | null\n): void {\n  currentInstance = instance;\n  currentPortalScope = instance?.portalScope ?? null;\n}\n\nexport function getCurrentPortalScope(): object | null {\n  return currentInstance?.portalScope ?? currentPortalScope;\n}\n\nexport function getSignalForInstance(instance: ComponentInstance): AbortSignal {\n  return ensureAbortController(instance).signal;\n}\n\n/**\n * Get the abort signal for the current component.\n *\n * The signal is guaranteed to be aborted when:\n * - Component unmounts\n * - Navigation occurs (different route)\n * - Parent is destroyed\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 getSignalForInstance(currentInstance);\n}\n\nexport function resetRenderState(instance: ComponentInstance): void {\n  instance.stateIndexCheck = -1;\n\n  for (const state of instance.stateValues) {\n    if (state) {\n      state._hasBeenRead = false;\n    }\n  }\n\n  instance._pendingReadSources = undefined;\n  instance._pendingReadSourceVersions = undefined;\n}\n\nexport function beginRenderTracking(instance: ComponentInstance): void {\n  instance._currentRenderToken = nextRenderToken();\n  instance._pendingReadSources = undefined;\n  instance._pendingReadSourceVersions = undefined;\n}\n\nexport function clearRenderTracking(instance: ComponentInstance): void {\n  instance._pendingReadSources = undefined;\n  instance._pendingReadSourceVersions = undefined;\n  instance._currentRenderToken = undefined;\n}\n\nexport function captureInlineRenderTracking(\n  instance: ComponentInstance\n): InlineRenderTrackingSnapshot {\n  return {\n    currentRenderToken: instance._currentRenderToken,\n    pendingReadSources: instance._pendingReadSources,\n    pendingReadSourceVersions: instance._pendingReadSourceVersions,\n  };\n}\n\nexport function restoreInlineRenderTracking(\n  instance: ComponentInstance,\n  snapshot: InlineRenderTrackingSnapshot\n): void {\n  instance._currentRenderToken = snapshot.currentRenderToken;\n  instance._pendingReadSources = snapshot.pendingReadSources;\n  instance._pendingReadSourceVersions = snapshot.pendingReadSourceVersions;\n}\n\nexport function enterRenderScopedComponent(\n  instance: ComponentInstance,\n  startStateIndex: number\n): ComponentScopeSnapshot {\n  const savedScope = captureScope();\n  currentInstance = instance;\n  currentPortalScope = instance.portalScope ?? savedScope.portalScope;\n  stateIndex = startStateIndex;\n  return savedScope;\n}\n\nexport function restoreRenderScopedComponent(\n  snapshot: ComponentScopeSnapshot\n): void {\n  restoreScope(snapshot);\n}\n\nexport function captureInlineComponentScope(): InstancePortalScopeSnapshot {\n  return captureInstancePortalScope();\n}\n\nexport function restoreInlineComponentScope(\n  snapshot: InstancePortalScopeSnapshot\n): void {\n  currentInstance = snapshot.instance;\n  currentPortalScope = snapshot.portalScope;\n}\n\nexport function enterComponentExecutionScope(\n  instance: ComponentInstance\n): object | null {\n  const savedPortalScope = currentPortalScope;\n  currentInstance = instance;\n  currentPortalScope = instance.portalScope ?? savedPortalScope;\n  stateIndex = 0;\n  return savedPortalScope;\n}\n\nexport function exitComponentExecutionScope(\n  savedPortalScope: object | null\n): void {\n  currentInstance = null;\n  currentPortalScope = savedPortalScope;\n}\n\nexport function enterDomCommitScope(\n  instance: ComponentInstance\n): ComponentInstance | null {\n  const previousInstance = currentInstance;\n  currentInstance = instance;\n  return previousInstance;\n}\n\nexport function restoreDomCommitScope(\n  previousInstance: ComponentInstance | null\n): void {\n  currentInstance = previousInstance;\n}\n\nexport function clearCurrentComponentScope(): ComponentScopeSnapshot {\n  const savedScope = captureScope();\n  currentInstance = null;\n  currentPortalScope = null;\n  return savedScope;\n}\n\nexport function restoreCurrentComponentScope(\n  snapshot: ComponentScopeSnapshot\n): void {\n  restoreScope(snapshot);\n}\n\nexport function getNextStateIndex(): number {\n  return stateIndex++;\n}\n\nexport function claimHookIndex(\n  instance: ComponentInstance,\n  hookName: string\n): number {\n  const index = getNextStateIndex();\n\n  if (index < instance.stateIndexCheck) {\n    throw new Error(\n      `Hook index violation: ${hookName}() call at index ${index}, ` +\n        `but previously saw index ${instance.stateIndexCheck}. ` +\n        `This happens when render-scoped hooks are called conditionally (inside if/for/etc). ` +\n        `Move all ${hookName}() calls to the top level of your component function, ` +\n        `before any conditionals.`\n    );\n  }\n\n  instance.stateIndexCheck = index;\n\n  if (instance.firstRenderComplete) {\n    if (instance.expectedStateIndices[index] !== index) {\n      throw new Error(\n        `Hook order violation: ${hookName}() called at index ${index}, ` +\n          `but this index was not in the first render's sequence [${instance.expectedStateIndices.join(', ')}]. ` +\n          `This usually means ${hookName}() is inside a conditional or loop. ` +\n          `Move all render-scoped hooks to the top level of your component function.`\n      );\n    }\n  } else {\n    instance.expectedStateIndices.push(index);\n  }\n\n  return index;\n}\n\nexport function getCurrentStateIndex(): number {\n  return stateIndex;\n}\n\nexport function resetStateIndex(): void {\n  stateIndex = 0;\n}\n\nexport function setStateIndex(value: number): void {\n  stateIndex = value;\n}\n"],"mappings":"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"}

package/dist/runtime/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../../src/runtime/context.ts"],"mappings":";;;;KA6BY,UAAA;AAAA,KAEP,UAAA,GAAa,eAAe;AAAA,KAC5B,oBAAA,GAAuB,UAAA,UAAoB,UAAU;AAAA,UAEzC,OAAA;EAAA,SACN,GAAA,EAAK,UAAA;EAAA,SACL,YAAA,EAAc,CAAA;EAAA,SAEd,KAAA,GAAQ,KAAA;IACf,KAAA,EAAO,CAAA;IACP,QAAA,GAAW,oBAAA;EAAA,MACP,UAAA;AAAA;AAAA,UAGS,YAAA;EACf,MAAA,EAAQ,YAAA;EAER,MAAA,EAAQ,GAAA,CAAI,UAAA;AAAA;AAAA,cAID,oBAAA;AAAA,iBAQG,oBAAA,CAAqB,IAAA,YAAgB,YAAY;AAAA,iBASjD,yBAAA,CACd,IAAA,WACA,KAAA,EAAO,YAAY,EACnB,SAAA;AAAA,iBAsEc,6BAAA,CACd,IAAA,WACA,KAAA,EAAO,YAAY,SACnB,SAAA;AAvGgB;AAGlB;;;;;;;;;;AAHkB,iBAsKF,WAAA,IAAe,KAAA,EAAO,YAAA,SAAqB,EAAA,QAAU,CAAA,GAAI,CAAA;;;;AAhKjD;AAIxB;;;;AAAmE;iBA+KnD,wBAAA,IACd,KAAA,EAAO,YAAA,SACP,EAAA,QAAU,CAAA,GACT,CAAA;AAAA,iBAYa,aAAA,IAAiB,YAAA,EAAc,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA,iBAiD3C,WAAA,IAAe,OAAA,EAAS,OAAA,CAAQ,CAAA,IAAK,CAAA;;AAvOY;AASjE;;iBA6WgB,gBAAA,IAAoB,YAAY;;;;;iBAgBhC,eAAA;;AA1XG;AAsEnB;iBA6TgB,sBAAA,IAA0B,YAAY;;;;;iBAQtC,qBAAA,IAAyB,YAAY"}

package/dist/runtime/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","names":[],"sources":["../../src/runtime/context.ts"],"sourcesContent":["/**\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 '../common/jsx';\nimport { ELEMENT_TYPE, STATIC_CHILDREN } from '../common/jsx';\nimport type { Props } from '../common/props';\nimport type { RenderableChild } from '../common/vnode';\nimport { getCurrentComponentInstance } from './component';\nimport type { ComponentInstance } from './component';\n\nexport type ContextKey = symbol;\n\ntype Renderable = RenderableChild;\ntype ContextScopeChildren = Renderable | (() => Renderable);\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: {\n    value: T;\n    children?: ContextScopeChildren;\n  }) => 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\ntype ContextFrameCarrier = {\n  [CONTEXT_FRAME_SYMBOL]?: ContextFrame;\n};\n\nconst vnodeContextFrames = new WeakMap<object, ContextFrame>();\n\nexport function getVNodeContextFrame(node: unknown): ContextFrame | undefined {\n  if (typeof node !== 'object' || node === null) {\n    return undefined;\n  }\n\n  const objectNode = node as ContextFrameCarrier;\n  return vnodeContextFrames.get(node) ?? objectNode[CONTEXT_FRAME_SYMBOL];\n}\n\nexport function markVNodeWithContextFrame(\n  node: unknown,\n  frame: ContextFrame,\n  overwrite = false\n): void {\n  if (typeof node !== 'object' || node === null) {\n    return;\n  }\n\n  if (!overwrite && getVNodeContextFrame(node)) {\n    return;\n  }\n\n  const objectNode = node as ContextFrameCarrier;\n  if (Object.prototype.hasOwnProperty.call(node, CONTEXT_FRAME_SYMBOL)) {\n    try {\n      objectNode[CONTEXT_FRAME_SYMBOL] = frame;\n      return;\n    } catch {\n      // Fall through to WeakMap metadata when the symbol slot is readonly.\n    }\n  }\n\n  if (Object.isExtensible(node)) {\n    try {\n      Object.defineProperty(node, CONTEXT_FRAME_SYMBOL, {\n        value: frame,\n        writable: true,\n        enumerable: true,\n        configurable: true,\n      });\n      return;\n    } catch {\n      // Fall through to WeakMap metadata for exotic objects/proxies.\n    }\n  }\n\n  vnodeContextFrames.set(node, frame);\n}\n\nfunction isVNodeLike(value: unknown): boolean {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    return false;\n  }\n\n  const objectValue = value as Record<string | symbol, unknown>;\n  if (objectValue.$$typeof === ELEMENT_TYPE) {\n    return true;\n  }\n\n  return (\n    'type' in objectValue &&\n    ('props' in objectValue || 'children' in objectValue)\n  );\n}\n\nfunction markContextPropValue(\n  value: unknown,\n  frame: ContextFrame,\n  overwrite: boolean\n): void {\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      markContextPropValue(item, frame, overwrite);\n    }\n    return;\n  }\n\n  if (isVNodeLike(value)) {\n    markVNodeTreeWithContextFrame(value, frame, overwrite);\n  }\n}\n\nexport function markVNodeTreeWithContextFrame(\n  node: unknown,\n  frame: ContextFrame | null,\n  overwrite = false\n): unknown {\n  if (!frame) return node;\n\n  if (Array.isArray(node)) {\n    for (const child of node) {\n      markVNodeTreeWithContextFrame(child, frame, overwrite);\n    }\n    return node;\n  }\n\n  if (typeof node !== 'object' || node === null) {\n    return node;\n  }\n\n  markVNodeWithContextFrame(node, frame, overwrite);\n\n  const objectNode = node as Record<string | symbol, unknown>;\n  const props =\n    typeof objectNode.props === 'object' && objectNode.props !== null\n      ? (objectNode.props as Record<string, unknown>)\n      : null;\n  const children = (props?.children ?? objectNode.children) as unknown;\n\n  if (Array.isArray(children)) {\n    for (const child of children) {\n      markVNodeTreeWithContextFrame(child, frame, overwrite);\n    }\n  } else if (children) {\n    markVNodeTreeWithContextFrame(children, frame, overwrite);\n  }\n\n  if (props) {\n    for (const key in props) {\n      if (key !== 'children') {\n        markContextPropValue(props[key], frame, overwrite);\n      }\n    }\n  }\n\n  return node;\n}\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: {\n      value: T;\n      children?: ContextScopeChildren;\n    }): JSXElement => {\n      const value = props.value;\n      // Scope component: creates a new frame and renders children within it\n      return {\n        $$typeof: ELEMENT_TYPE,\n        type: ContextScopeComponent,\n        props: { key, value, children: props.children },\n        key: null,\n      } as JSXElement;\n    },\n  };\n}\n\nfunction preserveStaticChildrenMarker(\n  source: readonly unknown[],\n  target: unknown[]\n): unknown[] {\n  if (\n    (\n      source as {\n        [STATIC_CHILDREN]?: boolean;\n      }\n    )[STATIC_CHILDREN] === true\n  ) {\n    Object.defineProperty(target, STATIC_CHILDREN, {\n      value: true,\n      enumerable: false,\n      configurable: true,\n    });\n  }\n\n  return target;\n}\n\nfunction isPresentRenderable(\n  value: Renderable | null | undefined\n): value is Renderable {\n  return value !== null && value !== undefined && value !== false;\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 ContextScopeChildren;\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  // Helper: create a function-child invoker node (centralized cast)\n  function createFunctionChildInvoker(\n    fn: () => Renderable,\n    frame: ContextFrame,\n    owner: ComponentInstance | null\n  ): Renderable {\n    return {\n      type: ContextFunctionChildInvoker,\n      props: { fn, __frame: frame, __owner: owner },\n    } as unknown as Renderable;\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 preserveStaticChildrenMarker(\n      children,\n      children.map((child) => {\n        if (typeof child === 'function') {\n          return createFunctionChildInvoker(\n            child as () => Renderable,\n            newFrame,\n            getCurrentComponentInstance()\n          );\n        }\n        return markWithFrame(child, newFrame);\n      })\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 createFunctionChildInvoker(\n      children as () => Renderable,\n      newFrame,\n      getCurrentComponentInstance()\n    );\n  } else if (isPresentRenderable(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  return markVNodeTreeWithContextFrame(node, frame, true) as Renderable;\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  __owner?: ComponentInstance | null;\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 (isPresentRenderable(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"],"mappings":"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"}

package/dist/runtime/control.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control.d.ts","names":[],"sources":["../../src/runtime/control.ts"],"mappings":";;;;;;UASiB,WAAA;EACf,GAAA;EACA,MAAA,QAAc,KAAK;EACnB,IAAA;AAAA;AAAA,UAGQ,sBAAA;EACR,SAAA;EACA,WAAA,EAAa,UAAA;EACb,YAAA,EAAc,KAAA;EACd,gBAAA,EAAkB,IAAA;EAClB,cAAA,EAAgB,iBAAA;EAChB,sBAAA;EACA,yBAAA;AAAA;AAAA,UAGe,SAAA,SAAkB,sBAAA;EACjC,IAAA;EACA,aAAA,EAAe,UAAA;EACf,cAAA,SAAuB,KAAA;EACvB,YAAA,IAAgB,KAAA,cAAmB,KAAA,WAAgB,KAAA;EACnD,aAAA;EACA,WAAA,EAAa,UAAA;AAAA;AAAA,UAGE,SAAA,SAAkB,sBAAA;EACjC,IAAA;EACA,QAAA,SAAiB,KAAA;EACjB,OAAA,EAAS,WAAA;AAAA;AAAA,KAGC,oBAAA,GAAuB,QAAA,YAAoB,SAAA,GAAY,SAAA;AAAA,iBAkCnD,eAAA,CACd,KAAA,WACA,YAAA,EAAc,SAAA,kBACd,cAAA,EAAgB,SAAA,qBACf,SAAA;AAAA,iBAkBa,iBAAA,CAAkB,KAAA,EAAO,SAAA,GAAY,KAAK;AAAA,iBAiD1C,uBAAA,CAAwB,KAAgB,EAAT,SAAS;AAAA,iBAUxC,eAAA,CACd,OAAA,EAAS,WAAA,IACT,QAAA,SAAiB,KAAA,WAChB,SAAA;AAAA,iBAea,iBAAA,CAAkB,KAAA,EAAO,SAAA,GAAY,KAAK;AAAA,iBAiC1C,uBAAA,CAAwB,KAAgB,EAAT,SAAS"}

package/dist/runtime/control.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"control.js","names":[],"sources":["../../src/runtime/control.ts"],"sourcesContent":["import type { VNode } from '../common/vnode';\nimport {\n  createChildScope,\n  disposeChildScope,\n  type ChildScope,\n} from './child-scope';\nimport { getCurrentInstance, type ComponentInstance } from './component';\nimport type { ForState } from './for';\n\nexport interface MatchBranch {\n  key: string | number;\n  render: () => VNode;\n  when: unknown;\n}\n\ninterface BranchControlStateBase {\n  activeKey: string | number | null;\n  activeScope: ChildScope | null;\n  activeVNodes: VNode[];\n  lastRemovedNodes: Node[];\n  parentInstance: ComponentInstance | null;\n  _enqueueBoundaryCommit?: (() => void) | null;\n  _hasPendingBoundaryCommit?: boolean;\n}\n\nexport interface ShowState extends BranchControlStateBase {\n  kind: 'show';\n  fallbackScope: ChildScope | null;\n  renderFallback: (() => VNode) | null;\n  renderTruthy: ((value: unknown) => VNode) | (() => VNode);\n  selectedValue: unknown;\n  truthyScope: ChildScope | null;\n}\n\nexport interface CaseState extends BranchControlStateBase {\n  kind: 'case';\n  fallback: (() => VNode) | null;\n  matches: MatchBranch[];\n}\n\nexport type ControlBoundaryState = ForState<unknown> | ShowState | CaseState;\n\nconst SHOW_TRUTHY_KEY = '__show-truthy__';\nconst SHOW_FALLBACK_KEY = '__show-fallback__';\nconst CASE_FALLBACK_KEY = '__case-fallback__';\n\nfunction disposeBranchScope(\n  state: BranchControlStateBase,\n  scope: ChildScope | null\n): void {\n  if (!scope) {\n    return;\n  }\n  const removedDom = scope.dom;\n  disposeChildScope(scope);\n  if (removedDom) {\n    state.lastRemovedNodes.push(removedDom);\n  }\n}\n\nfunction createBranchScope(\n  state: BranchControlStateBase,\n  key: string | number\n): ChildScope {\n  return createChildScope(state.parentInstance, key, () => {\n    if (state._enqueueBoundaryCommit) {\n      state._enqueueBoundaryCommit();\n      return;\n    }\n\n    state.parentInstance?._enqueueRun?.();\n  });\n}\n\nexport function createShowState(\n  value: unknown,\n  renderTruthy: ShowState['renderTruthy'],\n  renderFallback: ShowState['renderFallback']\n): ShowState {\n  return {\n    kind: 'show',\n    activeKey: null,\n    activeScope: null,\n    activeVNodes: [],\n    fallbackScope: null,\n    lastRemovedNodes: [],\n    parentInstance: getCurrentInstance(),\n    _enqueueBoundaryCommit: null,\n    _hasPendingBoundaryCommit: false,\n    renderFallback,\n    renderTruthy,\n    selectedValue: value,\n    truthyScope: null,\n  };\n}\n\nexport function evaluateShowState(state: ShowState): VNode[] {\n  state.lastRemovedNodes = [];\n\n  if (state.selectedValue) {\n    if (state.fallbackScope) {\n      disposeBranchScope(state, state.fallbackScope);\n      state.fallbackScope = null;\n    }\n\n    const truthyScope =\n      state.truthyScope ?? createBranchScope(state, SHOW_TRUTHY_KEY);\n    state.truthyScope = truthyScope;\n    state.activeScope = truthyScope;\n    state.activeKey = SHOW_TRUTHY_KEY;\n\n    const vnode = truthyScope.render(() =>\n      state.renderTruthy(state.selectedValue)\n    );\n    state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];\n    return state.activeVNodes;\n  }\n\n  if (state.truthyScope) {\n    disposeBranchScope(state, state.truthyScope);\n    state.truthyScope = null;\n  }\n\n  if (!state.renderFallback) {\n    if (state.fallbackScope) {\n      disposeBranchScope(state, state.fallbackScope);\n      state.fallbackScope = null;\n    }\n    state.activeKey = null;\n    state.activeScope = null;\n    state.activeVNodes = [];\n    return state.activeVNodes;\n  }\n\n  const fallbackScope =\n    state.fallbackScope ?? createBranchScope(state, SHOW_FALLBACK_KEY);\n  state.fallbackScope = fallbackScope;\n  state.activeScope = fallbackScope;\n  state.activeKey = SHOW_FALLBACK_KEY;\n\n  const vnode = fallbackScope.render(state.renderFallback);\n  state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];\n  return state.activeVNodes;\n}\n\nexport function clearShowDomUpdateState(state: ShowState): void {\n  if (state.truthyScope) {\n    state.truthyScope.needsDomUpdate = false;\n  }\n  if (state.fallbackScope) {\n    state.fallbackScope.needsDomUpdate = false;\n  }\n  state.lastRemovedNodes = [];\n}\n\nexport function createCaseState(\n  matches: MatchBranch[],\n  fallback: (() => VNode) | null\n): CaseState {\n  return {\n    kind: 'case',\n    activeKey: null,\n    activeScope: null,\n    activeVNodes: [],\n    fallback,\n    lastRemovedNodes: [],\n    matches,\n    parentInstance: getCurrentInstance(),\n    _enqueueBoundaryCommit: null,\n    _hasPendingBoundaryCommit: false,\n  };\n}\n\nexport function evaluateCaseState(state: CaseState): VNode[] {\n  state.lastRemovedNodes = [];\n\n  const selectedMatch =\n    state.matches.find((candidate) => Boolean(candidate.when)) ?? null;\n  const nextKey =\n    selectedMatch?.key ?? (state.fallback ? CASE_FALLBACK_KEY : null);\n\n  if (nextKey === null) {\n    if (state.activeScope) {\n      disposeBranchScope(state, state.activeScope);\n    }\n    state.activeKey = null;\n    state.activeScope = null;\n    state.activeVNodes = [];\n    return state.activeVNodes;\n  }\n\n  if (state.activeScope && state.activeKey !== nextKey) {\n    disposeBranchScope(state, state.activeScope);\n    state.activeScope = null;\n  }\n\n  const activeScope = state.activeScope ?? createBranchScope(state, nextKey);\n  state.activeKey = nextKey;\n  state.activeScope = activeScope;\n\n  const renderBranch = selectedMatch?.render ?? state.fallback;\n  const vnode = renderBranch ? activeScope.render(renderBranch) : null;\n  state.activeVNodes = vnode == null || vnode === false ? [] : [vnode];\n  return state.activeVNodes;\n}\n\nexport function clearCaseDomUpdateState(state: CaseState): void {\n  if (state.activeScope) {\n    state.activeScope.needsDomUpdate = false;\n  }\n  state.lastRemovedNodes = [];\n}\n"],"mappings":"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"}

package/dist/runtime/derive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"derive.d.ts","names":[],"sources":["../../src/runtime/derive.ts"],"mappings":";;;;UAmBiB,OAAA,YAAmB,cAAA,CAAe,CAAA;EAAA,IAC7C,CAAA;AAAA;AAAA,KAkBD,cAAA;EACH,KAAA,EAAO,CAAA;EACP,OAAA;EACA,KAAA,GAAQ,KAAA;AAAA,IACN,mBAAA;AAAA,iBAgMY,MAAA,OAAa,EAAA,QAAU,IAAA,GAAO,OAAA,CAAQ,IAAA;AAAA,iBAEtC,MAAA,YACd,MAAA,EAAQ,cAAA,CAAe,GAAA,IAAO,GAAA,UAAa,GAAA,GAC3C,GAAA,GAAM,KAAA,EAAO,GAAA,KAAQ,IAAA,GACpB,OAAA,CAAQ,IAAA"}

package/dist/runtime/derive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"derive.js","names":[],"sources":["../../src/runtime/derive.ts"],"sourcesContent":["import {\n  claimHookIndex,\n  getCurrentInstance,\n  type ComponentInstance,\n} from './component';\nimport { enqueueRuntimeLane, getRuntimeFlushVersion } from './access';\nimport {\n  clearDerivedDependencySubscriptions,\n  markReadableDerivedSubscribersDirty,\n  markReactivePropsDirtySource,\n  notifyReadableReaders,\n  recordReadableRead,\n  syncDerivedDependencySubscriptions,\n  type DerivedSubscriber,\n  type ReadableSource,\n  withDerivedReadTracking,\n} from './readable';\nimport { isSnapshotSource, type SnapshotSourceBrand } from './snapshot-source';\n\nexport interface Derived<T> extends ReadableSource<T> {\n  (): T;\n}\n\ninterface DerivedCell<T> extends Derived<T>, DerivedSubscriber {\n  _owner: ComponentInstance;\n  _hookIndex: number;\n  _compute: () => T;\n  _value: T;\n  _hasValue: boolean;\n  _dirty: boolean;\n  _scheduled: boolean;\n  _evaluating: boolean;\n  _lastRecomputeFlushVersion: number;\n  _sources: Set<ReadableSource<unknown>>;\n  _pendingDependencySources?: Set<ReadableSource<unknown>>;\n  _cleanup(): void;\n}\n\ntype SnapshotSource<T> = {\n  value: T | null;\n  pending?: boolean;\n  error?: Error | null;\n} & SnapshotSourceBrand;\n\nconst deriveCells = new WeakMap<\n  ComponentInstance,\n  Map<number, DerivedCell<unknown>>\n>();\nconst dirtyDerivedCells = new Set<DerivedCell<unknown>>();\nlet hasPendingDerivedFlush = false;\n\nfunction getDeriveStore(\n  instance: ComponentInstance\n): Map<number, DerivedCell<unknown>> {\n  let store = deriveCells.get(instance);\n  if (!store) {\n    store = new Map();\n    deriveCells.set(instance, store);\n  }\n  return store;\n}\n\nfunction markDerivedCellDirty(cell: DerivedCell<unknown>): void {\n  cell._dirty = true;\n  if (cell._scheduled) {\n    return;\n  }\n\n  cell._scheduled = true;\n  dirtyDerivedCells.add(cell);\n\n  if (!hasPendingDerivedFlush) {\n    hasPendingDerivedFlush = true;\n    enqueueRuntimeLane('derived', flushDirtyDerivedCells);\n  }\n}\n\nfunction flushDirtyDerivedCells(): void {\n  hasPendingDerivedFlush = false;\n\n  if (dirtyDerivedCells.size === 0) {\n    return;\n  }\n\n  const pending = dirtyDerivedCells.values();\n  let next = pending.next();\n\n  while (!next.done) {\n    const cell = next.value as DerivedCell<unknown>;\n    dirtyDerivedCells.delete(cell);\n    cell._scheduled = false;\n    if (!cell._dirty) {\n      next = pending.next();\n      continue;\n    }\n    recomputeDerivedCell(cell, true);\n    next = pending.next();\n  }\n}\n\nfunction recomputeDerivedCell<T>(\n  cell: DerivedCell<T>,\n  notifyDownstream: boolean\n): T {\n  if (!cell._dirty && cell._hasValue) {\n    return cell._value;\n  }\n\n  if (cell._evaluating) {\n    throw new Error('derive() cannot read itself recursively');\n  }\n\n  cell._evaluating = true;\n  cell._dirty = false;\n  cell._pendingDependencySources = new Set();\n\n  const prevSources = cell._sources;\n  let nextValue: T;\n\n  try {\n    nextValue = withDerivedReadTracking(cell, cell._compute);\n  } catch (error) {\n    cell._dirty = true;\n    cell._pendingDependencySources = undefined;\n    throw error;\n  } finally {\n    cell._evaluating = false;\n  }\n\n  const nextSources = cell._pendingDependencySources ?? new Set();\n  cell._pendingDependencySources = undefined;\n  syncDerivedDependencySubscriptions(cell, prevSources, nextSources);\n  cell._sources = nextSources;\n\n  const valueChanged = !cell._hasValue || !Object.is(cell._value, nextValue);\n  cell._hasValue = true;\n  cell._value = nextValue;\n  cell._lastRecomputeFlushVersion = getRuntimeFlushVersion();\n\n  if (valueChanged && notifyDownstream) {\n    markReadableDerivedSubscribersDirty(cell);\n    markReactivePropsDirtySource(cell);\n    notifyReadableReaders(cell);\n  }\n\n  return cell._value;\n}\n\nfunction createDerivedCell<T>(\n  instance: ComponentInstance,\n  hookIndex: number,\n  compute: () => T\n): DerivedCell<T> {\n  const cell = function derivedGetter(): T {\n    recordReadableRead(cell as DerivedCell<T>);\n    return recomputeDerivedCell(\n      cell as DerivedCell<T>,\n      (cell as DerivedCell<T>)._scheduled\n    );\n  } as DerivedCell<T>;\n\n  cell._owner = instance;\n  cell._hookIndex = hookIndex;\n  cell._compute = compute;\n  cell._value = undefined as T;\n  cell._hasValue = false;\n  cell._dirty = true;\n  cell._scheduled = false;\n  cell._evaluating = false;\n  cell._lastRecomputeFlushVersion = -1;\n  cell._sources = new Set();\n  cell._markDirty = () => {\n    markDerivedCellDirty(cell);\n  };\n  cell._cleanup = () => {\n    cell._scheduled = false;\n    cell._dirty = false;\n    cell._hasValue = false;\n    dirtyDerivedCells.delete(cell);\n    clearDerivedDependencySubscriptions(cell, cell._sources);\n    cell._derivedSubscribers?.clear();\n    cell._readers?.clear();\n  };\n\n  (instance.cleanupFns ??= []).push(() => {\n    cell._cleanup();\n    deriveCells.get(instance)?.delete(hookIndex);\n  });\n\n  return cell;\n}\n\nfunction getOrCreateDerivedCell<T>(\n  instance: ComponentInstance,\n  hookIndex: number,\n  compute: () => T\n): DerivedCell<T> {\n  const store = getDeriveStore(instance);\n  const existing = store.get(hookIndex) as DerivedCell<T> | undefined;\n  if (existing) {\n    existing._compute = compute;\n    if (existing._lastRecomputeFlushVersion !== getRuntimeFlushVersion()) {\n      existing._dirty = true;\n    }\n    return existing;\n  }\n\n  const created = createDerivedCell(instance, hookIndex, compute);\n  store.set(hookIndex, created as DerivedCell<unknown>);\n  return created;\n}\n\nfunction createMappedSelector<TIn, TOut>(\n  source: SnapshotSource<TIn> | TIn | (() => TIn),\n  map: (value: TIn) => TOut\n): () => TOut | null {\n  return () => {\n    let value: TIn;\n    if (typeof source === 'function') {\n      value = (source as () => TIn)();\n    } else if (isSnapshotSource(source)) {\n      value = (source as SnapshotSource<TIn>).value ?? (source as TIn);\n    } else {\n      value = source as TIn;\n    }\n\n    if (value == null) {\n      return null;\n    }\n\n    return map(value);\n  };\n}\n\nexport function derive<TOut>(fn: () => TOut): Derived<TOut>;\n\nexport function derive<TIn, TOut>(\n  source: SnapshotSource<TIn> | TIn | (() => TIn),\n  map: (value: TIn) => TOut\n): Derived<TOut | null>;\n\nexport function derive<TIn, TOut>(\n  source: SnapshotSource<TIn> | TIn | (() => TIn),\n  map?: (value: TIn) => TOut\n): Derived<TOut | null> | Derived<TIn> {\n  const instance = getCurrentInstance();\n  if (!instance) {\n    throw new Error(\n      'derive() can only be called during component render execution. ' +\n        'Move derive() calls to the top level of your component function.'\n    );\n  }\n\n  const hookIndex = claimHookIndex(instance, 'derive');\n  const compute =\n    map === undefined\n      ? () => (source as () => TIn)()\n      : createMappedSelector(source, map);\n\n  const cell = getOrCreateDerivedCell(\n    instance,\n    hookIndex,\n    compute as () => TOut | null | TIn\n  );\n  recomputeDerivedCell(cell, false);\n  return cell as Derived<TOut | null> | Derived<TIn>;\n}\n"],"mappings":"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"}

package/dist/runtime/dev-namespace.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-namespace.js","names":[],"sources":["../../src/runtime/dev-namespace.ts"],"sourcesContent":["/**\n * Dev-only namespace helpers for diagnostics\n *\n * Centralizes the repetitive globalThis.__ASKR__ access pattern\n * used throughout runtime for dev-mode diagnostics.\n */\n\nimport { isProductionEnvironment } from '../common/env';\n\ntype DevNamespace = Record<string, unknown>;\n\n/**\n * Get or create the __ASKR__ dev namespace on globalThis.\n * Returns empty object in production to avoid allocations.\n */\nexport function getDevNamespace(): DevNamespace {\n  if (isProductionEnvironment()) return {};\n  try {\n    const g = globalThis as unknown as Record<string, DevNamespace>;\n    if (!g.__ASKR__) g.__ASKR__ = {};\n    return g.__ASKR__;\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Set a value in the dev namespace (no-op in production).\n */\nexport function setDevValue(key: string, value: unknown): void {\n  if (isProductionEnvironment()) return;\n  try {\n    getDevNamespace()[key] = value;\n  } catch {\n    // ignore\n  }\n}\n\n/**\n * Get a value from the dev namespace (returns undefined in production).\n */\nexport function getDevValue<T>(key: string): T | undefined {\n  if (isProductionEnvironment()) return undefined;\n  try {\n    return getDevNamespace()[key] as T | undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Delete a value from the dev namespace (no-op in production).\n */\nexport function deleteDevValue(key: string): void {\n  if (isProductionEnvironment()) return;\n  try {\n    delete getDevNamespace()[key];\n  } catch {\n    // ignore\n  }\n}\n\n/**\n * Increment a counter in the dev namespace (no-op in production).\n * Safely handles non-number values by resetting to 1.\n */\nexport function incDevCounter(key: string): void {\n  if (isProductionEnvironment()) return;\n  try {\n    const ns = getDevNamespace();\n    const prev = typeof ns[key] === 'number' ? (ns[key] as number) : 0;\n    ns[key] = prev + 1;\n  } catch {\n    // ignore\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAeA,SAAgB,kBAAgC;CAC9C,IAAI,wBAAwB,GAAG,OAAO,CAAC;CACvC,IAAI;EACF,MAAM,IAAI;EACV,IAAI,CAAC,EAAE,UAAU,EAAE,WAAW,CAAC;EAC/B,OAAO,EAAE;CACX,QAAQ;EACN,OAAO,CAAC;CACV;AACF;;;;AAKA,SAAgB,YAAY,KAAa,OAAsB;CAC7D,IAAI,wBAAwB,GAAG;CAC/B,IAAI;EACF,gBAAgB,CAAC,CAAC,OAAO;CAC3B,QAAQ,CAER;AACF;;;;AAKA,SAAgB,YAAe,KAA4B;CACzD,IAAI,wBAAwB,GAAG,OAAO;CACtC,IAAI;EACF,OAAO,gBAAgB,CAAC,CAAC;CAC3B,QAAQ;EACN;CACF;AACF;;;;;AAkBA,SAAgB,cAAc,KAAmB;CAC/C,IAAI,wBAAwB,GAAG;CAC/B,IAAI;EACF,MAAM,KAAK,gBAAgB;EAE3B,GAAG,QADU,OAAO,GAAG,SAAS,WAAY,GAAG,OAAkB,KAChD;CACnB,QAAQ,CAER;AACF"}

package/dist/runtime/effect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect.d.ts","names":[],"sources":["../../src/runtime/effect.ts"],"mappings":";;;;UA4CiB,iBAAA;EACf,IAAA,EAAM,aAAA;EACN,OAAA,IAAW,CAAA;EACX,MAAA,CAAO,KAAA,EAAO,CAAA,EAAG,aAAA,EAAe,CAAA;EAChC,MAAA,CAAO,aAAA,EAAe,CAAA,EAAG,SAAA,EAAW,CAAA;EACpC,WAAA,EAAa,GAAA,CAAI,cAAA;EACjB,QAAA;EACA,QAAA;EACA,SAAA,EAAW,CAAA;EACX,OAAA,EAAS,KAAA;AAAA;AAAA,UAGM,uBAAA;EACf,OAAA;EACA,aAAA,CAAc,WAAA,QAAmB,CAAC;EAClC,KAAA;AAAA;AAAA,UAGe,8BAAA;EACf,IAAA,EAAM,aAAA;EACN,OAAA,QAAe,CAAA;EACf,MAAA,GAAS,KAAA,EAAO,CAAA,EAAG,aAAA,EAAe,CAAA;EAClC,MAAA,IAAU,aAAA,EAAe,CAAA,EAAG,SAAA,EAAW,CAAA;EACvC,OAAA,IAAW,KAAA;AAAA;AAAA,iBA2KG,iCAAA,CACd,MAA+B,EAAvB,cAAc;AAAA,iBAmCR,uBAAA,IACd,OAAA,EAAS,8BAAA,CAA+B,CAAA,IACvC,uBAAA,CAAwB,CAAA"}

package/dist/runtime/effect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect.js","names":[],"sources":["../../src/runtime/effect.ts"],"sourcesContent":["import { incDevCounter } from './dev-namespace';\nimport { type ReadableSource, withFineGrainedReadTracking } from './readable';\nimport { enqueueRuntimeLane } from './access';\nimport type { SchedulerLane } from './scheduler';\n\ntype EffectRegistry = WeakMap<\n  ReadableSource<unknown>,\n  Set<FineGrainedEffect<unknown>>\n>;\n\ntype EffectFlushSets = Record<SchedulerLane, Set<FineGrainedEffect<unknown>>>;\n\ntype EffectPendingFlushState = Record<SchedulerLane, boolean>;\ntype EffectLaneDirtyState = Record<SchedulerLane, boolean>;\n\nconst effectSources: EffectRegistry = new WeakMap();\nconst dirtyEffectsByLane: EffectFlushSets = {\n  derived: new Set(),\n  component: new Set(),\n  reactive: new Set(),\n  post: new Set(),\n};\nconst hasPendingLaneFlush: EffectPendingFlushState = {\n  derived: false,\n  component: false,\n  reactive: false,\n  post: false,\n};\n\nconst dirtyLaneState: EffectLaneDirtyState = {\n  derived: false,\n  component: false,\n  reactive: false,\n  post: false,\n};\n\nconst MAX_EFFECT_RUNS_PER_FLUSH = 50;\nconst LANE_FLUSH_TASKS: Record<SchedulerLane, () => void> = {\n  derived: () => flushLaneEffects('derived'),\n  component: () => flushLaneEffects('component'),\n  reactive: () => flushLaneEffects('reactive'),\n  post: () => flushLaneEffects('post'),\n};\n\nexport interface FineGrainedEffect<T> {\n  lane: SchedulerLane;\n  compute(): T;\n  commit(value: T, previousValue: T | undefined): void;\n  equals(previousValue: T, nextValue: T): boolean;\n  readSources: Set<ReadableSource<unknown>>;\n  isActive: boolean;\n  hasValue: boolean;\n  lastValue: T | undefined;\n  onError?(error: unknown): void;\n}\n\nexport interface FineGrainedEffectHandle<T> {\n  cleanup(): void;\n  updateCompute(nextCompute: () => T): void;\n  flush(): void;\n}\n\nexport interface CreateFineGrainedEffectOptions<T> {\n  lane: SchedulerLane;\n  compute: () => T;\n  commit: (value: T, previousValue: T | undefined) => void;\n  equals?: (previousValue: T, nextValue: T) => boolean;\n  onError?: (error: unknown) => void;\n}\n\nfunction registerEffectSource(\n  source: ReadableSource<unknown>,\n  effect: FineGrainedEffect<unknown>\n): void {\n  let effects = effectSources.get(source);\n  if (!effects) {\n    effects = new Set();\n    effectSources.set(source, effects);\n  }\n  effects.add(effect);\n}\n\nfunction unregisterEffectSource(\n  source: ReadableSource<unknown>,\n  effect: FineGrainedEffect<unknown>\n): void {\n  effectSources.get(source)?.delete(effect);\n}\n\nfunction clearEffectSubscriptions(effect: FineGrainedEffect<unknown>): void {\n  for (const source of effect.readSources) {\n    unregisterEffectSource(source, effect);\n  }\n  effect.readSources.clear();\n}\n\nfunction normalizeNextSources(\n  previousSources: Set<ReadableSource<unknown>>,\n  pendingSources: Set<ReadableSource<unknown>>\n): Set<ReadableSource<unknown>> {\n  if (previousSources.size === pendingSources.size) {\n    let same = true;\n    for (const source of previousSources) {\n      if (!pendingSources.has(source)) {\n        same = false;\n        break;\n      }\n    }\n\n    if (same) {\n      return previousSources;\n    }\n  }\n\n  return new Set(pendingSources);\n}\n\nfunction evaluateEffect<T>(effect: FineGrainedEffect<T>): {\n  value: T;\n  nextSources: Set<ReadableSource<unknown>>;\n} {\n  const pendingSources = new Set<ReadableSource<unknown>>();\n\n  incDevCounter('effectRuns');\n  const value = withFineGrainedReadTracking(pendingSources, () =>\n    effect.compute()\n  );\n  const nextSources = normalizeNextSources(effect.readSources, pendingSources);\n  return { value, nextSources };\n}\n\nfunction commitEffectSubscriptions(\n  effect: FineGrainedEffect<unknown>,\n  nextSources: Set<ReadableSource<unknown>>\n): void {\n  const previousSources = effect.readSources;\n\n  if (previousSources === nextSources) {\n    return;\n  }\n\n  for (const source of previousSources) {\n    if (!nextSources.has(source)) {\n      unregisterEffectSource(source, effect);\n    }\n  }\n\n  for (const source of nextSources) {\n    if (!previousSources.has(source)) {\n      registerEffectSource(source, effect);\n    }\n  }\n\n  effect.readSources = nextSources;\n}\n\nfunction commitEffectResult<T>(\n  effect: FineGrainedEffect<T>,\n  value: T,\n  nextSources: Set<ReadableSource<unknown>>\n): void {\n  const previousValue = effect.lastValue;\n  const shouldCommit =\n    !effect.hasValue || !effect.equals(previousValue as T, value);\n\n  if (shouldCommit) {\n    effect.commit(value, effect.hasValue ? previousValue : undefined);\n  }\n\n  commitEffectSubscriptions(effect, nextSources);\n  effect.lastValue = value;\n  effect.hasValue = true;\n}\n\nfunction flushLaneEffects(lane: SchedulerLane): void {\n  hasPendingLaneFlush[lane] = false;\n\n  const effects = dirtyEffectsByLane[lane];\n  if (effects.size === 0) {\n    return;\n  }\n\n  const pending = effects.values();\n  const effectRuns = new Map<FineGrainedEffect<unknown>, number>();\n  let next = pending.next();\n\n  while (!next.done) {\n    const effect = next.value as FineGrainedEffect<unknown>;\n    effects.delete(effect);\n    if (!effect.isActive) {\n      next = pending.next();\n      continue;\n    }\n\n    const runCount = (effectRuns.get(effect) ?? 0) + 1;\n    effectRuns.set(effect, runCount);\n    if (runCount > MAX_EFFECT_RUNS_PER_FLUSH) {\n      const error = new Error(\n        `[Askr] fine-grained effect exceeded ${MAX_EFFECT_RUNS_PER_FLUSH} runs in one flush. Likely reactive cycle.`\n      );\n      if (effect.onError) {\n        effect.onError(error);\n      } else {\n        throw error;\n      }\n      next = pending.next();\n      continue;\n    }\n\n    try {\n      const { value, nextSources } = evaluateEffect(effect);\n      commitEffectResult(effect, value, nextSources);\n    } catch (error) {\n      effect.onError?.(error);\n    }\n\n    next = pending.next();\n  }\n}\n\nfunction scheduleLaneFlush(lane: SchedulerLane): void {\n  if (hasPendingLaneFlush[lane]) {\n    return;\n  }\n\n  hasPendingLaneFlush[lane] = true;\n  enqueueRuntimeLane(lane, LANE_FLUSH_TASKS[lane]);\n}\n\nfunction unscheduleEffect(effect: FineGrainedEffect<unknown>): void {\n  dirtyEffectsByLane[effect.lane].delete(effect);\n}\n\nfunction recomputeEffectNow<T>(effect: FineGrainedEffect<T>): void {\n  const { value, nextSources } = evaluateEffect(effect);\n  commitEffectResult(effect, value, nextSources);\n}\n\nexport function markFineGrainedEffectsDirtySource(\n  source: ReadableSource<unknown>\n): void {\n  const effects = effectSources.get(source);\n  if (!effects || effects.size === 0) {\n    return;\n  }\n\n  dirtyLaneState.derived = false;\n  dirtyLaneState.component = false;\n  dirtyLaneState.reactive = false;\n  dirtyLaneState.post = false;\n\n  for (const effect of effects) {\n    if (!effect.isActive) {\n      continue;\n    }\n    const lane = effect.lane;\n    dirtyEffectsByLane[lane].add(effect);\n    dirtyLaneState[lane] = true;\n  }\n\n  if (dirtyLaneState.derived) {\n    scheduleLaneFlush('derived');\n  }\n  if (dirtyLaneState.component) {\n    scheduleLaneFlush('component');\n  }\n  if (dirtyLaneState.reactive) {\n    scheduleLaneFlush('reactive');\n  }\n  if (dirtyLaneState.post) {\n    scheduleLaneFlush('post');\n  }\n}\n\nexport function createFineGrainedEffect<T>(\n  options: CreateFineGrainedEffectOptions<T>\n): FineGrainedEffectHandle<T> {\n  const effect: FineGrainedEffect<T> = {\n    lane: options.lane,\n    compute: options.compute,\n    commit: options.commit,\n    equals: options.equals ?? Object.is,\n    readSources: new Set(),\n    isActive: true,\n    hasValue: false,\n    lastValue: undefined,\n    onError: options.onError,\n  };\n\n  recomputeEffectNow(effect);\n\n  return {\n    cleanup(): void {\n      if (!effect.isActive) {\n        return;\n      }\n\n      effect.isActive = false;\n      unscheduleEffect(effect);\n      clearEffectSubscriptions(effect);\n    },\n\n    updateCompute(nextCompute: () => T): void {\n      if (!effect.isActive) {\n        return;\n      }\n\n      effect.compute = nextCompute;\n      unscheduleEffect(effect);\n      recomputeEffectNow(effect);\n    },\n\n    flush(): void {\n      if (!effect.isActive) {\n        return;\n      }\n\n      unscheduleEffect(effect);\n      recomputeEffectNow(effect);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/runtime/events.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.js","names":[],"sources":["../../src/runtime/events.ts"],"sourcesContent":["/**\n * Event delegation system for Askr\n *\n * Provides efficient event handling by attaching listeners to a container\n * instead of individual elements. This significantly reduces memory usage\n * and improves performance when many elements have the same event type.\n *\n * Delegated handling is enabled by default. Tests and internal runtime code\n * can still disable or re-enable it when they need to exercise both modes.\n */\n\nimport { runRuntimeHandlerScope } from './access';\nimport { logger } from '../dev/logger';\nimport { incrementPerfMetric } from './perf-metrics';\nimport { incDevCounter } from './dev-namespace';\n\nexport interface DelegatedEventMap {\n  click: MouseEvent;\n  dblclick: MouseEvent;\n  mousedown: MouseEvent;\n  mouseup: MouseEvent;\n  mouseover: MouseEvent;\n  mouseout: MouseEvent;\n  mousemove: MouseEvent;\n  focus: FocusEvent;\n  blur: FocusEvent;\n  input: InputEvent;\n  change: Event;\n  keydown: KeyboardEvent;\n  keyup: KeyboardEvent;\n  keypress: KeyboardEvent;\n  submit: Event;\n  scroll: Event;\n  wheel: WheelEvent;\n  touchstart: TouchEvent;\n  touchend: TouchEvent;\n  touchmove: TouchEvent;\n  touchcancel: TouchEvent;\n}\n\nconst DELEGATED_EVENTS: (keyof DelegatedEventMap)[] = [\n  'click',\n  'dblclick',\n  'mousedown',\n  'mouseup',\n  'mouseover',\n  'mouseout',\n  'mousemove',\n  'focus',\n  'blur',\n  'input',\n  'change',\n  'keydown',\n  'keyup',\n  'keypress',\n  'submit',\n  'scroll',\n  'wheel',\n  'touchstart',\n  'touchend',\n  'touchmove',\n  'touchcancel',\n];\n\ninterface DelegatedHandler {\n  handler: EventListener;\n  original: EventListener;\n  element: Element;\n  container: Element;\n  eventName: string;\n  options?: AddEventListenerOptions;\n}\n\ntype DelegatedHandlerStore = DelegatedHandler | Map<string, DelegatedHandler>;\n\nconst delegatedHandlers = new WeakMap<Element, DelegatedHandlerStore>();\n\nlet eventDelegationEnabled = true;\nlet defaultContainer: Element | null = null;\nlet globalDelegationContainer: Element | null = null;\nconst containerDelegatedListeners = new Map<\n  Element,\n  Map<string, EventListener>\n>();\nconst containerDelegatedListenerUsage = new Map<Element, Map<string, number>>();\n\nexport function isEventDelegationEnabled(): boolean {\n  return eventDelegationEnabled;\n}\n\nexport function disableEventDelegation(): void {\n  eventDelegationEnabled = false;\n  cleanupAllDelegatedListeners();\n}\n\nexport function enableEventDelegation(container?: Element): void {\n  eventDelegationEnabled = true;\n  if (container) {\n    defaultContainer = container;\n  }\n}\n\nexport function setGlobalDelegationContainer(container: Element): void {\n  globalDelegationContainer = container;\n}\n\nfunction cleanupAllDelegatedListeners(): void {\n  for (const [container, listeners] of containerDelegatedListeners) {\n    for (const [eventName, handler] of listeners) {\n      container.removeEventListener(eventName, handler);\n    }\n  }\n  containerDelegatedListeners.clear();\n  containerDelegatedListenerUsage.clear();\n}\n\nfunction incrementContainerListenerUsage(\n  container: Element,\n  eventName: string\n): void {\n  let usage = containerDelegatedListenerUsage.get(container);\n  if (!usage) {\n    usage = new Map();\n    containerDelegatedListenerUsage.set(container, usage);\n  }\n  usage.set(eventName, (usage.get(eventName) ?? 0) + 1);\n}\n\nfunction decrementContainerListenerUsage(entry: DelegatedHandler): void {\n  const usage = containerDelegatedListenerUsage.get(entry.container);\n  if (!usage) {\n    return;\n  }\n\n  const nextCount = (usage.get(entry.eventName) ?? 0) - 1;\n  if (nextCount > 0) {\n    usage.set(entry.eventName, nextCount);\n    return;\n  }\n\n  usage.delete(entry.eventName);\n  const listeners = containerDelegatedListeners.get(entry.container);\n  const listener = listeners?.get(entry.eventName);\n  if (listener) {\n    entry.container.removeEventListener(entry.eventName, listener);\n    listeners?.delete(entry.eventName);\n  }\n\n  if (listeners?.size === 0) {\n    containerDelegatedListeners.delete(entry.container);\n  }\n  if (usage.size === 0) {\n    containerDelegatedListenerUsage.delete(entry.container);\n  }\n}\n\nfunction getDelegationContainer(): Element | null {\n  if (globalDelegationContainer) return globalDelegationContainer;\n  if (defaultContainer) return defaultContainer;\n  if (typeof document !== 'undefined') return document.body;\n  return null;\n}\n\nfunction attachDelegatedListener(\n  container: Element,\n  element: Element,\n  eventName: string,\n  handler: EventListener,\n  originalHandler: EventListener,\n  options?: AddEventListenerOptions\n): void {\n  const hadHandler = !!getDelegatedHandlerForElement(element, eventName);\n\n  if (!containerDelegatedListeners.has(container)) {\n    containerDelegatedListeners.set(container, new Map());\n  }\n  const containerListeners = containerDelegatedListeners.get(container)!;\n\n  if (!containerListeners.has(eventName)) {\n    const delegatedHandler = (e: Event) => {\n      const target = e.target as Element;\n      if (!target) return;\n\n      runRuntimeHandlerScope(() => {\n        let current: Element | null = target;\n        while (current && current !== container) {\n          incrementPerfMetric('delegatedAncestorHops');\n          const store = delegatedHandlers.get(current);\n          const entry = !store\n            ? undefined\n            : store instanceof Map\n              ? store.get(eventName)\n              : store.eventName === eventName\n                ? store\n                : undefined;\n          if (entry) {\n            try {\n              entry.handler(e);\n            } catch (error) {\n              logger.error('[Askr] Delegated event error:', error);\n            }\n          }\n\n          if (e.cancelBubble) {\n            break;\n          }\n\n          current = current.parentElement;\n        }\n      }, 'sync');\n    };\n\n    const passiveOptions = getPassiveOptions(eventName);\n    const listenerOptions = passiveOptions ?? options;\n\n    container.addEventListener(eventName, delegatedHandler, listenerOptions);\n    containerListeners.set(eventName, delegatedHandler);\n  }\n\n  setDelegatedHandlerForElement(element, {\n    handler,\n    original: originalHandler,\n    element,\n    container,\n    eventName,\n    options,\n  });\n  if (!hadHandler) {\n    incrementContainerListenerUsage(container, eventName);\n  }\n}\n\nfunction setDelegatedHandlerForElement(\n  element: Element,\n  entry: DelegatedHandler\n): void {\n  const existing = delegatedHandlers.get(element);\n  if (!existing) {\n    delegatedHandlers.set(element, entry);\n    return;\n  }\n\n  if (existing instanceof Map) {\n    existing.set(entry.eventName, entry);\n    return;\n  }\n\n  if (existing.eventName === entry.eventName) {\n    delegatedHandlers.set(element, entry);\n    return;\n  }\n\n  const next = new Map<string, DelegatedHandler>();\n  next.set(existing.eventName, existing);\n  next.set(entry.eventName, entry);\n  delegatedHandlers.set(element, next);\n}\n\nfunction getPassiveOptions(\n  eventName: string\n): AddEventListenerOptions | undefined {\n  if (\n    eventName === 'wheel' ||\n    eventName === 'scroll' ||\n    eventName.startsWith('touch')\n  ) {\n    return { passive: true };\n  }\n  return undefined;\n}\n\nexport function addDelegatedListener(\n  element: Element,\n  eventName: string,\n  handler: EventListener,\n  originalHandler: EventListener,\n  options?: AddEventListenerOptions\n): void {\n  if (!eventDelegationEnabled) return;\n\n  const container = getDelegationContainer();\n  if (!container) return;\n\n  incDevCounter('listenerAdds');\n\n  attachDelegatedListener(\n    container,\n    element,\n    eventName,\n    handler,\n    originalHandler,\n    options\n  );\n}\n\nexport function updateDelegatedListener(\n  element: Element,\n  eventName: string,\n  handler: EventListener,\n  originalHandler: EventListener,\n  options?: AddEventListenerOptions\n): boolean {\n  const existing = getDelegatedHandlerForElement(element, eventName);\n  if (!existing) {\n    return false;\n  }\n\n  const container = getDelegationContainer();\n  if (\n    !container ||\n    existing.container !== container ||\n    !containerDelegatedListeners.get(existing.container)?.has(eventName)\n  ) {\n    removeDelegatedListener(element, eventName);\n    return false;\n  }\n\n  existing.handler = handler;\n  existing.original = originalHandler;\n  existing.options = options;\n  return true;\n}\n\nexport function removeDelegatedListener(\n  element: Element,\n  eventName: string\n): void {\n  const existing = delegatedHandlers.get(element);\n  if (!existing) {\n    return;\n  }\n\n  if (existing instanceof Map) {\n    if (existing.has(eventName)) {\n      incDevCounter('listenerRemoves');\n      decrementContainerListenerUsage(existing.get(eventName)!);\n    }\n    existing.delete(eventName);\n    if (existing.size === 0) {\n      delegatedHandlers.delete(element);\n      return;\n    }\n    if (existing.size === 1) {\n      const only = existing.values().next().value as DelegatedHandler;\n      delegatedHandlers.set(element, only);\n    }\n    return;\n  }\n\n  if (existing.eventName === eventName) {\n    incDevCounter('listenerRemoves');\n    decrementContainerListenerUsage(existing);\n    delegatedHandlers.delete(element);\n  }\n}\n\nexport function getDelegatedHandlerForElement(\n  element: Element,\n  eventName: string\n): DelegatedHandler | undefined {\n  const store = delegatedHandlers.get(element);\n  if (!store) return undefined;\n  if (store instanceof Map) return store.get(eventName);\n  return store.eventName === eventName ? store : undefined;\n}\n\nexport function getDelegatedHandlersForElement(\n  element: Element\n): Map<string, DelegatedHandler> | undefined {\n  const store = delegatedHandlers.get(element);\n  if (!store) return undefined;\n  if (store instanceof Map) return store;\n  return new Map([[store.eventName, store]]);\n}\n\nexport function hasDelegatedHandler(\n  element: Element,\n  eventName: string\n): boolean {\n  return getDelegatedHandlerForElement(element, eventName) !== undefined;\n}\n\nexport function clearDelegatedHandlersForElement(element: Element): void {\n  const existing = delegatedHandlers.get(element);\n  if (existing instanceof Map) {\n    for (const entry of existing.values()) {\n      decrementContainerListenerUsage(entry);\n    }\n  } else if (existing) {\n    decrementContainerListenerUsage(existing);\n  }\n  delegatedHandlers.delete(element);\n}\n\nexport function getDelegatedEventNames(): readonly (keyof DelegatedEventMap)[] {\n  return DELEGATED_EVENTS;\n}\n\nexport function isDelegatedEvent(eventName: string): boolean {\n  return DELEGATED_EVENTS.includes(eventName as keyof DelegatedEventMap);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAwCA,MAAM,mBAAgD;CACpD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAaA,MAAM,oCAAoB,IAAI,QAAwC;AAEtE,IAAI,yBAAyB;AAG7B,MAAM,8CAA8B,IAAI,IAGtC;AACF,MAAM,kDAAkC,IAAI,IAAkC;AAE9E,SAAgB,2BAAoC;CAClD,OAAO;AACT;AA4BA,SAAS,gCACP,WACA,WACM;CACN,IAAI,QAAQ,gCAAgC,IAAI,SAAS;CACzD,IAAI,CAAC,OAAO;EACV,wBAAQ,IAAI,IAAI;EAChB,gCAAgC,IAAI,WAAW,KAAK;CACtD;CACA,MAAM,IAAI,YAAY,MAAM,IAAI,SAAS,KAAK,KAAK,CAAC;AACtD;AAEA,SAAS,gCAAgC,OAA+B;CACtE,MAAM,QAAQ,gCAAgC,IAAI,MAAM,SAAS;CACjE,IAAI,CAAC,OACH;CAGF,MAAM,aAAa,MAAM,IAAI,MAAM,SAAS,KAAK,KAAK;CACtD,IAAI,YAAY,GAAG;EACjB,MAAM,IAAI,MAAM,WAAW,SAAS;EACpC;CACF;CAEA,MAAM,OAAO,MAAM,SAAS;CAC5B,MAAM,YAAY,4BAA4B,IAAI,MAAM,SAAS;CACjE,MAAM,WAAW,WAAW,IAAI,MAAM,SAAS;CAC/C,IAAI,UAAU;EACZ,MAAM,UAAU,oBAAoB,MAAM,WAAW,QAAQ;EAC7D,WAAW,OAAO,MAAM,SAAS;CACnC;CAEA,IAAI,WAAW,SAAS,GACtB,4BAA4B,OAAO,MAAM,SAAS;CAEpD,IAAI,MAAM,SAAS,GACjB,gCAAgC,OAAO,MAAM,SAAS;AAE1D;AAEA,SAAS,yBAAyC;CAGhD,IAAI,OAAO,aAAa,aAAa,OAAO,SAAS;CACrD,OAAO;AACT;AAEA,SAAS,wBACP,WACA,SACA,WACA,SACA,iBACA,SACM;CACN,MAAM,aAAa,CAAC,CAAC,8BAA8B,SAAS,SAAS;CAErE,IAAI,CAAC,4BAA4B,IAAI,SAAS,GAC5C,4BAA4B,IAAI,2BAAW,IAAI,IAAI,CAAC;CAEtD,MAAM,qBAAqB,4BAA4B,IAAI,SAAS;CAEpE,IAAI,CAAC,mBAAmB,IAAI,SAAS,GAAG;EACtC,MAAM,oBAAoB,MAAa;GACrC,MAAM,SAAS,EAAE;GACjB,IAAI,CAAC,QAAQ;GAEb,6BAA6B;IAC3B,IAAI,UAA0B;IAC9B,OAAO,WAAW,YAAY,WAAW;KACvC,oBAAoB,uBAAuB;KAC3C,MAAM,QAAQ,kBAAkB,IAAI,OAAO;KAC3C,MAAM,QAAQ,CAAC,QACX,SACA,iBAAiB,MACf,MAAM,IAAI,SAAS,IACnB,MAAM,cAAc,YAClB,QACA;KACR,IAAI,OACF,IAAI;MACF,MAAM,QAAQ,CAAC;KACjB,SAAS,OAAO;MACd,OAAO,MAAM,iCAAiC,KAAK;KACrD;KAGF,IAAI,EAAE,cACJ;KAGF,UAAU,QAAQ;IACpB;GACF,GAAG,MAAM;EACX;EAGA,MAAM,kBADiB,kBAAkB,SACjB,KAAkB;EAE1C,UAAU,iBAAiB,WAAW,kBAAkB,eAAe;EACvE,mBAAmB,IAAI,WAAW,gBAAgB;CACpD;CAEA,8BAA8B,SAAS;EACrC;EACA,UAAU;EACV;EACA;EACA;EACA;CACF,CAAC;CACD,IAAI,CAAC,YACH,gCAAgC,WAAW,SAAS;AAExD;AAEA,SAAS,8BACP,SACA,OACM;CACN,MAAM,WAAW,kBAAkB,IAAI,OAAO;CAC9C,IAAI,CAAC,UAAU;EACb,kBAAkB,IAAI,SAAS,KAAK;EACpC;CACF;CAEA,IAAI,oBAAoB,KAAK;EAC3B,SAAS,IAAI,MAAM,WAAW,KAAK;EACnC;CACF;CAEA,IAAI,SAAS,cAAc,MAAM,WAAW;EAC1C,kBAAkB,IAAI,SAAS,KAAK;EACpC;CACF;CAEA,MAAM,uBAAO,IAAI,IAA8B;CAC/C,KAAK,IAAI,SAAS,WAAW,QAAQ;CACrC,KAAK,IAAI,MAAM,WAAW,KAAK;CAC/B,kBAAkB,IAAI,SAAS,IAAI;AACrC;AAEA,SAAS,kBACP,WACqC;CACrC,IACE,cAAc,WACd,cAAc,YACd,UAAU,WAAW,OAAO,GAE5B,OAAO,EAAE,SAAS,KAAK;AAG3B;AAEA,SAAgB,qBACd,SACA,WACA,SACA,iBACA,SACM;CAGN,MAAM,YAAY,uBAAuB;CACzC,IAAI,CAAC,WAAW;CAEhB,cAAc,cAAc;CAE5B,wBACE,WACA,SACA,WACA,SACA,iBACA,OACF;AACF;AAEA,SAAgB,wBACd,SACA,WACA,SACA,iBACA,SACS;CACT,MAAM,WAAW,8BAA8B,SAAS,SAAS;CACjE,IAAI,CAAC,UACH,OAAO;CAGT,MAAM,YAAY,uBAAuB;CACzC,IACE,CAAC,aACD,SAAS,cAAc,aACvB,CAAC,4BAA4B,IAAI,SAAS,SAAS,CAAC,EAAE,IAAI,SAAS,GACnE;EACA,wBAAwB,SAAS,SAAS;EAC1C,OAAO;CACT;CAEA,SAAS,UAAU;CACnB,SAAS,WAAW;CACpB,SAAS,UAAU;CACnB,OAAO;AACT;AAEA,SAAgB,wBACd,SACA,WACM;CACN,MAAM,WAAW,kBAAkB,IAAI,OAAO;CAC9C,IAAI,CAAC,UACH;CAGF,IAAI,oBAAoB,KAAK;EAC3B,IAAI,SAAS,IAAI,SAAS,GAAG;GAC3B,cAAc,iBAAiB;GAC/B,gCAAgC,SAAS,IAAI,SAAS,CAAE;EAC1D;EACA,SAAS,OAAO,SAAS;EACzB,IAAI,SAAS,SAAS,GAAG;GACvB,kBAAkB,OAAO,OAAO;GAChC;EACF;EACA,IAAI,SAAS,SAAS,GAAG;GACvB,MAAM,OAAO,SAAS,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC;GACtC,kBAAkB,IAAI,SAAS,IAAI;EACrC;EACA;CACF;CAEA,IAAI,SAAS,cAAc,WAAW;EACpC,cAAc,iBAAiB;EAC/B,gCAAgC,QAAQ;EACxC,kBAAkB,OAAO,OAAO;CAClC;AACF;AAEA,SAAgB,8BACd,SACA,WAC8B;CAC9B,MAAM,QAAQ,kBAAkB,IAAI,OAAO;CAC3C,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI,iBAAiB,KAAK,OAAO,MAAM,IAAI,SAAS;CACpD,OAAO,MAAM,cAAc,YAAY,QAAQ;AACjD;AAEA,SAAgB,+BACd,SAC2C;CAC3C,MAAM,QAAQ,kBAAkB,IAAI,OAAO;CAC3C,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI,iBAAiB,KAAK,OAAO;CACjC,uBAAO,IAAI,IAAI,CAAC,CAAC,MAAM,WAAW,KAAK,CAAC,CAAC;AAC3C;AASA,SAAgB,iCAAiC,SAAwB;CACvE,MAAM,WAAW,kBAAkB,IAAI,OAAO;CAC9C,IAAI,oBAAoB,KACtB,KAAK,MAAM,SAAS,SAAS,OAAO,GAClC,gCAAgC,KAAK;MAElC,IAAI,UACT,gCAAgC,QAAQ;CAE1C,kBAAkB,OAAO,OAAO;AAClC;AAMA,SAAgB,iBAAiB,WAA4B;CAC3D,OAAO,iBAAiB,SAAS,SAAoC;AACvE"}

package/dist/runtime/execution-model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"execution-model.js","names":[],"sources":["../../src/runtime/execution-model.ts"],"sourcesContent":["export type ExecutionModel = 'spa' | 'islands' | 'ssr';\n\nconst EXECUTION_MODEL_KEY = Symbol.for('__ASKR_EXECUTION_MODEL__');\n\nexport function getExecutionModel(): ExecutionModel | undefined {\n  const g = globalThis as unknown as Record<string | symbol, unknown>;\n  return g[EXECUTION_MODEL_KEY] as ExecutionModel | undefined;\n}\n\nexport function assertExecutionModel(model: ExecutionModel): void {\n  // Mixing execution models is forbidden: once an app starts in one model,\n  // attempting to start another is an invariant violation.\n  const g = globalThis as unknown as Record<string | symbol, unknown>;\n  const cur = g[EXECUTION_MODEL_KEY] as ExecutionModel | undefined;\n  if (cur && cur !== model) {\n    throw new Error(\n      `[Askr] mixing execution models is not allowed (current: ${cur}, attempted: ${model}). ` +\n        `Choose exactly one: createSPA, createSSR, or createIslands.`\n    );\n  }\n  if (!cur) g[EXECUTION_MODEL_KEY] = model;\n}\n"],"mappings":";AAEA,MAAM,sBAAsB,OAAO,IAAI,0BAA0B;AAEjE,SAAgB,oBAAgD;CAE9D,OAAO,WAAE;AACX;AAEA,SAAgB,qBAAqB,OAA6B;CAGhE,MAAM,IAAI;CACV,MAAM,MAAM,EAAE;CACd,IAAI,OAAO,QAAQ,OACjB,MAAM,IAAI,MACR,2DAA2D,IAAI,eAAe,MAAM,+DAEtF;CAEF,IAAI,CAAC,KAAK,EAAE,uBAAuB;AACrC"}

package/dist/runtime/fastlane.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fastlane.js","names":[],"sources":["../../src/runtime/fastlane.ts"],"sourcesContent":["import { isDevelopmentEnvironment } from '../common/env';\nimport {\n  getRuntimeRenderer,\n  getRuntimeSchedulerState,\n  runRuntimeWithSyncProgress,\n  setRuntimeBulkCommitProbe,\n} from './access';\nimport type { ComponentInstance } from './component';\nimport { finalizeReadableSubscriptions } from './readable';\nimport { Fragment } from '../common/jsx';\nimport { setDevValue, getDevValue, getDevNamespace } from './dev-namespace';\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  setDevValue('__FASTLANE_CLEARED_TASKS', 0);\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\nfunction finalizeReadSubscriptions(instance: ComponentInstance): void {\n  finalizeReadableSubscriptions(instance);\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 */\n\n// Helper to unwrap Fragment vnodes to get the first intrinsic element child\nfunction unwrapFragmentForFastPath(vnode: unknown): unknown {\n  if (!vnode || typeof vnode !== 'object' || !('type' in vnode)) return vnode;\n  const v = vnode as {\n    type: unknown;\n    children?: unknown;\n    props?: { children?: unknown };\n  };\n  // Check if it's a Fragment\n  if (\n    typeof v.type === 'symbol' &&\n    (v.type === Fragment || String(v.type) === 'Symbol(askr.fragment)')\n  ) {\n    const children = v.props?.children ?? v.children;\n    if (Array.isArray(children) && children.length > 0) {\n      // Return the first child that's an intrinsic element\n      for (const child of children) {\n        if (child && typeof child === 'object' && 'type' in child) {\n          const c = child as { type: unknown };\n          if (typeof c.type === 'string') {\n            return child;\n          }\n        }\n      }\n    }\n  }\n  return vnode;\n}\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\n  // Unwrap Fragment to get the actual element vnode for classification\n  const unwrappedResult = unwrapFragmentForFastPath(result);\n\n  if (\n    !unwrappedResult ||\n    typeof unwrappedResult !== 'object' ||\n    !('type' in unwrappedResult)\n  )\n    return { useFastPath: false, reason: 'not-vnode' };\n\n  const vnode = unwrappedResult 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 = vnode.props?.children ?? vnode.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 (const c of children) {\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) > 0)\n    return { useFastPath: false, reason: 'pending-mounts' };\n  if ((instance.commitOperations?.length ?? 0) > 0)\n    return { useFastPath: false, reason: 'pending-lifecycle-commits' };\n\n  // Ask renderer for keyed reorder eligibility (prop differences & heuristics)\n  // Ensure a keyed map is available for the first child by populating it proactively.\n  const renderer = getRuntimeRenderer();\n  try {\n    renderer.populateKeyMapForElement(firstChild);\n  } catch {\n    // ignore\n  }\n\n  const oldKeyMap = renderer.getKeyMapForElement(firstChild);\n  const decision = renderer.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): boolean {\n  // Performs the minimal, synchronous reorder-only commit.\n  const renderer = getRuntimeRenderer();\n\n  const schedBefore = isDevelopmentEnvironment()\n    ? getRuntimeSchedulerState()\n    : null;\n\n  enterBulkCommit();\n\n  try {\n    runRuntimeWithSyncProgress(() => {\n      renderer.evaluate(result, instance.target);\n\n      // Finalize runtime bookkeeping (read subscriptions / tokens)\n      try {\n        finalizeReadSubscriptions(instance);\n      } catch (e) {\n        if (isDevelopmentEnvironment()) throw e;\n      }\n    });\n\n    setDevValue('__FASTLANE_CLEARED_AFTER', 0);\n\n    // Dev-only invariant checks\n    if (isDevelopmentEnvironment()) {\n      validateFastLaneInvariants(instance, schedBefore);\n    }\n\n    return true;\n  } finally {\n    // Clear bulk commit flag first\n    exitBulkCommit();\n  }\n  // Note: The original code had a check here that was dead code because\n  // exitBulkCommit() already ran in the finally block. This comment serves\n  // as documentation that we've intentionally removed that unreachable code.\n}\n\n/**\n * Validates fast-lane invariants in dev mode.\n * Extracted to reduce complexity in commitReorderOnly.\n */\nfunction validateFastLaneInvariants(\n  instance: ComponentInstance,\n  schedBefore: ReturnType<typeof getRuntimeSchedulerState> | null\n): void {\n  const commitCount = getDevValue<number>('__LAST_FASTPATH_COMMIT_COUNT') ?? 0;\n  const invariants = {\n    commitCount,\n    mountOps: instance.mountOperations?.length ?? 0,\n    commitOps: instance.commitOperations?.length ?? 0,\n    cleanupFns: instance.cleanupFns?.length ?? 0,\n  };\n  setDevValue('__LAST_FASTLANE_INVARIANTS', invariants);\n\n  if (commitCount !== 1) {\n    console.error(\n      '[FASTLANE][INV] commitCount',\n      commitCount,\n      'diag',\n      getDevNamespace()\n    );\n    throw new Error(\n      'Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit'\n    );\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\n  if (invariants.commitOps > 0) {\n    throw new Error(\n      'Fast-lane invariant violated: lifecycle commit operations were registered during bulk commit'\n    );\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 = getRuntimeSchedulerState();\n  if (\n    schedBefore &&\n    schedAfter &&\n    schedAfter.taskCount > schedBefore.taskCount\n  ) {\n    console.error(\n      '[FASTLANE] schedBefore, schedAfter',\n      schedBefore,\n      schedAfter\n    );\n    console.error('[FASTLANE] enqueue logs', getDevValue('__ENQUEUE_LOGS'));\n    throw new Error(\n      'Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit'\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) {\n    // Clear stale fast-path diagnostics\n    setDevValue('__LAST_FASTPATH_STATS', undefined);\n    setDevValue('__LAST_FASTPATH_COMMIT_COUNT', 0);\n    return false;\n  }\n\n  try {\n    return commitReorderOnly(instance, result);\n  } catch (err) {\n    // Surface dev-only invariant failures, otherwise decline silently\n    if (isDevelopmentEnvironment()) throw err;\n    return false;\n  }\n}\n\nsetRuntimeBulkCommitProbe(isBulkCommitActive);\n"],"mappings":"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"}

package/dist/runtime/for-bench.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-bench.d.ts","names":[],"sources":["../../src/runtime/for-bench.ts"],"mappings":";UASiB,YAAA;EACf,YAAA;EACA,WAAA;EACA,YAAA;EACA,UAAA;EACA,qBAAA;EACA,UAAA;EACA,OAAA;EACA,SAAA;EACA,UAAA;EACA,UAAA;EACA,QAAA;EACA,WAAA;EACA,WAAA;EACA,eAAA;EACA,gBAAA;EACA,oBAAA;EACA,sBAAA;EACA,gBAAA;EACA,gBAAA;EACA,gBAAA;EACA,YAAA;AAAA;AAAA,KAGU,UAAA;AAAA,KA0CP,gBAAA;AAAA,KACA,YAAA;AAAA,iBAmJI,wBAAA,IAA4B,KAAA,EAAO,gBAAA,EAAkB,GAAA,QAAW,CAAA,GAAI,CAAA;AAAA,cAoChE,iBAAA;AAAA,cAUA,gBAAA,GAAgB,KAAA,EAlIQ,UAAU,EAAA,KAAA;AAAA,cAsIlC,mBAAA,GAAmB,IAlFa;AAAA,cAsFhC,iBAAA,GAAiB,KAAA,6BAnCI,EACtB;AAAA,cAsCC,kBAAA,GAAkB,OAAA,EAlFU,YAAY,EAAA,KAAA;AAAA,cAsFxC,oBAAA,SAAoB,wBAE0B;AAAA,cAE9C,wBAAA,GAAwB,KAnDwB,EAAhB,gBAAgB;AAAA,cAuDhD,eAAA,QArCmB,YAuCkB;AAAA,cAErC,iBAAA;AAAA,cAIA,mBAAA"}

package/dist/runtime/for-bench.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-bench.js","names":[],"sources":["../../src/runtime/for-bench.ts"],"sourcesContent":["import { isRuntimeEnvFlagEnabled } from '../common/env';\n\nconst BENCH_BUILD_ENABLED = isRuntimeEnvFlagEnabled('ASKR_BENCH');\n\ntype BenchGlobal = typeof globalThis & {\n  __ASKR_BENCH__?: boolean;\n  __ASKR_FOR_BENCH__?: BenchMetrics;\n};\n\nexport interface BenchMetrics {\n  itemsCreated: number;\n  itemsReused: number;\n  itemsRemoved: number;\n  itemsMoved: number;\n  rowFactoryInvocations: number;\n  keyLookups: number;\n  keyHits: number;\n  keyMisses: number;\n  domInserts: number;\n  domRemoves: number;\n  domMoves: number;\n  domAttrSets: number;\n  domTextSets: number;\n  domNodesCreated: number;\n  listenerBindings: number;\n  reactivePropsMounted: number;\n  replaceChildrenCommits: number;\n  bulkClearCommits: number;\n  reconcilePhaseMs: number;\n  domCommitPhaseMs: number;\n  fastLaneName: string | null;\n}\n\nexport type BenchEvent =\n  | 'itemCreated'\n  | 'itemReused'\n  | 'itemRemoved'\n  | 'itemMoved'\n  | 'rowFactory'\n  | 'keyLookup'\n  | 'keyHit'\n  | 'keyMiss'\n  | 'domInsert'\n  | 'domRemove'\n  | 'domMove'\n  | 'domAttrSet'\n  | 'domTextSet';\n\nfunction createInitialBenchMetrics(): BenchMetrics {\n  return {\n    itemsCreated: 0,\n    itemsReused: 0,\n    itemsRemoved: 0,\n    itemsMoved: 0,\n    rowFactoryInvocations: 0,\n    keyLookups: 0,\n    keyHits: 0,\n    keyMisses: 0,\n    domInserts: 0,\n    domRemoves: 0,\n    domMoves: 0,\n    domAttrSets: 0,\n    domTextSets: 0,\n    domNodesCreated: 0,\n    listenerBindings: 0,\n    reactivePropsMounted: 0,\n    replaceChildrenCommits: 0,\n    bulkClearCommits: 0,\n    reconcilePhaseMs: 0,\n    domCommitPhaseMs: 0,\n    fastLaneName: null,\n  };\n}\n\nconst emptyBenchMetrics = createInitialBenchMetrics();\ntype BenchMetricScope = 'coldCreate' | 'fullClear';\ntype BenchCounter =\n  | 'domNodesCreated'\n  | 'listenerBindings'\n  | 'reactivePropsMounted'\n  | 'replaceChildrenCommits'\n  | 'bulkClearCommits';\nlet activeBenchMetricScope: BenchMetricScope | null = null;\n\nfunction isBenchRuntimeEnabled(): boolean {\n  if (!BENCH_BUILD_ENABLED) {\n    return false;\n  }\n\n  try {\n    return !!(globalThis as BenchGlobal).__ASKR_BENCH__;\n  } catch {\n    return false;\n  }\n}\n\nfunction publishBenchMetrics(metrics: BenchMetrics): void {\n  if (!isBenchRuntimeEnabled()) {\n    return;\n  }\n\n  (globalThis as BenchGlobal).__ASKR_FOR_BENCH__ = { ...metrics };\n}\n\nconst flushBenchMetricsLive = (): void => {\n  if (!benchMetrics) {\n    return;\n  }\n\n  publishBenchMetrics(benchMetrics);\n};\n\nfunction resetBenchMetricsLive(metrics: BenchMetrics): void {\n  metrics.itemsCreated = 0;\n  metrics.itemsReused = 0;\n  metrics.itemsRemoved = 0;\n  metrics.itemsMoved = 0;\n  metrics.rowFactoryInvocations = 0;\n  metrics.keyLookups = 0;\n  metrics.keyHits = 0;\n  metrics.keyMisses = 0;\n  metrics.domInserts = 0;\n  metrics.domRemoves = 0;\n  metrics.domMoves = 0;\n  metrics.domAttrSets = 0;\n  metrics.domTextSets = 0;\n  metrics.domNodesCreated = 0;\n  metrics.listenerBindings = 0;\n  metrics.reactivePropsMounted = 0;\n  metrics.replaceChildrenCommits = 0;\n  metrics.bulkClearCommits = 0;\n  metrics.reconcilePhaseMs = 0;\n  metrics.domCommitPhaseMs = 0;\n  metrics.fastLaneName = null;\n  publishBenchMetrics(metrics);\n}\n\nconst benchMetrics = BENCH_BUILD_ENABLED ? createInitialBenchMetrics() : null;\n\nconst recordBenchEventLive = (event: BenchEvent, delta = 1): void => {\n  if (!isBenchRuntimeEnabled() || !benchMetrics) {\n    return;\n  }\n\n  if (delta === 0) {\n    return;\n  }\n\n  switch (event) {\n    case 'itemCreated':\n      benchMetrics.itemsCreated += delta;\n      break;\n    case 'itemReused':\n      benchMetrics.itemsReused += delta;\n      break;\n    case 'itemRemoved':\n      benchMetrics.itemsRemoved += delta;\n      break;\n    case 'itemMoved':\n      benchMetrics.itemsMoved += delta;\n      break;\n    case 'rowFactory':\n      benchMetrics.rowFactoryInvocations += delta;\n      break;\n    case 'keyLookup':\n      benchMetrics.keyLookups += delta;\n      break;\n    case 'keyHit':\n      benchMetrics.keyHits += delta;\n      break;\n    case 'keyMiss':\n      benchMetrics.keyMisses += delta;\n      break;\n    case 'domInsert':\n      benchMetrics.domInserts += delta;\n      break;\n    case 'domRemove':\n      benchMetrics.domRemoves += delta;\n      break;\n    case 'domMove':\n      benchMetrics.domMoves += delta;\n      break;\n    case 'domAttrSet':\n      benchMetrics.domAttrSets += delta;\n      break;\n    case 'domTextSet':\n      benchMetrics.domTextSets += delta;\n      break;\n  }\n};\n\nconst recordBenchFastLaneLive = (name: string): void => {\n  if (!isBenchRuntimeEnabled() || !benchMetrics) {\n    return;\n  }\n\n  benchMetrics.fastLaneName = name;\n};\n\nconst recordBenchCounterLive = (counter: BenchCounter, delta = 1): void => {\n  if (!isBenchRuntimeEnabled() || !benchMetrics || delta === 0) {\n    return;\n  }\n\n  switch (counter) {\n    case 'domNodesCreated':\n      benchMetrics.domNodesCreated += delta;\n      break;\n    case 'listenerBindings':\n      benchMetrics.listenerBindings += delta;\n      break;\n    case 'reactivePropsMounted':\n      benchMetrics.reactivePropsMounted += delta;\n      break;\n    case 'replaceChildrenCommits':\n      benchMetrics.replaceChildrenCommits += delta;\n      break;\n    case 'bulkClearCommits':\n      benchMetrics.bulkClearCommits += delta;\n      break;\n  }\n};\n\nfunction withBenchMetricScopeLive<T>(scope: BenchMetricScope, run: () => T): T {\n  if (!isBenchRuntimeEnabled()) {\n    return run();\n  }\n\n  const previousScope = activeBenchMetricScope;\n  activeBenchMetricScope = scope;\n\n  try {\n    return run();\n  } finally {\n    activeBenchMetricScope = previousScope;\n  }\n}\n\nconst isBenchMetricScopeActiveLive = (scope: BenchMetricScope): boolean =>\n  isBenchRuntimeEnabled() && activeBenchMetricScope === scope;\n\nconst recordBenchTimingLive = (\n  phase: 'reconcile' | 'domCommit',\n  ms: number\n): void => {\n  if (!isBenchRuntimeEnabled() || !benchMetrics) {\n    return;\n  }\n\n  if (phase === 'reconcile') {\n    benchMetrics.reconcilePhaseMs = ms;\n  } else {\n    benchMetrics.domCommitPhaseMs = ms;\n  }\n};\n\nconst getBenchMetricsLive = (): BenchMetrics =>\n  benchMetrics ? { ...benchMetrics } : { ...emptyBenchMetrics };\n\nexport const resetBenchMetrics = BENCH_BUILD_ENABLED\n  ? (): void => {\n      if (!isBenchRuntimeEnabled() || !benchMetrics) {\n        return;\n      }\n\n      resetBenchMetricsLive(benchMetrics);\n    }\n  : (): void => {};\n\nexport const recordBenchEvent = BENCH_BUILD_ENABLED\n  ? recordBenchEventLive\n  : (_event: BenchEvent): void => {};\n\nexport const recordBenchFastLane = BENCH_BUILD_ENABLED\n  ? recordBenchFastLaneLive\n  : (_name: string): void => {};\n\nexport const recordBenchTiming = BENCH_BUILD_ENABLED\n  ? recordBenchTimingLive\n  : (_phase: 'reconcile' | 'domCommit', _ms: number): void => {};\n\nexport const recordBenchCounter = BENCH_BUILD_ENABLED\n  ? recordBenchCounterLive\n  : (_counter: BenchCounter, _delta = 1): void => {};\n\nexport const withBenchMetricScope = BENCH_BUILD_ENABLED\n  ? withBenchMetricScopeLive\n  : <T>(_scope: BenchMetricScope, run: () => T): T => run();\n\nexport const isBenchMetricScopeActive = BENCH_BUILD_ENABLED\n  ? isBenchMetricScopeActiveLive\n  : (_scope: BenchMetricScope): boolean => false;\n\nexport const getBenchMetrics = BENCH_BUILD_ENABLED\n  ? getBenchMetricsLive\n  : (): BenchMetrics => ({ ...emptyBenchMetrics });\n\nexport const flushBenchMetrics = BENCH_BUILD_ENABLED\n  ? flushBenchMetricsLive\n  : (): void => {};\n\nexport const isBenchBuildEnabled = (): boolean => BENCH_BUILD_ENABLED;\n"],"mappings":"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"}

package/dist/runtime/for-internal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-internal.d.ts","names":[],"sources":["../../src/runtime/for-internal.ts"],"mappings":";;;;;;;;;KA6BY,iBAAA;AAAA,UAOK,QAAA;EACf,IAAA;EACA,YAAA,EAAc,CAAA;EACd,UAAA,EAAY,aAAA,CAAc,CAAA;EAC1B,QAAA,EAAU,KAAA;EACV,aAAA,EAAe,UAAA;EACf,KAAA,EAAO,GAAA,kBAAqB,eAAA,CAAgB,CAAA;EAC5C,WAAA,EAAa,KAAA;EACb,YAAA,EAAc,eAAA,CAAgB,CAAA;EAC9B,aAAA,EAAe,KAAA;EACf,IAAA,EAAM,WAAA,CAAY,QAAA,CAAS,CAAA,aAAc,IAAA,EAAM,CAAA,EAAG,KAAA;EAClD,QAAA,GAAW,IAAA,EAAM,CAAA,EAAG,KAAA,mBAAwB,KAAA;EAC5C,cAAA,EAAgB,iBAAA;EAChB,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,IAAA;EAClB,mBAAA;EACA,kBAAA;EACA,eAAA;EACA,mBAAA;EACA,qBAAA;EACA,aAAA,EAAe,uBAAA,CAAwB,CAAA;EACvC,oBAAA;EACA,sBAAA;EACA,yBAAA;EACA,WAAA,GAAc,GAAA;AAAA;AAAA,iBAmBA,cAAA,IACd,UAAA,EAAY,aAAA,CAAc,CAAA,GAC1B,IAAA,EAAM,QAAA,CAAS,CAAA,WACf,QAAA,GAAW,IAAA,EAAM,CAAA,EAAG,KAAA,mBAAwB,KAAA,EAC5C,QAAA,EAAU,KAAA,UACT,QAAA,CAAS,CAAA;AAAA,iBA8BI,WAAA,IACd,UAAA,EAAY,aAAA,CAAc,CAAA,GAC1B,IAAA,EAAM,QAAA,CAAS,CAAA,WACf,QAAA,GAAW,IAAA,EAAM,CAAA,EAAG,KAAA,mBAAwB,KAAA,EAC5C,QAAA,EAAU,KAAA,UACT,QAAA,CAAS,CAAA;AAAA,iBAgCI,gBAAA,IAAoB,QAAA,EAAU,QAAA,CAAS,CAAA,IAAK,KAAA;AAAA,iBAS5C,sBAAA,IAA0B,QAAA,EAAU,QAAQ,CAAC,CAAA"}

package/dist/runtime/for-internal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-internal.js","names":[],"sources":["../../src/runtime/for-internal.ts"],"sourcesContent":["/**\n * For primitive runtime\n *\n * Manages For state storage, hook binding, source evaluation,\n * and DOM update state cleanup.\n */\n\nimport { type ComponentInstance, getCurrentInstance } from './component';\nimport { claimHookIndex } from './component';\nimport type { VNode } from '../common/vnode';\nimport type { ChildScope } from './child-scope';\nimport type { ForItemInstance } from './for-scopes';\nimport type { ForProps } from '../control/for';\nimport type { ForEachSource } from '../control/for';\nimport type { FineGrainedEffectHandle } from './effect';\nimport { reconcileForItems } from './for-reconcile';\n\nexport {\n  getBenchMetrics,\n  isBenchMetricScopeActive,\n  recordBenchEvent,\n  recordBenchCounter,\n  recordBenchTiming,\n  resetBenchMetrics,\n  withBenchMetricScope,\n} from './for-bench';\n\nexport { reconcileForItems };\n\nexport type ForCommitStrategy =\n  | 'APPEND'\n  | 'TRUNCATE'\n  | 'NO_REORDER'\n  | 'SWAP'\n  | 'FULL_KEYED';\n\nexport interface ForState<T> {\n  kind: 'for';\n  currentItems: T[];\n  eachSource: ForEachSource<T>;\n  fallback: VNode | null;\n  fallbackScope: ChildScope | null;\n  items: Map<string | number, ForItemInstance<T>>;\n  orderedKeys: Array<string | number>;\n  orderedItems: ForItemInstance<T>[];\n  orderedVNodes: VNode[];\n  byFn: NonNullable<ForProps<T>['by']> | ((item: T, index: number) => number);\n  renderFn: (item: T, index: () => number) => VNode;\n  parentInstance: ComponentInstance | null;\n  lastCommitStrategy: ForCommitStrategy;\n  lastRemovedNodes: Node[];\n  pendingDirtyIndices: number[] | null;\n  pendingSwapIndices: [number, number] | null;\n  pendingMoveOnly: boolean;\n  _hasResolvedItemDom: boolean;\n  _needsSourceReconcile: boolean;\n  _sourceEffect: FineGrainedEffectHandle<T[]> | null;\n  _suspendSourceCommit: boolean;\n  _enqueueBoundaryCommit?: (() => void) | null;\n  _hasPendingBoundaryCommit?: boolean;\n  devKeyKinds?: Map<string, 'number' | 'string'>;\n}\n\nconst forStates = new WeakMap<\n  ComponentInstance,\n  Map<number, ForState<unknown>>\n>();\n\nfunction getForStore(\n  instance: ComponentInstance\n): Map<number, ForState<unknown>> {\n  let store = forStates.get(instance);\n  if (!store) {\n    store = new Map();\n    forStates.set(instance, store);\n  }\n  return store;\n}\n\nexport function createForState<T>(\n  eachSource: ForEachSource<T>,\n  byFn: ForState<T>['byFn'],\n  renderFn: (item: T, index: () => number) => VNode,\n  fallback: VNode | null\n): ForState<T> {\n  const parentInstance = getCurrentInstance();\n\n  return {\n    kind: 'for',\n    currentItems: [],\n    eachSource,\n    fallback,\n    fallbackScope: null,\n    items: new Map(),\n    orderedKeys: [],\n    orderedItems: [],\n    orderedVNodes: [],\n    byFn,\n    renderFn,\n    parentInstance,\n    lastCommitStrategy: 'NO_REORDER',\n    lastRemovedNodes: [],\n    pendingDirtyIndices: null,\n    pendingSwapIndices: null,\n    pendingMoveOnly: false,\n    _hasResolvedItemDom: false,\n    _needsSourceReconcile: false,\n    _sourceEffect: null,\n    _suspendSourceCommit: false,\n    _enqueueBoundaryCommit: null,\n    _hasPendingBoundaryCommit: false,\n  };\n}\n\nexport function useForState<T>(\n  eachSource: ForEachSource<T>,\n  byFn: ForState<T>['byFn'],\n  renderFn: (item: T, index: () => number) => VNode,\n  fallback: VNode | null\n): ForState<T> {\n  const instance = getCurrentInstance();\n  if (!instance) {\n    throw new Error(\n      'For can only be created during component render execution.'\n    );\n  }\n\n  const hookIndex = claimHookIndex(instance, 'For');\n  const store = getForStore(instance);\n  const existing = store.get(hookIndex) as ForState<T> | undefined;\n\n  if (existing) {\n    existing.eachSource = eachSource;\n    existing.byFn = byFn;\n    existing.renderFn = renderFn;\n    existing.fallback = fallback;\n    return existing;\n  }\n\n  const created = createForState(eachSource, byFn, renderFn, fallback);\n  store.set(hookIndex, created as ForState<unknown>);\n\n  (instance.cleanupFns ??= []).push(() => {\n    created._sourceEffect?.cleanup();\n    created._sourceEffect = null;\n    store.delete(hookIndex);\n  });\n\n  return created;\n}\n\nexport function evaluateForState<T>(forState: ForState<T>): VNode[] {\n  if (!Array.isArray(forState.currentItems)) {\n    throw new Error('For source must evaluate to an array');\n  }\n\n  forState._needsSourceReconcile = false;\n  return reconcileForItems(forState, forState.currentItems);\n}\n\nexport function clearForDomUpdateState<T>(forState: ForState<T>): void {\n  const dirtyIndices = forState.pendingDirtyIndices;\n  if (dirtyIndices && dirtyIndices.length > 0) {\n    for (let i = 0; i < dirtyIndices.length; i++) {\n      const itemInstance = forState.orderedItems[dirtyIndices[i]];\n      if (itemInstance) {\n        itemInstance.scope.needsDomUpdate = false;\n      }\n    }\n  } else {\n    for (let i = 0; i < forState.orderedKeys.length; i++) {\n      const key = forState.orderedKeys[i];\n      const itemInstance = forState.items.get(key);\n      if (itemInstance) {\n        itemInstance.scope.needsDomUpdate = false;\n      }\n    }\n  }\n\n  if (forState.fallbackScope) {\n    forState.fallbackScope.needsDomUpdate = false;\n  }\n  forState.lastRemovedNodes = [];\n  forState.pendingDirtyIndices = null;\n  forState.pendingSwapIndices = null;\n  forState.pendingMoveOnly = false;\n  forState._needsSourceReconcile = false;\n  forState._hasResolvedItemDom = forState.orderedKeys.length > 0;\n}\n"],"mappings":";;;;;;;;;;;AA+DA,MAAM,4BAAY,IAAI,QAGpB;AAEF,SAAS,YACP,UACgC;CAChC,IAAI,QAAQ,UAAU,IAAI,QAAQ;CAClC,IAAI,CAAC,OAAO;EACV,wBAAQ,IAAI,IAAI;EAChB,UAAU,IAAI,UAAU,KAAK;CAC/B;CACA,OAAO;AACT;AAEA,SAAgB,eACd,YACA,MACA,UACA,UACa;CACb,MAAM,iBAAiB,mBAAmB;CAE1C,OAAO;EACL,MAAM;EACN,cAAc,CAAC;EACf;EACA;EACA,eAAe;EACf,uBAAO,IAAI,IAAI;EACf,aAAa,CAAC;EACd,cAAc,CAAC;EACf,eAAe,CAAC;EAChB;EACA;EACA;EACA,oBAAoB;EACpB,kBAAkB,CAAC;EACnB,qBAAqB;EACrB,oBAAoB;EACpB,iBAAiB;EACjB,qBAAqB;EACrB,uBAAuB;EACvB,eAAe;EACf,sBAAsB;EACtB,wBAAwB;EACxB,2BAA2B;CAC7B;AACF;AAEA,SAAgB,YACd,YACA,MACA,UACA,UACa;CACb,MAAM,WAAW,mBAAmB;CACpC,IAAI,CAAC,UACH,MAAM,IAAI,MACR,4DACF;CAGF,MAAM,YAAY,eAAe,UAAU,KAAK;CAChD,MAAM,QAAQ,YAAY,QAAQ;CAClC,MAAM,WAAW,MAAM,IAAI,SAAS;CAEpC,IAAI,UAAU;EACZ,SAAS,aAAa;EACtB,SAAS,OAAO;EAChB,SAAS,WAAW;EACpB,SAAS,WAAW;EACpB,OAAO;CACT;CAEA,MAAM,UAAU,eAAe,YAAY,MAAM,UAAU,QAAQ;CACnE,MAAM,IAAI,WAAW,OAA4B;CAEjD,CAAC,SAAS,eAAe,CAAC,EAAA,CAAG,WAAW;EACtC,QAAQ,eAAe,QAAQ;EAC/B,QAAQ,gBAAgB;EACxB,MAAM,OAAO,SAAS;CACxB,CAAC;CAED,OAAO;AACT;AAEA,SAAgB,iBAAoB,UAAgC;CAClE,IAAI,CAAC,MAAM,QAAQ,SAAS,YAAY,GACtC,MAAM,IAAI,MAAM,sCAAsC;CAGxD,SAAS,wBAAwB;CACjC,OAAO,kBAAkB,UAAU,SAAS,YAAY;AAC1D;AAEA,SAAgB,uBAA0B,UAA6B;CACrE,MAAM,eAAe,SAAS;CAC9B,IAAI,gBAAgB,aAAa,SAAS,GACxC,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;EAC5C,MAAM,eAAe,SAAS,aAAa,aAAa;EACxD,IAAI,cACF,aAAa,MAAM,iBAAiB;CAExC;MAEA,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,YAAY,QAAQ,KAAK;EACpD,MAAM,MAAM,SAAS,YAAY;EACjC,MAAM,eAAe,SAAS,MAAM,IAAI,GAAG;EAC3C,IAAI,cACF,aAAa,MAAM,iBAAiB;CAExC;CAGF,IAAI,SAAS,eACX,SAAS,cAAc,iBAAiB;CAE1C,SAAS,mBAAmB,CAAC;CAC7B,SAAS,sBAAsB;CAC/B,SAAS,qBAAqB;CAC9B,SAAS,kBAAkB;CAC3B,SAAS,wBAAwB;CACjC,SAAS,sBAAsB,SAAS,YAAY,SAAS;AAC/D"}

package/dist/runtime/for-reconcile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-reconcile.d.ts","names":[],"sources":["../../src/runtime/for-reconcile.ts"],"mappings":";;;;iBAsEgB,iBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,QAAA,EAAU,CAAA,KACT,KAAA"}

package/dist/runtime/for-reconcile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-reconcile.js","names":[],"sources":["../../src/runtime/for-reconcile.ts"],"sourcesContent":["/**\n * For key validation and reconciliation strategy ownership.\n */\n\nimport type { VNode } from '../common/vnode';\nimport { isDevelopmentEnvironment } from '../common/env';\nimport {\n  createItemInstance,\n  disposeAllItems,\n  disposeFallbackScope,\n  disposeItemInstance,\n  renderFallbackScope,\n  syncForItemIndex,\n  updateItemInstance,\n  type ForItemInstance,\n} from './for-scopes';\nimport {\n  flushBenchMetrics,\n  isBenchBuildEnabled,\n  recordBenchEvent,\n  recordBenchFastLane,\n  recordBenchTiming,\n  resetBenchMetrics,\n} from './for-bench';\nimport type { ForState } from './for-internal';\n\nconst BENCH_BUILD_ENABLED = isBenchBuildEnabled();\n\nfunction failForValidation(message: string): never {\n  throw new Error(message);\n}\n\nfunction validateForKeys<T>(forState: ForState<T>, newArray: T[]): void {\n  if (!isDevelopmentEnvironment()) {\n    return;\n  }\n\n  const seen = new Set<string | number>();\n  const keyKinds = new Map<string, 'number' | 'string'>();\n  for (let i = 0; i < newArray.length; i++) {\n    const key = forState.byFn(newArray[i], i);\n\n    if (key === null || key === undefined) {\n      failForValidation(\n        '[askr] Invalid For key detected. Keys should be stable, non-null, and unique within a For list.'\n      );\n    }\n\n    if (seen.has(key)) {\n      failForValidation(\n        `[askr] Duplicate For key detected: ${String(key)}. Keys should be stable, non-null, and unique within a For list.`\n      );\n    }\n\n    seen.add(key);\n\n    const keyString = String(key);\n    const keyKind = typeof key;\n    const previousKeyKind = forState.devKeyKinds?.get(keyString);\n    if (previousKeyKind && previousKeyKind !== keyKind) {\n      failForValidation(\n        `[askr] For key type changed for ${keyString}. Keys must remain consistently typed across renders.`\n      );\n    }\n    keyKinds.set(keyString, keyKind as 'number' | 'string');\n  }\n\n  forState.devKeyKinds = keyKinds;\n}\n\nexport function reconcileForItems<T>(\n  forState: ForState<T>,\n  newArray: T[]\n): VNode[] {\n  forState.currentItems = newArray;\n  validateForKeys(forState, newArray);\n\n  if (BENCH_BUILD_ENABLED) {\n    resetBenchMetrics();\n  }\n\n  const reconcileStartMs = BENCH_BUILD_ENABLED ? performance.now() : 0;\n\n  const { items, orderedKeys, byFn } = forState;\n  const oldLen = orderedKeys.length;\n  const newLen = newArray.length;\n  forState.lastRemovedNodes = [];\n\n  if (newLen === 0) {\n    if (oldLen > 0) {\n      disposeAllItems(forState, forState.fallback ? 'teardown' : 'none');\n    }\n    recordBenchFastLane('TRUNCATE');\n    forState.lastCommitStrategy = 'TRUNCATE';\n    forState.pendingDirtyIndices = null;\n    forState.pendingSwapIndices = null;\n    forState.pendingMoveOnly = false;\n\n    if (BENCH_BUILD_ENABLED) {\n      recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n      flushBenchMetrics();\n    }\n\n    return renderFallbackScope(forState);\n  }\n\n  if (forState.fallbackScope) {\n    disposeFallbackScope(forState, 'none');\n  }\n\n  // FAST PATH A: APPEND\n  // Guard: oldLen <= newLen && all old keys match new keys at same indices\n  if (oldLen < newLen) {\n    let canUseAppendPath = true;\n    for (let i = 0; i < oldLen; i++) {\n      const key = byFn(newArray[i], i);\n      if (key !== orderedKeys[i]) {\n        canUseAppendPath = false;\n        break;\n      }\n    }\n\n    if (canUseAppendPath) {\n      recordBenchFastLane('APPEND');\n      forState.lastCommitStrategy = 'APPEND';\n      const resultVNodes = forState.orderedVNodes;\n      const resultItems = forState.orderedItems;\n      resultVNodes.length = newLen;\n      resultItems.length = newLen;\n\n      // Update existing rows in-place\n      for (let i = 0; i < oldLen; i++) {\n        const item = newArray[i];\n        const key = orderedKeys[i];\n        const existing = resultItems[i] ?? items.get(key)!;\n\n        updateItemInstance(forState, existing, item);\n\n        resultItems[i] = existing;\n        resultVNodes[i] = existing.scope.vnode as VNode;\n      }\n\n      recordBenchEvent('itemReused', oldLen);\n\n      // Create and append new rows\n      for (let i = oldLen; i < newLen; i++) {\n        const item = newArray[i];\n        const key = byFn(item, i);\n        const itemInstance = createItemInstance(key, item, i, forState);\n        items.set(key, itemInstance);\n        resultItems[i] = itemInstance;\n        resultVNodes[i] = itemInstance.scope.vnode as VNode;\n        orderedKeys[i] = key;\n      }\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.orderedVNodes = resultVNodes;\n      forState.pendingDirtyIndices = null;\n      forState.pendingSwapIndices = null;\n      forState.pendingMoveOnly = false;\n\n      return resultVNodes;\n    }\n  }\n\n  // FAST PATH B: TRUNCATE\n  // Guard: newLen <= oldLen && all new keys match old keys at same indices\n  if (newLen < oldLen) {\n    if (oldLen === newLen + 1) {\n      let removedIndex = -1;\n\n      for (let i = 0; i < newLen; i++) {\n        const nextKey = byFn(newArray[i], i);\n        if (nextKey !== orderedKeys[i]) {\n          removedIndex = i;\n          break;\n        }\n      }\n\n      if (removedIndex !== -1) {\n        let canUseRemoveOnePath = true;\n        for (let i = removedIndex; i < newLen; i++) {\n          const nextKey = byFn(newArray[i], i);\n          if (nextKey !== orderedKeys[i + 1]) {\n            canUseRemoveOnePath = false;\n            break;\n          }\n        }\n\n        if (canUseRemoveOnePath) {\n          recordBenchFastLane('REMOVE_ONE');\n          forState.lastCommitStrategy = 'NO_REORDER';\n\n          const previousOrderedItems = forState.orderedItems.slice();\n          const resultVNodes = forState.orderedVNodes;\n          const resultItems = forState.orderedItems;\n          resultVNodes.length = newLen;\n          resultItems.length = newLen;\n          const dirtyIndices: number[] = [];\n\n          for (let i = 0; i < newLen; i++) {\n            const item = newArray[i];\n            const key = i < removedIndex ? orderedKeys[i] : orderedKeys[i + 1];\n            const existing = items.get(key)!;\n            const scopeNeedsDomUpdate = existing.scope.needsDomUpdate;\n\n            const itemChanged = existing.item !== item;\n            const indexSignal = existing.indexSignal;\n            const indexChanged = indexSignal.peek() !== i;\n\n            if (itemChanged) {\n              updateItemInstance(forState, existing, item);\n            }\n\n            const indexVisibleChange = indexChanged\n              ? syncForItemIndex(forState, existing, i)\n              : false;\n\n            if (itemChanged || indexVisibleChange || scopeNeedsDomUpdate) {\n              dirtyIndices.push(i);\n            }\n\n            resultItems[i] = existing;\n            resultVNodes[i] = existing.scope.vnode as VNode;\n          }\n\n          recordBenchEvent('itemReused', newLen);\n\n          const removedKey = orderedKeys[removedIndex];\n          const removedItem = items.get(removedKey);\n          if (removedItem) {\n            disposeItemInstance(forState, removedItem, 'teardown');\n            items.delete(removedKey);\n          }\n\n          const nextOrderedKeys = orderedKeys.slice(0, newLen);\n          const nextOrderedItems = previousOrderedItems.slice(0, newLen);\n          for (let i = removedIndex; i < newLen; i++) {\n            nextOrderedKeys[i] = orderedKeys[i + 1];\n            nextOrderedItems[i] = previousOrderedItems[i + 1];\n          }\n          forState.orderedKeys = nextOrderedKeys;\n          forState.orderedItems = nextOrderedItems;\n\n          if (BENCH_BUILD_ENABLED) {\n            recordBenchTiming(\n              'reconcile',\n              performance.now() - reconcileStartMs\n            );\n            flushBenchMetrics();\n          }\n\n          forState.pendingDirtyIndices = dirtyIndices;\n          forState.pendingSwapIndices = null;\n          forState.pendingMoveOnly = false;\n\n          return resultVNodes;\n        }\n      }\n    }\n\n    let canUseTruncatePath = true;\n    for (let i = 0; i < newLen; i++) {\n      const key = byFn(newArray[i], i);\n      if (key !== orderedKeys[i]) {\n        canUseTruncatePath = false;\n        break;\n      }\n    }\n\n    if (canUseTruncatePath) {\n      recordBenchFastLane('TRUNCATE');\n      forState.lastCommitStrategy = 'TRUNCATE';\n      const resultVNodes = forState.orderedVNodes;\n      const resultItems = forState.orderedItems;\n      resultVNodes.length = newLen;\n      resultItems.length = newLen;\n      const isFullClear = newLen === 0;\n\n      // Update existing rows in-place\n      for (let i = 0; i < newLen; i++) {\n        const item = newArray[i];\n        const key = orderedKeys[i];\n        const existing = items.get(key)!;\n\n        updateItemInstance(forState, existing, item);\n\n        resultItems[i] = existing;\n        resultVNodes[i] = existing.scope.vnode as VNode;\n      }\n\n      recordBenchEvent('itemReused', newLen);\n\n      // Remove tail rows\n      for (let i = newLen; i < oldLen; i++) {\n        const key = orderedKeys[i];\n        const itemInstance = items.get(key);\n        if (itemInstance) {\n          disposeItemInstance(\n            forState,\n            itemInstance,\n            isFullClear ? 'full-clear' : 'teardown'\n          );\n          items.delete(key);\n        }\n      }\n\n      orderedKeys.length = newLen;\n      forState.orderedKeys = orderedKeys;\n      forState.orderedItems.length = newLen;\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.orderedVNodes = resultVNodes;\n      forState.pendingDirtyIndices = null;\n      forState.pendingSwapIndices = null;\n      forState.pendingMoveOnly = false;\n\n      return resultVNodes;\n    }\n  }\n\n  // FAST PATH C: NO-REORDER (in-place update only)\n  // Guard: oldLen === newLen && keys match at all indices\n  if (oldLen === newLen) {\n    let canUseNoReorderPath = true;\n    for (let i = 0; i < oldLen; i++) {\n      const key = byFn(newArray[i], i);\n      if (key !== orderedKeys[i]) {\n        canUseNoReorderPath = false;\n        break;\n      }\n    }\n\n    if (canUseNoReorderPath) {\n      recordBenchFastLane('NO_REORDER');\n      forState.lastCommitStrategy = 'NO_REORDER';\n      const resultVNodes = forState.orderedVNodes;\n      const resultItems = forState.orderedItems;\n      resultVNodes.length = oldLen;\n      resultItems.length = oldLen;\n      const dirtyIndices: number[] = [];\n      // Update in-place only, no DOM moves needed\n      for (let i = 0; i < oldLen; i++) {\n        const item = newArray[i];\n        const key = orderedKeys[i];\n        const existing = items.get(key)!;\n        const itemChanged = existing.item !== item;\n\n        if (itemChanged) {\n          updateItemInstance(forState, existing, item);\n        }\n\n        if (!itemChanged && existing.scope.needsDomUpdate) {\n          dirtyIndices.push(i);\n        }\n\n        resultItems[i] = existing;\n        resultVNodes[i] = existing.scope.vnode as VNode;\n      }\n\n      recordBenchEvent('itemReused', oldLen);\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.pendingDirtyIndices = dirtyIndices;\n      forState.pendingSwapIndices = null;\n      forState.pendingMoveOnly = false;\n\n      return resultVNodes;\n    }\n\n    let firstMismatch = -1;\n    let secondMismatch = -1;\n    let firstMismatchKey: string | number | null = null;\n    let secondMismatchKey: string | number | null = null;\n    let mismatchCount = 0;\n    let canUseSwapPath = true;\n\n    for (let i = 0; i < oldLen; i++) {\n      const item = newArray[i];\n      const key = byFn(newArray[i], i);\n      if (key === orderedKeys[i]) {\n        const existing = items.get(key);\n        if (existing && existing.item !== item) {\n          canUseSwapPath = false;\n          break;\n        }\n        continue;\n      }\n\n      mismatchCount++;\n      if (firstMismatch === -1) {\n        firstMismatch = i;\n        firstMismatchKey = key;\n        continue;\n      }\n\n      if (secondMismatch === -1) {\n        secondMismatch = i;\n        secondMismatchKey = key;\n        continue;\n      }\n\n      mismatchCount = 3;\n      break;\n    }\n\n    if (\n      canUseSwapPath &&\n      mismatchCount === 2 &&\n      firstMismatch !== -1 &&\n      secondMismatch !== -1 &&\n      firstMismatchKey === orderedKeys[secondMismatch] &&\n      secondMismatchKey === orderedKeys[firstMismatch]\n    ) {\n      recordBenchFastLane('SWAP');\n      recordBenchEvent('itemMoved');\n      recordBenchEvent('itemMoved');\n\n      forState.lastCommitStrategy = 'SWAP';\n\n      const nextOrderedKeys = orderedKeys.slice();\n      nextOrderedKeys[firstMismatch] = firstMismatchKey;\n      nextOrderedKeys[secondMismatch] = secondMismatchKey;\n\n      const resultVNodes = forState.orderedVNodes;\n      const firstExisting = items.get(firstMismatchKey)!;\n      const secondExisting = items.get(secondMismatchKey)!;\n      const firstItem = newArray[firstMismatch];\n      const secondItem = newArray[secondMismatch];\n      const nextOrderedItems = forState.orderedItems.slice();\n      nextOrderedItems[firstMismatch] = secondExisting;\n      nextOrderedItems[secondMismatch] = firstExisting;\n\n      recordBenchEvent('itemReused');\n      recordBenchEvent('itemReused');\n\n      if (firstExisting.item !== firstItem) {\n        updateItemInstance(forState, firstExisting, firstItem);\n      }\n\n      if (secondExisting.item !== secondItem) {\n        updateItemInstance(forState, secondExisting, secondItem);\n      }\n\n      syncForItemIndex(forState, firstExisting, firstMismatch);\n\n      syncForItemIndex(forState, secondExisting, secondMismatch);\n\n      resultVNodes[firstMismatch] = firstExisting.scope.vnode as VNode;\n      resultVNodes[secondMismatch] = secondExisting.scope.vnode as VNode;\n\n      forState.orderedKeys = nextOrderedKeys;\n      forState.orderedItems = nextOrderedItems;\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.pendingDirtyIndices = null;\n      forState.pendingSwapIndices = [firstMismatch, secondMismatch];\n      forState.pendingMoveOnly = true;\n\n      return resultVNodes;\n    }\n\n    let canUseMoveOnlyPath = true;\n    const moveOnlyKeys: Array<string | number> = [];\n    const moveOnlyItems: ForItemInstance<T>[] = [];\n    const moveOnlyVNodes: VNode[] = [];\n\n    for (let i = 0; i < oldLen; i++) {\n      const item = newArray[i];\n      const key = byFn(item, i);\n      const existing = items.get(key);\n\n      if (\n        !existing ||\n        existing.item !== item ||\n        (existing.indexSignal._hasBeenRead && existing.indexSignal.peek() !== i)\n      ) {\n        canUseMoveOnlyPath = false;\n        break;\n      }\n\n      moveOnlyKeys[i] = key;\n      moveOnlyItems[i] = existing;\n      moveOnlyVNodes[i] = existing.scope.vnode as VNode;\n      recordBenchEvent('itemReused');\n    }\n\n    if (canUseMoveOnlyPath) {\n      recordBenchFastLane('FULL_KEYED');\n      forState.lastCommitStrategy = 'FULL_KEYED';\n\n      for (let i = 0; i < moveOnlyItems.length; i++) {\n        syncForItemIndex(forState, moveOnlyItems[i], i);\n        moveOnlyVNodes[i] = moveOnlyItems[i].scope.vnode as VNode;\n      }\n\n      forState.orderedKeys = moveOnlyKeys;\n      forState.orderedItems = moveOnlyItems;\n      forState.orderedVNodes = moveOnlyVNodes;\n\n      if (BENCH_BUILD_ENABLED) {\n        recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n        flushBenchMetrics();\n      }\n\n      forState.pendingDirtyIndices = null;\n      forState.pendingSwapIndices = null;\n      forState.pendingMoveOnly = true;\n\n      return moveOnlyVNodes;\n    }\n  }\n\n  // FULL KEYED RECONCILIATION (slow path for complex reorders)\n  // Avoid allocating newKeyMap: iterate directly and track removals\n  recordBenchFastLane('FULL_KEYED');\n  forState.lastCommitStrategy = 'FULL_KEYED';\n\n  const toRemove = new Set(orderedKeys);\n  const newOrderedKeys: Array<string | number> = [];\n  const newOrderedItems: ForItemInstance<T>[] = [];\n  const resultVNodes: VNode[] = [];\n  let moveOnly = toRemove.size === newArray.length;\n\n  // Single pass: iterate new array directly, no intermediate map\n  for (let i = 0; i < newArray.length; i++) {\n    const item = newArray[i];\n    const key = byFn(item, i);\n    recordBenchEvent('keyLookup');\n\n    toRemove.delete(key);\n    newOrderedKeys.push(key);\n\n    const existing = items.get(key);\n    recordBenchEvent(existing ? 'keyHit' : 'keyMiss');\n\n    if (!existing) {\n      // Added: create new item instance\n      const itemInstance = createItemInstance(key, item, i, forState);\n      items.set(key, itemInstance);\n      newOrderedItems.push(itemInstance);\n      resultVNodes.push(itemInstance.scope.vnode as VNode);\n    } else {\n      // Exists: check if item changed (by identity)\n      recordBenchEvent('itemReused');\n      const itemChanged = existing.item !== item;\n      const indexChanged = existing.indexSignal.peek() !== i;\n\n      if (itemChanged) {\n        moveOnly = false;\n        updateItemInstance(forState, existing, item);\n      }\n\n      if (indexChanged) {\n        // Index changed: update index signal (triggers re-render if index is used)\n        syncForItemIndex(forState, existing, i);\n      }\n\n      newOrderedItems.push(existing);\n      resultVNodes.push(existing.scope.vnode as VNode);\n    }\n  }\n\n  // Remove deleted items\n  for (const key of toRemove) {\n    moveOnly = false;\n    const itemInstance = items.get(key);\n    if (itemInstance) {\n      disposeItemInstance(forState, itemInstance, 'none');\n      items.delete(key);\n    }\n  }\n\n  forState.orderedKeys = newOrderedKeys;\n  forState.orderedItems = newOrderedItems;\n\n  // Record reconcile timing\n  if (BENCH_BUILD_ENABLED) {\n    recordBenchTiming('reconcile', performance.now() - reconcileStartMs);\n    flushBenchMetrics();\n  }\n\n  forState.orderedVNodes = resultVNodes;\n  forState.pendingDirtyIndices = null;\n  forState.pendingSwapIndices = null;\n  forState.pendingMoveOnly = moveOnly;\n\n  return resultVNodes;\n}\n"],"mappings":"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"}

package/dist/runtime/for-scopes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-scopes.d.ts","names":[],"sources":["../../src/runtime/for-scopes.ts"],"mappings":";;;;;;UA+BiB,eAAA;EACf,GAAA;EACA,IAAA,EAAM,CAAA;EACN,YAAA,EAAc,CAAA;EACd,UAAA,EAAY,aAAA,CAAc,CAAA;EAC1B,mBAAA,EAAqB,GAAA,CAAI,WAAA,EAAa,qBAAA;EACtC,WAAA,EAAa,cAAA;EACb,KAAA,EAAO,UAAA;AAAA;AAAA,KAGG,qBAAA;AAAA,iBAMI,gBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,YAAA,EAAc,eAAA,CAAgB,CAAA,GAC9B,SAAA;AAAA,iBAmDc,mBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,YAAA,EAAc,eAAA,CAAgB,CAAA,GAC9B,UAAA,EAAY,qBAAA;AAAA,iBA0BE,kBAAA,IACd,GAAA,mBACA,IAAA,EAAM,CAAA,EACN,KAAA,UACA,QAAA,EAAU,QAAA,CAAS,CAAA,IAClB,eAAA,CAAgB,CAAA;AAAA,iBAkDH,kBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,YAAA,EAAc,eAAA,CAAgB,CAAA,GAC9B,IAAA,EAAM,CAAA;AAAA,iBAgEQ,oBAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,UAAA,EAAY,qBAAA;AAAA,iBAwBE,mBAAA,IAAuB,QAAA,EAAU,QAAA,CAAS,CAAA,IAAK,KAAA;AAAA,iBA4B/C,eAAA,IACd,QAAA,EAAU,QAAA,CAAS,CAAA,GACnB,UAAA,EAAY,qBAAA"}

package/dist/runtime/for-scopes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-scopes.js","names":[],"sources":["../../src/runtime/for-scopes.ts"],"sourcesContent":["/**\n * For item and fallback child-scope ownership.\n */\n\nimport type { DOMElement, VNode } from '../common/vnode';\nimport { isDevelopmentEnvironment } from '../common/env';\nimport type { ComponentInstance } from './component';\nimport {\n  createChildScope,\n  disposeChildScope,\n  type ChildScope,\n} from './child-scope';\nimport {\n  canProxyForItem,\n  createForIndexSignal,\n  createForItemSignal,\n  createReactiveForItem,\n  haveSameOwnKeys,\n  notifyForSignalReaders,\n  readForItemProperty,\n  removeForParentReaders,\n  scopeReadsSource,\n  syncForIndexSignal,\n  type ForIndexSignal,\n  type ForItemPropertySignal,\n  type ForItemSignal,\n} from './for-signals';\nimport { getRuntimeRenderer } from './access';\nimport { recordBenchEvent } from './for-bench';\nimport type { ForState } from './for-internal';\n\nexport interface ForItemInstance<T> {\n  key: string | number;\n  item: T;\n  reactiveItem: T;\n  itemSignal: ForItemSignal<T> | null;\n  itemPropertySignals: Map<PropertyKey, ForItemPropertySignal> | null;\n  indexSignal: ForIndexSignal;\n  scope: ChildScope;\n}\n\nexport type RemovedDomCleanupMode = 'none' | 'teardown' | 'full-clear';\n\nfunction enqueueForScopeUpdate(parent: ComponentInstance | null): void {\n  parent?._enqueueRun?.();\n}\n\nexport function syncForItemIndex<T>(\n  forState: ForState<T>,\n  itemInstance: ForItemInstance<T>,\n  nextIndex: number\n): boolean {\n  const indexSignal = itemInstance.indexSignal;\n  if (indexSignal.peek() === nextIndex) {\n    return false;\n  }\n\n  const scopeReadsIndex = scopeReadsSource(itemInstance.scope, indexSignal);\n  if (!scopeReadsIndex) {\n    syncForIndexSignal(indexSignal, nextIndex);\n    return false;\n  }\n\n  indexSignal.set(nextIndex, false);\n  notifyForSignalReaders(indexSignal, itemInstance.scope.componentInstance);\n\n  rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);\n\n  return true;\n}\n\nfunction materializeItemVnode(\n  key: string | number,\n  vnode: VNode | undefined\n): void {\n  if (vnode && typeof vnode === 'object' && 'type' in vnode) {\n    const vn = vnode as DOMElement;\n    vn.key = key;\n\n    if (typeof vn.type === 'string') {\n      if (!vn.props) vn.props = {};\n      if (vn.props['data-key'] === undefined) {\n        vn.props['data-key'] = String(key);\n      }\n    }\n  }\n}\n\nfunction renderItemScope<T>(\n  forState: ForState<T>,\n  scope: ChildScope,\n  item: T,\n  indexSignal: ForIndexSignal,\n  key: string | number\n): VNode {\n  recordBenchEvent('rowFactory');\n  const vnode = scope.render(() => forState.renderFn(item, indexSignal));\n  materializeItemVnode(key, vnode);\n  return vnode;\n}\n\nexport function disposeItemInstance<T>(\n  forState: ForState<T>,\n  itemInstance: ForItemInstance<T>,\n  domCleanup: RemovedDomCleanupMode\n): void {\n  recordBenchEvent('itemRemoved');\n  const removedDom = itemInstance.scope.dom;\n\n  try {\n    disposeChildScope(itemInstance.scope);\n  } catch (err) {\n    if (isDevelopmentEnvironment()) {\n      console.error('[For] Cleanup error:', err);\n    }\n  }\n\n  if (!removedDom) {\n    return;\n  }\n\n  if (removedDom instanceof Element) {\n    if (domCleanup === 'teardown') {\n      getRuntimeRenderer().teardownNodeSubtree(removedDom);\n    }\n  }\n\n  forState.lastRemovedNodes.push(removedDom);\n}\n\nexport function createItemInstance<T>(\n  key: string | number,\n  item: T,\n  index: number,\n  forState: ForState<T>\n): ForItemInstance<T> {\n  recordBenchEvent('itemCreated');\n\n  // Create index signal manually without going through state() hook\n  // to avoid hook order violations (each For item creates its signal dynamically)\n  const indexSignal = createForIndexSignal(index);\n  const itemSignal = canProxyForItem(item) ? createForItemSignal(item) : null;\n  const itemPropertySignals = itemSignal\n    ? new Map<PropertyKey, ForItemPropertySignal>()\n    : null;\n  const reactiveItem =\n    itemSignal && itemPropertySignals\n      ? createReactiveForItem(itemSignal, itemPropertySignals)\n      : item;\n  const scope = createChildScope(forState.parentInstance, key, () => {\n    if (forState._enqueueBoundaryCommit) {\n      forState._enqueueBoundaryCommit();\n      return;\n    }\n\n    enqueueForScopeUpdate(forState.parentInstance);\n  });\n\n  renderItemScope(forState, scope, reactiveItem, indexSignal, key);\n\n  return {\n    key,\n    item,\n    reactiveItem,\n    itemSignal,\n    itemPropertySignals,\n    indexSignal,\n    scope,\n  };\n}\n\nfunction rerenderItemInstance<T>(\n  forState: ForState<T>,\n  itemInstance: ForItemInstance<T>,\n  item: T\n): void {\n  renderItemScope(\n    forState,\n    itemInstance.scope,\n    item,\n    itemInstance.indexSignal,\n    itemInstance.key\n  );\n}\n\nexport function updateItemInstance<T>(\n  forState: ForState<T>,\n  itemInstance: ForItemInstance<T>,\n  item: T\n): boolean {\n  if (itemInstance.item === item) {\n    return false;\n  }\n\n  const previousItem = itemInstance.item;\n  itemInstance.item = item;\n\n  const scope = itemInstance.scope;\n  let scopeReadsChangedSignal = false;\n  const itemSignal = itemInstance.itemSignal;\n  if (!itemSignal) {\n    rerenderItemInstance(forState, itemInstance, item);\n    return true;\n  }\n\n  const propertySignals = itemInstance.itemPropertySignals;\n  const changedPropertySignals: Array<[ForItemPropertySignal, unknown]> = [];\n  if (propertySignals && propertySignals.size > 0) {\n    for (const [prop, propertySignal] of propertySignals) {\n      const previousValue = readForItemProperty(previousItem, prop);\n      const nextValue = readForItemProperty(item, prop);\n      if (Object.is(previousValue, nextValue)) {\n        continue;\n      }\n\n      if (scopeReadsSource(scope, propertySignal)) {\n        scopeReadsChangedSignal = true;\n      }\n\n      changedPropertySignals.push([propertySignal, nextValue]);\n    }\n  }\n\n  if (scopeReadsSource(scope, itemSignal)) {\n    scopeReadsChangedSignal = true;\n  }\n\n  const itemShapeChanged =\n    changedPropertySignals.length === 0 && !haveSameOwnKeys(previousItem, item);\n  const notifyReaders =\n    !scopeReadsChangedSignal &&\n    (changedPropertySignals.length > 0 || itemShapeChanged);\n  const visibleChange =\n    scopeReadsChangedSignal ||\n    changedPropertySignals.length > 0 ||\n    itemShapeChanged;\n  for (const [propertySignal, nextValue] of changedPropertySignals) {\n    removeForParentReaders(forState.parentInstance, propertySignal);\n    propertySignal.set(nextValue, notifyReaders);\n  }\n  removeForParentReaders(forState.parentInstance, itemSignal);\n  itemSignal.set(item, notifyReaders);\n\n  if (scopeReadsChangedSignal) {\n    rerenderItemInstance(forState, itemInstance, itemInstance.reactiveItem);\n  }\n\n  return visibleChange;\n}\n\nconst FOR_FALLBACK_SCOPE_KEY = '__for-fallback__';\n\nexport function disposeFallbackScope<T>(\n  forState: ForState<T>,\n  domCleanup: RemovedDomCleanupMode\n): void {\n  const fallbackScope = forState.fallbackScope;\n  if (!fallbackScope) {\n    return;\n  }\n\n  const removedDom = fallbackScope.dom;\n  disposeChildScope(fallbackScope);\n  forState.fallbackScope = null;\n\n  if (!removedDom) {\n    return;\n  }\n\n  if (removedDom instanceof Element) {\n    if (domCleanup === 'teardown') {\n      getRuntimeRenderer().teardownNodeSubtree(removedDom);\n    }\n  }\n\n  forState.lastRemovedNodes.push(removedDom);\n}\n\nexport function renderFallbackScope<T>(forState: ForState<T>): VNode[] {\n  if (forState.fallback == null || forState.fallback === false) {\n    if (forState.fallbackScope) {\n      disposeFallbackScope(forState, 'none');\n    }\n    forState.orderedVNodes = [];\n    forState.orderedItems = [];\n    return [];\n  }\n\n  const fallbackScope =\n    forState.fallbackScope ??\n    createChildScope(forState.parentInstance, FOR_FALLBACK_SCOPE_KEY, () => {\n      if (forState._enqueueBoundaryCommit) {\n        forState._enqueueBoundaryCommit();\n        return;\n      }\n\n      enqueueForScopeUpdate(forState.parentInstance);\n    });\n  forState.fallbackScope = fallbackScope;\n\n  const vnode = fallbackScope.render(() => forState.fallback as VNode);\n  forState.orderedVNodes = vnode == null || vnode === false ? [] : [vnode];\n  forState.orderedItems = [];\n  return forState.orderedVNodes;\n}\n\nexport function disposeAllItems<T>(\n  forState: ForState<T>,\n  domCleanup: RemovedDomCleanupMode\n): void {\n  const { items, orderedKeys } = forState;\n  for (let index = 0; index < orderedKeys.length; index += 1) {\n    const key = orderedKeys[index];\n    const itemInstance = items.get(key);\n    if (!itemInstance) {\n      continue;\n    }\n    disposeItemInstance(forState, itemInstance, domCleanup);\n    items.delete(key);\n  }\n  orderedKeys.length = 0;\n  forState.orderedKeys = orderedKeys;\n}\n"],"mappings":";;;;;;AA2CA,SAAS,sBAAsB,QAAwC;CACrE,QAAQ,cAAc;AACxB;AAEA,SAAgB,iBACd,UACA,cACA,WACS;CACT,MAAM,cAAc,aAAa;CACjC,IAAI,YAAY,KAAK,MAAM,WACzB,OAAO;CAIT,IAAI,CADoB,iBAAiB,aAAa,OAAO,WACxD,GAAiB;EACpB,mBAAmB,aAAa,SAAS;EACzC,OAAO;CACT;CAEA,YAAY,IAAI,WAAW,KAAK;CAChC,uBAAuB,aAAa,aAAa,MAAM,iBAAiB;CAExE,qBAAqB,UAAU,cAAc,aAAa,YAAY;CAEtE,OAAO;AACT;AAEA,SAAS,qBACP,KACA,OACM;CACN,IAAI,SAAS,OAAO,UAAU,YAAY,UAAU,OAAO;EACzD,MAAM,KAAK;EACX,GAAG,MAAM;EAET,IAAI,OAAO,GAAG,SAAS,UAAU;GAC/B,IAAI,CAAC,GAAG,OAAO,GAAG,QAAQ,CAAC;GAC3B,IAAI,GAAG,MAAM,gBAAgB,QAC3B,GAAG,MAAM,cAAc,OAAO,GAAG;EAErC;CACF;AACF;AAEA,SAAS,gBACP,UACA,OACA,MACA,aACA,KACO;CACP,iBAAiB,YAAY;CAC7B,MAAM,QAAQ,MAAM,aAAa,SAAS,SAAS,MAAM,WAAW,CAAC;CACrE,qBAAqB,KAAK,KAAK;CAC/B,OAAO;AACT;AAEA,SAAgB,oBACd,UACA,cACA,YACM;CACN,iBAAiB,aAAa;CAC9B,MAAM,aAAa,aAAa,MAAM;CAEtC,IAAI;EACF,kBAAkB,aAAa,KAAK;CACtC,SAAS,KAAK;EACZ,IAAI,yBAAyB,GAC3B,QAAQ,MAAM,wBAAwB,GAAG;CAE7C;CAEA,IAAI,CAAC,YACH;CAGF,IAAI,sBAAsB,SACxB;MAAI,eAAe,YACjB,mBAAmB,CAAC,CAAC,oBAAoB,UAAU;CACrD;CAGF,SAAS,iBAAiB,KAAK,UAAU;AAC3C;AAEA,SAAgB,mBACd,KACA,MACA,OACA,UACoB;CACpB,iBAAiB,aAAa;CAI9B,MAAM,cAAc,qBAAqB,KAAK;CAC9C,MAAM,aAAa,gBAAgB,IAAI,IAAI,oBAAoB,IAAI,IAAI;CACvE,MAAM,sBAAsB,6BACxB,IAAI,IAAwC,IAC5C;CACJ,MAAM,eACJ,cAAc,sBACV,sBAAsB,YAAY,mBAAmB,IACrD;CACN,MAAM,QAAQ,iBAAiB,SAAS,gBAAgB,WAAW;EACjE,IAAI,SAAS,wBAAwB;GACnC,SAAS,uBAAuB;GAChC;EACF;EAEA,sBAAsB,SAAS,cAAc;CAC/C,CAAC;CAED,gBAAgB,UAAU,OAAO,cAAc,aAAa,GAAG;CAE/D,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF;AAEA,SAAS,qBACP,UACA,cACA,MACM;CACN,gBACE,UACA,aAAa,OACb,MACA,aAAa,aACb,aAAa,GACf;AACF;AAEA,SAAgB,mBACd,UACA,cACA,MACS;CACT,IAAI,aAAa,SAAS,MACxB,OAAO;CAGT,MAAM,eAAe,aAAa;CAClC,aAAa,OAAO;CAEpB,MAAM,QAAQ,aAAa;CAC3B,IAAI,0BAA0B;CAC9B,MAAM,aAAa,aAAa;CAChC,IAAI,CAAC,YAAY;EACf,qBAAqB,UAAU,cAAc,IAAI;EACjD,OAAO;CACT;CAEA,MAAM,kBAAkB,aAAa;CACrC,MAAM,yBAAkE,CAAC;CACzE,IAAI,mBAAmB,gBAAgB,OAAO,GAC5C,KAAK,MAAM,CAAC,MAAM,mBAAmB,iBAAiB;EACpD,MAAM,gBAAgB,oBAAoB,cAAc,IAAI;EAC5D,MAAM,YAAY,oBAAoB,MAAM,IAAI;EAChD,IAAI,OAAO,GAAG,eAAe,SAAS,GACpC;EAGF,IAAI,iBAAiB,OAAO,cAAc,GACxC,0BAA0B;EAG5B,uBAAuB,KAAK,CAAC,gBAAgB,SAAS,CAAC;CACzD;CAGF,IAAI,iBAAiB,OAAO,UAAU,GACpC,0BAA0B;CAG5B,MAAM,mBACJ,uBAAuB,WAAW,KAAK,CAAC,gBAAgB,cAAc,IAAI;CAC5E,MAAM,gBACJ,CAAC,4BACA,uBAAuB,SAAS,KAAK;CACxC,MAAM,gBACJ,2BACA,uBAAuB,SAAS,KAChC;CACF,KAAK,MAAM,CAAC,gBAAgB,cAAc,wBAAwB;EAChE,uBAAuB,SAAS,gBAAgB,cAAc;EAC9D,eAAe,IAAI,WAAW,aAAa;CAC7C;CACA,uBAAuB,SAAS,gBAAgB,UAAU;CAC1D,WAAW,IAAI,MAAM,aAAa;CAElC,IAAI,yBACF,qBAAqB,UAAU,cAAc,aAAa,YAAY;CAGxE,OAAO;AACT;AAEA,MAAM,yBAAyB;AAE/B,SAAgB,qBACd,UACA,YACM;CACN,MAAM,gBAAgB,SAAS;CAC/B,IAAI,CAAC,eACH;CAGF,MAAM,aAAa,cAAc;CACjC,kBAAkB,aAAa;CAC/B,SAAS,gBAAgB;CAEzB,IAAI,CAAC,YACH;CAGF,IAAI,sBAAsB,SACxB;MAAI,eAAe,YACjB,mBAAmB,CAAC,CAAC,oBAAoB,UAAU;CACrD;CAGF,SAAS,iBAAiB,KAAK,UAAU;AAC3C;AAEA,SAAgB,oBAAuB,UAAgC;CACrE,IAAI,SAAS,YAAY,QAAQ,SAAS,aAAa,OAAO;EAC5D,IAAI,SAAS,eACX,qBAAqB,UAAU,MAAM;EAEvC,SAAS,gBAAgB,CAAC;EAC1B,SAAS,eAAe,CAAC;EACzB,OAAO,CAAC;CACV;CAEA,MAAM,gBACJ,SAAS,iBACT,iBAAiB,SAAS,gBAAgB,8BAA8B;EACtE,IAAI,SAAS,wBAAwB;GACnC,SAAS,uBAAuB;GAChC;EACF;EAEA,sBAAsB,SAAS,cAAc;CAC/C,CAAC;CACH,SAAS,gBAAgB;CAEzB,MAAM,QAAQ,cAAc,aAAa,SAAS,QAAiB;CACnE,SAAS,gBAAgB,SAAS,QAAQ,UAAU,QAAQ,CAAC,IAAI,CAAC,KAAK;CACvE,SAAS,eAAe,CAAC;CACzB,OAAO,SAAS;AAClB;AAEA,SAAgB,gBACd,UACA,YACM;CACN,MAAM,EAAE,OAAO,gBAAgB;CAC/B,KAAK,IAAI,QAAQ,GAAG,QAAQ,YAAY,QAAQ,SAAS,GAAG;EAC1D,MAAM,MAAM,YAAY;EACxB,MAAM,eAAe,MAAM,IAAI,GAAG;EAClC,IAAI,CAAC,cACH;EAEF,oBAAoB,UAAU,cAAc,UAAU;EACtD,MAAM,OAAO,GAAG;CAClB;CACA,YAAY,SAAS;CACrB,SAAS,cAAc;AACzB"}

package/dist/runtime/for-signals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-signals.d.ts","names":[],"sources":["../../src/runtime/for-signals.ts"],"mappings":";;;;;KAUY,aAAA,MAAmB,cAAA,CAAe,CAAA,WACrC,CAAA;EACL,IAAA,IAAQ,CAAA;EACR,GAAA,CAAI,QAAA,EAAU,CAAA,EAAG,aAAA;AAAA;AAAA,KAGT,qBAAA,GAAwB,cAAc;EAE9C,IAAA;EACA,GAAA,CAAI,QAAA,WAAmB,aAAA;AAAA;AAAA,KAGf,cAAA,GAAiB,cAAc;EAEvC,IAAA;EACA,GAAA,CACE,QAAA,aAAqB,IAAA,sBACrB,aAAA;AAAA;AAAA,iBAIU,sBAAA,CACd,MAAA,EAAQ,cAAA,WACR,YAAA,GAAe,iBAAiB;AAAA,iBAOlB,oBAAA,CAAqB,YAAA,WAAuB,cAAc;AAAA,iBA6B1D,kBAAA,CACd,WAAA,EAAa,cAAc,EAC3B,SAAA;AAAA,iBAUc,mBAAA,IAAuB,WAAA,EAAa,CAAA,GAAI,aAAA,CAAc,CAAA;AAAA,iBAwDtD,mBAAA,CAAoB,IAAA,WAAe,IAAA,EAAM,WAAW;AAAA,iBAIpD,eAAA,CACd,YAAA,WACA,QAAiB;AAAA,iBAkBH,gBAAA,CACd,KAAA,EAAO,UAAA,EACP,MAAA,EAAQ,cAAc;AAAA,iBAqBR,sBAAA,CACd,cAAA,EAAgB,iBAAA,SAChB,MAAA,EAAQ,cAAc;AAAA,iBA+BR,eAAA,CAAgB,IAAA,YAAgB,IAAI;AAAA,iBAMpC,qBAAA,IACd,UAAA,EAAY,aAAA,CAAc,CAAA,GAC1B,eAAA,EAAiB,GAAA,CAAI,WAAA,EAAa,qBAAA,IACjC,CAAA"}