@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.2

package/dist/types/release-envelope/plugin.d.ts

@@ -0,0 +1,30 @@
+type ReleaseEnvelopeTarget = 'cloudflare' | 'node' | string;
+export interface ReleaseEnvelopeConfig {
+    deploy?: {
+        target?: string;
+    };
+}
+export interface ReleaseEnvelopeAppContext {
+    apiOnly: boolean;
+    appDirectory: string;
+    distDirectory: string;
+    metaName: string;
+}
+export interface ReleaseEnvelopePluginApi<Config extends ReleaseEnvelopeConfig = ReleaseEnvelopeConfig> {
+    getAppContext(): ReleaseEnvelopeAppContext;
+    getNormalizedConfig(): Config;
+    onAfterBuild(handler: () => Promise<void>): void;
+    onBeforeDeploy(handler: () => Promise<void>): void;
+    onAfterDeploy(handler: () => Promise<void>): void;
+}
+export interface ReleaseEnvelopePlugin<Config extends ReleaseEnvelopeConfig = ReleaseEnvelopeConfig> {
+    name: string;
+    pre: string[];
+    post: string[];
+    setup(api: ReleaseEnvelopePluginApi<Config>): void;
+}
+export type ResolveDeployTarget<Config extends ReleaseEnvelopeConfig = ReleaseEnvelopeConfig> = (config: Config) => ReleaseEnvelopeTarget;
+export declare const createUltramodernReleaseEnvelopePlugin: <Config extends ReleaseEnvelopeConfig>({ resolveDeployTarget, }: {
+    resolveDeployTarget: ResolveDeployTarget<Config>;
+}) => ReleaseEnvelopePlugin<Config>;
+export {};

package/dist/types/release-envelope/types.d.ts

@@ -0,0 +1,62 @@
+export declare const MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION: 3;
+export declare const MICROVERTICAL_RELEASE_ENVELOPE_KIND: 'ultramodern-target-microvertical-release-envelope';
+export declare const MICROVERTICAL_RELEASE_TARGETS: readonly ['node', 'cloudflare'];
+export type MicroVerticalReleaseTarget = (typeof MICROVERTICAL_RELEASE_TARGETS)[number];
+export type MicroVerticalReleaseIdentity = {
+    unitId: string;
+    buildMarker: string;
+    sourceRevision: string;
+    releaseVersion: string;
+};
+export type MicroVerticalReleaseArtifactInput = {
+    logicalPath: string;
+    runtime: string;
+};
+export type MicroVerticalReleaseFileArtifact = MicroVerticalReleaseArtifactInput & {
+    kind: 'file';
+    byteLength: number;
+    sha256: string;
+};
+export type MicroVerticalReleaseSymbolicLinkArtifact = MicroVerticalReleaseArtifactInput & {
+    kind: 'symbolic-link';
+    linkTarget: string;
+    targetKind: 'directory' | 'file';
+    targetLogicalPath: string;
+};
+export type MicroVerticalReleaseArtifact = MicroVerticalReleaseFileArtifact | MicroVerticalReleaseSymbolicLinkArtifact;
+export type MicroVerticalReleaseArtifactInputs = {
+    artifacts: MicroVerticalReleaseArtifactInput[];
+    surfaces: MicroVerticalReleaseSurfaces;
+};
+export type MicroVerticalReleaseSurfaces = {
+    uiClient: string[];
+    ssr: string[];
+    apiBackend: string[];
+    backendFederation: {
+        manifest: string;
+        container: string;
+    };
+};
+export type MicroVerticalReleaseEnvelopePayload = {
+    schemaVersion: typeof MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION;
+    kind: typeof MICROVERTICAL_RELEASE_ENVELOPE_KIND;
+    target: MicroVerticalReleaseTarget;
+    identity: MicroVerticalReleaseIdentity;
+    artifacts: MicroVerticalReleaseArtifact[];
+    surfaces: MicroVerticalReleaseSurfaces;
+};
+export type MicroVerticalReleaseEnvelope = MicroVerticalReleaseEnvelopePayload & {
+    envelopeDigest: string;
+};
+export type CreateMicroVerticalReleaseEnvelopeInput = {
+    artifactRoot: string;
+    target: MicroVerticalReleaseTarget;
+    identity: MicroVerticalReleaseIdentity;
+    artifacts: MicroVerticalReleaseArtifactInput[];
+    surfaces: MicroVerticalReleaseSurfaces;
+};
+export type VerifyMicroVerticalReleaseEnvelopeOptions = {
+    artifactRoot: string;
+    logicalPathForArtifact?: (artifact: MicroVerticalReleaseArtifact) => string;
+    expectedTarget?: MicroVerticalReleaseTarget;
+};

package/dist/types/release-identity.d.ts

@@ -0,0 +1,16 @@
+export type UltramodernReleaseIdentity = {
+    buildMarker: string;
+    sourceRevision: string;
+};
+export declare const createUltramodernReleaseBuildMarker: ({ generationBuildMarker, sourceRevision, unitId, }: {
+    generationBuildMarker: string;
+    sourceRevision: string;
+    unitId: string;
+}) => string;
+export declare const resolveUltramodernSourceRevision: (workspaceRoot?: string, configuredSourceRevision?: string) => string;
+export declare const resolveUltramodernReleaseIdentity: ({ generationBuildMarker, sourceRevision: configuredSourceRevision, unitId, workspaceRoot, }: {
+    generationBuildMarker: string;
+    sourceRevision?: string;
+    unitId: string;
+    workspaceRoot?: string;
+}) => UltramodernReleaseIdentity;

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

@@ -0,0 +1 @@
+export declare const modernWorkerManifest: any;

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

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

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

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

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

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

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

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

package/dist/types/templates/cloudflare-entry.006-fetch-handler.d.mts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch(request: any, env: any, ctx: any): Promise<any>;
+};
+export default _default;

package/dist/types/templates/cloudflare-worker-fs-promises.d.mts

@@ -0,0 +1,5 @@
+export declare const readFile: () => Promise<never>;
+declare const _default: {
+    readFile: () => Promise<never>;
+};
+export default _default;

package/dist/types/templates/cloudflare-worker-loadable-server.d.mts

@@ -0,0 +1,48 @@
+import React from 'react';
+export declare function ChunkExtractorManager({ extractor, children }: {
+    children: any;
+    extractor: any;
+}): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+export declare class ChunkExtractor {
+    namespace: string;
+    stats: any;
+    publicPath: any;
+    outputPath: any;
+    entrypoints: string[];
+    chunks: any[];
+    constructor({ stats, entrypoints, namespace, outputPath, publicPath, }?: {
+        entrypoints?: string[] | undefined;
+        namespace?: string | undefined;
+        outputPath?: string | undefined;
+    });
+    addChunk(chunk: any): void;
+    collectChunks(app: any): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+    getChunkGroup(chunk: any): any;
+    getChunkInfo(chunkId: any): any;
+    resolvePublicUrl(filename: any): string;
+    createChunkAsset({ filename, chunk, type, linkType }: {
+        chunk: any;
+        filename: any;
+        linkType: any;
+        type: any;
+    }): {
+        filename: any;
+        integrity: any;
+        scriptType: string;
+        chunk: any;
+        url: string;
+        path: string;
+        type: any;
+        linkType: any;
+    } | undefined;
+    getChunkAssets(chunks: any): any;
+    getChunkChildAssets(chunks: any, type: any): any;
+    getChunkDependencies(chunks: any): any;
+    getRequiredChunksScriptContent(): string;
+    getRequiredChunksNamesScriptContent(): string;
+    getRequiredChunksScriptTag(extraProps?: {}): string;
+    getMainAssets(scriptType: any): any;
+    getScriptTags(extraProps?: {}): string;
+    getStyleTags(extraProps?: {}): any;
+    getLinkTags(extraProps?: {}): any;
+}

package/dist/types/templates/cloudflare-worker-mf-ssr-runtime-plugin.d.mts

@@ -0,0 +1,13 @@
+/**
+ * Workerd cannot initialize Module Federation's Node-oriented SSR data-fetch
+ * runtime. Cloudflare workers do not load native MF remotes, so retain the
+ * runtime-plugin contract without installing its server data-fetch hooks.
+ */
+export declare const injectDataFetchFunctionPlugin: () => {
+    name: string;
+    setup(): void;
+};
+export declare const mfSSRDevPlugin: () => {
+    name: string;
+    setup(): void;
+};

package/dist/types/templates/cloudflare-worker-path.d.mts

@@ -0,0 +1,21 @@
+export declare const sep = "/";
+export declare const delimiter = ":";
+export declare function isAbsolute(filePath: any): boolean;
+export declare function normalize(filePath: any): string;
+export declare function join(...segments: any[]): string;
+export declare function resolve(...segments: any[]): string;
+export declare function dirname(filePath: any): string;
+export declare function basename(filePath: any, suffix?: string): string;
+export declare function extname(filePath: any): string;
+declare const _default: {
+    basename: typeof basename;
+    delimiter: string;
+    dirname: typeof dirname;
+    extname: typeof extname;
+    isAbsolute: typeof isAbsolute;
+    join: typeof join;
+    normalize: typeof normalize;
+    resolve: typeof resolve;
+    sep: string;
+};
+export default _default;

package/package.json

@@ -0,0 +1,131 @@
+{
+  "name": "@bleedingdev/modern-js-app-tools-extensions",
+  "description": "Fork-owned UltraModern.js app-tools extensions for Cloudflare delivery and release envelopes.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/solutions/app-tools-extensions"
+  },
+  "license": "MIT",
+  "version": "3.8.3-ultramodern.2",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    },
+    "./cloudflare": {
+      "types": "./dist/types/cloudflare/index.d.ts",
+      "import": "./dist/esm-node/cloudflare/index.mjs",
+      "require": "./dist/cjs/cloudflare/index.js"
+    },
+    "./cloudflare-builder": {
+      "types": "./dist/types/cloudflare-builder.d.ts",
+      "import": "./dist/esm-node/cloudflare-builder.mjs",
+      "require": "./dist/cjs/cloudflare-builder.js"
+    },
+    "./cloudflare/*": {
+      "types": "./dist/types/cloudflare/*.d.ts",
+      "import": "./dist/esm-node/cloudflare/*.mjs",
+      "require": "./dist/cjs/cloudflare/*.js"
+    },
+    "./cloudflare-output-contract": {
+      "types": "./dist/types/cloudflare-output-contract.d.ts",
+      "import": "./dist/esm-node/cloudflare-output-contract.mjs",
+      "require": "./dist/cjs/cloudflare-output-contract.js"
+    },
+    "./cloudflare-output-plan": {
+      "types": "./dist/types/cloudflare-output-plan.d.ts",
+      "import": "./dist/esm-node/cloudflare-output-plan.mjs",
+      "require": "./dist/cjs/cloudflare-output-plan.js"
+    },
+    "./cloudflare-output-verifier": {
+      "types": "./dist/types/cloudflare-output-verifier/index.d.ts",
+      "import": "./dist/esm-node/cloudflare-output-verifier/index.mjs",
+      "require": "./dist/cjs/cloudflare-output-verifier/index.js"
+    },
+    "./cloudflare-output-verifier/*": {
+      "types": "./dist/types/cloudflare-output-verifier/*.d.ts",
+      "import": "./dist/esm-node/cloudflare-output-verifier/*.mjs",
+      "require": "./dist/cjs/cloudflare-output-verifier/*.js"
+    },
+    "./config": {
+      "types": "./dist/types/config.d.ts",
+      "import": "./dist/esm-node/config.mjs",
+      "require": "./dist/cjs/config.js"
+    },
+    "./release-envelope": {
+      "types": "./dist/types/release-envelope/index.d.ts",
+      "import": "./dist/esm-node/release-envelope/index.mjs",
+      "require": "./dist/cjs/release-envelope/index.js"
+    },
+    "./release-envelope/*": {
+      "types": "./dist/types/release-envelope/*.d.ts",
+      "import": "./dist/esm-node/release-envelope/*.mjs",
+      "require": "./dist/cjs/release-envelope/*.js"
+    },
+    "./release-identity": {
+      "types": "./dist/types/release-identity.d.ts",
+      "import": "./dist/esm-node/release-identity.mjs",
+      "require": "./dist/cjs/release-identity.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/types/*",
+        "./src/*"
+      ]
+    }
+  },
+  "engines": {
+    "node": ">=26.7.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^8.0.0",
+    "@babel/traverse": "^8.0.0",
+    "@loadable/component": "5.16.7",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.8.3-ultramodern.2",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.8.3-ultramodern.2",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.8.3-ultramodern.2",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.8.3-ultramodern.2",
+    "@swc/helpers": "^0.5.23",
+    "std-env": "4.2.0"
+  },
+  "peerDependencies": {
+    "@rsbuild/core": "2.2.0"
+  },
+  "devDependencies": {
+    "@module-federation/runtime-tools": "2.9.0",
+    "@rsbuild/core": "2.2.0",
+    "@rslib/core": "0.23.2",
+    "@scripts/rstest-config": "2.66.0",
+    "@types/babel__traverse": "7.28.0",
+    "@types/node": "^26.2.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "core-js": "^3.49.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "pretest": "pnpm run build",
+    "dev": "rslib build --watch",
+    "build": "rslib build",
+    "test": "rstest"
+  }
+}

package/src/cloudflare/artifacts.ts

@@ -0,0 +1,165 @@
+import path from 'node:path';
+import { fs as fse } from '@modern-js/utils';
+import type {
+  CloudflareWorkerArtifactConfig,
+  CloudflareWorkerPublicAssetConfig,
+} from '../config';
+import {
+  RESERVED_ARTIFACT_DESTINATION_DIRECTORIES,
+  RESERVED_ARTIFACT_DESTINATION_FILES,
+  ROUTE_SPEC_OUTPUT,
+} from './constants';
+import type { CloudflareModernConfig } from './types';
+import { normalizeRelativePath } from './utils';
+
+const normalizeCloudflareArtifact = (
+  artifact: CloudflareWorkerArtifactConfig,
+  index: number,
+) => {
+  const from = normalizeRelativePath(
+    artifact.from,
+    `deploy.worker.artifacts[${index}].from`,
+    'app root',
+  );
+  const to = normalizeRelativePath(
+    artifact.to,
+    `deploy.worker.artifacts[${index}].to`,
+    'Cloudflare output',
+  );
+  const [topLevelDestination] = to.split('/');
+  const reservedDestination = RESERVED_ARTIFACT_DESTINATION_FILES.has(to)
+    ? to
+    : topLevelDestination;
+
+  if (
+    RESERVED_ARTIFACT_DESTINATION_FILES.has(to) ||
+    RESERVED_ARTIFACT_DESTINATION_DIRECTORIES.has(topLevelDestination)
+  ) {
+    throw new Error(
+      `deploy.worker.artifacts[${index}].to must not target generated Cloudflare output path ${JSON.stringify(
+        reservedDestination,
+      )}.`,
+    );
+  }
+
+  return {
+    from,
+    to,
+    index,
+  };
+};
+
+export const getCloudflareArtifacts = (modernConfig: CloudflareModernConfig) =>
+  (modernConfig.deploy?.worker?.artifacts ?? []).map(
+    normalizeCloudflareArtifact,
+  );
+
+const normalizeCloudflarePublicAsset = (
+  asset: CloudflareWorkerPublicAssetConfig,
+  index: number,
+) => {
+  const from = normalizeRelativePath(
+    asset.from,
+    `deploy.worker.publicAssets[${index}].from`,
+    'app root',
+  );
+  const to = normalizeRelativePath(
+    asset.to,
+    `deploy.worker.publicAssets[${index}].to`,
+    'Cloudflare public output',
+    { allowRoot: true },
+  );
+
+  return {
+    from,
+    to,
+    index,
+  };
+};
+
+export const getCloudflarePublicAssets = (
+  modernConfig: CloudflareModernConfig,
+) =>
+  (modernConfig.deploy?.worker?.publicAssets ?? []).map(
+    normalizeCloudflarePublicAsset,
+  );
+
+export const copyCloudflareArtifacts = async (
+  appDirectory: string,
+  outputDirectory: string,
+  artifacts: ReturnType<typeof getCloudflareArtifacts>,
+) => {
+  for (const artifact of artifacts) {
+    const sourcePath = path.join(appDirectory, artifact.from);
+
+    if (!(await fse.pathExists(sourcePath))) {
+      throw new Error(
+        `deploy.worker.artifacts[${artifact.index}].from does not exist: ${artifact.from}`,
+      );
+    }
+
+    await fse.copy(sourcePath, path.join(outputDirectory, artifact.to));
+  }
+};
+
+export const copyCloudflarePublicAssets = async (
+  appDirectory: string,
+  publicDirectory: string,
+  publicAssets: ReturnType<typeof getCloudflarePublicAssets>,
+) => {
+  for (const asset of publicAssets) {
+    const sourcePath = path.join(appDirectory, asset.from);
+
+    if (!(await fse.pathExists(sourcePath))) {
+      throw new Error(
+        `deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`,
+      );
+    }
+
+    await fse.copy(sourcePath, path.join(publicDirectory, asset.to));
+  }
+};
+
+export const copyCloudflareD1Migrations = async (
+  appDirectory: string,
+  outputDirectory: string,
+  modernConfig: CloudflareModernConfig,
+) => {
+  for (const [index, database] of (
+    modernConfig.deploy?.worker?.d1Databases ?? []
+  ).entries()) {
+    if (!database.migrationsDir) {
+      continue;
+    }
+
+    const migrationsDir = normalizeRelativePath(
+      database.migrationsDir,
+      `deploy.worker.d1Databases[${index}].migrationsDir`,
+      'app root',
+    );
+    const sourcePath = path.join(appDirectory, migrationsDir);
+
+    if (!(await fse.pathExists(sourcePath))) {
+      throw new Error(
+        `deploy.worker.d1Databases[${index}].migrationsDir does not exist: ${migrationsDir}`,
+      );
+    }
+
+    await fse.copy(sourcePath, path.join(outputDirectory, migrationsDir));
+  }
+};
+
+export const readRouteSpec = async (outputDirectory: string) => {
+  const routeSpecPath = path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
+
+  if (!(await fse.pathExists(routeSpecPath))) {
+    return { routes: [] };
+  }
+
+  const routeSpec = await fse.readJSON(routeSpecPath);
+
+  return {
+    ...routeSpec,
+    routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : [],
+  };
+};

package/src/cloudflare/constants.ts

@@ -0,0 +1,50 @@
+import {
+  CLOUDFLARE_ASSETS_BINDING,
+  CLOUDFLARE_OUTPUT_PACKAGE_FILE,
+  CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY,
+  CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS,
+  CLOUDFLARE_RUNTIME_TYPE,
+  CLOUDFLARE_WORKER_BUNDLE_DIRECTORY,
+  CLOUDFLARE_WORKER_BUNDLE_FORMAT,
+  CLOUDFLARE_WORKER_ENTRY,
+  CLOUDFLARE_WORKER_MANIFEST,
+  CLOUDFLARE_WRANGLER_CONFIG_FILE,
+} from '../cloudflare-output-contract';
+
+export { CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT };
+
+export const WORKER_ENTRY = CLOUDFLARE_WORKER_ENTRY;
+export const WORKER_MANIFEST = CLOUDFLARE_WORKER_MANIFEST;
+export const WRANGLER_CONFIG_FILE = CLOUDFLARE_WRANGLER_CONFIG_FILE;
+export const OUTPUT_PACKAGE_FILE = CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+export const ASSETS_BINDING = CLOUDFLARE_ASSETS_BINDING;
+export const ROUTE_SPEC_FILE = 'route.json';
+export const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
+export const LOADABLE_STATS_FILE = 'loadable-stats.json';
+export const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+export const PUBLIC_ASSETS_DIRECTORY = CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+export const WORKER_BUNDLE_DIRECTORY = CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
+export const SERVER_BUNDLE_DIRECTORY = 'bundles';
+export const SERVER_OUTPUT_DIRECTORY = 'server';
+export const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
+  'api',
+  'shared',
+] as const;
+export const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+export const BFF_EFFECT_WORKER_DISPATCHER_EXPORT =
+  '__modern_create_effect_bff_dispatcher';
+export 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 const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
+export const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+export const REQUIRED_COMPATIBILITY_FLAGS =
+  CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+export const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
+  WRANGLER_CONFIG_FILE,
+  OUTPUT_PACKAGE_FILE,
+]);
+export const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES = new Set([
+  PUBLIC_ASSETS_DIRECTORY,
+  SERVER_OUTPUT_DIRECTORY,
+  WORKER_BUNDLE_DIRECTORY,
+]);