@qwik.dev/core 2.0.0-beta.32 → 2.0.0-beta.35

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.32-dev+0e29f8a
+ * @qwik.dev/core 2.0.0-beta.35-dev+4603135
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -9,13 +9,14 @@ import { isDev, isServer, isBrowser as isBrowser$1 } from '@qwik.dev/core/build'
 export { isBrowser, isDev, isServer } from '@qwik.dev/core/build';
 import { p } from '@qwik.dev/core/preloader';
 
-// same as isDev but separate so we can test
-const g = globalThis;
-const qDev = g.qDev !== false;
-const qInspector = g.qInspector === true;
-const qDynamicPlatform = g.qDynamicPlatform !== false;
-const qTest = g.qTest === true;
-const qRuntimeQrl = g.qRuntimeQrl === true;
+// Direct `globalThis.X` accesses (no alias) so Terser's `global_defs` engages
+// and folds these to literal booleans in production builds, allowing
+// `qTest ? testBranch : prodBranch` shims to tree-shake.
+const qDev = globalThis.qDev !== false;
+const qInspector = globalThis.qInspector === true;
+const qDynamicPlatform = globalThis.qDynamicPlatform !== false;
+const qTest = globalThis.qTest === true;
+const qRuntimeQrl = globalThis.qRuntimeQrl === true;
 const seal = (obj) => {
     if (qDev) {
         Object.seal(obj);
@@ -189,9 +190,9 @@ const isPrimitiveOrNullUndefined = (v) => {
     return (typeof v !== 'object' && typeof v !== 'function') || v === null || v === undefined;
 };
 
-const baseUrl = 'https://qwikdev-build-v2.qwik-8nx.pages.dev/docs/errors/#Q';
+const baseUrl = 'https://qwikdev-build-v2.qwik-8nx.pages.dev/docs/errors/#q';
 const codeToText = (code, ...parts) => {
-    if (qDev) {
+    if (isDev) {
         // Keep one error, one line to make it easier to search for the error message.
         // Keep in sync with packages/docs/src/routes/docs/errors/index.mdx
         const MAP = [
@@ -443,6 +444,7 @@ const ELEMENT_KEY = 'q:key';
 const ELEMENT_PROPS = 'q:props';
 const ELEMENT_SEQ = 'q:seq';
 const ELEMENT_SEQ_IDX = 'q:seqIdx';
+const Q_PREFIX = 'q:';
 const ITERATION_ITEM_SINGLE = 'q:p'; // Single iteration parameter (not an array)
 const ITERATION_ITEM_MULTI = 'q:ps'; // Multiple iteration parameters (array)
 /** Non serializable markers - always begins with `:` character */
@@ -450,6 +452,8 @@ const NON_SERIALIZABLE_MARKER_PREFIX = ':';
 const USE_ON_LOCAL = NON_SERIALIZABLE_MARKER_PREFIX + 'on';
 const USE_ON_LOCAL_SEQ_IDX = NON_SERIALIZABLE_MARKER_PREFIX + 'onIdx';
 const USE_ON_LOCAL_FLAGS = NON_SERIALIZABLE_MARKER_PREFIX + 'onFlags';
+const QCursorBoundary = Q_PREFIX + 'cursorBoundary';
+const QNearestCursorBoundary = NON_SERIALIZABLE_MARKER_PREFIX + 'nearestCursorBoundary';
 const Q_PROPS_SEPARATOR = ':';
 const dangerouslySetInnerHTML = 'dangerouslySetInnerHTML';
 const qwikInspectorAttr = 'data-qwik-inspector';
@@ -793,6 +797,30 @@ const styleKey = (qStyles, index) => {
     return `${hashCode(qStyles.$hash$)}-${index}`;
 };
 
+/**
+ * Creates a function that schedules `fn` to run as a microtask. Microtasks run before browser
+ * paint, preventing flickering.
+ */
+const createMicroTask = (fn) => {
+    return () => queueMicrotask(fn);
+};
+/**
+ * Creates a function that schedules `fn` to run as a macrotask. Macrotasks yield to the browser,
+ * allowing paint and user input. Used for time-slicing to avoid blocking the main thread.
+ */
+const createMacroTask = (fn) => {
+    let macroTask;
+    if (typeof MessageChannel !== 'undefined') {
+        const channel = new MessageChannel();
+        channel.port1.onmessage = () => fn();
+        macroTask = () => channel.port2.postMessage(null);
+    }
+    else {
+        macroTask = () => setTimeout(fn);
+    }
+    return macroTask;
+};
+
 // keep this import from core/build so the cjs build works
 const createPlatform = () => {
     return {
@@ -893,33 +921,13 @@ const isServerPlatform = () => {
     return false;
 };
 
-/**
- * Creates a function that schedules `fn` to run as a microtask. Microtasks run before browser
- * paint, preventing flickering.
- */
-const createMicroTask = (fn) => {
-    return () => queueMicrotask(fn);
-};
-/**
- * Creates a function that schedules `fn` to run as a macrotask. Macrotasks yield to the browser,
- * allowing paint and user input. Used for time-slicing to avoid blocking the main thread.
- */
-const createMacroTask = (fn) => {
-    let macroTask;
-    if (typeof MessageChannel !== 'undefined') {
-        const channel = new MessageChannel();
-        channel.port1.onmessage = () => fn();
-        macroTask = () => channel.port2.postMessage(null);
-    }
-    else {
-        macroTask = () => setTimeout(fn);
-    }
-    return macroTask;
-};
-
-const isBrowser = import.meta.env.TEST ? !isServerPlatform() : !isServer;
+const hasDocument = typeof document !== 'undefined';
+const isBrowser = (qTest ? !isServerPlatform() : !isServer) && hasDocument;
 // Browser-specific setup
 const doc = isBrowser ? document : undefined;
+const config = {
+    $maxIdlePreloads$: 25,
+};
 // Determine which rel attribute to use based on browser support
 const rel = isBrowser && doc.createElement('link').relList?.supports?.('modulepreload')
     ? 'modulePreload'
@@ -935,7 +943,6 @@ const BundleImportState_Alias = 3;
 const BundleImportState_Loaded = 4;
 
 let base;
-import.meta.env.TEST ? !isServerPlatform() : !isServer;
 const makeBundle = (name, deps) => {
     return {
         $name$: name,
@@ -965,7 +972,6 @@ const nextAdjustmentMacroTask = createMacroTask(processPendingAdjustments);
 let isTriggerScheduled = false;
 let isAdjustmentScheduled = false;
 let isProcessingAdjustments = false;
-const shouldYieldInBrowser = import.meta.env.TEST ? !isServerPlatform() : isBrowser$1;
 const adjustmentStack = [];
 /**
  * This is called when a bundle is queued, or finished loading.
@@ -987,10 +993,8 @@ function trigger() {
         const bundle = queue[0];
         const inverseProbability = bundle.$inverseProbability$;
         const probability = 1 - inverseProbability;
-        const allowedPreloads = // While the graph is not available, we limit to 5 preloads
-                5;
-        // When we're 99% sure, everything needs to be queued
-        if (probability >= 0.99 || preloadCount < allowedPreloads) {
+        // We want to preload all the transitive static (1) and dynamic (0.99) dependencies, throttled by the user defined maxIdlePreloads.
+        if (probability >= 0.99 || preloadCount < config.$maxIdlePreloads$) {
             queue.shift();
             preloadOne(bundle);
             if (performance.now() >= deadline) {
@@ -1007,13 +1011,12 @@ function trigger() {
         nextTriggerMacroTask();
     }
 }
-const enqueueAdjustment = (bundle, inverseProbability, context, seen) => {
+const enqueueAdjustment = (bundle, inverseProbability, seen) => {
     // Keep existing work on the stack hot and append new roots behind it.
     adjustmentStack.unshift({
         $bundle$: bundle,
         $inverseProbability$: inverseProbability,
         $seen$: seen,
-        $context$: context,
     });
 };
 const processAdjustmentFrame = () => {
@@ -1033,9 +1036,8 @@ const processAdjustmentFrame = () => {
         }
         const probability = 1 - bundle.$inverseProbability$;
         let newInverseProbability;
-        if (probability === 1 || (probability >= 0.99 && frame.$context$.$depsCount$ < 100)) {
-            frame.$context$.$depsCount$++;
-            // we're loaded at max probability, so elevate dynamic imports to 99% sure
+        if (probability === 1 || probability >= 0.99) {
+            // bundle is requested at max probability, so elevate all its transitive static and dynamic deps to 99% sure
             newInverseProbability = Math.min(0.01, 1 - dep.$importProbability$);
         }
         else {
@@ -1051,7 +1053,6 @@ const processAdjustmentFrame = () => {
             $bundle$: depBundle,
             $inverseProbability$: newInverseProbability,
             $seen$: frame.$seen$,
-            $context$: frame.$context$,
         });
         return true;
     }
@@ -1083,12 +1084,12 @@ function processPendingAdjustments() {
     }
     isAdjustmentScheduled = false;
     isProcessingAdjustments = true;
-    const deadline = shouldYieldInBrowser ? performance.now() + yieldInterval : 0;
+    const deadline = isBrowser ? performance.now() + yieldInterval : 0;
     let processed = false;
     while (adjustmentStack.length) {
         processed = true;
         const checkDeadline = processAdjustmentFrame();
-        if (shouldYieldInBrowser && checkDeadline && performance.now() >= deadline) {
+        if (isBrowser && checkDeadline && performance.now() >= deadline) {
             if (!isAdjustmentScheduled) {
                 isAdjustmentScheduled = true;
                 nextAdjustmentMacroTask();
@@ -1097,7 +1098,7 @@ function processPendingAdjustments() {
         }
     }
     isProcessingAdjustments = false;
-    if (processed && shouldYieldInBrowser) {
+    if (processed && isBrowser) {
         nextTriggerMacroTask();
     }
 }
@@ -1128,64 +1129,35 @@ const preloadOne = (bundle) => {
     };
     doc.head.appendChild(link);
 };
-/**
- * Adjust the probability of a bundle based on the probability of its dependent bundles, and queue
- * it if it's likely enough to be preloaded.
- *
- * Note that if the probability is 100%, we treat the dynamic imports as 99% sure, and both will be
- * preloaded without limit.
- *
- * We also limit "organic" probability to 98% so they don't get unlimited preloads.
- */
-const adjustProbabilities = (bundle, newInverseProbability, seen) => {
-    enqueueAdjustment(bundle, newInverseProbability, { $depsCount$: 0 }, seen);
-    if (shouldYieldInBrowser) {
-        nextAdjustmentMacroTask();
-    }
-    else {
-        processPendingAdjustments();
-    }
-};
-const handleBundle = (name, inverseProbability, context) => {
+const handleBundle = (name, inverseProbability) => {
     const bundle = getBundle(name);
-    if (bundle && bundle.$inverseProbability$ > inverseProbability) {
-        if (context) {
-            enqueueAdjustment(bundle, inverseProbability, context);
-        }
-        else {
-            adjustProbabilities(bundle, inverseProbability);
-        }
+    if (bundle) {
+        enqueueAdjustment(bundle, inverseProbability);
     }
 };
-const preload = (name, probability) => {
-    if (!name?.length) {
+const preload = (item, probability) => {
+    if (!item?.length) {
         return;
     }
-    let inverseProbability = 1 - probability ;
-    const context = { $depsCount$: 0 };
-    if (Array.isArray(name)) {
+    const inverseProbability = 1 - probability ;
+    if (Array.isArray(item)) {
         // We must process in reverse order to ensure first bundles are handled first
-        for (let i = name.length - 1; i >= 0; i--) {
-            const item = name[i];
-            if (typeof item === 'number') {
-                inverseProbability = 1 - item / 10;
-            }
-            else {
-                handleBundle(item, inverseProbability, context);
-            }
+        for (let i = item.length - 1; i >= 0; i--) {
+            const bundle = item[i];
+            handleBundle(bundle, inverseProbability);
         }
     }
     else {
-        handleBundle(name, inverseProbability, context);
+        handleBundle(item, inverseProbability);
     }
-    if (shouldYieldInBrowser) {
+    if (isBrowser) {
         nextAdjustmentMacroTask();
     }
     else {
         processPendingAdjustments();
     }
 };
-if (import.meta.env.TEST ? !isServerPlatform() : isBrowser$1) {
+if (isBrowser) {
     // Get early hints from qwikloader
     document.addEventListener('qsymbol', (ev) => {
         const { symbol, href } = ev.detail;
@@ -1219,7 +1191,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.32-dev+0e29f8a";
+const version = "2.0.0-beta.35-dev+4603135";
 
 const isNode = (value) => {
     return value && typeof value.nodeType === 'number';
@@ -1675,6 +1647,17 @@ function mergeCursors(container, newCursorData, oldCursor) {
             newCursorData.journal = oldJournal;
         }
     }
+    // merge cursor boundaries
+    const oldBoundaries = oldCursorData.boundaries;
+    if (__EXPERIMENTAL__.suspense && oldBoundaries && oldBoundaries.length > 0) {
+        const newBoundaries = (newCursorData.boundaries ||= []);
+        for (let i = 0; i < oldBoundaries.length; i++) {
+            const boundary = oldBoundaries[i];
+            if (!newBoundaries.includes(boundary)) {
+                newBoundaries.push(boundary);
+            }
+        }
+    }
 }
 /**
  * Gets the cursor data from a vNode.
@@ -1905,7 +1888,7 @@ class SignalImpl {
             // to unsubscribe from. So we need to store the reference from the effect back
             // to this signal.
             ensureContainsBackRef(effectSubscriber, this);
-            (import.meta.env.TEST ? !isDomContainer(this.$container$) : isServer) &&
+            (qTest ? !isDomContainer(this.$container$) : isServer) &&
                 addQrlToSerializationCtx(effectSubscriber, this.$container$);
         }
         return val;
@@ -2131,8 +2114,7 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     get untrackedValue() {
         this.$computeIfNeeded$();
         if (this.$current$?.$promise$) {
-            if (this.$untrackedValue$ === NEEDS_COMPUTATION ||
-                (import.meta.env.TEST ? isServerPlatform() : isServer)) {
+            if (this.$untrackedValue$ === NEEDS_COMPUTATION || (qTest ? isServerPlatform() : isServer)) {
                 throw this.$current$?.$promise$;
             }
             return this.$untrackedValue$;
@@ -2142,7 +2124,7 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         }
         // For clientOnly signals without initial value during SSR, throw if trying to read value
         // During SSR, clientOnly signals are skipped, so there's no computed value available
-        if ((import.meta.env.TEST ? isServerPlatform() : isServer) &&
+        if ((qTest ? isServerPlatform() : isServer) &&
             this.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */ &&
             this.$untrackedValue$ === NEEDS_COMPUTATION) {
             throw qError(35 /* QError.asyncClientOnlyValueDuringSSR */);
@@ -2216,7 +2198,7 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         // reading `.loading` means someone is interested in the result, so we should trigger the computation. The alternative is eager computation or imperative calls to invalidate; this seems nicer.
         this.$computeIfNeeded$();
         // During SSR there's no such thing as loading state, we must render complete results
-        if ((import.meta.env.TEST ? isServerPlatform() : isServer) && this.$current$?.$promise$) {
+        if ((qTest ? isServerPlatform() : isServer) && this.$current$?.$promise$) {
             throw this.$current$?.$promise$;
         }
         return this.$untrackedLoading$;
@@ -2317,7 +2299,7 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         if (!(this.$flags$ & 32 /* AsyncSignalFlags.EAGER_CLEANUP */) || this.$hasSubscribers$()) {
             return;
         }
-        if (!(import.meta.env.TEST ? !isServerPlatform() : isBrowser$1)) {
+        if (!(qTest ? !isServerPlatform() : isBrowser$1)) {
             return;
         }
         setTimeout(() => {
@@ -2340,8 +2322,7 @@ class AsyncSignalImpl extends ComputedSignalImpl {
             return;
         }
         // Skip computation on SSR for clientOnly signals
-        if ((import.meta.env.TEST ? isServerPlatform() : isServer) &&
-            this.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */) {
+        if ((qTest ? isServerPlatform() : isServer) && this.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */) {
             // We must pretend to load, and register as a listener for the captures
             this.$untrackedLoading$ = true;
             this.$container$?.serializationCtx.$eagerResume$.add(this);
@@ -2373,9 +2354,11 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     }
     async $runComputation$(running) {
         const isCurrent = () => running === this.$current$;
-        this.untrackedLoading = true;
         let fn = this.$computeQrl$.resolved;
         if (!fn) {
+            // QRL resolution is async — we have to publish loading=true before awaiting so
+            // subscribers know the value isn't ready yet.
+            this.untrackedLoading = true;
             fn = await this.$computeQrl$.resolve();
             if (running.$abortController$?.signal.aborted) {
                 running.$promise$ = null;
@@ -2390,9 +2373,20 @@ class AsyncSignalImpl extends ComputedSignalImpl {
                     running.$abortController$?.abort(error);
                 }, this.$timeoutMs$);
             }
-            // Try to stay sync if possible
+            // Try to stay sync if possible. Only publish loading=true to subscribers when
+            // the compute is actually asynchronous — a synchronous resolve (e.g. pre-loaded
+            // values injected via _injectAsyncSignalValue) should never transition through a
+            // visible loading state, which on SSR would fire the loading-effect subscribers
+            // (tasks) while the value is still "loading" from their perspective.
             const valuePromise = retryOnPromise(fn.bind(null, running));
-            const value = isPromise(valuePromise) ? await valuePromise : valuePromise;
+            let value;
+            if (isPromise(valuePromise)) {
+                this.untrackedLoading = true;
+                value = await valuePromise;
+            }
+            else {
+                value = valuePromise;
+            }
             running.$promise$ = null;
             if (running.$canWrite$) {
                 const jobs = this.$jobs$;
@@ -2476,7 +2470,7 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         }
     }
     $scheduleNextPoll$() {
-        if ((import.meta.env.TEST ? isServerPlatform() : isServer) || !this.$expires$) {
+        if ((qTest ? isServerPlatform() : isServer) || !this.$expires$) {
             return;
         }
         this.$clearNextPoll$();
@@ -3619,7 +3613,7 @@ const executeComponent = (container, renderHost, subscriptionHost, componentQRL,
         const inlineComponent = componentQRL;
         componentFn = () => invokeApply(iCtx, inlineComponent, [props || EMPTY_OBJ]);
     }
-    const isSsr = import.meta.env.TEST ? isServerPlatform() : isServer;
+    const isSsr = qTest ? isServerPlatform() : isServer;
     const executeComponentWithPromiseExceptionRetry = (retryCount = 0) => safeCall(() => {
         if (!isInlineComponent) {
             container.setHostProp(renderHost, ELEMENT_SEQ_IDX, null);
@@ -4004,6 +3998,214 @@ const createSetTextOperation = (target, text) => new SetTextOperation(target, te
 const createInsertOrMoveOperation = (target, parent, beforeTarget) => new InsertOrMoveOperation(target, parent, beforeTarget);
 const createSetAttributeOperation = (target, attrName, attrValue, scopedStyleIdPrefix = null, isSvg = false) => new SetAttributeOperation(target, attrName, attrValue, scopedStyleIdPrefix, isSvg);
 
+/**
+ * @internal
+ * The storage provider for hooks. Each invocation increases index i. Data is stored in an array.
+ */
+const useSequentialScope = () => {
+    const iCtx = useInvokeContext();
+    const hostElement = iCtx.$hostElement$;
+    const host = hostElement;
+    let seq = iCtx.$container$.getHostProp(host, ELEMENT_SEQ);
+    if (seq === null) {
+        seq = [];
+        iCtx.$container$.setHostProp(host, ELEMENT_SEQ, seq);
+    }
+    let seqIdx = iCtx.$container$.getHostProp(host, ELEMENT_SEQ_IDX);
+    if (seqIdx === null) {
+        seqIdx = 0;
+    }
+    iCtx.$container$.setHostProp(host, ELEMENT_SEQ_IDX, seqIdx + 1);
+    while (seq.length <= seqIdx) {
+        seq.push(undefined);
+    }
+    const set = (value) => {
+        if (qDev) {
+            verifySerializable(value);
+        }
+        return (seq[seqIdx] = value);
+    };
+    return {
+        val: seq[seqIdx],
+        set,
+        i: seqIdx,
+        iCtx,
+    };
+};
+
+const getSignal = (initialState) => {
+    const value = isFunction(initialState) && !isQwikComponent(initialState)
+        ? invoke(undefined, initialState)
+        : initialState;
+    return createSignal(value);
+};
+// <docs markdown="../readme.md#useSignal">
+// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
+// (edit ../readme.md#useSignal instead and run `pnpm docs.sync`)
+/**
+ * Creates an object with a single reactive `.value` property, that Qwik can track across
+ * serializations.
+ *
+ * Use it to create state for your application. The object has a getter and setter to track reads
+ * and writes of the `.value` property. When the value changes, any functions that read from it will
+ * re-run.
+ *
+ * Prefer `useSignal` over `useStore` when possible, as it is more efficient.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * const Signals = component$(() => {
+ *   const counter = useSignal(1);
+ *   const text = useSignal('changeme');
+ *   const toggle = useSignal(false);
+ *
+ *   // useSignal() can also accept a function to calculate the initial value
+ *   const state = useSignal(() => {
+ *     return expensiveInitialValue();
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick$={() => counter.value++}>Counter: {counter.value}</button>
+ *       {
+ *         // pass signal values as the value, the optimizer will make it pass the signal
+ *       }
+ *       <Child state={state.value} />
+ *       {
+ *         // signals can be bound to inputs. A property named `bind:x` implies that the property
+ * is a signal
+ *       }
+ *       <input type="text" bind:value={text} />
+ *       <input type="checkbox" bind:checked={toggle} />
+ *     </div>
+ *   );
+ * });
+ * ```
+ *
+ * @public
+ */
+// </docs>
+const useSignal = (initialState) => {
+    return useConstant((getSignal), initialState);
+};
+/**
+ * Stores a value which is retained for the lifetime of the component. Subsequent calls to
+ * `useConstant` will always return the first value given.
+ *
+ * If the value is a function, the function is invoked once to calculate the actual value. You can
+ * then also pass arguments to call the function with, so that you don't need to create a new
+ * function on every render.
+ *
+ * @example
+ *
+ * ```tsx
+ * const fixedRandomValue = useConstant(() => Math.random);
+ * const otherFixedRandomValue = useConstant(Math.random);
+ *
+ * const getConfig = (env: string) => { ... }
+ * const config = useConstant(getConfig, environment);
+ * ```
+ *
+ * @public
+ */
+const useConstant = (value, ...args) => {
+    const { val, set } = useSequentialScope();
+    if (val != null) {
+        return val;
+    }
+    // We don't want to create a subscription since we only run this once
+    // Note: We are not using `invoke` here because we don't want to clear the context
+    value = isFunction(value) && !isQwikComponent(value) ? untrack(value, ...args) : value;
+    return set(value);
+};
+
+const createCursorBoundary = () => {
+    return {
+        pending: createSignal(0),
+        version: createSignal(0),
+    };
+};
+/** @internal */
+const useCursorBoundary = () => {
+    if (!__EXPERIMENTAL__.suspense) {
+        throw new Error('useCursorBoundary is experimental and must be enabled with `experimental: ["suspense"]` in the `qwikVite` plugin.');
+    }
+    return useConstant(createCursorBoundary);
+};
+function addCursorBoundary(cursorData, vNode) {
+    if (!__EXPERIMENTAL__.suspense) {
+        return;
+    }
+    const boundary = getNearestCursorBoundary(cursorData.container, vNode);
+    if (!boundary) {
+        return;
+    }
+    const boundaries = (cursorData.boundaries ||= []);
+    if (!boundaries.includes(boundary)) {
+        boundaries.push(boundary);
+        boundary.pending.value++;
+    }
+}
+function resolveCursorBoundaries(cursorData) {
+    if (!__EXPERIMENTAL__.suspense) {
+        return;
+    }
+    const boundaries = cursorData.boundaries;
+    if (!boundaries) {
+        return;
+    }
+    cursorData.boundaries = null;
+    for (let i = 0; i < boundaries.length; i++) {
+        const boundary = boundaries[i];
+        boundary.pending.value = Math.max(0, boundary.pending.value - 1);
+        boundary.version.value++;
+    }
+}
+function getOwnCursorBoundary(container, vNode) {
+    if (!__EXPERIMENTAL__.suspense) {
+        return null;
+    }
+    return container.getHostProp(vNode, QCursorBoundary);
+}
+function getNearestCursorBoundaryProp(vNode) {
+    if (!__EXPERIMENTAL__.suspense) {
+        return null;
+    }
+    return (vnode_getProp(vNode, QNearestCursorBoundary, null) ||
+        null);
+}
+function clearNearestCursorBoundary(vNode) {
+    if (!__EXPERIMENTAL__.suspense) {
+        return;
+    }
+    vnode_setProp(vNode, QNearestCursorBoundary, null);
+}
+function getNearestCursorBoundary(container, vNode) {
+    if (!__EXPERIMENTAL__.suspense) {
+        return null;
+    }
+    return getNearestCursorBoundaryProp(vNode) || getOwnCursorBoundary(container, vNode);
+}
+function setNearestCursorBoundary(vNode, boundary) {
+    __EXPERIMENTAL__.suspense && vnode_setProp(vNode, QNearestCursorBoundary, boundary);
+}
+/** Updates the nearest cursor boundary cache on a vnode and any already-dirty descendants. */
+function updateDirtySubtreeCursorBoundary(container, vNode, boundary) {
+    if (!__EXPERIMENTAL__.suspense) {
+        return;
+    }
+    setNearestCursorBoundary(vNode, boundary);
+    const dirtyChildren = vNode.dirtyChildren;
+    if (!dirtyChildren || dirtyChildren.length === 0) {
+        return;
+    }
+    for (let i = 0; i < dirtyChildren.length; i++) {
+        const child = dirtyChildren[i];
+        updateDirtySubtreeCursorBoundary(container, child, getOwnCursorBoundary(container, child) || boundary);
+    }
+}
+
 const cleanupDestroyable = (destroyable) => {
     if (destroyable.$destroy$) {
         try {
@@ -4124,7 +4326,7 @@ function peekNextSiblingWithinBoundary(diffContext, vCurrent) {
 const _hasOwnProperty = Object.prototype.hasOwnProperty;
 /** Helper to set an attribute on a vnode. Extracted to module scope to avoid closure allocation. */
 function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalValue) {
-    import.meta.env.TEST &&
+    qTest &&
         scopedStyleIdPrefix &&
         vnode_setProp(vnode, debugStyleScopeIdPrefixAttr, scopedStyleIdPrefix);
     vnode_setProp(vnode, key, originalValue);
@@ -4528,8 +4730,10 @@ function expectProjection(diffContext) {
     }
 }
 function expectSlot(diffContext) {
+    const jsxNode = diffContext.$jsxValue$;
     const vHost = vnode_getProjectionParentComponent(diffContext.$vParent$);
     const slotNameKey = getSlotNameKey(diffContext, vHost);
+    const cursorBoundary = directGetPropsProxyProp(jsxNode, QCursorBoundary) || null;
     const vProjectedNode = vHost
         ? vnode_getProp(vHost, slotNameKey, 
         // for slots this id is vnode ref id
@@ -4540,6 +4744,8 @@ function expectSlot(diffContext) {
     if (vProjectedNode == null) {
         diffContext.$vNewNode$ = vnode_newVirtual();
         vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
+        vnode_setProp(diffContext.$vNewNode$, QCursorBoundary, cursorBoundary);
+        updateDirtySubtreeCursorBoundary(diffContext.$container$, diffContext.$vNewNode$, cursorBoundary);
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
             vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */); // Nothing to project, so render content of the slot.
@@ -4552,6 +4758,8 @@ function expectSlot(diffContext) {
         const oldParent = vProjectedNode.parent;
         diffContext.$vNewNode$ = vProjectedNode;
         vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
+        vnode_setProp(diffContext.$vNewNode$, QCursorBoundary, cursorBoundary);
+        updateDirtySubtreeCursorBoundary(diffContext.$container$, diffContext.$vNewNode$, cursorBoundary);
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
             vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */);
@@ -4787,7 +4995,7 @@ function registerEventHandlers(key, value, element, vnode, diffContext) {
 function createElementWithNamespace(diffContext, elementName) {
     const domParentVNode = vnode_getDomParentVNode(diffContext.$vParent$, true);
     const namespaceData = getNewElementNamespaceData(domParentVNode, elementName);
-    const currentDocument = import.meta.env.TEST ? diffContext.$container$.document : document;
+    const currentDocument = qTest ? diffContext.$container$.document : document;
     const element = namespaceData.elementNamespaceFlag === 0 /* VNodeFlags.NS_html */
         ? currentDocument.createElement(elementName)
         : currentDocument.createElementNS(namespaceData.elementNamespace, elementName);
@@ -4912,7 +5120,7 @@ const patchProperty = (diffContext, vnode, key, value, currentFile) => {
     setAttribute(diffContext.$journal$, vnode, key, value, diffContext.$scopedStyleIdPrefix$, originalValue);
 };
 function registerQwikLoaderEvent(diffContext, eventName) {
-    const qWindow = import.meta.env.TEST
+    const qWindow = qTest
         ? diffContext.$container$.document.defaultView
         : window;
     if (qWindow) {
@@ -5226,7 +5434,7 @@ function expectText(diffContext, text) {
             return;
         }
     }
-    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newText((import.meta.env.TEST ? diffContext.$container$.document : document).createTextNode(text), text)), getCurrentInsertBefore(diffContext));
+    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newText((qTest ? diffContext.$container$.document : document).createTextNode(text), text)), getCurrentInsertBefore(diffContext));
 }
 /**
  * Retrieve the key from the VNode.
@@ -6294,13 +6502,18 @@ function scheduleYield() {
  *
  * @param options - Walk options (time budget, etc.)
  */
-function processCursorQueue(options = {
-    timeBudget: 1000 / 60, // 60fps
-}) {
+function processCursorQueue() {
     isNextTickScheduled = false;
+    const startTime = performance.now();
+    const yieldTime = startTime + 15; // 16 ms = 60 FPS, use 15 to yield slightly before next frame
     let cursor = null;
     while ((cursor = getHighestPriorityCursor())) {
-        walkCursor(cursor, options);
+        if (walkCursor(cursor, yieldTime)) {
+            // Cursor overran time budget, yield to browser
+            // Note that each tick we process at least one thing
+            scheduleYield();
+            return;
+        }
     }
 }
 /**
@@ -6319,13 +6532,12 @@ function processCursorQueue(options = {
  * Note that there is only one walker for all containers in the app with the same Qwik version.
  *
  * @param cursor - The cursor to walk
- * @param options - Walk options (time budget, etc.)
- * @returns Walk result indicating completion status
+ * @param until - Time budget (timestamp to yield by)
+ * @returns `true` if the walk was paused due to time budget (do not process more cursors in this
+ *   tick)
  */
-function walkCursor(cursor, options) {
-    const { timeBudget } = options;
-    const isRunningOnServer = import.meta.env.TEST ? isServerPlatform() : isServer;
-    const startTime = performance.now();
+function walkCursor(cursor, until) {
+    const isRunningOnServer = qTest ? isServerPlatform() : isServer;
     const cursorData = getCursorData(cursor);
     // Check if cursor is blocked by a promise
     const blockingPromise = cursorData.promise;
@@ -6349,7 +6561,8 @@ function walkCursor(cursor, options) {
         // Skip if the vNode is not dirty
         if (!(currentVNode.dirty & 511 /* ChoreBits.DIRTY_MASK */)) {
             // Move to next node
-            setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
+            __EXPERIMENTAL__.suspense && clearNearestCursorBoundary(currentVNode);
+            setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor, container));
             continue;
         }
         // Skip if the vNode is deleted
@@ -6367,7 +6580,7 @@ function walkCursor(cursor, options) {
             }
             // Clear dirty bits and move to next node
             currentVNode.dirty &= -512 /* ChoreBits.DIRTY_MASK */;
-            setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
+            setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor, container));
             continue;
         }
         let result;
@@ -6410,6 +6623,7 @@ function walkCursor(cursor, options) {
         }
         // Handle blocking promise
         if (result && isPromise(result)) {
+            addCursorBoundary(cursorData, currentVNode);
             // Store promise on cursor and pause
             cursorData.promise = result;
             pauseCursor(cursor, container);
@@ -6426,13 +6640,8 @@ function walkCursor(cursor, options) {
             return;
         }
         // Check time budget (only for DOM, not SSR)
-        if (isBrowser$1) {
-            const elapsed = performance.now() - startTime;
-            if (elapsed >= timeBudget) {
-                // Schedule continuation as macrotask to actually yield to browser
-                scheduleYield();
-                return;
-            }
+        if (performance.now() >= until) {
+            return true;
         }
     }
     isDev &&
@@ -6445,6 +6654,7 @@ function finishWalk(container, cursor, cursorData, isServer) {
         if (!isServer) {
             executeFlushPhase(cursor, container);
         }
+        resolveCursorBoundaries(cursorData);
         if (cursorData.extraPromises) {
             Promise.all(cursorData.extraPromises).then(() => {
                 resolveCursor(container);
@@ -6465,30 +6675,14 @@ function tryDescendDirtyChildren(container, cursorData, currentVNode, cursor) {
     const dirtyChildren = currentVNode.dirtyChildren;
     if (!dirtyChildren || dirtyChildren.length === 0) {
         currentVNode.dirty &= -33 /* ChoreBits.CHILDREN */;
+        clearNearestCursorBoundary(currentVNode);
         return null;
     }
     partitionDirtyChildren(dirtyChildren, currentVNode);
-    // Scan dirtyChildren directly instead of going through getNextVNode.
-    // getNextVNode follows the child's parent/slotParent pointer, which for Projection nodes
-    // points to the DOM insertion location rather than currentVNode — that would scan the
-    // wrong dirtyChildren array and potentially cause infinite loops.
-    // const len = dirtyChildren.length;
-    // for (let i = 0; i < len; i++) {
-    //   const child = dirtyChildren[i];
-    //   if (child.dirty & ChoreBits.DIRTY_MASK) {
-    //     currentVNode.nextDirtyChildIndex = (i + 1) % len;
-    //     setCursorPosition(container, cursorData, child);
-    //     return child;
-    //   }
-    // }
-    // // No dirty child found — clean up
-    // currentVNode.dirty &= ~ChoreBits.CHILDREN;
-    // currentVNode.dirtyChildren = null;
     currentVNode.nextDirtyChildIndex = 0;
-    const next = getNextVNode(dirtyChildren[0], cursor);
+    const next = getNextVNode(dirtyChildren[0], cursor, container);
     setCursorPosition(container, cursorData, next);
     return next;
-    // return null;
 }
 /**
  * Partitions dirtyChildren array so non-projections come first, projections last. Uses in-place
@@ -6510,7 +6704,7 @@ function partitionDirtyChildren(dirtyChildren, parent) {
     }
 }
 /** @returns Next vNode to process, or null if traversal is complete */
-function getNextVNode(vNode, cursor) {
+function getNextVNode(vNode, cursor, container) {
     if (vNode === cursor) {
         if (cursor.dirty & 511 /* ChoreBits.DIRTY_MASK */) {
             return cursor;
@@ -6538,6 +6732,13 @@ function getNextVNode(vNode, cursor) {
     while (count-- > 0) {
         const nextVNode = dirtyChildren[index];
         if (nextVNode.dirty & 511 /* ChoreBits.DIRTY_MASK */) {
+            if (container && splitCursorBoundary(container, nextVNode)) {
+                index++;
+                if (index === len) {
+                    index = 0;
+                }
+                continue;
+            }
             parent.nextDirtyChildIndex = (index + 1) % len;
             return nextVNode;
         }
@@ -6550,7 +6751,22 @@ function getNextVNode(vNode, cursor) {
     parent.dirty &= -33 /* ChoreBits.CHILDREN */;
     parent.dirtyChildren = null;
     parent.nextDirtyChildIndex = 0;
-    return getNextVNode(parent, cursor);
+    __EXPERIMENTAL__.suspense && clearNearestCursorBoundary(parent);
+    return getNextVNode(parent, cursor, container);
+}
+function splitCursorBoundary(container, vNode) {
+    if (!__EXPERIMENTAL__.suspense) {
+        return false;
+    }
+    if (!vNode.props ||
+        !(QCursorBoundary in vNode.props) ||
+        !container.getHostProp(vNode, QCursorBoundary)) {
+        return false;
+    }
+    if (!isCursor(vNode)) {
+        addCursor(container, vNode, 0);
+    }
+    return true;
 }
 
 /**
@@ -6570,6 +6786,7 @@ function addCursor(container, root, priority) {
         position: root,
         priority: priority,
         promise: null,
+        boundaries: null,
     };
     setCursorData(root, cursorData);
     const cursor = root;
@@ -6613,7 +6830,7 @@ function _executeSsrChores(container, ssrNode) {
         if (ssrNode.dirty & 16 /* ChoreBits.COMPUTE */) {
             executeCompute(ssrNode, container);
         }
-        if (ssrNode.dirty & 511 /* ChoreBits.DIRTY_MASK */) {
+        if (isDev && ssrNode.dirty & 511 /* ChoreBits.DIRTY_MASK */) {
             // We are running on the server.
             // On server we can't schedule task for a different host!
             // Server is SSR, and therefore scheduling for anything but the current host
@@ -6736,14 +6953,23 @@ function propagatePath(target) {
  * Propagates dirty bits from vNode up to the specified cursorRoot. Used during diff when we know
  * the cursor root to merge with. Also updates cursor position if we pass through any cursors.
  */
-function propagateToCursorRoot(vNode, cursorRoot) {
+function propagateToCursorRoot(container, vNode, cursorRoot) {
     reusablePath.push(vNode);
+    let cursorBoundary = getOwnCursorBoundary(container, vNode);
     let current = vNode.slotParent || vNode.parent;
     while (current) {
         const isDirty = current.dirty & 511 /* ChoreBits.DIRTY_MASK */;
         const currentIsCursor = isCursor(current);
+        if (__EXPERIMENTAL__.suspense) {
+            cursorBoundary ||=
+                getOwnCursorBoundary(container, current) ||
+                    (isDirty ? getNearestCursorBoundary(container, current) : null);
+        }
         // Stop when we reach the cursor root or a dirty ancestor
         if (current === cursorRoot || isDirty) {
+            // Known cursor root / dirty ancestor case: cache the boundary discovered while walking
+            // before attaching this dirty vnode to the existing scheduled subtree.
+            setNearestCursorBoundary(vNode, cursorBoundary);
             propagatePath(current);
             // Update cursor position if current is a cursor
             if (currentIsCursor) {
@@ -6772,12 +6998,23 @@ function propagateToCursorRoot(vNode, cursorRoot) {
  * Finds a blocking cursor or dirty ancestor and propagates dirty bits to it. Returns true if found
  * and attached, false if a new cursor should be created.
  */
-function findAndPropagateToBlockingCursor(vNode) {
+function findAndPropagateToBlockingCursor(container, vNode) {
     reusablePath.push(vNode);
+    let cursorBoundary = __EXPERIMENTAL__.suspense
+        ? getOwnCursorBoundary(container, vNode)
+        : null;
     let current = vNode.slotParent || vNode.parent;
     while (current) {
         const currentIsCursor = isCursor(current);
+        if (__EXPERIMENTAL__.suspense) {
+            cursorBoundary ||=
+                getOwnCursorBoundary(container, current) ||
+                    (currentIsCursor ? getNearestCursorBoundary(container, current) : null);
+        }
         if (currentIsCursor) {
+            // Existing cursor case: attach this dirty vnode to the blocking cursor found above it and
+            // remember that cursor's nearest boundary for async/suspense bookkeeping.
+            setNearestCursorBoundary(vNode, cursorBoundary);
             propagatePath(current);
             reusablePath.length = 0;
             return true;
@@ -6785,11 +7022,14 @@ function findAndPropagateToBlockingCursor(vNode) {
         reusablePath.push(current);
         current = current.slotParent || current.parent;
     }
+    // New cursor case: no blocking cursor was found above this vnode, so cache the nearest boundary
+    // before the caller creates a cursor rooted at this vnode.
+    setNearestCursorBoundary(vNode, cursorBoundary);
     reusablePath.length = 0;
     return false;
 }
 function isSsrNodeGuard(_vNode) {
-    return import.meta.env.TEST ? isServerPlatform() : isServer;
+    return qTest ? isServerPlatform() : isServer;
 }
 /**
  * Marks a vNode as dirty and propagates dirty bits up the tree.
@@ -6820,11 +7060,14 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     const parent = vNode.slotParent || vNode.parent;
     // If cursorRoot is provided, propagate up to it
     if (cursorRoot && isRealDirty && parent && !parent.dirty) {
-        propagateToCursorRoot(vNode, cursorRoot);
+        propagateToCursorRoot(container, vNode, cursorRoot);
         return;
     }
     // We must attach to a cursor subtree if it exists
     if (parent && parent.dirty & 511 /* ChoreBits.DIRTY_MASK */) {
+        // Dirty parent case: this vnode joins an already scheduled subtree, so inherit the parent's
+        // nearest boundary unless this vnode owns a boundary itself.
+        setNearestCursorBoundary(vNode, getOwnCursorBoundary(container, vNode) || getNearestCursorBoundary(container, parent));
         if (isRealDirty) {
             parent.dirty |= 32 /* ChoreBits.CHILDREN */;
         }
@@ -6856,11 +7099,16 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     else if (!isCursor(vNode)) {
         // Check if there's an existing cursor that is blocking (executing a render-blocking task)
         // If so, merge with it instead of creating a new cursor (single-pass find + propagate)
-        if (!findAndPropagateToBlockingCursor(vNode)) {
+        if (!findAndPropagateToBlockingCursor(container, vNode)) {
             // No blocking cursor found, create a new one
             addCursor(container, vNode, 0);
         }
     }
+    else {
+        // Existing cursor-root case: the vnode is already the scheduled cursor, so only its own
+        // boundary can be authoritative here.
+        setNearestCursorBoundary(vNode, getOwnCursorBoundary(container, vNode));
+    }
 }
 function addVNodeOperation(journal, operation) {
     journal.push(operation);
@@ -7049,6 +7297,7 @@ const vnode_newText = (textNode, textContent) => {
     isDev && assertFalse(vnode_isVirtualVNode(vnode), 'Incorrect format of TextVNode.');
     return vnode;
 };
+/** @internal */
 const vnode_newVirtual = () => {
     const vnode = new VirtualVNode(null, 2 /* VNodeFlags.Virtual */ | (-1 << 12 /* VNodeFlagsIndex.shift */), // Flags
     null, null, null, null, null, null);
@@ -7061,6 +7310,7 @@ const vnode_newVirtual = () => {
 const vnode_isVNode = (vNode) => {
     return vNode instanceof VNode;
 };
+/** @internal */
 const vnode_isElementVNode = (vNode) => {
     return (vNode.flags & 1 /* VNodeFlags.Element */) === 1 /* VNodeFlags.Element */;
 };
@@ -7119,6 +7369,7 @@ const vnode_getNodeTypeName = (vNode) => {
     }
     return '<unknown>';
 };
+/** @internal */
 const vnode_getProp = (vNode, key, getObject) => {
     if (vnode_isElementVNode(vNode) || vnode_isVirtualVNode(vNode)) {
         const value = vNode.props?.[key] ?? null;
@@ -7131,6 +7382,7 @@ const vnode_getProp = (vNode, key, getObject) => {
     }
     return null;
 };
+/** @internal */
 const vnode_setProp = (vNode, key, value) => {
     if (value == null && vNode.props) {
         delete vNode.props[key];
@@ -7142,7 +7394,7 @@ const vnode_setProp = (vNode, key, value) => {
 };
 const vnode_setAttr = (journal, vNode, key, value, scopedStyleIdPrefix = null) => {
     if (vnode_isElementVNode(vNode)) {
-        import.meta.env.TEST &&
+        qTest &&
             scopedStyleIdPrefix &&
             vnode_setProp(vNode, debugStyleScopeIdPrefixAttr, scopedStyleIdPrefix);
         vnode_setProp(vNode, key, value);
@@ -7522,6 +7774,7 @@ const vnode_getChildWithIdx = (vNode, childIdx) => {
     return child;
 };
 const vNodeStack = [];
+/** @internal */
 const vnode_getVNodeForChildNode = (vNode, childElement) => {
     ensureElementVNode(vNode);
     let child = vnode_getFirstChild(vNode);
@@ -7835,6 +8088,7 @@ const vnode_inflateProjectionTrailingText = (journal, projection) => {
         vnode_ensureTextInflated(journal, last);
     }
 };
+/** @internal */
 const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
     if (vnode_isElementOrTextVNode(newChild)) {
         vnode_insertElementBefore(journal, parent, newChild, insertBefore);
@@ -7858,6 +8112,7 @@ const vnode_getDomParentVNode = (vnode, includeProjection) => {
     }
     return vnode;
 };
+/** @internal */
 const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
     isDev && assertEqual(vParent, vToRemove.parent, 'Parent mismatch.');
     if (vnode_isTextVNode(vToRemove)) {
@@ -7926,6 +8181,7 @@ const vnode_truncate = (journal, vParent, vDelete, removeDOM = true) => {
     vParent.lastChild = vPrevious;
 };
 //////////////////////////////////////////////////////////////////////////////////////////////////////
+/** @internal */
 const vnode_getElementName = (vnode) => {
     const elementVNode = ensureElementVNode(vnode);
     let elementName = elementVNode.elementName;
@@ -8727,41 +8983,6 @@ function clearStoreOrProps(producer, effect) {
     }
 }
 
-/**
- * @internal
- * The storage provider for hooks. Each invocation increases index i. Data is stored in an array.
- */
-const useSequentialScope = () => {
-    const iCtx = useInvokeContext();
-    const hostElement = iCtx.$hostElement$;
-    const host = hostElement;
-    let seq = iCtx.$container$.getHostProp(host, ELEMENT_SEQ);
-    if (seq === null) {
-        seq = [];
-        iCtx.$container$.setHostProp(host, ELEMENT_SEQ, seq);
-    }
-    let seqIdx = iCtx.$container$.getHostProp(host, ELEMENT_SEQ_IDX);
-    if (seqIdx === null) {
-        seqIdx = 0;
-    }
-    iCtx.$container$.setHostProp(host, ELEMENT_SEQ_IDX, seqIdx + 1);
-    while (seq.length <= seqIdx) {
-        seq.push(undefined);
-    }
-    const set = (value) => {
-        if (qDev) {
-            verifySerializable(value);
-        }
-        return (seq[seqIdx] = value);
-    };
-    return {
-        val: seq[seqIdx],
-        set,
-        i: seqIdx,
-        iCtx,
-    };
-};
-
 /** @internal */
 const useTaskQrl = (qrl, opts) => {
     const { val, set, iCtx, i } = useSequentialScope();
@@ -8907,7 +9128,7 @@ const addQrlToSerializationCtx = (effectSubscriber, container) => {
     }
 };
 const scheduleEffects = (container, signal, effects) => {
-    const isBrowser = import.meta.env.TEST ? !isServerPlatform() : !isServer;
+    const isRunningOnBrowser = qTest ? !isServerPlatform() : isBrowser$1;
     if (effects) {
         const scheduleEffect = (effectSubscription) => {
             const consumer = effectSubscription.consumer;
@@ -8924,7 +9145,7 @@ const scheduleEffects = (container, signal, effects) => {
                 markVNodeDirty(container, consumer, 4 /* ChoreBits.COMPONENT */);
             }
             else if (property === "." /* EffectProperty.VNODE */) {
-                if (isBrowser) {
+                if (isRunningOnBrowser) {
                     setNodeDiffPayload(consumer, signal);
                     markVNodeDirty(container, consumer, 2 /* ChoreBits.NODE_DIFF */);
                 }
@@ -8938,7 +9159,7 @@ const scheduleEffects = (container, signal, effects) => {
                         scopedStyleIdPrefix: data.$scopedStyleIdPrefix$,
                         value: signal,
                     };
-                    if (isBrowser) {
+                    if (isRunningOnBrowser) {
                         setNodePropData(consumer, property, payload);
                     }
                     else {
@@ -9294,7 +9515,7 @@ function addStoreEffect(target, prop, store, effectSubscription) {
     // to this signal.
     ensureContainsBackRef(effectSubscription, target);
     // TODO is this needed with the preloader?
-    (import.meta.env.TEST ? !isDomContainer(store.$container$) : isServer) &&
+    (qTest ? !isDomContainer(store.$container$) : isServer) &&
         addQrlToSerializationCtx(effectSubscription, store.$container$);
 }
 function setNewValueAndTriggerEffects(prop, value, target, currentStore) {
@@ -10398,7 +10619,9 @@ DomRefConstructor, symbolToChunkResolver, setProp, storeProxyMap, writer) => {
     if (!writer) {
         const buffer = [];
         writer = {
-            write: (text) => buffer.push(text),
+            write: (text) => {
+                buffer.push(text);
+            },
             toString: () => buffer.join(''),
         };
     }
@@ -10933,19 +11156,29 @@ const _noopQrl = (symbolName, lexicalScopeCapture) => {
 /** @internal */
 const _noopQrlDEV = (symbolName, opts, lexicalScopeCapture) => {
     const newQrl = _noopQrl(symbolName, lexicalScopeCapture);
+    qDev && newQrl.$setDev$(opts);
+    return newQrl;
+};
+/** @internal */
+const _qrlWithChunk = (chunk, importer, symbol, lexicalScopeCapture) => {
+    return createQRL(chunk, symbol, null, importer, lexicalScopeCapture);
+};
+/** @internal */
+const _qrlWithChunkDEV = (chunk, importer, symbol, opts, lexicalScopeCapture) => {
+    const newQrl = _qrlWithChunk(chunk, importer, symbol, lexicalScopeCapture);
     newQrl.$setDev$(opts);
     return newQrl;
 };
 /** @internal */
 const qrlDEV = (chunkOrFn, symbol, opts, lexicalScopeCapture) => {
     const newQrl = qrl(chunkOrFn, symbol, lexicalScopeCapture, 1);
-    newQrl.$setDev$(opts);
+    qDev && newQrl.$setDev$(opts);
     return newQrl;
 };
 /** @internal */
 const inlinedQrlDEV = (symbol, symbolName, opts, lexicalScopeCapture) => {
     const qrl = inlinedQrl(symbol, symbolName, lexicalScopeCapture);
-    qrl.$setDev$(opts);
+    qDev && qrl.$setDev$(opts);
     return qrl;
 };
 /**
@@ -10962,6 +11195,12 @@ const _regSymbol = (symbol, hash) => {
     return symbol;
 };
 
+/** @internal */
+const getAsyncLocalStorage = () => {
+    const process = globalThis.process;
+    return process?.getBuiltinModule?.('node:async_hooks')?.AsyncLocalStorage;
+};
+
 /** @file Shared types */
 /** @internal */
 function isStringifiable(value) {
@@ -11051,23 +11290,31 @@ async function _walkJSX(ssr, value, options) {
     const enqueue = (value) => stack.push(value);
     const drain = async () => {
         while (stack.length) {
-            const value = stack.pop();
-            // Reference equality first (no prototype walk), then typeof
-            if (value === MaybeAsyncSignal) {
-                const trackFn = stack.pop();
-                await retryOnPromise(() => stack.push(trackFn()));
-                continue;
-            }
-            if (typeof value === 'function') {
-                if (value === Promise) {
-                    stack.push(await stack.pop());
+            try {
+                const value = stack.pop();
+                // Reference equality first (no prototype walk), then typeof
+                if (value === MaybeAsyncSignal) {
+                    const trackFn = stack.pop();
+                    await retryOnPromise(() => stack.push(trackFn()));
+                    continue;
                 }
-                else {
-                    await value.apply(ssr);
+                if (typeof value === 'function') {
+                    if (value === Promise) {
+                        stack.push(await stack.pop());
+                    }
+                    else {
+                        await value.apply(ssr);
+                    }
+                    continue;
+                }
+                processJSXNode(ssr, enqueue, value, options);
+            }
+            finally {
+                const pendingFlush = ssr.streamHandler.waitForPendingFlush();
+                if (isPromise(pendingFlush)) {
+                    await pendingFlush;
                 }
-                continue;
             }
-            processJSXNode(ssr, enqueue, value, options);
         }
     };
     await drain();
@@ -11115,7 +11362,7 @@ function processJSXNode(ssr, enqueue, value, options) {
                         currentStyleScoped: options.currentStyleScoped,
                         parentComponentFrame: options.parentComponentFrame,
                     });
-                    ssr.streamHandler.flush();
+                    await ssr.streamHandler.flush();
                 }
             });
         }
@@ -11169,9 +11416,11 @@ function processJSXNode(ssr, enqueue, value, options) {
                     const componentFrame = options.parentComponentFrame;
                     if (componentFrame) {
                         const compId = componentFrame.componentNode.id || '';
-                        const projectionAttrs = isDev
-                            ? { [DEBUG_TYPE]: "P" /* VirtualType.Projection */ }
-                            : {};
+                        const projectionAttrs = isDev ? { [DEBUG_TYPE]: "P" /* VirtualType.Projection */ } : {};
+                        const cursorBoundary = directGetPropsProxyProp(jsx, QCursorBoundary);
+                        if (cursorBoundary) {
+                            projectionAttrs[QCursorBoundary] = cursorBoundary;
+                        }
                         projectionAttrs[QSlotParent] = compId;
                         ssr.openProjection(projectionAttrs);
                         const host = componentFrame.componentNode;
@@ -11212,7 +11461,7 @@ function processJSXNode(ssr, enqueue, value, options) {
                                     currentStyleScoped: options.currentStyleScoped,
                                     parentComponentFrame: options.parentComponentFrame,
                                 });
-                                ssr.streamHandler.flush();
+                                await ssr.streamHandler.flush();
                             },
                         });
                     }
@@ -12091,7 +12340,7 @@ function inflateWrappedSignalValue(signal) {
     }
 }
 function restoreEffectBackRefForConsumer(effect) {
-    const isServerSide = import.meta.env.TEST ? isServerPlatform() : isServer;
+    const isServerSide = qTest ? isServerPlatform() : isServer;
     const consumerBackRef = effect.consumer;
     if (isServerSide && !consumerBackRef) {
         // on browser, we don't serialize for example VNodes, so then on server side we don't have consumer
@@ -12239,6 +12488,7 @@ function getObjectById(id, stateData) {
     isDev && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
     return stateData[id];
 }
+/** @internal */
 function _createDeserializeContainer(stateData) {
     // eslint-disable-next-line prefer-const
     let state;
@@ -12281,6 +12531,14 @@ const _verifySerializable = (value, seen, ctx, preMessage) => {
         if (canSerialize(unwrapped)) {
             return value;
         }
+        // Framework-internal branded values (e.g. route loaders/actions, validators)
+        // are callables or objects that stamp __brand / __brand__ to opt out of the
+        // serializer walking their internals. Honor that for both objects and
+        // functions — loader/action refs are functions with __brand = 'server_loader'
+        // / 'server_action' and should not be rejected as unserializable.
+        if (unwrapped.__brand || unwrapped.__brand__) {
+            return value;
+        }
         const typeObj = typeof unwrapped;
         switch (typeObj) {
             case 'object':
@@ -12310,10 +12568,6 @@ const _verifySerializable = (value, seen, ctx, preMessage) => {
                 if (unwrapped instanceof VNode) {
                     return value;
                 }
-                // We have .__brand and .__brand__
-                if (unwrapped.__brand || unwrapped.__brand__) {
-                    return value;
-                }
                 if (isSerializableObject(unwrapped)) {
                     for (const [key, item] of Object.entries(unwrapped)) {
                         _verifySerializable(item, seen, ctx + '.' + key);
@@ -13137,6 +13391,7 @@ class DomContainer extends _SharedContainer {
             case OnRenderProp:
             case QCtxAttr:
             case QBackRefs:
+            case QCursorBoundary:
                 getObjectById = this.$getObjectById$;
                 break;
             case ELEMENT_SEQ_IDX:
@@ -13217,13 +13472,10 @@ class DomContainer extends _SharedContainer {
 let _locale = undefined;
 let localAsyncStore;
 if (isServer) {
-    import('node:async_hooks')
-        .then((module) => {
-        localAsyncStore = new module.AsyncLocalStorage();
-    })
-        .catch(() => {
-        // ignore if AsyncLocalStorage is not available
-    });
+    const AsyncLocalStorage = getAsyncLocalStorage();
+    if (AsyncLocalStorage) {
+        localAsyncStore = new AsyncLocalStorage();
+    }
 }
 /**
  * Retrieve the current locale.
@@ -14157,6 +14409,25 @@ const component$ = (onMount) => {
 /** @public */
 const event$ = implicit$FirstArg(eventQrl);
 
+/**
+ * Returns the client build manifest, which includes the mappings from symbols to bundles, the
+ * bundlegraph etc.
+ *
+ * @public
+ */
+const getClientManifest = () => {
+    // Keep this first because the magic-string first replaces the `!...` version and it can't replace after that.
+    const manifest = globalThis.__QWIK_MANIFEST__;
+    /**
+     * Keep as-is, this is replaced verbatim with `false` by the qwikVite plugin, so this function
+     * only throws if the build was not done correctly + no manifest was provided on globalThis.
+     */
+    if (!globalThis.__QWIK_MANIFEST__) {
+        throw new Error(`Client manifest is not available. It should have been automatically injected during the build process. Make sure that @qwik.dev/core is internal to the build.`);
+    }
+    return manifest;
+};
+
 /**
  * Render JSX.
  *
@@ -14727,7 +14998,7 @@ const useStylesScopedQrl = (styles) => {
  */
 // </docs>
 const useStylesScoped$ = /*#__PURE__*/ implicit$FirstArg(useStylesScopedQrl);
-const liveUpdate = isDev && ((import.meta.hot && typeof document !== 'undefined') || import.meta.env.TEST);
+const liveUpdate = isDev && ((import.meta.hot && typeof document !== 'undefined') || qTest);
 const _useStyles = (styleQrl, transform, scoped) => {
     assertQrl(styleQrl);
     // eslint-disable-next-line prefer-const
@@ -14779,93 +15050,6 @@ const _useStyles = (styleQrl, transform, scoped) => {
     return styleId;
 };
 
-const getSignal = (initialState) => {
-    const value = isFunction(initialState) && !isQwikComponent(initialState)
-        ? invoke(undefined, initialState)
-        : initialState;
-    return createSignal(value);
-};
-// <docs markdown="../readme.md#useSignal">
-// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
-// (edit ../readme.md#useSignal instead and run `pnpm docs.sync`)
-/**
- * Creates an object with a single reactive `.value` property, that Qwik can track across
- * serializations.
- *
- * Use it to create state for your application. The object has a getter and setter to track reads
- * and writes of the `.value` property. When the value changes, any functions that read from it will
- * re-run.
- *
- * Prefer `useSignal` over `useStore` when possible, as it is more efficient.
- *
- * ### Example
- *
- * ```tsx
- * const Signals = component$(() => {
- *   const counter = useSignal(1);
- *   const text = useSignal('changeme');
- *   const toggle = useSignal(false);
- *
- *   // useSignal() can also accept a function to calculate the initial value
- *   const state = useSignal(() => {
- *     return expensiveInitialValue();
- *   });
- *
- *   return (
- *     <div>
- *       <button onClick$={() => counter.value++}>Counter: {counter.value}</button>
- *       {
- *         // pass signal values as the value, the optimizer will make it pass the signal
- *       }
- *       <Child state={state.value} />
- *       {
- *         // signals can be bound to inputs. A property named `bind:x` implies that the property
- * is a signal
- *       }
- *       <input type="text" bind:value={text} />
- *       <input type="checkbox" bind:checked={toggle} />
- *     </div>
- *   );
- * });
- * ```
- *
- * @public
- */
-// </docs>
-const useSignal = (initialState) => {
-    return useConstant((getSignal), initialState);
-};
-/**
- * Stores a value which is retained for the lifetime of the component. Subsequent calls to
- * `useConstant` will always return the first value given.
- *
- * If the value is a function, the function is invoked once to calculate the actual value. You can
- * then also pass arguments to call the function with, so that you don't need to create a new
- * function on every render.
- *
- * @example
- *
- * ```tsx
- * const fixedRandomValue = useConstant(() => Math.random);
- * const otherFixedRandomValue = useConstant(Math.random);
- *
- * const getConfig = (env: string) => { ... }
- * const config = useConstant(getConfig, environment);
- * ```
- *
- * @public
- */
-const useConstant = (value, ...args) => {
-    const { val, set } = useSequentialScope();
-    if (val != null) {
-        return val;
-    }
-    // We don't want to create a subscription since we only run this once
-    // Note: We are not using `invoke` here because we don't want to clear the context
-    value = isFunction(value) && !isQwikComponent(value) ? untrack(value, ...args) : value;
-    return set(value);
-};
-
 const creator$2 = (qrl, options) => {
     qrl.resolve();
     return createComputedSignal(qrl, options);
@@ -15167,7 +15351,7 @@ const eachCmpTask = async ({ track }) => {
     const host = context.$hostElement$;
     const container = context.$container$;
     markVNodeDirty(container, host, 128 /* ChoreBits.RECONCILE */);
-    const isSsr = import.meta.env.TEST ? isServerPlatform() : isServer;
+    const isSsr = qTest ? isServerPlatform() : isServer;
     if (isSsr) {
         await container.$renderPromise$;
     }
@@ -15184,6 +15368,173 @@ const eachCmp = (props) => {
 const Each = /*#__PURE__*/ componentQrl(
 /*#__PURE__*/ inlinedQrl(eachCmp, '_eaC'));
 
+const RevealContext = /*#__PURE__*/ createContextId('qk-reveal');
+const createRevealContext = (props) => {
+    return {
+        order: props.order ?? 'parallel',
+        collapsed: props.collapsed === true,
+        items: [],
+        version: createSignal(0),
+    };
+};
+/** @internal */
+const revealCanReveal = () => {
+    const registration = _captures[0];
+    if (registration === null) {
+        return true;
+    }
+    const reveal = registration.reveal;
+    const current = registration.item;
+    const items = reveal.items;
+    // `version` is monotonic; the branch keeps the subscription read from being dropped by minifiers.
+    if (reveal.version.value < 0) {
+        return false;
+    }
+    switch (reveal.order) {
+        case 'together':
+            for (let i = 0; i < items.length; i++) {
+                if (items[i].boundary.pending.untrackedValue > 0) {
+                    return false;
+                }
+            }
+            return true;
+        case 'sequential':
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                if (item === current) {
+                    return true;
+                }
+                if (item.boundary.pending.untrackedValue > 0) {
+                    return false;
+                }
+            }
+            return true;
+        case 'reverse':
+            for (let i = items.length - 1; i >= 0; i--) {
+                const item = items[i];
+                if (item === current) {
+                    return true;
+                }
+                if (item.boundary.pending.untrackedValue > 0) {
+                    return false;
+                }
+            }
+            return true;
+        default:
+            return true;
+    }
+};
+/** @internal */
+const revealCleanupTask = ({ cleanup }) => {
+    const registration = _captures[0];
+    cleanup(() => {
+        // Keep the SSR registry intact so `reveal.items` serializes for resume.
+        if (qTest ? isServerPlatform() : !isBrowser$1) {
+            return;
+        }
+        const items = registration.reveal.items;
+        const index = items.indexOf(registration.item);
+        if (index !== -1) {
+            items.splice(index, 1);
+            registration.reveal.version.value++;
+        }
+    });
+};
+const useRevealBoundary = (boundary) => {
+    const reveal = useContext(RevealContext, null);
+    const registration = useConstant(() => {
+        if (reveal === null) {
+            return null;
+        }
+        const item = { boundary };
+        reveal.items.push(item);
+        return { reveal, item };
+    });
+    if (registration !== null) {
+        useTaskQrl(/*#__PURE__*/ inlinedQrl(revealCleanupTask, '_reT', [registration]), {
+            deferUpdates: false,
+        });
+    }
+    return registration;
+};
+/** @internal */
+const revealCmp = (props) => {
+    if (!__EXPERIMENTAL__.suspense) {
+        throw new Error('Reveal is experimental and must be enabled with `experimental: ["suspense"]` in the `qwikVite` plugin.');
+    }
+    const reveal = useConstant(createRevealContext, props);
+    useContextProvider(RevealContext, reveal);
+    return /*#__PURE__*/ _jsxSorted(Slot, null, null, null, 0, 'u7_0');
+};
+/** @public @experimental */
+const Reveal = /*#__PURE__*/ componentQrl(
+/*#__PURE__*/ inlinedQrl(revealCmp, '_reC'));
+
+const _hf0 = (p0, p1, p2, p3) => ({
+    display: p1.value === 'fallback' &&
+        p0.fallback != null &&
+        p0.fallback !== false &&
+        (p2 === null || p2.value || !p3.reveal.collapsed)
+        ? 'contents'
+        : 'none',
+});
+const _hf0_str = '{display:p1.value==="fallback"&&p0.fallback!=null&&p0.fallback!==false&&(p2===null||p2.value||!p3.reveal.collapsed)?"contents":"none"}';
+const _hf1 = (p0, p1, p2) => ({
+    display: (p2 === null || p2.value) && (p1.value === 'content' || p0.showStale) ? 'contents' : 'none',
+});
+const _hf1_str = '{display:(p2===null||p2.value)&&(p1.value==="content"||p0.showStale)?"contents":"none"}';
+/** @internal */
+const suspenseTask = ({ track, cleanup }) => {
+    const cursorBoundary = _captures[0], props = _captures[1], state = _captures[2], revealRegistration = _captures[3];
+    const pendingCount = track(cursorBoundary.pending);
+    const isBrowserEnv = qTest ? !isServerPlatform() : isBrowser$1;
+    if (revealRegistration !== null && isBrowserEnv) {
+        revealRegistration.reveal.version.value++;
+    }
+    if (!isBrowserEnv || pendingCount === 0) {
+        state.value = 'content';
+        return;
+    }
+    const delayTimer = setTimeout(() => {
+        if (cursorBoundary.pending.value > 0) {
+            state.value = 'fallback';
+        }
+    }, props.delay ?? 0);
+    cleanup(() => clearTimeout(delayTimer));
+};
+/** @internal */
+const suspenseCmp = (props) => {
+    if (!__EXPERIMENTAL__.suspense) {
+        throw new Error('Suspense is experimental and must be enabled with `experimental: ["suspense"]` in the `qwikVite` plugin.');
+    }
+    const state = useSignal('content');
+    const cursorBoundary = useCursorBoundary();
+    const revealRegistration = useRevealBoundary(cursorBoundary);
+    const canReveal = useComputedQrl(
+    /*#__PURE__*/ inlinedQrl(revealCanReveal, '_reR', [revealRegistration]));
+    useTaskQrl(
+    /*#__PURE__*/ inlinedQrl(suspenseTask, '_suT', [
+        cursorBoundary,
+        props,
+        state,
+        revealRegistration,
+    ]));
+    return /*#__PURE__*/ _jsxSorted(Fragment, null, null, [
+        /*#__PURE__*/ _jsxSorted('div', {
+            style: _fnSignal(_hf0, [props, state, canReveal, revealRegistration], _hf0_str),
+        }, null, _wrapProp(props, 'fallback'), 1, null),
+        /*#__PURE__*/ _jsxSorted('div', null, {
+            style: _fnSignal(_hf1, [props, state, canReveal], _hf1_str),
+        }, 
+        /*#__PURE__*/ _jsxSorted(Slot, {
+            [QCursorBoundary]: cursorBoundary,
+        }, null, null, 3, 'u6_0'), 1, null),
+    ], 1, 'u6_1');
+};
+/** @public @experimental */
+const Suspense = /*#__PURE__*/ componentQrl(
+/*#__PURE__*/ inlinedQrl(suspenseCmp, '_suC'));
+
 // keep this import from core/build so the cjs build works
 /**
  * @deprecated This is no longer needed as the preloading happens automatically in qrl-class.ts.
@@ -15192,7 +15543,7 @@ const Each = /*#__PURE__*/ componentQrl(
  * @alpha
  */
 const PrefetchServiceWorker = (opts) => {
-    const isTest = import.meta.env.TEST;
+    const isTest = qTest;
     if (isDev && !isTest) {
         const props = {
             dangerouslySetInnerHTML: '<!-- PrefetchServiceWorker is disabled in dev mode. -->',
@@ -15201,7 +15552,7 @@ const PrefetchServiceWorker = (opts) => {
     }
     // if an MFE app has a custom BASE_URL then this will be the correct value
     // if you're not using MFE from another codebase then you want to override this value to your custom setup
-    const baseUrl = import.meta.env.BASE_URL || '/';
+    const baseUrl = import.meta.env?.BASE_URL || '/';
     const resolvedOpts = {
         path: 'qwik-prefetch-service-worker.js',
         ...opts,
@@ -15279,5 +15630,5 @@ if (import.meta.hot) {
     });
 }
 
-export { $, Each, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, EMPTY_OBJ as _EMPTY_OBJ, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _addProjection, _captures, _chk, createQRL as _createQRL, _deserialize, _dumpState, eachCmp as _eaC, eachCmpTask as _eaT, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, _hmr, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, qrlToString as _qrlToString, _regSymbol, _removeProjection, _res, _resolveContextWithoutSequentialScope, _restProps, _rsc, _run, _serialize, setEvent as _setEvent, _setProjectionTarget, scheduleTask as _task, _updateProjectionProps, _useHmr, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsync$, createAsyncSignal as createAsyncQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
+export { $, Each, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, Reveal, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, Suspense, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, EMPTY_OBJ as _EMPTY_OBJ, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _addProjection, _captures, _chk, _createDeserializeContainer, createQRL as _createQRL, _deserialize, _dumpState, eachCmp as _eaC, eachCmpTask as _eaT, _executeSsrChores, _fnSignal, getAsyncLocalStorage as _getAsyncLocalStorage, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, _hmr, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, qrlToString as _qrlToString, _qrlWithChunk, _qrlWithChunkDEV, revealCmp as _reC, revealCanReveal as _reR, revealCleanupTask as _reT, _regSymbol, _removeProjection, _res, _resolveContextWithoutSequentialScope, _restProps, _rsc, _run, _serialize, setEvent as _setEvent, _setProjectionTarget, suspenseCmp as _suC, suspenseTask as _suT, scheduleTask as _task, _updateProjectionProps, _useHmr, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getElementName as _vnode_getElementName, vnode_getFirstChild as _vnode_getFirstChild, vnode_getProp as _vnode_getProp, vnode_getVNodeForChildNode as _vnode_getVNodeForChildNode, vnode_insertBefore as _vnode_insertBefore, vnode_isElementVNode as _vnode_isElementVNode, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_newVirtual as _vnode_newVirtual, vnode_remove as _vnode_remove, vnode_setProp as _vnode_setProp, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsync$, createAsyncSignal as createAsyncQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getClientManifest, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
 //# sourceMappingURL=core.mjs.map