@volter/editor-core 0.5.57

package/server/play-stall.ts

@@ -0,0 +1,126 @@
+/**
+ * THE ANSWER A STUCK PLAY OWES ITS CALLER.
+ *
+ * ## What this replaces
+ *
+ * Measured 2026-08-20 with `packages/editor/scripts/scale-harness`, canvas lane,
+ * N=20000, four consecutive runs. `vgai play` spent its full 120s budget and was
+ * refused with
+ *
+ *     Command timed out — the tab is present (last heartbeat 0.8s ago) and
+ *     did not respond.
+ *
+ * and then `screenshot` (15s) and `stop` (30s) were refused with that same
+ * sentence. Three silent timeouts in a row, and every reader — `vgai status`,
+ * the tab table, the journal — described a healthy session, because the
+ * heartbeat is a WORKER and kept beating at 0.4s while the page's main thread
+ * sat inside one 199.5-second synchronous block.
+ *
+ * The sentence was true and useless. It named the tab (fine), the beat (fine),
+ * and nothing about the eight-step boot that was actually stuck.
+ *
+ * ## The rule
+ *
+ * The page publishes each play-boot phase BEFORE that phase's work starts
+ * (`src/play-boot-phase.ts`), on the control channel, as its own tiny message —
+ * never inside the state snapshot, which is the expensive derivation a wedged
+ * page cannot produce. So the server always holds the phase the page was
+ * ENTERING when it went quiet, and this module turns that into the refusal, the
+ * journal row and the console entry.
+ *
+ * Pure and clock-injected: no I/O, no globals. `test/play-stall.test.ts` drives
+ * every branch directly.
+ */
+
+/** What the page last said about its play boot, as the server holds it. */
+export interface PlayPhaseRecord {
+  /** The phase being entered, or `null` once the boot settled either way. */
+  readonly phase: string | null;
+  /** Page clock: when it entered that phase. Never used for arithmetic — the
+   *  two clocks are not the same clock — only carried for the record. */
+  readonly at: number;
+  /** The play attempt's ordinal on the page. */
+  readonly run: number;
+  /** SERVER clock: when this report landed. Every age below is measured from
+   *  here, because it is the only timestamp both parties agree on. */
+  readonly receivedAt: number;
+}
+
+/** Commands whose timeout is about play whether or not a boot is in flight. */
+const PLAY_FAMILY = new Set(['play', 'restart', 'stop', 'pause', 'resume', 'step']);
+
+export interface PlayStallDiagnosis {
+  /** The full refusal the caller receives. */
+  readonly message: string;
+  /** The phase named, or `null` when no boot was in flight. */
+  readonly phase: string | null;
+  /** How long the page had been in it when the command expired, or `null`. */
+  readonly phaseAgeMs: number | null;
+}
+
+/**
+ * Compose the refusal for a relayed command that ran out of budget.
+ *
+ * `base` is the sentence the relay already produces (`Command timed out — the
+ * tab is present (…) and did not respond.`). It is kept VERBATIM and only
+ * extended: the CLI's own retry classifier matches fragments of these
+ * refusals (`vgai-cli/src/play-retry.ts`), and a rewritten message would
+ * silently change which failures it treats as retryable.
+ */
+export function playStallDiagnosis(args: {
+  readonly command: unknown;
+  readonly base: string;
+  readonly phase: PlayPhaseRecord | null;
+  readonly now: number;
+}): PlayStallDiagnosis {
+  const { base, phase, now } = args;
+  const command = typeof args.command === 'string' ? args.command : '';
+  const booting = phase !== null && phase.phase !== null;
+
+  if (booting) {
+    const ageMs = Math.max(0, now - phase.receivedAt);
+    return {
+      phase: phase.phase,
+      phaseAgeMs: ageMs,
+      message:
+        `${base} The page is still inside "${phase.phase}" — it entered that step ` +
+        `${(ageMs / 1000).toFixed(1)}s ago and has not left it. The page's own main thread is ` +
+        'inside that step; the heartbeat above is a worker, which is why the tab looks healthy ' +
+        'while nothing the page owns can answer. `volter-editor status` names the same phase, and the ' +
+        'session journal has the row.',
+    };
+  }
+
+  if (PLAY_FAMILY.has(command)) {
+    const settled = phase === null ? null : Math.max(0, now - phase.receivedAt);
+    const when =
+      settled === null
+        ? 'this session has never reported one'
+        : `the last one settled ${(settled / 1000).toFixed(1)}s ago`;
+    return {
+      phase: null,
+      phaseAgeMs: null,
+      message:
+        `${base} No play boot is in flight (${when}), so the page went quiet somewhere other ` +
+        'than play start — a heartbeat proves the tab, never the page.',
+    };
+  }
+
+  return { phase: null, phaseAgeMs: null, message: base };
+}
+
+/**
+ * The console-ledger condition text for a stalled command.
+ *
+ * Deliberately keyed on the PHASE and not on the elapsed time: the ledger
+ * fingerprints on the message, so putting a duration in it would make every
+ * occurrence a fresh condition and turn a repeating stall into a wall of
+ * one-count rows — the exact dedup failure `console-ledger.ts` exists to
+ * prevent, in the other direction.
+ */
+export function playStallConsoleMessage(command: unknown, phase: string | null): string {
+  const verb = typeof command === 'string' && command.length > 0 ? command : 'a command';
+  return phase === null
+    ? `\`${verb}\` timed out against a beating tab whose page never answered, with no play boot in flight.`
+    : `\`${verb}\` timed out while the page was inside "${phase}".`;
+}

package/server/process-shutdown.ts

@@ -0,0 +1,218 @@
+import { type ChildProcess, execFileSync } from 'node:child_process';
+import type { Server } from 'node:http';
+
+/** How long a detached child gets between SIGTERM and SIGKILL when its caller
+ *  does not say. A caller INSIDE the session's shutdown list passes a smaller
+ *  number, because its own budget is smaller than this — see
+ *  `createProcessShutdown`'s note on the arithmetic. */
+const DEFAULT_STOP_GRACE_MS = 5_000;
+
+/**
+ * Terminate a detached child and its whole process tree. Shared by the e2e
+ * server harness and the packaged E2E runner: keeping this under `server/`
+ * makes the runtime utility part of the editor package instead of forcing a
+ * published command to import an unshipped e2e helper.
+ *
+ * `graceMs` is the SIGTERM→SIGKILL window. It is a parameter because the
+ * session's shutdown list has a tighter budget than this default: a child that
+ * outlives its caller's own exit is an ORPHAN holding a reserved port, so the
+ * escalation has to complete inside the caller's window, not after it.
+ */
+export function stopProcess(proc: ChildProcess, graceMs = DEFAULT_STOP_GRACE_MS): Promise<void> {
+  const signalGroup = (signal: NodeJS.Signals) => {
+    if (proc.pid === undefined) return;
+    if (process.platform === 'win32') {
+      try {
+        execFileSync('taskkill', ['/PID', String(proc.pid), '/T', '/F'], { stdio: 'ignore' });
+      } catch {
+        /* already dead, or taskkill unavailable */
+      }
+      try {
+        proc.kill(signal);
+      } catch {
+        /* already dead */
+      }
+      return;
+    }
+    try {
+      process.kill(-proc.pid, signal);
+    } catch {
+      try {
+        proc.kill(signal);
+      } catch {
+        /* already dead */
+      }
+    }
+  };
+
+  return new Promise((resolve) => {
+    if (proc.exitCode !== null || proc.signalCode !== null) {
+      signalGroup('SIGKILL');
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      signalGroup('SIGKILL');
+      resolve();
+    }, graceMs);
+    proc.on('exit', () => {
+      clearTimeout(timer);
+      signalGroup('SIGKILL');
+      resolve();
+    });
+    signalGroup('SIGTERM');
+  });
+}
+
+/**
+ * ONE RESOURCE THIS SESSION IS STOPPING, and the name a post-mortem will read.
+ *
+ * The name is required because the failure this list exists to survive is
+ * UNATTENDED: a task that never settles is only visible as the ABSENCE of
+ * everything after it, and "cleanup timed out" with no name leaves a reader
+ * guessing which resource is still alive.
+ */
+export interface ShutdownTask {
+  /** What this stops, in the words a journal line should carry. */
+  readonly name: string;
+  run(): void | Promise<void>;
+}
+
+export interface ProcessShutdownOptions {
+  /** The WHOLE list's backstop. Bigger than `taskTimeoutMs` and nothing more:
+   *  with every task bounded and independent, the list's own duration is the
+   *  slowest task's, and this only catches a bug in the bounding itself. */
+  timeoutMs?: number;
+  /** Each task's OWN bound. See the note on `createProcessShutdown`. */
+  taskTimeoutMs?: number;
+  tasks: ReadonlyArray<ShutdownTask>;
+  exit?: (code: number) => void;
+  log?: (message: string) => void;
+  /** Where a task that did not finish, or threw, is RECORDED — the session
+   *  journal, handed in by the host because this module owns no project. */
+  journal?: (record: {
+    readonly task: string;
+    readonly outcome: 'timeout' | 'failed';
+    readonly ms: number;
+    readonly detail?: string;
+  }) => void;
+}
+
+/** Stop accepting requests and forcibly release persistent HTTP/SSE sockets. */
+export function closeHttpServer(server: Server): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (!server.listening) {
+      server.closeAllConnections?.();
+      resolve();
+      return;
+    }
+    server.close((error) => (error ? reject(error) : resolve()));
+    // `server.close()` waits for persistent SSE/keep-alive connections. They
+    // have no useful work after process shutdown begins, so close them after
+    // removing the listener and eliminate the restart race on the HTTP port.
+    server.closeAllConnections?.();
+  });
+}
+
+/**
+ * Build an idempotent, bounded signal handler.
+ *
+ * Node's default signal exit is disabled as soon as an application installs
+ * a SIGTERM/SIGINT listener. Tooling loaders (notably tsx/esbuild) may retain
+ * internal handles even after every application server and watcher closes,
+ * so waiting for an empty event loop is not a shutdown contract. Resources
+ * get one bounded graceful window and then the process exits explicitly.
+ *
+ * EVERY TASK RUNS INDEPENDENTLY AND EVERY TASK IS BOUNDED BY ITSELF. Both
+ * halves were bought by one measurement (2026-09-21, load average ~30, one
+ * `vgai close`): the session's journal had no `session-shutdown` line, the
+ * Code-OSS server survived as PPID 1 still holding its reserved `frame` port,
+ * and the next `vgai edit` refused by name. A shared bound is what makes one
+ * slow resource spend everybody's window, and the arithmetic has to close:
+ * `vgai close` SIGTERMs, waits 5.5 s and SIGKILLs the session's process GROUP —
+ * which never reaches the Code-OSS server, because that child is spawned
+ * detached into a group of its own. So the last of these tasks has to have
+ * FINISHED by then, not merely started, or a child outlives its parent with
+ * nobody left to signal it.
+ *
+ * A TASK THAT DOES NOT FINISH IS NAMED (`journal`), because the only other
+ * evidence it leaves is the absence of everything downstream of it.
+ */
+export function createProcessShutdown(
+  options: ProcessShutdownOptions,
+): (why: string) => Promise<void> {
+  // 4 s per task, 4.8 s for the list: the whole shutdown fits inside `vgai
+  // close`'s 5.5 s grace with room for the process's own exit, which the old
+  // 2 s tab wait plus a 5 s shared cleanup budget did not. The 4 s is sized so
+  // a task that must follow the tab-close notice (whose own budget is 2 s)
+  // still has ~2 s of its own — see dev.ts's list.
+  const taskTimeoutMs = options.taskTimeoutMs ?? 4_000;
+  const timeoutMs = options.timeoutMs ?? 4_800;
+  const exit = options.exit ?? ((code: number) => process.exit(code));
+  const log = options.log ?? ((message: string) => process.stderr.write(`${message}\n`));
+  const journal = options.journal ?? (() => {});
+  let pending: Promise<void> | null = null;
+
+  /** One task, bounded by itself. Rejects with the task's NAME in the message,
+   *  so the aggregate line below reads as a list of resources. */
+  const runTask = async (task: ShutdownTask): Promise<void> => {
+    const startedAt = Date.now();
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const outcome = await Promise.race([
+        Promise.resolve(task.run()).then(() => 'done' as const),
+        new Promise<'timeout'>((resolve) => {
+          timer = setTimeout(() => resolve('timeout'), taskTimeoutMs);
+        }),
+      ]);
+      if (outcome === 'timeout') {
+        journal({ task: task.name, outcome: 'timeout', ms: Date.now() - startedAt });
+        throw new Error(`${task.name} did not finish within ${taskTimeoutMs}ms`);
+      }
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      if (!detail.endsWith(`within ${taskTimeoutMs}ms`))
+        journal({ task: task.name, outcome: 'failed', ms: Date.now() - startedAt, detail });
+      throw error;
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  };
+
+  return (why: string) => {
+    if (pending) return pending;
+    pending = (async () => {
+      let timeout: ReturnType<typeof setTimeout> | undefined;
+      const cleanup = Promise.allSettled(options.tasks.map(runTask));
+      const result = await Promise.race([
+        cleanup.then((settled) => ({ type: 'settled' as const, settled })),
+        new Promise<{ type: 'timeout' }>((resolve) => {
+          timeout = setTimeout(() => resolve({ type: 'timeout' }), timeoutMs);
+        }),
+      ]);
+      if (timeout) clearTimeout(timeout);
+
+      if (result.type === 'timeout') {
+        log(`[vgai-editor] cleanup timed out after ${timeoutMs}ms (${why}); forcing exit`);
+        exit(1);
+        return;
+      }
+      const failures = result.settled.filter(
+        (item): item is PromiseRejectedResult => item.status === 'rejected',
+      );
+      if (failures.length > 0) {
+        log(
+          `[vgai-editor] cleanup failed (${why}): ${failures
+            .map((item) =>
+              item.reason instanceof Error ? item.reason.message : String(item.reason),
+            )
+            .join('; ')}`,
+        );
+        exit(1);
+        return;
+      }
+      exit(0);
+    })();
+    return pending;
+  };
+}

package/server/product-presets.ts

@@ -0,0 +1,55 @@
+/**
+ * WHAT THIS SESSION'S PRODUCT CAN CREATE — the New Project screen's half of
+ * the declaration a product's `bin` reads.
+ *
+ * CREATION IS THE PRODUCT'S (ARCHITECTURE-CORE §The target shape, rule 1): the
+ * presets, their names and what a project declares live in
+ * `<product>/presets.mjs`, never in the kit. The CLI reads that file when
+ * a person types `<product> create`; this session reads the SAME file, of the
+ * SAME product it is already serving, so the wizard and the command line
+ * cannot offer different compositions.
+ *
+ * Plain ESM, dynamically imported: the declaration is a product's code, not a
+ * config, and a running session must not compile it.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { assertProductCreateDeclaration, type ProductCreateDeclaration } from '@volter/editor-sdk/session/product-create';
+import { sessionProduct } from './session-product';
+
+/**
+ * Where a product declares its presets, relative to its package root. Beside
+ * `src/`, never inside it: `src/` is the product's FRAME entry — the one module
+ * its workbench build compiles — and this declaration is read by Node, at the
+ * command line and here, and compiled by nothing.
+ */
+export const PRODUCT_PRESETS_PATH = 'presets.mjs';
+
+export interface ProductCreatePresets {
+  readonly declaration: ProductCreateDeclaration;
+  /** The file it came from — every refusal names it. */
+  readonly source: string;
+}
+
+/**
+ * The create declaration of the product this session serves, or `null` when
+ * there is no product to ask (no project open, or a project that declares
+ * none). A product that exists but ships no declaration THROWS: it is a broken
+ * product, and a wizard silently offering nothing is how that stays unnoticed.
+ */
+export async function sessionCreatePresets(
+  projectPath: string | null,
+): Promise<ProductCreatePresets | null> {
+  const product = sessionProduct(projectPath);
+  if (product === null) return null;
+  const source = join(product.dir, PRODUCT_PRESETS_PATH);
+  if (!existsSync(source))
+    throw new Error(
+      `${product.name} declares no create presets (${source} is missing), so this session cannot ` +
+        'create a project. A product owns its own compositions — see ' +
+        '@volter/editor-sdk/session/product-create for its executable declaration.',
+    );
+  const module = (await import(pathToFileURL(source).href)) as { default?: unknown };
+  return { declaration: assertProductCreateDeclaration(module.default, source), source };
+}

package/server/project-build-artifact.ts

@@ -0,0 +1,95 @@
+/**
+ * Packages the OPEN PROJECT'S native `dist/` after its own `npm run build`.
+ * The zip is an ordinary web artifact and the report is ephemeral editor
+ * telemetry — neither creates an editor-private project format.
+ */
+
+import type { Dirent } from 'node:fs';
+import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import {
+  type BuildReport,
+  type BuildReportFile,
+  WEB_BUILD_ARTIFACT,
+} from '@volter/editor-sdk/session/build-report';
+import { zipSync } from 'fflate';
+import { resolveManifestPath } from '@volter/editor-project/manifest/locate';
+
+interface OutputFile extends BuildReportFile {
+  readonly absolutePath: string;
+}
+
+function portablePath(path: string): string {
+  return path.split(sep).join('/');
+}
+
+async function collectFiles(root: string, directory = root): Promise<OutputFile[]> {
+  let entries: Dirent[];
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+      throw new Error(
+        `The project's build completed without creating ${root}. ` +
+          'Its native build script must emit a static dist/ directory.',
+      );
+    }
+    throw error;
+  }
+
+  const files: OutputFile[] = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const absolutePath = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await collectFiles(root, absolutePath)));
+    } else if (entry.isFile()) {
+      files.push({
+        absolutePath,
+        path: portablePath(relative(root, absolutePath)),
+        bytes: (await stat(absolutePath)).size,
+      });
+    }
+  }
+  return files;
+}
+
+/** The ignored, machine-local artifact used by the editor's Download action. */
+export function projectBuildArtifactPath(projectRoot: string): string {
+  return resolve(projectRoot, '.vgai', 'tmp', 'build', WEB_BUILD_ARTIFACT);
+}
+
+export async function packageProjectWebBuild(projectRoot: string): Promise<BuildReport> {
+  const distRoot = resolve(projectRoot, 'dist');
+  const files = await collectFiles(distRoot);
+  if (files.length === 0) {
+    throw new Error(`The project's native build emitted an empty ${distRoot}.`);
+  }
+
+  const archive: Record<string, Uint8Array> = Object.create(null) as Record<string, Uint8Array>;
+  for (const file of files) archive[file.path] = await readFile(file.absolutePath);
+
+  // Keep the native manifest beside the static output, matching the existing
+  // deploy staging contract. If a custom build already emitted one, the source
+  // manifest is the authority and intentionally replaces it.
+  archive['vgai.project.json'] = await readFile(resolveManifestPath(projectRoot));
+
+  const bytes = zipSync(archive, { level: 6 });
+  const artifactPath = projectBuildArtifactPath(projectRoot);
+  await mkdir(dirname(artifactPath), { recursive: true });
+  await writeFile(artifactPath, bytes);
+
+  const outputBytes = files.reduce((sum, file) => sum + file.bytes, 0);
+  const largestFiles = files
+    .map(({ path, bytes }) => ({ path, bytes }))
+    .sort((a, b) => b.bytes - a.bytes || a.path.localeCompare(b.path))
+    .slice(0, 12);
+
+  return {
+    artifact: WEB_BUILD_ARTIFACT,
+    artifactBytes: bytes.byteLength,
+    outputBytes,
+    fileCount: files.length,
+    largestFiles,
+  };
+}

package/server/project-components.ts

@@ -0,0 +1,100 @@
+import type { Dirent } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+import { resolveManifestPath } from '@volter/editor-project/manifest/locate';
+import type { ProjectComponentEntry } from '../src/asset-workflow/project-content';
+import {
+  compareProjectComponents,
+  discoverComponentsInSource,
+  type IndexedProjectSource,
+  omitRootDocumentComponents,
+  projectFileSurfaces,
+  projectRegionEntries,
+  projectRootEntries,
+  reportUnreadableRegions,
+} from '../src/asset-workflow/project-source-index';
+import { ADAPTER_MODULE_FILENAME } from '../src/ui-source/adapter-region-includes';
+
+/**
+ * ABSENT resolves `null`; every OTHER failure rejects — the contract
+ * {@link projectRegionEntries} reads, and the classification only this side
+ * (which knows the backend is Node's fs) can make. A blanket
+ * `.catch(() => '')` here would report a permissions error or a corrupt file
+ * as "this project declares nothing", which is a declaration it never made.
+ */
+async function readOptionalFile(path: string): Promise<string | null> {
+  try {
+    return await readFile(path, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+const SOURCE_EXTENSION = /\.(?:[cm]?[jt]sx)$/i;
+const SKIPPED_DIRECTORIES = new Set(['node_modules', 'dist', 'build', '.git', '.vgai', 'tools']);
+
+function indexSourceEntry(
+  directory: string,
+  entry: Dirent,
+  pending: string[],
+  files: string[],
+): void {
+  const absolute = join(directory, entry.name);
+  if (entry.isDirectory()) {
+    if (!SKIPPED_DIRECTORIES.has(entry.name) && !entry.name.startsWith('.')) {
+      pending.push(absolute);
+    }
+    return;
+  }
+  if (entry.isFile() && SOURCE_EXTENSION.test(entry.name)) files.push(absolute);
+}
+
+export async function discoverProjectComponents(
+  projectRoot: string,
+): Promise<ProjectComponentEntry[]> {
+  const pending = [join(projectRoot, 'src')];
+  const files: string[] = [];
+  // Same ENOENT-only rule as `readOptionalFile` above: a missing directory
+  // is an honest "nothing declared here"; a permissions error or I/O failure
+  // is NOT — swallowing it would render a short component list as a fact
+  // about the project.
+  const enoentEmpty = (error: unknown): never[] => {
+    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') return [];
+    throw error;
+  };
+  while (pending.length > 0 && files.length < 512) {
+    const directory = pending.shift()!;
+    const entries = await readdir(directory, { withFileTypes: true }).catch(enoentEmpty);
+    for (const entry of entries) indexSourceEntry(directory, entry, pending, files);
+  }
+  const sources = (
+    await Promise.all(
+      files.map(async (absolute): Promise<IndexedProjectSource[]> => {
+        const path = relative(projectRoot, absolute).split(sep).join('/');
+        return readFile(absolute, 'utf8')
+          .then((source) => [{ path, source }])
+          .catch(enoentEmpty);
+      }),
+    )
+  ).flat();
+  // A file's surface is its REGION, resolved by the one shared resolver from
+  // this project's declarations and its own import edges — never from whichever
+  // library a file happens to name in its text.
+  const { regions, unreadable } = await projectRegionEntries(
+    () => readOptionalFile(resolveManifestPath(projectRoot)),
+    () => readOptionalFile(join(projectRoot, ADAPTER_MODULE_FILENAME)),
+  );
+  // Never dropped: the real loader evaluates the module and WOULD honor an
+  // `include` this static read could not see, so an unreported `unreadable`
+  // is the two readers disagreeing with nobody told.
+  if (unreadable) reportUnreadableRegions(projectRoot, unreadable);
+  const surfaces = projectFileSurfaces(sources, regions);
+  const discovered = sources.flatMap((file) =>
+    discoverComponentsInSource(file.source, file.path, surfaces.get(file.path) ?? 'unknown'),
+  );
+  const rootEntries = await projectRootEntries(() =>
+    readFile(resolveManifestPath(projectRoot), 'utf8'),
+  );
+  return omitRootDocumentComponents(discovered, rootEntries).sort(compareProjectComponents);
+}