@tai42/studio-sdk 6.1.1 → 7.0.0

package/src/plugin/registry.ts

@@ -18,11 +18,21 @@ import type {
   SettingsTabContribution,
   ToolPanelContribution,
 } from './types';
+import {
+  EXPRESSION_EDITOR_CONTRACT_VERSION,
+  type ExpressionEditorContribution,
+} from '../expression/types';
 
 const toolPanels = new Map<string, ToolPanelContribution>();
 const pages: RegisteredPage[] = [];
 const settingsTabs: RegisteredSettingsTab[] = [];
 const navEntries: RegisteredNavEntry[] = [];
+// `let`, never mutated in place: {@link ExpressionEditorsProvider} memoizes its
+// context value on this map's IDENTITY, so committing an editor must turn the
+// identity over — otherwise a field mounted on a core route (which never waits
+// for the plugin load pass) would keep the stale empty map and never grow its
+// launcher. The commit path below reassigns; nothing calls `.set` on it.
+let expressionEditors = new Map<string, ExpressionEditorContribution>();
 
 /**
  * Load one plugin: call its `register` entry with a context bound to `pluginId`,
@@ -50,6 +60,7 @@ export async function loadPlugin(pluginId: string, entry: PluginEntry): Promise<
   const stagedSettingsTabs: RegisteredSettingsTab[] = [];
   const stagedTabIds = new Set<string>();
   const stagedNavEntries: RegisteredNavEntry[] = [];
+  const stagedExpressionEditors = new Map<string, ExpressionEditorContribution>();
   let sealed = false;
 
   const context: PluginContext = {
@@ -117,6 +128,38 @@ export async function loadPlugin(pluginId: string, entry: PluginEntry): Promise<
       }
       stagedNavEntries.push({ ...contribution, pluginId });
     },
+    registerExpressionEditor(contribution: ExpressionEditorContribution): void {
+      if (sealed) {
+        throw new Error(
+          'registration is closed: a plugin must register during register(), not after it resolves',
+        );
+      }
+      // Contract-version mismatch is a LOUD per-plugin registration error, never a
+      // silent skip: an editor built against a different props contract would mount
+      // with the wrong props, so it is rejected during register() and becomes this
+      // plugin's error card. Checked before the duplicate guard so a mismatched
+      // contribution never claims a language.
+      if (contribution.contractVersion !== EXPRESSION_EDITOR_CONTRACT_VERSION) {
+        throw new Error(
+          `plugin “${pluginId}” registered an expression editor for “${contribution.language}” ` +
+            `targeting contract v${String(contribution.contractVersion)} but this host is ` +
+            `v${String(EXPRESSION_EDITOR_CONTRACT_VERSION)} — the editor must be rebuilt`,
+        );
+      }
+      // A language is a GLOBAL key: at most one editor across the deployment. A
+      // second contribution for a language already staged or committed (by this
+      // plugin or another) would leave one editor unreachable — fail loudly, as
+      // registerToolPanel does for a tool name.
+      if (
+        stagedExpressionEditors.has(contribution.language) ||
+        expressionEditors.has(contribution.language)
+      ) {
+        throw new Error(
+          `an expression editor is already registered for language ${contribution.language}`,
+        );
+      }
+      stagedExpressionEditors.set(contribution.language, contribution);
+    },
   };
 
   try {
@@ -158,11 +201,16 @@ export async function loadPlugin(pluginId: string, entry: PluginEntry): Promise<
   for (const navEntry of stagedNavEntries) {
     navEntries.push(navEntry);
   }
+  if (stagedExpressionEditors.size > 0) {
+    // Reassign (see the declaration): identity turnover is what re-notifies
+    // mounted ExpressionFields when the load pass commits an editor.
+    expressionEditors = new Map([...expressionEditors, ...stagedExpressionEditors]);
+  }
 }
 
 /** The shell reads this after loading every installed plugin bundle. */
 export function getContributions(): PluginContributions {
-  return { toolPanels, pages, settingsTabs, navEntries };
+  return { toolPanels, pages, settingsTabs, navEntries, expressionEditors };
 }
 
 /** Tests reset the module-level registry between cases. */
@@ -171,4 +219,5 @@ export function __resetContributions(): void {
   pages.length = 0;
   settingsTabs.length = 0;
   navEntries.length = 0;
+  expressionEditors = new Map();
 }

package/src/plugin/types.ts

@@ -22,6 +22,8 @@
  */
 import type { ComponentType } from 'react';
 
+import type { ExpressionEditorContribution } from '../expression/types';
+
 /**
  * A capability requirement a contribution may declare. `routes` is a list of
  * route-path prefixes (anyOf semantics, the same evaluator the shell nav uses):
@@ -193,6 +195,19 @@ export interface PluginContributions {
   readonly pages: readonly RegisteredPage[];
   readonly settingsTabs: readonly RegisteredSettingsTab[];
   readonly navEntries: readonly RegisteredNavEntry[];
+  /**
+   * The contributed expression editors, keyed by {@link ExpressionLanguage}. A
+   * language maps to at MOST one editor across the whole deployment — the registry
+   * rejects a second contribution for a language it already holds — so a field
+   * resolves its editor by language with no ambiguity. The shell reads this map and
+   * feeds it to `ExpressionEditorsProvider`; the plugin surface reaches it only
+   * through `useExpressionEditor`, never by enumerating this map.
+   *
+   * Optional in the TYPE (this host always provides it): a contributions object
+   * built against the pre-expression shape — an older host, a test double —
+   * remains a valid `PluginContributions`. Readers fall back to an empty map.
+   */
+  readonly expressionEditors?: ReadonlyMap<string, ExpressionEditorContribution>;
 }
 
 /**
@@ -218,6 +233,23 @@ export interface PluginContext {
    * registers (a nav entry with no page is a dead link and is rejected loudly).
    */
   registerNavEntry(contribution: NavEntryContribution): void;
+  /**
+   * Register the visual editor for one {@link ExpressionLanguage}, which every
+   * `ExpressionField` authoring that language then offers. A language is a GLOBAL
+   * key — at most one editor across the deployment — so a second contribution for a
+   * language already registered (by this plugin or another) is rejected loudly, as
+   * a duplicate tool panel is. A contribution whose `contractVersion` is not the
+   * host's {@link EXPRESSION_EDITOR_CONTRACT_VERSION} is likewise rejected loudly
+   * during registration — never silently skipped — so an editor built against an
+   * incompatible props contract is a visible per-plugin error, not a blank field.
+   *
+   * This method is OPTIONAL/ADDITIVE — optional in the TYPE too, so a plugin
+   * written against this SDK still typechecks against an older host context and
+   * a test double of the pre-expression context stays a valid `PluginContext`.
+   * Plugins feature-detect (`typeof context.registerExpressionEditor ===
+   * 'function'`) and no-op gracefully on hosts that predate the extension point.
+   */
+  registerExpressionEditor?(contribution: ExpressionEditorContribution): void;
 }
 
 /**

package/src/schema-editor/SchemaEditor.tsx

@@ -57,13 +57,17 @@ function seedText(value: Record<string, unknown> | null): string {
 }
 
 /**
- * Whether {@link SchemaForm} can render this schema's root — i.e. it classifies to a
- * concrete field kind rather than `unsupported`. A schema whose root the form cannot
- * render (or whose classification throws on a bad `$ref`) previews as a `JsonTree`.
+ * Whether {@link SchemaForm} can render this schema's root as a STRUCTURED form —
+ * i.e. it classifies to a concrete field kind rather than the free-form `json`
+ * fallback. A schema whose root has no structure to preview (a property-less
+ * object, an open/`allOf`/multi-type shape), or whose classification throws on a
+ * bad `$ref`, previews as a `JsonTree` of the schema dict instead. (Inside a live
+ * form such a node still renders the JSON editor; here, previewing a shapeless
+ * root as its own schema tree is the more legible affordance.)
  */
 function canRenderWithForm(schema: JsonSchema): boolean {
   try {
-    return classifySchema(schema, schema).model.kind !== 'unsupported';
+    return classifySchema(schema, schema).model.kind !== 'json';
   } catch {
     return false;
   }

package/src/schema-form/classify.ts

@@ -3,8 +3,9 @@
  * renderer and the validator classify through here so a construct is treated
  * identically everywhere. Classification resolves `$ref`, normalizes `anyOf`/
  * `oneOf` (null-union → nullable single field; multi-member → variant selector),
- * and lands every unrecognized construct on the explicit `unsupported` kind —
- * a field is never silently dropped.
+ * and lands every shape it has no structured editor for on the explicit `json`
+ * kind (a free-form JSON textarea) — a field is never silently dropped, and a
+ * shapeless one is edited as the JSON it is rather than dead-ending on a badge.
  */
 import {
   isNullSchema,
@@ -79,7 +80,18 @@ export type FieldModel =
       readonly variants: readonly UnionVariant[];
       readonly discriminator: string | undefined;
     }
-  | { readonly kind: 'unsupported'; readonly reason: string };
+  | {
+      // A shape with no structured editor to build — a property-less object, a
+      // bare `additionalProperties`-open object, an items-less array, an empty/
+      // multi-type/`allOf` schema. It is NOT undroppable: every one of these still
+      // describes JSON, so the renderer edits it as free-form JSON in a mono
+      // textarea rather than dead-ending on a badge. `jsonType` is the container
+      // the schema commits to, so a valid buffer must parse to it (`'any'` = no
+      // constraint beyond "is JSON"); `reason` records which shape fell through.
+      readonly kind: 'json';
+      readonly jsonType: 'object' | 'array' | 'any';
+      readonly reason: string;
+    };
 
 /** A fully classified field: its model plus resolved metadata. */
 export interface ClassifiedField {
@@ -120,13 +132,22 @@ function mediaUpload(schema: JsonSchema): MediaUpload | undefined {
   return undefined;
 }
 
-function unsupported(
+/**
+ * Land a shape the form has no structured editor for on the free-form JSON
+ * fallback (a mono JSON textarea) rather than a dead badge — a field is never
+ * silently dropped, and "any JSON" is the honest affordance for a shapeless one.
+ * `jsonType` is the container a valid buffer must parse to; `nullable` carries
+ * through so a nullable shape still accepts JSON `null`.
+ */
+function jsonFallback(
   schema: JsonSchema,
+  jsonType: 'object' | 'array' | 'any',
   reason: string,
   title: string | undefined,
   description: string | undefined,
+  nullable = false,
 ): ClassifiedField {
-  return { model: { kind: 'unsupported', reason }, nullable: false, schema, title, description };
+  return { model: { kind: 'json', jsonType, reason }, nullable, schema, title, description };
 }
 
 /**
@@ -139,11 +160,14 @@ export function classifySchema(raw: JsonSchema, root: JsonSchema): ClassifiedFie
   const title = firstString(raw.title, resolved.title);
   const description = firstString(raw.description, resolved.description);
 
-  // const pins a single value.
+  // const pins a single value. Null-acceptance is fully decidable here: the one
+  // permitted value either IS null or it is not. Without this, a `const: null`
+  // field would seed to null and then fail the validator's upstream "must not be
+  // null" gate before the equality check ever ran — permanently invalid.
   if ('const' in resolved) {
     return {
       model: { kind: 'const', value: resolved.const },
-      nullable: false,
+      nullable: resolved.const === null,
       schema: resolved,
       title,
       description,
@@ -167,7 +191,16 @@ export function classifySchema(raw: JsonSchema, root: JsonSchema): ClassifiedFie
     const nullable = nonNull.length !== members.length;
     const soleNonNull = nonNull[0];
     if (soleNonNull === undefined) {
-      return unsupported(resolved, 'union with no non-null members', title, description);
+      // Every member is `null` — degenerate, but `null` is still valid, so edit
+      // it as JSON (nullable) rather than dead-ending on a badge.
+      return jsonFallback(
+        resolved,
+        'any',
+        'union with no non-null members',
+        title,
+        description,
+        true,
+      );
     }
     if (nonNull.length === 1) {
       const inner = classifySchema(soleNonNull, root);
@@ -216,7 +249,19 @@ export function classifySchema(raw: JsonSchema, root: JsonSchema): ClassifiedFie
         description: description ?? inner.description,
       };
     }
-    return unsupported(resolved, 'allOf intersection of multiple schemas', title, description);
+    // Whether the intersection accepts `null` is not statically decidable here
+    // (it does iff EVERY member does), and the json escape hatch only enforces
+    // what it KNOWS — so stay permissive like `jsonType: 'any'` itself and let
+    // the server-side contract be the authority, rather than rejecting a null
+    // the schema may well permit (e.g. an intersection of open schemas).
+    return jsonFallback(
+      resolved,
+      'any',
+      'allOf intersection of multiple schemas',
+      title,
+      description,
+      true,
+    );
   }
 
   // Type-driven classification.
@@ -225,20 +270,41 @@ export function classifySchema(raw: JsonSchema, root: JsonSchema): ClassifiedFie
   const nullableByType = nonNullTypes.length !== types.length;
 
   if (nonNullTypes.length === 0) {
-    return unsupported(resolved, 'schema declares no renderable type', title, description);
+    // No `type` at all (an open `{}` schema, or `type: "null"` alone) accepts any
+    // JSON — the classic "any" field. Edit it as free-form JSON. Nullable is
+    // always true here: `type: "null"` declares it, and an open schema with no
+    // type keyword permits null like any other value (`nullableByType` would say
+    // false for it only because there is no type list to find "null" in).
+    return jsonFallback(
+      resolved,
+      'any',
+      'schema declares no renderable type',
+      title,
+      description,
+      true,
+    );
   }
   if (nonNullTypes.length > 1) {
-    return unsupported(
+    return jsonFallback(
       resolved,
+      'any',
       `multiple JSON types (${nonNullTypes.join(', ')}) without a discriminator`,
       title,
       description,
+      nullableByType,
     );
   }
 
   const type = nonNullTypes[0];
   if (type === undefined) {
-    return unsupported(resolved, 'schema declares no renderable type', title, description);
+    return jsonFallback(
+      resolved,
+      'any',
+      'schema declares no renderable type',
+      title,
+      description,
+      nullableByType,
+    );
   }
   switch (type) {
     case 'string':
@@ -275,7 +341,16 @@ export function classifySchema(raw: JsonSchema, root: JsonSchema): ClassifiedFie
       };
     case 'array': {
       if (resolved.items === undefined) {
-        return unsupported(resolved, 'array without an items schema', title, description);
+        // A bare array with no item schema: no per-item editor to build, but the
+        // value is still a JSON array — edit it whole as free-form JSON.
+        return jsonFallback(
+          resolved,
+          'array',
+          'array without an items schema',
+          title,
+          description,
+          nullableByType,
+        );
       }
       return {
         model: { kind: 'array', items: resolved.items },
@@ -289,8 +364,9 @@ export function classifySchema(raw: JsonSchema, root: JsonSchema): ClassifiedFie
       if (resolved.properties === undefined) {
         // A free-form object typed by a VALUE SCHEMA (`additionalProperties` is a
         // schema, not `false`/`true`/absent) is a string→X map — renderable as
-        // key/value rows. A boolean `additionalProperties` carries no value type
-        // to build an entry editor from, so it stays unsupported.
+        // key/value rows. A boolean/absent `additionalProperties` carries no value
+        // type to build an entry editor from, so it falls through to the free-form
+        // JSON editor (constrained to a JSON object).
         // Read as `unknown`: the value is parsed JSON, where `additionalProperties:
         // null` is possible and `typeof null === 'object'` would otherwise classify
         // it as a record with a `null` value schema.
@@ -304,11 +380,13 @@ export function classifySchema(raw: JsonSchema, root: JsonSchema): ClassifiedFie
             description,
           };
         }
-        return unsupported(
+        return jsonFallback(
           resolved,
-          'free-form object (additionalProperties map) is not supported',
+          'object',
+          'free-form object with no property schema',
           title,
           description,
+          nullableByType,
         );
       }
       const properties: (readonly [string, JsonSchema])[] = Object.entries(resolved.properties);
@@ -322,6 +400,13 @@ export function classifySchema(raw: JsonSchema, root: JsonSchema): ClassifiedFie
       };
     }
     default:
-      return unsupported(resolved, `unrecognized type "${String(type)}"`, title, description);
+      return jsonFallback(
+        resolved,
+        'any',
+        `unrecognized type "${String(type)}"`,
+        title,
+        description,
+        nullableByType,
+      );
   }
 }

package/src/schema-form/default-value.ts

@@ -61,7 +61,10 @@ export function defaultValueForSchema(schema: JsonSchema, root: JsonSchema = sch
     case 'number':
     case 'boolean':
     case 'union':
-    case 'unsupported':
+    case 'json':
+      // A free-form JSON field starts ABSENT (its editor seeds an empty buffer),
+      // like the other value-less kinds: an optional one never invents a value,
+      // and a required one is left absent so validation flags it.
       return undefined;
   }
 }

package/src/schema-form/field-node.tsx

@@ -13,12 +13,12 @@ import { ArrayField } from './array-field';
 import { classifySchema } from './classify';
 import { EnumField } from './enum-field';
 import { FieldGroup } from './field-group';
+import { JsonField } from './json-field';
 import { ObjectFields } from './object-fields';
 import { RecordField } from './record-field';
 import { scalarLabel } from './resolve';
 import { StringField } from './string-field';
 import { UnionField } from './union-field';
-import { UnsupportedNotice } from './unsupported-notice';
 import type { JsonSchema, SchemaFormErrors } from './types';
 
 interface FieldNodeProps {
@@ -48,13 +48,16 @@ export function FieldNode(props: FieldNodeProps): ReactNode {
   const model = classified.model;
 
   switch (model.kind) {
-    case 'unsupported':
+    case 'json':
       return (
-        <UnsupportedNotice
+        <JsonField
           heading={heading}
-          reason={model.reason}
           description={description}
           error={error}
+          jsonType={model.jsonType}
+          nullable={classified.nullable}
+          value={value}
+          onChange={onChange}
         />
       );
     case 'const':

package/src/schema-form/json-field.tsx

@@ -0,0 +1,143 @@
+/**
+ * The free-form JSON field: the honest editor for a schema node the form has no
+ * STRUCTURED control for — a property-less object, a bare `additionalProperties`-
+ * open object, an items-less array, an empty/multi-type/`allOf` shape. Rather than
+ * dead-end on an "Unsupported" badge (a value the user can see but not set), it
+ * offers a mono textarea seeded with the current value pretty-printed and commits
+ * the PARSED value through the same `onChange` a structured field uses.
+ *
+ * Validation is LOUD and local: the buffer must parse as JSON, and — when the
+ * schema commits to a container (`jsonType` `'object'`/`'array'`) — the parsed
+ * value must be that container. An invalid buffer shows an inline error and does
+ * NOT commit, so a half-typed edit never writes a broken value through; the last
+ * committed value stands until the buffer is valid again.
+ *
+ * The buffer is LOCAL state (an invalid buffer has no committed value to derive
+ * from), resynced only when a DIFFERENT value arrives from the parent — the same
+ * `lastEmitted` guard `record-field` uses, so a parent echoing our own commit back
+ * does not clobber what is being typed.
+ */
+import { useRef, useState } from 'react';
+import type { ReactNode } from 'react';
+
+import { Field } from '../components/field';
+import { Textarea } from '../components/inputs';
+import { errorMessage } from '../errors';
+
+/** The JSON container a `json` field commits to (see `classify`). */
+type JsonType = 'object' | 'array' | 'any';
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** The current value as textarea text: pretty-printed JSON, or empty for absent. */
+function serialize(value: unknown): string {
+  return value === undefined ? '' : JSON.stringify(value, null, 2);
+}
+
+/**
+ * The container constraint on a PARSED buffer, or `null` when it satisfies the
+ * schema. `null` (the JSON literal) is rejected only when the schema is not
+ * nullable — matching `validateAgainstSchema`, so the inline check and the
+ * pre-submit check agree.
+ */
+function containerError(value: unknown, jsonType: JsonType, nullable: boolean): string | null {
+  if (value === null) return nullable ? null : 'Must not be null.';
+  if (jsonType === 'object' && !isPlainObject(value)) {
+    return 'Must be a JSON object (e.g. {"key": "value"}).';
+  }
+  if (jsonType === 'array' && !Array.isArray(value)) {
+    return 'Must be a JSON array (e.g. [1, 2, 3]).';
+  }
+  return null;
+}
+
+/** The muted hint's leading noun, so the user knows what a valid buffer must be. */
+function hintNoun(jsonType: JsonType): string {
+  if (jsonType === 'object') return 'JSON object';
+  if (jsonType === 'array') return 'JSON array';
+  return 'JSON';
+}
+
+export function JsonField({
+  heading,
+  description,
+  error,
+  jsonType,
+  nullable,
+  value,
+  onChange,
+}: {
+  heading: string;
+  description: string | undefined;
+  error: string | undefined;
+  jsonType: JsonType;
+  nullable: boolean;
+  value: unknown;
+  onChange: (value: unknown) => void;
+}): ReactNode {
+  // The last value THIS field emitted. A parent echoing our own commit back
+  // passes it identity-equal, so the buffer (which may hold an invalid, un-
+  // committed edit) survives; a parent that swaps in a different value resyncs it.
+  const lastEmitted = useRef<unknown>(value);
+  const [buffer, setBuffer] = useState<string>(() => serialize(value));
+  const [parseError, setParseError] = useState<string | null>(null);
+  if (value !== lastEmitted.current) {
+    lastEmitted.current = value;
+    setBuffer(serialize(value));
+    setParseError(null);
+  }
+
+  const commit = (next: unknown): void => {
+    lastEmitted.current = next;
+    onChange(next);
+  };
+
+  const handleChange = (text: string): void => {
+    setBuffer(text);
+    // An empty buffer drops the value (emits `undefined`) — the same "absent
+    // optional" affordance a cleared text field gives; a required field's
+    // absence is then flagged by the pre-submit validator, not invented here.
+    if (text.trim() === '') {
+      setParseError(null);
+      commit(undefined);
+      return;
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(text);
+    } catch (thrown) {
+      // Invalid JSON: surface it, and DO NOT commit — the last valid value stands.
+      setParseError(`Invalid JSON: ${errorMessage(thrown)}`);
+      return;
+    }
+    const container = containerError(parsed, jsonType, nullable);
+    if (container !== null) {
+      setParseError(container);
+      return;
+    }
+    setParseError(null);
+    commit(parsed);
+  };
+
+  return (
+    <Field label={heading} description={description} error={parseError ?? error}>
+      <Textarea
+        value={buffer}
+        onChange={(event) => {
+          handleChange(event.target.value);
+        }}
+        rows={6}
+        aria-label={`${heading} JSON`}
+        className="tai-textarea-mono"
+        spellCheck={false}
+      />
+      {/* A muted hint, never an error: the field is USABLE, it just has no
+          structured schema to build a richer control from. */}
+      <p className="tai-field-hint" style={{ margin: 0 }}>
+        {`free-form ${hintNoun(jsonType)} — this field has no structured schema`}
+      </p>
+    </Field>
+  );
+}

package/src/schema-form/types.ts

@@ -3,8 +3,8 @@
  * is deliberately PERMISSIVE — every field is optional and an open index
  * signature admits unknown keywords — because the schemas come from Pydantic v2
  * and may carry constructs the renderer does not consume. Unknown keys never
- * break typing; the renderer classifies a node and surfaces anything it cannot
- * render as a LOUD "unsupported field" notice rather than dropping it.
+ * break typing; the renderer classifies a node and, for a shape it has no
+ * structured control for, offers a free-form JSON editor rather than dropping it.
  */
 
 /** The JSON-Schema `type` keyword values Pydantic emits. */

package/src/schema-form/validate.ts

@@ -1,8 +1,8 @@
 /**
  * `validateAgainstSchema` — a loud, structured pre-submit check. It walks the
  * schema against a value and returns a path-keyed `SchemaFormErrors` bag:
- * required-presence, type/format mismatches, enum/const violations, and any
- * `unsupported` construct (surfaced, never hidden). It never throws on a
+ * required-presence, type/format mismatches, enum/const violations, and the
+ * container constraint on a free-form `json` field. It never throws on a
  * malformed value — a malformed value IS the error it reports.
  */
 import { classifySchema } from './classify';
@@ -75,8 +75,14 @@ function walk(
 
   const { model } = classified;
   switch (model.kind) {
-    case 'unsupported':
-      errors[path] = `unsupported schema (${model.reason})`;
+    case 'json':
+      // A free-form JSON field: any JSON is accepted, subject only to the
+      // container the schema commits to (mirrors the renderer's inline check).
+      if (model.jsonType === 'object' && !isPlainObject(value)) {
+        errors[path] = 'must be a JSON object';
+      } else if (model.jsonType === 'array' && !Array.isArray(value)) {
+        errors[path] = 'must be a JSON array';
+      }
       return;
     case 'const':
       if (value !== model.value) errors[path] = `must equal ${scalarLabel(model.value)}`;

package/dist/schema-form/unsupported-notice.d.ts

@@ -1,18 +0,0 @@
-/**
- * The notice rendered for a schema node the form cannot turn into an input: a
- * warning badge — a mark beside its label, so the meaning never rests on the
- * tint alone — followed by the reason, shown inside a labelled field.
- *
- * The three parts each say ONE thing once. The `Field` prints the heading, the
- * `Badge` prints the state, and the hint prints the REASON alone — repeating
- * either of the first two there would name the field twice and the state twice,
- * in a developer-log register on a surface a user reads.
- */
-import type { ReactNode } from 'react';
-export declare function UnsupportedNotice({ heading, reason, description, error, }: {
-    heading: string;
-    reason: string;
-    description: string | undefined;
-    error: string | undefined;
-}): ReactNode;
-//# sourceMappingURL=unsupported-notice.d.ts.map

package/dist/schema-form/unsupported-notice.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unsupported-notice.d.ts","sourceRoot":"","sources":["../../src/schema-form/unsupported-notice.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAMvC,wBAAgB,iBAAiB,CAAC,EAChC,OAAO,EACP,MAAM,EACN,WAAW,EACX,KAAK,GACN,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,GAAG,SAAS,CAYZ"}

package/dist/schema-form/unsupported-notice.js

@@ -1,8 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Badge } from '../components/badge';
-import { Field } from '../components/field';
-import { AlertTriangleIcon } from '../components/icons';
-export function UnsupportedNotice({ heading, reason, description, error, }) {
-    return (_jsx(Field, { label: heading, description: description, error: error, group: true, children: _jsxs("div", { role: "alert", className: "tai-row", children: [_jsxs(Badge, { variant: "warning", children: [_jsx(AlertTriangleIcon, {}), "Unsupported"] }), _jsx("span", { className: "tai-field-hint", children: reason })] }) }));
-}
-//# sourceMappingURL=unsupported-notice.js.map

package/dist/schema-form/unsupported-notice.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unsupported-notice.js","sourceRoot":"","sources":["../../src/schema-form/unsupported-notice.tsx"],"names":[],"mappings":";AAYA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,UAAU,iBAAiB,CAAC,EAChC,OAAO,EACP,MAAM,EACN,WAAW,EACX,KAAK,GAMN;IACC,OAAO,CACL,KAAC,KAAK,IAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,kBAClE,eAAK,IAAI,EAAC,OAAO,EAAC,SAAS,EAAC,SAAS,aACnC,MAAC,KAAK,IAAC,OAAO,EAAC,SAAS,aACtB,KAAC,iBAAiB,KAAG,mBAEf,EACR,eAAM,SAAS,EAAC,gBAAgB,YAAE,MAAM,GAAQ,IAC5C,GACA,CACT,CAAC;AACJ,CAAC"}