@bleedingdev/modern-js-create 3.5.0-ultramodern.3 → 3.5.0-ultramodern.30

package/dist/cjs/ultramodern-workspace/pnpm-workspace-policy-plan.cjs

@@ -0,0 +1,166 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createPnpmWorkspacePolicyPlan: ()=>createPnpmWorkspacePolicyPlan,
+    drizzleOrmDeclarationPatchPath: ()=>drizzleOrmDeclarationPatchPath,
+    effectDeclarationPatchPath: ()=>effectDeclarationPatchPath,
+    moduleFederationBridgeReactPatchPath: ()=>moduleFederationBridgeReactPatchPath,
+    moduleFederationModernJsPatchPath: ()=>moduleFederationModernJsPatchPath,
+    strictEffectPackageVersionPolicyExclusions: ()=>strictEffectPackageVersionPolicyExclusions
+});
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+const strictEffectPackageVersionPolicyExclusions = [
+    `effect@${external_versions_cjs_namespaceObject.EFFECT_VERSION}`,
+    `@effect/opentelemetry@${external_versions_cjs_namespaceObject.EFFECT_VERSION}`
+];
+const moduleFederationModernJsPatchPath = `patches/@module-federation__modern-js-v3@${external_versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION}.patch`;
+const moduleFederationBridgeReactPatchPath = `patches/@module-federation__bridge-react@${external_versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION}.patch`;
+const effectDeclarationPatchPath = 'patches/effect-schema-error-type-id.patch';
+const drizzleOrmDeclarationPatchPath = 'patches/drizzle-orm-ts7-strict-declarations.patch';
+function createPnpmWorkspacePolicyPlan(options) {
+    return {
+        yamlActions: [
+            {
+                kind: 'replace-line',
+                pattern: /^ {4}'@effect\/vitest>effect': .+$/mu,
+                replacement: `    '@effect/vitest>effect': '${external_versions_cjs_namespaceObject.EFFECT_VERSION}'`
+            },
+            {
+                kind: 'ensure-scalar-map-entry',
+                key: 'overrides',
+                entryKey: "'@effect/opentelemetry'",
+                value: external_versions_cjs_namespaceObject.EFFECT_VERSION
+            },
+            {
+                kind: 'ensure-scalar-map-entry',
+                key: 'overrides',
+                entryKey: "'@effect/vitest'",
+                value: external_versions_cjs_namespaceObject.EFFECT_VITEST_VERSION
+            },
+            {
+                kind: 'ensure-scalar-map-entry',
+                key: 'overrides',
+                entryKey: 'effect',
+                value: external_versions_cjs_namespaceObject.EFFECT_VERSION
+            },
+            {
+                kind: 'ensure-scalar-map-entry',
+                key: 'allowBuilds',
+                entryKey: "'@parcel/watcher'",
+                value: 'true'
+            },
+            ...strictEffectPackageVersionPolicyExclusions.flatMap((item)=>createStrictEffectPackageVersionPolicyActions(item)),
+            {
+                kind: 'ensure-map-entry',
+                key: 'patchedDependencies',
+                entryKey: `effect@${external_versions_cjs_namespaceObject.EFFECT_VERSION}`,
+                value: effectDeclarationPatchPath
+            },
+            {
+                kind: 'ensure-map-entry',
+                key: 'patchedDependencies',
+                entryKey: `@module-federation/modern-js-v3@${external_versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION}`,
+                value: moduleFederationModernJsPatchPath
+            },
+            {
+                kind: 'ensure-map-entry',
+                key: 'patchedDependencies',
+                entryKey: `@module-federation/bridge-react@${external_versions_cjs_namespaceObject.MODULE_FEDERATION_VERSION}`,
+                value: moduleFederationBridgeReactPatchPath
+            },
+            options.usesDrizzleOrm ? {
+                kind: 'ensure-map-entry',
+                key: 'patchedDependencies',
+                entryKey: `drizzle-orm@${external_versions_cjs_namespaceObject.DRIZZLE_ORM_VERSION}`,
+                value: drizzleOrmDeclarationPatchPath
+            } : {
+                kind: 'remove-map-entry',
+                entryKey: `drizzle-orm@${external_versions_cjs_namespaceObject.DRIZZLE_ORM_VERSION}`
+            }
+        ],
+        declarationPatchActions: [
+            {
+                kind: 'ensure',
+                relativePatchPath: moduleFederationModernJsPatchPath
+            },
+            {
+                kind: 'ensure',
+                relativePatchPath: moduleFederationBridgeReactPatchPath
+            },
+            {
+                kind: 'ensure',
+                relativePatchPath: effectDeclarationPatchPath
+            },
+            {
+                kind: options.usesDrizzleOrm ? 'ensure' : 'remove-if-unchanged',
+                relativePatchPath: drizzleOrmDeclarationPatchPath
+            }
+        ],
+        requiresInstallOnChange: true
+    };
+}
+function createStrictEffectPackageVersionPolicyActions(item) {
+    const packageName = item.slice(0, item.lastIndexOf('@'));
+    const escapedPackageName = packageName.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return [
+        {
+            kind: 'replace-line',
+            pattern: new RegExp(`^ {2}- '${escapedPackageName}@[^']+'$`, 'gmu'),
+            replacement: `  - '${item}'`
+        },
+        {
+            kind: 'ensure-list-item',
+            key: 'minimumReleaseAgeExclude',
+            item
+        },
+        {
+            kind: 'ensure-list-item',
+            key: 'trustPolicyExclude',
+            item
+        }
+    ];
+}
+exports.createPnpmWorkspacePolicyPlan = __webpack_exports__.createPnpmWorkspacePolicyPlan;
+exports.drizzleOrmDeclarationPatchPath = __webpack_exports__.drizzleOrmDeclarationPatchPath;
+exports.effectDeclarationPatchPath = __webpack_exports__.effectDeclarationPatchPath;
+exports.moduleFederationBridgeReactPatchPath = __webpack_exports__.moduleFederationBridgeReactPatchPath;
+exports.moduleFederationModernJsPatchPath = __webpack_exports__.moduleFederationModernJsPatchPath;
+exports.strictEffectPackageVersionPolicyExclusions = __webpack_exports__.strictEffectPackageVersionPolicyExclusions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createPnpmWorkspacePolicyPlan",
+    "drizzleOrmDeclarationPatchPath",
+    "effectDeclarationPatchPath",
+    "moduleFederationBridgeReactPatchPath",
+    "moduleFederationModernJsPatchPath",
+    "strictEffectPackageVersionPolicyExclusions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/tooling-command-catalog.cjs

@@ -0,0 +1,153 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const defineToolingCommand = (command)=>({
+        ...command,
+        wrapperPath: `scripts/${command.wrapperName}.mts`
+    });
+const generatedToolingCommands = [
+    defineToolingCommand({
+        id: 'validate',
+        command: 'validate',
+        wrapperName: 'validate-ultramodern-workspace',
+        contractKey: 'validate',
+        rootScript: 'contract:check'
+    }),
+    defineToolingCommand({
+        id: 'typecheck',
+        command: 'typecheck',
+        wrapperName: 'ultramodern-typecheck',
+        contractKey: 'typecheck',
+        rootScript: 'typecheck',
+        templatePath: "templates/workspace-scripts/ultramodern-typecheck.mjs",
+        cwd: 'invocation'
+    }),
+    defineToolingCommand({
+        id: 'mfTypes',
+        command: 'mf-types',
+        wrapperName: 'assert-mf-types',
+        contractKey: 'mfTypes',
+        rootScript: 'mf:types'
+    }),
+    defineToolingCommand({
+        id: 'publicSurface',
+        command: 'public-surface',
+        wrapperName: 'generate-public-surface-assets',
+        contractKey: 'publicSurface',
+        templatePath: "templates/workspace-scripts/generate-public-surface-assets.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationGenerate',
+        command: 'backend-federation-generate',
+        wrapperName: 'generate-node-backend-federation',
+        contractKey: 'backendFederationGenerate',
+        rootScript: 'node:backend-federation:generate',
+        templatePath: "templates/workspace-scripts/generate-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationProof',
+        command: 'backend-federation-proof',
+        wrapperName: 'proof-node-backend-federation',
+        contractKey: 'backendFederationProof',
+        rootScript: 'node:proof',
+        templatePath: "templates/workspace-scripts/proof-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareProof',
+        command: 'cloudflare-proof',
+        wrapperName: 'proof-cloudflare-version',
+        contractKey: 'cloudflareProof',
+        rootScript: 'cloudflare:proof',
+        templatePath: "templates/workspace-scripts/proof-cloudflare-version.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareOutputVerify',
+        command: 'cloudflare-output-verify',
+        wrapperName: 'verify-cloudflare-output',
+        contractKey: 'cloudflareOutputVerify',
+        rootScript: 'cloudflare-output:verify'
+    }),
+    defineToolingCommand({
+        id: 'performanceReadiness',
+        command: 'performance-readiness',
+        wrapperName: 'ultramodern-performance-readiness',
+        contractKey: 'performanceReadiness',
+        rootScript: 'performance:readiness',
+        templatePath: "templates/workspace-scripts/ultramodern-performance-readiness.mjs"
+    }),
+    defineToolingCommand({
+        id: 'migrateStrictEffect',
+        command: 'migrate-strict-effect',
+        wrapperName: 'migrate-strict-effect',
+        contractKey: 'migrateStrictEffect',
+        rootScript: 'migrate:strict-effect'
+    }),
+    defineToolingCommand({
+        id: 'routesGenerate',
+        command: 'routes-generate',
+        wrapperName: 'generate-tanstack-routes',
+        contractKey: 'routesGenerate'
+    })
+];
+const toolingCommandById = Object.fromEntries(generatedToolingCommands.map((command)=>[
+        command.id,
+        command
+    ]));
+const GENERATED_TOOLING_COMMANDS = toolingCommandById;
+const generatedToolingCommandList = ()=>generatedToolingCommands.map((command)=>command.command);
+const createToolingWrapperContract = ()=>Object.fromEntries(generatedToolingCommands.map((command)=>[
+            command.contractKey,
+            command.wrapperPath
+        ]));
+const createGeneratedToolingWrapperMap = createToolingWrapperContract;
+__webpack_require__.d(__webpack_exports__, {}, {
+    GENERATED_TOOLING_COMMANDS: GENERATED_TOOLING_COMMANDS,
+    createGeneratedToolingWrapperMap: createGeneratedToolingWrapperMap,
+    createToolingWrapperContract: createToolingWrapperContract,
+    generatedToolingCommandList: generatedToolingCommandList,
+    generatedToolingCommands: generatedToolingCommands,
+    toolingCommandById: toolingCommandById
+});
+exports.GENERATED_TOOLING_COMMANDS = __webpack_exports__.GENERATED_TOOLING_COMMANDS;
+exports.createGeneratedToolingWrapperMap = __webpack_exports__.createGeneratedToolingWrapperMap;
+exports.createToolingWrapperContract = __webpack_exports__.createToolingWrapperContract;
+exports.generatedToolingCommandList = __webpack_exports__.generatedToolingCommandList;
+exports.generatedToolingCommands = __webpack_exports__.generatedToolingCommands;
+exports.toolingCommandById = __webpack_exports__.toolingCommandById;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GENERATED_TOOLING_COMMANDS",
+    "createGeneratedToolingWrapperMap",
+    "createToolingWrapperContract",
+    "generatedToolingCommandList",
+    "generatedToolingCommands",
+    "toolingCommandById"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/versions.cjs

@@ -37,9 +37,10 @@ const CLOUDFLARE_COMPATIBILITY_DATE = '2026-06-02';
 const TAILWIND_VERSION = '4.3.1';
 const TAILWIND_POSTCSS_VERSION = '4.3.1';
 const POSTCSS_VERSION = '8.5.15';
-const EFFECT_VERSION = '4.0.0-beta.91';
-const EFFECT_VITEST_VERSION = '4.0.0-beta.91';
+const EFFECT_VERSION = '4.0.0-beta.92';
+const EFFECT_VITEST_VERSION = '4.0.0-beta.92';
 const EFFECT_TSGO_VERSION = '0.14.6';
+const DRIZZLE_ORM_VERSION = '1.0.0-rc.4';
 const TYPESCRIPT_STABLE_VERSION = '6.0.3';
 const TYPESCRIPT_NATIVE_PREVIEW_VERSION = '7.0.0-dev.20260628.1';
 const TYPESCRIPT_VERSION = TYPESCRIPT_STABLE_VERSION;
@@ -51,7 +52,7 @@ const I18NEXT_VERSION = '26.3.1';
 const NODE_FETCH_VERSION = '^3.3.2';
 const REACT_VERSION = '^19.2.7';
 const REACT_DOM_VERSION = '^19.2.7';
-const REACT_ROUTER_VERSION = '7.18.0';
+const REACT_ROUTER_VERSION = '7.18.1';
 const TYPES_REACT_VERSION = '^19.2.17';
 const TYPES_REACT_DOM_VERSION = '^19.2.3';
 const NODE_VERSION = '26.3.0';
@@ -64,11 +65,13 @@ const ultramodernWorkspaceVersions = {
     moduleFederation: MODULE_FEDERATION_VERSION,
     effect: EFFECT_VERSION,
     effectVitest: EFFECT_VITEST_VERSION,
+    drizzleOrm: DRIZZLE_ORM_VERSION,
     tailwind: TAILWIND_VERSION,
     tailwindPostcss: TAILWIND_POSTCSS_VERSION
 };
 __webpack_require__.d(__webpack_exports__, {}, {
     CLOUDFLARE_COMPATIBILITY_DATE: CLOUDFLARE_COMPATIBILITY_DATE,
+    DRIZZLE_ORM_VERSION: DRIZZLE_ORM_VERSION,
     EFFECT_TSGO_VERSION: EFFECT_TSGO_VERSION,
     EFFECT_VERSION: EFFECT_VERSION,
     EFFECT_VITEST_VERSION: EFFECT_VITEST_VERSION,
@@ -102,6 +105,7 @@ __webpack_require__.d(__webpack_exports__, {}, {
     ultramodernWorkspaceVersions: ultramodernWorkspaceVersions
 });
 exports.CLOUDFLARE_COMPATIBILITY_DATE = __webpack_exports__.CLOUDFLARE_COMPATIBILITY_DATE;
+exports.DRIZZLE_ORM_VERSION = __webpack_exports__.DRIZZLE_ORM_VERSION;
 exports.EFFECT_TSGO_VERSION = __webpack_exports__.EFFECT_TSGO_VERSION;
 exports.EFFECT_VERSION = __webpack_exports__.EFFECT_VERSION;
 exports.EFFECT_VITEST_VERSION = __webpack_exports__.EFFECT_VITEST_VERSION;
@@ -135,6 +139,7 @@ exports.ZEPHYR_RSPACK_PLUGIN_VERSION = __webpack_exports__.ZEPHYR_RSPACK_PLUGIN_
 exports.ultramodernWorkspaceVersions = __webpack_exports__.ultramodernWorkspaceVersions;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CLOUDFLARE_COMPATIBILITY_DATE",
+    "DRIZZLE_ORM_VERSION",
     "EFFECT_TSGO_VERSION",
     "EFFECT_VERSION",
     "EFFECT_VITEST_VERSION",

package/dist/cjs/ultramodern-workspace/workspace-script-plan.cjs

@@ -0,0 +1,175 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createStrictTsgoTypecheckCommand: ()=>createStrictTsgoTypecheckCommand,
+    createWorkspaceAppPackageScripts: ()=>createWorkspaceAppPackageScripts,
+    createWorkspaceAppScriptPlan: ()=>createWorkspaceAppScriptPlan,
+    createWorkspaceRootPackageScripts: ()=>createWorkspaceRootPackageScripts,
+    createWorkspaceRootScriptPlan: ()=>createWorkspaceRootScriptPlan,
+    packageToolingWrapperCommand: ()=>packageToolingWrapperCommand,
+    rootToolingScriptName: ()=>rootToolingScriptName,
+    rootToolingWrapperCommand: ()=>rootToolingWrapperCommand,
+    workspaceAppPackageScriptNames: ()=>workspaceAppPackageScriptNames,
+    workspaceRootPackageScriptNames: ()=>workspaceRootPackageScriptNames
+});
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const external_public_surface_cjs_namespaceObject = require("./public-surface.cjs");
+const external_tooling_command_catalog_cjs_namespaceObject = require("./tooling-command-catalog.cjs");
+const toolingWrapperPath = (key)=>external_tooling_command_catalog_cjs_namespaceObject.GENERATED_TOOLING_COMMANDS[key].wrapperPath;
+const rootToolingScriptName = (key)=>{
+    const rootScript = external_tooling_command_catalog_cjs_namespaceObject.GENERATED_TOOLING_COMMANDS[key].rootScript;
+    if (!rootScript) throw new Error(`Generated tooling command ${key} does not define a root package script.`);
+    return rootScript;
+};
+const rootToolingWrapperCommand = (key)=>`node ./${toolingWrapperPath(key)}`;
+const relativeToolingWrapperPath = (packageDir, key)=>`${(0, external_naming_cjs_namespaceObject.relativeRootFor)(packageDir)}/${toolingWrapperPath(key)}`;
+const packageToolingWrapperCommand = (packageDir, key)=>`node ${relativeToolingWrapperPath(packageDir, key)}`;
+const workspaceRootPackageScriptNames = {
+    build: 'build',
+    cloudflareBuild: 'cloudflare:build',
+    cloudflareDeploy: 'cloudflare:deploy',
+    cloudflareProof: rootToolingScriptName('cloudflareProof'),
+    cloudflareOutputVerify: rootToolingScriptName('cloudflareOutputVerify'),
+    backendFederationGenerate: rootToolingScriptName('backendFederationGenerate'),
+    nodeProof: rootToolingScriptName('backendFederationProof'),
+    mfTypes: rootToolingScriptName('mfTypes'),
+    performanceReadiness: rootToolingScriptName('performanceReadiness'),
+    migrateStrictEffect: rootToolingScriptName('migrateStrictEffect'),
+    zeropsMaterialize: 'zerops:materialize',
+    contractCheck: rootToolingScriptName('validate'),
+    typecheck: 'typecheck',
+    check: 'check'
+};
+const workspaceAppPackageScriptNames = {
+    dev: 'dev',
+    build: 'build',
+    cloudflareBuild: 'cloudflare:build',
+    cloudflareDeploy: 'cloudflare:deploy',
+    cloudflarePreview: 'cloudflare:preview',
+    cloudflareProof: 'cloudflare:proof',
+    serve: 'serve',
+    typecheck: 'typecheck'
+};
+const createStrictTsgoTypecheckCommand = (packageDir)=>`${packageToolingWrapperCommand(packageDir, 'typecheck')} --project tsconfig.json`;
+function createWorkspaceAppScriptPlan(app) {
+    const backendFederationBuildCommand = (0, external_descriptors_cjs_namespaceObject.appHasApi)(app) ? `${packageToolingWrapperCommand(app.directory, 'backendFederationGenerate')} --app ${app.id}` : void 0;
+    const backendFederationCloudflareBuildCommand = backendFederationBuildCommand ? `${backendFederationBuildCommand} --target dist-cloudflare` : void 0;
+    const buildSteps = [
+        'ULTRAMODERN_ZEPHYR=false modern build',
+        backendFederationBuildCommand,
+        (0, external_public_surface_cjs_namespaceObject.createPublicSurfaceGenerationCommand)(app, 'dist'),
+        app.exposes ? packageToolingWrapperCommand(app.directory, 'mfTypes') : void 0
+    ].filter((step)=>Boolean(step));
+    const cloudflareBuildSteps = [
+        'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern build',
+        backendFederationCloudflareBuildCommand,
+        'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy --skip-build',
+        (0, external_public_surface_cjs_namespaceObject.createPublicSurfaceGenerationCommand)(app, 'cloudflare'),
+        `${packageToolingWrapperCommand(app.directory, 'cloudflareOutputVerify')} --app ${app.id}`
+    ].filter((step)=>Boolean(step));
+    return {
+        dev: 'modern dev',
+        build: buildSteps.join(' && '),
+        cloudflareBuild: cloudflareBuildSteps.join(' && '),
+        cloudflareDeploy: 'ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS=true pnpm run cloudflare:build && wrangler deploy --config .output/wrangler.json',
+        cloudflarePreview: 'pnpm run cloudflare:build && wrangler dev --config .output/wrangler.json',
+        cloudflareProof: `${packageToolingWrapperCommand(app.directory, 'cloudflareProof')} --app ${app.id}`,
+        serve: 'modern serve',
+        typecheck: createStrictTsgoTypecheckCommand(app.directory)
+    };
+}
+function createWorkspaceAppPackageScripts(app) {
+    const plan = createWorkspaceAppScriptPlan(app);
+    return Object.fromEntries(Object.entries(workspaceAppPackageScriptNames).map(([planKey, packageScriptName])=>[
+            packageScriptName,
+            plan[planKey]
+        ]));
+}
+function createWorkspaceRootScriptPlan(remotes = [], options = {}) {
+    const hasRemotes = remotes.length > 0;
+    const mfTypesScript = rootToolingScriptName('mfTypes');
+    const performanceReadinessScript = rootToolingScriptName('performanceReadiness');
+    const cloudflareOutputVerifyScript = rootToolingScriptName('cloudflareOutputVerify');
+    const backendFederationGenerateScript = rootToolingScriptName('backendFederationGenerate');
+    const nodeProofScript = rootToolingScriptName('backendFederationProof');
+    const bridgeCheck = options.bridgeCheck ?? '';
+    const remoteBuildPrefix = hasRemotes ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ' : '';
+    const remoteCloudflareBuildPrefix = hasRemotes ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && ' : '';
+    const remoteCloudflareDeployPrefix = hasRemotes ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && ' : '';
+    return {
+        build: `${remoteBuildPrefix}ULTRAMODERN_ZEPHYR=false pnpm --filter "./apps/shell-super-app" run build && pnpm ${mfTypesScript} && pnpm ${performanceReadinessScript}`,
+        cloudflareBuild: `${remoteCloudflareBuildPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm ${mfTypesScript} && pnpm ${cloudflareOutputVerifyScript}`,
+        cloudflareDeploy: `${remoteCloudflareDeployPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:deploy`,
+        cloudflareProof: `${rootToolingWrapperCommand('cloudflareProof')} --out .codex/reports/cloudflare-version-proof/public-url-proof.json`,
+        cloudflareOutputVerify: rootToolingWrapperCommand('cloudflareOutputVerify'),
+        backendFederationGenerate: rootToolingWrapperCommand('backendFederationGenerate'),
+        nodeProof: rootToolingWrapperCommand('backendFederationProof'),
+        mfTypes: rootToolingWrapperCommand('mfTypes'),
+        performanceReadiness: rootToolingWrapperCommand('performanceReadiness'),
+        migrateStrictEffect: rootToolingWrapperCommand('migrateStrictEffect'),
+        zeropsMaterialize: "node ./scripts/materialize-zerops-runtime.mjs",
+        contractCheck: rootToolingWrapperCommand('validate'),
+        typecheck: options.typecheck ?? `${rootToolingWrapperCommand('typecheck')} --project tsconfig.json`,
+        check: `pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm api:check && pnpm contract:check${hasRemotes ? ` && pnpm ${backendFederationGenerateScript} && pnpm ${nodeProofScript}` : ''} && pnpm performance:readiness${bridgeCheck}`
+    };
+}
+function createWorkspaceRootPackageScripts(remotes = [], options = {}) {
+    const plan = createWorkspaceRootScriptPlan(remotes, options);
+    return Object.fromEntries(Object.entries(workspaceRootPackageScriptNames).map(([planKey, packageScriptName])=>[
+            packageScriptName,
+            plan[planKey]
+        ]));
+}
+exports.createStrictTsgoTypecheckCommand = __webpack_exports__.createStrictTsgoTypecheckCommand;
+exports.createWorkspaceAppPackageScripts = __webpack_exports__.createWorkspaceAppPackageScripts;
+exports.createWorkspaceAppScriptPlan = __webpack_exports__.createWorkspaceAppScriptPlan;
+exports.createWorkspaceRootPackageScripts = __webpack_exports__.createWorkspaceRootPackageScripts;
+exports.createWorkspaceRootScriptPlan = __webpack_exports__.createWorkspaceRootScriptPlan;
+exports.packageToolingWrapperCommand = __webpack_exports__.packageToolingWrapperCommand;
+exports.rootToolingScriptName = __webpack_exports__.rootToolingScriptName;
+exports.rootToolingWrapperCommand = __webpack_exports__.rootToolingWrapperCommand;
+exports.workspaceAppPackageScriptNames = __webpack_exports__.workspaceAppPackageScriptNames;
+exports.workspaceRootPackageScriptNames = __webpack_exports__.workspaceRootPackageScriptNames;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createStrictTsgoTypecheckCommand",
+    "createWorkspaceAppPackageScripts",
+    "createWorkspaceAppScriptPlan",
+    "createWorkspaceRootPackageScripts",
+    "createWorkspaceRootScriptPlan",
+    "packageToolingWrapperCommand",
+    "rootToolingScriptName",
+    "rootToolingWrapperCommand",
+    "workspaceAppPackageScriptNames",
+    "workspaceRootPackageScriptNames"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});