@abide/abide 0.47.0 → 0.49.0

package/src/lib/ui/runtime/withoutHydration.ts

@@ -0,0 +1,22 @@
+import { RENDER } from './RENDER.ts'
+
+/*
+Runs `build` with the hydration claim cursor cleared, restoring it after. The
+control-flow blocks route FRESH builds through here — a pending/resolved await
+branch, a try's catch branch, a fillBefore insert — so their build helpers
+create nodes instead of trying to claim server DOM that isn't there. A rebuild
+that fires while an outer hydrate pass is still active (e.g. a synchronous write
+that flips a `when`/`switch` mid-hydrate) would otherwise make `cloneStatic` /
+text claim discarded or nonexistent nodes and silently render nothing. The
+`finally` restore lets a fresh build sit inside an ongoing hydrate pass without
+ending it early.
+*/
+export function withoutHydration<T>(build: () => T): T {
+    const previous = RENDER.hydration
+    RENDER.hydration = undefined
+    try {
+        return build()
+    } finally {
+        RENDER.hydration = previous
+    }
+}

package/src/lib/ui/startClient.ts

@@ -1,7 +1,7 @@
 import { cacheStoreSlot } from '../shared/cacheStoreSlot.ts'
 import { createCacheStore } from '../shared/createCacheStore.ts'
-import { globalCacheStoreSlot } from '../shared/globalCacheStoreSlot.ts'
 import { pageSlot } from '../shared/pageSlot.ts'
+import { sharedCacheStoreSlot } from '../shared/sharedCacheStoreSlot.ts'
 import type { SsrPayload } from '../shared/types/SsrPayload.ts'
 import type { StreamedResolution } from '../shared/types/StreamedResolution.ts'
 import { probeNavigation } from './probeNavigation.ts'
@@ -68,8 +68,8 @@ export function startClient(
 
     const store = createCacheStore()
     cacheStoreSlot.resolver = () => store
-    /* One tab store: cache(fn, { global: true }) shares it, so global is a no-op here. */
-    globalCacheStoreSlot.resolver = () => store
+    /* One tab store: cache(fn, { shared: true }) shares it, so shared is a no-op here. */
+    sharedCacheStoreSlot.resolver = () => store
     /* Seed both SSR cache partitions through the one streamed-resolution sink: `ssr.cache`
        (inline — reads settled at render-return, in __SSR__) and `__abideResumeCache` (pending
        {#await} reads whose `__abideResolve(...)` chunks the stream pushed during parse, before

package/src/lib/ui/state.ts

@@ -14,11 +14,17 @@ import { scope } from './scope.ts'
    reached ambiently so a component can pass a named value down its subtree. */
 type StateFn = {
     /* No-arg form for an undefined initial with a declared type: `state<Foo>()` is
-       `State<Foo | undefined>`. Without it `state<Foo>(undefined)` is an arity/assign
-       error and `state(undefined)` infers `T = undefined` (every `.value` access then
-       narrows to `never`). */
+       `State<Foo | undefined>`. Without it `state(undefined)` infers `T = undefined`
+       (every `.value` access then narrows to `never`). */
     <T>(): State<T | undefined>
     <T>(initial: T, transform?: (next: T, previous: T) => T): State<T>
+    /* The no-arg form spelled out: `state<Foo>(undefined)` is `State<Foo | undefined>`
+       too. Kept a distinct overload (not `initial?: T`) BELOW the general form — a real
+       initial still binds `T` from the value; only an explicit `undefined` (which the
+       general form rejects as "not assignable to T") falls through to here. A bare
+       `state(undefined)` still resolves against the general form (`T = undefined`), so
+       this overload changes nothing for it. */
+    <T>(initial: undefined): State<T | undefined>
     /* A writable cell reseeded from a reactive thunk (`state.linked(() => src())`). */
     linked: typeof linked
     /* A read-only cell computed from other cells (`state.computed(() => a() + b())`). */

package/src/serverEntry.ts

@@ -31,10 +31,10 @@ import { requestContext } from './lib/server/runtime/requestContext.ts'
 import { resolvePageSnapshot } from './lib/server/runtime/resolvePageSnapshot.ts'
 import { cacheStoreSlot } from './lib/shared/cacheStoreSlot.ts'
 import { createCacheStore } from './lib/shared/createCacheStore.ts'
-import { globalCacheStoreSlot } from './lib/shared/globalCacheStoreSlot.ts'
 import { loadEnvFromDataDir } from './lib/shared/loadEnvFromDataDir.ts'
 import { pageSlot } from './lib/shared/pageSlot.ts'
 import { runningAsStandaloneBinary } from './lib/shared/runningAsStandaloneBinary.ts'
+import { sharedCacheStoreSlot } from './lib/shared/sharedCacheStoreSlot.ts'
 
 /*
 Resolve config into process.env before anything reads it (createServer reads
@@ -65,16 +65,18 @@ await import('./_virtual/config.ts')
 // In a bundle, tie this server's life to the launcher's (no-op standalone).
 exitWithParent()
 
-cacheStoreSlot.resolver = () => requestContext.getStore()?.cache
-
-pageSlot.resolver = resolvePageSnapshot
-
 /*
-Process-level store for cache(fn, { global: true }) — one per server process,
-outlives every request so memoised external calls are shared across them.
+Process-level ("shared") store for cache(fn, { shared: true }) — one per server
+process, outlives every request so memoised external calls are shared across them.
+It is also the store a read with no request in flight resolves to, so boot/cron/
+socket-handler reads coalesce into a real store instead of an orphan fallback.
 */
-const globalCacheStore = createCacheStore()
-globalCacheStoreSlot.resolver = () => globalCacheStore
+const sharedCacheStore = createCacheStore()
+sharedCacheStoreSlot.resolver = () => sharedCacheStore
+
+cacheStoreSlot.resolver = () => requestContext.getStore()?.cache ?? sharedCacheStore
+
+pageSlot.resolver = resolvePageSnapshot
 
 await createServer({
     pages,

package/src/lib/shared/globalCacheStore.ts

@@ -1,15 +0,0 @@
-import { activeCacheStore } from './activeCacheStore.ts'
-import { globalCacheStoreSlot } from './globalCacheStoreSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/*
-Resolves the process-level CacheStore that `cache(fn, { global: true })` entries
-live in. The server entry registers a module-singleton resolver so the store
-survives across requests; the client points it at the active tab store. When no
-resolver is registered (isolated tests, or a client that never set one) it falls
-back to the active store, so `global` degrades to request/tab-scoped rather than
-throwing.
-*/
-export function globalCacheStore(): CacheStore {
-    return globalCacheStoreSlot.resolver?.() ?? activeCacheStore()
-}

package/src/lib/shared/globalCacheStoreSlot.ts

@@ -1,12 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/*
-Slot for the process-level cache store used by cache() entries opting into
-`global: true`. The server entry registers a module-singleton store outliving
-any one request; the client entry points it at its single tab store so
-`global` is a no-op there. No fallback creator — unset means no global store
-is registered, in which case globalCacheStore() falls back to the active
-(request/tab) store. Test helpers snapshot/poke `.resolver` directly.
-*/
-export const globalCacheStoreSlot = createResolverSlot<CacheStore>()