genesis-compiler 1.10.6 → 1.10.7

package/README.md

@@ -39,6 +39,7 @@ genesis/
 .genesis/            local, git-ignored (`genesis init` adds the ignore lines)
   machine-city.json  derived detailed source and function map
   program-city.json  derived simple subsystem and operation map
+  call-web.json      derived function call web (`genesis index --call-web`)
 ```
 
 Program paths describe public operations rather than languages or source
@@ -253,7 +254,7 @@ files alone does not refresh its existing context.
 | `genesis stack add <piece...>` | Resolves component dependencies/conflicts, records the selection, materializes missing project contracts, synchronizes declared skills, and prints the one-time preparation prompt. It does not install application packages or run an agent. |
 | `genesis skills sync` | Refreshes selected, unmodified managed skills while preserving customized and unmanaged copies. |
 | `genesis context <path...>` | Returns path-focused Program explanations, indexed functions, selected technology guidance, exact project contracts, and relevant skills. |
-| `genesis index [function-or-path...]` | Regenerates the derived code indexes and optionally searches the existing function/method inventory. |
+| `genesis index [--call-web] [function-or-path...]` | Regenerates the derived code indexes and optionally searches the existing function/method inventory. `--call-web` also writes the derived function call web. |
 | `genesis inspect environment` | Reports declared resources, public defaults, missing input names, and environment-file paths without returning secret values. |
 | `genesis inspect skills` | Reports selected skill freshness and ownership without changing files. |
 | `genesis inspect section <name>` | Returns one exact consumer-owned Stack section without interpreting or executing it. |
@@ -465,6 +466,18 @@ extractor warning does not stop ordinary work. They are rebuilt from the
 working tree, so they are not committed: `genesis init` adds both paths to the
 project's `.gitignore`.
 
+Machine City also lists entry points: commands, library exports, Program
+operations, tests and inspector-derived pages, components, routes, actions and
+jobs. A page entry is titled by its first registration, such as the URL path
+`/app/project/:slug`, else by the page's title. `genesis index --call-web`
+additionally writes `.genesis/call-web.json`,
+every function site and call site with its `probable`, `exact` or `unresolved`
+targets. The generic baseline is syntax and import scope only, so it is never
+`exact`; an inspector may supply exact facts for its files. The call web is
+written only when Git ignores its path (`genesis init` adds the line). Per-file
+extraction, including installed packages' public entry files, is cached inside
+the Git directory, so unchanged files are not parsed again.
+
 Local package exports whose entry files are excluded from indexing retain their
 declared import paths with unavailable symbol coverage and a diagnostic. They do
 not invalidate the rest of the architecture. After upgrading Genesis, run
@@ -988,6 +1001,9 @@ async callback receiving the fresh architecture facts. A host can run its finite
 inspector inside that callback, avoiding a second source extraction. Genesis
 joins the result and rechecks source, Stack, subsystem and package inputs before
 writing compact derived JSON; failures and cancellation retain the prior index.
+`indexCodebase({ callWeb: true })` also builds the call web; `readCallWeb()`
+returns it only while it matches the saved Machine City, `validateCallWeb()`
+checks a document and `CALL_WEB_SCHEMA` names its schema.
 `ARCHITECTURE_OBSERVATIONS_SCHEMA` identifies the neutral inspector document.
 `validateArchitectureObservations()` checks its evidence against supplied files
 and packages; `connectArchitectureObservations()` joins exact owners and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.10.6",
+  "version": "1.10.7",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {

package/plugins/genesis/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis",
-  "version": "1.10.6",
+  "version": "1.10.7",
   "description": "Makes Codex aware of optional Genesis adoption for existing projects.",
   "author": {
     "name": "Mobily Enterprises"

package/src/cli.js

@@ -65,7 +65,7 @@ const USAGE = `Usage:
   genesis templates list
   genesis templates apply <catalogue:technology/variant>
   genesis context <path...>
-  genesis index [function-or-path...]
+  genesis index [--call-web] [function-or-path...]
   genesis parsers list
   genesis parsers install <language...> | --all
   genesis parsers verify <language...> | --all
@@ -87,6 +87,7 @@ Options:
   --task <task>          Select the prompt task (default: work)
   --directory <path>     Parser cache directory (parsers commands only)
   --all                  Select every parser (parsers install/verify only)
+  --call-web             Also build .genesis/call-web.json (index only)
   --json                 Emit one machine-readable result
   --claude-part <1-4>    Emit one bounded Claude session-hook part
   -h, --help             Show this help
@@ -114,6 +115,7 @@ function parseCommand(argv) {
         json: { type: 'boolean', default: false },
         'claude-part': { type: 'string' },
         all: { type: 'boolean', default: false },
+        'call-web': { type: 'boolean', default: false },
         directory: { type: 'string' },
         'project-root': { type: 'string' },
         'stack-package': { type: 'string', multiple: true, default: [] },
@@ -128,6 +130,7 @@ function parseCommand(argv) {
     json: parsed.values.json,
     claudePart: parsed.values['claude-part'],
     all: parsed.values.all,
+    callWeb: parsed.values['call-web'],
     directory: parsed.values.directory,
     projectRoot: parsed.values['project-root'],
     stackPackages: parsed.values['stack-package'],
@@ -150,6 +153,9 @@ function parseCommand(argv) {
   if (options.templateSources.length && command !== 'templates') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --template-source is not applicable to ${command}.`);
   }
+  if (options.callWeb && command !== 'index') {
+    fail('CLI_OPTION_NOT_APPLICABLE', `Option --call-web is not applicable to ${command}.`);
+  }
   if (options.task !== undefined && command !== 'prompt') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --task is not applicable to ${command}.`);
   }
@@ -386,6 +392,7 @@ function writeResult(command, result) {
     line(process.stdout, result.summary);
     line(process.stdout, `Machine City: ${result.paths.machine}`);
     line(process.stdout, `Program City: ${result.paths.program}`);
+    if (result.paths.callWeb) line(process.stdout, `Call web: ${result.paths.callWeb}`);
     if (result.totalMatches > 0) {
       line(process.stdout, 'Matching functions:');
       for (const entry of result.matches) {
@@ -558,7 +565,7 @@ async function execute({ command, operands, options }, { signal, hostContext = n
     });
   }
   if (command === 'context') return getContext({ paths: operands, projectRoot, stackPackages });
-  if (command === 'index') return indexCodebase({ projectRoot, queries: operands, stackPackages });
+  if (command === 'index') return indexCodebase({ projectRoot, queries: operands, stackPackages, callWeb: options.callWeb });
   if (command === 'inspect') {
     if (operands[0] === 'section') {
       return {

package/src/index/architecture-observations.js

@@ -5,7 +5,22 @@ import { sha256, stableJson } from './utils.js';
 export const ARCHITECTURE_OBSERVATIONS_SCHEMA = 'genesis.architecture-observations.v1';
 const collections = ['pages', 'registrations', 'components', 'componentUses', 'entryOperations', 'operationUses'];
 const optionalCollections = ['imports'];
+// Call-web collections appear only when an inspector declares them, so
+// documents and merges without them keep their exact v1 shape.
+const callCollections = ['functions', 'calls', 'entryPoints'];
 const states = ['complete', 'partial', 'unsupported', 'unconfigured'];
+export const FUNCTION_KINDS = Object.freeze(['function', 'method', 'constructor', 'arrow', 'closure', 'module']);
+export const CALL_CERTAINTIES = Object.freeze(['exact', 'probable', 'unresolved']);
+export const CALL_METHODS = Object.freeze(['checker', 'di-binding', 'route-action', 'argument-flow', 'import-scope', 'same-file-name', 'self', 'receiver-name', 'none']);
+export const EXACT_CALL_METHODS = Object.freeze(['checker', 'di-binding', 'route-action', 'self', 'argument-flow']);
+export const ENTRY_POINT_KINDS = Object.freeze(['page', 'component', 'route', 'action', 'library-export', 'cli-command', 'job', 'program-operation', 'test']);
+export const MAX_CALL_TARGETS = 16;
+export const MAX_CALLS_PER_FILE = 2000;
+export const MAX_CALLEE_LENGTH = 120;
+// A file's top-level code is `fn:<path>#module`; every other function is named by its start.
+export const functionId = (file, start, kind) => kind === 'module' ? `fn:${file}#module` : `fn:${file}#${start.line}:${start.column}`;
+const before = (left, right) => left.line < right.line || (left.line === right.line && left.column < right.column);
+const notAfter = (left, right) => !before(right, left);
 const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
 const text = value => typeof value === 'string' && value.length > 0 && !/[\0\r\n]/u.test(value);
 const canonical = value => text(value) && value !== '.' && !/[\\]/u.test(value) && !path.posix.isAbsolute(value) && path.posix.normalize(value) === value && !value.split('/').includes('..');
@@ -15,6 +30,45 @@ function requireFact(condition, message) {
   if (!condition) throw new GenesisError('ARCHITECTURE_OBSERVATIONS_INVALID', message);
 }
 
+function validateCallWebFacts(document, ids, inputs, functionReference, operation) {
+  requireFact(document.calls === undefined || Array.isArray(document.functions), 'calls require functions.');
+  const functions = new Map();
+  for (const entry of document.functions || []) {
+    requireFact(inputs.has(entry.file), `${entry.id} must identify a declared input file.`);
+    requireFact(point(entry.start) && point(entry.end) && before(entry.start, entry.end), `${entry.id} has an impossible source range.`);
+    requireFact(entry.id === functionId(entry.file, entry.start, entry.kind), `${entry.id} must be fn:<path>#<start line>:<start column> (fn:<path>#module for module code).`);
+    requireFact(FUNCTION_KINDS.includes(entry.kind) && typeof entry.name === 'string' && !/[\0\r\n]/u.test(entry.name), `${entry.id} needs a known kind and a name (empty when anonymous).`);
+    requireFact(entry.kind !== 'module' || (entry.start.line === 1 && entry.start.column === 1), `${entry.id} module code starts at 1:1.`);
+    requireFact(entry.container == null || text(entry.container), `${entry.id} has an invalid container.`);
+    requireFact(entry.exported === undefined || typeof entry.exported === 'boolean', `${entry.id} has an invalid export flag.`);
+    requireFact(entry.evidence.every(evidence => evidence.path === entry.file), `${entry.id} evidence must be in its own file.`);
+    functions.set(entry.id, entry);
+  }
+  const perFile = new Map();
+  for (const call of document.calls || []) {
+    const from = functions.get(call.fromFunctionId);
+    requireFact(from && Array.isArray(call.targets) && call.targets.every(target => functions.has(target)) && new Set(call.targets).size === call.targets.length, `${call.id} must reference known caller and target functions.`);
+    requireFact(CALL_CERTAINTIES.includes(call.certainty) && CALL_METHODS.includes(call.method), `${call.id} needs a known certainty and method.`);
+    requireFact(typeof call.callee === 'string' && call.callee.length <= MAX_CALLEE_LENGTH && !call.callee.includes('\0'), `${call.id} callee text must be at most ${MAX_CALLEE_LENGTH} characters.`);
+    if (call.certainty === 'exact') requireFact(call.resolution === 'resolved' && call.targets.length === 1 && EXACT_CALL_METHODS.includes(call.method), `${call.id} exact calls need one resolved target from a resolver.`);
+    if (call.certainty === 'probable') requireFact(call.method !== 'none' && ((call.resolution === 'resolved' && call.targets.length === 1) || (call.resolution === 'ambiguous' && call.targets.length >= 2 && call.targets.length <= MAX_CALL_TARGETS)), `${call.id} probable calls need one resolved or 2-${MAX_CALL_TARGETS} ambiguous targets.`);
+    if (call.certainty === 'unresolved') requireFact(call.resolution === 'unresolved' && call.targets.length === 0 && call.method === 'none', `${call.id} unresolved calls have no targets and no method.`);
+    requireFact(call.evidence.every(evidence => evidence.path === from.file && notAfter(from.start, evidence.start) && notAfter(evidence.end, from.end)), `${call.id} evidence must lie inside its caller.`);
+    perFile.set(from.file, (perFile.get(from.file) || 0) + 1);
+    requireFact(perFile.get(from.file) <= MAX_CALLS_PER_FILE, `${from.file} has more than ${MAX_CALLS_PER_FILE} call records; truncate with CALLS_TRUNCATED.`);
+  }
+  for (const entry of document.entryPoints || []) {
+    requireFact(ENTRY_POINT_KINDS.includes(entry.kind) && text(entry.title), `${entry.id} needs a known kind and a title.`);
+    requireFact(inputs.has(entry.file), `${entry.id} must identify a declared input file.`);
+    requireFact(Array.isArray(entry.functionIds), `${entry.id} needs function identities.`);
+    for (const value of entry.functionIds) functionReference(value, entry.id);
+    if (entry.pageId != null) requireFact(ids.get(entry.pageId)?.name === 'pages', `${entry.id} refers to an unknown page.`);
+    if (entry.componentId != null) requireFact(ids.get(entry.componentId)?.name === 'components', `${entry.id} refers to an unknown component.`);
+    if (entry.operationKey != null) operation(entry.operationKey, entry.id);
+    if (entry.actionId != null) requireFact(text(entry.actionId), `${entry.id} has an invalid action identity.`);
+  }
+}
+
 // A finite, framework-independent JSON contract. Inspectors collect evidence;
 // this owner validates identities and joins without executing application code.
 export function validateArchitectureObservations(document, { files = [], packages = [] } = {}) {
@@ -23,7 +77,7 @@ export function validateArchitectureObservations(document, { files = [], package
   requireFact(Array.isArray(document.inputs), 'inputs must be an array.');
   requireFact(object(document.capabilities), 'capabilities must be an object.');
   for (const name of ['pages', 'components', 'entryOperations', 'operationUses']) requireFact(states.includes(document.capabilities[name]), `Missing or invalid ${name} capability.`);
-  if (document.capabilities.imports !== undefined) requireFact(states.includes(document.capabilities.imports), 'Invalid import coverage.');
+  for (const name of ['imports', ...callCollections]) if (document.capabilities[name] !== undefined) requireFact(states.includes(document.capabilities[name]), `Invalid ${name} coverage.`);
   requireFact(Array.isArray(document.diagnostics) && document.diagnostics.every(entry => object(entry) && text(entry.code) && text(entry.message)), 'diagnostics must contain code and message.');
   const filesByPath = new Map(files.map(file => [file.path, file]));
   const inputs = new Map();
@@ -35,8 +89,8 @@ export function validateArchitectureObservations(document, { files = [], package
     inputs.set(input.path, input);
   }
   const ids = new Map();
-  for (const name of [...collections, ...optionalCollections]) {
-    requireFact(Array.isArray(document[name]) || (optionalCollections.includes(name) && document[name] === undefined), `${name} must be an array.`);
+  for (const name of [...collections, ...optionalCollections, ...callCollections]) {
+    requireFact(Array.isArray(document[name]) || (!collections.includes(name) && document[name] === undefined), `${name} must be an array.`);
     for (const record of document[name] || []) {
       requireFact(object(record) && text(record.id) && !ids.has(record.id), `Invalid or duplicate ${name} identity.`);
       requireFact(['resolved', 'unresolved', 'ambiguous'].includes(record.resolution), `${record.id} needs an explicit resolution.`);
@@ -93,10 +147,24 @@ export function validateArchitectureObservations(document, { files = [], package
     if (entry.resolution === 'resolved') source(entry.controllerFile, entry.id);
     if (entry.controllerSymbol != null) requireFact(text(entry.controllerSymbol), `${entry.id} has an invalid symbol.`);
   }
+  // Without a function table (a saved compact copy), caller identities stay opaque strings.
+  const hasFunctions = Array.isArray(document.functions);
+  function functionReference(value, label) {
+    if (hasFunctions) reference(value, ['functions'], label);
+    else requireFact(text(value), `${label} has an invalid function identity.`);
+  }
+  for (const entry of document.entryOperations) {
+    if (entry.controllerFunctionId !== undefined) functionReference(entry.controllerFunctionId, entry.id);
+    if (entry.actionId !== undefined) requireFact(text(entry.actionId), `${entry.id} has an invalid action identity.`);
+  }
   for (const use of document.operationUses) {
-    reference(use.parentId, ['pages', 'components', 'componentUses'], use.id);
+    requireFact(use.parentId != null || use.fromFunctionId !== undefined, `${use.id} needs a page/component parent or a caller function.`);
+    if (use.parentId != null) reference(use.parentId, ['pages', 'components', 'componentUses'], use.id);
+    if (use.fromFunctionId !== undefined) functionReference(use.fromFunctionId, use.id);
     if (use.resolution === 'resolved') operation(use.key, use.id);
+    if (use.keyCertainty !== undefined) requireFact(use.resolution === 'resolved' && ['exact', 'probable'].includes(use.keyCertainty), `${use.id} key certainty applies only to a resolved key.`);
   }
+  validateCallWebFacts(document, ids, inputs, functionReference, operation);
   // Parent graphs must be finite. Shared definitions are not duplicate owners.
   for (const name of ['pages', 'componentUses']) for (const record of document[name]) {
     const seen = new Set([record.id]);
@@ -121,7 +189,9 @@ export function connectArchitectureObservations(document, files, packages = [])
   const connections = document.operationUses.map(use => {
     const matches = use.resolution === 'resolved' ? entries.get(stableJson(use.key)) || [] : [];
     const entry = matches.length === 1 ? matches[0] : null;
-    return { id: `connection:${use.id}`, useId: use.id, parentId: use.parentId, key: use.key || null, resolution: entry ? 'resolved' : matches.length > 1 ? 'ambiguous' : 'unresolved', entryId: entry?.id || null, controllerFileId: entry ? byPath.get(entry.controllerFile).id : null, controllerSymbol: entry?.controllerSymbol || null, evidence: [...use.evidence, ...(entry?.evidence || [])] };
+    // Caller facts appear only for function-level uses; an exact key alone makes an exact bridge.
+    const bridge = use.fromFunctionId === undefined ? {} : { fromFunctionId: use.fromFunctionId, controllerFunctionId: entry?.controllerFunctionId ?? null, certainty: entry ? (use.keyCertainty === 'exact' ? 'exact' : 'probable') : null };
+    return { id: `connection:${use.id}`, useId: use.id, parentId: use.parentId ?? null, key: use.key || null, resolution: entry ? 'resolved' : matches.length > 1 ? 'ambiguous' : 'unresolved', entryId: entry?.id || null, controllerFileId: entry ? byPath.get(entry.controllerFile).id : null, controllerSymbol: entry?.controllerSymbol || null, evidence: [...use.evidence, ...(entry?.evidence || [])], ...bridge };
   });
   return {
     ...document, connections,
@@ -130,9 +200,14 @@ export function connectArchitectureObservations(document, files, packages = [])
   };
 }
 
+const sameFunction = (left, right) => ['file', 'name', 'kind'].every(field => left[field] === right[field])
+  && stableJson([left.start, left.end]) === stableJson([right.start, right.end]);
+
 export function mergeArchitectureObservations(documents, { files = [], packages = [] } = {}) {
   requireFact(Array.isArray(documents) && documents.length > 0, 'At least one observation document is required.');
   const merged = { schema: ARCHITECTURE_OBSERVATIONS_SCHEMA, adapter: '', inputs: [], capabilities: {}, diagnostics: [], ...Object.fromEntries([...collections, ...optionalCollections].map(name => [name, []])) };
+  const declared = callCollections.filter(name => documents.some(document => document?.[name] !== undefined));
+  for (const name of declared) merged[name] = [];
   const adapters = new Set();
   for (const document of documents) {
     requireFact(document?.schema === ARCHITECTURE_OBSERVATIONS_SCHEMA && text(document.adapter) && !adapters.has(document.adapter), 'Every inspector needs a unique adapter identity and the observation schema.');
@@ -141,13 +216,20 @@ export function mergeArchitectureObservations(documents, { files = [], packages
       requireFact(!merged.packageIdentity || merged.packageIdentity === document.packageIdentity, 'Inspectors disagree about the package snapshot.');
       merged.packageIdentity = document.packageIdentity;
     }
-    for (const name of ['inputs', ...collections, ...optionalCollections]) {
-      requireFact(Array.isArray(document[name]) || (optionalCollections.includes(name) && document[name] === undefined), `${name} must be an array.`);
+    for (const name of ['inputs', ...collections, ...optionalCollections, ...declared]) {
+      requireFact(Array.isArray(document[name]) || (!collections.includes(name) && name !== 'inputs' && document[name] === undefined), `${name} must be an array.`);
       const byId = new Map(merged[name].map(record => [name === 'inputs' ? record.path : record.id, record]));
       for (const record of document[name] || []) {
         requireFact(object(record), `Invalid ${name} record.`);
         const id = name === 'inputs' ? record.path : record.id;
         const previous = byId.get(id);
+        if (name === 'functions') {
+          // The same function seen by two inspectors is one record; on
+          // disagreement the inspector earlier in Stack order wins.
+          if (previous && !sameFunction(previous, record)) merged.diagnostics.push({ code: 'FUNCTION_CONFLICT', path: record.file, message: `${document.adapter} and ${previous.adapter} disagree about ${id}; ${previous.adapter} is kept.` });
+          if (!previous) { const kept = { ...record, adapter: document.adapter }; merged[name].push(kept); byId.set(id, kept); }
+          continue;
+        }
         requireFact(!previous || stableJson(previous) === stableJson(record), `Conflicting ${name} identity ${id}.`);
         if (!previous) { merged[name].push(record); byId.set(id, record); }
       }
@@ -163,5 +245,10 @@ export function mergeArchitectureObservations(documents, { files = [], packages
   }
   const importCoverage = documents.map(document => document.capabilities?.imports || 'unconfigured');
   merged.capabilities.imports = new Set(importCoverage).size === 1 ? importCoverage[0] : 'partial';
+  for (const capability of callCollections) {
+    if (!documents.some(document => document.capabilities?.[capability] !== undefined)) continue;
+    const values = documents.map(document => document.capabilities?.[capability] || 'unconfigured');
+    merged.capabilities[capability] = new Set(values).size === 1 ? values[0] : 'partial';
+  }
   return validateArchitectureObservations(merged, { files, packages });
 }

package/src/index/architecture.js

@@ -1,10 +1,12 @@
 import path from 'node:path';
-import { connectArchitectureObservations } from './architecture-observations.js';
+import { connectArchitectureObservations, ENTRY_POINT_KINDS } from './architecture-observations.js';
 import { buildCityPresentation } from './city-presentation.js';
 import { GenesisError } from './errors.js';
 import { sha256, stableJson } from './utils.js';
 
 const owns = (root, file) => root === '.' || file.startsWith(`${root}/`);
+// Function and call tables live in the call web; Machine City keeps the rest.
+const withoutCallTables = ({ functions, calls, ...rest }) => rest;
 
 function resolveReference(file, reference, filesByPath, packages) {
   const specifier = reference.specifier;
@@ -80,7 +82,7 @@ export function buildArchitectureFacts({ machine, subsystemMap, program = null,
   })));
   const symbols = [...machine.functions, ...(machine.symbols || [])].map(symbol => ({ ...symbol, start: symbol.start || { line: symbol.line, column: symbol.column }, rangeAvailable: Boolean(symbol.end) }));
   const sourceHash = sha256(stableJson(files.map(file => ({ path: file.path, hash: file.hash, mode: file.mode }))));
-  let ui = observations ? connectArchitectureObservations(observations, files, packages) : null;
+  let ui = observations ? withoutCallTables(connectArchitectureObservations(observations, files, packages)) : null;
   if (!observations && previous?.ui) {
     // Source-only indexing must not erase unchanged consumer observations.
     // A changed snapshot requires its inspector; never carry guesses forward.
@@ -219,6 +221,23 @@ export function validateArchitectureFacts(snapshot) {
   }
   check(snapshot.capabilities && typeof snapshot.capabilities === 'object' && Array.isArray(snapshot.diagnostics), 'Missing architecture coverage or diagnostics.');
   for (const name of ['symbols', 'dependencies', 'pages', 'runtimeCalls']) check(['complete', 'partial', 'unsupported', 'unconfigured'].includes(snapshot.capabilities[name]), 'Invalid architecture coverage.');
+  for (const name of ['functions', 'calls', 'entryPoints']) check(snapshot.capabilities[name] === undefined || ['complete', 'partial', 'unsupported', 'unconfigured'].includes(snapshot.capabilities[name]), 'Invalid architecture coverage.');
+  const filesByPath = new Map([...files.values()].map(file => [file.path, file]));
+  if (snapshot.entryPoints !== undefined) {
+    check(Array.isArray(snapshot.entryPoints), 'entryPoints must be an array.');
+    const ids = new Set();
+    for (const entry of snapshot.entryPoints) {
+      check(entry && typeof entry.id === 'string' && entry.id.length > 0 && !ids.has(entry.id) && ENTRY_POINT_KINDS.includes(entry.kind) && typeof entry.title === 'string' && entry.title.length > 0, 'Invalid or duplicate entry point.');
+      ids.add(entry.id);
+      check(filesByPath.has(entry.file) && Array.isArray(entry.functionIds) && entry.functionIds.every(id => typeof id === 'string' && id.length > 0), `${entry.id} must name a known file and function identities.`);
+      check(Array.isArray(entry.evidence) && entry.evidence.length > 0 && entry.evidence.every(evidence => filesByPath.get(evidence?.path)?.hash === evidence.hash), `${entry.id} evidence is stale.`);
+    }
+  }
+  if (snapshot.callWeb != null) {
+    const { callWeb } = snapshot;
+    check(callWeb.path === '.genesis/call-web.json' && typeof callWeb.identity === 'string' && typeof callWeb.sourceIdentity === 'string' && callWeb.counts && typeof callWeb.counts === 'object' && callWeb.coverage && typeof callWeb.coverage === 'object', 'Invalid call-web summary.');
+    for (const name of ['functions', 'calls', 'exact', 'probable', 'unresolved']) check(Number.isSafeInteger(callWeb.counts[name]) && callWeb.counts[name] >= 0, 'Invalid call-web counts.');
+  }
   if (snapshot.ui) {
     const recomputed = connectArchitectureObservations(snapshot.ui, snapshot.files, snapshot.packages || []);
     check(stableJson(recomputed.connections) === stableJson(snapshot.ui.connections), 'Controller connections disagree with their evidence.');