import { C as ComponentResolutionSource, b as ContentIrErrorReporter, a as ComponentResolution } from './component-resolution.types-CNArz3ZR.cjs'; import * as react from 'react'; import { ComponentType, ReactNode } from 'react'; type ArrayItemScalarType = "string" | "number" | "boolean"; /** Value domain of a `record` field — typed scalars, or any JSON value. */ type RecordValueType = ArrayItemScalarType | "json"; type FieldBase = { required?: boolean; nullable?: boolean; /** Human guidance — JSON Schema `description` / variable `helpText`. */ description?: string; /** * Default VALUE (JSON Schema `default` / variable `defaultValue`). * Annotation-level: validators never apply it; emitters carry it verbatim. */ default?: unknown; }; type FieldSchema = (FieldBase & { type: "string" | "boolean"; }) | (FieldBase & { type: "number"; /** Inclusive lower bound — JSON Schema `minimum`. */ min?: number; /** Inclusive upper bound — JSON Schema `maximum`. */ max?: number; /** Increment — JSON Schema `multipleOf`. Annotation-level in the parser. */ step?: number; }) | (FieldBase & { type: "string[]"; /** Items-enum: each item must be one of these values (checkbox option sets). */ values?: string[]; /** With `values`: the set is advisory — any string item is also legal (`allowOther`). */ open?: boolean; }) | (FieldBase & { type: "number[]" | "boolean[]"; }) | (FieldBase & { type: "json"; }) | (FieldBase & { type: "json[]"; }) | (FieldBase & { type: "array"; itemKinds: string[]; }) | (FieldBase & { type: "object"; kind: string; }) | (FieldBase & { type: "inline_object"; fields: Record; /** additionalProperties: true — unknown keys are legal, not residue-only. */ open?: boolean; }) | (FieldBase & { type: "record"; values: RecordValueType; }) | (FieldBase & { type: "enum"; values: string[]; /** "One of these OR any string" — the option set is advisory (`allowOther`). */ open?: boolean; }) | (FieldBase & { type: "union"; scalars: Array<"string" | "number" | "boolean">; /** Object union members — kind refs (anyOf of $refs), may mix with scalars. */ kinds?: string[]; }); /** * Domain fields only — __kind is enforced by the parser via KindSchema.kind * (block slug). A kind with `root` set has NO field map (fields stays `{}`): * its value is the root field's type at the top level. See the module header. */ type KindSchema = { kind: string; fields: Record; /** Non-object root form — mutually exclusive with a non-empty `fields`. */ root?: FieldSchema; }; /** * The canonical IR contract for structured content. * * Every source (live agent stream, DB reload, Python-preprocessed results, * notes, any future surface) is normalized into these shapes exactly once. * Anything already carrying this IR passes through downstream layers by * reference — see `core/normalize.ts` for the idempotence law. * * This file is pure types + path helpers. No React, no Redux, no IO. */ /** Path of a value inside a parsed region (object keys + array indices). */ type IrPath = Array; /** * How a node's kind was (or wasn't) established. * * 🚨 `unverified` IS NOT `raw`, AND THE DIFFERENCE IS LOAD-BEARING (Arman's * ruling, 2026-08-29). "We checked it and it is wrong" and "we had nothing to * check it with" are opposite facts about a payload, and collapsing them cost * ~221 live kinds their component overnight: a kind whose schema never loaded * degraded to `raw`, the render route read `raw` as "broken instance", and * perfectly valid payloads were dumped as key/value lists instead of reaching * the component the user built. A consumer that treats `unverified` as a * failure is reintroducing that outage — the data is intact and MAY be * entirely valid; all that is missing is the schema that would prove it. */ type IrKindState = "resolved" | "speculative" | "pending_kind" | "pending_schema" | "unverified" | "raw"; /** * System-level zero-data-loss channel. Unknown keys are NEVER merged into a * node's `value` (they'd be indistinguishable from schema fields); they are * carried here verbatim — Protobuf unknown-fields discipline. Distinct from * any domain-level `additionalDetails` field, which is an ordinary schema * field inside `value`. */ interface IrResidue { /** Keys present in the source object but absent from the kind schema. */ extra: Record | null; /** Optional schema fields the source never provided. */ optionalMissing: string[] | null; /** Structured warnings attached during parsing (speculation backtracks, truncation, …). */ notices: Array<{ code: string; message: string; at?: number; }> | null; } /** Which wire syntax carried the kind discriminator for a node. */ type IrDiscriminator = { format: "json"; key: "__kind"; } | { format: "xml"; tag: string; } | { format: "fence"; language: string; }; /** A schema-shaped structured node. Children live inside `value` (and carry their own metadata via `nodeIndex`). */ interface IrStructuredNode { role: "structured"; /** Canonical kind slug. Empty string while pending. */ kind: string; kindState: IrKindState; discriminator: IrDiscriminator; /** Region-relative path ([] = region root). */ path: IrPath; status: "streaming" | "complete" | "error"; /** Compliant snapshot: schema fields + __kind ONLY. Unknown keys → residue. */ value: Record; residue: IrResidue | null; } /** Envelope version. Bump = migration point for persisted envelopes. */ declare const IR_VERSION: 1; /** * One parsed region's canonical form. Serializable (plain JSON), carried on * render blocks (`data.__ir`), persisted on artifacts and message metadata, * and — with `engine: "py-block-detector"` — accepted pre-built from Python. */ interface CanonicalBlockIR { v: typeof IR_VERSION; /** Provenance: which implementation produced this envelope. */ engine: "fe-kind-parser" | "py-block-detector"; /** Stable hash of the region source text — the idempotence / cache key. */ fingerprint: string; root: IrStructuredNode; /** * pathKey → node metadata for per-path readers (child kinds under root). * Carries each child node's residue — child snapshot values inside * `root.value` hold schema fields only, so WITHOUT this the envelope would * silently drop nested unknown keys (zero-data-loss violation). */ nodeIndex?: Record & { residue?: IrResidue | null; }>; } /** * KindDefinition — one kind, many facets. THE canonical registry entry. * * This does NOT merge BlockComponentRegistry or artifact-type-registry; the * `legacyBlockType` and `artifact` facets are FACADES pointing into them, so * migration is incremental and each registry keeps its own job. */ /** * The uniform props contract for kind-driven block components. This is what * de-special-cases flashcards: no component receives bespoke glue — every * kind component gets exactly this shape. */ interface KindBlockProps { kind: string; schema: KindSchema; /** Compliant snapshot value (schema fields + __kind). */ data: Record; status: "streaming" | "complete" | "error"; residue: IrResidue | null; path: IrPath; /** ParseSession identity for live child subscriptions; null after reload. */ identity: string | null; /** Child-kind schema lookup (replaces passing allSchemas around). */ resolve: (kind: string) => KindSchema | undefined; } type KindTier = "eager" | "warm" | "cold"; /** * A TABLE AS A KIND (KINDS-GLUE wave 3 §1.4): what the host learned from the store's * `custom.table_kind_facts` when it answered a `table:` kind. `stamp` moves on any Field or * choice change; `optionsTableIds` are the Tables whose records are this Table's choices (a change * there is a change here). `refusal` is the store's own sentence when the person may not open the * Table — the definition still exists so the card can say so instead of loading forever. */ interface TableKindFacet { tableId: string; organizationId: string | null; name: string | null; titleField: string | null; stamp: string | null; fieldIds: string[]; optionsTableIds: string[]; refusal?: string | null; } interface KindDefinition { /** Canonical slug — THE key. */ kind: string; /** null until the warm/cold fetch delivers it. */ schema: KindSchema | null; /** * Where the schema came from. `"table"` (KINDS-GLUE wave 3): the kind is `table:` — "a * record of that Table" — and its schema is derived from the Table's live Fields * (`@ai-matrx/records` `tableRenderSchema`), never a `kind_definition` row. */ schemaSource: "system" | "content_ir" | "table"; tier: KindTier; /** Present only for `schemaSource: "table"` — the Table the kind is derived from. */ table?: TableKindFacet; /** Component facet — lazy-loaded renderer for this kind. */ component?: { load: () => Promise<{ default: ComponentType; }>; }; /** Facade → BlockComponentRegistry type string (e.g. "flashcards"). */ legacyBlockType?: string; /** * Legacy-bridge facet: derive the existing component's `serverData` from a * canonical envelope. This is what lets a kind light up the REAL component * (FlashcardsBlock, …) with zero component changes during migration. */ toLegacyServerData?: (envelope: CanonicalBlockIR) => Record | undefined; /** Facade → artifact-type-registry canvasType. */ artifact?: { canvasType: string; }; /** * Markdown export facet — the FORWARD leg of artifact ⇄ markdown. Receives * the ZERO-LOSS reconstructed value object (the CALLER reconstructs — for * persisted structured artifacts `content.data` already IS that object; * this facet only renders it; `__kind` discriminators may still be * present and must be ignored). MUST produce human-readable markdown * (headings / lists / bold), never a JSON dump — a fenced json body under * a heading is acceptable only for inherently-code payloads (e.g. a * schema_proposal's JSON Schema). Unknown extra keys the renderer doesn't * understand MUST be appended under a small "Additional details" * (key: value) section so nothing silently vanishes. Kinds without this * facet fall back to `genericKindMarkdown` (kinds/kind-markdown-utils.ts). */ toMarkdown?: (value: Record) => string; persistence?: { persistStructured: boolean; }; /** Future XML tags / kind aliases resolving to this kind. */ discriminatorAliases?: string[]; /** * PARTIAL-READY opt-in — the streaming partial-kinds posture. * * While a structured region streams, the server may announce a PROVISIONAL * instance of this kind on `metadata.__ir_partial` (valid, closed JSON that * may be missing required fields). The default posture is PROGRESSIVE * (Arman, 2026-10-14): the provisional value is routed to the SAME component * that renders the final one, filling in as tokens arrive — exactly what a * chat stream already does. * * Set this to `false` only for a kind whose component is known to break on a * half value: its block keeps its loading skeleton until complete. `true` is * the default spelled out. A kind * with a `toLegacyServerData` bridge must ALSO pass `{ provisional: true }` * to `makeCompleteEnvelopeBridge` (pinned by a test). A component that * throws is caught, screams, and drops this kind back to withhold for the * session. * * Contract: common-docs/systems/architecture/content-ir/FEATURE.md */ partialReady?: boolean; /** * Loading-library slug (`kind_definition.metadata.loading_component`) — * which of the ~20 hardcoded loading components renders while this kind's * instance streams in / its schema+component fetch is in flight. Null or * unknown slugs fall back to the generic structured skeleton. */ loadingComponent?: string | null; } /** * Kind Directives — the grammar, the shell, and the position law (kernel edition). * * ONE system (Arman, 2026-08-23): the Matrx Envelope/Directive protocol and the * Content IR kind system are one system. A directive is an ordinary kind * instance — `{ "__kind": "directive_v1__", "items": [...] }` — * whose registered shape additionally carries execution semantics on the * server. This module is the PURE half, ported verbatim from the aidream source * of record (`packages/matrx-graph/matrx_graph/content_ir/directives.py`) so * every UI parses the grammar identically. It lives in the KERNEL because a * host that can parse a kind must be able to recognize a directive without a * second copy of these rules (matrx-frontend carried the only copy until * 2026-09-08; Workflow Studio had none and rendered directives as raw text). * * THE SLUG GRAMMAR — `directive_v__`: * - `directive_v` is a RESERVED prefix; a hand-authored kind may never claim it. * - `` comes from a CLOSED vocabulary, so parsing is unambiguous even * though nouns contain underscores: `directive_v1_reference_create_task` is * `(reference, "create_task")`. * - capability is DERIVED from the class, never stored twice. */ /** The CLOSED class vocabulary. Closed is what makes the grammar parseable. */ declare const CLASSES: readonly ["reference", "view", "create", "update", "delete", "action", "validation", "secret"]; type DirectiveClass = (typeof CLASSES)[number]; type DirectiveCapability = "pure" | "sensitive" | "side_effect"; /** A parsed directive slug. `slug` round-trips through `buildDirectiveSlug`. */ interface DirectiveSlug { slug: string; version: number; directiveClass: DirectiveClass; noun: string; capability: DirectiveCapability; /** Executes at an agent's output root (THE position law, half one). */ executes: boolean; /** Resolves to a live value inside content (THE position law, half two). */ inContent: boolean; } /** * Decode a Kind Directive — THE one entry point on every client. * * `decodeDirective()` recognizes the shell (current OR, for stored content * only, the retired 4-key one), reads the slug, and derives class + noun. A * caller only ever sees a parsed {@link DecodedDirective}; nothing downstream * inspects a raw shell again. * * ITEM VALIDATION IS THE SERVER'S. The registered item models live in aidream * (`services/content_ir_directives/registry.py`) and validate on apply; a * client-side copy of ~120 item models is exactly the drift the merge exists * to kill. The client parses identity, routes, and renders. Mirror of aidream * `services/content_ir_directives/decode.py`. */ interface DecodedDirective { /** The parsed slug — class, noun, capability and the position law. */ readonly parsed: DirectiveSlug; readonly slug: string; readonly directiveClass: DirectiveClass; readonly noun: string; readonly items: Record[]; /** The two-key shell, normalized — what a confirm POST round-trips. */ readonly shell: Record; /** True when this arrived in the retired 4-key shell and was translated. */ readonly legacyShell: boolean; } /** * THE AUTO-VIEW's naming half: every enrolled noun "instantly has a view" — * the prefix rule gives it a renderer, and this gives it a NAME. A shape the * client has never heard of must still read as "Create Agent · Agents", never * as the raw `agent` token and never as a slug. * * The catalog (`platform.entity_types` → the server's directive catalog) is the * authority for `label` / `family` / `title_column`; a host that mirrors it * passes a {@link DirectiveNounCatalog}. Without one — or for a noun the * catalog does not carry (a Kind Action like `plan_tree`) — the name degrades * to a title-cased token: legible, honestly derived, never blank. */ interface DirectiveNounEntry { /** The noun's human name — "Agent", "Plan tree". */ label?: string | null; /** The catalog family ("Agents"). */ family?: string | null; /** Which field of a row names it (`name`, `title`, …). */ titleColumn?: string | null; } /** A host-supplied lookup over the mirrored catalog. `undefined` = not carried. */ type DirectiveNounCatalog = (noun: string) => DirectiveNounEntry | undefined; /** * THE DIRECTIVE⇄KIND SEAM, client side. * * Arman, 2026-08-26: the envelope / Matrx-Actions system and the Shape (kind) * system are ONE system with several methods inside it. They meet at the ITEM. * A directive is a CONTAINER; its items are the payload, and when the server's * item model is already a `KindModel`, that payload IS a registered kind * instance — so the kind system already knows how to validate, render and copy * it. * * The seam is SERVER-DERIVED (`ShapeSpec.item_kind`). Since 2026-09-08 the ONE * kind endpoint publishes every directive shape as a KindDescriptor whose * `items` EDGE names the item kind, so a client reads it from the same * catalog it already holds — {@link directiveItemKindFromEdges}. A host that * mirrors the directive catalog manifest instead passes its map as a * {@link DirectiveItemKindLookup}. `null` is HONEST, never a gap-filler. */ /** A host-supplied lookup: slug → the kind ONE item is, or null. */ type DirectiveItemKindLookup = (slug: string) => string | null; interface DirectiveApplyResult { applied: number; failed: number; /** * The server's own receipt sentence ("Deleted task “Ship it”."), shown in * place of a bare count. Never composed client-side. */ message?: string | null; /** * The records the apply created or changed, so the tally is a way IN to them * (no dead ends). Rendered through `renderRecord`; absent → the sentence alone. */ records?: DirectiveRecordRef[]; /** * For an UPDATE: what each item's fields held just BEFORE the write, by item * index (`null` for an item the server did not record). The card draws the * applied change from this record — never from a live re-read, which after the * apply answers the NEW value (G6A review, 2026-10-02: "(no change)" for a * change that happened). */ before?: ReadonlyArray | null>; } /** * What the server's action ledger says about ONE block, read on mount so a * reloaded page never offers "Apply" for work that already ran (reviewer * defect 5, 2026-10-02). * * - `not_applied` — still to do (or partly done: the batch re-applies, and the * server replays the members it already holds). The card offers Apply. * - `in_flight` — another request is applying it right now. The card says it * is finishing and asks again shortly; it offers neither Apply nor a tally. * - `applied` — the ledger holds every item. The card shows the tally exactly * as a fresh apply would: the ledger's own sentence and the records, as doors. */ interface DirectiveApplyState { state: "not_applied" | "in_flight" | "applied"; /** The ledger row's sentence ("Created task."), never composed client-side. */ message?: string | null; /** * The records the LATEST apply wrote — the tally's doors. After "Run again" * that is the newest copy, never the first. */ records?: DirectiveRecordRef[]; /** * How many times the ledger holds this block as applied: 1 for the original, * one more for every "Run again". Absent → 1. A create that ran twice made * two records, and the card says so (reviewer, 2026-10-02). */ copies?: number; /** * For an applied UPDATE: each item's replaced values, by item index, from the * ledger row (`null` where the ledger has none — a row from before 2026-10-02). * Absent → the card says only what each field was set to. */ before?: ReadonlyArray | null>; } /** One record a directive names: the noun it is, and its id. */ interface DirectiveRecordRef { noun: string; id: string; } interface DirectiveRecordProps extends DirectiveRecordRef { /** * What to show until (or unless) the host resolves the live name — * "Task 1a2b3c4d". Never blank, never "Item". */ fallback: string; /** Where it is drawn: an item row, the confirm dialog, or the applied tally. */ context: "row" | "dialog" | "applied"; /** * True when the record is (about to be) in the trash — the host may still * name it but should not promise it opens as a live record. */ trashed?: boolean; } /** What the person is being asked to approve — everything the card knows. */ interface DirectiveAskRequest { directive: DecodedDirective; /** The items, exactly as they will be sent. */ items: Record[]; /** The noun's human label ("Task"), from the host's catalog when it has one. */ nounLabel: string; /** * True for "Run again": the ledger already holds this block, and a yes runs * it a SECOND time (`force`) — another copy for a create, the same fields * written again for an update, another delete for a restored record. The * question must say so. */ again?: boolean; } /** * The shell a card hands its host — the two keys, plus WHERE it sits. * * `conversationId` is the conversation the card renders in (a chat message), * absent in a person's own content (a note). It is the idempotency NAMESPACE: * a card in an agent's message must apply under the SAME key as that * proposal's Approve button, or the one action could run twice. */ interface DirectiveShell { __kind: string; items: Record[]; conversationId?: string; /** "Run again": skip the ledger's dedup and apply a second time. */ force?: boolean; } interface DirectiveOpenItemOptions { /** The item, `__kind`-stamped when the shape has an item kind. */ item: Record; /** The content-IR kind this item IS, or null when the shape has none. */ itemKind: string | null; /** What the item is called — the same title the card shows. */ title: string; /** "Run Create agent definition · item 1 of 1". */ subtitle: string | null; directive: DecodedDirective; index: number; total: number; } interface DirectiveCopyProps { /** * What the control is called to a screen reader. Never an id: for a record it * is type-generic ("this task"); a host with the record's live name replaces * it through `record`. */ label: string; /** The existing record this control copies, when it copies one — to name it. */ record?: DirectiveRecordRef; /** The value to copy — the whole shell or one item. */ value: unknown; /** The item's kind, when copying an item. */ kind?: string | null; size: "icon" | "xs"; } interface DirectiveHost { /** * Apply a side-effect directive as the user (the server re-validates every * item against the registered model and runs the ONE handler; idempotent). * Reject with an Error whose message is safe to show. */ confirm?: (shell: DirectiveShell) => Promise; /** * Ask the person BEFORE anything runs, naming the consequence (the records, * what changes). Resolve `true` to go ahead, `false` to leave the card as it * was. The Apply control stays idle while this is open — nothing reads as * "applying" until the person has said yes. Absent → `confirm` is called * directly (a host that asks inside `confirm` keeps working, but its card * will read "Applying…" while its dialog is up). */ ask?: (request: DirectiveAskRequest) => Promise; /** * Has this exact block already been applied? Read ONCE when the card mounts * (and again while the answer is `in_flight`), so the card survives a reload: * the server ledger, not component state, is what knows. The identity is the * server's (it hashes the validated items in the same namespace `confirm` * applies in), so a host asks — it never computes. Batch on the host side if * a page carries many cards. Reject with an Error when the ledger cannot be * read: the card reports it and offers Apply, which is safe because `confirm` * is idempotent. Absent → the card starts at Apply, as before. */ applyState?: (shell: DirectiveShell) => Promise; /** * Read the CURRENT values of ONE existing record, so an update says what it * replaces — "Status open → done", never just "→ done" (reviewer, * 2026-10-02). Resolve `null` when the record cannot be read (no access, no * such record, a noun the host cannot read); reject only for a real failure. * Absent → an update row shows the new values alone, as before. */ readRecord?: (ref: DirectiveRecordRef) => Promise | null>; /** * Draw ONE existing record by its live name, as a way to open it. Used on * update/delete rows (the record that will change), in the host's own ask * dialog if it likes, and on the applied tally (what was written). Absent → * the fallback text, unlinked. */ renderRecord?: (props: DirectiveRecordProps) => ReactNode; /** Open ONE item to read it properly before approving the write. */ openItem?: (options: DirectiveOpenItemOptions) => void; /** Host copy controls. */ renderCopy?: (props: DirectiveCopyProps) => ReactNode; /** * The app's word for one stored value of one pick-list field — the SAME word * the record's own screens and the write forms show ("incomplete" on a task * reads "Inbox"). One value, one display word everywhere (G8A review, * 2026-10-02: the card said "Status incomplete → completed"). Return null for * a field that is not a pick-list: its value is shown as written. Absent → * every value is shown as stored. */ valueLabel?: (ref: DirectiveValueRef) => string | null; /** The mirrored noun catalog (label / family / title column). */ nouns?: DirectiveNounCatalog; /** slug → the kind ONE item is (THE DIRECTIVE⇄KIND SEAM), or null. */ itemKind?: DirectiveItemKindLookup; /** Where a decode failure or an unhonourable shell is reported. Default: console.error. */ reportError?: (message: string) => void; /** * Plain words for a failed apply the host recognizes ("This button can't * create a task yet." + "Create it from Tasks instead."). The card never shows * the server's raw text as its sentence: it shows these words — or its own * verb-aware default — and keeps the raw text behind "Details". Return null * to use the default. */ explainFailure?: (failure: DirectiveFailure) => DirectiveFailureWords | null; } /** One stored value of one field of one record type. */ interface DirectiveValueRef { noun: string; field: string; value: string; } /** One failed apply, as the card knows it. */ interface DirectiveFailure { /** The server's / host's own text — technical; shown only behind Details. */ raw: string; directiveClass: string; noun: string; /** The noun's display label ("Task"). */ nounLabel: string; /** Items that failed, when some applied and some did not. */ failed?: number; /** Items in the block. */ total?: number; } /** What failed and what to do — each one short sentence. */ interface DirectiveFailureWords { what: string; next: string; /** * The text behind "Details", when the host words it (e.g. the server's field * names read as the form labels them — "Title is required", never * "name is required"). Absent → the raw text. */ details?: string; } /** Where a directive renders — today, the conversation it sits in (if any). */ interface DirectiveScope { conversationId?: string | null; } /** * Tell every card below WHERE it renders. A host draws a chat message's * directives inside one of these (or passes `conversationId` to * `DirectiveRender`), so the card applies in that conversation's namespace — * the same key the agent's proposal approves under. A note mounts none. */ declare function DirectiveScopeProvider({ conversationId, children, }: DirectiveScope & { children: ReactNode; }): react.JSX.Element; declare function useDirectiveScope(): DirectiveScope; interface DirectiveHostProviderProps { host: DirectiveHost; children: ReactNode; } declare function DirectiveHostProvider({ host, children }: DirectiveHostProviderProps): react.JSX.Element; /** * The wired directive host. Unlike the render host this does NOT throw when * unwired: a directive still renders (named, itemised, copy-less, apply-less) * — degrading the chrome is honest, hiding the content is not. */ declare function useDirectiveHost(): DirectiveHost; /** * 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; metadata?: Record; } /** 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; } /** * 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 * `
`; 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 Kind Directives seams (apply / open item / copy / noun catalog / item
     * kind). Optional: a host without them still renders every directive card,
     * apply-less and copy-less — honest chrome, never hidden content. Provided
     * to the directive tier by `ContentIrRenderProvider`; a host that has not
     * adopted the render provider mounts `DirectiveHostProvider` directly.
     */
    directives?: DirectiveHost;
}
/**
 * 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 {
    /**
     * `schemaState` is optional and read ONLY to suppress a negative verdict while this kind's
     * definition read has not answered ("pending") — THE COLD-VERDICT RULE, per kind.
     */
    kinds: Pick & {
        schemaState?(kind: string): "loaded" | "pending" | "absent" | "failed";
    };
    /**
     * `hasSettled` is optional and read ONLY to suppress a negative verdict from
     * a registry that has not loaded yet — see THE COLD-VERDICT RULE on
     * `ComponentResolutionSource`.
     */
    components: Pick & Partial>;
    reportError: ContentIrErrorReporter;
    platform: string;
}
/** Narrow a host (or anything host-shaped) to what the pure route needs. */
declare function routeEnvOf(host: ContentIrHost): KindRouteEnv;

/**
 * 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";
/**
 * THE DIRECTIVE TIER. A block whose root `__kind` is a reserved directive
 * slug (`directive_v…`) is typed to this block type and drawn by
 * `DirectiveRender` (`@ai-matrx/content-ir/react-directives`) — BEFORE the
 * component resolver is consulted. A directive is a kind whose display is the
 * directive card (the item inside it renders through the item's own kind —
 * THE DIRECTIVE⇄KIND SEAM), so no `kind_component` row exists or is needed,
 * and the "unregistered" / "no-component" floors must never claim one.
 * `"matrx"` is the block type matrx-frontend has dispatched directive fences
 * to since the envelope era; every host's dispatch table maps it to
 * `DirectiveRender`.
 */
declare const DIRECTIVE_BLOCK_TYPE: "matrx";
/** 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";
interface IrRouteMarker {
    by: ComponentResolution["resolvedBy"] | "generic" | "directive";
    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 | 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(block: T, env: KindRouteEnv, options?: KindRouteOptions): T;
/**
 * THE COLD-VERDICT RULE, per kind: have this kind's own lookups answered? Only then may the route
 * publish a negative verdict (that a slug names no kind). Exported so a host's loading layer holds its loader
 * on exactly the same predicate the route holds its verdict on.
 */
declare function kindLookupSettled(env: Pick, kind: string): boolean;
/**
 * 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): Record | null;

/**
 * Streaming partial kinds — the TS twin of the Python producer's contract.
 *
 * Cross-repo system-of-record (read it before changing anything here):
 * `common-docs/systems/architecture/content-ir/FEATURE.md`.
 * Python twin: `aidream/packages/matrx-graph/matrx_graph/content_ir/partial.py`.
 *
 * WHAT THIS IS
 * ------------
 * While a structured region streams, the server announces what it thinks the
 * region IS and what has arrived so far, so the UI fills in progressively
 * instead of showing a spinner until the closing brace. Three events, a CLOSED
 * union on `state`, all riding `metadata.__ir_partial` on the `render_block`
 * events this app already receives:
 *
 *   partial     — repeatable. A provisional instance whose `root.value` is
 *                 VALID, CLOSED JSON (the server truncates and closes it, so
 *                 this side never repairs or guesses). `kindState` is
 *                 "speculative": it MAY still turn out to be something else.
 *   superseded  — TERMINAL. The region completed as the announced kind; drop
 *                 the provisional render, the block's own content/`__ir` is the
 *                 truth.
 *   retracted   — TERMINAL escape hatch. Detection was wrong; `becameKind` /
 *                 `becameBlockType` name what it actually is. Never a silent
 *                 swap.
 *
 * WHY IT IS NOT ON `__ir`
 * -----------------------
 * `__ir` means "validated against the registered schema", and a valid `__ir`
 * is SEEDED into the fingerprint-keyed envelope memo. A provisional value
 * there would poison every later read of that region. The two channels never
 * touch: `classifyInboundEnvelopeMetadata` sees `absent` for a partial and
 * passes the metadata through by reference.
 *
 * Pure kernel module: types + validators only. No React, no Redux, no IO.
 * Lives in @ai-matrx/content-ir `wire/` so EVERY UI (Matrix, Workflow Studio,
 * the dashboard, the Chrome extension, the desktop app) reads the channel
 * through the same reader.
 */

/** The provisional node. Deliberately `IrStructuredNode`-shaped so existing IR readers work. */
interface PartialKindNode {
    role: "structured";
    /** The server's DETECTION GUESS for this region. */
    kind: string;
    /** Always "speculative" on a partial — pre-recognition, not a resolved kind. */
    kindState: "speculative";
    discriminator: IrDiscriminator;
    path: IrPath;
    status: "streaming";
    /**
     * Valid, closed JSON carrying its own `__kind`. MAY be missing required
     * schema fields — that is what `partial_unvalidated` in `residue.notices`
     * says. A renderer that throws on an absent field is not partial-ready and
     * must not be routed a provisional value.
     */
    value: Record;
    residue: IrResidue | null;
}
interface PartialKindEvent {
    v: typeof IR_VERSION;
    engine: string;
    state: "partial";
    /** Monotonic PER BLOCK — the ordering / staleness key. Keep the highest. */
    seq: number;
    fingerprint: string;
    root: PartialKindNode;
}

/**
 * Routing the PROVISIONAL half of the streaming partial-kinds contract.
 *
 * Cross-repo system-of-record (read it before changing anything here):
 * `common-docs/systems/architecture/content-ir/FEATURE.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: PROGRESSIVE BY DEFAULT, OPT OUT PER KIND (Arman, 2026-10-14)
 * ------------------------------------------------------------------------
 * A provisional value MAY be missing required fields — that is what the
 * `partial_unvalidated` notice declares. It used to be WITHHELD unless a kind
 * opted in with `partialReady: true`, so a run page showed a loader until the
 * end for components that render partial values perfectly well (the same
 * component fills in live on a chat stream, which never consulted this flag).
 * Now every kind with a real component is handed the provisional value — and
 * since Arman, 2026-10-26 ("Kind components get partial values immediately
 * everywhere … Remove the hold-back") there is no opt-out: `partialReady` is no
 * longer read. The safety net is unchanged and is what makes the
 * open default safe: a component that throws is caught by
 * `ProvisionalKindBoundary`, which screams and calls `markKindPartialUnsafe`,
 * dropping that kind back to withhold for the session; a bridged kind whose
 * bridge declines a thin value stays on its loader for that frame.
 *
 * 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 | 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;
/**
 * May this kind be handed a provisional value? Always — unless its component
 * already threw on one this session; see the module doc.
 */
declare function isPartialReadyKind(kind: string, _env: Pick): 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 canceled (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;
}, options?: Pick): {
    kind: string;
    envelope: CanonicalBlockIR;
} | null;
interface ProvisionalKindRender {
    /** 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;
}
interface SupersededKindRender {
    /** The completed block routed through the announced kind's normal component. */
    block: T;
    /** The kind the producer announced and then confirmed at terminal. */
    kind: string;
    /** Per-block ordering key, for diagnostics. */
    seq: number;
    /** Render-local complete envelope reconstructed from the block's own content. */
    envelope: CanonicalBlockIR;
}
/**
 * Finish the partial-kind handoff for a `superseded` terminal.
 *
 * A workflow run deliberately shadows its text channel while server-built
 * render blocks stream, so the browser never builds a verified `__ir`
 * envelope for that region. The terminal still proves that the announced kind
 * completed, and the block's own content is now closed JSON. Reconstruct a
 * render-local COMPLETE envelope from that content and route it through the
 * same component path as persisted/reloaded data. `retracted` is never
 * eligible, and a malformed or mismatched payload stays on the host's honest
 * raw fallback.
 */
declare function resolveSupersededKindRender;
}>(block: T, env: KindRouteEnv, options?: KindRouteOptions): SupersededKindRender | null;
/**
 * 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;
}>(block: T, env: KindRouteEnv, options?: PartialRenderOptions): ProvisionalKindRender | null;

/**
 * THE BOUND ROUTE — the pure route functions with a host's env and owned
 * types partially applied, built ONCE in a host wiring module.
 *
 * Every host was writing the same wrapper file by hand: one function per pure
 * route, each forwarding `matrx…Env` + `ownedTypes` (matrx-frontend carried
 * two such modules; the dashboard a third). Per C22 that repeated delta is
 * package-provided: a host module now only INJECTS (its env, its owned block
 * types) and re-exports what this factory returns.
 *
 * The functions are the exact pure routes — read `kind-route.ts` /
 * `partial-kind-route.ts` for semantics; nothing behavioral lives here.
 */

interface KindRouteBinding {
    /** Route one block through the bound registries. */
    applyIrKindRoute(block: T): T;
    /**
     * Rehydration route for STRUCTURED persisted artifacts: given a stored
     * zero-loss value object, derive the registered kind's legacy `serverData`
     * with no re-parse. Null for non-objects, unregistered kinds, or kinds
     * without a legacy bridge.
     */
    kindServerDataFromStoredValue(value: unknown): Record | null;
    /** Has this kind opted in to being handed a provisional value? */
    isPartialReadyKind(kind: string): boolean;
    /**
     * 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).
     */
    resolveProvisionalKindRender;
    }>(block: T, options?: Pick): ProvisionalKindRender | null;
    /**
     * Route a completed workflow block whose `superseded` terminal confirms the
     * kind but whose shadowed lane never built a verified envelope.
     */
    resolveSupersededKindRender;
    }>(block: T): SupersededKindRender | null;
}
/** Bind the pure routes to one host's env + owned block types. */
declare function createKindRouteBinding(env: KindRouteEnv, options?: KindRouteOptions): KindRouteBinding;

export { useDirectiveScope as $, GENERIC_STRUCTURED_COMPONENT_KEY as G, applyIrKindRoute as H, IR_PROVISIONAL_KEY as I, createKindRouteBinding as J, envelopeFromPartialKind as L, isPartialReadyKind as M, isProvisionalBlock as N, kindLookupSettled as O, kindServerDataFromStoredValue as Q, markKindPartialUnsafe as R, readIrRouteMarker as T, resetPartialUnsafeKinds as U, resetSourcelessDbRowReports as V, resolveAnnouncedKindLoading as W, resolveProvisionalKindRender as X, resolveSupersededKindRender as Y, routeEnvOf as Z, useDirectiveHost as _, DB_KIND_COMPONENT_KEY as h, DIRECTIVE_BLOCK_TYPE as i, DirectiveHostProvider as n, DirectiveScopeProvider as s, IR_ROUTE_KEY as w };
export type { KindRouteBinding as A, KindRouteOptions as B, ContentIrHost as C, DecodedDirective as D, ProvisionalKindRender as E, SupersededKindRender as F, KindRouteEnv as K, PartialRenderOptions as P, StructuredValueRenderProps as S, KindDefinitionSource as a, DirectiveClass as b, DirectiveHost as c, DirectiveFailure as d, DirectiveFailureWords as e, DirectiveRecordRef as f, ContentIrRenderSeams as g, DirectiveApplyResult as j, DirectiveApplyState as k, DirectiveAskRequest as l, DirectiveCopyProps as m, DirectiveHostProviderProps as o, DirectiveOpenItemOptions as p, DirectiveRecordProps as q, DirectiveScope as r, DirectiveShell as t, DirectiveValueRef as u, GenericFallbackReason as v, IrRenderBlock as x, IrRoutableBlock as y, IrRouteMarker as z };