@types/react-dom 19.2.4: exports

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify @types/react-dom.exports in pkg:npm/%40types/react-dom@19.2.4
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40types/react-dom@19.2.4
Demonstrate these symbols/APIs:
  - @types/react-dom.exports

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:55dc4f8a7376cd6d1b15c231ab35f40853a0435c4049ec2c237f26d7926b2937","contract":["@types/react-dom package.json defines an exports map exposing root, client, canary, server variants, static variants, experimental, test-utils, and package.json","All TypeScript declaration target files referenced in @types/react-dom exports map resolve and exist on disk","Root and client exports declare primary React DOM 19 APIs including createPortal, flushSync, createRoot, and hydrateRoot","Server export variants (server, server.browser, server.bun, server.edge, server.node) declare streaming and string rendering entrypoints","Static export variants (static, static.browser, static.edge, static.node) declare prerender and prerenderToNodeStream entrypoints","Canary, experimental, and test-utils export entrypoints declare forward-looking extensions and deprecated act re-export","Helper resolution and validation functions correctly inspect and verify all exported subpath targets and signature mappings"],"goal":"verify @types/react-dom.exports in pkg:npm/%40types/react-dom@19.2.4","kind":"HOW","packages":["pkg:npm/%40types/react-dom@19.2.4"],"schemaVersion":1,"symbols":["@types/react-dom.exports"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/%40types/react-dom@19.2.4"],"schemaVersion":1,"subject":"pkg:npm/%40types/react-dom@19.2.4","symbols":["@types/react-dom.exports"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-react-dom-exports",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-react-dom-exports",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "@types/react-dom": "19.2.4"
      }
    },
    "node_modules/@types/react": {
      "version": "19.2.18",
      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.18.tgz",
      "integrity": "sha512-AnzbBERsrLKtk2XSfTbYRLjQPdy116Sty4q+T+Bp3IC4l6jNBvreVPAHmpq9qhXQM7CXZPjLVmGMw9sy+hxQ3w==",
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "csstype": "^3.2.2"
      }
    },
    "node_modules/@types/react-dom": {
      "version": "19.2.4",
      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.4.tgz",
      "integrity": "sha512-Bsc+QHgp+P/F02XDzNCY9jnZNCUuLki36KT7VKrTXXLdHf+vHMNZnW1rVu5DNW/rCK+fya3DATySbLM4yhtKUw==",
      "license": "MIT",
      "peerDependencies": {
        "@types/react": "^19.2.0"
      }
    },
    "node_modules/csstype": {
      "version": "3.2.3",
      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
      "license": "MIT",
      "peer": true
    }
  }
}

{
  "name": "sample-react-dom-exports",
  "version": "1.0.0",
  "private": true,
  "license": "MIT-0",
  "dependencies": {
    "@types/react-dom": "19.2.4"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify @types/react-dom.exports in pkg:npm/%40types/react-dom@19.2.4",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40types/react-dom@19.2.4"
  ],
  "symbols": [
    "@types/react-dom.exports"
  ]
}

import fs from 'node:fs';
import path from 'node:path';
import { createRequire } from 'node:module';

const require = createRequire(import.meta.url);

/**
 * Returns the package.json object of @types/react-dom.
 * @returns {object} Parsed package.json
 */
export function getReactDomTypesPackage() {
  return require('@types/react-dom/package.json');
}

/**
 * Returns the directory path of @types/react-dom.
 * @returns {string} Directory path
 */
export function getReactDomTypesDir() {
  const pkgPath = require.resolve('@types/react-dom/package.json');
  return path.dirname(pkgPath);
}

/**
 * Returns all exported subpath keys defined in @types/react-dom package.json exports map.
 * @returns {string[]} List of export keys
 */
export function getExportedSubpaths() {
  const pkg = getReactDomTypesPackage();
  return Object.keys(pkg.exports || {});
}

/**
 * Resolves the relative or absolute path of the target file for a given export subpath.
 * @param {string} subpath - Export subpath key (e.g. '.', './client', './server.node')
 * @returns {string} Relative file path to the declaration file or target
 */
export function getExportTarget(subpath) {
  const pkg = getReactDomTypesPackage();
  const exportEntry = pkg.exports?.[subpath];
  if (!exportEntry) {
    throw new Error(`Subpath "${subpath}" not found in @types/react-dom exports`);
  }
  if (typeof exportEntry === 'string') {
    return exportEntry;
  }
  if (exportEntry.types?.default) {
    return exportEntry.types.default;
  }
  if (exportEntry.types) {
    return exportEntry.types;
  }
  if (exportEntry.default) {
    return exportEntry.default;
  }
  throw new Error(`Unable to resolve export target for subpath "${subpath}"`);
}

/**
 * Resolves the absolute file path on disk for a given export subpath.
 * @param {string} subpath - Export subpath key
 * @returns {string} Absolute path to target file
 */
export function resolveExportAbsolutePath(subpath) {
  const targetRel = getExportTarget(subpath);
  return path.resolve(getReactDomTypesDir(), targetRel);
}

/**
 * Verifies that all exported subpaths map to existing files on disk.
 * @returns {Array<{subpath: string, target: string, exists: boolean}>} Verification results
 */
export function verifyAllExports() {
  const subpaths = getExportedSubpaths();
  return subpaths.map((subpath) => {
    const target = getExportTarget(subpath);
    const absPath = resolveExportAbsolutePath(subpath);
    const exists = fs.existsSync(absPath);
    return { subpath, target, exists };
  });
}

/**
 * Loads text content for an exported subpath's target file.
 * @param {string} subpath - Export subpath key
 * @returns {string} File content
 */
export function loadExportContent(subpath) {
  const absPath = resolveExportAbsolutePath(subpath);
  return fs.readFileSync(absPath, 'utf8');
}

/**
 * Inspects export signatures across all major subpaths.
 * @returns {object} Summary of inspected export declarations
 */
export function inspectExportSignatures() {
  const rootContent = loadExportContent('.');
  const clientContent = loadExportContent('./client');
  const serverContent = loadExportContent('./server');
  const serverNodeContent = loadExportContent('./server.node');
  const serverBrowserContent = loadExportContent('./server.browser');
  const serverBunContent = loadExportContent('./server.bun');
  const serverEdgeContent = loadExportContent('./server.edge');
  const staticContent = loadExportContent('./static');
  const staticNodeContent = loadExportContent('./static.node');
  const staticBrowserContent = loadExportContent('./static.browser');
  const canaryContent = loadExportContent('./canary');
  const experimentalContent = loadExportContent('./experimental');
  const testUtilsContent = loadExportContent('./test-utils');

  return {
    root: {
      hasCreatePortal: rootContent.includes('function createPortal('),
      hasFlushSync: rootContent.includes('function flushSync<R>('),
      hasUseFormStatus: rootContent.includes('function useFormStatus()'),
      hasUseFormState: rootContent.includes('function useFormState<State>(')
    },
    client: {
      hasCreateRoot: clientContent.includes('function createRoot('),
      hasHydrateRoot: clientContent.includes('function hydrateRoot('),
      hasRootInterface: clientContent.includes('interface Root')
    },
    server: {
      hasRenderToString: serverContent.includes('function renderToString('),
      hasRenderToStaticMarkup: serverContent.includes('function renderToStaticMarkup('),
      hasRenderToPipeableStream: serverContent.includes('function renderToPipeableStream('),
      hasRenderToReadableStream: serverContent.includes('function renderToReadableStream(')
    },
    serverVariants: {
      nodeHasPipeableStream: serverNodeContent.includes('renderToPipeableStream'),
      browserHasReadableStream: serverBrowserContent.includes('renderToReadableStream'),
      bunHasReadableStream: serverBunContent.includes('renderToReadableStream'),
      edgeHasReadableStream: serverEdgeContent.includes('renderToReadableStream')
    },
    staticVariants: {
      staticHasPrerender: staticContent.includes('function prerender('),
      staticHasPrerenderToNodeStream: staticContent.includes('function prerenderToNodeStream('),
      nodeHasPrerenderToNodeStream: staticNodeContent.includes('prerenderToNodeStream'),
      browserHasPrerender: staticBrowserContent.includes('prerender')
    },
    extensions: {
      canaryHasBrowserUsable: canaryContent.includes('interface BrowserUsable'),
      experimentalHasDeclaration: experimentalContent.length > 0,
      testUtilsHasAct: testUtilsContent.includes('act')
    }
  };
}

import assert from 'node:assert/strict';
import fs from 'node:fs';
import {
  getReactDomTypesPackage,
  getReactDomTypesDir,
  getExportedSubpaths,
  getExportTarget,
  resolveExportAbsolutePath,
  verifyAllExports,
  loadExportContent,
  inspectExportSignatures
} from '../src/index.mjs';

// Contract 1: @types/react-dom package.json defines an exports map exposing root, client, canary, server variants, static variants, experimental, test-utils, and package.json
{
  const pkg = getReactDomTypesPackage();
  assert.equal(pkg.name, '@types/react-dom');
  assert.equal(pkg.version, '19.2.4');
  assert.equal(pkg.types, 'index.d.ts');
  assert.ok(pkg.exports, 'package.json should have exports map');

  const expectedSubpaths = [
    '.',
    './client',
    './canary',
    './server',
    './server.browser',
    './server.bun',
    './server.edge',
    './server.node',
    './static',
    './static.browser',
    './static.edge',
    './static.node',
    './experimental',
    './test-utils',
    './package.json'
  ];

  const actualSubpaths = getExportedSubpaths();
  for (const expected of expectedSubpaths) {
    assert.ok(
      actualSubpaths.includes(expected),
      `Export subpath "${expected}" should be defined in exports map`
    );
  }
}

// Contract 2: All TypeScript declaration target files referenced in @types/react-dom exports map resolve and exist on disk
{
  const results = verifyAllExports();
  assert.ok(results.length >= 15, 'Should have at least 15 export mappings');
  for (const item of results) {
    assert.equal(item.exists, true, `Export target for "${item.subpath}" (${item.target}) must exist on disk`);
  }
}

// Contract 3: Root and client exports declare primary React DOM 19 APIs including createPortal, flushSync, createRoot, and hydrateRoot
{
  const rootTarget = getExportTarget('.');
  assert.equal(rootTarget, './index.d.ts');
  const rootContent = loadExportContent('.');
  assert.ok(rootContent.includes('function createPortal('));
  assert.ok(rootContent.includes('function flushSync<R>('));
  assert.ok(rootContent.includes('function useFormStatus()'));
  assert.ok(rootContent.includes('function useFormState<State>('));

  const clientTarget = getExportTarget('./client');
  assert.equal(clientTarget, './client.d.ts');
  const clientContent = loadExportContent('./client');
  assert.ok(clientContent.includes('function createRoot('));
  assert.ok(clientContent.includes('function hydrateRoot('));
  assert.ok(clientContent.includes('interface Root'));
  assert.ok(clientContent.includes('interface RootOptions'));
}

// Contract 4: Server export variants (server, server.browser, server.bun, server.edge, server.node) declare streaming and string rendering entrypoints
{
  const serverContent = loadExportContent('./server');
  assert.ok(serverContent.includes('function renderToString('));
  assert.ok(serverContent.includes('function renderToStaticMarkup('));
  assert.ok(serverContent.includes('function renderToPipeableStream('));
  assert.ok(serverContent.includes('function renderToReadableStream('));

  const serverNodeContent = loadExportContent('./server.node');
  assert.ok(serverNodeContent.includes('renderToPipeableStream'));
  assert.ok(serverNodeContent.includes('renderToString'));

  const serverBrowserContent = loadExportContent('./server.browser');
  assert.ok(serverBrowserContent.includes('renderToReadableStream'));

  const serverBunContent = loadExportContent('./server.bun');
  assert.ok(serverBunContent.includes('renderToReadableStream'));

  const serverEdgeContent = loadExportContent('./server.edge');
  assert.ok(serverEdgeContent.includes('renderToReadableStream'));
}

// Contract 5: Static export variants (static, static.browser, static.edge, static.node) declare prerender and prerenderToNodeStream entrypoints
{
  const staticContent = loadExportContent('./static');
  assert.ok(staticContent.includes('function prerender('));
  assert.ok(staticContent.includes('function prerenderToNodeStream('));

  const staticNodeContent = loadExportContent('./static.node');
  assert.ok(staticNodeContent.includes('prerenderToNodeStream'));
  assert.ok(staticNodeContent.includes('prerender'));

  const staticBrowserContent = loadExportContent('./static.browser');
  assert.ok(staticBrowserContent.includes('prerender'));

  const staticEdgeContent = loadExportContent('./static.edge');
  assert.ok(staticEdgeContent.includes('prerender'));
}

// Contract 6: Canary, experimental, and test-utils export entrypoints declare forward-looking extensions and deprecated act re-export
{
  const canaryContent = loadExportContent('./canary');
  assert.ok(canaryContent.includes('interface BrowserUsable'));

  const experimentalContent = loadExportContent('./experimental');
  assert.ok(experimentalContent.length > 0);

  const testUtilsContent = loadExportContent('./test-utils');
  assert.ok(testUtilsContent.includes('act'));
}

// Contract 7: Helper resolution and validation functions correctly inspect and verify all exported subpath targets and signature mappings
{
  const signatures = inspectExportSignatures();
  assert.equal(signatures.root.hasCreatePortal, true);
  assert.equal(signatures.root.hasFlushSync, true);
  assert.equal(signatures.root.hasUseFormStatus, true);
  assert.equal(signatures.root.hasUseFormState, true);
  assert.equal(signatures.client.hasCreateRoot, true);
  assert.equal(signatures.client.hasHydrateRoot, true);
  assert.equal(signatures.client.hasRootInterface, true);
  assert.equal(signatures.server.hasRenderToString, true);
  assert.equal(signatures.server.hasRenderToStaticMarkup, true);
  assert.equal(signatures.server.hasRenderToPipeableStream, true);
  assert.equal(signatures.server.hasRenderToReadableStream, true);
  assert.equal(signatures.serverVariants.nodeHasPipeableStream, true);
  assert.equal(signatures.serverVariants.browserHasReadableStream, true);
  assert.equal(signatures.serverVariants.bunHasReadableStream, true);
  assert.equal(signatures.serverVariants.edgeHasReadableStream, true);
  assert.equal(signatures.staticVariants.staticHasPrerender, true);
  assert.equal(signatures.staticVariants.staticHasPrerenderToNodeStream, true);
  assert.equal(signatures.staticVariants.nodeHasPrerenderToNodeStream, true);
  assert.equal(signatures.staticVariants.browserHasPrerender, true);
  assert.equal(signatures.extensions.canaryHasBrowserUsable, true);
  assert.equal(signatures.extensions.experimentalHasDeclaration, true);
  assert.equal(signatures.extensions.testUtilsHasAct, true);
}

console.log('All @types/react-dom.exports contract assertions passed successfully.');