@objectstack/lint 17.0.0-rc.1 → 17.0.0-rc.2

package/dist/runtime-Cs64ShwN.d.cts

@@ -0,0 +1,254 @@
+type AnyRec = Record<string, unknown>;
+/** The three commands that hold a stack to the same author-time bar. */
+declare const AUTHORING_COMMANDS: readonly ["validate", "build", "lint"];
+type AuthoringCommand = (typeof AUTHORING_COMMANDS)[number];
+/**
+ * The authoring SURFACES this registry serves (#4463).
+ *
+ * - `cli` — `os validate` / `os build` / `os lint`. Which of the three is a
+ *   separate axis ({@link AuthoringRule.commands}); every rule here runs on the
+ *   `cli` surface, because that is where the registry was born.
+ * - `runtime-publish` — the metadata write path's PUBLISH gate: a
+ *   `state: 'active'` `saveMetaItem`, and the draft→active promotion in
+ *   `publishMetaItem`. Studio saves, REST `/meta` item CRUD and MCP/AI
+ *   authoring all funnel through those two, so wiring the surface once covers
+ *   all three doors (the maintainer ruling on #4463: one shared core, one
+ *   runtime gate, not a gate per surface).
+ *
+ * Draft saves are deliberately NOT a surface: a draft is allowed to be a
+ * half-finished thing, and gating one would break the Studio editing loop for
+ * no safety gain — the draft cannot execute until it is published, and
+ * publishing runs this table (#4463 D1).
+ */
+declare const AUTHORING_SURFACES: readonly ["cli", "runtime-publish"];
+type AuthoringSurface = (typeof AUTHORING_SURFACES)[number];
+/** `error` gates. `warning` advises. `info` is a suggestion (`os lint` grades it as one). */
+type AuthoringSeverity = 'error' | 'warning' | 'info';
+/**
+ * The one finding shape all three commands render. Rules whose own return type
+ * predates it are adapted at their registry entry, so the commands hold one
+ * type instead of a twenty-way union.
+ */
+interface AuthoringFinding {
+    severity: AuthoringSeverity;
+    /** Stable diagnostic rule id (used by docs, allowlists and `--json` consumers). */
+    rule: string;
+    /** Human-readable location, e.g. `object "leave_request"`. */
+    where: string;
+    /** Config path, e.g. `objects[3].sharingModel`. */
+    path: string;
+    /** What is wrong. */
+    message: string;
+    /** How to fix it. */
+    hint: string;
+}
+/**
+ * `gating` = the rule can emit `severity: 'error'`, so it MUST run on all three
+ * commands. `advisory` = it never does, and may be scoped with a reason.
+ *
+ * The claim is not taken on trust: the wiring guard reads each `advisory` rule's
+ * own source and fails if it emits an `error`. That check is the reason the tier
+ * is worth declaring — #3760 promoted a `lintFlowPatterns` rule from advisory to
+ * gating, and nothing anywhere asked whether its command coverage should follow.
+ */
+type AuthoringRuleTier = 'gating' | 'advisory';
+/**
+ * Which tier of the stack a rule reads.
+ *
+ * - `normalized` — the `normalizeStackInput` output, BEFORE the Zod parse. The
+ *   rules that need it check keys the parse strips (a flat list view in
+ *   `views: []`, `userFilters` on an object list view, a `visibleOn` alias): by
+ *   the time `result.data` exists the evidence is gone.
+ * - `parsed` — the post-parse stack, where defaults are filled and shapes are
+ *   settled.
+ *
+ * `os lint` never parses (it is the cheap pre-flight; a schema error is
+ * `os validate`'s verdict to give), so it runs BOTH tiers on the normalized
+ * stack. Every rule here is written to tolerate that — it is what `os lint`
+ * already did for the reference-integrity suite and the security linter.
+ */
+type AuthoringRuleInputTier = 'normalized' | 'parsed';
+/** Per-run inputs a rule may need beyond the stack itself. */
+interface AuthoringRuleContext {
+    /** ADR-0080 SDUI component manifest, when the project ships one. */
+    sduiManifest?: unknown;
+}
+interface AuthoringRule {
+    /** The exported function's name — the id the wiring guard asserts on. */
+    name: string;
+    tier: AuthoringRuleTier;
+    input: AuthoringRuleInputTier;
+    /** Which commands run it. Must be all three when `tier` is `gating`. */
+    commands: readonly AuthoringCommand[];
+    /** Repo-relative path to the rule's implementation (the guard verifies the tier claim against it). */
+    source: string;
+    /** REQUIRED when `commands` is not all three: why this rule is scoped. */
+    scopeReason?: string;
+    /**
+     * Which authoring surfaces run this rule (#4463). Always contains `'cli'`.
+     *
+     * Adding `'runtime-publish'` is what puts the rule on the metadata write
+     * path's publish gate; {@link runtimeTypes} then says which metadata types'
+     * writes it inspects. Leaving it off REQUIRES {@link surfaceReason} — the
+     * same discipline `scopeReason` applies to the command axis, for the same
+     * reason: the whole defect class #4409 and #4463 describe is coverage that
+     * narrowed silently.
+     */
+    surfaces: readonly AuthoringSurface[];
+    /**
+     * REQUIRED when `surfaces` includes `'runtime-publish'`: the SINGULAR
+     * metadata type names whose runtime write this rule inspects (e.g. `flow`).
+     *
+     * The runtime gate builds a per-write stack snapshot and only runs the rules
+     * that declare the written type, which is #4463 D2 option (c) expressed as
+     * data. Widening a rule to another type is a one-line edit here, not new
+     * wiring at the gate.
+     */
+    runtimeTypes?: readonly string[];
+    /** REQUIRED when `surfaces` omits `'runtime-publish'`: why the runtime gate does not run it. */
+    surfaceReason?: string;
+    run: (stack: AnyRec, ctx: AuthoringRuleContext) => readonly AuthoringFinding[];
+}
+/**
+ * `ExprIssue` is the one rule finding that carries no rule id of its own — it
+ * predates the `{ rule, path, hint }` shape every other rule settled on. Given
+ * one here so `os lint --json` and the docs can name it like any other.
+ */
+declare const EXPRESSION_INVALID = "expression-invalid";
+/**
+ * Every author-time rule the three commands share, in the order their findings
+ * are reported.
+ */
+declare const AUTHORING_RULES: readonly AuthoringRule[];
+/** The stack tiers a command has in hand when it runs the registry. */
+interface AuthoringRuleRun extends AuthoringRuleContext {
+    /** `normalizeStackInput` output — pre-Zod-parse. Always required. */
+    normalized: AnyRec;
+    /**
+     * Post-Zod-parse stack. Omitted by `os lint`, which does not parse; `parsed`
+     * rules then read `normalized` (see `AuthoringRuleInputTier`).
+     */
+    parsed?: AnyRec;
+}
+/** The rules `command` runs, in registry order. */
+declare function authoringRulesFor(command: AuthoringCommand): readonly AuthoringRule[];
+/**
+ * Run every rule registered for `command` and return the concatenated findings
+ * (empty = clean).
+ *
+ * Findings are collected across ALL rules rather than short-circuiting at the
+ * first failing one. The commands used to exit at the first failing gate, which
+ * meant an author with three unrelated problems fixed them in three round trips
+ * and could not tell how deep the hole went. One report per run is also what
+ * makes the three commands comparable: same rules, same order, same output.
+ */
+declare function runAuthoringRules(command: AuthoringCommand, run: AuthoringRuleRun): AuthoringFinding[];
+/** Split findings into the gating set and the advisory set (`warning` + `info`). */
+declare function splitBySeverity(findings: readonly AuthoringFinding[]): {
+    errors: AuthoringFinding[];
+    advisories: AuthoringFinding[];
+};
+
+/**
+ * The RUNTIME publish gate over the author-time rule registry (#4463).
+ *
+ * ## The hole this closes
+ *
+ * #4409/#4445 put 26 author-time rules behind one table and made `os validate`,
+ * `os build` and `os lint` run it by construction. All three are CLI commands.
+ * The metadata WRITE path — Studio's designer, REST `/meta` item CRUD, an
+ * MCP/AI author — reaches `saveMetaItem`, which ran a per-type Zod `safeParse`
+ * and nothing else. Zero of the 26 rules ran there. For a tenant that is not
+ * one weak door among four, it is the ONLY door: `os lint` cannot see a
+ * `sys_metadata` overlay row at all, so there was no command they could run
+ * instead.
+ *
+ * It also happens to be the door AI authors use. That is the axis the #4463
+ * ruling weighted highest: metadata written by a model is exactly the metadata
+ * most likely to be subtly wrong, and it was arriving through the one entrance
+ * with no checks on it.
+ *
+ * ## Shape
+ *
+ * This module is a GATE, not a rule engine. It owns no judgement: every finding
+ * it returns came from {@link AUTHORING_RULES}, the same array the three CLI
+ * commands run. Delete a rule from that table and this gate stops enforcing it
+ * in the same commit — which is the property the issue asked for, and the
+ * reason a second "runtime rule list" was never on the table.
+ *
+ * ## Why it evaluates DIFFERENTIALLY
+ *
+ * The rules are `(stack) => findings`. A runtime write is one ITEM. The gate
+ * therefore builds a per-write snapshot — the written item, plus the live
+ * registry's objects as resolution context — and runs the rules TWICE: once on
+ * the context alone, once with the item grafted in. Only findings the item
+ * ADDED are attributable to this write.
+ *
+ * That is not defensive padding, it is the D4 requirement made structural:
+ *
+ * - a tenant's existing `sys_metadata` rows may already violate a rule that did
+ *   not exist when they were written, and the read path must keep serving them
+ *   (ADR-0087's asymmetry). Gating on the absolute finding set would make an
+ *   unrelated legacy row block every future save;
+ * - the context is resolution material, not subject matter. Without the
+ *   subtraction, saving flow A would 422 because object B — untouched, already
+ *   stored, possibly shipped in a package — has a bad predicate.
+ *
+ * The cost is two passes over a small in-memory snapshot, on a PUBLISH (not on
+ * a draft autosave). That is the correct place to spend it.
+ */
+
+/** Everything the gate needs from the host runtime to build a snapshot. */
+interface RuntimeStackContext {
+    /**
+     * The live object declarations (registry + tenant overlay), as authored.
+     *
+     * Objects are the resolution universe almost every rule needs: `record.<field>`
+     * in a CEL predicate, a flow node's target object, a template path. This is
+     * where the runtime is strictly BETTER informed than `os lint`, which sees one
+     * package's config file and has to hedge.
+     */
+    objects?: readonly unknown[];
+}
+/** One rule's verdict at the runtime surface, carrying which rule produced it. */
+interface RuntimeGateResult {
+    /** Findings the written item ADDED, severity `error` — the reason to refuse the write. */
+    errors: AuthoringFinding[];
+    /** Findings the written item added at `warning` / `info`. Never blocks (#4463 P1). */
+    advisories: AuthoringFinding[];
+    /** Names of the registry rules that actually ran, in registry order. */
+    rulesRun: string[];
+}
+/**
+ * The rules the runtime publish gate runs for a write of `type` — read off
+ * {@link AUTHORING_RULES}, never a list of its own.
+ *
+ * @param type Singular metadata type name (`flow`, `object`, …).
+ */
+declare function runtimeAuthoringRulesFor(type: string): readonly AuthoringRule[];
+/** Every singular metadata type at least one rule gates at the runtime surface. */
+declare function runtimeGatedTypes(): string[];
+/** The stack key a metadata type occupies in a stack view, or null when unmapped. */
+declare function stackKeyForType(type: string): string | null;
+/**
+ * Judge one about-to-be-published metadata item against the shared registry.
+ *
+ * Returns an empty `errors` array when the item is clean OR when no rule gates
+ * its type — callers must not treat "no rules ran" as a failure, and
+ * `rulesRun` is there so a caller can tell the two apart.
+ *
+ * Pure: no I/O, no `process.env`, no logging. The escape hatch and the HTTP
+ * status live at the call site, where the request context is.
+ */
+declare function runRuntimeAuthoringRules(args: {
+    /** Singular metadata type of the item being written. */
+    type: string;
+    /** The item body as it will be persisted. */
+    item: unknown;
+    /** Live resolution context from the host runtime. */
+    context?: RuntimeStackContext;
+    /** ADR-0080 SDUI manifest, when the host has one. */
+    sduiManifest?: unknown;
+}): RuntimeGateResult;
+
+export { AUTHORING_COMMANDS as A, EXPRESSION_INVALID as E, type RuntimeGateResult as R, AUTHORING_RULES as a, AUTHORING_SURFACES as b, type AuthoringCommand as c, type AuthoringFinding as d, type AuthoringRule as e, type AuthoringRuleContext as f, type AuthoringRuleInputTier as g, type AuthoringRuleRun as h, type AuthoringRuleTier as i, type AuthoringSeverity as j, type AuthoringSurface as k, type RuntimeStackContext as l, authoringRulesFor as m, runRuntimeAuthoringRules as n, runtimeAuthoringRulesFor as o, runtimeGatedTypes as p, stackKeyForType as q, runAuthoringRules as r, splitBySeverity as s };

package/dist/runtime-Cs64ShwN.d.ts

@@ -0,0 +1,254 @@
+type AnyRec = Record<string, unknown>;
+/** The three commands that hold a stack to the same author-time bar. */
+declare const AUTHORING_COMMANDS: readonly ["validate", "build", "lint"];
+type AuthoringCommand = (typeof AUTHORING_COMMANDS)[number];
+/**
+ * The authoring SURFACES this registry serves (#4463).
+ *
+ * - `cli` — `os validate` / `os build` / `os lint`. Which of the three is a
+ *   separate axis ({@link AuthoringRule.commands}); every rule here runs on the
+ *   `cli` surface, because that is where the registry was born.
+ * - `runtime-publish` — the metadata write path's PUBLISH gate: a
+ *   `state: 'active'` `saveMetaItem`, and the draft→active promotion in
+ *   `publishMetaItem`. Studio saves, REST `/meta` item CRUD and MCP/AI
+ *   authoring all funnel through those two, so wiring the surface once covers
+ *   all three doors (the maintainer ruling on #4463: one shared core, one
+ *   runtime gate, not a gate per surface).
+ *
+ * Draft saves are deliberately NOT a surface: a draft is allowed to be a
+ * half-finished thing, and gating one would break the Studio editing loop for
+ * no safety gain — the draft cannot execute until it is published, and
+ * publishing runs this table (#4463 D1).
+ */
+declare const AUTHORING_SURFACES: readonly ["cli", "runtime-publish"];
+type AuthoringSurface = (typeof AUTHORING_SURFACES)[number];
+/** `error` gates. `warning` advises. `info` is a suggestion (`os lint` grades it as one). */
+type AuthoringSeverity = 'error' | 'warning' | 'info';
+/**
+ * The one finding shape all three commands render. Rules whose own return type
+ * predates it are adapted at their registry entry, so the commands hold one
+ * type instead of a twenty-way union.
+ */
+interface AuthoringFinding {
+    severity: AuthoringSeverity;
+    /** Stable diagnostic rule id (used by docs, allowlists and `--json` consumers). */
+    rule: string;
+    /** Human-readable location, e.g. `object "leave_request"`. */
+    where: string;
+    /** Config path, e.g. `objects[3].sharingModel`. */
+    path: string;
+    /** What is wrong. */
+    message: string;
+    /** How to fix it. */
+    hint: string;
+}
+/**
+ * `gating` = the rule can emit `severity: 'error'`, so it MUST run on all three
+ * commands. `advisory` = it never does, and may be scoped with a reason.
+ *
+ * The claim is not taken on trust: the wiring guard reads each `advisory` rule's
+ * own source and fails if it emits an `error`. That check is the reason the tier
+ * is worth declaring — #3760 promoted a `lintFlowPatterns` rule from advisory to
+ * gating, and nothing anywhere asked whether its command coverage should follow.
+ */
+type AuthoringRuleTier = 'gating' | 'advisory';
+/**
+ * Which tier of the stack a rule reads.
+ *
+ * - `normalized` — the `normalizeStackInput` output, BEFORE the Zod parse. The
+ *   rules that need it check keys the parse strips (a flat list view in
+ *   `views: []`, `userFilters` on an object list view, a `visibleOn` alias): by
+ *   the time `result.data` exists the evidence is gone.
+ * - `parsed` — the post-parse stack, where defaults are filled and shapes are
+ *   settled.
+ *
+ * `os lint` never parses (it is the cheap pre-flight; a schema error is
+ * `os validate`'s verdict to give), so it runs BOTH tiers on the normalized
+ * stack. Every rule here is written to tolerate that — it is what `os lint`
+ * already did for the reference-integrity suite and the security linter.
+ */
+type AuthoringRuleInputTier = 'normalized' | 'parsed';
+/** Per-run inputs a rule may need beyond the stack itself. */
+interface AuthoringRuleContext {
+    /** ADR-0080 SDUI component manifest, when the project ships one. */
+    sduiManifest?: unknown;
+}
+interface AuthoringRule {
+    /** The exported function's name — the id the wiring guard asserts on. */
+    name: string;
+    tier: AuthoringRuleTier;
+    input: AuthoringRuleInputTier;
+    /** Which commands run it. Must be all three when `tier` is `gating`. */
+    commands: readonly AuthoringCommand[];
+    /** Repo-relative path to the rule's implementation (the guard verifies the tier claim against it). */
+    source: string;
+    /** REQUIRED when `commands` is not all three: why this rule is scoped. */
+    scopeReason?: string;
+    /**
+     * Which authoring surfaces run this rule (#4463). Always contains `'cli'`.
+     *
+     * Adding `'runtime-publish'` is what puts the rule on the metadata write
+     * path's publish gate; {@link runtimeTypes} then says which metadata types'
+     * writes it inspects. Leaving it off REQUIRES {@link surfaceReason} — the
+     * same discipline `scopeReason` applies to the command axis, for the same
+     * reason: the whole defect class #4409 and #4463 describe is coverage that
+     * narrowed silently.
+     */
+    surfaces: readonly AuthoringSurface[];
+    /**
+     * REQUIRED when `surfaces` includes `'runtime-publish'`: the SINGULAR
+     * metadata type names whose runtime write this rule inspects (e.g. `flow`).
+     *
+     * The runtime gate builds a per-write stack snapshot and only runs the rules
+     * that declare the written type, which is #4463 D2 option (c) expressed as
+     * data. Widening a rule to another type is a one-line edit here, not new
+     * wiring at the gate.
+     */
+    runtimeTypes?: readonly string[];
+    /** REQUIRED when `surfaces` omits `'runtime-publish'`: why the runtime gate does not run it. */
+    surfaceReason?: string;
+    run: (stack: AnyRec, ctx: AuthoringRuleContext) => readonly AuthoringFinding[];
+}
+/**
+ * `ExprIssue` is the one rule finding that carries no rule id of its own — it
+ * predates the `{ rule, path, hint }` shape every other rule settled on. Given
+ * one here so `os lint --json` and the docs can name it like any other.
+ */
+declare const EXPRESSION_INVALID = "expression-invalid";
+/**
+ * Every author-time rule the three commands share, in the order their findings
+ * are reported.
+ */
+declare const AUTHORING_RULES: readonly AuthoringRule[];
+/** The stack tiers a command has in hand when it runs the registry. */
+interface AuthoringRuleRun extends AuthoringRuleContext {
+    /** `normalizeStackInput` output — pre-Zod-parse. Always required. */
+    normalized: AnyRec;
+    /**
+     * Post-Zod-parse stack. Omitted by `os lint`, which does not parse; `parsed`
+     * rules then read `normalized` (see `AuthoringRuleInputTier`).
+     */
+    parsed?: AnyRec;
+}
+/** The rules `command` runs, in registry order. */
+declare function authoringRulesFor(command: AuthoringCommand): readonly AuthoringRule[];
+/**
+ * Run every rule registered for `command` and return the concatenated findings
+ * (empty = clean).
+ *
+ * Findings are collected across ALL rules rather than short-circuiting at the
+ * first failing one. The commands used to exit at the first failing gate, which
+ * meant an author with three unrelated problems fixed them in three round trips
+ * and could not tell how deep the hole went. One report per run is also what
+ * makes the three commands comparable: same rules, same order, same output.
+ */
+declare function runAuthoringRules(command: AuthoringCommand, run: AuthoringRuleRun): AuthoringFinding[];
+/** Split findings into the gating set and the advisory set (`warning` + `info`). */
+declare function splitBySeverity(findings: readonly AuthoringFinding[]): {
+    errors: AuthoringFinding[];
+    advisories: AuthoringFinding[];
+};
+
+/**
+ * The RUNTIME publish gate over the author-time rule registry (#4463).
+ *
+ * ## The hole this closes
+ *
+ * #4409/#4445 put 26 author-time rules behind one table and made `os validate`,
+ * `os build` and `os lint` run it by construction. All three are CLI commands.
+ * The metadata WRITE path — Studio's designer, REST `/meta` item CRUD, an
+ * MCP/AI author — reaches `saveMetaItem`, which ran a per-type Zod `safeParse`
+ * and nothing else. Zero of the 26 rules ran there. For a tenant that is not
+ * one weak door among four, it is the ONLY door: `os lint` cannot see a
+ * `sys_metadata` overlay row at all, so there was no command they could run
+ * instead.
+ *
+ * It also happens to be the door AI authors use. That is the axis the #4463
+ * ruling weighted highest: metadata written by a model is exactly the metadata
+ * most likely to be subtly wrong, and it was arriving through the one entrance
+ * with no checks on it.
+ *
+ * ## Shape
+ *
+ * This module is a GATE, not a rule engine. It owns no judgement: every finding
+ * it returns came from {@link AUTHORING_RULES}, the same array the three CLI
+ * commands run. Delete a rule from that table and this gate stops enforcing it
+ * in the same commit — which is the property the issue asked for, and the
+ * reason a second "runtime rule list" was never on the table.
+ *
+ * ## Why it evaluates DIFFERENTIALLY
+ *
+ * The rules are `(stack) => findings`. A runtime write is one ITEM. The gate
+ * therefore builds a per-write snapshot — the written item, plus the live
+ * registry's objects as resolution context — and runs the rules TWICE: once on
+ * the context alone, once with the item grafted in. Only findings the item
+ * ADDED are attributable to this write.
+ *
+ * That is not defensive padding, it is the D4 requirement made structural:
+ *
+ * - a tenant's existing `sys_metadata` rows may already violate a rule that did
+ *   not exist when they were written, and the read path must keep serving them
+ *   (ADR-0087's asymmetry). Gating on the absolute finding set would make an
+ *   unrelated legacy row block every future save;
+ * - the context is resolution material, not subject matter. Without the
+ *   subtraction, saving flow A would 422 because object B — untouched, already
+ *   stored, possibly shipped in a package — has a bad predicate.
+ *
+ * The cost is two passes over a small in-memory snapshot, on a PUBLISH (not on
+ * a draft autosave). That is the correct place to spend it.
+ */
+
+/** Everything the gate needs from the host runtime to build a snapshot. */
+interface RuntimeStackContext {
+    /**
+     * The live object declarations (registry + tenant overlay), as authored.
+     *
+     * Objects are the resolution universe almost every rule needs: `record.<field>`
+     * in a CEL predicate, a flow node's target object, a template path. This is
+     * where the runtime is strictly BETTER informed than `os lint`, which sees one
+     * package's config file and has to hedge.
+     */
+    objects?: readonly unknown[];
+}
+/** One rule's verdict at the runtime surface, carrying which rule produced it. */
+interface RuntimeGateResult {
+    /** Findings the written item ADDED, severity `error` — the reason to refuse the write. */
+    errors: AuthoringFinding[];
+    /** Findings the written item added at `warning` / `info`. Never blocks (#4463 P1). */
+    advisories: AuthoringFinding[];
+    /** Names of the registry rules that actually ran, in registry order. */
+    rulesRun: string[];
+}
+/**
+ * The rules the runtime publish gate runs for a write of `type` — read off
+ * {@link AUTHORING_RULES}, never a list of its own.
+ *
+ * @param type Singular metadata type name (`flow`, `object`, …).
+ */
+declare function runtimeAuthoringRulesFor(type: string): readonly AuthoringRule[];
+/** Every singular metadata type at least one rule gates at the runtime surface. */
+declare function runtimeGatedTypes(): string[];
+/** The stack key a metadata type occupies in a stack view, or null when unmapped. */
+declare function stackKeyForType(type: string): string | null;
+/**
+ * Judge one about-to-be-published metadata item against the shared registry.
+ *
+ * Returns an empty `errors` array when the item is clean OR when no rule gates
+ * its type — callers must not treat "no rules ran" as a failure, and
+ * `rulesRun` is there so a caller can tell the two apart.
+ *
+ * Pure: no I/O, no `process.env`, no logging. The escape hatch and the HTTP
+ * status live at the call site, where the request context is.
+ */
+declare function runRuntimeAuthoringRules(args: {
+    /** Singular metadata type of the item being written. */
+    type: string;
+    /** The item body as it will be persisted. */
+    item: unknown;
+    /** Live resolution context from the host runtime. */
+    context?: RuntimeStackContext;
+    /** ADR-0080 SDUI manifest, when the host has one. */
+    sduiManifest?: unknown;
+}): RuntimeGateResult;
+
+export { AUTHORING_COMMANDS as A, EXPRESSION_INVALID as E, type RuntimeGateResult as R, AUTHORING_RULES as a, AUTHORING_SURFACES as b, type AuthoringCommand as c, type AuthoringFinding as d, type AuthoringRule as e, type AuthoringRuleContext as f, type AuthoringRuleInputTier as g, type AuthoringRuleRun as h, type AuthoringRuleTier as i, type AuthoringSeverity as j, type AuthoringSurface as k, type RuntimeStackContext as l, authoringRulesFor as m, runRuntimeAuthoringRules as n, runtimeAuthoringRulesFor as o, runtimeGatedTypes as p, stackKeyForType as q, runAuthoringRules as r, splitBySeverity as s };