@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

package/dist/esm-node/plugins/deploy/platforms/templates/cloudflare-entry.001-bootstrap-security.mjs

@@ -0,0 +1,22 @@
+const MODERN_WORKER_MANIFEST = p_workerManifest;
+p_workerModuleLoaders;
+new Map();
+new Map();
+new Map();
+const CORS_POLICY = MODERN_WORKER_MANIFEST.security?.cors || {};
+CORS_POLICY.assets;
+(CORS_POLICY.allowedOrigins || []).map((origin)=>String(origin).toLowerCase());
+(CORS_POLICY.allowedMethods?.length ? CORS_POLICY.allowedMethods : [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'OPTIONS'
+]).join(', ');
+(CORS_POLICY.allowedHeaders?.length ? CORS_POLICY.allowedHeaders : [
+    '*'
+]).join(', ');
+globalThis.__dirname ??= '/';
+globalThis.__filename ??= '/index.js';

package/dist/esm-node/plugins/deploy/platforms/templates/cloudflare-entry.006-fetch-handler.mjs

@@ -0,0 +1,32 @@
+export default {
+    async fetch (request, env, ctx) {
+        const corsPreflightResponse = await createCorsPreflightResponse(request, env);
+        if (corsPreflightResponse) return finalizeResponseForRequest(corsPreflightResponse, request);
+        const bffResponse = await dispatchBffRequest(request, env);
+        if (bffResponse) return finalizeResponseForRequest(withAppCorsHeaders(bffResponse, request), request);
+        const serviceBindingResponse = await dispatchServiceBindingRequest(request, env);
+        if (serviceBindingResponse) return finalizeResponseForRequest(withAppCorsHeaders(serviceBindingResponse, request), request);
+        const route = findRoute(request);
+        const { pathname } = new URL(request.url);
+        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) {
+            const assetResponse = await fetchAsset(request, env);
+            if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+            return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+                status: 404
+            }), request), request);
+        }
+        const localeRedirectResponse = createLocaleRedirectResponseForRequest(route, request);
+        if (localeRedirectResponse) return finalizeResponseForRequest(withAppCorsHeaders(localeRedirectResponse, request), request);
+        if (route?.worker) {
+            const renderableRequest = createRenderableRequest(request);
+            return finalizeResponseForRequest(withAppCorsHeaders(await dispatchRouteWorker(route, renderableRequest, env, ctx), request), request);
+        }
+        const htmlResponse = await fetchRouteHtml(route, request, env);
+        if (htmlResponse) return finalizeResponseForRequest(htmlResponse, request);
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+        return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+            status: 404
+        }), request), request);
+    }
+};

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

@@ -0,0 +1,82 @@
+import { type BackendFederationApp } from './config';
+export declare const createBackendRemoteEntrySource: (workspaceRoot: string, app: BackendFederationApp, effectApiPath: string, entryPath: string) => string;
+export declare const createBackendManifest: (workspaceRoot: string, distDirectory: string, app: BackendFederationApp) => {
+    schemaVersion: number;
+    id: string;
+    name: string;
+    version: string | undefined;
+    buildVersion: string | undefined;
+    metaData: {
+        name: string;
+        type: string;
+        buildInfo: {
+            buildVersion: string | undefined;
+            buildName: string | undefined;
+        };
+        remoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        globalName: string;
+        publicPath: string;
+        ssrRemoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        ssrPublicPath: string;
+    };
+    entry: {
+        file: string;
+        path: string;
+        type: string;
+        url: string;
+    };
+    exposes: {
+        id: string;
+        name: string;
+        path: string;
+        assets: {
+            js: {
+                async: never[];
+                sync: string[];
+            };
+            css: {
+                async: never[];
+                sync: never[];
+            };
+        };
+    }[];
+    shared: never[];
+    backendFederation: {
+        role: string;
+        name: string;
+        runtimeFramework: string;
+        strictEffectApproach: boolean;
+        contractVersion: string;
+        nodeAdapterVersion: string;
+        remoteType: string;
+        expose: string;
+        manifestUrl: string;
+        containerEntry: string;
+        source: {
+            module: string;
+        };
+        readinessPath: string;
+        openapiPath: string;
+        deliveryUnit?: import("@modern-js/utils/universal").DeliveryUnitContractBlock | undefined;
+        versionBoundary: {
+            invariant: string;
+            packageName: string | undefined;
+            version: string | undefined;
+            buildVersion: string | undefined;
+            uiManifestUrl?: string | undefined;
+            deliveryUnit?: {
+                unitId: string;
+                buildMarker: string;
+                sourceRevision: string;
+            } | undefined;
+        };
+    };
+};

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

@@ -0,0 +1,103 @@
+import { type DeliveryUnitContractBlock, type UltramodernBuildArtifact } from '@modern-js/utils/universal';
+export declare const COMPACT_CONFIG_PATH = ".modernjs/ultramodern.json";
+export type CompactApp = {
+    id?: unknown;
+    kind?: unknown;
+    path?: unknown;
+    package?: unknown;
+    port?: unknown;
+    api?: {
+        prefix?: unknown;
+        stem?: unknown;
+    };
+    moduleFederation?: {
+        name?: unknown;
+        manifestUrl?: unknown;
+    };
+    backendFederation?: {
+        name?: unknown;
+        versionBoundary?: {
+            ui?: {
+                manifestUrl?: unknown;
+            };
+        };
+        executionSurfaces?: {
+            node?: {
+                remoteName?: unknown;
+                manifestUrl?: unknown;
+                containerEntry?: unknown;
+                remoteType?: unknown;
+            };
+        };
+    };
+    deliveryUnit?: {
+        unitId?: unknown;
+        buildMarker?: unknown;
+        sourceRevision?: unknown;
+        packageName?: unknown;
+        version?: unknown;
+    };
+    serverExecution?: {
+        node?: {
+            remoteName?: unknown;
+            manifestUrl?: unknown;
+            containerEntry?: unknown;
+            remoteType?: unknown;
+        };
+    };
+};
+export type CompactConfig = {
+    topology?: {
+        apps?: CompactApp[];
+    };
+};
+export type BackendFederationApp = {
+    id: string;
+    directory: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    sourceRevision?: string;
+    deliveryUnit?: DeliveryUnitContractBlock;
+    port: number;
+    apiPrefix: string;
+    apiStem: string;
+    backendName: string;
+    manifestUrl: string;
+    containerEntry: string;
+    remoteType: string;
+    uiManifestUrl?: string;
+    compactDeliveryUnit?: {
+        unitId?: string;
+        buildMarker?: string;
+        sourceRevision?: string;
+        packageName?: string;
+        version?: string;
+    };
+};
+export type BackendFederationBuildIdentity = {
+    appId?: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    sourceRevision?: string;
+    artifact?: UltramodernBuildArtifact;
+};
+export declare const normalizeRelativePath: (value: string) => string;
+export declare const buildArtifactPathFor: (appDirectory: string) => string;
+export declare const buildModulePathFor: (appDirectory: string) => string;
+export declare const readBuildIdentity: (appDirectory: string) => Promise<BackendFederationBuildIdentity>;
+export declare const findWorkspaceRoot: (appDirectory: string) => string | undefined;
+export declare const resolveWorkspaceSourceRevision: (workspaceRoot: string) => Promise<string>;
+export declare const createStampedDeliveryUnit: (input: {
+    appId: string;
+    unitId?: string;
+    buildMarker?: string;
+    packageName?: string;
+    version?: string;
+    sourceRevision: string;
+}) => DeliveryUnitContractBlock | undefined;
+export declare const createAppFromCompactMetadata: (workspaceRoot: string, appDirectory: string, compactApp: CompactApp) => BackendFederationApp | undefined;
+export declare const findBackendFederationApp: (workspaceRoot: string, appDirectory: string) => Promise<BackendFederationApp | undefined>;

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

@@ -0,0 +1,13 @@
+import type { AppTools, CliPlugin } from '../../types';
+export type { BackendFederationBuildIdentity } from './config';
+export type BackendFederationArtifactResult = {
+    appId: string;
+    manifestPath: string;
+    containerPath: string;
+    deliveryUnitArtifactPath?: string;
+    remoteName: string;
+    remoteType: string;
+};
+export declare const emitBackendFederationArtifacts: (appDirectory: string, distDirectory: string) => Promise<BackendFederationArtifactResult | undefined>;
+export default _default;
+declare function _default(): CliPlugin<AppTools>;

package/dist/types/plugins/backendFederationBuild.d.ts

@@ -1,11 +1,2 @@
-import type { AppTools, CliPlugin } from '../types';
-export type BackendFederationArtifactResult = {
-    appId: string;
-    manifestPath: string;
-    containerPath: string;
-    remoteName: string;
-    remoteType: string;
-};
-export declare const emitBackendFederationArtifacts: (appDirectory: string, distDirectory: string) => Promise<BackendFederationArtifactResult | undefined>;
-export default _default;
-declare function _default(): CliPlugin<AppTools>;
+export type { BackendFederationArtifactResult } from './backend-federation/emit';
+export { default, emitBackendFederationArtifacts, } from './backend-federation/emit';

package/dist/types/plugins/deploy/platforms/cloudflare/artifacts.d.ts

@@ -0,0 +1,15 @@
+import type { CloudflareModernConfig } from './types';
+export declare const getCloudflareArtifacts: (modernConfig: CloudflareModernConfig) => {
+    from: string;
+    to: string;
+    index: number;
+}[];
+export declare const getCloudflarePublicAssets: (modernConfig: CloudflareModernConfig) => {
+    from: string;
+    to: string;
+    index: number;
+}[];
+export declare const copyCloudflareArtifacts: (appDirectory: string, outputDirectory: string, artifacts: ReturnType<typeof getCloudflareArtifacts>) => Promise<void>;
+export declare const copyCloudflarePublicAssets: (appDirectory: string, publicDirectory: string, publicAssets: ReturnType<typeof getCloudflarePublicAssets>) => Promise<void>;
+export declare const copyCloudflareD1Migrations: (appDirectory: string, outputDirectory: string, modernConfig: CloudflareModernConfig) => Promise<void>;
+export declare const readRouteSpec: (outputDirectory: string) => Promise<any>;

package/dist/types/plugins/deploy/platforms/cloudflare/constants.d.ts

@@ -0,0 +1,23 @@
+import { CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT } from '../cloudflare-output-contract';
+export { CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT };
+export declare const WORKER_ENTRY = "server/index.mjs";
+export declare const WORKER_MANIFEST = "server/modern-worker-manifest.json";
+export declare const WRANGLER_CONFIG_FILE = "wrangler.json";
+export declare const OUTPUT_PACKAGE_FILE = "package.json";
+export declare const ASSETS_BINDING = "ASSETS";
+export declare const ROUTE_SPEC_FILE = "route.json";
+export declare const ROUTE_SPEC_OUTPUT = "server/route.json";
+export declare const LOADABLE_STATS_FILE = "loadable-stats.json";
+export declare const ROUTE_MANIFEST_FILE = "routes-manifest.json";
+export declare const PUBLIC_ASSETS_DIRECTORY = "public";
+export declare const WORKER_BUNDLE_DIRECTORY = "worker";
+export declare const SERVER_BUNDLE_DIRECTORY = "bundles";
+export declare const SERVER_OUTPUT_DIRECTORY = "server";
+export declare const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES: readonly ['api', 'shared'];
+export declare const BFF_EFFECT_WORKER_ENTRY = "worker/__modern_bff_effect.js";
+export declare const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = "Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.";
+export declare const DEFAULT_COMPATIBILITY_DATE = "2026-06-02";
+export declare const COMPATIBILITY_DATE_PATTERN: RegExp;
+export declare const REQUIRED_COMPATIBILITY_FLAGS: readonly ["nodejs_compat", "global_fetch_strictly_public"];
+export declare const RESERVED_ARTIFACT_DESTINATION_FILES: Set<string>;
+export declare const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES: Set<string>;

package/dist/types/plugins/deploy/platforms/cloudflare/delivery-unit.d.ts

@@ -0,0 +1,23 @@
+import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+export type DeliveryUnitStamp = DeliveryUnitIdentity & {
+    surfaces: {
+        ui: DeliveryUnitIdentity & {
+            surface: 'ui';
+        };
+        api: DeliveryUnitIdentity & {
+            surface: 'api';
+        };
+    };
+};
+/**
+ * Resolve the delivery-unit record declared for this app by the workspace
+ * compact config (`.modernjs/ultramodern.json`). This is the topology source
+ * of truth the Cloudflare worker snapshot is verified against.
+ */
+export declare const resolveTopologyDeliveryUnit: (appDirectory: string) => Promise<DeliveryUnitIdentity | undefined>;
+/**
+ * Resolve the delivery-unit identity actually bundled into the worker by
+ * parsing the generated `shared/ultramodern-build.ts` module. This is the
+ * worker snapshot / UI+API surface source that gets stamped into the manifest.
+ */
+export declare const resolveWorkerDeliveryUnitStamp: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;

package/dist/types/plugins/deploy/platforms/cloudflare/i18n-worker.d.ts

@@ -0,0 +1,21 @@
+import type { CloudflareAppContext } from './types';
+export type WorkerI18nDetection = {
+    order: string[];
+    lookupQuerystring: string;
+    lookupCookie: string;
+    lookupHeader: string;
+};
+export type WorkerI18nEntry = {
+    i18nextDetector: boolean;
+    languages: string[];
+    fallbackLanguage: string;
+    detection: WorkerI18nDetection;
+    ignoreRedirectRoutes: string[];
+    staticRoutePrefixes: string[];
+    localisedUrls?: Record<string, Record<string, string>>;
+};
+export declare const createI18nWorkerManifest: (routeSpec: {
+    routes: Array<Record<string, unknown>>;
+}, appContext: CloudflareAppContext) => {
+    entries: Record<string, WorkerI18nEntry>;
+} | undefined;

package/dist/types/plugins/deploy/platforms/cloudflare/index.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePreset } from '../platform';
+export declare const createCloudflarePreset: CreatePreset;

package/dist/types/plugins/deploy/platforms/cloudflare/security-policies.d.ts

@@ -0,0 +1,88 @@
+import type { CloudflareWorkerSecurityConfig } from '../../../../types/config/deploy';
+export declare const DEFAULT_SECURITY_HEADERS: {
+    readonly referrerPolicy: 'strict-origin-when-cross-origin';
+    readonly contentTypeOptions: 'nosniff';
+    readonly permissionsPolicy: 'camera=(), geolocation=(), microphone=(), payment=(), usb=()';
+};
+export declare const DEFAULT_CORS_ALLOWED_METHODS: string[];
+export declare const DEFAULT_CSP_DIRECTIVES: Record<string, string[]>;
+export declare const createContentSecurityPolicy: (config?: CloudflareWorkerSecurityConfig['contentSecurityPolicy']) => {
+    mode: "off";
+    directives: {};
+    reason: string | undefined;
+} | {
+    mode: "enforce" | "report-only";
+    directives: {
+        [k: string]: string[];
+    };
+    reason: string | undefined;
+};
+export declare const createNoindexPolicy: (noindex: CloudflareWorkerSecurityConfig['noindex']) => {
+    workersDev: boolean;
+    localhost: boolean;
+    previewHostnames: never[];
+    reason?: undefined;
+} | {
+    workersDev: boolean;
+    localhost: boolean;
+    previewHostnames: string[];
+    reason: string | undefined;
+};
+export declare const createCloudflareWorkerCorsPolicy: (cors: CloudflareWorkerSecurityConfig['cors']) => {
+    assets: boolean;
+    allowedOrigins: string[];
+    allowedMethods: string[];
+    allowedHeaders: string[];
+    reason: string | undefined;
+};
+export declare const createCloudflareWorkerSecurityPolicy: (modernConfig: Parameters<CreatePreset>[0]['modernConfig']) => {
+    enabled: boolean;
+    cors: {
+        assets: boolean;
+        allowedOrigins: string[];
+        allowedMethods: string[];
+        allowedHeaders: string[];
+        reason: string | undefined;
+    };
+    reason: any;
+    headers?: undefined;
+    contentSecurityPolicy?: undefined;
+    noindex?: undefined;
+} | {
+    enabled: boolean;
+    headers: {
+        referrerPolicy: any;
+        contentTypeOptions: any;
+        permissionsPolicy: any;
+    };
+    contentSecurityPolicy: {
+        mode: "off";
+        directives: {};
+        reason: string | undefined;
+    } | {
+        mode: "enforce" | "report-only";
+        directives: {
+            [k: string]: string[];
+        };
+        reason: string | undefined;
+    };
+    noindex: {
+        workersDev: boolean;
+        localhost: boolean;
+        previewHostnames: never[];
+        reason?: undefined;
+    } | {
+        workersDev: boolean;
+        localhost: boolean;
+        previewHostnames: string[];
+        reason: string | undefined;
+    };
+    cors: {
+        assets: boolean;
+        allowedOrigins: string[];
+        allowedMethods: string[];
+        allowedHeaders: string[];
+        reason: string | undefined;
+    };
+    reason: any;
+};

package/dist/types/plugins/deploy/platforms/cloudflare/types.d.ts

@@ -0,0 +1,5 @@
+import type { CreatePreset } from '../platform';
+type CloudflarePresetOptions = Parameters<CreatePreset>[0];
+export type CloudflareAppContext = CloudflarePresetOptions['appContext'];
+export type CloudflareModernConfig = CloudflarePresetOptions['modernConfig'];
+export {};

package/dist/types/plugins/deploy/platforms/cloudflare/utils.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue } from '../../../../types/config/deploy';
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const normalizeRelativePath: (value: unknown, label: string, scope?: string, options?: {
+    allowRoot?: boolean;
+}) => string;
+export declare const isJsonRecord: (value: unknown) => value is Record<string, JsonValue>;

package/dist/types/plugins/deploy/platforms/cloudflare/worker-manifest.d.ts

@@ -0,0 +1,100 @@
+import type { DeliveryUnitStamp } from './delivery-unit';
+import type { CloudflareAppContext, CloudflareModernConfig } from './types';
+export declare const createWorkerManifest: (outputDirectory: string, modernConfig: CloudflareModernConfig, appContext: CloudflareAppContext, deliveryUnitStamp: DeliveryUnitStamp | undefined) => Promise<{
+    version: number;
+    runtime: {
+        type: string;
+        entry: string;
+        fetchExport: boolean;
+        nodeListen: boolean;
+    };
+    assets: {
+        binding: string;
+        directory: string;
+        runWorkerFirst: boolean;
+    };
+    routeSpec: {
+        file: string;
+        routes: any[];
+    };
+    workerBundles: {
+        directory: string;
+        format: string;
+        importableFromModuleWorker: boolean;
+        requestHandlerExport: string;
+    };
+    resources: {
+        loadableStats: string;
+        routeManifest: string;
+    };
+    security: {
+        enabled: boolean;
+        cors: {
+            assets: boolean;
+            allowedOrigins: string[];
+            allowedMethods: string[];
+            allowedHeaders: string[];
+            reason: string | undefined;
+        };
+        reason: any;
+        headers?: undefined;
+        contentSecurityPolicy?: undefined;
+        noindex?: undefined;
+    } | {
+        enabled: boolean;
+        headers: {
+            referrerPolicy: any;
+            contentTypeOptions: any;
+            permissionsPolicy: any;
+        };
+        contentSecurityPolicy: {
+            mode: "off";
+            directives: {};
+            reason: string | undefined;
+        } | {
+            mode: "enforce" | "report-only";
+            directives: {
+                [k: string]: string[];
+            };
+            reason: string | undefined;
+        };
+        noindex: {
+            workersDev: boolean;
+            localhost: boolean;
+            previewHostnames: never[];
+            reason?: undefined;
+        } | {
+            workersDev: boolean;
+            localhost: boolean;
+            previewHostnames: string[];
+            reason: string | undefined;
+        };
+        cors: {
+            assets: boolean;
+            allowedOrigins: string[];
+            allowedMethods: string[];
+            allowedHeaders: string[];
+            reason: string | undefined;
+        };
+        reason: any;
+    };
+    deliveryUnit?: DeliveryUnitStamp | undefined;
+    i18n: {
+        entries: Record<string, import("./i18n-worker").WorkerI18nEntry>;
+    } | undefined;
+    bff: {
+        runtimeFramework: string;
+        prefix: string;
+        worker: string;
+    } | undefined;
+    serviceBindings?: {
+        binding: any;
+        service: any;
+        prefix: any;
+        interface: string;
+    }[] | undefined;
+}>;
+export declare const createWorkerModuleLoaders: (manifest: any) => string;
+export declare const getPublicAssetExcludes: (appDirectory: string, modernConfig: CloudflareModernConfig) => string[];
+export declare const shouldCopyToPublicAssets: (src: string, distDirectory: string, publicAssetExcludes: string[]) => boolean;
+export declare const shouldCopyToWorkerBundle: (src: string, workerBundleDirectory: string) => boolean;

package/dist/types/plugins/deploy/platforms/cloudflare/wrangler-config.d.ts

@@ -0,0 +1,39 @@
+import type { JsonValue } from '../../../../types/config/deploy';
+import type { CloudflareModernConfig } from './types';
+export declare const createWorkerServiceBindings: (modernConfig: CloudflareModernConfig, configuredWranglerServices: JsonValue | undefined) => {
+    binding: string;
+    service: string;
+    prefix?: string | undefined;
+}[] | JsonValue | undefined;
+export declare const createWorkerManifestServiceBindings: (serviceBindings: ReturnType<typeof createWorkerServiceBindings>) => {
+    binding: any;
+    service: any;
+    prefix: any;
+    interface: string;
+}[] | undefined;
+export declare const createWranglerConfig: (appDirectory: string, modernConfig: CloudflareModernConfig) => {
+    $schema: string;
+    name: string;
+    compatibility_date: string;
+    main: string;
+    compatibility_flags: JsonValue[];
+    assets: {
+        directory: string;
+        binding: string;
+        run_worker_first: boolean;
+    };
+    d1_databases?: {
+        binding: string;
+        database_name: string;
+        database_id: string;
+        migrations_dir?: string | undefined;
+        preview_database_id?: string | undefined;
+        remote?: boolean | undefined;
+    }[] | JsonValue | undefined;
+    services?: string | number | boolean | JsonValue[] | {
+        binding: string;
+        service: string;
+    }[] | {
+        [key: string]: JsonValue;
+    } | null | undefined;
+};

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/identity.d.ts

@@ -0,0 +1,4 @@
+import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+import type { CloudflareOutputVerifierIssue, JsonObject } from './issues';
+export type CloudflareDeliveryUnitIdentity = DeliveryUnitIdentity;
+export declare const verifyDeliveryUnitIdentity: (issues: CloudflareOutputVerifierIssue[], manifest: JsonObject, manifestPath: string, declared: CloudflareDeliveryUnitIdentity | undefined) => void;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/index.d.ts

@@ -0,0 +1,18 @@
+import type { CloudflareDeliveryUnitIdentity } from './identity';
+import type { CloudflareOutputVerifierResult } from './issues';
+export type { CloudflareDeliveryUnitIdentity } from './identity';
+export type { CloudflareOutputVerifierIssue, CloudflareOutputVerifierIssueCode, CloudflareOutputVerifierResult, } from './issues';
+export { type VerifyCloudflareOutputMutationPolicyOptions, verifyCloudflareOutputMutationPolicy, } from './mutation-policy';
+export interface VerifyCloudflareOutputOptions {
+    outputDirectory: string;
+    importWorker?: boolean;
+    /**
+     * Topology-declared delivery-unit record (from the workspace compact config).
+     * When provided, the Cloudflare worker manifest must carry a matching
+     * `deliveryUnit` stamp so the deployed worker snapshot is proven to derive
+     * from the same delivery unit as the Node/API surfaces (ADR-0019 lane D).
+     */
+    deliveryUnit?: CloudflareDeliveryUnitIdentity;
+}
+export declare const verifyCloudflareOutput: (options: VerifyCloudflareOutputOptions) => Promise<CloudflareOutputVerifierResult>;
+export declare const assertCloudflareOutput: (options: VerifyCloudflareOutputOptions) => Promise<void>;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/issues.d.ts

@@ -0,0 +1,14 @@
+export type CloudflareOutputVerifierIssueCode = 'missing-file' | 'invalid-manifest' | 'invalid-wrangler' | 'invalid-package' | 'public-output-leak' | 'missing-worker-bundle' | 'invalid-worker-bundle' | 'worker-import-failed' | 'delivery-unit-drift' | 'missing-delivery-unit' | 'forbidden-mutation-pattern';
+export interface CloudflareOutputVerifierIssue {
+    code: CloudflareOutputVerifierIssueCode;
+    message: string;
+    path?: string;
+}
+export interface CloudflareOutputVerifierResult {
+    ok: boolean;
+    issues: CloudflareOutputVerifierIssue[];
+}
+export type JsonObject = Record<string, any>;
+export declare const addIssue: (issues: CloudflareOutputVerifierIssue[], issue: CloudflareOutputVerifierIssue) => void;
+export declare const assertEqual: (issues: CloudflareOutputVerifierIssue[], actual: unknown, expected: unknown, issue: CloudflareOutputVerifierIssue) => void;
+export declare const assertFlag: (issues: CloudflareOutputVerifierIssue[], flags: unknown, flag: string, issue: CloudflareOutputVerifierIssue) => void;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { CloudflareOutputVerifierIssue, JsonObject } from './issues';
+export declare const verifyManifestShape: (issues: CloudflareOutputVerifierIssue[], manifest: JsonObject, manifestPath: string) => void;