@bleedingdev/modern-js-create 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

package/dist/esm/ultramodern-workspace/naming.js

@@ -0,0 +1,71 @@
+import node_path from "node:path";
+const TAILWIND_PREFIX_DIGIT_WORDS = [
+    'zero',
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine'
+];
+function normalizePath(filePath) {
+    return filePath.split(node_path.sep).join('/');
+}
+function toPackageScope(packageName) {
+    const normalized = packageName.replace(/^@/, '').replace(/[\\/]+/g, '-').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[._-]+|[._-]+$/g, '').replace(/-{2,}/g, '-');
+    return normalized || 'ultramodern-superapp';
+}
+function toKebabCase(value) {
+    const normalized = value.trim().replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/[._]+/g, '-').toLowerCase().replace(/-+/g, '-').replace(/^-+|-+$/g, '');
+    return normalized;
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    return `${pascal.charAt(0).toLowerCase()}${pascal.slice(1)}`;
+}
+function toEnvSegment(value) {
+    return toKebabCase(value).replace(/-/g, '_').toUpperCase();
+}
+function createRspackUniqueName(app) {
+    return app.mfName;
+}
+function createRspackChunkLoadingGlobal(app) {
+    return `__ULTRAMODERN_${toEnvSegment(app.mfName)}_LOADED_CHUNKS__`;
+}
+function naming_packageName(scope, suffix) {
+    return `@${scope}/${suffix}`;
+}
+function relativeRootFor(packageDir) {
+    return normalizePath(node_path.relative(packageDir, '.') || '.');
+}
+function createTailwindPrefix(raw) {
+    const normalized = raw.toLowerCase().replace(/[^a-z0-9]/gu, '');
+    if (!normalized) throw new Error(`Cannot derive a Tailwind prefix from ${raw}`);
+    return normalized.replace(/[0-9]/gu, (digit)=>TAILWIND_PREFIX_DIGIT_WORDS[Number(digit)]);
+}
+function tailwindPrefixForApp(app) {
+    if ('shell' === app.kind) return 'shell';
+    return createTailwindPrefix(app.domain ?? app.id);
+}
+function assertUniqueTailwindPrefixes(apps) {
+    const seen = new Map();
+    const entries = apps.map((app)=>[
+            app.id,
+            tailwindPrefixForApp(app)
+        ]);
+    for (const [id, prefix] of entries){
+        const previous = seen.get(prefix);
+        if (previous) throw new Error(`Tailwind prefix ${prefix} for ${id} collides with ${previous}`);
+        seen.set(prefix, id);
+    }
+}
+function createTw(prefix) {
+    return (classList)=>classList.split(/\s+/u).filter(Boolean).map((candidate)=>`${prefix}:${candidate.replace(/\[&&\]:/gu, '')}`).join(' ');
+}
+function toPascalCase(value) {
+    return value.split(/[-_]+/).filter(Boolean).map((part)=>`${part.charAt(0).toUpperCase()}${part.slice(1)}`).join('');
+}
+export { TAILWIND_PREFIX_DIGIT_WORDS, assertUniqueTailwindPrefixes, createRspackChunkLoadingGlobal, createRspackUniqueName, createTailwindPrefix, createTw, naming_packageName as packageName, normalizePath, relativeRootFor, tailwindPrefixForApp, toCamelCase, toEnvSegment, toKebabCase, toPackageScope, toPascalCase };

package/dist/esm/ultramodern-workspace/package-json.js

@@ -0,0 +1,338 @@
+import { WORKSPACE_PACKAGE_VERSION, modernPackageSpecifier } from "../ultramodern-package-source.js";
+import { appHasEffectApi, remoteDependencyAlias, resolveRemoteRefs, shellApp, verticalEffectApps, zephyrRemoteDependency } from "./descriptors.js";
+import { readFileTemplate } from "./fs-io.js";
+import { packageName, relativeRootFor } from "./naming.js";
+import { createPublicSurfaceGenerationCommand } from "./public-surface.js";
+import { EFFECT_TSGO_VERSION, I18NEXT_VERSION, LEFTHOOK_VERSION, MODULE_FEDERATION_VERSION, NODE_FETCH_VERSION, OXFMT_VERSION, OXLINT_VERSION, PNPM_VERSION, POSTCSS_VERSION, REACT_DOM_VERSION, REACT_ROUTER_DOM_VERSION, REACT_VERSION, TAILWIND_POSTCSS_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, TYPESCRIPT_VERSION, TYPES_REACT_DOM_VERSION, TYPES_REACT_VERSION, ULTRACITE_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION } from "./versions.js";
+const effectTsgoTypecheckCommand = "node -e \"const fs = require('node:fs'); const { execFileSync, spawnSync } = require('node:child_process'); const bin = execFileSync('effect-tsgo', ['get-exe-path'], { encoding: 'utf8' }).trim(); if (process.platform !== 'win32') fs.chmodSync(bin, 0o755); const result = spawnSync(bin, ['--noEmit', '-p', 'tsconfig.json'], { stdio: 'inherit' }); process.exit(result.status ?? 1);\"";
+const effectDiagnostics = [
+    'anyUnknownInErrorContext',
+    'classSelfMismatch',
+    'duplicatePackage',
+    'effectFnImplicitAny',
+    'floatingEffect',
+    'genericEffectServices',
+    'missingEffectContext',
+    'missingEffectError',
+    'missingLayerContext',
+    'missingReturnYieldStar',
+    'missingStarInYieldEffectGen',
+    'nonObjectEffectServiceType',
+    'outdatedApi',
+    'overriddenSchemaConstructor',
+    'catchUnfailableEffect',
+    'effectFnIife',
+    'effectGenUsesAdapter',
+    'effectInFailure',
+    'effectInVoidSuccess',
+    'globalErrorInEffectCatch',
+    'globalErrorInEffectFailure',
+    'layerMergeAllWithDependencies',
+    'lazyPromiseInEffectSync',
+    'leakingRequirements',
+    'multipleEffectProvide',
+    'returnEffectInGen',
+    'runEffectInsideEffect',
+    'schemaSyncInEffect',
+    'scopeInLayerEffect',
+    'strictEffectProvide',
+    'tryCatchInEffectGen',
+    'unknownInEffectCatch',
+    'asyncFunction',
+    'cryptoRandomUUID',
+    'cryptoRandomUUIDInEffect',
+    'extendsNativeError',
+    'globalConsole',
+    'globalConsoleInEffect',
+    'globalDate',
+    'globalDateInEffect',
+    'globalFetch',
+    'globalFetchInEffect',
+    'globalRandom',
+    'globalRandomInEffect',
+    'globalTimers',
+    'globalTimersInEffect',
+    'instanceOfSchema',
+    'newPromise',
+    'nodeBuiltinImport',
+    'preferSchemaOverJson',
+    'processEnv',
+    'processEnvInEffect',
+    'unsafeEffectTypeAssertion',
+    'catchAllToMapError',
+    'deterministicKeys',
+    'effectDoNotation',
+    'effectFnOpportunity',
+    'effectMapFlatten',
+    'effectMapVoid',
+    'effectSucceedWithVoid',
+    'missedPipeableOpportunity',
+    'missingEffectServiceDependency',
+    'nestedEffectGenYield',
+    'redundantSchemaTagIdentifier',
+    'schemaStructWithTag',
+    'schemaUnionOfLiterals',
+    'serviceNotAsClass',
+    'strictBooleanExpressions',
+    'unnecessaryArrowBlock',
+    'unnecessaryEffectGen',
+    'unnecessaryFailYieldableError',
+    'unnecessaryPipe',
+    'unnecessaryPipeChain'
+];
+function appDependencies(scope, packageSource, app, remotes = []) {
+    const dependencies = {
+        '@modern-js/plugin-tanstack': modernPackageSpecifier('@modern-js/plugin-tanstack', packageSource),
+        '@modern-js/plugin-i18n': modernPackageSpecifier('@modern-js/plugin-i18n', packageSource),
+        '@modern-js/runtime': modernPackageSpecifier('@modern-js/runtime', packageSource),
+        '@module-federation/bridge-react': MODULE_FEDERATION_VERSION,
+        '@module-federation/modern-js-v3': MODULE_FEDERATION_VERSION,
+        '@module-federation/runtime': MODULE_FEDERATION_VERSION,
+        '@tanstack/react-router': TANSTACK_ROUTER_VERSION,
+        i18next: I18NEXT_VERSION,
+        'node-fetch': NODE_FETCH_VERSION,
+        [packageName(scope, 'shared-contracts')]: WORKSPACE_PACKAGE_VERSION,
+        [packageName(scope, 'shared-design-tokens')]: WORKSPACE_PACKAGE_VERSION,
+        react: REACT_VERSION,
+        'react-dom': REACT_DOM_VERSION,
+        'react-router-dom': REACT_ROUTER_DOM_VERSION
+    };
+    if ('shell' === app.kind) {
+        dependencies['@modern-js/plugin-bff'] = modernPackageSpecifier('@modern-js/plugin-bff', packageSource);
+        for (const remote of verticalEffectApps(remotes))dependencies[packageName(scope, remote.packageSuffix)] = WORKSPACE_PACKAGE_VERSION;
+    }
+    for (const remote of resolveRemoteRefs(app, remotes))dependencies[packageName(scope, remote.packageSuffix)] = WORKSPACE_PACKAGE_VERSION;
+    if (appHasEffectApi(app)) dependencies['@modern-js/plugin-bff'] = modernPackageSpecifier('@modern-js/plugin-bff', packageSource);
+    return dependencies;
+}
+function appDevDependencies(packageSource, enableTailwind) {
+    return {
+        '@modern-js/app-tools': modernPackageSpecifier('@modern-js/app-tools', packageSource),
+        '@effect/tsgo': EFFECT_TSGO_VERSION,
+        ...enableTailwind ? {
+            '@tailwindcss/postcss': `^${TAILWIND_POSTCSS_VERSION}`,
+            postcss: `^${POSTCSS_VERSION}`,
+            tailwindcss: `^${TAILWIND_VERSION}`
+        } : {},
+        "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION,
+        '@types/node': '^20',
+        '@types/react': TYPES_REACT_VERSION,
+        '@types/react-dom': TYPES_REACT_DOM_VERSION,
+        typescript: TYPESCRIPT_VERSION,
+        'zephyr-rspack-plugin': ZEPHYR_RSPACK_PLUGIN_VERSION,
+        wrangler: WRANGLER_VERSION
+    };
+}
+function createRootPackageJson(scope, packageSource, remotes = []) {
+    const shellFilter = `--filter ${packageName(scope, shellApp.packageSuffix)}`;
+    const remoteFilters = remotes.map((remote)=>`--filter ${packageName(scope, remote.packageSuffix)}`);
+    const remoteBuildPrefix = remotes.length > 0 ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ' : '';
+    const remoteCloudflareBuildPrefix = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && ' : '';
+    const remoteCloudflareDeployPrefix = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && ' : '';
+    return {
+        private: true,
+        name: scope,
+        version: '0.1.0',
+        type: 'module',
+        packageManager: `pnpm@${PNPM_VERSION}`,
+        scripts: {
+            dev: `pnpm --parallel ${[
+                shellFilter,
+                ...remoteFilters
+            ].join(' ')} dev`,
+            'dev:shell': `pnpm --filter ${packageName(scope, shellApp.packageSuffix)} dev`,
+            ...Object.fromEntries(remotes.map((remote)=>[
+                    `dev:${remote.packageSuffix}`,
+                    `pnpm --filter ${packageName(scope, remote.packageSuffix)} dev`
+                ])),
+            build: `${remoteBuildPrefix}ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm mf:types && pnpm performance:readiness`,
+            format: "oxfmt . '!repos/**'",
+            'format:check': "oxfmt --check . '!repos/**'",
+            lint: 'oxlint apps verticals packages',
+            'lint:fix': 'oxlint apps verticals packages --fix',
+            typecheck: `pnpm -r --filter "@${scope}/*" typecheck`,
+            'cloudflare:build': `${remoteCloudflareBuildPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types`,
+            'cloudflare:deploy': `${remoteCloudflareDeployPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:deploy`,
+            'cloudflare:proof': "node ./scripts/proof-cloudflare-version.mjs --out .codex/reports/cloudflare-version-proof/public-url-proof.json",
+            'skills:install': "node ./scripts/bootstrap-agent-skills.mjs",
+            'skills:check': "node ./scripts/bootstrap-agent-skills.mjs --check",
+            'agents:refs:install': "node ./scripts/setup-agent-reference-repos.mjs",
+            'agents:refs:check': "node ./scripts/setup-agent-reference-repos.mjs --check",
+            'mf:types': "node ./scripts/assert-mf-types.mjs",
+            'performance:readiness': "node ./scripts/ultramodern-performance-readiness.mjs",
+            'contract:check': "node ./scripts/validate-ultramodern-workspace.mjs",
+            'i18n:boundaries': "node ./scripts/check-ultramodern-i18n-boundaries.mjs",
+            postinstall: "oxfmt . '!repos/**' && node ./scripts/bootstrap-agent-skills.mjs --postinstall",
+            check: 'pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm contract:check && pnpm performance:readiness'
+        },
+        engines: {
+            node: '>=26',
+            pnpm: `>=${PNPM_VERSION} <11.6.0`
+        },
+        workspaces: [
+            'apps/*',
+            'verticals/*',
+            'packages/*'
+        ],
+        modernjs: {
+            preset: 'presetUltramodern',
+            workspace: 'ultramodern-superapp',
+            topology: './topology/reference-topology.json',
+            ownership: './topology/ownership.json',
+            packageSource: {
+                strategy: packageSource.strategy,
+                config: './.modernjs/ultramodern-package-source.json'
+            }
+        },
+        devDependencies: {
+            '@effect/tsgo': EFFECT_TSGO_VERSION,
+            '@modern-js/code-tools': modernPackageSpecifier('@modern-js/code-tools', packageSource),
+            '@modern-js/create': modernPackageSpecifier('@modern-js/create', packageSource),
+            "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION,
+            lefthook: LEFTHOOK_VERSION,
+            oxlint: OXLINT_VERSION,
+            oxfmt: OXFMT_VERSION,
+            ultracite: ULTRACITE_VERSION,
+            wrangler: WRANGLER_VERSION,
+            'zephyr-agent': ZEPHYR_AGENT_VERSION
+        }
+    };
+}
+function createZephyrDependencies(scope, app, remotes = []) {
+    if (!app.verticalRefs?.length) return {};
+    return Object.fromEntries(resolveRemoteRefs(app, remotes).map((remote)=>[
+            remoteDependencyAlias(remote),
+            zephyrRemoteDependency(scope, remote)
+        ]));
+}
+function createTsConfigBase() {
+    return {
+        compilerOptions: {
+            target: 'ESNext',
+            lib: [
+                'ESNext',
+                'DOM',
+                'DOM.Iterable'
+            ],
+            module: 'preserve',
+            moduleResolution: 'Bundler',
+            moduleDetection: 'force',
+            jsx: 'preserve',
+            isolatedModules: true,
+            verbatimModuleSyntax: true,
+            strict: true,
+            noEmit: true,
+            allowImportingTsExtensions: true,
+            allowJs: true,
+            esModuleInterop: true,
+            noUncheckedIndexedAccess: true,
+            exactOptionalPropertyTypes: true,
+            noImplicitOverride: true,
+            noFallthroughCasesInSwitch: true,
+            noPropertyAccessFromIndexSignature: true,
+            noImplicitReturns: true,
+            skipLibCheck: true,
+            resolveJsonModule: true,
+            plugins: [
+                {
+                    name: '@effect/language-service',
+                    diagnostics: true,
+                    includeSuggestionsInTsc: true,
+                    ignoreEffectSuggestionsInTscExitCode: false,
+                    ignoreEffectWarningsInTscExitCode: false,
+                    ignoreEffectErrorsInTscExitCode: false,
+                    skipDisabledOptimization: true,
+                    diagnosticSeverity: Object.fromEntries(effectDiagnostics.map((name)=>[
+                            name,
+                            'error'
+                        ]))
+                }
+            ]
+        }
+    };
+}
+function createPackageTsConfig(packageDir, includeApi = false) {
+    const include = [
+        'src',
+        'modern.config.ts',
+        'module-federation.config.ts'
+    ];
+    if (includeApi) include.push('api', 'shared');
+    return {
+        extends: `${relativeRootFor(packageDir)}/tsconfig.base.json`,
+        include
+    };
+}
+function createAppPackage(scope, app, packageSource, enableTailwind, remotes = []) {
+    const publicSurfaceBuildCommand = createPublicSurfaceGenerationCommand(app, 'dist');
+    const publicSurfaceCloudflareBuildCommand = createPublicSurfaceGenerationCommand(app, 'dist');
+    const publicSurfaceCloudflareOutputCommand = createPublicSurfaceGenerationCommand(app, 'cloudflare');
+    const packageExports = Object.fromEntries(Object.entries(app.exposes ?? {}).map(([expose, source])=>[
+            expose,
+            source
+        ]));
+    const packageJson = {
+        private: true,
+        name: packageName(scope, app.packageSuffix),
+        version: '0.1.0',
+        scripts: {
+            dev: 'modern dev',
+            build: app.exposes ? `ULTRAMODERN_ZEPHYR=false modern build && ${publicSurfaceBuildCommand} && node ${relativeRootFor(app.directory)}/scripts/assert-mf-types.mjs` : `ULTRAMODERN_ZEPHYR=false modern build && ${publicSurfaceBuildCommand}`,
+            'cloudflare:build': `ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern build && ${publicSurfaceCloudflareBuildCommand} && ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy && ${publicSurfaceCloudflareOutputCommand}`,
+            'cloudflare:deploy': 'ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS=true pnpm run cloudflare:build && wrangler deploy --config .output/wrangler.json',
+            'cloudflare:preview': 'pnpm run cloudflare:build && wrangler dev --config .output/wrangler.json',
+            'cloudflare:proof': `node ${relativeRootFor(app.directory)}/scripts/proof-cloudflare-version.mjs --app ${app.id}`,
+            serve: 'modern serve',
+            typecheck: effectTsgoTypecheckCommand
+        },
+        modernjs: {
+            preset: 'presetUltramodern',
+            role: 'shell' === app.kind ? 'shell' : 'module-federation-remote',
+            appId: app.id,
+            topology: `${relativeRootFor(app.directory)}/topology/reference-topology.json`,
+            ...appHasEffectApi(app) ? {
+                apiRuntime: 'effect-bff'
+            } : {}
+        },
+        'zephyr:dependencies': createZephyrDependencies(scope, app, remotes),
+        dependencies: appDependencies(scope, packageSource, app, remotes),
+        devDependencies: appDevDependencies(packageSource, enableTailwind)
+    };
+    if (appHasEffectApi(app)) Object.assign(packageExports, {
+        './effect/client': `./src/effect/${app.effectApi.stem}-client.ts`,
+        './shared/effect/api': './shared/effect/api.ts'
+    });
+    else if ('shell' === app.kind) Object.assign(packageExports, {
+        './effect/clients': './src/effect/vertical-clients.ts'
+    });
+    if (Object.keys(packageExports).length > 0) packageJson.exports = packageExports;
+    return packageJson;
+}
+function createSharedPackage(scope, id, description) {
+    const packageJson = {
+        private: true,
+        name: packageName(scope, id),
+        version: '0.1.0',
+        description,
+        type: 'module',
+        exports: {
+            '.': './src/index.ts'
+        },
+        scripts: {
+            typecheck: effectTsgoTypecheckCommand
+        },
+        devDependencies: {
+            '@effect/tsgo': EFFECT_TSGO_VERSION,
+            "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION
+        }
+    };
+    if ('shared-design-tokens' === id) packageJson.exports = {
+        ...packageJson.exports,
+        './tokens.css': './src/tokens.css'
+    };
+    return packageJson;
+}
+function createSharedContractsIndex() {
+    return readFileTemplate('packages/shared-contracts-index.ts');
+}
+export { appDependencies, appDevDependencies, createAppPackage, createPackageTsConfig, createRootPackageJson, createSharedContractsIndex, createSharedPackage, createTsConfigBase, createZephyrDependencies, effectDiagnostics, effectTsgoTypecheckCommand };

package/dist/esm/ultramodern-workspace/package-source.js

@@ -0,0 +1,21 @@
+import { BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, WORKSPACE_PACKAGE_VERSION } from "../ultramodern-package-source.js";
+function resolvePackageSource(options) {
+    const strategy = options.packageSource?.strategy ?? 'install';
+    if ('workspace' === strategy) return {
+        strategy,
+        modernPackageVersion: WORKSPACE_PACKAGE_VERSION,
+        registry: options.packageSource?.registry,
+        aliasScope: options.packageSource?.aliasScope,
+        aliasPackageNamePrefix: options.packageSource?.aliasPackageNamePrefix
+    };
+    const registry = options.packageSource?.registry;
+    const aliasScope = options.packageSource?.aliasScope ?? (registry ? void 0 : BLEEDINGDEV_PACKAGE_SCOPE);
+    return {
+        strategy,
+        modernPackageVersion: options.packageSource?.modernPackageVersion ?? options.modernVersion,
+        registry,
+        aliasScope,
+        aliasPackageNamePrefix: options.packageSource?.aliasPackageNamePrefix ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0)
+    };
+}
+export { resolvePackageSource };

package/dist/esm/ultramodern-workspace/policy.js

@@ -0,0 +1,183 @@
+import { appHasEffectApi, appI18nNamespace, createCloudflarePublicUrlEnv, createCloudflareWorkerName, effectApiPrefix, effectApiStem } from "./descriptors.js";
+import { createLocalisedUrlsMap } from "./routes.js";
+import { isRecord } from "./types.js";
+import { CLOUDFLARE_COMPATIBILITY_DATE } from "./versions.js";
+function createCloudflareProofRoute(app) {
+    if ('shell' === app.kind) return {
+        ssr: '/en',
+        mfManifest: '/mf-manifest.json',
+        locale: `/locales/en/${appI18nNamespace(app)}.json`
+    };
+    const languageRoutes = createLocalisedUrlsMap(app);
+    const firstCanonicalPath = Object.keys(languageRoutes)[0];
+    const localizedPath = firstCanonicalPath && isRecord(languageRoutes[firstCanonicalPath]) ? languageRoutes[firstCanonicalPath].en : void 0;
+    return {
+        ssr: localizedPath ?? '/en',
+        mfManifest: '/mf-manifest.json',
+        locale: `/locales/en/${appI18nNamespace(app)}.json`,
+        ...appHasEffectApi(app) ? {
+            effectReadiness: `${effectApiPrefix(app)}/effect/${effectApiStem(app)}/readiness`
+        } : {}
+    };
+}
+function createCloudflareSecurityContract() {
+    return {
+        enabled: true,
+        headers: {
+            referrerPolicy: 'strict-origin-when-cross-origin',
+            contentTypeOptions: 'nosniff',
+            permissionsPolicy: 'camera=(), geolocation=(), microphone=(), payment=(), usb=()'
+        },
+        contentSecurityPolicy: {
+            mode: 'report-only',
+            directives: {
+                'base-uri': [
+                    "'self'"
+                ],
+                'connect-src': [
+                    "'self'",
+                    'https:',
+                    'http:',
+                    'wss:',
+                    'ws:'
+                ],
+                'default-src': [
+                    "'self'"
+                ],
+                'font-src': [
+                    "'self'",
+                    'data:',
+                    'https:',
+                    'http:'
+                ],
+                'form-action': [
+                    "'self'"
+                ],
+                'frame-ancestors': [
+                    "'self'"
+                ],
+                'img-src': [
+                    "'self'",
+                    'data:',
+                    'blob:',
+                    'https:',
+                    'http:'
+                ],
+                'manifest-src': [
+                    "'self'",
+                    'https:',
+                    'http:'
+                ],
+                'object-src': [
+                    "'none'"
+                ],
+                "script-src": [
+                    "'self'",
+                    "'unsafe-inline'",
+                    "'unsafe-eval'",
+                    'https:',
+                    'http:',
+                    'blob:'
+                ],
+                'style-src': [
+                    "'self'",
+                    "'unsafe-inline'",
+                    'https:',
+                    'http:'
+                ],
+                'worker-src': [
+                    "'self'",
+                    'blob:'
+                ]
+            },
+            reason: "Report-only by default so Cloudflare Module Federation SSR can prove remote script, style, and connect compatibility before enforcement."
+        },
+        noindex: {
+            workersDev: true,
+            localhost: true,
+            previewHostnames: []
+        }
+    };
+}
+const PUBLIC_WEBSITE_POLICY = {
+    qualityGates: {
+        publicRoutes: {
+            requireSitemapWhenPresent: true,
+            requireRobotsSitemapConsistency: true,
+            requireWebManifestWhenPresent: true
+        },
+        statusCodes: {
+            notFoundRoute: '/__ultramodern-smoke-missing',
+            unknownRouteStatus: 404
+        },
+        indexing: {
+            previewNoindex: true,
+            productionPublicRoutesIndexable: true
+        },
+        assets: {
+            cssPreloadRequired: true,
+            cssResponseRequired: true,
+            cacheControlRequiredForCss: true,
+            sourcemapsPubliclyReferenced: false
+        },
+        budgets: {
+            ssrHtmlMaxBytes: 250000,
+            mfManifestMaxBytes: 500000,
+            localeJsonMaxBytes: 100000,
+            sitemapXmlMaxBytes: 500000,
+            cssAssetMaxBytes: 750000
+        },
+        csp: {
+            finalMode: 'report-only-dogfood',
+            decision: "Report-only remains the generated final mode until public smoke proof records MF SSR script/style/connect compatibility for the deployed surface."
+        }
+    },
+    publicHead: {
+        indexableRobots: 'index, follow',
+        privateRouteRobots: 'noindex, nofollow'
+    },
+    publicSurface: {
+        defaultProviderFile: 'route.sitemap.mjs',
+        draftPolicy: 'omit-draft-by-default',
+        indexablePolicy: 'omit-indexable-false'
+    }
+};
+function formatTsJsonValue(value, indent) {
+    return JSON.stringify(value, null, 2).replaceAll('\n', `\n${' '.repeat(indent)}`);
+}
+function formatIntegerCodeLiteral(value) {
+    return String(value).replace(/\B(?=(\d{3})+(?!\d))/gu, '_');
+}
+function createPublicWebsiteQualityGateContract() {
+    return PUBLIC_WEBSITE_POLICY.qualityGates;
+}
+function createPublicWebsiteBudgetFallback(budgetName) {
+    return formatIntegerCodeLiteral(PUBLIC_WEBSITE_POLICY.qualityGates.budgets[budgetName]);
+}
+function createPublicHeadRobotsPolicy() {
+    return PUBLIC_WEBSITE_POLICY.publicHead;
+}
+function createPublicSurfaceContentExpansionPolicy() {
+    return PUBLIC_WEBSITE_POLICY.publicSurface;
+}
+function createCloudflareDeployContract(scope, app) {
+    return {
+        target: 'cloudflare',
+        workerName: createCloudflareWorkerName(scope, app),
+        publicUrlEnv: createCloudflarePublicUrlEnv(app),
+        compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE,
+        compatibilityFlags: [
+            'nodejs_compat',
+            'global_fetch_strictly_public'
+        ],
+        assetsBinding: 'ASSETS',
+        routes: createCloudflareProofRoute(app),
+        security: createCloudflareSecurityContract(),
+        qualityGates: createPublicWebsiteQualityGateContract(),
+        evidence: {
+            proofScript: "scripts/proof-cloudflare-version.mjs",
+            reportDefault: '.codex/reports/cloudflare-version-proof/public-url-proof.json'
+        }
+    };
+}
+export { PUBLIC_WEBSITE_POLICY, createCloudflareDeployContract, createCloudflareProofRoute, createCloudflareSecurityContract, createPublicHeadRobotsPolicy, createPublicSurfaceContentExpansionPolicy, createPublicWebsiteBudgetFallback, createPublicWebsiteQualityGateContract, formatIntegerCodeLiteral, formatTsJsonValue };