@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-modern-configs.cjs

@@ -0,0 +1,187 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    updateGeneratedModernConfigs: ()=>updateGeneratedModernConfigs
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const workspace_state_cjs_namespaceObject = require("../../../ultramodern-workspace/add-vertical/workspace-state.cjs");
+const demo_components_cjs_namespaceObject = require("../../../ultramodern-workspace/demo-components.cjs");
+const descriptors_cjs_namespaceObject = require("../../../ultramodern-workspace/descriptors.cjs");
+const fs_io_cjs_namespaceObject = require("../../../ultramodern-workspace/fs-io.cjs");
+const module_federation_cjs_namespaceObject = require("../../../ultramodern-workspace/module-federation.cjs");
+const external_config_cjs_namespaceObject = require("../../config.cjs");
+const external_generated_ui_source_cjs_namespaceObject = require("./generated-ui-source.cjs");
+const external_io_cjs_namespaceObject = require("./io.cjs");
+const external_react_router_retirement_cjs_namespaceObject = require("./react-router-retirement.cjs");
+function isGeneratedShellComposition(source) {
+    return source.includes('const createRemoteComponent =') && source.includes('export const VerticalShowcase =');
+}
+function writeOwnedTypeScriptConfig(io, filePath, generatedSource, recognizedGeneratedSources = []) {
+    if (!external_node_fs_default().existsSync(filePath)) return io.writeGenerated(filePath, generatedSource);
+    const existingSource = external_node_fs_default().readFileSync(filePath, 'utf-8');
+    if (existingSource === generatedSource) return io.writeGenerated(filePath, existingSource);
+    if (recognizedGeneratedSources.includes(existingSource)) return io.writeGenerated(filePath, generatedSource);
+    io.log(`${external_node_path_default().relative(io.workspaceRoot, filePath)} was preserved: its generated ownership cannot be proven.`);
+    return false;
+}
+function removeOwnedTypeScriptConfig(io, filePath, recognizedGeneratedSources) {
+    if (!external_node_fs_default().existsSync(filePath)) return false;
+    if (recognizedGeneratedSources.includes(external_node_fs_default().readFileSync(filePath, 'utf-8'))) return io.remove(filePath);
+    io.log(`${external_node_path_default().relative(io.workspaceRoot, filePath)} was preserved: surface metadata cannot delete a config whose exact generated ownership cannot be proven.`);
+    return false;
+}
+function addLegacyGeneratedModernDefaults(source) {
+    const serverAnchor = "        publicDir: ['./locales', './assets'],\n";
+    const optionsEnd = '    },\n  ),\n);';
+    return source.replace(serverAnchor, `${serverAnchor}        ssr: {
+          mode: 'stream',
+          moduleFederationAppSSR: true,
+        },
+`).replace(optionsEnd, `      enableBffRequestId: true,
+      enableModuleFederationSSR: true,
+      enableTelemetryExporters: true,
+      telemetryFailLoudStartup: false,
+${optionsEnd}`);
+}
+function formatGeneratedModernConfigCandidates(generatedSources) {
+    return (0, fs_io_cjs_namespaceObject.formatGeneratedSourceCandidates)(generatedSources.map((source, index)=>[
+            `candidate-${index}.ts`,
+            source
+        ]));
+}
+const formatGeneratedTypeScriptConfig = (generatedSource)=>formatGeneratedModernConfigCandidates([
+        generatedSource
+    ])[0];
+function isGeneratedModernConfig(source, generatedSources) {
+    return generatedSources.includes(source);
+}
+function addPreviousTailwindOptimizationOverride(source) {
+    return source.replace('pluginTailwindcss()', 'pluginTailwindcss({ optimize: false })');
+}
+function removeTsCheckerBuildOverride(source) {
+    return source.replace(`        tsChecker: {
+          typescript: {
+            build: false,
+          },
+        },
+`, '');
+}
+function updateGeneratedModernConfigs(io, config) {
+    const apps = (0, external_config_cjs_namespaceObject.allWorkspaceAppsFromToolingConfig)(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    const overlayPath = external_node_path_default().join(io.workspaceRoot, 'topology/local-overlays/development.json');
+    const overlay = external_node_fs_default().existsSync(overlayPath) ? (0, external_io_cjs_namespaceObject.readJsonFile)(overlayPath) : {};
+    const overlayPorts = overlay.ports && 'object' == typeof overlay.ports ? overlay.ports : Object.fromEntries(apps.map((app)=>[
+            app.id,
+            app.port
+        ]));
+    const primaryShell = apps.find((app)=>'shell' === app.kind);
+    const configuredPorts = primaryShell ? {
+        ...overlayPorts,
+        [primaryShell.id]: primaryShell.port
+    } : overlayPorts;
+    const additionalShells = (0, external_config_cjs_namespaceObject.additionalShellsFromToolingConfig)(config);
+    const configuredDevPorts = additionalShells.length > 0 ? (0, workspace_state_cjs_namespaceObject.configuredDevelopmentPorts)(configuredPorts, additionalShells).toSorted((left, right)=>left - right) : void 0;
+    for (const app of apps){
+        const modernConfigPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'modern.config.ts');
+        const rawGeneratedModernConfig = (0, module_federation_cjs_namespaceObject.createAppModernConfig)(config.workspace.packageScope, app, remotes, config.features.tailwind, configuredDevPorts);
+        const previousTailwindModernConfig = addPreviousTailwindOptimizationOverride(rawGeneratedModernConfig);
+        const currentGeneratedModernConfigs = [
+            rawGeneratedModernConfig,
+            addLegacyGeneratedModernDefaults(rawGeneratedModernConfig),
+            previousTailwindModernConfig,
+            addLegacyGeneratedModernDefaults(previousTailwindModernConfig)
+        ];
+        const [generatedModernConfig, ...recognizedGeneratedModernConfigs] = formatGeneratedModernConfigCandidates(currentGeneratedModernConfigs.flatMap((source)=>[
+                source,
+                removeTsCheckerBuildOverride(source)
+            ]));
+        if (external_node_fs_default().existsSync(modernConfigPath)) {
+            const existingModernConfig = external_node_fs_default().readFileSync(modernConfigPath, 'utf-8');
+            if (existingModernConfig === generatedModernConfig) io.writeGenerated(modernConfigPath, existingModernConfig);
+            else if (isGeneratedModernConfig(existingModernConfig, [
+                generatedModernConfig,
+                ...recognizedGeneratedModernConfigs
+            ])) io.writeGenerated(modernConfigPath, generatedModernConfig);
+            else io.log(`${external_node_path_default().relative(io.workspaceRoot, modernConfigPath)} was preserved: an existing Modern config is consumer-owned unless its generated ownership can be proven.`);
+        } else io.writeGenerated(modernConfigPath, generatedModernConfig);
+        const moduleFederationConfigPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'module-federation.config.ts');
+        const enableBridgeRouter = (0, external_react_router_retirement_cjs_namespaceObject.appDeclaresReactRouter)(external_node_path_default().join(io.workspaceRoot, app.directory));
+        const createGeneratedModuleFederationConfig = (bridgeRouter)=>formatGeneratedTypeScriptConfig('shell' === app.kind ? (0, module_federation_cjs_namespaceObject.createShellModuleFederationConfig)(config.workspace.packageScope, app, remotes, bridgeRouter) : (0, module_federation_cjs_namespaceObject.createRemoteModuleFederationConfig)(config.workspace.packageScope, app, remotes, bridgeRouter));
+        const generatedModuleFederationConfig = createGeneratedModuleFederationConfig(enableBridgeRouter);
+        const recognizedModuleFederationConfigs = [
+            generatedModuleFederationConfig,
+            createGeneratedModuleFederationConfig(!enableBridgeRouter)
+        ];
+        if ((0, descriptors_cjs_namespaceObject.appEmitsBrowserUi)(app)) writeOwnedTypeScriptConfig(io, moduleFederationConfigPath, generatedModuleFederationConfig, recognizedModuleFederationConfigs);
+        else removeOwnedTypeScriptConfig(io, moduleFederationConfigPath, recognizedModuleFederationConfigs);
+        const backendFederationConfigPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'backend-federation.config.ts');
+        const generatedBackendFederationConfig = formatGeneratedTypeScriptConfig((0, module_federation_cjs_namespaceObject.createBackendModuleFederationConfig)(app));
+        if ((0, descriptors_cjs_namespaceObject.appHasApi)(app)) writeOwnedTypeScriptConfig(io, backendFederationConfigPath, generatedBackendFederationConfig, [
+            generatedBackendFederationConfig
+        ]);
+        else removeOwnedTypeScriptConfig(io, backendFederationConfigPath, [
+            generatedBackendFederationConfig
+        ]);
+        if ('shell' === app.kind) {
+            const shellUiRemotes = (0, descriptors_cjs_namespaceObject.resolveRemoteRefs)(app, remotes).filter(descriptors_cjs_namespaceObject.appEmitsBrowserUi);
+            const componentsPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'src/routes/vertical-components.tsx');
+            const workerComponentsPath = external_node_path_default().join(io.workspaceRoot, app.directory, 'src/routes/vertical-components.worker.tsx');
+            const existingComponents = external_node_fs_default().existsSync(componentsPath) ? external_node_fs_default().readFileSync(componentsPath, 'utf-8') : void 0;
+            if (void 0 === existingComponents || isGeneratedShellComposition(existingComponents)) {
+                io.writeGenerated(componentsPath, (0, demo_components_cjs_namespaceObject.createShellRemoteComponents)(app, shellUiRemotes));
+                io.writeGenerated(workerComponentsPath, (0, demo_components_cjs_namespaceObject.createShellWorkerRemoteComponents)(app, shellUiRemotes));
+            } else if (external_node_fs_default().existsSync(workerComponentsPath) && isGeneratedShellComposition(external_node_fs_default().readFileSync(workerComponentsPath, 'utf-8'))) io.remove(workerComponentsPath);
+        } else for (const expose of (0, descriptors_cjs_namespaceObject.distributedSsrExposes)(app))(0, external_generated_ui_source_cjs_namespaceObject.writeGeneratedUiSourceIfChanged)(io, external_node_path_default().join(io.workspaceRoot, app.directory, `src/routes/[lang]/_mf/fragment/${(0, descriptors_cjs_namespaceObject.distributedSsrFragmentSlug)(expose)}/page.tsx`), (0, demo_components_cjs_namespaceObject.createRemoteExposeFragmentPage)(app, expose));
+        if ((app.verticalRefs?.length ?? 0) > 0) {
+            (0, external_generated_ui_source_cjs_namespaceObject.writeGeneratedUiSourceIfChanged)(io, external_node_path_default().join(io.workspaceRoot, app.directory, 'src/federated-components.tsx'), (0, demo_components_cjs_namespaceObject.createFederatedComponentsRegistry)(config.workspace.packageScope, app, remotes));
+            (0, external_generated_ui_source_cjs_namespaceObject.writeGeneratedUiSourceIfChanged)(io, external_node_path_default().join(io.workspaceRoot, app.directory, 'src/federated-components.worker.tsx'), (0, demo_components_cjs_namespaceObject.createFederatedComponentsRegistry)(config.workspace.packageScope, app, remotes, true));
+        }
+    }
+}
+exports.updateGeneratedModernConfigs = __webpack_exports__.updateGeneratedModernConfigs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "updateGeneratedModernConfigs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-oxfmt.cjs

@@ -0,0 +1,146 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    ensureGeneratedOxfmtIgnorePatterns: ()=>ensureGeneratedOxfmtIgnorePatterns
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+function ensureGeneratedOxfmtIgnorePatterns(io) {
+    const configPath = external_node_path_default().join(io.workspaceRoot, 'oxfmt.config.ts');
+    if (!external_node_fs_default().existsSync(configPath)) return false;
+    const source = external_node_fs_default().readFileSync(configPath, 'utf-8');
+    const legacyPreset = /^([ \t]*)extends:\s*\[\s*ultracite\s*\],?[ \t]*$/mu;
+    const nextPresetSource = legacyPreset.test(source) ? source.replace(legacyPreset, '$1...ultracite,') : source;
+    const requiredPatterns = [
+        '.modernjs',
+        '.output',
+        'repos/**',
+        '**/modern-tanstack/**',
+        '**/routeTree.gen.*'
+    ];
+    const warnUnparseable = ()=>{
+        const message = `Could not update oxfmt.config.ts ignorePatterns automatically; add these entries manually: ${requiredPatterns.join(', ')}.`;
+        if (io.dryRun) io.log(message);
+        else process.stderr.write(`[ultramodern] ${message}\n`);
+    };
+    const writePresetReconciliation = ()=>{
+        if (nextPresetSource !== source) io.write(configPath, nextPresetSource);
+    };
+    const anchor = nextPresetSource.indexOf('ignorePatterns:');
+    if (-1 === anchor) {
+        warnUnparseable();
+        writePresetReconciliation();
+        return false;
+    }
+    const openBracket = nextPresetSource.indexOf('[', anchor);
+    if (-1 === openBracket) {
+        warnUnparseable();
+        writePresetReconciliation();
+        return false;
+    }
+    let depth = 0;
+    let closeBracket = -1;
+    let stringQuote;
+    for(let index = openBracket; index < nextPresetSource.length; index += 1){
+        const char = nextPresetSource[index];
+        if (stringQuote) {
+            if ('\\' === char) index += 1;
+            else if (char === stringQuote) stringQuote = void 0;
+            continue;
+        }
+        if ("'" === char || '"' === char || '`' === char) stringQuote = char;
+        else if ('[' === char) depth += 1;
+        else if (']' === char) {
+            depth -= 1;
+            if (0 === depth) {
+                closeBracket = index;
+                break;
+            }
+        }
+    }
+    if (-1 === closeBracket) {
+        warnUnparseable();
+        writePresetReconciliation();
+        return false;
+    }
+    const body = nextPresetSource.slice(openBracket + 1, closeBracket);
+    if (body.includes('...')) {
+        warnUnparseable();
+        writePresetReconciliation();
+        return false;
+    }
+    const literalPattern = /(['"`])((?:\\.|(?!\1).)*)\1/g;
+    const existing = new Set();
+    for (const match of body.matchAll(literalPattern))existing.add(match[2]);
+    const missing = requiredPatterns.filter((pattern)=>!existing.has(pattern));
+    if (0 === missing.length) {
+        writePresetReconciliation();
+        return true;
+    }
+    const bodyLines = body.split('\n');
+    let indent = '  ';
+    let quote = "'";
+    for(let index = bodyLines.length - 1; index >= 0; index -= 1){
+        const literal = bodyLines[index].match(/^(\s*)(['"`])/u);
+        if (literal) {
+            indent = literal[1];
+            quote = literal[2];
+            break;
+        }
+    }
+    const head = nextPresetSource.slice(0, closeBracket);
+    const rest = nextPresetSource.slice(closeBracket);
+    const tailMatch = head.match(/(\r?\n[ \t]*)$/u);
+    const tail = tailMatch ? tailMatch[1] : '\n';
+    let bodyContent = tailMatch ? head.slice(0, head.length - tail.length) : head;
+    if (!/[[,]\s*$/u.test(bodyContent)) bodyContent = `${bodyContent},`;
+    const insertionLines = missing.map((pattern)=>`${indent}${quote}${pattern}${quote},`).join('\n');
+    const nextSource = `${bodyContent}\n${insertionLines}${tail}${rest}`;
+    io.write(configPath, nextSource);
+    return true;
+}
+exports.ensureGeneratedOxfmtIgnorePatterns = __webpack_exports__.ensureGeneratedOxfmtIgnorePatterns;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ensureGeneratedOxfmtIgnorePatterns"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-oxlint.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    ensureGeneratedOxlintComponentStyle: ()=>ensureGeneratedOxlintComponentStyle
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const functionStyleRule = `    'func-style': [
+      'error',
+      'declaration',
+      {
+        allowArrowFunctions: true,
+      },
+    ],`;
+const componentStyleRule = `    'react/function-component-definition': [
+      'error',
+      {
+        namedComponents: ['function-declaration', 'arrow-function'],
+      },
+    ],`;
+const componentStyleRules = `  rules: {
+${functionStyleRule}
+${componentStyleRule}
+  },`;
+const hasFunctionStyleRule = (source)=>/['"]func-style['"]/u.test(source);
+const hasComponentStyleRule = (source)=>/['"]react\/function-component-definition['"]/u.test(source);
+const rulesAnchor = /^ {2}rules:\s*\{[ \t]*$/mu;
+const legacyComponentStyleRules = `  rules: {
+    'react/function-component-definition': [
+      'error',
+      {
+        namedComponents: ['function-declaration', 'arrow-function'],
+      },
+    ],
+  },`;
+function ensureGeneratedOxlintComponentStyle(io) {
+    const configPath = external_node_path_default().join(io.workspaceRoot, 'oxlint.config.ts');
+    if (!external_node_fs_default().existsSync(configPath)) return false;
+    const source = external_node_fs_default().readFileSync(configPath, 'utf-8');
+    const hasFunctionStyle = hasFunctionStyleRule(source);
+    const hasComponentStyle = hasComponentStyleRule(source);
+    if (hasFunctionStyle && hasComponentStyle) return false;
+    const warnUnparseable = ()=>{
+        const message = 'Could not update oxlint.config.ts component style policy automatically; regenerate the framework-owned config.';
+        if (io.dryRun) io.log(message);
+        else process.stderr.write(`[ultramodern] ${message}\n`);
+    };
+    if (hasComponentStyle && !hasFunctionStyle) {
+        if (!source.includes(legacyComponentStyleRules)) {
+            warnUnparseable();
+            return false;
+        }
+        return io.write(configPath, source.replace(rulesAnchor, (match)=>`${match}\n${functionStyleRule}`));
+    }
+    if (/^[ \t]*rules\s*:/mu.test(source)) {
+        warnUnparseable();
+        return false;
+    }
+    const extendsAnchor = /^ {2}extends:\s*\[\s*core\s*,\s*react\s*\],[ \t]*$/mu;
+    if (!extendsAnchor.test(source)) {
+        warnUnparseable();
+        return false;
+    }
+    return io.write(configPath, source.replace(extendsAnchor, (match)=>`${match}\n${componentStyleRules}`));
+}
+exports.ensureGeneratedOxlintComponentStyle = __webpack_exports__.ensureGeneratedOxlintComponentStyle;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ensureGeneratedOxlintComponentStyle"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-removal.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    removeGeneratedFileIfExists: ()=>removeGeneratedFileIfExists,
+    removeStaleBackendFederationArtifacts: ()=>removeStaleBackendFederationArtifacts
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_config_cjs_namespaceObject = require("../../config.cjs");
+function removeGeneratedFileIfExists(io, relativePath) {
+    return io.remove(external_node_path_default().join(io.workspaceRoot, relativePath));
+}
+function removeStaleBackendFederationArtifacts(io, config) {
+    let changed = false;
+    for (const relativePath of [
+        "scripts/generate-node-backend-federation.mts",
+        "scripts/proof-node-backend-federation.mts",
+        "scripts/verify-cloudflare-output.mts"
+    ])changed = removeGeneratedFileIfExists(io, relativePath) || changed;
+    for (const app of (0, external_config_cjs_namespaceObject.allWorkspaceAppsFromToolingConfig)(config))changed = removeGeneratedFileIfExists(io, external_node_path_default().join(app.directory, 'api/backend-federation.ts')) || changed;
+    return changed;
+}
+exports.removeGeneratedFileIfExists = __webpack_exports__.removeGeneratedFileIfExists;
+exports.removeStaleBackendFederationArtifacts = __webpack_exports__.removeStaleBackendFederationArtifacts;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "removeGeneratedFileIfExists",
+    "removeStaleBackendFederationArtifacts"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});