@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/esm-node/utils/effectClientGenerator.mjs

@@ -1,251 +1,2 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { deriveOperationVersion } from "@modern-js/bff-core";
-import { compatibleRequire, findExists, fs, logger } from "@modern-js/utils";
-import path from "path";
-import { collectEffectEndpoints, createEffectEndpointContractHash, ensureLeadingSlash, extractHttpApiFromModule, normalizeEffectPrefix } from "../runtime/effect/endpoint-contracts.mjs";
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-const DEFAULT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
-const EFFECT_CLIENT_RUNTIME_IMPORT = '@modern-js/plugin-bff/effect-client-runtime';
-let httpApiRuntimePromise;
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function isAbsoluteUrl(value) {
-    try {
-        new URL(value);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-function resolveBatchEndpoint(prefix, endpoint) {
-    const value = endpoint || '/_data/batch';
-    if (isAbsoluteUrl(value)) return value;
-    const normalizedPrefix = normalizeEffectPrefix(prefix);
-    const normalizedEndpoint = ensureLeadingSlash(value);
-    if (!normalizedPrefix) return normalizedEndpoint;
-    if (normalizedEndpoint === normalizedPrefix || normalizedEndpoint.startsWith(`${normalizedPrefix}/`)) return normalizedEndpoint;
-    return `${normalizedPrefix}${'/' === normalizedEndpoint ? '' : normalizedEndpoint}`;
-}
-function getPackageInfo(appDir) {
-    try {
-        const packageJsonPath = path.resolve(appDir, './package.json');
-        const packageJson = fs.readJSONSync(packageJsonPath);
-        return {
-            name: packageJson.name,
-            version: packageJson.version
-        };
-    } catch  {
-        return {};
-    }
-}
-async function getHttpApiRuntime() {
-    if (!httpApiRuntimePromise) httpApiRuntimePromise = (async ()=>{
-        let mod;
-        try {
-            mod = await compatibleRequire('effect/unstable/httpapi', false);
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (!message.includes("Cannot find module 'effect/unstable/httpapi'")) throw error;
-            const effectPackageJson = require.resolve('effect/package.json');
-            const effectHttpApiRuntimePath = path.join(path.dirname(effectPackageJson), 'dist', 'unstable', 'httpapi', 'index.js');
-            mod = await compatibleRequire(effectHttpApiRuntimePath, false);
-        }
-        if (isRecord(mod) && isRecord(mod.HttpApi)) {
-            const maybeHttpApi = mod.HttpApi;
-            if ('function' == typeof maybeHttpApi.isHttpApi && 'function' == typeof maybeHttpApi.reflect) return maybeHttpApi;
-        }
-        throw new Error('[BFF][Effect] Unable to resolve HttpApi runtime from effect/unstable/httpapi.');
-    })();
-    return httpApiRuntimePromise;
-}
-async function loadEffectApi(resourcePath) {
-    const httpApiRuntime = await getHttpApiRuntime();
-    const mod = await compatibleRequire(resourcePath, false);
-    return extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi);
-}
-function renderEffectClientCode(endpoints, options) {
-    const requestCreator = options.requestCreator || DEFAULT_REQUEST_CREATOR;
-    const httpMethodDecider = options.httpMethodDecider || 'functionName';
-    const packageInfo = getPackageInfo(options.appDir);
-    const packageName = packageInfo.name;
-    const dataPlatformAppNamespace = packageName || 'unknown-app';
-    const requestId = 'bundle' === options.target ? packageName || process.env.npm_package_name : void 0;
-    const normalizedRequestId = requestId || 'default';
-    const operationVersion = deriveOperationVersion(packageInfo.version);
-    const batchConfig = options.dataPlatformBatch;
-    const batchEndpoint = resolveBatchEndpoint(options.prefix, batchConfig?.endpoint);
-    const manifest = {
-        endpoints: endpoints.map((endpoint)=>({
-                apiId: endpoint.apiId,
-                group: endpoint.groupName,
-                endpoint: endpoint.endpointName,
-                method: endpoint.method,
-                routePath: endpoint.routePath,
-                schemaHash: createEffectEndpointContractHash(endpoint, normalizedRequestId),
-                operationVersion
-            }))
-    };
-    const config = {
-        appNamespace: dataPlatformAppNamespace,
-        ...requestId ? {
-            requestId
-        } : {},
-        port: options.port,
-        useEnvPort: 'server' === options.target,
-        defaultOrigin: `http://localhost:${String(options.port)}`,
-        httpMethodDecider,
-        batch: {
-            enabled: batchConfig?.enabled ?? true,
-            endpoint: batchEndpoint,
-            flushIntervalMs: batchConfig?.flushIntervalMs ?? 8,
-            maxBatchSize: batchConfig?.maxBatchSize ?? 16,
-            maxBatchBytes: batchConfig?.maxBatchBytes ?? 65536,
-            requestTimeoutMs: batchConfig?.requestTimeoutMs ?? 10000,
-            allowedMethods: batchConfig?.allowedMethods && batchConfig.allowedMethods.length > 0 ? batchConfig.allowedMethods : [
-                'GET'
-            ]
-        }
-    };
-    return `import * as __requestRuntime from ${JSON.stringify(requestCreator)};
-import { createGeneratedEffectClient } from ${JSON.stringify(EFFECT_CLIENT_RUNTIME_IMPORT)};
-
-const __manifest = ${JSON.stringify(manifest, null, 2)};
-
-const __config = ${JSON.stringify(config, null, 2)};
-
-const __generated = createGeneratedEffectClient(__manifest, __config, __requestRuntime);
-
-const client = __generated.client;
-const operationManifest = __generated.operationManifest;
-const createEffectRequestContext = __generated.createEffectRequestContext;
-const apiModule = {
-  client,
-  operationManifest,
-  createEffectRequestContext,
-};
-
-export { client, createEffectRequestContext, operationManifest };
-export default apiModule;
-`;
-}
-function renderClientShape(endpoints, valueType) {
-    if (0 === endpoints.length) return `Record<string, Record<string, ${valueType}>>`;
-    const groups = new Map();
-    for (const endpoint of endpoints){
-        const group = groups.get(endpoint.groupName) || [];
-        group.push(endpoint.endpointName);
-        groups.set(endpoint.groupName, group);
-    }
-    const groupEntries = [
-        ...groups.entries()
-    ].map(([groupName, names])=>{
-        const endpointEntries = names.map((name)=>`    ${JSON.stringify(name)}: ${valueType};`).join('\n');
-        return `  ${JSON.stringify(groupName)}: {\n${endpointEntries}\n  };`;
-    });
-    return `{\n${groupEntries.join('\n')}\n}`;
-}
-function renderEffectClientDeclaration(endpoints = []) {
-    return `export type EffectClientOperation = (
-  request?: unknown,
-) => Promise<unknown>;
-export type EffectClientGroup = Record<string, EffectClientOperation>;
-export type EffectClient = Record<string, EffectClientGroup>;
-export type EffectOperationDescriptor = {
-  appNamespace: string;
-  apiId: string;
-  group: string;
-  endpoint: string;
-  operationId: string;
-  routePath: string;
-  method: string;
-  operationVersion: number;
-  schemaHash: string;
-  version: number;
-};
-export type EffectOperationManifest = Record<
-  string,
-  Record<string, EffectOperationDescriptor>
->;
-export type EffectOperationContext = {
-  requestId?: string;
-  operationId?: string;
-  routePath?: string;
-  method?: string;
-  schemaHash?: string;
-  operationVersion?: number;
-  locale?: string;
-  traceparent?: string;
-  traceId?: string;
-  spanId?: string;
-  source?: string;
-  scope?: Record<string, unknown>;
-  sessionClaims?: Record<string, unknown>;
-  attributes?: Record<string, unknown>;
-};
-export type EffectRequestContext = {
-  headers?: Record<string, string>;
-  locale?: string;
-  operationContext?: EffectOperationContext;
-  traceparent?: string;
-  traceId?: string;
-  spanId?: string;
-};
-export type GeneratedEffectClient = ${renderClientShape(endpoints, 'EffectClientOperation')};
-export type GeneratedEffectOperationManifest = ${renderClientShape(endpoints, "EffectOperationDescriptor")};
-
-export declare const client: GeneratedEffectClient;
-export declare const createEffectRequestContext: (
-  requestContext: Record<string, unknown>,
-) => EffectRequestContext;
-export declare const operationManifest: GeneratedEffectOperationManifest;
-declare const apiModule: {
-  client: GeneratedEffectClient;
-  createEffectRequestContext: typeof createEffectRequestContext;
-  operationManifest: GeneratedEffectOperationManifest;
-};
-
-export default apiModule;
-`;
-}
-async function generateEffectClient(options) {
-    const api = await loadEffectApi(options.resourcePath);
-    if (!api) {
-        logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
-        return null;
-    }
-    const httpApiRuntime = await getHttpApiRuntime();
-    const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
-    return {
-        code: renderEffectClientCode(endpoints, options),
-        declaration: renderEffectClientDeclaration(endpoints),
-        endpoints
-    };
-}
-async function generateEffectClientCode(options) {
-    const artifacts = await generateEffectClient(options);
-    return artifacts ? artifacts.code : null;
-}
-function resolveEffectEntryFile(options) {
-    const { appDir, apiDir, effectEntry } = options;
-    const resolveEntry = (entryWithoutExt)=>{
-        if (path.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
-        return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
-    };
-    if (effectEntry) {
-        const entryWithoutExt = path.isAbsolute(effectEntry) ? effectEntry : path.resolve(appDir, effectEntry);
-        return resolveEntry(entryWithoutExt);
-    }
-    return resolveEntry(path.resolve(apiDir, 'index'));
-}
-export { generateEffectClient, generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile };
+import "node:module";
+export { generateEffectClient, generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile } from "./effect-client-generator/index.mjs";

package/dist/types/cli/compress.d.ts

@@ -0,0 +1,2 @@
+import type { ToolsDevServerConfig } from '@modern-js/builder';
+export declare const createCompressConfig: (devServer: ToolsDevServerConfig | undefined, prefix: string | string[] | undefined) => false | import("@rsbuild/core").CompressOptions | undefined;

package/dist/types/cli/generator.d.ts

@@ -0,0 +1,7 @@
+import type { AppTools } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+export declare const createBffGenerator: (api: CLIPluginAPI<AppTools>) => {
+    compileApi: () => Promise<void>;
+    generate: () => Promise<void>;
+    handleCrossProjectInvocation: (isBuild?: boolean) => Promise<void>;
+};

package/dist/types/cli/prefix.d.ts

@@ -0,0 +1,2 @@
+export declare const normalizePrefixList: (prefix: string | string[] | undefined) => string[];
+export declare const getPrimaryPrefix: (prefix: string | string[] | undefined) => string;

package/dist/types/cli/watch.d.ts

@@ -0,0 +1 @@
+export declare const isWatchableBffFile: (filename: string) => boolean;

package/dist/types/cli.d.ts

@@ -1,3 +1,2 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 export declare const bffPlugin: () => CliPlugin<AppTools>;
-export default bffPlugin;

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

@@ -0,0 +1,25 @@
+import type { DataBatchRequestItem, DataBatchTransportOptions, DataTransportRequestInfo } from '../types';
+type DataBatchFetch = NonNullable<DataBatchTransportOptions['fetch']>;
+type CreateBatchTransportQueueOptions = {
+    options: DataBatchTransportOptions;
+    baseFetch: DataBatchFetch;
+};
+export type QueuedBatchRequest = {
+    key: string;
+    endpoint: string;
+    requestUrl: string;
+    requestInit: RequestInit;
+    item: DataBatchRequestItem;
+    size: number;
+    resolve: (value: unknown) => void;
+    reject: (reason: unknown) => void;
+};
+export type BatchBucket = {
+    items: QueuedBatchRequest[];
+    bytes: number;
+    timer: ReturnType<typeof setTimeout> | null;
+    flushing: boolean;
+};
+export declare function ensureBucket(buckets: Map<string, BatchBucket>, endpoint: string): BatchBucket;
+export declare function createBatchTransportQueue({ options, baseFetch, }: CreateBatchTransportQueueOptions): (input: DataTransportRequestInfo, init?: RequestInit) => Promise<any>;
+export {};

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

@@ -0,0 +1,13 @@
+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 declare function toRequestBody(initBody: BodyInit | null | undefined): string | undefined;
+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/runtime/data-platform/batch/response.d.ts

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

package/dist/types/runtime/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/runtime/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/runtime/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/runtime/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/runtime/data-platform/index.d.ts

@@ -1,191 +1,7 @@
-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?: string;
-}
-export interface DataBatchRequestPayload {
-    protocolVersion: 1;
-    batchId: string;
-    sentAt: number;
-    items: DataBatchRequestItem[];
-}
-export interface DataBatchResponseItem {
-    id: string;
-    status: number;
-    headers?: Record<string, string>;
-    body?: string;
-}
-export interface DataBatchResponsePayload {
-    protocolVersion: 1;
-    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 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;
-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";
-type DataTransportRequestInfo = string | URL | Request;
-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 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;
-export declare function parseTraceparentHeader(header: string): TraceContext | null;
-export declare function formatTraceparentHeader(trace: TraceContext): string;
-export declare function deriveChildTraceContext(parent: TraceContext, childSpanId: string): TraceContext;
-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[];
-};
-export declare function createInvalidationEvent(input: {
-    sourceOperation: OperationDescriptor;
-    sourceScope: CacheScope;
-    targetNamespaces?: string[];
-    targetOperations?: OperationDescriptor[];
-}): InvalidationEvent;
-export declare function shouldApplyInvalidation(event: InvalidationEvent, subscriber: InvalidationSubscriber): boolean;
-export declare function createDataBatchTransport(options?: DataBatchTransportOptions): (input: DataTransportRequestInfo, init?: RequestInit) => Promise<any>;
-export {};
+export { createDataBatchTransport, createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch-transport';
+export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, normalizeOrigin, stableStringify, } from './codec';
+export { createInvalidationEvent, shouldApplyInvalidation, } from './invalidation';
+export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader, } from './trace';
+export type { CacheScope, 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/runtime/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/runtime/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;