@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm-node/ultramodern-workspace/workspace-script-plan.js

@@ -1,31 +1,30 @@
 import "node:module";
-import { appHasApi, sharedPackages, shellApp } from "./descriptors.js";
+import { appEmitsBrowserUi, appHasApi, sharedPackages, shellApp } from "./descriptors.js";
 import { relativeRootFor } from "./naming.js";
 import { createPublicSurfaceGenerationCommand } from "./public-surface.js";
 import { GENERATED_TOOLING_COMMANDS } from "./tooling-command-catalog.js";
-const GENERATED_POSTINSTALL_SCRIPT = "node ./scripts/bootstrap-agent-skills.mts --postinstall && oxfmt .";
-const toolingWrapperPath = (key)=>GENERATED_TOOLING_COMMANDS[key].wrapperPath;
+const GENERATED_POSTINSTALL_SCRIPT = 'ultramodern-create ultramodern skills install --postinstall';
+const WORKSPACE_SCRIPT_SEGMENT_PATTERN = /(?:'[^']*'|"(?:\\[^\r\n]|[^"\\`$]|\$(?![(']))*"|\\[^\r\n]|[^"'\\`&|;()<>\r\n^#$]|\$(?![('"]))+/gu;
+const toolingCommand = (key)=>`ultramodern-create ultramodern ${GENERATED_TOOLING_COMMANDS[key].command}`;
 const rootToolingScriptName = (key)=>{
     const rootScript = 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)=>`${relativeRootFor(packageDir)}/${toolingWrapperPath(key)}`;
-const packageToolingWrapperCommand = (packageDir, key)=>`node ${relativeToolingWrapperPath(packageDir, key)}`;
+const rootToolingWrapperCommand = toolingCommand;
+const packageToolingWrapperCommand = (_packageDir, key)=>toolingCommand(key);
 const workspaceRootPackageScriptNames = {
     build: 'build',
     cloudflareBuild: 'cloudflare:build',
     cloudflareDeploy: 'cloudflare:deploy',
     cloudflareProof: rootToolingScriptName('cloudflareProof'),
-    cloudflareSsrProof: 'cloudflare:ssr-proof',
+    cloudflareSsrProof: rootToolingScriptName('cloudflareSsrProof'),
     cloudflareOutputVerify: rootToolingScriptName('cloudflareOutputVerify'),
     backendFederationGenerate: rootToolingScriptName('backendFederationGenerate'),
     nodeProof: rootToolingScriptName('backendFederationProof'),
     mfTypes: rootToolingScriptName('mfTypes'),
     performanceReadiness: rootToolingScriptName('performanceReadiness'),
-    migrateStrictEffect: rootToolingScriptName('migrateStrictEffect'),
-    zeropsMaterialize: 'zerops:materialize',
+    zeropsMaterialize: rootToolingScriptName('zeropsMaterialize'),
     contractCheck: rootToolingScriptName('validate'),
     typecheck: 'typecheck',
     check: 'check'
@@ -49,23 +48,34 @@ const workspaceAppPackageScriptNames = {
     typecheck: 'typecheck'
 };
 const createStrictTsgoTypecheckCommand = (packageDir)=>`${packageToolingWrapperCommand(packageDir, 'typecheck')} --project tsconfig.json`;
+const createRoutesGenerateCommand = (app)=>appEmitsBrowserUi(app) ? `pnpm --dir ${relativeRootFor(app.directory)} exec ${toolingCommand('routesGenerate')} --app ${app.id} --manifest-only` : void 0;
 function createWorkspaceAppScriptPlan(app) {
+    const routesGenerate = createRoutesGenerateCommand(app);
     const buildSteps = [
-        'modern build',
+        routesGenerate,
+        'modern build --deploy-target node',
         createPublicSurfaceGenerationCommand(app, 'dist'),
-        'cross-env MODERNJS_DEPLOY=node modern deploy --skip-build'
-    ].filter((step)=>Boolean(step));
-    const cloudflareBuildSteps = [
-        'cross-env MODERNJS_DEPLOY=cloudflare modern build',
-        createPublicSurfaceGenerationCommand(app, 'cloudflare-dist'),
-        'cross-env MODERNJS_DEPLOY=cloudflare modern deploy --skip-build',
-        `${packageToolingWrapperCommand(app.directory, 'cloudflareOutputVerify')} --app ${app.id}`
+        'modern deploy --skip-build --deploy-target node'
     ].filter((step)=>Boolean(step));
+    const cloudflareOutputVerify = `${packageToolingWrapperCommand(app.directory, 'cloudflareOutputVerify')} --app ${app.id}`;
+    const cloudflareBuildSteps = (requirePublicUrls)=>[
+            routesGenerate,
+            'modern build --deploy-target cloudflare',
+            createPublicSurfaceGenerationCommand(app, 'cloudflare-dist', requirePublicUrls),
+            'modern deploy --skip-build --deploy-target cloudflare',
+            requirePublicUrls ? `${cloudflareOutputVerify} --require-public-urls` : cloudflareOutputVerify
+        ].filter((step)=>Boolean(step));
     return {
-        dev: 'modern dev',
+        dev: [
+            routesGenerate,
+            'modern dev'
+        ].filter((step)=>Boolean(step)).join(' && '),
         build: buildSteps.join(' && '),
-        cloudflareBuild: cloudflareBuildSteps.join(' && '),
-        cloudflareDeploy: 'cross-env ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS=true pnpm run cloudflare:build && wrangler deploy --config .output/wrangler.json',
+        cloudflareBuild: cloudflareBuildSteps(false).join(' && '),
+        cloudflareDeploy: [
+            ...cloudflareBuildSteps(true),
+            'wrangler deploy --config .output/wrangler.json'
+        ].join(' && '),
         cloudflarePreview: 'pnpm run cloudflare:build && wrangler dev --config .output/wrangler.json',
         cloudflareProof: `${packageToolingWrapperCommand(app.directory, 'cloudflareProof')} --app ${app.id}`,
         serve: 'modern serve',
@@ -104,7 +114,6 @@ function createReferencedRemoteDeclarationBuilds(remotes) {
 }
 function createWorkspaceRootScriptPlan(remotes = [], options = {}) {
     const hasRemotes = remotes.length > 0;
-    remotes.some(appHasApi);
     const shells = options.shells && options.shells.length > 0 ? options.shells : [
         shellApp
     ];
@@ -131,17 +140,16 @@ function createWorkspaceRootScriptPlan(remotes = [], options = {}) {
         cloudflareBuild: `${buildPrefix}${remoteCloudflareBuildPrefix}${shellCloudflareBuild} && pnpm ${mfTypesScript} --target cloudflare && pnpm ${cloudflareOutputVerifyScript}${cloudflareSsrProofSuffix}`,
         cloudflareDeploy: `${remoteCloudflareDeployPrefix}${shellCloudflareDeploy}`,
         cloudflareProof: `${rootToolingWrapperCommand('cloudflareProof')} --out .codex/reports/cloudflare-version-proof/public-url-proof.json`,
-        cloudflareSsrProof: "node ./scripts/proof-workerd-ssr.mts",
+        cloudflareSsrProof: rootToolingWrapperCommand('cloudflareSsrProof'),
         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",
+        zeropsMaterialize: rootToolingWrapperCommand('zeropsMaterialize'),
         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 && pnpm performance:readiness${bridgeCheck}`
+        typecheck: options.typecheck ?? `${rootToolingWrapperCommand('typecheck')} --build tsconfig.json`,
+        check: `pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm api:check:files && pnpm contract:check && pnpm performance:readiness${bridgeCheck}`
     };
 }
 function createWorkspaceRootPackageScripts(remotes = [], options = {}) {
@@ -153,4 +161,4 @@ function createWorkspaceRootPackageScripts(remotes = [], options = {}) {
             plan[planKey]
         ]));
 }
-export { GENERATED_POSTINSTALL_SCRIPT, createStrictTsgoTypecheckCommand, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts, createWorkspaceRootScriptPlan };
+export { GENERATED_POSTINSTALL_SCRIPT, WORKSPACE_SCRIPT_SEGMENT_PATTERN, createStrictTsgoTypecheckCommand, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts, createWorkspaceRootScriptPlan };

package/dist/esm-node/ultramodern-workspace/workspace-scripts.js

@@ -1,201 +1,21 @@
 import "node:module";
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { appHasApi } from "./descriptors.js";
-import { readFileTemplate as external_fs_io_js_readFileTemplate, renderFileTemplate, workspaceTemplateDir, writeFileReplacing } from "./fs-io.js";
-import { GENERATED_TOOLING_COMMANDS, generatedToolingCommands } from "./tooling-command-catalog.js";
-import { createWorkspaceValidationContract } from "./workspace-validation-contract.js";
-const singleQuoted = (value)=>`'${value.replace(/'/gu, "\\'")}'`;
-const toolWrapperResultHandling = `
-if (result.error) {
-  const launchTarget = createBin
-    ? process.execPath + ' with ULTRAMODERN_CREATE_BIN=' + createBin
-    : 'ultramodern-create from PATH';
-  console.error(
-    'Failed to launch ' +
-      launchTarget +
-      ' for UltraModern command "' +
-      ultramodernArgs.slice(1).join(' ') +
-      '": ' +
-      result.error.message,
-  );
-  process.exit(1);
-}
-
-process.exit(result.status ?? 1);
-`;
-function createToolWrapperScript(command, extraArgs = []) {
-    const commandLiteral = singleQuoted(command);
-    const extraArgsLiteral = `[${extraArgs.map(singleQuoted).join(', ')}]`;
-    return `#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const createBin = process.env.ULTRAMODERN_CREATE_BIN;
-const forwardedArgs = process.argv.slice(2);
-const workspaceRoot =
-  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
-  path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const ultramodernArgs = ['ultramodern', ${commandLiteral}, ...${extraArgsLiteral}, ...forwardedArgs];
-const result = createBin
-  ? spawnSync(process.execPath, [createBin, ...ultramodernArgs], {
-      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
-      stdio: 'inherit',
-    })
-  : spawnSync('ultramodern-create', ultramodernArgs, {
-      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
-      shell: process.platform === 'win32',
-      stdio: 'inherit',
-    });
-${toolWrapperResultHandling}`;
-}
-function writeGeneratedToolWrapperScript(targetDir, key) {
-    const command = GENERATED_TOOLING_COMMANDS[key];
-    writeWorkspaceOwnedMtsScript(targetDir, command.wrapperName, createToolWrapperScript(command.command));
-}
-function writeGeneratedToolWrapperScripts(targetDir, options = {}) {
-    const backendSurface = options.hasBackendSurface ?? !options.shellOnly;
-    for (const command of generatedToolingCommands)if (!(!backendSurface && BACKEND_FEDERATION_WRAPPER_IDS.has(command.id))) writeGeneratedToolWrapperScript(targetDir, command.id);
-}
-function createSkillsToolWrapperScript() {
-    return `#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const createBin = process.env.ULTRAMODERN_CREATE_BIN;
-const forwardedArgs = process.argv.slice(2);
-const workspaceRoot =
-  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
-  path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const checkOnly = forwardedArgs.includes('--check');
-const skillArgs = checkOnly
-  ? ['skills', 'check', ...forwardedArgs.filter(arg => arg !== '--check')]
-  : ['skills', 'install', ...forwardedArgs];
-const ultramodernArgs = ['ultramodern', ...skillArgs];
-const result = createBin
-  ? spawnSync(process.execPath, [createBin, ...ultramodernArgs], {
-      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
-      stdio: 'inherit',
-    })
-  : spawnSync('ultramodern-create', ultramodernArgs, {
-      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
-      shell: process.platform === 'win32',
-      stdio: 'inherit',
-    });
-${toolWrapperResultHandling}`;
-}
-function removeLegacyWorkspaceScript(targetDir, relativePath) {
-    node_fs.rmSync(node_path.join(targetDir, relativePath), {
-        force: true
-    });
-}
-function writeWorkspaceOwnedMtsScript(targetDir, name, content) {
-    writeFileReplacing(targetDir, `scripts/${name}.mts`, content);
-    removeLegacyWorkspaceScript(targetDir, `scripts/${name}.mjs`);
-}
-function migrateCopiedWorkspaceScriptToMts(targetDir, name) {
-    const legacyPath = node_path.join(targetDir, `scripts/${name}.mjs`);
-    const migratedPath = node_path.join(targetDir, `scripts/${name}.mts`);
-    if (!node_fs.existsSync(legacyPath)) return;
-    if (node_fs.existsSync(migratedPath)) return void node_fs.rmSync(legacyPath, {
-        force: true
-    });
-    node_fs.renameSync(legacyPath, migratedPath);
-}
-function createWorkspaceValidationScript(scope, enableTailwind, remotes = [], releaseCohort, additionalShells = [], primaryShell, compactConfigOverride, ownershipOverride, developmentOverlayOverride) {
-    const contract = createWorkspaceValidationContract(scope, enableTailwind, remotes, releaseCohort, additionalShells, primaryShell, compactConfigOverride, ownershipOverride, developmentOverlayOverride);
-    return renderFileTemplate("workspace-scripts/validate-ultramodern-workspace.mjs", {
-        workspaceValidationContractJson: JSON.stringify(contract, null, 2)
-    });
-}
-function createWorkspaceI18nBoundaryValidationScript() {
-    return external_fs_io_js_readFileTemplate("workspace-scripts/check-ultramodern-i18n-boundaries.mts");
-}
-function createWorkspaceApiBoundaryValidationScript() {
-    return external_fs_io_js_readFileTemplate("workspace-scripts/check-ultramodern-api-boundaries.mts");
-}
-function createPerformanceReadinessConfigScript() {
-    return external_fs_io_js_readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs");
-}
-function createWorkerdSsrProofScript() {
-    return external_fs_io_js_readFileTemplate("workspace-scripts/proof-workerd-ssr.mts");
-}
-function createZeropsRuntimeMaterializationScript() {
-    return external_fs_io_js_readFileTemplate("workspace-scripts/materialize-zerops-runtime.mjs");
-}
-function writeGeneratedWorkspaceScripts(targetDir, scope, enableTailwind, remotes = [], releaseCohort, additionalShells = [], primaryShell) {
-    const shellOnly = 0 === remotes.length;
-    const hasBackendSurface = remotes.some(appHasApi);
-    writeWorkspaceOwnedMtsScript(targetDir, 'check-ultramodern-i18n-boundaries', createWorkspaceI18nBoundaryValidationScript());
-    writeWorkspaceOwnedMtsScript(targetDir, 'check-ultramodern-api-boundaries', createWorkspaceApiBoundaryValidationScript());
-    if (!shellOnly) {
-        writeFileReplacing(targetDir, "scripts/materialize-zerops-runtime.mjs", createZeropsRuntimeMaterializationScript());
-        writeWorkspaceOwnedMtsScript(targetDir, 'proof-workerd-ssr', createWorkerdSsrProofScript());
-    }
-    writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.config.mjs", createPerformanceReadinessConfigScript());
-    writeGeneratedToolWrapperScripts(targetDir, {
-        shellOnly,
-        hasBackendSurface
-    });
-    writeWorkspaceOwnedMtsScript(targetDir, 'validate-ultramodern-workspace', createWorkspaceValidationScript(scope, enableTailwind, remotes, releaseCohort, additionalShells, primaryShell));
-    writeWorkspaceOwnedMtsScript(targetDir, 'bootstrap-agent-skills', createSkillsToolWrapperScript());
-    migrateCopiedWorkspaceScriptToMts(targetDir, 'setup-agent-reference-repos');
-}
-function createAgentReferenceReposSetupScript() {
-    return node_fs.readFileSync(node_path.join(workspaceTemplateDir, "scripts/setup-agent-reference-repos.mjs"), 'utf-8');
-}
-const BACKEND_FEDERATION_WRAPPER_IDS = new Set([
-    'backendFederationGenerate',
-    'backendFederationProof'
-]);
-function migratedWorkspaceScriptArtifacts(options) {
-    const artifacts = [
-        {
-            relativePath: "scripts/check-ultramodern-i18n-boundaries.mts",
-            content: createWorkspaceI18nBoundaryValidationScript(),
-            legacyPath: "scripts/check-ultramodern-i18n-boundaries.mjs"
-        },
-        {
-            relativePath: "scripts/check-ultramodern-api-boundaries.mts",
-            content: createWorkspaceApiBoundaryValidationScript(),
-            legacyPath: "scripts/check-ultramodern-api-boundaries.mjs"
-        },
+import { readFileTemplate, workspaceTemplateDir, writeFileReplacing } from "./fs-io.js";
+function createWorkspaceScriptArtifacts() {
+    return [
         {
             relativePath: "scripts/ultramodern-performance-readiness.config.mjs",
-            content: createPerformanceReadinessConfigScript()
-        },
-        {
-            relativePath: "scripts/bootstrap-agent-skills.mts",
-            content: createSkillsToolWrapperScript(),
-            legacyPath: "scripts/bootstrap-agent-skills.mjs"
+            content: readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs")
         },
         {
             relativePath: "scripts/setup-agent-reference-repos.mts",
-            content: createAgentReferenceReposSetupScript(),
-            legacyPath: "scripts/setup-agent-reference-repos.mjs"
+            content: node_fs.readFileSync(node_path.join(workspaceTemplateDir, "scripts/setup-agent-reference-repos.mjs"), 'utf8')
         }
     ];
-    if (!options.shellOnly) artifacts.push({
-        relativePath: "scripts/proof-workerd-ssr.mts",
-        content: createWorkerdSsrProofScript(),
-        legacyPath: "scripts/proof-workerd-ssr.mjs"
-    });
-    const backendSurface = options.hasBackendSurface ?? !options.shellOnly;
-    for (const command of generatedToolingCommands)if (!(!backendSurface && BACKEND_FEDERATION_WRAPPER_IDS.has(command.id))) artifacts.push({
-        relativePath: command.wrapperPath,
-        content: createToolWrapperScript(command.command),
-        legacyPath: command.wrapperPath.replace(/\.mts$/u, '.mjs')
-    });
-    return artifacts;
 }
-const migratedWorkspaceScriptBasenames = [
-    'check-ultramodern-i18n-boundaries',
-    'check-ultramodern-api-boundaries',
-    'bootstrap-agent-skills',
-    'setup-agent-reference-repos',
-    'proof-workerd-ssr',
-    ...generatedToolingCommands.map((command)=>command.wrapperName)
-];
-export { createWorkspaceValidationScript, createZeropsRuntimeMaterializationScript, migratedWorkspaceScriptArtifacts, migratedWorkspaceScriptBasenames, writeGeneratedWorkspaceScripts };
+function writeGeneratedWorkspaceScripts(targetDir, options = {}) {
+    for (const artifact of createWorkspaceScriptArtifacts())if (options.io) options.io.writeGenerated(node_path.join(targetDir, artifact.relativePath), artifact.content);
+    else writeFileReplacing(targetDir, artifact.relativePath, artifact.content);
+}
+export { createWorkspaceScriptArtifacts, writeGeneratedWorkspaceScripts };