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

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

@@ -0,0 +1,13 @@
+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/backend-federation/node.d.ts

@@ -0,0 +1,4 @@
+import type { BackendFederatedEffectApiModule, BackendFederationIdentityLoadOptions, BackendFederationLoadOptions } from './types';
+export declare function loadBackendFederatedEffectApi(options: BackendFederationIdentityLoadOptions): Promise<BackendFederatedEffectApiModule>;
+/** @deprecated Pass `expected` delivery-unit identity. */
+export declare function loadBackendFederatedEffectApi(options: BackendFederationLoadOptions): Promise<BackendFederatedEffectApiModule>;

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

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

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

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

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

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

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

@@ -0,0 +1,76 @@
+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 } from '@module-federation/runtime';
+import type { BackendFederationExpectedIdentity } from './identity';
+export type BackendFederationRemote = {
+    name: string;
+    entry: string;
+    type?: 'commonjs-module' | 'module' | string;
+    entryGlobalName?: string;
+    shareScope?: string | string[];
+    expose?: typeof BACKEND_FEDERATION_EFFECT_EXPOSE;
+    verification?: BackendFederationRemoteEntryVerification;
+};
+export type BackendFederationRuntimeOptions = {
+    hostName: string;
+    remote?: BackendFederationRemote;
+    remotes?: BackendFederationRemote[];
+    plugins?: ModuleFederationRuntimePlugin[];
+    entryPolicy?: BackendFederationRemoteEntryPolicy;
+};
+export type BackendFederationEntryExports = {
+    get: (id: string) => (() => Promise<unknown> | unknown) | Promise<() => Promise<unknown> | unknown>;
+    init?: (...args: unknown[]) => void | Promise<void>;
+};
+export type BackendFederatedEffectApiModule = EffectApiModule & {
+    backendFederationContract?: {
+        compatibility?: {
+            build?: unknown;
+            contractVersion?: unknown;
+            nodeAdapterVersion?: unknown;
+            packageName?: unknown;
+            /**
+             * ADR-0019 delivery-unit identity root, generator-emitted alongside
+             * manifest's `versionBoundary.deliveryUnit`. Additive/optional.
+             */
+            unitId?: unknown;
+            /** ADR-0019 delivery-unit source revision. Additive/optional. */
+            sourceRevision?: unknown;
+        };
+        name?: unknown;
+        role?: unknown;
+        runtimeFramework?: unknown;
+        strictEffectApproach?: unknown;
+    };
+    contract?: unknown;
+    operationContexts?: unknown;
+    runtime?: unknown;
+};
+export type BackendFederationLoadEntryPluginOptions = {
+    resolveEntry: (remote: BackendFederationRemote) => BackendFederationEntryExports | undefined | Promise<BackendFederationEntryExports | undefined>;
+};
+export type BackendFederationLoadOptions = BackendFederationRuntimeOptions & {
+    runtime?: ModuleFederation;
+    remoteName?: string;
+    expose?: string;
+};
+/**
+ * Identity-aware public load options (MV-G23): the expected delivery-unit
+ * `unitId` + `buildMarker` are mandatory and validated against the loaded
+ * expose's compatibility metadata.
+ */
+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 & {
+    loadEntry?: (args: {
+        remoteInfo: BackendFederationRemote;
+    }) => BackendFederationEntryExports | undefined | Promise<BackendFederationEntryExports | undefined>;
+};

package/dist/types/backend-federation/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeExpose(expose: string): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/types/backend-federation/validate-loaded.d.ts

@@ -0,0 +1,8 @@
+import type { BackendFederationExpectedIdentity } from './identity';
+import type { BackendFederatedEffectApiModule } from './types';
+export declare function validateLoadedBackendFederatedEffectApi(loaded: unknown, options: {
+    allowMissingIdentityMetadata?: boolean;
+    expected?: BackendFederationExpectedIdentity;
+    remoteName: string;
+    remoteRequest: string;
+}): BackendFederatedEffectApiModule;

package/dist/types/backend-federation-manifest/errors.d.ts

@@ -0,0 +1,11 @@
+export type BackendFederationManifestAdapterErrorCode = 'manifest_unavailable' | 'manifest_invalid' | 'remote_unavailable' | 'strict_effect_required' | 'timeout' | 'version_mismatch';
+export declare const BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT: 'modernjs:microvertical-server-fallback';
+export declare class BackendFederationManifestAdapterError extends Error {
+    code: BackendFederationManifestAdapterErrorCode;
+    readonly failureEvent: "modernjs:microvertical-server-fallback";
+    details?: Record<string, unknown>;
+    constructor(code: BackendFederationManifestAdapterErrorCode, message: string, cause?: unknown, details?: Record<string, unknown>);
+}
+export declare function assertManifestAdapter(condition: unknown, code: BackendFederationManifestAdapterErrorCode, message: string): asserts condition;
+export declare function assertVersionValue(actual: string | undefined, expected: string | undefined, label: string, details?: Record<string, unknown>): void;
+export declare function assertConsistentValue(left: string | undefined, right: string | undefined, label: string, details?: Record<string, unknown>): void;

package/dist/types/backend-federation-manifest/index.d.ts

@@ -0,0 +1,5 @@
+export type { BackendFederationManifestAdapterErrorCode } from './errors';
+export { BackendFederationManifestAdapterError } from './errors';
+export { loadBackendFederationManifest } from './reference';
+export { resolveBackendFederationRemoteFromManifest } from './remote';
+export type { BackendFederationManifest, BackendFederationManifestAdapterFallback, BackendFederationManifestAdapterOptions, BackendFederationManifestFetchResponse, BackendFederationVersionBoundaryExpectation, } from './types';

package/dist/types/backend-federation-manifest/load.d.ts

@@ -0,0 +1,3 @@
+import { type BackendFederatedEffectApiModule } from '../backend-federation';
+import type { BackendFederationManifestAdapterOptions } from './types';
+export declare function loadBackendFederatedEffectApiFromManifest(options: BackendFederationManifestAdapterOptions): Promise<BackendFederatedEffectApiModule>;

package/dist/types/backend-federation-manifest/metadata.d.ts

@@ -0,0 +1,18 @@
+import type { BackendFederationManifest } from './types';
+export declare function stringValue(value: unknown): string | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function recordField(value: Record<string, unknown> | undefined, field: string): Record<string, unknown> | undefined;
+export declare function resolveRemoteEntryFromMetadata(manifest: BackendFederationManifest): string | undefined;
+export declare function backendFederationMetadata(manifest: BackendFederationManifest): Record<string, unknown> | undefined;
+export declare function versionBoundaryMetadata(manifest: BackendFederationManifest): Record<string, unknown> | undefined;
+export declare function deliveryUnitMetadata(record: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+/**
+ * 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 declare function manifestDeliveryUnit(backendFederation: Record<string, unknown> | undefined, boundary: Record<string, unknown> | undefined): {
+    boundary: Record<string, unknown> | undefined;
+    top: Record<string, unknown> | undefined;
+};

package/dist/types/backend-federation-manifest/node.d.ts

@@ -0,0 +1,3 @@
+import type { BackendFederatedEffectApiModule } from '../backend-federation';
+import type { BackendFederationManifestAdapterOptions } from './types';
+export declare function loadBackendFederatedEffectApiFromManifest(options: BackendFederationManifestAdapterOptions): Promise<BackendFederatedEffectApiModule>;

package/dist/types/backend-federation-manifest/reference.d.ts

@@ -0,0 +1,4 @@
+import type { BackendFederationManifest, BackendFederationManifestAdapterOptions } from './types';
+export declare function resolveBackendFederationManifestReference(options: Pick<BackendFederationManifestAdapterOptions, 'env' | 'manifestEnv' | 'manifestPath' | 'manifestUrl'>): string | undefined;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number | undefined, label: string): Promise<T>;
+export declare function loadBackendFederationManifest(options: Pick<BackendFederationManifestAdapterOptions, 'env' | 'expected' | 'fetch' | 'manifest' | 'manifestEnv' | 'manifestPolicy' | 'manifestPath' | 'manifestUrl' | 'signal' | 'timeoutMs'>): Promise<BackendFederationManifest>;

package/dist/types/backend-federation-manifest/remote.d.ts

@@ -0,0 +1,3 @@
+import { type BackendFederationRemote } from '../backend-federation';
+import type { BackendFederationManifest } from './types';
+export declare function resolveBackendFederationRemoteFromManifest(manifest: BackendFederationManifest, remoteOverride?: Partial<BackendFederationRemote>): BackendFederationRemote;

package/dist/types/backend-federation-manifest/types.d.ts

@@ -0,0 +1,49 @@
+import type { BackendFederationRemoteEntryPolicy, BackendFederationResourcePolicy, BackendFederationResourceResponse } from '@modern-js/server-runtime-extensions/backend-federation-security';
+import type { ModuleFederation, ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import type { BackendFederatedEffectApiModule, BackendFederationRemote } from '../backend-federation';
+import type { BackendFederationManifestAdapterError } from './errors';
+export type BackendFederationManifest = Record<string, unknown>;
+export type BackendFederationVersionBoundaryExpectation = {
+    buildVersion?: string;
+    /**
+     * Delivery-unit build marker (ADR-0019). Semantically the same value as
+     * `buildVersion`; treated as an alias. If both are set and disagree the
+     * expectation itself is invalid and fails closed before any manifest
+     * comparison runs.
+     */
+    buildMarker?: string;
+    contractVersion?: string;
+    nodeAdapterVersion?: string;
+    packageName?: string;
+    remoteName?: string;
+    /**
+     * Delivery-unit identity root (ADR-0019 §3). When set, the manifest's
+     * `backendFederation.versionBoundary.deliveryUnit.unitId` (or the
+     * top-level `backendFederation.deliveryUnit.unitId` fallback) must match.
+     */
+    unitId?: string;
+    version?: string;
+};
+export type BackendFederationManifestFetchResponse = BackendFederationResourceResponse;
+export type BackendFederationManifestAdapterFallback = (error: BackendFederationManifestAdapterError, context: {
+    manifest?: BackendFederationManifest;
+    remote?: BackendFederationRemote;
+}) => BackendFederatedEffectApiModule | Promise<BackendFederatedEffectApiModule>;
+export type BackendFederationManifestAdapterOptions = {
+    entryPolicy?: BackendFederationRemoteEntryPolicy;
+    env?: Record<string, string | undefined>;
+    expected?: BackendFederationVersionBoundaryExpectation;
+    fallback?: BackendFederationManifestAdapterFallback;
+    fetch?: (url: string, init?: RequestInit) => Promise<BackendFederationManifestFetchResponse>;
+    hostName: string;
+    manifest?: BackendFederationManifest;
+    manifestEnv?: string;
+    manifestPolicy?: Omit<BackendFederationResourcePolicy, 'fetch'>;
+    manifestPath?: string;
+    manifestUrl?: string;
+    plugins?: ModuleFederationRuntimePlugin[];
+    remote?: Partial<BackendFederationRemote>;
+    runtime?: ModuleFederation;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+};

package/dist/types/backend-federation-manifest/validation.d.ts

@@ -0,0 +1,5 @@
+import { type BackendFederatedEffectApiModule, type BackendFederationRemote } from '../backend-federation';
+import type { BackendFederationManifest, BackendFederationVersionBoundaryExpectation } from './types';
+export declare function validateBackendFederationManifest(manifest: BackendFederationManifest, expected?: BackendFederationVersionBoundaryExpectation): void;
+export declare function validateLoadedBackendFederationContract(loaded: BackendFederatedEffectApiModule, manifest: BackendFederationManifest, remote: BackendFederationRemote): void;
+export declare function classifyLoadError(error: unknown): "remote_unavailable" | "strict_effect_required" | "timeout" | "version_mismatch";

package/dist/types/client-generator/built-entry.d.ts

@@ -0,0 +1,16 @@
+export declare function resolveBuiltEffectEntry(appDirectory: string, distDirectory: string, sourceEntry: string | undefined): string | undefined;
+export declare function bundleBuiltEffectEntryForNode(options: {
+    appDir: string;
+    apiDir: string;
+    distDir: string;
+    effectEntry?: string;
+    format: 'cjs' | 'esm';
+}): Promise<void>;
+export declare function resolveEffectEntryPaths(options: {
+    appDir: string;
+    apiDir: string;
+    effectEntry?: string;
+}): {
+    sourceEffectEntry: string | undefined;
+    relativeEffectEntry: string;
+};

package/dist/types/client-generator/generator.d.ts

@@ -0,0 +1,3 @@
+import type { EffectClientCodegenOptions, GeneratedEffectClientArtifacts } from './types';
+export declare function generateEffectClient(options: EffectClientCodegenOptions): Promise<GeneratedEffectClientArtifacts | null>;
+export declare function generateEffectClientCode(options: EffectClientCodegenOptions): Promise<string | null>;

package/dist/types/client-generator/index.d.ts

@@ -0,0 +1,4 @@
+export { bundleBuiltEffectEntryForNode, resolveEffectEntryPaths, } from './built-entry';
+export { generateEffectClient, generateEffectClientCode } from './generator';
+export { resolveEffectEntryFile } from './paths';
+export type { EffectClientCodegenOptions, GeneratedEffectClientArtifacts, } from './types';

package/dist/types/client-generator/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveEffectEntryFile(options: {
+    appDir: string;
+    apiDir: string;
+    effectEntry?: string;
+}): string | undefined;

package/dist/types/client-generator/rendering.d.ts

@@ -0,0 +1,24 @@
+import { type OperationContractMap } from '@modern-js/bff-core';
+import { type EffectEndpointMeta } from '@modern-js/bff-effect/effect';
+import type { EffectClientCodegenOptions } from './types';
+export type EffectClientGeneration = {
+    config: Record<string, unknown>;
+    manifest: {
+        endpoints: Array<{
+            apiId: string;
+            group: string;
+            endpoint: string;
+            method: string;
+            routePath: string;
+            schemaHash: string;
+            operationVersion: number;
+        }>;
+    };
+    operationContracts: OperationContractMap;
+    operationVersion: number;
+    requestCreator: string;
+    requestId: string;
+};
+export declare function renderEffectClientCode(generation: EffectClientGeneration): string;
+export declare function createEffectClientGeneration(endpoints: EffectEndpointMeta[], options: EffectClientCodegenOptions): EffectClientGeneration;
+export declare function renderEffectClientDeclaration(endpoints?: EffectEndpointMeta[]): string;

package/dist/types/client-generator/runtime.d.ts

@@ -0,0 +1,12 @@
+import { type HttpApiLike, type HttpApiReflect } from '@modern-js/bff-effect/effect';
+type HttpApiRuntime = {
+    isHttpApi: (value: unknown) => boolean;
+    reflect: HttpApiReflect;
+};
+export declare function getHttpApiRuntime(): Promise<HttpApiRuntime>;
+export declare function loadEffectApi(options: {
+    appDir: string;
+    resourcePath: string;
+    onDependency?: (dependency: string) => void;
+}): Promise<HttpApiLike | null>;
+export {};

package/dist/types/client-generator/types.d.ts

@@ -0,0 +1,33 @@
+import type { OperationContractMap } from '@modern-js/bff-core';
+import type { EffectEndpointMeta } from '@modern-js/bff-effect/effect';
+import type { HttpMethodDecider } from '@modern-js/types';
+export type EffectClientCodegenOptions = {
+    appDir: string;
+    apiDir: string;
+    resourcePath: string;
+    prefix: string;
+    port: number;
+    target?: string;
+    /** Producer identity used by cross-project clients and server contracts. */
+    requestId?: string;
+    requestCreator?: string;
+    httpMethodDecider?: HttpMethodDecider;
+    onDependency?: (dependency: string) => void;
+    dataPlatformBatch?: {
+        enabled?: boolean;
+        endpoint?: string;
+        flushIntervalMs?: number;
+        maxBatchSize?: number;
+        maxBatchBytes?: number;
+        requestTimeoutMs?: number;
+        allowedMethods?: string[];
+    };
+};
+export type GeneratedEffectClientArtifacts = {
+    code: string;
+    declaration: string;
+    endpoints: EffectEndpointMeta[];
+    operationContracts: OperationContractMap;
+    operationVersion: number;
+    requestId: string;
+};

package/dist/types/cross-project-generation/index.d.ts

@@ -0,0 +1 @@
+export { renderProducerRuntimeDefaults } from './render';

package/dist/types/cross-project-generation/render.d.ts

@@ -0,0 +1 @@
+export declare const renderProducerRuntimeDefaults: (requestIdValue: string) => string;

package/dist/types/cross-project-policy/evaluation.d.ts

@@ -0,0 +1,4 @@
+import { type CrossProjectRequestObservation, type NormalizedCrossProjectPolicy } from '@modern-js/bff-core/security/cross-project-policy';
+export type ResolvedCrossProjectPolicy = NormalizedCrossProjectPolicy;
+export declare const checkCrossProjectPolicyResponse: (headers: Record<string, unknown>, policy: ResolvedCrossProjectPolicy | undefined, observedRequest?: CrossProjectRequestObservation) => Response | null;
+export declare const checkCrossProjectPolicyForRequest: (request: Request, policy: ResolvedCrossProjectPolicy | undefined) => Response | null;

package/dist/types/cross-project-policy/index.d.ts

@@ -0,0 +1 @@
+export { resolveAdapterCrossProjectPolicy } from './node';

package/dist/types/cross-project-policy/node.d.ts

@@ -0,0 +1,4 @@
+import { type OperationContractSource } from '@modern-js/bff-core';
+import type { ServerPluginAPI } from '@modern-js/server-core';
+import type { ResolvedCrossProjectPolicy } from './evaluation';
+export declare const resolveAdapterCrossProjectPolicy: (api: ServerPluginAPI, handlers: OperationContractSource[]) => ResolvedCrossProjectPolicy | undefined;

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

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

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

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

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

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

package/dist/types/effect-adapter/index.d.ts

@@ -0,0 +1,19 @@
+import type { ServerPluginAPI } from '@modern-js/server-core';
+interface EffectAdapterMiddlewareOptions {
+    prefix: string | readonly string[];
+    enableHandleWeb?: boolean;
+}
+export declare class EffectAdapter {
+    private api;
+    private handler;
+    private unregisterRuntimeDisposer?;
+    private prefix;
+    private prefixes;
+    private matchingPrefixes;
+    private retired;
+    constructor(api: ServerPluginAPI);
+    registerMiddleware: (options: EffectAdapterMiddlewareOptions) => Promise<void>;
+    dispose: () => Promise<void>;
+    private loadHandler;
+}
+export {};

package/dist/types/effect-source-loader/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveEffectEntryFile } from '../client-generator/paths';
+export { bundleEffectEntryForNode } from './loader';
+export { generateEffectClientCode, generateEffectWorkerRuntimeWrapper, } from './worker-runtime-wrapper';

package/dist/types/effect-source-loader/loader.d.ts

@@ -0,0 +1,17 @@
+export type EffectSourceLoaderOptions = {
+    resourcePath: string;
+    appDir?: string;
+    onDependency?: (dependency: string) => void;
+};
+export declare function bundleEffectEntryForNode(options: {
+    appDir: string;
+    entryPath: string;
+    format: 'cjs' | 'esm';
+}): Promise<void>;
+/** Loads a production artifact without changing its native Node boundary. */
+export declare function loadEffectBuiltModule(resourcePath: string): Promise<unknown>;
+/**
+ * Loads an Effect source entry as native ESM while reporting its complete
+ * local source graph to the framework watcher.
+ */
+export declare function loadEffectSourceModule(options: EffectSourceLoaderOptions): Promise<unknown>;

package/dist/types/effect-source-loader/worker-runtime-wrapper.d.ts

@@ -0,0 +1,25 @@
+import type { HttpMethodDecider } from '@modern-js/types';
+import type { EffectClientCodegenOptions } from '../client-generator/types';
+type EffectWorkerRuntimeGenerationOptions = {
+    apiDir: string;
+    appDir: string;
+    effectDataPlatformBatch?: {
+        allowedMethods?: string[];
+        enabled?: boolean;
+        endpoint?: string;
+        flushIntervalMs?: number;
+        maxBatchBytes?: number;
+        maxBatchSize?: number;
+        requestTimeoutMs?: number;
+    };
+    httpMethodDecider?: HttpMethodDecider;
+    port: number;
+    prefix: string;
+    requestCreator?: string;
+    requestId?: string;
+};
+export declare function generateEffectWorkerRuntimeWrapper(loader: {
+    addDependency: (dependency: string) => void;
+}, options: EffectWorkerRuntimeGenerationOptions, resourcePath: string): Promise<string>;
+export declare function generateEffectClientCode(options: EffectClientCodegenOptions): Promise<string | null>;
+export {};

package/dist/types/hono/bind-route-handlers.d.ts

@@ -0,0 +1,10 @@
+import type { Context, MiddlewareHandler } from '@modern-js/server-core';
+import type { ResolvedCrossProjectPolicy } from '../cross-project-policy/evaluation';
+export interface BindHonoRouteHandlersOptions {
+    handler: MiddlewareHandler | MiddlewareHandler[];
+    policy?: ResolvedCrossProjectPolicy;
+    routePath: string;
+    onError?: (error: Error, context: Context) => unknown | Promise<unknown>;
+    reportError?: (error: unknown) => void;
+}
+export declare const bindHonoRouteHandlers: ({ handler, policy, routePath, onError, reportError, }: BindHonoRouteHandlersOptions) => MiddlewareHandler | MiddlewareHandler[];

package/dist/types/hono/cross-project-policy.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareHandler } from '@modern-js/server-core';
+import { type ResolvedCrossProjectPolicy } from '../cross-project-policy/evaluation';
+export declare const createHonoCrossProjectPolicyMiddleware: (policy: ResolvedCrossProjectPolicy, routePath: string) => MiddlewareHandler;

package/dist/types/hono/index.d.ts

@@ -0,0 +1 @@
+export { type BindHonoRouteHandlersOptions, bindHonoRouteHandlers, } from './bind-route-handlers';