@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/src/routerState.ts

@@ -3,7 +3,6 @@ import { createRuntimeContextExtension } from './contextExtensions';
 import type {
   InternalRouterRuntimeState,
   InternalRouterServerSnapshot,
-  RouterRouteMatchSnapshot,
   RouterServerPrepareResult,
 } from './routerStateTypes';
 
@@ -13,6 +12,9 @@ export type {
   InternalRouterServerSnapshot,
   RouterFramework,
   RouterLifecyclePhase,
+  RouterLinkTarget,
+  RouterNavigationCapability,
+  RouterNavigationSnapshot,
   RouterRouteMatchSnapshot,
   RouterServerPrepareResult,
 } from './routerStateTypes';
@@ -50,112 +52,138 @@ export function getRouterServerSnapshot(
   return routerServerSnapshotExtension.get(runtimeContext);
 }
 
-type RouterSnapshotLike = Partial<InternalRouterServerSnapshot>;
-
-function toHydrationScripts(state: {
-  hydrationScript?: string;
-  hydrationScripts?: string[];
-}) {
-  if (state.hydrationScripts?.length) {
-    return state.hydrationScripts;
-  }
-
-  return state.hydrationScript ? [state.hydrationScript] : undefined;
-}
-
-function getMatchedRouteIdsFromMatches(matches?: RouterRouteMatchSnapshot[]) {
-  const routeIds = matches
-    ?.map(match => match.assetRouteId ?? match.routeId)
-    .filter((routeId): routeId is string => typeof routeId === 'string');
-
-  return routeIds?.length ? routeIds : undefined;
-}
-
+/** Capture prepared metadata once; live router updates cannot rewrite it. */
 export function createRouterServerSnapshot(
-  state: RouterSnapshotLike,
+  snapshot: InternalRouterServerSnapshot,
 ): InternalRouterServerSnapshot {
-  const hydrationScripts = toHydrationScripts(state);
+  const matches = snapshot.matches?.map(match =>
+    Object.freeze({
+      ...match,
+      ...(match.params ? { params: Object.freeze({ ...match.params }) } : {}),
+    }),
+  );
   const matchedRouteIds =
-    state.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-
-  return {
-    ...state,
-    ...(hydrationScripts?.length
+    snapshot.matchedRouteIds ??
+    matches?.map(match => match.assetRouteId ?? match.routeId);
+  return Object.freeze({
+    ...snapshot,
+    ...(snapshot.hydrationScripts
+      ? { hydrationScripts: Object.freeze([...snapshot.hydrationScripts]) }
+      : {}),
+    ...(matchedRouteIds
+      ? { matchedRouteIds: Object.freeze([...matchedRouteIds]) }
+      : {}),
+    ...(matches ? { matches: Object.freeze(matches) } : {}),
+    ...(snapshot.errors
+      ? { errors: Object.freeze({ ...snapshot.errors }) }
+      : {}),
+    ...(snapshot.routerData
       ? {
-          hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-          hydrationScripts,
+          routerData: Object.freeze({
+            ...snapshot.routerData,
+            ...(snapshot.routerData.loaderData
+              ? {
+                  loaderData: Object.freeze({
+                    ...snapshot.routerData.loaderData,
+                  }),
+                }
+              : {}),
+            ...(snapshot.routerData.errors
+              ? { errors: Object.freeze({ ...snapshot.routerData.errors }) }
+              : {}),
+          }),
         }
       : {}),
-    ...(matchedRouteIds ? { matchedRouteIds } : {}),
+  });
+}
+
+/**
+ * Listeners per runtime context, so a consumer can react to the slot being
+ * filled in. A router provider publishes its instance during render - TanStack
+ * installs it when `RouterWrapper` renders - which is after anything that
+ * wraps the app has already evaluated. Without a notification those wrappers
+ * would hold a routerless view of the app for the rest of the session.
+ *
+ * Keyed weakly: the runtime context outlives neither the app nor this map.
+ */
+const routerRuntimeStateListeners = new WeakMap<object, Set<() => void>>();
+
+/**
+ * Observe the router runtime-state slot for the given runtime context.
+ * Returns an unsubscribe function; safe to call for a context that never
+ * receives a router.
+ */
+export function subscribeRouterRuntimeState(
+  runtimeContext: object,
+  listener: () => void,
+): () => void {
+  if (!runtimeContext || typeof runtimeContext !== 'object') {
+    return () => undefined;
+  }
+  let listeners = routerRuntimeStateListeners.get(runtimeContext);
+  if (!listeners) {
+    listeners = new Set();
+    routerRuntimeStateListeners.set(runtimeContext, listeners);
+  }
+  listeners.add(listener);
+  return () => {
+    listeners?.delete(listener);
   };
 }
 
-export function createRouterRuntimeState(
-  state: InternalRouterRuntimeState,
-): InternalRouterRuntimeState {
-  const hasSnapshotState =
-    Boolean(state.serverSnapshot) ||
-    Boolean(state.hydrationScript) ||
-    Boolean(state.hydrationScripts?.length) ||
-    Boolean(state.matchedRouteIds?.length) ||
-    Boolean(state.matches?.length);
-  const serverSnapshot = state.serverSnapshot
-    ? createRouterServerSnapshot({
-        ...state.serverSnapshot,
-        framework: state.serverSnapshot.framework ?? state.framework,
-        basename: state.serverSnapshot.basename ?? state.basename,
-        hydrationScript:
-          state.serverSnapshot.hydrationScript ?? state.hydrationScript,
-        hydrationScripts:
-          state.serverSnapshot.hydrationScripts ?? state.hydrationScripts,
-        matchedRouteIds:
-          state.serverSnapshot.matchedRouteIds ?? state.matchedRouteIds,
-        matches: state.serverSnapshot.matches ?? state.matches,
-      })
-    : hasSnapshotState
-      ? createRouterServerSnapshot({
-          framework: state.framework,
-          basename: state.basename,
-          hydrationScript: state.hydrationScript,
-          hydrationScripts: state.hydrationScripts,
-          matchedRouteIds: state.matchedRouteIds,
-          matches: state.matches,
-        })
-      : undefined;
-  const hydrationScripts = toHydrationScripts({
-    hydrationScript: state.hydrationScript ?? serverSnapshot?.hydrationScript,
-    hydrationScripts:
-      state.hydrationScripts ?? serverSnapshot?.hydrationScripts,
-  });
-  const matchedRouteIds =
-    state.matchedRouteIds ??
-    serverSnapshot?.matchedRouteIds ??
-    getMatchedRouteIdsFromMatches(state.matches);
+/** Contexts with a notification already scheduled, so a burst coalesces. */
+const pendingRouterRuntimeStateNotifications = new WeakSet<object>();
 
-  return {
-    ...state,
-    ...(hydrationScripts?.length
-      ? {
-          hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-          hydrationScripts,
-        }
-      : {}),
-    ...(matchedRouteIds ? { matchedRouteIds } : {}),
-    ...(serverSnapshot ? { serverSnapshot } : {}),
+function notifyRouterRuntimeState(runtimeContext: object) {
+  const listeners = routerRuntimeStateListeners.get(runtimeContext);
+  if (!listeners?.size) {
+    return;
+  }
+  if (pendingRouterRuntimeStateNotifications.has(runtimeContext)) {
+    return;
+  }
+  pendingRouterRuntimeStateNotifications.add(runtimeContext);
+  // Deferred deliberately. A router provider publishes its instance from
+  // inside its own render - `RouterWrapper` does - so calling observers
+  // synchronously would schedule an update on a component that is rendering,
+  // which React reports as "Cannot update a component while rendering a
+  // different component". Delivering after the current render lands keeps the
+  // notification correct and silent.
+  const deliver = () => {
+    pendingRouterRuntimeStateNotifications.delete(runtimeContext);
+    const current = routerRuntimeStateListeners.get(runtimeContext);
+    if (!current?.size) {
+      return;
+    }
+    for (const listener of [...current]) {
+      try {
+        listener();
+      } catch {
+        // One bad observer must not stop the router from being published.
+      }
+    }
   };
+  if (typeof queueMicrotask === 'function') {
+    queueMicrotask(deliver);
+  } else {
+    setTimeout(deliver, 0);
+  }
 }
 
 export function applyRouterRuntimeState<Context extends object>(
   runtimeContext: Context,
   state: InternalRouterRuntimeState,
 ) {
-  const normalized = createRouterRuntimeState(state);
-  routerRuntimeStateExtension.set(runtimeContext, normalized);
-  if (normalized.serverSnapshot) {
-    routerServerSnapshotExtension.set(
-      runtimeContext,
-      normalized.serverSnapshot,
-    );
+  const previous = routerRuntimeStateExtension.get(runtimeContext);
+  routerRuntimeStateExtension.set(runtimeContext, state);
+  // Only a change of identity is worth a re-render; `RouterWrapper` reapplies
+  // the same instance on every render of the app.
+  if (
+    previous?.instance !== state.instance ||
+    previous?.framework !== state.framework ||
+    previous?.navigation !== state.navigation
+  ) {
+    notifyRouterRuntimeState(runtimeContext);
   }
 
   return runtimeContext;
@@ -165,40 +193,24 @@ export function applyRouterServerPrepareResult<Context extends object>(
   runtimeContext: Context,
   result: RouterServerPrepareResult,
 ) {
-  const state = createRouterRuntimeState({
+  if (result.snapshot) {
+    routerServerSnapshotExtension.set(
+      runtimeContext,
+      createRouterServerSnapshot(result.snapshot),
+    );
+  }
+  return applyRouterRuntimeState(runtimeContext, {
     ...result.state,
     cleanup: result.cleanup ?? result.state.cleanup,
-    serverSnapshot: result.snapshot ?? result.state.serverSnapshot,
   });
-  applyRouterRuntimeState(runtimeContext, state);
-  return runtimeContext;
 }
 
 export function getRouterHydrationScripts(runtimeContext: object) {
-  const serverSnapshot = getRouterServerSnapshot(runtimeContext);
-  const runtimeState = getRouterRuntimeState(runtimeContext);
-  return (
-    serverSnapshot?.hydrationScripts ??
-    toHydrationScripts({
-      hydrationScript: serverSnapshot?.hydrationScript,
-    }) ??
-    runtimeState?.hydrationScripts ??
-    toHydrationScripts({
-      hydrationScript: runtimeState?.hydrationScript,
-    }) ??
-    []
-  );
+  return getRouterServerSnapshot(runtimeContext)?.hydrationScripts ?? [];
 }
 
 export function getRouterMatchedRouteIds(runtimeContext: object) {
-  const serverSnapshot = getRouterServerSnapshot(runtimeContext);
-  const runtimeState = getRouterRuntimeState(runtimeContext);
-  return (
-    serverSnapshot?.matchedRouteIds ??
-    getMatchedRouteIdsFromMatches(serverSnapshot?.matches) ??
-    runtimeState?.matchedRouteIds ??
-    getMatchedRouteIdsFromMatches(runtimeState?.matches)
-  );
+  return getRouterServerSnapshot(runtimeContext)?.matchedRouteIds;
 }
 
 export async function cleanupRouterRuntimeState(runtimeContext: object) {

package/src/routerStatePlugin.ts

@@ -1,8 +1,15 @@
+import type { createMemoryRouter } from '@modern-js/runtime-utils/router';
 import { createRouterPrefetchPolicy } from './routerPrefetchPolicy';
 import {
   applyRouterRuntimeState,
-  createRouterServerSnapshot,
+  applyRouterServerPrepareResult,
+  getRouterRuntimeState,
+  getRouterServerSnapshot,
 } from './routerState';
+import type {
+  RouterNavigationCapability,
+  RouterNavigationSnapshot,
+} from './routerStateTypes';
 
 type ReactRouterServerContext = {
   statusCode: number;
@@ -19,6 +26,47 @@ type RouterLifecycleEvent = {
   router?: unknown;
 };
 
+type PreparedRequest<RuntimeContext extends object = object> = {
+  runtimeContext: RuntimeContext;
+  routerResult?: {
+    statusCode?: number;
+    errors?: Record<string, unknown> | null;
+  };
+};
+
+export const ROUTER_CLEANUP_ERROR =
+  'An error occurs during router runtime cleanup';
+
+// Provider wrappers and application composition may share the same native API.
+// Install their common request policy once for that runtime instance.
+const installedRouterPolicies = new WeakSet<object>();
+
+function createReactRouterNavigation(
+  router: ReturnType<typeof createMemoryRouter>,
+  Link: RouterNavigationCapability['Link'],
+): RouterNavigationCapability {
+  let state: typeof router.state | undefined;
+  let snapshot: RouterNavigationSnapshot;
+  return {
+    Link,
+    getSnapshot() {
+      if (state !== router.state) {
+        state = router.state;
+        snapshot = {
+          location: state.location,
+          params: Object.assign(
+            {},
+            ...state.matches.map(match => match.params),
+          ),
+        };
+      }
+      return snapshot;
+    },
+    subscribe: listener => router.subscribe(listener),
+    navigate: (href, options) => router.navigate(href, options),
+  };
+}
+
 /** Install fork policy through lifecycle hooks supplied by the native owner. */
 export function createRouterStatePlugin<Hooks extends Record<string, unknown>>({
   registryHooks,
@@ -30,16 +78,56 @@ export function createRouterStatePlugin<Hooks extends Record<string, unknown>>({
     registryHooks,
     setup(api: {
       onBeforeRender: (callback: (context: object) => void) => unknown;
+      onRenderPrepared: (
+        callback: <RuntimeContext extends object>(
+          info: PreparedRequest<RuntimeContext>,
+        ) => PreparedRequest<RuntimeContext>,
+      ) => unknown;
+      onRequestEnd: (
+        callback: (info: { runtimeContext: object }) => Promise<void>,
+      ) => unknown;
       onAfterCreateRouter: (
         callback: (event: RouterLifecycleEvent) => void,
       ) => unknown;
     }) {
+      if (installedRouterPolicies.has(api)) {
+        return;
+      }
+      installedRouterPolicies.add(api);
       api.onBeforeRender(context => {
         const runtimeContext = context as {
           linkPrefetchPolicy?: ReturnType<typeof createRouterPrefetchPolicy>;
         };
         runtimeContext.linkPrefetchPolicy ??= createRouterPrefetchPolicy();
       });
+      api.onRenderPrepared(info => {
+        const snapshot = getRouterServerSnapshot(info.runtimeContext);
+        if (!snapshot) {
+          return info;
+        }
+        return {
+          ...info,
+          routerResult: {
+            statusCode: snapshot.statusCode ?? info.routerResult?.statusCode,
+            errors: snapshot.errors ?? info.routerResult?.errors,
+          },
+        };
+      });
+      api.onRequestEnd(async ({ runtimeContext }) => {
+        try {
+          await getRouterRuntimeState(runtimeContext)?.cleanup?.();
+        } catch (error) {
+          const { ssrContext } = runtimeContext as {
+            ssrContext?: {
+              onError: (error: unknown, message: string) => void;
+            };
+          };
+          if (!ssrContext) {
+            throw error;
+          }
+          ssrContext.onError(error, ROUTER_CLEANUP_ERROR);
+        }
+      });
       api.onAfterCreateRouter(event => {
         if (event.framework !== 'react-router') {
           return;
@@ -51,7 +139,7 @@ export function createRouterStatePlugin<Hooks extends Record<string, unknown>>({
           if (!routerContext) {
             return;
           }
-          const serverSnapshot = createRouterServerSnapshot({
+          const snapshot = {
             framework: event.framework,
             basename: event.basename,
             statusCode: routerContext.statusCode,
@@ -65,19 +153,27 @@ export function createRouterStatePlugin<Hooks extends Record<string, unknown>>({
                 ? [{ routeId: match.route.id }]
                 : [],
             ),
-          });
-          applyRouterRuntimeState(event.runtimeContext, {
-            framework: event.framework,
-            basename: event.basename,
-            instance: event.router,
-            matchedRouteIds: serverSnapshot.matchedRouteIds,
-            serverSnapshot,
+          };
+          applyRouterServerPrepareResult(event.runtimeContext, {
+            snapshot,
+            state: {
+              framework: event.framework,
+              basename: event.basename,
+              instance: event.router,
+            },
           });
         } else if (event.phase === 'client-create') {
+          const router = event.router as ReturnType<typeof createMemoryRouter>;
+          const { router: api } = event.runtimeContext as {
+            router?: { Link?: RouterNavigationCapability['Link'] };
+          };
           applyRouterRuntimeState(event.runtimeContext, {
             framework: event.framework,
             basename: event.basename,
-            instance: event.router,
+            instance: router,
+            ...(api?.Link
+              ? { navigation: createReactRouterNavigation(router, api.Link) }
+              : {}),
           });
         }
       });

package/src/routerStateTypes.ts

@@ -1,3 +1,5 @@
+import type React from 'react';
+
 export type BuiltInRouterFramework = 'react-router' | 'tanstack';
 
 export type RouterFramework = BuiltInRouterFramework | (string & {});
@@ -10,37 +12,65 @@ export interface RouterRouteMatchSnapshot {
 }
 
 export interface InternalRouterServerSnapshot {
-  framework?: RouterFramework;
-  basename?: string;
-  statusCode?: number;
-  errors?: Record<string, unknown>;
-  routerData?: {
-    loaderData?: Record<string, unknown>;
-    errors?: Record<string, unknown>;
+  readonly framework?: RouterFramework;
+  readonly basename?: string;
+  readonly statusCode?: number;
+  readonly errors?: Record<string, unknown>;
+  readonly routerData?: {
+    readonly loaderData?: Record<string, unknown>;
+    readonly errors?: Record<string, unknown>;
   };
-  hydrationScript?: string;
-  hydrationScripts?: string[];
-  matchedRouteIds?: string[];
-  matches?: RouterRouteMatchSnapshot[];
+  readonly hydrationScripts?: readonly string[];
+  readonly matchedRouteIds?: readonly string[];
+  readonly matches?: readonly RouterRouteMatchSnapshot[];
 }
 
 export interface InternalRouterRuntimeState {
   framework: RouterFramework;
   basename?: string;
   instance?: unknown;
-  hydrationScript?: string;
-  hydrationScripts?: string[];
-  matchedRouteIds?: string[];
-  matches?: RouterRouteMatchSnapshot[];
-  serverSnapshot?: InternalRouterServerSnapshot;
+  navigation?: RouterNavigationCapability;
   cleanup?: () => void | Promise<void>;
 }
 
 export interface RouterServerPrepareResult {
   state: InternalRouterRuntimeState;
   snapshot?: InternalRouterServerSnapshot;
-  redirect?: Response;
   cleanup?: () => void | Promise<void>;
 }
 
 export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';
+
+/** Provider-owned browser navigation. Consumers never inspect router internals. */
+export interface RouterNavigationSnapshot {
+  location: { pathname: string; search: string; hash: string };
+  params: Record<string, string>;
+}
+
+export interface RouterLinkTarget {
+  pathname: string;
+  href: string;
+  search?: Record<string, unknown>;
+  hash?: string;
+  hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+  prefetch?: 'intent' | 'render' | 'viewport' | 'none';
+  preload?: unknown;
+}
+
+export interface RouterNavigationCapability {
+  getSnapshot: () => RouterNavigationSnapshot;
+  subscribe: (listener: () => void) => () => void;
+  navigate: (
+    href: string,
+    options?: { replace?: boolean; state?: unknown },
+  ) => void | Promise<void>;
+  Link: React.ComponentType<{
+    to: string;
+    children?: React.ReactNode;
+    [key: string]: unknown;
+  }>;
+  createLinkProps?: (target: RouterLinkTarget) => {
+    to: string;
+    [key: string]: unknown;
+  };
+}

package/src/server-config/index.ts

@@ -1,2 +1,3 @@
 export type * from './bffRuntime';
+export type * from './serverSource';
 export type * from './serverTelemetry';

package/src/server-config/serverSource.ts

@@ -0,0 +1,23 @@
+/** Context passed to function items of a server `source.globalVars` chain. */
+export interface ServerGlobalVarsContext {
+  env: string;
+  target: 'web' | 'node' | 'web-worker';
+}
+
+export type ServerGlobalVars = Record<string, unknown>;
+
+type ServerGlobalVarsChainItem =
+  | ServerGlobalVars
+  | ((
+      config: ServerGlobalVars,
+      context: ServerGlobalVarsContext,
+    ) => ServerGlobalVars | void);
+
+/** Source options that server code reads from the application config. */
+export interface ServerSourceConfigExtension {
+  /**
+   * Compile-time constants replaced in server code, such as BFF handlers.
+   * Server code resolves the chain with `{ env: 'server', target: 'node' }`.
+   */
+  globalVars?: ServerGlobalVarsChainItem | ServerGlobalVarsChainItem[];
+}

package/dist/cjs/buildIdentity.js

@@ -1,73 +0,0 @@
-"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__);
-function readBuildValue(read, fallback) {
-    try {
-        return read();
-    } catch (error) {
-        if (null !== error && 'object' == typeof error && 'name' in error && 'ReferenceError' === error.name) return fallback;
-        throw error;
-    }
-}
-function resolveUltramodernBuildArtifact(artifact, readers) {
-    const buildMarker = readers ? readBuildValue(readers.buildMarker, artifact.deliveryUnit.buildMarker) : artifact.deliveryUnit.buildMarker;
-    const sourceRevision = readers ? readBuildValue(readers.sourceRevision, artifact.deliveryUnit.sourceRevision) : artifact.deliveryUnit.sourceRevision;
-    const identity = {
-        build: buildMarker,
-        buildMarker,
-        sourceRevision
-    };
-    return {
-        ...artifact,
-        deliveryUnit: {
-            ...artifact.deliveryUnit,
-            ...identity
-        },
-        surfaces: {
-            api: {
-                ...artifact.surfaces.api,
-                ...identity
-            },
-            ui: {
-                ...artifact.surfaces.ui,
-                ...identity
-            }
-        }
-    };
-}
-__webpack_require__.d(__webpack_exports__, {
-    resolveUltramodernBuildArtifact: ()=>resolveUltramodernBuildArtifact
-});
-exports.resolveUltramodernBuildArtifact = __webpack_exports__.resolveUltramodernBuildArtifact;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "resolveUltramodernBuildArtifact"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/buildIdentity.mjs

@@ -1,35 +0,0 @@
-function readBuildValue(read, fallback) {
-    try {
-        return read();
-    } catch (error) {
-        if (null !== error && 'object' == typeof error && 'name' in error && 'ReferenceError' === error.name) return fallback;
-        throw error;
-    }
-}
-function resolveUltramodernBuildArtifact(artifact, readers) {
-    const buildMarker = readers ? readBuildValue(readers.buildMarker, artifact.deliveryUnit.buildMarker) : artifact.deliveryUnit.buildMarker;
-    const sourceRevision = readers ? readBuildValue(readers.sourceRevision, artifact.deliveryUnit.sourceRevision) : artifact.deliveryUnit.sourceRevision;
-    const identity = {
-        build: buildMarker,
-        buildMarker,
-        sourceRevision
-    };
-    return {
-        ...artifact,
-        deliveryUnit: {
-            ...artifact.deliveryUnit,
-            ...identity
-        },
-        surfaces: {
-            api: {
-                ...artifact.surfaces.api,
-                ...identity
-            },
-            ui: {
-                ...artifact.surfaces.ui,
-                ...identity
-            }
-        }
-    };
-}
-export { resolveUltramodernBuildArtifact };