@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

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

@@ -0,0 +1,83 @@
+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;
+        appId: 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

@@ -0,0 +1,2 @@
+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,22 @@
+import type { CloudflareAppContext } from './types';
+type WorkerI18nDetection = {
+    order: string[];
+    lookupQuerystring: string;
+    lookupCookie: string;
+    lookupHeader: string;
+};
+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;
+export {};

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

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

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

@@ -0,0 +1,51 @@
+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,113 @@
+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, {
+            i18nextDetector: boolean;
+            languages: string[];
+            fallbackLanguage: string;
+            detection: {
+                order: string[];
+                lookupQuerystring: string;
+                lookupCookie: string;
+                lookupHeader: string;
+            };
+            ignoreRedirectRoutes: string[];
+            staticRoutePrefixes: string[];
+            localisedUrls?: Record<string, Record<string, string>>;
+        }>;
+    } | 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-contract.d.ts

@@ -0,0 +1,13 @@
+export declare const CLOUDFLARE_WORKER_ENTRY = "server/index.mjs";
+export declare const CLOUDFLARE_WORKER_MANIFEST = "server/modern-worker-manifest.json";
+export declare const CLOUDFLARE_WRANGLER_CONFIG_FILE = "wrangler.json";
+export declare const CLOUDFLARE_OUTPUT_PACKAGE_FILE = "package.json";
+export declare const CLOUDFLARE_WORKER_PACKAGE_FILE = "worker/package.json";
+export declare const CLOUDFLARE_ASSETS_BINDING = "ASSETS";
+export declare const CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = "public";
+export declare const CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = "worker";
+export declare const CLOUDFLARE_RUNTIME_TYPE = "cloudflare-module-worker";
+export declare const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = "module";
+export declare const CLOUDFLARE_WORKER_PACKAGE_TYPE = "commonjs";
+export declare const CLOUDFLARE_WORKER_BUNDLE_FORMAT = "commonjs";
+export declare const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS: readonly ['nodejs_compat', 'global_fetch_strictly_public'];

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

@@ -0,0 +1,34 @@
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_PACKAGE_TYPE } from './cloudflare-output-contract';
+type CloudflareOutputPlan = {
+    outputDirectory: string;
+    requiredFiles: string[];
+    publicLeakDirectories: string[];
+    paths: {
+        workerEntry: string;
+        workerManifest: string;
+        wranglerConfig: string;
+        outputPackage: string;
+        workerPackage: string;
+        publicAssets: string;
+        workerBundle: string;
+    };
+    packages: {
+        output: {
+            type: typeof CLOUDFLARE_OUTPUT_PACKAGE_TYPE;
+        };
+        worker: {
+            type: typeof CLOUDFLARE_WORKER_PACKAGE_TYPE;
+        };
+    };
+    wrangler: {
+        main: typeof CLOUDFLARE_WORKER_ENTRY;
+        assets: {
+            binding: typeof CLOUDFLARE_ASSETS_BINDING;
+            directory: `./${typeof CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`;
+            run_worker_first: true;
+        };
+        requiredCompatibilityFlags: typeof CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+    };
+};
+export declare function createCloudflareOutputPlan(outputDirectory: string): CloudflareOutputPlan;
+export {};

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;

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

@@ -0,0 +1,6 @@
+import type { CloudflareOutputVerifierResult } from './issues';
+export interface VerifyCloudflareOutputMutationPolicyOptions {
+    scanRoots: string[];
+}
+export declare const walkFiles: (root: string) => Promise<string[]>;
+export declare const verifyCloudflareOutputMutationPolicy: (options: VerifyCloudflareOutputMutationPolicyOptions) => Promise<CloudflareOutputVerifierResult>;

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

@@ -0,0 +1,15 @@
+import type { CloudflareOutputVerifierIssue, JsonObject } from './issues';
+interface WorkerBundleReference {
+    kind: 'effect-bff' | 'route';
+    reference: string;
+}
+interface ResolvedWorkerBundleReference extends WorkerBundleReference {
+    path: string;
+}
+export declare const getEffectBffWorker: (manifest: JsonObject) => any;
+export declare const getWorkerBundleReferences: (manifest: JsonObject) => WorkerBundleReference[];
+export declare const resolveWorkerBundleReference: (issues: CloudflareOutputVerifierIssue[], outputDirectory: string, reference: WorkerBundleReference, manifestPath: string) => ResolvedWorkerBundleReference | null;
+export declare const missingWorkerBundleMessage: (reference: WorkerBundleReference) => "Cloudflare Effect BFF manifest points to a missing worker bundle." | "Cloudflare route worker manifest points to a missing worker bundle.";
+export declare const verifyWorkerBundleReferences: (issues: CloudflareOutputVerifierIssue[], worker: ResolvedWorkerBundleReference, source: string) => void;
+export declare const verifyWorkerImport: (issues: CloudflareOutputVerifierIssue[], entryPath: string) => Promise<void>;
+export {};

package/dist/types/plugins/deploy/platforms/templates/cloudflare-entry.001-bootstrap-security.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/types/plugins/deploy/platforms/templates/cloudflare-entry.002-assets-routes.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/types/plugins/deploy/platforms/templates/cloudflare-entry.003-i18n-locales.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/types/plugins/deploy/platforms/templates/cloudflare-entry.004-rendering-css.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/types/plugins/deploy/platforms/templates/cloudflare-entry.005-worker-dispatch.d.mts

@@ -0,0 +1 @@
+export {};