@graphite-sports/sdk 0.6.0 → 0.7.0

package/index.d.ts

@@ -1,3 +1,4 @@
+import { ButtonHTMLAttributes } from 'react';
 import { ChangeEventHandler } from 'react';
 import { ColumnDef } from '@tanstack/react-table';
 import { ColumnHelper } from '@tanstack/table-core';
@@ -56,7 +57,7 @@ declare type AddGameEdit_2 = {
     game: Extract<GameKind, {
         type: 'game-node';
     }> & {
-        variant: {
+        kind: {
             type: 'parallel';
         };
     };
@@ -64,20 +65,13 @@ declare type AddGameEdit_2 = {
     division: GameDivision;
 });
 
-/**
- * <#0 extends {}, #1>(#0, #1) -> (#0 & {<self.key>: #1})
- */
-declare interface AddRecordFieldsNode {
-    fields: string[];
-}
-
 declare type AgeGroupClasses = Record<'female' | 'male', ClassId>;
 
 export declare type AnyQuerySchema = QuerySchema<QueryFields>;
 
-export declare function AppButton({ type, onClick, disabled: disabledProp, mutates, children, submit, className, loading, value, ref, href, autoFocus, }: AppButtonProps): JSX.Element;
+export declare function AppButton({ type, onClick, disabled: disabledProp, mutates, children, submit, className, loading, value, ref, href, autoFocus, ...aria }: AppButtonProps): JSX.Element;
 
-export declare type AppButtonProps = {
+export declare type AppButtonProps = Pick<ButtonHTMLAttributes<HTMLButtonElement>, 'aria-label' | 'aria-haspopup' | 'aria-expanded' | 'aria-required'> & {
     type?: AppButtonType;
     onClick?: () => void;
     disabled?: boolean;
@@ -157,7 +151,7 @@ export declare type AppInputProps = {
     autoFocus?: boolean;
 };
 
-export declare function AppListbox<TVal>({ options, value, onChange, label, description, disabled, placeholder, className, direction, readonly: readonlyProp, required, }: AppListboxProps<TVal>): JSX.Element;
+export declare function AppListbox<TVal>({ options, value, onChange, label, description, disabled, placeholder, className, direction, readonly: readonlyProp, required, describeOptions, }: AppListboxProps<TVal>): JSX.Element;
 
 export declare type AppListboxProps<TVal> = {
     options: Option_2<TVal>[];
@@ -171,6 +165,8 @@ export declare type AppListboxProps<TVal> = {
     direction?: 'up' | 'down';
     readonly?: boolean;
     required?: boolean;
+    /** Shows each option's description under it in the list. */
+    describeOptions?: boolean;
 };
 
 export declare function AppNumberInput<IsRequired extends boolean = false>({ label, description, value, onChange, min, max, integer, placeholder, required, disabled, readonly: readonlyProp, className, layout, onKeyDown, onFocus, onBlur, tabIndex, autoFocus, inputRef, }: AppNumberInputProps<IsRequired>): JSX.Element;
@@ -197,6 +193,22 @@ export declare type AppNumberInputProps<IsRequired extends boolean = false> = {
     inputRef?: React.RefObject<HTMLInputElement | null>;
 };
 
+/** Picks one of a few options, all of them visible at once with their descriptions, as a compact vertical list. */
+export declare function AppRadioGroup<TVal>({ label, options, value, onChange, disabled, readonly: readonlyProp, className, checkedMarker, }: AppRadioGroupProps<TVal>): JSX.Element;
+
+export declare type AppRadioGroupProps<TVal> = {
+    label: React_2.ReactNode;
+    /** Each one a radio, with its description below its label. */
+    options: Option_2<TVal>[];
+    value: TVal;
+    onChange: (value: TVal) => void;
+    disabled?: boolean;
+    readonly?: boolean;
+    className?: string;
+    /** Shown at the left edge of the checked option, positioned by itself, e.g. a port a line leaves from. */
+    checkedMarker?: React_2.ReactNode;
+};
+
 export declare function AppSwitch(props: AppSwitchProps): JSX.Element;
 
 export declare type AppSwitchProps = {
@@ -268,6 +280,8 @@ export declare type ArithmeticOperator = "add" | "subtract";
 
 export declare type ArrayValue<T = Primitive> = Value<T>[];
 
+declare type AutomationScriptError = { type: "ParseError"; error: { kind: ParseErrorKind; location: SourceLocation } } | { type: "TypeErrors"; error: TypeErrors };
+
 export declare type BIB = Brand<number, 'bib'>;
 
 declare type BooleanOp = "and" | "or" | "xor" | "not";
@@ -286,7 +300,7 @@ export declare type Brand<T, B> = T & {
 /** Stable reference — a new inline `select` on every `queryOptions()` call makes React Query re-select each render. */
 export declare function buildCompetitorsMapped(competitors: CompetitorDAO[]): CompetitorsMapped;
 
-export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspaceId" | "/workspace/:workspaceId/event/:eventId" | "/login" | "/register" | "/download" | "/preferences" | "/crate-workspace" | "/workspace/:workspaceId/create-event" | "/workspace/:workspaceId/event/:eventId/dashboard" | "/workspace/:workspaceId/event/:eventId/create-class" | "/workspace/:workspaceId/event/:eventId/class/:classId" | "/workspace/:workspaceId/event/:eventId/create-competitor" | "/workspace/:workspaceId/event/:eventId/create-team" | "/workspace/:workspaceId/event/:eventId/competitor/:competitorId" | "/workspace/:workspaceId/event/:eventId/create-format" | "/workspace/:workspaceId/event/:eventId/format/:formatId" | "/workspace/:workspaceId/event/:eventId/format/:formatId/tests" | "/workspace/:workspaceId/event/:eventId/format/:formatId/tests/:formatTestId" | "/workspace/:workspaceId/event/:eventId/graph" | "/workspace/:workspaceId/event/:eventId/simplified" | "/workspace/:workspaceId/event/:eventId/lineage" | "/workspace/:workspaceId/event/:eventId/create-game" | "/workspace/:workspaceId/event/:eventId/game/:gameId" | "/workspace/:workspaceId/event/:eventId/create-table" | "/workspace/:workspaceId/event/:eventId/table/:tableId" | "/workspace/:workspaceId/event/:eventId/create-game-format" | "/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId" | "/workspace/:workspaceId/event/:eventId/create-template" | "/workspace/:workspaceId/event/:eventId/template/:templateId" | "/workspace/:workspaceId/event/:eventId/extension/$extensionIdentifier">(path: Path, params: PathParams<Path>, ...query: {
+export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspaceId" | "/workspace/:workspaceId/event/:eventId" | "/login" | "/download" | "/register" | "/preferences" | "/crate-workspace" | "/workspace/:workspaceId/create-event" | "/workspace/:workspaceId/create-event/empty" | "/workspace/:workspaceId/create-event/template" | "/workspace/:workspaceId/create-event/assistant" | "/workspace/:workspaceId/event/:eventId/assistant" | "/workspace/:workspaceId/event/:eventId/create-class" | "/workspace/:workspaceId/event/:eventId/class/:classId" | "/workspace/:workspaceId/event/:eventId/create-competitor" | "/workspace/:workspaceId/event/:eventId/create-team" | "/workspace/:workspaceId/event/:eventId/competitor/:competitorId" | "/workspace/:workspaceId/event/:eventId/create-format" | "/workspace/:workspaceId/event/:eventId/format/:formatId" | "/workspace/:workspaceId/event/:eventId/format/:formatId/tests" | "/workspace/:workspaceId/event/:eventId/format/:formatId/tests/:formatTestId" | "/workspace/:workspaceId/event/:eventId/graph" | "/workspace/:workspaceId/event/:eventId/flow" | "/workspace/:workspaceId/event/:eventId/simplified" | "/workspace/:workspaceId/event/:eventId/lineage" | "/workspace/:workspaceId/event/:eventId/create-game" | "/workspace/:workspaceId/event/:eventId/game/:gameId" | "/workspace/:workspaceId/event/:eventId/create-table" | "/workspace/:workspaceId/event/:eventId/table/:tableId" | "/workspace/:workspaceId/event/:eventId/create-game-format" | "/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId" | "/workspace/:workspaceId/event/:eventId/create-scoring-definition" | "/workspace/:workspaceId/event/:eventId/scoring-definition/:scoringDefinitionId" | "/workspace/:workspaceId/event/:eventId/create-template" | "/workspace/:workspaceId/event/:eventId/template/:templateId" | "/workspace/:workspaceId/event/:eventId/extension/$extensionIdentifier">(path: Path, params: PathParams<Path>, ...query: {
     '/': undefined;
     '/download': undefined;
     '/login': QuerySchema<    {
@@ -299,17 +313,22 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/crate-workspace': undefined;
     '/workspace/:workspaceId': undefined;
     '/workspace/:workspaceId/create-event': undefined;
+    '/workspace/:workspaceId/create-event/empty': undefined;
+    '/workspace/:workspaceId/create-event/template': undefined;
+    '/workspace/:workspaceId/create-event/assistant': undefined;
     '/workspace/:workspaceId/event/:eventId': undefined;
-    '/workspace/:workspaceId/event/:eventId/dashboard': undefined;
-    '/workspace/:workspaceId/event/:eventId/create-class': undefined;
+    '/workspace/:workspaceId/event/:eventId/assistant': undefined;
+    '/workspace/:workspaceId/event/:eventId/create-class': QuerySchema<    {
+    readonly from: OptionalQueryField<ClassId>;
+    }>;
     '/workspace/:workspaceId/event/:eventId/class/:classId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-competitor': undefined;
     '/workspace/:workspaceId/event/:eventId/create-team': undefined;
     '/workspace/:workspaceId/event/:eventId/competitor/:competitorId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-format': QuerySchema<    {
     readonly name: OptionalQueryField<string>;
-    readonly template: OptionalQueryField<FormatId>;
     readonly place: OptionalQueryField<GamePlace>;
+    readonly from: OptionalQueryField<FormatId>;
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
     readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
@@ -317,17 +336,23 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
     readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
-    '/workspace/:workspaceId/event/:eventId/format/:formatId/tests': undefined;
+    '/workspace/:workspaceId/event/:eventId/format/:formatId/tests': QuerySchema<    {
+    readonly from: OptionalQueryField<FormatTestId>;
+    }>;
     '/workspace/:workspaceId/event/:eventId/format/:formatId/tests/:formatTestId': undefined;
     '/workspace/:workspaceId/event/:eventId/graph': QuerySchema<    {
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
+    /** The root format shown, else the one with the focused nodes or the first. */
+    readonly format: OptionalQueryField<FormatId>;
     }>;
-    '/workspace/:workspaceId/event/:eventId/simplified': QuerySchema<    {
+    '/workspace/:workspaceId/event/:eventId/flow': QuerySchema<    {
+    readonly focusNode: RepeatedQueryField<FormatNodeId>;
     /** Applied once, e.g. for a format just created to be used as a game. */
     readonly addGame: OptionalQueryField<AddGameEdit>;
-    readonly focusNode: RepeatedQueryField<FormatNodeId>;
-    readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
+    readonly sidebar: OptionalQueryField<string>;
     }>;
+    /** The flow's old path, which redirects there. */
+    '/workspace/:workspaceId/event/:eventId/simplified': undefined;
     '/workspace/:workspaceId/event/:eventId/lineage': QuerySchema<    {
     readonly game: OptionalQueryField<GameId>;
     readonly table: OptionalQueryField<TableId>;
@@ -338,12 +363,25 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     /** Narrows `node` down to its instances in these format instances. */
     readonly formatInstance: RepeatedQueryField<FormatInstanceHash>;
     }>;
-    '/workspace/:workspaceId/event/:eventId/create-game': undefined;
+    '/workspace/:workspaceId/event/:eventId/create-game': QuerySchema<    {
+    readonly from: OptionalQueryField<GameId>;
+    }>;
     '/workspace/:workspaceId/event/:eventId/game/:gameId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-table': undefined;
     '/workspace/:workspaceId/event/:eventId/table/:tableId': undefined;
-    '/workspace/:workspaceId/event/:eventId/create-game-format': undefined;
-    '/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId': undefined;
+    '/workspace/:workspaceId/event/:eventId/create-game-format': QuerySchema<    {
+    readonly from: OptionalQueryField<GameFormatId>;
+    }>;
+    '/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId': QuerySchema<    {
+    /** The tab of the modes shown: a kind of game or a mode of the game format, see `GameModeTabs`. */
+    readonly mode: OptionalQueryField<string>;
+    /** `modes` scrolls the modes into view once, for links to a mode. */
+    readonly reveal: OptionalQueryField<string>;
+    }>;
+    '/workspace/:workspaceId/event/:eventId/create-scoring-definition': QuerySchema<    {
+    readonly from: OptionalQueryField<ScoringDefinitionId>;
+    }>;
+    '/workspace/:workspaceId/event/:eventId/scoring-definition/:scoringDefinitionId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-template': undefined;
     '/workspace/:workspaceId/event/:eventId/template/:templateId': undefined;
     '/workspace/:workspaceId/event/:eventId/extension/$extensionIdentifier': undefined;
@@ -361,17 +399,22 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/crate-workspace': undefined;
     '/workspace/:workspaceId': undefined;
     '/workspace/:workspaceId/create-event': undefined;
+    '/workspace/:workspaceId/create-event/empty': undefined;
+    '/workspace/:workspaceId/create-event/template': undefined;
+    '/workspace/:workspaceId/create-event/assistant': undefined;
     '/workspace/:workspaceId/event/:eventId': undefined;
-    '/workspace/:workspaceId/event/:eventId/dashboard': undefined;
-    '/workspace/:workspaceId/event/:eventId/create-class': undefined;
+    '/workspace/:workspaceId/event/:eventId/assistant': undefined;
+    '/workspace/:workspaceId/event/:eventId/create-class': QuerySchema<    {
+    readonly from: OptionalQueryField<ClassId>;
+    }>;
     '/workspace/:workspaceId/event/:eventId/class/:classId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-competitor': undefined;
     '/workspace/:workspaceId/event/:eventId/create-team': undefined;
     '/workspace/:workspaceId/event/:eventId/competitor/:competitorId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-format': QuerySchema<    {
     readonly name: OptionalQueryField<string>;
-    readonly template: OptionalQueryField<FormatId>;
     readonly place: OptionalQueryField<GamePlace>;
+    readonly from: OptionalQueryField<FormatId>;
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
     readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
@@ -379,17 +422,23 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
     readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
-    '/workspace/:workspaceId/event/:eventId/format/:formatId/tests': undefined;
+    '/workspace/:workspaceId/event/:eventId/format/:formatId/tests': QuerySchema<    {
+    readonly from: OptionalQueryField<FormatTestId>;
+    }>;
     '/workspace/:workspaceId/event/:eventId/format/:formatId/tests/:formatTestId': undefined;
     '/workspace/:workspaceId/event/:eventId/graph': QuerySchema<    {
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
+    /** The root format shown, else the one with the focused nodes or the first. */
+    readonly format: OptionalQueryField<FormatId>;
     }>;
-    '/workspace/:workspaceId/event/:eventId/simplified': QuerySchema<    {
+    '/workspace/:workspaceId/event/:eventId/flow': QuerySchema<    {
+    readonly focusNode: RepeatedQueryField<FormatNodeId>;
     /** Applied once, e.g. for a format just created to be used as a game. */
     readonly addGame: OptionalQueryField<AddGameEdit>;
-    readonly focusNode: RepeatedQueryField<FormatNodeId>;
-    readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
+    readonly sidebar: OptionalQueryField<string>;
     }>;
+    /** The flow's old path, which redirects there. */
+    '/workspace/:workspaceId/event/:eventId/simplified': undefined;
     '/workspace/:workspaceId/event/:eventId/lineage': QuerySchema<    {
     readonly game: OptionalQueryField<GameId>;
     readonly table: OptionalQueryField<TableId>;
@@ -400,34 +449,41 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     /** Narrows `node` down to its instances in these format instances. */
     readonly formatInstance: RepeatedQueryField<FormatInstanceHash>;
     }>;
-    '/workspace/:workspaceId/event/:eventId/create-game': undefined;
+    '/workspace/:workspaceId/event/:eventId/create-game': QuerySchema<    {
+    readonly from: OptionalQueryField<GameId>;
+    }>;
     '/workspace/:workspaceId/event/:eventId/game/:gameId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-table': undefined;
     '/workspace/:workspaceId/event/:eventId/table/:tableId': undefined;
-    '/workspace/:workspaceId/event/:eventId/create-game-format': undefined;
-    '/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId': undefined;
+    '/workspace/:workspaceId/event/:eventId/create-game-format': QuerySchema<    {
+    readonly from: OptionalQueryField<GameFormatId>;
+    }>;
+    '/workspace/:workspaceId/event/:eventId/game-format/:gameFormatId': QuerySchema<    {
+    /** The tab of the modes shown: a kind of game or a mode of the game format, see `GameModeTabs`. */
+    readonly mode: OptionalQueryField<string>;
+    /** `modes` scrolls the modes into view once, for links to a mode. */
+    readonly reveal: OptionalQueryField<string>;
+    }>;
+    '/workspace/:workspaceId/event/:eventId/create-scoring-definition': QuerySchema<    {
+    readonly from: OptionalQueryField<ScoringDefinitionId>;
+    }>;
+    '/workspace/:workspaceId/event/:eventId/scoring-definition/:scoringDefinitionId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-template': undefined;
     '/workspace/:workspaceId/event/:eventId/template/:templateId': undefined;
     '/workspace/:workspaceId/event/:eventId/extension/$extensionIdentifier': undefined;
     '*': undefined;
 }[Path] ? T extends AnyQuerySchema ? [query?: QueryInput<T> | undefined] : [] : never : never) => string;
 
-/** How to handle a disqualification: one of the strategies to catch it, or "throw" - not catching it at all. */
-declare type CatchDqChoice = DqStrategy_2 | 'throw';
+/** A tutorial of the engine. */
+export declare interface BuiltInTutorial {
+    scope?: 'built-in';
+    id: TutorialId;
+}
 
 declare type ChildrenSpec = { type: "disallowed" } | { type: "allowed" } | { type: "closure"; signature: NodeSignature<Type> };
 
 export declare type ClassDAO = components['schemas']['ClassDAO'];
 
-/**
- * Outputs the competitors of classes as a table.
- *
- * ```text
- * multiple: ('roundrobin' | 'serpentine' | 'concat', ...Class) -> (Table<{}, Sorted>)
- * ```
- */
-declare type ClassesCompetitorsNode = null;
-
 /**
  * Identifies a class. Random ([Self::new_random]) from the endpoint, or derived by `ImportArchiveMutation`.
  * Deserializing one only yields a reference to an existing class; it does not check that it exists.
@@ -436,6 +492,20 @@ export declare type ClassId = string & { readonly __brand: 'classId' };
 
 export declare type ClassResponse = components['schemas']['ClassResponse'];
 
+/**
+ * The signature of a script closure: no variadic ports, exactly one output and an input name per input. The names
+ * are distinct variable names.
+ */
+declare interface ClosureSignature {
+    signature: NodeSignature<Type>;
+    inputNames: VariableName[];
+}
+
+/**
+ * Where a node gets the closure it calls.
+ */
+declare type ClosureSource = "children" | "input" | "deterministic-input";
+
 declare type CommonApiKeyId = Brand<number, 'commonApiKeyId'>;
 
 export declare type CommonWorkspaceId = WorkspaceRootId | WorkspaceSelfHostedId;
@@ -555,6 +625,11 @@ declare interface components {
             force: boolean;
             /** @description The id of the new format, see [FormatId::new_random]. It must not exist yet. */
             formatId: components["schemas"]["FormatId"];
+            /**
+             * @description Never changes afterwards.
+             * @default normal
+             */
+            kind: components["schemas"]["FormatKind"];
         };
         AddFormatTestMutation: {
             /** @default  */
@@ -567,10 +642,19 @@ declare interface components {
         };
         AddGameFormatMutation: {
             eventId: components["schemas"]["EventId"];
+            /** @description If true, saves the game format although its settings don't validate. Its game nodes are invalid then. */
+            force?: boolean;
             gameFormat: components["schemas"]["GameFormatDTO"];
             /** @description The id of the new game format, see [GameFormatId::new_random]. It must not exist yet. */
             gameFormatId: components["schemas"]["GameFormatId"];
         };
+        AddGameFormatQuery: {
+            /**
+             * @description If true, saves the game format although its settings don't validate. Its game nodes are invalid then.
+             * @default false
+             */
+            force: boolean;
+        };
         AddGameMutation: {
             eventId: components["schemas"]["EventId"];
             game: components["schemas"]["GameDTO"];
@@ -584,8 +668,13 @@ declare interface components {
             tableId: components["schemas"]["TableId"];
             variant: components["schemas"]["TableVariant"];
         };
-        /** @description <#0 extends {}, #1>(#0, #1) -> (#0 & {<self.key>: #1}) */
-        AddRecordFieldsNode: AddRecordFieldsNode;
+        /** @description Stores the definition even if it is invalid, with its errors. */
+        AddScoringDefinitionMutation: {
+            eventId: components["schemas"]["EventId"];
+            scoringDefinition: components["schemas"]["ScoringDefinitionDTO"];
+            /** @description The id of the new definition, see [ScoringDefinitionId::new_random]. It must not exist yet. */
+            scoringDefinitionId: components["schemas"]["ScoringDefinitionId"];
+        };
         AddTarget: {
             backendUrl: string;
             /** @description Replicate into this existing remote workspace instead of creating a new one. */
@@ -643,7 +732,8 @@ declare interface components {
              * Format: uuid
              * @description The template the entry belongs to: installing it links the entity to it and reuses the entity of the event
              *      installed from it before, see [template_origin](crate::graphite_engine::template_origin). Without one, the entity
-             *      is installed as a plain editable entity. Ignored for [ArchiveData::Group].
+             *      is installed as a plain editable entity. Never set on [ArchiveData::Group] and root formats, and ignored for them:
+             *      every import adds root formats anew as editable root formats.
              */
             templateOrigin?: string | null;
             /**
@@ -663,10 +753,10 @@ declare interface components {
                  */
                 invalid: boolean;
                 /**
-                 * @description Whether this is the root format of the exported event. See [import_archive::RootFormatImport] for how it gets imported.
-                 * @default false
+                 * @description The format gets imported with it.
+                 * @default normal
                  */
-                root: boolean;
+                kind: components["schemas"]["FormatKind"];
                 tests: components["schemas"]["FormatTestArchive"][];
                 /** @description Maps ids from the format DTO to uuids of [Archive::dependencies] */
                 wiring: components["schemas"]["Wiring"];
@@ -674,7 +764,43 @@ declare interface components {
         } | {
             /** @constant */
             type: "game-format";
-            data: components["schemas"]["GameFormatDTO"];
+            /**
+             * @description Describes the shape of a game and how its result is post processed.
+             *
+             *      `GameFormatSettings<Validated>` proves that every automation typechecks against the row type
+             *      left behind by the automations before it.
+             */
+            data: {
+                /** @default  */
+                description: string;
+                attributesType: components["schemas"]["RecordTypeWithDefaults"];
+                customData?: {
+                    [key: string]: string;
+                };
+                /**
+                 * @description Settings by disqualification kind. May hold kinds no automation disqualifies under. Kinds without an entry have
+                 *      the default settings.
+                 */
+                disqualifications?: {
+                    [key: string]: components["schemas"]["DqSettings"];
+                };
+                entryListColumns: components["schemas"]["RecordTypeWithDefaults"];
+                /** @description A group of game formats of the event. */
+                formatGroupId?: components["schemas"]["FormatGroupId"] | null;
+                name: string;
+                /** @description Run in order on every result row. */
+                postProcessingSteps: components["schemas"]["GameFormatStep_for_GameFormatPostProcessingStep"][];
+                /** @description Run in order on every row of the entry list, before the game. */
+                preProcessingSteps?: components["schemas"]["GameFormatStep_for_GameFormatPreProcessingStep"][];
+                resultListColumns: components["schemas"]["RecordTypeWithDefaults"];
+                tags?: components["schemas"]["Tags"];
+                /** @description Maps the game format's group to the uuid of its entry in [Archive::dependencies]. */
+                wiring?: components["schemas"]["Wiring"];
+            };
+        } | {
+            /** @constant */
+            type: "scoring-definition";
+            data: components["schemas"]["ScoringDefinitionDTO"];
         } | {
             /** @constant */
             type: "class";
@@ -711,11 +837,65 @@ declare interface components {
                 workspaceId: components["schemas"]["CommonWorkspaceId"];
             };
         };
+        AutomationError: {
+            /** Format: uint */
+            automationIndex: number;
+            /**
+             * Format: uint
+             * @description Which expression of the step is invalid, in the order of [GameFormatPreProcessingStep::expressions]. Steps with
+             *      one expression and errors not about an expression have `0`.
+             */
+            expressionIndex?: number;
+            kind: components["schemas"]["AutomationErrorKind"];
+            /** @description Which steps `automation_index` indexes. */
+            stage: components["schemas"]["ProcessingStage"];
+        };
+        AutomationErrorKind: {
+            /** @constant */
+            type: "script";
+            data: components["schemas"]["AutomationScriptError"];
+        } | {
+            /** @constant */
+            type: "non-primitive-column-type";
+        } | {
+            /** @constant */
+            type: "empty-sit-out-output-name";
+        } | {
+            /** @constant */
+            type: "empty-dq-key";
+        };
+        AutomationScriptError: AutomationScriptError;
         /** Format: int64 */
         BIB: BIB;
         BibNotUniqueError: components["schemas"]["BIB"];
         /** @enum {string} */
         BooleanOp: BooleanOp;
+        BranchDTO_for_CommonWorkspaceId: {
+            /** Format: date-time */
+            createdAt: string;
+            familyId: components["schemas"]["CommonWorkspaceId"];
+            /** @description The last log entry it shares with its parent. */
+            forkLogId?: components["schemas"]["LogId"] | null;
+            /** @description The last log entry of the branch. */
+            head: components["schemas"]["LogId"];
+            name: string;
+            parentWorkspaceId?: components["schemas"]["CommonWorkspaceId"] | null;
+            workspaceId: components["schemas"]["CommonWorkspaceId"];
+        };
+        BranchPathVariables_for_CommonWorkspaceId: {
+            branchId: components["schemas"]["CommonWorkspaceId"];
+        };
+        /** @description Query of every endpoint of a workspace. */
+        BranchQuery_for_CommonWorkspaceId: {
+            /** @description The branch of the workspace's family to use instead of its default branch (T-149). */
+            branch?: components["schemas"]["CommonWorkspaceId"] | null;
+        };
+        BranchesDTO_for_CommonWorkspaceId: {
+            /** @description The first one first. */
+            branches: components["schemas"]["BranchDTO_for_CommonWorkspaceId"][];
+            defaultBranch: components["schemas"]["CommonWorkspaceId"];
+            familyId: components["schemas"]["CommonWorkspaceId"];
+        };
         /** @description The [CICManagedState] of a relation that is a membership, so all but `DeletedByUser`. */
         CICMembershipState: "added-by-user" | "automation";
         ChildrenSpec: ChildrenSpec;
@@ -833,13 +1013,12 @@ declare interface components {
             competitorCount: number;
         };
         /**
-         * @description Outputs the competitors of classes as a table.
-         *
-         *      ```text
-         *      multiple: ('roundrobin' | 'serpentine' | 'concat', ...Class) -> (Table<{}, Sorted>)
-         *      ```
+         * @description The signature of a script closure: no variadic ports, exactly one output and an input name per input. The names
+         *      are distinct variable names.
          */
-        ClassesCompetitorsNode: ClassesCompetitorsNode;
+        ClosureSignature: ClosureSignature;
+        /** @description Where a node gets the closure it calls. */
+        ClosureSource: ClosureSource;
         /** Format: int64 */
         CommonApiKeyId: CommonApiKeyId;
         CommonWorkspaceId: CommonWorkspaceId;
@@ -1074,13 +1253,20 @@ declare interface components {
             /** @description If part of a group, the group will get included automatically. */
             formatIds: components["schemas"]["FormatId"][];
             gameFormatIds: components["schemas"]["GameFormatId"][];
+            /** @description Formats include the definitions they use anyway. */
+            scoringDefinitionIds?: components["schemas"]["ScoringDefinitionId"][];
+        };
+        CreateBranchBody: {
+            /** @description The last log entry the branch shares with the branch it is branched off. */
+            atEntry: components["schemas"]["LogId"];
+            name: string;
         };
         CreatedTarget: {
             apiKey: string;
             workspaceId: components["schemas"]["CommonWorkspaceId"];
         };
         /** @enum {string} */
-        CustomControl: "sort-criterion";
+        CustomControl: CustomControl;
         CustomDataEntity: {
             /** @constant */
             type: "game";
@@ -1300,6 +1486,22 @@ declare interface components {
             /** @constant */
             type: "unknown";
         };
+        DefaultChangeEvent_for_ScoringDefinitionId: {
+            /** @constant */
+            type: "created";
+            data: components["schemas"]["ScoringDefinitionId"];
+        } | {
+            /** @constant */
+            type: "updated";
+            data: components["schemas"]["ScoringDefinitionId"];
+        } | {
+            /** @constant */
+            type: "deleted";
+            data: components["schemas"]["ScoringDefinitionId"];
+        } | {
+            /** @constant */
+            type: "unknown";
+        };
         DefaultChangeEvent_for_TableId: {
             /** @constant */
             type: "created";
@@ -1351,10 +1553,16 @@ declare interface components {
         };
         /** @description What happens to the games and tables of node instances that get deleted. */
         DeleteInstanceSettings: "errorOnContent" | "keepContentAsCopy" | "deleteContent";
+        /** @description Definitions can only be deleted when no scoring node uses them. */
+        DeleteScoringDefinitionMutation: {
+            scoringDefinitionId: components["schemas"]["ScoringDefinitionId"];
+        };
         DeleteTableMutation: {
             id: components["schemas"]["TableId"];
         };
         DetailedSupertypeDiagnostics_for_Type: DetailedSupertypeDiagnostics<Type>;
+        /** @description A competitor's worst results that don't count towards their total. */
+        Discards: Discards;
         /**
          * @description Disqualifies every row of the table it receives, throwing them all under `key` so that a
          *      [`GroupNode`](super::group_node::GroupNode) further up the graph can collect them.
@@ -1373,13 +1581,13 @@ declare interface components {
             source: components["schemas"]["DivergedRows"];
             target: components["schemas"]["DivergedRows"];
         };
-        /** @description What a node does by default with a disqualification it can throw. */
-        DqDefaultStrategy: DqDefaultStrategy;
         DqKey: DqKey;
-        /** @description What a format or game format says about one of its disqualification kinds. */
+        DqKind: DqKind;
+        DqRecord: DqRecord;
+        /** @description What a game format says about one of its disqualification kinds. */
         DqSettings: DqSettings;
-        /** @description Decides how caught disqualifications are surfaced. */
-        DqStrategy: DqStrategy;
+        /** @description Where a competitor got disqualified. */
+        DqSource: DqSource;
         /**
          * @description How functions that combine tables from multiple competitor sources (e.g. merging or
          *      concatenating) should treat a competitor that appears in more than one of them.
@@ -1453,6 +1661,13 @@ declare interface components {
         } & {
             [key: string]: unknown;
         };
+        /** @description A log entry that changed an entity. */
+        EntityChange: {
+            description: string;
+            logId: components["schemas"]["LogId"];
+            /** Format: date-time */
+            timestamp: string;
+        };
         EntityChangeEvent: {
             /** @constant */
             type: "event";
@@ -1469,6 +1684,10 @@ declare interface components {
             /** @constant */
             type: "game-format";
             data: components["schemas"]["DefaultChangeEvent_for_GameFormatId"];
+        } | {
+            /** @constant */
+            type: "scoring-definition";
+            data: components["schemas"]["DefaultChangeEvent_for_ScoringDefinitionId"];
         } | {
             /** @constant */
             type: "format-group";
@@ -1522,7 +1741,12 @@ declare interface components {
             type: "content-in-event-folder";
         };
         /** @description Auto-generated discriminant enum variants */
-        EntityChangeEventDiscriminants: ("Event" | "Game" | "Table" | "GameFormat" | "FormatGroup" | "Row" | "RowMutation" | "FormatNode" | "Format" | "Class" | "Extension" | "Competitor" | "FormatTest" | "Log" | "ContentInEventFolder") | "CompetitorInTeam" | "CompetitorInClass";
+        EntityChangeEventDiscriminants: ("Event" | "Game" | "Table" | "GameFormat" | "ScoringDefinition" | "FormatGroup" | "Row" | "RowMutation" | "FormatNode" | "Format" | "Class" | "Extension" | "Competitor" | "FormatTest" | "Log" | "ContentInEventFolder") | "CompetitorInTeam" | "CompetitorInClass";
+        EntityHistoryQuery: {
+            entity: components["schemas"]["HistoryEntity"];
+            /** @description The id of the entity, as the API writes it. */
+            id: string;
+        };
         /** @description A scope portal that used to be there but got removed in order to be serializable */
         ErasedScopedTypeRef_for_Type: ErasedScopedTypeRef<Type>;
         EventCompetitorsNode: EventCompetitorsNode;
@@ -1538,11 +1762,6 @@ declare interface components {
             /** @description All competitors in this event are forced to have these parameters. */
             individualCompetitorTypes: components["schemas"]["RecordTypeWithDefaults"];
             name: string;
-            /**
-             * @description should only be null when creating an event. The next
-             *      action should always be to create and set the root format.
-             */
-            rootFormatId?: components["schemas"]["FormatId"] | null;
             settings: components["schemas"]["EventSettings"];
             /**
              * Format: date
@@ -1568,7 +1787,8 @@ declare interface components {
             /**
              * @default {
              *       "duplicateCompetitorPolicy": "error",
-             *       "invalidLinkedFormatPolicy": "last-known-table"
+             *       "invalidLinkedFormatPolicy": "last-known-table",
+             *       "sport": "44cfa5f1-264f-4b3c-9734-8a93f647d7d8"
              *     }
              */
             settings: components["schemas"]["EventSettings"];
@@ -1633,6 +1853,7 @@ declare interface components {
         };
         EventLineageRow: {
             competitorId: components["schemas"]["CompetitorId"];
+            dqs: components["schemas"]["DqRecord"][];
             /** Format: int64 */
             place?: number | null;
         };
@@ -1669,7 +1890,7 @@ declare interface components {
             rows: components["schemas"]["EventLineageRow"][];
             tableId: components["schemas"]["TableId"];
         };
-        /** @description Settings of an event that change how its formats execute. Missing fields get their defaults. */
+        /** @description Settings of an event. Missing fields get their defaults. */
         EventSettings: {
             /**
              * @description Whether nodes that combine tables from multiple competitor sources (e.g. merging or
@@ -1683,6 +1904,11 @@ declare interface components {
              * @default last-known-table
              */
             invalidLinkedFormatPolicy: components["schemas"]["InvalidLinkedFormatPolicy"];
+            /**
+             * @description Only clients read it, e.g. to name concepts the way the sport does ("races" instead of "games").
+             * @default 44cfa5f1-264f-4b3c-9734-8a93f647d7d8
+             */
+            sport: components["schemas"]["SportId"];
         };
         Example: {
             /**
@@ -1795,6 +2021,8 @@ declare interface components {
             data: components["schemas"]["GameWithTables"];
         });
         FolderPath: string[];
+        /** @description What the nodes representing a format do with a disqualification it raises. */
+        FormatCatch: FormatCatch;
         FormatConnectionDTO: FormatConnectionDTO;
         FormatDAO: {
             description: string;
@@ -1807,9 +2035,11 @@ declare interface components {
             customData: {
                 [key: string]: string;
             };
+            /** @default false */
+            deterministic: boolean;
             /** @default {} */
             disqualificationKinds: {
-                [key: string]: components["schemas"]["DqSettings"];
+                [key: string]: components["schemas"]["FormatDqKind"];
             };
             /** @description The default values in here are not guaranteed to be valid for the signature. */
             docs: components["schemas"]["NodeVariantDoc"];
@@ -1817,12 +2047,13 @@ declare interface components {
             eventId: components["schemas"]["EventId"];
             formatGroupId?: components["schemas"]["FormatGroupId"] | null;
             id: components["schemas"]["FormatId"];
+            kind: components["schemas"]["FormatKind"];
             name: string;
             signature: components["schemas"]["NodeSignature_for_Type_and_ParamRef"];
             /**
              * @default {
-             *       "nodes": {},
-             *       "sections": []
+             *       "groups": [],
+             *       "nodes": {}
              *     }
              */
             simplifiedView: components["schemas"]["SimplifiedView"];
@@ -1830,10 +2061,6 @@ declare interface components {
             templateOrigin?: string | null;
             valid: components["schemas"]["FormatValidity"];
         };
-        FormatDAOWithRoot: {
-            format: components["schemas"]["FormatDAO"];
-            isRoot: boolean;
-        };
         FormatDTO: {
             /** @default  */
             description: string;
@@ -1841,6 +2068,8 @@ declare interface components {
             customData?: {
                 [key: string]: string;
             };
+            /** @description Whether the format may contain only deterministic nodes, see [NodeType]. Its nodes are deterministic then. */
+            deterministic?: boolean;
             /**
              * @description All disqualifications that can escape this format. Like checked exceptions, every
              *      uncaught disqualification has to be declared and every declared one has to be throwable.
@@ -1848,7 +2077,7 @@ declare interface components {
              * @default {}
              */
             disqualificationKinds: {
-                [key: string]: components["schemas"]["DqSettings"];
+                [key: string]: components["schemas"]["FormatDqKind"];
             };
             /** @description There must be docs for every input and output. Otherwise formats get rejected. */
             docs: components["schemas"]["NodeVariantDoc"];
@@ -1862,6 +2091,8 @@ declare interface components {
             signature: components["schemas"]["NodeSignature_for_Type_and_ParamRef"];
             simplifiedView?: components["schemas"]["SimplifiedView"];
         };
+        /** @description What a format says about a disqualification kind it raises. */
+        FormatDqKind: FormatDqKind;
         FormatError: {
             /** @constant */
             type: "format-reference-error";
@@ -1880,14 +2111,11 @@ declare interface components {
         } | {
             /** @constant */
             type: "invalidate-parents";
-            data: components["schemas"]["FormatId"][];
+            data: components["schemas"]["InvalidatedFormat"][];
         } | {
             /** @constant */
             type: "node-has-content";
             data: components["schemas"]["NodeHasContentError"];
-        } | {
-            /** @constant */
-            type: "tried-to-delete-root-format";
         } | {
             /** @constant */
             type: "referenced-by-format-node";
@@ -1909,21 +2137,21 @@ declare interface components {
             type: "upload";
         };
         FormatGroupDAO: {
-            category: components["schemas"]["NodeCategory"];
             customData: {
                 [key: string]: string;
             };
             eventId: components["schemas"]["EventId"];
             id: components["schemas"]["FormatGroupId"];
+            members: components["schemas"]["FormatGroupMembers"];
             name: string;
             /** Format: uuid */
             templateOrigin?: string | null;
         };
         FormatGroupDTO: {
-            category: components["schemas"]["NodeCategory"];
             customData?: {
                 [key: string]: string;
             };
+            members: components["schemas"]["FormatGroupMembers"];
             name: string;
         };
         /**
@@ -1932,6 +2160,18 @@ declare interface components {
          *      Deserializing one only yields a reference to an existing format group; it does not check that it exists.
          */
         FormatGroupId: FormatGroupId;
+        /**
+         * @description What a format group groups, fixed when the group is created. Formats and game formats can only be in a group of
+         *      their kind.
+         */
+        FormatGroupMembers: {
+            /** @constant */
+            type: "formats";
+            category: components["schemas"]["NodeCategory"];
+        } | {
+            /** @constant */
+            type: "game-formats";
+        };
         FormatGroupPathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
             formatGroupId: components["schemas"]["FormatGroupId"];
@@ -2007,6 +2247,8 @@ declare interface components {
             formatInstance: components["schemas"]["FormatInstanceDAO"];
             nodeStates: components["schemas"]["NodeInstanceStateDTO"][];
         };
+        /** @description Set when the format is created and never changed: only the inputs that create a format take it. */
+        FormatKind: "normal" | "root-format";
         FormatNodeConnectionDAO: {
             pins: components["schemas"]["ConnectionPin"][];
             sourceFormatNodeId: components["schemas"]["FormatNodeId"];
@@ -2115,8 +2357,12 @@ declare interface components {
             data: components["schemas"]["GameFormatId"];
         } | {
             /** @constant */
-            type: "invalid-standalone-input-table";
-            data: components["schemas"]["TableId"];
+            type: "invalid-input-table-link";
+            data: components["schemas"]["FormatNodeId"];
+        } | {
+            /** @constant */
+            type: "cyclic-input-table-link";
+            data: components["schemas"]["FormatNodeId"];
         } | {
             /** @constant */
             type: "invalid-portal-source";
@@ -2141,7 +2387,7 @@ declare interface components {
         };
         /** @description An action invalidated a format */
         FormatRevalidationError: {
-            invalidatedFormats: components["schemas"]["FormatId"][];
+            invalidatedFormats: components["schemas"]["InvalidatedFormat"][];
         };
         FormatTest: {
             description: string;
@@ -2200,6 +2446,10 @@ declare interface components {
             /** @constant */
             type: "custom";
             competitors: components["schemas"]["CompetitorDTO"][];
+        } | {
+            /** @constant */
+            type: "custom-teams";
+            competitors: components["schemas"]["CompetitorDTO"][];
         };
         FormatTestDTO: {
             /** @default  */
@@ -2364,7 +2614,6 @@ declare interface components {
             formatInstanceId: components["schemas"]["FormatInstanceHash"];
             formatNodeId: components["schemas"]["FormatNodeId"];
         };
-        GTFilterKind: GTFilterKind;
         GameDAO: {
             attributes: components["schemas"]["RecordValue_for_Primitive"];
             customData: {
@@ -2390,6 +2639,11 @@ declare interface components {
             gameFormatId: components["schemas"]["GameFormatId"];
             name: string;
         };
+        /**
+         * @description What a game node does with a disqualification kind of its game format: throw it on, or catch it with a
+         *      [LadderDqStrategy]. The game format sets the default for its game nodes, each node can override it.
+         */
+        GameDqHandling: GameDqHandling;
         /**
          * @description Describes the shape of a game and how its result is post processed.
          *
@@ -2411,13 +2665,20 @@ declare interface components {
             };
             entryListColumns: components["schemas"]["RecordTypeWithDefaults"];
             eventId: components["schemas"]["EventId"];
+            /** @description A group of game formats. */
+            formatGroupId?: components["schemas"]["FormatGroupId"] | null;
             id: components["schemas"]["GameFormatId"];
             name: string;
             /** @description Run in order on every result row. */
-            postProcessingSteps: components["schemas"]["GameFormatPostProcessingStep"][];
+            postProcessingSteps: components["schemas"]["GameFormatStep_for_GameFormatPostProcessingStep"][];
+            /** @description Run in order on every row of the entry list, before the game. */
+            preProcessingSteps?: components["schemas"]["GameFormatStep_for_GameFormatPreProcessingStep"][];
             resultListColumns: components["schemas"]["RecordTypeWithDefaults"];
+            tags: components["schemas"]["Tags"];
             /** Format: uuid */
             templateOrigin?: string | null;
+            /** @description Whether `settings` validate. With force, game formats are saved although they don't: their game nodes are invalid. */
+            valid: components["schemas"]["FormatValidity"];
         };
         /**
          * @description Describes the shape of a game and how its result is post processed.
@@ -2440,10 +2701,15 @@ declare interface components {
                 [key: string]: components["schemas"]["DqSettings"];
             };
             entryListColumns: components["schemas"]["RecordTypeWithDefaults"];
+            /** @description A group of game formats of the event. */
+            formatGroupId?: components["schemas"]["FormatGroupId"] | null;
             name: string;
             /** @description Run in order on every result row. */
-            postProcessingSteps: components["schemas"]["GameFormatPostProcessingStep"][];
+            postProcessingSteps: components["schemas"]["GameFormatStep_for_GameFormatPostProcessingStep"][];
+            /** @description Run in order on every row of the entry list, before the game. */
+            preProcessingSteps?: components["schemas"]["GameFormatStep_for_GameFormatPreProcessingStep"][];
             resultListColumns: components["schemas"]["RecordTypeWithDefaults"];
+            tags?: components["schemas"]["Tags"];
         };
         /**
          * Format: uuid
@@ -2456,12 +2722,14 @@ declare interface components {
             gameFormatId: components["schemas"]["GameFormatId"];
             workspaceId: components["schemas"]["CommonWorkspaceId"];
         };
-        /**
-         * @description One step of a game format's post processing. Automations run in order on every row of a game's
-         *      result, after the result has been entered. They never change the stored result of the game, only
-         *      the result table the game node outputs.
-         */
-        GameFormatPostProcessingStep: GameFormatPostProcessingStep;
+        /** @description A pre or post processing step with a description for the people reading the game format. */
+        GameFormatStep_for_GameFormatPostProcessingStep: GameFormatStep<GameFormatPostProcessingStep>;
+        /** @description A pre or post processing step with a description for the people reading the game format. */
+        GameFormatStep_for_GameFormatPreProcessingStep: GameFormatStep<GameFormatPreProcessingStep>;
+        GameFormatValidationError: {
+            /** @description Not empty. */
+            errors: components["schemas"]["AutomationError"][];
+        };
         /**
          * Format: uuid
          * @description Identifies a game, the primary key of `games`. Comes from one of:
@@ -2473,9 +2741,9 @@ declare interface components {
          *      Changing a derivation changes what replaying a log produces and needs an `ENGINE_VERSION` increment.
          */
         GameId: GameId;
-        GameNodeDTO: GameNodeDTO;
         /** @description How many games a game node plays and how they depend on each other. */
-        GameNodeVariant: GameNodeVariant;
+        GameModeKind: GameModeKind;
+        GameNodeDTO: GameNodeDTO;
         GamePathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
             gameId: components["schemas"]["GameId"];
@@ -2524,6 +2792,8 @@ declare interface components {
         };
         /** @description Location of a validation error in the graph. */
         GraphLocation: GraphLocation;
+        /** @description How a group outputs the disqualifications of a key it catches. */
+        GroupCatch: GroupCatch;
         /**
          * @description Contains other nodes. It can add its name to the folder path of its descendants and catch the disqualifications
          *      they throw.
@@ -2577,6 +2847,13 @@ declare interface components {
         });
         /** @enum {string} */
         HeaderStyle: "simple";
+        /**
+         * @description The kinds of entities with a history.
+         * @enum {string}
+         */
+        HistoryEntity: "event" | "game" | "table" | "game-format" | "scoring-definition" | "format-group" | "format" | "format-node" | "format-test" | "class" | "competitor";
+        /** @description A note, serialized as a plain string, or a disqualification. */
+        HistoryEntry: HistoryEntry;
         ImportArchiveError: {
             /** @constant */
             type: "invalid-archive";
@@ -2589,9 +2866,6 @@ declare interface components {
             /** @constant */
             type: "missing-lookup-format-group";
             data: components["schemas"]["FormatGroupId"];
-        } | {
-            /** @constant */
-            type: "multiple-root-formats";
         };
         ImportArchiveMutation: {
             archive: components["schemas"]["Archive"];
@@ -2603,9 +2877,11 @@ declare interface components {
              *      built; reusing a seed in the same event reproduces the same ids.
              */
             nodeUuidSeed?: components["schemas"]["Seed"] | null;
-            /** @default as-format */
-            rootFormat: components["schemas"]["RootFormatImport"];
         };
+        /** @description Node types that aren't deterministic: they read or write the workspace, play games or raise disqualifications. */
+        ImpureNodeType: ImpureNodeType;
+        /** @description Auto-generated discriminant enum variants */
+        ImpureNodeTypeDiscriminants: ("game" | "input-table" | "class" | "disqualify" | "split-by-class" | "event-competitors" | "classes-competitors") | "output-table";
         /**
          * @description The object provides metadata about the API.
          *      The metadata MAY be used by the clients if needed,
@@ -2639,8 +2915,14 @@ declare interface components {
         } & {
             [key: string]: unknown;
         };
+        /** @description Node types as deterministic as what they stand for. */
+        InheritedNodeType: InheritedNodeType;
+        /** @description Auto-generated discriminant enum variants */
+        InheritedNodeTypeDiscriminants: "format" | "filter-table" | "table-map" | "array-map" | "repeat";
         /** Format: uint16 */
         InputIdx: InputIdx;
+        /** @description The table an InputTableNode outputs. */
+        InputTableLink: InputTableLink;
         InstallExtensionBody: {
             identifier: components["schemas"]["ExtensionIdentifier"];
             kind: components["schemas"]["ExtensionKind"];
@@ -2663,6 +2945,16 @@ declare interface components {
         };
         InvalidLinkedFormatPolicy: "empty-table" | "node-error" | "last-known-table";
         InvalidNodeReason: InvalidNodeReason;
+        /** @description A valid format that an action would make invalid. */
+        InvalidatedFormat: {
+            /** @description Why it would turn invalid: its validation errors after the action. */
+            errors: components["schemas"]["FormatValidationError"][];
+            formatId: components["schemas"]["FormatId"];
+        };
+        /** @description How the finals of a ladder game node get their name or their attributes. */
+        LadderInput: LadderInput;
+        /** @description The finals of a ladder game node. */
+        LadderNode: LadderNode;
         /** @description License information for the exposed API. */
         License: {
             /** @description An [SPDX](https://spdx.org/spdx-specification-21-web-version#h.jxpfx0ykyb60) license expression for the API. The `identifier` field is mutually exclusive of the `url` field. */
@@ -2727,17 +3019,10 @@ declare interface components {
         } | {
             operationId: string;
         });
-        /** @description Links the entities a template was created from to its archive entries. */
+        /** @description Links the entities a template was created from to its archive entries, except root formats, which are never linked. */
         LinkToTemplateMutation: {
             wiring: components["schemas"]["Wiring"];
         };
-        LoadArchiveQuery: {
-            /**
-             * @description What to do with a root format contained in the archive.
-             * @default as-format
-             */
-            rootFormat: components["schemas"]["RootFormatImport"];
-        };
         LocalExtensionPath: {
             extensionIdent: components["schemas"]["ExtensionIdentifier"];
         };
@@ -2772,6 +3057,11 @@ declare interface components {
         };
         /** Format: uuid */
         LogBatchId: string;
+        /** @description Log entries of a branch, in log order. */
+        LogEntriesDTO: {
+            branch: components["schemas"]["CommonWorkspaceId"];
+            entries: components["schemas"]["LogEntrySmall"][];
+        };
         LogEntry: {
             /** @constant */
             type: "add-game-format";
@@ -2788,6 +3078,22 @@ declare interface components {
             /** @constant */
             type: "update-game-format";
             data: components["schemas"]["UpdateGameFormatMutation"];
+        } | {
+            /** @constant */
+            type: "add-scoring-definition";
+            data: components["schemas"]["AddScoringDefinitionMutation"];
+        } | {
+            /** @constant */
+            type: "rename-scoring-definition";
+            data: components["schemas"]["RenameScoringDefinitionMutation"];
+        } | {
+            /** @constant */
+            type: "delete-scoring-definition";
+            data: components["schemas"]["DeleteScoringDefinitionMutation"];
+        } | {
+            /** @constant */
+            type: "update-scoring-definition";
+            data: components["schemas"]["UpdateScoringDefinitionMutation"];
         } | {
             /** @constant */
             type: "add-class";
@@ -3028,9 +3334,35 @@ declare interface components {
         };
         /**
          * @description What a continuation does with competitors of its parts that are missing from the previous result.
-         *      If the previous result is empty, nobody is missing: everyone's previous total is 0.
+         *
+         *      A continuation of a scoring's result, straight or through nodes that keep the table's metadata, scores like one
+         *      scoring node over all parts of the chain: the points of the earlier parts are carried, the discards and tie breaks of
+         *      the last node apply to all parts, `part.index` counts through the chain, and the result has the columns of all
+         *      parts. Each part's points come from the node that scores it. The direction must be the same along the chain. For
+         *      competitors new in a later node, only [Self::ScoredAsAbsent] is exactly like one node. Continuing a table that
+         *      doesn't come from a scoring only adds to its `total_points` and keeps its columns.
+         *
+         *      If the previous result is empty, nobody is missing.
          */
         MissingFromPrevious: MissingFromPrevious;
+        /** @description Something a format uses that its [FormatRefs] lack. */
+        MissingReference: {
+            /** @constant */
+            type: "format";
+            data: components["schemas"]["FormatId"];
+        } | {
+            /** @constant */
+            type: "game-format";
+            data: components["schemas"]["GameFormatId"];
+        } | {
+            /** @constant */
+            type: "scoring-definition";
+            data: components["schemas"]["ScoringDefinitionId"];
+        } | {
+            /** @constant */
+            type: "input-table-link";
+            data: components["schemas"]["InputTableLink"];
+        };
         /** @enum {string} */
         MultiplexingStrategy: MultiplexingStrategy;
         NameQuery: {
@@ -3039,15 +3371,34 @@ declare interface components {
         NoSupertypeLayerReason: NoSupertypeLayerReason;
         NoSupertypeLayer_for_Type: NoSupertypeLayer<Type>;
         /** @enum {string} */
-        NodeCategory: "logic" | "game" | "tables" | "arrays" | "math" | "class" | "input-output" | "invalid" | "other" | "root";
+        NodeCategory: NodeCategory;
         NodeConfigurationError: NodeConfigurationError;
         NodeDocTest: {
             description?: string | null;
             format: components["schemas"]["FormatDTO"];
+            dependencies: components["schemas"]["NodeDocTestDependencies"];
             name?: string | null;
             nodeType: components["schemas"]["NodeType"];
             test: components["schemas"]["FormatTestDefinition"];
         };
+        /** @description What the format of a [NodeDocTest] refers to, by the ids it uses. The test imports them with the format. */
+        NodeDocTestDependencies: {
+            classes: {
+                [key: string]: components["schemas"]["ClassDTO"];
+            };
+            formats: {
+                [key: string]: components["schemas"]["FormatDTO"];
+            };
+            gameFormats: {
+                [key: string]: components["schemas"]["GameFormatDTO"];
+            };
+            /** @description The prototypes of the Class and Format nodes of these, as an event with them has them. */
+            prototypes: components["schemas"]["NodePrototype"][];
+            /** @description The fundamental scorings the Scoring nodes use, by their archive ids, see [FundamentalScoring::archive_id]. */
+            scoringDefinitions: {
+                [key: string]: components["schemas"]["ScoringDefinitionDTO"];
+            };
+        };
         NodeErrorState_for_NodeRuntimeError: {
             /** @constant */
             type: "ok";
@@ -3104,7 +3455,6 @@ declare interface components {
         NodePlacement: {
             group?: components["schemas"]["SimplifiedGroupId"] | null;
             link?: components["schemas"]["NodeLinkId"] | null;
-            section: components["schemas"]["SimplifiedSectionId"];
         };
         NodePrototype: {
             /**
@@ -3138,9 +3488,15 @@ declare interface components {
         NodeRuntimeError: {
             /** @constant */
             type: "table-kind-mismatch";
+        } | {
+            /** @constant */
+            type: "scoring-direction-mismatch";
         } | {
             /** @constant */
             type: "table-ownership-mismatch";
+        } | {
+            /** @constant */
+            type: "linked-format-is-invalid";
         } | {
             /** @constant */
             type: "game-not-found";
@@ -3170,6 +3526,9 @@ declare interface components {
         } | {
             /** @constant */
             type: "integer-overflow";
+        } | {
+            /** @constant */
+            type: "invalid-math-operands";
         } | {
             /** @constant */
             type: "record-field-does-not-exist";
@@ -3190,17 +3549,26 @@ declare interface components {
                 /** Format: uint */
                 expectedRowLength: number;
                 /** Format: uint */
-                foundRowLength?: number | null;
+                foundRowLength: number;
                 /** Format: uint */
                 rowIndex: number;
             };
+        } | {
+            /** @constant */
+            type: "invalid-distribution";
+            data: {
+                /** Format: int64 */
+                maxTableSize: number;
+                /** Format: int64 */
+                minTableSize: number;
+            };
         } | {
             /** @constant */
             type: "invalid-row-types";
             data: components["schemas"]["RecordValueTypeValidationError"];
         } | {
             /** @constant */
-            type: "disqualification-script-error";
+            type: "script-error";
             data: components["schemas"]["RuntimeErrorKind"];
         };
         /**
@@ -3213,24 +3581,29 @@ declare interface components {
          *      Written in notation as `<T>(T) -> (T)` for the identity node.
          */
         NodeSignature_for_Type_and_ParamRef: NodeSignature<Type, ParamRef>;
+        /**
+         * @description What a node does. Its purity says whether its nodes are deterministic: what they output depends only on their inputs,
+         *      their node type and the formats and scoring definitions they reference. Deterministic formats (see
+         *      [FormatInterface::deterministic]) and pipelines contain only deterministic nodes.
+         *
+         *      Top level purity distinction to have that be a type system invariant from the start. Reduces invariants.
+         */
         NodeType: NodeType;
-        /** @description Auto-generated discriminant enum variants */
-        NodeTypeDiscriminants: ("input" | "output" | "format" | "math" | "game" | "input-table" | "portal" | "class" | "disqualify" | "group" | "string-concat" | "string-format" | "sort-node" | "constant" | "merge-tables" | "divide-table" | "distribute-table" | "split-table" | "concat" | "remove-places" | "table-map" | "length" | "boolean-op" | "record-field" | "add-record-fields" | "fallback" | "gt-row" | "filter-gt" | "comparison" | "comment" | "ternary" | "separate-row" | "update-row" | "array-map" | "create-array" | "create-table" | "array-access" | "unpack-array" | "promotion-relegation" | "age-at" | "split-by-class" | "empty-record" | "event-competitors" | "add-columns" | "matrix-transpose" | "simple-scoring" | "classes-competitors") | "output-table" | "invalid";
-        NodeVariantDoc: {
-            description?: string | null;
-            /** @default other */
-            category: components["schemas"]["NodeCategory"];
-            /** @description If the node has `children_spec` set to `Closure`, this documents that closure */
-            closureDocs?: components["schemas"]["NodeVariantDoc"] | null;
-            inputVargsToArrayArrayLabel: components["schemas"]["PortLabelPart"][];
-            inputs: components["schemas"]["PortsDoc"];
-            /** @description The label for the new output when vargs_to_array is enabled. */
-            outputVargsToArrayArrayLabel: components["schemas"]["PortLabelPart"][];
-            /** @description The label for the new input when vargs_to_array is enabled. */
-            outputVargsToArrayCountLabel: components["schemas"]["PortLabelPart"][];
-            outputs: components["schemas"]["PortsDoc"];
-            variantLabel: string;
+        /** @description The kind of a [NodeType] without its data: `{ "purity": "pure", "type": "math" }`. */
+        NodeTypeDiscriminants: {
+            type: components["schemas"]["PureNodeTypeDiscriminants"];
+            /** @constant */
+            purity: "pure";
+        } | {
+            type: components["schemas"]["ImpureNodeTypeDiscriminants"];
+            /** @constant */
+            purity: "impure";
+        } | {
+            type: components["schemas"]["InheritedNodeTypeDiscriminants"];
+            /** @constant */
+            purity: "inherited";
         };
+        NodeVariantDoc: NodeVariantDoc;
         NodeVariantPrototype: {
             childrenSpec: components["schemas"]["ChildrenSpec"];
             /**
@@ -3241,8 +3614,6 @@ declare interface components {
             /** Format: uint32 */
             defaultOutputVargCount: number;
             includeInSearch: boolean;
-            /** @description These outputs emit warnings when not used */
-            mustUseOutputs: components["schemas"]["OutputIdx"][];
             /** @description Uniquely identifies a node variant */
             nodeType: components["schemas"]["NodeType"];
             /** @description Type of settings excluding the variant property. */
@@ -3864,49 +4235,20 @@ declare interface components {
         Paths: {
             [key: string]: components["schemas"]["ReferenceOr_for_PathItem"];
         };
-        PortDoc: {
-            description?: string | null;
-            defaultValue?: components["schemas"]["Value_for_Primitive"] | null;
-            /** @description CustomControls only get used when enabled with this property. */
-            enabledCustomControls: components["schemas"]["CustomControl"][];
-            /** @description Each port label part gets turned into a string and then concatenated to retrieve the full label. */
-            label: components["schemas"]["PortLabelPart"][];
-            /** @description Finite value options representing the value will get labeled with the string */
-            valueLabels: [
-            components["schemas"]["Value_for_Primitive"],
-            string
-            ][];
-        };
-        PortLabelPart: {
-            /** @constant */
-            type: "idx-decimal";
-            /** Format: int64 */
-            data: number;
-        } | {
-            /** @constant */
-            type: "idx-alphabetic";
-            /** Format: int64 */
-            data: number;
-        } | {
-            /** @constant */
-            type: "idx-ordinal";
-            /** Format: int64 */
-            data: number;
-        } | {
-            /** @constant */
-            type: "string";
-            data: string;
-        };
+        PortDoc: PortDoc;
+        PortLabelPart: PortLabelPart;
         /** @description A list of port types, optionally with a variadic type (`...T`). */
         PortTypes_for_Type_and_ErasedScopedTypeRef_for_Type: PortTypes<Type, components["schemas"]["ErasedScopedTypeRef_for_Type"]>;
         /** @description A list of port types, optionally with a variadic type (`...T`). */
         PortTypes_for_Type_and_ParamRef: PortTypes<Type, ParamRef>;
-        PortsDoc: {
-            ports: components["schemas"]["PortDoc"][];
-            varg?: components["schemas"]["PortDoc"] | null;
-        };
+        PortsDoc: PortsDoc;
         PostFormatQuery: {
             force: boolean;
+            /**
+             * @description Never changes afterwards.
+             * @default normal
+             */
+            kind: components["schemas"]["FormatKind"];
         };
         PostRandomCompetitorsQuery: {
             count: components["schemas"]["LimitedInt_for_1_and_500"];
@@ -3918,6 +4260,15 @@ declare interface components {
         };
         /** @description Crate local version of [std::convert::Infallible] */
         Primitive: Primitive;
+        /**
+         * @description The pre or post processing steps of a game format.
+         * @enum {string}
+         */
+        ProcessingStage: ProcessingStage;
+        /** @description Deterministic node types. Input, output, group, portal and comment nodes only route values. */
+        PureNodeType: PureNodeType;
+        /** @description Auto-generated discriminant enum variants */
+        PureNodeTypeDiscriminants: ("input" | "output" | "group" | "portal" | "comment" | "math" | "string-concat" | "string-format" | "sort-table" | "constant" | "merge-tables" | "divide-table" | "distribute-table" | "split-table" | "concat-tables" | "remove-places" | "transfer-history" | "length" | "boolean-op" | "record-field" | "record" | "record-access" | "fallback" | "comparison" | "ternary" | "separate-row" | "update-row" | "create-array" | "create-table" | "array-access" | "unpack-array" | "promotion-relegation" | "age-at" | "add-columns" | "matrix-transpose" | "scoring" | "script-closure") | "invalid" | "zip";
         PushTableRowMutationsMutation: {
             /**
              * @description Challenge for a client to prevent accidentally
@@ -3938,6 +4289,10 @@ declare interface components {
             classId: components["schemas"]["ClassId"];
             seed: components["schemas"]["Seed"];
         };
+        /** @description Reads `keys` of a record, see [record_access_node_sig]. */
+        RecordAccessNode: RecordAccessNode;
+        /** @description What a record node adds its fields to. */
+        RecordBase: RecordBase;
         /** @enum {string} */
         RecordFieldOp: RecordFieldOp;
         RecordMakeValidMutation: RecordMakeValidMutation;
@@ -3955,6 +4310,8 @@ declare interface components {
             /** @description The mutations that were applied to make the record valid. */
             mutations: components["schemas"]["RecordMakeValidMutation"][];
         };
+        /** @description The record node: a record with `fields`, see [record_node_sig]. */
+        RecordNode: RecordNode;
         /** @description RecordTypes should **only** be manipulated though this helper to have a single source of truth for the structure. */
         RecordTypeHelper_for_ParamRef: RecordTypeHelper<ParamRef>;
         RecordTypeWithDefaults: RecordTypeWithDefaults;
@@ -4179,6 +4536,9 @@ declare interface components {
              */
             force: boolean;
         };
+        RenameBranchBody: {
+            name: string;
+        };
         RenameClassMutation: {
             classId: components["schemas"]["ClassId"];
             name: string;
@@ -4191,6 +4551,12 @@ declare interface components {
             gameFormatId: components["schemas"]["GameFormatId"];
             name: string;
         };
+        RenameScoringDefinitionMutation: {
+            name: string;
+            scoringDefinitionId: components["schemas"]["ScoringDefinitionId"];
+        };
+        /** @description What a repeat node runs its closure for. */
+        RepeatOver: RepeatOver;
         ReplicateWorkspaceQuery: {
             logId: components["schemas"]["LogId"];
             name: string;
@@ -4315,8 +4681,6 @@ declare interface components {
         } & {
             [key: string]: components["schemas"]["ReferenceOr_for_Response"];
         };
-        /** @description What happens to a format of the archive that was the root format of the exported event. */
-        RootFormatImport: "as-format" | "overwrite" | "ignore";
         RootFormatResponse: {
             rootFormat: components["schemas"]["FullFormatDAO"];
             /** @description None if the format was never executed */
@@ -4392,11 +4756,99 @@ declare interface components {
             /** @description Additional external documentation for this schema. */
             externalDocs?: components["schemas"]["ExternalDocumentation"] | null;
         };
-        /** @description Only `[a-z0-9-]`, at least one character. */
-        SecretName: string;
-        SecretPath: {
-            extensionIdent: components["schemas"]["ExtensionIdentifier"];
-            name: components["schemas"]["SecretName"];
+        /** @description A way to score a part, with parameters a node sets. An entity of an event, like a game format. */
+        ScoringDefinition: ScoringDefinition;
+        /** @description A scoring definition of an event. Can be stored invalid, like a format: then every format using it is invalid. */
+        ScoringDefinitionDAO: {
+            customData: {
+                [key: string]: string;
+            };
+            definition: components["schemas"]["ScoringDefinition"];
+            /** @description [ScoringDefinition::validate], empty for a valid definition. */
+            errors: components["schemas"]["ScoringScriptError"][];
+            eventId: components["schemas"]["EventId"];
+            id: components["schemas"]["ScoringDefinitionId"];
+            /** Format: uuid */
+            templateOrigin?: string | null;
+            valid: components["schemas"]["FormatValidity"];
+        };
+        /** @description A way to score a part, with parameters a node sets. An entity of an event, like a game format. */
+        ScoringDefinitionDTO: {
+            description: string;
+            customData?: {
+                [key: string]: string;
+            };
+            direction: components["schemas"]["ScoringDirection"];
+            name: string;
+            /** @description The documentation of each parameter, by name, like the ports of a node. */
+            parameterDocs: {
+                [key: string]: components["schemas"]["PortDoc"];
+            };
+            /** @description The script sees their values as `params`. Every parameter has a default. */
+            parameters: components["schemas"]["RecordTypeWithDefaults"];
+            /** @description The columns the rows of every part must have, the script sees them in `row.attributes`. */
+            requiredColumns: components["schemas"]["RecordTypeHelper_for_ParamRef"];
+            /** @description A graphite script, typechecked like [ScoringPoints::Custom]'s with `params` in addition. */
+            script: string;
+            /** @description Examples of what the definition scores, see [Self::run_test]. */
+            tests: components["schemas"]["ScoringTest"][];
+        };
+        /**
+         * Format: uuid
+         * @description Identifies a scoring definition of an event. Random ([Self::new_random]) from the endpoint, derived for the
+         *      fundamental scorings of a new event, or derived by `ImportArchiveMutation`. Deserializing one only yields a
+         *      reference to an existing definition; it does not check that it exists.
+         */
+        ScoringDefinitionId: ScoringDefinitionId;
+        ScoringDefinitionPathVariables_for_CommonWorkspaceId: {
+            eventId: components["schemas"]["EventId"];
+            scoringDefinitionId: components["schemas"]["ScoringDefinitionId"];
+            workspaceId: components["schemas"]["CommonWorkspaceId"];
+        };
+        ScoringDirection: ScoringDirection;
+        /**
+         * @description Scores competitors over several parts, e.g. the races of a series.
+         *
+         *      ```text
+         *      <R0 extends {}, ...>(Table<R0, Sorted>, ...) -> (Table<{total_points: P, <part name>: P, ...}, Sorted>)
+         *      ```
+         *
+         *      One input per part and one output table. Competitors are the union of all parts. The script of `points` computes
+         *      the points of every competitor in every part. `P` is `Integer` if the script returns integers whatever the
+         *      columns of the parts, else `Integer | Float`. If the points are `null` for a part, the competitor is left out of
+         *      the result. The total is the sum of the points, without the worst `discards`. The output is ranked by the total in
+         *      the direction of `points`, ties are broken by the `tie_breaks` in order, and competitors still tied share the
+         *      place.
+         *
+         *      With `continues_previous`, the first input is the result of a previous scoring,
+         *      `Table<{total_points: Integer | Float}, Sorted>`, and the totals add this node's parts to the previous
+         *      `total_points`. The previous result's other columns are carried over, those named like a part are replaced. Ties
+         *      keep the previous result's order. Discards and tie breaks only see this node's parts.
+         */
+        ScoringNode: ScoringNode;
+        /** @description One scored part, e.g. a single race of a series. */
+        ScoringPart: ScoringPart;
+        /** @description The points of a scoring node. */
+        ScoringPoints: ScoringPoints;
+        /** @description The script of a scoring node does not parse or typecheck. */
+        ScoringScriptError: ScoringScriptError;
+        /** @description Parts scored with values of the parameters, and the result they are expected to score to. */
+        ScoringTest: ScoringTest;
+        ScoringTestPart: ScoringTestPart;
+        /**
+         * @description Outputs a deterministic closure (scripts are) with `signature`. Calling it runs `script` with each input bound to the
+         *      variable of its name, and what the script evaluates to is the closure's output.
+         *
+         *      ```text
+         *      () -> (<signature>)
+         *      ```
+         */
+        ScriptClosureNode: ScriptClosureNode;
+        /** @description Only `[a-z0-9-]`, at least one character. */
+        SecretName: string;
+        SecretPath: {
+            extensionIdent: components["schemas"]["ExtensionIdentifier"];
+            name: components["schemas"]["SecretName"];
         };
         /** @description At most 16 KiB. Its [Debug] does not show the value. */
         SecretValue: string;
@@ -4544,29 +4996,6 @@ declare interface components {
         SetFormatsFormatGroupQuery: {
             formatGroupId?: components["schemas"]["FormatGroupId"] | null;
         };
-        /**
-         * @description Place 1 = 1 point, Place 2 = 2 points, etc.
-         *      On tie, whoever won the part with the highest priority wins.
-         *      If still tied, the next lower priority part is considered etc.
-         *
-         *      ```text
-         *      (Table<{}, Sorted>, ...) -> (Table<{total_points: Integer, <part name>: Integer, ...}, Sorted>)
-         *      ```
-         *
-         *      One input per part and one output table, sorted by ascending total points.
-         *      Competitors are the union of all parts: a competitor without a place in a part
-         *      (missing from the table of that part, or in it without a place) scores one point
-         *      more than that part has rows, so not finishing a part is always worse than
-         *      finishing it last. An empty part has not taken place yet and scores 0 for everyone.
-         *
-         *      With `continues_previous`, the first input is the result of a previous scoring,
-         *      `Table<{total_points: Integer}, Sorted>`, and the totals add this node's parts to the previous `total_points`.
-         *      The previous result's other columns are carried over, those named like a part are replaced. Ties keep the
-         *      previous result's order.
-         */
-        SimpleScoringNode: SimpleScoringNode;
-        /** @description One scored part, e.g. a single race of a series. */
-        SimpleScoringPart: SimpleScoringPart;
         SimplifiedGroup: {
             id: components["schemas"]["SimplifiedGroupId"];
             name: string;
@@ -4576,25 +5005,19 @@ declare interface components {
          * @description Unique per format, not only per section.
          */
         SimplifiedGroupId: SimplifiedGroupId;
-        SimplifiedSection: {
-            /** @description In display order. */
-            groups: components["schemas"]["SimplifiedGroup"][];
-            id: components["schemas"]["SimplifiedSectionId"];
-            name: string;
-        };
-        /** Format: uuid */
-        SimplifiedSectionId: SimplifiedSectionId;
         /**
          * @description How the simplified view arranges the format's nodes. Only the simplified view interprets it: the backend stores it,
          *      keeps its references consistent ([Self::repaired]) and carries it over to copies with new node ids.
          */
         SimplifiedView: {
+            /** @description In display order. */
+            groups: components["schemas"]["SimplifiedGroup"][];
             nodes: {
                 [key: string]: components["schemas"]["NodePlacement"];
             };
-            /** @description In display order. */
-            sections: components["schemas"]["SimplifiedSection"][];
         };
+        /** @description Where the rows of the competitors sitting out go. They keep no columns. */
+        SitOutHandling: SitOutHandling;
         SnapshotMultipart: {
             /** Format: binary */
             file: Blob;
@@ -4644,14 +5067,21 @@ declare interface components {
          *
          *      for `Static { split_count }`:
          *      ```text
-         *      <C extends {}>(Table<C, Sorted>, Integer * split_count) -> (Table<C, Sorted> * (split_count + 1))
+         *      <C extends {}>(table: Table<C, Sorted>, cut_1: Integer, …, cut_<split_count>: Integer)
+         *          -> (part_1: Table<C, Sorted>, …, part_<split_count + 1>: Table<C, Sorted>)
          *      ```
          *      for `Dynamic`:
          *      ```text
-         *      <C extends {}>(Table<C, Sorted>, Array<Integer>) -> (Array<Table<C, Sorted>>)
+         *      <C extends {}>(table: Table<C, Sorted>, cuts: Array<Integer>) -> (parts: Array<Table<C, Sorted>>)
          *      ```
          */
         SplitTableNode: SplitTableNode;
+        /**
+         * Format: uuid
+         * @description Identifies a sport, the content that the root server serves. Unknown ids are not refused: the event keeps
+         *      them, clients fall back to the generic sport.
+         */
+        SportId: string;
         /** @description A standalone table of the user. Its kind is always [TableKind::Other], its state is set like the state of any table. */
         StandaloneTableDTO: {
             columnTypes: components["schemas"]["RecordTypeWithDefaults"];
@@ -4688,24 +5118,26 @@ declare interface components {
              */
             gameDepth: number;
             id: components["schemas"]["TableId"];
-            /** @description The owner of the tables data (items, attributes and state) */
-            layerOneOwner: components["schemas"]["TableOwner"];
+            /** @description Empty for the entry and result tables of game nodes: clients name game tables by their [Self::table_kind]. */
             name: string;
+            /** @description Who created the table. */
             owner: components["schemas"]["ContentOwner"];
+            ownership: components["schemas"]["TableOwnership"];
             state: components["schemas"]["ContentState"];
-            /** @description Set by nodes. */
-            stateLayerOne: components["schemas"]["TableState"];
-            /** @description Overwrites layer one if Some */
-            stateLayerTwo?: components["schemas"]["TableState"] | null;
+            /** @description Set by nodes only. */
+            stateNodes?: components["schemas"]["TableState"] | null;
+            /** @description Set by users only, takes precedence over [Self::state_nodes]. See [Self::resolve_state]. */
+            stateUser?: components["schemas"]["TableState"] | null;
             tableKind: components["schemas"]["TableKind"];
             variant: components["schemas"]["TableVariant"];
         };
         TableDTO: {
             name: string;
-            /** @description If Some, sets either layer one or layer two state depending on who issues the request. */
+            /** @description The [TableDAO::state_user]. */
             state?: components["schemas"]["TableState"] | null;
             tableKind: components["schemas"]["TableKind"];
         };
+        TableFilter: TableFilter;
         /**
          * Format: uuid
          * @description Identifies a table, the primary key of `tables`. Comes from one of:
@@ -4766,8 +5198,11 @@ declare interface components {
             /** @description The test id of the node reading the table. */
             nodeId: components["schemas"]["FormatNodeTestId"];
         };
-        /** @enum {string} */
-        TableOwner: "nodes" | "user";
+        /**
+         * @description Who writes the rows of a table. Independent of who created it ([ContentOwner]): nodes create user owned tables too,
+         *      e.g. the result tables of their games, but a table the user created is always user owned.
+         */
+        TableOwnership: "node-owned" | "user-owned";
         TablePathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
             tableId: components["schemas"]["TableId"];
@@ -4821,6 +5256,8 @@ declare interface components {
         } & {
             [key: string]: unknown;
         };
+        /** @description A set of tags, each trimmed and not empty. Deserializing normalizes any list of strings into this. */
+        Tags: string[];
         TargetDTO: {
             acknowledged: components["schemas"]["LogHead"];
             backendUrl: string;
@@ -4938,7 +5375,13 @@ declare interface components {
             /** @constant */
             type: "format-group";
             id: components["schemas"]["FormatGroupId"];
+        } | {
+            /** @constant */
+            type: "scoring-definition";
+            id: components["schemas"]["ScoringDefinitionId"];
         };
+        /** @description A rule deciding between competitors with the same total. */
+        TieBreak: TieBreak;
         /**
          * @description The first value are the seconds of the delta, the second are nanoseconds.
          *      the nanoseconds are always 0 <= nanos < (1000000)
@@ -4947,6 +5390,11 @@ declare interface components {
         number,
         number
         ];
+        /** @description Query of every endpoint that reads a running workspace. */
+        TimeMachineQuery: {
+            /** @description Shows the workspace as it was right after this log entry, read-only. `0` is the empty workspace. */
+            atEntry?: components["schemas"]["LogId"] | null;
+        };
         /** @description One way a row got to where it is. */
         Trail: Trail;
         Type: Type;
@@ -5072,6 +5520,11 @@ declare interface components {
             test: components["schemas"]["FormatTestDefinition"];
         };
         UpdateGameFormatMutation: {
+            /**
+             * @description If true, saves the game format although its settings don't validate, invalidating the formats using it and
+             *      with them their games. Implies `invalidate_formats`.
+             */
+            force?: boolean;
             gameFormat: components["schemas"]["GameFormatDTO"];
             id: components["schemas"]["GameFormatId"];
             /** @description If true, will proceed even if that invalidates formats. */
@@ -5082,6 +5535,12 @@ declare interface components {
             modifyRows: boolean;
         };
         UpdateGameFormatQuery: {
+            /**
+             * @description If true, saves the game format although its settings don't validate, invalidating the formats using it and
+             *      with them their games. Implies `invalidateFormats`.
+             * @default false
+             */
+            force: boolean;
             /**
              * @description If true, will proceed even if that invalidates formats.
              * @default false
@@ -5102,8 +5561,38 @@ declare interface components {
             game: components["schemas"]["GameDTO"];
             id: components["schemas"]["GameId"];
         };
+        /**
+         * @description Stores the definition even if it is invalid, with its errors. The formats using it are revalidated, the parameters
+         *      of their scoring nodes made valid for the new parameters with the defaults.
+         */
+        UpdateScoringDefinitionMutation: {
+            id: components["schemas"]["ScoringDefinitionId"];
+            /** @description If true, will proceed even if that invalidates formats, like an invalid definition does. */
+            invalidateFormats: boolean;
+            /** @description If true, will reset now incompatible parameters of the scoring nodes to their defaults. */
+            modifyUsages: boolean;
+            scoringDefinition: components["schemas"]["ScoringDefinitionDTO"];
+        };
+        UpdateScoringDefinitionQuery: {
+            /**
+             * @description If true, will proceed even if that invalidates formats.
+             * @default false
+             */
+            invalidateFormats: boolean;
+            /**
+             * @description If true, will reset now incompatible parameters of the scoring nodes to their defaults.
+             * @default false
+             */
+            modifyUsages: boolean;
+        };
         /** @description Renames a standalone table of the user and sets its column types. */
         UpdateStandaloneTableMutation: {
+            /**
+             * @description Lets changed column types invalidate the formats whose InputTableNodes link the table. Without it, the update
+             *      fails if that would make any of them invalid.
+             * @default false
+             */
+            invalidateFormats: boolean;
             /**
              * @description Makes the rows and row mutations valid for changed column types, see [RecordTypeWithDefaults::make_valid].
              *      Without it, the update fails if that would change any of them.
@@ -5113,6 +5602,12 @@ declare interface components {
             tableId: components["schemas"]["TableId"];
         };
         UpdateStandaloneTableQuery: {
+            /**
+             * @description If true, changed column types may make the formats invalid whose input table nodes link the table. Otherwise
+             *      the update fails with `format-revalidation` naming them.
+             * @default false
+             */
+            invalidateFormats: boolean;
             /**
              * @description If true, makes the rows and row mutations valid for changed column types (missing or mistyped columns get the
              *      column's default). Otherwise the update fails with `change-would-modify-rows` if that would change any of them.
@@ -5155,6 +5650,8 @@ declare interface components {
          * @description Changes in here are breaking changes for logs
          */
         Value_for_SerializableNonPrimitiveValue: Value<SerializableNonPrimitiveValue>;
+        /** @description A name a script can refer to as a variable: an identifier that isn't a keyword. */
+        VariableName: VariableName;
         /**
          * @description The ids inside an archive (in its format DTO and here) are archive-local join keys, not ids of a workspace: each
          *      maps to the [Archive::uuid] of the dependency it refers to. Importing gives the entities new ids.
@@ -5172,6 +5669,9 @@ declare interface components {
             gameFormats: {
                 [key: string]: string;
             };
+            scoringDefinitions?: {
+                [key: string]: string;
+            };
             scriptedNodes: {
                 [key: string]: string;
             };
@@ -5200,6 +5700,8 @@ declare interface components {
             /** @description Anything but normal makes the workspace read-only. */
             state: components["schemas"]["WorkspaceState"];
         };
+        /** @description What a zip node does with lists of different lengths. */
+        ZipLengths: ZipLengths;
     };
     responses: never;
     parameters: never;
@@ -5262,6 +5764,27 @@ paginatedRowModel: (table: Table_2<any, any>) => () => RowModel<any, any>;
 columnVisibilityFeature: TableFeature;
 }, TData>;
 
+/**
+ * A page of the create-event assistant. The assistant shows it after its own steps, once per contribution of the
+ * extensions installed on the event, in install order. The extension stores what is entered itself, saving every change
+ * right away like the rest of the assistant; the assistant only keeps the page's {@link CreateEventAssistantProgress},
+ * shared by everyone working on the event.
+ */
+export declare interface CreateEventAssistantContribution {
+    title: Record<Locales, string>;
+    Component: FC<CreateEventAssistantProps>;
+}
+
+/** Whether the user can go on from the page to the next step of the assistant (`done`) or not yet (`incomplete`). */
+export declare type CreateEventAssistantProgress = 'incomplete' | 'done';
+
+export declare type CreateEventAssistantProps = EventPath & {
+    progress: CreateEventAssistantProgress;
+    onProgressChange: (progress: CreateEventAssistantProgress) => void;
+};
+
+declare type CustomControl = "sort-criterion";
+
 export declare const DateTimeInput: FC<DateTimeInputProps>;
 
 export declare interface DateTimeInputProps {
@@ -5294,22 +5817,45 @@ declare interface DetailedSupertypeDiagnostics<T> {
 export declare interface DialogButton<T> {
     value: T;
     label: ReactNode;
-    theme?: 'primary' | 'default' | 'danger';
+    /** Default: 'secondary'. */
+    theme?: AppButtonType;
+}
+
+/** What a dialog says: a short question or statement, the explanation of it and how serious it is. */
+export declare interface DialogMessage {
+    title: ReactNode;
+    body?: ReactNode;
+    /** Default: 'plain', without an icon. 'danger' is for what destroys data or has failed. */
+    tone?: DialogTone;
 }
 
-declare interface DialogOptions {
+export declare interface DialogOptions {
     /** Shows it in a window (see `ModalConfig.window`), for content with links that the user may follow first. */
-    window?: {
-        title: ReactNode;
-    };
+    window?: WindowOptions;
 }
 
+export declare type DialogTone = 'plain' | 'info' | 'warning' | 'danger';
+
 /**
  * Greys out a disabled competitor wherever it is shown. Nodes don't spawn disabled competitors, but they can still be
  * in classes and tables.
  */
 export declare function disabledCompetitorClassName(competitor: Pick<CompetitorDAO, 'enabled'> | undefined): string | undefined;
 
+/**
+ * A competitor's worst results that don't count towards their total.
+ */
+declare interface Discards {
+    /**
+     * How many results are discarded.
+     */
+    count: number;
+    /**
+     * A result whose `dqs` (see [script_type_context]) hold one of these keys is never discarded.
+     */
+    keep: DqKey[];
+}
+
 /**
  * Disqualifies every row of the table it receives, throwing them all under `key` so that a
  * [`GroupNode`](super::group_node::GroupNode) further up the graph can collect them.
@@ -5318,39 +5864,42 @@ declare interface DisqualifyNode {
     key: DqKey;
 }
 
-/**
- * What a node does by default with a disqualification it can throw.
- */
-declare type DqDefaultStrategy = "throw" | "output-placed" | "output-unplaced" | "append-placed" | "append-unplaced";
-
 /** A caught disqualification. The strategy decides how multiple caught tables of the key get merged. */
 declare interface DqEntry {
     key: DqKey_2;
     mergeStrategy: MultiplexingStrategy_2;
+    /** Whether the caught competitors keep their places. Disqualified competitors are usually unplaced. */
+    placed: boolean;
 }
 
-declare type DqKey = string;
+export declare type DqKey = string;
 
 declare type DqKey_2 = components['schemas']['DqKey'];
 
+export declare type DqKind = { type: "disqualified" };
+
+export declare interface DqRecord {
+    key: DqKey;
+    at: DqSource;
+    kind: DqKind;
+}
+
 /**
- * What a format or game format says about one of its disqualification kinds.
+ * What a game format says about one of its disqualification kinds.
  */
 declare interface DqSettings {
     description: string;
     /**
-     * Initialises `catch_dqs` of new nodes.
+     * What the game nodes of the game format do with the disqualification by default. Each game node can override
+     * it, see `GameNodeDTO::catches`.
      */
-    defaultStrategy: DqDefaultStrategy;
+    strategy: GameDqHandling;
 }
 
 /**
- * Decides how caught disqualifications are surfaced.
+ * Where a competitor got disqualified.
  */
-declare type DqStrategy = "output-placed" | "output-unplaced" | "append-placed" | "append-unplaced";
-
-/** How a game or format node surfaces a disqualification it catches. */
-declare type DqStrategy_2 = components['schemas']['DqStrategy'];
+export declare type DqSource = { type: "game"; game: string; ladder: boolean; formatTags: string[] } | { type: "node"; node: string };
 
 export declare type DraggableChildProps = React_2.HTMLAttributes<HTMLElement> & React_2.RefAttributes<HTMLElement>;
 
@@ -5374,7 +5923,9 @@ export declare type EngineQueryOptions<T> = UnusedSkipTokenOptions<T, Error, T,
  */
 declare type ErasedScopedTypeRef<T> = { type: "Param"; data: ParamRef } | { type: "ScopedExpr"; data: { expr: TypeExpr<T, ErasedScopedTypeRef<T>> } };
 
-declare type EventCompetitorsNode = CompetitorType_2;
+declare interface EventCompetitorsNode {
+    competitorType: CompetitorType_2;
+}
 
 export declare const eventFoldersByEventQueryOptions: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<ContentInEventFolderDTO[]>;
 
@@ -5395,6 +5946,10 @@ export declare class ExpressionInContextWasm {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * The type the expression evaluates to.
+     */
+    returnType(): TypeExpr<Type, ParamRef>;
     /**
      * Runs the expression with the provided primitive values.
      * @throws {ExpressionInContextError} if the expression is not valid or
@@ -5419,6 +5974,7 @@ export declare function extensionContribution<K extends keyof ExtensionContribut
 
 /** Props the host passes when rendering an inject at each slot. */
 export declare type ExtensionContributions = {
+    'create-event-assistant': CreateEventAssistantContribution;
     'game-format-page-bottom': GameFormatPageContribution;
     'game-page': GamePageContribution;
     'table-drop': TableDropContribution;
@@ -5488,6 +6044,15 @@ export declare interface ExtensionSidebarContribution {
 
 export declare type ExtensionSidebarProps = EventPath;
 
+/**
+ * A tutorial of the calling extension: its `id` only has to be unique within the extension, the state is stored as
+ * preference `tutorial:ext:<identifier>/<id>`, `identifier` being the one the extension is installed under.
+ */
+export declare interface ExtensionTutorial {
+    scope: 'extension';
+    id: string;
+}
+
 declare type ExtractRecordFieldError<T> = { type: "field-does-not-exist"; data: string } | { type: "invalid-type"; data: { field: string; value: Value<T> | null } };
 
 export declare interface FieldTypeWithDefault {
@@ -5496,6 +6061,10 @@ export declare interface FieldTypeWithDefault {
      * Validated to be a subtype of field_type
      */
     default: Value | null;
+    /**
+     * Never blank. Skipped when `None` so that types without one serialize (and hash) as before.
+     */
+    description?: string;
 }
 
 /** Games and result tables live in folders, and folders in folders. */
@@ -5509,6 +6078,11 @@ declare type FolderContentRef = {
 
 declare type FolderId = FormatNodeId;
 
+/**
+ * What the nodes representing a format do with a disqualification it raises.
+ */
+declare type FormatCatch = "throw" | "output-unplaced";
+
 /**
  * How a competitor is written out. Kept apart from the components that show competitors so both
  * the picker and the selector can reach it without importing each other.
@@ -5523,6 +6097,23 @@ declare interface FormatConnectionDTO {
     pins: ConnectionPin[];
 }
 
+/**
+ * What a format says about a disqualification kind it raises.
+ */
+declare interface FormatDqKind {
+    description?: string;
+    /**
+     * What the nodes representing the format do with the disqualification.
+     */
+    catch: FormatCatch;
+    /**
+     * The columns of the rows the format throws with the kind, which the nodes representing it throw them with. The
+     * editor sets them to what it infers; the validator checks that what the graph throws has them. None known: rows
+     * without columns.
+     */
+    columns?: RecordTypeHelper;
+}
+
 declare type FormatGroupId = Brand<string, 'formatGroupId'>;
 
 /**
@@ -5577,7 +6168,7 @@ declare type FormatTestId = Brand<string, 'formatTestId'>;
 /**
  * Represents a state in which the format is not valid for execution but can be stored in the db.
  */
-declare type FormatValidationError = { type: "uncaught-throw"; data: Record<DqKey, RowTypeHelper[]> } | { type: "unthrown-disqualification-kinds"; data: DqKey[] } | { type: "root-format-with-disqualification-kinds" } | { type: "graph-is-cyclic" } | { type: "too-many-inputs"; data: ParentType } | { type: "too-many-outputs"; data: ParentType } | { type: "invalid-node"; data: [FormatNodeId, InvalidNodeReason] } | { type: "too-many-closure-inputs" } | { type: "root-format-with-input-or-output" } | { type: "child-format-is-invalid"; data: FormatId } | { type: "root-format-referenced"; data: FormatId } | { type: "cyclic-parent-relation"; data: FormatNodeId[] } | { type: "illegal-child"; data: FormatNodeId } | { type: "parent-connected-to-child"; data: { parent: FormatNodeId; child: FormatNodeId } } | { type: "connection-escapes-scope"; data: { source: FormatNodeId; target: FormatNodeId; scope: FormatNodeId } } | { type: "input-or-output-node-with-parent" } | { type: "node-configuration-error"; data: NodeConfigurationError } | { type: "cyclic-format-dependency" } | { type: "type-validation-errors"; data: ValidationError<Type>[] } | { type: "static-input-received-non-static-connection" } | { type: "nodety-error"; data: NodetyError } | { type: "format-of-other-event-referenced"; data: FormatId } | { type: "invalid-signature" } | { type: "missing-output-node" };
+declare type FormatValidationError = { type: "uncaught-throw"; data: Record<DqKey, RowTypeHelper[]> } | { type: "unthrown-disqualification-kinds"; data: DqKey[] } | { type: "thrown-columns-not-as-declared"; data: { key: DqKey; thrown: RecordTypeHelper } } | { type: "root-format-with-disqualification-kinds" } | { type: "graph-is-cyclic" } | { type: "too-many-inputs"; data: ParentType } | { type: "too-many-outputs"; data: ParentType } | { type: "invalid-node"; data: [FormatNodeId, InvalidNodeReason] } | { type: "invalid-scoring-script"; data: [FormatNodeId, ScoringScriptError] } | { type: "scoring-definition-is-invalid"; data: [FormatNodeId, ScoringDefinitionId] } | { type: "scoring-direction-mismatch"; data: FormatNodeId } | { type: "too-many-closure-inputs" } | { type: "root-format-with-input-or-output" } | { type: "child-format-is-invalid"; data: FormatId } | { type: "root-format-referenced"; data: FormatId } | { type: "cyclic-parent-relation"; data: FormatNodeId[] } | { type: "illegal-child"; data: FormatNodeId } | { type: "parent-connected-to-child"; data: { parent: FormatNodeId; child: FormatNodeId } } | { type: "connection-escapes-scope"; data: { source: FormatNodeId; target: FormatNodeId; scope: FormatNodeId } } | { type: "input-or-output-node-with-parent" } | { type: "node-configuration-error"; data: NodeConfigurationError } | { type: "cyclic-format-dependency" } | { type: "type-validation-errors"; data: ValidationError<Type>[] } | { type: "static-input-received-non-static-connection" } | { type: "nodety-error"; data: NodetyError } | { type: "format-of-other-event-referenced"; data: FormatId } | { type: "invalid-signature" } | { type: "missing-output-node" } | { type: "effectful-node"; data: FormatNodeId };
 
 declare type FormatValidity = "invalid" | "valid";
 
@@ -5590,11 +6181,11 @@ export declare type FormFieldHookId = object;
 
 export declare interface FormFieldMeta {
     /**
-     * true if setValue has been called at least once since the last reset
+     * true if setValue has been called at least once since the last reset, so the field shows a value of its own
      */
     isTouched: boolean;
     /**
-     * true if the working value differs from the base value
+     * true if the working value differs from the base value and is not being saved
      */
     isChanged: boolean;
     /**
@@ -5635,7 +6226,7 @@ export declare interface FormFieldProps<I, O = I> {
 }
 
 export declare interface FormFieldRegistry {
-    registerFormField: (hookId: FormFieldHookId, formField: FormFieldMeta) => void;
+    registerFormField: (hookId: FormFieldHookId, formField: GroupedFormField) => void;
     unregisterFormField: (hookId: FormFieldHookId) => void;
     /**
      * `useFormField` bound to this registry. Follows the rules of hooks:
@@ -5662,13 +6253,21 @@ declare type GameDivision = {
     type: 'fixed';
     strategy: 'serpentine' | 'roundrobin';
     count: number;
-} | {
+}
+/** The min and max table size of the distribute table node: `maxSize - minSize` are its backfill rounds. */
+| {
     type: 'dynamic';
     strategy: 'serpentine' | 'roundrobin';
+    minSize: number;
     maxSize: number;
-    allowBackfill: boolean;
 };
 
+/**
+ * What a game node does with a disqualification kind of its game format: throw it on, or catch it with a
+ * [LadderDqStrategy]. The game format sets the default for its game nodes, each node can override it.
+ */
+declare type GameDqHandling = "throw" | "output-unplaced" | "append-placed" | "append-unplaced" | "append-ladder-placed" | "append-ladder-unplaced";
+
 export declare type GameDTO = components['schemas']['GameDTO'];
 
 export declare type GameFormatDTO = components['schemas']['GameFormatDTO'];
@@ -5692,34 +6291,56 @@ export declare type GameFormatPageProps = EventPath & {
  * result, after the result has been entered. They never change the stored result of the game, only
  * the result table the game node outputs.
  */
-declare type GameFormatPostProcessingStep = { type: "disqualify"; data: { key: DqKey; expression: string } } | { type: "set-output-column"; data: { column: string; columnType: TypeExpr<Type>; expression: string } };
+declare type GameFormatPostProcessingStep = { type: "disqualify"; data: { key: DqKey; expression: string } } | { type: "set-output-column"; data: { column: string; columnType: TypeExpr<Type>; expression: string } } | { type: "add-to-history"; data: { addToHistory: string } };
+
+/**
+ * One step of a game format's pre processing. Steps run in order on every row of a game's entry list, before the
+ * game.
+ */
+declare type GameFormatPreProcessingStep = { type: "sit-out"; data: { condition: string; thenAddToHistory: string; handling: SitOutHandling } } | { type: "drop"; data: { condition: string } };
+
+/**
+ * A pre or post processing step with a description for the people reading the game format.
+ */
+declare type GameFormatStep<T> = T & { description?: string };
 
 export declare type GameId = Brand<string, 'gameId'>;
 
-declare type GameKind = {
+declare type GameKind = 
+/** `catches` overrides what the game format does with its disqualification kinds, see `GameNodeDTO.catches`. */
+    {
     type: 'game-node';
     gameFormatId: GameFormatId;
-    variant: GameNodeVariant_2;
+    kind: GameNodeKind;
+    catches?: Record<DqKey_2, GameDqHandling>;
 } | {
     type: 'gamified-format';
     formatId: FormatId;
 };
 
+/**
+ * How many games a game node plays and how they depend on each other.
+ */
+declare type GameModeKind = "single" | "parallel" | "ladder";
+
 declare interface GameNodeDTO {
-    variant: GameNodeVariant;
     gameFormatId: GameFormatId;
+    kind: GameModeKind;
+    /**
+     * The finals of a ladder node, nothing for other kinds.
+     */
+    ladder?: LadderNode | null;
     /**
-     * Caught disqualifications are not thrown. [DqStrategy] decides how they are surfaced.
+     * What the node does with a disqualification kind of its game format, overriding the game format's default for
+     * it (its [DqSettings]). Only keys the game format raises, see [GameNodeKind::catch_dqs].
      */
-    catchDqs?: Record<DqKey, DqStrategy>;
+    catches?: Record<DqKey, GameDqHandling>;
 }
 
 /**
- * How many games a game node plays and how they depend on each other.
+ * What a game node plays: its kind with the node's settings for ladders.
  */
-declare type GameNodeVariant = { type: "single" } | { type: "parallel" } | { type: "sequential"; data: { gameCount: number } };
-
-declare type GameNodeVariant_2 = components['schemas']['GameNodeVariant'];
+declare type GameNodeKind = { type: "single" } | { type: "parallel" } | { type: "ladder"; data: LadderNode };
 
 export declare type GamePageContribution = FormContribution<GamePageProps & {
     game: WorkingGameDTO;
@@ -5729,7 +6350,7 @@ export declare type GamePageProps = EventPath & {
     gameId: GameId | null;
 };
 
-/** Where a game goes in the simplified view of the root format. */
+/** Where a game goes in the flow. */
 declare type GamePlace = Omit<AddGameEdit, 'type' | 'game' | 'division'>;
 
 export declare const gamesWithTablesMappedByEventQO: (workspaceId: CommonWorkspaceId, eventId: EventId) => EngineQueryOptions<Map<GameId, GameWithTables>>;
@@ -5763,6 +6384,28 @@ export declare const getTableByIdQueryOptions: (workspaceId: CommonWorkspaceId,
  */
 declare type GraphLocation = { type: "Edge"; data: number } | { type: "InputPort"; data: { nodeIdx: number; inputIdx: number } };
 
+/**
+ * How a group outputs the disqualifications of a key it catches.
+ */
+declare interface GroupCatch {
+    /**
+     * How multiple caught tables get merged.
+     */
+    merge: MultiplexingStrategy;
+    /**
+     * Whether the merged competitors keep their places. Disqualified competitors are usually unplaced.
+     */
+    placed: boolean;
+}
+
+/** A field as its group sees it, to take its value through a save. */
+export declare interface GroupedFormField extends FormFieldMeta {
+    /** Keeps showing the overwritten value, as saved and no longer persisted, until `settle`. */
+    commit: () => void;
+    /** Drops the committed value, once the base value holds what was saved. */
+    settle: () => void;
+}
+
 /**
  * Contains other nodes. It can add its name to the folder path of its descendants and catch the disqualifications
  * they throw.
@@ -5774,10 +6417,9 @@ declare interface GroupNode {
      */
     folder: boolean;
     /**
-     * The node has one output per catch key, in order. The strategy decides how multiple
-     * caught tables of the same key get merged.
+     * The node has one output per catch key, in order.
      */
-    catches: Record<DqKey, MultiplexingStrategy>;
+    catches: Record<DqKey, GroupCatch>;
 }
 
 /** The settings of a group node: BE-C's unified folder, group and catch-dq node. */
@@ -5794,22 +6436,32 @@ declare interface GroupSettings {
     catches: DqEntry[];
 }
 
-declare type GTFilterKind = { type: "class-filter" } | { type: "gender" } | { type: "comparison-filter"; data: ComparisonOp } | { type: "custom" };
-
 export declare const H1: FC<H1Props>;
 
-export declare interface H1Props {
-    children?: ReactNode;
+export declare type H1Props = {
     className?: string;
-}
+} & HeadingContent;
 
 export declare const H2: FC<H2Props>;
 
-export declare interface H2Props {
-    children?: ReactNode;
+export declare type H2Props = {
     className?: string;
     noMargin?: boolean;
-}
+} & HeadingContent;
+
+/** A tutorial is named by its heading, so a heading with one has plain text. */
+export declare type HeadingContent = {
+    children?: ReactNode;
+    tutorial?: undefined;
+} | {
+    children: string;
+    tutorial?: Tutorial;
+};
+
+/**
+ * A note, serialized as a plain string, or a disqualification.
+ */
+export declare type HistoryEntry = string | DqRecord;
 
 export declare function HR({ className }: HRProps): JSX.Element;
 
@@ -5817,6 +6469,16 @@ export declare type HRProps = {
     className?: string;
 };
 
+/**
+ * Node types that aren't deterministic: they read or write the workspace, play games or raise disqualifications.
+ */
+declare type ImpureNodeType = ({ type: "game" } & GameNodeDTO) | { type: "output-table"; columnTypes?: RecordTypeWithDefaults } | { type: "input-table"; link: InputTableLink } | { type: "class"; classId: ClassId } | ({ type: "disqualify" } & DisqualifyNode) | { type: "split-by-class"; classCount: number } | ({ type: "event-competitors" } & EventCompetitorsNode) | { type: "classes-competitors" };
+
+/**
+ * Node types as deterministic as what they stand for.
+ */
+declare type InheritedNodeType = { type: "format"; formatId: FormatId; catches?: Record<DqKey, FormatCatch> } | { type: "filter-table"; filter: TableFilter } | { type: "table-map"; closure: ClosureSource } | { type: "array-map"; closure: ClosureSource } | { type: "repeat"; closure: ClosureSource; over: RepeatOver };
+
 declare type InputIdx = number & { readonly __brand: 'inputIdx' };
 
 export declare enum InputLayout {
@@ -5826,10 +6488,17 @@ export declare enum InputLayout {
      */
     Compact = 1,
     /** Fills the parent (e.g. a table cell) without the browser's default ~20ch input min-width. */
-    Fill = 2
+    Fill = 2,
+    /** As wide as its text, at most as wide as the parent. */
+    Content = 3
 }
 
-declare type InvalidNodeReason = { type: "invalid-node" } | { type: "node-is-not-variadic-but-vargs-to-array-set" } | { type: "illegal-control-values" } | ({ type: "node-configuration-error" } & NodeConfigurationError) | { type: "catching-disqualifications-of-variadic-format" } | { type: "appending-disqualifications-to-incompatible-output" } | { type: "game-result-not-assignable-to-entry" };
+/**
+ * The table an InputTableNode outputs.
+ */
+declare type InputTableLink = { type: "table"; data: { tableId: TableId } } | { type: "output-table"; data: { nodeId: FormatNodeId } };
+
+declare type InvalidNodeReason = { type: "invalid-node" } | { type: "node-is-not-variadic-but-vargs-to-array-set" } | { type: "illegal-control-values" } | ({ type: "node-configuration-error" } & NodeConfigurationError) | { type: "catching-disqualifications-of-variadic-format" } | { type: "appending-disqualifications-to-incompatible-output" } | { type: "game-result-not-assignable-to-entry" } | { type: "game-mode-ladder-mismatch" } | { type: "stale-dq-override" } | { type: "invalid-script"; error: AutomationScriptError } | { type: "invalid-game-format" };
 
 /** Anything that can be selected and removed. A connection is identified by its target port: inputs take one connection. */
 declare type ItemRef = {
@@ -5846,6 +6515,20 @@ declare type ItemRef = {
     id: FormatNodeId;
 };
 
+/**
+ * How the finals of a ladder game node get their name or their attributes.
+ */
+declare type LadderInput = "per-game" | "shared";
+
+/**
+ * The finals of a ladder game node.
+ */
+declare interface LadderNode {
+    gameCount: number;
+    names: LadderInput;
+    attributes: LadderInput;
+}
+
 /** Loads graphite-script from the host's wasm on demand, a static import would make this entry an async module. */
 export declare const loadGraphiteScript: () => Promise<{
     primValueToTypeExpr: typeof primValueToTypeExpr;
@@ -5887,14 +6570,11 @@ export declare interface LogOperation {
  * connected to the first input of the new game or result table that its kind and type fit.
  */
 declare type LoweredFormatEdit = 
-/**
-* Into `section`, or into a new section of its own with null; connected into the input `connectTo` if given, replacing
-* its connection like `connect` does.
-*/
+/** Into `section`, connected into the input `connectTo` if given, replacing its connection like `connect` does. */
     {
     type: 'add-source';
     source: SourceKind;
-    section: SectionId | null;
+    section: SectionId;
     connectTo?: ElementPortRef;
 }
 /** A new game or result table goes where `at` points, e.g. first, or where a connection was dropped. */
@@ -5994,22 +6674,20 @@ declare type LoweredFormatEdit =
     }[];
     order?: SimplifiedGroupId[];
 }
-/** Copies the section with all its nodes into a new one right after it, linked among themselves only. */
+/** Refused with an empty name: a section is always named. */
 | {
-    type: 'copy-section';
-    section: SectionId;
-} | {
     type: 'rename-section';
     section: SectionId;
     name: string;
 }
 /**
-* A new, last section. An age group section starts with its groups, each with a class source of its class, and goes
-* among the others (see `withAgeGroupsInSync`).
+* A new, last section called `name`. An age group section starts with its groups, each with a class source of its
+* class, is named after its age group and goes among the others (see `withAgeGroupsInSync`).
 */
 | {
     type: 'add-section';
     section: SectionId;
+    name: string;
     kind: NewSectionKind;
 }
 /** Makes the class sources of the age group section's groups those of another age group. */
@@ -6026,20 +6704,6 @@ declare type LoweredFormatEdit =
     type: 'set-section-kind';
     section: SectionId;
     kind: SimplifiedSectionKind['type'];
-}
-/**
-* Moves the section one place up (-1) or down (1) in the order of sections, over all age group sections at once. Age
-* group sections go youngest first and aren't moved.
-*/
-| {
-    type: 'move-section';
-    section: SectionId;
-    step: -1 | 1;
-}
-/** Removes the section with all its nodes. */
-| {
-    type: 'delete-section';
-    section: SectionId;
 } | {
     type: 'rename-group';
     section: SectionId;
@@ -6145,13 +6809,6 @@ declare type LoweredFormatEdit =
     game: ElementId;
     to: GameKind;
 }
-/** For game nodes and gamified formats alike; appending on gamified formats adds or updates their `Concat`. */
-| {
-    type: 'set-game-dq';
-    game: ElementId;
-    key: DqKey_2;
-    choice: CatchDqChoice;
-}
 /**
 * The steps of a stage's pipeline are the nodes of its chain. A new step goes in before the node at `index`, or after
 * the last with the chain's length. Taking a step out connects what it got to what it fed, where the types fit.
@@ -6192,19 +6849,32 @@ export declare type MergePathParams<A, B> = {
 
 /**
  * What a continuation does with competitors of its parts that are missing from the previous result.
- * If the previous result is empty, nobody is missing: everyone's previous total is 0.
+ *
+ * A continuation of a scoring's result, straight or through nodes that keep the table's metadata, scores like one
+ * scoring node over all parts of the chain: the points of the earlier parts are carried, the discards and tie breaks of
+ * the last node apply to all parts, `part.index` counts through the chain, and the result has the columns of all
+ * parts. Each part's points come from the node that scores it. The direction must be the same along the chain. For
+ * competitors new in a later node, only [Self::ScoredAsAbsent] is exactly like one node. Continuing a table that
+ * doesn't come from a scoring only adds to its `total_points` and keeps its columns.
+ *
+ * If the previous result is empty, nobody is missing.
  */
-declare type MissingFromPrevious = "leave-out" | "worst-total-plus-one";
+declare type MissingFromPrevious = "leave-out" | "worst-total-plus-one" | "scored-as-absent";
 
 export declare function Modal({ children, isOpen, onClose, closable, height, width, verticalPosition, horizontalPosition, lightbox, blockBackground, }: ModalProps): null;
 
 /** Modal inner body: explicit width; shell uses `width: 'fit'` and shrink-wraps to this. */
-export declare const modalBodyNarrow = "p-6 w-[min(500px,calc(100vw - 2rem))] min-w-0 md:min-w-[320px]";
+export declare const modalBodyNarrow = "p-6 w-[min(500px,calc(100vw_-_2rem))] min-w-0 md:min-w-[320px]";
 
 export declare interface ModalConfig {
     id: string;
     content: ReactNode;
     closable?: boolean;
+    /**
+     * Default: 'shown'. Whether a closable modal has an X in its top right corner. Hide it for content that has its own
+     * button to close it, such as a dialog; ESC and a click outside still close it.
+     */
+    xButton?: 'shown' | 'hidden';
     height?: 'fit' | 'fill';
     width?: 'fit' | 'fill';
     verticalPosition?: 'center' | 'top' | 'bottom';
@@ -6212,13 +6882,13 @@ export declare interface ModalConfig {
     lightbox?: boolean;
     blockBackground?: boolean;
     /**
-     * Opens it as a window instead: one that the user drags around by this title, that leaves the page behind it usable
-     * and that only its X closes. It stays open across navigation, so it suits content with links, such as errors
-     * pointing at what caused them. Ignores the options about size, position and background.
+     * Opens it as a window instead: one that the user drags around by this title and resizes by its corner, that leaves
+     * the page behind it usable and that only its X closes. It stays open across navigation, so it suits content with
+     * links, such as errors pointing at what caused them, and pages (see `WindowRouter`), whose route guards then ask
+     * before the X closes it. Ignores the options about size, position and background. With `closable: false` it has no
+     * X.
      */
-    window?: {
-        title: ReactNode;
-    };
+    window?: WindowOptions;
     onClose?: () => void;
 }
 
@@ -6262,6 +6932,8 @@ declare type MultiplexingStrategy = "serpentine" | "round-robin";
 
 declare type MultiplexingStrategy_2 = components['schemas']['MultiplexingStrategy'];
 
+export declare type NamedTable = Pick<TableDAO, 'name' | 'tableKind' | 'variant'>;
+
 declare type NewSectionKind = {
     type: 'simple' | 'layered';
 } | {
@@ -6269,6 +6941,8 @@ declare type NewSectionKind = {
     classes: AgeGroupClasses;
 };
 
+declare type NodeCategory = "logic" | "game" | "tables" | "arrays" | "math" | "class" | "input-output" | "invalid" | "other" | "root";
+
 declare type NodeConfigurationError = { type: "extract-record-field-error"; data: ExtractRecordFieldError<Primitive> } | { type: "invalid-value"; data: { identifier: string; message: string; givenValue: Value<SerializableNonPrimitiveValue> } } | { type: "node-is-not-variadic-but-vargs-to-array-set" } | { type: "found-closure-input-node-in-non-closure" } | { type: "invalid-node" } | { type: "illegal-vargs-to-array" } | { type: "illegal-control-values" };
 
 declare type NodeInstanceHash = Brand<string, 'nodeInstanceHash'>;
@@ -6331,10 +7005,49 @@ export declare interface NodeSignature<T, R = ParamRef> {
 
 declare type NodetyError = { type: "NodeHasChildren" } | { type: "ParentNotFound" } | { type: "NodeNotFound" } | { type: "CycleDetected" } | { type: "TypeExprValidationError"; error: TypeExprValidationError };
 
-declare type NodeType = { type: "input" } | { type: "output" } | { type: "format"; data: { formatId: FormatId; catchDqs?: Record<DqKey, DqStrategy> } } | { type: "math"; data: { op: MathNodeOp } } | { type: "game"; data: GameNodeDTO } | { type: "output-table" } | { type: "input-table"; data: { tableId: TableId } } | { type: "portal"; data: { sourceNodeId: FormatNodeId; sourceOutput: OutputIdx } } | { type: "class"; data: { classId: ClassId } } | { type: "disqualify"; data: DisqualifyNode } | { type: "group"; data: GroupNode } | { type: "string-concat" } | { type: "string-format" } | { type: "sort-node" } | { type: "constant" } | { type: "merge-tables" } | { type: "divide-table" } | { type: "distribute-table" } | { type: "split-table"; data: SplitTableNode } | { type: "concat"; data: { sorted: boolean } } | { type: "remove-places" } | { type: "table-map" } | { type: "length" } | { type: "boolean-op"; data: { op: BooleanOp } } | { type: "record-field"; data: { op: RecordFieldOp } } | { type: "add-record-fields"; data: AddRecordFieldsNode } | { type: "fallback" } | { type: "gt-row"; data: { errorOnNotFound: boolean } } | { type: "filter-gt"; data: { filter: GTFilterKind } } | { type: "comparison"; data: { op: ComparisonOp } } | { type: "comment"; data: { comment: string; linkedNodeId?: FormatNodeId } } | { type: "ternary" } | { type: "separate-row" } | { type: "update-row" } | { type: "array-map" } | { type: "create-array" } | { type: "create-table" } | { type: "array-access"; data: { errorOnNotFound: boolean } } | { type: "unpack-array"; data: { errorOnNotFound: boolean } } | { type: "promotion-relegation"; data: { finalCount: number | null } } | { type: "age-at" } | { type: "split-by-class"; data: { classCount: number } } | { type: "invalid"; data: { nodeType: NodeType } } | { type: "empty-record" } | { type: "event-competitors"; data: EventCompetitorsNode } | { type: "add-columns"; data: AddColumnsNode } | { type: "matrix-transpose" } | { type: "simple-scoring"; data: SimpleScoringNode } | { type: "classes-competitors"; data: ClassesCompetitorsNode };
+/**
+ * What a node does. Its purity says whether its nodes are deterministic: what they output depends only on their inputs,
+ * their node type and the formats and scoring definitions they reference. Deterministic formats (see
+ * [FormatInterface::deterministic]) and pipelines contain only deterministic nodes.
+ *
+ * Top level purity distinction to have that be a type system invariant from the start. Reduces invariants.
+ */
+declare type NodeType = ({ purity: "pure" } & PureNodeType) | ({ purity: "impure" } & ImpureNodeType) | ({ purity: "inherited" } & InheritedNodeType);
 
-/** A change of a node's settings: its node type and its data, the values of its inputs or its number of variadic ports. */
-declare type NodeUpdate = Partial<Pick<FormatNodeDTO_2, 'nodeType' | 'controlValues' | 'addedInputVargs' | 'addedOutputVargs'>>;
+/**
+ * A change of a node's settings: its node type and its data, the values of its inputs or its variadic ports, which it
+ * can collect into lists, or one of them to remove.
+ */
+declare type NodeUpdate = Partial<Pick<FormatNodeDTO_2, 'nodeType' | 'controlValues' | 'addedInputVargs' | 'addedOutputVargs' | 'inputVargsToArray' | 'outputVargsToArray'> & {
+    removedInput: number;
+}>;
+
+declare interface NodeVariantDoc {
+    variantLabel: string;
+    inputs: PortsDoc;
+    outputs: PortsDoc;
+    description?: string | null;
+    /**
+     * The label for the new input when vargs_to_array is enabled.
+     */
+    outputVargsToArrayCountLabel: PortLabelPart[];
+    /**
+     * The label for the new output when vargs_to_array is enabled.
+     */
+    outputVargsToArrayArrayLabel: PortLabelPart[];
+    inputVargsToArrayArrayLabel: PortLabelPart[];
+    category: NodeCategory;
+    /**
+     * If the node has `children_spec` set to `Closure`, this documents that closure
+     */
+    closureDocs?: NodeVariantDoc | null;
+    /**
+     * The outputs the editor warns about while they aren't connected, with the reason: without them the node is
+     * useless, like a value of a `#[must_use]` function in Rust. Not serialized while empty, so that log entries of
+     * docs without must-use outputs keep their hashes.
+     */
+    mustUse?: Record<number, string>;
+}
 
 declare type NoMetadata = Record<never, never>;
 
@@ -6375,6 +7088,10 @@ export declare type OperatorOf<T> = Extract<TypeOperators[keyof TypeOperators],
 
 declare interface Option_2<TVal> {
     label: React_2.ReactNode;
+    /** Shown before the label, in the list and when selected; one rendering nothing takes no room. */
+    icon?: React_2.ReactNode;
+    /** Explains the option where a control has room for it, like `AppRadioGroup`. */
+    description?: React_2.ReactNode;
     value: TVal;
     disabled?: boolean;
 }
@@ -6440,6 +7157,30 @@ export declare type PersistedStateOptions = {
     version?: number;
 };
 
+declare interface PortDoc {
+    /**
+     * Each port label part gets turned into a string and then concatenated to retrieve the full label.
+     */
+    label: PortLabelPart[];
+    description?: string | null;
+    /**
+     * Finite value options representing the value will get labeled with the string
+     */
+    valueLabels: [Value, string][];
+    /**
+     * CustomControls only get used when enabled with this property.
+     */
+    enabledCustomControls: CustomControl[];
+    defaultValue?: Value | null;
+}
+
+declare type PortLabelPart = { type: "idx-decimal"; data: number } | { type: "idx-alphabetic"; data: number } | { type: "idx-ordinal"; data: number } | { type: "string"; data: string };
+
+declare interface PortsDoc {
+    ports: PortDoc[];
+    varg?: PortDoc | null;
+}
+
 /**
  * A list of port types, optionally with a variadic type (`...T`).
  */
@@ -6455,6 +7196,16 @@ export declare type Primitive = never;
 
 declare function primValueToTypeExpr(value: Value<Primitive>): TypeExpr<Type, ParamRef>;
 
+/**
+ * The pre or post processing steps of a game format.
+ */
+declare type ProcessingStage = "pre-processing" | "post-processing";
+
+/**
+ * Deterministic node types. Input, output, group, portal and comment nodes only route values.
+ */
+declare type PureNodeType = { type: "invalid"; nodeType: NodeType } | { type: "input" } | { type: "output" } | ({ type: "group" } & GroupNode) | { type: "portal"; sourceNodeId: FormatNodeId; sourceOutput: OutputIdx } | { type: "comment"; comment: string; linkedNodeId?: FormatNodeId } | { type: "math"; op: MathNodeOp } | { type: "string-concat" } | { type: "string-format" } | { type: "sort-table" } | { type: "constant" } | { type: "merge-tables" } | { type: "divide-table" } | { type: "distribute-table" } | { type: "split-table"; split: SplitTableNode } | { type: "concat-tables"; sorted: boolean } | { type: "remove-places" } | { type: "transfer-history" } | { type: "length" } | { type: "boolean-op"; op: BooleanOp } | { type: "record-field"; op: RecordFieldOp } | ({ type: "record" } & RecordNode) | ({ type: "record-access" } & RecordAccessNode) | { type: "fallback" } | { type: "comparison"; op: ComparisonOp } | { type: "ternary" } | { type: "separate-row" } | { type: "update-row" } | { type: "create-array" } | { type: "create-table" } | { type: "array-access"; errorOnNotFound: boolean } | { type: "unpack-array"; errorOnNotFound: boolean } | { type: "promotion-relegation"; finalCount: number | null } | { type: "age-at" } | ({ type: "add-columns" } & AddColumnsNode) | { type: "matrix-transpose" } | { type: "zip"; lengths: ZipLengths } | ({ type: "scoring" } & ScoringNode) | ({ type: "script-closure" } & ScriptClosureNode);
+
 /**
  * Replaces the rows a table holds on layer one.
  *
@@ -6493,6 +7244,9 @@ export declare function putTableRows(workspaceId: CommonWorkspaceId, eventId: Ev
     } | {
         type: "change-would-modify-rows";
         data: components["schemas"]["RecordModifications"];
+    } | {
+        type: "format-revalidation";
+        data: components["schemas"]["FormatRevalidationError"];
     };
 }>;
 
@@ -6526,6 +7280,18 @@ export declare interface QuerySchema<Fields extends QueryFields> {
     set<Key extends keyof Fields>(search: string, key: Key, value: QueryFieldValue<Fields[Key]>): string;
 }
 
+/**
+ * Reads `keys` of a record, see [record_access_node_sig].
+ */
+declare interface RecordAccessNode {
+    keys: string[];
+}
+
+/**
+ * What a record node adds its fields to.
+ */
+declare type RecordBase = "extend" | "new";
+
 declare type RecordFieldOp = "read-field" | "write-field";
 
 declare interface RecordMakeValidMutation {
@@ -6533,6 +7299,14 @@ declare interface RecordMakeValidMutation {
     newValue: Value;
 }
 
+/**
+ * The record node: a record with `fields`, see [record_node_sig].
+ */
+declare interface RecordNode {
+    fields: string[];
+    base: RecordBase;
+}
+
 /**
  * RecordTypes should **only** be manipulated though this helper to have a single source of truth for the structure.
  */
@@ -6553,6 +7327,11 @@ export declare interface RepeatedQueryField<T> {
     codec: QueryCodec<T>;
 }
 
+/**
+ * What a repeat node runs its closure for.
+ */
+declare type RepeatOver = "count" | "list";
+
 export declare function ResizablePanel({ value, onChange, edge, min, max, hideWhenBelowMin, onClose, children, className, contentClassName, }: ResizablePanelProps): JSX.Element;
 
 export declare interface ResizablePanelProps {
@@ -6604,6 +7383,8 @@ export declare interface RouterContextType {
     register: (route: string) => boolean;
     back: () => void;
     unregister: (route: string) => void;
+    /** What unloads the routes below, see `useGuardRoute`. */
+    scope: RouterScope;
 }
 
 export declare interface RouterLocation {
@@ -6612,6 +7393,14 @@ export declare interface RouterLocation {
     hash: string;
 }
 
+/** The app's routes are unloaded by navigating, a window's (see `WindowRouter`) by closing it. */
+export declare type RouterScope = {
+    type: 'app';
+} | {
+    type: 'window';
+    windowId: string;
+};
+
 /**
  * Rows can only be created and moved by this crate, so that their [Origin] stays truthful.
  */
@@ -6622,6 +7411,11 @@ export declare interface Row {
     competitorId: number;
     place: number | null;
     columns: RecordValue;
+    /**
+     * What happened to the competitor so far. Histories of the same competitor arriving on several paths are united
+     * in table order. Left out when empty.
+     */
+    history?: RowHistory;
 }
 
 export declare interface RowAction<T> {
@@ -6636,6 +7430,15 @@ export declare interface RowAction<T> {
     readOnlySafe?: boolean;
 }
 
+/**
+ * What happened to a competitor on the way to a row, oldest first: the notes game format automations added and the
+ * disqualifications the competitor collected.
+ *
+ * Holds every disqualification once (identity: key, source and kind), so uniting the histories of the same
+ * competitor from several paths doesn't count any twice. Notes are concatenated.
+ */
+export declare type RowHistory = HistoryEntry[];
+
 declare type RowMutationIdx = Brand<number, 'rowMutationIdx'>;
 
 declare type RowMutationKind = { type: "set-record-field"; field: string; value: Value } | { type: "push-unranked"; columns: RecordValue<Primitive> } | { type: "remove" } | { type: "set-place"; place: number } | { type: "set-unranked"; tiebraker: number } | { type: "set-place-and-tie-braker"; place: number; tiebraker: number };
@@ -6676,13 +7479,51 @@ declare interface RowTypeHelper<R = ParamRef> {
     columns: RecordTypeHelper<R>;
 }
 
-declare type RuntimeErrorKind = { type: "division-by-zero" } | { type: "variable-not-found"; data: { name: string } } | { type: "function-not-found"; data: { name: string } } | { type: "index-out-of-bounds" } | { type: "invalid-index" } | { type: "invalid-math-operands" } | { type: "non-boolean-condition" } | { type: "non-boolean-operand" } | { type: "invalid-comparison-operands" } | { type: "argument"; data: { expected: string; got: string } };
+declare type RuntimeErrorKind = { type: "division-by-zero" } | { type: "variable-not-found"; data: { name: string } } | { type: "function-not-found"; data: { name: string } } | { type: "index-out-of-bounds" } | { type: "invalid-index" } | { type: "invalid-math-operands" } | { type: "non-boolean-condition" } | { type: "non-boolean-operand" } | { type: "invalid-comparison-operands" } | { type: "argument"; data: { expected: string; got: string } } | { type: "function-failed"; data: { message: string } };
+
+/**
+ * A way to score a part, with parameters a node sets. An entity of an event, like a game format.
+ */
+declare interface ScoringDefinition {
+    name: string;
+    description: string;
+    /**
+     * The script sees their values as `params`. Every parameter has a default.
+     */
+    parameters: RecordTypeWithDefaults;
+    /**
+     * The documentation of each parameter, by name, like the ports of a node.
+     */
+    parameterDocs: Record<string, PortDoc>;
+    /**
+     * The columns the rows of every part must have, the script sees them in `row.attributes`.
+     */
+    requiredColumns: RecordTypeHelper;
+    direction: ScoringDirection;
+    /**
+     * A graphite script, typechecked like [ScoringPoints::Custom]'s with `params` in addition.
+     */
+    script: string;
+    /**
+     * Examples of what the definition scores, see [Self::run_test].
+     */
+    tests: ScoringTest[];
+}
+
+/**
+ * Identifies a scoring definition of an event. Random ([Self::new_random]) from the endpoint, derived for the
+ * fundamental scorings of a new event, or derived by `ImportArchiveMutation`. Deserializing one only yields a
+ * reference to an existing definition; it does not check that it exists.
+ */
+declare type ScoringDefinitionId = string & { readonly __brand: 'scoringDefinitionId' };
+
+declare type ScoringDirection = "lower-is-better" | "higher-is-better";
 
 /** A sequential scoring of fewer than two parts is a parallel one (see `ResultScoring`). */
 declare interface ScoringEdit {
     mode: ScoringMode;
     parts: {
-        part: SimpleScoringPart_2;
+        part: ScoringPart_2;
         from: number | null;
     }[];
 }
@@ -6694,6 +7535,105 @@ declare type ScoringMode = {
     missing: MissingFromPrevious;
 };
 
+/**
+ * Scores competitors over several parts, e.g. the races of a series.
+ *
+ * ```text
+ * <R0 extends {}, ...>(Table<R0, Sorted>, ...) -> (Table<{total_points: P, <part name>: P, ...}, Sorted>)
+ * ```
+ *
+ * One input per part and one output table. Competitors are the union of all parts. The script of `points` computes
+ * the points of every competitor in every part. `P` is `Integer` if the script returns integers whatever the
+ * columns of the parts, else `Integer | Float`. If the points are `null` for a part, the competitor is left out of
+ * the result. The total is the sum of the points, without the worst `discards`. The output is ranked by the total in
+ * the direction of `points`, ties are broken by the `tie_breaks` in order, and competitors still tied share the
+ * place.
+ *
+ * With `continues_previous`, the first input is the result of a previous scoring,
+ * `Table<{total_points: Integer | Float}, Sorted>`, and the totals add this node's parts to the previous
+ * `total_points`. The previous result's other columns are carried over, those named like a part are replaced. Ties
+ * keep the previous result's order. Discards and tie breaks only see this node's parts.
+ */
+declare interface ScoringNode {
+    parts: ScoringPart[];
+    continuesPrevious?: MissingFromPrevious;
+    points: ScoringPoints;
+    discards: Discards;
+    /**
+     * Decide between competitors with the same total, in order.
+     */
+    tieBreaks: TieBreak[];
+}
+
+/**
+ * One scored part, e.g. a single race of a series.
+ */
+declare interface ScoringPart {
+    /**
+     * Used as the name of the output column holding the points of this part.
+     */
+    name: string;
+    /**
+     * [TieBreak::PartPriority] compares higher priority parts first.
+     */
+    priority: number;
+}
+
+declare type ScoringPart_2 = components['schemas']['ScoringPart'];
+
+/**
+ * The points of a scoring node.
+ */
+declare type ScoringPoints = { type: "definition"; data: { definition: ScoringDefinitionId; params: RecordValue } } | { type: "custom"; data: { script: string; direction: ScoringDirection } };
+
+/**
+ * The script of a scoring node does not parse or typecheck.
+ */
+declare interface ScoringScriptError {
+    /**
+     * The part the script fails to typecheck for, none if it does not parse.
+     */
+    part: string | null;
+    message: string;
+}
+
+/**
+ * Parts scored with values of the parameters, and the result they are expected to score to.
+ */
+declare interface ScoringTest {
+    name: string;
+    description: string;
+    params: RecordValue;
+    parts: ScoringTestPart[];
+    /**
+     * The scored rows, best first: the places and the columns, the points of every part and the total. Their
+     * disqualifications and history are not compared.
+     */
+    expected: Rows<Sorted>;
+}
+
+declare interface ScoringTestPart {
+    /**
+     * The name of the column of its points.
+     */
+    name: string;
+    rows: Rows<Sorted>;
+}
+
+/**
+ * Outputs a deterministic closure (scripts are) with `signature`. Calling it runs `script` with each input bound to the
+ * variable of its name, and what the script evaluates to is the closure's output.
+ *
+ * ```text
+ * () -> (<signature>)
+ * ```
+ */
+declare interface ScriptClosureNode {
+    script: string;
+    signature: ClosureSignature;
+    docs: NodeVariantDoc;
+}
+
 export declare function SearchInput({ value, onChange, placeholder, className, autoFocus, ref, onKeyDown }: SearchInputProps): JSX.Element;
 
 export declare type SearchInputProps = {
@@ -6706,11 +7646,8 @@ export declare type SearchInputProps = {
     onKeyDown?: (event: KeyboardEvent_2<HTMLInputElement>) => void;
 };
 
-/**
- * A section of the simplified view (see `SimplifiedView`). Until it is stored, a section is identified by the lowest
- * node id of its island, which is a uuid like the ids of stored sections.
- */
-declare type SectionId = SimplifiedSectionId;
+/** A section of the flow (see `SimplifiedView`): the id of its root format. */
+declare type SectionId = FormatId;
 
 declare type SerializableNonPrimitiveValue = { type: "game-table"; data: Table<Unsorted, StateMetadata> } | { type: "game-table-sorted"; data: Table<Sorted, StateMetadata> } | { type: "row"; data: Row } | { type: "class"; data: string } | { type: "closure" };
 
@@ -6722,10 +7659,12 @@ declare type SerializableNonPrimitiveValue = { type: "game-table"; data: Table<U
 export declare type Shortcut = readonly string[];
 
 /**
- * Shows a dialog that can be dismissed (ESC, click outside, or X button; only X for a window)
- * Returns the selected value or null if dismissed
+ * Shows a dialog that can be dismissed (ESC, click outside; only the X of a window). The first primary button, or else
+ * the first button, has the focus. Without buttons, it has a close button.
+ *
+ * @returns the value of the chosen button or null if dismissed
  */
-export declare function showDialog<T>(modal: ModalControls, buttons: DialogButton<T>[], content: ReactNode, { window }?: DialogOptions): Promise<T | null>;
+export declare function showDialog<T>(modal: ModalControls, buttons: DialogButton<T>[], message: DialogMessage, { window }?: DialogOptions): Promise<T | null>;
 
 /**
  * A panel as a column of its own, next to the content. Keeping it out of the content gives toolbars the whole
@@ -6786,57 +7725,11 @@ export declare type SidePanelIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 export declare type SidePanelVariant = 'dock' | 'drawer';
 
-/**
- * Place 1 = 1 point, Place 2 = 2 points, etc.
- * On tie, whoever won the part with the highest priority wins.
- * If still tied, the next lower priority part is considered etc.
- *
- * ```text
- * (Table<{}, Sorted>, ...) -> (Table<{total_points: Integer, <part name>: Integer, ...}, Sorted>)
- * ```
- *
- * One input per part and one output table, sorted by ascending total points.
- * Competitors are the union of all parts: a competitor without a place in a part
- * (missing from the table of that part, or in it without a place) scores one point
- * more than that part has rows, so not finishing a part is always worse than
- * finishing it last. An empty part has not taken place yet and scores 0 for everyone.
- *
- * With `continues_previous`, the first input is the result of a previous scoring,
- * `Table<{total_points: Integer}, Sorted>`, and the totals add this node's parts to the previous `total_points`.
- * The previous result's other columns are carried over, those named like a part are replaced. Ties keep the
- * previous result's order.
- */
-declare interface SimpleScoringNode {
-    parts: SimpleScoringPart[];
-    /**
-     * Missing means a scoring that continues none, so that nodes written before keep their serialization.
-     */
-    continuesPrevious?: MissingFromPrevious;
-}
-
-/**
- * One scored part, e.g. a single race of a series.
- */
-declare interface SimpleScoringPart {
-    /**
-     * Used as the name of the output column holding the points of this part.
-     */
-    name: string;
-    /**
-     * Higher priority parts break ties first.
-     */
-    priority: number;
-}
-
-declare type SimpleScoringPart_2 = components['schemas']['SimpleScoringPart'];
-
 /**
  * Unique per format, not only per section.
  */
 declare type SimplifiedGroupId = string & { readonly __brand: 'simplifiedGroupId' };
 
-declare type SimplifiedSectionId = string & { readonly __brand: 'simplifiedSectionId' };
-
 /** A `simple` section has no groups. An age group's classes are the values of its two groups' class sources, see `ageGroupOf`. */
 declare type SimplifiedSectionKind = {
     type: 'layered';
@@ -6850,6 +7743,11 @@ declare type SimplifiedSectionKind = {
     };
 };
 
+/**
+ * Where the rows of the competitors sitting out go. They keep no columns.
+ */
+declare type SitOutHandling = { type: "append-placed" } | { type: "append-unplaced" } | { type: "append-ladder-placed" } | { type: "append-ladder-unplaced" } | { type: "output"; data: { name: string } } | { type: "throw"; data: { key: DqKey } };
+
 /**
  * Sorted game tables have the following guarantees:
  * - None places are last
@@ -6872,7 +7770,7 @@ declare type SourceKind = {
     type: 'classes-competitors';
 } | {
     type: 'input-table';
-    tableId: TableId;
+    link: InputTableLink;
 };
 
 /**
@@ -6888,11 +7786,12 @@ declare interface SourceLocation {
  *
  * for `Static { split_count }`:
  * ```text
- * <C extends {}>(Table<C, Sorted>, Integer * split_count) -> (Table<C, Sorted> * (split_count + 1))
+ * <C extends {}>(table: Table<C, Sorted>, cut_1: Integer, …, cut_<split_count>: Integer)
+ *     -> (part_1: Table<C, Sorted>, …, part_<split_count + 1>: Table<C, Sorted>)
  * ```
  * for `Dynamic`:
  * ```text
- * <C extends {}>(Table<C, Sorted>, Array<Integer>) -> (Array<Table<C, Sorted>>)
+ * <C extends {}>(table: Table<C, Sorted>, cuts: Array<Integer>) -> (parts: Array<Table<C, Sorted>>)
  * ```
  */
 declare type SplitTableNode = { type: "static"; data: { splitCount: number } } | { type: "dynamic" };
@@ -6947,6 +7846,8 @@ export declare type TableDropTarget = EventPath & {
     table: TableDAO;
 };
 
+declare type TableFilter = { type: "comparison-filter"; data: ComparisonOp } | { type: "class-filter" } | { type: "gender" } | { type: "custom"; data: ClosureSource };
+
 /**
  * Identifies a table, the primary key of `tables`. Comes from one of:
  * - [Self::new_random]: a table the user adds. The endpoint picks the id and the mutation carries it.
@@ -7010,6 +7911,24 @@ declare type TableState = number;
 
 export declare type TableWithType = components['schemas']['TableWithType'];
 
+/**
+ * The names of the concepts that sports name differently, in one locale. Plain data, so it can come from anywhere.
+ *
+ * A translation takes a term as an argument that its formatter fills in, `{game?|game}`, or capitalized
+ * `{Game?|Game}`; callers pass nothing. German translations use singular terms without articles or adjectives (the
+ * gender differs between terms) and never in compounds.
+ */
+export declare type Terminology = Record<TermKey, string>;
+
+export declare type TermKey = (typeof termKeys)[number];
+
+declare const termKeys: readonly ["game", "games", "gameFormat", "gameFormats", "entryTable", "entryTables", "resultTable", "resultTables", "ladder", "ladders", "parallelGames", "bib", "bibs", "gameFlow", "competitors"];
+
+/**
+ * A rule deciding between competitors with the same total.
+ */
+declare type TieBreak = "part-priority" | "countback" | "last-part";
+
 export declare type TimeDelta = components['schemas']['TimeDeltaSchema'];
 
 export declare const TimeDeltaInput: FC<TimeDeltaInputProps>;
@@ -7039,6 +7958,17 @@ declare interface Trail {
     steps: Step[];
 }
 
+/** Help on the section of the heading it belongs to. */
+export declare type Tutorial = {
+    content: ReactNode;
+} & (BuiltInTutorial | ExtensionTutorial);
+
+/**
+ * Every place of the engine showing a tutorial has its own id, its state is stored per user as preference
+ * `tutorial:<id>`. None starts with `ext:`, which is the namespace of the extensions' tutorials.
+ */
+export declare type TutorialId = 'game-format/tables' | 'game-format/variants' | 'game-format/pre-processing' | 'game-format/post-processing' | 'game-format/disqualifications' | 'scoring-definition/parameters' | 'scoring-definition/required-columns' | 'scoring-definition/script' | 'scoring-definition/tests' | 'game/manually-created' | 'game/add-competitors' | 'class/add-competitors' | 'team/add-members' | 'competitor/add-to-class' | 'archives/export';
+
 export declare type Type = { type: "integer"; data: { min: number | null; max: number | null } } | { type: "float" } | { type: "string"; data: string | null } | { type: "boolean" } | { type: "iterable" } | { type: "countable" } | { type: "comparable" } | { type: "sortable" } | { type: "unit" } | { type: "time-delta" } | { type: "date-time" } | { type: "date" } | { type: "primitive" } | { type: "competitor-id" } | { type: "array" } | { type: "record" } | { type: "table" } | { type: "row" } | { type: "table-sorting"; data: TableSorting } | { type: "class" };
 
 /**
@@ -7060,7 +7990,7 @@ declare interface TypeError_2 {
     location: SourceLocation;
 }
 
-declare type TypeErrorKind = { type: "unknown-variable"; data: { name: string } } | { type: "unknown-function"; data: { name: string } } | { type: "wrong-arity"; data: { name: string; expected: number; got: number } } | { type: "type-mismatch"; data: { expected: string; got: string } } | { type: "non-integer-index" } | { type: "non-record-property-access" } | { type: "nodety"; data: { message: string } };
+declare type TypeErrorKind = { type: "unknown-variable"; data: { name: string } } | { type: "unknown-function"; data: { name: string } } | { type: "wrong-arity"; data: { name: string; expected: number; got: number } } | { type: "type-mismatch"; data: { expected: string; got: string } } | { type: "non-integer-index" } | { type: "non-record-property-access" } | { type: "unknown-method"; data: { name: string; receiver: string } } | { type: "misplaced-lambda" } | { type: "nodety"; data: { message: string } };
 
 declare type TypeErrors = TypeError_2[];
 
@@ -7116,6 +8046,9 @@ declare type Unsorted = null;
 /** The engine's active locale. Extensions ship their own dictionaries and select them by it. */
 export declare function useEngineLocale(): Locales;
 
+/** The terms in the locale of the engine, or in `locale`. Extensions can name the concepts with them. */
+export declare function useEngineTerminology(locale?: Locales): Terminology;
+
 /** Returns a `fetch` for `path` (relative, e.g. `"items"`) on the calling extension's own backend in the current event. */
 export declare function useExtensionBackend(): ExtensionHost['backend'];
 
@@ -7155,6 +8088,9 @@ export declare function useRouter(): RouterContextType;
  */
 export declare function useRunLogBatch(): (workspaceId: CommonWorkspaceId, operations: LogOperation[], label: ReactNode) => Promise<boolean | null>;
 
+/** The names of tables as the engine shows them (see `tableName`), e.g. for extensions. */
+export declare function useTableName(): (table: NamedTable) => string;
+
 /** The `:` params that are uuids, by name. All other `:` params are numbers. Workspace ids are uuids on root only. */
 declare type UuidPathParams = {
     workspaceId: CommonWorkspaceId;
@@ -7164,6 +8100,7 @@ declare type UuidPathParams = {
     formatTestId: FormatTestId;
     gameFormatId: GameFormatId;
     gameId: GameId;
+    scoringDefinitionId: ScoringDefinitionId;
     tableId: TableId;
 };
 
@@ -7194,6 +8131,11 @@ export declare type Value<T = Primitive> = { type: "unit" } | { type: "float"; d
  */
 export declare function valueIntoExportable(value: Value): ExportableValue;
 
+/**
+ * A name a script can refer to as a variable: an identifier that isn't a keyword.
+ */
+declare type VariableName = string;
+
 export declare function Warning({ children, className }: WarningProps): JSX.Element;
 
 export declare interface WarningProps {
@@ -7201,6 +8143,33 @@ export declare interface WarningProps {
     className?: string;
 }
 
+/** See `ModalConfig.window`. The user resizes a window by its bottom right corner, its content scrolls inside. */
+export declare interface WindowOptions {
+    title: ReactNode;
+    /** Its size until the user resizes it. Default: fit content. */
+    size?: WindowStartSize;
+    /**
+     * Default: 'never'. With a bar, a button in its title bar hides it and `MinimizedWindowsBar` shows the bar next to a
+     * button that restores it.
+     */
+    minimize?: 'never' | {
+        bar: ReactNode;
+    };
+}
+
+export declare interface WindowSize {
+    width: number;
+    height: number;
+}
+
+/** The size a window opens with, until the user resizes it. */
+export declare type WindowStartSize = {
+    type: 'fit-content';
+} | {
+    type: 'initial';
+    size: WindowSize;
+};
+
 /**
  * Same as GameDTO but with gameFormatId optional
  */
@@ -7212,4 +8181,9 @@ export declare type WorkspaceRootId = Brand<string, 'workspaceRootId'>;
 
 export declare type WorkspaceSelfHostedId = Brand<number, 'workspaceSelfHostedId'>;
 
+/**
+ * What a zip node does with lists of different lengths.
+ */
+declare type ZipLengths = "longest" | "shortest" | "a";
+
 export { }