@abide/abide 0.32.2 → 0.33.1

package/src/lib/shared/types/CacheEntry.ts

@@ -39,20 +39,20 @@ into `__SSR__`; ones still pending were consumed via `{#await}` (render emitted
 the pending branch without blocking) and stream a resolve chunk instead.
 
 `refreshing` flips true while this entry is reloading data it already held —
-either a policy stale-while-revalidate refetch (value still visible) or the
-default drop-then-reload (the prior entry was invalidated and dropped, this is
-its replacement read). It backs refreshing(), distinguishing a reload from a
+either an `swr` refetch (stale value still visible) or the default
+drop-then-reload (the prior entry was invalidated and dropped, this is its
+replacement read). It backs refreshing(), distinguishing a reload from a
 first-ever load; cleared when the read settles.
 
-`invalidation` holds an `invalidate` throttle/debounce policy: the refetch
-thunk (the call captured with its args) plus the policy and its runtime timer
-state, so invalidate() can rate-limit refetches of this key instead of dropping
-the entry and refetching on every invalidation. Set at registration when the
-creating read declared a policy, or attached by a later read declaring one on
-an entry that lacks it (hydrated snapshot entries always start without one) —
-first policy wins. An armed `timer` is cleared if the entry is evicted, so a
-dead key never refetches. Wrap-time validation guarantees a policy never
-coexists with ttl: 0 and never sits on a non-replayable remote method.
+`invalidation` holds the entry's `swr` policy: the refetch thunk (the call
+captured with its args) plus its optional throttle/debounce window and runtime
+timer state, so invalidate() keeps the stale value and revalidates this key —
+rate-limited by the window — instead of dropping the entry. Set at registration
+when the creating read declared `swr`, or attached by a later read declaring it
+on an entry that lacks it (hydrated snapshot entries always start without one) —
+first wins. An armed `timer` is cleared if the entry is evicted, so a dead key
+never refetches. Wrap-time validation guarantees `swr` never coexists with
+ttl: 0 and never sits on a non-replayable remote method.
 */
 export type CacheEntry = {
     key: string

package/src/lib/shared/types/CacheOptions.ts

@@ -18,22 +18,26 @@ for per-request data: the default keeps a per-user response from leaking across
 requests. Write only `global: true`; there is no `false` form. On the client
 there is a single tab store, so the flag is a no-op there.
 
-`invalidate` controls how a `cache.invalidate` hit on this key is applied, in ms.
-`{ throttle: N }` refetches on the leading edge then at most once per N ms while
-invalidations keep arriving; `{ debounce: N }` refetches only after N ms of
-quiet. Both coalesce a burst of invalidations (e.g. a socket spraying
-`cache.invalidate`) into far fewer calls and keep serving the existing (stale)
-value until the refetch resolves — stale-while-revalidate. They affect only the
-refetch-after-invalidate; the first fetch and arg-change fetches stay immediate.
-A policy declares the call safe to re-run unprompted: cache() throws at wrap
-time on both set at once, on ttl: 0 (nothing retained, nothing to revalidate),
-and on a non-replayable remote method (replaying a write is a state change
-disguised as a refresh). Producers are uncheckable — declare a policy only on
-a producer that is a pure read.
+`swr` is stale-while-revalidate: it changes what a `cache.invalidate` hit does
+to this key. Without it, an invalidate drops the entry and the next read shows
+`pending()`. With it, the entry is kept and refetched in the background — the
+existing (stale) value stays visible and `refreshing()` reports the in-flight
+reload — so the reader never blanks. It governs only the refetch-after-invalidate;
+the first fetch and arg-change fetches stay immediate regardless.
+
+`swr: true` refetches immediately on every invalidate. An optional window
+coalesces a burst (e.g. a socket spraying `cache.invalidate`) into far fewer
+calls: `swr: { throttle: N }` refetches on the leading edge then at most once
+per N ms while invalidations keep arriving; `swr: { debounce: N }` refetches
+only after N ms of quiet. `swr` declares the call safe to re-run unprompted:
+cache() throws at wrap time on throttle+debounce set at once, on ttl: 0 (nothing
+retained, nothing to revalidate), and on a non-replayable remote method
+(replaying a write is a state change disguised as a refresh). Producers are
+uncheckable — set `swr` only on a producer that is a pure read.
 */
 export type CacheOptions = {
     ttl?: number
     scope?: string | string[]
     global?: boolean
-    invalidate?: { throttle?: number; debounce?: number }
+    swr?: boolean | { throttle?: number; debounce?: number }
 }

package/src/lib/ui/README.md

@@ -70,7 +70,7 @@ write-path microbench this runs ~20× faster than a deep-proxy signal baseline.
 ```
 .abide → analyzeComponent (split script/style/template, desugar signals → doc,
                            lower data access, scope CSS)
-       → generateBuild  (client: openChild/appendText/attr/on/each/when/…)
+       → generateBuild  (client: skeleton/cloneStatic/appendText/attr/on/each/when/…)
        → generateSSR    (server: HTML-string back-end, await markers)
        → hoistCells     (static paths → cells)
        → compileModule  (ES module: default mount + render() for SSR)

package/src/lib/ui/compile/UI_RUNTIME_IMPORTS.ts

@@ -14,11 +14,13 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string }[] = [
     { name: 'derived', specifier: 'ui/derived' },
     { name: 'effect', specifier: 'ui/effect' },
     { name: 'mount', specifier: 'ui/dom/mount' },
-    { name: 'openChild', specifier: 'ui/dom/openChild' },
     { name: 'appendText', specifier: 'ui/dom/appendText' },
+    { name: 'appendTextAt', specifier: 'ui/dom/appendTextAt' },
     { name: 'appendSnippet', specifier: 'ui/dom/appendSnippet' },
     { name: 'appendStatic', specifier: 'ui/dom/appendStatic' },
     { name: 'cloneStatic', specifier: 'ui/dom/cloneStatic' },
+    { name: 'skeleton', specifier: 'ui/dom/skeleton' },
+    { name: 'anchorCursor', specifier: 'ui/dom/anchorCursor' },
     { name: 'attr', specifier: 'ui/dom/attr' },
     { name: 'on', specifier: 'ui/dom/on' },
     { name: 'attach', specifier: 'ui/dom/attach' },
@@ -28,6 +30,7 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string }[] = [
     { name: 'awaitBlock', specifier: 'ui/dom/awaitBlock' },
     { name: 'tryBlock', specifier: 'ui/dom/tryBlock' },
     { name: 'switchBlock', specifier: 'ui/dom/switchBlock' },
+    { name: 'mountSlot', specifier: 'ui/dom/mountSlot' },
     { name: 'mountChild', specifier: 'ui/dom/mountChild' },
     { name: 'hydrate', specifier: 'ui/dom/hydrate' },
     { name: 'nextBlockId', specifier: 'ui/runtime/nextBlockId' },

package/src/lib/ui/compile/componentWrapperTag.ts

@@ -6,7 +6,7 @@ lowercased — readable in devtools, a real box like any abide wrapper. But a na
 that lowercases to a real HTML element (`Button`→`button`, `Input`→`input`) yields a
 wrapper with a content model the parser enforces: void elements self-close, and
 `<button>`/`<a>`/table/list/select families reject or foster the component's own
-markup as the wrapper's siblings — so on hydration `openChild` finds the wrapper
+markup as the wrapper's siblings — so on hydration the skeleton locates the wrapper
 empty, claims `null`, and `attr` throws on it. Those names map to a hyphenated
 custom-element tag (a custom element is never void and has no content model) made
 layout-transparent with `display:contents`, so the component's real root still lays