@volter/editor-game 0.5.65

package/src/build/build-session.ts

@@ -0,0 +1,247 @@
+/**
+ * THE BUILD SESSION — one truth for the three build surfaces this package
+ * contributes (the Build Profiles document, the native Output channel and
+ * the build-progress status item). Module scope on purpose: the old bottom
+ * BUILD tab lost its log whenever the pane unmounted mid-build, so the
+ * session outlives any one surface.
+ *
+ * Builds spawn `npm run <script>` on the editor's dev server, which is the
+ * only place a project's own scripts run.
+ *
+ * `startBuild` reveals the native Build output channel through the host door.
+ */
+
+import {
+  listConfigurations,
+  startBuild as startBuildConfiguration,
+} from '../host/api/configurations';
+import type { EditorHostOutputDiagnostic } from '@volter/editor-sdk/host';
+import { editorHost } from '@volter/editor-sdk/host';
+import type { BuildReport } from '@volter/editor-sdk/session/build-report';
+import { useEffect, useState } from 'react';
+import { formatBytes } from './format-bytes';
+
+const BUILD_OUTPUT_ID = 'build';
+
+/** The Build Profiles document's contribution id (`build-profiles.document.tsx`),
+ *  as `workspace.openContributedDocument` names it. */
+export const BUILD_PROFILES_DOCUMENT_ID = 'build-profiles.document';
+
+/** Open (or activate) the Build Profiles document — what every build entry
+ *  point does: the header's Export button, the palette's build actions, the
+ *  Window menu and the `show-build` verb. */
+export function openBuildProfilesDocument(): boolean {
+  return editorHost().workspace.openContributedDocument(BUILD_PROFILES_DOCUMENT_ID);
+}
+
+/** A build-role configuration's id (ARCHITECTURE-CORE §The project model). */
+export type BuildTarget = string;
+export type BuildPhase = 'idle' | 'building' | 'done';
+
+export interface BuildResult {
+  ok: boolean;
+  code: number | null;
+  report?: BuildReport;
+}
+
+export interface BuildProfile {
+  readonly id: BuildTarget;
+  readonly label: string;
+  readonly subtitle: string;
+}
+
+/** The project's build-role configurations, as profiles. Empty until the
+ *  manifest declares one; nothing is assumed. */
+export function useBuildProfiles(): readonly BuildProfile[] {
+  const [profiles, setProfiles] = useState<readonly BuildProfile[]>([]);
+  useEffect(() => {
+    let cancelled = false;
+    void listConfigurations()
+      .then((all) => {
+        if (cancelled) return;
+        setProfiles(
+          all
+            .filter((c) => c.role === 'build')
+            .map((c) => ({ id: c.id, label: c.id, subtitle: c.describe ?? c.kind })),
+        );
+      })
+      .catch(() => {
+        if (!cancelled) setProfiles([]);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return profiles;
+}
+
+export interface BuildSession {
+  readonly phase: BuildPhase;
+  readonly target: BuildTarget;
+  readonly log: readonly string[];
+  readonly result: BuildResult | null;
+}
+
+let _session: BuildSession = { phase: 'idle', target: '', log: [], result: null };
+let _version = 0;
+const _listeners = new Set<() => void>();
+let _abort: AbortController | null = null;
+
+function setSession(patch: Partial<BuildSession>): void {
+  _session = { ..._session, ...patch };
+  _version++;
+  publishBuildOutput();
+  for (const fn of _listeners) fn();
+}
+
+/** Subscribe to build-session changes. Returns unsubscribe. */
+export function subscribeBuildSession(fn: () => void): () => void {
+  _listeners.add(fn);
+  return () => {
+    _listeners.delete(fn);
+  };
+}
+
+/** Monotonic change counter — the `getSnapshot` for `useSyncExternalStore`. */
+export function buildSessionVersion(): number {
+  return _version;
+}
+
+/** The current build session (stable reference between changes). */
+export function getBuildSession(): BuildSession {
+  return _session;
+}
+
+/** Back to idle (the `Build Again` reset). No-op mid-build. */
+export function resetBuildSession(): void {
+  if (_session.phase === 'building') return;
+  setSession({ phase: 'idle', log: [], result: null });
+}
+
+/** Abort a running build (the old panel's Cancel, unchanged semantics). */
+export function cancelBuild(): void {
+  _abort?.abort();
+  setSession({ phase: 'idle' });
+}
+
+/** The build log is an Output channel; failures with source locations also reach Problems. */
+export function showBuildOutput(): void {
+  publishBuildOutput();
+  editorHost().output.show(BUILD_OUTPUT_ID);
+}
+
+function publishBuildOutput(): void {
+  const session = getBuildSession();
+  let text = session.log.length ? `${session.log.join('\n')}\n` : '';
+  if (session.phase === 'done' && session.result) {
+    text += `\n${session.result.ok ? 'Build complete.' : `Build failed (exit code: ${session.result.code ?? 'unknown'}).`}\n`;
+    if (session.result.report) {
+      const report = session.result.report;
+      text += `${formatBytes(report.artifactBytes)} package · ${formatBytes(report.outputBytes)} output · ${report.fileCount} files\n`;
+    }
+  }
+  editorHost().output.write(BUILD_OUTPUT_ID, 'Build', text, buildDiagnostics(text));
+}
+
+/** Only explicit compiler locations become markers. Unlocated failures stay in Output. */
+export function buildDiagnostics(text: string): EditorHostOutputDiagnostic[] {
+  const diagnostics: EditorHostOutputDiagnostic[] = [];
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: compiler logs contain ANSI SGR escapes.
+  const plain = text.replace(/\u001b\[[0-9;]*m/g, '');
+  for (const line of plain.split(/\r?\n/)) {
+    // TypeScript pretty and plain forms; esbuild's explicit file:line:column errors.
+    const match =
+      line.match(/^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s+(.*)$/) ??
+      line.match(/^(.+?):(\d+):(\d+)\s*[-:]?\s*(error|warning)\s*:?[ ]*(.*)$/i);
+    if (!match) continue;
+    const path = match[1]!.trim();
+    if (path.startsWith('/') || path.split(/[\\/]/).includes('..')) continue;
+    diagnostics.push({
+      path,
+      line: Math.max(1, Number(match[2])),
+      column: Math.max(1, Number(match[3])),
+      severity: match[4]!.toLowerCase() === 'warning' ? 'warning' : 'error',
+      message: match[5]!,
+    });
+  }
+  return diagnostics;
+}
+
+/**
+ * Run a build — the `startExport` SSE stream, consumed at module scope so the
+ * session outlives any one surface. Reveals the Build Output tab so the log
+ * has somewhere visible to stream.
+ */
+export async function startBuild(target: BuildTarget): Promise<void> {
+  if (_session.phase === 'building') return;
+  setSession({ phase: 'building', target, log: [], result: null });
+  showBuildOutput();
+
+  const controller = new AbortController();
+  _abort = controller;
+
+  try {
+    const res = await startBuildConfiguration(target, controller.signal);
+
+    if (!res.ok) {
+      const err = (await res.json().catch(() => ({ error: 'Build request failed' }))) as {
+        error?: string;
+      };
+      setSession({
+        phase: 'done',
+        log: [..._session.log, `Error: ${err.error ?? res.statusText}`],
+        result: { ok: false, code: null },
+      });
+      return;
+    }
+
+    const reader = res.body!.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+
+      const parts = buffer.split('\n\n');
+      buffer = parts.pop()!;
+
+      for (const part of parts) {
+        if (part.startsWith(':')) continue;
+        const lines = part.split('\n');
+        let event = '';
+        let data = '';
+        for (const line of lines) {
+          if (line.startsWith('event: ')) event = line.slice(7);
+          else if (line.startsWith('data: ')) data = line.slice(6);
+        }
+        if (event === 'log') {
+          let lineText: string;
+          try {
+            lineText = JSON.parse(data) as string;
+          } catch {
+            lineText = data;
+          }
+          setSession({ log: [..._session.log, lineText] });
+        } else if (event === 'done') {
+          let result: BuildResult;
+          try {
+            result = JSON.parse(data) as BuildResult;
+          } catch {
+            result = { ok: false, code: null };
+          }
+          setSession({ phase: 'done', result });
+        }
+      }
+    }
+  } catch (err: unknown) {
+    if ((err as Error).name !== 'AbortError') {
+      setSession({
+        phase: 'done',
+        log: [..._session.log, `Error: ${(err as Error).message}`],
+        result: { ok: false, code: null },
+      });
+    }
+  }
+}

package/src/build/format-bytes.ts

@@ -0,0 +1,14 @@
+/** Byte sizes as the build surfaces print them (B / KB / MB / GB, two
+ *  significant places under 10). Shared by the output log's result line and
+ *  the Build Profiles document's report summary. */
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ['KB', 'MB', 'GB'];
+  let value = bytes / 1024;
+  let unit = units[0]!;
+  for (let index = 1; index < units.length && value >= 1024; index++) {
+    value /= 1024;
+    unit = units[index]!;
+  }
+  return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${unit}`;
+}

package/src/command-results.ts

@@ -0,0 +1,36 @@
+/**
+ * The two result builders the game skew's command verbs answer with — copied
+ * out of the editor's `command-listener.ts` with the verbs that used them
+ * (WORK.md §The workbench), because they are result SHAPES, not host API: a
+ * few lines of object literal each, owned by whoever produces the answer.
+ *
+ * They live in `src/` rather than inside one contribution module because
+ * three of this package's command contributions (`gameplay`, `bridge`,
+ * `game-eval`) answer with the same two shapes, and a third copy of a
+ * structured-error mapping is how `data.code` drifts between verbs the SDK
+ * matches on by code.
+ */
+
+import type { EditorCommandResult } from '@volter/editor-sdk/commands';
+
+/** The genuinely-no-live-world answer: a structured failure, never a
+ *  fabricated success. */
+export const notPlayingResult = (): EditorCommandResult => ({
+  ok: false,
+  error: 'not in play mode — start play before using the debug seam',
+});
+
+/** Surface a thrown engine error carrying a machine-readable `code`
+ *  (`DebugError`, `InputActionError` — duck-typed, so no engine-module
+ *  identity coupling) as a structured relay failure: `data.code` plus the
+ *  error's own data (registered-name lists, zod issues). The SDK maps these
+ *  to operation error codes — never by parsing message prose. */
+export function structuredErrorResult(err: unknown): EditorCommandResult {
+  const message = err instanceof Error ? err.message : String(err);
+  const e = err as { code?: unknown; data?: unknown };
+  if (typeof e?.code === 'string') {
+    const extra = typeof e.data === 'object' && e.data !== null ? e.data : {};
+    return { ok: false, error: message, data: { ...extra, code: e.code } };
+  }
+  return { ok: false, error: message };
+}

package/src/coverage/live-authoring-surface.ts

@@ -0,0 +1,30 @@
+/**
+ * Project-level authoring-surface coverage: the Edit documents and Content
+ * pieces the resolved adapter table actually presents. Runtime capture alone
+ * cannot answer this; a game may mount perfectly while exposing no authoring
+ * surface at all.
+ */
+
+import {
+  type CapabilityCoverageReport,
+  deriveCapabilityCoverage,
+} from '../host/coverage/capability-coverage';
+import { projectAdapterFacet } from '@volter/editor-core/project-adapter';
+import { getCurrentProject } from '@volter/editor-core/project-manager';
+import { authoringSurfaceFromTable } from '@volter/editor-core/scene-document-plan';
+import { projectStoriesReady } from '@volter/editor-core/stories/story-registry';
+import { availableWorkspaceDocuments } from '@volter/editor-core/workspace-available-documents';
+import { openWorkspaceDocuments } from '@volter/editor-core/workspace-document-registry';
+
+export function authoringSurfaceCoverage(): CapabilityCoverageReport | null {
+  const facet = projectAdapterFacet();
+  if (!facet || !projectStoriesReady()) return null;
+  return deriveCapabilityCoverage({
+    worldId: getCurrentProject()?.config.name ?? 'project',
+    authoringSurface: authoringSurfaceFromTable(
+      facet.scenes,
+      openWorkspaceDocuments().map((document) => document.descriptor.id),
+      availableWorkspaceDocuments().map((document) => document.descriptor.id),
+    ),
+  });
+}

package/src/coverage/live-project-verbs.ts

@@ -0,0 +1,162 @@
+/**
+ * THE `project.*` COVERAGE OF THE OPEN PROJECT — the live half of
+ * `coverage/project-verb-coverage.ts`.
+ *
+ * It reads the session's own singletons plus two project files the browser
+ * cannot read for itself, and hands the facts to the pure derivation. The
+ * report goes out the doors coverage already uses — `vgai status`'s
+ * `projectCoverage` facet, and the editor console via
+ * `coverage/session-coverage.ts`, which unions this family with the other two
+ * so one headline counts them all. No new transport, no new panel: the console
+ * sync forwards every warning to the server's unresolved ledger, which is what
+ * makes an absent verb a STANDING condition rather than a line somebody
+ * scrolled past.
+ *
+ * ## Why this family does NOT stand down for an ingested mount
+ *
+ * `coverage/native-system-coverage.ts` steps aside for an ingest because that
+ * lane has a STRONGER measurement of the same slots (the game's declared
+ * carrier). Nothing of the sort exists here: "can this project build" is a
+ * question about the opened PROJECT, and a vendored game opened as a
+ * project has it just as much as a scaffolded one. One producer, both lanes —
+ * which is also why every other report passes `projectVerbs: []`.
+ *
+ * ## Asking is part of the job
+ *
+ * The file-facts source is cached-on-first-ask and asked by nothing else, so
+ * this module KICKS OFF the read rather than reporting `unanswered` forever —
+ * a row whose whole point is "nobody looked" must not be the reason nobody
+ * looks.
+ */
+
+import {
+  type CapabilityCoverageReport,
+  deriveCapabilityCoverage,
+} from '../host/coverage/capability-coverage';
+import {
+  measureProjectVerbs,
+  type ProjectRootFact,
+  type ProjectVerbFacts,
+} from '../host/coverage/project-verb-coverage';
+import { editorServerJson } from '@volter/editor-core/editor-server-response';
+import { getCurrentProject } from '@volter/editor-core/project-manager';
+
+/** What the server answers on `/__editor/project-verbs` — facts only. */
+interface ProjectFileFacts {
+  readonly scripts: readonly string[] | null;
+  readonly hasPackageJson: boolean;
+  readonly dependencies?: readonly string[] | null;
+  readonly roots: readonly ProjectRootFact[] | null;
+  readonly unavailable: string | null;
+}
+
+/** Unread until the server answers, and unread is NOT "there is none". */
+let _files: ProjectFileFacts | null = null;
+let _request: Promise<ProjectFileFacts> | null = null;
+/** Which project `_files` describes, so a project switch re-asks instead of
+ *  reporting the previous project's scripts against the new one. */
+let _filesFor: string | null = null;
+
+/**
+ * Drop the cached file facts so the next read re-asks the dev server. Called
+ * on `vgai restart` (a restart is precisely "my project's files changed —
+ * re-read them"; the probe-measured failure was the dependency detector
+ * grading rows against a package.json edit two restarts old) and by tests.
+ */
+export function invalidateProjectFileFacts(): void {
+  _files = null;
+  _request = null;
+  _filesFor = null;
+}
+
+/**
+ * Ask the dev server for the project's own files, once per open project.
+ *
+ * A transport failure is NOT an absence: it lands as `scripts: null` with the
+ * reason, which the rules report as unmeasured. There is exactly one safe
+ * direction for this question to fail in.
+ */
+async function loadProjectFileFacts(
+  rootPath: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<ProjectFileFacts> {
+  if (_files && _filesFor === rootPath) return _files;
+  if (_request && _filesFor === rootPath) return _request;
+  _filesFor = rootPath;
+  _files = null;
+  _request = (async () => {
+    let answer: ProjectFileFacts;
+    try {
+      const res = await fetchImpl('/__editor/project-verbs');
+      answer = await editorServerJson<ProjectFileFacts>(res, 'project-verbs did not answer');
+    } catch (error) {
+      answer = {
+        scripts: null,
+        hasPackageJson: false,
+        dependencies: null,
+        roots: null,
+        unavailable: `the editor could not reach its dev server to read this project's own files (${
+          error instanceof Error ? error.message : String(error)
+        })`,
+      };
+    }
+    _files = answer;
+    return answer;
+  })();
+  return _request;
+}
+
+/**
+ * The open project's dependency NAMES, off the SAME single fetch the verb rows
+ * use — the `system.*` family's detector input.
+ *
+ * `null` is "not answered yet / not answerable" (an unlanded fetch, an
+ * unreadable package.json), and every caller must treat it as such:
+ * an absent library list is not evidence that a library is absent, and reading
+ * it as one would fabricate the very reassurance the detector exists to
+ * withhold. Deliberately does NOT kick off the fetch itself —
+ * {@link projectVerbFacts} owns that, so there is one request and one cache.
+ */
+export function projectDependencyNames(): readonly string[] | null {
+  const project = getCurrentProject();
+  if (!project) return null;
+  const files = _filesFor === project.rootPath ? _files : null;
+  return files?.dependencies ?? null;
+}
+
+/**
+ * Everything the rules read, assembled from the live session — and the reads
+ * kicked off where they have not happened yet.
+ *
+ * `null` when there is no open project at all: a verb report about no project
+ * would be three fabricated gaps, which is worse than no rows.
+ */
+export function projectVerbFacts(): ProjectVerbFacts | null {
+  const project = getCurrentProject();
+  if (!project) return null;
+  void loadProjectFileFacts(project.rootPath);
+  const files = _filesFor === project.rootPath ? _files : null;
+  return {
+    scripts: files?.scripts ?? null,
+    hasPackageJson: files?.hasPackageJson ?? false,
+    roots: files?.roots ?? null,
+    unavailable:
+      files?.unavailable ??
+      (files ? null : 'the editor has not finished reading this project’s own files yet'),
+  };
+}
+
+/**
+ * The `project.*` report for the open project, re-derived on every read — the
+ * scripts a project declares change while it is open (`vgai add` writes them),
+ * so a cached answer would start lying.
+ */
+export function projectVerbCoverage(): CapabilityCoverageReport | null {
+  const facts = projectVerbFacts();
+  if (!facts) return null;
+  const project = getCurrentProject();
+  return deriveCapabilityCoverage({
+    worldId: project?.config.name ?? 'project',
+    projectVerbs: measureProjectVerbs(facts),
+  });
+}

package/src/coverage/native-system-coverage.ts

@@ -0,0 +1,143 @@
+/**
+ * THE `SystemAdapters` COVERAGE OF A NATIVE MOUNT — the live half of
+ * `coverage/system-adapter-coverage.ts`.
+ *
+ * It reads the session's own singletons and hands the facts to the pure
+ * derivation. The report goes out the two doors coverage already uses —
+ * `vgai status`'s `systemCoverage` facet, and the editor console via
+ * `coverage/session-coverage.ts`, which unions this family with the others so
+ * one headline counts them all — so an unbound slot becomes a STANDING
+ * condition rather than a one-off line. No new transport, no new panel, and no
+ * dismiss: the console sync forwards every warning to the server's unresolved
+ * ledger, which is what makes it persistent.
+ *
+ * ## Why this is a separate report from `coverage/root-coverage.ts`
+ *
+ * A `SystemAdapters` slot is GAME-scoped, not root-scoped:
+ * `runtime/game.ts`'s `computeSystemAdapters` merges every mounted root's bag
+ * into ONE registry, and `authoring/active-systems.ts` is the single object the
+ * editor's panels call. Deriving it per root would print the same six rows once
+ * per root and invent a per-root ownership the engine does not have.
+ *
+ * ## Why it stands down for an ingested mount
+ *
+ * `ingest/mount-coverage.ts` already measures the same slots for an ingest,
+ * against the game's DECLARED carrier — strictly stronger evidence, because a
+ * declaration can distinguish "I have no physics" from "nobody looked". Where
+ * that measurement exists it is the one that runs; this module is the answer
+ * for the mounts that have no contract to read.
+ */
+
+import { getActiveSystems } from '@volter/editor-core/authoring/active-systems';
+import { mountedRootSubjects } from '@volter/editor-core/authoring/mounted-root-subjects';
+import {
+  type CapabilityCoverageReport,
+  deriveCapabilityCoverage,
+} from '../host/coverage/capability-coverage';
+import { measureNativeSystemAdapters } from '../host/coverage/system-adapter-coverage';
+import { liveCoverage } from '@volter/editor-core/live-session-registry';
+import { getCurrentProject } from '@volter/editor-core/project-manager';
+import { toolContributionPlay } from '@volter/editor-core/tool-contribution-play';
+import type { DeclaredSystemAbsence, Game } from '@volter/game-runtime/runtime/game';
+import { projectDependencyNames } from './live-project-verbs';
+
+/**
+ * What the mounted roots' `systems` tables declared ABSENT, read off the live
+ * Game — the DETECT-OR-DECLARE input that turns a derived excuse into the
+ * game's own answer.
+ *
+ * Reached through `tool-contribution-play.ts` rather than `play-mode.ts` on
+ * purpose: importing play-mode here would drag the whole runtime boot chain
+ * into every consumer of this module (its own header states the rule).
+ *
+ * While a Game is live its declarations are read directly. While stopped, the
+ * last mount's reading is retained per project and labeled as such — the
+ * declaration is a static fact about the entry's `systems` table, and
+ * forgetting it at stop demoted the game's own answer to a host inference.
+ * `[]` only when this project has never mounted in this session.
+ */
+function declaredAbsences(): {
+  absences: readonly DeclaredSystemAbsence[];
+  fromLastMount: boolean;
+} {
+  const game = toolContributionPlay()?.game as Game | undefined;
+  const projectPath = getCurrentProject()?.rootPath ?? null;
+  if (game) {
+    if (projectPath !== null) {
+      lastMountAbsences = { projectPath, absences: game.declaredSystemAbsences ?? [] };
+    }
+    return { absences: game.declaredSystemAbsences ?? [], fromLastMount: false };
+  }
+  // Stopped. The declaration is a static fact about the entry's `systems`
+  // table, so the LAST mount's reading remains the game's own answer — the
+  // probe-measured failure was this very row demoting to "the HOST's
+  // observation" the moment play stopped, silently understating the game's
+  // declared answer as an inference. Retained per project, labeled as the
+  // last-mount reading by the derivation.
+  if (lastMountAbsences !== null && lastMountAbsences.projectPath === projectPath) {
+    return { absences: lastMountAbsences.absences, fromLastMount: true };
+  }
+  return { absences: [], fromLastMount: false };
+}
+
+/** The last play mount's declared absences, per project — see above. */
+let lastMountAbsences: {
+  projectPath: string;
+  absences: readonly DeclaredSystemAbsence[];
+} | null = null;
+
+/**
+ * The native system-adapter report, or `null` when this session is not the one
+ * being described: an ingested mount (whose own measurement is better) or a
+ * session with no open project (nothing to read a `server` block from, and
+ * guessing would be the fabrication the anti-shim rule forbids).
+ *
+ * Re-derived on every read. The registry gains and loses adapters across a play
+ * enter/exit, so a cached answer would start lying.
+ */
+export function nativeSystemCoverage(): CapabilityCoverageReport | null {
+  // A lane grading its own contracts (an ingested game) owns this family.
+  if (liveCoverage() !== null) return null;
+  const project = getCurrentProject();
+  if (!project) return null;
+  const mounted = mountedRootSubjects();
+  // Nothing mounted ⇒ the registry has not been ASKED, and "a probe that has
+  // not run yet reports info, never gap" (the derivation's own rule). The
+  // measured violation: a pre-mount session emitted "7 of 7 system seams
+  // MISSING" into the server's unresolved ledger — seven gaps against a mount
+  // that did not exist — and the entry stood beside the real post-mount report
+  // forever. An unasked question is not a family with something to say.
+  if (mounted.length === 0) return null;
+  // An isolated foreign document is a real AUTHORING mount, so root coverage
+  // must grade its editor providers, but it is not a native engine Game and
+  // owns no game-scoped SystemAdapters registry. Treating that document as a
+  // native mount fabricated a `system.debug` failure the moment an adapter-
+  // owned scene was opened. Stand down only when every mounted subject says it
+  // is foreign; a mixed project with any native root still has a real native
+  // game registry to measure.
+  if (mounted.every((subject) => subject.adapter.provenance?.source === 'foreign')) return null;
+  const declared = declaredAbsences();
+  return deriveCapabilityCoverage({
+    worldId: project.config.name,
+    systemAdapters: measureNativeSystemAdapters(getActiveSystems(), {
+      // A `process` configuration WITH A PORT — the same rule
+      // `edit-mode-networking.ts`'s `readServerConfig` already used, and the
+      // one this line was missing. `process` is the general "a process the
+      // project runs beside the host" kind, not a synonym for "Colyseus
+      // server": the `arena` example declares two port-less ones that choose
+      // a camera, and grading on `kind` alone reported a missing
+      // NetworkingAdapter for a single-player game, telling its author to
+      // register one because "this project declares a `server` block" when it
+      // declares nothing of the sort. A matchmaker is a listener; no port, no
+      // server. (`vgai edit`'s auto-boot had the identical bug — see
+      // `packages/vgai-cli/src/colyseus-autoboot.ts`'s `readDeclaredProcess`.)
+      declaresServer: (project.config.configurations ?? []).some(
+        (c) => c.kind === 'process' && typeof (c as { port?: unknown }).port === 'number',
+      ),
+      mounted: true,
+      declaredAbsences: declared.absences,
+      absencesFromLastMount: declared.fromLastMount,
+      dependencies: projectDependencyNames(),
+    }),
+  });
+}