@ai-matrx/content-ir-react 0.7.1 → 0.8.0

package/dist/index.d.cts

@@ -1,279 +1,17 @@
-import * as react from 'react';
-import react__default, { ReactNode } from 'react';
-import { KindDefinition, CanonicalBlockIR, PartialKindEvent } from '@ai-matrx/content-ir';
-
-/**
- * THE SCREAM SEAM.
- *
- * Every recovery path in this package is loud: a defective component row, a
- * failed resolver load, a kind whose component throws on a provisional value.
- * The package refuses to own where those screams land — matrx-frontend routes
- * them to the Error Inspector, the dashboard to its own log, the extension to
- * its background page. Each host binds one function.
- *
- * A host that binds a no-op has chosen silence, which is a defect in itself;
- * {@link consoleErrorReporter} is the honest default.
- */
-interface ContentIrErrorReport {
-    /** Always `"content-ir"` — hosts key their capture stores on it. */
-    source: "content-ir";
-    message: string;
-    name?: string;
-    stack?: string;
-    /** Free-form grouping key (the host's `relation`), e.g. `"partial-kind"`. */
-    relation?: string;
-    raw?: unknown;
-}
-type ContentIrErrorReporter = (report: ContentIrErrorReport) => void;
-/** The default when a host binds nothing: never silent. */
-declare const consoleErrorReporter: ContentIrErrorReporter;
-
-/**
- * The (kind, platform, role) → component vocabulary — the Shape System's
- * resolver contract (rulings R1 + R6), stated once for every UI.
- *
- * Cross-repo system-of-record:
- * `common-docs/systems/content-ir-twin/FEATURE.md` (package boundary) and
- * `matrx-frontend/features/content-ir/docs/SHAPE_SYSTEM.md` (the semantics).
- *
- * Nothing here knows where a row comes from. A host supplies rows from
- * `content_ir.kind_component` (Supabase, a REST call, a fixture); the resolver
- * only knows the shape.
- */
-/** JSON object, restated locally so this package depends on no host type. */
-type JsonObject = Record<string, unknown>;
-/**
- * Which face of the shape a component draws.
- *
- * - `output` — the shape's finished value, the component a reader sees.
- * - `input`  — the authoring form for a value of this shape.
- * - `loading` — the shape's LOADING face: what renders from the instant the
- *   kind is identified until its output component has a renderable frame.
- *   Authored per kind like any other component and fed the region's partial
- *   value each frame, so it can PERFORM the arrival (surface real text as it
- *   lands) instead of drawing a shapeless skeleton. Optional: a kind with no
- *   `loading` component falls back to the host's loading library.
- */
-type ComponentRole = "output" | "input" | "loading";
-/**
- * One `content_ir.kind_component` row, projected to exactly what rendering
- * needs. Hosts map their own query result onto this.
- */
-interface KindComponentRow {
-    kind: string;
-    platform: string;
-    role: ComponentRole;
-    componentKey: string;
-    /** `source` column vocabulary: "bundled" | "db" (db = web sandbox only). */
-    source: string;
-    config: JsonObject;
-    isActive: boolean;
-    componentSource: string | null;
-    propsTransform: string | null;
-    /**
-     * Whether the row carries a real `component_source` body — supplied by the
-     * host when its warm list is BODY-LESS (the lazy design: metadata travels
-     * on the list, the body arrives per kind via the cold fetch). Omitted →
-     * derived from `componentSource` itself, so eager hosts change nothing.
-     */
-    hasComponentSource?: boolean;
-    pinnedKindVersion: number | null;
-    updatedAt: string | null;
-    createdBy: string | null;
-}
-/**
- * One COMPILED bootstrap entry — the trusted-at-boot floor a host ships in its
- * bundle, available synchronously from the first streamed byte.
- */
-interface SystemComponentEntry {
-    kind: string;
-    platform: string;
-    role: ComponentRole;
-    componentKey: string;
-    source: string;
-    config: JsonObject;
-}
-/** The resolver's answer for one (kind, platform, role). */
-interface ComponentResolution {
-    /** The component key the renderer routes on (e.g. "flashcards"). */
-    componentKey: string;
-    source: string;
-    config: JsonObject;
-    /**
-     * Render-trust verdict (R6). Compiled entries are always active (trusted at
-     * bootstrap); DB rows carry their own `is_active`.
-     */
-    isActive: boolean;
-    /** Which tier produced this answer — the verification hook's `by`. */
-    resolvedBy: "compiled" | "db";
-    componentSource: string | null;
-    propsTransform: string | null;
-    /**
-     * TRUE when the row owns a real component body — even if `componentSource`
-     * is null because the host's warm list is body-less and the cold fetch has
-     * not landed it yet. THE routing gate: `routeToDbComponent` re-types on
-     * this flag, never on body presence, so a body-less row still routes and
-     * the renderer fetches/compiles the body lazily.
-     */
-    hasComponentSource: boolean;
-    pinnedKindVersion: number | null;
-    /** The db row's `updated_at` — the compile-cache staleness key. */
-    updatedAt: string | null;
-    createdBy: string | null;
-}
-/**
- * The read side of a component resolver, as the render layer consumes it.
- * The package ships {@link ComponentResolver}; a host with its own resolver
- * only has to satisfy this.
- */
-interface ComponentResolutionSource {
-    /** Synchronous — the render seam's per-block call. */
-    resolve(kind: string, platform: string, role: ComponentRole): ComponentResolution | null;
-    /** Eager targeted fetch for one kind; fire-and-forget, never awaited on the hot path. */
-    requestComponent(kind: string, platform: string, role: ComponentRole): void;
-    /** One list fetch per session. */
-    ensureWarm(): Promise<void>;
-    /** Refresh-on-view; rate-limited and deduped by the implementation. */
-    refresh(maxAgeMs?: number): Promise<void>;
-    /** Monotonic tier version — has anything at all changed? */
-    getVersion(): number;
-    /** Monotonic per-kind version (+ wholesale epoch) — the granular repaint key. */
-    getKindVersion(kind: string): number;
-    subscribe(listener: () => void): () => void;
-    subscribeKind(kind: string, listener: () => void): () => void;
-}
-
-/**
- * THE HOST CONTRACT — everything this package refuses to decide.
- *
- * The kernel (`@ai-matrx/content-ir`) proved the shape: extract the portable
- * part, let host capability enter through explicit named seams. The render
- * layer needs four things it must never own:
- *
- *  1. WHERE KIND DEFINITIONS COME FROM (a bundled table, `content_ir`, a REST
- *     call). The route only asks "is this kind registered, and does it carry a
- *     legacy bridge / a partial-ready opt-in".
- *  2. WHERE COMPONENT ROWS COME FROM — {@link ComponentResolutionSource}. The
- *     package ships `ComponentResolver`, which any host can construct with its
- *     own loaders; a host with its own resolver only has to satisfy the type.
- *  3. HOW A ROUTED BLOCK ACTUALLY DRAWS. `applyIrKindRoute` decides a block's
- *     TYPE; turning that type into pixels is the host's dispatch table
- *     (matrx-frontend's `BlockRenderer`, the dashboard's small map). The
- *     package never imports a component library.
- *  4. WHERE SCREAMS LAND — {@link ContentIrErrorReporter}.
- *
- * No Next.js, no Redux, no Supabase, no router, no host error capture. If a
- * seam is missing, ADD A SEAM — never an import.
- */
-
-/**
- * The minimum a render block must expose for the kind route to work. Hosts
- * pass their own richer block type through; the route is generic over `T` and
- * preserves every extra field.
- */
-interface IrRoutableBlock {
-    type: string;
-    serverData?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-}
-/** A routable block that also carries its source text (the raw region). */
-interface IrRenderBlock extends IrRoutableBlock {
-    content: string;
-    language?: string;
-}
-/**
- * Where registered kinds come from. `getDefinition` is the only method the
- * pure route needs; the rest drive the granular repaint and the warm-up tick
- * that keeps a cold registry from being mistaken for "this kind has no
- * component".
- */
-interface KindDefinitionSource {
-    getDefinition(kind: string): KindDefinition | undefined;
-    /** Monotonic per-kind version — the repaint snapshot key. */
-    getKindVersion(kind: string): number;
-    subscribeKind(kind: string, listener: () => void): () => void;
-    /** One definition load per app session. */
-    ensureWarm(): Promise<void>;
-}
-/**
- * The rendering seams. Everything here returns host UI; the package supplies
- * the DECISIONS and the chrome-free structure around them.
- */
-interface ContentIrRenderSeams {
-    /**
-     * Draw a block the kind route has already typed. This is the host's dispatch
-     * table — the single place a component key becomes a component.
-     */
-    renderBlock(block: IrRenderBlock): ReactNode;
-    /**
-     * THE FLOOR: render ANY JSON value as a human document. Reached when a kind
-     * has no render-trusted component, when the value is not an object at all,
-     * and by the generic structured view.
-     *
-     * This is deliberately a seam and not a bundled component. Rendering a value
-     * WELL means prose through the host's markdown renderer, media through the
-     * host's file handler, and uniform arrays through the host's data table —
-     * all of which are host property. A host that has none of those can pass a
-     * `<pre>`; it will be honest, just plain.
-     */
-    renderValue(props: StructuredValueRenderProps): ReactNode;
-    /**
-     * The "still arriving" indicator used by the provisional frame. Optional —
-     * hosts without a shimmer get plain text.
-     */
-    renderShimmer?(text: string): ReactNode;
-    /**
-     * The honest "this shape has no custom component yet" notice. Optional: the
-     * package draws a plain amber line when a host supplies nothing, and a host
-     * with an icon set or its own callout component supplies that instead. It is
-     * a seam and not a bundled component because this package depends on no icon
-     * library.
-     */
-    renderNotice?(text: string): ReactNode;
-}
-interface StructuredValueRenderProps {
-    value: unknown;
-    /** The kind slug this value claims, when known. Honesty line only — never a renderer choice. */
-    kind?: string;
-    /** Why this shape has no custom view, in human words. */
-    note?: string;
-    /** Show the "what this is / raw data" footer. Default true. */
-    footer?: boolean;
-}
-/**
- * One host, wired once, read by every component in this package through
- * {@link ContentIrRenderProvider}.
- */
-interface ContentIrHost extends ContentIrRenderSeams {
-    kinds: KindDefinitionSource;
-    components: ComponentResolutionSource;
-    reportError: ContentIrErrorReporter;
-    /**
-     * The `kind_component.platform` this host resolves as. "web" for every
-     * browser UI; the column already models "react-native" and friends, and a
-     * host that lies here renders the wrong component everywhere.
-     */
-    platform: string;
-}
-/**
- * The pure route's dependencies — a strict subset of {@link ContentIrHost},
- * because `applyIrKindRoute` is called OUTSIDE React (reducers, stream
- * accumulators, tests) where there is no provider to read.
- */
-interface KindRouteEnv {
-    kinds: Pick<KindDefinitionSource, "getDefinition">;
-    components: Pick<ComponentResolutionSource, "resolve">;
-    reportError: ContentIrErrorReporter;
-    platform: string;
-}
-/** Narrow a host (or anything host-shaped) to what the pure route needs. */
-declare function routeEnvOf(host: ContentIrHost): KindRouteEnv;
+import { C as ComponentResolutionSource, a as ComponentResolution, b as ContentIrErrorReporter } from './component-resolution.types-fvR92hW7.cjs';
+export { c as ComponentRole, d as ContentIrErrorReport, J as JsonObject, K as KindComponentRow, S as SystemComponentEntry, e as consoleErrorReporter } from './component-resolution.types-fvR92hW7.cjs';
+import { C as ContentIrHost, K as KindRouteEnv, a as KindDefinitionSource } from './route-C55jsF4B.cjs';
+export { b as ContentIrRenderSeams, D as DB_KIND_COMPONENT_KEY, G as GENERIC_STRUCTURED_COMPONENT_KEY, c as GenericFallbackReason, I as IR_PROVISIONAL_KEY, d as IR_ROUTE_KEY, e as IrRenderBlock, f as IrRoutableBlock, g as IrRouteMarker, h as KindRouteBinding, i as KindRouteOptions, P as PartialRenderOptions, j as ProvisionalKindRender, S as StructuredValueRenderProps, k as applyIrKindRoute, l as createKindRouteBinding, m as envelopeFromPartialKind, n as isPartialReadyKind, o as isProvisionalBlock, p as kindServerDataFromStoredValue, q as markKindPartialUnsafe, r as readIrRouteMarker, s as resetPartialUnsafeKinds, t as resetSourcelessDbRowReports, u as resolveAnnouncedKindLoading, v as resolveProvisionalKindRender, w as routeEnvOf } from './route-C55jsF4B.cjs';
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+export { ComponentResolver, ComponentResolverOptions } from './resolver.cjs';
+import '@ai-matrx/content-ir';
 
 interface ContentIrRenderProviderProps {
     host: ContentIrHost;
     children: ReactNode;
 }
-declare function ContentIrRenderProvider({ host, children, }: ContentIrRenderProviderProps): react.JSX.Element;
+declare function ContentIrRenderProvider({ host, children, }: ContentIrRenderProviderProps): React.JSX.Element;
 /**
  * The wired host, or null. For the rare consumer that can legitimately run
  * without a provider because it was handed its sources explicitly (see
@@ -285,399 +23,6 @@ declare function useContentIrHost(): ContentIrHost;
 /** The wired host narrowed to what the pure route functions take. */
 declare function useKindRouteEnv(): KindRouteEnv;
 
-/**
- * The Shape System component RESOLVER (rulings R1 + R6): (kind, platform,
- * role) → component, with two tiers:
- *
- * - eager: a COMPILED bootstrap the host ships in its bundle — the
- *   trusted-at-boot floor, available at import so the render seam can gate
- *   synchronously from the first streamed byte.
- * - warm:  one `content_ir.kind_component` list fetch per app session
- *   (`ensureWarm`). A DB row for a (kind, platform, role) OVERRIDES the
- *   compiled entry once warm; the compiled floor keeps answering until then
- *   (and forever, on DB failure).
- *
- * Resolution is SYNCHRONOUS (the render seam calls it per block); the only
- * async work is the loading, off the render path.
- *
- * WHAT MOVED AND WHY. This class was matrx-frontend's `ComponentRegistry`. It
- * is a large part of why a second UI could not render a kind: every tier rule,
- * every repaint counter, every dedupe latch lived in one app. Nothing about it
- * is Next.js, Redux, or Supabase — the only host-specific parts were the two
- * loaders and the error sink, which are now constructor arguments.
- */
-
-interface ComponentResolverOptions {
-    /**
-     * The compiled bootstrap, as a THUNK resolved on first use: a host's system
-     * component table is often mid-initialization when this module evaluates
-     * (matrx-frontend's registry cluster has a deliberate import cycle).
-     */
-    compiledEntries?: () => SystemComponentEntry[];
-    /** The warm/refresh list load — every `kind_component` row the user may see. */
-    loadAll?: () => Promise<KindComponentRow[]>;
-    /** The eager single-kind load fired the moment a kind is identified mid-stream. */
-    loadForKind?: (kind: string, platform: string) => Promise<KindComponentRow[]>;
-    /** Where recovery screams land. Defaults to `console.error`, never silence. */
-    reportError?: ContentIrErrorReporter;
-    /** Clock seam — the refresh rate limiter. Defaults to `Date.now`. */
-    now?: () => number;
-}
-declare class ComponentResolver implements ComponentResolutionSource {
-    private compiled;
-    private readonly db;
-    private warmPromise;
-    private warmFailureLogged;
-    /**
-     * When the last successful wholesale refresh landed, or null for "never".
-     * Explicitly nullable rather than 0: with a host-supplied clock that starts
-     * near zero, a `0` sentinel makes the FIRST refresh look rate-limited and
-     * silently skip.
-     */
-    private lastRefreshAt;
-    private refreshPromise;
-    private readonly listeners;
-    /**
-     * Cold single-kind fetch dedupe (streaming eager path). In-flight is keyed
-     * by (kind, platform) — the fetch unit; misses are keyed by (kind, platform,
-     * role) so a miss on web/output never suppresses other roles, and CLEARED on
-     * every wholesale refresh (a component created mid-session becomes eagerly
-     * fetchable again — misses are cheap to re-verify).
-     */
-    private readonly coldInFlight;
-    private readonly coldMisses;
-    /** Monotonic db-tier version — the repaint hook's snapshot key. */
-    private version;
-    /** Per-kind versions + listeners (granular repaint) + wholesale epoch. */
-    private readonly kindVersions;
-    private readonly kindListeners;
-    private epoch;
-    private readonly reportError;
-    private readonly now;
-    private readonly options;
-    constructor(options?: ComponentResolverOptions);
-    private compiledMap;
-    /**
-     * Synchronous resolve — the render seam's per-block call. DB override first
-     * (once warm), compiled floor second, null for unknown.
-     */
-    resolve(kind: string, platform: string, role: ComponentRole): ComponentResolution | null;
-    /** R6 floor check: compiled-bootstrap membership = always render-trusted. */
-    hasCompiled(kind: string, platform: string, role: ComponentRole): boolean;
-    /**
-     * Pure ingest — the warm landing point and the unit-test seam. First row per
-     * key wins: rows arrive is_default-first / sort_order-asc from the source.
-     */
-    ingestDbRows(rows: readonly KindComponentRow[]): void;
-    /**
-     * Refresh landing point: REPLACE the db tier wholesale (same
-     * first-row-per-key contract as {@link ingestDbRows}) so edits, deletions,
-     * and is_active flips all take effect. Always notifies.
-     */
-    replaceDbRows(rows: readonly KindComponentRow[]): void;
-    getVersion(): number;
-    getKindVersion(kind: string): number;
-    subscribeKind(kind: string, listener: () => void): () => void;
-    subscribe(listener: () => void): () => void;
-    private bumpKind;
-    private notifyChanged;
-    /**
-     * A warm metadata shell is resolved enough for routing, but not for the
-     * host's db-component renderer. Its body must still come from the cold
-     * single-kind loader.
-     */
-    private needsColdFetch;
-    /**
-     * Cold rows are the authoritative heavy form of warm metadata shells. Keep
-     * the same first-row-per-key winner contract, but replace an existing shell
-     * so `componentSource` / `propsTransform` can land and repaint the kind.
-     */
-    private ingestColdRows;
-    /**
-     * The eager lightweight single-kind fetch (streaming path): the moment a
-     * cloud kind is identified mid-stream, pull ONLY that kind's resolver rows
-     * and ingest them so {@link resolve} can answer before — or shortly after —
-     * the region completes. Deduped in-flight and by known-miss. Fire-and-forget;
-     * failures are loud (the warm list remains the backstop).
-     */
-    requestComponent(kind: string, platform: string, role: ComponentRole): void;
-    /**
-     * Refresh-on-view: re-fetch the warm list and REPLACE the db tier, so an
-     * edited `source='db'` component (its `updated_at` bump re-keys the host's
-     * compile cache) renders fresh on the next view. Deduped in-flight and
-     * rate-limited by `maxAgeMs` (default 10s) — mounting several previews costs
-     * one fetch. Server-side edits do NOT push to open clients; the contract is
-     * refresh-on-view via this call.
-     */
-    refresh(maxAgeMs?: number): Promise<void>;
-    /** One list fetch per app session; failed loads retry on the next call. */
-    ensureWarm(): Promise<void>;
-}
-
-/**
- * THE KIND ROUTE — the render flip, as a pure block transform.
- *
- * A block whose `metadata.__ir` envelope resolved a REGISTERED kind is routed
- * to that kind's component: via the legacy-bridge facet (`legacyBlockType` +
- * `toLegacyServerData`) when the kind has one, so the block enters the host's
- * existing renderer as its real type with envelope-derived serverData;
- * otherwise via the component resolver. Blocks with no envelope, an
- * unregistered kind, or no bridge facet pass through UNTOUCHED — the strangler
- * seam.
- *
- * This is where a bare/fenced JSON flashcard_set — which a text detector could
- * only ever call "code" — becomes real flashcards, live while streaming.
- *
- * PORTABILITY. This function was matrx-frontend's `react/kind-route.ts` and is
- * the single most-copied thing in the system: every UI that renders a kind has
- * to make exactly these decisions in exactly this order, and a second
- * implementation of them is a guaranteed divergence. It takes its registries,
- * its platform, and its error sink as an {@link KindRouteEnv} argument rather
- * than importing them, so it is callable from a reducer, a stream accumulator,
- * a test, or a React render — in any app.
- *
- * Semantics: `matrx-frontend/features/content-ir/docs/SHAPE_SYSTEM.md`
- * (registry, dual gate, `kind_component` resolution, rulings R1 + R6).
- */
-
-/**
- * Runtime routing marker (the Shape System's verification hook): stamped on
- * `metadata.__ir_route` whenever a block routes AND the component resolver
- * produced the decision. `by` says which resolver tier answered ("compiled"
- * floor vs a warm `content_ir.kind_component` row) — the live proof of
- * registry-resolution vs hard-coded fallback. Metadata-only, non-breaking.
- */
-declare const IR_ROUTE_KEY: "__ir_route";
-/**
- * The component key the R6 generic fallback routes to — the official renderer
- * for a KNOWN shape that nothing render-trusted claims. Hosts map this key to
- * their generic structured view (the package ships one: `GenericStructuredView`).
- */
-declare const GENERIC_STRUCTURED_COMPONENT_KEY: "generic_structured";
-/**
- * The block type a DB-sourced (user-authored) kind component renders as.
- * FE-synthesized: produced ONLY here, never emitted upstream. A host that has
- * no sandbox for user components simply does not map this key — the block then
- * falls to that host's unknown-type handling, which is honest.
- */
-declare const DB_KIND_COMPONENT_KEY: "db_kind_component";
-/** Test-only reset of the once-per-kind console latch. */
-declare function resetSourcelessDbRowReports(): void;
-/** Why a block landed on the generic viewer instead of a real renderer. */
-type GenericFallbackReason = 
-/** No compiled bridge and no `content_ir.kind_component` row at all. */
-"no-component"
-/** A component row exists but is held `is_active = false`. */
- | "inactive"
-/**
- * An ACTIVE component row exists and names `generic_structured` — i.e. the
- * fallback, registered under a component's name. This reads as coverage to
- * every count-the-rows check on the platform and is not: the reader still
- * gets a key/value dump. Kept as its own reason because the repair differs
- * (author a component AND retire the decoy row), and because a page that
- * silently marked itself `by: "bundled"` here is how 226 of 428 active
- * kinds came to be certified as renderable while rendering generically
- * (found 2026-08-23).
- */
- | "generic-row"
-/**
- * The envelope carries a kind-preserved RAW: the payload identified a
- * registered kind and its value FAILED a check — a schema violation, an
- * array-item kind mismatch, a duplicate key, a contradicted speculation.
- * The instance is BROKEN, not component-less — the repair is fixing the
- * payload or the schema, and the generic floor must acknowledge the kind and
- * surface the recorded problems.
- *
- * NOT this: a kind whose schema was never available (`kindState:
- * "unverified"`). Nothing checked that value, so calling it broken is a
- * false accusation — it routes to its component. The two were one state
- * until 2026-08-29 and conflating them was a platform-wide outage.
- */
- | "broken-instance"
-/**
- * The slug is not in the registry at all (typo, foreign emitter, a shape
- * not yet created). Routed anyway — Arman's 2026-08-29 ruling: a root
- * `__kind` key means the kind system owns the render, no exceptions. The
- * repair is creating/registering the shape (or fixing the slug).
- */
- | "unregistered";
-interface IrRouteMarker {
-    by: ComponentResolution["resolvedBy"] | "generic";
-    key: string;
-    /**
-     * Only on the generic fallback: the shape is NOT render-trusted, so the
-     * viewer must say so out loud (R6 — never an error, never hidden content).
-     */
-    unverified?: true;
-    reason?: GenericFallbackReason;
-}
-/** Read the routing marker a block picked up at the seam (or null). */
-declare function readIrRouteMarker(metadata: Record<string, unknown> | null | undefined): IrRouteMarker | null;
-interface KindRouteOptions {
-    /**
-     * Block types this host OWNS and the route must never re-type, however good
-     * the envelope on them looks.
-     *
-     * matrx-frontend passes `["artifact"]`: an artifact block has an identity, a
-     * version, and a Canvas to open in, and since 2026-08-18 it carries
-     * `metadata.__ir` so SELECTORS can read the envelope. That envelope is DATA
-     * there, not a route — re-typing it to the bare kind component would strip
-     * the artifact chrome and lose the door to the Canvas.
-     */
-    ownedTypes?: readonly string[];
-}
-declare function applyIrKindRoute<T extends IrRoutableBlock>(block: T, env: KindRouteEnv, options?: KindRouteOptions): T;
-/**
- * Rehydration route for STRUCTURED persisted artifacts.
- *
- * A materialized kind artifact stores its zero-loss value object (carrying
- * `__kind`) alongside its row. Given that stored value, derive the registered
- * kind's legacy `serverData` WITHOUT re-parsing any text: the value wraps into
- * a complete envelope and runs through the same `toLegacyServerData` bridge the
- * live stream uses. Returns null for non-objects, unregistered kinds, or kinds
- * without a legacy bridge — callers fall back to their string-payload path.
- */
-declare function kindServerDataFromStoredValue(value: unknown, env: Pick<KindRouteEnv, "kinds">): Record<string, unknown> | null;
-
-/**
- * Routing the PROVISIONAL half of the streaming partial-kinds contract.
- *
- * Cross-repo system-of-record (read it before changing anything here):
- * `common-docs/systems/content-ir-system/STREAMING_PARTIAL_KINDS.md` §8.
- * The reader/validator half lives in `@ai-matrx/content-ir` (`wire/partial-kind`);
- * the wire gate runs in each host's stream ingest.
- *
- * WHAT THIS DOES
- * --------------
- * While a structured region streams, the server announces what it thinks the
- * region IS and what has arrived so far (`metadata.__ir_partial`). This module
- * turns that provisional event into a routed block that renders through the
- * EXACT SAME component the final value renders in — which is the entire point:
- * a bespoke skeleton renderer would be a second render path and is banned.
- *
- * HOW, without touching the verified channel
- * ------------------------------------------
- * `root` is deliberately `IrStructuredNode`-shaped, so the event wraps into a
- * `CanonicalBlockIR` and every existing reader — the compiled bridge, the
- * component resolver, the db-component flip, the generic viewer — works
- * unchanged. That provisional envelope is placed on a RENDER-LOCAL COPY of the
- * block's metadata under `__ir`, never on the wire and never in host state. The
- * block also carries `__ir_provisional: true` so any downstream reader can tell
- * a provisional render from a verified one.
- *
- * THE POSTURE: WITHHOLD BY DEFAULT, OPT IN PER KIND
- * -------------------------------------------------
- * A provisional value MAY be missing required fields — that is what the
- * `partial_unvalidated` notice declares — and §8 of the contract requires that
- * a component which throws on an absent field is not routed one. Rather than
- * audit every component, the default is WITHHOLD: nothing changes and the block
- * keeps its loading skeleton. A kind opts in with `partialReady: true` on its
- * registry definition. If an opted-in component throws anyway,
- * `ProvisionalKindBoundary` screams and calls `markKindPartialUnsafe`, which
- * drops that kind back to withhold for the rest of the session — loud recovery,
- * never a broken surface.
- *
- * TERMINALS
- * ---------
- * `superseded` and `retracted` produce NO provisional render, so the swap to
- * the final value happens in the same frame the terminal arrives — never a
- * flicker through an empty state. Both are explicit EVENTS: the terminal is
- * never inferred from the arrival of `__ir`, because a completed block often
- * has no `__ir` at all (unregistered kind, schema drift, cold catalog) and
- * inferring it would leave the skeleton up forever in exactly those cases.
- */
-
-/**
- * Marker stamped on a render-local block whose `__ir` is PROVISIONAL. Never
- * emitted by a producer, never persisted, never on the wire.
- */
-declare const IR_PROVISIONAL_KEY: "__ir_provisional";
-/** True when this block's metadata carries a provisional (not verified) envelope. */
-declare function isProvisionalBlock(metadata: Record<string, unknown> | null | undefined): boolean;
-/** Wrap a validated `partial` event into the envelope shape every IR reader consumes. */
-declare function envelopeFromPartialKind(event: PartialKindEvent): CanonicalBlockIR;
-/** Loud recovery hook — called by ProvisionalKindBoundary when a render throws. */
-declare function markKindPartialUnsafe(kind: string): void;
-/** Test-only reset of the session latch. */
-declare function resetPartialUnsafeKinds(): void;
-/**
- * Has this kind opted in to being handed a provisional value? Withhold is the
- * default; see the module doc.
- */
-declare function isPartialReadyKind(kind: string, env: Pick<KindRouteEnv, "kinds">): boolean;
-interface PartialRenderOptions extends KindRouteOptions {
-    /**
-     * Is the STREAM still running? Message-wide, deliberately — not this block's
-     * own completion.
-     *
-     * 🚨 THE ANTI-STUCK-SKELETON BACKSTOP. Law 1 of the contract says every
-     * partial ends in exactly one terminal, and that law is the ONLY thing
-     * standing between a user and a "Still arriving" skeleton that never
-     * resolves. It is a producer guarantee with at least three ways to not fire:
-     * the drain skips a block missing from the final block list, the emitter
-     * early-returns once the stream ended or was cancelled (so a client abort
-     * drops every retraction), and a flush failure is swallowed so it never kills
-     * a run.
-     *
-     * Once the stream is over, no terminal can ever arrive, so a still-open
-     * provisional is stuck by definition — drop it and let the block's own
-     * content and `__ir` be the truth. Correct to be message-wide: a terminal for
-     * THIS block may still be in flight while the block itself looks finished.
-     *
-     * `undefined` reads as active, so a caller that does not thread stream state
-     * keeps live rendering rather than silently losing it.
-     */
-    streamActive?: boolean;
-}
-/**
- * The ANNOUNCED-but-not-yet-renderable state: the server has said what this
- * region is, and the region cannot render its real component yet.
- *
- * WHY THIS EXISTS SEPARATELY FROM THE VERIFIED CHANNEL. On a chat stream the
- * host's own accumulator fills `__ir` in as it parses. A WORKFLOW run's lane
- * does not: when the server opens the block scope it marks the text channel
- * `block_shadowed` and the lane stops feeding its accumulator, precisely so one
- * region is never rendered twice under two sets of block ids
- * (STREAMING_PARTIAL_KINDS.md §7b rule 4). So on a run page there is NO
- * streaming `__ir` — the ONLY thing that knows what the region is, is the
- * partial channel. Without this, a workflow node's structured answer fell
- * through to the raw-text renderer: a generic loader, then raw JSON
- * accumulating, then a swap at the end.
- *
- * Returns the provisional envelope to feed the kind's loading component, or
- * null when there is nothing announced (no event, a terminal, a dead stream).
- * Deliberately independent of `partialReady`: withholding a VALUE from a
- * component that might throw on it is a real decision, but withholding the
- * kind's own loading state is not — a skeleton cannot throw, and the reader
- * seeing what is coming is the whole point.
- */
-declare function resolveAnnouncedKindLoading(block: {
-    metadata?: Record<string, unknown>;
-}, options?: Pick<PartialRenderOptions, "streamActive">): {
-    kind: string;
-    envelope: CanonicalBlockIR;
-} | null;
-interface ProvisionalKindRender<T> {
-    /** The routed block — same type/serverData shape the final value produces. */
-    block: T;
-    /** The announced (speculative) kind. */
-    kind: string;
-    /** Per-block ordering key, for diagnostics. */
-    seq: number;
-    /** The provisional envelope — feeds the loading skeleton used as the throw fallback. */
-    envelope: CanonicalBlockIR;
-}
-/**
- * Resolve a block's provisional render, or null when there is nothing to show
- * provisionally (no event, a terminal event, a withheld kind, a kind nothing
- * can route, or a verified envelope that already won).
- *
- * Pure: no React, no host state, no side effects beyond the registry reads.
- */
-declare function resolveProvisionalKindRender<T extends IrRoutableBlock & {
-    metadata?: Record<string, unknown>;
-}>(block: T, env: KindRouteEnv, options?: PartialRenderOptions): ProvisionalKindRender<T> | null;
-
 /**
  * The two registries this hook watches. Passed explicitly by a host whose
  * render path sits BELOW no provider — matrx-frontend's block renderer runs
@@ -755,7 +100,7 @@ interface KindInstanceRenderProps {
     variant?: "card" | "bare";
     className?: string;
 }
-declare function KindInstanceRender({ kind, value, showRoutingNote, unroutableFallback, variant, className, }: KindInstanceRenderProps): react.JSX.Element;
+declare function KindInstanceRender({ kind, value, showRoutingNote, unroutableFallback, variant, className, }: KindInstanceRenderProps): React.JSX.Element;
 
 /**
  * The safety net + the "still arriving" affordance for a provisional kind
@@ -789,7 +134,7 @@ interface ProvisionalKindBoundaryOwnProps {
     fallback: ReactNode;
     children: ReactNode;
 }
-declare function ProvisionalKindBoundary(props: ProvisionalKindBoundaryOwnProps): react__default.JSX.Element;
+declare function ProvisionalKindBoundary(props: ProvisionalKindBoundaryOwnProps): React__default.JSX.Element;
 /**
  * The "still arriving" frame. `aria-busy` carries the same fact to assistive
  * tech that the chip carries visually. The chip's own rendering is a host seam
@@ -798,7 +143,7 @@ declare function ProvisionalKindBoundary(props: ProvisionalKindBoundaryOwnProps)
  */
 declare function ProvisionalKindFrame({ children }: {
     children: ReactNode;
-}): react__default.JSX.Element;
+}): React__default.JSX.Element;
 
 interface GenericStructuredViewProps {
     /** The raw region source — the zero-loss floor when no envelope survived. */
@@ -812,7 +157,7 @@ interface GenericStructuredViewProps {
     streamingIndicator?: ReactNode;
     className?: string;
 }
-declare function GenericStructuredView({ content, metadata, streamingIndicator, className, }: GenericStructuredViewProps): react.JSX.Element;
+declare function GenericStructuredView({ content, metadata, streamingIndicator, className, }: GenericStructuredViewProps): React.JSX.Element;
 
 interface DelegatedOutputProps {
     output: unknown;
@@ -840,14 +185,14 @@ interface DelegatedOutputProps {
  * holding, so it is what routes. With no kind at all there is nothing to route
  * to, and the host's fallback (or the floor) shows what the step produced.
  */
-declare function DelegatedOutput({ output, declaredKind, fallback, emptyLabel, }: DelegatedOutputProps): react.JSX.Element;
+declare function DelegatedOutput({ output, declaredKind, fallback, emptyLabel, }: DelegatedOutputProps): React.JSX.Element;
 interface NodeOutcomeViewProps {
     serverData?: unknown;
     /** Passed through to {@link DelegatedOutput}. */
     fallback?: (output: unknown) => ReactNode;
 }
 /** THE renderer for the `node_outcome` runtime wrapper kind. */
-declare function NodeOutcomeView({ serverData, fallback }: NodeOutcomeViewProps): react.JSX.Element | null;
+declare function NodeOutcomeView({ serverData, fallback }: NodeOutcomeViewProps): React.JSX.Element | null;
 interface RunResultViewProps {
     serverData?: unknown;
     fallback?: (output: unknown) => ReactNode;
@@ -864,6 +209,269 @@ interface RunResultViewProps {
  * outcomes — otherwise it is the same content the outcomes already carry, and
  * showing both is the duplication the wrapper exists to prevent.
  */
-declare function RunResultView({ serverData, fallback }: RunResultViewProps): react.JSX.Element | null;
+declare function RunResultView({ serverData, fallback }: RunResultViewProps): React.JSX.Element | null;
+
+/**
+ * The DB-component COMPILE CACHE — session-scoped, keyed per winning row
+ * VERSION, with the loud-recovery policy built in.
+ *
+ * This was matrx-frontend's `dbKindComponentCache.ts` (316 lines of compile
+ * caching + invalidation living in one host), absorbed per C22: cache
+ * mechanics, key derivation, the scream-once latch, transform recovery, and
+ * config narrowing are PACKAGE policy — every host was going to need exactly
+ * these lines, bug for bug. What stays host-injected is exactly what is
+ * host-shaped:
+ *
+ *  - THE COMPILER ({@link DbKindComponentCompiler}). Compiling or sandboxing
+ *    user-authored component source is a security-shaped host decision — the
+ *    package never bundles Babel or an allowlist scope. matrx-frontend
+ *    injects its shared allowlist compiler (`compileSlotComponent`); a host
+ *    with no sandbox simply never constructs a cache.
+ *  - The default allowed-imports list (host scope registry).
+ *  - Where screams land ({@link ContentIrErrorReporter}) and where durable
+ *    incidents go ({@link DbKindComponentIncidentSink}).
+ *  - Invalidation TRIGGERS ({@link DbKindComponentCachePorts.registerInvalidation}):
+ *    the host wires its invalidation-registry keys (e.g.
+ *    `@ai-matrx/kit/invalidation` fired by name when an agent edits a
+ *    component row); the cache owns what invalidation MEANS.
+ *
+ * Contract (the db-row component contract, SHAPE_SYSTEM.md):
+ *  - `component_source` compiles to a React component receiving
+ *    `{ data, kind, config, runAction, onResolve?, uiOptions? }` where `data`
+ *    is the kind instance value.
+ *  - `props_transform` (optional) compiles to a `(data) => data` function
+ *    applied to the value BEFORE it reaches the component. A throwing or
+ *    non-compiling transform screams and the untransformed value is used
+ *    (never a blank hole).
+ *  - `config.allowed_imports` (string[]) narrows the compile scope; absent,
+ *    the row gets the host's FULL registered allowlist.
+ *
+ * Cache key: (kind, platform, role, row.updated_at) — one compile per winning
+ * row VERSION. A resolver refresh delivering an edited row (bumped
+ * `updated_at`) re-keys and recompiles naturally; `invalidate` /
+ * `invalidateAll` force-drop keys. Server edits never push to open clients —
+ * the contract is refresh-on-view.
+ */
+
+/**
+ * Settings the MOUNTING UI dictates to a kind component — the standard,
+ * growing arg list every component honors (Arman, 2026-07-23). `selectionMode`
+ * is the first: it tells a component whether the surface wants the user to
+ * pick one value, many, or none (pure display). A component reads what it
+ * understands and ignores the rest; absent = its own default (usually display).
+ */
+interface KindComponentUiOptions {
+    selectionMode?: "single" | "multiple" | "none";
+    [key: string]: unknown;
+}
+/**
+ * The return channel: how a kind component hands a chosen value back to the
+ * surface that mounted it (a Kind Request). The mirror of `runAction`
+ * (surface → agent); this is component → surface. Undefined in normal render
+ * (chat/notes) — the component simply doesn't offer selection there.
+ */
+type ResolveKindValue = (value: unknown) => void;
+/** The envelope every kind action resolves to — a skip/failure is never a silent pass. */
+type DbKindActionResult = {
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The action seam a compiled component receives: `runAction(key, input)`
+ * triggers a registered platform capability (e.g. "trigger_agent"). Always
+ * resolves to an `{ ok }` envelope, never throws — safe to call from imperfect
+ * component code. This is the ONLY side-effect channel a sandboxed component
+ * gets; it reaches no data directly.
+ */
+type RunDbKindAction = (key: string, input: unknown) => Promise<DbKindActionResult>;
+/** Props every compiled DB kind component receives. */
+interface DbKindComponentRenderProps {
+    /** The kind instance value — post-`props_transform` when one exists. */
+    data: unknown;
+    /** The kind slug the value belongs to. */
+    kind: string;
+    /** The resolver row's `config` object, verbatim (narrowed — see {@link DbKindComponentCache.config}). */
+    config: Record<string, unknown>;
+    /** The action seam — see {@link RunDbKindAction}. */
+    runAction: RunDbKindAction;
+    /**
+     * Present only when the component is mounted inside a Kind Request. Call it
+     * with the user's chosen value to hand that value back to the requesting
+     * surface (which resolves its promise). Undefined in normal render.
+     */
+    onResolve?: ResolveKindValue;
+    /** Settings the mounting surface dictates (e.g. `{ selectionMode: "single" }`). */
+    uiOptions?: KindComponentUiOptions;
+}
+interface CompiledDbKindComponent {
+    Component: React.ComponentType<DbKindComponentRenderProps>;
+    /** Compiled `props_transform`, or null when the row declares none. */
+    transform: ((data: unknown) => unknown) | null;
+}
+type DbKindCompileResult = {
+    ok: true;
+    compiled: CompiledDbKindComponent;
+} | {
+    ok: false;
+    error: string;
+};
+/** The failure modes a browser can observe on a DB kind component. */
+type DbKindComponentIncidentType = 
+/** `component_source` did not compile (or produced no component). */
+"compile_error"
+/** The compiled component threw during render (error boundary caught it). */
+ | "render_throw"
+/** `props_transform` failed to compile or threw. */
+ | "transform_error";
+/**
+ * One durable render incident — the payload for whoever can actually FIX the
+ * component. A host sink typically files it on the kind's own incident queue
+ * (matrx-frontend: `content_ir.kind_component_incident` via RPC); without a
+ * sink, a broken component seen only by ordinary users is invisible to its
+ * author forever. `data` is the kind instance value — a privacy-conscious sink
+ * reduces it to keys + types before it leaves the browser.
+ */
+interface DbKindComponentIncident {
+    kind: string;
+    errorType: DbKindComponentIncidentType;
+    message: string;
+    platform?: string;
+    role?: string;
+    componentKey?: string | null;
+    componentUpdatedAt?: string | null;
+    stack?: string | null;
+    data?: unknown;
+}
+type DbKindComponentIncidentSink = (incident: DbKindComponentIncident) => void;
+/**
+ * THE COMPILER PORT. Matches matrx-frontend's shared allowlist compiler
+ * (`compileSlotComponent`) structurally: source in, `{ Component | error }`
+ * out, never throws. The compiled component is generically typed — the cache
+ * performs the single deliberate narrowing where the generic compiler meets
+ * the kind prop contract.
+ */
+type DbKindComponentCompiler = (args: {
+    code: string;
+    allowedImports: string[];
+}) => {
+    Component: React.ComponentType<Record<string, unknown>> | null;
+    error: string | null;
+};
+interface DbKindComponentCachePorts {
+    /** The host's sandbox compiler — see {@link DbKindComponentCompiler}. */
+    compile: DbKindComponentCompiler;
+    /** The FULL registered allowlist a row without `config.allowed_imports` gets. */
+    defaultAllowedImports: () => string[];
+    /** Where screams land (every recovery path is loud). */
+    reportError: ContentIrErrorReporter;
+    /** Durable incident sink — optional, but a host without one blinds authors. */
+    reportIncident?: DbKindComponentIncidentSink;
+    /** Default `kind_component.platform` for this host (default "web"). */
+    platform?: string;
+    /**
+     * THE INVALIDATION REGISTRATION PORT. Called once at construction with the
+     * cache's `invalidateAll`; the host registers it under its own invalidation
+     * keys (e.g. `@ai-matrx/kit/invalidation`'s name-keyed registry, fired when
+     * an agent's component write completes). The cache owns the mechanics —
+     * what gets dropped, the scream-latch reset; the host owns only WHEN.
+     */
+    registerInvalidation?: (invalidateAll: () => void) => void;
+}
+interface DbKindComponentCache {
+    /**
+     * Compile (once per resolver key per row version) a db-source resolution's
+     * `component_source` + optional `props_transform`. Synchronous — the caller
+     * (a lazily-loaded Impl) already paid the compiler chunk.
+     */
+    getOrCompile(kind: string, resolution: ComponentResolution, platform?: string, role?: string): DbKindCompileResult;
+    /**
+     * Apply the row's transform to the kind value. Loud on throw, never fatal —
+     * the untransformed value comes back so content is never hidden.
+     */
+    applyPropsTransform(kind: string, compiled: CompiledDbKindComponent, value: unknown): unknown;
+    /**
+     * THE CONFIG BOUNDARY. `ComponentResolution.config` is typed
+     * `Record<string, unknown>` — deliberately agnostic about a host's JSONB
+     * interior. This narrows at runtime (plain object → itself; anything else →
+     * scream + empty config) rather than asserting: a row whose `config` is not
+     * an object is a malformed `kind_component` row, and the component still
+     * renders rather than crashing.
+     */
+    config(config: unknown, kind: string): Record<string, unknown>;
+    /** Drop a (kind, platform, role) key family (authoring surfaces call after editing a row). */
+    invalidate(kind: string, platform?: string, role?: string): void;
+    /** Drop everything — the invalidation-port payload. */
+    invalidateAll(): void;
+}
+/**
+ * A routed lazy warm row owns a real body, but the per-kind cold fetch has not
+ * landed it yet. This is loading, not a compile failure.
+ */
+declare function isDbKindComponentBodyPending(resolution: ComponentResolution): boolean;
+/** Build the session cache. One per host app — construct it in the wiring module. */
+declare function createDbKindComponentCache(ports: DbKindComponentCachePorts): DbKindComponentCache;
+
+/**
+ * DbKindComponentErrorBoundary — the DEFAULT error boundary around a compiled
+ * DB kind component (absorbed from matrx-frontend per the C23 retrofit; the
+ * package previously shipped "no error capture by design", which left every
+ * host to rebuild this class).
+ *
+ * A user-authored component that throws during render must never crash the
+ * surface (chat, notes, admin preview). The boundary catches, renders the
+ * fallback (the kind's generic structured viewer — the R6 disposition, never
+ * a blank hole), and SCREAMS: a recovery firing means a real bug got past
+ * authoring.
+ *
+ * `resetSignal` (the component's `updated_at`) un-latches the boundary when a
+ * NEW component version arrives: an author who fixes a throwing component must
+ * see the fix on the next re-render, not stay stuck on the fallback until a
+ * full unmount. Without this the error state is sticky for the whole session —
+ * the "broke, then magically fixed itself minutes later" class. React error
+ * boundaries never self-clear, so a version change is the only safe signal
+ * (`hasError` alone can't tell a fixed version from the same broken one).
+ *
+ * `onCaught` is the scream seam: a host binds its structured render-error
+ * capture + durable incident filing (matrx-frontend files a `render_throw`
+ * incident so the component's author learns). Bound to nothing, the default is
+ * an honest console scream — never silence.
+ */
+
+interface DbKindComponentErrorBoundaryProps {
+    kind: string;
+    /** The resolved component's `updated_at`; a change means a new version. */
+    resetSignal: string | null;
+    fallback: React.ReactNode;
+    children: React.ReactNode;
+    /**
+     * Where the catch lands. A host binds structured capture + incident filing
+     * here; the default screams to the console. NOTE for hosts whose console
+     * adapter persists `console.error`: bind this (which replaces the default)
+     * rather than mirroring the capture through the console twice.
+     */
+    onCaught?: (error: Error, info: {
+        componentStack: string | null;
+    }) => void;
+}
+interface State {
+    hasError: boolean;
+    /**
+     * The `resetSignal` seen on the LAST render — tracked every render (not just
+     * on error) so that at throw time it already holds the version that threw.
+     * `getDerivedStateFromError` cannot read props, so this is how the boundary
+     * knows which version to un-latch away from.
+     */
+    signalAtLastRender: string | null;
+}
+declare class DbKindComponentErrorBoundary extends React.Component<DbKindComponentErrorBoundaryProps, State> {
+    constructor(props: DbKindComponentErrorBoundaryProps);
+    static getDerivedStateFromError(): Partial<State>;
+    static getDerivedStateFromProps(props: DbKindComponentErrorBoundaryProps, state: State): State | null;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
 
-export { type ComponentResolution, type ComponentResolutionSource, ComponentResolver, type ComponentResolverOptions, type ComponentRole, type ContentIrErrorReport, type ContentIrErrorReporter, type ContentIrHost, ContentIrRenderProvider, type ContentIrRenderProviderProps, type ContentIrRenderSeams, DB_KIND_COMPONENT_KEY, DelegatedOutput, type DelegatedOutputProps, GENERIC_STRUCTURED_COMPONENT_KEY, type GenericFallbackReason, GenericStructuredView, type GenericStructuredViewProps, IR_PROVISIONAL_KEY, IR_ROUTE_KEY, type IrRenderBlock, type IrRoutableBlock, type IrRouteMarker, type JsonObject, type KindComponentRow, type KindDefinitionSource, KindInstanceRender, type KindInstanceRenderProps, type KindRouteEnv, type KindRouteOptions, type KindVersionSources, NodeOutcomeView, type NodeOutcomeViewProps, type PartialRenderOptions, ProvisionalKindBoundary, ProvisionalKindFrame, type ProvisionalKindRender, RunResultView, type RunResultViewProps, type StructuredValueRenderProps, type SystemComponentEntry, applyIrKindRoute, consoleErrorReporter, envelopeFromPartialKind, isPartialReadyKind, isProvisionalBlock, isRecordValue, kindIsRoutable, kindServerDataFromStoredValue, markKindPartialUnsafe, readIrRouteMarker, resetPartialUnsafeKinds, resetSourcelessDbRowReports, resolveAnnouncedKindLoading, resolveProvisionalKindRender, routeEnvOf, useContentIrHost, useContentIrHostOrNull, useContentIrKindVersion, useKindRouteEnv };
+export { type CompiledDbKindComponent, ComponentResolution, ComponentResolutionSource, ContentIrErrorReporter, ContentIrHost, ContentIrRenderProvider, type ContentIrRenderProviderProps, type DbKindActionResult, type DbKindCompileResult, type DbKindComponentCache, type DbKindComponentCachePorts, type DbKindComponentCompiler, DbKindComponentErrorBoundary, type DbKindComponentErrorBoundaryProps, type DbKindComponentIncident, type DbKindComponentIncidentSink, type DbKindComponentIncidentType, type DbKindComponentRenderProps, DelegatedOutput, type DelegatedOutputProps, GenericStructuredView, type GenericStructuredViewProps, type KindComponentUiOptions, KindDefinitionSource, KindInstanceRender, type KindInstanceRenderProps, KindRouteEnv, type KindVersionSources, NodeOutcomeView, type NodeOutcomeViewProps, ProvisionalKindBoundary, ProvisionalKindFrame, type ResolveKindValue, type RunDbKindAction, RunResultView, type RunResultViewProps, createDbKindComponentCache, isDbKindComponentBodyPending, isRecordValue, kindIsRoutable, useContentIrHost, useContentIrHostOrNull, useContentIrKindVersion, useKindRouteEnv };