@bleedingdev/modern-js-plugin-bff 3.8.3-ultramodern.1 → 3.8.3-ultramodern.2

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

@@ -1,257 +0,0 @@
-import "node:module";
-import node_crypto from "node:crypto";
-import node_fs from "node:fs";
-import { builtinModules, createRequire } from "node:module";
-import node_path from "node:path";
-import { pathToFileURL } from "node:url";
-import { build, transform } from "esbuild";
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-const SOURCE_LOADERS = new Map([
-    [
-        '.js',
-        'js'
-    ],
-    [
-        '.jsx',
-        'jsx'
-    ],
-    [
-        '.mjs',
-        'js'
-    ],
-    [
-        '.cjs',
-        'js'
-    ],
-    [
-        '.ts',
-        'ts'
-    ],
-    [
-        '.tsx',
-        'tsx'
-    ],
-    [
-        '.mts',
-        'ts'
-    ],
-    [
-        '.cts',
-        'ts'
-    ]
-]);
-function sourceLoader(args) {
-    return SOURCE_LOADERS.get(node_path.extname(args.path).toLowerCase());
-}
-function preserveSourceModuleSemantics() {
-    return {
-        name: 'modern-js-effect-source-semantics',
-        setup (buildApi) {
-            buildApi.onLoad({
-                filter: /\.[cm]?[jt]sx?$/
-            }, async (args)=>{
-                const loader = sourceLoader(args);
-                if (!loader) return;
-                const source = await node_fs.promises.readFile(args.path, 'utf8');
-                const compiled = await transform(source, {
-                    define: {
-                        'import.meta.url': JSON.stringify(pathToFileURL(args.path).href)
-                    },
-                    jsx: 'automatic',
-                    loader,
-                    sourcefile: args.path,
-                    target: 'node20'
-                });
-                return {
-                    contents: compiled.code,
-                    loader: 'js',
-                    resolveDir: node_path.dirname(args.path)
-                };
-            });
-        }
-    };
-}
-const nodeBuiltins = new Set([
-    ...builtinModules,
-    ...builtinModules.map((name)=>`node:${name}`)
-]);
-const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
-async function isEsmOnlyFile(filename) {
-    const extension = node_path.extname(filename).toLowerCase();
-    if ('.mjs' === extension || '.mts' === extension) return true;
-    if ('.cjs' === extension || '.cts' === extension) return false;
-    let directory = node_path.dirname(filename);
-    while(true){
-        const packagePath = node_path.join(directory, 'package.json');
-        try {
-            const packageJson = JSON.parse(await node_fs.promises.readFile(packagePath, 'utf8'));
-            return 'module' === packageJson.type;
-        } catch (error) {
-            if (!error || 'object' != typeof error || !('code' in error) || 'ENOENT' !== error.code) throw error;
-        }
-        const parent = node_path.dirname(directory);
-        if (parent === directory) return false;
-        directory = parent;
-    }
-}
-function isBareSpecifier(specifier) {
-    return !specifier.startsWith('.') && !specifier.startsWith('/') && !node_path.isAbsolute(specifier);
-}
-function externalizeInstalledDependencies(options) {
-    const runtimeRequire = createRequire(node_path.join(options.runtimeResolveDir, '__modern_effect_entry.cjs'));
-    return {
-        name: 'modern-js-effect-installed-dependencies',
-        setup (buildApi) {
-            buildApi.onResolve({
-                filter: /.*/
-            }, async (args)=>{
-                if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
-                    external: true,
-                    path: args.path
-                } : void 0;
-                const resolution = await buildApi.resolve(args.path, {
-                    importer: args.importer,
-                    kind: args.kind,
-                    namespace: args.namespace,
-                    pluginData: {
-                        ...args.pluginData,
-                        [dependencyResolutionMarker]: true
-                    },
-                    resolveDir: args.resolveDir
-                });
-                if (resolution.errors.length > 0) return {
-                    external: true,
-                    path: args.path
-                };
-                if (resolution.external || !resolution.path) return {
-                    external: true,
-                    path: args.path
-                };
-                const realPath = await node_fs.promises.realpath(resolution.path).catch(()=>resolution.path);
-                if (realPath.includes(`${node_path.sep}node_modules${node_path.sep}`)) {
-                    const runtimeResolution = await buildApi.resolve(args.path, {
-                        importer: '',
-                        kind: args.kind,
-                        namespace: 'file',
-                        pluginData: {
-                            [dependencyResolutionMarker]: true
-                        },
-                        resolveDir: options.runtimeResolveDir
-                    });
-                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) {
-                        if ('cjs' === options.format) {
-                            let requiredPath;
-                            try {
-                                requiredPath = runtimeRequire.resolve(args.path);
-                            } catch  {
-                                requiredPath = runtimeResolution.path;
-                            }
-                            if (await isEsmOnlyFile(requiredPath)) return {
-                                namespace: resolution.namespace,
-                                path: resolution.path,
-                                pluginData: resolution.pluginData,
-                                sideEffects: resolution.sideEffects,
-                                suffix: resolution.suffix,
-                                warnings: resolution.warnings
-                            };
-                        }
-                        return {
-                            external: true,
-                            path: args.path
-                        };
-                    }
-                }
-                return {
-                    namespace: resolution.namespace,
-                    path: resolution.path,
-                    pluginData: resolution.pluginData,
-                    sideEffects: resolution.sideEffects,
-                    suffix: resolution.suffix,
-                    warnings: resolution.warnings
-                };
-            });
-        }
-    };
-}
-async function bundleEffectEntryForNode(options) {
-    await build({
-        absWorkingDir: options.appDir,
-        allowOverwrite: true,
-        bundle: true,
-        entryPoints: [
-            options.entryPath
-        ],
-        format: options.format,
-        logLevel: 'silent',
-        outfile: options.entryPath,
-        platform: 'node',
-        plugins: [
-            externalizeInstalledDependencies({
-                format: options.format,
-                runtimeResolveDir: options.appDir
-            }),
-            preserveSourceModuleSemantics()
-        ],
-        target: 'node20'
-    });
-}
-function isWatchableInput(filename) {
-    return !filename.includes(`${node_path.sep}node_modules${node_path.sep}`) && (SOURCE_LOADERS.has(node_path.extname(filename).toLowerCase()) || '.json' === node_path.extname(filename).toLowerCase());
-}
-function normalizeImportedModule(module) {
-    if (!module || 'object' != typeof module) return module;
-    const namespace = module;
-    const commonJsModule = namespace.default;
-    if (1 === Object.keys(namespace).length && null !== commonJsModule && 'object' == typeof commonJsModule && true === commonJsModule.__esModule) return commonJsModule;
-    return module;
-}
-async function loadEffectBuiltModule(resourcePath) {
-    const canonicalPath = await node_fs.promises.realpath(node_path.resolve(resourcePath));
-    if (!await isEsmOnlyFile(canonicalPath)) return createRequire(canonicalPath)(canonicalPath);
-    return normalizeImportedModule(await dynamicImport(pathToFileURL(canonicalPath).href));
-}
-async function loadEffectSourceModule(options) {
-    const resourcePath = node_path.resolve(options.resourcePath);
-    const appDir = node_path.resolve(options.appDir ?? node_path.dirname(resourcePath));
-    const tsconfigPath = node_path.join(appDir, 'tsconfig.json');
-    const cacheDirectory = node_path.join(appDir, 'node_modules', '.cache', 'modern-js', 'effect-source-loader');
-    const outputName = node_crypto.createHash('sha256').update(resourcePath).digest('hex').slice(0, 24);
-    const outputPath = node_path.join(cacheDirectory, `${outputName}.mjs`);
-    await node_fs.promises.mkdir(cacheDirectory, {
-        recursive: true
-    });
-    const result = await build({
-        absWorkingDir: appDir,
-        banner: {
-            js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify(pathToFileURL(resourcePath).href)});`
-        },
-        bundle: true,
-        entryPoints: [
-            resourcePath
-        ],
-        format: 'esm',
-        jsx: 'automatic',
-        logLevel: 'silent',
-        metafile: true,
-        outfile: outputPath,
-        platform: 'node',
-        plugins: [
-            externalizeInstalledDependencies({
-                format: 'esm',
-                runtimeResolveDir: appDir
-            }),
-            preserveSourceModuleSemantics()
-        ],
-        sourcemap: 'inline',
-        target: 'node20',
-        tsconfig: node_fs.existsSync(tsconfigPath) ? tsconfigPath : void 0
-    });
-    for (const input of Object.keys(result.metafile.inputs)){
-        const dependency = node_path.isAbsolute(input) ? node_path.normalize(input) : node_path.resolve(appDir, input);
-        if (isWatchableInput(dependency)) options.onDependency?.(dependency);
-    }
-    const output = await node_fs.promises.readFile(outputPath);
-    const revision = node_crypto.createHash('sha256').update(output).digest('hex');
-    return normalizeImportedModule(await dynamicImport(`${pathToFileURL(outputPath).href}?v=${revision}`));
-}
-export { bundleEffectEntryForNode, loadEffectBuiltModule, loadEffectSourceModule };

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

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

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

@@ -1,8 +0,0 @@
-import type { DataBatchTransportOptions, DataTransportRequestInfo } from '../types';
-type DataBatchFetch = NonNullable<DataBatchTransportOptions['fetch']>;
-type CreateBatchTransportQueueOptions = {
-    options: DataBatchTransportOptions;
-    baseFetch: DataBatchFetch;
-};
-export declare function createBatchTransportQueue({ options, baseFetch, }: CreateBatchTransportQueueOptions): (input: DataTransportRequestInfo, init?: RequestInit) => Promise<any>;
-export {};

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

@@ -1,13 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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/runtime/data-platform/batch/telemetry.d.ts

@@ -1,4 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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/invalidation.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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/runtime/data-platform/types.d.ts

@@ -1,146 +0,0 @@
-/**
- * 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?: 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 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/runtime/data-platform/validation.d.ts

@@ -1,29 +0,0 @@
-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/runtime/effect/adapter/constants.d.ts

@@ -1 +0,0 @@
-export declare const before: string[];

package/dist/types/runtime/effect/adapter/cross-project-policy.d.ts

@@ -1,4 +0,0 @@
-import type { ServerPluginAPI } from '@modern-js/server-core';
-import { type ResolvedCrossProjectPolicy } from '../../../utils/crossProjectServerPolicy';
-import type { EffectApiModule } from '../module';
-export declare function resolveEffectAdapterCrossProjectPolicy(api: ServerPluginAPI, prefix: string, mod: EffectApiModule | null): Promise<ResolvedCrossProjectPolicy | undefined>;

package/dist/types/runtime/effect/adapter/entry.d.ts

@@ -1,2 +0,0 @@
-import type { ServerPluginAPI } from '@modern-js/server-core';
-export declare function resolveEffectAdapterEntryFile(api: ServerPluginAPI): string | undefined;

package/dist/types/runtime/effect/adapter/error-response.d.ts

@@ -1,2 +0,0 @@
-import type { Context, ServerPluginAPI } from '@modern-js/server-core';
-export declare function createEffectAdapterRuntimeErrorResponse(api: ServerPluginAPI, error: unknown, c: Context): Promise<Response>;

package/dist/types/runtime/effect/adapter/handler.d.ts

@@ -1,7 +0,0 @@
-import type { ServerPluginAPI } from '@modern-js/server-core';
-import { type ResolvedCrossProjectPolicy } from '../../../utils/crossProjectServerPolicy';
-import { type EffectApiModule } from '../module';
-export declare function loadEffectAdapterHandlerFromModule(api: ServerPluginAPI, mod: EffectApiModule, crossProjectPolicy: ResolvedCrossProjectPolicy | undefined): Promise<{
-    handler: import("../module").EffectBffRequestHandler;
-    dispose?: () => Promise<void>;
-} | null>;

package/dist/types/runtime/effect/adapter.d.ts

@@ -1,22 +0,0 @@
-import type { ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
-import type { ResolvedCrossProjectPolicy } from '../../utils/crossProjectServerPolicy';
-interface MiddlewareOptions {
-    prefix: string;
-    enableHandleWeb?: boolean;
-}
-export declare class EffectAdapter {
-    private api;
-    isEffect: boolean;
-    effectMiddleware?: ServerMiddleware;
-    crossProjectPolicy?: ResolvedCrossProjectPolicy;
-    private handler;
-    private dispose;
-    private prefix;
-    constructor(api: ServerPluginAPI);
-    registerMiddleware: (options: MiddlewareOptions) => Promise<void>;
-    onApiHandlersUpdated: () => Promise<void>;
-    private resolveEntryFile;
-    private reloadHandler;
-    private disposeCurrentHandler;
-}
-export {};

package/dist/types/runtime/effect/backend-federation/entry.d.ts

@@ -1,2 +0,0 @@
-import type { BackendFederationRemote, BackendFederationRuntimeOptions } from './types';
-export declare function loadBackendFederationExpose(remote: BackendFederationRemote, expose: string, options: BackendFederationRuntimeOptions): Promise<unknown>;

package/dist/types/runtime/effect/backend-federation/identity.d.ts

@@ -1,30 +0,0 @@
-/**
- * Mandatory delivery-unit identity for public backend federation loads
- * (MV-G23, ADR-0019 / RESOLUTION-0001 §2.3): consumers pass the record's
- * `unitId` + `buildMarker` through to identity validation.
- */
-export type BackendFederationExpectedIdentity = {
-    unitId: string;
-    buildMarker: string;
-};
-export type BackendFederationIdentityIssue = {
-    path: string;
-    message: string;
-};
-/**
- * Shared expected-identity validation for loaded backend federation modules.
- * Compares the expose's `backendFederationContract.compatibility` identity
- * (`unitId`, `build`) against the consumer's expected delivery-unit identity.
- * Missing identity metadata is an error: with an expectation present there is
- * no legacy escape hatch.
- */
-export declare function validateExpectedBackendFederationIdentity(loaded: unknown, expected: BackendFederationExpectedIdentity, options?: {
-    /**
-     * Tolerate exposes that declare no identity metadata (legacy modules).
-     * Mismatching declared values still fail. Used by the manifest adapter,
-     * whose manifest-side identity is already validated against `expected`;
-     * the raw identity-aware loader is strict.
-     */
-    allowMissingIdentityMetadata?: boolean;
-}): BackendFederationIdentityIssue[];
-export declare function formatBackendFederationIdentityIssues(issues: BackendFederationIdentityIssue[]): string;

package/dist/types/runtime/effect/backend-federation/load.d.ts

@@ -1,13 +0,0 @@
-import type { BackendFederatedEffectApiModule, BackendFederationIdentityLoadOptions, BackendFederationLoadOptions } from './types';
-/**
- * Load a federated Effect API with mandatory delivery-unit identity
- * validation (MV-G23): the loaded expose's compatibility metadata must match
- * `expected.unitId` + `expected.buildMarker`.
- */
-export declare function loadBackendFederatedEffectApi(options: BackendFederationIdentityLoadOptions): Promise<BackendFederatedEffectApiModule>;
-/**
- * @deprecated Pass `expected` (delivery-unit `unitId` + `buildMarker`).
- * Loads without an expected identity cannot be validated against a resolved
- * delivery-unit record and emit a runtime warning.
- */
-export declare function loadBackendFederatedEffectApi(options: BackendFederationLoadOptions): Promise<BackendFederatedEffectApiModule>;

package/dist/types/runtime/effect/backend-federation/plugin.d.ts

@@ -1,3 +0,0 @@
-import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-import type { BackendFederationLoadEntryPluginOptions } from './types';
-export declare function createBackendFederationLoadEntryPlugin(options: BackendFederationLoadEntryPluginOptions): ModuleFederationRuntimePlugin;

package/dist/types/runtime/effect/backend-federation/remotes.d.ts

@@ -1,2 +0,0 @@
-import type { BackendFederationRuntimeOptions } from './types';
-export declare function collectRemotes(options: BackendFederationRuntimeOptions): import("./types").BackendFederationRemote[];

package/dist/types/runtime/effect/backend-federation/runtime.d.ts

@@ -1,3 +0,0 @@
-import { ModuleFederation } from '@module-federation/runtime';
-import type { BackendFederationRuntimeOptions } from './types';
-export declare function createBackendFederationRuntime(options: BackendFederationRuntimeOptions): ModuleFederation;