@fluojs/react 0.1.0

package/dist/vite/asset-utils.d.ts

@@ -0,0 +1,57 @@
+import type { ReactAssetMap, ReactBootstrapAsset } from '../server-entry.js';
+import type { DependencyGraph, ParsedManifest, ParsedManifestEntry } from './types.js';
+/**
+ * Collects the import graph for a client manifest entry with dependencies first.
+ *
+ * @param manifest Parsed Vite manifest.
+ * @param rootEntry Browser hydration entry.
+ * @returns Ordered graph entries and missing-import diagnostics.
+ */
+export declare function collectDependencyGraph(manifest: ParsedManifest, rootEntry: ParsedManifestEntry): DependencyGraph;
+/**
+ * Resolves a Vite manifest file path to a public URL.
+ *
+ * @param file Manifest file path or already absolute URL.
+ * @param base Optional Vite base path.
+ * @returns Public URL suitable for emitted HTML or asset maps.
+ */
+export declare function createPublicUrl(file: string, base: string | undefined): string;
+/**
+ * Checks whether a Vite output path is a JavaScript chunk supported by the React Vite bridge.
+ *
+ * @param file Manifest output file path.
+ * @returns `true` when the output path has a supported JavaScript extension.
+ */
+export declare function isJavaScriptOutput(file: string): boolean;
+/**
+ * Clones bootstrap assets while preserving first-seen order by source URL.
+ *
+ * @param assets Bootstrap assets to clone and deduplicate.
+ * @returns Defensive bootstrap asset snapshot.
+ */
+export declare function cloneUniqueBootstrapAssets(assets: readonly ReactBootstrapAsset[]): readonly ReactBootstrapAsset[];
+/**
+ * Collects stylesheet URLs in dependency order with duplicate removal.
+ *
+ * @param entries Dependency-ordered client graph entries.
+ * @param base Optional Vite base path.
+ * @returns Stylesheet URLs ordered before hydration scripts.
+ */
+export declare function collectCssUrls(entries: readonly ParsedManifestEntry[], base: string | undefined): readonly string[];
+/**
+ * Collects JavaScript module URLs in dependency order.
+ *
+ * @param entries Dependency-ordered client graph entries.
+ * @param base Optional Vite base path.
+ * @returns Public JavaScript module URLs.
+ */
+export declare function collectModuleUrls(entries: readonly ParsedManifestEntry[], base: string | undefined): readonly string[];
+/**
+ * Creates a defensive asset map snapshot from every manifest file, stylesheet, and static asset.
+ *
+ * @param manifest Parsed Vite manifest.
+ * @param base Optional Vite base path.
+ * @returns Asset map compatible with the stable React server entry contract.
+ */
+export declare function createAssetMap(manifest: ParsedManifest, base: string | undefined): ReactAssetMap;
+//# sourceMappingURL=asset-utils.d.ts.map

package/dist/vite/asset-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-utils.d.ts","sourceRoot":"","sources":["../../src/vite/asset-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAkC,MAAM,oBAAoB,CAAC;AAI7G,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAMvF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,mBAAmB,GAC7B,eAAe,CAkCjB;AAcD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAM9E;AAcD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIxD;AAkBD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,mBAAmB,EAAE,GACrC,SAAS,mBAAmB,EAAE,CAgBhC;AAaD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,SAAS,MAAM,EAAE,CAanB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,SAAS,MAAM,EAAE,CAEnB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,CA2BhG"}

package/dist/vite/asset-utils.js

@@ -0,0 +1,184 @@
+import { ABSOLUTE_URL_PATTERN, JAVASCRIPT_OUTPUT_EXTENSIONS } from './types.js';
+import { createMalformedDiagnostic } from './diagnostics.js';
+function readOwnEntry(manifest, entryId) {
+  return Object.hasOwn(manifest, entryId) ? manifest[entryId] : undefined;
+}
+
+/**
+ * Collects the import graph for a client manifest entry with dependencies first.
+ *
+ * @param manifest Parsed Vite manifest.
+ * @param rootEntry Browser hydration entry.
+ * @returns Ordered graph entries and missing-import diagnostics.
+ */
+export function collectDependencyGraph(manifest, rootEntry) {
+  const diagnostics = [];
+  const entries = [];
+  const visited = new Set();
+  function visit(entry) {
+    if (visited.has(entry.id)) {
+      return;
+    }
+    visited.add(entry.id);
+    for (const importId of entry.imports) {
+      const importedEntry = readOwnEntry(manifest, importId);
+      if (importedEntry === undefined) {
+        diagnostics.push(createMalformedDiagnostic(`React Vite manifest entry "${entry.id}" imports missing chunk "${importId}".`, `${entry.id}.imports`));
+        continue;
+      }
+      visit(importedEntry);
+    }
+    entries.push(entry);
+  }
+  visit(rootEntry);
+  return {
+    diagnostics,
+    entries
+  };
+}
+function normalizeBase(base) {
+  if (base === undefined) {
+    return '/';
+  }
+  if (base === '') {
+    return '';
+  }
+  return base.endsWith('/') ? base : `${base}/`;
+}
+
+/**
+ * Resolves a Vite manifest file path to a public URL.
+ *
+ * @param file Manifest file path or already absolute URL.
+ * @param base Optional Vite base path.
+ * @returns Public URL suitable for emitted HTML or asset maps.
+ */
+export function createPublicUrl(file, base) {
+  if (file.startsWith('/') || ABSOLUTE_URL_PATTERN.test(file)) {
+    return file;
+  }
+  return `${normalizeBase(base)}${file}`;
+}
+function stripUrlSuffix(file) {
+  const queryIndex = file.indexOf('?');
+  const hashIndex = file.indexOf('#');
+  const suffixIndexes = [queryIndex, hashIndex].filter(index => index >= 0);
+  if (suffixIndexes.length === 0) {
+    return file;
+  }
+  return file.slice(0, Math.min(...suffixIndexes));
+}
+
+/**
+ * Checks whether a Vite output path is a JavaScript chunk supported by the React Vite bridge.
+ *
+ * @param file Manifest output file path.
+ * @returns `true` when the output path has a supported JavaScript extension.
+ */
+export function isJavaScriptOutput(file) {
+  const pathname = stripUrlSuffix(file);
+  return JAVASCRIPT_OUTPUT_EXTENSIONS.some(extension => pathname.endsWith(extension));
+}
+function getBootstrapAssetSource(asset) {
+  return typeof asset === 'string' ? asset : asset.src;
+}
+function cloneBootstrapDescriptor(asset) {
+  return {
+    ...(asset.crossOrigin !== undefined ? {
+      crossOrigin: asset.crossOrigin
+    } : {}),
+    ...(asset.integrity !== undefined ? {
+      integrity: asset.integrity
+    } : {}),
+    src: asset.src
+  };
+}
+function cloneBootstrapAsset(asset) {
+  return typeof asset === 'string' ? asset : cloneBootstrapDescriptor(asset);
+}
+
+/**
+ * Clones bootstrap assets while preserving first-seen order by source URL.
+ *
+ * @param assets Bootstrap assets to clone and deduplicate.
+ * @returns Defensive bootstrap asset snapshot.
+ */
+export function cloneUniqueBootstrapAssets(assets) {
+  const cloned = [];
+  const seenSources = new Set();
+  for (const asset of assets) {
+    const source = getBootstrapAssetSource(asset);
+    if (seenSources.has(source)) {
+      continue;
+    }
+    seenSources.add(source);
+    cloned.push(cloneBootstrapAsset(asset));
+  }
+  return cloned;
+}
+function appendUniqueUrls(target, seen, urls) {
+  for (const url of urls) {
+    if (seen.has(url)) {
+      continue;
+    }
+    seen.add(url);
+    target.push(url);
+  }
+}
+
+/**
+ * Collects stylesheet URLs in dependency order with duplicate removal.
+ *
+ * @param entries Dependency-ordered client graph entries.
+ * @param base Optional Vite base path.
+ * @returns Stylesheet URLs ordered before hydration scripts.
+ */
+export function collectCssUrls(entries, base) {
+  const css = [];
+  const seen = new Set();
+  for (const entry of entries) {
+    appendUniqueUrls(css, seen, entry.css.map(file => createPublicUrl(file, base)));
+  }
+  return css;
+}
+
+/**
+ * Collects JavaScript module URLs in dependency order.
+ *
+ * @param entries Dependency-ordered client graph entries.
+ * @param base Optional Vite base path.
+ * @returns Public JavaScript module URLs.
+ */
+export function collectModuleUrls(entries, base) {
+  return entries.map(entry => createPublicUrl(entry.file, base));
+}
+
+/**
+ * Creates a defensive asset map snapshot from every manifest file, stylesheet, and static asset.
+ *
+ * @param manifest Parsed Vite manifest.
+ * @param base Optional Vite base path.
+ * @returns Asset map compatible with the stable React server entry contract.
+ */
+export function createAssetMap(manifest, base) {
+  const assetMap = {};
+  Object.setPrototypeOf(assetMap, null);
+  for (const [entryId, entry] of Object.entries(manifest)) {
+    const publicFile = createPublicUrl(entry.file, base);
+    assetMap[entryId] = publicFile;
+    assetMap[entry.file] = publicFile;
+    if (entry.name !== undefined) {
+      assetMap[entry.name] = publicFile;
+    }
+    if (entry.src !== undefined) {
+      assetMap[entry.src] = publicFile;
+    }
+    for (const css of entry.css) {
+      assetMap[css] = createPublicUrl(css, base);
+    }
+    for (const asset of entry.assets) {
+      assetMap[asset] = createPublicUrl(asset, base);
+    }
+  }
+  return assetMap;
+}

package/dist/vite/create-asset-manifest.d.ts

@@ -0,0 +1,9 @@
+import type { ReactViteAssetManifestResult, ReactViteManifestOptions } from './types.js';
+/**
+ * Parses a Vite manifest into React hydration assets without importing Vite from the root package.
+ *
+ * @param options Manifest input, explicit React entry selectors, public base path, and trusted bootstrap metadata.
+ * @returns A typed asset manifest on success, or diagnostics for expected manifest and output-shape failures.
+ */
+export declare function createReactViteAssetManifest(options: ReactViteManifestOptions): ReactViteAssetManifestResult;
+//# sourceMappingURL=create-asset-manifest.d.ts.map

package/dist/vite/create-asset-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-asset-manifest.d.ts","sourceRoot":"","sources":["../../src/vite/create-asset-manifest.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAMV,4BAA4B,EAG5B,wBAAwB,EAEzB,MAAM,YAAY,CAAC;AA8EpB;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,wBAAwB,GAChC,4BAA4B,CAoC9B"}

package/dist/vite/create-asset-manifest.js

@@ -0,0 +1,127 @@
+import { cloneUniqueBootstrapAssets, collectCssUrls, collectDependencyGraph, collectModuleUrls, createAssetMap, createPublicUrl, isJavaScriptOutput } from './asset-utils.js';
+import { createMissingEntryDiagnostic, createUnsupportedOutputDiagnostic } from './diagnostics.js';
+import { parseReactViteBuildManifest, resolveManifestEntry } from './parse-manifest.js';
+function createResolvedEntry(entry, base) {
+  return {
+    assets: entry.assets.map(asset => createPublicUrl(asset, base)),
+    css: entry.css.map(css => createPublicUrl(css, base)),
+    file: entry.file,
+    id: entry.id,
+    imports: [...entry.imports],
+    publicUrl: createPublicUrl(entry.file, base)
+  };
+}
+function createBootstrapData(input) {
+  return {
+    ...(input.bootstrapScriptContent !== undefined ? {
+      bootstrapScriptContent: input.bootstrapScriptContent
+    } : {}),
+    ...(input.identifierPrefix !== undefined ? {
+      identifierPrefix: input.identifierPrefix
+    } : {}),
+    ...(input.nonce !== undefined ? {
+      nonce: input.nonce
+    } : {})
+  };
+}
+function createHydrationOptions(input) {
+  return {
+    assetMap: input.assetMap,
+    ...(input.modules.length > 0 ? {
+      bootstrapModules: input.modules
+    } : {}),
+    ...(input.bootstrap.bootstrapScriptContent !== undefined ? {
+      bootstrapScriptContent: input.bootstrap.bootstrapScriptContent
+    } : {}),
+    ...(input.scripts.length > 0 ? {
+      bootstrapScripts: input.scripts
+    } : {}),
+    ...(input.bootstrap.identifierPrefix !== undefined ? {
+      identifierPrefix: input.bootstrap.identifierPrefix
+    } : {}),
+    ...(input.bootstrap.nonce !== undefined ? {
+      nonce: input.bootstrap.nonce
+    } : {})
+  };
+}
+function createSuccessManifest(input) {
+  const {
+    clientGraph,
+    manifest,
+    options,
+    serverEntry
+  } = input;
+  const assetMap = createAssetMap(manifest, options.base);
+  const css = collectCssUrls(clientGraph.entries, options.base);
+  const manifestModuleUrls = collectModuleUrls(clientGraph.entries, options.base);
+  const modules = cloneUniqueBootstrapAssets([...manifestModuleUrls, ...(options.bootstrapModules ?? [])]);
+  const scripts = cloneUniqueBootstrapAssets(options.bootstrapScripts ?? []);
+  const bootstrap = createBootstrapData(options);
+  const hydrationOptions = createHydrationOptions({
+    assetMap,
+    bootstrap,
+    modules,
+    scripts
+  });
+  const clientEntry = clientGraph.entries[clientGraph.entries.length - 1];
+  if (clientEntry === undefined) {
+    return {
+      diagnostics: [createMissingEntryDiagnostic('client', options.entries.client)],
+      ok: false
+    };
+  }
+  return {
+    manifest: {
+      assetMap,
+      bootstrap,
+      clientEntry: createResolvedEntry(clientEntry, options.base),
+      css,
+      hydrationOptions,
+      js: {
+        modules,
+        scripts
+      },
+      serverEntry: createResolvedEntry(serverEntry, options.base)
+    },
+    ok: true
+  };
+}
+
+/**
+ * Parses a Vite manifest into React hydration assets without importing Vite from the root package.
+ *
+ * @param options Manifest input, explicit React entry selectors, public base path, and trusted bootstrap metadata.
+ * @returns A typed asset manifest on success, or diagnostics for expected manifest and output-shape failures.
+ */
+export function createReactViteAssetManifest(options) {
+  const parsed = parseReactViteBuildManifest(options.manifest);
+  if (!parsed.ok) {
+    return parsed;
+  }
+  const serverResult = resolveManifestEntry(parsed.manifest, 'server', options.entries.server);
+  const clientResult = resolveManifestEntry(parsed.manifest, 'client', options.entries.client);
+  const entryDiagnostics = [...serverResult.diagnostics, ...clientResult.diagnostics];
+  const serverEntry = serverResult.entry;
+  const clientEntry = clientResult.entry;
+  if (serverEntry === undefined || clientEntry === undefined) {
+    return {
+      diagnostics: entryDiagnostics,
+      ok: false
+    };
+  }
+  const clientGraph = collectDependencyGraph(parsed.manifest, clientEntry);
+  const unsupportedDiagnostics = [...(isJavaScriptOutput(serverEntry.file) ? [] : [createUnsupportedOutputDiagnostic('server', serverEntry)]), ...clientGraph.entries.flatMap(entry => isJavaScriptOutput(entry.file) ? [] : [createUnsupportedOutputDiagnostic('client', entry)])];
+  const diagnostics = [...clientGraph.diagnostics, ...unsupportedDiagnostics];
+  if (diagnostics.length > 0) {
+    return {
+      diagnostics,
+      ok: false
+    };
+  }
+  return createSuccessManifest({
+    clientGraph,
+    manifest: parsed.manifest,
+    options,
+    serverEntry
+  });
+}

package/dist/vite/diagnostics.d.ts

@@ -0,0 +1,27 @@
+import { type EntryRole, type ParsedManifestEntry } from './types.js';
+import type { ReactViteManifestDiagnostic } from './types.js';
+/**
+ * Creates a malformed-manifest diagnostic.
+ *
+ * @param message Human-readable explanation for the malformed manifest value.
+ * @param path Optional manifest path for field-level failures.
+ * @returns A diagnostic with the stable malformed-manifest code.
+ */
+export declare function createMalformedDiagnostic(message: string, path?: string): ReactViteManifestDiagnostic;
+/**
+ * Creates a missing-entry diagnostic for the requested React entry role.
+ *
+ * @param role React entry role being resolved.
+ * @param entry Requested manifest key, `src`, or `name`.
+ * @returns A diagnostic with the role-specific missing-entry code.
+ */
+export declare function createMissingEntryDiagnostic(role: EntryRole, entry: string): ReactViteManifestDiagnostic;
+/**
+ * Creates an unsupported-output diagnostic when a selected chunk is not JavaScript.
+ *
+ * @param role React entry role whose output shape was rejected.
+ * @param entry Parsed manifest entry with the unsupported output file.
+ * @returns A diagnostic with the stable unsupported-output code.
+ */
+export declare function createUnsupportedOutputDiagnostic(role: EntryRole, entry: ParsedManifestEntry): ReactViteManifestDiagnostic;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/vite/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../src/vite/diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACxF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,GACZ,2BAA2B,CAM7B;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,GACZ,2BAA2B,CAM7B;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,mBAAmB,GACzB,2BAA2B,CAM7B"}

package/dist/vite/diagnostics.js

@@ -0,0 +1,47 @@
+import { DIAGNOSTIC_CODES } from './types.js';
+/**
+ * Creates a malformed-manifest diagnostic.
+ *
+ * @param message Human-readable explanation for the malformed manifest value.
+ * @param path Optional manifest path for field-level failures.
+ * @returns A diagnostic with the stable malformed-manifest code.
+ */
+export function createMalformedDiagnostic(message, path) {
+  return {
+    code: DIAGNOSTIC_CODES.malformed,
+    message,
+    ...(path !== undefined ? {
+      path
+    } : {})
+  };
+}
+
+/**
+ * Creates a missing-entry diagnostic for the requested React entry role.
+ *
+ * @param role React entry role being resolved.
+ * @param entry Requested manifest key, `src`, or `name`.
+ * @returns A diagnostic with the role-specific missing-entry code.
+ */
+export function createMissingEntryDiagnostic(role, entry) {
+  return {
+    code: role === 'server' ? DIAGNOSTIC_CODES.missingServerEntry : DIAGNOSTIC_CODES.missingClientEntry,
+    entry,
+    message: `React Vite ${role} entry "${entry}" was not found in the manifest.`
+  };
+}
+
+/**
+ * Creates an unsupported-output diagnostic when a selected chunk is not JavaScript.
+ *
+ * @param role React entry role whose output shape was rejected.
+ * @param entry Parsed manifest entry with the unsupported output file.
+ * @returns A diagnostic with the stable unsupported-output code.
+ */
+export function createUnsupportedOutputDiagnostic(role, entry) {
+  return {
+    code: DIAGNOSTIC_CODES.unsupportedOutputShape,
+    entry: entry.id,
+    message: `React Vite ${role} entry "${entry.id}" must resolve to a JavaScript output file, received "${entry.file}".`
+  };
+}

package/dist/vite/parse-manifest.d.ts

@@ -0,0 +1,18 @@
+import type { EntryResolveResult, EntryRole, ManifestParseResult, ParsedManifest } from './types.js';
+/**
+ * Parses unknown Vite manifest data into a typed manifest map.
+ *
+ * @param value Manifest value loaded at a trust boundary.
+ * @returns Parsed manifest data or malformed-manifest diagnostics.
+ */
+export declare function parseReactViteBuildManifest(value: unknown): ManifestParseResult;
+/**
+ * Resolves a React server or client entry by manifest key, `src`, or `name`.
+ *
+ * @param manifest Parsed Vite manifest.
+ * @param role React entry role being resolved.
+ * @param entryId Requested manifest key, `src`, or `name`.
+ * @returns The resolved manifest entry or role-specific diagnostics.
+ */
+export declare function resolveManifestEntry(manifest: ParsedManifest, role: EntryRole, entryId: string): EntryResolveResult;
+//# sourceMappingURL=parse-manifest.d.ts.map

package/dist/vite/parse-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-manifest.d.ts","sourceRoot":"","sources":["../../src/vite/parse-manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EAGT,mBAAmB,EACnB,cAAc,EAIf,MAAM,YAAY,CAAC;AA6HpB;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CA0B/E;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,MAAM,GACd,kBAAkB,CA0BpB"}

package/dist/vite/parse-manifest.js

@@ -0,0 +1,168 @@
+import { DIAGNOSTIC_CODES } from './types.js';
+import { createMalformedDiagnostic, createMissingEntryDiagnostic } from './diagnostics.js';
+function isUnknownRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every(item => typeof item === 'string');
+}
+function readOwnValue(record, key) {
+  return Object.hasOwn(record, key) ? record[key] : undefined;
+}
+function readOptionalString(reader, field) {
+  const value = readOwnValue(reader.entry, field);
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  reader.diagnostics.push(createMalformedDiagnostic(`React Vite manifest entry "${reader.entryId}" field "${field}" must be a string.`, `${reader.entryId}.${field}`));
+  return undefined;
+}
+function readOptionalBoolean(reader, field) {
+  const value = readOwnValue(reader.entry, field);
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  reader.diagnostics.push(createMalformedDiagnostic(`React Vite manifest entry "${reader.entryId}" field "${field}" must be a boolean.`, `${reader.entryId}.${field}`));
+  return undefined;
+}
+function readOptionalStringArray(reader, field) {
+  const value = readOwnValue(reader.entry, field);
+  if (value === undefined) {
+    return [];
+  }
+  if (isStringArray(value)) {
+    return [...value];
+  }
+  reader.diagnostics.push(createMalformedDiagnostic(`React Vite manifest entry "${reader.entryId}" field "${field}" must be an array of strings.`, `${reader.entryId}.${field}`));
+  return [];
+}
+function parseManifestEntry(entryId, rawEntry) {
+  if (!isUnknownRecord(rawEntry)) {
+    return {
+      diagnostics: [createMalformedDiagnostic(`React Vite manifest entry "${entryId}" must be an object.`, entryId)]
+    };
+  }
+  const diagnostics = [];
+  const reader = {
+    diagnostics,
+    entry: rawEntry,
+    entryId
+  };
+  const fileValue = readOwnValue(rawEntry, 'file');
+  const file = typeof fileValue === 'string' ? fileValue : '';
+  if (typeof fileValue !== 'string') {
+    diagnostics.push(createMalformedDiagnostic(`React Vite manifest entry "${entryId}" field "file" must be a string.`, `${entryId}.file`));
+  }
+  const assets = readOptionalStringArray(reader, 'assets');
+  const css = readOptionalStringArray(reader, 'css');
+  const imports = readOptionalStringArray(reader, 'imports');
+  const isDynamicEntry = readOptionalBoolean(reader, 'isDynamicEntry');
+  const isEntry = readOptionalBoolean(reader, 'isEntry');
+  const name = readOptionalString(reader, 'name');
+  const src = readOptionalString(reader, 'src');
+  if (diagnostics.length > 0) {
+    return {
+      diagnostics
+    };
+  }
+  return {
+    diagnostics: [],
+    entry: {
+      assets,
+      css,
+      file,
+      id: entryId,
+      imports,
+      ...(isDynamicEntry !== undefined ? {
+        isDynamicEntry
+      } : {}),
+      ...(isEntry !== undefined ? {
+        isEntry
+      } : {}),
+      ...(name !== undefined ? {
+        name
+      } : {}),
+      ...(src !== undefined ? {
+        src
+      } : {})
+    }
+  };
+}
+
+/**
+ * Parses unknown Vite manifest data into a typed manifest map.
+ *
+ * @param value Manifest value loaded at a trust boundary.
+ * @returns Parsed manifest data or malformed-manifest diagnostics.
+ */
+export function parseReactViteBuildManifest(value) {
+  if (!isUnknownRecord(value)) {
+    return {
+      diagnostics: [createMalformedDiagnostic('React Vite manifest must be an object keyed by entry id.')],
+      ok: false
+    };
+  }
+  const diagnostics = [];
+  const manifest = {};
+  Object.setPrototypeOf(manifest, null);
+  for (const [entryId, rawEntry] of Object.entries(value)) {
+    const parsed = parseManifestEntry(entryId, rawEntry);
+    diagnostics.push(...parsed.diagnostics);
+    if (parsed.entry !== undefined) {
+      manifest[entryId] = parsed.entry;
+    }
+  }
+  if (diagnostics.length > 0) {
+    return {
+      diagnostics,
+      ok: false
+    };
+  }
+  return {
+    manifest,
+    ok: true
+  };
+}
+
+/**
+ * Resolves a React server or client entry by manifest key, `src`, or `name`.
+ *
+ * @param manifest Parsed Vite manifest.
+ * @param role React entry role being resolved.
+ * @param entryId Requested manifest key, `src`, or `name`.
+ * @returns The resolved manifest entry or role-specific diagnostics.
+ */
+export function resolveManifestEntry(manifest, role, entryId) {
+  const exactEntry = readOwnValue(manifest, entryId);
+  if (exactEntry !== undefined) {
+    return {
+      diagnostics: [],
+      entry: exactEntry
+    };
+  }
+  const matches = Object.values(manifest).filter(entry => entry.src === entryId || entry.name === entryId);
+  if (matches.length === 1) {
+    return {
+      diagnostics: [],
+      entry: matches[0]
+    };
+  }
+  if (matches.length > 1) {
+    return {
+      diagnostics: [{
+        code: DIAGNOSTIC_CODES.unsupportedOutputShape,
+        entry: entryId,
+        message: `React Vite ${role} entry "${entryId}" matched multiple manifest entries.`
+      }]
+    };
+  }
+  return {
+    diagnostics: [createMissingEntryDiagnostic(role, entryId)]
+  };
+}