@tai42/studio-sdk 6.2.0 → 7.0.0

package/src/expression/ExpressionField.tsx

@@ -0,0 +1,330 @@
+/**
+ * `ExpressionField` — the SDK's expression-authoring control. It is a plain SDK
+ * text field (a `Field` wrapping a `Textarea`, or a `TextInput` when
+ * `multiline={false}`) that GROWS a "visual editor" affordance only when a plugin
+ * has contributed an editor for the field's language. With no editor registered —
+ * or no {@link ExpressionEditorsProvider} mounted above it — it stays exactly a
+ * text field, so a consumer adopts it with no dependency on any editor being
+ * installed (graceful absence).
+ *
+ * The launcher half — the button that lazily loads the editor behind `Suspense`,
+ * warms its chunk on open-intent, and turns a `load()` rejection into a loud
+ * inline error — is the standalone {@link ExpressionEditorLauncher}, exported so a
+ * dense grid can compose its OWN input + an icon-only door in one row and reuse
+ * this exact mount semantics rather than reimplementing them. `ExpressionField`
+ * consumes that same component internally, so there is one source of truth for how
+ * an editor is mounted.
+ *
+ * The interaction is ported from babelfish's `jq-editor-button.tsx` but styled
+ * with SDK primitives and generalised to any {@link ExpressionLanguage}: the
+ * whole {@link ExpressionFieldDeclaration} threads onto the editor, so its context
+ * chip, Test seeding, and server-validate hook all read from one object, and each
+ * degrades on its own when absent.
+ */
+import {
+  Suspense,
+  lazy,
+  useMemo,
+  useState,
+  type InputHTMLAttributes,
+  type ReactElement,
+  type ReactNode,
+  type TextareaHTMLAttributes,
+} from 'react';
+
+import { Button, Spinner } from '../components/primitives';
+import { ErrorBoundary } from '../components/error-boundary';
+import { Field } from '../components/field';
+import { TextInput, Textarea } from '../components/inputs';
+import { GridIcon } from '../components/icons';
+
+import { useExpressionEditor } from './context';
+import type { ExpressionFieldDeclaration } from './types';
+
+/**
+ * The native attributes {@link ExpressionField} FORWARDS to its underlying control
+ * (`Textarea` or, single-line, `TextInput`), minus the ones the field owns itself.
+ * Intersecting both attribute sets keeps the pass-through valid whichever element
+ * `multiline` selects, and omitting the owned keys keeps a caller from
+ * accidentally severing the value/edit wiring or the monospace class. This is the
+ * `inputs.tsx` pass-through doctrine (a caller's native attribute reaches the
+ * element) narrowed to what a field can safely surrender — `name`, `onBlur`,
+ * `maxLength`, `style`, `data-*`, and the like.
+ */
+export type ExpressionControlProps = Omit<
+  TextareaHTMLAttributes<HTMLTextAreaElement> & InputHTMLAttributes<HTMLInputElement>,
+  | 'value'
+  | 'onChange'
+  | 'disabled'
+  | 'rows'
+  | 'placeholder'
+  | 'className'
+  | 'spellCheck'
+  | 'children'
+>;
+
+export interface ExpressionEditorLauncherProps {
+  /** What language the field authors, what its input is, and how to sample/validate it. */
+  readonly declaration: ExpressionFieldDeclaration;
+  /** The field's current expression ('' when unset), the editor seeds itself with. */
+  readonly value: string;
+  /** Called with the authored expression when the user saves in the editor. */
+  readonly onSave: (expression: string) => void;
+  /** The label the editor titles itself with; also enriches the launcher's name. */
+  readonly fieldLabel: string;
+  /** Icon-only launcher for narrow rows; the full name rides `aria-label`. */
+  readonly compact?: boolean;
+  /**
+   * Open the editor READ-ONLY (no Save). This is the launcher's ONLY blocking knob:
+   * a launcher has no inline textarea to disable, so — unlike {@link ExpressionField}'s
+   * `disabled`, which conflates textarea-disabled with editor-read-only — the door
+   * expresses author-blocking solely here. {@link ExpressionField} maps its own
+   * `disabled` onto this by default, and its `editorReadOnly` overrides that.
+   */
+  readonly editorReadOnly?: boolean;
+  /**
+   * Override the launcher's hover `title` (e.g. a rerun/side-effect hint). Absent,
+   * the title is derived from the declaration's shape ("Visual editor · input: …").
+   */
+  readonly title?: string;
+}
+
+/**
+ * The launcher + lazily-loaded editor for one expression field, standalone so a
+ * compact grid can drop it beside its own input. It resolves the contributed
+ * editor for `declaration.language` itself and renders NOTHING when none is
+ * registered (or no {@link ExpressionEditorsProvider} is mounted) — the same
+ * graceful absence {@link ExpressionField} degrades to a plain text field on.
+ */
+export function ExpressionEditorLauncher({
+  declaration,
+  value,
+  onSave,
+  fieldLabel,
+  compact = false,
+  editorReadOnly = false,
+  title,
+}: ExpressionEditorLauncherProps): ReactElement | null {
+  const contribution = useExpressionEditor(declaration.language);
+  const [open, setOpen] = useState(false);
+
+  // A fresh lazy wrapper per contribution: the module resolves once and React
+  // caches it, so re-opening the editor does not re-fetch the chunk.
+  const LazyEditor = useMemo(
+    () =>
+      contribution === null
+        ? null
+        : lazy(() => contribution.load().then((module) => ({ default: module.Editor }))),
+    [contribution],
+  );
+
+  if (contribution === null || LazyEditor === null) return null;
+
+  // Warm the chunk on OPEN-INTENT (hover/focus) and again on click, both
+  // best-effort: a preload that throws must never block opening the editor, whose
+  // own lazy import stays the loud path if the module genuinely cannot load.
+  const warm = (): void => {
+    contribution.preload?.();
+  };
+
+  const shapeLabel = declaration.shape?.label;
+  const openLabel = shapeLabel
+    ? `Open the visual editor for ${fieldLabel} (input: ${shapeLabel})`
+    : `Open the visual editor for ${fieldLabel}`;
+  const resolvedTitle =
+    title ?? (shapeLabel ? `Visual editor · input: ${shapeLabel}` : 'Visual editor');
+
+  return (
+    <>
+      <Button
+        type="button"
+        variant="secondary"
+        onClick={() => {
+          warm();
+          setOpen(true);
+        }}
+        onMouseEnter={warm}
+        onFocus={warm}
+        aria-label={openLabel}
+        title={resolvedTitle}
+      >
+        <GridIcon aria-hidden />
+        {compact ? null : ' Visual editor'}
+      </Button>
+      {open ? (
+        // A load() rejection throws through Suspense on render; the boundary turns
+        // it into a loud inline error where the editor would have appeared rather
+        // than blanking the field around it.
+        <ErrorBoundary label="Visual editor">
+          <Suspense fallback={<Spinner label="Loading the visual editor" />}>
+            <LazyEditor
+              declaration={declaration}
+              open
+              initialExpression={value}
+              fieldLabel={fieldLabel}
+              readOnly={editorReadOnly}
+              onSave={(expression) => {
+                onSave(expression);
+                setOpen(false);
+              }}
+              onClose={() => {
+                setOpen(false);
+              }}
+            />
+          </Suspense>
+        </ErrorBoundary>
+      ) : null}
+    </>
+  );
+}
+
+export interface ExpressionFieldProps {
+  /** The `Field` label; also the editor's title unless {@link fieldLabel} overrides it. */
+  readonly label: string;
+  /**
+   * Render the label for assistive tech only (visually hidden) — for a dense grid
+   * of otherwise-identical expression rows that each need a unique, addressable
+   * name but have no room for a visible label. The `label` text is still the
+   * accessible name (see {@link Field.hideLabel}).
+   */
+  readonly hideLabel?: boolean;
+  /** Optional field description rendered under the control. */
+  readonly description?: string;
+  /** Optional error rendered under the control (also flags the field invalid). */
+  readonly error?: string;
+  /** What language the field authors, what its input is, and how to sample/validate it. */
+  readonly declaration: ExpressionFieldDeclaration;
+  /** The field's current expression ('' when unset). */
+  readonly value: string;
+  /** Called with the new expression on both textarea edits and an editor save. */
+  readonly onChange: (expression: string) => void;
+  /**
+   * Disables INLINE editing (the textarea/input is `disabled`). By default it also
+   * opens the editor read-only, so a blocked value can still be inspected; pass
+   * {@link editorReadOnly} to decouple the two.
+   */
+  readonly disabled?: boolean;
+  /**
+   * Whether the visual editor opens READ-ONLY, independent of {@link disabled}.
+   * Defaults to `disabled` — the historical coupling — so a caller that never sets
+   * it keeps today's behaviour. Set it `false` to let the editor author a value
+   * whose textarea is disabled, or `true` to lock the editor while the textarea
+   * stays editable.
+   */
+  readonly editorReadOnly?: boolean;
+  /** Icon-only launcher for narrow rows; the full name rides `aria-label`. */
+  readonly compact?: boolean;
+  /** The label the editor titles itself with; defaults to {@link label}. */
+  readonly fieldLabel?: string;
+  /**
+   * Author the field on a SINGLE line — a `TextInput` instead of a `Textarea` —
+   * for a per-argument grid row. Defaults to `true` (multiline). The visual-editor
+   * launcher is unaffected.
+   */
+  readonly multiline?: boolean;
+  /**
+   * Render the expression content in the design system's monospace face. Defaults
+   * to TRUE: an expression is code, and code reads in a mono font (jq filters,
+   * paths, and operators align and disambiguate `l`/`1`/`I` there) — the same face
+   * every jq surface in the ecosystem paints. A prose-ish field can opt out with
+   * `false`.
+   */
+  readonly monospace?: boolean;
+  /**
+   * Override the launcher button's hover `title` (e.g. a rerun/side-effect hint),
+   * threaded to {@link ExpressionEditorLauncher.title}.
+   */
+  readonly launcherTitle?: string;
+  /** Textarea row count (defaults to the SDK `Textarea` default); ignored when single-line. */
+  readonly rows?: number;
+  /** Textarea/input placeholder. */
+  readonly placeholder?: string;
+  /**
+   * Narrow native-attribute pass-through to the underlying control — `name`,
+   * `onBlur`, `maxLength`, `style`, `data-*`, and the like. The field owns
+   * value/onChange/disabled/rows/placeholder/spellCheck and the monospace class, so
+   * those are not forwardable (see {@link ExpressionControlProps}).
+   */
+  readonly textareaProps?: ExpressionControlProps;
+}
+
+export function ExpressionField({
+  label,
+  hideLabel = false,
+  description,
+  error,
+  declaration,
+  value,
+  onChange,
+  disabled = false,
+  editorReadOnly,
+  compact = false,
+  fieldLabel,
+  multiline = true,
+  monospace = true,
+  launcherTitle,
+  rows,
+  placeholder,
+  textareaProps,
+}: ExpressionFieldProps): ReactElement {
+  const contribution = useExpressionEditor(declaration.language);
+
+  const monoClassName = monospace
+    ? multiline
+      ? 'tai-textarea-mono'
+      : 'tai-input-mono'
+    : undefined;
+
+  // The editor's read-only state is INDEPENDENT of the textarea's disabled state,
+  // but defaults to it so the historical coupling holds for a caller that never
+  // asks for the two to differ.
+  const resolvedEditorReadOnly = editorReadOnly ?? disabled;
+
+  const control: ReactNode = multiline ? (
+    <Textarea
+      {...textareaProps}
+      value={value}
+      onChange={(event) => {
+        onChange(event.target.value);
+      }}
+      disabled={disabled}
+      spellCheck={false}
+      rows={rows}
+      placeholder={placeholder}
+      className={monoClassName}
+    />
+  ) : (
+    <TextInput
+      {...textareaProps}
+      value={value}
+      onChange={(event) => {
+        onChange(event.target.value);
+      }}
+      disabled={disabled}
+      spellCheck={false}
+      placeholder={placeholder}
+      className={monoClassName}
+    />
+  );
+
+  return (
+    <Field label={label} hideLabel={hideLabel} description={description} error={error}>
+      {control}
+      {contribution !== null ? (
+        <div
+          style={{ display: 'flex', justifyContent: 'flex-end', marginTop: 'var(--tai-space-2)' }}
+        >
+          <ExpressionEditorLauncher
+            declaration={declaration}
+            value={value}
+            onSave={onChange}
+            fieldLabel={fieldLabel ?? label}
+            compact={compact}
+            editorReadOnly={resolvedEditorReadOnly}
+            title={launcherTitle}
+          />
+        </div>
+      ) : null}
+    </Field>
+  );
+}

package/src/expression/context.tsx

@@ -0,0 +1,83 @@
+/**
+ * The consumption bridge for contributed expression editors: the SHELL reads the
+ * committed contributions from `@tai42/studio-sdk/host` and mounts
+ * {@link ExpressionEditorsProvider} high in the tree, so both host features and
+ * plugin pages resolve an editor for a language through {@link useExpressionEditor}.
+ *
+ * WHY A CONTEXT AND NOT A DIRECT REGISTRY READ: the contribution registry lives in
+ * the host-only `@tai42/studio-sdk/host` module, which the plugin surface
+ * deliberately cannot import — a served plugin bundle must not be able to forge,
+ * wipe, or ENUMERATE the registry. React itself is the one import-map singleton
+ * both bundles share (the shell externalises `react` and `@tai42/studio-sdk`), so a
+ * context provided by the host reaches a plugin page's render. The provider carries
+ * the editors as a private context value the plugin surface never exports, and the
+ * only door through it is {@link useExpressionEditor}, which resolves ONE language
+ * to ONE contribution. A plugin can look up the editor for its own field and no
+ * more: it cannot list the languages, count the editors, or mutate the set.
+ *
+ * ABSENT PROVIDER IS A FIRST-CLASS STATE: a field rendered with no provider above
+ * it (a host that never wired the bridge, a test that mounts a field bare) resolves
+ * `null` and degrades to a plain text field. That is the graceful-absence contract
+ * {@link ExpressionField} relies on, so the hook returns `null` rather than throwing.
+ */
+import { createContext, createElement, useContext, useMemo, type ReactNode } from 'react';
+
+import type { ExpressionEditorContribution, ExpressionLanguage } from './types';
+
+/**
+ * The provider's private value: a language → contribution lookup. Held as a
+ * function, not the raw map, so even the context value hands a consumer nothing to
+ * iterate — the sole operation is resolve-one-language. The context is module-local
+ * and never exported, so a plugin bundle cannot read it directly either.
+ */
+type EditorLookup = (language: ExpressionLanguage) => ExpressionEditorContribution | null;
+
+const ExpressionEditorsContext = createContext<EditorLookup | null>(null);
+
+export interface ExpressionEditorsProviderProps {
+  /**
+   * The committed editor contributions, keyed by language — exactly the shell's
+   * `getContributions().expressionEditors`. Passed as the read-only map it already
+   * is; the provider never mutates or re-exposes it, and wraps it in a lookup so a
+   * consumer can only resolve, never enumerate.
+   */
+  readonly editors: ReadonlyMap<string, ExpressionEditorContribution>;
+  readonly children: ReactNode;
+}
+
+/**
+ * Publishes the contributed editors to the subtree as a lookup. The shell mounts
+ * this once, above both the host feature routes and the plugin pages, with the
+ * host registry's `expressionEditors` map. Re-rendering with a new `editors` map
+ * (the load pass completing) updates every consumer.
+ */
+export function ExpressionEditorsProvider({
+  editors,
+  children,
+}: ExpressionEditorsProviderProps): ReactNode {
+  // Memoised on the `editors` map so the context value keeps a STABLE identity
+  // across re-renders that do not change the map — a new closure every render would
+  // re-notify every consumer that reads the context (every mounted field) for
+  // nothing. The identity turns over exactly when the map does (the load pass
+  // committing a new editor), which is the one time consumers must re-resolve.
+  const lookup = useMemo<EditorLookup>(
+    () => (language) => editors.get(language) ?? null,
+    [editors],
+  );
+  return createElement(ExpressionEditorsContext.Provider, { value: lookup }, children);
+}
+
+/**
+ * Resolve the contributed editor for one expression language, or `null` when none
+ * is registered OR no {@link ExpressionEditorsProvider} is mounted above the caller.
+ * This is the ONLY way a plugin surface reaches a contributed editor: it cannot
+ * enumerate or mutate the registry, only ask for one language. `null` is the
+ * graceful-absence signal {@link ExpressionField} renders a plain text field on.
+ */
+export function useExpressionEditor(
+  language: ExpressionLanguage,
+): ExpressionEditorContribution | null {
+  const lookup = useContext(ExpressionEditorsContext);
+  if (lookup === null) return null;
+  return lookup(language);
+}

package/src/expression/types.ts

@@ -0,0 +1,164 @@
+/**
+ * The SDK's AGNOSTIC expression-field vocabulary: the language-neutral graduation
+ * of babelfish jq-studio's field-declaration surface into the platform SDK, so any
+ * Studio consumer (a flow product, a tai42 feature, a third-party plugin) can
+ * declare an expression field the SAME way and any plugin can contribute the
+ * editor that authors it.
+ *
+ * A host declares an expression field through these generic types — a language
+ * tag, a DESCRIPTOR of what the expression's input document IS (not an enum of
+ * shapes the editor hard-codes), a sample-input provider, and a pluggable
+ * server-validate hook. Nothing here names anything product-specific, so the same
+ * SDK serves flows' node/tool-result envelopes and tai42's webhook-body /
+ * auth-context / tool-result shapes without a type change. babelfish's flows
+ * adapter retypes its own envelopes onto these; the descriptor fields are kept
+ * isomorphic to jq-studio's `JqInputShapeDescriptor` so that mapping is a rename,
+ * not a reshape.
+ *
+ * The editor itself is NOT in the SDK — it is a plugin CONTRIBUTION
+ * ({@link ExpressionEditorContribution}), lazily loaded across the plugin
+ * boundary. This module is the shared contract both sides retype against.
+ */
+import type { ComponentType } from 'react';
+
+/**
+ * The expression language an expression field authors. `'jq'` is the only language
+ * that exists today; the tag is an OPEN string union so a host (or a later plugin)
+ * can name another pipeline language without a change to this type. The literal
+ * keeps `'jq'` on the autocomplete list while `string` keeps the union open.
+ */
+export type ExpressionLanguage = 'jq' | (string & {});
+
+/**
+ * One top-level key of the expression's input document, with a one-line gloss the
+ * editor may surface (a context chip, an input-node body, path suggestions).
+ * Graduated from jq-studio's `JqInputKey`.
+ */
+export interface ExpressionInputKey {
+  readonly name: string;
+  readonly gloss: string;
+}
+
+/**
+ * A descriptor of what the expression's input document IS for a field — the shape
+ * the expression receives as its root. Deliberately open: a host builds these from
+ * its own domain, so ANY envelope is expressible, including ones the editor has
+ * never heard of. The `id` is an opaque, host-namespaced string used only for
+ * memoisation/telemetry. Graduated from jq-studio's `JqInputShapeDescriptor` with
+ * every field isomorphic, so the flows adapter maps its `JQType` onto this without
+ * reshaping.
+ */
+export interface ExpressionShapeDescriptor {
+  /** Stable, host-namespaced id (opaque to the editor). */
+  readonly id: string;
+  /** Short chip label — what the input is here, e.g. "node envelope". */
+  readonly label: string;
+  /** One sentence: what the input document is in this field. */
+  readonly blurb: string;
+  /** The top-level keys of the input document, each with a one-liner. */
+  readonly keys: readonly ExpressionInputKey[];
+  /** What the expression must RETURN, e.g. "true or false" | "an object". */
+  readonly returns: string;
+  /** Per-field caveats (e.g. ".iterate.item is always null in a while condition"). */
+  readonly caveats?: readonly string[];
+  /** A static skeleton of the input document — the cheap, honest default a Test
+   *  panel seeds its input with. A host may override it dynamically through the
+   *  declaration's {@link ExpressionSampleInputProvider}. */
+  readonly sample?: unknown;
+}
+
+/** A provider of a concrete sample input for the editor's Test panel. A function
+ *  (not a value) so a host can supply a static skeleton now and a live sample
+ *  later without changing this API. Graduated from jq-studio's
+ *  `SampleInputProvider`. */
+export type ExpressionSampleInputProvider = () => unknown;
+
+/** The answer a pluggable validator gives for an expression against its declared
+ *  shape. Mirrors babelfish `validate_jq`'s result WITHOUT importing its types, so
+ *  the hook stays host-agnostic. */
+export interface ExpressionValidationResult {
+  readonly ok: boolean;
+  readonly compiles?: boolean;
+  readonly singleEmit?: boolean;
+  readonly message?: string;
+}
+
+/** A pluggable server-validate hook. The editor calls it with the current
+ *  expression and the sample input; the host routes it to its own validator (flows
+ *  wires babelfish's `validate_jq` endpoint here). Absent = no server validation
+ *  (a local runtime may still power the Test panel). Graduated from jq-studio's
+ *  `ServerValidateHook`. */
+export type ExpressionServerValidate = (args: {
+  readonly expression: string;
+  readonly sampleInput: unknown;
+}) => Promise<ExpressionValidationResult>;
+
+/**
+ * The declaration a host attaches to an expression field: the language, what the
+ * input document is (descriptor), how to sample it, and how to server-validate it.
+ * Every property beyond `language` is optional so adoption is incremental — an
+ * undeclared-but-for-language field behaves exactly as a plain text field. No
+ * property names anything host-specific. Graduated from jq-studio's
+ * `JqFieldDeclaration`.
+ */
+export interface ExpressionFieldDeclaration {
+  readonly language: ExpressionLanguage;
+  readonly shape?: ExpressionShapeDescriptor;
+  readonly sampleInput?: ExpressionSampleInputProvider;
+  readonly serverValidate?: ExpressionServerValidate;
+}
+
+/**
+ * The props a contributed editor component receives when the field opens it. The
+ * WHOLE {@link ExpressionFieldDeclaration} crosses (not just `shape` /
+ * `serverValidate`), so the editor reads the input descriptor for its context
+ * chip, the sample provider for Test seeding, and the validate hook for its
+ * Validate action from one object. `onSave` writes the authored expression back
+ * through the field; `onClose` dismisses without saving.
+ */
+export interface ExpressionEditorProps {
+  /** What the field feeds and how to sample/validate it (see the type). */
+  readonly declaration: ExpressionFieldDeclaration;
+  /** Whether the editor is open — the field mounts it only while true. */
+  readonly open: boolean;
+  /** The field's current expression ('' when unset), the editor seeds itself with. */
+  readonly initialExpression: string;
+  /** The field label the editor titles itself with. */
+  readonly fieldLabel?: string;
+  /** Author-blocking: the editor renders read-only (no Save) when true. */
+  readonly readOnly?: boolean;
+  /** Called with the authored expression when the user saves. */
+  readonly onSave: (expression: string) => void;
+  /** Called when the user dismisses the editor without saving. */
+  readonly onClose: () => void;
+}
+
+/**
+ * The contract version an {@link ExpressionEditorContribution} must target. Bumped
+ * only on a BREAKING change to {@link ExpressionEditorProps} or the contribution
+ * shape; the registry rejects a contribution whose `contractVersion` is not
+ * exactly this, so a host never mounts an editor built against an incompatible
+ * props contract. It is distinct from `STUDIO_PLUGIN_API_VERSION`: the plugin API
+ * gains this whole extension point ADDITIVELY (that version does not move), and
+ * this narrower number then versions the editor props independently.
+ */
+export const EXPRESSION_EDITOR_CONTRACT_VERSION = 1;
+
+/**
+ * A plugin's contribution of the editor for one expression language. The editor
+ * rides a SEPARATE chunk (a visual canvas, converters, a language runtime), so it
+ * is fetched lazily: `load` resolves the module exposing the `Editor` component,
+ * and the optional `preload` warms that chunk on open-intent (hover/focus) so the
+ * editor is ready by the time the user opens it. `contractVersion` must equal
+ * {@link EXPRESSION_EDITOR_CONTRACT_VERSION} or the registry rejects it loudly.
+ */
+export interface ExpressionEditorContribution {
+  /** The language this editor authors; the lookup key a field resolves by. */
+  readonly language: ExpressionLanguage;
+  /** The {@link ExpressionEditorProps} contract this editor was built against. */
+  readonly contractVersion: number;
+  /** Best-effort warm of the editor's chunk on open-intent; never awaited by the field. */
+  readonly preload?: () => void;
+  /** Resolve the editor component's chunk; rejection surfaces as the field's loud error. */
+  readonly load: () => Promise<{ readonly Editor: ComponentType<ExpressionEditorProps> }>;
+}

package/src/index.ts

@@ -48,6 +48,28 @@ export type {
 export { STUDIO_PLUGIN_API_VERSION, checkPluginApiVersion } from './plugin/version';
 export type { VersionGateResult } from './plugin/version';
 
+// -- Expression fields (declaration vocabulary + editor extension point) ------
+export { EXPRESSION_EDITOR_CONTRACT_VERSION } from './expression/types';
+export type {
+  ExpressionLanguage,
+  ExpressionInputKey,
+  ExpressionShapeDescriptor,
+  ExpressionSampleInputProvider,
+  ExpressionValidationResult,
+  ExpressionServerValidate,
+  ExpressionFieldDeclaration,
+  ExpressionEditorProps,
+  ExpressionEditorContribution,
+} from './expression/types';
+export { ExpressionEditorsProvider, useExpressionEditor } from './expression/context';
+export type { ExpressionEditorsProviderProps } from './expression/context';
+export { ExpressionField, ExpressionEditorLauncher } from './expression/ExpressionField';
+export type {
+  ExpressionFieldProps,
+  ExpressionEditorLauncherProps,
+  ExpressionControlProps,
+} from './expression/ExpressionField';
+
 // -- Hooks -------------------------------------------------------------------
 export { ApiProvider, useApi } from './hooks/useApi';
 export type { ApiClient } from './hooks/useApi';