hoi4-agent-tools 2.1.0 → 2.2.0

package/dist/hoi4_agent_tools/mcp/tools/technology.js

@@ -0,0 +1,368 @@
+import { z } from 'zod/v4';
+import { publicArtifactLink } from '../../core/artifacts.js';
+import { compareCodeUnits, hashCanonical } from '../../core/canonical.js';
+import { emptyServiceResult } from '../../core/result.js';
+import { workspaceIdSchema } from '../../schemas/common.js';
+import { technologyDefectClassSchema, technologyDirectionSchema, technologyGraphReferenceSchema, technologyIdSchema, technologyImpactSchema, technologyProposedSourceSchema, technologyRenderViewSchema, technologyUnlockKindSchema, } from '../../schemas/technology.js';
+import { TechnologyTreeViewer, technologyDiagnostics, } from '../../technology/service.js';
+import { compactValidatedInputSchema } from '../server/context-schemas.js';
+import { nonNegativeIntegerSchema, sha256Schema } from '../server/output-schemas.js';
+import { progressReporter } from '../server/progress.js';
+import { errorResult, setInlineFilesScanned, strictOperationResultSchema, toolResult, } from '../server/result.js';
+const technologyMode = z.enum([
+    'scan',
+    'folders',
+    'trace',
+    'explain',
+    'unlocks',
+    'bonus_coverage',
+    'lint',
+    'impact',
+]);
+const inspectInput = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    mode: technologyMode,
+    folderId: technologyIdSchema.optional(),
+    technologyId: technologyIdSchema.optional(),
+    categoryId: technologyIdSchema.optional(),
+    targetKind: technologyUnlockKindSchema.optional(),
+    targetId: technologyIdSchema.optional(),
+    direction: technologyDirectionSchema.optional(),
+    maxDepth: z.number().int().min(1).max(256).optional(),
+    maxNodes: z.number().int().min(1).max(25_000).optional(),
+    includeSubTechnologies: z.boolean().optional(),
+    classifications: z.array(technologyDefectClassSchema).max(4).optional(),
+    codes: z.array(z.string().min(1).max(256)).max(100).optional(),
+    impact: compactValidatedInputSchema(technologyImpactSchema, 'Rename or removal subject.').optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.mode === 'trace' || value.mode === 'explain') && value.technologyId === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['technologyId'],
+            message: `${value.mode} requires technologyId`,
+        });
+    if (value.mode === 'impact' && value.impact === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['impact'],
+            message: 'Impact mode requires impact',
+        });
+});
+const renderInput = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    view: technologyRenderViewSchema.exclude(['comparison']),
+    folderId: technologyIdSchema.optional(),
+    technologyId: technologyIdSchema.optional(),
+    categoryId: technologyIdSchema.optional(),
+    targetId: technologyIdSchema.optional(),
+    maxNodes: z.number().int().min(1).max(2_000).optional(),
+    includeHtml: z.boolean().optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.view === 'folder' && value.folderId === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['folderId'],
+            message: 'Folder view requires folderId',
+        });
+});
+const compareInput = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    before: compactValidatedInputSchema(technologyGraphReferenceSchema, 'Revision or graph resource.').optional(),
+    after: compactValidatedInputSchema(technologyGraphReferenceSchema, 'Revision or graph resource.').optional(),
+    proposedSources: z
+        .array(compactValidatedInputSchema(technologyProposedSourceSchema, 'In-memory source overlay.'))
+        .min(1)
+        .max(128)
+        .optional(),
+    render: z.boolean().optional(),
+    maxRenderNodes: z.number().int().min(1).max(2_000).optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.after !== undefined && value.proposedSources !== undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['after'],
+            message: 'after conflicts with proposedSources',
+        });
+});
+const countsSchema = z
+    .object({
+    technologies: nonNegativeIntegerSchema,
+    legacyDoctrines: nonNegativeIntegerSchema,
+    folders: nonNegativeIntegerSchema,
+    placements: nonNegativeIntegerSchema,
+    edges: nonNegativeIntegerSchema,
+    unlocks: nonNegativeIntegerSchema,
+    references: nonNegativeIntegerSchema,
+    issues: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+    artifacts: nonNegativeIntegerSchema,
+})
+    .strict();
+const analysisOutput = strictOperationResultSchema(z
+    .object({
+    mode: technologyMode,
+    revision: sha256Schema,
+    graphHash: sha256Schema,
+    counts: countsSchema,
+})
+    .strict());
+const renderOutput = strictOperationResultSchema(z
+    .object({
+    view: technologyRenderViewSchema,
+    revision: sha256Schema,
+    graphHash: sha256Schema,
+    hashes: z
+        .object({
+        json: sha256Schema,
+        svg: sha256Schema,
+        png: sha256Schema,
+        html: sha256Schema.optional(),
+    })
+        .strict(),
+    selectedNodes: nonNegativeIntegerSchema,
+    omittedNodes: nonNegativeIntegerSchema,
+    focusedRenders: nonNegativeIntegerSchema,
+    sourceAccurate: z.boolean(),
+})
+    .strict());
+const compareOutput = strictOperationResultSchema(z
+    .object({
+    beforeRevision: sha256Schema,
+    afterRevision: sha256Schema,
+    added: nonNegativeIntegerSchema,
+    removed: nonNegativeIntegerSchema,
+    renamed: nonNegativeIntegerSchema,
+    moved: nonNegativeIntegerSchema,
+    regressions: nonNegativeIntegerSchema,
+    artifacts: nonNegativeIntegerSchema,
+    renderHashes: z
+        .object({ json: sha256Schema, svg: sha256Schema, png: sha256Schema })
+        .strict()
+        .optional(),
+})
+    .strict());
+const readOnly = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+function graphHash(graph) {
+    return hashCanonical({
+        schemaVersion: graph.schemaVersion,
+        workspaceIdentity: graph.workspaceIdentity,
+        revision: graph.revision,
+        statistics: graph.statistics,
+        sourceHashes: graph.sourceHashes,
+    });
+}
+function counts(graph, artifacts) {
+    return {
+        technologies: graph.statistics.technologyCount,
+        legacyDoctrines: graph.statistics.legacyDoctrineCount,
+        folders: graph.statistics.folderCount,
+        placements: graph.statistics.placementCount,
+        edges: graph.edges.length,
+        unlocks: graph.statistics.unlockCount,
+        references: graph.statistics.externalReferenceCount,
+        issues: graph.statistics.issueCount,
+        unresolved: graph.statistics.unresolvedCount,
+        artifacts,
+    };
+}
+function validation(graph) {
+    const blocking = technologyDiagnostics(graph).filter(({ severity }) => severity === 'error' || severity === 'blocker').length;
+    return {
+        passed: graph.complete && blocking === 0,
+        checks: [
+            {
+                id: 'technology-analysis',
+                passed: graph.complete && blocking === 0,
+                message: graph.complete
+                    ? `${blocking} blocking technology diagnostics; full evidence is linked`
+                    : `${graph.skippedSourceCount} source(s) were skipped; full evidence is linked`,
+            },
+        ],
+    };
+}
+function analysisRequest(input, workspaceId, context, signal) {
+    const impact = input.impact === undefined
+        ? undefined
+        : {
+            kind: input.impact.kind,
+            id: input.impact.id,
+            operation: input.impact.operation,
+            ...(input.impact.replacementId === undefined
+                ? {}
+                : { replacementId: input.impact.replacementId }),
+        };
+    const values = {
+        folderId: input.folderId,
+        technologyId: input.technologyId,
+        categoryId: input.categoryId,
+        targetKind: input.targetKind,
+        targetId: input.targetId,
+        direction: input.direction,
+        maxDepth: input.maxDepth,
+        maxNodes: input.maxNodes,
+        includeSubTechnologies: input.includeSubTechnologies,
+        classifications: input.classifications,
+        codes: input.codes,
+        impact,
+        refresh: input.refresh,
+    };
+    const compact = Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
+    return {
+        workspaceId,
+        mode: input.mode,
+        ...compact,
+        ...(context.principal === undefined ? {} : { principal: context.principal }),
+        signal,
+    };
+}
+export function registerTechnologyTools(server, engine, context) {
+    const viewer = new TechnologyTreeViewer(engine);
+    server.registerTool('hoi4.tech_inspect', {
+        title: 'Inspect technology trees',
+        description: 'Scan, discover folders, trace, explain, inspect unlocks or bonuses, lint, and assess impact.',
+        inputSchema: inspectInput,
+        outputSchema: analysisOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const workspaceId = engine.resolver.resolveWorkspaceId(input.workspaceId, context.principal);
+        try {
+            const progress = progressReporter(extra);
+            await progress.report(0, 2, 'Analyzing technologies');
+            const output = await viewer.analyze(analysisRequest(input, workspaceId, context, progress.signal));
+            const result = emptyServiceResult(workspaceId, {
+                mode: input.mode,
+                revision: output.graph.revision,
+                graphHash: graphHash(output.graph),
+                counts: counts(output.graph, output.artifacts.length),
+            });
+            result.code = output.graph.complete ? 'TECH_INSPECTED' : 'TECH_INSPECTED_PARTIAL';
+            setInlineFilesScanned(result, output.graph.filesScanned);
+            result.artifacts = output.artifacts.map(publicArtifactLink);
+            result.validation = validation(output.graph);
+            await progress.report(2, 2, 'Technology analysis complete');
+            return toolResult(result);
+        }
+        catch (error) {
+            return errorResult(error, workspaceId);
+        }
+    });
+    server.registerTool('hoi4.tech_render', {
+        title: 'Render technology trees',
+        description: 'Render source-linked JSON, SVG, PNG, and optional HTML technology views.',
+        inputSchema: renderInput,
+        outputSchema: renderOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const workspaceId = engine.resolver.resolveWorkspaceId(input.workspaceId, context.principal);
+        try {
+            const progress = progressReporter(extra);
+            const request = {
+                workspaceId,
+                view: input.view,
+                ...(input.folderId === undefined ? {} : { folderId: input.folderId }),
+                ...(input.technologyId === undefined ? {} : { technologyId: input.technologyId }),
+                ...(input.categoryId === undefined ? {} : { categoryId: input.categoryId }),
+                ...(input.targetId === undefined ? {} : { targetId: input.targetId }),
+                ...(input.maxNodes === undefined ? {} : { maxNodes: input.maxNodes }),
+                ...(input.includeHtml === undefined ? {} : { includeHtml: input.includeHtml }),
+                ...(input.refresh === undefined ? {} : { refresh: input.refresh }),
+                ...(context.principal === undefined ? {} : { principal: context.principal }),
+                signal: progress.signal,
+            };
+            const output = await viewer.renderAndStore(request);
+            const result = emptyServiceResult(workspaceId, {
+                view: output.render.view,
+                revision: output.graph.revision,
+                graphHash: graphHash(output.graph),
+                hashes: output.render.hashes,
+                selectedNodes: output.render.selectedIds.length,
+                omittedNodes: output.render.omittedNodeCount,
+                focusedRenders: output.focused.length,
+                sourceAccurate: output.render.sourceAccurate,
+            });
+            result.code = output.graph.complete ? 'TECH_RENDERED' : 'TECH_RENDERED_PARTIAL';
+            setInlineFilesScanned(result, output.graph.filesScanned);
+            result.artifacts = output.artifacts.map(publicArtifactLink);
+            result.validation = validation(output.graph);
+            return toolResult(result);
+        }
+        catch (error) {
+            return errorResult(error, workspaceId);
+        }
+    });
+    server.registerTool('hoi4.tech_compare', {
+        title: 'Compare technology trees',
+        description: 'Compare cached, resource-backed, current, or proposed source graphs without writes.',
+        inputSchema: compareInput,
+        outputSchema: compareOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const workspaceId = engine.resolver.resolveWorkspaceId(input.workspaceId, context.principal);
+        try {
+            const progress = progressReporter(extra);
+            const request = {
+                workspaceId,
+                ...(input.before === undefined
+                    ? {}
+                    : { before: input.before }),
+                ...(input.after === undefined
+                    ? {}
+                    : { after: input.after }),
+                ...(input.proposedSources === undefined
+                    ? {}
+                    : {
+                        proposedSources: input.proposedSources,
+                    }),
+                ...(input.render === undefined ? {} : { render: input.render }),
+                ...(input.maxRenderNodes === undefined ? {} : { maxRenderNodes: input.maxRenderNodes }),
+                ...(input.refresh === undefined ? {} : { refresh: input.refresh }),
+                ...(context.principal === undefined ? {} : { principal: context.principal }),
+                signal: progress.signal,
+            };
+            const output = await viewer.compareAndStore(request);
+            const comparison = output.comparison;
+            const result = emptyServiceResult(workspaceId, {
+                beforeRevision: comparison.beforeRevision,
+                afterRevision: comparison.afterRevision,
+                added: comparison.technologies.added.length,
+                removed: comparison.technologies.removed.length,
+                renamed: comparison.technologies.renamed.length,
+                moved: comparison.technologies.moved.length,
+                regressions: comparison.regressions.length,
+                artifacts: output.artifacts.length,
+                ...(output.render === undefined ? {} : { renderHashes: output.render.hashes }),
+            });
+            result.code =
+                output.before.complete && output.after.complete
+                    ? 'TECH_COMPARED'
+                    : 'TECH_COMPARED_PARTIAL';
+            setInlineFilesScanned(result, [...new Set([...output.before.filesScanned, ...output.after.filesScanned])].sort(compareCodeUnits));
+            result.artifacts = output.artifacts.map(publicArtifactLink);
+            result.validation = {
+                passed: validation(output.before).passed && validation(output.after).passed,
+                checks: [...validation(output.before).checks, ...validation(output.after).checks],
+            };
+            return toolResult(result);
+        }
+        catch (error) {
+            return errorResult(error, workspaceId);
+        }
+    });
+}

package/dist/hoi4_agent_tools/schemas/technology.js

@@ -0,0 +1,77 @@
+import { z } from 'zod/v4';
+import { SOURCE_MAX_BYTES } from '../core/source/index.js';
+import { workspaceRelativePathSchema } from './common.js';
+export const technologyIdSchema = z.string().min(1).max(512);
+export const technologyDirectionSchema = z.enum(['prerequisites', 'descendants', 'both']);
+export const technologyUnlockKindSchema = z.enum([
+    'equipment',
+    'equipment_module',
+    'sub_unit',
+    'building',
+    'ability',
+    'tactic',
+    'other',
+]);
+export const technologyDefectClassSchema = z.enum([
+    'confirmed_error',
+    'probable_defect',
+    'design_warning',
+    'unresolved_analysis',
+]);
+export const technologyRenderViewSchema = z.enum([
+    'summary',
+    'folder',
+    'dependencies',
+    'technology',
+    'doctrine',
+    'exclusive',
+    'memberships',
+    'bonuses',
+    'grants',
+    'unlocks',
+    'metadata',
+    'assets',
+    'unresolved',
+    'comparison',
+]);
+export const technologyImpactSchema = z
+    .object({
+    kind: z.enum(['technology', 'category', 'folder', 'unlock_target']),
+    id: technologyIdSchema,
+    operation: z.enum(['remove', 'rename']),
+    replacementId: technologyIdSchema.optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.operation === 'rename' && value.replacementId === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['replacementId'],
+            message: 'Rename requires replacementId',
+        });
+});
+export const technologyGraphReferenceSchema = z
+    .object({
+    revision: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    artifactUri: z
+        .string()
+        .min(1)
+        .max(8_192)
+        .regex(/^hoi4-agent:\/\//u)
+        .optional(),
+})
+    .strict()
+    .refine(({ revision, artifactUri }) => Number(revision !== undefined) + Number(artifactUri !== undefined) === 1, 'Provide exactly one revision or artifact URI');
+export const technologyProposedSourceSchema = z
+    .object({
+    relativePath: workspaceRelativePathSchema,
+    source: z.string().max(SOURCE_MAX_BYTES).nullable(),
+    expectedSourceHash: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+})
+    .strict();

package/dist/hoi4_agent_tools/technology/compare.js

@@ -0,0 +1,240 @@
+import { compareCodeUnits, hashCanonical } from '../core/canonical.js';
+function byId(values) {
+    return new Map(values.map((value) => [value.id, value]));
+}
+function placementSignature(values) {
+    return hashCanonical(values
+        .map(({ folderId, x, y, xExpression, yExpression }) => ({
+        folderId,
+        x: x ?? null,
+        y: y ?? null,
+        xExpression: xExpression ?? null,
+        yExpression: yExpression ?? null,
+    }))
+        .sort((left, right) => compareCodeUnits(left.folderId, right.folderId) ||
+        (left.x ?? 0) - (right.x ?? 0) ||
+        (left.y ?? 0) - (right.y ?? 0)));
+}
+function edgeKey(edge) {
+    return hashCanonical({
+        kind: edge.kind,
+        from: edge.from,
+        to: edge.to,
+        coefficient: edge.coefficient ?? null,
+        ignoreForLayout: edge.ignoreForLayout ?? null,
+    });
+}
+function unlockKey(unlock) {
+    return hashCanonical({
+        technologyId: unlock.technologyId,
+        kind: unlock.kind,
+        targetId: unlock.targetId,
+        level: unlock.level ?? null,
+    });
+}
+function externalKey(reference) {
+    return hashCanonical({
+        kind: reference.kind,
+        sourceKind: reference.sourceKind,
+        sourceId: reference.sourceId,
+        technologyId: reference.technologyId ?? null,
+        categoryId: reference.categoryId ?? null,
+        helperStack: reference.helperStack,
+        expression: reference.expression,
+    });
+}
+function issueKey(issue) {
+    return hashCanonical({
+        code: issue.code,
+        classification: issue.classification,
+        details: issue.details,
+    });
+}
+function difference(before, after, key) {
+    const beforeKeys = new Set(before.map(key));
+    const afterKeys = new Set(after.map(key));
+    return {
+        added: after.filter((value) => !beforeKeys.has(key(value))),
+        removed: before.filter((value) => !afterKeys.has(key(value))),
+    };
+}
+function reachable(graph, signal) {
+    const incoming = new Map();
+    const outgoing = new Map();
+    for (const technology of graph.technologies) {
+        incoming.set(technology.id, 0);
+        outgoing.set(technology.id, []);
+    }
+    for (const edge of graph.edges.filter(({ kind }) => kind === 'prerequisite')) {
+        if (!incoming.has(edge.from) || !incoming.has(edge.to))
+            continue;
+        incoming.set(edge.to, (incoming.get(edge.to) ?? 0) + 1);
+        outgoing.get(edge.from).push(edge.to);
+    }
+    const result = new Set();
+    const pending = graph.technologies
+        .filter(({ id, hidden }) => hidden !== true && (incoming.get(id) ?? 0) === 0)
+        .map(({ id }) => id);
+    while (pending.length > 0) {
+        signal?.throwIfAborted();
+        const current = pending.pop();
+        if (result.has(current))
+            continue;
+        result.add(current);
+        pending.push(...(outgoing.get(current) ?? []));
+    }
+    return result;
+}
+function technologyMetadata(technology) {
+    return {
+        kind: technology.kind,
+        startYear: technology.startYear ?? null,
+        researchCost: technology.researchCost ?? null,
+        doctrineName: technology.doctrineName ?? null,
+        hidden: technology.hidden,
+        folders: technology.folders,
+        categories: technology.categories,
+        tags: technology.tags,
+        subTechnologies: technology.subTechnologies,
+        ai: technology.ai,
+        effectSignature: technology.effectSignature,
+        localisation: technology.localisation,
+        icon: technology.icon,
+    };
+}
+function renameCandidates(removed, added, beforePlacements, afterPlacements, signal) {
+    const candidates = [];
+    const claimed = new Set();
+    for (const before of removed) {
+        signal?.throwIfAborted();
+        const matches = added
+            .filter((after) => !claimed.has(after.id))
+            .map((after) => {
+            const evidence = [];
+            if (before.effectSignature === after.effectSignature)
+                evidence.push('identical effect and unlock signature');
+            if (before.startYear === after.startYear && before.researchCost === after.researchCost)
+                evidence.push('identical year and research cost');
+            if (placementSignature(beforePlacements.filter(({ technologyId }) => technologyId === before.id)) ===
+                placementSignature(afterPlacements.filter(({ technologyId }) => technologyId === after.id)))
+                evidence.push('identical folder placements');
+            if (before.categories.join('\0') === after.categories.join('\0'))
+                evidence.push('identical category membership');
+            if (before.source.path === after.source.path)
+                evidence.push('same source file');
+            return { after, evidence };
+        })
+            .filter(({ evidence }) => evidence.length >= 4)
+            .sort((left, right) => right.evidence.length - left.evidence.length ||
+            compareCodeUnits(left.after.id, right.after.id));
+        if (matches.length !== 1)
+            continue;
+        const match = matches[0];
+        claimed.add(match.after.id);
+        candidates.push({
+            beforeId: before.id,
+            afterId: match.after.id,
+            confidence: match.evidence.length >= 5 ? 'high' : 'medium',
+            evidence: match.evidence,
+        });
+    }
+    return candidates.sort((left, right) => compareCodeUnits(left.beforeId, right.beforeId));
+}
+export function compareTechnologyGraphs(before, after, signal) {
+    signal?.throwIfAborted();
+    const beforeTech = byId(before.technologies);
+    const afterTech = byId(after.technologies);
+    const addedDefinitions = after.technologies.filter(({ id }) => !beforeTech.has(id));
+    const removedDefinitions = before.technologies.filter(({ id }) => !afterTech.has(id));
+    const added = addedDefinitions.map(({ id }) => id).sort(compareCodeUnits);
+    const removed = removedDefinitions.map(({ id }) => id).sort(compareCodeUnits);
+    const moved = [];
+    const metadataChanged = [];
+    for (const [technologyId, beforeDefinition] of beforeTech) {
+        signal?.throwIfAborted();
+        const afterDefinition = afterTech.get(technologyId);
+        if (afterDefinition === undefined)
+            continue;
+        const beforePlacement = before.placements.filter(({ technologyId: id }) => id === technologyId);
+        const afterPlacement = after.placements.filter(({ technologyId: id }) => id === technologyId);
+        if (placementSignature(beforePlacement) !== placementSignature(afterPlacement))
+            moved.push({ technologyId, before: beforePlacement, after: afterPlacement });
+        const beforeMetadata = technologyMetadata(beforeDefinition);
+        const afterMetadata = technologyMetadata(afterDefinition);
+        const fields = Object.keys(beforeMetadata)
+            .filter((field) => hashCanonical(beforeMetadata[field]) !== hashCanonical(afterMetadata[field]))
+            .sort(compareCodeUnits);
+        if (fields.length > 0)
+            metadataChanged.push({
+                technologyId,
+                fields,
+                before: Object.fromEntries(fields.map((field) => [field, beforeMetadata[field]])),
+                after: Object.fromEntries(fields.map((field) => [field, afterMetadata[field]])),
+            });
+    }
+    const edges = difference(before.edges, after.edges, edgeKey);
+    const unlocks = difference(before.unlocks, after.unlocks, unlockKey);
+    const externalReferences = difference(before.externalReferences, after.externalReferences, externalKey);
+    const beforeFolders = byId(before.folders);
+    const afterFolders = byId(after.folders);
+    const folderAdded = after.folders
+        .filter(({ id }) => !beforeFolders.has(id))
+        .map(({ id }) => id)
+        .sort(compareCodeUnits);
+    const folderRemoved = before.folders
+        .filter(({ id }) => !afterFolders.has(id))
+        .map(({ id }) => id)
+        .sort(compareCodeUnits);
+    const folderChanged = before.folders
+        .filter(({ id }) => {
+        const afterFolder = afterFolders.get(id);
+        return (afterFolder !== undefined &&
+            hashCanonical({ ...beforeFolders.get(id), source: undefined }) !==
+                hashCanonical({ ...afterFolder, source: undefined }));
+    })
+        .map(({ id }) => id)
+        .sort(compareCodeUnits);
+    const issueDifference = difference(before.issues, after.issues, issueKey);
+    const retained = before.issues.filter((issue) => new Set(after.issues.map(issueKey)).has(issueKey(issue))).length;
+    const beforeReachable = reachable(before, signal);
+    const afterReachable = reachable(after, signal);
+    const sourceFiles = {
+        added: Object.keys(after.sourceHashes)
+            .filter((sourcePath) => !(sourcePath in before.sourceHashes))
+            .sort(compareCodeUnits),
+        removed: Object.keys(before.sourceHashes)
+            .filter((sourcePath) => !(sourcePath in after.sourceHashes))
+            .sort(compareCodeUnits),
+        changed: Object.keys(before.sourceHashes)
+            .filter((sourcePath) => after.sourceHashes[sourcePath] !== undefined &&
+            after.sourceHashes[sourcePath] !== before.sourceHashes[sourcePath])
+            .sort(compareCodeUnits),
+    };
+    return {
+        schemaVersion: 1,
+        beforeRevision: before.revision,
+        afterRevision: after.revision,
+        technologies: {
+            added,
+            removed,
+            renamed: renameCandidates(removedDefinitions, addedDefinitions, before.placements, after.placements, signal),
+            moved: moved.sort((left, right) => compareCodeUnits(left.technologyId, right.technologyId)),
+            metadataChanged: metadataChanged.sort((left, right) => compareCodeUnits(left.technologyId, right.technologyId)),
+        },
+        edges,
+        unlocks,
+        externalReferences,
+        folders: { added: folderAdded, removed: folderRemoved, changed: folderChanged },
+        issues: { introduced: issueDifference.added, resolved: issueDifference.removed, retained },
+        reachability: {
+            newlyReachable: [...afterReachable]
+                .filter((id) => !beforeReachable.has(id))
+                .sort(compareCodeUnits),
+            newlyOrphaned: [...beforeReachable]
+                .filter((id) => !afterReachable.has(id) && afterTech.has(id))
+                .sort(compareCodeUnits),
+        },
+        sourceFiles,
+        regressions: issueDifference.added.filter(({ classification }) => classification === 'confirmed_error' || classification === 'probable_defect'),
+    };
+}