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

package/template-workspace/patches/effect-schema-error-type-id.patch

@@ -0,0 +1,18 @@
+diff --git a/dist/internal/schema/schema.d.ts b/dist/internal/schema/schema.d.ts
+index 7fbeec1a56a85ab1569f8b80e319fb4638a91615..21d38f72238f748d989d3080f77d0edfc63c0e16 100644
+--- a/dist/internal/schema/schema.d.ts
++++ b/dist/internal/schema/schema.d.ts
+@@ -3,0 +4 @@
++export declare const SchemaErrorTypeId: "~effect/Schema/SchemaError";
+diff --git a/dist/unstable/http/internal/preResponseHandler.d.ts b/dist/unstable/http/internal/preResponseHandler.d.ts
+index 81e81e744fa55db2647a8483991db403d451e7dd..040d6c97b85d0c01d4a477013010b9f54d462de8 100644
+--- a/dist/unstable/http/internal/preResponseHandler.d.ts
++++ b/dist/unstable/http/internal/preResponseHandler.d.ts
+@@ -1 +1,6 @@
+-export {};
++import type * as Effect from "../../../Effect.ts";
++import type { HttpServerError } from "../HttpServerError.ts";
++import type { HttpServerRequest } from "../HttpServerRequest.ts";
++import type { HttpServerResponse } from "../HttpServerResponse.ts";
++export declare const requestPreResponseHandlers: WeakMap<object, (request: HttpServerRequest, response: HttpServerResponse) => Effect.Effect<HttpServerResponse, HttpServerError>>;
++export declare const appendPreResponseHandlerUnsafe: (request: HttpServerRequest, handler: (request: HttpServerRequest, response: HttpServerResponse) => Effect.Effect<HttpServerResponse, HttpServerError>) => void;

package/template-workspace/pnpm-workspace.yaml.handlebars

@@ -8,6 +8,8 @@ minimumReleaseAgeStrict: true
 minimumReleaseAgeIgnoreMissingTime: false
 minimumReleaseAgeExclude:
   - '@bleedingdev/modern-js-*'
+  - 'effect@{{effectVersion}}'
+  - '@effect/opentelemetry@{{effectVersion}}'
   - '@tanstack/react-router'
   - '@tanstack/router-core'
   - 'typescript'
@@ -25,6 +27,7 @@ minimumReleaseAgeExclude:
 trustPolicy: no-downgrade
 trustPolicyIgnoreAfter: 1440
 trustPolicyExclude:
+  - 'effect@{{effectVersion}}'
   - '@effect/opentelemetry@{{effectVersion}}'
 blockExoticSubdeps: true
 engineStrict: true
@@ -45,11 +48,13 @@ peerDependencyRules:
 overrides:
   '@tanstack/react-router': {{tanstackRouterVersion}}
   '@tanstack/router-core': {{tanstackRouterCoreVersion}}
+  '@effect/opentelemetry': {{effectVersion}}
   '@effect/vitest': {{effectVitestVersion}}
   effect: {{effectVersion}}
   node-fetch: '{{nodeFetchVersion}}'
 
 allowBuilds:
+  '@parcel/watcher': true
   '@swc/core': true
   core-js: true
   esbuild: true
@@ -59,4 +64,7 @@ allowBuilds:
   workerd: true
 
 patchedDependencies:
+  '@module-federation/modern-js-v3@{{moduleFederationVersion}}': patches/@module-federation__modern-js-v3@{{moduleFederationVersion}}.patch
+  '@module-federation/bridge-react@{{moduleFederationVersion}}': patches/@module-federation__bridge-react@{{moduleFederationVersion}}.patch
   '@tanstack/router-core@{{tanstackRouterCoreVersion}}': patches/@tanstack__router-core@{{tanstackRouterCoreVersion}}.patch
+  'effect@{{effectVersion}}': patches/effect-schema-error-type-id.patch

package/template-workspace/scripts/bootstrap-agent-skills.mjs

@@ -7,8 +7,14 @@ import { fileURLToPath } from 'node:url';
 const root = process.cwd();
 const scriptDir = path.dirname(fileURLToPath(import.meta.url));
 const templateWorkspaceDir = path.resolve(scriptDir, '..');
+// Vendored skills always ship under template-workspace/.codex/skills; the
+// workspace-side lockfile may live under .agents/ (agents-standard layout) or
+// .codex/ (legacy default).
 const vendoredSkillsDir = path.join(templateWorkspaceDir, '.codex/skills');
-const lockPath = path.join(root, '.codex/skills-lock.json');
+const lockRoot = fs.existsSync(path.join(root, '.agents/skills-lock.json'))
+  ? '.agents'
+  : '.codex';
+const lockPath = path.join(root, `${lockRoot}/skills-lock.json`);
 const checkOnly = process.argv.includes('--check');
 const postinstall = process.argv.includes('--postinstall');
 const truthy = value => /^(1|true|yes|on)$/i.test(String(value ?? ''));
@@ -175,12 +181,14 @@ const resolveSkillDir = (sourceRoot, skillName) => {
 };
 
 if (!fs.existsSync(lockPath)) {
-  console.error('Missing .codex/skills-lock.json');
+  console.error(
+    'Missing skills-lock.json: expected .agents/skills-lock.json or .codex/skills-lock.json',
+  );
   process.exit(1);
 }
 
 const lock = readJson(lockPath);
-const installDir = path.join(root, lock.installDir ?? '.codex/skills');
+const installDir = path.join(root, lock.installDir ?? `${lockRoot}/skills`);
 const sources = lock.sources ?? [];
 const vendoredSources = sources.filter(source => source.install === 'vendored');
 const cloneSources = sources.filter(source => source.install === 'clone');

package/templates/workspace-scripts/check-ultramodern-api-boundaries.mts

@@ -189,6 +189,7 @@ if (exists('apps/shell-super-app') && verticalDirectories.length > 0) {
 
 function assertApiSurface(appPath) {
   const apiEntry = `${appPath}/api/index.ts`;
+  const backendEffectExpose = `${appPath}/api/effect-api.ts`;
   const sharedApi = `${appPath}/shared/api.ts`;
   const srcApiDirectory = `${appPath}/src/api`;
   const modernConfig = `${appPath}/modern.config.ts`;
@@ -235,8 +236,45 @@ function assertApiSurface(appPath) {
       'must import the contract from ../shared/api.ts.',
     );
   }
-
-  if (exists(sharedApi)) {
+ if (exists(backendEffectExpose)) {
+ const backendExpose = readText(backendEffectExpose);
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /backendFederationContract/u,
+ 'must export backendFederationContract metadata.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /role:\s*['"]microvertical-server['"]/u,
+ 'must describe the MicroVertical server role.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /strictEffectApproach:\s*true/u,
+ 'must preserve strict Effect backend execution.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /contractVersion:\s*['"]microvertical-server-effect-v1['"]/u,
+ 'must preserve the MicroVertical server contract version.',
+ );
+ assertContains(
+ backendEffectExpose,
+ backendExpose,
+ /runtime\s*=\s*apiRuntime/u,
+ 'must export the generated Effect BFF runtime.',
+ );
+ assert(
+ !/\b(request|handler)\s*:\s*async\s*\(/u.test(backendExpose),
+ `${backendEffectExpose}: must not expose raw request handlers.`,
+ );
+ }
+
+ if (exists(sharedApi)) {
     const contract = readText(sharedApi);
     assertContains(
       sharedApi,

package/templates/workspace-scripts/generate-node-backend-federation.mjs

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const workspaceRoot = path.resolve(
+  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
+    path.join(path.dirname(fileURLToPath(import.meta.url)), '../..'),
+);
+const configPath = path.join(workspaceRoot, '.modernjs/ultramodern.json');
+const contractVersion = 'microvertical-server-effect-v1';
+const nodeAdapterVersion = 'backend-mf-effect-v1';
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+function readBuildIdentity(app) {
+  const buildModulePath = path.join(
+    workspaceRoot,
+    app.path,
+    'shared/ultramodern-build.ts',
+  );
+  if (!fs.existsSync(buildModulePath)) {
+    return {};
+  }
+
+  const source = fs.readFileSync(buildModulePath, 'utf8');
+  return {
+    buildVersion: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+    packageName: source.match(/\bpackageName:\s*['"]([^'"]+)['"]/u)?.[1],
+    version: source.match(/\bversion:\s*['"]([^'"]+)['"]/u)?.[1],
+    unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+    sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1],
+  };
+}
+
+function parseArgs(argv) {
+  const options = {
+    app: undefined,
+    target: 'dist',
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--app') {
+      options.app = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--target') {
+      options.target = argv[index + 1] ?? options.target;
+      index += 1;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      console.log(
+        'Usage: node scripts/generate-node-backend-federation.mts [--app <id>] [--target dist|dist-cloudflare]',
+      );
+      process.exit(0);
+    }
+  }
+  return options;
+}
+
+function backendApps(config, appFilter) {
+  return (config.topology?.apps ?? []).filter(app => {
+    if (app.kind !== 'vertical') {
+      return false;
+    }
+    if (!backendFederationMetadata(app)) {
+      return false;
+    }
+    return appFilter ? app.id === appFilter : true;
+  });
+}
+
+function backendFederationMetadata(app) {
+  return app.backendFederation ?? app.api?.backendFederation;
+}
+
+function backendFederationExposes(app) {
+  const backend = backendFederationMetadata(app);
+  const exposes = Array.isArray(backend.exposes)
+    ? backend.exposes.filter(expose => typeof expose === 'string')
+    : backend.exposes &&
+        typeof backend.exposes === 'object' &&
+        !Array.isArray(backend.exposes)
+      ? Object.keys(backend.exposes)
+    : [];
+
+  if (exposes.length > 0) {
+    return exposes;
+  }
+
+  if (typeof backend.expose === 'string') {
+    return [backend.expose];
+  }
+
+  throw new Error(`${app.id} backend federation expose metadata is missing`);
+}
+
+function normalizeBackendFederation(app) {
+  const backend = backendFederationMetadata(app);
+  const nodeSurface = backend.executionSurfaces?.node ?? {};
+  const exposes = backendFederationExposes(app);
+
+  return {
+    ...backend,
+    name: backend.name ?? nodeSurface.remoteName,
+    remoteType: backend.remoteType ?? nodeSurface.remoteType ?? 'module',
+    manifestUrl: backend.manifestUrl ?? nodeSurface.manifestUrl,
+    containerEntry: backend.containerEntry ?? nodeSurface.containerEntry,
+    runtimePackage: backend.runtimePackage ?? nodeSurface.runtimePackage,
+    contractVersion:
+      backend.contractVersion ??
+      backend.compatibility?.contractVersion ??
+      contractVersion,
+    nodeAdapterVersion:
+      backend.nodeAdapterVersion ?? nodeSurface.adapterVersion ?? nodeAdapterVersion,
+    expose:
+      typeof backend.expose === 'string'
+        ? backend.expose
+        : (nodeSurface.expose ?? exposes[0]),
+    exposes,
+  };
+}
+
+function createRemoteEntrySource(app) {
+  const exposes = backendFederationExposes(app);
+  return `const factories = {
+${exposes
+  .map(
+    expose => `${JSON.stringify(expose)}: async () =>
+  import(new URL('../api/backend-federation.ts', import.meta.url).href),
+`,
+  )
+  .join('')}
+};
+
+export async function init() {}
+
+export function get(id) {
+  const factory = factories[id];
+  if (!factory) {
+    throw new Error(\`Unknown backend federation expose \${id}\`);
+  }
+  return factory;
+}
+
+export default { init, get };
+`;
+}
+
+function createManifest(app) {
+  const backend = normalizeBackendFederation(app);
+  const buildIdentity = readBuildIdentity(app);
+  const compactDeliveryUnit =
+    app.deliveryUnit && typeof app.deliveryUnit === 'object'
+      ? app.deliveryUnit
+      : undefined;
+  const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
+  const sourceRevision =
+    compactDeliveryUnit?.sourceRevision ?? buildIdentity.sourceRevision;
+  return {
+    schemaVersion: 1,
+    name: backend.name,
+    id: backend.name,
+    version: buildIdentity.version,
+    buildVersion: buildIdentity.buildVersion,
+    type: backend.remoteType,
+    entry: {
+      url: backend.containerEntry,
+      type: backend.remoteType,
+    },
+    metaData: {
+      name: backend.name,
+      type: backend.remoteType,
+      buildInfo: {
+        buildName: buildIdentity.packageName,
+        buildVersion: buildIdentity.buildVersion,
+      },
+      remoteEntry: {
+        name: 'backendRemoteEntry.mjs',
+        path: '',
+        type: backend.remoteType,
+      },
+        exposes: backend.exposes.map(expose => ({
+          id: expose,
+          name: expose,
+        path: expose,
+      })),
+    },
+    exposes: backend.exposes.map(expose => ({
+      id: expose,
+      name: expose,
+      path: expose,
+    })),
+    backendFederation: {
+      role: backend.role ?? 'microvertical-server',
+      name: backend.name,
+      runtimeFramework: backend.runtimeFramework ?? 'effect',
+      strictEffectApproach: backend.strictEffectApproach ?? true,
+      contractVersion: backend.contractVersion,
+      nodeAdapterVersion: backend.nodeAdapterVersion,
+      manifestUrl: backend.manifestUrl,
+      containerEntry: backend.containerEntry,
+      expose: backend.expose,
+      runtimePackage: backend.runtimePackage,
+      ...(unitId && buildIdentity.buildVersion
+        ? {
+            deliveryUnit: {
+              schemaVersion: 1,
+              kind: 'microvertical-delivery-unit',
+              unitId,
+              packageName: buildIdentity.packageName,
+              version: buildIdentity.version,
+              buildMarker: buildIdentity.buildVersion,
+              sourceRevision,
+            },
+          }
+        : {}),
+      versionBoundary: {
+        packageName: buildIdentity.packageName,
+        version: buildIdentity.version,
+        buildVersion: buildIdentity.buildVersion,
+        ...(unitId && buildIdentity.buildVersion
+          ? {
+              deliveryUnit: {
+                unitId,
+                buildMarker: buildIdentity.buildVersion,
+              },
+            }
+          : {}),
+      },
+    },
+  };
+}
+
+const options = parseArgs(process.argv.slice(2));
+const config = readJson(configPath);
+const apps = backendApps(config, options.app);
+
+if (options.app && apps.length === 0) {
+  throw new Error(`No generated backend federation app matched ${options.app}`);
+}
+
+for (const app of apps) {
+  const outputDir = path.join(workspaceRoot, app.path, options.target);
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(outputDir, 'backendRemoteEntry.mjs'),
+    createRemoteEntrySource(app),
+    'utf-8',
+  );
+  fs.writeFileSync(
+    path.join(outputDir, 'backend-mf-manifest.json'),
+    `${JSON.stringify(createManifest(app), null, 2)}\n`,
+    'utf-8',
+  );
+  console.log(
+    `[ultramodern] generated backend federation artifacts for ${app.id} in ${path.relative(
+      workspaceRoot,
+      outputDir,
+    )}`,
+  );
+}
+
+if (apps.length === 0) {
+  console.log('[ultramodern] no backend federation apps to generate');
+}