@rangojs/router 0.4.0 → 0.4.2

package/dist/types.backup/browser/action-coordinator.d.ts

@@ -1,57 +0,0 @@
-import type { ActionEntry } from "./event-controller.js";
-/**
- * Post-reconciliation action outcome (discriminated union). Error and
- * full-update-unsupported cases are handled inline in the bridge before
- * reconciliation; this only covers successfully-reconciled partial responses.
- */
-type ActionScenario = {
-    type: "navigated-away";
-    historyKeyChanged: boolean;
-    onInterceptRoute: boolean;
-} | {
-    type: "hmr-missing";
-} | {
-    type: "consolidation-needed";
-    segmentIds: string[];
-} | {
-    type: "concurrent-skip";
-    otherFetchingCount: number;
-} | {
-    type: "normal";
-};
-/**
- * Plain data inputs for classifying a post-reconciliation action outcome.
- * No browser objects or controller references — all values are snapshots.
- */
-export interface ActionOutcomeInput {
-    /** This action's unique instance ID */
-    handleId: string;
-    /** All in-flight action entries (snapshot from event controller) */
-    inflightActions: Map<string, ActionEntry>;
-    /** Whether any concurrent actions occurred (controller-level shared flag) */
-    hadAnyConcurrentActions: boolean;
-    /** Segments revalidated by concurrent actions (from tracking set) */
-    revalidatedSegments: Set<string>;
-    /** window.location.pathname captured at action start */
-    actionStartPathname: string;
-    /** window.location.pathname at classification time */
-    currentPathname: string;
-    /** window.history.state?.key captured at action start */
-    actionStartLocationKey: string | undefined;
-    /** window.history.state?.key at classification time */
-    currentLocationKey: string | undefined;
-    /** Number of segments after reconciliation */
-    reconciledSegmentCount: number;
-    /** Number of matched segment IDs from server */
-    matchedCount: number;
-    /** Current intercept source URL (null when not on intercept route) */
-    currentInterceptSource: string | null;
-}
-/**
- * Classify a post-reconciliation action outcome. Ordered priority chain: each
- * case assumes the earlier ones are false (e.g. concurrent-skip only applies on
- * the still-current route, consolidation only once no action is still fetching).
- * The bridge calls this to decide whether to render, skip, consolidate, or refetch.
- */
-export declare function classifyActionOutcome(input: ActionOutcomeInput): ActionScenario;
-export {};

package/dist/types.backup/browser/action-fence.d.ts

@@ -1,33 +0,0 @@
-/**
- * Action fence: a refcounted flag that is raised while a server action is in
- * flight and lowered when it resolves.
- *
- * It replaces the eager cache clear the action bridge used to do at action
- * start. While the fence is up, the decision of whether the action invalidated
- * anything is deferred to the response:
- *
- * - prefetch consumption is suspended (a queued prefetch result is not served),
- * - a genuine navigation during the flight fetches with `cache: "no-store"` so
- *   it cannot be served stale bytes from the browser's Vary-keyed HTTP cache,
- * - popstate reads are treated as stale-while-revalidate.
- *
- * Nothing is wiped, rotated, or broadcast while the fence is up — that is what
- * keeps a sibling tab from seeing a pre-commit signal. Refcounted so concurrent
- * actions compose: each action raises and lowers its own reference, and the
- * fence is down only when the count reaches zero.
- *
- * The refcount is a single module-level counter, not keyed by routerId.
- * Consumers (navigation-client.ts, prefetch/fetch.ts, navigation-bridge.ts)
- * read it unscoped, so an action in one router would suppress another router's
- * navigation/prefetch caches. This is correct only because two routers cannot
- * coexist in one live document: an SPA navigation crossing a host-router
- * boundary forces a full document reload (src/router/request-classification.ts
- * app-switch terminal), so there is always exactly one live router per
- * document. A future multi-router-in-one-document feature must not silently
- * inherit this global, cross-router cache suppression.
- */
-export declare function enterActionFence(): void;
-export declare function exitActionFence(): void;
-export declare function isActionFenceActive(): boolean;
-/** Test-only: reset the refcount between cases. */
-export declare function __resetActionFence(): void;

package/dist/types.backup/browser/app-shell.d.ts

@@ -1,34 +0,0 @@
-import type { ComponentType, ReactNode } from "react";
-/**
- * App-shell metadata: the per-router fields describing the "envelope" around
- * the current app's segment tree — the rootLayout (Document), basename,
- * version, and router identity. Set once from the initial RSC payload and read
- * through the AppShellRef when rendering segments.
- *
- * This is a per-document value. A navigation that crosses a host-router app
- * boundary is a full document load (the server returns X-RSC-Reload for it;
- * see request-classification.ts, mode "app-switch"), so the target app's shell
- * — along with everything else document-level (theme, warmup, prefetch-TTL) —
- * is established fresh by the target app's own load. The shell is never swapped
- * in place within a session.
- */
-export interface AppShell {
-    /** Router identity. Used to namespace per-app client state (e.g. the
-     *  rango-state localStorage key) so sibling apps on the same origin
-     *  cannot observe each other's cache invalidations. */
-    routerId?: string;
-    rootLayout?: ComponentType<{
-        children: ReactNode;
-    }>;
-    basename?: string;
-    version?: string;
-}
-/**
- * Container for the active app shell. Read-through via `get()` so closures
- * (e.g. the segment renderer) capture the ref and read the shell at call time
- * rather than closing over a stale snapshot.
- */
-export interface AppShellRef {
-    get(): AppShell;
-}
-export declare function createAppShellRef(initial: AppShell): AppShellRef;

package/dist/types.backup/browser/app-version.d.ts

@@ -1,6 +0,0 @@
-/**
- * Mutable app version — updated after HMR revalidation.
- * Read by prefetch, navigation, and context code.
- */
-export declare function getAppVersion(): string | undefined;
-export declare function setAppVersion(version: string | undefined): void;

package/dist/types.backup/browser/connection-warmup.d.ts

@@ -1,31 +0,0 @@
-/**
- * Connection warmup: keep TLS alive after idle periods.
- *
- * After IDLE_TIMEOUT of no user interaction the connection is marked "cold".
- * On the next pointer/touch interaction or a visibility change, a HEAD request
- * warms the TLS connection before the user actually clicks a link.
- *
- * Extracted from NavigationProvider so the idle/cold/warmup state machine is
- * unit-testable with an injected environment (document, fetch, timers).
- *
- * Ordering bug this guards against: the warmup listeners (mousemove/touchstart)
- * share events with the idle-reset listeners, and the idle-reset listener is
- * registered first, so it clears the live "cold" flag before the warmup
- * listener reads it on the same event. A separate coldLatch — set when the
- * connection goes cold and cleared only when warmup fires or listeners detach,
- * never by the idle reset — lets the warmup decision see the pre-reset cold
- * state regardless of listener ordering.
- */
-type TimerHandle = ReturnType<typeof setTimeout>;
-export interface WarmupEnv {
-    doc: Pick<Document, "addEventListener" | "removeEventListener" | "visibilityState">;
-    fetch: typeof fetch;
-    setTimeout: (fn: () => void, ms: number) => TimerHandle;
-    clearTimeout: (handle: TimerHandle | undefined) => void;
-}
-/**
- * Start the connection-warmup state machine. Returns a cleanup function that
- * cancels timers and removes all listeners.
- */
-export declare function startConnectionWarmup(env?: WarmupEnv): () => void;
-export {};

package/dist/types.backup/browser/cookie-name.d.ts

@@ -1,66 +0,0 @@
-/**
- * Rango state cookie: value codec and attribute serialization.
- *
- * Shared by the client (the document.cookie writer in rango-state.ts) and the
- * server (the Set-Cookie writer in invalidateClientCache). Environment-agnostic:
- * no window/document access and no name composition.
- *
- * Name RESOLUTION deliberately lives elsewhere (router init, see
- * router/state-cookie-name.ts). Keeping composition out of this shared module
- * is what lets the client read the server-resolved name verbatim and compose
- * nothing.
- */
-/** Default prefix when `stateCookiePrefix` is unset or empty after sanitization. */
-export declare const DEFAULT_STATE_COOKIE_PREFIX = "rango-state";
-/** Internal response header carrying the keepClientCache() directive. */
-export declare const KEEP_CACHE_HEADER = "x-rango-keep-cache";
-/** True for a per-client signal header. */
-export declare function isPerClientSignalHeader(name: string): boolean;
-/** True if `headers` carries any per-client signal. */
-export declare function hasPerClientSignal(headers: Headers): boolean;
-/** Remove every per-client signal header from `headers` in place. */
-export declare function stripPerClientSignals(headers: Headers): void;
-/**
- * Read the raw, UNDECODED value of a single cookie from a cookie string (a
- * `document.cookie` jar or a request `Cookie` header). Shared by both seats so
- * the client mirror and the server monotonic-guard read the SAME jar entry —
- * their agreement is the guard's contract. First match wins (the entry the
- * client's mirror holds); exact name boundary via the `=`; an empty value
- * (`name=`) returns null (treated as absent, not a usable prior value).
- */
-export declare function getRawCookieValue(cookieString: string | null, name: string): string | null;
-/**
- * Encode a state value for the wire: `encodeURIComponent(version):timestamp`.
- * Only the build-derived version is encoded (it is arbitrary); the `:`
- * separator and numeric timestamp stay raw, so the `{version}:{timestamp}`
- * shape survives and `:` is a legal cookie-value octet.
- */
-export declare function encodeStateValue(version: string, timestamp: number): string;
-/** Parsed state value. `version` is decoded; `timestamp` is the raw integer. */
-export interface StateValue {
-    version: string;
-    timestamp: number;
-}
-/**
- * Decode a wire value back into `{version, timestamp}`. Returns null for a
- * malformed value (no `:`, empty version, or non-numeric timestamp) so callers
- * mint fresh instead of trusting garbage.
- */
-export declare function decodeStateValue(raw: string): StateValue | null;
-/**
- * Mint a fresh state value whose timestamp is strictly greater than the previous
- * one, so a re-mint inside the same millisecond (or a backward clock step) still
- * differs from the current value. `prevRaw` is the current wire value (the
- * client's in-memory mirror, or the server's inbound header/cookie) or null; its
- * timestamp is the floor. Shared by both seats so the monotonic guard lives once.
- */
-export declare function mintStateValue(version: string, prevRaw: string | null): string;
-/**
- * Attribute string for the state cookie. Session cookie (no Max-Age/Expires),
- * Path=/ (whole app), SameSite=Lax (sent on top-level navigations), and Secure
- * only on https so the document.cookie write does not silently fail on plain
- * http dev. Never HttpOnly (the client reads and writes it).
- */
-export declare function stateCookieAttributes(secure: boolean): string;
-/** Serialize a full `name=value` cookie string with the state attributes. */
-export declare function serializeStateCookie(name: string, value: string, secure: boolean): string;

package/dist/types.backup/browser/event-controller.d.ts

@@ -1,221 +0,0 @@
-import type { ReactNode } from "react";
-import type { NavigationLocation, NavigateOptions, TrackedActionState, InflightAction, RscMetadata, HandleData, StreamingToken } from "./types.js";
-/**
- * Phase of a navigation operation
- */
-export type NavigationPhase = "fetching" | "streaming";
-/**
- * Phase of an action operation
- */
-export type ActionPhase = "fetching" | "streaming" | "settling";
-/**
- * Entry tracking an in-flight navigation
- */
-export interface NavigationEntry {
-    url: string;
-    abort: AbortController;
-    phase: NavigationPhase;
-    startedAt: number;
-    options?: NavigateOptions & {
-        skipLoadingState?: boolean;
-    };
-}
-/**
- * Entry tracking an in-flight action
- */
-export interface ActionEntry {
-    /** Unique instance ID for this action invocation */
-    id: string;
-    /** Server action function ID (normalized name like "addToCart") */
-    actionId: string;
-    /** Abort controller for this action */
-    abort: AbortController;
-    /** Current phase of the action */
-    phase: ActionPhase;
-    /** Action arguments */
-    payload: unknown[];
-    /** Result from action (set on completion) */
-    result?: unknown;
-    /** Error from action (set on failure) */
-    error?: unknown;
-    /** Segment IDs that were revalidated by this action */
-    revalidatedSegments: string[];
-    /** Timestamp when action started */
-    startedAt: number;
-    /** Whether action processing is complete (may still be streaming) */
-    completed?: boolean;
-}
-/**
- * Derived navigation state (computed from source of truth)
- */
-export interface DerivedNavigationState {
-    /** Navigation lifecycle state */
-    state: "idle" | "loading";
-    /** Whether any operation is streaming */
-    isStreaming: boolean;
-    /** Whether a navigation is active (fetching or streaming, before commit) */
-    isNavigating: boolean;
-    /** Current committed location */
-    location: NavigationLocation;
-    /** URL being navigated to (null if idle) */
-    pendingUrl: string | null;
-    /** List of inflight actions (for compatibility) */
-    inflightActions: InflightAction[];
-}
-/**
- * Callback for UI updates when root should re-render
- */
-export type UpdateCallback = (update: {
-    root: ReactNode | Promise<ReactNode>;
-    metadata: RscMetadata;
-}) => void;
-/**
- * State change listener
- */
-export type StateListener = () => void;
-/**
- * Action state listener
- */
-export type ActionStateListener = (state: TrackedActionState) => void;
-/**
- * Handle state listener
- */
-export type HandleListener = () => void;
-/**
- * Internal handle state stored in controller.
- *
- * Two segment lists are exposed because they serve different consumers:
- *
- * - `segmentOrder` drives handle collection (collectHandleData). Includes
- *   parallel slot ids and reorders them after their parent so later-wins
- *   collect functions (e.g. Meta) get the right precedence.
- * - `routeSegmentIds` is the layouts-and-routes-only list documented by
- *   `useSegments().segmentIds`. Parallels and loader sub-ids are stripped;
- *   raw matched order is preserved.
- *
- * Both are derived from the same `matched` input on each setHandleData call
- * so they stay in sync.
- */
-export interface HandleState {
-    data: HandleData;
-    segmentOrder: string[];
-    routeSegmentIds: string[];
-}
-/**
- * Result from starting a navigation
- * Implements Disposable for use with `using` keyword
- */
-export interface NavigationHandle extends Disposable {
-    /** Abort controller for this navigation */
-    abort: AbortController;
-    /** Signal for this navigation */
-    signal: AbortSignal;
-    /** Start streaming and get a token to end it later */
-    startStreaming(): StreamingToken;
-    /** Complete the navigation successfully */
-    complete(location: NavigationLocation): void;
-    /** Whether navigation was completed successfully */
-    readonly completed: boolean;
-}
-/**
- * Result from starting an action
- * Implements Disposable for use with `using` keyword
- */
-export interface ActionHandle extends Disposable {
-    /** Unique instance ID */
-    id: string;
-    /** Abort controller for this action */
-    abort: AbortController;
-    /** Signal for this action */
-    signal: AbortSignal;
-    /** Start streaming and get a token to end it later */
-    startStreaming(): StreamingToken;
-    /** Record segments that were revalidated */
-    recordRevalidatedSegments(segmentIds: string[]): void;
-    /**
-     * Claim the subset of a location-state payload this action may write. A key
-     * is claimed only if no later-initiated action in the SAME cohort has already
-     * claimed it, so same-key concurrent writes resolve to the last-initiated
-     * action while distinct keys from every action survive. Recording the claim
-     * stops a later-settling earlier action from overwriting it. Arbitration is
-     * scoped to the action's cohort (its originating history entry, captured at
-     * startAction), so an action on one entry cannot suppress an action on
-     * another that happens to write the same slot.
-     *
-     * Contract: this guarantees the FINAL value is the last-initiated action's,
-     * not that the loser is never momentarily visible. When an earlier-initiated
-     * action settles first, its value is merged and observable until the
-     * later-initiated winner's response lands and overwrites it.
-     */
-    claimLocationState(state: Record<string, unknown>): Record<string, unknown>;
-    /** Complete the action with result */
-    complete(result?: unknown): void;
-    /** Fail the action with error */
-    fail(error: unknown): void;
-    /** Whether action was completed (success or failure) */
-    readonly settled: boolean;
-    /** Check if any concurrent actions were started */
-    hadConcurrentActions: boolean;
-    /** Get raw set of segments revalidated by concurrent actions */
-    getRevalidatedSegments(): Set<string>;
-    /** Clear consolidation tracking */
-    clearConsolidation(): void;
-}
-/**
- * Event controller interface
- */
-export interface EventController {
-    startNavigation(url: string, options?: NavigateOptions & {
-        skipLoadingState?: boolean;
-    }): NavigationHandle;
-    abortNavigation(): void;
-    startAction(actionId: string, args: unknown[], 
-    /** Originating history entry key; scopes location-state arbitration. */
-    cohort?: string): ActionHandle;
-    abortAllActions(): void;
-    getState(): DerivedNavigationState;
-    getActionState(actionId: string): TrackedActionState;
-    getLocation(): NavigationLocation;
-    setLocation(location: NavigationLocation): void;
-    subscribe(listener: StateListener): () => void;
-    subscribeToAction(actionId: string, listener: ActionStateListener): () => void;
-    subscribeToHandles(listener: HandleListener): () => void;
-    setHandleData(data: HandleData, matched?: string[], isPartial?: boolean, 
-    /**
-     * Segment ids that were re-resolved on the server this request (the
-     * partial response's `diff`). On a partial update, any existing bucket
-     * keyed under one of these ids that has no incoming entry is treated as
-     * stale and cleared. Without this, a parallel slot that revalidates but
-     * pushes nothing leaves its previous bucket in place forever.
-     */
-    resolvedIds?: string[]): void;
-    getHandleState(): HandleState;
-    /**
-     * Update ONLY `routeSegmentIds` (what `useSegments` reads) from `matched`,
-     * leaving `data` and `segmentOrder` (what `useHandle` collects over) untouched.
-     * Used while a deferred handle is resolving: the route has changed (so
-     * `useSegments` must reflect the new segment ids) but `useHandle` still holds
-     * its previous value until the deferred snapshot is applied.
-     */
-    setRouteSegmentIds(matched: string[]): void;
-    setParams(params: Record<string, string>): void;
-    getParams(): Record<string, string>;
-    getCurrentNavigation(): NavigationEntry | null;
-    getInflightActions(): Map<string, ActionEntry>;
-    /** Whether any concurrent actions have occurred (shared across all handles) */
-    hadAnyConcurrentActions(): boolean;
-}
-export interface EventControllerConfig {
-    initialLocation?: NavigationLocation;
-}
-/**
- * Create an event controller for managing navigation and action state
- *
- * The controller uses a reactive model where:
- * - Source of truth: currentNavigation, inflightActions, location
- * - Derived state: navState, isStreaming computed from source
- *
- * Navigation uses switchMap semantics (new nav cancels previous).
- * Actions use mergeMap semantics (all run concurrently, consolidate at end).
- */
-export declare function createEventController(config?: EventControllerConfig): EventController;

package/dist/types.backup/browser/history-state.d.ts

@@ -1,26 +0,0 @@
-/**
- * Resolve navigation state - handles both LocationStateEntry[] and plain formats
- */
-export declare function resolveNavigationState(state: unknown): unknown;
-/**
- * Build history state object from user state
- * - Typed state: spread directly into history.state
- * - Plain state: store in history.state.state
- */
-export declare function buildHistoryState(userState: unknown, routerState?: {
-    intercept?: boolean;
-    sourceUrl?: string;
-}, serverState?: Record<string, unknown>): Record<string, unknown> | null;
-/**
- * Stamp an `idx` on the next history entry's state and call push/replaceState.
- * Push increments the current idx; replace keeps it. Initial entry idx is 0.
- * Used by useRouter().back() to detect "first entry in this session" without
- * relying on the Navigation API.
- */
-export declare function pushHistoryWithIdx(state: Record<string, unknown> | null, url: string, replace: boolean): void;
-/**
- * Merge server-set location state into the current history entry.
- * Replaces the current history state and dispatches notification event
- * so useLocationState hooks re-read from history.state.
- */
-export declare function mergeLocationState(locationState: Record<string, unknown>): void;

package/dist/types.backup/browser/index.d.ts

@@ -1 +0,0 @@
-export { initBrowserApp, Rango, type InitBrowserAppOptions, } from "./rsc-router.js";

package/dist/types.backup/browser/intercept-utils.d.ts

@@ -1,30 +0,0 @@
-import type { ResolvedSegment } from "./types.js";
-import type { SlotState } from "../types.js";
-/**
- * Check if a segment is an intercept segment.
- * Intercept segments have namespace starting with "intercept:" — both the
- * parallel container (@modal) and its content children receive this namespace
- * from intercept-resolution.ts. Regular parallel segments like @sidebar do not.
- */
-export declare function isInterceptSegment(s: ResolvedSegment): boolean;
-/**
- * Split an array of segments into main and intercept groups.
- * Intercept segments are separated for explicit injection into the render tree
- * via the interceptSegments render option.
- */
-export declare function splitInterceptSegments(segments: ResolvedSegment[]): {
-    main: ResolvedSegment[];
-    intercept: ResolvedSegment[];
-};
-/**
- * Check if any slot is currently active (has content to render).
- * Active slots indicate an intercept response where a parallel segment
- * (e.g., @modal) has matched and should be rendered.
- */
-export declare function hasActiveIntercept(slots?: Record<string, SlotState>): boolean;
-/**
- * Check if cached segments contain any intercept segments.
- * Intercept caches shouldn't be used for cached SWR rendering since
- * whether interception happens depends on the current page context.
- */
-export declare function isInterceptOnlyCache(segments: ResolvedSegment[]): boolean;

package/dist/types.backup/browser/invalidate-client-cache.d.ts

@@ -1,17 +0,0 @@
-/**
- * Client seat of `invalidateClientCache()` (the `default` export condition).
- *
- * Makes the current client behave as if a server action had just completed:
- * the history cache is marked stale (SWR), the prefetch map is flushed, the
- * state rotates, and sibling tabs are broadcast to — the same
- * `markCacheAsStaleAndBroadcast()` path the server-action bridge uses. This is
- * the gentler mark-stale (not hard-clear) behavior, so Back renders the cached
- * entry instantly and revalidates.
- */
-export declare function invalidateClientCache(): void;
-/**
- * Client no-op for `keepClientCache()`. It is a server action directive (the
- * `react-server` condition sets a response header the action bridge reads);
- * there is nothing to suppress from the client side.
- */
-export declare function keepClientCache(): void;

package/dist/types.backup/browser/link-interceptor.d.ts

@@ -1,43 +0,0 @@
-import type { LinkInterceptorOptions, NavigateOptions } from "./types.js";
-/**
- * Check if an anchor points to the same page with only a hash change.
- * Used by both Link component and link-interceptor to let the browser
- * handle anchor scrolling natively.
- */
-export declare function isHashOnlyNavigation(anchor: HTMLAnchorElement): boolean;
-/**
- * Default link interception predicate
- *
- * Returns true if the link should be intercepted for SPA navigation.
- * Filters out:
- * - Cross-origin links
- * - Links with download attribute
- * - Links with target other than _self
- * - Links with data-no-intercept attribute
- *
- * @param link - The anchor element to check
- * @returns true if the link should be intercepted
- */
-export declare function defaultShouldIntercept(link: HTMLAnchorElement): boolean;
-/**
- * Set up link interception for SPA navigation
- *
- * Attaches a global click handler to intercept clicks on anchor elements
- * and call the onNavigate callback instead of performing a full page load.
- *
- * @param onNavigate - Callback when a link should navigate via SPA
- * @param options - Configuration options
- * @returns Cleanup function to remove the event listener
- *
- * @example
- * ```typescript
- * const cleanup = setupLinkInterception((url) => {
- *   window.history.pushState({}, "", url);
- *   fetchPartialUpdate(url);
- * });
- *
- * // Later, to clean up:
- * cleanup();
- * ```
- */
-export declare function setupLinkInterception(onNavigate: (url: string, options?: NavigateOptions) => void, options?: LinkInterceptorOptions): () => void;

package/dist/types.backup/browser/logging.d.ts

@@ -1,33 +0,0 @@
-/**
- * Module-level debug flag for guarding call sites whose debug arguments do
- * non-trivial work (joins, maps, spreads, object literals). Because the Vite
- * transform folds INTERNAL_RANGO_DEBUG to a literal, an `if (IS_BROWSER_DEBUG)`
- * guard is minifier-DCE-able — the whole block drops from the production bundle.
- * Prefer this over isBrowserDebugEnabled() at hot call sites: a const guard folds
- * where a function call may not.
- */
-export declare const IS_BROWSER_DEBUG: boolean;
-interface BrowserLogContext {
-    requestId: string;
-    txId: string;
-    operation: string;
-}
-export declare function isBrowserDebugEnabled(): boolean;
-export declare function startBrowserTransaction(operation: string): BrowserLogContext;
-export declare function browserDebugLog(ctx: BrowserLogContext, message: string, details?: Record<string, unknown>): void;
-/**
- * Simple gated console.log for browser-side debug output.
- * Unlike browserDebugLog, this doesn't require a transaction context -
- * use it for standalone debug messages in partial-update, navigation-bridge, etc.
- */
-export declare function debugLog(msg: string, ...args: unknown[]): void;
-/**
- * Boot-sequence debug log: one line per initial-document step (flight decode,
- * handle stream, bridge wiring, initial tree build, hydration commit), each
- * stamped with performance.now() so the gap BEFORE hydrateRoot is visible.
- * The initial document path was otherwise silent — FE debug only started
- * talking at the first soft navigation, so a boot stall (e.g. an await that
- * holds initBrowserApp, and with it hydrateRoot) was invisible.
- */
-export declare function bootLog(step: string, details?: Record<string, unknown>): void;
-export {};

package/dist/types.backup/browser/merge-segment-loaders.d.ts

@@ -1,38 +0,0 @@
-import type { ResolvedSegment } from "./types.js";
-/**
- * Merge partial loader data from server with cached loader data.
- *
- * During partial revalidation (stale or action), the server may return only
- * some loaders that pass the revalidation check. The component still needs
- * all loader data, so we merge fresh data with cached data.
- *
- * @param fromServer - Segment returned from server with partial loaders
- * @param fromCache - Cached segment with full loader data
- * @returns Merged segment with complete loader data
- */
-export declare function mergeSegmentLoaders(fromServer: ResolvedSegment, fromCache: ResolvedSegment): ResolvedSegment;
-/**
- * Check if segments need loader merging during partial revalidation.
- *
- * Returns true when:
- * - Server returned fewer loaders than cached (partial revalidation)
- * - Both segments have loader data promises
- */
-export declare function needsLoaderMerge(fromServer: ResolvedSegment, fromCache: ResolvedSegment | undefined): fromCache is ResolvedSegment;
-/**
- * Insert diff segments that aren't in the matched array into allSegments.
- *
- * During consolidation fetch for concurrent actions, loader segments may be
- * excluded from the request. The server returns them in the diff but not in
- * the matched array. This function inserts them at the correct position
- * (after their parent layout segment).
- *
- * Loader segment IDs follow the pattern: {parentLayoutId}D{index}.{loaderId}
- * Example: M9L0L1D0.actionCounter has parent layout M9L0L1
- *
- * @param allSegments - Mutable array of segments to insert into
- * @param diff - Array of segment IDs that changed (from server response)
- * @param matchedIdSet - Set of segment IDs from matched array
- * @param newSegmentMap - Map of segment ID to segment data from server
- */
-export declare function insertMissingDiffSegments(allSegments: ResolvedSegment[], diff: string[] | undefined, matchedIdSet: Set<string>, newSegmentMap: Map<string, ResolvedSegment>): void;