@rsc-kit/core 0.1.0

package/dist/revalidate.d.ts

@@ -0,0 +1,43 @@
+/** What this needs from a runtime: somewhere to keep per-action state. */
+interface Scope {
+    getStore(): Set<string> | undefined;
+    run<T>(store: Set<string>, fn: () => T): T;
+}
+/**
+ * AsyncLocalStorage, wherever this happens to be running.
+ *
+ * The global first, because that is where a Worker has it — and where the
+ * engine puts it, since @vitejs/plugin-rsc assigns
+ * `globalThis.AsyncLocalStorage` for React's edge build. Then the module,
+ * which is where Node, Bun and Deno have it.
+ *
+ * There is no third branch on purpose. The engine bundle imports
+ * `node:async_hooks` statically, so async context is a requirement of the
+ * whole system rather than of this file: a runtime without it cannot load the
+ * engine at all, and a fallback here would be code that can never run.
+ */
+export declare function resolveScope(from?: Record<string, unknown>): Promise<Scope>;
+/**
+ * Mark a region of the current page for re-rendering.
+ *
+ * `'page'` and `'all'` re-render the page or the whole document; any other
+ * name is a section or a parallel slot. Unknown names are refused by the
+ * renderer with the names it does know, rather than quietly refreshing
+ * nothing.
+ *
+ * Outside an action this does nothing rather than throwing: it is reasonable
+ * for shared code to mark, and unreasonable for that to fail when the same
+ * function is called during an ordinary render.
+ */
+export declare function revalidate(target: string): void;
+/** Whether anything is listening, for a host that wants to warn about the rest. */
+export declare function isRevalidating(): boolean;
+/**
+ * Run an action with somewhere for its marks to go, and collect them.
+ *
+ * The marks are read *after* the action has run, because what it invalidated
+ * is only known once its work is done.
+ */
+export declare function withRevalidation<T>(run: (taken: () => string[]) => Promise<T>): Promise<T>;
+export {};
+//# sourceMappingURL=revalidate.d.ts.map

package/dist/revalidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revalidate.d.ts","sourceRoot":"","sources":["../src/revalidate.ts"],"names":[],"mappings":"AAmBA,0EAA0E;AAC1E,UAAU,KAAK;IACb,QAAQ,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;IACnC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;CAC3C;AAqBD;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAGhC,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAW,GACtC,OAAO,CAAC,KAAK,CAAC,CAQhB;AAOD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,mFAAmF;AACnF,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,MAAM,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GACzC,OAAO,CAAC,CAAC,CAAC,CAcZ"}

package/dist/revalidate.js

@@ -0,0 +1,99 @@
+// Marking part of a page stale from inside a server action.
+//
+// The point is one round trip. An action that changes an order could tell the
+// browser to go and re-fetch something, but then the answer the user is
+// waiting on arrives before the screen is right, and the fix costs another
+// request. Marking instead lets the action's own answer carry the re-rendered
+// region back with it — the client applies it and never knows it asked.
+//
+//   'use server'
+//   export async function addOrder(order) {
+//     await orders.insert(order)
+//     revalidate('orders')       // the section or slot by that name
+//     return { ok: true }
+//   }
+//
+// Scoped to the action that is running, not global, because two requests can
+// be in flight at once and marking is per-request state. In Laravel this is a
+// `scoped()` binding on the container.
+/**
+ * One store, however many copies of this module exist.
+ *
+ * The app's actions are bundled into the server bundle; the host that runs
+ * them is not. So this module is loaded twice, and two scopes mean the action
+ * marks in one and the host reads the other — everything appears to work, the
+ * action's answer simply never carries anything back, and no error is raised
+ * on either side.
+ *
+ * The engine installs its host callable on globalThis for exactly this
+ * reason. This is the same crossing.
+ */
+const SCOPE = Symbol.for('@rsc-kit/core.revalidation-scope');
+const globals = globalThis;
+let ready = null;
+let warned = false;
+/**
+ * AsyncLocalStorage, wherever this happens to be running.
+ *
+ * The global first, because that is where a Worker has it — and where the
+ * engine puts it, since @vitejs/plugin-rsc assigns
+ * `globalThis.AsyncLocalStorage` for React's edge build. Then the module,
+ * which is where Node, Bun and Deno have it.
+ *
+ * There is no third branch on purpose. The engine bundle imports
+ * `node:async_hooks` statically, so async context is a requirement of the
+ * whole system rather than of this file: a runtime without it cannot load the
+ * engine at all, and a fallback here would be code that can never run.
+ */
+export async function resolveScope(
+// Injectable so the branch a Worker takes can be tested from a runtime that
+// would otherwise never reach it.
+from = globals) {
+    const Ambient = from.AsyncLocalStorage;
+    if (Ambient)
+        return new Ambient();
+    const { AsyncLocalStorage } = await import('node:async_hooks');
+    return new AsyncLocalStorage();
+}
+/** The scope, once resolved. Null before the first action runs. */
+function scope() {
+    return globals[SCOPE] ?? null;
+}
+/**
+ * Mark a region of the current page for re-rendering.
+ *
+ * `'page'` and `'all'` re-render the page or the whole document; any other
+ * name is a section or a parallel slot. Unknown names are refused by the
+ * renderer with the names it does know, rather than quietly refreshing
+ * nothing.
+ *
+ * Outside an action this does nothing rather than throwing: it is reasonable
+ * for shared code to mark, and unreasonable for that to fail when the same
+ * function is called during an ordinary render.
+ */
+export function revalidate(target) {
+    scope()?.getStore()?.add(target);
+}
+/** Whether anything is listening, for a host that wants to warn about the rest. */
+export function isRevalidating() {
+    return scope()?.getStore() !== undefined;
+}
+/**
+ * Run an action with somewhere for its marks to go, and collect them.
+ *
+ * The marks are read *after* the action has run, because what it invalidated
+ * is only known once its work is done.
+ */
+export async function withRevalidation(run) {
+    if (!globals[SCOPE]) {
+        // Resolved once and shared, for the same reason the scope itself is: a
+        // second copy of this module must not end up with a second scope.
+        ready ??= resolveScope().then((resolved) => {
+            globals[SCOPE] ??= resolved;
+        });
+        await ready;
+    }
+    const marked = new Set();
+    return await scope().run(marked, () => run(() => [...marked]));
+}
+//# sourceMappingURL=revalidate.js.map

package/dist/revalidate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revalidate.js","sourceRoot":"","sources":["../src/revalidate.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,EAAE;AACF,8EAA8E;AAC9E,wEAAwE;AACxE,2EAA2E;AAC3E,8EAA8E;AAC9E,wEAAwE;AACxE,EAAE;AACF,iBAAiB;AACjB,4CAA4C;AAC5C,iCAAiC;AACjC,qEAAqE;AACrE,0BAA0B;AAC1B,MAAM;AACN,EAAE;AACF,6EAA6E;AAC7E,8EAA8E;AAC9E,uCAAuC;AAQvC;;;;;;;;;;;GAWG;AACH,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAA;AAE5D,MAAM,OAAO,GAAG,UAA8C,CAAA;AAE9D,IAAI,KAAK,GAAyB,IAAI,CAAA;AACtC,IAAI,MAAM,GAAG,KAAK,CAAA;AAElB;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY;AAChC,4EAA4E;AAC5E,kCAAkC;AAClC,IAAI,GAA4B,OAAO;IAEvC,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAkD,CAAA;IAEvE,IAAI,OAAO;QAAE,OAAO,IAAI,OAAO,EAAE,CAAA;IAEjC,MAAM,EAAE,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAA;IAE9D,OAAO,IAAI,iBAAiB,EAAwB,CAAA;AACtD,CAAC;AAED,mEAAmE;AACnE,SAAS,KAAK;IACZ,OAAQ,OAAO,CAAC,KAAK,CAAuB,IAAI,IAAI,CAAA;AACtD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,UAAU,CAAC,MAAc;IACvC,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;AAClC,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,cAAc;IAC5B,OAAO,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,SAAS,CAAA;AAC1C,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,GAA0C;IAE1C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACpB,uEAAuE;QACvE,kEAAkE;QAClE,KAAK,KAAK,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;YACzC,OAAO,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAA;QAC7B,CAAC,CAAC,CAAA;QAEF,MAAM,KAAK,CAAA;IACb,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAA;IAEhC,OAAO,MAAM,KAAK,EAAG,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;AACjE,CAAC"}

package/dist/routes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Augmented by the generated `rsc-routes.d.ts`. Empty here on purpose.
+ *
+ * Declaration merging rather than a generic parameter, because the routes are
+ * a property of the project, not of each call site — threading them through
+ * every component that renders a Link is not a thing anyone would do twice.
+ */
+export interface Register {
+}
+/** The route patterns this app declared: `'/posts/[slug]'`. */
+export type RoutePattern = Register extends {
+    routes: infer R extends string;
+} ? R : string;
+/** Whether anything was registered. `string` means the generator never ran. */
+type Unregistered = string extends RoutePattern ? true : false;
+/**
+ * A pattern with its dynamic segments opened up: `/posts/[slug]` accepts
+ * `/posts/anything`.
+ *
+ * Catch-all and single params both become `${string}`, which for a catch-all
+ * also swallows the slashes — `/docs/[...path]` accepts `/docs/a/b/c`.
+ */
+type Filled<P extends string> = P extends `${infer A}[...${string}]${infer B}` ? `${A}${string}${Filled<B>}` : P extends `${infer A}[${string}]${infer B}` ? `${A}${string}${Filled<B>}` : P;
+/**
+ * Not a route, but a legitimate href: another site, a mail client, a phone
+ * number, an anchor on this page, a bare query string.
+ */
+type OffRoute = `${string}://${string}` | `mailto:${string}` | `tel:${string}` | `#${string}` | `?${string}`;
+/**
+ * A url this app can answer, or one that deliberately leaves it.
+ *
+ * Cast when the destination is computed rather than written:
+ * `href={path as Href}`.
+ */
+export type Href = Unregistered extends true ? string : Filled<RoutePattern> | `${Filled<RoutePattern>}?${string}` | `${Filled<RoutePattern>}#${string}` | OffRoute;
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;CAAG;AAE5B,+DAA+D;AAC/D,MAAM,MAAM,YAAY,GAAG,QAAQ,SAAS;IAAE,MAAM,EAAE,MAAM,CAAC,SAAS,MAAM,CAAA;CAAE,GAAG,CAAC,GAAG,MAAM,CAAA;AAE3F,+EAA+E;AAC/E,KAAK,YAAY,GAAG,MAAM,SAAS,YAAY,GAAG,IAAI,GAAG,KAAK,CAAA;AAE9D;;;;;;GAMG;AACH,KAAK,MAAM,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,OAAO,MAAM,IAAI,MAAM,CAAC,EAAE,GAC1E,GAAG,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,GAC3B,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,MAAM,IAAI,MAAM,CAAC,EAAE,GACzC,GAAG,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,GAC3B,CAAC,CAAA;AAEP;;;GAGG;AACH,KAAK,QAAQ,GAAG,GAAG,MAAM,MAAM,MAAM,EAAE,GAAG,UAAU,MAAM,EAAE,GAAG,OAAO,MAAM,EAAE,GAAG,IAAI,MAAM,EAAE,GAAG,IAAI,MAAM,EAAE,CAAA;AAE5G;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG,YAAY,SAAS,IAAI,GACxC,MAAM,GACN,MAAM,CAAC,YAAY,CAAC,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,MAAM,EAAE,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,MAAM,EAAE,GAAG,QAAQ,CAAA"}

package/dist/routes.js

@@ -0,0 +1,28 @@
+// Typed routes: the urls this app can actually answer, as a type.
+//
+// Laravel needs route() because the url lives in PHP and can move
+// independently of the name it is called by. Here the url *is* the file path,
+// so a name would be indirection that buys nothing. What is worth having is
+// the other half — a link to a page that does not exist should fail at build
+// time rather than in the browser.
+//
+// There is no route() builder to go with this, deliberately. A template
+// literal is checked the same way — `/posts/${slug}` compiles and
+// `/postz/${slug}` does not — so a builder would only wrap what the language
+// already does. Encoding a value that is not url-safe is `encodeURIComponent`
+// in the template, the same as anywhere else.
+//
+// The build already walks app/ and knows every route's segments, so it writes
+// one line into the app's source dir:
+//
+//   declare module '@rsc-kit/core/routes' {
+//     interface Register { routes: '/' | '/posts/[slug]' }
+//   }
+//
+// Everything below is derived from that union. An app that never runs the
+// generator — a generic host, a Laravel app that has not rebuilt — registers
+// nothing, `RoutePattern` stays `string`, and every url-taking API is exactly
+// as permissive as it was before. That fallback is the reason this can ship
+// without a flag.
+export {};
+//# sourceMappingURL=routes.js.map

package/dist/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.js","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,EAAE;AACF,kEAAkE;AAClE,8EAA8E;AAC9E,4EAA4E;AAC5E,6EAA6E;AAC7E,mCAAmC;AACnC,EAAE;AACF,wEAAwE;AACxE,kEAAkE;AAClE,6EAA6E;AAC7E,8EAA8E;AAC9E,8CAA8C;AAC9C,EAAE;AACF,8EAA8E;AAC9E,sCAAsC;AACtC,EAAE;AACF,4CAA4C;AAC5C,2DAA2D;AAC3D,MAAM;AACN,EAAE;AACF,0EAA0E;AAC1E,6EAA6E;AAC7E,8EAA8E;AAC9E,4EAA4E;AAC5E,kBAAkB"}

package/dist/routing.d.ts

@@ -0,0 +1,52 @@
+import type { ManifestRoute, RouteManifest } from './manifest.js';
+/** A matched route and the params its url segments bound. */
+export interface MatchedRoute {
+    route: ManifestRoute;
+    params: Record<string, string>;
+}
+/**
+ * Match a pathname against the manifest's segments.
+ *
+ * The manifest stores segments rather than a pattern string, because the
+ * pattern is the host's dialect — Laravel writes `{slug}`, Hono writes
+ * `:slug`, and neither is the build's business. Matching them directly means
+ * no dialect at all.
+ *
+ * Static segments beat dynamic ones at the same position: /docs/new is the
+ * page called new, not the page called [slug] with slug=new.
+ */
+export declare function matchRoute(manifest: RouteManifest, pathname: string): MatchedRoute | null;
+/**
+ * The interceptor registered for a slot, if this url has one.
+ *
+ * Matched against the url being navigated *to*: `(.)posts/[slug]` intercepts
+ * /posts/anything, and the params it binds are the target's, not the page the
+ * modal opens over.
+ */
+export declare function matchIntercept(manifest: RouteManifest, pathname: string, slot: string): {
+    component: string;
+    params: Record<string, string>;
+} | null;
+/**
+ * How much of the layout chain the client already holds.
+ *
+ * It sends the chain outermost-first; the shared prefix is what it can keep.
+ * Answering with a whole document instead is not merely wasteful — it replaces
+ * the root, and replacing the root unmounts every page retained behind the
+ * current one, so a half-typed form does not survive going back.
+ */
+export declare function sharedDepth(held: string | null, chain: string[]): number;
+/**
+ * What a page is remembered as, for retention and for the prefetch cache.
+ *
+ * The same url intercepted and not intercepted are two different things to go
+ * back to — a modal over the feed, and the post on its own page — so they
+ * cannot share a key or restoring one returns the other.
+ *
+ * Shared because both halves compute it: the host stores under this key and
+ * the client looks under it. Written out at each of the seven places that
+ * needed it, they only had to disagree once, and the symptom is a navigation
+ * that silently rebuilds a page it was holding.
+ */
+export declare function retentionKey(path: string, interceptSlot?: string | null): string;
+//# sourceMappingURL=routing.d.ts.map

package/dist/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../src/routing.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAgB,MAAM,eAAe,CAAA;AAE/E,6DAA6D;AAC7D,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAuBzF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,aAAa,EACvB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CA8B9D;AA4BD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAWxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAIhF"}

package/dist/routing.js

@@ -0,0 +1,146 @@
+// Matching a url to a route, and deciding how much of the page to send.
+//
+// Pure: no Request, no Response, no filesystem. That is what lets the same
+// implementation serve three callers — the request handler, the prerenderer
+// enumerating what to build, and the generated server bundle, which embeds its
+// own route table and answers these without a manifest being passed around at
+// all.
+//
+// Every host would otherwise write this, and would get the same two things
+// wrong: answering /docs/new with [slug], and treating the layout chain as a
+// set rather than a sequence.
+/**
+ * Match a pathname against the manifest's segments.
+ *
+ * The manifest stores segments rather than a pattern string, because the
+ * pattern is the host's dialect — Laravel writes `{slug}`, Hono writes
+ * `:slug`, and neither is the build's business. Matching them directly means
+ * no dialect at all.
+ *
+ * Static segments beat dynamic ones at the same position: /docs/new is the
+ * page called new, not the page called [slug] with slug=new.
+ */
+export function matchRoute(manifest, pathname) {
+    const parts = pathname.split('/').filter(Boolean);
+    let best = null;
+    let bestScore = -1;
+    for (const route of manifest.routes) {
+        const bound = bindSegments(route.segments, parts);
+        if (!bound)
+            continue;
+        // More static segments wins; a catch-all is the weakest possible match.
+        const score = route.segments.reduce((n, s) => n + (s.type === 'static' ? 2 : s.type === 'param' ? 1 : 0), 0);
+        if (score > bestScore) {
+            best = { route, params: bound };
+            bestScore = score;
+        }
+    }
+    return best;
+}
+/**
+ * The interceptor registered for a slot, if this url has one.
+ *
+ * Matched against the url being navigated *to*: `(.)posts/[slug]` intercepts
+ * /posts/anything, and the params it binds are the target's, not the page the
+ * modal opens over.
+ */
+export function matchIntercept(manifest, pathname, slot) {
+    const parts = pathname.split('/').filter(Boolean);
+    let best = null;
+    let bestScore = -1;
+    for (const intercept of manifest.intercepts) {
+        if (intercept.slot !== slot)
+            continue;
+        const params = bindSegments(intercept.segments, parts);
+        if (!params)
+            continue;
+        // Scored exactly as matchRoute scores, and for the same reason: a static
+        // segment beats a dynamic one at the same position. Taking the first match
+        // instead made the two disagree about which route a url belongs to — and
+        // the guard is chosen by one while the content comes from the other, so a
+        // url could be checked against the unguarded route and rendered from the
+        // guarded one.
+        const score = intercept.segments.reduce((n, segment) => n + (segment.type === 'static' ? 2 : segment.type === 'param' ? 1 : 0), 0);
+        if (score > bestScore) {
+            best = { component: intercept.component, params };
+            bestScore = score;
+        }
+    }
+    return best;
+}
+function bindSegments(segments, parts) {
+    const params = {};
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (segment.type === 'catchAll') {
+            // Swallows the rest, including none of it.
+            params[segment.value] = parts.slice(i).join('/');
+            return params;
+        }
+        if (i >= parts.length)
+            return null;
+        if (segment.type === 'static') {
+            if (parts[i] !== segment.value)
+                return null;
+            continue;
+        }
+        params[segment.value] = decodeURIComponent(parts[i]);
+    }
+    return segments.length === parts.length ? params : null;
+}
+/**
+ * How much of the layout chain the client already holds.
+ *
+ * It sends the chain outermost-first; the shared prefix is what it can keep.
+ * Answering with a whole document instead is not merely wasteful — it replaces
+ * the root, and replacing the root unmounts every page retained behind the
+ * current one, so a half-typed form does not survive going back.
+ */
+export function sharedDepth(held, chain) {
+    if (!held)
+        return 0;
+    const mounted = held.split(',').filter(Boolean);
+    let shared = 0;
+    while (shared < mounted.length && shared < chain.length && mounted[shared] === chain[shared]) {
+        shared++;
+    }
+    return shared;
+}
+/**
+ * What a page is remembered as, for retention and for the prefetch cache.
+ *
+ * The same url intercepted and not intercepted are two different things to go
+ * back to — a modal over the feed, and the post on its own page — so they
+ * cannot share a key or restoring one returns the other.
+ *
+ * Shared because both halves compute it: the host stores under this key and
+ * the client looks under it. Written out at each of the seven places that
+ * needed it, they only had to disagree once, and the symptom is a navigation
+ * that silently rebuilds a page it was holding.
+ */
+export function retentionKey(path, interceptSlot) {
+    const normalised = normalisePath(path);
+    return interceptSlot ? `__intercept:${interceptSlot}:${normalised}` : normalised;
+}
+/**
+ * The same page written two ways is one key.
+ *
+ * A static host serves /orders as a directory, so the browser's url ends in a
+ * slash while the build wrote the page down as /orders. Left unequal, the
+ * entry retained for a page is never the one looked up on the way back: it
+ * stays in the document, hidden, while a second copy is fetched and rendered
+ * beside it — so the form you were filling in is there, and not the one you
+ * are looking at.
+ */
+function normalisePath(path) {
+    // Absolute urls reach this from the initial page, which is identified by
+    // href rather than by the path a link would use.
+    const withoutOrigin = path.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]+/i, '');
+    const [pathname, rest = ''] = splitQuery(withoutOrigin);
+    return (pathname.replace(/\/+$/, '') || '/') + rest;
+}
+function splitQuery(url) {
+    const cut = url.search(/[?#]/);
+    return cut === -1 ? [url, ''] : [url.slice(0, cut), url.slice(cut)];
+}
+//# sourceMappingURL=routing.js.map

package/dist/routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.js","sourceRoot":"","sources":["../src/routing.ts"],"names":[],"mappings":"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"}

package/dist/runtime.d.ts

@@ -0,0 +1,36 @@
+export type SocketLike = {
+    write(data: string | Uint8Array): number;
+    flush(): void;
+    /**
+     * Hang up. Optional only because a caller may hold a stub; every real
+     * transport has one, and a frame stream that cannot be parsed has to be
+     * ended rather than resynchronised — see the invalid-length branch in
+     * worker.ts for what resuming costs.
+     */
+    end?(): void;
+};
+export interface SocketHandlers {
+    data(socket: SocketLike, data: Uint8Array): void | Promise<void>;
+    drain?(socket: SocketLike): void;
+    open?(socket: SocketLike): void;
+    close?(socket: SocketLike): void;
+    error?(socket: SocketLike, error: Error): void;
+}
+export interface ListenOptions {
+    unix?: string;
+    hostname?: string;
+    port?: number;
+}
+/** True when running under Bun rather than Node. */
+export declare const isBun: boolean;
+export declare const runtimeName: string;
+/** Yield to the event loop so queued socket writes flush before continuing. */
+export declare function yieldToEventLoop(): Promise<void>;
+/** Every .ts/.js file under dir, as paths relative to it. */
+export declare function scanScripts(dir: string): string[];
+export interface Server {
+    stop(): void;
+}
+/** Listen on a Unix socket or TCP address, dispatching to Bun-shaped handlers. */
+export declare function listen(options: ListenOptions, handlers: SocketHandlers): Server;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAA;IACxC,KAAK,IAAI,IAAI,CAAA;IACb;;;;;OAKG;IACH,GAAG,CAAC,IAAI,IAAI,CAAA;CACb,CAAA;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAChE,KAAK,CAAC,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAA;IAChC,IAAI,CAAC,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAA;IAC/B,KAAK,CAAC,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAA;IAChC,KAAK,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CAC/C;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,oDAAoD;AACpD,eAAO,MAAM,KAAK,SAA+D,CAAA;AAEjF,eAAO,MAAM,WAAW,QAAyB,CAAA;AAEjD,+EAA+E;AAC/E,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEhD;AAED,6DAA6D;AAC7D,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBjD;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,IAAI,IAAI,CAAA;CACb;AAED,kFAAkF;AAClF,wBAAgB,MAAM,CAAC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAW/E"}

package/dist/runtime.js

@@ -0,0 +1,86 @@
+// Runtime shim for the worker.
+//
+// The worker's only runtime-specific surface is the socket server, a yield to
+// the event loop, and a directory walk. Bun and Node both provide all three;
+// this presents them under one shape so worker.ts never branches.
+//
+// The write contract is Bun's: write() returns the number of bytes accepted, so
+// a partial write can be queued and retried on drain. Node never writes
+// partially — it queues internally — so the Node adapter always reports a full
+// write and the caller's pending-buffer path simply never engages.
+import { createServer } from 'node:net';
+import { readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+/** True when running under Bun rather than Node. */
+export const isBun = typeof globalThis.Bun !== 'undefined';
+export const runtimeName = isBun ? 'bun' : 'node';
+/** Yield to the event loop so queued socket writes flush before continuing. */
+export function yieldToEventLoop() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+/** Every .ts/.js file under dir, as paths relative to it. */
+export function scanScripts(dir) {
+    const found = [];
+    const walk = (current) => {
+        for (const entry of readdirSync(current)) {
+            const abs = join(current, entry);
+            if (statSync(abs).isDirectory()) {
+                walk(abs);
+            }
+            else if (/\.(ts|js)$/.test(entry)) {
+                found.push(relative(dir, abs));
+            }
+        }
+    };
+    walk(dir);
+    return found;
+}
+/** Listen on a Unix socket or TCP address, dispatching to Bun-shaped handlers. */
+export function listen(options, handlers) {
+    if (isBun) {
+        const server = globalThis.Bun.listen({
+            ...(options.unix ? { unix: options.unix } : { hostname: options.hostname, port: options.port }),
+            socket: handlers,
+        });
+        return { stop: () => server.stop() };
+    }
+    return listenOnNode(options, handlers);
+}
+function listenOnNode(options, handlers) {
+    const server = createServer((connection) => {
+        // One adapter per connection: the worker uses the socket object as a Map
+        // key, so it has to be stable for the connection's lifetime.
+        const socket = {
+            write(data) {
+                const buffer = typeof data === 'string' ? Buffer.from(data, 'utf-8') : Buffer.from(data);
+                // Node buffers whatever the kernel would not take, so everything is
+                // always accepted. The boolean it returns is a backpressure hint, not
+                // a byte count.
+                connection.write(buffer);
+                return buffer.length;
+            },
+            flush() { },
+            end() {
+                connection.end();
+            },
+        };
+        connection.on('data', (chunk) => {
+            // Always bytes: the socket is never given an encoding, so node hands
+            // back a Buffer rather than a string.
+            void handlers.data(socket, chunk);
+        });
+        connection.on('drain', () => handlers.drain?.(socket));
+        connection.on('close', () => handlers.close?.(socket));
+        connection.on('error', (error) => handlers.error?.(socket, error));
+        handlers.open?.(socket);
+    });
+    server.on('error', (error) => handlers.error?.(null, error));
+    if (options.unix) {
+        server.listen(options.unix);
+    }
+    else {
+        server.listen(options.port, options.hostname);
+    }
+    return { stop: () => server.close() };
+}
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}

package/dist/safeUrl.d.ts

@@ -0,0 +1,10 @@
+export declare function isSafeRedirect(value: string): boolean;
+/**
+ * The same check, as a refusal.
+ *
+ * Says the value back, deliberately. A destination that fails this is far more
+ * often a bug in what the app computed than an attack, and a message that does
+ * not name the value leaves nothing to go on.
+ */
+export declare function assertSafeRedirect(value: string): void;
+//# sourceMappingURL=safeUrl.d.ts.map

package/dist/safeUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeUrl.d.ts","sourceRoot":"","sources":["../src/safeUrl.ts"],"names":[],"mappings":"AAeA,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAWrD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAQtD"}

package/dist/safeUrl.js

@@ -0,0 +1,40 @@
+// Whether a redirect destination is a url a browser should be sent to.
+//
+// A destination is routinely computed rather than written — redirect()'s own
+// documentation describes reading one from a cookie as the usual case — and it
+// reaches location.href, location.replace and an inline script. A scheme other
+// than http(s) in any of those is script execution rather than navigation.
+//
+// Parsed rather than pattern-matched. javascript: can be written with mixed
+// case, with a newline inside it, or behind leading control characters, and
+// each of those is a different regex to get wrong. The URL parser normalises
+// all of it already, so asking it for the protocol is shorter and correct.
+/** A base that cannot collide with a real origin, for resolving relative urls. */
+const NOWHERE = 'https://rsc-kit.invalid/';
+export function isSafeRedirect(value) {
+    try {
+        const { protocol } = new URL(value, NOWHERE);
+        // http and https only. Not data:, not blob:, not javascript:, and not a
+        // custom app scheme — a browser handing one of those to another program is
+        // not something a render should be able to trigger.
+        return protocol === 'http:' || protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The same check, as a refusal.
+ *
+ * Says the value back, deliberately. A destination that fails this is far more
+ * often a bug in what the app computed than an attack, and a message that does
+ * not name the value leaves nothing to go on.
+ */
+export function assertSafeRedirect(value) {
+    if (isSafeRedirect(value))
+        return;
+    throw new Error('Not a url a redirect may go to: ' + JSON.stringify(value) + '. ' +
+        'A destination has to be a path or an http(s) url — any other scheme is ' +
+        'handed to the browser as something to run rather than somewhere to go.');
+}
+//# sourceMappingURL=safeUrl.js.map

package/dist/safeUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeUrl.js","sourceRoot":"","sources":["../src/safeUrl.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,EAAE;AACF,6EAA6E;AAC7E,+EAA+E;AAC/E,+EAA+E;AAC/E,2EAA2E;AAC3E,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,6EAA6E;AAC7E,2EAA2E;AAE3E,kFAAkF;AAClF,MAAM,OAAO,GAAG,0BAA0B,CAAA;AAE1C,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,IAAI,CAAC;QACH,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAE5C,wEAAwE;QACxE,2EAA2E;QAC3E,oDAAoD;QACpD,OAAO,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,QAAQ,CAAA;IACtD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,IAAI,cAAc,CAAC,KAAK,CAAC;QAAE,OAAM;IAEjC,MAAM,IAAI,KAAK,CACb,kCAAkC,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI;QAC/D,yEAAyE;QACzE,wEAAwE,CAC3E,CAAA;AACH,CAAC"}