@fictjs/runtime 0.0.15 → 0.2.0

package/dist/{props-ES0Ag_Wd.d.ts → props-CBwuh35e.d.cts}

@@ -1,17 +1,20 @@
-import { C as Cleanup, F as FictNode, D as DOMElement } from './effect-Auji1rz9.js';
-
-type Memo<T> = () => T;
-declare function createMemo<T>(fn: () => T): Memo<T>;
+import { C as Cleanup, F as FictNode, D as DOMElement } from './effect-ClARNUCc.cjs';
 
 type LifecycleFn = () => void | Cleanup;
+interface CreateRootOptions {
+    inherit?: boolean;
+}
 declare function onMount(fn: LifecycleFn): void;
 declare function onDestroy(fn: LifecycleFn): void;
 declare function onCleanup(fn: Cleanup): void;
-declare function createRoot<T>(fn: () => T): {
+declare function createRoot<T>(fn: () => T, options?: CreateRootOptions): {
     dispose: () => void;
     value: T;
 };
 
+type Memo<T> = () => T;
+declare function createMemo<T>(fn: () => T): Memo<T>;
+
 declare const Fragment: unique symbol;
 declare namespace JSX {
     type Element = FictNode;
@@ -741,9 +744,13 @@ declare function mergeProps<T extends Record<string, unknown>>(...sources: (Merg
 type PropGetter<T> = (() => T) & {
     __fictProp: true;
 };
+interface PropOptions {
+    unwrap?: boolean;
+}
 /**
  * Memoize a prop getter to cache expensive computations.
  * Use when prop expressions involve heavy calculations or you need lazy, reactive props.
+ * Set { unwrap: false } to keep nested prop getters as values.
  *
  * @example
  * ```tsx
@@ -755,6 +762,6 @@ type PropGetter<T> = (() => T) & {
  * <Child data={memoizedData} />
  * ```
  */
-declare function prop<T>(getter: () => T): PropGetter<T>;
+declare function prop<T>(getter: () => T, options?: PropOptions): PropGetter<T>;
 
 export { Fragment as F, JSX as J, type Memo as M, __fictProp as _, onDestroy as a, onCleanup as b, createMemo as c, createRoot as d, createElement as e, __fictPropsRest as f, createPropsProxy as g, mergeProps as m, onMount as o, prop as p, render as r, template as t };

package/dist/{props-CrOMYbLv.d.cts → props-DAyeRPwH.d.ts}

@@ -1,17 +1,20 @@
-import { C as Cleanup, F as FictNode, D as DOMElement } from './effect-Auji1rz9.cjs';
-
-type Memo<T> = () => T;
-declare function createMemo<T>(fn: () => T): Memo<T>;
+import { C as Cleanup, F as FictNode, D as DOMElement } from './effect-ClARNUCc.js';
 
 type LifecycleFn = () => void | Cleanup;
+interface CreateRootOptions {
+    inherit?: boolean;
+}
 declare function onMount(fn: LifecycleFn): void;
 declare function onDestroy(fn: LifecycleFn): void;
 declare function onCleanup(fn: Cleanup): void;
-declare function createRoot<T>(fn: () => T): {
+declare function createRoot<T>(fn: () => T, options?: CreateRootOptions): {
     dispose: () => void;
     value: T;
 };
 
+type Memo<T> = () => T;
+declare function createMemo<T>(fn: () => T): Memo<T>;
+
 declare const Fragment: unique symbol;
 declare namespace JSX {
     type Element = FictNode;
@@ -741,9 +744,13 @@ declare function mergeProps<T extends Record<string, unknown>>(...sources: (Merg
 type PropGetter<T> = (() => T) & {
     __fictProp: true;
 };
+interface PropOptions {
+    unwrap?: boolean;
+}
 /**
  * Memoize a prop getter to cache expensive computations.
  * Use when prop expressions involve heavy calculations or you need lazy, reactive props.
+ * Set { unwrap: false } to keep nested prop getters as values.
  *
  * @example
  * ```tsx
@@ -755,6 +762,6 @@ type PropGetter<T> = (() => T) & {
  * <Child data={memoizedData} />
  * ```
  */
-declare function prop<T>(getter: () => T): PropGetter<T>;
+declare function prop<T>(getter: () => T, options?: PropOptions): PropGetter<T>;
 
 export { Fragment as F, JSX as J, type Memo as M, __fictProp as _, onDestroy as a, onCleanup as b, createMemo as c, createRoot as d, createElement as e, __fictPropsRest as f, createPropsProxy as g, mergeProps as m, onMount as o, prop as p, render as r, template as t };

package/dist/{scope-S6eAzBJZ.d.ts → scope-DvgMquEy.d.ts}

@@ -1,4 +1,4 @@
-import { O as MaybeReactive } from './effect-Auji1rz9.js';
+import { O as MaybeReactive } from './effect-ClARNUCc.js';
 
 /**
  * Signal accessor - function to get/set signal value

package/dist/{scope-DKYzWfTn.d.cts → scope-xmdo6lVU.d.cts}

@@ -1,4 +1,4 @@
-import { O as MaybeReactive } from './effect-Auji1rz9.cjs';
+import { O as MaybeReactive } from './effect-ClARNUCc.cjs';
 
 /**
  * Signal accessor - function to get/set signal value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fictjs/runtime",
-  "version": "0.0.15",
+  "version": "0.2.0",
   "description": "Fict reactive runtime",
   "publishConfig": {
     "access": "public",

package/src/binding.ts

@@ -36,7 +36,7 @@ import {
 } from './lifecycle'
 import { toNodeArray, removeNodes, insertNodesBefore } from './node-ops'
 import { batch } from './scheduler'
-import { computed, untrack } from './signal'
+import { computed, untrack, isSignal, isComputed, isEffect, isEffectScope } from './signal'
 import type { Cleanup, FictNode } from './types'
 
 const isDev =
@@ -70,11 +70,43 @@ export interface BindingHandle {
 // ============================================================================
 
 /**
- * Check if a value is reactive (a getter function)
- * Note: Event handlers (functions that take arguments) are NOT reactive values
+ * Check if a value is reactive (a getter function that returns a value).
+ *
+ * A value is considered reactive if:
+ * 1. It's a signal or computed value created by the runtime (marked with Symbol)
+ * 2. It's a zero-argument function (getter pattern used by the compiler)
+ *
+ * NOT considered reactive:
+ * - Event handlers (functions that take arguments)
+ * - Effect disposers (zero-arg but for cleanup, not value access)
+ * - Effect scopes (zero-arg but for scope management)
+ *
+ * @param value - The value to check
+ * @returns true if the value is a reactive getter
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0)
+ * isReactive(count)          // true - signal accessor
+ * isReactive(() => 42)       // true - getter pattern
+ * isReactive((x) => x)       // false - takes argument
+ * isReactive('hello')        // false - not a function
+ * isReactive(effectDisposer) // false - effect cleanup function
+ * ```
  */
 export function isReactive(value: unknown): value is () => unknown {
-  return typeof value === 'function' && value.length === 0
+  if (typeof value !== 'function') return false
+
+  // Check for runtime-created signals/computed (most reliable)
+  if (isSignal(value) || isComputed(value)) return true
+
+  // Exclude effect disposers and effect scopes - they are zero-arg
+  // functions but not reactive getters
+  if (isEffect(value) || isEffectScope(value)) return false
+
+  // Fall back to length check for compiler-generated getters
+  // Zero-argument functions are treated as reactive getters
+  return value.length === 0
 }
 
 /**
@@ -590,6 +622,7 @@ export function insert(
     const root = createRootContext(hostRoot)
     const prev = pushRoot(root)
     let nodes: Node[] = []
+    let handledError = false
     try {
       let newNode: Node | Node[]
 
@@ -614,14 +647,34 @@ export function insert(
       }
 
       nodes = toNodeArray(newNode)
+      if (root.suspended) {
+        handledError = true
+        destroyRoot(root)
+        return
+      }
       if (parentNode) {
         insertNodesBefore(parentNode, nodes, marker)
       }
+    } catch (err) {
+      if (handleSuspend(err as any, root)) {
+        handledError = true
+        destroyRoot(root)
+        return
+      }
+      if (handleError(err, { source: 'renderChild' }, root)) {
+        handledError = true
+        destroyRoot(root)
+        return
+      }
+      throw err
     } finally {
       popRoot(prev)
-      flushOnMount(root)
+      if (!handledError) {
+        flushOnMount(root)
+      }
     }
 
+    // If we reach here, no error was handled (handledError blocks return early)
     currentRoot = root
     currentNodes = nodes
   })
@@ -952,9 +1005,10 @@ export function bindEvent(
   const rootRef = getCurrentRoot()
 
   // Optimization: Global Event Delegation
-  // If the event is delegatable and no special options (capture, passive) are used,
+  // If the event is delegatable and no options were provided,
   // we attach the handler to the element property and rely on the global listener.
-  if (isDev && DelegatedEvents.has(eventName) && !options) {
+  const shouldDelegate = options == null && DelegatedEvents.has(eventName)
+  if (shouldDelegate) {
     const key = `$$${eventName}`
 
     // Ensure global delegation is active for this event
@@ -1235,7 +1289,7 @@ function assignProp(
   // Standard event handling: onClick, onInput, etc.
   if (prop.slice(0, 2) === 'on') {
     const eventName = prop.slice(2).toLowerCase()
-    const shouldDelegate = isDev && DelegatedEvents.has(eventName)
+    const shouldDelegate = DelegatedEvents.has(eventName)
     if (!shouldDelegate && prev) {
       const handler = Array.isArray(prev) ? prev[0] : prev
       node.removeEventListener(eventName, handler as EventListener)

package/src/constants.ts

@@ -263,10 +263,9 @@ export const $$EVENTS = '_$FICT_DELEGATE'
 /**
  * Events that should use event delegation for performance
  * These events bubble and are commonly used across many elements
+ * Note: This must match the compiler's DelegatedEvents set
  */
-const delegatedEvents = isDev ? DelegatedEventNames : []
-
-export const DelegatedEvents = new Set<string>(delegatedEvents)
+export const DelegatedEvents = new Set<string>(DelegatedEventNames)
 
 // ============================================================================
 // SVG Support

package/src/dev-entry.ts

@@ -0,0 +1,22 @@
+// Unified runtime entry for dev/test aliasing.
+// Re-export internal compiler APIs plus public runtime exports so all code
+// shares a single reactive instance.
+export * from './internal'
+export {
+  batch,
+  createContext,
+  createRef,
+  createRoot,
+  ErrorBoundary,
+  hasContext,
+  onCleanup,
+  onMount,
+  render,
+  startTransition,
+  Suspense,
+  createSuspenseToken,
+  untrack,
+  useContext,
+  useDeferredValue,
+  useTransition,
+} from './index'

package/src/effect.ts

@@ -1,6 +1,7 @@
 import {
   getCurrentRoot,
   handleError,
+  handleSuspend,
   registerRootCleanup,
   runCleanupList,
   withEffectCleanups,
@@ -34,6 +35,9 @@ export function createEffect(fn: Effect): () => void {
           bucket.push(maybeCleanup)
         }
       } catch (err) {
+        if (handleSuspend(err as any, rootForError)) {
+          return
+        }
         if (handleError(err, { source: 'effect' }, rootForError)) {
           return
         }
@@ -43,7 +47,7 @@ export function createEffect(fn: Effect): () => void {
     cleanups = bucket
   }
 
-  const disposeEffect = effectWithCleanup(run, doCleanup)
+  const disposeEffect = effectWithCleanup(run, doCleanup, rootForError)
   const teardown = () => {
     runCleanupList(cleanups)
     disposeEffect()
@@ -76,6 +80,9 @@ export function createRenderEffect(fn: Effect): () => void {
         cleanup = maybeCleanup
       }
     } catch (err) {
+      if (handleSuspend(err as any, rootForError)) {
+        return
+      }
       const handled = handleError(err, { source: 'effect' }, rootForError)
       if (handled) {
         return
@@ -84,7 +91,7 @@ export function createRenderEffect(fn: Effect): () => void {
     }
   }
 
-  const disposeEffect = effectWithCleanup(run, doCleanup)
+  const disposeEffect = effectWithCleanup(run, doCleanup, rootForError)
   const teardown = () => {
     if (cleanup) {
       cleanup()

package/src/lifecycle.ts

@@ -15,6 +15,11 @@ export interface RootContext {
   destroyCallbacks: Cleanup[]
   errorHandlers?: ErrorHandler[]
   suspenseHandlers?: SuspenseHandler[]
+  suspended?: boolean
+}
+
+export interface CreateRootOptions {
+  inherit?: boolean
 }
 
 type ErrorHandler = (err: unknown, info?: ErrorInfo) => boolean | void
@@ -25,8 +30,8 @@ let currentEffectCleanups: Cleanup[] | undefined
 const globalErrorHandlers = new WeakMap<RootContext, ErrorHandler[]>()
 const globalSuspenseHandlers = new WeakMap<RootContext, SuspenseHandler[]>()
 
-export function createRootContext(parent: RootContext | undefined = currentRoot): RootContext {
-  return { parent, cleanups: [], destroyCallbacks: [] }
+export function createRootContext(parent?: RootContext): RootContext {
+  return { parent, cleanups: [], destroyCallbacks: [], suspended: false }
 }
 
 export function pushRoot(root: RootContext): RootContext | undefined {
@@ -111,8 +116,12 @@ export function destroyRoot(root: RootContext): void {
   }
 }
 
-export function createRoot<T>(fn: () => T): { dispose: () => void; value: T } {
-  const root = createRootContext()
+export function createRoot<T>(
+  fn: () => T,
+  options?: CreateRootOptions,
+): { dispose: () => void; value: T } {
+  const parent = options?.inherit ? currentRoot : undefined
+  const root = createRootContext(parent)
   const prev = pushRoot(root)
   let value: T
   try {
@@ -259,13 +268,18 @@ export function handleSuspend(
   startRoot?: RootContext,
 ): boolean {
   let root: RootContext | undefined = startRoot ?? currentRoot
+  const originRoot = root // Preserve reference to set suspended flag on success
   while (root) {
     const handlers = root.suspenseHandlers
     if (handlers && handlers.length) {
       for (let i = handlers.length - 1; i >= 0; i--) {
         const handler = handlers[i]!
         const handled = handler(token)
-        if (handled !== false) return true
+        if (handled !== false) {
+          // Only set suspended = true when a handler actually handles the token
+          if (originRoot) originRoot.suspended = true
+          return true
+        }
       }
     }
     root = root.parent
@@ -280,7 +294,11 @@ export function handleSuspend(
     for (let i = globalForRoot.length - 1; i >= 0; i--) {
       const handler = globalForRoot[i]!
       const handled = handler(token)
-      if (handled !== false) return true
+      if (handled !== false) {
+        // Only set suspended = true when a handler actually handles the token
+        if (originRoot) originRoot.suspended = true
+        return true
+      }
     }
   }
   return false

package/src/list-helpers.ts

@@ -135,8 +135,17 @@ export function moveNodesBefore(parent: Node, nodes: Node[], anchor: Node | null
           try {
             const clone = parent.ownerDocument.importNode(node, true)
             parent.insertBefore(clone, anchor)
-            // Note: Cloning during move breaks references in KeyedBlock.nodes
-            // This is a worst-case fallback for tests.
+            // Update the nodes array with the clone to maintain correct references.
+            // This ensures future operations (like removal or reordering) work correctly.
+            nodes[i] = clone
+            if (isDev) {
+              console.warn(
+                `[fict] Node cloning fallback triggered during list reordering. ` +
+                  `This may indicate cross-document node insertion. ` +
+                  `The node reference has been updated to the clone.`,
+              )
+            }
+            anchor = clone
             continue
           } catch {
             // Clone fallback failed
@@ -491,7 +500,9 @@ function createFineGrainedKeyedList<T>(
       endParent === startParent &&
       (endParent as Node).nodeType !== 11
     ) {
-      return endParent as ParentNode & Node
+      const parentNode = endParent as ParentNode & Node
+      if ('isConnected' in parentNode && !parentNode.isConnected) return null
+      return parentNode
     }
     return null
   }

package/src/props.ts

@@ -1,5 +1,6 @@
 import { createMemo } from './memo'
 
+const PROP_GETTER_MARKER = Symbol.for('fict:prop-getter')
 const propGetters = new WeakSet<(...args: unknown[]) => unknown>()
 const rawToProxy = new WeakMap<object, object>()
 const proxyToRaw = new WeakMap<object, object>()
@@ -12,12 +13,21 @@ const proxyToRaw = new WeakMap<object, object>()
 export function __fictProp<T>(getter: () => T): () => T {
   if (typeof getter === 'function' && getter.length === 0) {
     propGetters.add(getter)
+    if (Object.isExtensible(getter)) {
+      try {
+        ;(getter as (() => T) & { [PROP_GETTER_MARKER]?: boolean })[PROP_GETTER_MARKER] = true
+      } catch {
+        // Ignore marker failures on non-standard function objects.
+      }
+    }
   }
   return getter
 }
 
 function isPropGetter(value: unknown): value is () => unknown {
-  return typeof value === 'function' && propGetters.has(value as (...args: unknown[]) => unknown)
+  if (typeof value !== 'function') return false
+  const fn = value as (() => unknown) & { [PROP_GETTER_MARKER]?: boolean }
+  return propGetters.has(fn as (...args: unknown[]) => unknown) || fn[PROP_GETTER_MARKER] === true
 }
 
 export function createPropsProxy<T extends Record<string, unknown>>(props: T): T {
@@ -189,9 +199,14 @@ export function mergeProps<T extends Record<string, unknown>>(
 }
 
 export type PropGetter<T> = (() => T) & { __fictProp: true }
+
+export interface PropOptions {
+  unwrap?: boolean
+}
 /**
  * Memoize a prop getter to cache expensive computations.
  * Use when prop expressions involve heavy calculations or you need lazy, reactive props.
+ * Set { unwrap: false } to keep nested prop getters as values.
  *
  * @example
  * ```tsx
@@ -203,10 +218,21 @@ export type PropGetter<T> = (() => T) & { __fictProp: true }
  * <Child data={memoizedData} />
  * ```
  */
-export function prop<T>(getter: () => T): PropGetter<T> {
+export function prop<T>(getter: () => T, options?: PropOptions): PropGetter<T> {
   if (isPropGetter(getter)) {
     return getter as PropGetter<T>
   }
+  // Capture getter to avoid type narrowing from isPropGetter guard
+  const fn: () => T = getter
+  const unwrap = options?.unwrap !== false
   // Wrap in prop so component props proxy auto-unwraps when passed down.
-  return __fictProp(createMemo(getter)) as PropGetter<T>
+  return __fictProp(
+    createMemo(() => {
+      const value = fn()
+      if (unwrap && isPropGetter(value)) {
+        return (value as () => T)()
+      }
+      return value
+    }),
+  ) as PropGetter<T>
 }

package/src/scope.ts

@@ -25,7 +25,7 @@ export function createScope(): ReactiveScope {
 
   const run = <T>(fn: () => T): T => {
     stop()
-    const { dispose: rootDispose, value } = createRoot(fn)
+    const { dispose: rootDispose, value } = createRoot(fn, { inherit: true })
     dispose = rootDispose
     return value
   }

package/src/signal.ts

@@ -1,6 +1,12 @@
 import { beginFlushGuard, beforeEffectRunGuard, endFlushGuard } from './cycle-guard'
 import { getDevtoolsHook } from './devtools'
-import { registerRootCleanup } from './lifecycle'
+import {
+  getCurrentRoot,
+  handleError,
+  handleSuspend,
+  registerRootCleanup,
+  type RootContext,
+} from './lifecycle'
 
 const isDev =
   typeof __DEV__ !== 'undefined'
@@ -103,6 +109,8 @@ export interface EffectNode extends BaseNode {
   depsTail: Link | undefined
   /** Optional cleanup runner to be called before checkDirty */
   runCleanup?: () => void
+  /** Root context for error/suspense handling */
+  root?: RootContext
   /** Devtools ID */
   __id?: number | undefined
 }
@@ -808,7 +816,25 @@ function runEffect(e: EffectNode): void {
         inCleanup = false
       }
     }
-    if (checkDirty(e.deps, e)) {
+    let isDirty = false
+    try {
+      isDirty = checkDirty(e.deps, e)
+    } catch (err) {
+      if (handleSuspend(err as any, e.root)) {
+        if (e.flags !== 0) {
+          e.flags = Watching
+        }
+        return
+      }
+      if (handleError(err, { source: 'effect' }, e.root)) {
+        if (e.flags !== 0) {
+          e.flags = Watching
+        }
+        return
+      }
+      throw err
+    }
+    if (isDirty) {
       ++cycle
       effectRunDevtools(e)
       e.depsTail = undefined
@@ -1031,7 +1057,7 @@ function computedOper<T>(this: ComputedNode<T>): T {
  * @returns An effect disposer function
  */
 export function effect(fn: () => void): EffectDisposer {
-  const e = {
+  const e: EffectNode = {
     fn,
     subs: undefined,
     subsTail: undefined,
@@ -1040,6 +1066,10 @@ export function effect(fn: () => void): EffectDisposer {
     flags: WatchingRunning,
     __id: undefined as number | undefined,
   }
+  const root = getCurrentRoot()
+  if (root) {
+    e.root = root
+  }
 
   registerEffectDevtools(e)
 
@@ -1066,9 +1096,14 @@ export function effect(fn: () => void): EffectDisposer {
  * cleanup functions to access the previous values of signals.
  * @param fn - The effect function
  * @param cleanupRunner - Function to run cleanups before signal value commit
+ * @param root - Root context for error/suspense handling (defaults to current root)
  * @returns An effect disposer function
  */
-export function effectWithCleanup(fn: () => void, cleanupRunner: () => void): EffectDisposer {
+export function effectWithCleanup(
+  fn: () => void,
+  cleanupRunner: () => void,
+  root?: RootContext,
+): EffectDisposer {
   const e: EffectNode = {
     fn,
     subs: undefined,
@@ -1079,6 +1114,10 @@ export function effectWithCleanup(fn: () => void, cleanupRunner: () => void): Ef
     runCleanup: cleanupRunner,
     __id: undefined as number | undefined,
   }
+  const resolvedRoot = root ?? getCurrentRoot()
+  if (resolvedRoot) {
+    e.root = resolvedRoot
+  }
 
   registerEffectDevtools(e)
 

package/src/suspense.ts

@@ -60,11 +60,6 @@ export function Suspense(props: SuspenseProps): FictNode {
       ? (props.fallback as (e?: unknown) => FictNode)(err)
       : props.fallback
 
-  const switchView = (view: FictNode | null) => {
-    currentView(view)
-    renderView(view)
-  }
-
   const renderView = (view: FictNode | null) => {
     if (cleanup) {
       cleanup()
@@ -88,8 +83,9 @@ export function Suspense(props: SuspenseProps): FictNode {
       // Suspended view: child threw a suspense token and was handled upstream.
       // Avoid replacing existing fallback content; tear down this attempt.
       const suspendedAttempt =
-        nodes.length > 0 &&
-        nodes.every(node => node instanceof Comment && (node as Comment).data === 'fict:suspend')
+        root.suspended ||
+        (nodes.length > 0 &&
+          nodes.every(node => node instanceof Comment && (node as Comment).data === 'fict:suspend'))
       if (suspendedAttempt) {
         popRoot(prev)
         destroyRoot(root)
@@ -134,7 +130,10 @@ export function Suspense(props: SuspenseProps): FictNode {
   registerSuspenseHandler(token => {
     const tokenEpoch = epoch
     pending(pending() + 1)
-    switchView(toFallback())
+    // Directly render fallback instead of using switchView to avoid
+    // triggering the effect which would cause duplicate renders
+    currentView(toFallback())
+    renderView(toFallback())
 
     const thenable = (token as SuspenseToken).then
       ? (token as SuspenseToken)
@@ -157,7 +156,9 @@ export function Suspense(props: SuspenseProps): FictNode {
           const newPending = Math.max(0, pending() - 1)
           pending(newPending)
           if (newPending === 0) {
-            switchView(props.children ?? null)
+            // Directly render children instead of using switchView
+            currentView(props.children ?? null)
+            renderView(props.children ?? null)
             onResolveMaybe()
           }
         },
@@ -180,9 +181,10 @@ export function Suspense(props: SuspenseProps): FictNode {
     return false
   })
 
-  createEffect(() => {
-    renderView(currentView())
-  })
+  // Initial render - render children directly
+  // Note: This will be called synchronously during component creation.
+  // If children suspend, the handler above will be called and switch to fallback.
+  renderView(props.children ?? null)
 
   if (props.resetKeys !== undefined) {
     const isGetter =
@@ -195,7 +197,9 @@ export function Suspense(props: SuspenseProps): FictNode {
         prev = next
         epoch++
         pending(0)
-        switchView(props.children ?? null)
+        // Directly render children instead of using switchView
+        currentView(props.children ?? null)
+        renderView(props.children ?? null)
       }
     })
   }

package/dist/chunk-624QY53A.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/fict/fict/packages/runtime/dist/chunk-624QY53A.cjs","../src/scope.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACA;ACOO,SAAS,WAAA,CAAA,EAA6B;AAC3C,EAAA,IAAI,QAAA,EAA+B,IAAA;AAEnC,EAAA,MAAM,KAAA,EAAO,CAAA,EAAA,GAAM;AACjB,IAAA,GAAA,CAAI,OAAA,EAAS;AACX,MAAA,OAAA,CAAQ,CAAA;AACR,MAAA,QAAA,EAAU,IAAA;AAAA,IACZ;AAAA,EACF,CAAA;AAEA,EAAA,MAAM,IAAA,EAAM,CAAI,EAAA,EAAA,GAAmB;AACjC,IAAA,IAAA,CAAK,CAAA;AACL,IAAA,MAAM,EAAE,OAAA,EAAS,WAAA,EAAa,MAAM,EAAA,EAAI,0CAAA,EAAa,CAAA;AACrD,IAAA,QAAA,EAAU,WAAA;AACV,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AAEA,EAAA,mDAAA,IAAwB,CAAA;AACxB,EAAA,OAAO,EAAE,GAAA,EAAK,KAAK,CAAA;AACrB;AAMO,SAAS,UAAA,CAAW,IAAA,EAA8B,EAAA,EAAsB;AAC7E,EAAA,MAAM,MAAA,EAAQ,WAAA,CAAY,CAAA;AAC1B,EAAA,MAAM,SAAA,EAAW,CAAA,EAAA,GAAO,0CAAA,IAAe,EAAA,EAAK,IAAA,CAAuB,EAAA,EAAI,CAAC,CAAC,IAAA;AAEzE,EAAA,4CAAA,CAAa,EAAA,GAAM;AACjB,IAAA,MAAM,QAAA,EAAU,QAAA,CAAS,CAAA;AACzB,IAAA,GAAA,CAAI,OAAA,EAAS;AACX,MAAA,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA;AAAA,IACd,EAAA,KAAO;AACL,MAAA,KAAA,CAAM,IAAA,CAAK,CAAA;AAAA,IACb;AAAA,EACF,CAAC,CAAA;AAED,EAAA,yCAAA,KAAU,CAAM,IAAI,CAAA;AACtB;ADfA;AACA;AACE;AACA;AACF,mEAAC","file":"/home/runner/work/fict/fict/packages/runtime/dist/chunk-624QY53A.cjs","sourcesContent":[null,"import { isReactive, type MaybeReactive } from './binding'\nimport { createEffect } from './effect'\nimport { createRoot, onCleanup, registerRootCleanup } from './lifecycle'\n\nexport { effectScope } from './signal'\n\nexport interface ReactiveScope {\n  run<T>(fn: () => T): T\n  stop(): void\n}\n\n/**\n * Create an explicit reactive scope that can contain effects/memos and be stopped manually.\n * The scope registers with the current root for cleanup.\n */\nexport function createScope(): ReactiveScope {\n  let dispose: (() => void) | null = null\n\n  const stop = () => {\n    if (dispose) {\n      dispose()\n      dispose = null\n    }\n  }\n\n  const run = <T>(fn: () => T): T => {\n    stop()\n    const { dispose: rootDispose, value } = createRoot(fn)\n    dispose = rootDispose\n    return value\n  }\n\n  registerRootCleanup(stop)\n  return { run, stop }\n}\n\n/**\n * Run a block of reactive code inside a managed scope that follows a boolean flag.\n * When the flag turns false, the scope is disposed and all contained effects/memos are cleaned up.\n */\nexport function runInScope(flag: MaybeReactive<boolean>, fn: () => void): void {\n  const scope = createScope()\n  const evaluate = () => (isReactive(flag) ? (flag as () => boolean)() : !!flag)\n\n  createEffect(() => {\n    const enabled = evaluate()\n    if (enabled) {\n      scope.run(fn)\n    } else {\n      scope.stop()\n    }\n  })\n\n  onCleanup(scope.stop)\n}\n"]}