@wular/pnext 0.0.4 → 0.0.6

package/src/client/profile.ts

@@ -2,37 +2,37 @@
 // esbuild / write), off unless PNEXT_CLIENT_PROFILE is set. The bench needs the
 // split to prove where the residual sits; a build must not pay for it.
 // eslint-disable-next-line turbo/no-undeclared-env-vars
-const enabled = Boolean(process.env.PNEXT_CLIENT_PROFILE);
+const enabled = Boolean(process.env.PNEXT_CLIENT_PROFILE)
 
-const totals = new Map<string, number>();
-const spans = new Map<string, [number, number][]>();
+const totals = new Map<string, number>()
+const spans = new Map<string, [number, number][]>()
 
 /** Total wall covered by at least one span (overlaps counted once). */
 function unionMs(intervals: [number, number][]) {
-  const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
-  let total = 0;
-  let [openStart, openEnd] = sorted[0] ?? [0, 0];
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0])
+  let total = 0
+  let [openStart, openEnd] = sorted[0] ?? [0, 0]
   for (const [start, end] of sorted.slice(1)) {
     if (start > openEnd) {
-      total += openEnd - openStart;
-      [openStart, openEnd] = [start, end];
+      total += openEnd - openStart
+      ;[openStart, openEnd] = [start, end]
     } else if (end > openEnd) {
-      openEnd = end;
+      openEnd = end
     }
   }
-  return total + (openEnd - openStart);
+  return total + (openEnd - openStart)
 }
 
 export const clientProfile = {
   enabled,
   /** Time `task` under `phase`. Returns the task's value untouched. */
   time<T>(phase: string, task: () => T): T {
-    if (!enabled) return task();
-    const start = performance.now();
+    if (!enabled) return task()
+    const start = performance.now()
     try {
-      return task();
+      return task()
     } finally {
-      totals.set(phase, (totals.get(phase) ?? 0) + (performance.now() - start));
+      totals.set(phase, (totals.get(phase) ?? 0) + (performance.now() - start))
     }
   },
   /**
@@ -40,36 +40,36 @@ export const clientProfile = {
    * the same second many times. Record spans and report the union - the wall the phase occupies.
    */
   async timeAsync<T>(phase: string, task: () => Promise<T>): Promise<T> {
-    if (!enabled) return task();
-    const start = performance.now();
+    if (!enabled) return task()
+    const start = performance.now()
     try {
-      return await task();
+      return await task()
     } finally {
-      (spans.get(phase) ?? spans.set(phase, []).get(phase)!).push([start, performance.now()]);
+      ;(spans.get(phase) ?? spans.set(phase, []).get(phase)!).push([start, performance.now()])
     }
   },
   count(key: string, by = 1) {
-    if (!enabled) return;
-    totals.set(key, (totals.get(key) ?? 0) + by);
+    if (!enabled) return
+    totals.set(key, (totals.get(key) ?? 0) + by)
   },
   reset() {
-    totals.clear();
-    spans.clear();
+    totals.clear()
+    spans.clear()
   },
   snapshot(): Record<string, number> {
     return {
       ...Object.fromEntries(totals),
       ...Object.fromEntries([...spans].map(([phase, list]) => [phase, unionMs(list)])),
-    };
+    }
   },
   /** Print the snapshot and clear it, so a second stage starts from zero. */
   report(label: string) {
-    if (!enabled) return;
-    const snap = this.snapshot();
+    if (!enabled) return
+    const snap = this.snapshot()
     const line = Object.entries(snap)
       .map(([phase, value]) => `${phase} ${value < 100 ? value.toFixed(1) : Math.round(value)}`)
-      .join(' · ');
-    console.log(`pnext client profile [${label}] ${line}`);
-    this.reset();
+      .join(' · ')
+    console.log(`pnext client profile [${label}] ${line}`)
+    this.reset()
   },
-};
+}

package/src/client/react-compiler.ts

@@ -1,9 +1,14 @@
-import { transform, transformSync, type TransformOptions, type TransformResult } from 'oxc-transform';
-import type { getCompatModeExtensions } from '../extensions';
+import {
+  transform,
+  transformSync,
+  type TransformOptions,
+  type TransformResult,
+} from 'oxc-transform'
+import type { getCompatModeExtensions } from '../extensions'
 
 type ReactCompilerOptions = NonNullable<
   ReturnType<ReturnType<typeof getCompatModeExtensions>['reactCompilerOptions']>
->;
+>
 
 // oxc-transform runs the React Compiler (Rust port) plus TypeScript stripping
 // in a single pass, replacing the @babel/core round-trip. JSX is left intact
@@ -17,7 +22,7 @@ function compilerOptions(options: ReactCompilerOptions): TransformOptions {
       panicThreshold: 'critical_errors',
       target: options.target as '17' | '18' | '19',
     },
-  };
+  }
 }
 
 /**
@@ -35,7 +40,7 @@ export async function transformReactCompiler(
   file: string,
   options: ReactCompilerOptions,
 ) {
-  return reactCompilerResult(await transform(file, source, compilerOptions(options)), source, file);
+  return reactCompilerResult(await transform(file, source, compilerOptions(options)), source, file)
 }
 
 /** Same pass, for the few callers that cannot await (kept in lock-step above). */
@@ -44,7 +49,7 @@ export function transformReactCompilerSync(
   file: string,
   options: ReactCompilerOptions,
 ) {
-  return reactCompilerResult(transformSync(file, source, compilerOptions(options)), source, file);
+  return reactCompilerResult(transformSync(file, source, compilerOptions(options)), source, file)
 }
 
 function reactCompilerResult(result: TransformResult, source: string, file: string) {
@@ -56,16 +61,16 @@ function reactCompilerResult(result: TransformResult, source: string, file: stri
   if (!result.code) {
     // Only genuine transform failures (not React Compiler bailouts) are worth
     // surfacing; esbuild re-parses the fallback source and would flag the rest.
-    const failures = result.errors.filter(error => !error.message.startsWith('[ReactCompiler]'));
+    const failures = result.errors.filter(error => !error.message.startsWith('[ReactCompiler]'))
     if (failures.length > 0) {
       console.error(
         `React Compiler (oxc) failed for ${file}:\n${failures.map(error => error.message).join('\n')}`,
-      );
+      )
     }
-    return source;
+    return source
   }
 
-  return result.code;
+  return result.code
 }
 
 export function stripPureTypeImports(source: string) {
@@ -78,17 +83,17 @@ export function stripPureTypeImports(source: string) {
           .split(',')
           .map(item => item.trim())
           .filter(Boolean)
-          .filter(item => !item.startsWith('type '));
+          .filter(item => !item.startsWith('type '))
 
         return valueSpecifiers.length > 0
           ? `import { ${valueSpecifiers.join(', ')} } from ${specifier};`
-          : '';
+          : ''
       },
-    );
+    )
 }
 
 /** JSX always; a plain .ts/.js only when it looks like it holds a component. */
 export function shouldReactCompile(source: string, file: string) {
-  if (/\.[cm]?[jt]sx$/.test(file)) return true;
-  return /\b(?:use[A-Z][\w$]*|createElement|memo|forwardRef)\b/.test(source);
+  if (/\.[cm]?[jt]sx$/.test(file)) return true
+  return /\b(?:use[A-Z][\w$]*|createElement|memo|forwardRef)\b/.test(source)
 }

package/src/client/{compat-surface.ts → react-tier.ts}

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import path from 'node:path';
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import path from 'node:path'
 
 /**
  * Conservative static scan of a compat app's client graph deciding whether the client bundle can ship
@@ -41,7 +41,7 @@ const LITE_REACT_NAMES = new Set([
   'version',
   'ViewTransition',
   'addTransitionType',
-]);
+])
 
 // Framework client modules known not to pull preact/compat. Every other bare specifier (npm packages,
 // next/dynamic, next/image, ...) disqualifies the lite tier.
@@ -53,123 +53,123 @@ const SAFE_BARE_SPECIFIERS = new Set([
   'preact/jsx-runtime',
   'react/jsx-runtime',
   'react/jsx-dev-runtime',
-]);
+])
 
 // Compat-only semantics preact core lacks: React's onChange/onDoubleClick synthetic mapping,
 // default* form props, string refs, legacy class lifecycles - plus async component shapes (they
 // suspend). Matching anywhere in a file (even a comment) just falls back to the full tier.
 const UNSAFE_TOKENS =
-  /\bonChange\b|\bonDoubleClick\b|\bdefaultProps\b|\bgetSnapshotBeforeUpdate\b|\bcomponentWillReceiveProps\b|\bUNSAFE_\w+|\bref\s*=\s*["']|async\s+function\s+[A-Z]|(?:const|let|var)\s+[A-Z][\w$]*\s*=\s*async\b|export\s+default\s+async\b/;
+  /\bonChange\b|\bonDoubleClick\b|\bdefaultProps\b|\bgetSnapshotBeforeUpdate\b|\bcomponentWillReceiveProps\b|\bUNSAFE_\w+|\bref\s*=\s*["']|async\s+function\s+[A-Z]|(?:const|let|var)\s+[A-Z][\w$]*\s*=\s*async\b|export\s+default\s+async\b/
 
 // defaultValue/defaultChecked are native DOM properties preact core assigns correctly on
 // input/textarea; only <select defaultValue> needs preact/compat's special handling.
 function unsafeDefaultValue(source: string) {
-  return source.includes('defaultValue') && source.includes('<select');
+  return source.includes('defaultValue') && source.includes('<select')
 }
 
-const STATIC_IMPORT = /(?:^|\n)\s*(?:import|export)\s+([^;'"]*?)\s*from\s*(['"])([^'"]+)\2/g;
-const BARE_IMPORT = /(?:^|\n)\s*import\s*(['"])([^'"]+)\1/g;
-const DYNAMIC_IMPORT = /\bimport\(\s*(['"])([^'"]+)\1/g;
+const STATIC_IMPORT = /(?:^|\n)\s*(?:import|export)\s+([^;'"]*?)\s*from\s*(['"])([^'"]+)\2/g
+const BARE_IMPORT = /(?:^|\n)\s*import\s*(['"])([^'"]+)\1/g
+const DYNAMIC_IMPORT = /\bimport\(\s*(['"])([^'"]+)\1/g
 
-const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx|mjs|cjs)$/;
+const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']
+const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx|mjs|cjs)$/
 
 export function clientSuspenseFree(seeds: Iterable<string>): boolean {
-  const queue: string[] = [];
-  const visited = new Set<string>();
+  const queue: string[] = []
+  const visited = new Set<string>()
   for (const seed of seeds) {
-    if (!seed || visited.has(seed)) continue;
-    visited.add(seed);
-    queue.push(seed);
+    if (!seed || visited.has(seed)) continue
+    visited.add(seed)
+    queue.push(seed)
   }
   while (queue.length > 0) {
-    const file = queue.pop()!;
-    if (!SOURCE_EXTENSION.test(file) || !existsSync(file)) return false;
-    let source: string;
+    const file = queue.pop()!
+    if (!SOURCE_EXTENSION.test(file) || !existsSync(file)) return false
+    let source: string
     try {
-      source = readFileSync(file, 'utf8');
+      source = readFileSync(file, 'utf8')
     } catch {
-      return false;
+      return false
     }
-    if (UNSAFE_TOKENS.test(source) || unsafeDefaultValue(source)) return false;
+    if (UNSAFE_TOKENS.test(source) || unsafeDefaultValue(source)) return false
     for (const [clause, specifier] of importsOf(source)) {
       if (specifier === 'react') {
-        if (!liteReactClause(clause)) return false;
-        continue;
+        if (!liteReactClause(clause)) return false
+        continue
       }
-      if (SAFE_BARE_SPECIFIERS.has(specifier)) continue;
+      if (SAFE_BARE_SPECIFIERS.has(specifier)) continue
       if (specifier.startsWith('.')) {
-        if (clause !== undefined && typeOnlyClause(clause)) continue;
-        const resolved = resolveRelative(path.dirname(file), specifier);
-        if (resolved === ASSET) continue;
-        if (!resolved) return false;
+        if (clause !== undefined && typeOnlyClause(clause)) continue
+        const resolved = resolveRelative(path.dirname(file), specifier)
+        if (resolved === ASSET) continue
+        if (!resolved) return false
         if (!visited.has(resolved)) {
-          visited.add(resolved);
-          queue.push(resolved);
+          visited.add(resolved)
+          queue.push(resolved)
         }
-        continue;
+        continue
       }
       // Unknown bare package or framework module that may pull preact/compat.
-      if (clause === undefined || !typeOnlyClause(clause)) return false;
+      if (clause === undefined || !typeOnlyClause(clause)) return false
     }
   }
-  return true;
+  return true
 }
 
 function* importsOf(source: string): Generator<[clause: string | undefined, specifier: string]> {
-  for (const match of source.matchAll(STATIC_IMPORT)) yield [match[1], match[3] ?? ''];
-  for (const match of source.matchAll(BARE_IMPORT)) yield [undefined, match[2] ?? ''];
-  for (const match of source.matchAll(DYNAMIC_IMPORT)) yield [undefined, match[2] ?? ''];
+  for (const match of source.matchAll(STATIC_IMPORT)) yield [match[1], match[3] ?? '']
+  for (const match of source.matchAll(BARE_IMPORT)) yield [undefined, match[2] ?? '']
+  for (const match of source.matchAll(DYNAMIC_IMPORT)) yield [undefined, match[2] ?? '']
 }
 
 function typeOnlyClause(clause: string) {
-  return /^type\s/.test(clause.trim());
+  return /^type\s/.test(clause.trim())
 }
 
 function liteReactClause(clause: string | undefined): boolean {
-  if (clause === undefined) return true;
-  const trimmed = clause.trim();
-  if (typeOnlyClause(trimmed)) return true;
+  if (clause === undefined) return true
+  const trimmed = clause.trim()
+  if (typeOnlyClause(trimmed)) return true
   // Default or namespace import: the whole surface is reachable - full tier.
-  const braceStart = trimmed.indexOf('{');
-  if (braceStart !== 0) return false;
-  const braceEnd = trimmed.indexOf('}');
-  if (braceEnd === -1) return false;
+  const braceStart = trimmed.indexOf('{')
+  if (braceStart !== 0) return false
+  const braceEnd = trimmed.indexOf('}')
+  if (braceEnd === -1) return false
   for (const entry of trimmed.slice(braceStart + 1, braceEnd).split(',')) {
-    const name = entry.trim();
-    if (!name || name.startsWith('type ')) continue;
-    const imported = (name.split(/\s+as\s+/)[0] ?? '').trim();
-    if (!LITE_REACT_NAMES.has(imported)) return false;
+    const name = entry.trim()
+    if (!name || name.startsWith('type ')) continue
+    const imported = (name.split(/\s+as\s+/)[0] ?? '').trim()
+    if (!LITE_REACT_NAMES.has(imported)) return false
   }
-  return true;
+  return true
 }
 
-const ASSET = Symbol('pnext.compat-surface.asset');
+const ASSET = Symbol('pnext.compat-surface.asset')
 
 function resolveRelative(dir: string, specifier: string): string | typeof ASSET | undefined {
-  let base = path.resolve(dir, specifier);
-  const direct = fileAt(base);
-  if (direct) return direct;
+  let base = path.resolve(dir, specifier)
+  const direct = fileAt(base)
+  if (direct) return direct
   // NodeNext-style `./x.js` pointing at `./x.ts(x)`.
-  if (/\.(?:js|jsx|mjs|cjs)$/.test(base)) base = base.replace(/\.[^.]+$/, '');
+  if (/\.(?:js|jsx|mjs|cjs)$/.test(base)) base = base.replace(/\.[^.]+$/, '')
   for (const extension of SOURCE_EXTENSIONS) {
-    const candidate = fileAt(base + extension);
-    if (candidate) return candidate;
+    const candidate = fileAt(base + extension)
+    if (candidate) return candidate
   }
   for (const extension of SOURCE_EXTENSIONS) {
-    const candidate = fileAt(path.join(base, `index${extension}`));
-    if (candidate) return candidate;
+    const candidate = fileAt(path.join(base, `index${extension}`))
+    if (candidate) return candidate
   }
-  return undefined;
+  return undefined
 }
 
 function fileAt(candidate: string): string | typeof ASSET | undefined {
-  if (!existsSync(candidate)) return undefined;
+  if (!existsSync(candidate)) return undefined
   try {
-    if (!statSync(candidate).isFile()) return undefined;
+    if (!statSync(candidate).isFile()) return undefined
   } catch {
-    return undefined;
+    return undefined
   }
   // Styles/assets never carry react surface.
-  return SOURCE_EXTENSION.test(candidate) ? candidate : ASSET;
+  return SOURCE_EXTENSION.test(candidate) ? candidate : ASSET
 }

package/src/client/reference-stub.ts

@@ -4,15 +4,15 @@
  * boundary from the server graph - the dev module pass and the vendor bundler (a package's own
  * `'use client'` files, reached mid-bundle).
  */
-import path from 'node:path';
-import { clientReferenceId } from './reference';
-import { pathToFileHref } from '../config';
-import type { ResolvedConfig } from '../config';
-import { resolveImport } from '../resolve/imports';
-import { moduleExportNames, moduleExportStars } from '../resolve/scan-facts';
-import { readText } from '../utils/fs';
+import path from 'node:path'
+import { clientReferenceId } from './reference'
+import { pathToFileHref } from '../config'
+import type { ResolvedConfig } from '../config'
+import { resolveImport } from '../resolve/imports'
+import { moduleExportNames, moduleExportStars } from '../resolve/scan-facts'
+import { readText } from '../utils/fs'
 
-export const clientReferenceRuntimeFile = path.resolve(import.meta.dirname, 'reference.ts');
+export const clientReferenceRuntimeFile = path.resolve(import.meta.dirname, 'reference.ts')
 
 export interface ClientReferenceModuleOptions {
   /**
@@ -21,7 +21,7 @@ export interface ClientReferenceModuleOptions {
    * reach pnext's own source tree, and the symbol is registry-global, so an
    * inlined lookup is the same symbol the renderer tests for.
    */
-  inlineSymbol?: boolean;
+  inlineSymbol?: boolean
 }
 
 export function clientReferenceModuleSource(
@@ -30,16 +30,16 @@ export function clientReferenceModuleSource(
   options: ClientReferenceModuleOptions = {},
 ) {
   const reference = (exportName: string) =>
-    `createReference({ id: ${JSON.stringify(`c-${clientReferenceId(sourceFile, exportName)}`)}, file: ${JSON.stringify(sourceFile)}, exportName: ${JSON.stringify(exportName)} })`;
+    `createReference({ id: ${JSON.stringify(`c-${clientReferenceId(sourceFile, exportName)}`)}, file: ${JSON.stringify(sourceFile)}, exportName: ${JSON.stringify(exportName)} })`
   const defaultExport = exportNames.includes('default')
     ? `export default ${reference('default')};`
-    : '';
+    : ''
   const namedExports = exportNames
     .filter(name => name !== 'default')
-    .map(name => `export const ${name} = ${reference(name)};`);
+    .map(name => `export const ${name} = ${reference(name)};`)
   const symbol = options.inlineSymbol
     ? `const clientReferenceSymbol = Symbol.for('pnext.clientReference');`
-    : `import { clientReferenceSymbol } from ${JSON.stringify(pathToFileHref(clientReferenceRuntimeFile))};`;
+    : `import { clientReferenceSymbol } from ${JSON.stringify(pathToFileHref(clientReferenceRuntimeFile))};`
 
   return `${symbol}
 
@@ -53,7 +53,7 @@ function createReference(reference) {
 
 ${defaultExport}
 ${namedExports.join('\n')}
-`;
+`
 }
 
 /**
@@ -67,32 +67,32 @@ export async function clientReferenceExportNames(
   source?: string,
   visited = new Set<string>(),
 ): Promise<string[]> {
-  const key = path.resolve(file);
-  if (visited.has(key)) return [];
-  visited.add(key);
-  const text = source ?? (await readText(file));
-  const names = new Set(moduleExportNames(text, file));
+  const key = path.resolve(file)
+  if (visited.has(key)) return []
+  visited.add(key)
+  const text = source ?? (await readText(file))
+  const names = new Set(moduleExportNames(text, file))
   // A CommonJS-style client module (`exports.X = ...`) has no ESM exports for
   // the transpiler scan; recover the statically visible names so its reference
   // shim exposes them (mirrors the client bundle's CJS-name recovery).
   if (names.size === 0) {
     for (const match of text.matchAll(/\bexports\.([A-Za-z_$][\w$]*)\s*=/g)) {
-      if (match[1] !== '__esModule') names.add(match[1]!);
+      if (match[1] !== '__esModule') names.add(match[1]!)
     }
-    if (/\bmodule\.exports\s*=/.test(text)) names.add('default');
+    if (/\bmodule\.exports\s*=/.test(text)) names.add('default')
   }
   // `export * from './x'` re-exports every named export of the target, whose
   // names live in that module — union them recursively (default stays
   // excluded, per ES module star semantics). `export * as ns from` exports
   // only `ns`, which the own-module scan already lists.
   for (const specifier of moduleExportStars(text, file)) {
-    const resolved = resolveImport(config.root, file, specifier);
-    if (!resolved || !isInside(config.workspaceRoot, resolved)) continue;
+    const resolved = resolveImport(config.root, file, specifier)
+    if (!resolved || !isInside(config.workspaceRoot, resolved)) continue
     for (const name of await clientReferenceExportNames(config, resolved, undefined, visited)) {
-      if (name !== 'default') names.add(name);
+      if (name !== 'default') names.add(name)
     }
   }
-  return [...names];
+  return [...names]
 }
 
 /**
@@ -104,42 +104,42 @@ export async function clientReferenceExportNames(
  */
 export function hasUseClientDirective(source: string) {
   const isSpace = (index: number) => {
-    const code = source.charCodeAt(index);
-    return code === 32 || (code >= 9 && code <= 13) || (code > 127 && /\s/.test(source[index]!));
-  };
-  let i = 0;
+    const code = source.charCodeAt(index)
+    return code === 32 || (code >= 9 && code <= 13) || (code > 127 && /\s/.test(source[index]!))
+  }
+  let i = 0
   for (;;) {
-    while (i < source.length && isSpace(i)) i += 1;
+    while (i < source.length && isSpace(i)) i += 1
     if (source.startsWith('//', i)) {
-      const newline = source.indexOf('\n', i);
-      if (newline === -1) return false;
-      i = newline + 1;
-      continue;
+      const newline = source.indexOf('\n', i)
+      if (newline === -1) return false
+      i = newline + 1
+      continue
     }
     if (source.startsWith('/*', i)) {
-      const end = source.indexOf('*/', i + 2);
-      if (end === -1) return false;
-      i = end + 2;
-      continue;
+      const end = source.indexOf('*/', i + 2)
+      if (end === -1) return false
+      i = end + 2
+      continue
     }
     // Anything that is not a string literal ends the prologue.
-    const quote = source[i];
-    if (quote !== '"' && quote !== "'") return false;
-    let end = i + 1;
+    const quote = source[i]
+    if (quote !== '"' && quote !== "'") return false
+    let end = i + 1
     while (end < source.length) {
-      const char = source[end]!;
-      if (char === quote || char === '\n' || char === '\\') break;
-      end += 1;
+      const char = source[end]!
+      if (char === quote || char === '\n' || char === '\\') break
+      end += 1
     }
-    if (source[end] !== quote) return false;
-    if (source.slice(i + 1, end) === 'use client') return true;
-    i = end + 1;
-    while (i < source.length && isSpace(i)) i += 1;
-    if (source[i] === ';') i += 1;
+    if (source[end] !== quote) return false
+    if (source.slice(i + 1, end) === 'use client') return true
+    i = end + 1
+    while (i < source.length && isSpace(i)) i += 1
+    if (source[i] === ';') i += 1
   }
 }
 
 function isInside(root: string, file: string) {
-  const relative = path.relative(root, file);
-  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+  const relative = path.relative(root, file)
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
 }

package/src/client/reference.ts

@@ -1,11 +1,11 @@
-import { createHash } from 'node:crypto';
+import { createHash } from 'node:crypto'
 
 export interface ClientReference {
-  id: string;
-  file: string;
-  exportName: string;
-  dynamic?: ClientDynamicReference;
-  cssImports?: string[];
+  id: string
+  file: string
+  exportName: string
+  dynamic?: ClientDynamicReference
+  cssImports?: string[]
   /**
    * A `'use client'` module imported only for its side effects (a bare
    * `import './client-only'` with no bindings). It is never rendered as a
@@ -14,21 +14,21 @@ export interface ClientReference {
    * client entry (a bare side-effect import) to run its top-level code. It has
    * no SSR component, so it is excluded from every server-side marking pass.
    */
-  sideEffect?: boolean;
+  sideEffect?: boolean
 }
 
 export interface ClientDynamicReference {
-  load?: 'render' | 'visible';
-  rootMargin?: string;
-  ssr?: boolean;
-  threshold?: number | number[];
+  load?: 'render' | 'visible'
+  rootMargin?: string
+  ssr?: boolean
+  threshold?: number | number[]
 }
 
-export const clientReferenceSymbol = Symbol.for('pnext.clientReference');
+export const clientReferenceSymbol = Symbol.for('pnext.clientReference')
 
 export type ClientComponent = ((props: Record<string, unknown>) => unknown) & {
-  [clientReferenceSymbol]?: ClientReference;
-};
+  [clientReferenceSymbol]?: ClientReference
+}
 
 export function clientReferenceId(file: string, exportName: string) {
   return createHash('sha256')
@@ -36,12 +36,12 @@ export function clientReferenceId(file: string, exportName: string) {
     .update('\0')
     .update(exportName)
     .digest('hex')
-    .slice(0, 10);
+    .slice(0, 10)
 }
 
 export function ssrClientReference(reference: Pick<ClientReference, 'dynamic' | 'sideEffect'>) {
-  if (reference.sideEffect) return false;
-  if (reference.dynamic?.ssr === false) return false;
-  if (reference.dynamic?.load === 'visible' && reference.dynamic.ssr !== true) return false;
-  return true;
+  if (reference.sideEffect) return false
+  if (reference.dynamic?.ssr === false) return false
+  if (reference.dynamic?.load === 'visible' && reference.dynamic.ssr !== true) return false
+  return true
 }