@kudzujs/core 0.16.11 → 0.16.12

package/MIGRATION_ROADMAP.md

@@ -57,7 +57,7 @@ Syntax compatibility does not mean reproducing React wholesale. Kudzu accepts th
 - stronger JavaScript failure resilience;
 - no remaining material large-route build-scaling weakness.
 
-The completed 0.9 plan defines the cross-framework comparison and release gate. The active application packet is `0.20.1` in the capability release plan below. Benchmark-only feature omission, unmatched accessibility, weighted scores that hide losses, and unrecorded environment differences do not count as proof.
+The completed 0.9 plan defines the cross-framework comparison and release gate. The active application packet is `0.20.2` in the capability release plan below. Benchmark-only feature omission, unmatched accessibility, weighted scores that hide losses, and unrecorded environment differences do not count as proof.
 
 ### 0.10.0 Through 0.21.x: Application Capability Release Train
 

package/PERFORMANCE.md

@@ -2,6 +2,17 @@
 
 Reproducibility classes: `npm run benchmark`, `npm run benchmark:keyed`, `npm run benchmark:native`, `npm run benchmark:module-cache`, `npm run benchmark:project-navigation`, `npm run benchmark:project-state`, and `npm run benchmark:source-scale` are maintained in this repository; `npm run benchmark:commerce` is a maintained paired runner over the public external storefront; older excluded-workspace sections are historical provenance only and are not current framework rankings.
 
+## 0.16.12 Bounded Application Inspection
+
+Measured 2026-08-31 on Linux x64 with Node 24.14.0. Inspection is a build-time
+projection over existing source, compatibility, ownership, capability, and
+artifact records. Representative deploy manifests and hashes remain unchanged.
+The maintained Worker graph remains 907 raw / 477 gzip B and the window graph
+remains 14,456 raw / 6,160 gzip B. Seven clean builds record a 648.7 ms median
+on this host without a timing comparison. Browser-disabled and required-Chrome
+suites pass 295/295 tests, package smoke passes, and bounded deterministic CLI
+coverage includes reachable-source filtering and structured blocker output.
+
 ## 0.16.11 Structured Compiler Diagnostics
 
 Measured 2026-08-31 on Linux x64 with Node 24.14.0. Structured diagnostics are

package/README.md

@@ -14,7 +14,7 @@ Kudzu compiles ordinary React-shaped TypeScript and TSX into complete static HTM
 
 > Experimental `0.16.x`: the compiler API and supported TSX surface may change.
 
-**Latest release: 0.16.11 - Structured compiler diagnostics.** `kudzu build --json` now emits stable codes, semantic stages, exact authored-source ranges, compatibility classes, and safe suggestions while ordinary human diagnostics and browser output remain unchanged. Read the [release notes](./RELEASES.md#01611---structured-compiler-diagnostics), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.16.11), or follow the [architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.16.12 - Bounded application inspection.** `kudzu inspect --json` now projects reachable modules, routes, packages, capabilities, semantic owners, and first blockers from the existing build graph in deterministic bounded output without dumping raw IR. Read the [release notes](./RELEASES.md#01612---bounded-application-inspection), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.16.12), or follow the [architecture packet](./docs/next-architecture/README.md).
 
 - [Documentation](https://kudzujs.cloud/docs)
 - [Installation guide](https://kudzujs.cloud/docs#install)

package/RELEASES.md

@@ -1,5 +1,38 @@
 # Kudzu Releases
 
+## 0.16.12 - Bounded Application Inspection
+
+Kudzu 0.16.12 lets tools select the first migration blocker from a compact
+reachable-application inventory instead of reading the compiler's raw semantic
+records or scanning an entire source tree.
+
+### Changed in 0.16.12
+
+- Adds `kudzu inspect --json`, which runs the authoritative build graph and emits
+  one versioned report of reachable modules, routes, package compatibility,
+  capability families, semantic owners, and blocker candidates.
+- Sorts every section before applying fixed limits and reports total and omitted
+  counts so large applications retain bounded deterministic context.
+- Distinguishes confirmed structured diagnostic blockers from unsupported
+  compatibility sites and partial-package review candidates.
+- Excludes unreachable source, generated module code, HTML, RouteIR, ModuleIR,
+  captures, state values, and complete artifact closures from inspection output.
+- Reuses existing source, compatibility, ownership, capability, and artifact
+  records; it adds no analyzer, semantic primitive, runtime concept, public
+  application API, or browser byte.
+- Updates `create-kudzu@0.1.137` to generate projects on
+  `@kudzujs/core@^0.16.12`.
+
+`inspect` performs the ordinary authoritative build, including configured
+`afterBuild()` behavior. A structured compiler failure returns a bounded blocked
+report with incomplete inventory rather than pretending that later facts exist.
+
+### Upgrade
+
+```sh
+npm install @kudzujs/core@^0.16.12
+```
+
 ## 0.16.11 - Structured Compiler Diagnostics
 
 Kudzu 0.16.11 gives tools and agents stable machine-readable authored-source

package/bin/kudzu.mjs

@@ -6,19 +6,32 @@ import { fileURLToPath } from "node:url"
 
 const command = process.argv[2] ?? "dev"
 
-if (command === "build" && !process.env.KUDZU_BUILD_CHILD) {
+if ((command === "build" || command === "inspect") && !process.env.KUDZU_BUILD_CHILD) {
   const child = spawnSync(process.execPath, ["--expose-gc", "--max-semi-space-size=8", fileURLToPath(import.meta.url), ...process.argv.slice(2)], {
     stdio: "inherit",
     env: { ...process.env, KUDZU_BUILD_CHILD: "1" }
   })
   if (child.error) throw child.error
   process.exitCode = child.status ?? 1
-} else if (command === "build" || command === "dev") {
+} else if (command === "build" || command === "dev" || command === "inspect") {
   module.enableCompileCache?.()
-  const { build, dev } = await import("../framework/build.mjs")
+  const { build, dev, inspect } = await import("../framework/build.mjs")
   const json = command === "build" && process.argv.includes("--json")
   try {
-    await (command === "build" ? build({ quiet: json }) : dev())
+    if (command === "inspect") {
+      if (!process.argv.includes("--json")) {
+        console.error("Use: kudzu inspect --json")
+        process.exitCode = 1
+      } else {
+        const log = console.log
+        console.log = console.error
+        try {
+          process.stdout.write(`${JSON.stringify(await inspect())}\n`)
+        } finally {
+          console.log = log
+        }
+      }
+    } else await (command === "build" ? build({ quiet: json }) : dev())
   } catch (error) {
     const { diagnosticEnvelope } = await import("../framework/compiler/diagnostics.mjs")
     const envelope = diagnosticEnvelope(error)
@@ -27,6 +40,6 @@ if (command === "build" && !process.env.KUDZU_BUILD_CHILD) {
     process.exitCode = 1
   }
 } else {
-  console.error(`Unknown command: ${command}\nUse: kudzu <build|dev>`)
+  console.error(`Unknown command: ${command}\nUse: kudzu <build|dev|inspect>`)
   process.exitCode = 1
 }

package/docs/next-architecture/README.md

@@ -15,7 +15,7 @@ The completed `0.9.0` milestone is recorded in [`0.9-semantic-compression.md`](.
 
 [`1.0-large-application-compatibility-audit.md`](./1.0-large-application-compatibility-audit.md) records the first post-0.9 probes against Memos, Apache Answer, and Actual Budget. The audit finds that reduced slices build but whole-application source retention and behavior parity do not yet pass.
 
-[`application-capability-release-plan.md`](./application-capability-release-plan.md) is the authoritative post-0.9 execution queue, currently at `0.20.1`. It assigns one application-capability section to each minor release and one independently accepted evidence packet to each patch release from `0.10.0` through the `1.0.0` gate. It supersedes the provisional 0.10/0.11/0.12 tool-first ordering in the completed 0.9 handoff without rewriting that historical record.
+[`application-capability-release-plan.md`](./application-capability-release-plan.md) is the authoritative post-0.9 execution queue, currently at `0.20.2`. It assigns one application-capability section to each minor release and one independently accepted evidence packet to each patch release from `0.10.0` through the `1.0.0` gate. It supersedes the provisional 0.10/0.11/0.12 tool-first ordering in the completed 0.9 handoff without rewriting that historical record.
 
 ## Required Invariants
 

package/docs/next-architecture/application-capability-release-plan.md

@@ -1826,6 +1826,27 @@ artifact accounting, and `git diff --check` pass. The packet ships as
 - **Done condition:** the first blocker can be selected without reading hundreds
   of source or dependency files.
 
+Complete. `kudzu inspect --json` now runs the authoritative build and projects
+the existing reachable source, compatibility, ComponentAnalysis, ModuleIR,
+CapabilityIR, and route-artifact records into one versioned report. Modules,
+routes, packages, compatibility sites, capability families, semantic owners,
+and blockers sort before fixed section limits; totals and omitted counts keep
+large-project context explicit. Unreachable source, generated code, HTML, raw
+IR, captures, state values, and full artifact closures remain excluded.
+
+One real CLI fixture proves reachable filtering, static and interactive route
+facts, native package classification, state ownership, project-relative paths,
+deterministic output, and structured blocked inventory. A synthetic 101-module
+and 51-blocker check proves sort-before-truncation and first-blocker retention.
+The implementation is one 154-line projection over existing records plus the
+existing build/CLI seam; it adds no analyzer, semantic primitive, compiler pass,
+normalization entry, runtime concept, or browser module. Representative deploy
+manifests and hashes remain unchanged. Worker and window graphs remain 907 raw /
+477 gzip and 14,456 raw / 6,160 gzip bytes; seven clean builds record a 648.7 ms
+median without a timing comparison. Browser-disabled and required-Chrome suites
+pass 295/295 tests, package smoke and artifact accounting pass, and the packet
+ships as `@kudzujs/core@0.16.12` with `create-kudzu@0.1.137`.
+
 ### `0.20.2`: `kudzu explain --route`
 
 - **Purpose:** trace one authored route to its selected browser artifacts.
@@ -2051,3 +2072,4 @@ release transaction where possible or document and publish a forward-fix patch.
 | `0.19.4` | Closed by existing effect ownership | Preserve reaction mutation, version deduplication, stale-socket rejection, reconnect, keyed identity, exact route cleanup, fresh ownership, bounded handles/listeners/timers, and public zero-JavaScript output. | No production change; no release consumed |
 | `0.19.5` | Deferred by stop condition | Resume only from a complete pinned Actual Budget workspace with an executable dependency graph and honest retention denominator. | Sparse acquisition omits required workspace and core packages; no compatibility claim |
 | `0.20.0` | Released as `0.16.11` | Preserve stable diagnostic schema/codes, authored ranges, human errors, compatibility reuse, and zero browser/output delta. | Patch release retained the `0.16.x` public version line |
+| `0.20.1` | Released as `0.16.12` | Preserve bounded deterministic reachable inventory, first-blocker retention, existing-record reuse, and zero browser/output delta. | Patch release retained the `0.16.x` public version line |

package/docs/next-architecture/compiler-current-architecture.md

@@ -1,6 +1,6 @@
 # Current Compiler Architecture
 
-This maps the current `0.16.11` architecture, built on the completed `0.9.0` semantic-compression release and `0.8.23` Goal A compiler foundation. The active application packet is `0.20.1`; file and function names are the stable references, while line numbers are intentionally omitted because later work may still move code.
+This maps the current `0.16.12` architecture, built on the completed `0.9.0` semantic-compression release and `0.8.23` Goal A compiler foundation. The active application packet is `0.20.2`; file and function names are the stable references, while line numbers are intentionally omitted because later work may still move code.
 
 ## Responsibility Map
 

package/docs/next-architecture/large-application-ai-native-roadmap.md

@@ -2,9 +2,9 @@
 
 ## Status
 
-Completed compiler-foundation record and longer-term plan after `0.8.35`. The [`0.9-semantic-compression.md`](./0.9-semantic-compression.md) execution queue is complete. The active queue for current work is [`application-capability-release-plan.md`](./application-capability-release-plan.md) at packet `0.20.1`. This document does not mark any remaining planned capability as supported and does not authorize a React runtime, VDOM, hydration, retained browser component tree, generic rerenderer, public store/query/resource API, SPA router, or islands.
+Completed compiler-foundation record and longer-term plan after `0.8.35`. The [`0.9-semantic-compression.md`](./0.9-semantic-compression.md) execution queue is complete. The active queue for current work is [`application-capability-release-plan.md`](./application-capability-release-plan.md) at packet `0.20.2`. This document does not mark any remaining planned capability as supported and does not authorize a React runtime, VDOM, hydration, retained browser component tree, generic rerenderer, public store/query/resource API, SPA router, or islands.
 
-[`MIGRATION_ROADMAP.md`](../../MIGRATION_ROADMAP.md) remains the product authority for product invariants and fixture-driven feature selection. [`application-capability-release-plan.md`](./application-capability-release-plan.md) is authoritative for current work order and evidence at packet `0.20.1`; this plan retains the completed foundation, deferred program, and long-term production gates. If implementation evidence changes either boundary, update the relevant document before broadening a patch.
+[`MIGRATION_ROADMAP.md`](../../MIGRATION_ROADMAP.md) remains the product authority for product invariants and fixture-driven feature selection. [`application-capability-release-plan.md`](./application-capability-release-plan.md) is authoritative for current work order and evidence at packet `0.20.2`; this plan retains the completed foundation, deferred program, and long-term production gates. If implementation evidence changes either boundary, update the relevant document before broadening a patch.
 
 ## Product Outcome
 
@@ -483,4 +483,4 @@ The first comparison is Kudzu versus React + Vite using the same agent, model, t
 
 ## Immediate Decision
 
-All listed foundation and `0.9` slices are complete. Current work continues at `0.20.1` `kudzu inspect --json` under the [`application-capability-release-plan.md`](./application-capability-release-plan.md); keep ResourceIR limited to qualifying independent fixtures, and do not add range ownership, virtualization, optimistic transactions, a public adapter/store API, or a router before evidence justifies them.
+All listed foundation and `0.9` slices are complete. Current work continues at `0.20.2` `kudzu explain --route` under the [`application-capability-release-plan.md`](./application-capability-release-plan.md); keep ResourceIR limited to qualifying independent fixtures, and do not add range ownership, virtualization, optimistic transactions, a public adapter/store API, or a router before evidence justifies them.

package/docs/next-architecture/versioning.md

@@ -1,6 +1,6 @@
 # Planned Version Sequence
 
-This is an execution sequence, not release history. `0.8.16` through `0.8.62` are completed scopes represented by package/release records. The `0.10.0` through `1.0.0` minor/patch sequence is maintained in [`application-capability-release-plan.md`](./application-capability-release-plan.md), currently at `0.20.1`; that plan supersedes the provisional tool-first 0.10/0.11/0.12 ordering in the completed 0.9 handoff.
+This is an execution sequence, not release history. `0.8.16` through `0.8.62` are completed scopes represented by package/release records. The `0.10.0` through `1.0.0` minor/patch sequence is maintained in [`application-capability-release-plan.md`](./application-capability-release-plan.md), currently at `0.20.2`; that plan supersedes the provisional tool-first 0.10/0.11/0.12 ordering in the completed 0.9 handoff.
 
 Keep each patch behavior-preserving and independently reviewable. If a boundary proves inseparable, revise this plan before combining releases; do not silently broaden a patch.
 
@@ -66,7 +66,7 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 
 ## Generator Versions
 
-`create-kudzu@0.1.136` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.16.11`.
+`create-kudzu@0.1.137` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.16.12`.
 
 ## Release Boundary
 

package/framework/build.mjs

@@ -5,7 +5,8 @@ import { pathToFileURL } from "node:url"
 import { build as bundle, transform } from "esbuild"
 import { createEffectCodegen } from "./compiler/effect-codegen.mjs"
 import { createCompatibilityReport } from "./compiler/compatibility-registry.mjs"
-import { normalizeDiagnosticError } from "./compiler/diagnostics.mjs"
+import { diagnosticEnvelope, normalizeDiagnosticError } from "./compiler/diagnostics.mjs"
+import { createInspectionReport } from "./compiler/inspection-report.mjs"
 import { generateListRuntime } from "./compiler/list-runtime-codegen.mjs"
 import { assetPath, browserPath, relativeModulePath, withBase } from "./compiler/path-helpers.mjs"
 import { createProjectSession } from "./compiler/project-session.mjs"
@@ -38,7 +39,12 @@ export async function build({ quiet = false, minify = true, root: projectRoot =
   return buildWithSession(project, { quiet, minify, retainCache: false })
 }
 
-export async function buildWithSession(project, { changedFiles, quiet = false, minify = true, retainCache = true } = {}) {
+export async function inspect({ minify = true, root: projectRoot = process.cwd() } = {}) {
+  const project = createProjectSession(projectRoot)
+  return buildWithSession(project, { quiet: true, minify, retainCache: false, inspection: true })
+}
+
+export async function buildWithSession(project, { changedFiles, quiet = false, minify = true, retainCache = true, inspection = false } = {}) {
   const { root, outputDirectory } = project
   const stagedOutput = join(root, ".kudzu-dist-staging")
   const backupOutput = join(root, ".kudzu-dist-backup")
@@ -47,13 +53,16 @@ export async function buildWithSession(project, { changedFiles, quiet = false, m
   try {
     await recoverOutput(outputDirectory, backupOutput)
     await rm(stagedOutput, { recursive: true, force: true })
-    const { result, pageCount, behaviorCount, cache } = await buildInto(project, stagedOutput, { changedFiles, minify, quiet, retainCache })
+    const { result, pageCount, behaviorCount, cache, inspectionData } = await buildInto(project, stagedOutput, { changedFiles, minify, quiet, retainCache })
     await promoteOutput(stagedOutput, outputDirectory, backupOutput)
     project.buildCache = retainCache ? cache : undefined
     if (!quiet) console.log(`Built ${pageCount} page(s), ${behaviorCount} interactive page(s) into dist/`)
-    return result
+    return inspection ? createInspectionReport(inspectionData) : result
   } catch (error) {
-    throw normalizeDiagnosticError(error, root)
+    const normalized = normalizeDiagnosticError(error, root)
+    const envelope = inspection && diagnosticEnvelope(normalized)
+    if (envelope) return createInspectionReport({ diagnostics: envelope.diagnostics })
+    throw normalized
   } finally {
     try {
       await rm(stagedOutput, { recursive: true, force: true })
@@ -107,7 +116,8 @@ async function buildInto(project, outputDirectory, { changedFiles, minify, quiet
   if (!pageFiles.length) throw new Error("No pages found in src/pages/")
   const pageSources = new Map(pageFiles.map(file => [file, new Set(reachableSourceFiles([file], allSourceFileSet, sourceIndex))]))
   const sourceFiles = [...new Set([...pageSources.values()].flatMap(files => [...files]))].sort()
-  await writePrettyJson(join(workDirectory, "kudzu-compatibility.json"), createCompatibilityReport(sourceFiles.map(file => ({ file: relative(root, file).replaceAll(sep, "/"), source: sourceIndex.get(file) }))))
+  const compatibility = createCompatibilityReport(sourceFiles.map(file => ({ file: relative(root, file).replaceAll(sep, "/"), source: sourceIndex.get(file) })))
+  await writePrettyJson(join(workDirectory, "kudzu-compatibility.json"), compatibility)
   const sourceFileSet = project.sourceFiles
   sourceFileSet.clear()
   for (const file of sourceFiles) sourceFileSet.add(file)
@@ -527,6 +537,7 @@ async function buildInto(project, outputDirectory, { changedFiles, minify, quiet
   const incremental = { compiledModules, renderedPages }
   return {
     result: { sourceResults, incremental },
+    inspectionData: { sourceFiles: sourceFiles.map(file => relative(root, file).replaceAll(sep, "/")), sourceResults, compatibility, artifacts },
     pageCount: routeRecords.length,
     behaviorCount,
     cache: { pageRenders, pageSources, placeholders, sourceResults: sourceResultsByFile }

package/framework/compiler/inspection-report.mjs

@@ -0,0 +1,156 @@
+const limits = Object.freeze({ modules: 100, routes: 100, packages: 100, compatibilitySites: 100, capabilities: 50, owners: 100, blockers: 50 })
+
+export function createInspectionReport({ sourceFiles = [], sourceResults = [], compatibility, artifacts, diagnostics = [] } = {}) {
+  const complete = diagnostics.length === 0
+  const modules = complete ? moduleFacts(sourceFiles, sourceResults) : []
+  const routes = complete ? routeFacts(artifacts?.routes ?? []) : []
+  const packages = complete ? [...(compatibility?.packages ?? [])] : []
+  const compatibilitySites = complete ? [...(compatibility?.sites ?? [])] : []
+  const capabilities = complete ? capabilityFacts(artifacts?.runtimeFamilies ?? []) : []
+  const owners = complete ? ownerFacts(sourceResults) : []
+  const blockers = complete ? compatibilityBlockers(compatibilitySites) : diagnosticBlockers(diagnostics)
+  const sections = { modules, routes, packages, compatibilitySites, capabilities, owners, blockers }
+
+  return {
+    version: 1,
+    status: blockers.some(blocker => blocker.severity === "error") ? "blocked" : "ready",
+    inventoryComplete: complete,
+    limits,
+    summary: Object.fromEntries(Object.entries(sections).map(([name, entries]) => [name, entries.length])),
+    ...Object.fromEntries(Object.entries(sections).map(([name, entries]) => [name, entries.slice(0, limits[name])])),
+    omitted: Object.fromEntries(Object.entries(sections).map(([name, entries]) => [name, Math.max(0, entries.length - limits[name])])),
+  }
+}
+
+function moduleFacts(sourceFiles, sourceResults) {
+  const results = new Map(sourceResults.map(result => [result.file, result]))
+  return [...sourceFiles].sort(compareText).map(file => {
+    const result = results.get(file)
+    const moduleIR = result?.moduleIR
+    return compact({
+      file,
+      kind: file.endsWith(".worker.ts") ? "worker" : file.startsWith("src/pages/") && file.endsWith(".tsx") ? "page" : "module",
+      owners: result?.componentAnalysis.owners.length ?? 0,
+      specializations: result?.componentAnalysis.specializations.length ?? 0,
+      signals: moduleIR?.signals.length ?? 0,
+      sharedStates: moduleIR?.sharedStates.length ?? 0,
+      sharedActions: moduleIR?.sharedActions.length ?? 0,
+      handlers: moduleIR?.handlers.length ?? 0,
+      bindings: moduleIR?.bindings.length ?? 0,
+      derived: moduleIR?.derived.length ?? 0,
+      effects: moduleIR?.effects.length ?? 0,
+      keyedBlocks: moduleIR?.keyedBlocks.length ?? 0,
+      imports: moduleIR?.imports.length ?? 0,
+    })
+  })
+}
+
+function routeFacts(routes) {
+  return [...routes].sort((left, right) => compareText(left.route, right.route)).map(route => ({
+    route: route.route,
+    runtimeFamily: route.runtime.family,
+    static: route.runtime.family === null && route.runtime.entries.length === 0 && route.handlers.entries.length === 0 && route.handlers.chunks.length === 0 && route.handlers.lazyChunks.length === 0 && route.workers.length === 0,
+    capabilities: enabledFacts(route.capability.manifest),
+    artifacts: {
+      runtimeEntries: route.runtime.entries.length,
+      runtimeRequirements: route.runtime.requirements.length,
+      handlerEntries: route.handlers.entries.length,
+      chunks: route.handlers.chunks.length,
+      lazyChunks: route.handlers.lazyChunks.length,
+      workers: route.workers.length,
+      styles: route.styles.length,
+    },
+  }))
+}
+
+function capabilityFacts(families) {
+  return [...families].sort((left, right) => compareText(left.id, right.id)).map(family => ({
+    id: family.id,
+    navigation: family.navigation,
+    routes: family.routes.length,
+    facts: enabledFacts(family.manifest),
+    requirements: family.requirements.length,
+  }))
+}
+
+function ownerFacts(sourceResults) {
+  const owners = []
+  for (const result of sourceResults) {
+    const effects = result.moduleIR.effects
+    const blocks = result.moduleIR.keyedBlocks
+    for (const owner of result.componentAnalysis.owners) owners.push(ownerFact(result.file, "component", owner, effects, blocks))
+    for (const owner of result.componentAnalysis.specializations) owners.push(ownerFact(result.file, "specialization", owner, effects, blocks))
+  }
+  return owners.sort((left, right) => compareText(left.module, right.module) || compareText(left.kind, right.kind) || left.slot - right.slot)
+}
+
+function ownerFact(module, kind, owner, effects, blocks) {
+  return {
+    module,
+    kind,
+    slot: owner.slot,
+    name: typeof owner.name === "string" ? owner.name : typeof owner.component === "string" ? owner.component : owner.component?.name ?? "anonymous",
+    ...compact({
+      stateCount: owner.states?.length ?? 0,
+      refCount: owner.refs?.length ?? 0,
+      idCount: owner.ids?.length ?? 0,
+      effectCount: effects.filter(effect => effect.ownership?.owner?.kind === kind && effect.ownership.owner.slot === owner.slot).length,
+      keyedBlockCount: kind === "specialization" ? blocks.filter(block => block.specializations?.includes(owner.slot)).length : 0,
+    }),
+  }
+}
+
+function compatibilityBlockers(sites) {
+  return sites.filter(site => site.classification === "Unsupported" || site.classification === "Partial").map(site => ({
+    kind: "compatibility",
+    severity: site.classification === "Unsupported" ? "error" : "review",
+    code: site.rule,
+    file: site.file,
+    location: site.location,
+    package: site.package,
+    imported: site.imported,
+    classification: site.classification,
+  })).sort(compareBlockers)
+}
+
+function diagnosticBlockers(diagnostics) {
+  return diagnostics.map(diagnostic => ({
+    kind: "diagnostic",
+    severity: diagnostic.severity,
+    code: diagnostic.code,
+    stage: diagnostic.stage,
+    message: diagnostic.message,
+    ...(diagnostic.source ? { source: diagnostic.source } : {}),
+    compatibilityClass: diagnostic.compatibilityClass,
+    suggestion: diagnostic.suggestion,
+  })).sort(compareBlockers)
+}
+
+function enabledFacts(value, prefix = "") {
+  const facts = []
+  for (const [key, entry] of Object.entries(value ?? {}).sort(([left], [right]) => compareText(left, right))) {
+    if (key === "version") continue
+    const path = prefix ? `${prefix}.${key}` : key
+    if (entry === true) facts.push(path)
+    else if (typeof entry === "number" && entry > 0) facts.push(`${path}=${entry}`)
+    else if (Array.isArray(entry)) for (const item of entry) facts.push(`${path}=${item}`)
+    else if (entry && typeof entry === "object") facts.push(...enabledFacts(entry, path))
+  }
+  return facts
+}
+
+function compact(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== 0))
+}
+
+function compareBlockers(left, right) {
+  const leftFile = left.file ?? left.source?.file ?? ""
+  const rightFile = right.file ?? right.source?.file ?? ""
+  const leftLocation = left.location ?? left.source?.start ?? {}
+  const rightLocation = right.location ?? right.source?.start ?? {}
+  return compareText(leftFile, rightFile) || (leftLocation.line ?? 0) - (rightLocation.line ?? 0) || (leftLocation.column ?? 0) - (rightLocation.column ?? 0) || compareText(left.code, right.code)
+}
+
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kudzujs/core",
-  "version": "0.16.11",
+  "version": "0.16.12",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",