@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/types/request-policy/policyCore.d.ts

@@ -0,0 +1,107 @@
+import type { IdentityBindingViolation, OperationContext, OperationContractOptions, OperationContractViolation, TransportTarget } from './types.js';
+export declare const TRACEPARENT_HEADER = "traceparent";
+export declare const isSecuredRequestId: (requestId: string) => boolean;
+export declare const isEmptyDomain: (domain?: string) => boolean;
+export declare const firstHeaderValue: (value: unknown) => any;
+export declare const findHeaderKey: (headers: Record<string, any>, header: string) => string | undefined;
+export declare const readHeader: (headers: Record<string, any>, header: string) => any;
+export declare const writeHeader: (headers: Record<string, any>, header: string, value: unknown) => void;
+export declare const deleteHeader: (headers: Record<string, any>, header: string) => void;
+export declare const toOrigin: (value?: string) => string | undefined;
+export declare const parseTraceparentValue: (value: unknown) => import("./traceparent.js").TraceparentContext | undefined;
+export declare const buildOperationContext: ({ requestId, method, path, operationContext, traceparent, }: {
+    requestId: string;
+    method: string;
+    path: string;
+    operationContext?: OperationContext | undefined;
+    traceparent?: unknown;
+}) => {
+    requestId: string;
+    operationId: string;
+    routePath: string;
+    method: string;
+    schemaHash?: string | undefined;
+    operationVersion?: number | undefined;
+    traceparent?: string | undefined;
+    traceId?: string | undefined;
+    spanId?: string | undefined;
+};
+type OperationContextPayload = ReturnType<typeof buildOperationContext>;
+export declare class ProducerClientNotInitializedError extends Error {
+    readonly code = "BFF_PRODUCER_CLIENT_NOT_INITIALIZED";
+    constructor(requestId: string);
+}
+export declare class ProducerDomainNotConfiguredError extends Error {
+    readonly code = "BFF_PRODUCER_DOMAIN_NOT_CONFIGURED";
+    constructor(requestId: string);
+}
+export declare class CrossOriginEnvelopePolicyError extends Error {
+    readonly code = "BFF_CROSS_ORIGIN_ENVELOPE_NOT_ALLOWED";
+    constructor(requestId: string, sourceOrigin?: string, targetOrigin?: string);
+}
+export declare class IdentityBindingViolationError extends Error {
+    readonly code = "BFF_IDENTITY_BINDING_VIOLATION";
+    readonly violation: IdentityBindingViolation;
+    constructor(violation: IdentityBindingViolation);
+}
+export declare class OperationContractViolationError extends Error {
+    readonly code = "BFF_OPERATION_CONTRACT_VIOLATION";
+    readonly violation: OperationContractViolation;
+    constructor(violation: OperationContractViolation);
+}
+export declare const validateOperationContract: ({ requestId, target, contextPayload, operationContract, }: {
+    requestId: string;
+    target: TransportTarget;
+    contextPayload: OperationContextPayload;
+    operationContract: OperationContractOptions | undefined;
+}) => void;
+export declare const resolveConfiguredRequest: <F>(configuredRequests: Map<string, F>, requestId: string, fallback: F) => F;
+/**
+ * Builds the JSON value for the `x-modernjs-bff-envelope` header and throws
+ * when the cross-origin envelope policy denies the flow. Returns the
+ * serialized envelope.
+ */
+export declare const buildEnvelopeHeaderValue: ({ requestId, target, sourceOrigin, targetOrigin, traceContext, allowCrossOriginEnvelope, }: {
+    requestId: string;
+    target: TransportTarget;
+    sourceOrigin: string | undefined;
+    targetOrigin: string | undefined;
+    traceContext: {
+        traceId: string;
+        spanId: string;
+    } | null | undefined;
+    allowCrossOriginEnvelope: boolean | ((options: {
+        requestId: string;
+        sourceOrigin?: string;
+        targetOrigin?: string;
+        target: TransportTarget;
+    }) => boolean) | undefined;
+}) => string;
+/**
+ * Derives the operation context for a secured requestId, validates it against
+ * the configured operation contract and writes the `x-operation-id` and
+ * `x-modernjs-bff-operation-context` headers (without clobbering caller
+ * provided values for the id header).
+ */
+export declare const attachOperationContextHeaders: ({ headers, requestId, target, method, path, operationContext, operationContract, operationContextHeader, operationContextDetailHeader, }: {
+    headers: Record<string, any>;
+    requestId: string;
+    target: TransportTarget;
+    method: string;
+    path: string;
+    operationContext: OperationContext | undefined;
+    operationContract: OperationContractOptions | undefined;
+    operationContextHeader: string;
+    operationContextDetailHeader: string;
+}) => {
+    requestId: string;
+    operationId: string;
+    routePath: string;
+    method: string;
+    schemaHash?: string | undefined;
+    operationVersion?: number | undefined;
+    traceparent?: string | undefined;
+    traceId?: string | undefined;
+    spanId?: string | undefined;
+};
+export {};

package/dist/types/request-policy/requestContext.d.ts

@@ -0,0 +1,22 @@
+import type { OperationContext } from './types.js';
+export declare const BFF_LOCALE_HEADER = "accept-language";
+export declare const BFF_TRACEPARENT_HEADER = "traceparent";
+export type RequestContextInput = {
+    headers?: Record<string, unknown>;
+    locale?: string;
+    traceparent?: string;
+    operationContext?: OperationContext;
+};
+export type RequestContextSnapshot = {
+    headers: Record<string, string>;
+    locale?: string;
+    traceparent?: string;
+    traceId?: string;
+    spanId?: string;
+    operationContext?: OperationContext;
+};
+export declare function createRequestContextSnapshot(input?: RequestContextInput): RequestContextSnapshot;
+export declare function createRequestContextHeaders(input?: RequestContextInput): Record<string, string>;
+export { parseTraceparent, type TraceparentContext } from './traceparent.js';
+export type * from './types.js';
+export { BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS, BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, } from './types.js';

package/dist/types/request-policy/traceparent.d.ts

@@ -0,0 +1,10 @@
+export type TraceparentContext = {
+    traceId: string;
+    spanId: string;
+    sampled: boolean;
+};
+/**
+ * Parse a W3C trace context `traceparent` header (version 00).
+ * All-zero trace ids and span ids are rejected per the W3C spec.
+ */
+export declare function parseTraceparent(traceparent: string | undefined | null): TraceparentContext | undefined;

package/dist/types/request-policy/transport.d.ts

@@ -0,0 +1,12 @@
+import type { TransportResilienceOptions, TransportTarget } from './types.js';
+type ExecuteWithResilienceOptions = {
+    requestId: string;
+    target: TransportTarget;
+    method: string;
+    url: string;
+    init: Record<string, any>;
+    fetcher: (...args: any[]) => Promise<any>;
+    transport?: TransportResilienceOptions;
+};
+export declare const executeWithResilience: ({ requestId, target, method, url, init, fetcher, transport, }: ExecuteWithResilienceOptions) => Promise<any>;
+export {};

package/dist/types/request-policy/types.d.ts

@@ -0,0 +1,144 @@
+import type { HttpMethodDecider, IOptions as NativeOptions, RequestCreatorOptions as NativeRequestCreatorOptions, UploadCreatorOptions as NativeUploadCreatorOptions, Sender } from '@modern-js/create-request/client';
+export type { BFFRequestPayload, HttpMethodDecider, Sender, } from '@modern-js/create-request/client';
+export declare const BFF_ENVELOPE_HEADER = "x-modernjs-bff-envelope";
+export declare const BFF_OPERATION_CONTEXT_HEADER = "x-operation-id";
+export declare const BFF_OPERATION_CONTEXT_DETAIL_HEADER = "x-modernjs-bff-operation-context";
+export declare const BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS: readonly ['x-tenant-id', 'x-subject-id', 'x-user-id', "x-operation-id"];
+export type ResolveHeadersOptions = {
+    requestId: string;
+    allowedHeaders: string[];
+    incomingHeaders: Record<string, any>;
+};
+export type ResolveHeaders = (options: ResolveHeadersOptions) => Record<string, any> | void;
+export type AllowCrossOriginEnvelopeOptions = {
+    requestId: string;
+    sourceOrigin?: string;
+    targetOrigin?: string;
+    target: 'server' | 'browser';
+};
+export type AllowCrossOriginEnvelope = boolean | ((options: AllowCrossOriginEnvelopeOptions) => boolean);
+export type TransportTarget = 'server' | 'browser';
+export type RetryDecisionContext = {
+    requestId: string;
+    target: TransportTarget;
+    method: string;
+    url: string;
+    attempt: number;
+    maxAttempts: number;
+    error: unknown;
+    statusCode?: number;
+};
+export type RetryBackoffOptions = {
+    retries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitterRatio?: number;
+    retryableStatusCodes?: number[];
+    shouldRetry?: (context: RetryDecisionContext) => boolean;
+};
+export type DegradedModeReason = 'timeout' | 'retry' | 'retry_exhausted';
+export type DegradedModeEvent = {
+    requestId: string;
+    target: TransportTarget;
+    method: string;
+    url: string;
+    reason: DegradedModeReason;
+    attempt: number;
+    maxAttempts: number;
+    timeoutMs?: number;
+    backoffMs?: number;
+    statusCode?: number;
+    error?: unknown;
+};
+export type TransportResilienceOptions = {
+    timeoutMs?: number;
+    retry?: RetryBackoffOptions;
+    onDegraded?: (event: DegradedModeEvent) => void;
+};
+export type IdentityBindingViolationReason = 'client_override_blocked' | 'client_override_rejected';
+export type IdentityBindingViolation = {
+    requestId: string;
+    target: TransportTarget;
+    header: string;
+    reason: IdentityBindingViolationReason;
+    attemptedValue?: unknown;
+    derivedValue?: unknown;
+};
+export type DeriveIdentityHeadersOptions = {
+    requestId: string;
+    target: TransportTarget;
+    incomingHeaders: Record<string, any>;
+    protectedHeaders: string[];
+};
+export type IdentityBindingOptions = {
+    enabled?: boolean;
+    strict?: boolean;
+    protectedHeaders?: string[];
+    deriveHeaders?: (options: DeriveIdentityHeadersOptions) => Record<string, any> | void;
+    onViolation?: (violation: IdentityBindingViolation) => void;
+};
+export type OperationContractViolationReason = 'missing_schema_hash' | 'missing_operation_version';
+export type OperationContractViolation = {
+    requestId: string;
+    target: TransportTarget;
+    operationId: string;
+    reason: OperationContractViolationReason;
+    routePath?: string;
+    method?: string;
+    schemaHash?: string;
+    operationVersion?: number;
+};
+export type CrossProjectOperationContract = {
+    schemaHash?: string;
+    operationVersion?: number;
+};
+export type CrossProjectPolicyViolationReason = 'missing_envelope' | 'invalid_envelope' | 'missing_request_id' | 'namespace_not_allowed' | 'missing_operation_context' | 'operation_context_mismatch' | 'missing_operation_context_details' | 'invalid_operation_context_details' | 'operation_context_details_request_id_mismatch' | 'missing_operation_schema_hash' | 'missing_operation_version' | 'unknown_operation_contract' | 'operation_schema_hash_mismatch' | 'operation_version_mismatch' | 'producer_identity_mismatch';
+export type CrossProjectPolicyViolation = {
+    code: 'BFF_CROSS_PROJECT_POLICY_DENIED';
+    reason: CrossProjectPolicyViolationReason;
+    message: string;
+    status: number;
+};
+export type OperationContractOptions = {
+    enabled?: boolean;
+    strict?: boolean;
+    requireSchemaHash?: boolean;
+    requireOperationVersion?: boolean;
+    onViolation?: (violation: OperationContractViolation) => void;
+};
+export type OperationContextSource = 'client' | 'server' | 'generated-client' | 'effect-server' | 'data-platform' | 'unknown';
+export type OperationContext = {
+    requestId?: string;
+    operationId?: string;
+    routePath?: string;
+    method?: string;
+    schemaHash?: string;
+    operationVersion?: number;
+    locale?: string;
+    traceparent?: string;
+    traceId?: string;
+    spanId?: string;
+    source?: OperationContextSource;
+    scope?: Record<string, unknown>;
+    sessionClaims?: Record<string, unknown>;
+    attributes?: Record<string, unknown>;
+};
+export type RequestCreatorOptions<F = typeof fetch> = Omit<NativeRequestCreatorOptions<F>, 'hooks'> & {
+    operationContext?: OperationContext;
+};
+export type RequestCreator<F = typeof fetch> = {
+    (options: RequestCreatorOptions<F>): Sender;
+    (path: string, method: string, port: number, httpMethodDecider?: HttpMethodDecider, fetch?: F, requestId?: string, operationContext?: OperationContext): Sender;
+};
+export type UploadCreatorOptions = Omit<NativeUploadCreatorOptions, 'hooks'> & {
+    operationContext?: OperationContext;
+};
+export type UploadCreator = (options: UploadCreatorOptions) => Sender;
+export type IOptions<F = typeof fetch> = NativeOptions<F> & {
+    resolveHeaders?: ResolveHeaders;
+    transport?: TransportResilienceOptions;
+    requireEnvelope?: boolean;
+    allowCrossOriginEnvelope?: AllowCrossOriginEnvelope;
+    identityBinding?: IdentityBindingOptions;
+    operationContract?: OperationContractOptions;
+};

package/dist/types/routeHydration.d.ts

@@ -0,0 +1,24 @@
+type RouteAssetManifest = {
+    assets?: string[];
+};
+export type RouteManifestLike = {
+    routeAssets?: Record<string, RouteAssetManifest | undefined>;
+};
+export type ScriptChunkLike = {
+    filename?: string;
+    url?: string;
+};
+export declare function getMatchedRouteChunks<T>(routeManifest: RouteManifestLike | undefined, matchedRouteIds: readonly string[], routeAssetToChunk: (asset: string) => T): T[];
+export declare const orderHydrationScriptChunks: <T extends ScriptChunkLike>({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
+    asyncEntryChunks: T[];
+    collectedChunks: T[];
+    matchedRouteChunks: T[];
+    entryName: string;
+}) => T[];
+export declare function injectBeforeHydrationEntryScript(template: string, scripts: string, entryName?: string): string;
+export declare function replaceChunkJsPlaceholder(template: string, scripts: string, entryName: string | undefined, placeholder: string): string;
+export declare function createRouteHydrationScriptTags(routeManifest: RouteManifestLike | undefined, matchedRouteIds: readonly string[], entryName: string, options?: {
+    nonce?: string;
+    template?: string;
+}): string;
+export {};

package/dist/types/routerPrefetchPolicy.d.ts

@@ -0,0 +1,28 @@
+type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+type PrefetchState = {
+    code: boolean;
+    data: boolean;
+};
+/** Policy-only contract: native links supply elements, route inputs and loads. */
+export declare function createRouterPrefetchPolicy(): {
+    canWarmup: () => boolean;
+    allowData(route: unknown): boolean;
+    observe({ element, prefetch: inputPrefetch, preload: inputPreload, notify, }: {
+        element: HTMLAnchorElement | null;
+        prefetch?: PrefetchBehavior;
+        preload?: PrefetchBehavior | false;
+        notify: (state: PrefetchState) => void;
+    }): {
+        onIntent(): void;
+        onCancel(): void;
+        dispose(): void;
+    };
+    schedule({ runtimeContext, chunkLoader, publicPath, key: operationKey, run, }: {
+        runtimeContext: object;
+        chunkLoader: object;
+        publicPath: string;
+        key: string;
+        run: () => Promise<unknown>;
+    }): () => void;
+};
+export {};

package/dist/types/routerProvider.d.ts

@@ -0,0 +1,55 @@
+/** Structural plugin contract; the composing integration supplies native hooks. */
+export type RouterProviderPlugin = {
+    name?: string;
+    registryHooks?: Record<string, unknown>;
+    setup?: (api: any) => unknown;
+    [key: string]: unknown;
+};
+/**
+ * Guard for the wrapper plugin (`router/internal`): a resolved provider is
+ * only invoked through `setup`, so registry hooks outside the canonical
+ * router hook contract cannot be registered for it. Returns the offending
+ * hook names and warns once so they are surfaced instead of silently dropped.
+ */
+export declare function reportUnsupportedProviderRegistryHooks(providerPlugin: {
+    name?: string;
+    registryHooks?: Record<string, unknown>;
+}, routerProviderRegistryHooks: Record<string, unknown>): string[];
+export type RouterProviderFactory = (userConfig?: any) => RouterProviderPlugin;
+export type RouterProviderRegistration = {
+    name: string;
+    factory: RouterProviderFactory;
+    isDefault?: boolean;
+};
+/**
+ * App-owned provider catalog. Provider factories close over their module graph,
+ * so they must be resolved from the runtime wrapper that owns the app instead
+ * of from a page-global first-registration winner.
+ */
+export type RouterProviderRealm = Readonly<{
+    defaultProvider?: string;
+    get: (name: string) => RouterProviderFactory | undefined;
+    names: () => readonly string[];
+}>;
+export declare function createRouterProviderRealm(registrations: readonly RouterProviderRegistration[]): RouterProviderRealm;
+export declare function resolveRouterProvider(framework: string | undefined, options: {
+    realm: RouterProviderRealm;
+}): RouterProviderFactory;
+/** Compose app-owned providers without importing the native runtime graph. */
+export declare function createRouterPlugin<Hooks extends Record<string, unknown>>({ defaultProvider, registryHooks, localProviders, }: {
+    defaultProvider: {
+        name: string;
+        factory: RouterProviderFactory;
+    };
+    registryHooks: Hooks;
+    localProviders?: readonly Omit<RouterProviderRegistration, 'isDefault'>[];
+}): (userConfig?: Record<string, any>) => {
+    name: string;
+    registryHooks: Hooks;
+    setup(api: {
+        getRuntimeConfig: () => {
+            router?: Record<string, unknown>;
+        };
+        [key: string]: any;
+    }): void;
+};

package/dist/types/routerState.d.ts

@@ -0,0 +1,17 @@
+import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterServerPrepareResult } from './routerStateTypes.js';
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterLifecyclePhase, RouterLinkTarget, RouterNavigationCapability, RouterNavigationSnapshot, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from './routerStateTypes.js';
+export declare function getRouterRuntimeState(runtimeContext: object): InternalRouterRuntimeState | undefined;
+export declare function getRouterServerSnapshot(runtimeContext: object): InternalRouterServerSnapshot | undefined;
+/** Capture prepared metadata once; live router updates cannot rewrite it. */
+export declare function createRouterServerSnapshot(snapshot: InternalRouterServerSnapshot): InternalRouterServerSnapshot;
+/**
+ * Observe the router runtime-state slot for the given runtime context.
+ * Returns an unsubscribe function; safe to call for a context that never
+ * receives a router.
+ */
+export declare function subscribeRouterRuntimeState(runtimeContext: object, listener: () => void): () => void;
+export declare function applyRouterRuntimeState<Context extends object>(runtimeContext: Context, state: InternalRouterRuntimeState): Context;
+export declare function applyRouterServerPrepareResult<Context extends object>(runtimeContext: Context, result: RouterServerPrepareResult): Context;
+export declare function getRouterHydrationScripts(runtimeContext: object): readonly string[];
+export declare function getRouterMatchedRouteIds(runtimeContext: object): readonly string[] | undefined;
+export declare function cleanupRouterRuntimeState(runtimeContext: object): Promise<void>;

package/dist/types/routerStatePlugin.d.ts

@@ -0,0 +1,19 @@
+type RouterLifecycleEvent = {
+    framework: string;
+    phase: string;
+    runtimeContext: object;
+    basename?: string;
+    router?: unknown;
+};
+/** Install fork policy through lifecycle hooks supplied by the native owner. */
+export declare function createRouterStatePlugin<Hooks extends Record<string, unknown>>({ registryHooks, }: {
+    registryHooks: Hooks;
+}): {
+    name: string;
+    registryHooks: Hooks;
+    setup(api: {
+        onBeforeRender: (callback: (context: object) => void) => unknown;
+        onAfterCreateRouter: (callback: (event: RouterLifecycleEvent) => void) => unknown;
+    }): void;
+};
+export {};

package/dist/types/routerStateTypes.d.ts

@@ -0,0 +1,70 @@
+import type React from 'react';
+export type BuiltInRouterFramework = 'react-router' | 'tanstack';
+export type RouterFramework = BuiltInRouterFramework | (string & {});
+export interface RouterRouteMatchSnapshot {
+    routeId: string;
+    assetRouteId?: string;
+    pathname?: string;
+    params?: Record<string, string>;
+}
+export interface InternalRouterServerSnapshot {
+    readonly framework?: RouterFramework;
+    readonly basename?: string;
+    readonly statusCode?: number;
+    readonly errors?: Record<string, unknown>;
+    readonly routerData?: {
+        readonly loaderData?: Record<string, unknown>;
+        readonly errors?: Record<string, unknown>;
+    };
+    readonly hydrationScripts?: readonly string[];
+    readonly matchedRouteIds?: readonly string[];
+    readonly matches?: readonly RouterRouteMatchSnapshot[];
+}
+export interface InternalRouterRuntimeState {
+    framework: RouterFramework;
+    basename?: string;
+    instance?: unknown;
+    navigation?: RouterNavigationCapability;
+    cleanup?: () => void | Promise<void>;
+}
+export interface RouterServerPrepareResult {
+    state: InternalRouterRuntimeState;
+    snapshot?: InternalRouterServerSnapshot;
+    cleanup?: () => void | Promise<void>;
+}
+export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';
+/** Provider-owned browser navigation. Consumers never inspect router internals. */
+export interface RouterNavigationSnapshot {
+    location: {
+        pathname: string;
+        search: string;
+        hash: string;
+    };
+    params: Record<string, string>;
+}
+export interface RouterLinkTarget {
+    pathname: string;
+    href: string;
+    search?: Record<string, unknown>;
+    hash?: string;
+    hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+    prefetch?: 'intent' | 'render' | 'viewport' | 'none';
+    preload?: unknown;
+}
+export interface RouterNavigationCapability {
+    getSnapshot: () => RouterNavigationSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    navigate: (href: string, options?: {
+        replace?: boolean;
+        state?: unknown;
+    }) => void | Promise<void>;
+    Link: React.ComponentType<{
+        to: string;
+        children?: React.ReactNode;
+        [key: string]: unknown;
+    }>;
+    createLinkProps?: (target: RouterLinkTarget) => {
+        to: string;
+        [key: string]: unknown;
+    };
+}

package/dist/types/rsc-disabled/rscDisabledClientBrowserRuntime.d.ts

@@ -0,0 +1,9 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createFromFetch: typeof disabledRscRuntime;
+export declare const createFromReadableStream: typeof disabledRscRuntime;
+export declare const createServerReference: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const encodeReply: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;
+export declare const setFindSourceMapURLCallback: typeof disabledRscRuntime;
+export declare const setServerCallback: typeof disabledRscRuntime;

package/dist/types/rsc-disabled/rscDisabledClientEdgeRuntime.d.ts

@@ -0,0 +1,7 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createFromFetch: typeof disabledRscRuntime;
+export declare const createFromReadableStream: typeof disabledRscRuntime;
+export declare const createServerReference: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const encodeReply: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;

package/dist/types/rsc-disabled/rscDisabledClientNodeRuntime.d.ts

@@ -0,0 +1,8 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createFromFetch: typeof disabledRscRuntime;
+export declare const createFromNodeStream: typeof disabledRscRuntime;
+export declare const createFromReadableStream: typeof disabledRscRuntime;
+export declare const createServerReference: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const encodeReply: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;

package/dist/types/rsc-disabled/rscDisabledRuntimeError.d.ts

@@ -0,0 +1 @@
+export declare function disabledRscRuntime(): never;

package/dist/types/rsc-disabled/rscDisabledServerEdgeRuntime.d.ts

@@ -0,0 +1,15 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createServerEntry: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const decodeAction: typeof disabledRscRuntime;
+export declare const decodeFormState: typeof disabledRscRuntime;
+export declare const decodeReply: typeof disabledRscRuntime;
+export declare const decodeReplyFromAsyncIterable: typeof disabledRscRuntime;
+export declare const decryptServerActionBoundArgs: typeof disabledRscRuntime;
+export declare const encryptServerActionBoundArgs: typeof disabledRscRuntime;
+export declare const ensureServerActions: typeof disabledRscRuntime;
+export declare const loadServerAction: typeof disabledRscRuntime;
+export declare const registerClientReference: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;
+export declare const renderToReadableStream: typeof disabledRscRuntime;
+export declare const setServerActionBoundArgsEncryption: typeof disabledRscRuntime;

package/dist/types/rsc-disabled/rscDisabledServerNodeRuntime.d.ts

@@ -0,0 +1,17 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createServerEntry: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const decodeAction: typeof disabledRscRuntime;
+export declare const decodeFormState: typeof disabledRscRuntime;
+export declare const decodeReply: typeof disabledRscRuntime;
+export declare const decodeReplyFromAsyncIterable: typeof disabledRscRuntime;
+export declare const decodeReplyFromBusboy: typeof disabledRscRuntime;
+export declare const decryptServerActionBoundArgs: typeof disabledRscRuntime;
+export declare const encryptServerActionBoundArgs: typeof disabledRscRuntime;
+export declare const ensureServerActions: typeof disabledRscRuntime;
+export declare const loadServerAction: typeof disabledRscRuntime;
+export declare const registerClientReference: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;
+export declare const renderToPipeableStream: typeof disabledRscRuntime;
+export declare const renderToReadableStream: typeof disabledRscRuntime;
+export declare const setServerActionBoundArgsEncryption: typeof disabledRscRuntime;

package/dist/types/runtimeContextProjection.d.ts

@@ -0,0 +1,30 @@
+interface ProjectionContext {
+    isBrowser?: boolean;
+    ssrContext?: {
+        request: {
+            url?: unknown;
+            userAgent?: unknown;
+            cookie?: unknown;
+            pathname?: unknown;
+            query?: object;
+            params?: object;
+            headers?: object;
+            host?: unknown;
+            referer?: unknown;
+        };
+        response: {
+            locals?: unknown;
+        };
+    };
+}
+export declare function projectRuntimeContext<InternalContext extends ProjectionContext, PublicContext extends ProjectionContext>(projection: {
+    internalContext: InternalContext;
+    publicContext: PublicContext;
+}, options: {
+    context: InternalContext;
+    isRsc: boolean;
+}): {
+    internalContext: InternalContext;
+    publicContext: PublicContext;
+};
+export {};