@graphite-sports/sdk 0.2.0 → 0.3.0

package/index.d.ts

@@ -1,6 +1,7 @@
 import { ChangeEventHandler } from 'react';
 import { ColumnDef } from '@tanstack/react-table';
 import { ColumnHelper } from '@tanstack/table-core';
+import { ColumnVisibilityState } from '@tanstack/react-table';
 import { ComponentProps } from 'react';
 import { CSSProperties } from 'react';
 import type { DataTag } from '@tanstack/react-query';
@@ -9,6 +10,7 @@ import { FocusEventHandler } from 'react';
 import { HTMLInputTypeAttribute } from 'react';
 import { JSX } from 'react/jsx-runtime';
 import { KeyboardEventHandler } from 'react';
+import { OnChangeFn } from '@tanstack/react-table';
 import { default as React_2 } from 'react';
 import * as React_3 from 'react';
 import { ReactNode } from 'react';
@@ -29,7 +31,7 @@ import type { UnusedSkipTokenOptions } from '@tanstack/react-query';
 
 export declare type AnyQuerySchema = QuerySchema<QueryFields>;
 
-export declare function AppButton({ type, onClick, disabled: disabledProp, mutates, children, submit, className, loading, value, ref, href, }: AppButtonProps): JSX.Element;
+export declare function AppButton({ type, onClick, disabled: disabledProp, mutates, children, submit, className, loading, value, ref, href, autoFocus, }: AppButtonProps): JSX.Element;
 
 export declare type AppButtonProps = {
     type?: AppButtonType;
@@ -43,6 +45,8 @@ export declare type AppButtonProps = {
     loading?: boolean;
     value?: string;
     ref?: RefObject<HTMLButtonElement | null>;
+    /** Focuses the button on mount, and with `href` also when this turns true later. */
+    autoFocus?: boolean;
     /** Makes the button a link to this route, so it can also be opened in a new tab. `onClick` runs before routing. */
     href?: string;
 };
@@ -162,7 +166,7 @@ export declare function AppTab({ className, ...props }: ComponentProps<typeof Ta
 
 export declare function AppTabGroup(props: ComponentProps<typeof TabGroup>): JSX.Element;
 
-export declare function AppTable<TData extends RowData>({ data, columns, actions, allowSelect, getRowId, getRowState, rowClicked, rowHref, initialPageSize, initialSorting, pageSizes, enableSorting, autoResetPageIndex, emptyTableText, columnVisibilityStorageKey, }: TableProps<TData>): JSX.Element;
+export declare function AppTable<TData extends RowData>({ data, columns, actions, allowSelect, getRowId, getRowState, rowClicked, rowHref, initialPageSize, initialSorting, pageSizes, enableSorting, autoResetPageIndex, emptyTableText, columnVisibility: columnVisibilityState, }: TableProps<TData>): JSX.Element;
 
 export declare type AppTableFeatures = typeof appTableFeatures;
 
@@ -233,7 +237,9 @@ export declare function buildCompetitorsMapped(competitors: CompetitorDAO[]): Co
 export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspaceId" | "/workspace/:workspaceId/event/:eventId" | "/download" | "/login" | "/register" | "/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/lineage" | "/workspace/:workspaceId/event/:eventId/create-game" | "/workspace/:workspaceId/event/:eventId/game/:gameId" | "/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: {
     '/': undefined;
     '/download': undefined;
-    '/login': undefined;
+    '/login': QuerySchema<    {
+    readonly returnTo: OptionalQueryField<ReturnPath>;
+    }>;
     '/register': undefined;
     '/preferences': undefined;
     '/crate-workspace': undefined;
@@ -248,11 +254,11 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/workspace/:workspaceId/event/:eventId/competitor/:competitorId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-format': QuerySchema<    {
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
-    readonly formatInstance: OptionalQueryField<FormatInstanceId>;
+    readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
     '/workspace/:workspaceId/event/:eventId/format/:formatId': QuerySchema<    {
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
-    readonly formatInstance: OptionalQueryField<FormatInstanceId>;
+    readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
     '/workspace/:workspaceId/event/:eventId/format/:formatId/tests': undefined;
     '/workspace/:workspaceId/event/:eventId/format/:formatId/tests/:formatTestId': undefined;
@@ -267,7 +273,7 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     /** Picks what these nodes own, or the steps they did. */
     readonly node: RepeatedQueryField<FormatNodeId>;
     /** Narrows `node` down to its instances in these format instances. */
-    readonly formatInstance: RepeatedQueryField<FormatInstanceId>;
+    readonly formatInstance: RepeatedQueryField<FormatInstanceHash>;
     }>;
     '/workspace/:workspaceId/event/:eventId/create-game': undefined;
     '/workspace/:workspaceId/event/:eventId/game/:gameId': undefined;
@@ -281,7 +287,9 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
 }[Path] extends infer T ? T extends {
     '/': undefined;
     '/download': undefined;
-    '/login': undefined;
+    '/login': QuerySchema<    {
+    readonly returnTo: OptionalQueryField<ReturnPath>;
+    }>;
     '/register': undefined;
     '/preferences': undefined;
     '/crate-workspace': undefined;
@@ -296,11 +304,11 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     '/workspace/:workspaceId/event/:eventId/competitor/:competitorId': undefined;
     '/workspace/:workspaceId/event/:eventId/create-format': QuerySchema<    {
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
-    readonly formatInstance: OptionalQueryField<FormatInstanceId>;
+    readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
     '/workspace/:workspaceId/event/:eventId/format/:formatId': QuerySchema<    {
     readonly focusNode: RepeatedQueryField<FormatNodeId>;
-    readonly formatInstance: OptionalQueryField<FormatInstanceId>;
+    readonly formatInstance: OptionalQueryField<FormatInstanceHash>;
     }>;
     '/workspace/:workspaceId/event/:eventId/format/:formatId/tests': undefined;
     '/workspace/:workspaceId/event/:eventId/format/:formatId/tests/:formatTestId': undefined;
@@ -315,7 +323,7 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
     /** Picks what these nodes own, or the steps they did. */
     readonly node: RepeatedQueryField<FormatNodeId>;
     /** Narrows `node` down to its instances in these format instances. */
-    readonly formatInstance: RepeatedQueryField<FormatInstanceId>;
+    readonly formatInstance: RepeatedQueryField<FormatInstanceHash>;
     }>;
     '/workspace/:workspaceId/event/:eventId/create-game': undefined;
     '/workspace/:workspaceId/event/:eventId/game/:gameId': undefined;
@@ -330,7 +338,7 @@ export declare const buildRoute: <Path extends "*" | "/" | "/workspace/:workspac
 
 export declare type ClassDAO = components['schemas']['ClassDAO'];
 
-export declare type ClassId = Brand<number, 'classId'>;
+export declare type ClassId = Brand<string, 'classId'>;
 
 export declare type ClassResponse = components['schemas']['ClassResponse'];
 
@@ -396,15 +404,24 @@ declare interface components {
         APIVersion: {
             /** Format: uint32 */
             engineVersion: number;
+            /** @description Base URL of the web app that uses this server, configured with `GRAPHITE_UI_URL`. */
+            uiUrl: string;
             version: components["schemas"]["SemVer"];
         };
         AddClassMutation: {
             classDto: components["schemas"]["ClassDTO"];
+            /** @description The id of the new class, see [ClassId::new_random]. It must not exist yet. */
+            classId: components["schemas"]["ClassId"];
             eventId: components["schemas"]["EventId"];
         };
         AddClassesMutation: {
             classDtos: components["schemas"]["ClassDTO"][];
             eventId: components["schemas"]["EventId"];
+            /**
+             * @description The classes get ids derived from it, see [ClassId::nth_of_seed]. Random, picked by the endpoint; reusing a seed
+             *      reproduces the same ids.
+             */
+            idSeed: components["schemas"]["Seed"];
         };
         /** @description <C extends {}, P extends Primitive, S extends Sorted|Unsorted>(Table<C, S>, P) -> (Table<C & {<self.key>: P}, S>) */
         AddColumnsNode: {
@@ -414,37 +431,53 @@ declare interface components {
             competitorDtos: components["schemas"]["CompetitorDTO"][];
             competitorType: components["schemas"]["CompetitorType"];
             eventId: components["schemas"]["EventId"];
+            /** @description The competitors get consecutive ids starting here. The endpoint picks [CompetitorDAO::next_id] inside [GraphiteEngine::mutate_with](crate::graphite_engine::GraphiteEngine::mutate_with). */
+            firstCompetitorId: components["schemas"]["CompetitorId"];
         };
         AddEventMutation: {
             eventDto: components["schemas"]["EventDTO"];
+            /** @description The id of the new event, see [EventId::new_random]. It must not exist yet. */
+            eventId: components["schemas"]["EventId"];
         };
         AddFormatGroupMutation: {
             eventId: components["schemas"]["EventId"];
             formatGroup: components["schemas"]["FormatGroupDTO"];
+            /** @description The id of the new format group, see [FormatGroupId::new_random]. It must not exist yet. */
+            formatGroupId: components["schemas"]["FormatGroupId"];
         };
         AddFormatMutation: {
             format: components["schemas"]["FormatDTO"];
             eventId: components["schemas"]["EventId"];
             force: boolean;
+            /** @description The id of the new format, see [FormatId::new_random]. It must not exist yet. */
+            formatId: components["schemas"]["FormatId"];
         };
         AddFormatTestMutation: {
             /** @default  */
             description: string;
             formatId: components["schemas"]["FormatId"];
+            /** @description The id of the new format test, see [FormatTestId::new_random]. It must not exist yet. */
+            formatTestId: components["schemas"]["FormatTestId"];
             name: string;
             test: components["schemas"]["FormatTestDefinition"];
         };
         AddGameFormatMutation: {
             eventId: components["schemas"]["EventId"];
             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"];
         };
         AddGameMutation: {
             eventId: components["schemas"]["EventId"];
             game: components["schemas"]["GameDTO"];
+            /** @description The id of the new game, see [GameId::new_random]. It must not exist yet. */
+            gameId: components["schemas"]["GameId"];
         };
         AddGameTableMutation: {
             eventId: components["schemas"]["EventId"];
             gameTable: components["schemas"]["TableDTO"];
+            /** @description The id of the new table, see [TableId::new_random]. It must not exist yet. */
+            tableId: components["schemas"]["TableId"];
             variant: components["schemas"]["TableVariant"];
         };
         /** @description <#0 extends {}, #1>(#0, #1) -> (#0 & {<self.key>: #1}) */
@@ -473,6 +506,15 @@ declare interface components {
             type: "at-date";
             date: string;
         };
+        /** @description Query of every endpoint with write access to a workspace. */
+        AllowNewGraphErrorsQuery: {
+            /**
+             * @description Applies mutations even if they cause node errors that did not exist before.
+             *      Without it such mutations are rolled back with HTTP 409 and the new node errors.
+             * @default false
+             */
+            allowNewGraphErrors: boolean;
+        };
         AlterTeamCompetitorsMutation: {
             additions: components["schemas"]["CompetitorId"][];
             removals: components["schemas"]["CompetitorId"][];
@@ -667,7 +709,12 @@ declare interface components {
         };
         /** @enum {string} */
         ClassGender: "female-only" | "male-only" | "all-genders";
-        /** Format: int64 */
+        /**
+         * Format: uuid
+         * @description Identifies a class. Random ([Self::new_random]) from the endpoint, [Self::nth_of_seed] for `AddClassesMutation`,
+         *      or derived by `ImportArchiveMutation`.
+         *      Deserializing one only yields a reference to an existing class; it does not check that it exists.
+         */
         ClassId: ClassId;
         ClassPathVariables_for_CommonWorkspaceId: {
             classId: components["schemas"]["ClassId"];
@@ -722,7 +769,12 @@ declare interface components {
             lastName?: string | null;
             teamName?: string | null;
         };
-        /** Format: int64 */
+        /**
+         * Format: int64
+         * @description Identifies a competitor in the workspace, at least [Self::FIRST]. Not autoincrement: the endpoint picks
+         *      [CompetitorDAO::next_id] inside `GraphiteEngine::mutate_with` and `AddCompetitorsMutation` carries it. The ids of deleted competitors can come back,
+         *      so don't hold on to the id of a deleted competitor.
+         */
         CompetitorId: CompetitorId;
         CompetitorInClassDTO: {
             classId: components["schemas"]["ClassId"];
@@ -730,19 +782,14 @@ declare interface components {
             /** Format: int64 */
             place: number;
         };
-        /** Format: int64 */
-        CompetitorInClassId: number;
         CompetitorInTeamDAO: {
             competitorId: components["schemas"]["CompetitorId"];
             from: string;
-            id: components["schemas"]["CompetitorInTeamId"];
             /** @description Id of competitor */
             teamId: components["schemas"]["CompetitorId"];
             to?: string | null;
         };
         /** Format: int64 */
-        CompetitorInTeamId: number;
-        /** Format: int64 */
         CompetitorNotUniqueError: number;
         CompetitorPathVariables_for_CommonWorkspaceId: {
             competitorId: components["schemas"]["CompetitorId"];
@@ -886,12 +933,27 @@ declare interface components {
         ContentInEventFolderDTO: {
             classIds: components["schemas"]["ClassId"][];
             eventId: components["schemas"]["EventId"];
+            /** @description Exactly one of `game_id` and `game_table_id` is set (SQL CHECK). */
             gameId?: components["schemas"]["GameId"] | null;
+            /** @description Any table, not only tables of games. */
             gameTableId?: components["schemas"]["TableId"] | null;
-            /** Format: int64 */
-            id: number;
             path: components["schemas"]["FolderPath"];
         };
+        /** @description Who created a game or a table. Encodes the columns `format_instance_id`, `format_node_id` and `node_key`. */
+        ContentOwner: {
+            /** @constant */
+            type: "user";
+        } | {
+            /** @constant */
+            type: "node";
+            data: {
+                nodeInstance: components["schemas"]["FormatNodeInstanceId"];
+                /** Format: int64 */
+                nodeKey: number;
+            };
+        };
+        /** @description Whether the content a node owns is the output of its last execution. */
+        ContentState: "ok" | "stale" | "node-error";
         /** @enum {string} */
         CookieStyle: "form";
         CreateApiKeyBody: {
@@ -959,38 +1021,6 @@ declare interface components {
             /** @constant */
             type: "unknown";
         };
-        DefaultChangeEvent_for_CompetitorInClassId: {
-            /** @constant */
-            type: "created";
-            data: components["schemas"]["CompetitorInClassId"];
-        } | {
-            /** @constant */
-            type: "updated";
-            data: components["schemas"]["CompetitorInClassId"];
-        } | {
-            /** @constant */
-            type: "deleted";
-            data: components["schemas"]["CompetitorInClassId"];
-        } | {
-            /** @constant */
-            type: "unknown";
-        };
-        DefaultChangeEvent_for_CompetitorInTeamId: {
-            /** @constant */
-            type: "created";
-            data: components["schemas"]["CompetitorInTeamId"];
-        } | {
-            /** @constant */
-            type: "updated";
-            data: components["schemas"]["CompetitorInTeamId"];
-        } | {
-            /** @constant */
-            type: "deleted";
-            data: components["schemas"]["CompetitorInTeamId"];
-        } | {
-            /** @constant */
-            type: "unknown";
-        };
         DefaultChangeEvent_for_EventId: {
             /** @constant */
             type: "created";
@@ -1168,7 +1198,7 @@ declare interface components {
         DeleteGameMutation: {
             id: components["schemas"]["GameId"];
         };
-        /** @enum {string} */
+        /** @description What happens to the games and tables of node instances that get deleted. */
         DeleteInstanceSettings: "errorOnContent" | "keepContentAsCopy" | "deleteContent";
         DeleteTableMutation: {
             id: components["schemas"]["TableId"];
@@ -1205,12 +1235,14 @@ declare interface components {
         DuplicateFormatShallowMutation: {
             formatId: components["schemas"]["FormatId"];
             /**
-             * Format: uint64
-             * @description Seed for regenerating node ids
+             * @description Random, picked when the mutation is built. The node ids of the copy and its id ([FormatId::of_copy]) derive
+             *      from it, so reusing a seed reproduces the same ids.
              */
-            nodeUuidSeed: number;
+            nodeUuidSeed: components["schemas"]["Seed"];
         };
         DuplicateGameFormatMutation: {
+            /** @description The id of the new copy, see [GameFormatId::new_random]. It must not exist yet. */
+            copyId: components["schemas"]["GameFormatId"];
             gameFormatId: components["schemas"]["GameFormatId"];
         };
         /** @description A single encoding definition applied to a single schema property. */
@@ -1324,11 +1356,11 @@ declare interface components {
         } | {
             /** @constant */
             type: "competitor-in-team";
-            data: components["schemas"]["DefaultChangeEvent_for_CompetitorInTeamId"];
+            data: components["schemas"]["DefaultChangeEvent_for_CompetitorId"];
         } | {
             /** @constant */
             type: "competitor-in-class";
-            data: components["schemas"]["DefaultChangeEvent_for_CompetitorInClassId"];
+            data: components["schemas"]["DefaultChangeEvent_for_ClassId"];
         } | {
             /** @constant */
             type: "format-test";
@@ -1341,11 +1373,8 @@ declare interface components {
             /** @constant */
             type: "content-in-event-folder";
         };
-        /**
-         * @description Auto-generated discriminant enum variants
-         * @enum {string}
-         */
-        EntityChangeEventDiscriminants: "Event" | "Game" | "Table" | "GameFormat" | "FormatGroup" | "Row" | "RowMutation" | "FormatNode" | "Format" | "Class" | "Extension" | "Competitor" | "CompetitorInTeam" | "CompetitorInClass" | "FormatTest" | "Log" | "ContentInEventFolder";
+        /** @description Auto-generated discriminant enum variants */
+        EntityChangeEventDiscriminants: ("Event" | "Game" | "Table" | "GameFormat" | "FormatGroup" | "Row" | "RowMutation" | "FormatNode" | "Format" | "Class" | "Extension" | "Competitor" | "FormatTest" | "Log" | "ContentInEventFolder") | "CompetitorInTeam" | "CompetitorInClass";
         /** @description A scope portal that used to be there but got removed in order to be serializable */
         ErasedScopedTypeRef_for_Type: {
             /** @constant */
@@ -1411,7 +1440,11 @@ declare interface components {
              */
             testMode: boolean;
         };
-        /** Format: int64 */
+        /**
+         * Format: uuid
+         * @description Identifies an event. Random ([Self::new_random]): the endpoint picks it and `AddEventMutation` carries it.
+         *      Deserializing one only yields a reference to an existing event; it does not check that it exists.
+         */
         EventId: EventId;
         /**
          * @description Everything needed to draw how the tables of an event come from each other, without their rows (see
@@ -1428,7 +1461,7 @@ declare interface components {
             /** @description Without stale tables. */
             tables: components["schemas"]["EventLineageTable"][];
         };
-        /** @description A way from `parent_table_id` into `table_id`. */
+        /** @description A way from `parent_table_id` into `id.table_id`. */
         EventLineageEdge: {
             /** @description Referenced by [EventRowLineageEdge::id]. */
             id: components["schemas"]["TableLineageId"];
@@ -1444,22 +1477,22 @@ declare interface components {
              * @description How many rows took this way.
              */
             rowCount: number;
-            tableId: components["schemas"]["TableId"];
         };
         EventLineageGame: {
             entryTableId?: components["schemas"]["TableId"] | null;
             id: components["schemas"]["GameId"];
             name: string;
-            owningFormatNodeInstanceId?: components["schemas"]["FormatNodeInstanceId"] | null;
+            owningFormatNodeInstanceId?: components["schemas"]["NodeInstanceHash"] | null;
             resultTableId?: components["schemas"]["TableId"] | null;
         };
         EventLineageNode: {
             /** @description Set for class nodes, the rows they create are the competitors of the class. */
             classId?: components["schemas"]["ClassId"] | null;
             formatId: components["schemas"]["FormatId"];
-            formatInstanceId: components["schemas"]["FormatInstanceId"];
+            formatInstanceId: components["schemas"]["FormatInstanceHash"];
             formatNodeId: components["schemas"]["FormatNodeId"];
-            id: components["schemas"]["FormatNodeInstanceId"];
+            /** @description Referenced by [Step::node]. */
+            id: components["schemas"]["NodeInstanceHash"];
             nodeType: components["schemas"]["NodeTypeDiscriminants"];
         };
         EventLineageRow: {
@@ -1472,7 +1505,7 @@ declare interface components {
             gameId?: components["schemas"]["GameId"] | null;
             id: components["schemas"]["TableId"];
             name: string;
-            owningNodeInstanceId?: components["schemas"]["FormatNodeInstanceId"] | null;
+            owningNodeInstanceId?: components["schemas"]["NodeInstanceHash"] | null;
             /** Format: uint */
             rowCount: number;
             state: components["schemas"]["TableState"];
@@ -1723,14 +1756,27 @@ declare interface components {
             category: components["schemas"]["NodeCategory"];
             name: string;
         };
-        /** Format: int64 */
+        /**
+         * Format: uuid
+         * @description Identifies a format group. Random ([Self::new_random]) from the endpoint, or derived by `ImportArchiveMutation`.
+         *      Deserializing one only yields a reference to an existing format group; it does not check that it exists.
+         */
         FormatGroupId: FormatGroupId;
         FormatGroupPathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
             formatGroupId: components["schemas"]["FormatGroupId"];
             workspaceId: components["schemas"]["CommonWorkspaceId"];
         };
-        /** Format: int64 */
+        /**
+         * Format: uuid
+         * @description Identifies a format. Comes from one of:
+         *      - [Self::new_random]: the endpoint picks it and `AddFormatMutation` carries it.
+         *      - [Self::root_of]: the root format of an event.
+         *      - [Self::of_copy]: the copy a mutation makes with a seed.
+         *      - `ImportArchiveMutation`: derived from the seed, the event and the archive entry.
+         *
+         *      Deserializing one only yields a reference to an existing format; it does not check that it exists.
+         */
         FormatId: FormatId;
         FormatInstanceDAO: {
             /** @description Temporary solution. Needed to know the event of an invalidated node instance. */
@@ -1744,14 +1790,19 @@ declare interface components {
              *      additionally need some sort of closure key.
              */
             formatNodeId?: components["schemas"]["FormatNodeId"] | null;
-            id: components["schemas"]["FormatInstanceId"];
+            /**
+             * @description Always [Self::derived_id]. Private so that it can only come from [Self::root], [Self::new_child] or the DB, and
+             *      [Self::update_with_new_id] re-derives it when the parent changes.
+             */
+            id: components["schemas"]["FormatInstanceHash"];
             /**
              * Format: int64
              * @description Same concept as keys in react
              */
             key: number;
-            /** @description None if root format */
-            parentFormatNodeInstanceId?: components["schemas"]["FormatNodeInstanceId"] | null;
+            /** @description None if root format. See [Self::parent]. */
+            parentId?: components["schemas"]["FormatInstanceHash"] | null;
+            parentNodeId?: components["schemas"]["FormatNodeId"] | null;
             /**
              * @description True if this instance was not hit the last time it should
              *      have gotten executed. Example: Map node maps 10 times (creates
@@ -1763,12 +1814,23 @@ declare interface components {
              */
             stale: boolean;
         };
-        /** Format: int64 */
-        FormatInstanceId: FormatInstanceId;
+        /**
+         * Format: uuid
+         * @description Identifies a format instance, the primary key of `format_instances`.
+         *
+         *      Derived from where the instance sits in the tree of instances: the root instance of an event from its root format,
+         *      every other instance from the [NodeInstanceHash] of the node that instantiated it and the key the node gave it.
+         *      So executing a graph creates the same hashes every time.
+         *
+         *      New hashes only come from these derivations. Deserializing one (client requests, the DB) only yields a reference to
+         *      an existing instance; it does not check that it exists or how it was made. Changing a derivation changes what
+         *      replaying a log produces and needs an `ENGINE_VERSION` increment.
+         */
+        FormatInstanceHash: FormatInstanceHash;
         FormatInstancePathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
             formatId: components["schemas"]["FormatId"];
-            formatInstanceId: components["schemas"]["FormatInstanceId"];
+            formatInstanceId: components["schemas"]["FormatInstanceHash"];
             workspaceId: components["schemas"]["CommonWorkspaceId"];
         };
         FormatInstanceTestResult: {
@@ -1776,8 +1838,6 @@ declare interface components {
             nodeStates: components["schemas"]["NodeInstanceStateDTO"][];
         };
         FormatNodeConnectionDAO: {
-            /** Format: int64 */
-            id: number;
             pins: components["schemas"]["ConnectionPin"][];
             sourceFormatNodeId: components["schemas"]["FormatNodeId"];
             sourceOutput: components["schemas"]["OutputIdx"];
@@ -1842,8 +1902,11 @@ declare interface components {
             outputVargsToArray: boolean;
             parentNodeId?: components["schemas"]["FormatNodeId"] | null;
             settings: components["schemas"]["RecordValue_for_Primitive"];
-            /** @description Ignored for existing nodes, because a node's test id never changes. */
-            testId: components["schemas"]["FormatNodeTestId"];
+            /**
+             * @description Ignored for existing nodes, because a node's test id never changes. Defaults to the node id.
+             * @default null
+             */
+            testId: components["schemas"]["FormatNodeTestId"] | null;
             typeHints: components["schemas"]["TypeHints_for_Type_and_ParamRef"];
             /** Format: int64 */
             xPos: number;
@@ -1852,14 +1915,11 @@ declare interface components {
         };
         /** Format: uuid */
         FormatNodeId: FormatNodeId;
-        FormatNodeInstanceDAO: {
-            formatInstanceId: components["schemas"]["FormatInstanceId"];
-            /** @description Set if the node instance is a child of at least one NodeFolderNode */
+        /** @description The node `format_node_id` in the format instance `format_instance_id`. */
+        FormatNodeInstanceId: {
+            formatInstanceId: components["schemas"]["FormatInstanceHash"];
             formatNodeId: components["schemas"]["FormatNodeId"];
-            id: components["schemas"]["FormatNodeInstanceId"];
         };
-        /** Format: int64 */
-        FormatNodeInstanceId: FormatNodeInstanceId;
         /** Format: uuid */
         FormatNodeTestId: FormatNodeTestId;
         FormatPathVariables_for_CommonWorkspaceId: {
@@ -1878,6 +1938,14 @@ declare interface components {
             /** @constant */
             type: "non-unique-node-id";
             data: components["schemas"]["FormatNodeId"];
+        } | {
+            /** @constant */
+            type: "non-unique-test-id";
+            data: components["schemas"]["FormatNodeTestId"];
+        } | {
+            /** @constant */
+            type: "non-unique-connection";
+            data: components["schemas"]["FormatConnectionDTO"];
         } | {
             /** @constant */
             type: "parent-does-not-exist";
@@ -1923,10 +1991,6 @@ declare interface components {
         FormatRevalidationError: {
             invalidatedFormats: components["schemas"]["FormatId"][];
         };
-        FormatRuntimeError: {
-            location: components["schemas"]["FormatNodeInstanceDAO"];
-            nodeError: components["schemas"]["NodeRuntimeError"];
-        };
         FormatTest: {
             description: string;
             formatId: components["schemas"]["FormatId"];
@@ -2011,8 +2075,8 @@ declare interface components {
             data: components["schemas"]["ImportArchiveError"];
         } | {
             /** @constant */
-            type: "format-error";
-            data: components["schemas"]["FormatRuntimeError"];
+            type: "node-error";
+            data: components["schemas"]["LocatedNodeError"];
         } | {
             /** @constant */
             type: "outputs-do-not-match";
@@ -2090,7 +2154,12 @@ declare interface components {
                 name: string;
             };
         };
-        /** Format: int64 */
+        /**
+         * Format: uuid
+         * @description Identifies a format test. Random ([Self::new_random]) from the endpoint, or [Self::nth_imported] for the tests
+         *      of an imported format.
+         *      Deserializing one only yields a reference to an existing format test; it does not check that it exists.
+         */
         FormatTestId: FormatTestId;
         FormatTestPathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
@@ -2115,7 +2184,7 @@ declare interface components {
              * @description The id of the root format instance that for the tests.
              *      The results of this format instance are in [Self::format_instance_states]
              */
-            testFormatInstanceId: components["schemas"]["FormatInstanceId"];
+            testFormatInstanceId: components["schemas"]["FormatInstanceHash"];
         };
         /** @description Represents a state in which the format is not valid for execution but can be stored in the db. */
         FormatValidationError: {
@@ -2236,12 +2305,11 @@ declare interface components {
              */
             parentFormatNodeFolderPath: string[];
         };
+        /** @description The node `format_node_id` in the format instance `format_instance_id`. */
         FullNodeInstance: {
             formatId: components["schemas"]["FormatId"];
-            formatInstanceId: components["schemas"]["FormatInstanceId"];
-            /** @description Set if the node instance is a child of at least one NodeFolderNode */
+            formatInstanceId: components["schemas"]["FormatInstanceHash"];
             formatNodeId: components["schemas"]["FormatNodeId"];
-            id: components["schemas"]["FormatNodeInstanceId"];
         };
         GTFilterKind: {
             /** @constant */
@@ -2271,15 +2339,8 @@ declare interface components {
             gameFormatId: components["schemas"]["GameFormatId"];
             id: components["schemas"]["GameId"];
             name: string;
-            /** Format: int64 */
-            nodeKey?: number | null;
-            owningFormatNodeInstanceId?: components["schemas"]["FormatNodeInstanceId"] | null;
-            /**
-             * @description True if
-             *      - created by a node but the last execution of the node did not touch this game.
-             *      - Or the owning node was deleted.
-             */
-            stale: boolean;
+            owner: components["schemas"]["ContentOwner"];
+            state: components["schemas"]["ContentState"];
         };
         GameDTO: {
             attributes: components["schemas"]["RecordValue_for_Primitive"];
@@ -2330,7 +2391,11 @@ declare interface components {
             postProcessingSteps: components["schemas"]["GameFormatPostProcessingStep"][];
             resultListColumns: components["schemas"]["RecordTypeWithDefaults"];
         };
-        /** Format: int64 */
+        /**
+         * Format: uuid
+         * @description Identifies a game format. Random ([Self::new_random]) from the endpoint, or derived by `ImportArchiveMutation`.
+         *      Deserializing one only yields a reference to an existing game format; it does not check that it exists.
+         */
         GameFormatId: GameFormatId;
         GameFormatPathVariables_for_CommonWorkspaceId: {
             eventId: components["schemas"]["EventId"];
@@ -2358,7 +2423,16 @@ declare interface components {
                 expression: string;
             };
         };
-        /** Format: int64 */
+        /**
+         * Format: uuid
+         * @description Identifies a game, the primary key of `games`. Comes from one of:
+         *      - [Self::new_random]: a game of the user. The endpoint picks the id and the mutation carries it.
+         *      - [Self::of_node]: a game of a node, see [GameDAO::derived_id]. Executing a graph creates the same ids every time.
+         *      - [GameDAO::keep_as_user_copy]: a game of a node that the user kept when the node instance got deleted.
+         *
+         *      Deserializing one only yields a reference to an existing game; it does not check that it exists or how it was made.
+         *      Changing a derivation changes what replaying a log produces and needs an `ENGINE_VERSION` increment.
+         */
         GameId: GameId;
         GameNodeDTO: {
             /**
@@ -2420,7 +2494,7 @@ declare interface components {
         /** @enum {string} */
         GenderGuess: "male" | "female" | "may-be-male" | "may-be-female" | "both-male-female" | "not-sure" | "not-found";
         GetFormatInstancesStateQuery: {
-            formatInstanceIds: components["schemas"]["FormatInstanceId"][];
+            formatInstanceIds: components["schemas"]["FormatInstanceHash"][];
         };
         GetIsBibUniqueQuery: {
             bib: components["schemas"]["BIB"];
@@ -2529,11 +2603,12 @@ declare interface components {
              */
             linkTemplate: boolean;
             /**
-             * Format: uint64
              * @description When `Some`, regenerates format node ids from this seed (deterministic log replay).
              *      When `None`, preserves archive node ids — for one-shot imports such as format tests.
+             *      Mixed with the event, the ids of the imported entities derive from it too. Random, picked when the mutation is
+             *      built; reusing a seed in the same event reproduces the same ids.
              */
-            nodeUuidSeed?: number | null;
+            nodeUuidSeed?: components["schemas"]["Seed"] | null;
             /** @default as-format */
             rootFormat: components["schemas"]["RootFormatImport"];
         };
@@ -2698,6 +2773,14 @@ declare interface components {
          *      Can be created from a single character (e.g. `'T'`) or a string (hashed for multi-char names).
          */
         LocalParamID: number;
+        /** @description An error that originated in a node, identified independently of the unstable `NodeIndex`. */
+        LocatedNodeError: {
+            error: components["schemas"]["NodeRuntimeError"];
+            eventId: components["schemas"]["EventId"];
+            formatId: components["schemas"]["FormatId"];
+            formatInstanceId: components["schemas"]["FormatInstanceHash"];
+            formatNodeId: components["schemas"]["FormatNodeId"];
+        };
         /** Format: uuid */
         LogBatchId: string;
         LogEntry: {
@@ -2852,6 +2935,10 @@ declare interface components {
             /** @constant */
             type: "update-full-resolved-game-table-layer-one";
             data: components["schemas"]["UpdateTableRowsLayerOneMutation"];
+        } | {
+            /** @constant */
+            type: "remove-hidden-row";
+            data: components["schemas"]["RemoveHiddenRowMutation"];
         } | {
             /** @constant */
             type: "add-extension";
@@ -2916,10 +3003,10 @@ declare interface components {
             name: string;
             nodeId: components["schemas"]["FormatNodeId"];
             /**
-             * Format: uint64
-             * @description Persist the seed so later log entries can refer to the same copied node IDs on replay.
+             * @description Persist the seed so later log entries can refer to the same copied node IDs on replay. Random, picked when the
+             *      mutation is built; the id of the copied format derives from it too ([FormatId::of_copy]).
              */
-            nodeUuidSeed: number;
+            nodeUuidSeed: components["schemas"]["Seed"];
         };
         MakeNodeSingleUserRequest: {
             /** @description The exact name to give the copied format. */
@@ -2992,7 +3079,40 @@ declare interface components {
             nodeType: components["schemas"]["NodeType"];
             test: components["schemas"]["FormatTestDefinition"];
         };
+        NodeErrorState_for_NodeRuntimeError: {
+            /** @constant */
+            type: "ok";
+        } | {
+            /** @constant */
+            type: "partial-errors";
+            data: {
+                errorPorts: {
+                    [key: string]: components["schemas"]["NodeRuntimeError"];
+                };
+            };
+        } | {
+            /** @constant */
+            type: "full-error";
+            data: components["schemas"]["NodeRuntimeError"];
+        } | {
+            /** @constant */
+            type: "skipped";
+            data: components["schemas"]["NodeRuntimeError"];
+        };
         NodeHasContentError: null;
+        /**
+         * Format: uuid
+         * @description Identifies a node instance: a node of a format within one [FormatInstanceHash].
+         *
+         *      Derived from the format instance and the node id, see [Self::of]. It is the parent of the format instances the node
+         *      creates ([FormatInstanceHash::new_child]) and the origin that table lineage attributes the steps of the node to. Like
+         *      [FormatInstanceHash], new hashes only come from the derivation, deserializing only yields a reference, and changing
+         *      the derivation needs an `ENGINE_VERSION` increment.
+         *
+         *      A node that gets a new id, like the nodes copied by `MakeNodeSingleUserMutation`, gets new node instance hashes.
+         *      Everything derived from them has to move along.
+         */
+        NodeInstanceHash: NodeInstanceHash;
         NodeInstanceStateDTO: {
             /** @description Effective execution folder of this node, used as the root of its owned-content tree. */
             folderPath: components["schemas"]["FolderPath"];
@@ -3032,6 +3152,10 @@ declare interface components {
                 name: string;
             };
         };
+        /**
+         * @description Error that happened while executing a node. Caused by invalid input to
+         *      the node or other factors caused by invalid use of the node.
+         */
         NodeRuntimeError: {
             /** @constant */
             type: "table-kind-mismatch";
@@ -3067,15 +3191,6 @@ declare interface components {
         } | {
             /** @constant */
             type: "integer-overflow";
-        } | {
-            /** @constant */
-            type: "mux-invalid-multiplexing-strategy";
-        } | {
-            /** @constant */
-            type: "mux-competitor-not-unique";
-            data: {
-                competitorId: components["schemas"]["CompetitorId"];
-            };
         } | {
             /** @constant */
             type: "record-field-does-not-exist";
@@ -3100,10 +3215,6 @@ declare interface components {
                 /** Format: uint */
                 rowIndex: number;
             };
-        } | {
-            /** @constant */
-            type: "closure-failed";
-            data: components["schemas"]["FormatRuntimeError"];
         } | {
             /** @constant */
             type: "invalid-row-types";
@@ -4175,12 +4286,7 @@ declare interface components {
         QueryStyle: "form" | "spaceDelimited" | "pipeDelimited" | "deepObject";
         RandomizeClassPlacesMutation: {
             classId: components["schemas"]["ClassId"];
-            /**
-             * Format: uint64
-             * @description Defaults so log entries written before the seed existed still deserialize.
-             * @default 0
-             */
-            seed: number;
+            seed: components["schemas"]["Seed"];
         };
         /** @enum {string} */
         RecordFieldOp: "read-field" | "write-field";
@@ -4416,6 +4522,11 @@ declare interface components {
             eventId: components["schemas"]["EventId"];
             identifier: string;
         };
+        /** @description Removes a row nodes don't see, see [ResolvedTable::hidden_rows]. */
+        RemoveHiddenRowMutation: {
+            competitorId: components["schemas"]["CompetitorId"];
+            tableId: components["schemas"]["TableId"];
+        };
         RemoveTargetQuery: {
             /**
              * @description Only forget the target, without pushing the remaining rows and resetting the remote.
@@ -4447,6 +4558,8 @@ declare interface components {
             id: components["schemas"]["LogId"];
             /** Format: date-time */
             timestamp: string;
+            /** Format: uint32 */
+            version: number;
         };
         ReplicationConflict: {
             /** @constant */
@@ -4456,6 +4569,12 @@ declare interface components {
             /** @constant */
             type: "hash-mismatch";
             head: components["schemas"]["LogHead"];
+        } | {
+            /** @constant */
+            type: "unsupported-version";
+            id: components["schemas"]["LogId"];
+            /** Format: uint32 */
+            version: number;
         };
         ReplicationHead: {
             /** Format: uuid */
@@ -4500,6 +4619,13 @@ declare interface components {
         Resolve: {
             keep: components["schemas"]["Side"];
         };
+        /** @description A table as nodes see it, without the results whose competitor is not in the entry of their game. */
+        ResolvedTable: {
+            /** @description The results whose competitor is not in the entry of their game. Nodes don't see them. */
+            hiddenRows: components["schemas"]["Row"][];
+            rows: components["schemas"]["Rows_for_Sorted"];
+            state: components["schemas"]["TableState"];
+        };
         Response: {
             /**
              * @description REQUIRED. A description of the response.
@@ -4551,7 +4677,7 @@ declare interface components {
         RootFormatResponse: {
             rootFormat: components["schemas"]["FullFormatDAO"];
             /** @description None if the format was never executed */
-            rootFormatInstanceId?: components["schemas"]["FormatInstanceId"] | null;
+            rootFormatInstanceId?: components["schemas"]["FormatInstanceHash"] | null;
         };
         /** @description Rows can only be created and moved by this crate, so that their [Origin] stays truthful. */
         Row: Row;
@@ -4573,10 +4699,6 @@ declare interface components {
             steps: components["schemas"]["Step"][];
             tableId: components["schemas"]["TableId"];
         };
-        RowLineageQuery: {
-            /** @description The competitor of the row */
-            competitorId: components["schemas"]["CompetitorId"];
-        };
         RowMutationChangeEvent: {
             gameTableId: components["schemas"]["TableId"];
         };
@@ -4589,11 +4711,12 @@ declare interface components {
             batch: number;
             competitorId: components["schemas"]["CompetitorId"];
             gameTableId: components["schemas"]["TableId"];
-            id: components["schemas"]["RowMutationId"];
+            /** @description Counts per table, so it is unique only together with `game_table_id`. */
+            idx: components["schemas"]["RowMutationIdx"];
             kind: components["schemas"]["RowMutationKind"];
         };
         /** Format: int64 */
-        RowMutationId: RowMutationId;
+        RowMutationIdx: RowMutationIdx;
         RowMutationKind: {
             /** @constant */
             type: "set-record-field";
@@ -4635,6 +4758,10 @@ declare interface components {
             competitorId: number;
             kind: components["schemas"]["RowMutationKind"];
         };
+        RowQuery: {
+            /** @description The competitor of the row */
+            competitorId: components["schemas"]["CompetitorId"];
+        };
         RowSummary: {
             description: string;
             hash: number[];
@@ -4758,8 +4885,18 @@ declare interface components {
         } & {
             [key: string]: unknown;
         });
+        /**
+         * Format: uuid
+         * @description The random seed a log entry stores so that replaying it derives the same ids, see [IdSeed].
+         *
+         *      A uuid instead of a `u64` (as it used to be): JSON clients like the frontend read numbers as JavaScript doubles,
+         *      which round integers above 2^53, so a seed that went through them derived different ids on replay. A uuid is
+         *      serialized as a string and survives that unchanged.
+         */
+        Seed: string;
         SemVer: string;
         SerializableNodeResult: {
+            errorState: components["schemas"]["NodeErrorState_for_NodeRuntimeError"];
             values: components["schemas"]["SerializablePortValues_for_OutputIdx"];
         };
         SerializableNonPrimitiveValue: {
@@ -4777,8 +4914,8 @@ declare interface components {
         } | {
             /** @constant */
             type: "class";
-            /** Format: int64 */
-            data: number;
+            /** Format: uuid */
+            data: string;
         } | {
             /** @constant */
             type: "closure";
@@ -4970,10 +5107,11 @@ declare interface components {
         };
         Step: {
             /**
-             * Format: int64
-             * @description Whoever ran the operation, see [Origin::attributed]. None until it is attributed.
+             * Format: uuid
+             * @description Whoever ran the operation, see [Origin::attributed]: the engine's `NodeInstanceHash`, a raw uuid because this
+             *      crate doesn't know engine types. None until it is attributed.
              */
-            node?: number | null;
+            node?: string | null;
             op: components["schemas"]["StepOp"];
         };
         /** @description An operation that moved rows between or within tables. */
@@ -5009,19 +5147,8 @@ declare interface components {
             /** @description The owner of the tables data (items, attributes and state) */
             layerOneOwner: components["schemas"]["TableOwner"];
             name: string;
-            /**
-             * Format: int64
-             * @description The key provided by the creating node. None if not created by a node.
-             */
-            nodeKey?: number | null;
-            /** @description Set only if the table is owned by a node and is not part of a game. */
-            owningNodeInstanceId?: components["schemas"]["FormatNodeInstanceId"] | null;
-            /**
-             * @description True if
-             *      - created by a node but the last execution of the node did not touch this table.
-             *      - Or the owning node was deleted.
-             */
-            stale: boolean;
+            owner: components["schemas"]["ContentOwner"];
+            state: components["schemas"]["ContentState"];
             /** @description Set by nodes. */
             stateLayerOne: components["schemas"]["TableState"];
             /** @description Overwrites layer one if Some */
@@ -5035,7 +5162,18 @@ declare interface components {
             state?: components["schemas"]["TableState"] | null;
             tableKind: components["schemas"]["TableKind"];
         };
-        /** Format: int64 */
+        /**
+         * Format: uuid
+         * @description 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.
+         *      - [Self::of_user_game]: the entry and result table of a game of the user.
+         *      - [Self::of_game] and [Self::of_node]: a table of a node, see [TableDAO::derived_id]. Executing a graph creates the
+         *        same ids every time.
+         *      - [TableDAO::keep_as_user_copy]: a table of a node that the user kept when the node instance got deleted.
+         *
+         *      Deserializing one only yields a reference to an existing table; it does not check that it exists or how it was
+         *      made. Changing a derivation changes what replaying a log produces and needs an `ENGINE_VERSION` increment.
+         */
         TableId: TableId;
         TableItemsMutationDTO: {
             challenge: components["schemas"]["TableMutationChallenge"];
@@ -5046,8 +5184,12 @@ declare interface components {
          * @enum {string}
          */
         TableKind: "entry-list" | "result-list" | "other";
-        /** Format: int64 */
-        TableLineageId: TableLineageId;
+        /** @description The way number `idx` into `table_id`. */
+        TableLineageId: {
+            /** Format: int64 */
+            idx: number;
+            tableId: components["schemas"]["TableId"];
+        };
         TableMutationChallenge: {
             /** @constant */
             type: "force-push";
@@ -5056,9 +5198,9 @@ declare interface components {
             type: "controlled-push";
             /**
              * @description If None, expect this mutation to be the first one.
-             *      Otherwise expect `head` to be the id of the currently most recent mutation.
+             *      Otherwise expect `head` to be the id of the currently most recent mutation of the table.
              */
-            head?: components["schemas"]["RowMutationId"] | null;
+            head?: components["schemas"]["RowMutationIdx"] | null;
         };
         /**
          * @description Overwrites a table. See [`TableOverwrite::for_game_result`]/[`TableOverwrite::for_game_entry`]
@@ -5152,17 +5294,20 @@ declare interface components {
             /** Format: uuid */
             id: string;
             remoteWorkspaceId: components["schemas"]["CommonWorkspaceId"];
-            /** Format: int64 */
-            rowsBehind: number;
-            status: components["schemas"]["TargetStatus"];
+            status: components["schemas"]["TargetStatusDTO"];
+            /** @description Base URL of the web app of the target server, as it last reported it. */
+            uiUrl?: string | null;
         };
         TargetPath: {
             /** Format: uuid */
             targetId: string;
         };
-        TargetStatus: {
+        /** @description The status of a target as clients see it, so up-to-date can not have rows behind. */
+        TargetStatusDTO: {
             /** @constant */
             type: "pushing";
+            /** Format: int64 */
+            rowsBehind?: number | null;
         } | {
             /** @constant */
             type: "up-to-date";
@@ -5170,6 +5315,8 @@ declare interface components {
             /** @constant */
             type: "retrying";
             lastError: components["schemas"]["SourceError"];
+            /** Format: int64 */
+            rowsBehind?: number | null;
         } | {
             /** @constant */
             type: "conflicted";
@@ -5622,8 +5769,20 @@ declare interface components {
         ValidationErrorKind_for_Type: ValidationErrorKind<Type>;
         /** @description A validation error with its location and kind. */
         ValidationError_for_Type: ValidationError<Type>;
+        /**
+         * Important
+         * @description Changes in here are breaking changes for logs
+         */
         Value_for_Primitive: Value<Primitive>;
+        /**
+         * Important
+         * @description Changes in here are breaking changes for logs
+         */
         Value_for_SerializableNonPrimitiveValue: Value<SerializableNonPrimitiveValue>;
+        /**
+         * @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.
+         */
         Wiring: {
             classes: {
                 [key: string]: string;
@@ -5655,6 +5814,16 @@ declare interface components {
         WorkspacePathVariables_for_CommonWorkspaceId: {
             workspaceId: components["schemas"]["CommonWorkspaceId"];
         };
+        /** @enum {string} */
+        WorkspaceState: "normal" | "checked-out" | "replication-target";
+        /** @description The state of a workspace that clients display live. More workspace state goes here. */
+        WorkspaceStateDTO: {
+            /** @description All errors that originated in a node, sorted by their location. */
+            nodeErrors: components["schemas"]["LocatedNodeError"][];
+            replicationTargets: components["schemas"]["TargetDTO"][];
+            /** @description Anything but normal makes the workspace read-only. */
+            state: components["schemas"]["WorkspaceState"];
+        };
     };
     responses: never;
     parameters: never;
@@ -5728,6 +5897,8 @@ export declare const DateTimeText: FC<DateTimeTextProps>;
 export declare interface DateTimeTextProps {
     value: Date | number | string;
     className?: string;
+    /** Shows the time passed since `value` ("5 minutes ago") instead of the timestamp. */
+    relative?: boolean;
 }
 
 declare interface DetailedSupertypeDiagnostics<T> {
@@ -5736,7 +5907,7 @@ declare interface DetailedSupertypeDiagnostics<T> {
 
 export declare interface DialogButton<T> {
     value: T;
-    label: string;
+    label: ReactNode;
     theme?: 'primary' | 'default' | 'danger';
 }
 
@@ -5750,7 +5921,7 @@ 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>> } };
 
-export declare type EventId = Brand<number, 'eventId'>;
+export declare type EventId = Brand<string, 'eventId'>;
 
 export declare interface EventPath {
     workspaceId: CommonWorkspaceId;
@@ -5852,19 +6023,17 @@ declare interface FieldTypeWithDefault {
  */
 export declare function formatCompetitorName(competitor: CompetitorDAO): string;
 
-declare type FormatGroupId = Brand<number, 'formatGroupId'>;
+declare type FormatGroupId = Brand<string, 'formatGroupId'>;
 
-declare type FormatId = Brand<number, 'formatId'>;
+declare type FormatId = Brand<string, 'formatId'>;
 
-export declare type FormatInstanceId = Brand<number, 'formatInstanceId'>;
+export declare type FormatInstanceHash = Brand<string, 'formatInstanceHash'>;
 
 export declare type FormatNodeId = Brand<string, 'formatNodeId'>;
 
-declare type FormatNodeInstanceId = Brand<number, 'formatNodeInstanceId'>;
-
 declare type FormatNodeTestId = Brand<string, 'formatNodeTestId'>;
 
-declare type FormatTestId = Brand<number, 'formatTestId'>;
+declare type FormatTestId = Brand<string, 'formatTestId'>;
 
 export declare type FormContribution<Props, DTO> = FC<Props & {
     formFieldRegistry: FormFieldRegistry;
@@ -5942,7 +6111,7 @@ export declare type GameDTO = components['schemas']['GameDTO'];
 
 export declare type GameFormatDTO = components['schemas']['GameFormatDTO'];
 
-export declare type GameFormatId = Brand<number, 'gameFormatId'>;
+export declare type GameFormatId = Brand<string, 'gameFormatId'>;
 
 export declare type GameFormatPageContribution = FormContribution<GameFormatPageProps & {
     gameFormat: GameFormatDTO;
@@ -5952,7 +6121,7 @@ export declare type GameFormatPageProps = EventPath & {
     gameFormatId: GameFormatId | null;
 };
 
-export declare type GameId = Brand<number, 'gameId'>;
+export declare type GameId = Brand<string, 'gameId'>;
 
 export declare type GamePageContribution = FormContribution<GamePageProps & {
     game: WorkingGameDTO;
@@ -5975,7 +6144,7 @@ export declare const getCompetitorInTeamMappingAtQueryOptions: (workspaceId: Com
  */
 export declare const getCompetitorsQO: (workspaceId: CommonWorkspaceId, eventId: EventId, competitorTypeFilter?: CompetitorType) => EngineQueryOptions<CompetitorDAO[]>;
 
-export declare const getGameTableResolvedByGameQO: (workspaceId: CommonWorkspaceId, eventId: EventId, gameID: GameId, tableKind: "EntryList" | "ResultList") => EngineQueryOptions<TableSortedDTO>;
+export declare const getGameTableResolvedByGameQO: (workspaceId: CommonWorkspaceId, eventId: EventId, gameID: GameId, tableKind: "EntryList" | "ResultList") => EngineQueryOptions<ResolvedTableDTO>;
 
 /**
  * Location of a validation error in the graph.
@@ -6015,6 +6184,12 @@ export declare enum InputLayout {
     Fill = 2
 }
 
+/** 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;
+    validateExpression: typeof validateExpression;
+}>;
+
 export declare const LoadingOverlay: FC<LoadingOverlayProps>;
 
 export declare type LoadingOverlayProps = {
@@ -6082,6 +6257,8 @@ export declare interface ModalProps {
     blockBackground?: boolean;
 }
 
+declare type NodeInstanceHash = Brand<string, 'nodeInstanceHash'>;
+
 /**
  * Function-like type for a node: generic parameters, inputs, outputs, and defaults.
  * Written in notation as `<T>(T) -> (T)` for the identity node.
@@ -6201,7 +6378,7 @@ export declare interface ParsedQuery<Values> {
 export declare type PathParams<Path extends string> = Path extends `${infer Base}/*` ? PathParams<Base> : Path extends `${infer _}/${infer Rest}` ? MergePathParams<PathSegmentParam<_>, PathParams<Rest>> : PathSegmentParam<Path>;
 
 export declare type PathSegmentParam<S extends string> = S extends `:${infer P}` ? {
-    [K in P]: number;
+    [K in P]: K extends keyof UuidPathParams ? UuidPathParams[K] : number;
 } : S extends `$${infer P}` ? {
     [K in P]: string;
 } : Record<never, never>;
@@ -6231,7 +6408,7 @@ export declare interface PortTypes<T, R = ParamRef> {
  */
 export declare type Primitive = never;
 
-export declare function primValueToTypeExpr(value: Value<Primitive>): TypeExpr<Type, ParamRef>;
+declare function primValueToTypeExpr(value: Value<Primitive>): TypeExpr<Type, ParamRef>;
 
 export declare interface QueryCodec<T> {
     parse(value: string): T | null;
@@ -6307,6 +6484,14 @@ export declare interface ResizablePanelProps {
 
 export declare type ResizeEdge = 'left' | 'right' | 'top' | 'bottom';
 
+export declare type ResolvedTableDTO = components['schemas']['ResolvedTable'];
+
+/** A path on this origin, so navigating to it can never leave the app. */
+export declare type ReturnPath = Brand<string, 'returnPath'>;
+
+/** The only way to get a {@link ReturnPath}. Rejects URLs leaving the origin like `//evil.com` or `/\evil.com`. */
+export declare const returnPath: QueryCodec<ReturnPath>;
+
 export declare interface RouterContextType {
     /** The pathname used for route matching and persistence keys. */
     path: string;
@@ -6355,7 +6540,7 @@ export declare interface RowAction<T> {
     readOnlySafe?: boolean;
 }
 
-declare type RowMutationId = Brand<number, 'rowMutationId'>;
+declare type RowMutationIdx = Brand<number, 'rowMutationIdx'>;
 
 declare interface Rows<SortingState> {
     /**
@@ -6385,7 +6570,7 @@ export declare type SearchInputProps = {
     className?: string;
 };
 
-declare type SerializableNonPrimitiveValue = { type: "game-table"; data: Table<Unsorted_2, StateMetadata> } | { type: "game-table-sorted"; data: Table<Sorted_2, StateMetadata> } | { type: "row"; data: Row } | { type: "class"; data: number } | { type: "closure" };
+declare type SerializableNonPrimitiveValue = { type: "game-table"; data: Table<Unsorted_2, StateMetadata> } | { type: "game-table-sorted"; data: Table<Sorted_2, StateMetadata> } | { type: "row"; data: Row } | { type: "class"; data: string } | { type: "closure" };
 
 /**
  * A keyboard shortcut as the keys to press together, e.g. `['Mod', 'Shift', 'Z']`. `Mod` is Ctrl, or
@@ -6428,9 +6613,7 @@ export declare enum StorageType {
  */
 declare type Table<SortingState, M = NoMetadata> = { rows: Rows<SortingState> } & M;
 
-export declare type TableId = Brand<number, 'tableId'>;
-
-declare type TableLineageId = Brand<number, 'tableLineageId'>;
+export declare type TableId = Brand<string, 'tableId'>;
 
 export declare interface TableProps<TData extends RowData> {
     data: TData[];
@@ -6462,10 +6645,10 @@ export declare interface TableProps<TData extends RowData> {
     /** Text to be displayed when there is no data */
     emptyTableText?: ReactNode;
     /**
-     * When provided, shows a "Columns" toggle button above the table and persists column
-     * visibility to localStorage under this key. Columns with `enableHiding: false` are excluded.
+     * When provided, shows a "Columns" toggle button above the table, e.g. with the state of `usePersistedState`.
+     * Columns with `enableHiding: false` are excluded.
      */
-    columnVisibilityStorageKey?: string;
+    columnVisibility?: [ColumnVisibilityState, OnChangeFn<ColumnVisibilityState>];
 }
 
 export declare type TableSortedDTO = components['schemas']['Table_for_Sorted_and_StateMetadata'];
@@ -6578,11 +6761,22 @@ export declare function usePersistedState<S>(storageKey: string, initialState: S
 /** Hook to use the router context. Must be called within a <Router> provider. */
 export declare function useRouter(): RouterContextType;
 
+/** The `:` params that are uuids, by name. All other `:` params are numbers. */
+declare type UuidPathParams = {
+    classId: ClassId;
+    eventId: EventId;
+    formatId: FormatId;
+    formatTestId: FormatTestId;
+    gameFormatId: GameFormatId;
+    gameId: GameId;
+    tableId: TableId;
+};
+
 /**
  * Validates the expression and returns a `ExpressionInContextWasm` if the expression is valid.
  * @throws {ValidateExpressionError} if the expression is not valid.
  */
-export declare function validateExpression(expression: string, context: TypeContext): ExpressionInContextWasm;
+declare function validateExpression(expression: string, context: TypeContext): ExpressionInContextWasm;
 
 /**
  * A validation error with its location and kind.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphite-sports/sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "MIT",
   "repository": "github:Graphite-sports/starter-extension",
   "homepage": "https://github.com/Graphite-sports/starter-extension",