@rebask/core 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luis Alvarez D
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,19 @@
-# Temporary Holding Version
+# rebask
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Vite plugin and runtime for React Server Components apps. It adds file-based routing, streaming HTML,
+Partial Pre-Rendering (PPR), Server Functions, and soft navigations.
+
+[Documentation](https://rebask.com/docs) · [Cheatsheet](https://rebask.com/cheatsheet)
+
+## Getting started
+
+```bash
+# npm
+npm create rebask-app@latest
+
+# pnpm
+pnpm create rebask-app
+
+# bun
+bunx create-rebask-app
+```

package/dist/adapter-utils.d.ts

@@ -0,0 +1,21 @@
+export { copyBuildPaths, getBuildPaths } from "./lib/build-paths.js";
+export { STATIC } from "./lib/cache-storage.js";
+export { getPluginApi } from "./lib/plugin-utils.js";
+export { compareRouteSegments } from "./lib/route-specificity.js";
+/**
+ * Runs when a page or layout RSC payload was rendered and is cacheable, so an adapter can cache it.
+ * `url` is where the client fetches that payload, and `options` are the ones the adapter registered
+ * its hooks module with.
+ */
+export type OnCacheableRsc<Options = unknown> = (info: {
+    url: URL;
+}, options: Options) => void;
+/**
+ * Runs after an HTML resume finished streaming, unless it is marked as not needing an upgrade, so
+ * an adapter can schedule that upgrade. `url` is the page the resume belongs to, and `options` are
+ * the ones the adapter registered its hooks module with.
+ */
+export type OnHtmlResume<Options = unknown> = (info: {
+    url: URL;
+}, options: Options) => void;
+//# sourceMappingURL=adapter-utils.d.ts.map

package/dist/adapter-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-utils.d.ts","sourceRoot":"","sources":["../src/adapter-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAEjE;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,OAAO,GAAG,OAAO,IAAI,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,GAAG,CAAA;CAAE,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;AAE9F;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,OAAO,GAAG,OAAO,IAAI,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,GAAG,CAAA;CAAE,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA"}

package/dist/adapter-utils.js

@@ -0,0 +1,4 @@
+export { copyBuildPaths, getBuildPaths } from "./lib/build-paths.js";
+export { STATIC } from "./lib/cache-storage.js";
+export { getPluginApi } from "./lib/plugin-utils.js";
+export { compareRouteSegments } from "./lib/route-specificity.js";

package/dist/cache-handler.d.ts

@@ -0,0 +1,2 @@
+export { cacheHandler } from "virtual:rebask/cache-handler";
+//# sourceMappingURL=cache-handler.d.ts.map

package/dist/cache-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-handler.d.ts","sourceRoot":"","sources":["../src/cache-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/cache-handler.js

@@ -0,0 +1 @@
+export { cacheHandler } from "virtual:rebask/cache-handler";

package/dist/cache.client.d.ts

@@ -0,0 +1,5 @@
+export declare function cacheLife(): void;
+export declare function cacheTag(): void;
+export declare function revalidateTag(): Promise<void>;
+export declare function durableCache(): void;
+//# sourceMappingURL=cache.client.d.ts.map

package/dist/cache.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.client.d.ts","sourceRoot":"","sources":["../src/cache.client.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS,SAExB;AAED,wBAAgB,QAAQ,SAEvB;AAED,wBAAsB,aAAa,kBAElC;AAED,wBAAgB,YAAY,SAE3B"}

package/dist/cache.client.js

@@ -0,0 +1,13 @@
+import { ServerOnlyApiError } from "./lib/errors.js";
+export function cacheLife() {
+    throw new ServerOnlyApiError("cacheLife");
+}
+export function cacheTag() {
+    throw new ServerOnlyApiError("cacheTag");
+}
+export async function revalidateTag() {
+    throw new ServerOnlyApiError("revalidateTag");
+}
+export function durableCache() {
+    throw new ServerOnlyApiError("durableCache");
+}

package/dist/cache.d.ts

@@ -0,0 +1,60 @@
+export type { CacheLife } from "./lib/cache-context.js";
+export { BaseCacheStorage, type CacheEntry, type CacheEntryStatus, CacheEntryType, type CacheStorage, } from "./lib/cache-storage.js";
+export { durableCache } from "./lib/durable-cache.js";
+export { FilesystemCacheStorage } from "./lib/file-system-cache.js";
+export { type LRUCacheOptions, withLRU } from "./lib/lru-cache.js";
+export { isPageCacheKey } from "./lib/cache-keys.js";
+/**
+ * Configure the cache lifetime for the current scope.
+ *
+ * Can be called inside a "use cache" function to control function-level caching,
+ * or directly in a server component to control page-level HTML/RSC caching.
+ *
+ * Aggregation rules:
+ * - revalidate and expire: minimum wins (most restrictive value across all calls)
+ * - tags: merged (union of all tags)
+ *
+ * @example
+ * ```tsx
+ * // Page-level: controls HTML and RSC segment cache
+ * export default async function ProductsPage() {
+ *   cacheLife({ revalidate: 300, expire: 3600 })
+ *   return <ProductList />
+ * }
+ *
+ * // Function-level: controls individual data cache
+ * async function getData() {
+ *   'use cache'
+ *   cacheLife({ revalidate: 300, expire: 3600 })
+ *   return fetch('/api/data')
+ * }
+ * ```
+ */
+export declare function cacheLife(config: {
+    revalidate: number;
+    expire?: number;
+} | {
+    revalidate: number;
+}): void;
+/**
+ * Add cache tags for on-demand revalidation.
+ *
+ * Can be called inside a "use cache" function or directly in a server component.
+ */
+export declare function cacheTag(...tags: string[]): void;
+/**
+ * Invalidate all cache entries associated with the given tag.
+ *
+ * After calling this, subsequent requests will treat entries tagged with
+ * this tag as stale, causing them to be regenerated.
+ *
+ * @example
+ * ```ts
+ * import { revalidateTag } from "@rebask/core/cache"
+ *
+ * // Invalidate all entries tagged with "products"
+ * await revalidateTag("products")
+ * ```
+ */
+export declare function revalidateTag(tag: string): Promise<void>;
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAKA,YAAY,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EACN,gBAAgB,EAChB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,cAAc,EACd,KAAK,YAAY,GACjB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAA;AACnE,OAAO,EAAE,KAAK,eAAe,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,SAAS,CACxB,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,QAQxE;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,QASzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,iBAG9C"}

package/dist/cache.js

@@ -0,0 +1,72 @@
+import { insideUseCache, setCacheLife } from "./lib/cache-context.js";
+import { getCacheHandler } from "./lib/config.js";
+import { revalidateTagChannel } from "./lib/devtools-channels.js";
+import { insideRequestHandling } from "./request-context.js";
+export { BaseCacheStorage, CacheEntryType, } from "./lib/cache-storage.js";
+export { durableCache } from "./lib/durable-cache.js";
+export { FilesystemCacheStorage } from "./lib/file-system-cache.js";
+export { withLRU } from "./lib/lru-cache.js";
+export { isPageCacheKey } from "./lib/cache-keys.js";
+/**
+ * Configure the cache lifetime for the current scope.
+ *
+ * Can be called inside a "use cache" function to control function-level caching,
+ * or directly in a server component to control page-level HTML/RSC caching.
+ *
+ * Aggregation rules:
+ * - revalidate and expire: minimum wins (most restrictive value across all calls)
+ * - tags: merged (union of all tags)
+ *
+ * @example
+ * ```tsx
+ * // Page-level: controls HTML and RSC segment cache
+ * export default async function ProductsPage() {
+ *   cacheLife({ revalidate: 300, expire: 3600 })
+ *   return <ProductList />
+ * }
+ *
+ * // Function-level: controls individual data cache
+ * async function getData() {
+ *   'use cache'
+ *   cacheLife({ revalidate: 300, expire: 3600 })
+ *   return fetch('/api/data')
+ * }
+ * ```
+ */
+export function cacheLife(config) {
+    if (!insideUseCache() && !insideRequestHandling()) {
+        throw new Error('`cacheLife()` can only be called inside a server component or a "use cache" function.');
+    }
+    setCacheLife(config);
+}
+/**
+ * Add cache tags for on-demand revalidation.
+ *
+ * Can be called inside a "use cache" function or directly in a server component.
+ */
+export function cacheTag(...tags) {
+    if (!insideUseCache() && !insideRequestHandling()) {
+        throw new Error('`cacheTag()` can only be called inside a server component or a "use cache" function.');
+    }
+    if (tags.length === 0)
+        return;
+    setCacheLife({ tags: new Set(tags) });
+}
+/**
+ * Invalidate all cache entries associated with the given tag.
+ *
+ * After calling this, subsequent requests will treat entries tagged with
+ * this tag as stale, causing them to be regenerated.
+ *
+ * @example
+ * ```ts
+ * import { revalidateTag } from "@rebask/core/cache"
+ *
+ * // Invalidate all entries tagged with "products"
+ * await revalidateTag("products")
+ * ```
+ */
+export async function revalidateTag(tag) {
+    revalidateTagChannel.publish({ tag });
+    await getCacheHandler().revalidateTag(tag);
+}

package/dist/components/app-root.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+import type { RouterCache } from "../lib/router-cache.js";
+/** Shared document root for SSR and client hydration. */
+export declare function AppRoot({ cache, trailing, }: {
+    cache: RouterCache;
+    /** SSR-only sibling after the app tree (must not sit above CacheSlot). */
+    trailing?: ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=app-root.d.ts.map

package/dist/components/app-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-root.d.ts","sourceRoot":"","sources":["../../src/components/app-root.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAc,MAAM,OAAO,CAAA;AAElD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAOzD,yDAAyD;AACzD,wBAAgB,OAAO,CAAC,EACvB,KAAK,EACL,QAAQ,GACR,EAAE;IACF,KAAK,EAAE,WAAW,CAAA;IAClB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,SAAS,CAAA;CACpB,+BAcA"}

package/dist/components/app-root.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { StrictMode } from "react";
+import { HMR } from "../lib/hmr.js";
+import { ScrollHandler } from "../lib/scroll.js";
+import { ObserveNavigations } from "../observe-navigations.js";
+import { CacheSlot, RouterCacheProvider } from "./cache-slot.js";
+import { ErrorBoundary } from "./error-boundary.js";
+import { DefaultError } from "./error-pages.js";
+/** Shared document root for SSR and client hydration. */
+export function AppRoot({ cache, trailing, }) {
+    return (_jsx(StrictMode, { children: _jsxs(RouterCacheProvider, { value: cache, children: [_jsx(HMR, {}), _jsx(ObserveNavigations, {}), _jsx(ScrollHandler, {}), _jsx(ErrorBoundary, { root: true, fallback: _jsx(DefaultError, {}), children: _jsx(CacheSlot, { cache: cache }) }), trailing] }) }));
+}

package/dist/components/cache-hints-marker.d.ts

@@ -0,0 +1,15 @@
+import type { CacheHintsProps } from "./cache-hints.js";
+/**
+ * Client-side marker rendered by the server `<CacheHints>` component. Plays
+ * two roles:
+ *
+ * 1. Its props are serialized into the RSC payload, so the prefetch walker
+ *    can find it (identity check on `elementType === CacheHintsMarker`) and
+ *    register hints before the segment is rendered.
+ * 2. After hydration, its `useEffect` calls `router.setCacheHints()` so
+ *    initial-page renders (which never go through prefetch) also register
+ *    hints. The router uses the surrounding `<SegmentBoundary>` to target
+ *    the right segment.
+ */
+export declare function CacheHintsMarker({ stale, tags, mustRevalidate }: CacheHintsProps): null;
+//# sourceMappingURL=cache-hints-marker.d.ts.map

package/dist/components/cache-hints-marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-hints-marker.d.ts","sourceRoot":"","sources":["../../src/components/cache-hints-marker.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,eAAe,QAwBhF"}

package/dist/components/cache-hints-marker.js

@@ -0,0 +1,38 @@
+"use client";
+import { useEffect } from "react";
+import { useRouter } from "../router.js";
+/**
+ * Client-side marker rendered by the server `<CacheHints>` component. Plays
+ * two roles:
+ *
+ * 1. Its props are serialized into the RSC payload, so the prefetch walker
+ *    can find it (identity check on `elementType === CacheHintsMarker`) and
+ *    register hints before the segment is rendered.
+ * 2. After hydration, its `useEffect` calls `router.setCacheHints()` so
+ *    initial-page renders (which never go through prefetch) also register
+ *    hints. The router uses the surrounding `<SegmentBoundary>` to target
+ *    the right segment.
+ */
+export function CacheHintsMarker({ stale, tags, mustRevalidate }) {
+    const router = useRouter();
+    useEffect(() => {
+        let cancelled = false;
+        Promise.all([
+            Promise.resolve(stale),
+            Promise.resolve(tags),
+            Promise.resolve(mustRevalidate),
+        ]).then(([resolvedStale, resolvedTags, resolvedMustRevalidate]) => {
+            if (!cancelled) {
+                router.setCacheHints({
+                    stale: resolvedStale,
+                    tags: resolvedTags,
+                    mustRevalidate: resolvedMustRevalidate,
+                });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [router, stale, tags, mustRevalidate]);
+    return null;
+}

package/dist/components/cache-hints.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Resolved cache hints stored on a cached segment and accepted by the
+ * imperative `useRouter().setCacheHints()` API.
+ */
+export interface ResolvedCacheHints {
+    stale?: number;
+    tags?: string[];
+    mustRevalidate?: boolean;
+}
+export interface CacheHintsProps {
+    /**
+     * How long, in seconds, the client router should treat this segment's cached content as
+     * fresh, defaults to "fresh forever".
+     *
+     * After `stale` seconds, the next navigation to this route revalidates the segment in the
+     * background while serving the cached version (stale-while-revalidate).
+     *
+     * Values below `2` are clamped to `2`. The floor absorbs the latency between a hover stale check
+     * and the click that follows, so a single user interaction doesn't double-fetch the segment.
+     */
+    stale?: number | PromiseLike<number>;
+    /**
+     * Client-side cache tags for this segment. These are independent from any server-side cache tags
+     * as they only affect the client router.
+     *
+     * If multiple `<CacheHints>` write tags onto the same segment, the last write replaces the
+     * previous one, tags are not merged.
+     */
+    tags?: string[] | PromiseLike<string[]>;
+    /**
+     * Opt out of stale-while-revalidate for this segment. When set, the suspending placeholder is
+     * written immediately and the nearest `<Suspense>` fallback shows while the new payload is in
+     * flight. Use it for segments whose stale data is unsafe to display.
+     */
+    mustRevalidate?: boolean | PromiseLike<boolean>;
+}
+/**
+ * Declares cache hints for the route segment (page, layout, or not-found)
+ * that renders it. Use it to tell the client router how long it can keep
+ * serving a segment's cached RSC payload before revalidating.
+ *
+ * Must be rendered from a server component.
+ *
+ * @example
+ * ```tsx
+ * export default async function ProductsPage() {
+ *   const data = await getProducts()
+ *   return (
+ *     <>
+ *       <CacheHints stale={data.isDraft ? 0 : 300} />
+ *       <ProductList items={data.items} />
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+export declare function CacheHints(props: CacheHintsProps): import("react").JSX.Element;
+//# sourceMappingURL=cache-hints.d.ts.map

package/dist/components/cache-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-hints.d.ts","sourceRoot":"","sources":["../../src/components/cache-hints.tsx"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,cAAc,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,MAAM,WAAW,eAAe;IAC/B;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAA;IACpC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,CAAA;IACvC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAA;CAC/C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,+BAOhD"}

package/dist/components/cache-hints.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CacheHintsMarker } from "./cache-hints-marker.js";
+/**
+ * Declares cache hints for the route segment (page, layout, or not-found)
+ * that renders it. Use it to tell the client router how long it can keep
+ * serving a segment's cached RSC payload before revalidating.
+ *
+ * Must be rendered from a server component.
+ *
+ * @example
+ * ```tsx
+ * export default async function ProductsPage() {
+ *   const data = await getProducts()
+ *   return (
+ *     <>
+ *       <CacheHints stale={data.isDraft ? 0 : 300} />
+ *       <ProductList items={data.items} />
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+export function CacheHints(props) {
+    if (typeof window !== "undefined") {
+        throw new Error("<CacheHints> can only be used inside a server component.");
+    }
+    return (_jsx(CacheHintsMarker, { stale: props.stale, tags: props.tags, mustRevalidate: props.mustRevalidate }));
+}

package/dist/components/cache-slot.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import type { RouterCache } from "../lib/router-cache.js";
+export declare function RouterCacheProvider({ value, children, }: {
+    value: RouterCache;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useRouterCache(): RouterCache;
+export declare function CacheSlot(props: {
+    cache: RouterCache;
+}): ReactNode;
+export declare function CacheSlot(props: {
+    slotKey: string;
+}): ReactNode;
+//# sourceMappingURL=cache-slot.d.ts.map

package/dist/components/cache-slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-slot.d.ts","sourceRoot":"","sources":["../../src/components/cache-slot.tsx"],"names":[],"mappings":"AAGA,OAAO,EAGN,KAAK,SAAS,EAMd,MAAM,OAAO,CAAA;AACd,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAmBzD,wBAAgB,mBAAmB,CAAC,EACnC,KAAK,EACL,QAAQ,GACR,EAAE;IACF,KAAK,EAAE,WAAW,CAAA;IAClB,QAAQ,EAAE,SAAS,CAAA;CACnB,+BAEA;AAED,wBAAgB,cAAc,gBAI7B;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,WAAW,CAAA;CAAE,GAAG,SAAS,CAAA;AACnE,wBAAgB,SAAS,CAAC,KAAK,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAA"}

package/dist/components/cache-slot.js

@@ -0,0 +1,42 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Activity, createContext, startTransition, useContext, useEffect, useState, useSyncExternalStore, } from "react";
+import { SegmentBoundary } from "./segment-boundary.js";
+// We duplicate the `useAtom` hook to use `atom.get` as the third parameter
+// of `useSyncExternalStore` instead of `atom.getInitial`. Without that we can't
+// update the atom value on the server side when doing SSR.
+function useAtom(atom) {
+    const value = useSyncExternalStore(atom.sub, atom.get, atom.get);
+    return [value, atom.set];
+}
+const RouterCacheContext = createContext(null);
+export function RouterCacheProvider({ value, children, }) {
+    return _jsx(RouterCacheContext.Provider, { value: value, children: children });
+}
+export function useRouterCache() {
+    const cache = useContext(RouterCacheContext);
+    if (!cache)
+        throw new Error("useRouterCache must be used within a RouterCacheProvider");
+    return cache;
+}
+export function CacheSlot({ cache: cacheProp, slotKey = "" }) {
+    const cacheFromContext = useRouterCache();
+    const cache = cacheProp || cacheFromContext;
+    const cacheNode = cache.getNodeFromSlotKey(slotKey);
+    const [slots] = useAtom(cacheNode.slots);
+    if (slots.length === 0)
+        return null;
+    return slots.map((slotAtom) => (_jsx(SlotContent, { slotAtom: slotAtom }, cache.getSlotReactKey(slotAtom))));
+}
+function SlotContent({ slotAtom }) {
+    const [slot] = useAtom(slotAtom);
+    const [content, setContent] = useState(slot.content);
+    if (!slot.retainContent && content !== slot.content)
+        setContent(slot.content);
+    useEffect(() => {
+        // Keep the current content visible if the replacement suspends above its own Suspense boundaries.
+        if (slot.retainContent)
+            startTransition(() => setContent(slot.content));
+    }, [slot.content, slot.retainContent]);
+    return (_jsx(Activity, { mode: slot.active ? "visible" : "hidden", children: _jsx(SegmentBoundary, { path: slot.key, children: content }) }));
+}

package/dist/components/delay.d.ts

@@ -0,0 +1,4 @@
+export declare function Delay({ promise }: {
+    promise: Promise<any>;
+}): import("react").JSX.Element;
+//# sourceMappingURL=delay.d.ts.map

package/dist/components/delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../src/components/delay.tsx"],"names":[],"mappings":"AAOA,wBAAgB,KAAK,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;CAAE,+BAM3D"}

package/dist/components/delay.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, use } from "react";
+function DelayContent({ promise }) {
+    use(promise);
+    return null;
+}
+export function Delay({ promise }) {
+    return (_jsx(Suspense, { children: _jsx(DelayContent, { promise: promise }) }));
+}

package/dist/components/dev-overlay.d.ts

@@ -0,0 +1,2 @@
+export declare function DevOverlay(): import("react").JSX.Element | null;
+//# sourceMappingURL=dev-overlay.d.ts.map

package/dist/components/dev-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-overlay.d.ts","sourceRoot":"","sources":["../../src/components/dev-overlay.tsx"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,uCAgGzB"}

package/dist/components/dev-overlay.js

@@ -0,0 +1,79 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { reportDevtoolsError, showViteErrorOverlay } from "../lib/vite-error-overlay.js";
+export function DevOverlay() {
+    const [warning, setWarning] = useState(null);
+    useEffect(() => {
+        const onWindowError = (event) => {
+            if (event.error) {
+                reportDevtoolsError(event.error);
+                showViteErrorOverlay(event.error);
+            }
+        };
+        const onUnhandledRejection = (event) => {
+            reportDevtoolsError(event.reason);
+        };
+        const removeWindowListeners = () => {
+            window.removeEventListener("error", onWindowError);
+            window.removeEventListener("unhandledrejection", onUnhandledRejection);
+        };
+        window.addEventListener("error", onWindowError);
+        window.addEventListener("unhandledrejection", onUnhandledRejection);
+        if (!import.meta.hot)
+            return removeWindowListeners;
+        const onWarning = (data) => {
+            setWarning(data.message);
+        };
+        const onDevError = (data) => {
+            const error = new Error(data.message);
+            if (data.guidance) {
+                error.stack = [data.stack, `[rebask] ${data.guidance}`].filter(Boolean).join("\n\n");
+            }
+            else if (data.stack) {
+                error.stack = data.stack;
+            }
+            console.error(error);
+            showViteErrorOverlay(error);
+        };
+        // Rebask DevTools lists warnings in its messages, so the warning button is only a fallback.
+        if (!__REBASK_DEVTOOLS)
+            import.meta.hot.on("rebask:warning", onWarning);
+        // Listen for dev error updates
+        import.meta.hot.on("rebask:error", onDevError);
+        // Signal to server that we're ready to receive warnings
+        import.meta.hot.send("rebask:overlay-ready", {});
+        return () => {
+            removeWindowListeners();
+            import.meta.hot?.off("rebask:warning", onWarning);
+            import.meta.hot?.off("rebask:error", onDevError);
+        };
+    }, []);
+    if (!warning)
+        return null;
+    const styles = `
+		.rebask-warning-btn {
+			position: fixed;
+			bottom: 20px;
+			right: 20px;
+			z-index: 999999;
+			width: 48px;
+			height: 48px;
+			border-radius: 50%;
+			border: none;
+			background: #ff5555;
+			color: white;
+			font-size: 20px;
+			cursor: pointer;
+			pointer-events: auto;
+			box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+			transition: transform 0.2s, box-shadow 0.2s;
+		}
+		.rebask-warning-btn:hover {
+			transform: scale(1.1);
+			box-shadow: 0 6px 16px rgba(0,0,0,0.4);
+		}
+	`;
+    return (_jsxs(_Fragment, { children: [_jsx("style", { children: styles }), _jsx("button", { "data-testid": "rebask-dev-overlay", type: "button", className: "rebask-warning-btn", onClick: () => {
+                    showViteErrorOverlay(warning);
+                }, title: "Rebask Development Warning (click for details)", children: "!" })] }));
+}

package/dist/components/error-boundary-client.d.ts

@@ -0,0 +1,49 @@
+import { Component, type ReactNode } from "react";
+import type { RevisionSnapshot, RouterCache } from "../lib/router-cache.js";
+type BoundaryRenderProps = {
+    children: ReactNode;
+    fallback: ReactNode;
+    hasError?: boolean;
+};
+export type BoundaryClientProps = BoundaryRenderProps & {
+    boundaryKey: string;
+};
+type BoundaryCacheState = {
+    boundaryKey: string;
+    segmentPath: string;
+    snapshot: RevisionSnapshot;
+    failed: boolean;
+};
+type ErrorBoundaryClientInnerProps = BoundaryRenderProps & BoundaryCacheState;
+type BoundaryCacheStateResult = BoundaryCacheState & {
+    acceptsServerError: boolean;
+};
+type ErrorBoundaryClientState = {
+    hasError: boolean;
+    snapshot: RevisionSnapshot;
+};
+export declare class ErrorBoundaryClientInner extends Component<ErrorBoundaryClientInnerProps, ErrorBoundaryClientState> {
+    static contextType: import("react").Context<RouterCache | null>;
+    context: RouterCache | null;
+    state: ErrorBoundaryClientState;
+    constructor(props: ErrorBoundaryClientInnerProps);
+    static getDerivedStateFromProps(props: ErrorBoundaryClientInnerProps, state: ErrorBoundaryClientState): {
+        hasError: boolean;
+        snapshot: RevisionSnapshot;
+    } | {
+        snapshot?: undefined;
+        hasError: boolean;
+    } | null;
+    static getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(_prevProps: ErrorBoundaryClientInnerProps, prevState: ErrorBoundaryClientState): void;
+    componentDidCatch(error: Error): void;
+    render(): ReactNode;
+    protected recordFailure(): void;
+}
+export declare function ErrorBoundaryClient(props: BoundaryClientProps): import("react").JSX.Element;
+export declare function useBoundaryCacheState(boundaryKey: string): BoundaryCacheStateResult;
+export {};
+//# sourceMappingURL=error-boundary-client.d.ts.map