@weasel-js/labkit 1.4.2 → 1.4.4

package/src/trial/Trial.tsx

@@ -239,11 +239,11 @@ function TrialRuntime({ record, instrument, store, isLast, chrome, suppress }: T
       updateTrialState(record.id, next);
       bus.emit('state.change');
     },
-    setConfig: (key, value) => {
-      const evt = `config.change:${String(key)}`;
+    setConfig: (path, value) => {
+      const evt = `config.change:${path}`;
       snapshotIfNeeded('config.change');
       snapshotIfNeeded(evt);
-      updateTrialConfig(record.id, key as never, value as never);
+      updateTrialConfig(record.id, path, value);
       bus.emit('config.change');
       bus.emit(evt);
     },

package/src/trial/TrialChrome.tsx

@@ -9,6 +9,7 @@ import { TitleBarRegion } from '../chrome/regions/TitleBarRegion';
 import { ToolbarRegion } from '../chrome/regions/ToolbarRegion';
 import { ViewportRegion } from '../chrome/regions/ViewportRegion';
 import type { TrialChromeContext, TrialContribution, TrialRegion } from '../chrome/types';
+import { hasConfigPath, schemaNodeAtPath, withValueAtPath } from '../config/path';
 import { useConfigSchema } from '../config/useConfigSchema';
 import type { Instrument } from '../instrument/types';
 import type { JobHandle } from '../job/types';
@@ -135,16 +136,20 @@ export function TrialChrome({
       configSchema,
       configFields: instrument.config ? [] : (instrument.configSchema?.() ?? []),
       config: record.config,
-      setConfig: (key, value) => {
+      setConfig: (path, value) => {
         const prevConfig = record.config as Record<string, unknown>;
-        if (process.env.NODE_ENV !== 'production' && !(key in prevConfig)) {
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          !hasConfigPath(prevConfig, path) &&
+          schemaNodeAtPath(configSchema.group, path) === undefined
+        ) {
           console.warn(
-            `[labkit] setConfig: unknown key "${key}" for instrument "${record.instrumentName}"`,
+            `[labkit] setConfig: unknown path "${path}" for instrument "${record.instrumentName}"`,
           );
         }
-        updateTrialConfig(trialId, key as never, value as never);
+        updateTrialConfig(trialId, path, value);
         if (instrument.onConfigChange) {
-          const nextConfig = { ...prevConfig, [key]: value };
+          const nextConfig = withValueAtPath(prevConfig, path, value);
           const nextState = instrument.onConfigChange(nextConfig, prevConfig, record.state);
           updateTrialState(trialId, nextState as never);
         }

package/src/trial/trialOps.ts

@@ -1,5 +1,7 @@
+import { fillConfigDefaults } from '../config/path';
 import type { Instrument, InstrumentList } from '../instrument/types';
 import type { TrialRecord } from '../state/types';
+import { newId } from '../state/helpers';
 
 const DEFAULT_VIEW = { zoom: 1, pan: { x: 0, y: 0 } } as const;
 
@@ -27,15 +29,10 @@ export interface AddTrialOptions<TC = Record<string, unknown>> {
   config?: Partial<TC>;
 }
 
-/** `defaultConfig()` with `seed` written over it. Config is flat — a leaf's
- *  path is its config key — so this is the whole merge. */
+/** `defaultConfig()` with `seed` written over it, down the tree: a seed naming
+ *  one leaf of a group leaves that group's other leaves at their defaults. */
 function seedConfig<TC>(defaults: TC, seed: Partial<TC> | undefined): TC {
-  if (!seed) return defaults;
-  const out = { ...defaults };
-  for (const [key, value] of Object.entries(seed)) {
-    if (value !== undefined) (out as Record<string, unknown>)[key] = value;
-  }
-  return out;
+  return seed ? fillConfigDefaults(seed, defaults) : defaults;
 }
 
 /** Append a new trial running `instrumentName`, at that instrument's default
@@ -51,7 +48,7 @@ export function addTrial(
   const config = seedConfig(instrument.defaultConfig(), options.config);
   const state = instrument.initialState(config);
   const record: TrialRecord = {
-    id: crypto.randomUUID(),
+    id: newId(),
     instrumentName,
     config,
     state,
@@ -70,7 +67,7 @@ export function cloneTrial(trials: TrialRecord[], id: string): TrialRecord[] {
   if (!source) return trials;
   const clone: TrialRecord = {
     ...source,
-    id: crypto.randomUUID(),
+    id: newId(),
     config: structuredClone(source.config),
     state: structuredClone(source.state),
     view: structuredClone(source.view),

package/dist/_dts/types-lg4TSCb2.d.ts

@@ -1,164 +0,0 @@
-import { T as ToolPrefLeaf, a as ToolPrefGroup } from './weasel-canvas-FJTFi3ZZ.js';
-import { P as PrefRenderer } from './PrefsForm.d-CgxUequc.js';
-
-/**
- * Renders the control cell for one config leaf. Identical to weasel-ui's
- * `PrefRenderer` on purpose — aliased rather than redeclared so the two
- * cannot drift.
- */
-type ControlRenderer = PrefRenderer;
-/** One labeled choice in an `enum` leaf. */
-interface ConfigOption {
-    value: string;
-    label: string;
-}
-/** Everything a leaf can carry beyond its kind and default. A flat union of
- *  every `Pref*` leaf's extras, plus labkit's own `debounceMs`. */
-interface Annotations {
-    name?: string;
-    description?: string;
-    hidden?: boolean;
-    block?: boolean;
-    pair?: string;
-    min?: number;
-    max?: number;
-    step?: number;
-    suffix?: string;
-    control?: string;
-    options?: readonly ConfigOption[];
-    placeholder?: string;
-    maxLength?: number;
-    /** Milliseconds to debounce a string leaf's live writes. Default 150. */
-    debounceMs?: number;
-}
-/** What a rule contributes. `kind` is honored only while it is still unset,
- *  which is what makes `f.value` claimable and a kinded factory final. */
-type LeafPatch = Annotations & {
-    kind?: string;
-};
-/** What a rule is given for the leaf it is deciding about. */
-interface ConfigRuleContext {
-    /** The config key this leaf writes. */
-    key: string;
-    /** Dotted path within the schema. Equal to `key` while schemas are flat. */
-    path: string;
-    /** The leaf's default value. A rule may read it but never change it. */
-    default: unknown;
-    /** What earlier rules and the author's own annotations have settled. */
-    leaf: Readonly<LeafPatch>;
-}
-/**
- * Decides part of how a leaf is presented. Returns a patch, or null to
- * abstain. Merging is gap-filling: a property already settled is never
- * overwritten, so the author's annotations beat every rule and a consumer's
- * rules beat labkit's built-ins.
- */
-type ConfigRule = (ctx: ConfigRuleContext) => LeafPatch | null;
-/** A presentational bucket of leaves, rendered under one heading. */
-interface SectionSpec {
-    label: string;
-    paths: readonly string[];
-}
-/** A schema resolved against a set of rules: the vocabulary weasel-ui renders,
- *  plus the three things labkit keeps on the side because `PrefLeaf` has no
- *  field for them. */
-interface ResolvedConfig {
-    /** Flat: every leaf is a direct child, so a leaf's path is its config key. */
-    group: ToolPrefGroup;
-    sections: readonly SectionSpec[];
-    showIf: ReadonlyMap<string, (config: Record<string, unknown>) => boolean>;
-    /** Node-level `.render` overrides, keyed by path. */
-    renderers: Readonly<Record<string, ControlRenderer>>;
-}
-/** Per-node extras that do not belong on a `PrefLeaf`. */
-interface NodeOptions {
-    section?: string;
-    showIf?: (config: Record<string, unknown>) => boolean;
-    render?: ControlRenderer;
-    validate?: (leaf: ToolPrefLeaf) => string[];
-}
-/** The builder's leaf: a kind (or null, to be decided by rules), a default,
- *  an annotation bag, and the extras above. */
-interface ConfigNode<T = unknown> {
-    readonly kind: string | null;
-    readonly default: T;
-    readonly annotations: Readonly<Annotations>;
-    readonly options: Readonly<NodeOptions>;
-}
-/** The value type a node produces. */
-type NodeValue<N> = N extends ConfigNode<infer T> ? T : never;
-/** The config type a builder shape produces. */
-type InferConfig<S> = {
-    [K in keyof S]: NodeValue<S[K]>;
-};
-/** An instrument's config, declared once. */
-interface ConfigSchema<TC> {
-    readonly nodes: Readonly<Record<string, ConfigNode>>;
-    /** The starting config — what `defaultConfig()` would have returned. */
-    defaults(): TC;
-}
-/** The config type behind a schema: `ConfigOf<typeof sceneConfig>`. */
-type ConfigOf<S> = S extends ConfigSchema<infer TC> ? TC : never;
-
-/** Which control a config field is edited with. */
-type ConfigFieldType = 'slider' | 'checkbox' | 'select' | 'number' | 'text' | 'color';
-/** What every config field carries: the config key it writes, the label shown
- *  beside it, and which control renders it. */
-interface ConfigFieldBase {
-    key: string;
-    label: string;
-    type: ConfigFieldType;
-}
-/** A bounded number edited by dragging. */
-interface SliderField extends ConfigFieldBase {
-    type: 'slider';
-    default: number;
-    min: number;
-    max: number;
-    step?: number;
-}
-/** A boolean. */
-interface CheckboxField extends ConfigFieldBase {
-    type: 'checkbox';
-    default: boolean;
-}
-/** One choice in a select field. */
-interface SelectOption {
-    value: string;
-    label: string;
-}
-/** A fixed set of labeled choices. */
-interface SelectField extends ConfigFieldBase {
-    type: 'select';
-    default: string;
-    options: SelectOption[];
-}
-/** A number typed directly, optionally bounded. Use a slider field instead
- *  when the range matters more than the exact value. */
-interface NumberField extends ConfigFieldBase {
-    type: 'number';
-    default: number;
-    min?: number;
-    max?: number;
-    step?: number;
-}
-/** A free-text string. Writes are debounced so typing does not re-run the
- *  instrument on every keystroke. */
-interface TextField extends ConfigFieldBase {
-    type: 'text';
-    default: string;
-    placeholder?: string;
-    maxLength?: number;
-    /** Milliseconds to debounce live setConfig calls. Default 150 ms. Set to 0 to disable. */
-    debounceMs?: number;
-}
-/** A color, as a CSS color string. */
-interface ColorField extends ConfigFieldBase {
-    type: 'color';
-    default: string;
-}
-/** One field of an instrument's config schema. The schema is what the control
- *  panel renders, and what `validateConfigSchema` checks. */
-type ConfigField = SliderField | CheckboxField | SelectField | NumberField | TextField | ColorField;
-
-export type { Annotations as A, ConfigField as C, InferConfig as I, LeafPatch as L, NodeOptions as N, ResolvedConfig as R, SectionSpec as S, TextField as T, ConfigSchema as a, ConfigNode as b, ControlRenderer as c, ConfigOption as d, ConfigRule as e, ConfigRuleContext as f, CheckboxField as g, ColorField as h, ConfigFieldBase as i, ConfigFieldType as j, ConfigOf as k, NodeValue as l, NumberField as m, SelectField as n, SelectOption as o, SliderField as p };