@bleedingdev/modern-js-bff-effect 3.8.3-ultramodern.2

package/dist/esm-node/effect-client/index.mjs

@@ -0,0 +1,111 @@
+import "node:module";
+import { createRequestContextHeaders } from "@modern-js/create-request";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
+import { getRpcSerializationLayer } from "../effect/rpcSerialization.mjs";
+import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
+import * as __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 from "effect/unstable/http/HttpClientError";
+import * as __rspack_external_effect_Data_2b3f4efb from "effect/Data";
+import * as __rspack_external_effect_Exit_1ca64b33 from "effect/Exit";
+import * as __rspack_external_effect_ManagedRuntime_bfe218e3 from "effect/ManagedRuntime";
+import * as __rspack_external_effect_Scope_f87b0bd6 from "effect/Scope";
+class EffectRpcClientError extends __rspack_external_effect_Data_2b3f4efb.TaggedError('EffectRpcClientError') {
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function applySelection(value, selection) {
+    if (true === selection || void 0 === selection) return value;
+    if (Array.isArray(value)) return value.map((item)=>applySelection(item, selection));
+    if (!isRecord(value) || !isRecord(selection)) return value;
+    const masked = {};
+    for (const key of Object.keys(selection)){
+        const selected = selection[key];
+        if (void 0 !== selected && key in value && (true === selected || isRecord(selected))) masked[key] = applySelection(value[key], selected);
+    }
+    return masked;
+}
+function view() {
+    return (selection)=>selection;
+}
+function mask(value, selection) {
+    return applySelection(value, selection);
+}
+function runEffectView(request, selection) {
+    return new Promise((resolve, reject)=>{
+        request.then((value)=>resolve(mask(value, selection)), (reason)=>reject(reason));
+    });
+}
+function makeEffectHttpApiClient(api, options) {
+    const requestContextHeaders = createRequestContextHeaders(options?.requestContext);
+    const transformClient = (client)=>{
+        const contextClient = 0 === Object.keys(requestContextHeaders).length ? client : client.pipe(HttpClient.mapRequest((request)=>{
+            let nextRequest = request;
+            for (const [header, value] of Object.entries(requestContextHeaders))if (void 0 === nextRequest.headers[header.toLowerCase()]) nextRequest = HttpClientRequest.setHeader(nextRequest, header, value);
+            return nextRequest;
+        }));
+        return 'function' == typeof options?.transformClient ? options.transformClient(contextClient) : contextClient;
+    };
+    return HttpApiClient.make(api, {
+        baseUrl: options?.baseUrl,
+        transformClient,
+        transformResponse: options?.transformResponse
+    }).pipe(__rspack_external_effect_Effect_41060786.provide(FetchHttpClient.layer));
+}
+function makeEffectRpcClient(group, options) {
+    const protocolLayer = __rspack_external_effect_Layer_69c46453.provide(RpcClient.layerProtocolHttp({
+        url: options.url
+    }), __rspack_external_effect_Layer_69c46453.mergeAll(getRpcSerializationLayer(options.serialization), FetchHttpClient.layer));
+    const middlewareLayer = options.middlewareLayer ?? __rspack_external_effect_Layer_69c46453.empty;
+    const runtimeLayer = __rspack_external_effect_Layer_69c46453.mergeAll(protocolLayer, middlewareLayer);
+    return __rspack_external_effect_Effect_41060786.tryPromise({
+        try: async ()=>{
+            const runtime = __rspack_external_effect_ManagedRuntime_bfe218e3.make(runtimeLayer);
+            let scope;
+            try {
+                const clientScope = await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.make());
+                scope = clientScope;
+                const client = await runtime.runPromise(RpcClient.make(group, {
+                    flatten: options.flatten
+                }).pipe(__rspack_external_effect_Effect_41060786.provideService(__rspack_external_effect_Scope_f87b0bd6.Scope, clientScope)));
+                let disposePromise;
+                const clientWithDispose = Object.assign(client, {
+                    dispose: ()=>{
+                        disposePromise ??= (async ()=>{
+                            let scopeCloseError;
+                            try {
+                                await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.close(clientScope, __rspack_external_effect_Exit_1ca64b33["void"]));
+                            } catch (error) {
+                                scopeCloseError = error;
+                            }
+                            try {
+                                await runtime.dispose();
+                            } catch (error) {
+                                if (void 0 === scopeCloseError) throw error;
+                            }
+                            if (void 0 !== scopeCloseError) throw scopeCloseError;
+                        })();
+                        return disposePromise;
+                    }
+                });
+                return clientWithDispose;
+            } catch (error) {
+                if (void 0 !== scope) try {
+                    await runtime.runPromise(__rspack_external_effect_Scope_f87b0bd6.close(scope, __rspack_external_effect_Exit_1ca64b33["void"]));
+                } catch  {}
+                try {
+                    await runtime.dispose();
+                } catch  {}
+                throw error;
+            }
+        },
+        catch: (error)=>new EffectRpcClientError({
+                cause: error
+            })
+    });
+}
+const runEffectRequest = __rspack_external_effect_Effect_41060786.runPromise;
+export { EffectRpcClientError, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Schema_6065f72d as Schema, __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 as HttpClientError, makeEffectHttpApiClient, makeEffectRpcClient, mask, runEffectRequest, runEffectView, view };

package/dist/esm-node/effect-client/request-context.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { isRecord } from "./guards.mjs";
+const createEffectRequestContext = (createRequestContextHeaders, requestContext)=>{
+    if (!isRecord(requestContext)) return {};
+    const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
+    return {
+        ...requestContext,
+        headers
+    };
+};
+const applyRequestContext = (normalizedRequest, request, createRequestContext)=>{
+    if (!isRecord(request) || !isRecord(request.requestContext)) return normalizedRequest;
+    const requestContext = createRequestContext(request.requestContext);
+    const requestHeaders = isRecord(requestContext.headers) ? requestContext.headers : {};
+    if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
+    return {
+        ...normalizedRequest,
+        headers: {
+            ...isRecord(normalizedRequest.headers) ? normalizedRequest.headers : {},
+            ...requestHeaders
+        }
+    };
+};
+export { applyRequestContext, createEffectRequestContext };

package/dist/esm-node/effect-client/request.mjs

@@ -0,0 +1,29 @@
+import "node:module";
+import { isRecord } from "./guards.mjs";
+const METHODS_WITHOUT_BODY = new Set([
+    'GET',
+    'DELETE',
+    'HEAD',
+    'OPTIONS'
+]);
+const normalizeRequest = (method, request)=>{
+    if (!isRecord(request)) return {};
+    const payload = {
+        ...request
+    };
+    if (isRecord(request.path) && !isRecord(payload.params)) payload.params = request.path;
+    if (isRecord(request.urlParams) && !isRecord(payload.query)) payload.query = request.urlParams;
+    if (isRecord(request.headers) && !isRecord(payload.headers)) payload.headers = request.headers;
+    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
+    else if (METHODS_WITHOUT_BODY.has(method)) {
+        if (isRecord(request.payload)) payload.query = isRecord(payload.query) ? {
+            ...payload.query,
+            ...request.payload
+        } : request.payload;
+        else if (!('body' in payload)) payload.body = request.payload;
+    } else if (!isRecord(request.payload) || 'data' in payload) {
+        if (!('body' in payload)) payload.body = request.payload;
+    } else payload.data = request.payload;
+    return payload;
+};
+export { normalizeRequest };

package/dist/esm-node/effect-client/runtime.mjs

@@ -0,0 +1,63 @@
+import "node:module";
+import { configureGeneratedEffectClientRuntime } from "./batch.mjs";
+import { prepareEffectRequest } from "./envelope.mjs";
+import { createEffectRequestContext as external_request_context_mjs_createEffectRequestContext } from "./request-context.mjs";
+const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
+    const createRequest = requestRuntime.createRequest;
+    const configureRequest = 'function' == typeof requestRuntime.configure ? requestRuntime.configure : void 0;
+    const createRequestContextHeaders = 'function' == typeof requestRuntime.createRequestContextHeaders ? requestRuntime.createRequestContextHeaders : void 0;
+    const httpMethodDecider = config.httpMethodDecider || 'functionName';
+    const port = config.useEnvPort && "u" > typeof process && process.env && process.env.PORT ? process.env.PORT : config.port;
+    configureGeneratedEffectClientRuntime(config, configureRequest);
+    const createEffectRequestContext = (requestContext)=>external_request_context_mjs_createEffectRequestContext(createRequestContextHeaders, requestContext);
+    const client = {};
+    const operationManifest = {};
+    for (const endpoint of manifest.endpoints){
+        const operationId = `${endpoint.method}:${endpoint.routePath}`;
+        const operation = {
+            appNamespace: config.appNamespace,
+            apiId: endpoint.apiId,
+            group: endpoint.group,
+            endpoint: endpoint.endpoint,
+            operationId,
+            routePath: endpoint.routePath,
+            method: endpoint.method,
+            operationVersion: endpoint.operationVersion,
+            schemaHash: endpoint.schemaHash,
+            version: endpoint.operationVersion
+        };
+        const sender = createRequest({
+            path: endpoint.routePath,
+            method: endpoint.method,
+            port,
+            operationContext: {
+                operationId,
+                routePath: endpoint.routePath,
+                method: endpoint.method,
+                schemaHash: endpoint.schemaHash,
+                operationVersion: endpoint.operationVersion
+            },
+            httpMethodDecider,
+            ...config.requestId ? {
+                requestId: config.requestId
+            } : {}
+        });
+        const call = (request = {})=>sender(prepareEffectRequest({
+                endpoint,
+                operation,
+                request,
+                config,
+                createEffectRequestContext
+            }));
+        client[endpoint.group] ??= {};
+        client[endpoint.group][endpoint.endpoint] = call;
+        operationManifest[endpoint.group] ??= {};
+        operationManifest[endpoint.group][endpoint.endpoint] = operation;
+    }
+    return {
+        client,
+        operationManifest,
+        createEffectRequestContext
+    };
+};
+export { createGeneratedEffectClient };

package/dist/esm-node/effect-client/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/headers.mjs

@@ -0,0 +1,9 @@
+import "node:module";
+function toHeaderRecord(headers) {
+    const record = {};
+    headers.forEach((value, key)=>{
+        record[key] = value;
+    });
+    return record;
+}
+export { toHeaderRecord };

package/dist/esm-node/index.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+import * as __rspack_external__data_platform_index_mjs_e91ceab4 from "./data-platform/index.mjs";
+import * as __rspack_external__effect_client_index_mjs_a83cfa33 from "./effect-client/index.mjs";
+export * from "./effect/index.mjs";
+export { __rspack_external__data_platform_index_mjs_e91ceab4 as DataPlatform, __rspack_external__effect_client_index_mjs_a83cfa33 as EffectClient };

package/dist/esm-node/rslib-runtime.mjs

@@ -0,0 +1,19 @@
+import "node:module";
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+export { __webpack_require__ };

package/dist/types/data-platform/batch/protocol.d.ts

@@ -0,0 +1,9 @@
+import type { DataBatchBody, DataBatchHeader, DataBatchResponseItem } from '../types';
+export declare function encodeBatchBody(bytes: Uint8Array): DataBatchBody;
+export declare function encodeBatchText(value: string): DataBatchBody;
+export declare function decodeBatchBody(body: DataBatchBody): Uint8Array<ArrayBuffer>;
+export declare function isBatchBody(value: unknown): value is DataBatchBody;
+export declare function isBatchHeaderList(value: unknown): value is DataBatchHeader[];
+export declare function isNullBodyStatus(status: number): boolean;
+export declare function toBatchResponseHeaders(headers: Headers): DataBatchHeader[];
+export declare function toBatchResponseItem(id: string, response: Response, omitBody?: boolean): Promise<DataBatchResponseItem>;

package/dist/types/data-platform/batch/queue.d.ts

@@ -0,0 +1,47 @@
+import type { DataBatchRequestItem, DataBatchTransportOptions, DataTransportRequestInfo } from '../types';
+type DataBatchFetch = NonNullable<DataBatchTransportOptions['fetch']>;
+type CreateBatchTransportQueueOptions = {
+    options: DataBatchTransportOptions;
+    baseFetch: DataBatchFetch;
+    bucketRegistry?: BatchBucketRegistry;
+};
+type RequestLifetime = {
+    signal: AbortSignal;
+    timedOut: boolean;
+    dispose: () => void;
+};
+type QueuedBatchRequest = {
+    key: string;
+    bucketKey: string;
+    endpoint: string;
+    requestInput: DataTransportRequestInfo;
+    requestInit: RequestInit;
+    authorization: string | undefined;
+    cookie: string | undefined;
+    credentials: RequestCredentials;
+    item: DataBatchRequestItem;
+    lifetime: RequestLifetime;
+    phase: 'queued' | 'flushing' | 'settled';
+    promise: Promise<unknown>;
+    abortListener: () => void;
+    abortBatchIfUnused?: () => void;
+    resolve: (value: unknown) => void;
+    reject: (reason: unknown) => void;
+};
+type BatchBucket = {
+    items: QueuedBatchRequest[];
+    bytes: number;
+    batchId: string;
+    sentAt: number;
+    timer: ReturnType<typeof setTimeout> | null;
+    flushing: boolean;
+};
+export declare class BatchBucketRegistry {
+    private readonly buckets;
+    get size(): number;
+    get(bucketKey: string): BatchBucket | undefined;
+    ensure(bucketKey: string): BatchBucket;
+    releaseIfIdle(bucketKey: string, bucket: BatchBucket): boolean;
+}
+export declare function createBatchTransportQueue({ options, baseFetch, bucketRegistry, }: CreateBatchTransportQueueOptions): (input: DataTransportRequestInfo, init?: RequestInit) => Promise<any>;
+export {};

package/dist/types/data-platform/batch/request.d.ts

@@ -0,0 +1,19 @@
+import type { DataBatchBody } from '../types';
+export declare function toHeaderRecord(headers: HeadersInit | undefined): Record<string, string>;
+export declare function measureTextBytes(value: string): number;
+export declare function createBatchId(): string;
+export declare function normalizeMethod(method: string | undefined): string;
+export type PreparedBatchRequestBody = {
+    body: DataBatchBody | undefined;
+    inferredContentType: string | undefined;
+    batchable: boolean;
+};
+export declare function toRequestBody(initBody: BodyInit | null | undefined): Promise<PreparedBatchRequestBody>;
+export declare function shouldBatchRequest(input: {
+    method: string;
+    body: string | undefined;
+    headers: Record<string, string>;
+    allowedMethods: Set<string>;
+    batchEndpoint: string;
+    requestUrl: URL;
+}): boolean;

package/dist/types/data-platform/batch/response.d.ts

@@ -0,0 +1,3 @@
+import type { DataBatchResponsePayload } from '../types';
+export declare function isBatchResponsePayload(value: unknown): value is DataBatchResponsePayload;
+export declare function parseResponseLikeCreateRequest(response: Response): Promise<any>;

package/dist/types/data-platform/batch/telemetry.d.ts

@@ -0,0 +1,4 @@
+import type { DataBatchTransportEvent, DataBatchTransportTelemetryAttributes } from '../types';
+export declare const DATA_BATCH_TRANSPORT_OTEL_EVENT = "modernjs.data.batch";
+export declare function createDataBatchTransportTelemetryAttributes(event: DataBatchTransportEvent): DataBatchTransportTelemetryAttributes;
+export declare function emitDataBatchTransportEvent(onEvent: ((event: DataBatchTransportEvent) => void) | undefined, event: DataBatchTransportEvent): void;

package/dist/types/data-platform/batch/url.d.ts

@@ -0,0 +1,4 @@
+import type { DataTransportRequestInfo } from '../types';
+export declare function resolveRuntimeOrigin(): string;
+export declare function toAbsoluteUrl(input: DataTransportRequestInfo): URL;
+export declare function normalizeBatchEndpoint(requestUrl: URL, endpoint: string | undefined): URL;

package/dist/types/data-platform/batch-transport.d.ts

@@ -0,0 +1,3 @@
+import type { DataBatchTransportOptions } from './types';
+export { createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch/telemetry';
+export declare function createDataBatchTransport(options?: DataBatchTransportOptions): (input: import("./types").DataTransportRequestInfo, init?: RequestInit) => Promise<any>;

package/dist/types/data-platform/codec.d.ts

@@ -0,0 +1,17 @@
+import type { CacheScope, DataRequestMode, OperationDescriptor, RequestEnvelope, SelectionPlan } from './types';
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function stableStringify(value: unknown): string;
+export declare function encodeRequestEnvelopeHeader(envelope: RequestEnvelope): string;
+export declare function decodeRequestEnvelopeHeader(value: string): RequestEnvelope | null;
+export declare function hashString(value: string): string;
+export declare function sanitizeSegment(segment: string): string;
+export declare function normalizeOrigin(origin: string): string;
+export declare function createOperationId(input: OperationDescriptor): string;
+export declare function buildScopeKey(scope: CacheScope): string;
+export declare function buildQueryKey(input: {
+    operationId: string;
+    scopeKey: string;
+    requestMode?: DataRequestMode;
+    requestInput?: unknown;
+    selectionPlan?: SelectionPlan;
+}): string;

package/dist/types/data-platform/index.d.ts

@@ -0,0 +1,8 @@
+export { measureTextBytes, normalizeMethod } from './batch/request';
+export { createDataBatchTransport, createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch-transport';
+export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, isPlainObject, normalizeOrigin, stableStringify, } from './codec';
+export { createInvalidationEvent, shouldApplyInvalidation, } from './invalidation';
+export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader, } from './trace';
+export type { CacheScope, DataBatchBody, DataBatchHeader, DataBatchRequestItem, DataBatchRequestPayload, DataBatchResponseItem, DataBatchResponsePayload, DataBatchTransportEvent, DataBatchTransportOptions, DataBatchTransportTelemetryAttributes, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, InvalidationEvent, InvalidationSubscriber, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext, } from './types';
+export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, } from './types';
+export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan, } from './validation';

package/dist/types/data-platform/invalidation.d.ts

@@ -0,0 +1,8 @@
+import type { CacheScope, InvalidationEvent, InvalidationSubscriber, OperationDescriptor } from './types';
+export declare function createInvalidationEvent(input: {
+    sourceOperation: OperationDescriptor;
+    sourceScope: CacheScope;
+    targetNamespaces?: string[];
+    targetOperations?: OperationDescriptor[];
+}): InvalidationEvent;
+export declare function shouldApplyInvalidation(event: InvalidationEvent, subscriber: InvalidationSubscriber): boolean;

package/dist/types/data-platform/trace.d.ts

@@ -0,0 +1,4 @@
+import type { TraceContext } from './types';
+export declare function parseTraceparentHeader(header: string): TraceContext | null;
+export declare function formatTraceparentHeader(trace: TraceContext): string;
+export declare function deriveChildTraceContext(parent: TraceContext, childSpanId: string): TraceContext;

package/dist/types/data-platform/types.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Data-platform envelope (`x-modernjs-data-envelope`): the TRANSPORT/CACHE
+ * contract of the effect lane — protocol versioning, cache scope keys,
+ * selection plans, batching and hydration checksums.
+ *
+ * Boundary note (one envelope system per concern): cross-project
+ * AUTHORIZATION is the bff-core policy's job (`x-modernjs-bff-envelope` +
+ * operation contracts, evaluated server-side in both the hono and effect
+ * lanes). Nothing in this module is a trust boundary; treat every value
+ * here as client-asserted cache metadata.
+ */
+export type DataRequestMode = 'cache-first' | 'stale-while-revalidate' | 'network-only';
+export type DataMutationMode = 'optimistic' | 'pessimistic' | 'fire-and-forget';
+export type SelectionPlan = {
+    [field: string]: true | SelectionPlan;
+};
+export interface OperationDescriptor {
+    appNamespace: string;
+    apiId: string;
+    group: string;
+    endpoint: string;
+    schemaHash?: string;
+    version?: number;
+}
+export interface CacheScope {
+    appNamespace: string;
+    origin: string;
+    tenantId?: string;
+    userId?: string;
+    sessionId?: string;
+}
+export interface TraceContext {
+    traceId: string;
+    spanId: string;
+    sampled: boolean;
+    parentSpanId?: string;
+}
+export interface RequestEnvelope<Input = unknown> {
+    protocolVersion: 1;
+    operationId: string;
+    appNamespace: string;
+    origin: string;
+    requestMode: DataRequestMode;
+    mutationMode?: DataMutationMode;
+    scopeKey: string;
+    input: Input;
+    inputHash: string;
+    selectionPlan?: SelectionPlan;
+    selectionHash?: string;
+    traceparent?: string;
+    timestamp: number;
+}
+export interface HydrationEnvelope<Payload = unknown> {
+    protocolVersion: 1;
+    runtimeVersion: string;
+    appNamespace: string;
+    origin: string;
+    createdAt: number;
+    payload: Payload;
+    checksum: string;
+}
+export interface InvalidationEvent {
+    sourceNamespace: string;
+    sourceOperationId: string;
+    scopeKey: string;
+    targetNamespaces?: string[];
+    targetOperationIds?: string[];
+}
+export interface InvalidationSubscriber {
+    namespace: string;
+    operationIds?: string[];
+    scopeKey?: string;
+    acceptCrossNamespace?: boolean;
+}
+export interface DataBatchRequestItem {
+    id: string;
+    path: string;
+    method: string;
+    headers?: Record<string, string>;
+    body?: DataBatchBody;
+}
+export interface DataBatchRequestPayload {
+    protocolVersion: 2;
+    batchId: string;
+    sentAt: number;
+    items: DataBatchRequestItem[];
+}
+export interface DataBatchResponseItem {
+    id: string;
+    status: number;
+    headers?: DataBatchHeader[];
+    body?: DataBatchBody;
+}
+export interface DataBatchBody {
+    encoding: 'base64';
+    data: string;
+}
+export type DataBatchHeader = [name: string, value: string];
+export interface DataBatchResponsePayload {
+    protocolVersion: 2;
+    batchId: string;
+    receivedAt: number;
+    items: DataBatchResponseItem[];
+}
+export interface DataBatchTransportEvent {
+    type: 'enqueue' | 'flush' | 'fallback' | 'disable';
+    endpoint: string;
+    batchId?: string;
+    size?: number;
+    reason?: string;
+}
+export type DataBatchTransportTelemetryAttributes = Record<string, string | number | boolean>;
+export interface DataBatchTransportOptions {
+    endpoint?: string;
+    fetch?: (input: DataTransportRequestInfo, init?: RequestInit) => Promise<Response>;
+    flushIntervalMs?: number;
+    maxBatchSize?: number;
+    maxBatchBytes?: number;
+    requestTimeoutMs?: number;
+    allowedMethods?: string[];
+    onEvent?: (event: DataBatchTransportEvent) => void;
+}
+export interface SelectionPlanValidationOptions {
+    maxDepth?: number;
+    maxFields?: number;
+    allowedLeafPaths?: ReadonlyArray<string>;
+}
+export interface SelectionPlanValidationResult {
+    ok: boolean;
+    errors: string[];
+    stats: {
+        maxDepth: number;
+        fieldCount: number;
+    };
+}
+export interface RequestEnvelopeValidationOptions {
+    expectedProtocolVersion?: number;
+    expectedNamespace?: string;
+    expectedOrigin?: string;
+    requireTraceContext?: boolean;
+}
+export interface HydrationEnvelopeValidationOptions {
+    expectedProtocolVersion?: number;
+    expectedNamespace?: string;
+    expectedOrigin?: string;
+    expectedRuntimeVersion?: string;
+}
+export declare const DEFAULT_DATA_ENVELOPE_HEADER = "x-modernjs-data-envelope";
+export declare const DEFAULT_DATA_BATCH_ENDPOINT = "/_data/batch";
+export declare const DEFAULT_DATA_BATCH_HEADER = "x-modernjs-data-batch";
+export type DataTransportRequestInfo = string | URL | Request;

package/dist/types/data-platform/validation.d.ts

@@ -0,0 +1,29 @@
+import type { CacheScope, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext } from './types';
+export declare function validateSelectionPlan(plan: SelectionPlan, options?: SelectionPlanValidationOptions): SelectionPlanValidationResult;
+export declare function createRequestEnvelope<Input>(input: {
+    operation: OperationDescriptor;
+    scope: CacheScope;
+    requestInput: Input;
+    selectionPlan?: SelectionPlan;
+    requestMode?: DataRequestMode;
+    mutationMode?: DataMutationMode;
+    traceContext?: TraceContext;
+    requireTraceContext?: boolean;
+    timestamp?: number;
+    protocolVersion?: 1;
+}): RequestEnvelope<Input>;
+export declare function validateRequestEnvelope(envelope: RequestEnvelope, options?: RequestEnvelopeValidationOptions): {
+    ok: boolean;
+    errors: string[];
+};
+export declare function createHydrationEnvelope<Payload>(input: {
+    runtimeVersion: string;
+    scope: Pick<CacheScope, 'appNamespace' | 'origin'>;
+    payload: Payload;
+    createdAt?: number;
+    protocolVersion?: 1;
+}): HydrationEnvelope<Payload>;
+export declare function validateHydrationEnvelope(envelope: HydrationEnvelope, options?: HydrationEnvelopeValidationOptions): {
+    ok: boolean;
+    errors: string[];
+};

package/dist/types/effect/context.d.ts

@@ -0,0 +1,5 @@
+import { type EffectContext } from './operation-context';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
+export declare const runWithEffectContext: <T>(context: EffectContext, cb: () => T) => T;
+export declare const useEffectContext: () => EffectContext;
+export declare const useOperationContext: () => import("@modern-js/create-request").OperationContext;

package/dist/types/effect/dispatch.d.ts

@@ -0,0 +1,13 @@
+import type { EffectBffRequestHandler } from './module';
+import { type EffectContext } from './operation-context';
+type EffectDispatchContextRunner = <T>(context: EffectContext, cb: () => T) => T;
+export type DispatchEffectBffRequestOptions = {
+    prefix?: string;
+    env?: Record<string, unknown>;
+    path?: string;
+    method?: string;
+    runWithEffectContext: EffectDispatchContextRunner;
+    onError?: (error: unknown, context: EffectContext) => Promise<Response> | Response;
+};
+export declare function dispatchEffectBffRequestWithContext(handler: EffectBffRequestHandler, request: Request, options: DispatchEffectBffRequestOptions): Promise<Response>;
+export {};

package/dist/types/effect/edge-context.d.ts

@@ -0,0 +1,5 @@
+import { type EffectContext } from './operation-context';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
+export declare const runWithEffectContext: <T>(context: EffectContext, cb: () => T) => T;
+export declare const useEffectContext: () => EffectContext;
+export declare const useOperationContext: () => import("@modern-js/create-request").OperationContext;