@fictjs/runtime 0.17.0 → 0.17.1

package/src/context.ts

@@ -56,6 +56,7 @@ import {
   type RootContext,
 } from './lifecycle'
 import { insertNodesBefore, removeNodes, toNodeArray } from './node-ops'
+import { untrack } from './signal'
 import type { BaseProps, FictNode } from './types'
 
 // ============================================================================
@@ -222,7 +223,13 @@ export function createContext<T>(defaultValue: T): Context<T> {
     createRenderEffect(() => {
       // Update context value on re-render (if value prop changes reactively)
       contextMap.set(id, props.value)
-      renderChildren(props.children)
+
+      // Provider value updates should not subscribe this effect to arbitrary
+      // signal reads that happen while rendering descendants. Child trees own
+      // their own reactivity; the provider only needs to react to its props.
+      untrack(() => {
+        renderChildren(props.children)
+      })
     })
 
     return fragment

package/src/dom.ts

@@ -19,7 +19,9 @@ import {
   createClassBinding,
   createChildBinding,
   bindEvent,
+  bindRef,
   isReactive,
+  registerCreateElement,
   type MaybeReactive,
   type AttributeSetter,
   type BindingHandle,
@@ -27,7 +29,7 @@ import {
 import { Properties, ChildProperties, getPropAlias, SVGElements, SVGNamespace } from './constants'
 import { getDevtoolsHook } from './devtools'
 import { __fictPushContext, __fictPopContext, __fictGetCurrentComponentId } from './hooks'
-import { claimNodes, isHydratingActive, withHydration } from './hydration'
+import { claimNodes, claimText, isHydratingActive, withHydration } from './hydration'
 import { Fragment } from './jsx'
 import {
   createRootContext,
@@ -51,7 +53,7 @@ import {
   __fictExitHydration,
 } from './resume'
 import { untrack } from './scheduler'
-import type { DOMElement, FictNode, FictVNode, RefObject } from './types'
+import type { DOMElement, FictNode, FictVNode } from './types'
 
 type NamespaceContext = 'svg' | 'mathml' | null
 
@@ -214,6 +216,8 @@ export function createElement(node: FictNode): DOMElement {
   return createElementWithContext(node, null, resolveOwnerDocument())
 }
 
+registerCreateElement(createElement)
+
 function resolveNamespace(tagName: string, namespace: NamespaceContext): NamespaceContext {
   if (tagName === 'svg') return 'svg'
   if (tagName === 'math') return 'mathml'
@@ -227,6 +231,13 @@ function resolveOwnerDocument(ownerDocument?: Document): Document {
   return ownerDocument ?? getCurrentRoot()?.ownerDocument ?? document
 }
 
+function createTextNodeWithHydration(value: string, ownerDocument: Document): Text {
+  if (!isHydratingActive()) {
+    return ownerDocument.createTextNode(value)
+  }
+  return claimText(value, () => ownerDocument.createTextNode(value))
+}
+
 function createElementWithContext(
   node: FictNode,
   namespace: NamespaceContext,
@@ -239,14 +250,14 @@ function createElementWithContext(
 
   // Null/undefined/false - empty placeholder
   if (node === null || node === undefined || node === false) {
-    return ownerDocument.createTextNode('')
+    return createTextNodeWithHydration('', ownerDocument)
   }
 
   // Reactive getter function - resolve to actual node
   if (isReactive(node)) {
     const resolved = (node as () => FictNode)()
     if (resolved === node) {
-      return ownerDocument.createTextNode('')
+      return createTextNodeWithHydration('', ownerDocument)
     }
     return createElementWithContext(resolved, namespace, ownerDocument)
   }
@@ -254,7 +265,7 @@ function createElementWithContext(
   // Non-reactive function values are not valid DOM nodes.
   // Keep callback values inert instead of stringifying function source.
   if (typeof node === 'function') {
-    return ownerDocument.createTextNode('')
+    return createTextNodeWithHydration('', ownerDocument)
   }
 
   if (typeof node === 'object' && node !== null && !(node instanceof Node)) {
@@ -290,11 +301,11 @@ function createElementWithContext(
 
   // Primitive values - text node
   if (typeof node === 'string' || typeof node === 'number') {
-    return ownerDocument.createTextNode(String(node))
+    return createTextNodeWithHydration(String(node), ownerDocument)
   }
 
   if (typeof node === 'boolean') {
-    return ownerDocument.createTextNode('')
+    return createTextNodeWithHydration('', ownerDocument)
   }
 
   // VNode
@@ -615,7 +626,7 @@ function appendChildNode(
   // Cast to Node for remaining logic
   let domNode: Node
   if (typeof child !== 'object' || child === null) {
-    domNode = parentOwnerDocument.createTextNode(String(child ?? ''))
+    domNode = createTextNodeWithHydration(String(child ?? ''), parentOwnerDocument)
   } else {
     domNode = createElementWithContext(child as any, namespace, parentOwnerDocument) as Node
   }
@@ -675,43 +686,14 @@ function appendChildren(
  * Both types are automatically cleaned up on unmount.
  */
 function applyRef(el: Element, value: unknown): void {
-  if (typeof value === 'function') {
-    // Callback ref
-    const refFn = value as (el: Element | null) => void
-    refFn(el)
-
-    // Match React behavior: call ref(null) on unmount
-    const root = getCurrentRoot()
-    if (root) {
-      registerRootCleanup(() => {
-        refFn(null)
-      })
-    } else if (isDev) {
-      console.warn(
-        '[fict] Ref applied outside of a root context. ' +
-          'The ref cleanup (setting to null) will not run automatically. ' +
-          'Consider using createRoot() or ensure the element is created within a component.',
-      )
-    }
-  } else if (value && typeof value === 'object' && 'current' in value) {
-    // Object ref
-    const refObj = value as RefObject<Element>
-    refObj.current = el
-
-    // Auto-cleanup on unmount
-    const root = getCurrentRoot()
-    if (root) {
-      registerRootCleanup(() => {
-        refObj.current = null
-      })
-    } else if (isDev) {
-      console.warn(
-        '[fict] Ref applied outside of a root context. ' +
-          'The ref cleanup (setting to null) will not run automatically. ' +
-          'Consider using createRoot() or ensure the element is created within a component.',
-      )
-    }
+  if (!getCurrentRoot() && isDev) {
+    console.warn(
+      '[fict] Ref applied outside of a root context. ' +
+        'The ref cleanup (setting to null) will not run automatically. ' +
+        'Consider using createRoot() or ensure the element is created within a component.',
+    )
   }
+  bindRef(el, value)
 }
 
 // ============================================================================

package/src/effect.ts

@@ -21,7 +21,7 @@ export function createEffect(fn: Effect, options?: EffectOptions): () => void {
 
   // Cleanup runner - called by runEffect BEFORE signal values are committed
   const doCleanup = () => {
-    runCleanupList(cleanups)
+    runCleanupList(cleanups, rootForError)
     cleanups = []
   }
 
@@ -49,7 +49,7 @@ export function createEffect(fn: Effect, options?: EffectOptions): () => void {
 
   const disposeEffect = effectWithCleanup(run, doCleanup, rootForError, options)
   const teardown = () => {
-    runCleanupList(cleanups)
+    runCleanupList(cleanups, rootForError)
     disposeEffect()
   }
 
@@ -61,15 +61,13 @@ export function createEffect(fn: Effect, options?: EffectOptions): () => void {
 export const $effect = createEffect
 
 export function createRenderEffect(fn: Effect, options?: EffectOptions): () => void {
-  let cleanup: Cleanup | undefined
+  let cleanups: Cleanup[] = []
   const rootForError = getCurrentRoot()
 
   // Cleanup runner - called by runEffect BEFORE signal values are committed
   const doCleanup = () => {
-    if (cleanup) {
-      cleanup()
-      cleanup = undefined
-    }
+    runCleanupList(cleanups, rootForError)
+    cleanups = []
   }
 
   const run = () => {
@@ -77,7 +75,9 @@ export function createRenderEffect(fn: Effect, options?: EffectOptions): () => v
     try {
       const maybeCleanup = fn()
       if (typeof maybeCleanup === 'function') {
-        cleanup = maybeCleanup
+        cleanups = [maybeCleanup]
+      } else {
+        cleanups = []
       }
     } catch (err) {
       if (handleSuspend(err as any, rootForError)) {
@@ -93,10 +93,7 @@ export function createRenderEffect(fn: Effect, options?: EffectOptions): () => v
 
   const disposeEffect = effectWithCleanup(run, doCleanup, rootForError, options)
   const teardown = () => {
-    if (cleanup) {
-      cleanup()
-      cleanup = undefined
-    }
+    runCleanupList(cleanups, rootForError)
     disposeEffect()
   }
 

package/src/error-boundary.ts

@@ -8,6 +8,7 @@ import {
   pushRoot,
   popRoot,
   registerErrorHandler,
+  registerRootCleanup,
 } from './lifecycle'
 import { insertNodesBefore, removeNodes, toNodeArray } from './node-ops'
 import type { BaseProps, FictNode } from './types'
@@ -105,6 +106,13 @@ export function ErrorBoundary(props: ErrorBoundaryProps): FictNode {
 
   renderValue(props.children ?? null)
 
+  registerRootCleanup(() => {
+    if (cleanup) {
+      cleanup()
+      cleanup = undefined
+    }
+  })
+
   registerErrorHandler(err => {
     renderValue(toView(err))
     props.onError?.(err)

package/src/hydration.ts

@@ -6,7 +6,7 @@ interface HydrationContext {
 
 const hydrationStack: HydrationContext[] = []
 
-export function withHydration(root: ParentNode & Node, fn: () => void): void {
+export function withHydration<T>(root: ParentNode & Node, fn: () => T): T {
   const owner = root.ownerDocument ?? document
   hydrationStack.push({
     cursor: root.firstChild,
@@ -14,25 +14,25 @@ export function withHydration(root: ParentNode & Node, fn: () => void): void {
     owner,
   })
   try {
-    fn()
+    return fn()
   } finally {
     hydrationStack.pop()
   }
 }
 
-export function withHydrationRange(
+export function withHydrationRange<T>(
   start: Node | null,
   end: Node | null,
   owner: Document,
-  fn: () => void,
-): void {
+  fn: () => T,
+): T {
   hydrationStack.push({
     cursor: start,
     boundary: end,
     owner,
   })
   try {
-    fn()
+    return fn()
   } finally {
     hydrationStack.pop()
   }
@@ -70,6 +70,25 @@ export function claimNodes(templateRoot: Node, fallback: () => Node): Node {
   return frag
 }
 
+export function claimText(value: string, fallback: () => Text): Text {
+  const ctx = hydrationStack[hydrationStack.length - 1]
+  if (
+    !ctx ||
+    !ctx.cursor ||
+    ctx.cursor === ctx.boundary ||
+    ctx.cursor.nodeType !== Node.TEXT_NODE
+  ) {
+    return fallback()
+  }
+
+  const text = ctx.cursor as Text
+  ctx.cursor = text.nextSibling
+  if (text.data !== value) {
+    text.data = value
+  }
+  return text
+}
+
 export function isHydratingActive(): boolean {
   return hydrationStack.length > 0
 }

package/src/lifecycle.ts

@@ -29,8 +29,6 @@ type SuspenseHandler = (token: SuspenseToken | PromiseLike<unknown>) => boolean
 
 let currentRoot: RootContext | undefined
 let currentEffectCleanups: Cleanup[] | undefined
-const globalErrorHandlers = new WeakMap<RootContext, ErrorHandler[]>()
-const globalSuspenseHandlers = new WeakMap<RootContext, SuspenseHandler[]>()
 const rootDevtoolsIds = new WeakMap<RootContext, number>()
 let nextRootDevtoolsId = 0
 
@@ -115,20 +113,28 @@ export function onCleanup(fn: Cleanup): void {
 export function flushOnMount(root: RootContext): void {
   const cbs = root.onMountCallbacks
   if (!cbs || cbs.length === 0) return
-  // Temporarily restore root context so onCleanup calls inside
-  // mount callbacks register correctly
+  try {
+    withRootContext(root, () => {
+      for (let i = 0; i < cbs.length; i++) {
+        const cleanup = cbs[i]!()
+        if (typeof cleanup === 'function') {
+          root.cleanups.push(cleanup)
+        }
+      }
+    })
+  } finally {
+    cbs.length = 0
+  }
+}
+
+export function withRootContext<T>(root: RootContext | undefined, fn: () => T): T {
+  if (!root) return fn()
   const prevRoot = currentRoot
   currentRoot = root
   try {
-    for (let i = 0; i < cbs.length; i++) {
-      const cleanup = cbs[i]!()
-      if (typeof cleanup === 'function') {
-        root.cleanups.push(cleanup)
-      }
-    }
+    return fn()
   } finally {
     currentRoot = prevRoot
-    cbs.length = 0
   }
 }
 
@@ -139,7 +145,7 @@ export function registerRootCleanup(fn: Cleanup): void {
 }
 
 export function clearRoot(root: RootContext): void {
-  runCleanupList(root.cleanups)
+  runCleanupList(root.cleanups, root)
   if (root.onMountCallbacks) {
     root.onMountCallbacks.length = 0
   }
@@ -147,19 +153,13 @@ export function clearRoot(root: RootContext): void {
 
 export function destroyRoot(root: RootContext): void {
   clearRoot(root)
-  runCleanupList(root.destroyCallbacks)
+  runCleanupList(root.destroyCallbacks, root)
   if (root.errorHandlers) {
     root.errorHandlers.length = 0
   }
-  if (globalErrorHandlers.has(root)) {
-    globalErrorHandlers.delete(root)
-  }
   if (root.suspenseHandlers) {
     root.suspenseHandlers.length = 0
   }
-  if (globalSuspenseHandlers.has(root)) {
-    globalSuspenseHandlers.delete(root)
-  }
   disposeRootDevtools(root)
 }
 
@@ -201,21 +201,23 @@ export function registerEffectCleanup(fn: Cleanup): void {
   }
 }
 
-export function runCleanupList(list: Cleanup[]): void {
+export function runCleanupList(list: Cleanup[], root?: RootContext): void {
   let error: unknown
-  for (let i = list.length - 1; i >= 0; i--) {
-    try {
-      const cleanup = list[i]
-      if (cleanup) cleanup()
-    } catch (err) {
-      if (error === undefined) {
-        error = err
+  withRootContext(root, () => {
+    for (let i = list.length - 1; i >= 0; i--) {
+      try {
+        const cleanup = list[i]
+        if (cleanup) cleanup()
+      } catch (err) {
+        if (error === undefined) {
+          error = err
+        }
       }
     }
-  }
+  })
   list.length = 0
   if (error !== undefined) {
-    if (!handleError(error, { source: 'cleanup' })) {
+    if (!handleError(error, { source: 'cleanup' }, root)) {
       throw error
     }
   }
@@ -239,12 +241,6 @@ export function registerErrorHandler(fn: ErrorHandler): void {
     currentRoot.errorHandlers = []
   }
   currentRoot.errorHandlers.push(fn)
-  const existing = globalErrorHandlers.get(currentRoot)
-  if (existing) {
-    existing.push(fn)
-  } else {
-    globalErrorHandlers.set(currentRoot, [fn])
-  }
 }
 
 export function registerSuspenseHandler(fn: SuspenseHandler): void {
@@ -258,12 +254,6 @@ export function registerSuspenseHandler(fn: SuspenseHandler): void {
     currentRoot.suspenseHandlers = []
   }
   currentRoot.suspenseHandlers.push(fn)
-  const existing = globalSuspenseHandlers.get(currentRoot)
-  if (existing) {
-    existing.push(fn)
-  } else {
-    globalSuspenseHandlers.set(currentRoot, [fn])
-  }
 }
 
 export function handleError(err: unknown, info?: ErrorInfo, startRoot?: RootContext): boolean {
@@ -286,24 +276,6 @@ export function handleError(err: unknown, info?: ErrorInfo, startRoot?: RootCont
     }
     root = root.parent
   }
-  const globalForRoot = startRoot
-    ? globalErrorHandlers.get(startRoot)
-    : currentRoot
-      ? globalErrorHandlers.get(currentRoot)
-      : undefined
-  if (globalForRoot && globalForRoot.length) {
-    for (let i = globalForRoot.length - 1; i >= 0; i--) {
-      const handler = globalForRoot[i]!
-      try {
-        const handled = handler(error, info)
-        if (handled !== false) {
-          return true
-        }
-      } catch (nextErr) {
-        error = nextErr
-      }
-    }
-  }
   // The caller (e.g., runCleanupList) can decide whether to rethrow.
   // This makes the API consistent: handleError always returns a boolean
   // indicating whether the error was handled.
@@ -334,25 +306,5 @@ export function handleSuspend(
     }
     root = root.parent
   }
-  const globalForRoot =
-    startRoot && globalSuspenseHandlers.get(startRoot)
-      ? globalSuspenseHandlers.get(startRoot)
-      : currentRoot
-        ? globalSuspenseHandlers.get(currentRoot)
-        : undefined
-  if (globalForRoot && globalForRoot.length) {
-    for (let i = globalForRoot.length - 1; i >= 0; i--) {
-      const handler = globalForRoot[i]!
-      const handled = handler(token)
-      if (handled !== false) {
-        // Only set suspended = true when a handler actually handles the token
-        if (originRoot) {
-          originRoot.suspended = true
-          setRootSuspendDevtools(originRoot, true)
-        }
-        return true
-      }
-    }
-  }
   return false
 }

package/src/signal.ts

@@ -6,6 +6,7 @@ import {
   handleError,
   handleSuspend,
   registerRootCleanup,
+  withRootContext,
   type RootContext,
 } from './lifecycle'
 import type { SuspenseToken } from './types'
@@ -890,7 +891,9 @@ function runEffect(e: EffectNode): void {
     inCleanup = true
     activeCleanupFlushId = currentFlushId
     try {
-      e.runCleanup()
+      withRootContext(e.root, () => {
+        e.runCleanup!()
+      })
     } finally {
       activeCleanupFlushId = 0
       inCleanup = false

package/src/suspense.ts

@@ -8,6 +8,7 @@ import {
   handleError,
   pushRoot,
   popRoot,
+  registerRootCleanup,
   registerSuspenseHandler,
 } from './lifecycle'
 import { insertNodesBefore, removeNodes, toNodeArray } from './node-ops'
@@ -234,6 +235,13 @@ export function Suspense(props: SuspenseProps): FictNode {
   // If children suspend, the handler above will be called and switch to fallback.
   renderView(props.children ?? null)
 
+  registerRootCleanup(() => {
+    if (cleanup) {
+      cleanup()
+      cleanup = undefined
+    }
+  })
+
   if (props.resetKeys !== undefined) {
     const isGetter =
       typeof props.resetKeys === 'function' && (props.resetKeys as () => unknown).length === 0

package/dist/chunk-6DNYVH5U.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/fict/fict/packages/runtime/dist/chunk-6DNYVH5U.cjs","../src/context.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACA;ACoFA,IAAM,eAAA,kBAAiB,IAAI,OAAA,CAA2C,CAAA;AAKtE,SAAS,aAAA,CAAc,IAAA,EAAyC;AAC9D,EAAA,IAAI,IAAA,EAAM,cAAA,CAAe,GAAA,CAAI,IAAI,CAAA;AACjC,EAAA,GAAA,CAAI,CAAC,GAAA,EAAK;AACR,IAAA,IAAA,kBAAM,IAAI,GAAA,CAAI,CAAA;AACd,IAAA,cAAA,CAAe,GAAA,CAAI,IAAA,EAAM,GAAG,CAAA;AAAA,EAC9B;AACA,EAAA,OAAO,GAAA;AACT;AA0CO,SAAS,aAAA,CAAiB,YAAA,EAA6B;AAC5D,EAAA,MAAM,GAAA,EAAK,MAAA,CAAO,cAAc,CAAA;AAEhC,EAAA,MAAM,QAAA,EAAsB;AAAA,IAC1B,EAAA;AAAA,IACA,YAAA;AAAA,IACA,QAAA,EAAU;AAAA,EACZ,CAAA;AAGA,EAAA,OAAA,CAAQ,SAAA,EAAW,SAAS,QAAA,CAAS,KAAA,EAAmC;AACtE,IAAA,MAAM,SAAA,EAAW,8CAAA,CAAe;AAIhC,IAAA,MAAM,aAAA,EAAe,iDAAA,QAA0B,CAAA;AAG/C,IAAA,MAAM,WAAA,EAAa,aAAA,CAAc,YAAY,CAAA;AAC7C,IAAA,UAAA,CAAW,GAAA,CAAI,EAAA,EAAI,KAAA,CAAM,KAAK,CAAA;AAG9B,IAAA,MAAM,oBAAA,oCAAsB,YAAA,CAAa,aAAA,0BAAiB,QAAA,2BAAU,iBAAA,UAAiB,UAAA;AACrF,IAAA,MAAM,SAAA,EAAW,mBAAA,CAAoB,sBAAA,CAAuB,CAAA;AAC5D,IAAA,MAAM,OAAA,EAAS,mBAAA,CAAoB,aAAA,CAAc,UAAU,CAAA;AAC3D,IAAA,QAAA,CAAS,WAAA,CAAY,MAAM,CAAA;AAE3B,IAAA,IAAI,OAAA;AACJ,IAAA,IAAI,YAAA,EAAsB,CAAC,CAAA;AAE3B,IAAA,MAAM,eAAA,EAAiB,CAAC,QAAA,EAAA,GAAuB;AAE7C,MAAA,GAAA,CAAI,OAAA,EAAS;AACX,QAAA,OAAA,CAAQ,CAAA;AACR,QAAA,QAAA,EAAU,KAAA,CAAA;AAAA,MACZ;AACA,MAAA,GAAA,CAAI,WAAA,CAAY,MAAA,EAAQ;AACtB,QAAA,2CAAA,WAAuB,CAAA;AACvB,QAAA,YAAA,EAAc,CAAC,CAAA;AAAA,MACjB;AAEA,MAAA,GAAA,CAAI,SAAA,GAAY,KAAA,GAAQ,SAAA,IAAa,KAAA,EAAO;AAC1C,QAAA,MAAA;AAAA,MACF;AAEA,MAAA,MAAM,KAAA,EAAO,wCAAA,YAAqB,CAAA;AAClC,MAAA,IAAI,MAAA,EAAgB,CAAC,CAAA;AACrB,MAAA,IAAI;AACF,QAAA,MAAM,OAAA,EAAS,6CAAA,QAAsB,CAAA;AACrC,QAAA,MAAA,EAAQ,2CAAA,MAAY,EAAQ,mBAAmB,CAAA;AAC/C,QAAA,MAAM,WAAA,EAAa,MAAA,CAAO,UAAA;AAC1B,QAAA,GAAA,CAAI,UAAA,EAAY;AACd,UAAA,iDAAA,UAAkB,EAAY,KAAA,EAAO,MAAM,CAAA;AAAA,QAC7C;AAAA,MACF,EAAA,QAAE;AACA,QAAA,uCAAA,IAAY,CAAA;AACZ,QAAA,4CAAA,YAAyB,CAAA;AAAA,MAC3B;AAEA,MAAA,QAAA,EAAU,CAAA,EAAA,GAAM;AACd,QAAA,2CAAA,YAAwB,CAAA;AACxB,QAAA,2CAAA,KAAiB,CAAA;AAAA,MACnB,CAAA;AACA,MAAA,YAAA,EAAc,KAAA;AAAA,IAChB,CAAA;AAGA,IAAA,kDAAA,CAAmB,EAAA,GAAM;AAEvB,MAAA,UAAA,CAAW,GAAA,CAAI,EAAA,EAAI,KAAA,CAAM,KAAK,CAAA;AAC9B,MAAA,cAAA,CAAe,KAAA,CAAM,QAAQ,CAAA;AAAA,IAC/B,CAAC,CAAA;AAED,IAAA,OAAO,QAAA;AAAA,EACT,CAAA;AAEA,EAAA,OAAO,OAAA;AACT;AAsBO,SAAS,UAAA,CAAc,OAAA,EAAwB;AACpD,EAAA,IAAI,KAAA,EAAO,8CAAA,CAAe;AAG1B,EAAA,MAAA,CAAO,IAAA,EAAM;AACX,IAAA,MAAM,WAAA,EAAa,cAAA,CAAe,GAAA,CAAI,IAAI,CAAA;AAC1C,IAAA,GAAA,CAAI,WAAA,GAAc,UAAA,CAAW,GAAA,CAAI,OAAA,CAAQ,EAAE,CAAA,EAAG;AAC5C,MAAA,OAAO,UAAA,CAAW,GAAA,CAAI,OAAA,CAAQ,EAAE,CAAA;AAAA,IAClC;AACA,IAAA,KAAA,EAAO,IAAA,CAAK,MAAA;AAAA,EACd;AAGA,EAAA,OAAO,OAAA,CAAQ,YAAA;AACjB;AAqBO,SAAS,UAAA,CAAc,OAAA,EAA8B;AAC1D,EAAA,IAAI,KAAA,EAAO,8CAAA,CAAe;AAE1B,EAAA,MAAA,CAAO,IAAA,EAAM;AACX,IAAA,MAAM,WAAA,EAAa,cAAA,CAAe,GAAA,CAAI,IAAI,CAAA;AAC1C,IAAA,GAAA,CAAI,WAAA,GAAc,UAAA,CAAW,GAAA,CAAI,OAAA,CAAQ,EAAE,CAAA,EAAG;AAC5C,MAAA,OAAO,IAAA;AAAA,IACT;AACA,IAAA,KAAA,EAAO,IAAA,CAAK,MAAA;AAAA,EACd;AAEA,EAAA,OAAO,KAAA;AACT;ADnMA;AACA;AACE;AACA;AACA;AACF,wGAAC","file":"/home/runner/work/fict/fict/packages/runtime/dist/chunk-6DNYVH5U.cjs","sourcesContent":[null,"/**\n * @fileoverview Context API for Fict\n *\n * Provides a way to pass data through the component tree without having to pass\n * props down manually at every level. Context is designed for:\n *\n * - SSR isolation (different request = different context values)\n * - Multi-instance support (multiple app roots with different values)\n * - Subtree scoping (override values in specific parts of the tree)\n *\n * ## Design Principles\n *\n * 1. **Reuses existing RootContext hierarchy** - Uses parent chain for value lookup,\n *    consistent with handleError/handleSuspend mechanisms.\n *\n * 2. **Zero extra root creation overhead** - Provider doesn't create new root,\n *    only mounts value on current root.\n *\n * 3. **Auto-aligned with insert/suspense boundaries** - Because they create child\n *    roots that inherit parent, context values propagate correctly.\n *\n * ## Usage\n *\n * ```tsx\n * // Create context with default value\n * const ThemeContext = createContext<'light' | 'dark'>('light')\n *\n * // Provide value to subtree\n * function App() {\n *   return (\n *     <ThemeContext.Provider value=\"dark\">\n *       <ThemedComponent />\n *     </ThemeContext.Provider>\n *   )\n * }\n *\n * // Consume value\n * function ThemedComponent() {\n *   const theme = useContext(ThemeContext)\n *   return <div class={theme}>...</div>\n * }\n * ```\n *\n * @module\n */\n\nimport { createElement } from './dom'\nimport { createRenderEffect } from './effect'\nimport {\n  createRootContext,\n  destroyRoot,\n  flushOnMount,\n  getCurrentRoot,\n  popRoot,\n  pushRoot,\n  type RootContext,\n} from './lifecycle'\nimport { insertNodesBefore, removeNodes, toNodeArray } from './node-ops'\nimport type { BaseProps, FictNode } from './types'\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Context object created by createContext.\n * Contains the Provider component and serves as a key for context lookup.\n */\nexport interface Context<T> {\n  /** Unique identifier for this context */\n  readonly id: symbol\n  /** Default value when no provider is found */\n  readonly defaultValue: T\n  /** Provider component for supplying context values */\n  Provider: ContextProvider<T>\n  /** Display name for debugging */\n  displayName?: string\n}\n\n/**\n * Props for the Context Provider component\n */\nexport interface ProviderProps<T> extends BaseProps {\n  /** The value to provide to the subtree */\n  value: T\n}\n\n/**\n * Provider component type\n */\nexport type ContextProvider<T> = (props: ProviderProps<T>) => FictNode\n\n// ============================================================================\n// Internal Context Storage\n// ============================================================================\n\n/**\n * WeakMap to store context values per RootContext.\n * Using WeakMap ensures proper garbage collection when roots are destroyed.\n */\nconst contextStorage = new WeakMap<RootContext, Map<symbol, unknown>>()\n\n/**\n * Get the context map for a root, creating it if needed\n */\nfunction getContextMap(root: RootContext): Map<symbol, unknown> {\n  let map = contextStorage.get(root)\n  if (!map) {\n    map = new Map()\n    contextStorage.set(root, map)\n  }\n  return map\n}\n\n// ============================================================================\n// Context API\n// ============================================================================\n\n/**\n * Creates a new context with the given default value.\n *\n * Context provides a way to pass values through the component tree without\n * explicit props drilling. It's especially useful for:\n *\n * - Theme data\n * - Locale/i18n settings\n * - Authentication state\n * - Feature flags\n * - Any data that many components at different nesting levels need\n *\n * @param defaultValue - The value to use when no Provider is found above in the tree\n * @returns A context object with a Provider component\n *\n * @example\n * ```tsx\n * // Create a theme context\n * const ThemeContext = createContext<'light' | 'dark'>('light')\n *\n * // Use the provider\n * function App() {\n *   return (\n *     <ThemeContext.Provider value=\"dark\">\n *       <Content />\n *     </ThemeContext.Provider>\n *   )\n * }\n *\n * // Consume the context\n * function Content() {\n *   const theme = useContext(ThemeContext)\n *   return <div class={`theme-${theme}`}>Hello</div>\n * }\n * ```\n */\nexport function createContext<T>(defaultValue: T): Context<T> {\n  const id = Symbol('fict.context')\n\n  const context: Context<T> = {\n    id,\n    defaultValue,\n    Provider: null as unknown as ContextProvider<T>,\n  }\n\n  // Create the Provider component\n  context.Provider = function Provider(props: ProviderProps<T>): FictNode {\n    const hostRoot = getCurrentRoot()\n\n    // Create a child root for the provider's subtree\n    // This establishes the provider boundary - children will look up from here\n    const providerRoot = createRootContext(hostRoot)\n\n    // Store the context value on this root\n    const contextMap = getContextMap(providerRoot)\n    contextMap.set(id, props.value)\n\n    // Create DOM structure\n    const markerOwnerDocument = providerRoot.ownerDocument ?? hostRoot?.ownerDocument ?? document\n    const fragment = markerOwnerDocument.createDocumentFragment()\n    const marker = markerOwnerDocument.createComment('fict:ctx')\n    fragment.appendChild(marker)\n\n    let cleanup: (() => void) | undefined\n    let activeNodes: Node[] = []\n\n    const renderChildren = (children: FictNode) => {\n      // Cleanup previous render\n      if (cleanup) {\n        cleanup()\n        cleanup = undefined\n      }\n      if (activeNodes.length) {\n        removeNodes(activeNodes)\n        activeNodes = []\n      }\n\n      if (children == null || children === false) {\n        return\n      }\n\n      const prev = pushRoot(providerRoot)\n      let nodes: Node[] = []\n      try {\n        const output = createElement(children)\n        nodes = toNodeArray(output, markerOwnerDocument)\n        const parentNode = marker.parentNode as (ParentNode & Node) | null\n        if (parentNode) {\n          insertNodesBefore(parentNode, nodes, marker)\n        }\n      } finally {\n        popRoot(prev)\n        flushOnMount(providerRoot)\n      }\n\n      cleanup = () => {\n        destroyRoot(providerRoot)\n        removeNodes(nodes)\n      }\n      activeNodes = nodes\n    }\n\n    // Initial render\n    createRenderEffect(() => {\n      // Update context value on re-render (if value prop changes reactively)\n      contextMap.set(id, props.value)\n      renderChildren(props.children)\n    })\n\n    return fragment\n  }\n\n  return context\n}\n\n/**\n * Reads the current value of a context.\n *\n * useContext looks up through the RootContext parent chain to find the\n * nearest Provider for this context. If no Provider is found, returns\n * the context's default value.\n *\n * @param context - The context object created by createContext\n * @returns The current context value\n *\n * @example\n * ```tsx\n * const ThemeContext = createContext('light')\n *\n * function ThemedButton() {\n *   const theme = useContext(ThemeContext)\n *   return <button class={theme === 'dark' ? 'btn-dark' : 'btn-light'}>Click</button>\n * }\n * ```\n */\nexport function useContext<T>(context: Context<T>): T {\n  let root = getCurrentRoot()\n\n  // Walk up the parent chain looking for the context value\n  while (root) {\n    const contextMap = contextStorage.get(root)\n    if (contextMap && contextMap.has(context.id)) {\n      return contextMap.get(context.id) as T\n    }\n    root = root.parent\n  }\n\n  // No provider found, return default value\n  return context.defaultValue\n}\n\n/**\n * Checks if a context value is currently provided in the tree.\n *\n * Useful for conditional behavior when a provider may or may not exist.\n *\n * @param context - The context object to check\n * @returns true if a Provider exists above in the tree\n *\n * @example\n * ```tsx\n * function OptionalTheme() {\n *   if (hasContext(ThemeContext)) {\n *     const theme = useContext(ThemeContext)\n *     return <div class={theme}>Themed content</div>\n *   }\n *   return <div>Default content</div>\n * }\n * ```\n */\nexport function hasContext<T>(context: Context<T>): boolean {\n  let root = getCurrentRoot()\n\n  while (root) {\n    const contextMap = contextStorage.get(root)\n    if (contextMap && contextMap.has(context.id)) {\n      return true\n    }\n    root = root.parent\n  }\n\n  return false\n}\n"]}