@jbrowse/core 5.0.0-beta.7 → 5.0.0-beta.9

package/esm/pluggableElementTypes/models/BaseConnectionModelFactory.d.ts

@@ -14,16 +14,26 @@ declare function stateModelFactory(pluginManager: PluginManager): import("@jbrow
      */
     configuration: import("../../configuration/configurationSchema.ts").IConfigurationReference<import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
         readonly name: {
-            readonly type: "string";
-            readonly defaultValue: "nameOfConnection";
-            readonly description: "a unique name for this connection";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly assemblyNames: {
-            readonly type: "stringArray";
-            readonly defaultValue: readonly [];
-            readonly description: "optional list of names of assemblies in this connection";
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "connectionId">>>;
+        type: {
+            type: "string";
+        } & {
+            defaultValue: string;
+        };
+        connectionId: {
+            type: "string";
+        } & {
+            defaultValue: string;
+        };
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "connectionId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>>;
     /**
      * #property
      * set when the connection is being re-established on session load (its

package/esm/pluggableElementTypes/models/BaseDisplayModel.d.ts

@@ -1,6 +1,7 @@
 import type { AnyConfigurationModel } from '../../configuration/index.ts';
 import type { MenuItem } from '../../ui/index.ts';
 import type { RpcStatus } from '../../util/progress.ts';
+import type { UnappliedSetting } from '../../util/unknownSnapshotKeys.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
 import type React from 'react';
 export declare const BaseDisplay: import("@jbrowse/mobx-state-tree").IModelType<{
@@ -202,15 +203,14 @@ export declare const BaseDisplay: import("@jbrowse/mobx-state-tree").IModelType<
     readonly featureNoun: string;
     /**
      * #getter
-     * Overridable hook: which widget `openFeatureWidget` opens for one of
-     * this display's features. The default is the generic one, which is what
-     * a display drawing plain features wants and what the canvas base spelled
-     * out by hand.
+     * The widget `openFeatureWidget` opens for one of this display's
+     * features. Displays may override it. The default is the generic feature
+     * widget, for displays drawing plain features.
      *
-     * An override is a display whose features have a vocabulary of their own —
-     * a read, a variant, a synteny block — and the `id` is deliberately part
-     * of it: two displays naming one id share the drawer panel, which is the
-     * behaviour when the two are showing the same kind of thing.
+     * Displays whose features are a specific kind (a read, a variant, a
+     * synteny block) override it, including the `id`: two displays naming
+     * one id share the drawer panel, which suits two displays showing the
+     * same kind of feature.
      */
     readonly featureWidgetType: {
         type: string;
@@ -423,15 +423,14 @@ export declare const BaseDisplay: import("@jbrowse/mobx-state-tree").IModelType<
             readonly featureNoun: string;
             /**
              * #getter
-             * Overridable hook: which widget `openFeatureWidget` opens for one of
-             * this display's features. The default is the generic one, which is what
-             * a display drawing plain features wants and what the canvas base spelled
-             * out by hand.
+             * The widget `openFeatureWidget` opens for one of this display's
+             * features. Displays may override it. The default is the generic feature
+             * widget, for displays drawing plain features.
              *
-             * An override is a display whose features have a vocabulary of their own —
-             * a read, a variant, a synteny block — and the `id` is deliberately part
-             * of it: two displays naming one id share the drawer panel, which is the
-             * behaviour when the two are showing the same kind of thing.
+             * Displays whose features are a specific kind (a read, a variant, a
+             * synteny block) override it, including the `id`: two displays naming
+             * one id share the drawer panel, which suits two displays showing the
+             * same kind of feature.
              */
             readonly featureWidgetType: {
                 type: string;
@@ -636,15 +635,14 @@ export declare const BaseDisplay: import("@jbrowse/mobx-state-tree").IModelType<
             readonly featureNoun: string;
             /**
              * #getter
-             * Overridable hook: which widget `openFeatureWidget` opens for one of
-             * this display's features. The default is the generic one, which is what
-             * a display drawing plain features wants and what the canvas base spelled
-             * out by hand.
+             * The widget `openFeatureWidget` opens for one of this display's
+             * features. Displays may override it. The default is the generic feature
+             * widget, for displays drawing plain features.
              *
-             * An override is a display whose features have a vocabulary of their own —
-             * a read, a variant, a synteny block — and the `id` is deliberately part
-             * of it: two displays naming one id share the drawer panel, which is the
-             * behaviour when the two are showing the same kind of thing.
+             * Displays whose features are a specific kind (a read, a variant, a
+             * synteny block) override it, including the `id`: two displays naming
+             * one id share the drawer panel, which suits two displays showing the
+             * same kind of feature.
              */
             readonly featureWidgetType: {
                 type: string;
@@ -686,40 +684,39 @@ export declare const BaseDisplay: import("@jbrowse/mobx-state-tree").IModelType<
     reload(): void;
     /**
      * #action
-     * Apply a bag of display settings to the LIVE display, and report what
-     * landed. Each key runs through the display config schema's
-     * `preProcessSnapshot` (shorthand expansions, legacy-key migrations —
-     * the same lowering a session spec's inline track keys get in
-     * `showTrackGeneric`), then writes the matching config slot. Keys that
-     * are not slots come back in `unapplied` rather than vanishing: the
-     * settings vocabulary's historical failure mode is the silently dropped
-     * key.
+     * Apply a set of display settings to the live display, and report which
+     * were applied. Each key runs through the display config schema's
+     * `preProcessSnapshot` (shorthand expansions and legacy-key migrations,
+     * as `showTrackGeneric` applies to a session spec's inline track keys),
+     * then writes the matching config slot. A key naming a sub-schema
+     * (`facet`, `color`) replaces the whole object, its string shorthand
+     * lifted by that schema, and `null` clears it. Keys that are not slots
+     * come back in `unapplied` as `{ key, reason }`, so a caller can tell a
+     * misspelling from a key that has an action instead of a slot.
      *
-     * `allowSetters` additionally routes a non-slot key to a conventionally
-     * named single-argument `set<Key>` action. Opt-in, never the default:
-     * the declarative surfaces (session specs, share links, embeds) feed
-     * this whole bags of untyped JSON, and a blanket fallback would let
-     * them reach internal setters (`setError`, `setScrollTop`, ...) and
+     * `allowSetters` also routes a non-slot key to a single-argument action
+     * named `set<Key>`. It is off by default because session specs, share
+     * links and embeds pass untyped JSON here, and a default fallback would
+     * let them call internal setters (`setError`, `setScrollTop`, ...) and
      * call multi-argument setters with one argument. A caller that wants a
-     * specific action can also simply call it.
+     * specific action can call it directly.
      *
-     * A key whose write THREW is reported separately, in `failed` — it is the
-     * only one of the three that means the caller got something wrong, and
-     * the only one worth a notification. `unapplied` is not: at the
-     * `showTrackGeneric` call site it also collects keys that surface
-     * consumed itself (`type`) and MST display props the display snapshot
-     * already applied (`resolution`), so treating it as "dropped" would
-     * report a correct call as broken.
+     * A key whose write threw is reported in `failed`. Only `failed` means
+     * the caller passed a bad value. `unapplied` needs the caller's own
+     * context to read: `showTrackGeneric` spreads the same settings into the
+     * display's snapshot, so a declared prop (`resolution`) has already
+     * landed by the time it reports here, while the restyle path spreads
+     * nothing and every entry there did nothing.
      *
-     * Per-key errors do not abort the rest of the bag — a caller
+     * A per-key error does not abort the remaining keys. A caller
      * mid-`showTrack` has already pushed the track, and one rejected value
-     * must not strand a half-configured track.
+     * should not leave it half-configured.
      */
     applyDisplaySettings(settings: Record<string, unknown>, options?: {
         allowSetters?: boolean;
     }): {
         applied: string[];
-        unapplied: string[];
+        unapplied: UnappliedSetting[];
         failed: {
             key: string;
             error: string;

package/esm/pluggableElementTypes/models/BaseDisplayModel.js

@@ -1,7 +1,8 @@
 import { hasParent, isAlive, types } from '@jbrowse/mobx-state-tree';
-import { getConf, isConfigurationSlot, preProcessSlotValues, } from '../../configuration/index.js';
+import { getConf, isConfigurationSlot, isConfigurationSubschema, mergedSubschemaValue, preProcessSlotValues, } from '../../configuration/index.js';
 import { getContainingTrack, getEnv, statusFraction, statusMessageText, } from '../../util/index.js';
 import { ElementId } from '../../util/types/mst.js';
+import { displaySetterName } from '../../util/unknownSnapshotKeys.js';
 /**
  * #stateModel BaseDisplay
  * #category display
@@ -139,15 +140,14 @@ function stateModelFactory() {
         },
         /**
          * #getter
-         * Overridable hook: which widget `openFeatureWidget` opens for one of
-         * this display's features. The default is the generic one, which is what
-         * a display drawing plain features wants and what the canvas base spelled
-         * out by hand.
+         * The widget `openFeatureWidget` opens for one of this display's
+         * features. Displays may override it. The default is the generic feature
+         * widget, for displays drawing plain features.
          *
-         * An override is a display whose features have a vocabulary of their own —
-         * a read, a variant, a synteny block — and the `id` is deliberately part
-         * of it: two displays naming one id share the drawer panel, which is the
-         * behaviour when the two are showing the same kind of thing.
+         * Displays whose features are a specific kind (a read, a variant, a
+         * synteny block) override it, including the `id`: two displays naming
+         * one id share the drawer panel, which suits two displays showing the
+         * same kind of feature.
          */
         get featureWidgetType() {
             return {
@@ -212,34 +212,33 @@ function stateModelFactory() {
         reload() { },
         /**
          * #action
-         * Apply a bag of display settings to the LIVE display, and report what
-         * landed. Each key runs through the display config schema's
-         * `preProcessSnapshot` (shorthand expansions, legacy-key migrations —
-         * the same lowering a session spec's inline track keys get in
-         * `showTrackGeneric`), then writes the matching config slot. Keys that
-         * are not slots come back in `unapplied` rather than vanishing: the
-         * settings vocabulary's historical failure mode is the silently dropped
-         * key.
+         * Apply a set of display settings to the live display, and report which
+         * were applied. Each key runs through the display config schema's
+         * `preProcessSnapshot` (shorthand expansions and legacy-key migrations,
+         * as `showTrackGeneric` applies to a session spec's inline track keys),
+         * then writes the matching config slot. A key naming a sub-schema
+         * (`facet`, `color`) replaces the whole object, its string shorthand
+         * lifted by that schema, and `null` clears it. Keys that are not slots
+         * come back in `unapplied` as `{ key, reason }`, so a caller can tell a
+         * misspelling from a key that has an action instead of a slot.
          *
-         * `allowSetters` additionally routes a non-slot key to a conventionally
-         * named single-argument `set<Key>` action. Opt-in, never the default:
-         * the declarative surfaces (session specs, share links, embeds) feed
-         * this whole bags of untyped JSON, and a blanket fallback would let
-         * them reach internal setters (`setError`, `setScrollTop`, ...) and
+         * `allowSetters` also routes a non-slot key to a single-argument action
+         * named `set<Key>`. It is off by default because session specs, share
+         * links and embeds pass untyped JSON here, and a default fallback would
+         * let them call internal setters (`setError`, `setScrollTop`, ...) and
          * call multi-argument setters with one argument. A caller that wants a
-         * specific action can also simply call it.
+         * specific action can call it directly.
          *
-         * A key whose write THREW is reported separately, in `failed` — it is the
-         * only one of the three that means the caller got something wrong, and
-         * the only one worth a notification. `unapplied` is not: at the
-         * `showTrackGeneric` call site it also collects keys that surface
-         * consumed itself (`type`) and MST display props the display snapshot
-         * already applied (`resolution`), so treating it as "dropped" would
-         * report a correct call as broken.
+         * A key whose write threw is reported in `failed`. Only `failed` means
+         * the caller passed a bad value. `unapplied` needs the caller's own
+         * context to read: `showTrackGeneric` spreads the same settings into the
+         * display's snapshot, so a declared prop (`resolution`) has already
+         * landed by the time it reports here, while the restyle path spreads
+         * nothing and every entry there did nothing.
          *
-         * Per-key errors do not abort the rest of the bag — a caller
+         * A per-key error does not abort the remaining keys. A caller
          * mid-`showTrack` has already pushed the track, and one rejected value
-         * must not strand a half-configured track.
+         * should not leave it half-configured.
          */
         applyDisplaySettings(settings, options) {
             // configuration is the reference every concrete display adds at
@@ -252,7 +251,7 @@ function stateModelFactory() {
             const slots = preProcessSlotValues(configuration, settings);
             for (const [key, value] of Object.entries(slots)) {
                 if (!key || key === 'type') {
-                    unapplied.push(key ? 'type (switch the display type instead)' : '(empty key)');
+                    unapplied.push({ key, reason: key ? 'display-type' : 'no-slot' });
                     continue;
                 }
                 try {
@@ -264,9 +263,14 @@ function stateModelFactory() {
                         applied.push(key);
                         continue;
                     }
-                    const setter = self[`set${key[0].toUpperCase()}${key.slice(1)}`];
+                    if (isConfigurationSubschema(configuration, key)) {
+                        configuration.setSubschema(key, mergedSubschemaValue(configuration, key, value));
+                        applied.push(key);
+                        continue;
+                    }
+                    const setter = self[displaySetterName(key)];
                     if (typeof setter !== 'function') {
-                        unapplied.push(key);
+                        unapplied.push({ key, reason: 'no-slot' });
                     }
                     else if (options?.allowSetters) {
                         ;
@@ -274,7 +278,7 @@ function stateModelFactory() {
                         applied.push(`${key} (via setter)`);
                     }
                     else {
-                        unapplied.push(`${key} (not a config slot; a set${key[0].toUpperCase()}${key.slice(1)} action exists — call it, or pass { allowSetters: true })`);
+                        unapplied.push({ key, reason: 'setter-only' });
                     }
                 }
                 catch (e) {

package/esm/pluggableElementTypes/models/BaseTrackModel.d.ts

@@ -1,6 +1,6 @@
 import type PluginManager from '../../PluginManager.ts';
 import type { RefNameMismatch } from '../../assemblyManager/refNameMismatch.ts';
-import type { AnyConfigurationSchemaType } from '../../configuration/index.ts';
+import type { AnyConfigurationModel, AnyConfigurationSchemaType } from '../../configuration/index.ts';
 import type { MenuItem } from '../../ui/index.ts';
 import type { DisplayModel } from './BaseDisplayModel.tsx';
 import type { FileTypeExporter } from './saveTrackFileTypes/types.ts';
@@ -107,10 +107,7 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
      * always filtered them; this exposes the same list to code, because the
      * alternative is every caller re-deriving it from the plugin manager.
      */
-    readonly compatibleDisplays: (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: Record<string, unknown>): any;
-        setSlot(slotName: string, value: unknown): void;
-    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>)[];
+    readonly compatibleDisplays: AnyConfigurationModel[];
     /**
      * #getter
      */
@@ -146,7 +143,7 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
     /**
      * #getter
      */
-    readonly adapterType: import("../AdapterType.ts").default;
+    readonly adapterType: import("../AdapterType.ts").default<any>;
 } & {
     /**
      * #action
@@ -175,7 +172,7 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
         allowSetters?: boolean;
     }): {
         applied: string[];
-        unapplied: string[];
+        unapplied: import("../../util/unknownSnapshotKeys.ts").UnappliedSetting[];
         failed: {
             key: string;
             error: string;
@@ -236,12 +233,12 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
     readonly exportsDataViaAdapter: boolean;
     /**
      * #getter
-     * What "Save track data" may pull before it asks. The adapter's own
-     * `fetchSizeLimit` where it declares one, so a save does not quietly
-     * disagree with the size this track's display already refuses to render;
-     * otherwise a default. Deliberately generous — unlike the display's gate
-     * this is a confirmation rather than a refusal, and the user asked for
-     * these bytes by name.
+     * The size in bytes above which "Save track data" asks for confirmation
+     * before fetching. Uses the adapter's `fetchSizeLimit` where it declares
+     * one, so a save asks at the same size at which the track's display
+     * refuses to render; otherwise a default. The default is generous
+     * because exceeding it only prompts for confirmation, and the user
+     * explicitly requested the data.
      */
     readonly exportByteLimit: number;
     /**

package/esm/pluggableElementTypes/models/BaseTrackModel.js

@@ -403,12 +403,12 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
         },
         /**
          * #getter
-         * What "Save track data" may pull before it asks. The adapter's own
-         * `fetchSizeLimit` where it declares one, so a save does not quietly
-         * disagree with the size this track's display already refuses to render;
-         * otherwise a default. Deliberately generous — unlike the display's gate
-         * this is a confirmation rather than a refusal, and the user asked for
-         * these bytes by name.
+         * The size in bytes above which "Save track data" asks for confirmation
+         * before fetching. Uses the adapter's `fetchSizeLimit` where it declares
+         * one, so a save asks at the same size at which the track's display
+         * refuses to render; otherwise a default. The default is generous
+         * because exceeding it only prompts for confirmation, and the user
+         * explicitly requested the data.
          */
         get exportByteLimit() {
             return adapterByteLimit(getConf(self, ['adapter', 'fetchSizeLimit']), DEFAULT_EXPORT_BYTE_LIMIT);

package/esm/pluggableElementTypes/models/BaseViewModel.d.ts

@@ -47,15 +47,25 @@ declare const BaseViewModel: import("@jbrowse/mobx-state-tree").IModelType<{
 } & {
     /**
      * #getter
-     * Whether this view's body is in the DOM, counting the views it is nested
-     * inside — which is the question a display's phase actually asks.
+     * Overridable hook (default true): whether this view's mounted body
+     * renders its own displays. A linear genome view collapsed to its ruler
+     * mounts the scalebar and none of its tracks, so a display in it can no
+     * more paint than one in a view scrolled off screen. Views nested in this
+     * one are unaffected: they paint wherever their own body is.
+     */
+    readonly rendersDisplays: boolean;
+    /**
+     * #getter
+     * Whether this view's displays have a canvas to paint into: its body is in
+     * the DOM, counting the views it is nested inside, and the body renders
+     * them (`rendersDisplays`). This is the question a display's phase asks.
      *
-     * `bodyMounted` alone answers it only for a view a container renders
-     * directly. A view nested in another view (a synteny row, a breakpoint
-     * panel) has no container writing its flag, so it reads `true` forever
-     * while its whole subtree is out of the DOM, and every display in it waits
-     * for a first paint that nothing will make — the hang this flag exists to
-     * prevent, one level down.
+     * `bodyMounted` alone answers the DOM half only for a view a container
+     * renders directly. A view nested in another view (a synteny row, a
+     * breakpoint panel) has no container writing its flag, so it reads `true`
+     * forever while its whole subtree is out of the DOM, and every display in
+     * it waits for a first paint that nothing will make — the hang this flag
+     * exists to prevent, one level down.
      *
      * An ancestor that does not carry the flag at all leaves the answer alone
      * rather than excusing the paint: only an explicit `false` unmounts, so a
@@ -177,15 +187,25 @@ export declare const BaseViewModelWithDisplayedRegions: import("@jbrowse/mobx-st
 } & {
     /**
      * #getter
-     * Whether this view's body is in the DOM, counting the views it is nested
-     * inside — which is the question a display's phase actually asks.
-     *
-     * `bodyMounted` alone answers it only for a view a container renders
-     * directly. A view nested in another view (a synteny row, a breakpoint
-     * panel) has no container writing its flag, so it reads `true` forever
-     * while its whole subtree is out of the DOM, and every display in it waits
-     * for a first paint that nothing will make — the hang this flag exists to
-     * prevent, one level down.
+     * Overridable hook (default true): whether this view's mounted body
+     * renders its own displays. A linear genome view collapsed to its ruler
+     * mounts the scalebar and none of its tracks, so a display in it can no
+     * more paint than one in a view scrolled off screen. Views nested in this
+     * one are unaffected: they paint wherever their own body is.
+     */
+    readonly rendersDisplays: boolean;
+    /**
+     * #getter
+     * Whether this view's displays have a canvas to paint into: its body is in
+     * the DOM, counting the views it is nested inside, and the body renders
+     * them (`rendersDisplays`). This is the question a display's phase asks.
+     *
+     * `bodyMounted` alone answers the DOM half only for a view a container
+     * renders directly. A view nested in another view (a synteny row, a
+     * breakpoint panel) has no container writing its flag, so it reads `true`
+     * forever while its whole subtree is out of the DOM, and every display in
+     * it waits for a first paint that nothing will make — the hang this flag
+     * exists to prevent, one level down.
      *
      * An ancestor that does not carry the flag at all leaves the answer alone
      * rather than excusing the paint: only an explicit `false` unmounts, so a

package/esm/pluggableElementTypes/models/BaseViewModel.js

@@ -20,6 +20,10 @@ function containingViewOf(node) {
     }
     return undefined;
 }
+function bodyInDom(view) {
+    const parent = containingViewOf(view);
+    return (view.bodyMounted !== false && (parent === undefined || bodyInDom(parent)));
+}
 /**
  * #stateModel BaseViewModel
  * #category view
@@ -69,15 +73,27 @@ const BaseViewModel = types
     .views(self => ({
     /**
      * #getter
-     * Whether this view's body is in the DOM, counting the views it is nested
-     * inside — which is the question a display's phase actually asks.
+     * Overridable hook (default true): whether this view's mounted body
+     * renders its own displays. A linear genome view collapsed to its ruler
+     * mounts the scalebar and none of its tracks, so a display in it can no
+     * more paint than one in a view scrolled off screen. Views nested in this
+     * one are unaffected: they paint wherever their own body is.
+     */
+    get rendersDisplays() {
+        return true;
+    },
+    /**
+     * #getter
+     * Whether this view's displays have a canvas to paint into: its body is in
+     * the DOM, counting the views it is nested inside, and the body renders
+     * them (`rendersDisplays`). This is the question a display's phase asks.
      *
-     * `bodyMounted` alone answers it only for a view a container renders
-     * directly. A view nested in another view (a synteny row, a breakpoint
-     * panel) has no container writing its flag, so it reads `true` forever
-     * while its whole subtree is out of the DOM, and every display in it waits
-     * for a first paint that nothing will make — the hang this flag exists to
-     * prevent, one level down.
+     * `bodyMounted` alone answers the DOM half only for a view a container
+     * renders directly. A view nested in another view (a synteny row, a
+     * breakpoint panel) has no container writing its flag, so it reads `true`
+     * forever while its whole subtree is out of the DOM, and every display in
+     * it waits for a first paint that nothing will make — the hang this flag
+     * exists to prevent, one level down.
      *
      * An ancestor that does not carry the flag at all leaves the answer alone
      * rather than excusing the paint: only an explicit `false` unmounts, so a
@@ -85,8 +101,7 @@ const BaseViewModel = types
      * that shows up as a slow test rather than as a picture of an empty view.
      */
     get effectiveBodyMounted() {
-        return (self.bodyMounted &&
-            containingViewOf(self)?.effectiveBodyMounted !== false);
+        return this.rendersDisplays && bodyInDom(self);
     },
     /**
      * #method

package/esm/pluggableElementTypes/models/InternetAccountModel.d.ts

@@ -20,31 +20,41 @@ export declare const InternetAccount: import("@jbrowse/mobx-state-tree").IModelT
      */
     configuration: import("../../configuration/configurationSchema.ts").IConfigurationReference<import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
         readonly name: {
-            readonly description: "descriptive name of the internet account";
-            readonly type: "string";
-            readonly defaultValue: "";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly description: {
-            readonly description: "a description of the internet account";
-            readonly type: "string";
-            readonly defaultValue: "";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly authHeader: {
-            readonly description: "request header for credentials";
-            readonly type: "string";
-            readonly defaultValue: "Authorization";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly tokenType: {
-            readonly description: "a custom name for a token to include in the header";
-            readonly type: "string";
-            readonly defaultValue: "";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly domains: {
-            readonly description: "array of valid domains the url can contain to use this account";
-            readonly type: "stringArray";
-            readonly defaultValue: readonly [];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId">>>;
+        type: {
+            type: "string";
+        } & {
+            defaultValue: string;
+        };
+        internetAccountId: {
+            type: "string";
+        } & {
+            defaultValue: string;
+        };
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>>;
 }, {
     /**
      * #getter

package/esm/pluggableElementTypes/models/assertDisplayContract.d.ts

@@ -50,7 +50,7 @@ export type FetchAutorunOutcome =
  * answers nothing either way — the same deferral `awaitingPrerequisite` gets,
  * reached from inside the foundation rather than declared by the display. The
  * per-region family's in-flight-fetch skip is the case: `reload()` signals the
- * running fetch's stop token but `activeStopToken` clears in `runFetch`'s
+ * running fetch's signal but `activeSignal` clears in `runFetch`'s
  * finally, so the very next run can still see `isLoading` — and that fetch
  * ending bumps `fetchGeneration`, which the autorun tracks. Consuming the bump
  * there would answer the retry with a run that predates it.