@magicvr/schema-ui-shell 0.1.0

package/lib/datetime.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Display-time formatting (GOAL-011 table style): ISO-8601 timestamps are
+ * rendered in a human-readable local-time form ("2026-08-01 18:02") instead
+ * of the raw wire value ("2026-08-01T18:02:44.000Z").
+ *
+ * Returns null when the value is not a renderable timestamp so callers fall
+ * back to the raw text (numbers, booleans, plain strings, arbitrary dates
+ * with other shapes stay untouched).
+ */
+/**
+ * Formats an ISO-8601 timestamp string to local "YYYY-MM-DD HH:mm". Returns
+ * null for non-timestamp values, malformed dates, or non-string input.
+ */
+export declare function formatDisplayTime(value: unknown): string | null;

package/lib/fetch-timeout.d.ts

@@ -0,0 +1,13 @@
+/**
+ * W10 F-002: fetch timeout wrapper.
+ *
+ * Wraps a fetch implementation so a hung request (slow network, stalled
+ * server) aborts after a bounded window instead of pending forever. The
+ * returned function is drop-in compatible with `typeof fetch`; a caller-
+ * provided AbortSignal in `init` is composed with the timeout signal (either
+ * firing aborts the request). Timers are cleared once the request settles, so
+ * no handles leak on the happy path.
+ */
+/** Default ceiling for a single request (30s). */
+export declare const DEFAULT_FETCH_TIMEOUT_MS = 30000;
+export declare function withTimeout(fetchImpl?: typeof fetch, timeoutMs?: number): typeof fetch;

package/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@magicvr/schema-ui-shell",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "schema-ui-core 包面（VP-023 R3 六包化）",
+  "main": "index.js",
+  "types": "./app/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./app/index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "lib",
+    "theme",
+    "components",
+    "app",
+    "host",
+    "i18n",
+    "ui",
+    "renderer",
+    "render"
+  ],
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/renderer/confirm.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Confirm dialog for row actions that declare a `confirm` string (S4 · GOAL-007).
+ *
+ * One-time renderer completion allowed by I-007-003 §9.5 (`confirm*.tsx`). The
+ * message text comes from the schema row action entry (`table.props.actions[].
+ * confirm` / `confirmKey`), so the dialog stays fixture-driven; cancelling
+ * mirrors the frozen `executeAction` CONFIRM_CANCELLED path and never issues
+ * a request.
+ *
+ * W14 F-12 (GOAL-018): keyboard/accessibility — initial focus on Cancel, ESC
+ * cancels, and Tab is trapped inside the dialog.
+ */
+export declare function ConfirmDialog({ message, onConfirm, onCancel, }: {
+    message: string;
+    onConfirm: () => void;
+    onCancel: () => void;
+}): import("react").JSX.Element;

package/renderer/custom-components.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentType } from "react";
+import type { RenderCustomNode, RenderNode } from "@/renderer/render.types";
+export interface CustomComponentProps {
+    node: RenderCustomNode;
+    context: Record<string, unknown>;
+    /** Children declared under the custom node (rarely used). */
+    children?: RenderNode[];
+}
+/** Registers a custom node component (idempotent; later registrations win). */
+export declare function registerCustomComponent(key: string, component: ComponentType<CustomComponentProps>): void;
+/** Returns the registered component for a key, or null when unregistered. */
+export declare function getCustomComponent(key: string): ComponentType<CustomComponentProps> | null;
+/** Test-only: clears the registry. */
+export declare function resetCustomComponentsForTests(): void;

package/renderer/form-controls.d.ts

@@ -0,0 +1,45 @@
+import { type ReactNode } from "react";
+import { type MessageParams } from "@/i18n/catalog";
+import type { UploadableFile } from "@/protocol/conformance/upload-orchestration";
+import { type FormControlField } from "@/renderer/form-controls.types";
+export interface FormControlsProps {
+    fields: FormControlField[];
+    values: Record<string, unknown>;
+    onChange: (id: string, value: unknown) => void;
+    disabled?: boolean;
+    /** Per-field disabled override (R5 renderer reaction state). */
+    fieldDisabled?: (id: string) => boolean;
+    idPrefix?: string;
+    /** Upload control transport (ADR-0012): validates + uploads + returns the field value. */
+    onUpload?: (field: FormControlField, files: UploadableFile[]) => Promise<unknown>;
+    /** GOAL-014 D-002 §4: inline field errors keyed by field id (submit-time
+     * validation + server fieldErrors echo). */
+    fieldErrors?: Record<string, string>;
+    /** GOAL-014 D-002 §4: column count (default 1 = single-column layout).
+     * >1 enables a responsive grid; the mobile layout stays single-column. */
+    columns?: number;
+    /** W11 · U-01/U-02: auth-aware transport for dynamic option sources
+     * (optionsSource); defaults to globalThis.fetch. */
+    fetcher?: typeof fetch;
+    /**
+     * A-003 (GOAL-013 audit response): search-mode presentation — compact
+     * responsive auto-grid (1..5 columns), keyword input with search prefix
+     * icon + clear affordance. Search schemas keep their exact JSON shape.
+     */
+    searchMode?: boolean;
+    /** A-003: action cluster (Reset button) rendered inside the
+     * search-mode grid so it aligns with the field row. */
+    actionSlot?: ReactNode;
+    /**
+     * A-003 (user pairing rule): one search button rendered side-by-side with
+     * EVERY keyword input field in search mode — as many buttons as there are
+     * text inputs, each pair adjacent in the same grid cell.
+     */
+    searchButtonSlot?: ReactNode;
+}
+export type FieldTranslator = (key: string, params?: MessageParams, literalFallback?: string) => string;
+export declare function optionList(field: FormControlField, t: FieldTranslator): Array<{
+    value: string;
+    label: string;
+}>;
+export declare function FormControls({ fields, values, onChange, disabled, fieldDisabled, idPrefix, onUpload, fieldErrors, columns, fetcher, searchMode: searchModeProp, actionSlot, searchButtonSlot, }: FormControlsProps): import("react").JSX.Element;

package/renderer/form-controls.types.d.ts

@@ -0,0 +1,135 @@
+/**
+ * D-FORM form control surface (frozen §5 whitelist + I-PROTO-FULL-001 full
+ * registry surface).
+ *
+ * Wire rules from schema-ui-docs@2.7.0 (fixed commit ca9e5fe…):
+ *  - base: input → string, select (single) → string, inputNumber → number,
+ *    datePicker → ISO 8601 string, dateRangePicker → {start,end} pair bound
+ *    to startField/endField (registry props; no single-field wire)
+ *  - 2.6 (capability form.controls.extended): textarea → string, switch → boolean,
+ *    checkbox → boolean, radio → single string, select.mode=multiple → string[]
+ *  - 2.7 (capability form.controls.advanced): cascader → path string[],
+ *    checkboxGroup → value string[], richText → markdown string, password → string
+ *  - 2.7 props.defaultValue must match the field's wire type
+ *
+ * The schema-driven page gate (meta.protocolVersion + requiredCapabilities) is
+ * enforced by checkFormCapabilities; the Renderer-level page gate lands in 2c.
+ */
+export type FormControlType = "input" | "select" | "inputNumber" | "datePicker" | "dateRangePicker" | "textarea" | "switch" | "checkbox" | "radio" | "cascader" | "checkboxGroup" | "richText" | "password" | "upload";
+export declare const FORM_CONTROLS_EXTENDED_CAPABILITY = "form.controls.extended";
+export declare const FORM_CONTROLS_ADVANCED_CAPABILITY = "form.controls.advanced";
+/** ADR-0021: `form.props.recordSource` prefill GET (registry since 2.1). */
+export declare const FORM_RECORD_LOAD_CAPABILITY = "form.record.load";
+/** ADR-0040 (since 2.9): `readOnly` field declaration (value still projects). */
+export declare const FORM_CONTROLS_READONLY_CAPABILITY = "form.controls.readonly";
+export type WireKind = "string" | "boolean" | "string-array" | "number" | "date-range";
+export interface FormOption {
+    value: string;
+    label?: string;
+    /** S2 (VP-007): i18n key resolved before `label` (upstream registry field). */
+    labelKey?: string;
+}
+export interface DateRangeValue {
+    start: string;
+    end: string;
+}
+export interface FormControlField {
+    id: string;
+    label?: string;
+    /** S2 (VP-007): i18n key resolved before `label` (missing-key observable). */
+    labelKey?: string;
+    placeholder?: string;
+    /** S2 (VP-007): i18n key resolved before `placeholder` (local doc convention). */
+    placeholderKey?: string;
+    type: FormControlType;
+    /** select only: single (default) or multiple. */
+    mode?: "single" | "multiple";
+    options?: FormOption[];
+    /**
+     * W11 · U-01/U-02 — dynamic option source, aligned with the upstream
+     * registry shape (component-registry.json, since 0.2): an object with a
+     * required single-slash same-origin url plus the response item fields used
+     * for value/label. The response is {items:[...]} (or a bare array); while
+     * the source loads, static options (if any) remain the fallback; an invalid
+     * source or failed fetch fails closed to an empty option set.
+     */
+    optionsSource?: {
+        url: string;
+        /** Optional scalar query params appended to url (e.g. pageSize). */
+        params?: Record<string, string | number | boolean | null>;
+        labelField: string;
+        valueField: string;
+    };
+    defaultValue?: unknown;
+    /** dateRangePicker only: the two bound output fields (registry props). */
+    startField?: string;
+    endField?: string;
+    /** inputNumber constraints (registry props, since 0.2.1). */
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    /** GOAL-014 D-002 §3: field-level validation constraints (optional). */
+    required?: boolean;
+    /** ADR-0040 (since 2.9): read-only field — user cannot edit, value still
+     * participates in values and the submit projection (bodyMapping);
+     * recordSource backfill and reactions keep writing. Requires protocol
+     * >= 2.9 and form.controls.readonly. */
+    readOnly?: boolean;
+    /** Regex pattern for string-typed fields (submit-time validation). */
+    pattern?: string;
+    /** String length bounds for input/textarea. */
+    minLength?: number;
+    maxLength?: number;
+    /** datePicker display format (display-only; data stays ISO 8601). */
+    format?: string;
+    /** upload only: direct-URL mode (registry oneOf with actionRef). */
+    action?: string;
+    /** upload only: references a top-level type=upload action (requires actions.upload). */
+    actionRef?: string;
+    /**
+     * W17: optional Host-local addon rendered under this field. The value is a
+     * registered custom-component key (e.g. cron-preview). Not a protocol
+     * control type.
+     */
+    afterComponent?: string;
+    /** upload constraints (direct-URL mode only; actionRef mode reads the action). */
+    accept?: string;
+    maxSize?: number;
+    multiple?: boolean;
+}
+export interface FormControlMeta {
+    protocolVersion: string;
+    requiredCapabilities: string[];
+}
+export interface FormControlGateError {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function isWhitelistedFormControl(type: string): type is FormControlType;
+export declare function wireKindOf(field: FormControlField): WireKind;
+/** Coerces a raw control value to its wire kind; defaultValue applies when raw is empty. */
+export declare function coerceFieldValue(field: FormControlField, raw: unknown): unknown;
+/** Fails closed when defaultValue does not match the field's wire type. */
+export declare function validateDefaultValue(field: FormControlField): FormControlGateError | null;
+/** Gates a control set against page meta (P-005 / frozen capability rules). */
+export declare function checkFormCapabilities(meta: FormControlMeta, fields: FormControlField[]): FormControlGateError[];
+/** Validates an arbitrary page-meta value without assuming record types. */
+export declare function checkFormCapabilitiesRaw(metaValue: unknown, fields: FormControlField[]): FormControlGateError[];
+/** One submit-time field validation failure (GOAL-014 D-002 §3). */
+export interface FieldValidationError {
+    field: string;
+    code: "REQUIRED" | "PATTERN" | "MIN_LENGTH" | "MAX_LENGTH" | "MIN_VALUE" | "MAX_VALUE";
+    /** Stable i18n key (form.validation.*); message is the en fallback. */
+    messageKey: string;
+    message: string;
+}
+/**
+ * Validates form values against each field's declared constraints (GOAL-014
+ * D-002 §3.1). Pure function: returns all failures (not just the first) so
+ * the host can inline every field error. Boolean fields (switch/checkbox)
+ * never fail REQUIRED — their wire kind is boolean and the toggle has an
+ * explicit state.
+ */
+export declare function validateFieldValues(fields: FormControlField[], values: Record<string, unknown>): FieldValidationError[];

package/renderer/modal.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from "react";
+export declare function ModalHost({ title, onClose, children, }: {
+    title?: string;
+    onClose: () => void;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/renderer/permissions.d.ts

@@ -0,0 +1,53 @@
+import { type NavigationContext } from "@/protocol/app-manifest";
+/**
+ * R4 D-PERM permission evaluation engine (ADR-0023, frozen by GOAL-006 D-004).
+ *
+ * Coverage scope: the minimal renderer subset exercised by the frozen
+ * permissions-inheritance fixtures — permissionCascade / permissionIntent
+ * validation (fail-closed error codes) and effectivePermission evaluation for
+ * the approved target kinds (formField / formSubmit / rowAction /
+ * toolbarTrigger / actionButton). Execution-time gating (visibleWhen →
+ * permission → disabled/requiresSelection → confirm → action) is modeled for
+ * rowAction / toolbarTrigger / actionButton / default form submit.
+ */
+export type PermissionKey = "view" | "edit" | "delete";
+export type L2ErrorCode = "PROTOCOL_VERSION_TOO_LOW" | "CAPABILITY_REQUIRED" | "PERMISSION_CASCADE_TYPE_INVALID" | "PERMISSION_CASCADE_KEYS_INVALID" | "PERMISSION_CASCADE_SOURCE_MISSING" | "PERMISSION_INTENT_FORBIDDEN" | "PERMISSION_INTENT_INVALID";
+export interface L2Error {
+    code: L2ErrorCode;
+    path: string;
+}
+export interface PermissionTarget {
+    targetId: string;
+    kind: "formField" | "formSubmit" | "rowAction" | "toolbarTrigger" | "actionButton" | "column";
+    key: PermissionKey;
+    cascadeApplied: boolean;
+    cascadedBy: string[];
+    effectivePermission: boolean;
+}
+export interface ExecutionRequest {
+    targetId: string;
+    visible: boolean;
+    confirm?: boolean;
+    confirmed?: boolean;
+    disabled?: boolean;
+    requiresSelection?: boolean;
+}
+export interface ExecutionResult {
+    outcome: "EXECUTED" | "BLOCKED" | "CONFIRM_CANCELLED";
+    reason?: "NOT_VISIBLE" | "PERMISSION_DENIED" | "DISABLED";
+    events: Array<{
+        type: "confirmShown" | "actionExecuted";
+    }>;
+}
+type JsonRecord = Record<string, unknown>;
+/** Validates the permission fields of a page; returns all L2 errors. */
+export declare function validatePermissions(page: JsonRecord): L2Error[];
+/**
+ * Evaluates the effective permission of every approved target in the page
+ * against the frozen $context snapshot. Targets in modal content and
+ * navigated pages start new roots (ADR-0023 D2a).
+ */
+export declare function evaluatePermissionTargets(page: JsonRecord, context: NavigationContext): PermissionTarget[];
+/** Gates an action: visible → permission → disabled/requiresSelection → confirm. */
+export declare function executeAction(page: JsonRecord, request: ExecutionRequest, context: NavigationContext): ExecutionResult;
+export {};

package/renderer/reaction-engine.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Multi-round snapshot reaction engine (schema-ui-docs@2.7.0 · 02-reaction-expression.md §14).
+ *
+ * Implements the upstream conformance contract (`conformance/fixtures/reactions/cases.json`):
+ *   Snapshot → Evaluate → Commit → Next tick, with:
+ *   - per-field reactions [{ when, fulfill, otherwise }] (value/visible/required/disabled)
+ *   - observers evaluated against every round snapshot
+ *   - baselines + resetMissingOtherwise (condition false without otherwise → restore baseline;
+ *     explicit writes win over implicit baseline restores)
+ *   - externalUpdates applied between rounds
+ *   - deep-equal change detection (no commit / no next round on no-op writes)
+ *   - loop protection (REACTION_LOOP_LIMIT after maxRounds, default 10)
+ *   - MULTIPLE_VALUE_WRITES warnings (last write wins, deterministic order)
+ */
+export interface ReactionRuleInput {
+    when: string;
+    fulfill?: Record<string, unknown>;
+    otherwise?: Record<string, unknown>;
+}
+export interface FieldReactionInput {
+    field: string;
+    reactions: ReactionRuleInput[];
+}
+export interface ReactionObserverInput {
+    id: string;
+    when: string;
+}
+export interface ExternalUpdateInput {
+    afterRound: number;
+    values: Record<string, unknown>;
+}
+export interface ReactionEngineInput {
+    initialValues: Record<string, unknown>;
+    fields?: FieldReactionInput[];
+    observers?: ReactionObserverInput[];
+    baselines?: Record<string, unknown>;
+    resetMissingOtherwise?: boolean;
+    externalUpdates?: ExternalUpdateInput[];
+    maxRounds?: number;
+}
+export interface ReactionRound {
+    round: number;
+    snapshot: Record<string, unknown>;
+    observations: Record<string, boolean>;
+    commits: Array<{
+        field: string;
+        value: unknown;
+    }>;
+}
+export interface MultipleValueWritesWarning {
+    code: "MULTIPLE_VALUE_WRITES";
+    field: string;
+    count: number;
+}
+export interface ReactionEngineOk {
+    ok: true;
+    values: Record<string, unknown>;
+    rounds: ReactionRound[];
+    warnings: MultipleValueWritesWarning[];
+}
+export interface ReactionEngineLoopError {
+    ok: false;
+    code: "REACTION_LOOP_LIMIT";
+    maxRounds: number;
+    values: Record<string, unknown>;
+    roundCount: number;
+    dependencyFields: string[];
+}
+export type ReactionEngineResult = ReactionEngineOk | ReactionEngineLoopError;
+/** Per-field control state after convergence (renderer integration). */
+export interface ReactionFieldState {
+    visible?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+}
+export interface ReactionEngineDetailed {
+    result: ReactionEngineResult;
+    fieldStates: Record<string, ReactionFieldState>;
+}
+export declare const DEFAULT_MAX_ROUNDS = 10;
+/**
+ * Runs the multi-round engine.
+ *
+ * A field's committed `value` only lands in `commits` when it deep-differs
+ * from the snapshot value; a no-op write neither commits nor schedules the
+ * next round. Rounds stop when no committed field is a dependency of any
+ * expression (reaction when or observer when).
+ */
+export declare function runReactionEngine(input: ReactionEngineInput): ReactionEngineResult;
+/** Engine + per-field control state (visible/required/disabled/value) from
+ * the final round — used by the Renderer's form integration. */
+export declare function runReactionEngineDetailed(input: ReactionEngineInput): ReactionEngineDetailed;

package/renderer/reaction-expression.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Full protocol expression engine (schema-ui-docs@2.7.0 · docs/02-reaction-expression.md).
+ *
+ * Whitelisted grammar (no eval / new Function):
+ *   - namespaces: $deps.<field>, $self, $context.user.* / $context.features.*
+ *   - operators:  ==  !=  >  >=  <  <=  contains  &&  ||  !
+ *   - grouping:   ( )
+ *   - literals:   'str' | "str" | number (int/float/exponent) | true | false | null
+ *
+ * Semantics (ADR-0016 / §7-§14):
+ *   - strict typing, no coercion: 1 == 1.0 true; 1 == '1' false; true == 1 false
+ *   - contains: array left operand, strict element equality; non-array → false
+ *   - string ordering by Unicode code points (not UTF-16 code units)
+ *   - undefined values compare as false (missing deps never throw)
+ */
+export type ExprValue = string | number | boolean | null | ExprValue[] | {
+    [key: string]: ExprValue;
+} | undefined;
+export interface ReactionEnv {
+    /** $deps.<field> values (form field snapshot). */
+    deps?: Record<string, unknown>;
+    /** $self (current field value). */
+    self?: unknown;
+    /** $context.user.* / $context.features.* snapshots. */
+    context?: Record<string, unknown>;
+}
+export type ParseError = {
+    ok: false;
+    code: "SYNTAX";
+    message: string;
+} | {
+    ok: false;
+    code: "FORBIDDEN_VARIABLE";
+    message: string;
+} | {
+    ok: false;
+    code: "UNSUPPORTED_OPERATOR";
+    message: string;
+};
+export type ParsedExpr = {
+    kind: "literal";
+    value: ExprValue;
+} | {
+    kind: "var";
+    path: string[];
+} | {
+    kind: "self";
+} | {
+    kind: "not";
+    operand: ParsedExpr;
+} | {
+    kind: "and";
+    left: ParsedExpr;
+    right: ParsedExpr;
+} | {
+    kind: "or";
+    left: ParsedExpr;
+    right: ParsedExpr;
+} | {
+    kind: "compare";
+    op: "==" | "!=" | ">" | ">=" | "<" | "<=" | "contains";
+    left: ParsedExpr;
+    right: ParsedExpr;
+};
+/** Parses a whitelisted expression; returns the AST or a typed error. */
+export declare function parseExpression(source: string): ParsedExpr | ParseError;
+/** Deep equality (arrays/objects by structure; scalars by strict identity). */
+export declare function deepEqual(left: unknown, right: unknown): boolean;
+/** Evaluates a whitelisted expression to a boolean; invalid input → false. */
+export declare function evaluateFullExpression(source: string, env: ReactionEnv): boolean;
+/** True when `source` parses under the full grammar. */
+export declare function isValidFullExpression(source: string): boolean;
+/** Extracts the $deps.<root> field names referenced by an expression. */
+export declare function expressionDependencyFields(source: string): string[];

package/renderer/reactions.d.ts

@@ -0,0 +1,64 @@
+/**
+ * R5 D-EXPR reaction surface (frozen Q: reactions operate on the $context
+ * namespace only; no field-value triggers).
+ *
+ * A reaction is a `{ when, apply }` rule: `when` is a frozen $context
+ * expression (evaluateExpression grammar), and `apply` turns a form control
+ * state on/off when the expression holds. This is the renderer-level
+ * equivalent of the navigation visibleWhen gate, applied to form fields.
+ *
+ * Fails closed: an unparseable `when` expression or an unknown apply target
+ * keeps the field at its default state instead of mutating it silently.
+ */
+export interface ReactionApply {
+    fieldId: string;
+    /** visible/disabled toggles are explicit booleans (no implicit flip). */
+    visible?: boolean;
+    disabled?: boolean;
+}
+export interface ReactionRule {
+    id: string;
+    when: string;
+    apply: ReactionApply[];
+}
+export type ReactionErrorCode = "REACTION_EXPRESSION_INVALID" | "REACTION_APPLY_FIELD_UNKNOWN" | "REACTION_APPLY_INVALID";
+export interface ReactionError {
+    code: ReactionErrorCode;
+    path: string;
+    message: string;
+}
+export interface FormControlState {
+    visible: boolean;
+    disabled: boolean;
+}
+export type FormControlStateMap = Record<string, FormControlState>;
+export interface ReactionEvaluation {
+    state: FormControlStateMap;
+    errors: ReactionError[];
+}
+/** Parses a raw reaction rule, fail-closed on malformed shapes. */
+export declare function parseReactionRule(value: unknown, path: string): ReactionRule | ReactionError;
+/**
+ * Evaluates a reaction rule list against the frozen $context snapshot.
+ * Unknown apply fieldIds fail closed (keep default) and are reported.
+ */
+export declare function evaluateReactions(rules: ReactionRule[], context: Record<string, unknown>, fieldIds: string[]): ReactionEvaluation;
+/** Validates raw rules and returns parsed rules + fail-closed errors. */
+export declare function parseAndEvaluateReactions(rawRules: unknown, context: Record<string, unknown>, fieldIds: string[]): ReactionEvaluation;
+export interface FullReactionResult {
+    /** True when the form declares upstream-shaped per-field reactions ($deps). */
+    usesFullEngine: boolean;
+    /** Per-field control state after convergence (visible/disabled). */
+    state: FormControlStateMap;
+    /** Value commits to merge into the form values (last-wins, convergent). */
+    values: Record<string, unknown>;
+    errors: ReactionError[];
+}
+/**
+ * Resolves the full multi-round $deps reaction engine over a form's fields.
+ *
+ * Upstream shape (02-reaction-expression.md): each field node carries
+ * `reactions: [{ when, fulfill, otherwise }]`. Returns the convergent control
+ * state + value commits; malformed rules fail closed (reported, not applied).
+ */
+export declare function resolveFullFormReactions(rawFields: unknown, values: Record<string, unknown>, baselines: Record<string, unknown>): FullReactionResult;