teamplay 0.5.0-alpha.14 → 0.5.0-alpha.16

package/dist/index.d.ts

@@ -57,7 +57,7 @@ export { default as sub } from './orm/sub.js';
 export { default as useSub, useAsyncSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from './react/useSub.js';
 export { default as useSuspendMemo, useSuspendMemoByKey } from './react/useSuspendMemo.js';
 export declare const observer: ObserverFunction;
-export { useBatch, useDoc, useDoc$, useBatchDoc, useBatchDoc$, useAsyncDoc, useAsyncDoc$, useQuery, useQuery$, useAsyncQuery, useAsyncQuery$, useBatchQuery, useBatchQuery$, useQueryIds, useBatchQueryIds, useAsyncQueryIds, useQueryDoc, useQueryDoc$, useBatchQueryDoc, useBatchQueryDoc$, useAsyncQueryDoc, useAsyncQueryDoc$ } from './orm/Compat/hooksCompat.js';
+export { useBatch, useBatchDoc, useBatchDoc$, useBatchQuery, useBatchQuery$, useQueryIds, useBatchQueryIds, useAsyncQueryIds, useQueryDoc, useQueryDoc$, useBatchQueryDoc, useBatchQueryDoc$, useAsyncQueryDoc, useAsyncQueryDoc$ } from './orm/Compat/hooksCompat.js';
 export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
 export { useDidUpdate, useOnce, useSyncEffect } from './react/helpers.js';
 export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from './orm/connection.js';

package/dist/index.js

@@ -18,7 +18,7 @@ export { default as sub } from "./orm/sub.js";
 export { default as useSub, useAsyncSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from "./react/useSub.js";
 export { default as useSuspendMemo, useSuspendMemoByKey } from "./react/useSuspendMemo.js";
 export const observer = runtimeObserver;
-export { useBatch, useDoc, useDoc$, useBatchDoc, useBatchDoc$, useAsyncDoc, useAsyncDoc$, useQuery, useQuery$, useAsyncQuery, useAsyncQuery$, useBatchQuery, useBatchQuery$, useQueryIds, useBatchQueryIds, useAsyncQueryIds, useQueryDoc, useQueryDoc$, useBatchQueryDoc, useBatchQueryDoc$, useAsyncQueryDoc, useAsyncQueryDoc$ } from './orm/Compat/hooksCompat.js';
+export { useBatch, useBatchDoc, useBatchDoc$, useBatchQuery, useBatchQuery$, useQueryIds, useBatchQueryIds, useAsyncQueryIds, useQueryDoc, useQueryDoc$, useBatchQueryDoc, useBatchQueryDoc$, useAsyncQueryDoc, useAsyncQueryDoc$ } from './orm/Compat/hooksCompat.js';
 export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
 export { useDidUpdate, useOnce, useSyncEffect } from "./react/helpers.js";
 export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from "./orm/connection.js";

package/dist/orm/Compat/hooksCompat.d.ts

@@ -1,14 +1,6 @@
 export const useBatch: any
-export const useDoc: any
-export const useDoc$: any
 export const useBatchDoc: any
 export const useBatchDoc$: any
-export const useAsyncDoc: any
-export const useAsyncDoc$: any
-export const useQuery: any
-export const useQuery$: any
-export const useAsyncQuery: any
-export const useAsyncQuery$: any
 export const useBatchQuery: any
 export const useBatchQuery$: any
 export const useQueryIds: any

package/dist/orm/Compat/hooksCompat.js

@@ -11,15 +11,6 @@ export function useBatch() {
     if (promise)
         throw promise;
 }
-export function useDoc$(collection, id, options) {
-    const $doc = getDocSignal(collection, id, 'useDoc');
-    const normalizedOptions = normalizeSyncSubOptions(options);
-    return useSub($doc, undefined, normalizedOptions);
-}
-export function useDoc(collection, id, options) {
-    const $doc = useDoc$(collection, id, options);
-    return [$doc.get(), $doc];
-}
 export function useBatchDoc(collection, id, options) {
     const $doc = useBatchDoc$(collection, id, options);
     if (!$doc)
@@ -31,16 +22,6 @@ export function useBatchDoc$(collection, id, _options) {
     const options = _options ? { ..._options, ...BATCH_SUB_OPTIONS } : BATCH_SUB_OPTIONS;
     return useSub($doc, undefined, options);
 }
-export function useAsyncDoc$(collection, id, options) {
-    const $doc = getDocSignal(collection, id, 'useAsyncDoc');
-    return useAsyncSub($doc, undefined, options);
-}
-export function useAsyncDoc(collection, id, options) {
-    const $doc = useAsyncDoc$(collection, id, options);
-    if (!$doc)
-        return [undefined, undefined];
-    return [$doc.get(), $doc];
-}
 function useSubscribedQuery(collection, query, options, hookName, subscribe) {
     const normalizedQuery = normalizeQuery(query, hookName);
     const $collection = getCollectionSignal(collection, query, hookName);
@@ -56,22 +37,13 @@ function getExtraQuerySignal($query, normalizedQuery) {
         return $query;
     return isExtraQuery(normalizedQuery) ? $query.extra : $query;
 }
-export function useQuery$(collection, query, options) {
+function useSyncQueryResult(collection, query, options, hookName) {
     const normalizedOptions = normalizeSyncSubOptions(options);
-    const { $query } = useSubscribedQuery(collection, query, normalizedOptions, 'useQuery', useSub);
-    return $query;
-}
-export function useQuery(collection, query, options) {
-    const normalizedOptions = normalizeSyncSubOptions(options);
-    const { $collection, $query } = useSubscribedQuery(collection, query, normalizedOptions, 'useQuery', useSub);
+    const { $collection, $query } = useSubscribedQuery(collection, query, normalizedOptions, hookName, useSub);
     return [$query.get(), $collection];
 }
-export function useAsyncQuery$(collection, query, options) {
-    const { $query } = useSubscribedQuery(collection, query, options, 'useAsyncQuery', useAsyncSub);
-    return $query;
-}
-export function useAsyncQuery(collection, query, options) {
-    const { $collection, $query } = useSubscribedQuery(collection, query, options, 'useAsyncQuery', useAsyncSub);
+function useAsyncQueryResult(collection, query, options, hookName) {
+    const { $collection, $query } = useSubscribedQuery(collection, query, options, hookName, useAsyncSub);
     if (!$query)
         return [undefined, $collection];
     return [$query.get(), $collection];
@@ -92,7 +64,7 @@ export function useQueryIds(collection, ids = [], options = {}) {
     const list = Array.isArray(ids) ? ids.slice() : [];
     if (options?.reverse)
         list.reverse();
-    const [docs, $collection] = useQuery(collection, { _id: { $in: list } }, options);
+    const [docs, $collection] = useSyncQueryResult(collection, { _id: { $in: list } }, options, 'useQueryIds');
     if (!docs)
         return [docs, $collection];
     const docsById = new Map();
@@ -124,7 +96,7 @@ export function useAsyncQueryIds(collection, ids = [], options = {}) {
     const list = Array.isArray(ids) ? ids.slice() : [];
     if (options?.reverse)
         list.reverse();
-    const [docs, $collection] = useAsyncQuery(collection, { _id: { $in: list } }, options);
+    const [docs, $collection] = useAsyncQueryResult(collection, { _id: { $in: list } }, options, 'useAsyncQueryIds');
     if (docs == null)
         return [undefined, $collection];
     const docsById = new Map();
@@ -143,7 +115,7 @@ export function useQueryDoc(collection, query, options) {
         $limit: 1,
         $sort: normalized.$sort || { createdAt: -1 }
     };
-    const [docs, $collection] = useQuery(collection, queryDoc, options);
+    const [docs, $collection] = useSyncQueryResult(collection, queryDoc, options, 'useQueryDoc');
     const doc = docs && docs[0];
     const docId = doc?._id ?? doc?.id;
     const $doc = docId != null ? $collection[docId] : undefined;
@@ -179,7 +151,7 @@ export function useAsyncQueryDoc(collection, query, options) {
         $limit: 1,
         $sort: normalized.$sort || { createdAt: -1 }
     };
-    const [docs, $collection] = useAsyncQuery(collection, queryDoc, options);
+    const [docs, $collection] = useAsyncQueryResult(collection, queryDoc, options, 'useAsyncQueryDoc');
     if (docs == null)
         return [undefined, undefined];
     const doc = docs && docs[0];
@@ -247,7 +219,6 @@ function isExtraQuery(query) {
 const BATCH_SUB_OPTIONS = Object.freeze({
     async: false,
     batch: true,
-    renderAttemptCleanup: true,
     // Batch hooks are a hard suspense barrier. Deferred params can skip the barrier
     // on route transitions and cause immediate reads from stale/empty local nodes.
     defer: false
@@ -259,7 +230,6 @@ function normalizeSyncSubOptions(options) {
     return {
         ...(options || {}),
         async: false,
-        renderAttemptCleanup: true,
         // Compat sync hooks are strict by design: no deferred snapshots between route/tab switches.
         defer: false
     };

package/dist/react/convertToObserver.js

@@ -7,7 +7,6 @@ import executionContextTracker from "./executionContextTracker.js";
 import { pipeComponentMeta, useUnmount, useId, useTriggerUpdate } from "./helpers.js";
 import trapRender from './trapRender.js';
 import { scheduleReaction } from '../orm/batchScheduler.js';
-import { isCompatComponent, unmarkCompatComponent } from "./compatComponentRegistry.js";
 const DEFAULT_THROTTLE_TIMEOUT = 100;
 export default function convertToObserver(BaseComponent, { forwardRef, cache: enableCache = true, throttle, ...options } = {}) {
     throttle = normalizeThrottle(throttle);
@@ -33,7 +32,7 @@ export default function convertToObserver(BaseComponent, { forwardRef, cache: en
                     hasDeferredUpdateAfterExecutionContext = false;
                     triggerUpdate();
                 }
-                else if (isCompatComponent(componentId)) {
+                else {
                     if (hasDeferredUpdateAfterExecutionContext)
                         return;
                     hasDeferredUpdateAfterExecutionContext = true;
@@ -53,7 +52,6 @@ export default function convertToObserver(BaseComponent, { forwardRef, cache: en
                 if (!reactionRef.current)
                     throw Error(`NO REACTION REF - ${where}`);
                 destroyRef.current = undefined;
-                unmarkCompatComponent(componentId);
                 unobserve(reactionRef.current);
                 reactionRef.current = undefined;
                 destroyCache(where);
@@ -71,7 +69,6 @@ export default function convertToObserver(BaseComponent, { forwardRef, cache: en
         }
         // clean up observer on unmount
         useUnmount(() => {
-            unmarkCompatComponent(componentId);
             destroyRef.current?.('useUnmount()');
         });
         return reactionRef.current(...args);

package/dist/react/renderAttemptDestroyer.d.ts

@@ -1,17 +1,9 @@
-type DestroyAttempt = () => unknown | Promise<unknown>;
 declare class RenderAttemptDestroyer {
-    fns: DestroyAttempt[];
-    renderAttemptCleanupArmed: boolean;
     suspenseGateArmed: boolean;
     constructor();
-    add(fn: DestroyAttempt | undefined, { renderAttemptCleanup }?: {
-        renderAttemptCleanup?: boolean;
-    }): void;
-    armRenderAttemptCleanup(): void;
     armSuspenseGate(): void;
     consumeThenableHandling(): {
         shouldKeepShellAlive: boolean;
-        destroyAttempt?: () => Promise<void>;
     };
     reset(): void;
 }

package/dist/react/renderAttemptDestroyer.js

@@ -1,45 +1,19 @@
 class RenderAttemptDestroyer {
-    fns;
-    renderAttemptCleanupArmed;
     suspenseGateArmed;
     constructor() {
-        this.fns = [];
-        this.renderAttemptCleanupArmed = false;
         this.suspenseGateArmed = false;
     }
-    add(fn, { renderAttemptCleanup = false } = {}) {
-        if (typeof fn !== 'function')
-            return;
-        this.fns.push(fn);
-        if (renderAttemptCleanup)
-            this.renderAttemptCleanupArmed = true;
-    }
-    armRenderAttemptCleanup() {
-        this.renderAttemptCleanupArmed = true;
-    }
     armSuspenseGate() {
         this.suspenseGateArmed = true;
     }
     consumeThenableHandling() {
-        const shouldRunAttemptCleanup = this.renderAttemptCleanupArmed && this.fns.length > 0;
-        const shouldKeepShellAlive = this.suspenseGateArmed || shouldRunAttemptCleanup;
-        let destroyAttempt;
-        if (shouldRunAttemptCleanup) {
-            const fns = [...this.fns];
-            destroyAttempt = async () => {
-                await Promise.allSettled(fns.map(fn => fn()));
-                fns.length = 0;
-            };
-        }
+        const shouldKeepShellAlive = this.suspenseGateArmed;
         this.reset();
         return {
-            shouldKeepShellAlive,
-            destroyAttempt
+            shouldKeepShellAlive
         };
     }
     reset() {
-        this.fns.length = 0;
-        this.renderAttemptCleanupArmed = false;
         this.suspenseGateArmed = false;
     }
 }

package/dist/react/trapRender.js

@@ -24,9 +24,9 @@ export default function trapRender({ render, cache, destroy, componentId }) {
                 destroyed = true;
                 throw err;
             }
-            const { shouldKeepShellAlive, destroyAttempt } = renderAttemptDestroyer.consumeThenableHandling();
+            const { shouldKeepShellAlive } = renderAttemptDestroyer.consumeThenableHandling();
             if (shouldKeepShellAlive) {
-                throw Promise.resolve(err).then(() => destroyAttempt?.());
+                throw Promise.resolve(err);
             }
             // TODO: this might only be needed only if promise is thrown
             //       (check if useUnmount in convertToObserver is called if a regular error is thrown)

package/dist/react/useSub.d.ts

@@ -1,5 +1,5 @@
 import type { AggregationFunction, AggregationParams, ClientAggregationFunction } from '@teamplay/utils/aggregation';
-import type { CollectionSignal, ComputedQueryParamsInput, DocumentSignal, QueryParams, RegisteredAggregationInput, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, WildcardSignalPath } from '../orm/Signal.js';
+import { type CollectionSignal, type ComputedQueryParamsInput, type DocumentSignal, type QueryParams, type RegisteredAggregationInput, type SignalModelConstructor, type SubResult, type TypedAggregationInput, type TypedAggregationSignal, type WildcardSignalPath } from '../orm/Signal.js';
 export interface UseSubOptions {
     /** Return `undefined` while loading instead of throwing a Suspense promise. */
     async?: boolean;
@@ -7,9 +7,14 @@ export interface UseSubOptions {
     defer?: boolean | number;
     /** Batch Suspense promises across multiple subscriptions in one render attempt. */
     batch?: boolean;
-    /** Enable cleanup for observer render attempts when a subscription suspends. */
-    renderAttemptCleanup?: boolean;
 }
+/**
+ * Subscribe to a document signal in React async mode.
+ * @param signal Document signal to subscribe to.
+ * @param params Must be omitted for document subscriptions.
+ * @param options Subscription behavior options.
+ */
+export declare function useAsyncSub<TSignal extends DocumentSignal<any, any, any>>(signal: TSignal, options?: UseSubOptions): SubResult<TSignal>;
 /**
  * Subscribe to a document signal in React async mode.
  * @param signal Document signal to subscribe to.
@@ -61,6 +66,13 @@ export declare function useAsyncSub<TDocument, TDocumentModel extends SignalMode
  * @param options Subscription behavior options.
  */
 export declare function useAsyncSub<TOutput = unknown, TCollection extends string = string>(signal: AggregationFunction<TOutput, TCollection>, params?: AggregationParams, options?: UseSubOptions): SubResult<AggregationFunction<TOutput, TCollection>, AggregationParams | undefined>;
+/**
+ * Subscribe to a document signal in React.
+ * @param signal Document signal to subscribe to.
+ * @param params Must be omitted for document subscriptions.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<TSignal extends DocumentSignal<any, any, any>>(signal: TSignal, options?: UseSubOptions): SubResult<TSignal>;
 /**
  * Subscribe to a document signal in React.
  * @param signal Document signal to subscribe to.
@@ -112,8 +124,8 @@ export default function useSub<TDocument, TDocumentModel extends SignalModelCons
  * @param options Subscription behavior options.
  */
 export default function useSub<TOutput = unknown, TCollection extends string = string>(signal: AggregationFunction<TOutput, TCollection>, params?: AggregationParams, options?: UseSubOptions): SubResult<AggregationFunction<TOutput, TCollection>, AggregationParams | undefined>;
-export declare function useSubDeferred(signal: unknown, params?: unknown, { async, defer, batch, renderAttemptCleanup }?: UseSubOptions): unknown;
-export declare function useSubClassic(signal: unknown, params?: unknown, { async, batch, renderAttemptCleanup }?: UseSubOptions): unknown;
+export declare function useSubDeferred(signal: unknown, params?: unknown, { async, defer, batch }?: UseSubOptions): unknown;
+export declare function useSubClassic(signal: unknown, params?: unknown, { async, batch }?: UseSubOptions): unknown;
 export declare function setTestThrottling(ms: number): void;
 export declare function resetTestThrottling(): void;
 export declare function setUseDeferredValue(value: boolean): void;

package/dist/react/useSub.js

@@ -1,11 +1,11 @@
 import { useRef, useDeferredValue } from 'react';
 import sub from "../orm/sub.js";
-import { useScheduleUpdate, useCache, useDefer, useId } from "./helpers.js";
+import { useScheduleUpdate, useCache, useDefer } from "./helpers.js";
 import executionContextTracker from "./executionContextTracker.js";
 import * as promiseBatcher from "./promiseBatcher.js";
-import renderAttemptDestroyer from "./renderAttemptDestroyer.js";
-import { markCompatComponent } from "./compatComponentRegistry.js";
+import { isPublicDocumentSignal } from "../orm/Signal.js";
 const runtimeSub = sub;
+const USE_SUB_OPTION_KEYS = new Set(['async', 'defer', 'batch']);
 let TEST_THROTTLING = false;
 // experimental feature to leverage useDeferredValue() to handle re-subscriptions.
 // Currently it does lead to issues with extra rerenders and requires further investigation
@@ -13,10 +13,27 @@ let USE_DEFERRED_VALUE = true;
 // by default we want to defer stuff if possible instead of throwing promises
 let DEFAULT_DEFER = true;
 export function useAsyncSub(signal, params, options) {
-    return runUseSub(signal, params, { ...options, async: true });
+    const normalized = normalizeUseSubArgs(signal, params, options);
+    return runUseSub(normalized.signal, normalized.params, { ...normalized.options, async: true });
 }
 export default function useSub(signal, params, options) {
-    return runUseSub(signal, params, options);
+    const normalized = normalizeUseSubArgs(signal, params, options);
+    return runUseSub(normalized.signal, normalized.params, normalized.options);
+}
+function normalizeUseSubArgs(signal, params, options) {
+    if (options === undefined && params !== undefined && isPublicDocumentSignal(signal) && isUseSubOptions(params)) {
+        return {
+            signal,
+            params: undefined,
+            options: params
+        };
+    }
+    return { signal, params, options };
+}
+function isUseSubOptions(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    return Object.keys(value).every(key => USE_SUB_OPTION_KEYS.has(key));
 }
 function runUseSub(signal, params, options) {
     if (USE_DEFERRED_VALUE) {
@@ -27,13 +44,10 @@ function runUseSub(signal, params, options) {
     }
 }
 // version of sub() which works as a react hook and throws promise for Suspense
-export function useSubDeferred(signal, params, { async = false, defer, batch = false, renderAttemptCleanup = false } = {}) {
+export function useSubDeferred(signal, params, { async = false, defer, batch = false } = {}) {
     const $signalRef = useRef();
-    const componentId = useId();
     const scheduleUpdate = useScheduleUpdate();
     const observerDefer = useDefer();
-    if (renderAttemptCleanup)
-        markCompatComponent(componentId);
     if (batch)
         promiseBatcher.activate();
     defer ??= observerDefer ?? DEFAULT_DEFER;
@@ -52,8 +66,6 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
             // On resubscribe we keep rendering previous signal and refresh in background.
             if (!hasPreviousSignal) {
                 promiseBatcher.add(promise);
-                if (renderAttemptCleanup)
-                    registerRenderAttemptCleanup(signal, params);
             }
             else {
                 scheduleUpdate(promise);
@@ -71,8 +83,6 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
             scheduleUpdate(promise);
             return $signalRef.current;
         }
-        if (renderAttemptCleanup)
-            registerRenderAttemptCleanup(signal, params);
         throw promise;
         // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists
     }
@@ -85,13 +95,10 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
 }
 // classic version which initially throws promise for Suspense
 // but if we get a promise second time, we return the last signal and wait for promise to resolve
-export function useSubClassic(signal, params, { async = false, batch = false, renderAttemptCleanup = false } = {}) {
+export function useSubClassic(signal, params, { async = false, batch = false } = {}) {
     const id = executionContextTracker.newHookId();
-    const componentId = useId();
     const cache = useCache(undefined);
     const scheduleUpdate = useScheduleUpdate();
-    if (renderAttemptCleanup)
-        markCompatComponent(componentId);
     if (batch)
         promiseBatcher.activate();
     const promiseOrSignal = params != null ? runtimeSub(signal, params) : runtimeSub(signal);
@@ -104,8 +111,6 @@ export function useSubClassic(signal, params, { async = false, batch = false, re
             // On resubscribe we keep rendering previous signal and refresh in background.
             if (!hasPreviousSignal) {
                 promiseBatcher.add(promise);
-                if (renderAttemptCleanup)
-                    registerRenderAttemptCleanup(signal, params);
             }
             else {
                 scheduleUpdate(promise);
@@ -126,8 +131,6 @@ export function useSubClassic(signal, params, { async = false, batch = false, re
                 scheduleUpdate(promise);
                 return;
             }
-            if (renderAttemptCleanup)
-                registerRenderAttemptCleanup(signal, params);
             // in regular mode we throw the promise to be caught by Suspense
             // this way we guarantee that the signal with all the data
             // will always be there when component is rendered
@@ -180,10 +183,3 @@ function isThenable(value) {
         (typeof value === 'object' || typeof value === 'function') &&
         typeof value.then === 'function';
 }
-function registerRenderAttemptCleanup(_signal, _params) {
-    // Legacy hooks don't build per-hook init objects like Racer.
-    // We still need a marker so trapRender can defer observer-shell cleanup
-    // only when a real attempt cleanup exists.
-    // This path must not arm suspense-gate keep-alive by itself.
-    renderAttemptDestroyer.armRenderAttemptCleanup();
-}

package/dist/react/useSuspendMemo.js

@@ -1,13 +1,11 @@
 import executionContextTracker from "./executionContextTracker.js";
-import { useCache, useId } from "./helpers.js";
-import { markCompatComponent } from "./compatComponentRegistry.js";
+import { useCache } from "./helpers.js";
 import renderAttemptDestroyer from "./renderAttemptDestroyer.js";
 const IN_FLIGHT_BY_KEY = new Map();
 export default function useSuspendMemo(factory, deps) {
     if (typeof factory !== 'function')
         throw Error('useSuspendMemo() expects a factory function');
     deps = normalizeDeps(deps);
-    const componentId = useId();
     const cache = useCache(undefined);
     const hookId = executionContextTracker.newHookId();
     const cacheKey = `suspendMemo:${hookId}`;
@@ -24,7 +22,6 @@ export default function useSuspendMemo(factory, deps) {
     if (entry.status === 'done')
         return entry.value;
     if (entry.status === 'pending') {
-        markCompatComponent(componentId);
         renderAttemptDestroyer.armSuspenseGate();
         throw entry.promise;
     }
@@ -45,7 +42,6 @@ export default function useSuspendMemo(factory, deps) {
         });
         entry.status = 'pending';
         entry.promise = promise;
-        markCompatComponent(componentId);
         renderAttemptDestroyer.armSuspenseGate();
         throw promise;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.14",
+  "version": "0.5.0-alpha.16",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -134,5 +134,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "84185ddad8cdbac3d2dfcc48cff3588e5ab99630"
+  "gitHead": "a6f311fb793aeeba904b81416400e609ab597174"
 }

package/dist/react/compatComponentRegistry.d.ts

@@ -1,4 +0,0 @@
-export declare function markCompatComponent(componentId: string | undefined): void;
-export declare function unmarkCompatComponent(componentId: string | undefined): void;
-export declare function isCompatComponent(componentId: string | undefined): boolean;
-export declare function __resetCompatComponentRegistryForTests(): void;

package/dist/react/compatComponentRegistry.js

@@ -1,19 +0,0 @@
-const compatComponentIds = new Set();
-export function markCompatComponent(componentId) {
-    if (!componentId)
-        return;
-    compatComponentIds.add(componentId);
-}
-export function unmarkCompatComponent(componentId) {
-    if (!componentId)
-        return;
-    compatComponentIds.delete(componentId);
-}
-export function isCompatComponent(componentId) {
-    if (!componentId)
-        return false;
-    return compatComponentIds.has(componentId);
-}
-export function __resetCompatComponentRegistryForTests() {
-    compatComponentIds.clear();
-}