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

package/dist/esm/data-platform/batch/telemetry.mjs

@@ -0,0 +1,27 @@
+import { trace } from "@opentelemetry/api";
+const DATA_BATCH_TRANSPORT_OTEL_EVENT = 'modernjs.data.batch';
+function createDataBatchTransportTelemetryAttributes(event) {
+    return {
+        'modernjs.data.batch.type': event.type,
+        'modernjs.data.batch.endpoint': event.endpoint,
+        'modernjs.data.batch.degraded': 'fallback' === event.type || 'disable' === event.type,
+        ...event.batchId ? {
+            'modernjs.data.batch.id': event.batchId
+        } : {},
+        ...'number' == typeof event.size ? {
+            'modernjs.data.batch.size': event.size
+        } : {},
+        ...event.reason ? {
+            'modernjs.data.batch.reason': event.reason
+        } : {}
+    };
+}
+function emitDataBatchTransportEvent(onEvent, event) {
+    try {
+        onEvent?.(event);
+    } catch  {}
+    try {
+        trace.getActiveSpan()?.addEvent(DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes(event));
+    } catch  {}
+}
+export { DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes, emitDataBatchTransportEvent };

package/dist/esm/data-platform/batch/url.mjs

@@ -0,0 +1,25 @@
+import { DEFAULT_DATA_BATCH_ENDPOINT } from "../types.mjs";
+function resolveRuntimeOrigin() {
+    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
+    if ("u" > typeof globalThis && globalThis.location && 'string' == typeof globalThis.location?.origin) return globalThis.location.origin;
+    return 'http://localhost';
+}
+function toAbsoluteUrl(input) {
+    if (input instanceof URL) return input;
+    if ("u" > typeof Request && input instanceof Request) return new URL(input.url);
+    const value = String(input);
+    try {
+        return new URL(value);
+    } catch  {
+        return new URL(value, resolveRuntimeOrigin());
+    }
+}
+function normalizeBatchEndpoint(requestUrl, endpoint) {
+    const value = endpoint || DEFAULT_DATA_BATCH_ENDPOINT;
+    try {
+        return new URL(value);
+    } catch  {
+        return new URL(value, requestUrl.origin);
+    }
+}
+export { normalizeBatchEndpoint, resolveRuntimeOrigin, toAbsoluteUrl };

package/dist/esm/data-platform/batch-transport.mjs

@@ -0,0 +1,12 @@
+import { createBatchTransportQueue } from "./batch/queue.mjs";
+function createDataBatchTransport(options = {}) {
+    const fallbackFetch = 'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
+    const baseFetch = options.fetch || fallbackFetch;
+    if (!baseFetch) throw new Error('createDataBatchTransport requires a fetch implementation');
+    return createBatchTransportQueue({
+        options,
+        baseFetch
+    });
+}
+export { DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes, emitDataBatchTransportEvent } from "./batch/telemetry.mjs";
+export { createDataBatchTransport };

package/dist/esm/data-platform/codec.mjs

@@ -0,0 +1,90 @@
+function isPlainObject(value) {
+    if ('object' != typeof value || null === value || Array.isArray(value)) return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || null === proto;
+}
+function canonicalize(value) {
+    if (Array.isArray(value)) return value.map((item)=>canonicalize(item));
+    if (isPlainObject(value)) return Object.keys(value).sort().reduce((acc, key)=>{
+        acc[key] = canonicalize(value[key]);
+        return acc;
+    }, {});
+    return value;
+}
+function stableStringify(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function encodeRequestEnvelopeHeader(envelope) {
+    return encodeURIComponent(stableStringify(envelope));
+}
+function isRequestEnvelopeShape(value) {
+    if (!isPlainObject(value)) return false;
+    return 1 === value.protocolVersion && 'string' == typeof value.operationId && 'string' == typeof value.appNamespace && 'string' == typeof value.origin && 'string' == typeof value.scopeKey && 'string' == typeof value.inputHash && 'number' == typeof value.timestamp;
+}
+function decodeRequestEnvelopeHeader(value) {
+    try {
+        const decoded = decodeURIComponent(value);
+        const parsed = JSON.parse(decoded);
+        if (!isRequestEnvelopeShape(parsed)) return null;
+        return parsed;
+    } catch  {
+        return null;
+    }
+}
+function hashString(value) {
+    let hash = 0x811c9dc5;
+    for(let index = 0; index < value.length; index++){
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+function sanitizeSegment(segment) {
+    const normalized = segment.trim().replace(/[^a-zA-Z0-9_-]+/g, '_');
+    return normalized.length > 0 ? normalized : 'unknown';
+}
+function normalizeOrigin(origin) {
+    const normalized = origin.trim();
+    try {
+        const url = new URL(normalized);
+        return `${url.protocol}//${url.host}`.toLowerCase();
+    } catch  {
+        return normalized.toLowerCase();
+    }
+}
+function normalizeOperationDescriptor(input) {
+    return {
+        appNamespace: sanitizeSegment(input.appNamespace),
+        apiId: sanitizeSegment(input.apiId),
+        group: sanitizeSegment(input.group),
+        endpoint: sanitizeSegment(input.endpoint),
+        schemaHash: input.schemaHash || null,
+        version: input.version ?? 1
+    };
+}
+function createOperationId(input) {
+    const descriptor = normalizeOperationDescriptor(input);
+    const readable = `${descriptor.appNamespace}.${descriptor.apiId}.${descriptor.group}.${descriptor.endpoint}.v${String(descriptor.version)}`;
+    return `${readable}:${hashString(stableStringify(descriptor))}`;
+}
+function buildScopeKey(scope) {
+    const canonical = {
+        appNamespace: sanitizeSegment(scope.appNamespace),
+        origin: normalizeOrigin(scope.origin),
+        tenantId: scope.tenantId ?? null,
+        userId: scope.userId ?? null,
+        sessionId: scope.sessionId ?? null
+    };
+    return `${canonical.appNamespace}:${hashString(stableStringify(canonical))}`;
+}
+function buildQueryKey(input) {
+    const canonical = {
+        operationId: input.operationId,
+        scopeKey: input.scopeKey,
+        requestMode: input.requestMode ?? 'cache-first',
+        requestInput: input.requestInput ?? null,
+        selectionPlan: input.selectionPlan ?? null
+    };
+    return `${input.operationId}:${hashString(stableStringify(canonical))}`;
+}
+export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, hashString, isPlainObject, normalizeOrigin, sanitizeSegment, stableStringify };

package/dist/esm/data-platform/index.mjs

@@ -0,0 +1,7 @@
+export { measureTextBytes, normalizeMethod } from "./batch/request.mjs";
+export { DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransport, createDataBatchTransportTelemetryAttributes, emitDataBatchTransportEvent } from "./batch-transport.mjs";
+export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, isPlainObject, normalizeOrigin, stableStringify } from "./codec.mjs";
+export { createInvalidationEvent, shouldApplyInvalidation } from "./invalidation.mjs";
+export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader } from "./trace.mjs";
+export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER } from "./types.mjs";
+export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan } from "./validation.mjs";

package/dist/esm/data-platform/invalidation.mjs

@@ -0,0 +1,20 @@
+import { buildScopeKey, createOperationId, sanitizeSegment } from "./codec.mjs";
+function createInvalidationEvent(input) {
+    return {
+        sourceNamespace: sanitizeSegment(input.sourceOperation.appNamespace),
+        sourceOperationId: createOperationId(input.sourceOperation),
+        scopeKey: buildScopeKey(input.sourceScope),
+        targetNamespaces: input.targetNamespaces?.map((namespace)=>sanitizeSegment(namespace)),
+        targetOperationIds: input.targetOperations?.map((operation)=>createOperationId(operation))
+    };
+}
+function shouldApplyInvalidation(event, subscriber) {
+    if (subscriber.scopeKey && subscriber.scopeKey !== event.scopeKey) return false;
+    const sameNamespace = subscriber.namespace === event.sourceNamespace;
+    const allowedCrossNamespace = true === subscriber.acceptCrossNamespace && event.targetNamespaces?.includes(subscriber.namespace) === true;
+    if (!sameNamespace && !allowedCrossNamespace) return false;
+    if (!subscriber.operationIds || 0 === subscriber.operationIds.length) return true;
+    if (!event.targetOperationIds || 0 === event.targetOperationIds.length) return true;
+    return subscriber.operationIds.some((operationId)=>event.targetOperationIds?.includes(operationId));
+}
+export { createInvalidationEvent, shouldApplyInvalidation };

package/dist/esm/data-platform/trace.mjs

@@ -0,0 +1,29 @@
+import { parseTraceparent } from "@modern-js/create-request";
+function isAllZeroHex(value) {
+    return /^0+$/.test(value);
+}
+function isValidHex(value, length) {
+    return value.length === length && /^[0-9a-f]+$/.test(value);
+}
+function parseTraceparentHeader(header) {
+    return parseTraceparent(header) ?? null;
+}
+function formatTraceparentHeader(trace) {
+    const traceId = trace.traceId.toLowerCase();
+    const spanId = trace.spanId.toLowerCase();
+    if (!isValidHex(traceId, 32) || !isValidHex(spanId, 16)) throw new Error('Invalid trace context: traceId/spanId format mismatch');
+    if (isAllZeroHex(traceId) || isAllZeroHex(spanId)) throw new Error('Invalid trace context: traceId/spanId cannot be zero');
+    const flags = trace.sampled ? '01' : '00';
+    return `00-${traceId}-${spanId}-${flags}`;
+}
+function deriveChildTraceContext(parent, childSpanId) {
+    const normalizedSpanId = childSpanId.toLowerCase();
+    if (!isValidHex(normalizedSpanId, 16) || isAllZeroHex(normalizedSpanId)) throw new Error('Invalid child span id');
+    return {
+        traceId: parent.traceId.toLowerCase(),
+        spanId: normalizedSpanId,
+        sampled: parent.sampled,
+        parentSpanId: parent.spanId.toLowerCase()
+    };
+}
+export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader };

package/dist/esm/data-platform/types.mjs

@@ -0,0 +1,4 @@
+const DEFAULT_DATA_ENVELOPE_HEADER = 'x-modernjs-data-envelope';
+const DEFAULT_DATA_BATCH_ENDPOINT = '/_data/batch';
+const DEFAULT_DATA_BATCH_HEADER = 'x-modernjs-data-batch';
+export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER };

package/dist/esm/data-platform/validation.mjs

@@ -0,0 +1,128 @@
+import { buildScopeKey, createOperationId, hashString, isPlainObject, normalizeOrigin, sanitizeSegment, stableStringify } from "./codec.mjs";
+import { formatTraceparentHeader, parseTraceparentHeader } from "./trace.mjs";
+function validateSelectionPlan(plan, options = {}) {
+    const maxDepthLimit = options.maxDepth ?? 8;
+    const maxFieldsLimit = options.maxFields ?? 256;
+    const allowedLeafPaths = options.allowedLeafPaths ? new Set(options.allowedLeafPaths) : null;
+    const errors = [];
+    let maxDepth = 0;
+    let fieldCount = 0;
+    const walk = (node, path)=>{
+        if (!isPlainObject(node)) return void errors.push(`Selection node at "${path.join('.') || '<root>'}" must be an object`);
+        const keys = Object.keys(node);
+        if (0 === keys.length) return void errors.push(`Selection node at "${path.join('.') || '<root>'}" cannot be empty`);
+        for (const key of keys){
+            fieldCount += 1;
+            if (fieldCount > maxFieldsLimit) return void errors.push(`Selection has too many fields: ${String(fieldCount)} > ${String(maxFieldsLimit)}`);
+            const nextPath = [
+                ...path,
+                key
+            ];
+            const depth = nextPath.length;
+            if (depth > maxDepth) maxDepth = depth;
+            if (depth > maxDepthLimit) return void errors.push(`Selection exceeds maxDepth at "${nextPath.join('.')}" (${String(depth)} > ${String(maxDepthLimit)})`);
+            const value = node[key];
+            if (true === value) {
+                if (allowedLeafPaths && !allowedLeafPaths.has(nextPath.join('.'))) errors.push(`Unknown selected field "${nextPath.join('.')}"`);
+                continue;
+            }
+            if (!isPlainObject(value)) {
+                errors.push(`Invalid selection value at "${nextPath.join('.')}"; expected true or nested object`);
+                continue;
+            }
+            walk(value, nextPath);
+        }
+    };
+    walk(plan, []);
+    return {
+        ok: 0 === errors.length,
+        errors,
+        stats: {
+            maxDepth,
+            fieldCount
+        }
+    };
+}
+function createRequestEnvelope(input) {
+    if (input.requireTraceContext && !input.traceContext) throw new Error('Trace context is required for this request envelope');
+    const traceparent = input.traceContext ? formatTraceparentHeader(input.traceContext) : void 0;
+    const envelope = {
+        protocolVersion: input.protocolVersion ?? 1,
+        operationId: createOperationId(input.operation),
+        appNamespace: sanitizeSegment(input.scope.appNamespace),
+        origin: normalizeOrigin(input.scope.origin),
+        requestMode: input.requestMode ?? 'cache-first',
+        mutationMode: input.mutationMode,
+        scopeKey: buildScopeKey(input.scope),
+        input: input.requestInput,
+        inputHash: hashString(stableStringify(input.requestInput ?? null)),
+        selectionPlan: input.selectionPlan,
+        selectionHash: input.selectionPlan ? hashString(stableStringify(input.selectionPlan)) : void 0,
+        traceparent,
+        timestamp: input.timestamp ?? Date.now()
+    };
+    return envelope;
+}
+function validateRequestEnvelope(envelope, options = {}) {
+    const errors = [];
+    if (void 0 !== options.expectedProtocolVersion && envelope.protocolVersion !== options.expectedProtocolVersion) errors.push(`Protocol mismatch: expected ${String(options.expectedProtocolVersion)} but received ${String(envelope.protocolVersion)}`);
+    if (options.expectedNamespace && envelope.appNamespace !== options.expectedNamespace) errors.push(`Namespace mismatch: expected ${options.expectedNamespace} but received ${envelope.appNamespace}`);
+    if (options.expectedOrigin) {
+        const expectedOrigin = normalizeOrigin(options.expectedOrigin);
+        if (envelope.origin !== expectedOrigin) errors.push(`Origin mismatch: expected ${expectedOrigin} but received ${envelope.origin}`);
+    }
+    if (!envelope.operationId) errors.push('Missing operationId');
+    if (!envelope.scopeKey) errors.push('Missing scopeKey');
+    if (options.requireTraceContext && !envelope.traceparent) errors.push('Missing trace context');
+    if (envelope.traceparent && !parseTraceparentHeader(envelope.traceparent)) errors.push('Invalid traceparent header');
+    const computedInputHash = hashString(stableStringify(envelope.input ?? null));
+    if (computedInputHash !== envelope.inputHash) errors.push('Input hash mismatch');
+    if (envelope.selectionPlan) {
+        const computedSelectionHash = hashString(stableStringify(envelope.selectionPlan));
+        if (computedSelectionHash !== envelope.selectionHash) errors.push('Selection hash mismatch');
+    }
+    return {
+        ok: 0 === errors.length,
+        errors
+    };
+}
+function createHydrationEnvelope(input) {
+    const envelopeWithoutChecksum = {
+        protocolVersion: input.protocolVersion ?? 1,
+        runtimeVersion: input.runtimeVersion,
+        appNamespace: sanitizeSegment(input.scope.appNamespace),
+        origin: normalizeOrigin(input.scope.origin),
+        createdAt: input.createdAt ?? Date.now(),
+        payload: input.payload
+    };
+    const checksum = hashString(stableStringify(envelopeWithoutChecksum));
+    return {
+        ...envelopeWithoutChecksum,
+        checksum
+    };
+}
+function validateHydrationEnvelope(envelope, options = {}) {
+    const errors = [];
+    if (void 0 !== options.expectedProtocolVersion && envelope.protocolVersion !== options.expectedProtocolVersion) errors.push(`Protocol mismatch: expected ${String(options.expectedProtocolVersion)} but received ${String(envelope.protocolVersion)}`);
+    if (options.expectedNamespace && envelope.appNamespace !== options.expectedNamespace) errors.push(`Namespace mismatch: expected ${options.expectedNamespace} but received ${envelope.appNamespace}`);
+    if (options.expectedOrigin) {
+        const expectedOrigin = normalizeOrigin(options.expectedOrigin);
+        if (envelope.origin !== expectedOrigin) errors.push(`Origin mismatch: expected ${expectedOrigin} but received ${envelope.origin}`);
+    }
+    if (options.expectedRuntimeVersion && envelope.runtimeVersion !== options.expectedRuntimeVersion) errors.push(`Runtime version mismatch: expected ${options.expectedRuntimeVersion} but received ${envelope.runtimeVersion}`);
+    const checksumBase = {
+        protocolVersion: envelope.protocolVersion,
+        runtimeVersion: envelope.runtimeVersion,
+        appNamespace: envelope.appNamespace,
+        origin: envelope.origin,
+        createdAt: envelope.createdAt,
+        payload: envelope.payload
+    };
+    const checksum = hashString(stableStringify(checksumBase));
+    if (checksum !== envelope.checksum) errors.push('Hydration checksum mismatch');
+    return {
+        ok: 0 === errors.length,
+        errors
+    };
+}
+export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan };

package/dist/esm/effect/context.mjs

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createEffectOperationContext, kEffectContextStorage } from "./operation-context.mjs";
+const globalStore = globalThis;
+const effectContextStorage = globalStore[kEffectContextStorage] ?? (globalStore[kEffectContextStorage] = new AsyncLocalStorage());
+const runWithEffectContext = (context, cb)=>effectContextStorage.run(context, cb);
+const useEffectContext = ()=>{
+    const context = effectContextStorage.getStore();
+    if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
+    return context;
+};
+const useOperationContext = ()=>useEffectContext().operationContext;
+export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm/effect/dispatch.mjs

@@ -0,0 +1,63 @@
+import { createSafeFailureResponse } from "@modern-js/runtime-extensions/safe-failure";
+import { createEffectOperationContext } from "./operation-context.mjs";
+function normalizeEffectBffPrefix(prefix) {
+    if (!prefix || '/' === prefix) return '';
+    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+}
+function removeEffectBffPrefixFromPath(pathname, prefix) {
+    const normalized = normalizeEffectBffPrefix(prefix);
+    if (!normalized || pathname !== normalized && !pathname.startsWith(`${normalized}/`)) return pathname;
+    const sliced = pathname.slice(normalized.length);
+    return sliced.startsWith('/') ? sliced : `/${sliced}`;
+}
+function matchesEffectBffPrefix(pathname, prefix) {
+    const normalized = normalizeEffectBffPrefix(prefix);
+    return !normalized || pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function createEffectBffMountedRequest(req, prefix) {
+    const url = new URL(req.url);
+    const nextPath = removeEffectBffPrefixFromPath(url.pathname, prefix);
+    if (nextPath !== url.pathname) {
+        url.pathname = nextPath;
+        return new Request(url, req);
+    }
+    return req;
+}
+function createEffectBffDispatchContext(originalRequest, mountedRequest, options) {
+    const path = options.path ?? new URL(originalRequest.url).pathname;
+    const method = options.method ?? originalRequest.method;
+    const env = options.env ?? {};
+    return {
+        request: mountedRequest,
+        env,
+        path,
+        method,
+        operationContext: createEffectOperationContext({
+            request: mountedRequest,
+            env,
+            path,
+            method
+        })
+    };
+}
+async function dispatchEffectBffRequestWithContext(handler, request, options) {
+    const requestPath = new URL(request.url).pathname;
+    if (!matchesEffectBffPrefix(requestPath, options.prefix)) return new Response('', {
+        status: 404
+    });
+    const mountedRequest = createEffectBffMountedRequest(request, options.prefix);
+    const effectContext = createEffectBffDispatchContext(request, mountedRequest, options);
+    try {
+        const response = await options.runWithEffectContext(effectContext, ()=>handler(mountedRequest, effectContext));
+        if (!(response instanceof Response)) throw new Error('[BFF][Effect] Effect handler must return Response instance.');
+        return new Response(response.body, response);
+    } catch (error) {
+        if (error instanceof Response) return new Response(error.body, error);
+        if (options.onError) {
+            const errorResponse = await options.onError(error, effectContext);
+            if (errorResponse instanceof Response) return errorResponse;
+        }
+        return createSafeFailureResponse(error);
+    }
+}
+export { dispatchEffectBffRequestWithContext };

package/dist/esm/effect/edge-context.mjs

@@ -0,0 +1,14 @@
+import { createEffectOperationContext, kEffectContextStorage } from "./operation-context.mjs";
+const globalStore = globalThis;
+const asyncHooks = globalStore.process?.getBuiltinModule?.('node:async_hooks');
+const AsyncLocalStorage = asyncHooks?.AsyncLocalStorage;
+if ('function' != typeof AsyncLocalStorage) throw new Error('[BFF][Effect] The edge runtime must provide AsyncLocalStorage. Enable Node.js compatibility or the nodejs_als compatibility flag.');
+const effectContextStorage = globalStore[kEffectContextStorage] ?? (globalStore[kEffectContextStorage] = new AsyncLocalStorage());
+const runWithEffectContext = (context, cb)=>effectContextStorage.run(context, cb);
+const useEffectContext = ()=>{
+    const context = effectContextStorage.getStore();
+    if (!context) throw new Error("Can't call useEffectContext out of Effect runtime scope");
+    return context;
+};
+const useOperationContext = ()=>useEffectContext().operationContext;
+export { createEffectOperationContext, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm/effect/edge-dispatcher.mjs

@@ -0,0 +1,115 @@
+import { evaluateCrossProjectPolicy, resolveCrossProjectRequestObservation } from "@modern-js/bff-core/security/cross-project-policy";
+import { toHeaderRecord } from "../headers.mjs";
+import { dispatchEffectBffRequestWithContext } from "./dispatch.mjs";
+import { runWithEffectContext, useEffectContext, useOperationContext } from "./edge-context.mjs";
+import { resolveEffectBffModuleHandler } from "./module.mjs";
+import * as __rspack_external_effect_Config_76cfa59d from "effect/Config";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
+import * as __rspack_external_effect_Option_0498e63a from "effect/Option";
+import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
+const NORMALIZED_POLICY_BOOLEAN_FIELDS = [
+    'enabled',
+    'requireEnvelope',
+    'requireOperationContext',
+    'requireOperationContextDetails',
+    'requireOperationSchemaHash',
+    'requireOperationVersion',
+    'allowUnknownOperations'
+];
+function assertNormalizedCrossProjectPolicy(policy) {
+    if (void 0 === policy) return;
+    if (!policy || 'object' != typeof policy || Array.isArray(policy)) throw new Error('[BFF][Effect] Edge cross-project policy must be a normalized object.');
+    for (const field of NORMALIZED_POLICY_BOOLEAN_FIELDS)if ('boolean' != typeof policy[field]) throw new Error(`[BFF][Effect] Edge cross-project policy requires boolean ${field}.`);
+    if (!policy.expectedOperationContracts || 'object' != typeof policy.expectedOperationContracts || Array.isArray(policy.expectedOperationContracts)) throw new Error('[BFF][Effect] Edge cross-project policy requires expectedOperationContracts object.');
+}
+function restoreEffectBffMountPath(request, prefix) {
+    const pathname = new URL(request.url).pathname;
+    if (!prefix || '/' === prefix) return pathname;
+    const normalizedPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return '/' === pathname ? normalizedPrefix : `${normalizedPrefix}${pathname}`;
+}
+async function dispatchEffectBffRequest(handler, request, options = {}) {
+    return dispatchEffectBffRequestWithContext(handler, request, {
+        ...options,
+        runWithEffectContext: runWithEffectContext
+    });
+}
+async function createEffectBffEdgeDispatcher(options) {
+    const crossProjectPolicy = options.crossProjectPolicy;
+    assertNormalizedCrossProjectPolicy(crossProjectPolicy);
+    const loaded = await resolveEffectBffModuleHandler(options.module, {
+        openapi: options.openapi,
+        dataPlatform: options.dataPlatform,
+        validateRequest: crossProjectPolicy?.enabled === true ? (request)=>{
+            const pathname = new URL(request.url).pathname;
+            const observedRequest = resolveCrossProjectRequestObservation({
+                method: request.method,
+                pathname
+            }, crossProjectPolicy) ?? {
+                method: request.method,
+                routePath: restoreEffectBffMountPath(request, options.prefix)
+            };
+            const violation = evaluateCrossProjectPolicy(toHeaderRecord(request.headers), crossProjectPolicy, observedRequest);
+            if (!violation) return null;
+            return new Response(JSON.stringify({
+                code: violation.code,
+                reason: violation.reason,
+                message: violation.message
+            }), {
+                status: violation.status,
+                headers: {
+                    'content-type': 'application/json; charset=utf-8'
+                }
+            });
+        } : void 0,
+        onWarning: options.onWarning
+    });
+    if (!loaded) throw new Error('[BFF][Effect] Invalid Effect edge module. Export defineEffectBff(...) or a { api, layer } HttpApi module.');
+    const retiredError = new Error('[BFF][Effect] Edge dispatcher is disposing or has been disposed.');
+    let acceptingRequests = true;
+    let activeDispatches = 0;
+    let resolveDrain;
+    let disposePromise;
+    return {
+        dispatch: (request, dispatchOptions = {})=>{
+            if (!acceptingRequests) return Promise.reject(retiredError);
+            activeDispatches += 1;
+            return dispatchEffectBffRequest(loaded.handler, request, {
+                ...dispatchOptions,
+                prefix: options.prefix,
+                onError: options.onError
+            }).finally(()=>{
+                activeDispatches -= 1;
+                if (0 === activeDispatches) {
+                    resolveDrain?.();
+                    resolveDrain = void 0;
+                }
+            });
+        },
+        dispose: ()=>{
+            disposePromise ??= (async ()=>{
+                acceptingRequests = false;
+                if (activeDispatches > 0) await new Promise((resolve)=>{
+                    resolveDrain = resolve;
+                });
+                await loaded.dispose?.();
+            })();
+            return disposePromise;
+        }
+    };
+}
+const createEffectBffTestHandler = createEffectBffEdgeHandler;
+async function createEffectBffEdgeHandler(options) {
+    const dispatcher = await createEffectBffEdgeDispatcher(options);
+    return {
+        handler: dispatcher.dispatch,
+        dispose: dispatcher.dispose
+    };
+}
+export { Cookies, Etag, FetchHttpClient, FindMyWay, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpEffect, HttpIncomingMessage, HttpMethod, HttpMiddleware, HttpPlatform, HttpRouter, HttpServer, HttpServerError, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer, HttpStatus, HttpTraceContext, Multipart, MultipartParser, Template, Url, UrlParams } from "effect/unstable/http";
+export { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpApiTest, OpenApi } from "effect/unstable/httpapi";
+export { Rpc, RpcClient, RpcClientError, RpcGroup, RpcMessage, RpcMiddleware, RpcSchema, RpcSerialization, RpcServer, RpcTest, RpcWorker, Utils } from "effect/unstable/rpc";
+export { createHttpApiHandler, defineEffectBff, defineEffectRpcBff } from "./handler.mjs";
+export { createEffectOperationContext } from "./operation-context.mjs";
+export { __rspack_external_effect_Config_76cfa59d as Config, __rspack_external_effect_Effect_41060786 as Effect, __rspack_external_effect_Layer_69c46453 as Layer, __rspack_external_effect_Option_0498e63a as Option, __rspack_external_effect_Schema_6065f72d as Schema, createEffectBffEdgeDispatcher, createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, runWithEffectContext, useEffectContext, useOperationContext };

package/dist/esm/effect/edge.mjs

@@ -0,0 +1 @@
+export * from "./edge-dispatcher.mjs";

package/dist/esm/effect/endpoint-contracts.mjs

@@ -0,0 +1,68 @@
+import { createOperationContractHash } from "@modern-js/bff-core";
+import { classifyEffectBffEntryModule, isValidatorAwareHandlerFactory } from "./entry-shape.mjs";
+function resolveEffectEndpointName(endpoint) {
+    if ('string' == typeof endpoint.identifier && endpoint.identifier) return endpoint.identifier;
+    if ('string' == typeof endpoint.name && endpoint.name) return endpoint.name;
+    return '';
+}
+function ensureLeadingSlash(pathname) {
+    return pathname.startsWith('/') ? pathname : `/${pathname}`;
+}
+function normalizeEffectPrefix(prefix) {
+    if ('/' === prefix) return '';
+    return ensureLeadingSlash(prefix || '/api');
+}
+function getEffectRoutePath(prefix, endpointPath) {
+    const normalizedPrefix = normalizeEffectPrefix(prefix);
+    const normalizedEndpointPath = ensureLeadingSlash(endpointPath);
+    const finalEndpointPath = '/' === normalizedEndpointPath ? '' : endpointPath;
+    if (!normalizedPrefix && !finalEndpointPath) return '/';
+    return `${normalizedPrefix}${finalEndpointPath || ''}`;
+}
+function resolveEffectApiId(api) {
+    const fallback = 'EffectHttpApi';
+    if ('identifier' in api && 'string' == typeof api.identifier && api.identifier) return api.identifier;
+    return fallback;
+}
+function collectEffectEndpoints(reflect, api, prefix) {
+    const endpoints = [];
+    const apiId = resolveEffectApiId(api);
+    reflect(api, {
+        onGroup: ()=>{},
+        onEndpoint: ({ group, endpoint })=>{
+            endpoints.push({
+                apiId,
+                groupName: String(group.identifier),
+                endpointName: resolveEffectEndpointName(endpoint),
+                method: String(endpoint.method).toUpperCase(),
+                routePath: getEffectRoutePath(prefix, String(endpoint.path))
+            });
+        }
+    });
+    return endpoints.sort((a, b)=>{
+        if (a.groupName === b.groupName) return a.endpointName.localeCompare(b.endpointName);
+        return a.groupName.localeCompare(b.groupName);
+    });
+}
+function toOperationContractSources(endpoints) {
+    return endpoints.map(createEffectOperationContractSource);
+}
+function createEffectOperationContractSource(endpoint) {
+    return {
+        name: endpoint.endpointName,
+        httpMethod: endpoint.method,
+        routePath: endpoint.routePath
+    };
+}
+async function extractHttpApiFromModule(mod, isHttpApi) {
+    const facts = classifyEffectBffEntryModule(mod, {
+        isRequestHandler: (value)=>'function' == typeof value,
+        isValidatorAwareHandlerFactory: isValidatorAwareHandlerFactory,
+        isHttpApi
+    });
+    return !facts?.legacyShape && facts?.api !== void 0 && facts.hasRuntimeLayer && (void 0 === facts.createHandler || facts.createHandlerValidatorAware) ? facts.api : null;
+}
+function createEffectEndpointContractHash(endpoint, requestId) {
+    return createOperationContractHash(createEffectOperationContractSource(endpoint), requestId);
+}
+export { collectEffectEndpoints, createEffectEndpointContractHash, ensureLeadingSlash, extractHttpApiFromModule, normalizeEffectPrefix, toOperationContractSources };

package/dist/esm/effect/entry-shape-registry.mjs

@@ -0,0 +1,17 @@
+"use strict";
+import { __webpack_require__ } from "../rslib-runtime.mjs";
+__webpack_require__.add({
+    1970 (module) {
+        const validatorAwareHandlerFactories = new WeakSet();
+        module.exports = {
+            register (factory) {
+                validatorAwareHandlerFactories.add(factory);
+                return factory;
+            },
+            is (factory) {
+                return 'function' == typeof factory && validatorAwareHandlerFactories.has(factory);
+            }
+        };
+    }
+});
+__webpack_require__("1970");