tsondb 0.10.1 → 0.11.0

package/dist/src/node/index.js

@@ -34,7 +34,7 @@ const _validate = (dataRootPath, entities, instancesByEntityName, options = {})
     const errors = (checkOnlyEntities.length > 0
         ? entities.filter(entity => checkOnlyEntities.includes(entity.name))
         : entities)
-        .flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateEntityDecl(validationHelpers, entity, instance.content))) ?? []))
+        .flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateEntityDecl(validationHelpers, [], entity, instance.content))) ?? []))
         .toSorted((a, b) => a.message.localeCompare(b.message));
     if (errors.length === 0) {
         debug("All entities are valid");

package/dist/src/node/schema/Node.d.ts

@@ -64,8 +64,8 @@ export declare const createValidators: (instancesByEntityName: InstancesByEntity
 export type Predicate<T extends Node> = (node: Node) => node is T;
 export type GetNestedDeclarations<T extends Node = Node> = (addedDecls: NestedDecl[], node: T, parentDecl: Decl | undefined) => NestedDecl[];
 export declare const getNestedDeclarations: GetNestedDeclarations;
-export type Validator<T extends Node = Node> = (helpers: Validators, node: T, value: unknown) => Error[];
-export type ValidatorOfParamDecl<T extends Node = Node> = (helpers: Validators, node: T, typeArgs: Type[], value: unknown) => Error[];
+export type Validator<T extends Node = Node> = (helpers: Validators, inDecls: Decl[], node: T, value: unknown) => Error[];
+export type ValidatorOfParamDecl<T extends Node = Node> = (helpers: Validators, inDecls: Decl[], node: T, typeArgs: Type[], value: unknown) => Error[];
 export declare const validateDecl: ValidatorOfParamDecl<Decl>;
 export declare const validateType: Validator<Type>;
 export type NodeWithResolvedTypeArguments<T extends Node | null> = T extends BooleanType | DateType | FloatType | IntegerType | StringType | ReferenceIdentifierType ? T : T extends EntityDecl<infer N, infer P, infer FK> ? EntityDecl<N, {
@@ -80,8 +80,8 @@ export type NodeWithResolvedTypeArguments<T extends Node | null> = T extends Boo
 }> : T extends TypeArgumentType ? Type : T extends IncludeIdentifierType<[], IncludableDeclP<[]>> ? T : T extends IncludeIdentifierType ? Type : T extends NestedEntityMapType<infer N, infer P> ? NestedEntityMapType<N, {
     [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
 }> : T extends TypeParameter<infer N, infer C> ? TypeParameter<N, NodeWithResolvedTypeArguments<C>> : T extends ChildEntitiesType<infer E> ? ChildEntitiesType<E> : T extends null ? null : never;
-export type TypeArgumentsResolver<T extends Node = Node> = (args: Record<string, Type>, node: T) => NodeWithResolvedTypeArguments<T>;
-export declare const resolveTypeArguments: <T extends Node = Node>(args: Record<string, Type>, node: T) => NodeWithResolvedTypeArguments<T>;
+export type TypeArgumentsResolver<T extends Node = Node> = (args: Record<string, Type>, node: T, inDecl: Decl[]) => NodeWithResolvedTypeArguments<T>;
+export declare const resolveTypeArguments: <T extends Node = Node>(args: Record<string, Type>, node: T, inDecl: Decl[]) => NodeWithResolvedTypeArguments<T>;
 export type SerializedNodeMap = {
     [NodeKind.EntityDecl]: [EntityDecl, SerializedEntityDecl];
     [NodeKind.EnumDecl]: [EnumDecl, SerializedEnumDecl];
@@ -114,5 +114,5 @@ export type Serialized<T extends Node> = T extends EntityDecl<infer Name, infer
 export type SerializedOf<T extends Node> = SerializedNodeMap[T["kind"]][1];
 export type Serializer<T extends Node = Node> = (node: T) => Serialized<T>;
 export declare const serializeNode: <T extends Node>(node: T) => Serialized<T>;
-export type GetReferences<T extends Node = Node> = (node: T, value: unknown) => string[];
+export type GetReferences<T extends Node = Node> = (node: T, value: unknown, inDecl: Decl[]) => string[];
 export declare const getReferences: GetReferences;

package/dist/src/node/schema/Node.js

@@ -147,86 +147,86 @@ export const getNestedDeclarations = (addedDecls, node, parentDecl) => {
             return assertExhaustive(node);
     }
 };
-export const validateDecl = (helpers, decl, typeArgs, value) => {
+export const validateDecl = (helpers, inDecls, decl, typeArgs, value) => {
     switch (decl.kind) {
         case NodeKind.EntityDecl:
-            return validateEntityDecl(helpers, decl, value);
+            return validateEntityDecl(helpers, inDecls, decl, value);
         case NodeKind.EnumDecl:
-            return validateEnumDecl(helpers, decl, typeArgs, value);
+            return validateEnumDecl(helpers, inDecls, decl, typeArgs, value);
         case NodeKind.TypeAliasDecl:
-            return validateTypeAliasDecl(helpers, decl, typeArgs, value);
+            return validateTypeAliasDecl(helpers, inDecls, decl, typeArgs, value);
         default:
             return assertExhaustive(decl);
     }
 };
-export const validateType = (helpers, type, value) => {
+export const validateType = (helpers, inDecls, type, value) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
-            return validateArrayType(helpers, type, value);
+            return validateArrayType(helpers, inDecls, type, value);
         case NodeKind.ObjectType:
-            return validateObjectType(helpers, type, value);
+            return validateObjectType(helpers, inDecls, type, value);
         case NodeKind.BooleanType:
-            return validateBooleanType(helpers, type, value);
+            return validateBooleanType(helpers, inDecls, type, value);
         case NodeKind.DateType:
-            return validateDateType(helpers, type, value);
+            return validateDateType(helpers, inDecls, type, value);
         case NodeKind.FloatType:
-            return validateFloatType(helpers, type, value);
+            return validateFloatType(helpers, inDecls, type, value);
         case NodeKind.IntegerType:
-            return validateIntegerType(helpers, type, value);
+            return validateIntegerType(helpers, inDecls, type, value);
         case NodeKind.StringType:
-            return validateStringType(helpers, type, value);
+            return validateStringType(helpers, inDecls, type, value);
         case NodeKind.TypeArgumentType:
-            return validateTypeArgumentType(helpers, type, value);
+            return validateTypeArgumentType(helpers, inDecls, type, value);
         case NodeKind.ReferenceIdentifierType:
-            return validateReferenceIdentifierType(helpers, type, value);
+            return validateReferenceIdentifierType(helpers, inDecls, type, value);
         case NodeKind.IncludeIdentifierType:
-            return validateIncludeIdentifierType(helpers, type, value);
+            return validateIncludeIdentifierType(helpers, inDecls, type, value);
         case NodeKind.NestedEntityMapType:
-            return validateNestedEntityMapType(helpers, type, value);
+            return validateNestedEntityMapType(helpers, inDecls, type, value);
         case NodeKind.EnumType:
-            return validateEnumType(helpers, type, value);
+            return validateEnumType(helpers, inDecls, type, value);
         case NodeKind.ChildEntitiesType:
-            return validateChildEntitiesType(helpers, type, value);
+            return validateChildEntitiesType(helpers, inDecls, type, value);
         default:
             return assertExhaustive(type);
     }
 };
-export const resolveTypeArguments = (args, node) => {
+export const resolveTypeArguments = (args, node, inDecl) => {
     switch (node.kind) {
         case NodeKind.EntityDecl:
-            return resolveTypeArgumentsInEntityDecl(args, node);
+            return resolveTypeArgumentsInEntityDecl(args, node, inDecl);
         case NodeKind.EnumDecl:
-            return resolveTypeArgumentsInEnumDecl(args, node);
+            return resolveTypeArgumentsInEnumDecl(args, node, inDecl);
         case NodeKind.TypeAliasDecl:
-            return resolveTypeArgumentsInTypeAliasDecl(args, node);
+            return resolveTypeArgumentsInTypeAliasDecl(args, node, inDecl);
         case NodeKind.ArrayType:
-            return resolveTypeArgumentsInArrayType(args, node);
+            return resolveTypeArgumentsInArrayType(args, node, inDecl);
         case NodeKind.ObjectType:
-            return resolveTypeArgumentsInObjectType(args, node);
+            return resolveTypeArgumentsInObjectType(args, node, inDecl);
         case NodeKind.BooleanType:
-            return resolveTypeArgumentsInBooleanType(args, node);
+            return resolveTypeArgumentsInBooleanType(args, node, inDecl);
         case NodeKind.DateType:
-            return resolveTypeArgumentsInDateType(args, node);
+            return resolveTypeArgumentsInDateType(args, node, inDecl);
         case NodeKind.FloatType:
-            return resolveTypeArgumentsInFloatType(args, node);
+            return resolveTypeArgumentsInFloatType(args, node, inDecl);
         case NodeKind.IntegerType:
-            return resolveTypeArgumentsInIntegerType(args, node);
+            return resolveTypeArgumentsInIntegerType(args, node, inDecl);
         case NodeKind.StringType:
-            return resolveTypeArgumentsInStringType(args, node);
+            return resolveTypeArgumentsInStringType(args, node, inDecl);
         case NodeKind.TypeArgumentType:
             return resolveTypeArgumentsInTypeArgumentType(args, node);
         case NodeKind.ReferenceIdentifierType:
-            return resolveTypeArgumentsInReferenceIdentifierType(args, node);
+            return resolveTypeArgumentsInReferenceIdentifierType(args, node, inDecl);
         case NodeKind.IncludeIdentifierType:
-            return resolveTypeArgumentsInIncludeIdentifierType(args, node);
+            return resolveTypeArgumentsInIncludeIdentifierType(args, node, inDecl);
         case NodeKind.NestedEntityMapType:
-            return resolveTypeArgumentsInNestedEntityMapType(args, node);
+            return resolveTypeArgumentsInNestedEntityMapType(args, node, inDecl);
         case NodeKind.EnumType:
-            return resolveTypeArgumentsInEnumType(args, node);
+            return resolveTypeArgumentsInEnumType(args, node, inDecl);
         case NodeKind.TypeParameter:
-            return resolveTypeArgumentsInTypeParameter(args, node);
+            return resolveTypeArgumentsInTypeParameter(args, node, inDecl);
         case NodeKind.ChildEntitiesType:
-            return resolveTypeArgumentsInChildEntitiesType(args, node);
+            return resolveTypeArgumentsInChildEntitiesType(args, node, inDecl);
         default:
             return assertExhaustive(node);
     }
@@ -271,42 +271,42 @@ export const serializeNode = (node) => {
             return assertExhaustive(node);
     }
 };
-export const getReferences = (node, value) => {
+export const getReferences = (node, value, inDecl) => {
     switch (node.kind) {
         case NodeKind.EntityDecl:
-            return getReferencesForEntityDecl(node, value);
+            return getReferencesForEntityDecl(node, value, inDecl);
         case NodeKind.EnumDecl:
-            return getReferencesForEnumDecl(node, value);
+            return getReferencesForEnumDecl(node, value, inDecl);
         case NodeKind.TypeAliasDecl:
-            return getReferencesForTypeAliasDecl(node, value);
+            return getReferencesForTypeAliasDecl(node, value, inDecl);
         case NodeKind.ArrayType:
-            return getReferencesForArrayType(node, value);
+            return getReferencesForArrayType(node, value, inDecl);
         case NodeKind.ObjectType:
-            return getReferencesForObjectType(node, value);
+            return getReferencesForObjectType(node, value, inDecl);
         case NodeKind.BooleanType:
-            return getReferencesForBooleanType(node, value);
+            return getReferencesForBooleanType(node, value, inDecl);
         case NodeKind.DateType:
-            return getReferencesForDateType(node, value);
+            return getReferencesForDateType(node, value, inDecl);
         case NodeKind.FloatType:
-            return getReferencesForFloatType(node, value);
+            return getReferencesForFloatType(node, value, inDecl);
         case NodeKind.IntegerType:
-            return getReferencesForIntegerType(node, value);
+            return getReferencesForIntegerType(node, value, inDecl);
         case NodeKind.StringType:
-            return getReferencesForStringType(node, value);
+            return getReferencesForStringType(node, value, inDecl);
         case NodeKind.TypeArgumentType:
-            return getReferencesForTypeArgumentType(node, value);
+            return getReferencesForTypeArgumentType(node, value, inDecl);
         case NodeKind.ReferenceIdentifierType:
-            return getReferencesForReferenceIdentifierType(node, value);
+            return getReferencesForReferenceIdentifierType(node, value, inDecl);
         case NodeKind.IncludeIdentifierType:
-            return getReferencesForIncludeIdentifierType(node, value);
+            return getReferencesForIncludeIdentifierType(node, value, inDecl);
         case NodeKind.NestedEntityMapType:
-            return getReferencesForNestedEntityMapType(node, value);
+            return getReferencesForNestedEntityMapType(node, value, inDecl);
         case NodeKind.EnumType:
-            return getReferencesForEnumType(node, value);
+            return getReferencesForEnumType(node, value, inDecl);
         case NodeKind.TypeParameter:
-            return getReferencesForTypeParameter(node, value);
+            return getReferencesForTypeParameter(node, value, inDecl);
         case NodeKind.ChildEntitiesType:
-            return getReferencesForChildEntitiesType(node, value);
+            return getReferencesForChildEntitiesType(node, value, inDecl);
         default:
             return assertExhaustive(node);
     }

package/dist/src/node/schema/Schema.js

@@ -1,8 +1,9 @@
 import Debug from "debug";
+import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { getParameterNames, walkNodeTree } from "./declarations/Declaration.js";
 import { isEntityDecl } from "./declarations/EntityDecl.js";
 import { cases, isEnumDecl } from "./declarations/EnumDecl.js";
-import { getNestedDeclarations } from "./Node.js";
+import { getNestedDeclarations, NodeKind } from "./Node.js";
 import { isObjectType } from "./types/generic/ObjectType.js";
 import { isStringType } from "./types/primitives/StringType.js";
 import { isChildEntitiesType } from "./types/references/ChildEntitiesType.js";
@@ -152,6 +153,60 @@ const checkChildEntitiesProvideCorrectPathToParentReferenceIdentifierType = (dec
         }
     }
 };
+const isDeclarationRecursive = (declToCheck) => {
+    const isDeclarationIncludedInNode = (visitedDecls, node) => {
+        switch (node.kind) {
+            case NodeKind.EntityDecl:
+            case NodeKind.EnumDecl:
+            case NodeKind.TypeAliasDecl:
+                return visitedDecls.includes(node)
+                    ? false
+                    : declToCheck === node ||
+                        isDeclarationIncludedInNode([...visitedDecls, node], node.type.value);
+            case NodeKind.BooleanType:
+            case NodeKind.DateType:
+            case NodeKind.FloatType:
+            case NodeKind.IntegerType:
+            case NodeKind.StringType:
+            case NodeKind.TypeArgumentType:
+            case NodeKind.ReferenceIdentifierType:
+            case NodeKind.TypeParameter:
+            case NodeKind.ChildEntitiesType:
+                return false;
+            case NodeKind.ArrayType:
+                return isDeclarationIncludedInNode(visitedDecls, node.items);
+            case NodeKind.ObjectType:
+                return Object.entries(node.properties).some(([_, memberDecl]) => isDeclarationIncludedInNode(visitedDecls, memberDecl.type));
+            case NodeKind.IncludeIdentifierType:
+                return (declToCheck === node.reference ||
+                    isDeclarationIncludedInNode(visitedDecls, node.reference));
+            case NodeKind.NestedEntityMapType:
+                return isDeclarationIncludedInNode(visitedDecls, node.type.value);
+            case NodeKind.EnumType:
+                return Object.entries(node.values).some(([_, caseDecl]) => caseDecl.type !== null && isDeclarationIncludedInNode(visitedDecls, caseDecl.type));
+            default:
+                return assertExhaustive(node);
+        }
+    };
+    return isDeclarationIncludedInNode([declToCheck], declToCheck.type.value);
+};
+const checkRecursiveGenericTypeAliasesAndEnumerationsAreOnlyParameterizedDirectlyInTypeAliases = (declarations) => {
+    const genericRecursiveDeclarations = declarations.filter(decl => isDeclarationRecursive(decl) && decl.parameters.length > 0);
+    for (const decl of declarations) {
+        walkNodeTree((node, parentTypes) => {
+            if (isIncludeIdentifierType(node) &&
+                genericRecursiveDeclarations.includes(node.reference) &&
+                decl !== node.reference) {
+                if (parentTypes.length > 0) {
+                    throw TypeError(`generic recursive type "${node.reference.name}", referenced in declaration "${decl.name}", may only be included as a direct descendant of a type alias. This is required for resolving generics for outputs without support for generics, as well as internal type validation.`);
+                }
+                if (decl.parameters.length > 0) {
+                    throw TypeError(`generic recursive type "${node.reference.name}", referenced in declaration "${decl.name}", may only be included in a non-generic type alias. This is required for resolving generics for outputs without support for generics, as well as internal type validation.`);
+                }
+            }
+        }, decl);
+    }
+};
 const addDeclarations = (existingDecls, declsToAdd) => declsToAdd.reduce((accDecls, decl) => {
     if (!accDecls.includes(decl)) {
         return getNestedDeclarations(accDecls, decl.kind === "NestedEntity" ? decl.type : decl, undefined);
@@ -176,6 +231,8 @@ export const Schema = (declarations, localeEntity) => {
     checkChildEntitiesProvideCorrectPathToParentReferenceIdentifierType(allDeclsWithoutNestedEntities);
     debug("checking child entity types ...");
     checkChildEntityTypes(localeEntity, allDeclsWithoutNestedEntities);
+    debug("checking generic recursive types ...");
+    checkRecursiveGenericTypeAliasesAndEnumerationsAreOnlyParameterizedDirectlyInTypeAliases(allDeclsWithoutNestedEntities);
     debug("created schema, no integrity violations found");
     return {
         declarations: allDeclsWithoutNestedEntities,

package/dist/src/node/schema/declarations/Declaration.js

@@ -16,7 +16,7 @@ export const validateDeclName = (name) => {
     }
 };
 export const isDeclWithoutTypeParameters = (decl) => decl.parameters.length === 0;
-export const resolveTypeArgumentsInDecls = (decls) => decls.filter(isDeclWithoutTypeParameters).map(decl => resolveTypeArguments({}, decl));
+export const resolveTypeArgumentsInDecls = (decls) => decls.filter(isDeclWithoutTypeParameters).map(decl => resolveTypeArguments({}, decl, []));
 export function walkNodeTree(callbackFn, decl) {
     callbackFn(decl, [], decl);
     walkTypeNodeTree(callbackFn, decl.type.value, [], decl);

package/dist/src/node/schema/declarations/EntityDecl.js

@@ -27,10 +27,10 @@ export { EntityDecl as Entity };
 export const isEntityDecl = node => node.kind === NodeKind.EntityDecl;
 export const isEntityDeclWithParentReference = (decl) => decl.parentReferenceKey !== undefined;
 export const getNestedDeclarationsInEntityDecl = (isDeclAdded, decl) => getNestedDeclarationsInObjectType(isDeclAdded, decl.type.value, decl);
-export const validateEntityDecl = (helpers, decl, value) => validateType(helpers, decl.type.value, value);
-export const resolveTypeArgumentsInEntityDecl = (_args, decl) => EntityDecl(decl.sourceUrl, {
+export const validateEntityDecl = (helpers, inDecls, decl, value) => validateType(helpers, inDecls, decl.type.value, value);
+export const resolveTypeArgumentsInEntityDecl = (_args, decl, inDecl) => EntityDecl(decl.sourceUrl, {
     ...decl,
-    type: () => resolveTypeArguments({}, decl.type.value),
+    type: () => resolveTypeArguments({}, decl.type.value, [...inDecl, decl]),
 });
 const createEntityIdentifierComment = () => "The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.";
 export const addEphemeralUUIDToType = (decl) => ({
@@ -57,4 +57,4 @@ export const serializeEntityDecl = (type) => ({
         : type.displayName,
     displayNameCustomizer: type.displayNameCustomizer !== undefined,
 });
-export const getReferencesForEntityDecl = (decl, value) => getReferencesForObjectType(decl.type.value, value);
+export const getReferencesForEntityDecl = (decl, value, inDecl) => getReferencesForObjectType(decl.type.value, value, [...inDecl, decl]);

package/dist/src/node/schema/declarations/EnumDecl.js

@@ -29,17 +29,20 @@ export const EnumDecl = (sourceUrl, options) => {
 export { EnumDecl as Enum };
 export const isEnumDecl = node => node.kind === NodeKind.EnumDecl;
 export const getNestedDeclarationsInEnumDecl = (addedDecls, decl) => getNestedDeclarationsInEnumType(addedDecls, decl.type.value, decl);
-export const validateEnumDecl = (helpers, decl, args, value) => validateEnumType(helpers, resolveTypeArgumentsInEnumType(getTypeArgumentsRecord(decl, args), decl.type.value), value);
-export const resolveTypeArgumentsInEnumDecl = (args, decl) => EnumDecl(decl.sourceUrl, {
+export const validateEnumDecl = (helpers, inDecls, decl, args, value) => validateEnumType(helpers, [...inDecls, decl], resolveTypeArgumentsInEnumType(getTypeArgumentsRecord(decl, args), decl.type.value, [
+    ...inDecls,
+    decl,
+]), value);
+export const resolveTypeArgumentsInEnumDecl = (args, decl, inDecl) => EnumDecl(decl.sourceUrl, {
     name: decl.name,
     comment: decl.comment,
     isDeprecated: decl.isDeprecated,
-    values: () => resolveTypeArgumentsInEnumType(args, decl.type.value).values,
+    values: () => resolveTypeArgumentsInEnumType(args, decl.type.value, [...inDecl, decl]).values,
 });
 export const serializeEnumDecl = decl => ({
     ...decl,
     type: serializeEnumType(decl.type.value),
     parameters: decl.parameters.map(param => serializeTypeParameter(param)),
 });
-export const getReferencesForEnumDecl = (decl, value) => getReferencesForEnumType(decl.type.value, value);
+export const getReferencesForEnumDecl = (decl, value, inDecl) => getReferencesForEnumType(decl.type.value, value, [...inDecl, decl]);
 export const cases = (decl) => Object.values(decl.type.value.values);

package/dist/src/node/schema/declarations/TypeAliasDecl.d.ts

@@ -3,7 +3,7 @@ import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeA
 import { NodeKind } from "../Node.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
 import type { Type } from "../types/Type.ts";
-import type { BaseDecl, TypeArguments } from "./Declaration.ts";
+import type { BaseDecl, Decl, TypeArguments } from "./Declaration.ts";
 export interface TypeAliasDecl<Name extends string = string, T extends Type = Type, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["TypeAliasDecl"];
     type: Lazy<T>;
@@ -26,7 +26,7 @@ export declare const TypeAliasDecl: <Name extends string, T extends Type>(source
 export { TypeAliasDecl as TypeAlias };
 export declare const isTypeAliasDecl: Predicate<TypeAliasDecl>;
 export declare const getNestedDeclarationsInTypeAliasDecl: GetNestedDeclarations<TypeAliasDecl>;
-export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: Validators, decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
+export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: Validators, inDecls: Decl[], decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
 export declare const resolveTypeArgumentsInTypeAliasDecl: TypeArgumentsResolver<TypeAliasDecl>;
 export declare const serializeTypeAliasDecl: Serializer<TypeAliasDecl>;
 export declare const getReferencesForTypeAliasDecl: GetReferences<TypeAliasDecl>;

package/dist/src/node/schema/declarations/TypeAliasDecl.js

@@ -27,14 +27,14 @@ export const TypeAliasDecl = (sourceUrl, options) => {
 export { TypeAliasDecl as TypeAlias };
 export const isTypeAliasDecl = node => node.kind === NodeKind.TypeAliasDecl;
 export const getNestedDeclarationsInTypeAliasDecl = (addedDecls, decl) => getNestedDeclarations(addedDecls, decl.type.value, decl);
-export const validateTypeAliasDecl = ((helpers, decl, args, value) => validateType(helpers, resolveTypeArguments(getTypeArgumentsRecord(decl, args), decl.type.value), value));
-export const resolveTypeArgumentsInTypeAliasDecl = (args, decl) => TypeAliasDecl(decl.sourceUrl, {
+export const validateTypeAliasDecl = ((helpers, inDecls, decl, args, value) => validateType(helpers, [...inDecls, decl], resolveTypeArguments(getTypeArgumentsRecord(decl, args), decl.type.value, [...inDecls, decl]), value));
+export const resolveTypeArgumentsInTypeAliasDecl = (args, decl, inDecl) => TypeAliasDecl(decl.sourceUrl, {
     ...decl,
-    type: () => resolveTypeArguments(args, decl.type.value),
+    type: () => resolveTypeArguments(args, decl.type.value, [...inDecl, decl]),
 });
 export const serializeTypeAliasDecl = type => ({
     ...type,
     type: serializeNode(type.type.value),
     parameters: type.parameters.map(param => serializeTypeParameter(param)),
 });
-export const getReferencesForTypeAliasDecl = (decl, value) => getReferences(decl.type.value, value);
+export const getReferencesForTypeAliasDecl = (decl, value, inDecl) => getReferences(decl.type.value, value, [...inDecl, decl]);

package/dist/src/node/schema/types/generic/ArrayType.js

@@ -15,21 +15,21 @@ export const ArrayType = (items, options = {}) => ({
 export { ArrayType as Array };
 export const isArrayType = node => node.kind === NodeKind.ArrayType;
 export const getNestedDeclarationsInArrayType = (addedDecls, type, parentDecl) => getNestedDeclarations(addedDecls, type.items, parentDecl);
-export const validateArrayType = (helpers, type, value) => {
+export const validateArrayType = (helpers, inDecls, type, value) => {
     if (!Array.isArray(value)) {
         return [TypeError(`expected an array, but got ${json(value, helpers.useStyling)}`)];
     }
     return parallelizeErrors([
         ...validateArrayConstraints(type, value),
-        ...value.map((item, index) => wrapErrorsIfAny(`at index ${key(index.toString(), helpers.useStyling)}`, validateType(helpers, type.items, item))),
+        ...value.map((item, index) => wrapErrorsIfAny(`at index ${key(index.toString(), helpers.useStyling)}`, validateType(helpers, inDecls, type.items, item))),
     ]);
 };
-export const resolveTypeArgumentsInArrayType = (args, type) => ArrayType(resolveTypeArguments(args, type.items), {
+export const resolveTypeArgumentsInArrayType = (args, type, inDecl) => ArrayType(resolveTypeArguments(args, type.items, inDecl), {
     ...type,
 });
 export const serializeArrayType = type => ({
     ...type,
     items: serializeNode(type.items),
 });
-export const getReferencesForArrayType = (type, value) => Array.isArray(value) ? value.flatMap(item => getReferences(type.items, item)) : [];
+export const getReferencesForArrayType = (type, value, inDecl) => Array.isArray(value) ? value.flatMap(item => getReferences(type.items, item, inDecl)) : [];
 export const formatArrayValue = (type, value) => Array.isArray(value) ? value.map(item => formatValue(type.items, item)) : value;

package/dist/src/node/schema/types/generic/EnumType.js

@@ -10,7 +10,7 @@ export const EnumType = (values) => ({
 });
 export const isEnumType = node => node.kind === NodeKind.EnumType;
 export const getNestedDeclarationsInEnumType = (addedDecls, type, parentDecl) => Object.values(type.values).reduce((acc, caseMember) => caseMember.type === null ? acc : getNestedDeclarations(acc, caseMember.type, parentDecl), addedDecls);
-export const validateEnumType = (helpers, type, value) => {
+export const validateEnumType = (helpers, inDecls, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
     }
@@ -42,16 +42,16 @@ export const validateEnumType = (helpers, type, value) => {
             ];
         }
         return parallelizeErrors([
-            wrapErrorsIfAny(`at enum case ${key(`"${caseName}"`, helpers.useStyling)}`, validateType(helpers, associatedType, value[caseName])),
+            wrapErrorsIfAny(`at enum case ${key(`"${caseName}"`, helpers.useStyling)}`, validateType(helpers, inDecls, associatedType, value[caseName])),
         ]);
     }
     return [];
 };
-export const resolveTypeArgumentsInEnumType = (args, type) => EnumType(Object.fromEntries(Object.entries(type.values).map(([key, { type, ...caseMember }]) => [
+export const resolveTypeArgumentsInEnumType = (args, type, inDecl) => EnumType(Object.fromEntries(Object.entries(type.values).map(([key, { type, ...caseMember }]) => [
     key,
     {
         ...caseMember,
-        type: type === null ? null : resolveTypeArguments(args, type),
+        type: type === null ? null : resolveTypeArguments(args, type, inDecl),
     },
 ])));
 export const EnumCaseDecl = (options) => ({
@@ -69,7 +69,7 @@ export const serializeEnumType = type => ({
         },
     ])),
 });
-export const getReferencesForEnumType = (type, value) => {
+export const getReferencesForEnumType = (type, value, inDecl) => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
@@ -82,7 +82,7 @@ export const getReferencesForEnumType = (type, value) => {
         type.values[enumCase] !== undefined &&
         type.values[enumCase].type !== null &&
         enumCase in value
-        ? getReferences(type.values[enumCase].type, value[enumCase])
+        ? getReferences(type.values[enumCase].type, value[enumCase], inDecl)
         : [];
 };
 export const formatEnumType = (type, value) => {

package/dist/src/node/schema/types/generic/ObjectType.js

@@ -26,7 +26,7 @@ export const ObjectType = (properties, options = {}) => {
 export { ObjectType as Object };
 export const isObjectType = node => node.kind === NodeKind.ObjectType;
 export const getNestedDeclarationsInObjectType = (addedDecls, type, parentDecl) => Object.values(type.properties).reduce((acc, prop) => getNestedDeclarations(acc, prop.type, parentDecl), addedDecls);
-export const validateObjectType = (helpers, type, value) => {
+export const validateObjectType = (helpers, inDecls, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
     }
@@ -40,13 +40,13 @@ export const validateObjectType = (helpers, type, value) => {
                 return TypeError(`missing required property ${keyColor(`"${key}"`, helpers.useStyling)}`);
             }
             else if (prop.isRequired || value[key] !== undefined) {
-                return wrapErrorsIfAny(`at object key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateType(helpers, prop.type, value[key]));
+                return wrapErrorsIfAny(`at object key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateType(helpers, inDecls, prop.type, value[key]));
             }
             return undefined;
         }),
     ]);
 };
-export const resolveTypeArgumentsInObjectType = (args, type) => ObjectType(Object.fromEntries(Object.entries(type.properties).map(([key, config]) => [key, { ...config, type: resolveTypeArguments(args, config.type) }])), {
+export const resolveTypeArgumentsInObjectType = (args, type, inDecl) => ObjectType(Object.fromEntries(Object.entries(type.properties).map(([key, config]) => [key, { ...config, type: resolveTypeArguments(args, config.type, inDecl) }])), {
     ...type,
 });
 const MemberDecl = (isRequired, type, comment, isDeprecated) => ({
@@ -68,8 +68,8 @@ export const serializeObjectType = (type) => ({
         },
     ])),
 });
-export const getReferencesForObjectType = (type, value) => typeof value === "object" && value !== null
-    ? Object.entries(value).flatMap(([key, propValue]) => type.properties[key] ? getReferences(type.properties[key].type, propValue) : [])
+export const getReferencesForObjectType = (type, value, inDecl) => typeof value === "object" && value !== null
+    ? Object.entries(value).flatMap(([key, propValue]) => type.properties[key] ? getReferences(type.properties[key].type, propValue, inDecl) : [])
     : [];
 export const formatObjectValue = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
     ? sortObjectKeys(Object.fromEntries(Object.entries(value).map(([key, item]) => [

package/dist/src/node/schema/types/primitives/BooleanType.js

@@ -6,7 +6,7 @@ export const BooleanType = () => ({
 export { BooleanType as Boolean };
 export const isBooleanType = node => node.kind === NodeKind.BooleanType;
 export const getNestedDeclarationsInBooleanType = addedDecls => addedDecls;
-export const validateBooleanType = (helpers, _type, value) => {
+export const validateBooleanType = (helpers, _inDecls, _type, value) => {
     if (typeof value !== "boolean") {
         return [TypeError(`expected a boolean value, but got ${json(value, helpers.useStyling)}`)];
     }

package/dist/src/node/schema/types/primitives/DateType.js

@@ -8,7 +8,7 @@ export const DateType = (options) => ({
 export { DateType as Date };
 export const isDateType = node => node.kind === NodeKind.DateType;
 export const getNestedDeclarationsInDateType = addedDecls => addedDecls;
-export const validateDateType = (helpers, type, value) => {
+export const validateDateType = (helpers, _inDecls, type, value) => {
     if (typeof value !== "string") {
         return [TypeError(`expected a string, but got ${json(value, helpers.useStyling)}`)];
     }

package/dist/src/node/schema/types/primitives/FloatType.js

@@ -8,7 +8,7 @@ export const FloatType = (options = {}) => ({
 export { FloatType as Float };
 export const isFloatType = node => node.kind === NodeKind.FloatType;
 export const getNestedDeclarationsInFloatType = addedDecls => addedDecls;
-export const validateFloatType = (helpers, type, value) => {
+export const validateFloatType = (helpers, _inDecls, type, value) => {
     if (typeof value !== "number") {
         return [
             TypeError(`expected a floating-point number, but got ${json(value, helpers.useStyling)}`),

package/dist/src/node/schema/types/primitives/IntegerType.js

@@ -12,7 +12,7 @@ export const IntegerType = (options = {}) => ({
 export { IntegerType as Integer };
 export const isIntegerType = node => node.kind === NodeKind.IntegerType;
 export const getNestedDeclarationsInIntegerType = addedDecls => addedDecls;
-export const validateIntegerType = (helpers, type, value) => {
+export const validateIntegerType = (helpers, _inDecls, type, value) => {
     if (typeof value !== "number" || !Number.isInteger(value)) {
         return [TypeError(`expected an integer, but got ${json(value, helpers.useStyling)}`)];
     }

package/dist/src/node/schema/types/primitives/StringType.js

@@ -8,7 +8,7 @@ export const StringType = (options = {}) => ({
 export { StringType as String };
 export const isStringType = node => node.kind === NodeKind.StringType;
 export const getNestedDeclarationsInStringType = addedDecls => addedDecls;
-export const validateStringType = (helpers, type, value) => {
+export const validateStringType = (helpers, _inDecls, type, value) => {
     if (typeof value !== "string") {
         return [TypeError(`expected a string, but got ${json(value, helpers.useStyling)}`)];
     }

package/dist/src/node/schema/types/references/IncludeIdentifierType.d.ts

@@ -1,7 +1,7 @@
 import type { SerializedIncludeIdentifierType } from "../../../../shared/schema/types/IncludeIdentifierType.ts";
-import type { IncludableDeclP, TypeArguments } from "../../declarations/Declaration.ts";
+import type { Decl, IncludableDeclP, TypeArguments } from "../../declarations/Declaration.ts";
 import type { EnumDecl } from "../../declarations/EnumDecl.ts";
-import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.ts";
+import { type TypeAliasDecl } from "../../declarations/TypeAliasDecl.ts";
 import type { GetNestedDeclarations, GetReferences, Predicate, SerializedTypeParameters, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
 import type { TypeParameter } from "../../TypeParameter.ts";
@@ -20,7 +20,7 @@ export { IncludeIdentifierType as IncludeIdentifier };
 export declare const isIncludeIdentifierType: Predicate<IncludeIdentifierType>;
 export declare const getNestedDeclarationsInIncludeIdentifierType: GetNestedDeclarations<IncludeIdentifierType>;
 export declare const validateIncludeIdentifierType: Validator<IncludeIdentifierType>;
-export declare const resolveTypeArgumentsInIncludeIdentifierType: <T extends IncludeIdentifierType>(args: Record<string, Type>, type: T) => T extends IncludeIdentifierType<[], IncludableDeclP<[]>> ? T : Type;
+export declare const resolveTypeArgumentsInIncludeIdentifierType: <T extends IncludeIdentifierType>(args: Record<string, Type>, type: T, inDecl: Decl[]) => (T & IncludeIdentifierType<[], IncludableDeclP<[]>>) | (T extends IncludeIdentifierType<[], IncludableDeclP<[]>> ? T : Type);
 export declare const serializeIncludeIdentifierType: <Params extends TypeParameter[] = TypeParameter<string, Type>[], T extends TConstraint<Params> = TConstraint<Params>>(type: IncludeIdentifierType<Params, T>) => SerializedIncludeIdentifierType<SerializedTypeParameters<Params>>;
 export declare const getReferencesForIncludeIdentifierType: GetReferences<IncludeIdentifierType>;
 export declare const formatIncludeIdentifierValue: StructureFormatter<IncludeIdentifierType>;

package/dist/src/node/schema/types/references/IncludeIdentifierType.js

@@ -1,7 +1,9 @@
-import { getTypeArgumentsRecord } from "../../declarations/Declaration.js";
+import { getTypeArgumentsRecord, isDeclWithoutTypeParameters, } from "../../declarations/Declaration.js";
+import { isTypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
 import { getNestedDeclarations, getReferences, NodeKind, resolveTypeArguments, serializeNode, validateDecl, } from "../../Node.js";
 import { formatEnumType } from "../generic/EnumType.js";
 import { formatValue } from "../Type.js";
+import { isTypeArgumentType } from "./TypeArgumentType.js";
 export const GenIncludeIdentifierType = (reference, args) => ({
     kind: NodeKind.IncludeIdentifierType,
     reference,
@@ -19,16 +21,38 @@ const isNoGenericIncludeIdentifierType = (node) => node.args.length === 0 && nod
 export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type, parentDecl) => type.args.reduce((accAddedDecls, arg) => getNestedDeclarations(accAddedDecls, arg, parentDecl), addedDecls.includes(type.reference)
     ? addedDecls
     : getNestedDeclarations(addedDecls, type.reference, parentDecl));
-export const validateIncludeIdentifierType = (helpers, type, value) => validateDecl(helpers, type.reference, type.args, value);
-export const resolveTypeArgumentsInIncludeIdentifierType = ((args, type) => (isNoGenericIncludeIdentifierType(type)
-    ? type
-    : resolveTypeArguments(getTypeArgumentsRecord(type.reference, type.args.map(arg => resolveTypeArguments(args, arg))), type.reference).type.value));
+export const validateIncludeIdentifierType = (helpers, inDecls, type, value) => validateDecl(helpers, inDecls, type.reference, type.args, value);
+export const resolveTypeArgumentsInIncludeIdentifierType = ((args, type, inDecl) => {
+    if (isNoGenericIncludeIdentifierType(type)) {
+        return type;
+    }
+    else {
+        const parentDecl = inDecl[inDecl.length - 1];
+        const grandParentDecl = inDecl[inDecl.length - 2];
+        if (grandParentDecl?.name === "AdventurePointsDependingOnActiveInstancesMultiplier") {
+            console.log(type.args.every((arg, argIndex) => isTypeArgumentType(arg) && parentDecl?.parameters[argIndex] === arg.argument));
+        }
+        if (type.reference === parentDecl &&
+            parentDecl.parameters.length > 0 &&
+            grandParentDecl &&
+            isDeclWithoutTypeParameters(grandParentDecl) &&
+            isTypeAliasDecl(grandParentDecl) &&
+            type.args.every((arg, argIndex) => isTypeArgumentType(arg) && parentDecl.parameters[argIndex] === arg.argument)) {
+            const grandParentDeclType = grandParentDecl.type.value;
+            if (isIncludeIdentifierType(grandParentDeclType) &&
+                grandParentDeclType.reference === type.reference) {
+                return IncludeIdentifierType(grandParentDecl);
+            }
+        }
+        return resolveTypeArguments(getTypeArgumentsRecord(type.reference, type.args.map(arg => resolveTypeArguments(args, arg, inDecl))), type.reference, inDecl).type.value;
+    }
+});
 export const serializeIncludeIdentifierType = ((type) => ({
     ...type,
     reference: type.reference.name,
     args: type.args.map(arg => serializeNode(arg)),
 }));
-export const getReferencesForIncludeIdentifierType = (type, value) => getReferences(resolveTypeArguments(getTypeArgumentsRecord(type.reference, type.args), type.reference), value);
+export const getReferencesForIncludeIdentifierType = (type, value, inDecl) => getReferences(resolveTypeArguments(getTypeArgumentsRecord(type.reference, type.args), type.reference, inDecl), value, inDecl);
 export const formatIncludeIdentifierValue = (type, value) => {
     switch (type.reference.kind) {
         case NodeKind.TypeAliasDecl:

package/dist/src/node/schema/types/references/NestedEntityMapType.js

@@ -27,18 +27,18 @@ const _NestedEntityMapType = (options) => {
 };
 export const isNestedEntityMapType = node => node.kind === NodeKind.NestedEntityMapType;
 export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type, parentDecl) => getNestedDeclarations(getNestedDeclarations(addedDecls, type.secondaryEntity, parentDecl), type.type.value, parentDecl);
-export const validateNestedEntityMapType = (helpers, type, value) => {
+export const validateNestedEntityMapType = (helpers, inDecls, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
     }
-    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateType(helpers, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
+    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateType(helpers, inDecls, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
         name: type.secondaryEntity.name,
         value: key,
     })))));
 };
-export const resolveTypeArgumentsInNestedEntityMapType = (args, type) => _NestedEntityMapType({
+export const resolveTypeArgumentsInNestedEntityMapType = (args, type, inDecl) => _NestedEntityMapType({
     ...type,
-    type: () => resolveTypeArguments(args, type.type.value),
+    type: () => resolveTypeArguments(args, type.type.value, inDecl),
 });
 export const serializeNestedEntityMapType = type => ({
     ...type,
@@ -47,11 +47,11 @@ export const serializeNestedEntityMapType = type => ({
         ? serializeObjectType(type.type.value)
         : serializeIncludeIdentifierType(type.type.value),
 });
-export const getReferencesForNestedEntityMapType = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
+export const getReferencesForNestedEntityMapType = (type, value, inDecl) => typeof value === "object" && value !== null && !Array.isArray(value)
     ? Object.values(value)
         .flatMap(item => isObjectType(type.type.value)
-        ? getReferencesForObjectType(type.type.value, item)
-        : getReferencesForIncludeIdentifierType(type.type.value, item))
+        ? getReferencesForObjectType(type.type.value, item, inDecl)
+        : getReferencesForIncludeIdentifierType(type.type.value, item, inDecl))
         .concat(Object.keys(value))
     : [];
 export const formatNestedEntityMapValue = (type, value) => isObjectType(type.type.value)

package/dist/src/node/schema/types/references/ReferenceIdentifierType.js

@@ -9,7 +9,7 @@ export const isReferenceIdentifierType = (node) => node.kind === NodeKind.Refere
 export const getNestedDeclarationsInReferenceIdentifierType = (addedDecls, type, parentDecl) => addedDecls.includes(type.entity)
     ? addedDecls
     : getNestedDeclarations(addedDecls, type.entity, parentDecl);
-export const validateReferenceIdentifierType = (helpers, type, value) => validateType(helpers, createEntityIdentifierType(), value).concat(helpers.checkReferentialIntegrity({
+export const validateReferenceIdentifierType = (helpers, inDecls, type, value) => validateType(helpers, inDecls, createEntityIdentifierType(), value).concat(helpers.checkReferentialIntegrity({
     name: type.entity.name,
     value: value,
 }));

package/dist/src/node/schema/types/references/TypeArgumentType.js

@@ -7,7 +7,7 @@ export const TypeArgumentType = (argument) => ({
 export { TypeArgumentType as TypeArgument };
 export const isTypeArgumentType = (node) => node.kind === NodeKind.TypeArgumentType;
 export const getNestedDeclarationsInTypeArgumentType = addedDecls => addedDecls;
-export const validateTypeArgumentType = (_helpers, type) => {
+export const validateTypeArgumentType = (_helpers, _inDecls, type) => {
     throw new TypeError(`generic argument "${type.argument.name}" has not been replaced with a concrete type`);
 };
 export const resolveTypeArgumentsInTypeArgumentType = ((args, type) => {

package/dist/src/node/utils/instanceOperations.js

@@ -27,7 +27,7 @@ export const createInstance = async (dataRoot, localeEntity, instancesByEntityNa
     }
 };
 export const checkUpdateInstancePossible = (instancesByEntityName, entity, instanceContent) => {
-    const validationErrors = validateEntityDecl(createValidators(instancesByEntityName, false), entity, instanceContent);
+    const validationErrors = validateEntityDecl(createValidators(instancesByEntityName, false), [], entity, instanceContent);
     if (validationErrors.length > 0) {
         return error([400, validationErrors.map(getErrorMessageForDisplay).join("\n\n")]);
     }

package/dist/src/node/utils/references.js

@@ -58,13 +58,13 @@ export const updateReferencesToInstances = (entitiesByName, referencesToInstance
     const entity = entitiesByName[entityName];
     if (entity) {
         if (oldInstance === undefined) {
-            return addReferences(referencesToInstances, getReferencesForEntityDecl(entity, newInstance), instanceId);
+            return addReferences(referencesToInstances, getReferencesForEntityDecl(entity, newInstance, []), instanceId);
         }
         if (newInstance === undefined) {
-            return removeReferences(referencesToInstances, getReferencesForEntityDecl(entity, oldInstance), instanceId);
+            return removeReferences(referencesToInstances, getReferencesForEntityDecl(entity, oldInstance, []), instanceId);
         }
-        const oldReferences = getReferencesForEntityDecl(entity, oldInstance);
-        const newReferences = getReferencesForEntityDecl(entity, newInstance);
+        const oldReferences = getReferencesForEntityDecl(entity, oldInstance, []);
+        const newReferences = getReferencesForEntityDecl(entity, newInstance, []);
         const { added, removed } = difference(oldReferences, newReferences);
         return removeReferences(addReferences(referencesToInstances, added, instanceId), removed, instanceId);
     }

package/dist/src/shared/utils/markdown.d.ts

@@ -24,11 +24,17 @@ type AttributedStringMarkdownNode = {
     attributes: Record<string, string | number | boolean>;
     content: InlineMarkdownNode[];
 };
+type SuperscriptInlineNode = {
+    kind: "superscript";
+    content: InlineMarkdownNode[];
+};
 type FootnoteRefInlineNode = {
     kind: "footnoteRef";
     label: string;
 };
-export type InlineMarkdownNode = BoldMarkdownNode | ItalicMarkdownNode | CodeMarkdownNode | LinkMarkdownNode | AttributedStringMarkdownNode | TextNode | FootnoteRefInlineNode;
+export type InlineMarkdownNode = BoldMarkdownNode | ItalicMarkdownNode | CodeMarkdownNode | LinkMarkdownNode | AttributedStringMarkdownNode | TextNode | SuperscriptInlineNode | FootnoteRefInlineNode;
+export declare const parseInlineMarkdown: (text: string) => InlineMarkdownNode[];
+export declare const parseInlineMarkdownForSyntaxHighlighting: (text: string) => InlineMarkdownNode[];
 export declare const checkTableRowsAreSections: (rows: TableRowBlockNode[] | TableSectionBlockNode[]) => rows is TableSectionBlockNode[];
 export declare const syntaxNodeToString: (node: BlockSyntaxMarkdownNode) => string;
 export type ParagraphBlockNode = {

package/dist/src/shared/utils/markdown.js

@@ -150,6 +150,17 @@ const attributedRule = {
         };
     },
 };
+const superscriptRule = {
+    pattern: /\^(.*?)\^/,
+    map: (result, parseInside) => ({
+        kind: "superscript",
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
+        kind: "superscript",
+        content: [textNode("^"), ...parseInside(result[1] ?? ""), textNode("^")],
+    }),
+};
 const footnoteRefRule = {
     pattern: /(?<!\\)\[\^([a-zA-Z0-9*]+?)\]/,
     map: ([_match, label = ""]) => ({
@@ -185,6 +196,7 @@ const inlineRules = [
     italicWithBoldRule,
     boldRule,
     italicRule,
+    superscriptRule,
     footnoteRefRule,
     textRule,
 ];
@@ -210,7 +222,8 @@ const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
         return parseForInlineRules(rules.slice(1), text, forSyntaxHighlighting);
     }
 };
-const parseInlineMarkdown = (text, forSyntaxHighlighting) => parseForInlineRules(inlineRules, text, forSyntaxHighlighting);
+export const parseInlineMarkdown = (text) => parseForInlineRules(inlineRules, text, false);
+export const parseInlineMarkdownForSyntaxHighlighting = (text) => reduceSyntaxNodes(parseForInlineRules(inlineRules, text, true));
 const nodesForTrailingWhitespace = (text) => {
     const trailingWhitespace = text ?? "";
     return trailingWhitespace.length === 0 ? [] : [textNode(trailingWhitespace)];
@@ -222,7 +235,7 @@ const listRule = {
         ordered: /^\d+\. /.test(result[0]),
         content: (result[1] ?? "").split("\n").map(item => ({
             kind: "listItem",
-            content: parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), false),
+            content: parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, "")),
         })),
     }),
     mapHighlighting: result => [
@@ -231,7 +244,7 @@ const listRule = {
                 kind: "listItemMarker",
                 content: /^(\d+\. |[-*] )/.exec(item)?.[1] ?? "",
             },
-            ...parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), true),
+            ...parseInlineMarkdownForSyntaxHighlighting(item.replace(/^\d+\. |[-*] /, "")),
             ...(index < array.length - 1 ? [textNode("\n")] : []),
         ]),
         ...nodesForTrailingWhitespace(result[2]),
@@ -241,10 +254,10 @@ const paragraphRule = {
     pattern: /^((?:[^\n]+?)(?:\n[^\n]+?)*)(\n{2,}|\s*$)/,
     map: ([_res, content = "", _trailingWhitespace]) => ({
         kind: "paragraph",
-        content: parseInlineMarkdown(content, false),
+        content: parseInlineMarkdown(content),
     }),
     mapHighlighting: ([_res, content = "", trailingWhitespace]) => [
-        ...parseInlineMarkdown(content, true),
+        ...parseInlineMarkdownForSyntaxHighlighting(content),
         ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
@@ -253,11 +266,11 @@ const headingRule = {
     map: result => ({
         kind: "heading",
         level: result[1]?.length ?? 1,
-        content: parseInlineMarkdown(result[3] ?? "", false),
+        content: parseInlineMarkdown(result[3] ?? ""),
     }),
     mapHighlighting: result => [
         { kind: "headingMarker", content: (result[1] ?? "") + (result[2] ?? "") },
-        ...parseInlineMarkdown(result[3] ?? "", true),
+        ...parseInlineMarkdownForSyntaxHighlighting(result[3] ?? ""),
         ...nodesForTrailingWhitespace(result[4]),
     ],
 };
@@ -279,7 +292,7 @@ const parseContentRow = (row) => row
             omitUndefinedKeys({
                 kind: "tableCell",
                 colSpan: colSpan !== undefined && colSpan > 1 ? colSpan : undefined,
-                content: parseInlineMarkdown(segment.trim(), false),
+                content: parseInlineMarkdown(segment.trim()),
             }),
         ];
     }
@@ -287,7 +300,7 @@ const parseContentRow = (row) => row
 }, []);
 const parseContentRowForSyntaxHighlighting = (row) => row.split(/(\|+)/).reduce((acc, segment, index) => {
     if (index % 2 === 0) {
-        return [...acc, ...parseInlineMarkdown(segment, true)];
+        return [...acc, ...parseInlineMarkdownForSyntaxHighlighting(segment)];
     }
     else {
         return [...acc, tableMarker(segment)];
@@ -313,7 +326,9 @@ const tableRule = {
     pattern: /^(?:(\|#)(.+?)(#\|)\n)?(\|)?(.+?(?:(?<!\\)\|.+?)+)((?<!\\)\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|?.+?(?:(?<!\\)\|+.+?)*(?:(?<!\\)\|+)?)+)(\n{2,}|$)/,
     map: ([_res, _captionMarkerStart, caption, _captionMarkerEnd, _headerMarkerStart, headers, _headerMarkerEnd, bodySeparators = "", body, _trailingWhitespace,]) => omitUndefinedKeys({
         kind: "table",
-        caption: caption !== undefined ? parseInlineMarkdown(caption.trim(), false) : undefined,
+        caption: caption !== undefined
+            ? parseInlineMarkdownForSyntaxHighlighting(caption.trim())
+            : undefined,
         columns: trimPipes(bodySeparators)
             .split("|")
             .map(col => omitUndefinedKeys({
@@ -387,7 +402,7 @@ const tableRule = {
         ...(caption !== undefined
             ? [
                 tableMarker(captionMarkerStart ?? ""),
-                ...parseInlineMarkdown(caption, true),
+                ...parseInlineMarkdownForSyntaxHighlighting(caption),
                 tableMarker(captionMarkerEnd ?? ""),
                 textNode("\n"),
             ]
@@ -396,8 +411,8 @@ const tableRule = {
         ...(headers
             ?.split("|")
             .flatMap((th, i) => i === 0
-            ? parseInlineMarkdown(th, true)
-            : [tableMarker("|"), ...parseInlineMarkdown(th, true)]) ?? []),
+            ? parseInlineMarkdownForSyntaxHighlighting(th)
+            : [tableMarker("|"), ...parseInlineMarkdownForSyntaxHighlighting(th)]) ?? []),
         tableMarker(headerMarkerEnd ?? ""),
         textNode("\n"),
         tableMarker(bodySeparators ?? ""),
@@ -439,6 +454,7 @@ export const syntaxNodeToString = (node) => {
         case "italic":
         case "link":
         case "attributed":
+        case "superscript":
             return node.content.map(syntaxNodeToString).join("");
         case "text":
         case "code":
@@ -461,6 +477,7 @@ const addIndentationToSyntax = (nodes, nextUpperNode) => nodes.reduce((accNodes,
         case "italic":
         case "link":
         case "attributed":
+        case "superscript":
             return [
                 ...accNodes,
                 {
@@ -516,7 +533,7 @@ const definitionListRule = {
             const terms = termsText
                 .trim()
                 .split("\n")
-                .map(term => parseInlineMarkdown(term.trim(), false));
+                .map(term => parseInlineMarkdown(term.trim()));
             const definitions = definitionsText
                 .split("\n:")
                 .slice(1)
@@ -537,7 +554,7 @@ const definitionListRule = {
             const terms = termsText
                 .split("\n")
                 .flatMap((term, index, termArray) => [
-                ...parseInlineMarkdown(term, true),
+                ...parseInlineMarkdownForSyntaxHighlighting(term),
                 ...(index < termArray.length - 1 ? [textNode("\n")] : []),
             ]);
             const definitions = definitionsText
@@ -602,6 +619,7 @@ const reduceSyntaxNode = (node) => {
         case "bold":
         case "italic":
         case "link":
+        case "superscript":
             return { ...node, content: reduceSyntaxNodes(node.content) };
         case "code":
         case "attributed":
@@ -628,6 +646,7 @@ const syntaxNodeMergeRules = {
     headingMarker: (a, b) => ({ ...a, content: a.content + b.content }),
     sectionMarker: (a, b) => ({ ...a, content: a.content + b.content }),
     footnoteMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    superscript: (a, b) => ({ ...a, content: [...a.content, ...b.content] }),
     definitionMarker: (a, b) => ({ ...a, content: a.content + b.content }),
     footnoteRef: null,
     link: null,

package/dist/src/web/routes/Entity.js

@@ -26,7 +26,7 @@ export const Entity = () => {
     const gitClient = useContext(GitClientContext);
     const { reloadEntities } = useContext(EntitiesContext);
     const { declaration: entity, isLocaleEntity } = entityFromRoute ?? {};
-    const [instances, reloadInstances] = useMappedAPIResource(getInstancesByEntityName, mapInstances, locales, name ?? "");
+    const [instances, reloadInstances] = useMappedAPIResource(getInstancesByEntityName, mapInstances, locales, entity?.name ?? "");
     const [localeInstances] = useMappedAPIResource(getLocaleInstances, localeMapper, locales, config.localeEntityName);
     useEffect(() => {
         document.title = toTitleCase(entity?.namePlural ?? name ?? "") + " — TSONDB";
@@ -39,11 +39,11 @@ export const Entity = () => {
             }
         }
     }, [created]);
-    if (!name) {
+    if (entity?.name === undefined) {
         return _jsx(NotFound, {});
     }
-    if (!entity || !instances) {
-        return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: homeTitle }], children: [_jsxs("div", { class: "header-with-btns", children: [_jsx("h1", { children: toTitleCase(entity?.namePlural ?? name) }), _jsx("a", { class: "btn btn--primary", "aria-disabled": true, children: "Add" })] }), _jsx("p", { class: "loading", children: "Loading \u2026" })] }));
+    if (!instances) {
+        return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: homeTitle }], children: [_jsxs("div", { class: "header-with-btns", children: [_jsx("h1", { children: toTitleCase(entity.namePlural) }), _jsx("a", { class: "btn btn--primary", "aria-disabled": true, children: "Add" })] }), _jsx("p", { class: "loading", children: "Loading \u2026" })] }));
     }
     const lowerSearchText = searchText.toLowerCase();
     const filteredInstances = (searchText.length === 0

package/dist/src/web/utils/InlineMarkdown.js

@@ -22,6 +22,8 @@ export const InlineMarkdown = ({ node }) => {
             const trailingNodes = node.content.slice(attributesEnd);
             return (_jsxs("span", { class: "attributed", ...Object.fromEntries(Object.entries(node.attributes).map(([k, v]) => [`data-${k}`, v.toString()])), children: [leadingNodes.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))), Array.from({ length: count }, (_, i) => (_jsxs(Fragment, { children: [_jsx("span", { class: "attributed__name", children: _jsx(InlineMarkdown, { node: attributes[i * 4] ?? emptyNode }) }), _jsx("span", { class: "attributed__separator", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 1] ?? emptyNode }) }), _jsx("span", { class: "attributed__value", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 2] ?? emptyNode }) }), i < count - 1 && (_jsx("span", { class: "attributed__separator", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 3] ?? emptyNode }) }))] }, `attr-${(i + 1).toString()}`))), trailingNodes.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i)))] }));
         }
+        case "superscript":
+            return (_jsx("sup", { children: node.content.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))) }));
         case "footnoteRef": {
             const isNumeric = /^\d+$/.test(node.label);
             return (_jsx("sup", { class: "footnote-ref" + (isNumeric ? " footnote-ref--numeric" : ""), "data-reference": node.label, style: { "--label": isNumeric ? Number.parseInt(node.label) : node.label }, children: _jsx("span", { class: "footnote-label", children: node.label }) }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -32,19 +32,19 @@
     "release:sign": "commit-and-tag-version --sign --signoff"
   },
   "devDependencies": {
-    "@eslint/js": "^9.36.0",
+    "@eslint/js": "^9.37.0",
     "@types/debug": "^4.1.12",
     "@types/express": "^5.0.3",
-    "@types/node": "^24.6.2",
+    "@types/node": "^24.8.1",
     "commit-and-tag-version": "^12.6.0",
-    "eslint": "^9.36.0",
+    "eslint": "^9.37.0",
     "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^6.1.0",
+    "eslint-plugin-react-hooks": "^7.0.0",
     "globals": "^16.4.0",
     "prettier": "^3.6.2",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.45.0"
+    "typescript-eslint": "^8.46.1"
   },
   "dependencies": {
     "@preact/signals": "^2.3.2",