@qwik.dev/core 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/core.cjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.3-dev+aa098fc
+ * @qwik.dev/core 2.0.0-beta.5-dev+8887f7e
  * 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
@@ -74,6 +74,24 @@
         return err;
     };
 
+    /** @private */
+    const isSerializableObject = (v) => {
+        const proto = Object.getPrototypeOf(v);
+        return proto === Object.prototype || proto === Array.prototype || proto === null;
+    };
+    const isObject = (v) => {
+        return typeof v === 'object' && v !== null;
+    };
+    const isArray = (v) => {
+        return Array.isArray(v);
+    };
+    const isString = (v) => {
+        return typeof v === 'string';
+    };
+    const isFunction = (v) => {
+        return typeof v === 'function';
+    };
+
     const codeToText = (code, ...parts) => {
         if (qDev) {
             // Keep one error, one line to make it easier to search for the error message.
@@ -118,7 +136,7 @@
             if (parts.length) {
                 text = text.replaceAll(/{{(\d+)}}/g, (_, index) => {
                     let v = parts[index];
-                    if (v && typeof v === 'object' && v.constructor === Object) {
+                    if (v && isObject(v) && v.constructor === Object) {
                         v = JSON.stringify(v).slice(0, 50);
                     }
                     return v;
@@ -379,7 +397,7 @@
             setTimeout(resolve, timeout);
         });
     };
-    // Retries a function that throws a promise.
+    /** Retries a function that throws a promise. */
     function retryOnPromise(fn, retryCount = 0) {
         const retryOrThrow = (e) => {
             if (isPromise(e) && retryCount < MAX_RETRY_ON_PROMISE_COUNT) {
@@ -404,24 +422,6 @@
         }
     }
 
-    /** @private */
-    const isSerializableObject = (v) => {
-        const proto = Object.getPrototypeOf(v);
-        return proto === Object.prototype || proto === Array.prototype || proto === null;
-    };
-    const isObject = (v) => {
-        return !!v && typeof v === 'object';
-    };
-    const isArray = (v) => {
-        return Array.isArray(v);
-    };
-    const isString = (v) => {
-        return typeof v === 'string';
-    };
-    const isFunction = (v) => {
-        return typeof v === 'function';
-    };
-
     const ASSERT_DISCLAIMER = 'Internal assert, this is likely caused by a bug in Qwik: ';
     function assertDefined(value, text, ...parts) {
         if (qDev) {
@@ -641,7 +641,7 @@
             this.$funcStr$ = fnStr;
             this.$flags$ = flags;
         }
-        $invalidate$() {
+        invalidate() {
             this.$flags$ |= 1 /* SignalFlags.INVALID */;
             this.$forceRunEffects$ = false;
             this.$container$?.$scheduler$(7 /* ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS */, this.$hostElement$, this, this.$effects$);
@@ -651,9 +651,8 @@
          * remained the same object.
          */
         force() {
-            this.$flags$ |= 1 /* SignalFlags.INVALID */;
-            this.$forceRunEffects$ = false;
-            triggerEffects(this.$container$, this, this.$effects$);
+            this.$forceRunEffects$ = true;
+            this.$container$?.$scheduler$(7 /* ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS */, this.$hostElement$, this, this.$effects$);
         }
         get untrackedValue() {
             const didChange = this.$computeIfNeeded$();
@@ -711,7 +710,6 @@
     }
 
     let _context;
-    /** @public */
     const tryGetInvokeContext = () => {
         if (!_context) {
             const context = typeof document !== 'undefined' && document && document.__q_context__;
@@ -732,6 +730,7 @@
         }
         return ctx;
     };
+    /** @internal */
     const useInvokeContext = () => {
         const ctx = tryGetInvokeContext();
         if (!ctx || ctx.$event$ !== RenderEvent) {
@@ -777,7 +776,7 @@
     // TODO how about putting url and locale (and event/custom?) in to a "static" object
     const newInvokeContext = (locale, hostElement, element, event, url) => {
         // ServerRequestEvent has .locale, but it's not always defined.
-        const $locale$ = locale || (typeof event === 'object' && event && 'locale' in event ? event.locale : undefined);
+        const $locale$ = locale || (event && isObject(event) && 'locale' in event ? event.locale : undefined);
         const ctx = {
             $url$: url,
             $i$: 0,
@@ -857,6 +856,13 @@
         }
     };
     /** @internal */
+    const _getContextContainer = () => {
+        const iCtx = tryGetInvokeContext();
+        if (iCtx) {
+            return iCtx.$container$;
+        }
+    };
+    /** @internal */
     const _jsxBranch = (input) => {
         return input;
     };
@@ -1230,7 +1236,7 @@
      *
      * @public
      */
-    const version = "2.0.0-beta.3-dev+aa098fc";
+    const version = "2.0.0-beta.5-dev+8887f7e";
 
     /** @internal */
     const EMPTY_ARRAY = [];
@@ -1395,6 +1401,8 @@
     const _VAR_PROPS = Symbol('VAR');
     /** @internal @deprecated v1 compat */
     const _IMMUTABLE = Symbol('IMMUTABLE');
+    /** @internal */
+    const _UNINITIALIZED = Symbol('UNINITIALIZED');
 
     // <docs markdown="../../readme.md#implicit$FirstArg">
     // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
@@ -1464,14 +1472,15 @@
         constructor(container, fn, 
         // We need a separate flag to know when the computation needs running because
         // we need the old value to know if effects need running after computation
-        flags = 1 /* SignalFlags.INVALID */) {
+        flags = 1 /* SignalFlags.INVALID */ |
+            16 /* ComputedSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */) {
             // The value is used for comparison when signals trigger, which can only happen
             // when it was calculated before. Therefore we can pass whatever we like.
             super(container, NEEDS_COMPUTATION);
             this.$computeQrl$ = fn;
             this.$flags$ = flags;
         }
-        $invalidate$() {
+        invalidate() {
             this.$flags$ |= 1 /* SignalFlags.INVALID */;
             this.$forceRunEffects$ = false;
             this.$container$?.$scheduler$(7 /* ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS */, null, this, this.$effects$);
@@ -1541,7 +1550,7 @@
      */
     class SerializerSignalImpl extends ComputedSignalImpl {
         constructor(container, argQrl) {
-            super(container, argQrl);
+            super(container, argQrl, 1 /* SignalFlags.INVALID */ | 16 /* ComputedSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */);
         }
         $didInitialize$ = false;
         $computeIfNeeded$() {
@@ -1557,7 +1566,7 @@
             const update = arg.update;
             const currentValue = this.$untrackedValue$ === NEEDS_COMPUTATION ? initial : this.$untrackedValue$;
             const untrackedValue = trackSignal(() => this.$didInitialize$
-                ? update?.(currentValue)
+                ? update?.(currentValue) || currentValue
                 : deserialize(currentValue), this, "." /* EffectProperty.VNODE */, this.$container$);
             const didChange = (this.$didInitialize$ && untrackedValue !== 'undefined') ||
                 untrackedValue !== this.$untrackedValue$;
@@ -1646,8 +1655,7 @@
             }
             const flags = this.$flags$;
             if (flags & 1 /* StoreFlags.RECURSIVE */ &&
-                typeof value === 'object' &&
-                value !== null &&
+                isObject(value) &&
                 !Object.isFrozen(value) &&
                 !isStore(value) &&
                 !Object.isFrozen(target)) {
@@ -1825,7 +1833,7 @@
         $loadingEffects$ = null;
         $errorEffects$ = null;
         $destroy$;
-        $promiseValue$ = null;
+        $promiseValue$ = NEEDS_COMPUTATION;
         [_EFFECT_BACK_REF] = null;
         constructor(container, fn, flags = 1 /* SignalFlags.INVALID */) {
             super(container, fn, flags);
@@ -1859,6 +1867,10 @@
         get untrackedError() {
             return this.$untrackedError$;
         }
+        invalidate() {
+            super.invalidate();
+            this.$promiseValue$ = NEEDS_COMPUTATION;
+        }
         $computeIfNeeded$() {
             if (!(this.$flags$ & 1 /* SignalFlags.INVALID */)) {
                 return false;
@@ -1866,11 +1878,12 @@
             const computeQrl = this.$computeQrl$;
             throwIfQRLNotResolved(computeQrl);
             const [cleanup] = cleanupFn(this, (err) => this.$container$?.handleError(err, null));
-            const untrackedValue = this.$promiseValue$ ??
-                computeQrl.getFn()({
+            const untrackedValue = this.$promiseValue$ === NEEDS_COMPUTATION
+                ? computeQrl.getFn()({
                     track: trackFn(this, this.$container$),
                     cleanup,
-                });
+                })
+                : this.$promiseValue$;
             if (isPromise(untrackedValue)) {
                 this.untrackedLoading = true;
                 this.untrackedError = null;
@@ -1881,11 +1894,12 @@
                     this.untrackedError = null;
                 })
                     .catch((err) => {
+                    this.$promiseValue$ = err;
                     this.untrackedLoading = false;
                     this.untrackedError = err;
                 });
             }
-            this.$promiseValue$ = null;
+            this.$promiseValue$ = NEEDS_COMPUTATION;
             this.$flags$ &= -2 /* SignalFlags.INVALID */;
             const didChange = untrackedValue !== this.$untrackedValue$;
             if (didChange) {
@@ -1900,13 +1914,15 @@
         return new SignalImpl(null, value);
     };
     /** @internal */
-    const createComputedSignal = (qrl) => {
-        throwIfQRLNotResolved(qrl);
-        return new ComputedSignalImpl(null, qrl);
+    const createComputedSignal = (qrl, options) => {
+        return new ComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'always'));
+    };
+    /** @internal */
+    const createAsyncComputedSignal = (qrl, options) => {
+        return new AsyncComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'never'));
     };
     /** @internal */
     const createSerializerSignal = (arg) => {
-        throwIfQRLNotResolved(arg);
         return new SerializerSignalImpl(null, arg);
     };
 
@@ -1925,11 +1941,22 @@
      * The QRL must be a function which returns the value of the signal. The function must not have side
      * effects, and it must be synchronous.
      *
-     * If you need the function to be async, use `useSignal` and `useTask$` instead.
+     * If you need the function to be async, use `useAsyncComputed$` instead.
      *
      * @public
      */
     const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedSignal);
+    /**
+     * Create an async computed signal which is calculated from the given QRL. A computed signal is a
+     * signal which is calculated from other signals or async operation. When the signals change, the
+     * computed signal is recalculated.
+     *
+     * The QRL must be a function which returns the value of the signal. The function must not have side
+     * effects, and it can be async.
+     *
+     * @public
+     */
+    const createAsyncComputed$ = /*#__PURE__*/ implicit$FirstArg(createAsyncComputedSignal);
     /**
      * Create a signal that holds a custom serializable value. See {@link useSerializer$} for more
      * details.
@@ -1989,17 +2016,6 @@
         // the object is not reactive, so we can just return the value
         return obj[prop];
     };
-    /** @internal */
-    const _wrapStore = (obj, prop) => {
-        const target = getStoreTarget(obj);
-        const value = target[prop];
-        if (isSignal(value)) {
-            return value;
-        }
-        else {
-            return new WrappedSignalImpl(null, getProp, [obj, prop], null, 1 /* SignalFlags.INVALID */);
-        }
-    };
     /** @internal @deprecated v1 compat */
     const _wrapSignal = (obj, prop) => {
         const r = _wrapProp(obj, prop);
@@ -2434,9 +2450,12 @@
             return jsx;
         }, (err) => {
             if (isPromise(err) && retryCount < MAX_RETRY_ON_PROMISE_COUNT) {
-                return err.then(() => executeComponentWithPromiseExceptionRetry(retryCount++));
+                return err.then(() => executeComponentWithPromiseExceptionRetry(++retryCount));
             }
             else {
+                if (retryCount >= MAX_RETRY_ON_PROMISE_COUNT) {
+                    throw new Error(`Max retry count of component execution reached`);
+                }
                 throw err;
             }
         });
@@ -4999,10 +5018,12 @@
             return resource.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
         }
         else if (isSignal(resource)) {
-            return Promise.resolve(resource.value).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
+            const value = retryOnPromise(() => resource.value);
+            const promise = isPromise(value) ? value : Promise.resolve(value);
+            return promise.then(useBindInvokeContext(props.onResolved));
         }
         else {
-            return Promise.resolve(resource).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
+            return Promise.resolve(resource).then(useBindInvokeContext(props.onResolved));
         }
     }
     const _createResourceReturn = (opts) => {
@@ -5533,7 +5554,7 @@
                             if (target instanceof ComputedSignalImpl || target instanceof WrappedSignalImpl) {
                                 const forceRunEffects = target.$forceRunEffects$;
                                 target.$forceRunEffects$ = false;
-                                if (!effects?.size) {
+                                if (!effects?.size && !forceRunEffects) {
                                     break;
                                 }
                                 // needed for computed signals and throwing QRLs
@@ -6477,7 +6498,7 @@
                             container.$scheduler$(1 /* ChoreType.QRL_RESOLVE */, null, consumer.$computeQrl$);
                         }
                     }
-                    consumer.$invalidate$();
+                    consumer.invalidate();
                 }
                 else if (property === ":" /* EffectProperty.COMPONENT */) {
                     const host = consumer;
@@ -6512,7 +6533,23 @@
     };
     /** @internal */
     const isSerializerObj = (obj) => {
-        return (typeof obj === 'object' && obj !== null && typeof obj[SerializerSymbol] === 'function');
+        return isObject(obj) && typeof obj[SerializerSymbol] === 'function';
+    };
+    const getComputedSignalFlags = (serializationStrategy) => {
+        let flags = 1 /* SignalFlags.INVALID */;
+        switch (serializationStrategy) {
+            // TODO: implement this in the future
+            // case 'auto':
+            //   flags |= ComputedSignalFlags.SERIALIZATION_STRATEGY_AUTO;
+            //   break;
+            case 'never':
+                flags |= 8 /* ComputedSignalFlags.SERIALIZATION_STRATEGY_NEVER */;
+                break;
+            case 'always':
+                flags |= 16 /* ComputedSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */;
+                break;
+        }
+        return flags;
     };
 
     const stringifyPath = [];
@@ -8252,7 +8289,7 @@
     /** There's [documentation](./serialization.md) */
     const deserializedProxyMap = new WeakMap();
     const isDeserializerProxy = (value) => {
-        return typeof value === 'object' && value !== null && SERIALIZER_PROXY_UNWRAP in value;
+        return isObject(value) && SERIALIZER_PROXY_UNWRAP in value;
     };
     const SERIALIZER_PROXY_UNWRAP = Symbol('UNWRAP');
     /** Call this on the serialized root state */
@@ -8460,9 +8497,7 @@
                 if (hasValue) {
                     asyncComputed.$untrackedValue$ = d[6];
                 }
-                else {
-                    asyncComputed.$flags$ |= 1 /* SignalFlags.INVALID */;
-                }
+                asyncComputed.$flags$ |= 1 /* SignalFlags.INVALID */;
                 break;
             }
             // Inflating a SerializerSignal is the same as inflating a ComputedSignal
@@ -8562,7 +8597,7 @@
                 propsProxy[_VAR_PROPS] = data === 0 ? {} : data[0];
                 propsProxy[_CONST_PROPS] = data[1];
                 break;
-            case 35 /* TypeIds.EffectData */: {
+            case 35 /* TypeIds.SubscriptionData */: {
                 const effectData = target;
                 effectData.data.$scopedStyleIdPrefix$ = data[0];
                 effectData.data.$isConst$ = data[1];
@@ -8583,6 +8618,7 @@
         EMPTY_OBJ,
         NEEDS_COMPUTATION,
         STORE_ALL_PROPS,
+        _UNINITIALIZED,
         Slot,
         Fragment,
         NaN,
@@ -8602,6 +8638,7 @@
         'EMPTY_OBJ',
         'NEEDS_COMPUTATION',
         'STORE_ALL_PROPS',
+        '_UNINITIALIZED',
         'Slot',
         'Fragment',
         'NaN',
@@ -8623,7 +8660,13 @@
                 if (!container.$forwardRefs$) {
                     throw qError(18 /* QError.serializeErrorCannotAllocate */, ['forward ref']);
                 }
-                return container.$getObjectById$(container.$forwardRefs$[value]);
+                const rootRef = container.$forwardRefs$[value];
+                if (rootRef === -1) {
+                    return _UNINITIALIZED;
+                }
+                else {
+                    return container.$getObjectById$(rootRef);
+                }
             case 2 /* TypeIds.ForwardRefs */:
                 return value;
             case 3 /* TypeIds.Constant */:
@@ -8718,7 +8761,7 @@
                 else {
                     throw qError(17 /* QError.serializeErrorExpectedVNode */, [typeof vNode]);
                 }
-            case 35 /* TypeIds.EffectData */:
+            case 35 /* TypeIds.SubscriptionData */:
                 return new SubscriptionData({});
             default:
                 throw qError(18 /* QError.serializeErrorCannotAllocate */, [typeId]);
@@ -8780,7 +8823,7 @@
             };
         }
         const seenObjsMap = new Map();
-        const rootsPathMap = new Map();
+        const objectPathStringCache = new Map();
         const syncFnMap = new Map();
         const syncFns = [];
         const roots = [];
@@ -8789,7 +8832,7 @@
             return seenObjsMap.set(obj, { $parent$: parent, $index$: index, $rootIndex$: -1 });
         };
         const $addRootPath$ = (obj) => {
-            const rootPath = rootsPathMap.get(obj);
+            const rootPath = objectPathStringCache.get(obj);
             if (rootPath) {
                 return rootPath;
             }
@@ -8808,7 +8851,7 @@
                 current = seenObjsMap.get(current.$parent$);
             }
             const pathStr = path.length > 1 ? path.join(' ') : path.length ? path[0] : seen.$index$;
-            rootsPathMap.set(obj, pathStr);
+            objectPathStringCache.set(obj, pathStr);
             return pathStr;
         };
         const $addRoot$ = (obj, parent = null) => {
@@ -8875,7 +8918,7 @@
             $storeProxyMap$: storeProxyMap,
             $getProp$: getProp,
             $setProp$: setProp,
-            $pathMap$: rootsPathMap,
+            $objectPathStringCache$: objectPathStringCache,
         };
     };
     function $discoverRoots$(serializationContext, obj, parent, index) {
@@ -8899,7 +8942,8 @@
                 for (let i = 1; i < value.length; i += 2) {
                     const keyValue = value[i - 1];
                     const attrValue = value[i];
-                    if (typeof attrValue === 'string' ||
+                    if (attrValue == null ||
+                        typeof attrValue === 'string' ||
                         // skip empty props
                         (keyValue === ELEMENT_PROPS &&
                             Object.keys(attrValue).length === 0)) {
@@ -8924,6 +8968,14 @@
             this.$qrl$ = $qrl$;
         }
     }
+    class SerializationWeakRef {
+        $obj$;
+        constructor($obj$) {
+            this.$obj$ = $obj$;
+        }
+    }
+    /** @internal */
+    const _serializationWeakRef = (obj) => new SerializationWeakRef(obj);
     /**
      * Format:
      *
@@ -8934,12 +8986,14 @@
      * - Therefore root indexes need to be doubled to get the actual index.
      */
     async function serialize(serializationContext) {
-        const { $writer$, $isSsrNode$, $isDomRef$, $storeProxyMap$, $addRoot$, $pathMap$, $wasSeen$ } = serializationContext;
+        const { $writer$, $isSsrNode$, $isDomRef$, $storeProxyMap$, $addRoot$, $objectPathStringCache$, $wasSeen$, } = serializationContext;
         let depth = 0;
+        let rootIdx = 0;
         const forwardRefs = [];
         let forwardRefsId = 0;
         const promises = new Set();
         const preloadQrls = new Set();
+        const s11nWeakRefs = new Map();
         let parent = null;
         const isRootObject = () => depth === 0;
         const outputArray = (value, writeFn) => {
@@ -8984,19 +9038,41 @@
         };
         const addPreloadQrl = (qrl) => {
             preloadQrls.add(qrl);
-            serializationContext.$addRoot$(qrl, null);
+            serializationContext.$addRoot$(qrl);
         };
-        const outputRootRef = (value, rootDepth = 0) => {
+        const outputAsRootRef = (value, rootDepth = 0) => {
             const seen = $wasSeen$(value);
-            const rootRefPath = $pathMap$.get(value);
+            const rootRefPath = $objectPathStringCache$.get(value);
+            // Objects are the only way to create circular dependencies.
+            // So the first thing to to is to see if we have a circular dependency.
+            // (NOTE: For root objects we need to serialize them regardless if we have seen
+            //        them before, otherwise the root object reference will point to itself.)
+            // Also note that depth will be 1 for objects in root
             if (rootDepth === depth && seen && seen.$parent$ !== null && rootRefPath) {
                 output(0 /* TypeIds.RootRef */, rootRefPath);
                 return true;
             }
             else if (depth > rootDepth && seen && seen.$rootIndex$ !== -1) {
+                // We have seen this object before, so we can serialize it as a reference.
+                // Otherwise serialize as normal
                 output(0 /* TypeIds.RootRef */, seen.$rootIndex$);
                 return true;
             }
+            else if (s11nWeakRefs.has(value)) {
+                const forwardRefId = s11nWeakRefs.get(value);
+                // We see the object again, we must now make it a root and update the forward ref
+                if (rootDepth === depth) {
+                    // It's already a root
+                    forwardRefs[forwardRefId] = rootIdx;
+                }
+                else {
+                    // ref
+                    const rootRef = $addRoot$(value);
+                    output(0 /* TypeIds.RootRef */, rootRef);
+                    forwardRefs[forwardRefId] = rootRef;
+                    return true;
+                }
+            }
             return false;
         };
         const writeValue = (value) => {
@@ -9011,13 +9087,13 @@
             }
             else if (typeof value === 'function') {
                 if (value === Slot) {
-                    output(3 /* TypeIds.Constant */, 9 /* Constants.Slot */);
+                    output(3 /* TypeIds.Constant */, 10 /* Constants.Slot */);
                 }
                 else if (value === Fragment) {
-                    output(3 /* TypeIds.Constant */, 10 /* Constants.Fragment */);
+                    output(3 /* TypeIds.Constant */, 11 /* Constants.Fragment */);
                 }
                 else if (isQrl(value)) {
-                    if (!outputRootRef(value)) {
+                    if (!outputAsRootRef(value)) {
                         const qrl = qrlToString(serializationContext, value);
                         const type = preloadQrls.has(value) ? 21 /* TypeIds.PreloadQRL */ : 20 /* TypeIds.QRL */;
                         if (isRootObject()) {
@@ -9040,19 +9116,19 @@
             }
             else if (typeof value === 'number') {
                 if (Number.isNaN(value)) {
-                    output(3 /* TypeIds.Constant */, 11 /* Constants.NaN */);
+                    output(3 /* TypeIds.Constant */, 12 /* Constants.NaN */);
                 }
                 else if (!Number.isFinite(value)) {
-                    output(3 /* TypeIds.Constant */, value < 0 ? 13 /* Constants.NegativeInfinity */ : 12 /* Constants.PositiveInfinity */);
+                    output(3 /* TypeIds.Constant */, value < 0 ? 14 /* Constants.NegativeInfinity */ : 13 /* Constants.PositiveInfinity */);
                 }
                 else if (value === Number.MAX_SAFE_INTEGER) {
-                    output(3 /* TypeIds.Constant */, 14 /* Constants.MaxSafeInt */);
+                    output(3 /* TypeIds.Constant */, 15 /* Constants.MaxSafeInt */);
                 }
                 else if (value === Number.MAX_SAFE_INTEGER - 1) {
-                    output(3 /* TypeIds.Constant */, 15 /* Constants.AlmostMaxSafeInt */);
+                    output(3 /* TypeIds.Constant */, 16 /* Constants.AlmostMaxSafeInt */);
                 }
                 else if (value === Number.MIN_SAFE_INTEGER) {
-                    output(3 /* TypeIds.Constant */, 16 /* Constants.MinSafeInt */);
+                    output(3 /* TypeIds.Constant */, 17 /* Constants.MinSafeInt */);
                 }
                 else {
                     output(4 /* TypeIds.Number */, value);
@@ -9082,7 +9158,7 @@
                     output(3 /* TypeIds.Constant */, 4 /* Constants.EmptyString */);
                 }
                 else {
-                    if (!outputRootRef(value)) {
+                    if (!outputAsRootRef(value)) {
                         output(5 /* TypeIds.String */, value);
                     }
                 }
@@ -9096,6 +9172,9 @@
             else if (value === STORE_ALL_PROPS) {
                 output(3 /* TypeIds.Constant */, 8 /* Constants.STORE_ALL_PROPS */);
             }
+            else if (value === _UNINITIALIZED) {
+                output(3 /* TypeIds.Constant */, 9 /* Constants.UNINITIALIZED */);
+            }
             else {
                 throw qError(20 /* QError.serializeErrorUnknownType */, [typeof value]);
             }
@@ -9105,14 +9184,11 @@
              * The object writer outputs an array object (without type prefix) and this increases the depth
              * for the objects within (depth 1).
              */
-            // Objects are the only way to create circular dependencies.
-            // So the first thing to to is to see if we have a circular dependency.
-            // (NOTE: For root objects we need to serialize them regardless if we have seen
-            //        them before, otherwise the root object reference will point to itself.)
-            // Also note that depth will be 1 for objects in root
-            if (outputRootRef(value, 1)) {
+            if (outputAsRootRef(value, 1)) {
                 return;
             }
+            // handle custom serializers
+            // add to the seen map
             if (isPropsProxy(value)) {
                 const varProps = value[_VAR_PROPS];
                 const constProps = value[_CONST_PROPS];
@@ -9124,7 +9200,7 @@
                 output(34 /* TypeIds.PropsProxy */, out);
             }
             else if (value instanceof SubscriptionData) {
-                output(35 /* TypeIds.EffectData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
+                output(35 /* TypeIds.SubscriptionData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
             }
             else if (isStore(value)) {
                 if (isResource(value)) {
@@ -9200,14 +9276,6 @@
                     output(1 /* TypeIds.ForwardRef */, forwardRefId);
                     return;
                 }
-                /**
-                 * Special case: when a Signal value is an SSRNode, it always needs to be a DOM ref instead.
-                 * It can never be meant to become a vNode, because vNodes are internal only.
-                 */
-                const v = value instanceof ComputedSignalImpl &&
-                    (value.$flags$ & 1 /* SignalFlags.INVALID */ || fastSkipSerialize(value.$untrackedValue$))
-                    ? NEEDS_COMPUTATION
-                    : value.$untrackedValue$;
                 if (value instanceof WrappedSignalImpl) {
                     output(26 /* TypeIds.WrappedSignal */, [
                         ...serializeWrappingFn(serializationContext, value),
@@ -9217,35 +9285,34 @@
                         ...(value.$effects$ || []),
                     ]);
                 }
-                else if (value instanceof AsyncComputedSignalImpl) {
-                    addPreloadQrl(value.$computeQrl$);
-                    const out = [
-                        value.$computeQrl$,
-                        value.$effects$,
-                        value.$loadingEffects$,
-                        value.$errorEffects$,
-                        value.$untrackedLoading$,
-                        value.$untrackedError$,
-                    ];
-                    if (v !== NEEDS_COMPUTATION) {
-                        out.push(v);
-                    }
-                    output(28 /* TypeIds.AsyncComputedSignal */, out);
-                }
                 else if (value instanceof ComputedSignalImpl) {
+                    let v = value.$untrackedValue$;
+                    const shouldAlwaysSerialize = value.$flags$ & 16 /* ComputedSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */;
+                    const shouldNeverSerialize = value.$flags$ & 8 /* ComputedSignalFlags.SERIALIZATION_STRATEGY_NEVER */;
+                    const isInvalid = value.$flags$ & 1 /* SignalFlags.INVALID */;
+                    const isSkippable = fastSkipSerialize(value.$untrackedValue$);
+                    if (shouldAlwaysSerialize) {
+                        v = value.$untrackedValue$;
+                    }
+                    else if (shouldNeverSerialize) {
+                        v = NEEDS_COMPUTATION;
+                    }
+                    else if (isInvalid || isSkippable) {
+                        v = NEEDS_COMPUTATION;
+                    }
                     addPreloadQrl(value.$computeQrl$);
-                    const out = [
-                        value.$computeQrl$,
-                        // TODO check if we can use domVRef for effects
-                        value.$effects$,
-                    ];
+                    const out = [value.$computeQrl$, value.$effects$];
+                    const isAsync = value instanceof AsyncComputedSignalImpl;
+                    if (isAsync) {
+                        out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedLoading$, value.$untrackedError$);
+                    }
                     if (v !== NEEDS_COMPUTATION) {
                         out.push(v);
                     }
-                    output(27 /* TypeIds.ComputedSignal */, out);
+                    output(isAsync ? 28 /* TypeIds.AsyncComputedSignal */ : 27 /* TypeIds.ComputedSignal */, out);
                 }
                 else {
-                    output(25 /* TypeIds.Signal */, [v, ...(value.$effects$ || [])]);
+                    output(25 /* TypeIds.Signal */, [value.$untrackedValue$, ...(value.$effects$ || [])]);
                 }
             }
             else if (value instanceof URL) {
@@ -9380,6 +9447,12 @@
                 const out = btoa(buf).replace(/=+$/, '');
                 output(19 /* TypeIds.Uint8Array */, out);
             }
+            else if (value instanceof SerializationWeakRef) {
+                const forwardRefId = forwardRefsId++;
+                s11nWeakRefs.set(value.$obj$, forwardRefId);
+                forwardRefs[forwardRefId] = -1;
+                output(1 /* TypeIds.ForwardRef */, forwardRefId);
+            }
             else if (vnode_isVNode(value)) {
                 output(3 /* TypeIds.Constant */, 0 /* Constants.Undefined */);
             }
@@ -9403,21 +9476,20 @@
         }
         const outputRoots = async () => {
             $writer$.write('[');
-            let lastRootsLength = 0;
             let rootsLength = serializationContext.$roots$.length;
-            while (lastRootsLength < rootsLength || promises.size) {
-                if (lastRootsLength !== 0) {
+            while (rootIdx < rootsLength || promises.size) {
+                if (rootIdx !== 0) {
                     $writer$.write(',');
                 }
                 let separator = false;
-                for (let i = lastRootsLength; i < rootsLength; i++) {
+                for (; rootIdx < rootsLength; rootIdx++) {
                     if (separator) {
                         $writer$.write(',');
                     }
                     else {
                         separator = true;
                     }
-                    writeValue(serializationContext.$roots$[i]);
+                    writeValue(serializationContext.$roots$[rootIdx]);
                 }
                 if (promises.size) {
                     try {
@@ -9427,7 +9499,6 @@
                         // ignore rejections, they will be serialized as rejected promises
                     }
                 }
-                lastRootsLength = rootsLength;
                 rootsLength = serializationContext.$roots$.length;
             }
             if (forwardRefs.length) {
@@ -9733,7 +9804,7 @@
         return (
         // THINK: Not sure if we need to keep track of functions (QRLs) Let's skip them for now.
         // and see if we have a test case which requires them.
-        (typeof obj === 'object' && obj !== null) ||
+        isObject(obj) ||
             /**
              * We track all strings greater than 1 character, because those take at least 6 bytes to encode
              * and even with 999 root objects it saves one byte per reference. Tracking more objects makes
@@ -9761,9 +9832,7 @@
         return '__brand' in value && value.__brand === 'resource';
     }
     const frameworkType = (obj) => {
-        return ((typeof obj === 'object' &&
-            obj !== null &&
-            (obj instanceof SignalImpl || obj instanceof Task || isJSXNode(obj))) ||
+        return ((isObject(obj) && (obj instanceof SignalImpl || obj instanceof Task || isJSXNode(obj))) ||
             isQrl(obj));
     };
     const canSerialize = (value, seen = new WeakSet()) => {
@@ -9849,6 +9918,9 @@
                 return true;
             }
         }
+        else if (value === _UNINITIALIZED) {
+            return true;
+        }
         return false;
     };
     const QRL_RUNTIME_CHUNK = 'mock-chunk';
@@ -9888,12 +9960,12 @@
         'FormData',
         'JSXNode',
         'PropsProxy',
-        'EffectData',
+        'SubscriptionData',
     ];
     const circularProofJson = (obj, indent) => {
         const seen = new WeakSet();
-        return JSON.stringify(obj, (key, value) => {
-            if (typeof value === 'object' && value !== null) {
+        return JSON.stringify(obj, (_, value) => {
+            if (isObject(value)) {
                 if (seen.has(value)) {
                     return `[Circular ${value.constructor.name}]`;
                 }
@@ -9930,7 +10002,7 @@
             let value = state[++i];
             if (key === undefined) {
                 hasRaw = true;
-                out.push(`${RED}[raw${typeof value === 'object' && value ? ` ${value.constructor.name}` : ''}]${RESET} ${printRaw(value, `${prefix}  `)}`);
+                out.push(`${RED}[raw${isObject(value) ? ` ${value.constructor.name}` : ''}]${RESET} ${printRaw(value, `${prefix}  `)}`);
             }
             else {
                 if (key === 3 /* TypeIds.Constant */) {
@@ -10044,7 +10116,6 @@
         return value;
     };
     const noSerializeSet = /*#__PURE__*/ new WeakSet();
-    const weakSerializeSet = /*#__PURE__*/ new WeakSet();
     const shouldSerialize = (obj) => {
         if (isObject(obj) || isFunction(obj)) {
             return !noSerializeSet.has(obj);
@@ -10053,7 +10124,7 @@
     };
     const fastSkipSerialize = (obj) => {
         return (obj &&
-            (typeof obj === 'object' || typeof obj === 'function') &&
+            (isObject(obj) || typeof obj === 'function') &&
             (NoSerializeSymbol in obj || noSerializeSet.has(obj)));
     };
     // <docs markdown="../../readme.md#noSerialize">
@@ -10078,16 +10149,11 @@
     // </docs>
     const noSerialize = (input) => {
         // only add supported values to the noSerializeSet, prevent console errors
-        if ((typeof input === 'object' && input !== null) || typeof input === 'function') {
+        if ((isObject(input) && input !== null) || typeof input === 'function') {
             noSerializeSet.add(input);
         }
         return input;
     };
-    /** @internal */
-    const _weakSerialize = (input) => {
-        weakSerializeSet.add(input);
-        return input;
-    };
     /**
      * If an object has this property, it will not be serialized. Use this on prototypes to avoid having
      * to call `noSerialize()` on every object.
@@ -11291,13 +11357,13 @@
         return set(value);
     };
 
-    const useComputedCommon = (qrl, Class) => {
+    const useComputedCommon = (qrl, createFn, options) => {
         const { val, set } = useSequentialScope();
         if (val) {
             return val;
         }
         assertQrl(qrl);
-        const signal = new Class(null, qrl);
+        const signal = createFn(qrl, options);
         set(signal);
         // Note that we first save the signal
         // and then we throw to load the qrl
@@ -11306,8 +11372,8 @@
         return signal;
     };
     /** @internal */
-    const useComputedQrl = (qrl) => {
-        return useComputedCommon(qrl, ComputedSignalImpl);
+    const useComputedQrl = (qrl, options) => {
+        return useComputedCommon(qrl, createComputedSignal, options);
     };
     /**
      * Creates a computed signal which is calculated from the given function. A computed signal is a
@@ -11322,7 +11388,7 @@
     const useComputed$ = implicit$FirstArg(useComputedQrl);
 
     /** @internal */
-    const useSerializerQrl = (qrl) => useComputedCommon(qrl, SerializerSignalImpl);
+    const useSerializerQrl = (qrl) => useComputedCommon(qrl, createSerializerSignal);
     /**
      * Creates a signal which holds a custom serializable value. It requires that the value implements
      * the `CustomSerializable` type, which means having a function under the `[SerializeSymbol]`
@@ -11577,8 +11643,8 @@
     const useVisibleTask$ = /*#__PURE__*/ implicit$FirstArg(useVisibleTaskQrl);
 
     /** @internal */
-    const useAsyncComputedQrl = (qrl) => {
-        return useComputedCommon(qrl, AsyncComputedSignalImpl);
+    const useAsyncComputedQrl = (qrl, options) => {
+        return useComputedCommon(qrl, createAsyncComputedSignal, options);
     };
     /**
      * Creates a computed signal which is calculated from the given function. A computed signal is a
@@ -11702,10 +11768,12 @@
     exports._IMMUTABLE = _IMMUTABLE;
     exports._SharedContainer = _SharedContainer;
     exports._SubscriptionData = SubscriptionData;
+    exports._UNINITIALIZED = _UNINITIALIZED;
     exports._VAR_PROPS = _VAR_PROPS;
     exports._deserialize = _deserialize;
     exports._dumpState = dumpState;
     exports._fnSignal = _fnSignal;
+    exports._getContextContainer = _getContextContainer;
     exports._getContextElement = _getContextElement;
     exports._getContextEvent = _getContextEvent;
     exports._getDomContainer = getDomContainer;
@@ -11725,18 +11793,20 @@
     exports._regSymbol = _regSymbol;
     exports._restProps = _restProps;
     exports._run = queueQRL;
+    exports._serializationWeakRef = _serializationWeakRef;
     exports._serialize = _serialize;
     exports._task = scheduleTask;
+    exports._useInvokeContext = useInvokeContext;
     exports._verifySerializable = verifySerializable;
     exports._vnode_toString = vnode_toString;
     exports._waitUntilRendered = _waitUntilRendered;
     exports._walkJSX = _walkJSX;
-    exports._weakSerialize = _weakSerialize;
     exports._wrapProp = _wrapProp;
     exports._wrapSignal = _wrapSignal;
-    exports._wrapStore = _wrapStore;
     exports.component$ = component$;
     exports.componentQrl = componentQrl;
+    exports.createAsyncComputed$ = createAsyncComputed$;
+    exports.createAsyncComputedQrl = createAsyncComputedSignal;
     exports.createComputed$ = createComputed$;
     exports.createComputedQrl = createComputedSignal;
     exports.createContextId = createContextId;