@bleedingdev/modern-js-plugin-bff-extensions 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/src/backend-federation/identity.ts

@@ -21,23 +21,12 @@ export type BackendFederationIdentityIssue = {
  * 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.
+ * Missing identity metadata is an error.
  */
 export 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[] {
-  const allowMissing = options.allowMissingIdentityMetadata === true;
   const issues: BackendFederationIdentityIssue[] = [];
   const contract = isRecord(loaded)
     ? loaded.backendFederationContract
@@ -45,9 +34,6 @@ export function validateExpectedBackendFederationIdentity(
   const compatibility = isRecord(contract) ? contract.compatibility : undefined;
 
   if (!isRecord(compatibility)) {
-    if (allowMissing) {
-      return [];
-    }
     return [
       {
         path: 'backendFederationContract.compatibility',
@@ -59,12 +45,10 @@ export function validateExpectedBackendFederationIdentity(
 
   const unitId = compatibility.unitId;
   if (typeof unitId !== 'string' || unitId.length === 0) {
-    if (!allowMissing) {
-      issues.push({
-        path: 'backendFederationContract.compatibility.unitId',
-        message: `missing delivery-unit id; expected ${expected.unitId}`,
-      });
-    }
+    issues.push({
+      path: 'backendFederationContract.compatibility.unitId',
+      message: `missing delivery-unit id; expected ${expected.unitId}`,
+    });
   } else if (unitId !== expected.unitId) {
     issues.push({
       path: 'backendFederationContract.compatibility.unitId',
@@ -74,12 +58,10 @@ export function validateExpectedBackendFederationIdentity(
 
   const build = compatibility.build;
   if (typeof build !== 'string' || build.length === 0) {
-    if (!allowMissing) {
-      issues.push({
-        path: 'backendFederationContract.compatibility.build',
-        message: `missing build marker; expected ${expected.buildMarker}`,
-      });
-    }
+    issues.push({
+      path: 'backendFederationContract.compatibility.build',
+      message: `missing build marker; expected ${expected.buildMarker}`,
+    });
   } else if (build !== expected.buildMarker) {
     issues.push({
       path: 'backendFederationContract.compatibility.build',

package/src/backend-federation/index.ts

@@ -5,7 +5,7 @@ import {
   BACKEND_FEDERATION_EFFECT_EXPOSE,
   BACKEND_FEDERATION_MANIFEST_FILE,
   BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
-} from '@modern-js/utils/universal';
+} from '@modern-js/backend-federation-contracts';
 
 export {
   type BackendFederationExpectedIdentity,

package/src/backend-federation/load.ts

@@ -1,9 +1,5 @@
-import { BACKEND_FEDERATION_EFFECT_EXPOSE } from '@modern-js/utils/universal';
-import * as Effect from 'effect/Effect';
-import * as Logger from 'effect/Logger';
+import { BACKEND_FEDERATION_EFFECT_EXPOSE } from '@modern-js/backend-federation-contracts';
 
-import { type BackendFederationExpectedIdentity } from './identity';
-import { LEGACY_LOAD_WARNING } from './legacy-warning';
 import { collectRemotes } from './remotes';
 import { createBackendFederationRuntime } from './runtime';
 import type {
@@ -14,18 +10,6 @@ import type {
 import { normalizeExpose } from './utils';
 import { validateLoadedBackendFederatedEffectApi } from './validate-loaded';
 
-const legacyWarningLogger = Logger.withLeveledConsole(Logger.formatLogFmt);
-
-function warnLegacyLoad() {
-  Effect.runSync(
-    Effect.provideService(
-      Effect.logWarning(LEGACY_LOAD_WARNING),
-      Logger.CurrentLoggers,
-      new Set([legacyWarningLogger]),
-    ),
-  );
-}
-
 /**
  * Load a federated Effect API with mandatory delivery-unit identity
  * validation (MV-G23): the loaded expose's compatibility metadata must match
@@ -33,20 +17,6 @@ function warnLegacyLoad() {
  */
 export 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 function loadBackendFederatedEffectApi(
-  options: BackendFederationLoadOptions,
-): Promise<BackendFederatedEffectApiModule>;
-export function loadBackendFederatedEffectApi(
-  options: BackendFederationLoadOptions & {
-    expected?: BackendFederationExpectedIdentity;
-    allowMissingIdentityMetadata?: boolean;
-  },
 ): Promise<BackendFederatedEffectApiModule> {
   const remoteName = options.remote?.name ?? options.remoteName;
   if (remoteName === undefined || remoteName.length === 0) {
@@ -55,8 +25,12 @@ export function loadBackendFederatedEffectApi(
     );
   }
 
-  if (options.expected === undefined) {
-    warnLegacyLoad();
+  if (!options.expected?.unitId || !options.expected.buildMarker) {
+    return Promise.reject(
+      new Error(
+        '[BFF][Effect] Backend federation requires expected.unitId and expected.buildMarker.',
+      ),
+    );
   }
 
   if (options.runtime !== undefined) {
@@ -93,7 +67,6 @@ export function loadBackendFederatedEffectApi(
   const remoteRequest = `${remoteName}/${normalizeExpose(expose)}`;
   return runtime.loadRemote(remoteRequest).then(loaded =>
     validateLoadedBackendFederatedEffectApi(loaded, {
-      allowMissingIdentityMetadata: options.allowMissingIdentityMetadata,
       expected: options.expected,
       remoteName,
       remoteRequest,

package/src/backend-federation/node.ts

@@ -1,6 +1,5 @@
 import { evaluateNodeBackendFederationCommonJs } from '@modern-js/server-runtime-extensions/backend-federation-security/node';
 
-import type { BackendFederationExpectedIdentity } from './identity';
 import { loadBackendFederatedEffectApi as loadUniversalBackendFederatedEffectApi } from './load';
 import type {
   BackendFederatedEffectApiModule,
@@ -10,16 +9,6 @@ import type {
 
 export function loadBackendFederatedEffectApi(
   options: BackendFederationIdentityLoadOptions,
-): Promise<BackendFederatedEffectApiModule>;
-/** @deprecated Pass `expected` delivery-unit identity. */
-export function loadBackendFederatedEffectApi(
-  options: BackendFederationLoadOptions,
-): Promise<BackendFederatedEffectApiModule>;
-export function loadBackendFederatedEffectApi(
-  options: BackendFederationLoadOptions & {
-    expected?: BackendFederationExpectedIdentity;
-    allowMissingIdentityMetadata?: boolean;
-  },
 ): Promise<BackendFederatedEffectApiModule> {
   return loadUniversalBackendFederatedEffectApi({
     ...options,

package/src/backend-federation/types.ts

@@ -1,9 +1,9 @@
+import type { BACKEND_FEDERATION_EFFECT_EXPOSE } from '@modern-js/backend-federation-contracts';
 import type { EffectApiModule } from '@modern-js/bff-effect/effect';
 import type {
   BackendFederationRemoteEntryPolicy,
   BackendFederationRemoteEntryVerification,
 } from '@modern-js/server-runtime-extensions/backend-federation-security';
-import type { BACKEND_FEDERATION_EFFECT_EXPOSE } from '@modern-js/utils/universal';
 import type {
   ModuleFederation,
   ModuleFederationRuntimePlugin,
@@ -85,12 +85,6 @@ export type BackendFederationLoadOptions = BackendFederationRuntimeOptions & {
 export type BackendFederationIdentityLoadOptions =
   BackendFederationLoadOptions & {
     expected: BackendFederationExpectedIdentity;
-    /**
-     * Tolerate legacy exposes without identity metadata (mismatching declared
-     * values still fail). Prefer leaving this unset: identity-less exposes
-     * cannot be validated against a resolved delivery-unit record.
-     */
-    allowMissingIdentityMetadata?: boolean;
   };
 
 export type BackendFederationLoadEntryPlugin = ModuleFederationRuntimePlugin & {

package/src/backend-federation/validate-loaded.ts

@@ -9,8 +9,7 @@ import { isRecord } from './utils';
 export function validateLoadedBackendFederatedEffectApi(
   loaded: unknown,
   options: {
-    allowMissingIdentityMetadata?: boolean;
-    expected?: BackendFederationExpectedIdentity;
+    expected: BackendFederationExpectedIdentity;
     remoteName: string;
     remoteRequest: string;
   },
@@ -52,14 +51,10 @@ export function validateLoadedBackendFederatedEffectApi(
     );
   }
 
-  if (options.expected !== undefined) {
+  {
     const issues = validateExpectedBackendFederationIdentity(
       loaded,
       options.expected,
-      {
-        allowMissingIdentityMetadata:
-          options.allowMissingIdentityMetadata === true,
-      },
     );
     if (issues.length > 0) {
       throw new Error(

package/src/backend-federation-manifest/load.ts

@@ -7,6 +7,12 @@ import {
 } from '../backend-federation';
 import { loadBackendFederatedEffectApi } from '../backend-federation/load';
 import { BackendFederationManifestAdapterError } from './errors';
+import {
+  backendFederationMetadata,
+  manifestDeliveryUnit,
+  stringValue,
+  versionBoundaryMetadata,
+} from './metadata';
 import { loadBackendFederationManifest } from './reference';
 import { resolveBackendFederationRemoteFromManifest } from './remote';
 import type {
@@ -19,6 +25,10 @@ import {
   validateLoadedBackendFederationContract,
 } from './validation';
 
+// One manifest+entry budget. Explicit outer 0 opts out; nested 0 cannot
+// disable a positive nested deadline.
+const DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS = 10_000;
+
 function createManifestLoadScope(
   options: BackendFederationManifestAdapterOptions,
 ) {
@@ -38,9 +48,14 @@ function createManifestLoadScope(
       );
     }
   }
+  const positivePolicyTimeouts = policyTimeouts.filter(timeout => timeout > 0);
   const timeoutMs =
     options.timeoutMs ??
-    (policyTimeouts.length > 0 ? Math.min(...policyTimeouts) : 0);
+    (policyTimeouts.length === 0
+      ? DEFAULT_SHARED_MANIFEST_LOAD_TIMEOUT_MS
+      : positivePolicyTimeouts.length > 0
+        ? Math.min(...positivePolicyTimeouts)
+        : 0);
   const inputSignals = [
     options.signal,
     options.manifestPolicy?.signal,
@@ -134,6 +149,39 @@ function throwIfManifestLoadAborted(signal: AbortSignal) {
   }
 }
 
+// Stop waiting even when trusted plugin work ignores cancellation. The race
+// observes late rejections; it cannot stop that work from running.
+function settleOnSharedAbort<T>(
+  promise: Promise<T>,
+  signal: AbortSignal,
+): Promise<T> {
+  if (signal.aborted) {
+    // Observe work even when the pre-aborted path never reaches Promise.race.
+    promise.catch(() => {});
+    throwIfManifestLoadAborted(signal);
+  }
+
+  let onAbort: (() => void) | undefined;
+  const aborted = new Promise<never>((_resolve, reject) => {
+    onAbort = () => {
+      reject(
+        new BackendFederationManifestAdapterError(
+          'remote_unavailable',
+          '[BFF][Effect] Backend federation load was aborted before remote execution.',
+          signal.reason,
+        ),
+      );
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+
+  return Promise.race([promise, aborted]).finally(() => {
+    if (onAbort) {
+      signal.removeEventListener('abort', onAbort);
+    }
+  });
+}
+
 export async function loadBackendFederatedEffectApiFromManifest(
   options: BackendFederationManifestAdapterOptions,
 ): Promise<BackendFederatedEffectApiModule> {
@@ -144,16 +192,19 @@ export async function loadBackendFederatedEffectApiFromManifest(
   try {
     scope = createManifestLoadScope(options);
     throwIfManifestLoadAborted(scope.signal);
-    manifest = await loadBackendFederationManifest({
-      ...options,
-      manifestPolicy: {
-        ...options.manifestPolicy,
+    manifest = await settleOnSharedAbort(
+      loadBackendFederationManifest({
+        ...options,
+        manifestPolicy: {
+          ...options.manifestPolicy,
+          signal: scope.signal,
+          timeoutMs: 0,
+        },
         signal: scope.signal,
         timeoutMs: 0,
-      },
-      signal: scope.signal,
-      timeoutMs: 0,
-    });
+      }),
+      scope.signal,
+    );
     validateBackendFederationManifest(manifest, options.expected);
     remote = resolveBackendFederationRemoteFromManifest(
       manifest,
@@ -204,37 +255,40 @@ export async function loadBackendFederatedEffectApiFromManifest(
       );
     }
 
-    const loaded = await loadBackendFederatedEffectApi({
-      hostName: options.hostName,
-      remote,
-      ...(options.plugins ? { plugins: options.plugins } : {}),
-      entryPolicy: {
-        ...options.entryPolicy,
-        signal: scope.signal,
-        timeoutMs: 0,
-      },
-      ...(options.runtime ? { runtime: options.runtime } : {}),
-      // MV-G23: route the manifest adapter through the raw loader's shared
-      // delivery-unit identity validation when an identity is expected.
-      ...(options.expected?.unitId && options.expected.buildMarker
-        ? {
-            expected: {
-              unitId: options.expected.unitId,
-              buildMarker: options.expected.buildMarker,
-            },
-            // The manifest's identity is already validated against
-            // `expected`; legacy exposes without identity metadata stay
-            // loadable (mismatching declared values still fail).
-            allowMissingIdentityMetadata: true,
-          }
-        : {}),
-    }).catch((error: unknown) => {
+    const deliveryUnit = manifestDeliveryUnit(
+      backendFederationMetadata(manifest),
+      versionBoundaryMetadata(manifest),
+    );
+    const unitId =
+      stringValue(deliveryUnit.boundary?.unitId) ??
+      stringValue(deliveryUnit.top?.unitId);
+    const buildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
+    if (!unitId || !buildMarker)
       throw new BackendFederationManifestAdapterError(
-        scope?.timedOut() === true ? 'timeout' : classifyLoadError(error),
-        `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE}.`,
-        error,
+        'manifest_invalid',
+        'Backend federation manifest requires delivery-unit identity.',
       );
-    });
+    const loaded = await settleOnSharedAbort(
+      loadBackendFederatedEffectApi({
+        hostName: options.hostName,
+        remote,
+        ...(options.plugins ? { plugins: options.plugins } : {}),
+        entryPolicy: {
+          ...options.entryPolicy,
+          signal: scope.signal,
+          timeoutMs: 0,
+        },
+        ...(options.runtime ? { runtime: options.runtime } : {}),
+        expected: { unitId, buildMarker },
+      }).catch((error: unknown) => {
+        throw new BackendFederationManifestAdapterError(
+          scope?.timedOut() === true ? 'timeout' : classifyLoadError(error),
+          `[BFF][Effect] Backend federation remote ${remote?.name ?? 'unknown'} could not load ${remote?.expose ?? BACKEND_FEDERATION_EFFECT_EXPOSE}.`,
+          error,
+        );
+      }),
+      scope.signal,
+    );
 
     validateLoadedBackendFederationContract(loaded, manifest, remote);
 

package/src/backend-federation-manifest/metadata.ts

@@ -3,7 +3,7 @@
 import {
   backendFederationMetadata as sharedBackendFederationMetadata,
   backendFederationVersionBoundary as sharedBackendFederationVersionBoundary,
-} from '@modern-js/utils/universal';
+} from '@modern-js/backend-federation-contracts';
 import type { BackendFederationManifest } from './types';
 
 export function stringValue(value: unknown) {
@@ -56,12 +56,6 @@ export function deliveryUnitMetadata(
   return recordField(record, 'deliveryUnit');
 }
 
-/**
- * Resolves the delivery-unit identity root for a manifest (ADR-0019 §3):
- * prefers `versionBoundary.deliveryUnit`, falls back to the top-level
- * `backendFederation.deliveryUnit` record. Both are additive/optional so
- * legacy manifests without delivery-unit metadata continue to validate.
- */
 export function manifestDeliveryUnit(
   backendFederation: Record<string, unknown> | undefined,
   boundary: Record<string, unknown> | undefined,

package/src/backend-federation-manifest/remote.ts

@@ -1,10 +1,10 @@
 // @effect-diagnostics asyncFunction:off extendsNativeError:off globalTimers:off newPromise:off strictBooleanExpressions:off
 
+import { backendFederationExposeNames } from '@modern-js/backend-federation-contracts';
 import {
   BackendFederationRemoteEntryError,
   resolveBackendFederationRemoteEntryVerification,
 } from '@modern-js/server-runtime-extensions/backend-federation-security';
-import { backendFederationExposeNames } from '@modern-js/utils/universal';
 import {
   BACKEND_FEDERATION_EFFECT_EXPOSE,
   type BackendFederationRemote,

package/src/backend-federation-manifest/validation.ts

@@ -3,7 +3,7 @@
 import {
   formatBackendFederationValidationErrors,
   validateBackendFederationManifest as validateBackendFederationManifestContract,
-} from '@modern-js/utils/universal';
+} from '@modern-js/backend-federation-contracts';
 import {
   BACKEND_FEDERATION_CONTRACT_VERSION,
   BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
@@ -48,11 +48,6 @@ function resolveExpectedBuildMarker(
     );
   }
 
-  // Intentionally no fallback to `buildVersion` here: this is only used to
-  // compare against manifest `deliveryUnit.buildMarker`, which is a
-  // separate, additive field. Callers that only pass `buildVersion` (the
-  // pre-ADR-0019 expectation shape) must not be forced to also match a
-  // delivery-unit build marker on the manifest.
   return expected.buildMarker;
 }
 
@@ -70,7 +65,6 @@ export function validateBackendFederationManifest(
   const manifestShape = validateBackendFederationManifestContract(manifest, {
     expectedContractVersion: false,
     expectedNodeAdapterVersion: false,
-    validateDeliveryUnit: false,
   });
   assertManifestAdapter(
     manifestShape.ok,
@@ -151,6 +145,11 @@ export function validateBackendFederationManifest(
   const manifestUnitId =
     stringValue(deliveryUnit.boundary?.unitId) ??
     stringValue(deliveryUnit.top?.unitId);
+  assertManifestAdapter(
+    manifestUnitId && stringValue(deliveryUnit.boundary?.buildMarker),
+    'manifest_invalid',
+    'Backend federation manifest requires delivery-unit unitId and buildMarker.',
+  );
   assertVersionValue(manifestUnitId, expected.unitId, 'deliveryUnit.unitId');
   assertVersionValue(
     stringValue(deliveryUnit.boundary?.buildMarker),
@@ -214,16 +213,14 @@ export function validateLoadedBackendFederationContract(
     stringValue(deliveryUnit.top?.unitId);
   const manifestBuildMarker = stringValue(deliveryUnit.boundary?.buildMarker);
 
-  // Only enforced when both sides declare the field: absence on either side
-  // is a legacy manifest/expose and must stay backward compatible.
-  assertConsistentValue(
-    manifestUnitId,
+  assertVersionValue(
     stringValue(compatibility.unitId),
+    manifestUnitId,
     'deliveryUnit.unitId vs expose compatibility.unitId',
   );
-  assertConsistentValue(
-    manifestBuildMarker,
+  assertVersionValue(
     stringValue(compatibility.build),
+    manifestBuildMarker,
     'deliveryUnit.buildMarker vs expose compatibility.build',
   );
 }

package/src/cross-project-policy/evaluation.ts

@@ -3,7 +3,7 @@ import {
   evaluateCrossProjectPolicy,
   type NormalizedCrossProjectPolicy,
   resolveCrossProjectRequestObservation,
-} from '@modern-js/bff-core/security/cross-project-policy';
+} from '@modern-js/server-runtime-extensions/bff-policy';
 
 export type ResolvedCrossProjectPolicy = NormalizedCrossProjectPolicy;
 

package/src/cross-project-policy/node.ts

@@ -1,12 +1,12 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
-
+import '@modern-js/server-runtime-extensions/server-config';
+import type { ServerPluginAPI } from '@modern-js/server-core';
 import {
   deriveOperationVersion,
   type OperationContractSource,
   resolveCrossProjectPolicy,
-} from '@modern-js/bff-core';
-import type { ServerPluginAPI } from '@modern-js/server-core';
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
 
 import type { ResolvedCrossProjectPolicy } from './evaluation';
 

package/src/cross-project-policy/producer-runtime.ts

@@ -0,0 +1,43 @@
+interface ProducerClientOptions {
+  requestId?: string;
+  requireEnvelope?: boolean;
+  identityBinding?: {
+    enabled?: boolean;
+    strict?: boolean;
+    protectedHeaders?: string[];
+  };
+  operationContract?: {
+    enabled?: boolean;
+    strict?: boolean;
+    requireSchemaHash?: boolean;
+    requireOperationVersion?: boolean;
+  };
+}
+
+/** Bind producer defaults once while preserving every per-call nested override. */
+export function createProducerClient<
+  Options extends ProducerClientOptions,
+  Result,
+>(
+  configure: (options: Options) => Result,
+  { requestId }: { requestId: string },
+) {
+  return (options?: Options): Result =>
+    configure({
+      requestId,
+      requireEnvelope: true,
+      ...options,
+      identityBinding: {
+        enabled: true,
+        strict: true,
+        ...options?.identityBinding,
+      },
+      operationContract: {
+        enabled: true,
+        strict: true,
+        requireSchemaHash: true,
+        requireOperationVersion: true,
+        ...options?.operationContract,
+      },
+    } as Options);
+}

package/src/effect-adapter/entry.ts

@@ -1,6 +1,7 @@
 // @effect-diagnostics nodeBuiltinImport:off strictBooleanExpressions:off
 
 import path from 'node:path';
+import '@modern-js/server-runtime-extensions/server-config';
 import type { ServerPluginAPI } from '@modern-js/server-core';
 import { API_DIR, findExists, fs, isProd } from '@modern-js/utils';
 

package/src/effect-adapter/index.ts

@@ -1,6 +1,7 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off nodeBuiltinImport:off strictBooleanExpressions:off
 
 import path from 'node:path';
+import '@modern-js/server-runtime-extensions/server-config';
 import {
   dispatchEffectBffRequest,
   type EffectApiModule,
@@ -244,3 +245,7 @@ export class EffectAdapter {
     this.handler = candidate;
   }
 }
+
+export const createRuntimeAdapters = (api: ServerPluginAPI) => [
+  new EffectAdapter(api),
+];

package/src/{client-generator → effect-source-loader}/built-entry.ts

@@ -41,9 +41,7 @@ export async function bundleBuiltEffectEntryForNode(options: {
       }`,
     );
   }
-  const { bundleEffectEntryForNode } = await import(
-    '../effect-source-loader/loader'
-  );
+  const { bundleEffectEntryForNode } = await import('./loader');
   return bundleEffectEntryForNode({
     appDir,
     entryPath: builtEntry,

package/src/effect-source-loader/http-api-runtime.ts

@@ -0,0 +1,39 @@
+import {
+  extractHttpApiFromModule,
+  type HttpApiLike,
+  type HttpApiReflect,
+} from '@modern-js/bff-effect/effect';
+import { HttpApi } from 'effect/unstable/httpapi';
+import { loadEffectSourceModule } from './loader';
+
+type HttpApiRuntime = {
+  isHttpApi: (value: unknown) => boolean;
+  reflect: HttpApiReflect;
+};
+
+export function getHttpApiRuntime(): Promise<HttpApiRuntime> {
+  return Promise.resolve({
+    isHttpApi: HttpApi.isHttpApi,
+    reflect: (api, handlers) => {
+      if (!HttpApi.isHttpApi(api)) {
+        throw new TypeError('[BFF][Effect] Expected an HttpApi contract.');
+      }
+      HttpApi.reflect(api, {
+        onGroup: handlers.onGroup ?? (() => {}),
+        onEndpoint: handlers.onEndpoint,
+      });
+    },
+  });
+}
+
+export function loadEffectApi(options: {
+  appDir: string;
+  resourcePath: string;
+  onDependency?: (dependency: string) => void;
+}): Promise<HttpApiLike | null> {
+  return getHttpApiRuntime().then(httpApiRuntime =>
+    loadEffectSourceModule(options).then(mod =>
+      extractHttpApiFromModule(mod, httpApiRuntime.isHttpApi),
+    ),
+  );
+}

package/src/effect-source-loader/index.ts

@@ -1,6 +1,9 @@
-export { resolveEffectEntryFile } from '../client-generator/paths';
-export { bundleEffectEntryForNode } from './loader';
 export {
-  generateEffectClientCode,
-  generateEffectWorkerRuntimeWrapper,
-} from './worker-runtime-wrapper';
+  bundleBuiltEffectEntryForNode,
+  resolveEffectEntryPaths,
+} from './built-entry';
+export { bundleEffectEntryForNode } from './loader';
+export { resolveEffectOperationContracts } from './operation-contracts';
+export { resolveEffectEntryFile } from './paths';
+export { bundleEffectWorkerRuntimeSource } from './worker-runtime-source';
+export { generateEffectWorkerRuntimeWrapper } from './worker-runtime-wrapper';