@jbrowse/core 5.0.0-beta.1 → 5.0.0-beta.11

package/esm/configuration/requirements.js

@@ -0,0 +1,88 @@
+import { getConfigurationSchemaMetadata } from './schemaRegistry.js';
+import { isBareConfigurationSchemaType, isSlotDefinitionEntry, shorthandTargets, } from './schemaTypes.js';
+function memberOf(definition, name) {
+    return Object.hasOwn(definition, name) ? definition[name] : undefined;
+}
+function subSchemaOf(entry) {
+    return isBareConfigurationSchemaType(entry)
+        ? getConfigurationSchemaMetadata(entry)
+        : undefined;
+}
+function requiredPathProblem(modelName, definition, path) {
+    const [head = '', ...rest] = path;
+    const entry = memberOf(definition, head);
+    const sub = subSchemaOf(entry);
+    return entry === undefined
+        ? `${modelName} declares no "${head}"`
+        : rest.length > 0
+            ? sub
+                ? requiredPathProblem(sub.name, sub.definition, rest)
+                : `"${head}" is not a single sub-schema, so no path runs through it`
+            : isSlotDefinitionEntry(entry)
+                ? entry.defaultValue === undefined ||
+                    typeof entry.defaultValue === 'string'
+                    ? undefined
+                    : `"${head}" holds no string, and a requirement is met by naming one`
+                : sub?.options.shorthand !== undefined
+                    ? undefined
+                    : `"${head}" is neither a slot nor a sub-schema a string lifts into`;
+}
+export function checkRequirements(modelName, definition, requires) {
+    for (const { when, slots } of requires) {
+        for (const [slot, values = []] of Object.entries(when)) {
+            const entry = memberOf(definition, slot);
+            if (!isSlotDefinitionEntry(entry)) {
+                throw new Error(`${modelName} requires something when "${slot}" holds a value, and declares no such slot`);
+            }
+            const refused = values.filter(value => entry.model?.is(value) === false);
+            if (refused.length > 0) {
+                throw new Error(`${modelName} requires something when "${slot}" holds ${refused.join(', ')}, which the slot does not take`);
+            }
+        }
+        for (const path of slots) {
+            const problem = requiredPathProblem(modelName, definition, path.split('.'));
+            if (problem) {
+                throw new Error(`${modelName} requires "${path}", and ${problem}`);
+            }
+        }
+    }
+}
+function namesAValue(definition, snapshot, path) {
+    const [head = '', ...rest] = path;
+    const value = typeof snapshot === 'object' && snapshot !== null
+        ? snapshot[head]
+        : undefined;
+    const sub = subSchemaOf(memberOf(definition, head));
+    const named = sub && shorthandTargets(sub).string;
+    return rest.length > 0
+        ? sub !== undefined && namesAValue(sub.definition, value, rest)
+        : typeof value === 'string'
+            ? value !== ''
+            : sub !== undefined &&
+                named !== undefined &&
+                namesAValue(sub.definition, value, [named]);
+}
+/**
+ * #api core/configuration
+ * The `requires` entries of a configuration schema that `snapshot` does not
+ * meet, as a config file or `getSnapshot` spells it: a slot left off reads as
+ * its default, so a `when` value that is the default fires for an absent slot,
+ * which is what the generated JSON Schema's `if` does.
+ */
+export function requirementProblems(type, snapshot) {
+    const schema = getConfigurationSchemaMetadata(type);
+    if (!schema) {
+        return [];
+    }
+    const { definition } = schema;
+    return (schema.options.requires ?? [])
+        .filter(({ when }) => Object.entries(when).every(([slot, values]) => {
+        const entry = memberOf(definition, slot);
+        const held = snapshot[slot] ??
+            (isSlotDefinitionEntry(entry) ? entry.defaultValue : undefined);
+        return typeof held === 'string' && values?.includes(held);
+    }))
+        .flatMap(({ id, slots, message }) => slots
+        .filter(path => !namesAValue(definition, snapshot, path.split('.')))
+        .map(slot => ({ id, slot, message })));
+}

package/esm/configuration/schemaRegistry.d.ts

@@ -1,7 +1,9 @@
 import type { ConfigurationSchemaDefinition, MergedConfigurationSchemaOptions } from './configurationSchema.ts';
-import type { AnyConfigurationModel } from './types.ts';
+import type { AnyConfigurationModel, AnyConfigurationSchemaType } from './types.ts';
 import type { IAnyType } from '@jbrowse/mobx-state-tree';
 export interface ConfigurationSchemaMetadata {
+    /** the name `ConfigurationSchema` was given, e.g. `FeatureColor` */
+    name: string;
     /** the raw slot/sub-schema/constant table, also carrying per-slot editor metadata */
     definition: ConfigurationSchemaDefinition;
     /**
@@ -9,27 +11,42 @@ export interface ConfigurationSchemaMetadata {
      * i.e. with any `baseConfiguration`'s hooks already composed in
      */
     options: MergedConfigurationSchemaOptions<any, any>;
+    /** the frozen-family slots, the only members a snapshot's `null` is stored in */
+    storesNull: ReadonlySet<string>;
+    /** the `featureField` slots, which the reader hands over as written */
+    featureFields: ReadonlySet<string>;
+    /** the slots that refuse a `jexl:` string: every one but a callback and a featureField */
+    takesNoCallback: ReadonlyMap<string, string>;
 }
 export declare function registerConfigurationSchema(type: IAnyType, metadata: ConfigurationSchemaMetadata): void;
-export declare function getConfigurationSchemaMetadata(type: IAnyType): ConfigurationSchemaMetadata | undefined;
+/**
+ * A schema's metadata, by the schema type or a live node of it. Undefined for
+ * anything `ConfigurationSchema` did not build — a pluggable union, an array
+ * of schemas.
+ */
+export declare function getConfigurationSchemaMetadata(nodeOrType: AnyConfigurationModel | IAnyType): ConfigurationSchemaMetadata | undefined;
 export declare function isRegisteredConfigurationSchema(type: IAnyType): boolean;
+export interface ConfigurationSchemaUnionMetadata {
+    /** the name `ConfigurationSchemaUnion` was given, e.g. `MarkTransform` */
+    name: string;
+    /** each member schema, keyed by the `type` it answers to */
+    members: Record<string, AnyConfigurationSchemaType>;
+}
+export declare function registerConfigurationSchemaUnion(type: IAnyType, metadata: ConfigurationSchemaUnionMetadata): void;
+/**
+ * The name and members of a union `ConfigurationSchemaUnion` built, or
+ * undefined for any other type — a pluggable element union included.
+ */
+export declare function getConfigurationSchemaUnion(type: IAnyType): ConfigurationSchemaUnionMetadata | undefined;
 /**
  * The slot/sub-schema/constant table for a config (includes slots merged in from
  * `baseConfiguration` at schema construction). Undefined when the argument isn't
  * a registered configuration schema. The single accessor for "what are this
- * config's slots?" — shared by the slot facade, promotable defaults, and
- * `fullConfSnapshot`.
+ * config's slots?" — shared by the slot facade and `fullConfSnapshot`.
  *
- * Takes a live node *or* the schema type itself. Every in-tree reader holds a
- * node, which is why the `getType` hop is here; a caller enumerating registered
- * element types (`ConfigSlotDefaults.test.ts`) holds only the type, and for a
- * track schema it cannot get a node — `explicitIdentifier` makes `trackId` a
- * required MST identifier, so there is nothing to `create({})`.
+ * Takes a live node *or* the schema type itself: a caller enumerating
+ * registered element types (`ConfigSlotDefaults.test.ts`) holds only the type,
+ * and for a track schema it cannot get a node — `explicitIdentifier` makes
+ * `trackId` a required MST identifier, so there is nothing to `create({})`.
  */
 export declare function getConfigurationSchemaDefinition(nodeOrType: AnyConfigurationModel | IAnyType): ConfigurationSchemaDefinition | undefined;
-/**
- * The construction options a live config node's schema was built with
- * (identifier kind, `explicitlyTyped`, the `preProcessSnapshot` hook). Undefined
- * when the node's type isn't a registered configuration schema.
- */
-export declare function getConfigurationSchemaOptions(node: AnyConfigurationModel): MergedConfigurationSchemaOptions<any, any> | undefined;

package/esm/configuration/schemaRegistry.js

@@ -1,50 +1,48 @@
-import { getType, isType } from '@jbrowse/mobx-state-tree';
-// Per-schema metadata keyed by the MST type itself. Registered for BOTH the
-// outer stripDefault wrapper (what `ConfigurationSchema` returns and what
-// sub-schema properties hold) and the inner model (what `getType(node)` returns
-// for a live config), so a lookup succeeds from either handle.
-//
-// This replaces stamping `jbrowseSchemaDefinition`/`jbrowseSchemaOptions`/
-// `isJBrowseConfigurationSchema` onto the MST type objects: the type stays a
-// plain MST type, "is this a config schema" is registry membership instead of a
-// flag-or-name-match, and the metadata is reached by type identity. The map is
-// weak, so a discarded schema type is collected normally.
+import { getType, isType, unwrapType } from '@jbrowse/mobx-state-tree';
+// Per-schema metadata keyed by the model type `ConfigurationSchema` builds. A
+// lookup arrives by any handle on it — the stripDefault wrapper the factory
+// returns and a sub-schema property holds, an `optional` or `snapshotProcessor`
+// around that, a resolved `types.late`, or `getType(node)` — and `unwrapType`
+// takes each to the model. The type stays a plain MST type, "is this a config
+// schema" is registry membership, and the map is weak, so a discarded schema
+// type is collected normally.
 const schemaRegistry = new WeakMap();
 export function registerConfigurationSchema(type, metadata) {
     schemaRegistry.set(type, metadata);
 }
-export function getConfigurationSchemaMetadata(type) {
-    return schemaRegistry.get(type);
+/**
+ * A schema's metadata, by the schema type or a live node of it. Undefined for
+ * anything `ConfigurationSchema` did not build — a pluggable union, an array
+ * of schemas.
+ */
+export function getConfigurationSchemaMetadata(nodeOrType) {
+    return schemaRegistry.get(unwrapType(isType(nodeOrType) ? nodeOrType : getType(nodeOrType)));
 }
 export function isRegisteredConfigurationSchema(type) {
-    return schemaRegistry.has(type);
+    return schemaRegistry.has(unwrapType(type));
+}
+const unionRegistry = new WeakMap();
+export function registerConfigurationSchemaUnion(type, metadata) {
+    unionRegistry.set(type, metadata);
+}
+/**
+ * The name and members of a union `ConfigurationSchemaUnion` built, or
+ * undefined for any other type — a pluggable element union included.
+ */
+export function getConfigurationSchemaUnion(type) {
+    return unionRegistry.get(type);
 }
-// The three lookups above take a schema *type*; the two below take a live config
-// *node* and make the `getType` hop themselves, which is what every reader
-// actually wants — a node is what they hold. Leaving the hop to the call site is
-// how `slotFacade` came to reach the registry directly for `options` while going
-// through a helper for `definition`.
 /**
  * The slot/sub-schema/constant table for a config (includes slots merged in from
  * `baseConfiguration` at schema construction). Undefined when the argument isn't
  * a registered configuration schema. The single accessor for "what are this
- * config's slots?" — shared by the slot facade, promotable defaults, and
- * `fullConfSnapshot`.
+ * config's slots?" — shared by the slot facade and `fullConfSnapshot`.
  *
- * Takes a live node *or* the schema type itself. Every in-tree reader holds a
- * node, which is why the `getType` hop is here; a caller enumerating registered
- * element types (`ConfigSlotDefaults.test.ts`) holds only the type, and for a
- * track schema it cannot get a node — `explicitIdentifier` makes `trackId` a
- * required MST identifier, so there is nothing to `create({})`.
+ * Takes a live node *or* the schema type itself: a caller enumerating
+ * registered element types (`ConfigSlotDefaults.test.ts`) holds only the type,
+ * and for a track schema it cannot get a node — `explicitIdentifier` makes
+ * `trackId` a required MST identifier, so there is nothing to `create({})`.
  */
 export function getConfigurationSchemaDefinition(nodeOrType) {
-    return getConfigurationSchemaMetadata(isType(nodeOrType) ? nodeOrType : getType(nodeOrType))?.definition;
-}
-/**
- * The construction options a live config node's schema was built with
- * (identifier kind, `explicitlyTyped`, the `preProcessSnapshot` hook). Undefined
- * when the node's type isn't a registered configuration schema.
- */
-export function getConfigurationSchemaOptions(node) {
-    return getConfigurationSchemaMetadata(getType(node))?.options;
+    return getConfigurationSchemaMetadata(nodeOrType)?.definition;
 }

package/esm/configuration/schemaTypes.d.ts

@@ -1,14 +1,16 @@
 import type { ConfigSlotDefinition } from './configurationSlot.ts';
+import type { ConfigurationSchemaMetadata } from './schemaRegistry.ts';
 import type { AnyConfigurationModel, AnyConfigurationSchemaType } from './types.ts';
 /**
- * given a union of explicitly typed configuration schema types,
- * extract an array of the type names contained in the union
- *
- * @param unionType -
- * @returns Array of type names contained in the union
+ * The names an explicitly typed union's members answer to, each the name its
+ * schema was given, read through whatever wraps the union — a pluggable
+ * union's `snapshotProcessor`, a `maybe`, a `types.late`. A member that is
+ * itself a union contributes its own; a member with no type of its own throws.
  */
 export declare function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType: unknown): string[];
+/** The type `ConfigurationSchema()` built, by any handle on it (`schemaRegistry.ts`). */
 export declare function isBareConfigurationSchemaType(thing: unknown): thing is AnyConfigurationSchemaType;
+/** A schema, or a union, array or map of them. */
 export declare function isConfigurationSchemaType(thing: unknown): thing is AnyConfigurationSchemaType;
 /**
  * A configuration schema definition maps each key to exactly one of three kinds
@@ -21,3 +23,17 @@ export declare function isConfigurationSchemaType(thing: unknown): thing is AnyC
 export declare function isConstantEntry(def: unknown): def is string | number;
 export declare function isSlotDefinitionEntry(def: unknown): def is ConfigSlotDefinition;
 export declare function isConfigurationModel(thing: unknown): thing is AnyConfigurationModel;
+/** A bare value a schema's `shorthand` lifts. */
+export type ShorthandForm = 'string' | 'number';
+/**
+ * The slot a bare value of each form lifts into, off a `shorthand` option:
+ * each slot it names takes the form its own type holds, a number where it
+ * holds one (`rules: [7.3]`) and a string otherwise (`color: 'red'`), so a
+ * width naming `value` and `field` reads `size: 3` as the one and
+ * `size: 'score'` as the other.
+ */
+export declare function shorthandTargetsOf(definition: Record<string, unknown>, shorthand: string | readonly string[] | undefined): Partial<Record<ShorthandForm, string>>;
+/** The shorthand form of a bare value, or undefined for any other value. */
+export declare function bareFormOf(value: unknown): ShorthandForm | undefined;
+/** {@link shorthandTargetsOf} a registered schema. */
+export declare function shorthandTargets({ definition, options, }: ConfigurationSchemaMetadata): Partial<Record<ShorthandForm, string>>;

package/esm/configuration/schemaTypes.js

@@ -5,75 +5,50 @@
  * schema construction, every reader, and the config editor — so "is this a
  * config schema?" and "what kind of entry is this?" have one answer everywhere.
  */
-import { getType, isArrayType, isLateType, isMapType, isModelType, isOptionalType, isStateTreeNode, isType, isUnionType, } from '@jbrowse/mobx-state-tree';
-import { getDefaultValue, getSubType, getUnionSubTypes, resolveLateType, } from '../util/mst-reflection.js';
-import { isRegisteredConfigurationSchema } from './schemaRegistry.js';
+import { asArrayType, asMapType, getType, getUnionSubtypes, isStateTreeNode, isType, isUnionType, } from '@jbrowse/mobx-state-tree';
+import { getConfigurationSchemaMetadata, isRegisteredConfigurationSchema, } from './schemaRegistry.js';
 /**
- * given a union of explicitly typed configuration schema types,
- * extract an array of the type names contained in the union
- *
- * @param unionType -
- * @returns Array of type names contained in the union
+ * The names an explicitly typed union's members answer to, each the name its
+ * schema was given, read through whatever wraps the union — a pluggable
+ * union's `snapshotProcessor`, a `maybe`, a `types.late`. A member that is
+ * itself a union contributes its own; a member with no type of its own throws.
  */
 export function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType) {
-    if (isType(maybeUnionType)) {
-        const resolved = resolveLateType(maybeUnionType);
-        if (isUnionType(resolved)) {
-            const typeNames = [];
-            for (const subType of getUnionSubTypes(resolved)) {
-                const resolvedSub = resolveLateType(subType);
-                // a nested union contributes its own names; otherwise the subtype is a
-                // single explicitly-typed schema whose name is its default's `type`
-                const nested = getTypeNamesFromExplicitlyTypedUnion(resolvedSub);
-                if (nested.length) {
-                    typeNames.push(...nested);
-                }
-                else {
-                    const typeName = getDefaultValue(resolvedSub).type;
-                    if (!typeName) {
-                        throw new Error(`invalid config schema type ${resolvedSub}`);
-                    }
-                    typeNames.push(typeName);
-                }
-            }
-            return typeNames;
-        }
+    if (!isType(maybeUnionType) || !isUnionType(maybeUnionType)) {
+        return [];
     }
-    return [];
-}
-export function isBareConfigurationSchemaType(thing) {
-    if (isType(thing)) {
-        if (isModelType(thing) && isRegisteredConfigurationSchema(thing)) {
-            return true;
+    return getUnionSubtypes(maybeUnionType).flatMap(member => {
+        const meta = getConfigurationSchemaMetadata(member);
+        if (meta?.options.explicitlyTyped) {
+            return [meta.name];
         }
-        // if it's a late type, assume its a config schema
-        if (isLateType(thing)) {
-            return true;
+        if (isUnionType(member)) {
+            return getTypeNamesFromExplicitlyTypedUnion(member);
         }
-    }
-    return false;
+        // the branch a `maybe`-like union adds so the slot can be absent
+        if (member.name === 'undefined') {
+            return [];
+        }
+        throw new Error(`invalid config schema type ${member.name}`);
+    });
+}
+/** The type `ConfigurationSchema()` built, by any handle on it (`schemaRegistry.ts`). */
+export function isBareConfigurationSchemaType(thing) {
+    return isType(thing) && isRegisteredConfigurationSchema(thing);
 }
+/** A schema, or a union, array or map of them. */
 export function isConfigurationSchemaType(thing) {
-    // written as a series of if-statements instead of a big logical because this
-    // construction gives much better debugging backtraces.
-    // also, note that the order of these statements matters, because for example
-    // some union types are also optional types
     if (!isType(thing)) {
         return false;
     }
-    else if (isBareConfigurationSchemaType(thing)) {
+    if (isBareConfigurationSchemaType(thing)) {
         return true;
     }
-    else if (isUnionType(thing)) {
-        return getUnionSubTypes(thing).every(t => isConfigurationSchemaType(t) || t.name === 'undefined');
-    }
-    else if ((isOptionalType(thing) || isArrayType(thing) || isMapType(thing)) &&
-        isConfigurationSchemaType(getSubType(thing))) {
-        return true;
-    }
-    else {
-        return false;
+    if (isUnionType(thing)) {
+        return getUnionSubtypes(thing).every(t => isConfigurationSchemaType(t) || t.name === 'undefined');
     }
+    const collection = asArrayType(thing) ?? asMapType(thing);
+    return !!collection && isConfigurationSchemaType(collection.getChildType());
 }
 /**
  * A configuration schema definition maps each key to exactly one of three kinds
@@ -92,3 +67,39 @@ export function isSlotDefinitionEntry(def) {
 export function isConfigurationModel(thing) {
     return isStateTreeNode(thing) && isConfigurationSchemaType(getType(thing));
 }
+const NUMBER_SLOT_TYPES = new Set(['number', 'integer', 'maybeNumber']);
+/**
+ * The slot a bare value of each form lifts into, off a `shorthand` option:
+ * each slot it names takes the form its own type holds, a number where it
+ * holds one (`rules: [7.3]`) and a string otherwise (`color: 'red'`), so a
+ * width naming `value` and `field` reads `size: 3` as the one and
+ * `size: 'score'` as the other.
+ */
+export function shorthandTargetsOf(definition, shorthand) {
+    const slots = shorthand === undefined
+        ? []
+        : typeof shorthand === 'string'
+            ? [shorthand]
+            : shorthand;
+    return Object.fromEntries(slots.map(slot => {
+        const entry = definition[slot];
+        return [
+            isSlotDefinitionEntry(entry) && NUMBER_SLOT_TYPES.has(entry.type)
+                ? 'number'
+                : 'string',
+            slot,
+        ];
+    }));
+}
+/** The shorthand form of a bare value, or undefined for any other value. */
+export function bareFormOf(value) {
+    return typeof value === 'string'
+        ? 'string'
+        : typeof value === 'number'
+            ? 'number'
+            : undefined;
+}
+/** {@link shorthandTargetsOf} a registered schema. */
+export function shorthandTargets({ definition, options, }) {
+    return shorthandTargetsOf(definition, options.shorthand);
+}

package/esm/configuration/slotFacade.d.ts

@@ -1,24 +1,19 @@
 import type PluginManager from '../PluginManager.ts';
 import type { ConfigSlotDefinition, ConfigSlotType } from './configurationSlot.ts';
 import type { AnyConfigurationModel } from './types.ts';
+import type { IAnyType } from '@jbrowse/mobx-state-tree';
 /**
  * Whether `slotName` on a config node is a slot (vs a nested sub-schema or a
  * string/number constant).
  */
 export declare function isConfigurationSlot(node: AnyConfigurationModel, slotName: string): boolean;
 /**
- * Run `node`'s own schema `preProcessSnapshot` over a partial bag of slot
- * values headed for that config.
- *
- * A config.json snapshot gets this for free on `create`, but the session/URL
- * path writes slots one `setSlot` at a time onto an already-created config, so
- * without this a schema's shorthand expansions and legacy-key migrations apply
- * to `config.json` and silently no-op in a session spec, share link, or embed —
- * the surfaces that are supposed to speak the same vocabulary. The hooks are
- * written to normalize whatever subset of keys they're handed, so a partial bag
- * is the same shape they already tolerate.
+ * Why a config of type `schema` cannot hold `value` at `key`, or undefined
+ * when it can: the schema's own lift first, then the slot's type, or a
+ * sub-schema's lift and checks. Also undefined for a key the schema does not
+ * declare, which is a question for its caller.
  */
-export declare function preProcessSlotValues(node: AnyConfigurationModel, values: Record<string, unknown>): Record<string, unknown>;
+export declare function slotValueRefusal(schema: IAnyType, key: string, value: unknown): string | undefined;
 /**
  * The duck-typed object the config editor's leaf components consume. They never
  * touch MST internals — only this shape (see ColorEditor.test.tsx, which passes
@@ -33,20 +28,9 @@ export interface SlotFacade {
     contextVariable: string[];
     defaultValue: unknown;
     /**
-     * For a `promotable` slot, the value its unset state resolves to when nothing
-     * is promoted (see `promotableResolve.ts`). Undefined on a plain slot, whose
-     * `defaultValue` is already the concrete value.
-     *
-     * Here because a promotable slot's `defaultValue` is always the `undefined`
-     * inherit sentinel, so an editor rendering `defaultValue` for an unset slot
-     * shows nothing at all — for a `maybeBoolean` that reads as a concrete
-     * `false`, which is wrong for every slot whose base is `true`. The editor
-     * still cannot see the *session* tier of the cascade (its target is often a
-     * detached config node), so this is the honest answer it can give: what unset
-     * means with nothing promoted.
+     * enum choices, present only for the enum slot types; a `stringEnumArray`'s
+     * are the choices of each entry
      */
-    promotedBase?: unknown;
-    /** enum choices, present only for `stringEnum`/`maybeStringEnum` slots */
     choices?: string[];
     pluginManager: PluginManager;
     readonly value: unknown;
@@ -54,17 +38,16 @@ export interface SlotFacade {
      * Whether the slot holds a non-default value. Each slot is `stripDefault`-
      * wrapped, so an at-default slot is omitted from the config snapshot — the
      * same signal the persistence/delta layer uses (robust for map/array slots
-     * where a live-value `deepEqual` against the plain default would misfire). For
-     * a promotable slot, "non-default" means customized rather than inheriting.
+     * where a live-value `deepEqual` against the plain default would misfire).
      */
     readonly modified: boolean;
     set: (val: unknown) => void;
 }
 /**
  * The vocabulary an enum slot offers, or undefined for any other slot. Reads the
- * author's own `types.enumeration` off `model` — `stringEnum` and
- * `maybeStringEnum` are the only two types the editor takes choices from, so a
- * slot typed anything else renders as free text however valid its `model` is.
+ * author's own `types.enumeration` off `model` — the enum types are the only
+ * ones the editor takes choices from, so a slot typed anything else renders as
+ * free text however valid its `model` is.
  *
  * Shared by the config editor's facade below and by
  * `ConfigSlotDefaults.test.ts`, which snapshots every schema's vocabularies:

package/esm/configuration/slotFacade.js

@@ -1,8 +1,11 @@
-import { getSnapshot } from '@jbrowse/mobx-state-tree';
+import { asModelType, getSnapshot } from '@jbrowse/mobx-state-tree';
 import { getEnumerationValues } from '../util/mst-reflection.js';
 import { getEnv } from '../util/mstUtils.js';
-import { getConfigurationSchemaDefinition, getConfigurationSchemaOptions, } from './schemaRegistry.js';
-import { isSlotDefinitionEntry } from './schemaTypes.js';
+import { slotWriteRefusal } from './configurationSlot.js';
+import { setConf } from './getConf.js';
+import { getConfigurationSchemaDefinition, getConfigurationSchemaMetadata, } from './schemaRegistry.js';
+import { isConfigurationSchemaType, isSlotDefinitionEntry, } from './schemaTypes.js';
+import { preProcessSnapshotWith } from './snapshotPreprocess.js';
 /**
  * The slot's metadata entry, or undefined when `slotName` names a nested
  * sub-schema or a string/number constant rather than a slot.
@@ -19,26 +22,42 @@ export function isConfigurationSlot(node, slotName) {
     return !!slotDefinition(node, slotName);
 }
 /**
- * Run `node`'s own schema `preProcessSnapshot` over a partial bag of slot
- * values headed for that config.
- *
- * A config.json snapshot gets this for free on `create`, but the session/URL
- * path writes slots one `setSlot` at a time onto an already-created config, so
- * without this a schema's shorthand expansions and legacy-key migrations apply
- * to `config.json` and silently no-op in a session spec, share link, or embed —
- * the surfaces that are supposed to speak the same vocabulary. The hooks are
- * written to normalize whatever subset of keys they're handed, so a partial bag
- * is the same shape they already tolerate.
+ * Why a config of type `schema` cannot hold `value` at `key`, or undefined
+ * when it can: the schema's own lift first, then the slot's type, or a
+ * sub-schema's lift and checks. Also undefined for a key the schema does not
+ * declare, which is a question for its caller.
  */
-export function preProcessSlotValues(node, values) {
-    const preProcess = getConfigurationSchemaOptions(node)?.preProcessSnapshot;
-    return preProcess ? preProcess(values) : values;
+export function slotValueRefusal(schema, key, value) {
+    const meta = getConfigurationSchemaMetadata(schema);
+    const entry = meta?.definition[key];
+    if (!meta || entry === undefined) {
+        return undefined;
+    }
+    const subSchema = isConfigurationSchemaType(entry)
+        ? entry
+        : undefined;
+    // the slot's own property type, built once with the schema: what `setSlot`
+    // checks a write against
+    const slotType = asModelType(schema)?.properties[key];
+    try {
+        const lifted = preProcessSnapshotWith(meta, { [key]: value })[key];
+        if (subSchema) {
+            subSchema.create(lifted);
+        }
+        else if (isSlotDefinitionEntry(entry) && !slotType?.is(lifted)) {
+            return slotWriteRefusal(`${meta.name}.${key}`, entry.type, value);
+        }
+        return undefined;
+    }
+    catch (e) {
+        return e instanceof Error ? e.message : String(e);
+    }
 }
 /**
  * The vocabulary an enum slot offers, or undefined for any other slot. Reads the
- * author's own `types.enumeration` off `model` — `stringEnum` and
- * `maybeStringEnum` are the only two types the editor takes choices from, so a
- * slot typed anything else renders as free text however valid its `model` is.
+ * author's own `types.enumeration` off `model` — the enum types are the only
+ * ones the editor takes choices from, so a slot typed anything else renders as
+ * free text however valid its `model` is.
  *
  * Shared by the config editor's facade below and by
  * `ConfigSlotDefaults.test.ts`, which snapshots every schema's vocabularies:
@@ -47,7 +66,10 @@ export function preProcessSlotValues(node, values) {
  */
 export function slotChoices(def) {
     const { type, model } = def;
-    return (type === 'stringEnum' || type === 'maybeStringEnum') && model
+    return (type === 'stringEnum' ||
+        type === 'maybeStringEnum' ||
+        type === 'stringEnumArray') &&
+        model
         ? getEnumerationValues(model)
         : undefined;
 }
@@ -66,14 +88,13 @@ export function getSlotDefinition(node, slotName) {
 }
 export function makeSlotFacade(node, slotName) {
     const definition = getSlotDefinition(node, slotName);
-    const { type, description = '', defaultValue, promotedBase, contextVariable = [], } = definition;
+    const { type, description = '', defaultValue, contextVariable = [], } = definition;
     return {
         name: slotName,
         description,
         type,
         contextVariable,
         defaultValue,
-        promotedBase,
         choices: slotChoices(definition),
         pluginManager: getEnv(node).pluginManager,
         get value() {
@@ -83,7 +104,7 @@ export function makeSlotFacade(node, slotName) {
             return slotName in getSnapshot(node);
         },
         set(val) {
-            node.setSlot(slotName, val);
+            setConf(node, slotName, val);
         },
     };
 }