@bleedingdev/modern-js-renderer-solid 0.0.0-stage → 3.9.3-ultramodern.2

package/src/i18n/index.ts

@@ -0,0 +1,35 @@
+export {
+  createRequestLanguageRedirect,
+  detectRequestLanguage,
+  languageFromPathname,
+  type RequestLanguageDetection,
+  type ResolvedRequestLanguage,
+  type ResolveRequestLanguageOptions,
+  resolveRequestLanguage,
+} from '@modern-js/i18n-runtime-extensions/request-language';
+export {
+  createI18nSsrHandoffInlineData,
+  I18N_SSR_HANDOFF_ELEMENT_ID,
+  type I18nSsrHandoffPayload,
+  type I18nSsrHandoffResources,
+  readI18nSsrHandoff,
+} from '@modern-js/i18n-runtime-extensions/ssrLanguageHandoff';
+// Renderer-neutral pieces an application entry composes with these bindings.
+export {
+  type CreateI18nUrlRewriteOptions,
+  createI18nUrlRewrite,
+  type I18nLocationRewrite,
+} from '@modern-js/i18n-runtime-extensions/urlRewrite';
+export { I18nContext } from './context';
+export { I18nProvider, type I18nProviderProps } from './I18nProvider';
+export {
+  LocalizedLink,
+  type LocalizedLinkProps,
+  useIsLocalizedActive,
+} from './LocalizedLink';
+export {
+  createLatestLanguageSync,
+  type SolidLatestLanguageSyncOptions,
+} from './languageSync';
+export type { I18nContextValue, I18nInstanceLike } from './types';
+export { type UseI18nReturn, useI18n } from './useI18n';

package/src/i18n/languageSync.ts

@@ -0,0 +1,113 @@
+import {
+  createLatestLanguageSyncBinding,
+  type LanguageSyncFailure,
+  type LanguageSyncPolicy,
+} from '@modern-js/i18n-runtime-extensions/language-sync/controller';
+import * as Solid from 'solid-js';
+
+export interface SolidLatestLanguageSyncOptions<TTarget extends object> {
+  /** The sync target, e.g. the per-request i18next instance. Reactive. */
+  target: Solid.Accessor<TTarget | undefined>;
+  /** The language the URL (or other source of truth) currently wants. Reactive. */
+  desiredLanguage: Solid.Accessor<string | undefined>;
+  changeLanguage: (
+    target: TTarget,
+    language: string,
+  ) => PromiseLike<unknown> | unknown;
+  commitLanguage: (target: TTarget, language: string) => void;
+  /** @default () => true */
+  enabled?: Solid.Accessor<boolean>;
+  policy?: LanguageSyncPolicy;
+  readLanguage?: (target: TTarget) => string | undefined;
+  reportFailure?: (failure: LanguageSyncFailure) => void;
+}
+
+/**
+ * Solid binding over the fork's renderer-neutral `Coordinator`/`Binding` pair
+ * (`@modern-js/i18n-runtime-extensions`'s `createLatestLanguageSyncBinding`):
+ * the same "latest intent wins, retry with backoff, report terminal failure"
+ * policy the React `useLatestLanguageSync` hook drives.
+ *
+ * Solid 2's `createEffect` has a compute/effect split (`compute(prev)` is
+ * tracked, `effect(next)` runs imperatively and may return a cleanup run
+ * before the next invocation or on disposal) rather than Solid 1's
+ * single-phase `createEffect(fn)` — reactive reads happen in `compute`,
+ * subscriptions happen in `effect`, which returns their cleanup.
+ *
+ * Returns a function to request a language change (e.g. from a language
+ * switcher), independent of the reactive `desiredLanguage` source.
+ */
+export function createLatestLanguageSync<TTarget extends object>(
+  options: SolidLatestLanguageSyncOptions<TTarget>,
+): (language: string) => void {
+  const binding = createLatestLanguageSyncBinding<TTarget>(options.policy);
+  const enabled = () => options.enabled?.() ?? true;
+
+  Solid.createEffect(
+    () => undefined,
+    () => {
+      binding.updateCallbacks({
+        changeLanguage: options.changeLanguage,
+        commitLanguage: options.commitLanguage,
+        readLanguage: options.readLanguage,
+        reportFailure: options.reportFailure,
+      });
+    },
+  );
+
+  Solid.createEffect(
+    () => (enabled() ? options.target() : undefined),
+    target => {
+      if (!target) {
+        return;
+      }
+      binding.activate(target);
+      return () => binding.deactivate();
+    },
+  );
+
+  type SyncTargetTuple<TTarget> = readonly [
+    target: TTarget | undefined,
+    desiredLanguage: string | undefined,
+  ];
+
+  Solid.createEffect(
+    (): SyncTargetTuple<TTarget> =>
+      enabled()
+        ? [options.target(), options.desiredLanguage()]
+        : [undefined, undefined],
+    ([target, desiredLanguage]) => {
+      if (!target || !desiredLanguage) {
+        binding.clearRequest();
+        return;
+      }
+      binding.request(desiredLanguage);
+    },
+  );
+
+  Solid.createEffect(
+    (): SyncTargetTuple<TTarget> =>
+      enabled() && typeof window !== 'undefined'
+        ? [options.target(), options.desiredLanguage()]
+        : [undefined, undefined],
+    ([target, desiredLanguage]) => {
+      if (!target || !desiredLanguage) {
+        return;
+      }
+      const retryCurrentIntent = () => binding.request(desiredLanguage);
+      const retryVisibleIntent = () => {
+        if (document.visibilityState === 'visible') {
+          retryCurrentIntent();
+        }
+      };
+      window.addEventListener('online', retryCurrentIntent);
+      document.addEventListener('visibilitychange', retryVisibleIntent);
+      return () => {
+        window.removeEventListener('online', retryCurrentIntent);
+        document.removeEventListener('visibilitychange', retryVisibleIntent);
+      };
+    },
+  );
+
+  return (language: string) => binding.request(language);
+}

package/src/i18n/types.ts

@@ -0,0 +1,35 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+
+/**
+ * The slice of an i18next-shaped instance this binding needs. Deliberately
+ * not `@modern-js/plugin-i18n`'s `I18nInstance`: that type is intentionally
+ * narrowed (no index signature, non-overloaded methods — see plugin-i18n's
+ * fork notes) and, more importantly, the plugin package's peer dependencies
+ * require React/ReactDOM, which a Solid-only application must never need to
+ * install. `on`/`off` are real i18next `EventEmitter` methods this interface
+ * adds back for the reactive `languageChanged` subscription.
+ */
+export interface I18nInstanceLike {
+  language: string;
+  t(key: string | string[], options?: Record<string, unknown>): string;
+  changeLanguage?(lng?: string): Promise<unknown> | unknown;
+  on?(event: 'languageChanged', callback: (lng: string) => void): void;
+  off?(event: 'languageChanged', callback: (lng: string) => void): void;
+  /** SSR per-request isolation: the server clones a base instance per request. */
+  cloneInstance?(options?: Record<string, unknown>): I18nInstanceLike;
+}
+
+export interface I18nContextValue {
+  /** Per-request instance. Never a module-level singleton. */
+  instance: I18nInstanceLike;
+  languages: readonly string[];
+  localisedUrls?: LocalisedUrlsOption;
+  /**
+   * Reactive current language, owned by `I18nProvider`. Every consumer
+   * (`useI18n`, `LocalizedLink`) reads this single shared signal rather than
+   * each subscribing to `instance`'s `languageChanged` event independently —
+   * `instance.language` is a plain mutable field, not itself reactive, so
+   * reading it directly would silently never update a Solid computation.
+   */
+  language: () => string;
+}

package/src/i18n/useI18n.ts

@@ -0,0 +1,121 @@
+import {
+  configuredLanguage,
+  localizePath,
+} from '@modern-js/i18n-runtime-extensions/paths';
+import { languageFromPathname } from '@modern-js/i18n-runtime-extensions/request-language';
+import * as Solid from 'solid-js';
+import { useRouter } from '../router';
+import { I18nContext } from './context';
+import type { I18nInstanceLike } from './types';
+
+export interface UseI18nReturn {
+  /** Reactive: re-evaluates when i18next fires `languageChanged`. */
+  t: I18nInstanceLike['t'];
+  /** Reactive current language accessor, shared with every other consumer. */
+  language: Solid.Accessor<string>;
+  languages: readonly string[];
+  /** The raw per-request instance, for advanced use (namespaces, `exists`, ...). */
+  instance: I18nInstanceLike;
+  /**
+   * Switches the i18next instance's language. Inside a router, also replaces
+   * the current URL with the localized path for the new language.
+   */
+  changeLanguage: (language: string) => Promise<void>;
+}
+
+/**
+ * Language switches per instance run one at a time: a switch that a newer
+ * one has superseded before it starts is skipped, so no two switches ever
+ * interleave their language loads and navigations.
+ */
+const languageSwitches = new WeakMap<
+  object,
+  { latest: number; queue: Promise<void> }
+>();
+
+/**
+ * Must render under `I18nProvider`; `useContext` on the default-less
+ * `I18nContext` throws `ContextNotFoundError` otherwise, rather than
+ * silently reading a fallback instance. The reactive `language` signal lives
+ * on the provider (one `languageChanged` subscription per request, shared by
+ * every consumer) — this hook just reads it.
+ */
+export function useI18n(): UseI18nReturn {
+  const context = Solid.useContext(I18nContext);
+  const { instance, languages, localisedUrls, language } = context;
+
+  const t: I18nInstanceLike['t'] = (key, options) => {
+    // Read the signal so every consumer of `t` re-renders on language change,
+    // even though `instance.t` itself is not reactive.
+    language();
+    return instance.t(key, options);
+  };
+
+  const router = useRouter({ warn: false });
+
+  const changeLanguage = (requested: string): Promise<void> => {
+    // i18next would fall back silently and the URL would gain an unknown
+    // segment. An unsupported request is rejected before it supersedes any
+    // queued switch.
+    let nextLanguage: string;
+    try {
+      nextLanguage = configuredLanguage(requested, languages);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const state = languageSwitches.get(instance) ?? {
+      latest: 0,
+      queue: Promise.resolve(),
+    };
+    languageSwitches.set(instance, state);
+    const generation = ++state.latest;
+    const run = state.queue.then(async () => {
+      if (state.latest !== generation) return;
+      // Earlier switches have settled, so this is the language the current
+      // URL was committed with.
+      const committed = instance.language;
+      // The public URL carries the locale. Under the i18n URL rewrite the
+      // router's own location is canonical and has none.
+      const publicLanguage = () =>
+        router
+          ? languageFromPathname(
+              new URL(router.state.location.publicHref, 'http://localhost')
+                .pathname,
+              languages,
+              router.options.basepath,
+            )
+          : undefined;
+      // A failed, blocked or redirected switch leaves the page on some URL;
+      // the language follows that URL's locale, or the committed language on
+      // a URL without one.
+      const reconcile = async () => {
+        const language = publicLanguage() ?? committed;
+        if (instance.language !== language)
+          await instance.changeLanguage?.(language);
+      };
+      try {
+        await instance.changeLanguage?.(nextLanguage);
+      } catch (error) {
+        await reconcile();
+        throw error;
+      }
+      if (!router) return;
+      // The full href keeps the query and fragment across the language switch.
+      const href = localizePath(router.state.location.href, nextLanguage, {
+        languages: [...languages],
+        localisedUrls,
+      });
+      try {
+        await router.navigate({ to: '.', href, replace: true });
+      } catch (error) {
+        await reconcile();
+        throw error;
+      }
+      if (publicLanguage() !== nextLanguage) await reconcile();
+    });
+    state.queue = run.catch(() => {});
+    return run;
+  };
+
+  return { t, language, languages, instance, changeLanguage };
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+/** This entry contains identity only. Select client, router or server explicitly. */
+export const SOLID_RENDERER_PROFILE = {
+  renderer: 'solid',
+  solid: '2.0.0-rc.13',
+  web: '2.0.0-rc.13',
+  router: '@modern-js/renderer-solid/router@3.8.3',
+  routerSource: '4fbd65c5c3b40be87a6248867c22021c1c19bba8',
+  routerCore: '1.171.34',
+  history: '1.162.4',
+  publicRouteData: {
+    containers: ['plain-record', 'null-record', 'array'],
+    values: 'canonical-scalars',
+    deferred: 'checked-top-level-native-promises',
+    mutation: 'immutable-public-snapshot',
+    unsupported: ['Date', 'RegExp', 'Map', 'Set', 'AsyncIterable'],
+  },
+  publicContext: {
+    source: 'managed-constructor-route-context-and-before-load',
+    providerOverrides: 'unsupported',
+  },
+  nativePromiseMetadata: {
+    runtime: '2.0.0-rc.13',
+    fields: ['s', 'v'],
+    status: [0, 1, 2],
+    handle: 'sealed-with-checked-metadata',
+  },
+  nativeRegistry: {
+    source: 'managed-router-match-transfer',
+    rawRejectedMatchInjection: 'unsupported',
+  },
+  nativeRequestContext: {
+    scope: 'complete-native-request-handler',
+    event: 'one-per-request-session',
+  },
+  nativeResponseHead: {
+    statusText: 'fetch-response-status-text',
+    terminalOutcome: 'authoritative',
+    cache: 'intersect-with-session-policy',
+  },
+  dataHttpTransport: 'renderer-core-rich-public-data',
+} as const;

package/src/manifest.ts

@@ -0,0 +1,337 @@
+import type { NativeCompilerArtifacts } from '@modern-js/renderer-core/adapter';
+import {
+  nativeModuleManifestFilename,
+  type RendererIdentity,
+  readRendererIdentity,
+} from '@modern-js/renderer-core/identity';
+
+export const SOLID_COMPILER_VERSION = '2.0.0-rc.13';
+export function solidModuleManifestFilename(entryName: string): string {
+  return nativeModuleManifestFilename('solid', entryName);
+}
+
+/** The compiler's structural JSON boundary matches native Solid AssetManifest. */
+interface SolidPreloadAttributes {
+  type?: string;
+  crossorigin?: '' | true | 'anonymous' | 'use-credentials';
+  integrity?: string;
+  referrerpolicy?:
+    | 'no-referrer'
+    | 'no-referrer-when-downgrade'
+    | 'origin'
+    | 'origin-when-cross-origin'
+    | 'same-origin'
+    | 'strict-origin'
+    | 'strict-origin-when-cross-origin'
+    | 'unsafe-url';
+  fetchpriority?: 'high' | 'low' | 'auto';
+  media?: string;
+}
+
+export type SolidPreloadLink = SolidPreloadAttributes &
+  (
+    | {
+        href: string;
+        as: 'fetch' | 'font' | 'script' | 'style' | 'track';
+        imagesrcset?: never;
+        imagesizes?: never;
+      }
+    | { href: string; as: 'image'; imagesrcset?: string; imagesizes?: string }
+    | { href?: never; as: 'image'; imagesrcset: string; imagesizes?: string }
+  );
+
+export interface SolidAssetChunk {
+  file: string;
+  css?: string[];
+  imports?: string[];
+  isEntry?: boolean;
+  preloads?: SolidPreloadLink[];
+}
+
+export type SolidAssetManifest = Record<string, SolidAssetChunk> & {
+  _base?: string;
+};
+
+export interface SolidModuleManifest {
+  schemaVersion: 1;
+  renderer: 'solid';
+  compilerVersion: typeof SOLID_COMPILER_VERSION;
+  /** The shared source-build identity owner stamps this before runtime use. */
+  rendererIdentity: RendererIdentity;
+  modules: SolidAssetManifest;
+}
+
+function requireRecord(
+  value: unknown,
+  description: string,
+): Record<string, unknown> {
+  if (
+    !value ||
+    typeof value !== 'object' ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  ) {
+    throw new Error(`Invalid Solid module manifest ${description}`);
+  }
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== 'string' || !descriptor || !('value' in descriptor)) {
+      throw new Error(
+        `Invalid Solid module manifest ${description}: data properties are required`,
+      );
+    }
+  }
+  return value as Record<string, unknown>;
+}
+
+function requireArray(
+  value: unknown,
+  description: string,
+): asserts value is unknown[] {
+  if (
+    !Array.isArray(value) ||
+    Object.getPrototypeOf(value) !== Array.prototype
+  ) {
+    throw new Error(
+      `Invalid Solid module manifest ${description}: an array is required`,
+    );
+  }
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (
+      typeof key !== 'string' ||
+      (key !== 'length' && !/^(0|[1-9]\d*)$/.test(key)) ||
+      !descriptor ||
+      !('value' in descriptor)
+    ) {
+      throw new Error(
+        `Invalid Solid module manifest ${description}: array data properties are required`,
+      );
+    }
+  }
+}
+
+function requireStrings(
+  value: unknown,
+  description: string,
+): asserts value is string[] {
+  requireArray(value, description);
+  for (let index = 0; index < value.length; index++) {
+    if (typeof value[index] !== 'string' || !value[index]) {
+      throw new Error(
+        `Invalid Solid module manifest ${description}: nonempty strings are required`,
+      );
+    }
+  }
+}
+
+/** Validate the same path concatenation used by the native rc13 asset resolver. */
+function validateAssetUrl(base: string | undefined, file: string): void {
+  const prefix = base || '/';
+  const joined = /^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(file)
+    ? file
+    : `${prefix.endsWith('/') ? prefix : `${prefix}/`}${file.startsWith('/') ? file.slice(1) : file}`;
+  try {
+    new URL(joined, 'https://manifest.invalid/');
+  } catch (cause) {
+    throw new Error(`Invalid Solid module manifest asset URL: ${file}`, {
+      cause,
+    });
+  }
+}
+
+function validatePreload(value: unknown, base: string | undefined): void {
+  const link = requireRecord(value, 'preload');
+  if (
+    !['fetch', 'font', 'image', 'script', 'style', 'track'].includes(
+      link.as as string,
+    )
+  ) {
+    throw new Error('Invalid Solid module manifest preload destination');
+  }
+  if (link.href !== undefined) {
+    if (typeof link.href !== 'string' || !link.href) {
+      throw new Error('Invalid Solid module manifest preload href');
+    }
+    validateAssetUrl(base, link.href);
+  }
+  if (link.as === 'image') {
+    if (
+      link.imagesrcset !== undefined &&
+      (typeof link.imagesrcset !== 'string' || !link.imagesrcset)
+    ) {
+      throw new Error('Invalid Solid module manifest image preload source set');
+    }
+    if (link.href === undefined && link.imagesrcset === undefined) {
+      throw new Error('Invalid Solid module manifest image preload source');
+    }
+    if (link.imagesizes !== undefined && typeof link.imagesizes !== 'string') {
+      throw new Error('Invalid Solid module manifest image preload sizes');
+    }
+  } else if (
+    link.href === undefined ||
+    link.imagesrcset !== undefined ||
+    link.imagesizes !== undefined
+  ) {
+    throw new Error('Invalid Solid module manifest preload source');
+  }
+  for (const key of ['type', 'integrity', 'media']) {
+    if (link[key] !== undefined && typeof link[key] !== 'string') {
+      throw new Error(`Invalid Solid module manifest preload ${key}`);
+    }
+  }
+  const enumerated: Record<string, readonly unknown[]> = {
+    crossorigin: ['', true, 'anonymous', 'use-credentials'],
+    fetchpriority: ['high', 'low', 'auto'],
+    referrerpolicy: [
+      'no-referrer',
+      'no-referrer-when-downgrade',
+      'origin',
+      'origin-when-cross-origin',
+      'same-origin',
+      'strict-origin',
+      'strict-origin-when-cross-origin',
+      'unsafe-url',
+    ],
+  };
+  for (const [key, values] of Object.entries(enumerated)) {
+    if (link[key] !== undefined && !values.includes(link[key])) {
+      throw new Error(`Invalid Solid module manifest preload ${key}`);
+    }
+  }
+}
+
+function assertCurrentIdentity(
+  manifest: Record<string, unknown>,
+  expectedIdentity: RendererIdentity,
+): void {
+  if (!manifest.rendererIdentity || expectedIdentity.renderer !== 'solid') {
+    throw new Error(
+      'Solid module manifest requires the current Solid application build identity.',
+    );
+  }
+  try {
+    readRendererIdentity(manifest.rendererIdentity, expectedIdentity);
+  } catch (cause) {
+    throw new Error(
+      'Stale Solid module manifest identity. Serve the manifest and hydration assets from the same application build.',
+      { cause },
+    );
+  }
+}
+
+function readSolidModuleManifest(
+  value: object,
+  expectedIdentity: RendererIdentity,
+): SolidModuleManifest {
+  const manifest = requireRecord(value, 'envelope');
+  if (
+    manifest.schemaVersion !== 1 ||
+    manifest.renderer !== 'solid' ||
+    manifest.compilerVersion !== SOLID_COMPILER_VERSION
+  ) {
+    throw new Error(
+      `Solid module manifest compiler ABI mismatch. Rebuild with @solidjs/compiler ${SOLID_COMPILER_VERSION}.`,
+    );
+  }
+  assertCurrentIdentity(manifest, expectedIdentity);
+  if (
+    !manifest.modules ||
+    typeof manifest.modules !== 'object' ||
+    Array.isArray(manifest.modules)
+  ) {
+    throw new Error(
+      'Solid module manifest has no module inventory. Rebuild the application.',
+    );
+  }
+  const modules = requireRecord(manifest.modules, 'module inventory');
+  if (modules._base !== undefined && typeof modules._base !== 'string') {
+    throw new Error('Invalid Solid module manifest asset base');
+  }
+  const base = modules._base as string | undefined;
+  for (const [key, value] of Object.entries(modules)) {
+    if (key === '_base') continue;
+    const chunk = requireRecord(value, `chunk ${key}`);
+    if (typeof chunk.file !== 'string' || !chunk.file) {
+      throw new Error(
+        `Invalid Solid module manifest chunk ${key}: a nonempty file is required`,
+      );
+    }
+    validateAssetUrl(base, chunk.file);
+    for (const field of ['css', 'imports']) {
+      if (chunk[field] !== undefined)
+        requireStrings(chunk[field], `${key}.${field}`);
+    }
+    for (const file of (chunk.css as string[] | undefined) ?? [])
+      validateAssetUrl(base, file);
+    if (chunk.isEntry !== undefined && typeof chunk.isEntry !== 'boolean') {
+      throw new Error(
+        `Invalid Solid module manifest chunk ${key}: isEntry must be boolean`,
+      );
+    }
+    if (chunk.preloads !== undefined) {
+      requireArray(chunk.preloads, `${key}.preloads`);
+      for (const preload of chunk.preloads) validatePreload(preload, base);
+    }
+  }
+  for (const [key, value] of Object.entries(modules)) {
+    if (key === '_base') continue;
+    for (const dependency of (value as SolidAssetChunk).imports ?? []) {
+      if (dependency === '_base' || !Object.hasOwn(modules, dependency)) {
+        throw new Error(
+          `Solid module manifest chunk ${key} imports missing own chunk ${dependency}`,
+        );
+      }
+    }
+  }
+  return manifest as unknown as SolidModuleManifest;
+}
+
+/** A build's manifest is an immutable artifact: its shape is checked once. */
+const validatedManifests = new WeakMap<object, SolidModuleManifest>();
+
+export function validateSolidModuleManifest(
+  value: unknown,
+  expectedIdentity: RendererIdentity,
+  requiredModuleKeys: readonly string[] = [],
+): SolidModuleManifest {
+  if (!value || typeof value !== 'object') {
+    throw new Error(
+      'Missing Solid module manifest. Rebuild the application before SSR or hydration.',
+    );
+  }
+  let manifest = validatedManifests.get(value);
+  if (manifest) {
+    assertCurrentIdentity(
+      manifest as unknown as Record<string, unknown>,
+      expectedIdentity,
+    );
+  } else {
+    manifest = readSolidModuleManifest(value, expectedIdentity);
+    validatedManifests.set(value, manifest);
+  }
+  for (const key of requiredModuleKeys) {
+    if (key === '_base' || !Object.hasOwn(manifest.modules, key)) {
+      throw new Error(
+        `Solid module manifest is missing ${key}. Rebuild the application before SSR or hydration.`,
+      );
+    }
+  }
+  return manifest;
+}
+
+/**
+ * The compiler artifact ABI. It lives in this runtime module, not in the
+ * build-only `./plugin`, because the production server validates manifests
+ * with it and deployments trace it from there.
+ */
+export const compilerArtifacts: NativeCompilerArtifacts = {
+  clientManifestFile: solidModuleManifestFilename,
+  async validateClientManifest(value, identity) {
+    return { nativeManifest: validateSolidModuleManifest(value, identity) };
+  },
+  isMutableDevelopmentAsset(filename, entryNames) {
+    return entryNames.some(
+      entry => filename === solidModuleManifestFilename(entry),
+    );
+  },
+};