@bleedingdev/modern-js-plugin-bff-build-extensions 0.0.0 → 3.9.0-ultramodern.11

package/src/compile.ts

@@ -0,0 +1,39 @@
+import type { AppTools, BffCompilation } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import {
+  serializeServerGlobalVars,
+  transformServerGlobalVars,
+} from './server-global-vars';
+
+export function registerBffCompilation(api: CLIPluginAPI<AppTools>) {
+  const serialized = new WeakMap<
+    BffCompilation,
+    ReturnType<typeof serializeServerGlobalVars>
+  >();
+  api.onBeforeBffCompile(context => {
+    serialized.set(
+      context,
+      serializeServerGlobalVars(api.getNormalizedConfig().source.globalVars),
+    );
+  });
+  api.onAfterBffCompile(async context => {
+    const globals = serialized.get(context);
+    if (!globals)
+      throw new Error('BFF compilation completed without its before hook.');
+    serialized.delete(context);
+    await transformServerGlobalVars([...context.outputDirectories], globals);
+    if (api.getAppContext().bffRuntimeFramework !== 'effect') return;
+    // Hosted APIs use the producer's compiled entry; it is not emitted by this app.
+    if (api.getNormalizedConfig().bff?.isCrossProjectServer === true) return;
+    const { bundleBuiltEffectEntryForNode } = await import(
+      '@modern-js/plugin-bff-extensions/effect-source-loader'
+    );
+    await bundleBuiltEffectEntryForNode({
+      appDir: context.appDirectory,
+      apiDir: context.apiDirectory,
+      distDir: context.distDirectory,
+      effectEntry: api.getNormalizedConfig().bff?.effect?.entry,
+      format: context.moduleType === 'module' ? 'esm' : 'cjs',
+    });
+  });
+}

package/src/cross-project.ts

@@ -0,0 +1,72 @@
+import '@modern-js/server-runtime-extensions/server-config';
+import path from 'node:path';
+import {
+  type CrossProjectApiPluginOptions,
+  createCrossProjectApiPlugin,
+} from '@modern-js/plugin-bff/cross-project';
+import type { OperationContractMap } from '@modern-js/server-runtime-extensions/bff-policy/node';
+
+export interface CrossProjectBffDescriptor {
+  native: Omit<CrossProjectApiPluginOptions, 'modifyResolvedConfig'>;
+  runtimeFramework: 'hono' | 'effect';
+  relativeEffectEntry: string;
+  requestId: string;
+  operationContracts: OperationContractMap;
+}
+
+export function createCrossProjectBffPlugin(
+  descriptor: CrossProjectBffDescriptor,
+) {
+  return createCrossProjectApiPlugin({
+    ...descriptor.native,
+    modifyResolvedConfig: (resolvedConfig, { sdkDistDirectory, api }) => {
+      const config = api.getConfig();
+      const configuredRuntimeFramework = config?.bff?.runtimeFramework;
+      if (
+        configuredRuntimeFramework &&
+        configuredRuntimeFramework !== descriptor.runtimeFramework
+      ) {
+        throw new Error(
+          `[${descriptor.native.packageName}] Runtime framework mismatch for cross-project BFF. Detected "${configuredRuntimeFramework}", but producer SDK requires "${descriptor.runtimeFramework}".`,
+        );
+      }
+      const effectEntry = descriptor.relativeEffectEntry
+        ? path.join(sdkDistDirectory, descriptor.relativeEffectEntry)
+        : undefined;
+      api.updateAppContext({
+        ...(effectEntry ? { apiDirectory: path.dirname(effectEntry) } : {}),
+        bffRuntimeFramework: descriptor.runtimeFramework,
+      });
+      resolvedConfig.bff ??= {};
+      resolvedConfig.bff.runtimeFramework = descriptor.runtimeFramework;
+      if (effectEntry)
+        resolvedConfig.bff.effect = {
+          ...resolvedConfig.bff.effect,
+          entry: effectEntry,
+        };
+      resolvedConfig.bff.requestId =
+        resolvedConfig.bff.requestId ||
+        config?.bff?.requestId ||
+        descriptor.requestId ||
+        descriptor.native.packageName ||
+        'default';
+      const policy = resolvedConfig.bff.crossProjectPolicy;
+      resolvedConfig.bff.crossProjectPolicy = {
+        ...policy,
+        enabled: policy?.enabled ?? true,
+        requireEnvelope: policy?.requireEnvelope ?? true,
+        requireOperationContext: policy?.requireOperationContext ?? true,
+        requireOperationContextDetails:
+          policy?.requireOperationContextDetails ?? true,
+        requireOperationSchemaHash: policy?.requireOperationSchemaHash ?? true,
+        requireOperationVersion: policy?.requireOperationVersion ?? true,
+        allowUnknownOperations: policy?.allowUnknownOperations ?? false,
+        expectedOperationContracts: {
+          ...policy?.expectedOperationContracts,
+          ...descriptor.operationContracts,
+        },
+      };
+      return resolvedConfig;
+    },
+  });
+}

package/src/generated-entries.ts

@@ -0,0 +1,105 @@
+import { pathToFileURL } from 'node:url';
+import type {
+  AppTools,
+  BffGeneratedEntries,
+  BffGeneration,
+} from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import { fs, upath as path } from '@modern-js/utils';
+import {
+  BFF_REQUEST_RUNTIME,
+  type BffGenerationMetadata,
+} from './client-artifacts';
+import type { CrossProjectBffDescriptor } from './cross-project';
+
+export function registerBffGeneratedEntries(
+  api: CLIPluginAPI<AppTools>,
+  metadata: WeakMap<BffGeneration, BffGenerationMetadata>,
+) {
+  api.modifyBffGeneratedEntries(async (entries: BffGeneratedEntries) => {
+    const { generation } = entries;
+    const details = metadata.get(generation);
+    if (!details)
+      throw new Error(
+        'BFF entries require completed operation contract collection.',
+      );
+    metadata.delete(generation);
+    const packageJson = await fs.readJSON(
+      path.join(generation.appDirectory, 'package.json'),
+    );
+    const runtimeSpecifier =
+      api.getNormalizedConfig().bff?.runtimeCreateRequest ||
+      BFF_REQUEST_RUNTIME;
+    const dependencies = [
+      '@modern-js/plugin-bff-build-extensions',
+      '@modern-js/plugin-bff-extensions',
+    ];
+    const emitsClient =
+      details.runtimeFramework === 'hono' && generation.apiFiles.length > 0;
+    if (
+      details.runtimeFramework === 'hono' &&
+      (runtimeSpecifier === BFF_REQUEST_RUNTIME ||
+        (emitsClient &&
+          (generation.requestCreator || BFF_REQUEST_RUNTIME) ===
+            BFF_REQUEST_RUNTIME))
+    )
+      dependencies.push('@modern-js/runtime-extensions');
+    for (const name of dependencies) {
+      const specifier =
+        packageJson.dependencies?.[name] ||
+        packageJson.devDependencies?.[name] ||
+        fs.readJSONSync(require.resolve(`${name}/package.json`)).version;
+      entries.packageDependencies[name] = specifier;
+    }
+    const descriptor: CrossProjectBffDescriptor = {
+      native: {
+        packageName: packageJson.name,
+        prefix: generation.prefix,
+        relativeDistPath: path.normalize(generation.relativeDistPath),
+        relativeApiPath: path.relative(
+          generation.appDirectory,
+          generation.apiDirectory,
+        ),
+        relativeLambdaPath: path.relative(
+          generation.appDirectory,
+          generation.lambdaDirectory,
+        ),
+      },
+      runtimeFramework: details.runtimeFramework,
+      relativeEffectEntry: details.relativeEffectEntry,
+      requestId: generation.requestId,
+      operationContracts: details.operationContracts,
+    };
+    const isModule =
+      api.getAppContext().moduleType === 'module' ||
+      packageJson.type === 'module';
+    entries.plugin = {
+      code: isModule
+        ? `import { createCrossProjectBffPlugin } from '@modern-js/plugin-bff-build-extensions/cross-project';\nexport const crossProjectApiPlugin = () => createCrossProjectBffPlugin(${JSON.stringify(descriptor)});\n`
+        : `'use strict';\nconst { createCrossProjectBffPlugin } = require('@modern-js/plugin-bff-build-extensions/cross-project');\nexports.crossProjectApiPlugin = () => createCrossProjectBffPlugin(${JSON.stringify(descriptor)});\n`,
+      declaration: `import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>;
+`,
+    };
+    if (details.runtimeFramework === 'effect') {
+      entries.runtime = null;
+      return entries;
+    }
+    const runtime = JSON.stringify(runtimeSpecifier);
+    const esmRuntime = JSON.stringify(
+      path.isAbsolute(runtimeSpecifier)
+        ? pathToFileURL(runtimeSpecifier).href
+        : runtimeSpecifier,
+    );
+    entries.runtime = {
+      code: isModule
+        ? `import { configure as _configure } from ${esmRuntime};\nimport { createProducerClient } from '@modern-js/plugin-bff-extensions/producer-runtime';\nexport const configure = createProducerClient(_configure, { requestId: ${JSON.stringify(generation.requestId)} });\nexport const initProducerClient = configure;\n`
+        : `'use strict';\nconst { configure: _configure } = require(${runtime});\nconst { createProducerClient } = require('@modern-js/plugin-bff-extensions/producer-runtime');\nconst configure = createProducerClient(_configure, { requestId: ${JSON.stringify(generation.requestId)} });\nexports.configure = configure;\nexports.initProducerClient = configure;\n`,
+      declaration: `type Runtime = typeof import(${runtime});
+export declare const initProducerClient: (options?: Parameters<Runtime['configure']>[0]) => ReturnType<Runtime['configure']>;
+export declare const configure: typeof initProducerClient;
+`,
+    };
+    return entries;
+  });
+}

package/src/hono-client-codegen.ts

@@ -0,0 +1,83 @@
+import path from 'node:path';
+import type { ClientCodegenPlugin } from '@modern-js/bff-core';
+import {
+  buildOperationContractMap,
+  createOperationSchemaHash,
+  deriveOperationVersion,
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
+
+const REQUEST_RUNTIME = '@modern-js/runtime-extensions/request-policy';
+
+export const modifyClient: ClientCodegenPlugin = (draft, context) => {
+  const { appDir, requestId } = context.options;
+  draft.requestCreator = context.options.requestCreator || REQUEST_RUNTIME;
+  let version: string | undefined;
+  try {
+    version = require(path.resolve(appDir, 'package.json')).version;
+  } catch {
+    // Missing or invalid package metadata uses the established version fallback.
+  }
+  const operationVersion = deriveOperationVersion(version);
+  const normalizedRequestId = requestId || 'default';
+  const operationContracts = buildOperationContractMap({
+    handlers: [...context.handlerInfos],
+    requestId: normalizedRequestId,
+    operationVersion,
+  });
+  const operationEntries = context.handlerInfos
+    .map(handlerInfo => {
+      const httpMethod = handlerInfo.httpMethod.toUpperCase();
+      return {
+        name: handlerInfo.name,
+        httpMethod,
+        routePath: handlerInfo.routePath,
+        schemaHash:
+          operationContracts[`${httpMethod}:${handlerInfo.routePath}`]
+            ?.schemaHash ?? '',
+      };
+    })
+    .sort((a, b) =>
+      `${a.routePath}:${a.httpMethod}:${a.name}`.localeCompare(
+        `${b.routePath}:${b.httpMethod}:${b.name}`,
+      ),
+    );
+  const schemaHash = createOperationSchemaHash(
+    operationEntries,
+    normalizedRequestId,
+  );
+  for (const { handlerInfo, optionProperties } of draft.handlers) {
+    if (handlerInfo.action === 'upload' && !requestId) continue;
+    const method = handlerInfo.httpMethod.toUpperCase();
+    const operationContext = {
+      operationId: handlerInfo.name,
+      routePath: handlerInfo.routePath,
+      method,
+      schemaHash:
+        operationContracts[`${method}:${handlerInfo.routePath}`]?.schemaHash ??
+        '',
+      operationVersion,
+    };
+    optionProperties.push(
+      `operationContext: ${JSON.stringify(operationContext)}`,
+    );
+  }
+  if (requestId) {
+    draft.imports.push(
+      `import * as requestRuntime from ${JSON.stringify(draft.requestCreator)};`,
+      'import { createProducerClient } from "@modern-js/plugin-bff-extensions/producer-runtime";',
+    );
+    draft.statements.push(`export const initProducerClient = (options = {}) => {
+  const configure = requestRuntime.configure;
+  if (typeof configure !== 'function') {
+    console.warn('[modernjs] Compatibility request creator path does not expose configure(); use default @modern-js/create-request or migrate the compatibility path.');
+    return undefined;
+  }
+  return createProducerClient(configure, { requestId: ${JSON.stringify(requestId)} })(options);
+};`);
+  }
+  draft.statements.push(
+    `export const operationVersion = ${String(operationVersion)};`,
+    `export const operationSchemaHash = ${JSON.stringify(schemaHash)};`,
+    `export const operationManifest = ${JSON.stringify({ operationVersion, schemaHash, operations: operationEntries }, null, 2)};`,
+  );
+};

package/src/index.ts

@@ -0,0 +1,127 @@
+import '@modern-js/server-runtime-extensions/server-config';
+import type { AppTools, BffGeneration, CliPlugin } from '@modern-js/app-tools';
+import { bffPlugin as nativeBffPlugin } from '@modern-js/plugin-bff';
+import { fs, upath as path } from '@modern-js/utils';
+import {
+  BFF_REQUEST_RUNTIME,
+  type BffGenerationMetadata,
+  registerBffClientArtifacts,
+} from './client-artifacts';
+import { registerBffCompilation } from './compile';
+import { registerBffGeneratedEntries } from './generated-entries';
+import { resolveSelfModule } from './self-module';
+
+export const bffPlugin = (): CliPlugin<AppTools> => ({
+  name: '@modern-js/plugin-bff-build-extensions',
+  usePlugins: [nativeBffPlugin()],
+  pre: ['@modern-js/plugin-bff'],
+  setup: api => {
+    const hooks = api.getHooks();
+    for (const name of [
+      'onBeforeBffCompile',
+      'onAfterBffCompile',
+      'modifyBffClientArtifacts',
+      'modifyBffGeneratedEntries',
+    ] as const) {
+      if (typeof hooks[name]?.tap !== 'function')
+        throw new Error(`Native BFF build hook ${name} is unavailable.`);
+    }
+    api.config(() => ({
+      bff: {
+        requestCreator: BFF_REQUEST_RUNTIME,
+        runtimeCreateRequest: BFF_REQUEST_RUNTIME,
+        clientCodegenPlugin: resolveSelfModule('hono-client-codegen'),
+      },
+    }));
+    const runtimeFramework = api.getConfig()?.bff?.runtimeFramework;
+    if (
+      runtimeFramework !== undefined &&
+      runtimeFramework !== 'hono' &&
+      runtimeFramework !== 'effect'
+    ) {
+      throw new Error(`Unsupported Effect BFF runtime "${runtimeFramework}".`);
+    }
+    api.updateAppContext({ bffRuntimeFramework: runtimeFramework ?? 'effect' });
+    api._internalServerPlugins(({ plugins }) => {
+      const nativePlugins = plugins.filter(
+        plugin => plugin.name === '@modern-js/plugin-bff/server-plugin',
+      );
+      if (nativePlugins.length !== 1) {
+        throw new Error('Expected exactly one native BFF server plugin.');
+      }
+      const native = nativePlugins[0]!;
+      const runtimeAdapters = native.options?.runtimeAdapters ?? {};
+      const effect = '@modern-js/plugin-bff-extensions/effect-adapter';
+      const honoRouteBinder = '@modern-js/plugin-bff-extensions/hono/node';
+      if (
+        native.options?.honoRouteBinder !== undefined &&
+        native.options.honoRouteBinder !== honoRouteBinder
+      ) {
+        throw new Error('The Hono BFF route binder is already configured.');
+      }
+      if (
+        runtimeAdapters.effect !== undefined &&
+        runtimeAdapters.effect !== effect
+      ) {
+        throw new Error(
+          'The Effect BFF runtime adapter is already configured.',
+        );
+      }
+      native.options = {
+        ...native.options,
+        honoRouteBinder,
+        runtimeAdapters: { ...runtimeAdapters, effect },
+      };
+      return { plugins };
+    });
+    const metadata = new WeakMap<BffGeneration, BffGenerationMetadata>();
+    registerBffCompilation(api);
+    registerBffClientArtifacts(api, metadata);
+    registerBffGeneratedEntries(api, metadata);
+    api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
+      if (api.getAppContext().bffRuntimeFramework !== 'effect') return;
+      const { appDirectory, apiDirectory } = api.getAppContext();
+      const bff = api.getNormalizedConfig().bff;
+      if (!fs.existsSync(apiDirectory) && bff?.effect?.entry === undefined)
+        return;
+      const { resolveEffectEntryFile } = await import(
+        '@modern-js/plugin-bff-extensions/effect-source-loader'
+      );
+      const entry = resolveEffectEntryFile({
+        appDir: appDirectory,
+        apiDir: apiDirectory,
+        effectEntry: bff?.effect?.entry,
+      });
+      if (!entry)
+        throw new Error(`Cannot resolve Effect BFF entry in ${apiDirectory}.`);
+      const canonical = (file: string) =>
+        path.normalize(
+          fs.existsSync(file) ? fs.realpathSync(file) : path.resolve(file),
+        );
+      const entryPath = canonical(entry);
+      const isEntry = (resource: string) => canonical(resource) === entryPath;
+      chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(isEntry);
+      chain.module.rule('js-bff-api').exclude.add(isEntry);
+      chain.module
+        .rule('js-bff-effect-entry')
+        .test(isEntry)
+        .use('effect-bff-loader')
+        .loader(
+          require.resolve(
+            '@modern-js/plugin-bff-extensions/effect-source-loader/rspack-loader',
+          ),
+        )
+        .options({
+          appDir: appDirectory,
+          apiDir: apiDirectory,
+          effectEntry: entry,
+          prefix: Array.isArray(bff?.prefix)
+            ? bff.prefix[0]
+            : bff?.prefix || '/api',
+          requestId: bff?.requestId,
+        });
+    });
+  },
+});
+
+export default bffPlugin;

package/src/self-module.ts

@@ -0,0 +1,26 @@
+import { createRequire } from 'node:module';
+
+const selfRequire = createRequire(import.meta.url);
+
+/**
+ * Resolve a file this package ships alongside the calling module.
+ *
+ * Resolving it by this package's own public name (`@modern-js/plugin-bff-build-extensions/<name>`)
+ * only works where the package can see itself in a `node_modules` directory —
+ * under pnpm's isolated layout it is anchored in its own `.pnpm` directory and
+ * the lookup fails for a consumer, surfacing as an opaque `require.resolve`
+ * error in the middle of a build. A sibling lookup works in every layout:
+ * source (`src/*.ts`), CommonJS (`dist/cjs/*.js`) and ESM (`dist/esm-node/*.mjs`)
+ * all place these files next to each other.
+ */
+export const resolveSelfModule = (name: string): string => {
+  for (const extension of ['.js', '.mjs', '.cjs', '.ts']) {
+    try {
+      return selfRequire.resolve(`./${name}${extension}`);
+    } catch {
+      // Try the next extension this package may have been built with.
+    }
+  }
+  // A layout that hoists this package still resolves the public specifier.
+  return selfRequire.resolve(`@modern-js/plugin-bff-build-extensions/${name}`);
+};

package/src/server-global-vars.ts

@@ -0,0 +1,145 @@
+import type { AppTools } from '@modern-js/app-tools';
+import type { RsbuildTarget } from '@modern-js/builder';
+import { applyOptionsChain, fs, upath as path } from '@modern-js/utils';
+import { transform } from '@swc/core';
+
+type SerializedGlobalVars = Record<string, string>;
+type ServerGlobalVarsOptions = NonNullable<
+  NonNullable<AppTools['config']>['source']
+>['globalVars'];
+
+const RELEASE_IDENTITY_GLOBAL_NAMES = [
+  'ULTRAMODERN_BUILD_MARKER',
+  'ULTRAMODERN_SOURCE_REVISION',
+  'ULTRAMODERN_RELEASE_VERSION',
+] as const;
+
+const collectJavaScriptFiles = (directory: string): Promise<string[]> =>
+  Promise.resolve()
+    .then(() => fs.readdir(directory, { withFileTypes: true }))
+    .then(entries =>
+      Promise.all(
+        entries.map(entry => {
+          const absolutePath = path.join(directory, entry.name);
+          if (entry.isDirectory()) {
+            return collectJavaScriptFiles(absolutePath);
+          }
+          return /\.(?:c|m)?js$/u.test(entry.name) ? [absolutePath] : [];
+        }),
+      ).then(nested => nested.flat()),
+    );
+
+export const serializeServerGlobalVars = (
+  options: ServerGlobalVarsOptions,
+): SerializedGlobalVars => {
+  const globalVars = applyOptionsChain<
+    Record<string, unknown>,
+    { env: string; target: RsbuildTarget }
+  >({}, options, {
+    env: 'server',
+    target: 'node',
+  });
+
+  return Object.fromEntries(
+    Object.entries(globalVars).map(([key, value]) => {
+      let serialized: string | undefined;
+      try {
+        serialized = JSON.stringify(value);
+      } catch (error) {
+        throw new Error(
+          `source.globalVars["${key}"] cannot be serialized exactly for BFF compilation.`,
+          { cause: error },
+        );
+      }
+      if (serialized === undefined) {
+        throw new Error(
+          `source.globalVars["${key}"] cannot be serialized exactly for BFF compilation.`,
+        );
+      }
+      return [key, serialized];
+    }),
+  );
+};
+
+export const transformServerGlobalVars = (
+  outputDirectories: string[],
+  globalVars: SerializedGlobalVars,
+) =>
+  Promise.resolve().then(() => {
+    if (Object.keys(globalVars).length === 0) {
+      return undefined;
+    }
+
+    return Promise.all(
+      outputDirectories.map(directory =>
+        fs
+          .pathExists(directory)
+          .then(directoryExists => (directoryExists ? directory : undefined)),
+      ),
+    )
+      .then(existingDirectories => {
+        const filesPromise = Promise.all(
+          existingDirectories
+            .filter((directory): directory is string => directory !== undefined)
+            .map(collectJavaScriptFiles),
+        ).then(files => files.flat());
+
+        const releaseIdentityBanner = RELEASE_IDENTITY_GLOBAL_NAMES.every(
+          name => Object.hasOwn(globalVars, name),
+        )
+          ? `${RELEASE_IDENTITY_GLOBAL_NAMES.map(name => `void ${globalVars[name]};`).join('')}\n`
+          : '';
+
+        return filesPromise.then(files =>
+          Promise.all(
+            files.map(filename =>
+              fs.readFile(filename, 'utf8').then(source => {
+                const sourceMapFilename = `${filename}.map`;
+                return fs
+                  .pathExists(sourceMapFilename)
+                  .then(sourceMapExists => {
+                    const inputSourceMapPromise: Promise<string | undefined> =
+                      sourceMapExists
+                        ? fs.readFile(sourceMapFilename, 'utf8')
+                        : Promise.resolve(undefined);
+
+                    return inputSourceMapPromise.then(inputSourceMap =>
+                      transform(`${releaseIdentityBanner}${source}`, {
+                        filename,
+                        inputSourceMap,
+                        sourceMaps: sourceMapExists,
+                        jsc: {
+                          parser: {
+                            syntax: 'ecmascript',
+                          },
+                          preserveAllComments: true,
+                          target: 'es2024',
+                          transform: {
+                            optimizer: {
+                              globals: {
+                                vars: globalVars,
+                              },
+                            },
+                          },
+                        },
+                      }).then(result =>
+                        fs.writeFile(filename, result.code).then(() => {
+                          if (
+                            sourceMapExists &&
+                            result.map !== undefined &&
+                            result.map.length > 0
+                          ) {
+                            return fs.writeFile(sourceMapFilename, result.map);
+                          }
+                          return undefined;
+                        }),
+                      ),
+                    );
+                  });
+              }),
+            ),
+          ),
+        );
+      })
+      .then(() => undefined);
+  });

package/README.md

@@ -1,3 +0,0 @@
-# @bleedingdev/modern-js-plugin-bff-build-extensions
-
-This 0.0.0 version only registers the package name so npm trusted publishing can be configured. It contains no runtime implementation. Use the subsequent UltraModern.js release, published from the repository workflow with provenance.