vultus-core 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vultus-core",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "license": "Apache-2.0",
   "description": "Framework-neutral action model + hooks for vultus (antd-free by design)",
   "repository": {

package/src/ArgStoreContext.tsx

@@ -0,0 +1,16 @@
+import { createContext, useContext, type ReactNode } from 'react';
+import type { ArgStore } from './argStore.js';
+
+const ArgStoreContext = createContext<ArgStore | undefined>(undefined);
+
+/** Gives the subtree below an ArgStore (Praeceptor: the URL store around the module page, localStorage around the print dialog). */
+export function ArgStoreProvider({ store, children }: { store: ArgStore; children?: ReactNode }) {
+  return <ArgStoreContext.Provider value={store}>{children}</ArgStoreContext.Provider>;
+}
+
+/** The nearest ArgStoreProvider's store; a hook with none above it fails loudly rather than reading nothing. */
+export function useArgStore(): ArgStore {
+  const store = useContext(ArgStoreContext);
+  if (store === undefined) throw new Error('No ArgStoreProvider is above this component');
+  return store;
+}

package/src/Components.tsx

@@ -0,0 +1,47 @@
+import { createContext, useContext, useMemo, type ComponentType, type ReactNode } from 'react';
+
+/** A spinner an app lends to vultus/optio, rendered in place of their native loading indicators. */
+export interface SpinnerProps {
+  /** The spinner's identity: stable across re-renders and remounts, unique on the page (after scoping). */
+  spinnerKey: string;
+  /** antd's names (the height of antd's Spin indicator) or a height in px. */
+  size?: 'small' | 'default' | 'large' | number;
+  /** Accessible label; the spinner's own default when omitted. */
+  label?: string;
+}
+export type SpinnerComponent = ComponentType<SpinnerProps>;
+
+/** Components an app lends to the libraries. */
+export interface VultusComponents {
+  Spinner?: SpinnerComponent;
+}
+
+/**
+ * The components an app lends to vultus/optio in place of their own UI. Default is `{}`
+ * (none lent) so vultus-core stays framework-neutral; vultus-antd's `VultusProvider` merges
+ * in whatever an app passes as `components`.
+ */
+export const VultusComponentsContext = createContext<VultusComponents>({});
+
+export function useVultusComponents(): VultusComponents {
+  return useContext(VultusComponentsContext);
+}
+
+/** The scope path (segment names, outermost first) that `useSpinnerKey` prefixes onto local keys. */
+const SpinnerScopeContext = createContext<string[]>([]);
+
+/** Prefixes every spinner key below with `name` (scopes nest: outer/inner). */
+export function SpinnerScope({ name, children }: { name: string; children?: ReactNode }) {
+  const outer = useContext(SpinnerScopeContext);
+  // Memoized so consumers below (useSpinnerKey, via SpinnerScopeContext) don't re-render
+  // on every SpinnerScope re-render — only when the scope path actually changes. Matters
+  // once whole conversation views sit inside a SpinnerScope.
+  const scope = useMemo(() => [...outer, name], [outer, name]);
+  return <SpinnerScopeContext.Provider value={scope}>{children}</SpinnerScopeContext.Provider>;
+}
+
+/** The scoped key for a library-local key: 'outer/inner/local', or 'local' outside any scope. */
+export function useSpinnerKey(localKey: string): string {
+  const scope = useContext(SpinnerScopeContext);
+  return [...scope, localKey].join('/');
+}

package/src/FieldContext.tsx

@@ -0,0 +1,98 @@
+import { createContext, useContext, useMemo, type JSX, type ReactNode } from 'react';
+
+/**
+ * What useFieldContext gives when no FieldContextProvider is above: a field's function that
+ * declares a parameter then has nothing to receive, and resolving it throws.
+ */
+export const NO_FIELD_CONTEXT: unique symbol = Symbol('vultus.noFieldContext');
+
+/** The field context as the hooks hold it: the guarded value, or the mark that there is none. */
+export type FieldCtx = object | typeof NO_FIELD_CONTEXT;
+
+/** The merged value of the providers above, and the same value guarded against missing keys. */
+interface Provided {
+  raw: object;
+  guarded: object;
+}
+
+const FieldContext = createContext<Provided | undefined>(undefined);
+
+/**
+ * Keys that libraries read to find out what an object is (a thenable, JSON, a test matcher, a
+ * React element, a DOM node or element, a mock function), and the `@@`-prefixed sentinels
+ * (Immutable's) that printers such as pretty-format test for. Reading them on the context is a
+ * probe, not a mistake.
+ */
+const PROBED_KEYS = new Set([
+  'then', 'toJSON', 'asymmetricMatch', '$$typeof', 'nodeType', 'tagName', 'hasAttribute', '_isMockFunction',
+]);
+
+function isProbe(key: string): boolean {
+  return PROBED_KEYS.has(key) || key.startsWith('@@');
+}
+
+/** What the guard throws for a key no provider gave, so readingContext can tell it from the function's own errors. */
+class MissingKeyError extends Error {}
+
+/**
+ * The context value as the definitions' functions receive it: reading a key that no provider
+ * gave throws, naming it and the keys present, so a forgotten value fails loudly instead of
+ * passing `undefined` along. A key provided with the value `undefined` is fine.
+ */
+function guard(raw: object): object {
+  return new Proxy(raw, {
+    get(target, key, receiver) {
+      if (typeof key === 'string' && !isProbe(key) && !(key in target)) {
+        throw new MissingKeyError(`Field context: '${key}' was never provided (provided: ${Object.keys(target).join(', ')})`);
+      }
+      return Reflect.get(target, key, receiver);
+    },
+  });
+}
+
+/**
+ * Runs `read`, a call of a definition's function with the field context. A key it reads that
+ * no provider gave throws with `where` (`Field '<id>': option '<name>'`) in front of the
+ * guard's message, so the error names the field and the option as well as the key; any other
+ * error passes through unchanged.
+ */
+export function readingContext<T>(where: string, read: () => T): T {
+  try {
+    return read();
+  } catch (error) {
+    if (error instanceof MissingKeyError) throw new Error(`${where}: ${error.message}`, { cause: error });
+    throw error;
+  }
+}
+
+/**
+ * Gives the fields below a context, the argument their definitions' functions receive. Nested
+ * providers merge, the inner value winning: an app can provide `t` near the root and the data
+ * a page shows further down.
+ */
+export function FieldContextProvider({ value, children }: { value: object; children?: ReactNode }) {
+  const outer = useContext(FieldContext);
+  // Memoized on the outer context and `value`: a caller passing a fresh object literal gets a
+  // new context every render anyway; a stable `value` keeps the fields below from re-rendering.
+  const provided = useMemo(() => {
+    const raw = { ...outer?.raw, ...value };
+    return { raw, guarded: guard(raw) };
+  }, [outer, value]);
+  return <FieldContext.Provider value={provided}>{children}</FieldContext.Provider>;
+}
+
+/**
+ * A FieldContextProvider typed for the context `Ctx` an app's definitions are written against.
+ * It is the same provider (one React context), so typed providers nest and merge with each
+ * other and with the untyped one; each gives part of the context.
+ */
+export function createFieldContext<Ctx extends object>(): {
+  Provider: (props: { value: Partial<Ctx>; children?: ReactNode }) => JSX.Element;
+} {
+  return { Provider: FieldContextProvider };
+}
+
+/** The field context the hooks resolve functions with: the guarded value, or NO_FIELD_CONTEXT. */
+export function useFieldContext(): FieldCtx {
+  return useContext(FieldContext)?.guarded ?? NO_FIELD_CONTEXT;
+}

package/src/argStore.ts

@@ -0,0 +1,49 @@
+/** Whether a write pushes a new history entry or replaces the current one; a store without history ignores it. */
+export type UpdateMethod = 'push' | 'replace';
+
+/** One key's new raw value, or `undefined` to remove it (the key reads back as its default). */
+export interface RawChange {
+  key: string;
+  raw: string | undefined;
+}
+
+/**
+ * A store for argument values kept as strings (moxb's url-arg backends, batched): a URL query,
+ * localStorage, or (here) memory. `read` and `write` move raw strings only — parsing, defaults
+ * and equality live in the value type and in useArg, not here. The hooks call its methods on
+ * the store, never detached, so a store may be a class whose methods use `this`.
+ */
+export interface ArgStore {
+  read(key: string): string | undefined;
+  /** Applies every change, then notifies subscribers once — several keys changed together are one history entry. */
+  write(changes: RawChange[], method: UpdateMethod): void;
+  subscribe(listener: () => void): () => void;
+  /** The href a write of `changes` would produce, where the store has one (a URL store); omitted otherwise. */
+  hrefFor?(changes: RawChange[]): string;
+}
+
+/** An ArgStore over a plain object, for tests and demos. `snapshot()` is a copy, for assertions. */
+export function memoryStore(initial: Record<string, string> = {}): ArgStore & { snapshot(): Record<string, string> } {
+  const data: Record<string, string> = { ...initial };
+  const listeners = new Set<() => void>();
+
+  return {
+    read(key) {
+      return data[key];
+    },
+    write(changes, _method) {
+      for (const { key, raw } of changes) {
+        if (raw === undefined) delete data[key];
+        else data[key] = raw;
+      }
+      listeners.forEach((listener) => listener());
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    snapshot() {
+      return { ...data };
+    },
+  };
+}

package/src/choices.ts

@@ -0,0 +1,62 @@
+import type { ReactNode } from 'react';
+import { calculateEnabled } from './field.js';
+import { getReason, getVerdict } from './decision.js';
+import type { Decision } from './types.js';
+
+/**
+ * One choice of a one-of or many-of field, or a tree node (moxb's
+ * BindOneOfChoice). Shared by useOneOfField today; useManyOfField and the
+ * tree hook (later tasks) build on the same shape.
+ */
+export interface OneOfChoice<T extends string = string> {
+  value: T;
+  /** Shown for the choice; default: the value. */
+  label?: string;
+  /** What choosing it does (moxb's `help`), markdown; also the field's current state when it is chosen. */
+  description?: string;
+  /** Shown before the label (or instead of it, for an icon-only widget), like an action's icon. */
+  icon?: ReactNode;
+  /** Choosable? Default true, optionally with a reason. Use `enabled` or `disabled`, not contradicting each other. */
+  enabled?: Decision;
+  disabled?: Decision;
+  /** Shown as the main or a dangerous choice, like an action's variant. Default 'default'. */
+  variant?: 'default' | 'primary' | 'danger';
+  /** A heading the choice is listed under, after the choices without one (OneOfSelect); default none. */
+  group?: string;
+  /** Shown after the label in secondary colour, e.g. a count ("12", "12 · 8%"). Default none. */
+  note?: string;
+  /** Shown faded, e.g. a choice with nothing behind it right now (no matching tasks). Default false. */
+  dimmed?: boolean;
+}
+
+/** A choice as the widgets get it. */
+export interface OneOfChoiceControls<T extends string = string> {
+  value: T;
+  label: string;
+  description: string | undefined;
+  icon: ReactNode | undefined;
+  enabled: boolean;
+  whyDisabled: string | undefined;
+  variant: 'default' | 'primary' | 'danger';
+  group: string | undefined;
+  note: string | undefined;
+  dimmed: boolean;
+}
+
+/** Resolves a choice's `enabled` / `disabled` and defaults, as useOneOfField does for each of its choices. */
+export function resolveChoice<T extends string>(fieldId: string, choice: OneOfChoice<T>): OneOfChoiceControls<T> {
+  const decision = calculateEnabled(`${fieldId}.${choice.value}`, choice.enabled, choice.disabled);
+  const enabled = getVerdict(decision, true);
+  return {
+    value: choice.value,
+    label: choice.label ?? choice.value,
+    description: choice.description,
+    icon: choice.icon,
+    enabled,
+    whyDisabled: enabled ? undefined : getReason(decision),
+    variant: choice.variant ?? 'default',
+    group: choice.group,
+    note: choice.note,
+    dimmed: choice.dimmed ?? false,
+  };
+}

package/src/field.ts

@@ -1,6 +1,7 @@
 import { useState } from 'react';
 import { getReason, getVerdict, invertDecision } from './decision.js';
-import { resolve } from './resolve.js';
+import { useFieldContext } from './FieldContext.js';
+import { resolveIn } from './resolve.js';
 import { useAction } from './useAction.js';
 import type {
   ConfirmationSpec,
@@ -21,6 +22,12 @@ import type {
  * Design notes: unitas docs/2026-10-05-vultus-field-model-design.md.
  */
 
+/** The field kinds (FieldControls.type and a FieldDefinition's `kind`). */
+export type FieldKind = 'boolean' | 'mixed-boolean' | 'oneOf' | 'manyOf' | 'numeric' | 'range' | 'tree' | 'text';
+
+/** The widget to render a field with: a name, or a name with display options overriding its defaults. */
+export type WidgetHint = string | { name: string; [option: string]: unknown };
+
 /** How an immediately committing field stores a change: an action that receives the requested value. */
 export interface FieldCommit<TRequest, RouteId extends string = string> {
   fire: (next: TRequest, ctx: ExecutionContext) => Promise<void> | void;
@@ -32,16 +39,30 @@ export interface FieldCommit<TRequest, RouteId extends string = string> {
 /** The key of a value in `valueDescriptions`: 'true' / 'false' for booleans, the value itself for strings. */
 export type ValueKey<T> = T extends boolean ? `${T}` : T extends string | number ? `${T}` : never;
 
-interface FieldBaseOptions<TValue> {
+/**
+ * What every field has, whatever its storage. `Ctx` is the field context the options' functions
+ * receive (see FieldContextProvider); a function without parameters needs none.
+ */
+export interface FieldBaseOptions<TValue, Ctx = any> {
   id: string;
-  label?: ValueOrFn<string>;
-  description?: ValueOrFn<string | undefined>;
+  /**
+   * The field's kind, as a FieldDefinition carries it (optional here: a hook knows its own
+   * kind). Given and different from the hook's own kind, it throws — a defence against passing
+   * the wrong definition to a kind-specific hook.
+   */
+  kind?: FieldKind;
+  label?: ValueOrFn<string, Ctx>;
+  description?: ValueOrFn<string | undefined, Ctx>;
+  /** Shown while the field is empty (moxb's Value); a widget that has no notion of "empty" ignores it. */
+  placeholder?: ValueOrFn<string | undefined, Ctx>;
+  /** The widget to render this field with: a name, or a name with its display options. Each kind has a default; vultus-antd's `<Field>` applies render-site overrides on top of this. */
+  widget?: WidgetHint;
   /** Shown? Default true. Use `visible` or `hidden`, not contradicting each other. */
-  visible?: ValueOrFn<boolean>;
-  hidden?: ValueOrFn<boolean>;
+  visible?: ValueOrFn<boolean, Ctx>;
+  hidden?: ValueOrFn<boolean, Ctx>;
   /** Changeable? Default true, optionally with a reason. Use `enabled` or `disabled`, not contradicting each other. */
-  enabled?: ValueOrFn<Decision>;
-  disabled?: ValueOrFn<Decision>;
+  enabled?: ValueOrFn<Decision, Ctx>;
+  disabled?: ValueOrFn<Decision, Ctx>;
   /**
    * What each value means right now, keyed by value (for booleans `true` / `false`, and `mixed`
    * where the field can show it). Shown with the current value, next to `description`, which
@@ -55,23 +76,24 @@ interface FieldBaseOptions<TValue> {
  * `TValue` and can be asked for a `TRequest`; usually the same type, but an aggregate can show
  * a state that cannot be requested (a boolean field showing 'mixed').
  */
-export type FieldStorage<TValue, TRequest = TValue, RouteId extends string = string> =
-  /** Inside the field: its own state, starting at `initialValue`. */
-  | { initialValue?: TValue; value?: never; onChange?: never; commit?: never }
+export type FieldStorage<TValue, TRequest = TValue, RouteId extends string = string, Ctx = any> =
+  /** Inside the field: its own state, starting at `initialValue` (resolved once, when the field mounts). */
+  | { initialValue?: ValueOrFn<TValue, Ctx>; value?: never; onChange?: never; commit?: never }
   /** Outside, changed locally: the caller owns the value and applies `onChange`. */
   | { value: TValue; onChange: (value: TRequest) => void; initialValue?: never; commit?: never }
   /** Outside, committed immediately: `commit.fire` stores the change (pending, messages, confirmation). */
   | { value: TValue; commit: FieldCommit<TRequest, RouteId>; initialValue?: never; onChange?: never };
 
-export type FieldOptions<TValue, TRequest = TValue, RouteId extends string = string> =
-  FieldBaseOptions<TValue> & FieldStorage<TValue, TRequest, RouteId>;
+export type FieldOptions<TValue, TRequest = TValue, RouteId extends string = string, Ctx = any> =
+  FieldBaseOptions<TValue, Ctx> & FieldStorage<TValue, TRequest, RouteId, Ctx>;
 
 /** What a field widget receives: everything it shows, and the one way to change the value. */
 export interface FieldControls<TValue, TRequest = TValue> {
-  type: string;
+  type: FieldKind;
   id: string;
   label: string;
   description: string | undefined;
+  placeholder: string | undefined;
   /** What the current value means (from `valueDescriptions`). */
   valueDescription: string | undefined;
   visible: boolean;
@@ -82,10 +104,13 @@ export interface FieldControls<TValue, TRequest = TValue> {
   setValue(next: TRequest): void;
   /** A commit is running. */
   pending: boolean;
+  /** The field stores through `commit` — true exactly in commit storage mode, so a widget can hold back requests while typing. */
+  commits: boolean;
   /** Messages of the last commit. */
   messages: Message[];
   /** The confirmation a widget must obtain before requesting `next`, if any. */
   confirmationFor(next: TRequest): ConfirmationSpec | undefined;
+  widget: WidgetHint | undefined;
 }
 
 export type FieldStorageMode = 'inside' | 'local' | 'commit';
@@ -122,27 +147,38 @@ export function calculateEnabled(id: string, enabled: Decision | undefined, disa
 /**
  * The shared core of every field hook: label and description, visibility and
  * enabled state (with reason), the storage mode, and in commit mode the setter
- * as an action (its pending state and messages become the field's).
+ * as an action (its pending state and messages become the field's). Functions
+ * among the options are resolved with the field context, on every render;
+ * `initialValue` once, when the field mounts. A kind's hook passes its implicit
+ * initial value as a zero-argument function, so that too is computed only then.
  */
-export function useFieldCore<TValue, TRequest extends TValue = TValue, RouteId extends string = string>(
-  type: string,
-  opts: FieldOptions<TValue, TRequest, RouteId>,
+export function useFieldCore<TValue, TRequest extends TValue = TValue, RouteId extends string = string, Ctx = any>(
+  type: FieldKind,
+  opts: FieldOptions<TValue, TRequest, RouteId, Ctx>,
   registry?: ErrorRoutesRegistry<RouteId>,
 ): FieldControls<TValue, TRequest> {
+  if (opts.kind !== undefined && opts.kind !== type) {
+    throw new Error(`Field '${opts.id}': a definition of kind '${opts.kind}' was passed to the '${type}' hook`);
+  }
   const mode = fieldStorageMode(opts.id, opts as FieldStorage<unknown, unknown, string>);
-  const [inner, setInner] = useState<TValue>(opts.initialValue as TValue);
+  const ctx = useFieldContext();
+  const where = (name: string) => `Field '${opts.id}': option '${name}'`;
+  const [inner, setInner] = useState<TValue>(
+    () => resolveIn<TValue | undefined>(opts.initialValue, undefined, ctx, where('initialValue')) as TValue,
+  );
 
-  const label = resolve(opts.label, '');
-  const description = resolve<string | undefined>(opts.description, undefined);
+  const label = resolveIn(opts.label, '', ctx, where('label'));
+  const description = resolveIn<string | undefined>(opts.description, undefined, ctx, where('description'));
+  const placeholder = resolveIn<string | undefined>(opts.placeholder, undefined, ctx, where('placeholder'));
   const visible = calculateVisible(
     opts.id,
-    resolve<boolean | undefined>(opts.visible, undefined),
-    resolve<boolean | undefined>(opts.hidden, undefined),
+    resolveIn<boolean | undefined>(opts.visible, undefined, ctx, where('visible')),
+    resolveIn<boolean | undefined>(opts.hidden, undefined, ctx, where('hidden')),
   );
   const enabledDecision = calculateEnabled(
     opts.id,
-    resolve<Decision | undefined>(opts.enabled, undefined),
-    resolve<Decision | undefined>(opts.disabled, undefined),
+    resolveIn<Decision | undefined>(opts.enabled, undefined, ctx, where('enabled')),
+    resolveIn<Decision | undefined>(opts.disabled, undefined, ctx, where('disabled')),
   );
   const enabled = getVerdict(enabledDecision, true);
   const whyDisabled = enabled ? undefined : getReason(enabledDecision);
@@ -184,6 +220,7 @@ export function useFieldCore<TValue, TRequest extends TValue = TValue, RouteId e
     id: opts.id,
     label,
     description,
+    placeholder,
     valueDescription,
     visible,
     enabled,
@@ -191,7 +228,9 @@ export function useFieldCore<TValue, TRequest extends TValue = TValue, RouteId e
     value,
     setValue,
     pending,
+    commits: mode === 'commit',
     messages: mode === 'commit' ? (setter.messages ?? []) : [],
     confirmationFor,
+    widget: opts.widget,
   };
 }

package/src/index.ts

@@ -6,16 +6,66 @@ export * from './routeApiError.js';
 export { ActionErrorContext, useActionErrorCtx } from './useActionErrorCtx.js';
 export { useAction } from './useAction.js';
 export { useActionList } from './useActionList.js';
+export {
+  FieldContextProvider, createFieldContext, useFieldContext, NO_FIELD_CONTEXT, type FieldCtx,
+} from './FieldContext.js';
 export {
   useFieldCore, fieldStorageMode, calculateVisible, calculateEnabled,
-  type FieldCommit, type FieldControls, type FieldOptions, type FieldStorage, type FieldStorageMode, type ValueKey,
+  type FieldBaseOptions, type FieldCommit, type FieldControls, type FieldOptions, type FieldStorage, type FieldStorageMode,
+  type FieldKind, type WidgetHint, type ValueKey,
 } from './field.js';
-export { useBoolField, type BoolFieldControls, type BoolFieldOptions } from './useBoolField.js';
+export { resolveChoice, type OneOfChoice, type OneOfChoiceControls } from './choices.js';
+export { normalizeText } from './normalizeText.js';
+export { useBoolField, boolInitialValue, type BoolFieldControls, type BoolFieldOptions } from './useBoolField.js';
 export {
-  useMixedBoolField, aggregateBool, type MixedBool, type MixedBoolFieldControls, type MixedBoolFieldOptions,
+  useMixedBoolField, aggregateBool, mixedBoolInitialValue,
+  type MixedBool, type MixedBoolFieldControls, type MixedBoolFieldOptions,
 } from './useMixedBoolField.js';
 export {
-  useOneOfField, type OneOfChoice, type OneOfChoiceControls, type OneOfFieldControls, type OneOfFieldOptions,
+  useOneOfField, oneOfInitialValue, type OneOfFieldControls, type OneOfFieldOptions, type OneOfOwnOptions,
 } from './useOneOfField.js';
+export {
+  useManyOfField, manyOfInitialValue,
+  type ManyOfFieldControls, type ManyOfFieldOptions, type ManyOfOwnOptions, type ManyOfChoiceControls,
+} from './useManyOfField.js';
+export { clamp, resolveNumeric, type NumericBounds, type ResolvedNumeric } from './numeric.js';
+export {
+  useNumericField, numericInitialValue,
+  type NumericFieldControls, type NumericFieldOptions, type NumericOwnOptions,
+} from './useNumericField.js';
+export {
+  useRangeField, rangeInitialValue,
+  type NumberRange, type RangeFieldControls, type RangeFieldOptions, type RangeOwnOptions,
+} from './useRangeField.js';
+export {
+  normalizeTreeValue, coveredNodes, toggleTreeValue, expandedTreeKeys, filterTree,
+  type TreeNode, type TreeNodeControls, type TreeSelection, type TreeExpand,
+} from './tree.js';
+export {
+  useTreeField, treeInitialValue,
+  type TreeFieldControls, type TreeFieldOptions, type TreeOwnOptions,
+} from './useTreeField.js';
+export {
+  useTextField, textInitialValue,
+  type TextFieldControls, type TextFieldOptions, type TextOwnOptions,
+} from './useTextField.js';
+export {
+  booleanType, stringType, stringSetType, numberType, rangeType, type ValueType,
+} from './valueTypes.js';
+export { initialValueOf, valueTypeOf, sanitizeStored, type FieldDefinition } from './kinds.js';
+export { memoryStore, type ArgStore, type RawChange, type UpdateMethod } from './argStore.js';
+export { localStorageStore } from './localStorageStore.js';
+export { ArgStoreProvider, useArgStore } from './ArgStoreContext.js';
+export {
+  useArg, useArgWriter, setArg, resetArg,
+  type ArgDefinition, type ArgControls, type ArgChange,
+} from './useArg.js';
+export {
+  argOf, useStoredField, useStoredFields, type StoredField, type StoredFields,
+} from './useStoredField.js';
 export { InternalLinkContext, useInternalLink, type InternalLinkComponent } from './LinkContext.js';
 export { MessageSinkContext, useMessageSink, type MessageSink } from './MessageSink.js';
+export {
+  VultusComponentsContext, useVultusComponents, SpinnerScope, useSpinnerKey,
+  type VultusComponents, type SpinnerProps, type SpinnerComponent,
+} from './Components.js';