@pbkware/fielded-text-web 0.1.2 → 0.2.2

package/src/fields/instances/ft-float-field.ts

@@ -1,6 +1,9 @@
 import { FtSequenceInvokation } from '../../sequences/core/ft-sequence-invokation.js';
 import { FtSequenceItem } from '../../sequences/core/ft-sequence-item.js';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
 import { FtFloatFieldDefinition } from '../definitions/ft-float-field-definition.js';
+import { FtFieldTypeError } from './errors/ft-field-type-error.js';
+import { FtField } from './ft-field.js';
 import { FtGenericField } from './ft-generic-field.js';
 
 /**
@@ -26,18 +29,26 @@ export class FtFloatField extends FtGenericField<number> {
     return this.definition.styles;
   }
 
-  get nullableValue(): number | null {
-    return this.isNull() ? null : this.value;
+  static cast(field: FtField): field is FtFloatField {
+    return field.dataType === FtDataType.Float;
   }
 
-  set nullableValue(value: number | null) {
-    if (value === null) {
-      this.setNull();
+  override setValue(newValue: FtField.Value): number {
+    if (typeof newValue === 'number') {
+      return super.setValue(newValue);
     } else {
-      this.value = value;
+      throw new FtFieldTypeError(`Invalid type (${typeof newValue}) for float field: ${this.name}`);
     }
   }
 
+  protected override getAsFloat(): number {
+    return this.getValue();
+  }
+
+  protected override setAsFloat(newValue: number): void {
+    super.setValue(newValue);
+  }
+
   protected isValueEqual(left: number, right: number): boolean {
     return left === right;
   }

package/src/fields/instances/ft-generic-field.ts

@@ -1,6 +1,7 @@
 import { FtSequenceInvokation } from '../../sequences/core/ft-sequence-invokation.js';
 import { FtSequenceItem } from '../../sequences/core/ft-sequence-item.js';
 import { FtSequenceRedirectType } from '../../types/enums/ft-sequence-redirect-type.js';
+import { FtAssertError } from '../../utils/ft-internal-error.js';
 import { FtGenericFieldDefinition } from '../definitions/ft-generic-field-definition.js';
 import { FtField } from './ft-field.js';
 
@@ -9,7 +10,7 @@ import { FtField } from './ft-field.js';
  * Provides type-safe value access and implements conversion methods.
  * @public
  */
-export abstract class FtGenericField<T> extends FtField {
+export abstract class FtGenericField<T extends FtField.Value> extends FtField {
   private _value!: T;
 
   protected constructor(
@@ -22,11 +23,11 @@ export abstract class FtGenericField<T> extends FtField {
 
     // Verify the sequenceItem's definition matches the provided definition
     if (sequenceItem.fieldDefinition !== definition) {
-      throw new Error('SequenceItem definition must match provided definition');
-    }
-
-    if (definition.constant && !definition.null) {
-      this._value = definition.value;
+      throw new FtAssertError('FGC60112', `${definition.metaName}, ${sequenceItem.fieldDefinition?.metaName}`);
+    } else {
+      if (definition.constant && !definition.null) {
+        this._value = definition.value;
+      }
     }
   }
 
@@ -34,104 +35,54 @@ export abstract class FtGenericField<T> extends FtField {
     return super.definition_ as FtGenericFieldDefinition<T>;
   }
 
-  get value(): T {
-    return this.getValueOrThrowNull();
+  override get value(): T {
+    if (this.isNull()) {
+      throw new Error(`Attempt to get value from null field "${this.name}"`);
+    } else {
+      return this._value;
+    }
   }
 
-  set value(val: T) {
+  override set value(val: T) {
     this.setValue(val); // ignore fieldsAffectedFromIndex for direct value sets, as sequence redirects are not expected in this case
   }
 
+  override get nullableValue(): T | null {
+    return this.isNull() ? null : this._value;
+  }
+
+  override set nullableValue(value: T | null) {
+    if (value === null) {
+      this.setNull();
+    } else {
+      this.setValue(value);
+    }
+  }
+
   setValue(val: T): number {
     if (this.constant) {
       throw new Error(`Cannot set constant field "${this.name}"`);
     } else {
       this.clearNonConstantNull();
       this._value = val;
-      this.valueAssigned = true;
+      this._valueAssigned = true;
       return this.checkValueSequenceRedirect(); // returns fieldsAffectedFromIndex
     }
   }
 
-  protected getAsNonNullValueText(): string {
+  formatValue(): string {
     try {
-      return this.definition_.getValueText(this._value);
+      return this.definition_.formatValue(this._value);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to convert field "${this.name}" to text: ${message}`, { cause: error });
     }
   }
 
-  protected getAsNonNullObject(): unknown {
+  protected getValue(): T {
     return this._value;
   }
 
-  protected getAsNonNullString(): string {
-    return String(this._value);
-  }
-
-  protected getAsBoolean(): boolean {
-    return Boolean(this._value);
-  }
-
-  protected getAsInteger(): number {
-    return Number(this._value);
-  }
-
-  protected getAsBigInt(): bigint {
-    if (typeof this._value === 'bigint') {
-      return this._value;
-    }
-    return BigInt(Number(this._value));
-  }
-
-  protected getAsFloat(): number {
-    return Number(this._value);
-  }
-
-  protected getAsDateTime(): Date {
-    if (this._value instanceof Date) {
-      return this._value;
-    }
-    return new Date(Number(this._value));
-  }
-
-  protected getAsDecimal(): number {
-    return Number(this._value);
-  }
-
-  protected setAsNonNullObject(newValue: unknown): void {
-    this.value = newValue as T;
-  }
-
-  protected setAsNonNullString(newValue: string): void {
-    this.value = newValue as unknown as T;
-  }
-
-  protected setAsBoolean(newValue: boolean): void {
-    this.value = newValue as unknown as T;
-  }
-
-  protected setAsInteger(newValue: number): void {
-    this.value = newValue as unknown as T;
-  }
-
-  protected setAsBigInt(newValue: bigint): void {
-    this.value = newValue as unknown as T;
-  }
-
-  protected setAsFloat(newValue: number): void {
-    this.value = newValue as unknown as T;
-  }
-
-  protected setAsDateTime(newValue: Date): void {
-    this.value = newValue as unknown as T;
-  }
-
-  protected setAsDecimal(newValue: number): void {
-    this.value = newValue as unknown as T;
-  }
-
   protected getAsRedirectBoolean(): boolean {
     return Boolean(this._value);
   }
@@ -158,11 +109,11 @@ export abstract class FtGenericField<T> extends FtField {
     return Number(this._value);
   }
 
-  protected loadNonNullValue(valueText: string): void {
+  protected override loadValueFromText(valueText: string): void {
     if (!this.constant) {
       this.clearNonConstantNull();
       this._value = this.definition_.parseValueText(valueText);
-      this.valueAssigned = true;
+      this._valueAssigned = true;
       this.checkValueSequenceRedirect(); // ignore fieldsAffectedFromIndex for value loads, as sequence redirects are not expected in this case
     } else {
       if (this.isNull()) {
@@ -177,13 +128,6 @@ export abstract class FtGenericField<T> extends FtField {
     }
   }
 
-  private getValueOrThrowNull(): T {
-    if (this.isNull()) {
-      throw new Error(`Attempt to get value from null field "${this.name}"`);
-    }
-    return this._value;
-  }
-
   private checkValueSequenceRedirect(): number {
     if (this.sequenceRedirectList.count > 0 && !this.sidelined) {
       let redirected = false;

package/src/fields/instances/ft-integer-field.ts

@@ -1,6 +1,9 @@
+import { FtDataType } from '../../index.js';
 import { FtSequenceInvokation } from '../../sequences/core/ft-sequence-invokation.js';
 import { FtSequenceItem } from '../../sequences/core/ft-sequence-item.js';
 import { FtIntegerFieldDefinition } from '../definitions/ft-integer-field-definition.js';
+import { FtFieldTypeError } from './errors/ft-field-type-error.js';
+import { FtField } from './ft-field.js';
 import { FtGenericField } from './ft-generic-field.js';
 
 /**
@@ -26,18 +29,37 @@ export class FtIntegerField extends FtGenericField<bigint> {
     return this.definition.styles;
   }
 
-  get nullableValue(): bigint | null {
-    return this.isNull() ? null : this.value;
+  static cast(field: FtField): field is FtIntegerField {
+    return field.dataType === FtDataType.Integer;
   }
 
-  set nullableValue(value: bigint | null) {
-    if (value === null) {
-      this.setNull();
-    } else {
-      this.value = value;
+  override setValue(newValue: FtField.Value): number {
+    switch (typeof newValue) {
+      case 'bigint':
+        return super.setValue(newValue);
+      case 'number':
+        return super.setValue(BigInt(newValue));
+      default:
+        throw new FtFieldTypeError(`Invalid type (${typeof newValue}) for integer field: ${this.name}`);
     }
   }
 
+  protected override getAsBigInt(): bigint {
+    return this.getValue();
+  }
+
+  protected override setAsBigInt(newValue: bigint): void {
+    super.setValue(newValue);
+  }
+
+  protected override getAsInteger(): number {
+    return Number(this.getValue());
+  }
+
+  protected override setAsInteger(newValue: number): void {
+    super.setValue(BigInt(newValue));
+  }
+
   protected isValueEqual(left: bigint, right: bigint): boolean {
     return left === right;
   }

package/src/fields/instances/ft-string-field.ts

@@ -1,6 +1,9 @@
 import { FtSequenceInvokation } from '../../sequences/core/ft-sequence-invokation.js';
 import { FtSequenceItem } from '../../sequences/core/ft-sequence-item.js';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
 import { FtStringFieldDefinition } from '../definitions/ft-string-field-definition.js';
+import { FtFieldTypeError } from './errors/ft-field-type-error.js';
+import { FtField } from './ft-field.js';
 import { FtGenericField } from './ft-generic-field.js';
 
 /**
@@ -14,24 +17,24 @@ export class FtStringField extends FtGenericField<string> {
     super(sequenceInvokation, sequenceItem, FtStringField.VALUE_TEXT_NULL_TRIMMABLE, definition);
   }
 
-  get nullableValue(): string | null {
-    return this.isNull() ? null : this.value;
+  static cast(field: FtField): field is FtStringField {
+    return field.dataType === FtDataType.String;
   }
 
-  set nullableValue(value: string | null) {
-    if (value === null) {
-      this.setNull();
+  override setValue(newValue: FtField.Value): number {
+    if (typeof newValue === 'string') {
+      return super.setValue(newValue);
     } else {
-      this.value = value;
+      throw new FtFieldTypeError(`Invalid type (${typeof newValue}) for string field: ${this.name}`);
     }
   }
 
-  override setValue(value: string | null): number {
-    if (value === null) {
-      return this.setNull(); // returns fieldsAffectedFromIndex
-    } else {
-      return super.setValue(value); // returns fieldsAffectedFromIndex
-    }
+  protected override getAsString(): string {
+    return this.getValue();
+  }
+
+  protected override setAsString(newValue: string): void {
+    super.setValue(newValue);
   }
 
   protected isValueEqual(left: string, right: string): boolean {

package/src/index.ts

@@ -7,8 +7,6 @@ export {
   DotNetNumberStyles,
 } from '@pbkware/dot-net-date-number-formatting';
 
-export { Result } from '@pbkware/js-utils';
-
 // Enums
 export { FtBooleanStyles } from './types/enums/ft-boolean-styles.js';
 export { FtEndOfLineAutoWriteType } from './types/enums/ft-end-of-line-auto-write-type.js';
@@ -31,6 +29,11 @@ export { FtTruncateType } from './types/enums/ft-truncate-type.js';
 export { FtDataType } from './types/enums/ft-data-type.js';
 export { FtSequenceRedirectType } from './types/enums/ft-sequence-redirect-type.js';
 
+// Utils
+export { FtCommaText } from './utils/ft-comma-text.js';
+export { FtInternalError } from './utils/ft-internal-error.js';
+export { FtErr, FtOk, FtResult } from './utils/ft-result.js';
+
 // Core meta classes
 export { FtBooleanMetaField } from './meta/fields/ft-boolean-meta-field.js';
 export { FtDateTimeMetaField } from './meta/fields/ft-date-time-meta-field.js';
@@ -135,13 +138,19 @@ export { FtDateTimeStylesMetaSerialization } from './meta-serialization/styles/f
 export { FtNumberStylesMetaSerialization } from './meta-serialization/styles/ft-number-styles-meta-serialization.js';
 
 // Serialization errors and exceptions
-export { FtSerializationError } from './types/errors/ft-serialization-error.js';
-export { FtSerializationException } from './types/errors/ft-serialization-exception.js';
+export { FtFieldNullError as FtNullError } from './fields/instances/errors/ft-field-null-error.js';
+export { FtFieldTypeError as FtTypeError } from './fields/instances/errors/ft-field-type-error.js';
+export { FtSerializationErrorCode } from './serialization/ft-serialization-error-code.js';
+export { FtSerializationError } from './serialization/ft-serialization-error.js';
+
+// Serialization core
+export { FtSerializationCore } from './serialization/ft-serialization-core.js';
 
 // Serialization reader
 export { FtDeclaredParameterRec, FtDeclaredParameters } from './serialization/ft-declared-parameters.js';
 export { FtSerializationReader } from './serialization/ft-serialization-reader.js';
-export { FtStringReader, FtTextReader } from './serialization/ft-text-reader.js';
+export { FtStringReader } from './serialization/text-reader/ft-string-reader.js';
+export { FtTextReader } from './serialization/text-reader/ft-text-reader.js';
 
 // Serialization writer
 export { FtWriterSettings } from './api/ft-writer-settings.js';
@@ -158,28 +167,28 @@ export { FtWriter } from './api/ft-writer.js';
 /**
  * @public
  */
-export type { FtFieldHeadingReadyEventArgs } from './types/events/ft-field-heading-ready-event-args.js';
+export type { FtFieldHeadingReadyEventArgs } from './serialization/events/ft-field-heading-ready-event-args.js';
 /**
  * @public
  */
-export type { FtFieldValueReadyEventArgs } from './types/events/ft-field-value-ready-event-args.js';
+export type { FtFieldValueReadyEventArgs } from './serialization/events/ft-field-value-ready-event-args.js';
 /**
  * @public
  */
-export type { FtHeadingLineFinishedEventArgs } from './types/events/ft-heading-line-finished-event-args.js';
+export type { FtHeadingLineFinishedEventArgs } from './serialization/events/ft-heading-line-finished-event-args.js';
 /**
  * @public
  */
-export type { FtHeadingLineStartedEventArgs } from './types/events/ft-heading-line-started-event-args.js';
+export type { FtHeadingLineStartedEventArgs } from './serialization/events/ft-heading-line-started-event-args.js';
 /**
  * @public
  */
-export type { FtRecordFinishedEventArgs } from './types/events/ft-record-finished-event-args.js';
+export type { FtRecordFinishedEventArgs } from './serialization/events/ft-record-finished-event-args.js';
 /**
  * @public
  */
-export type { FtRecordStartedEventArgs } from './types/events/ft-record-started-event-args.js';
+export type { FtRecordStartedEventArgs } from './serialization/events/ft-record-started-event-args.js';
 /**
  * @public
  */
-export type { FtSequenceRedirectedEventArgs } from './types/events/ft-sequence-redirected-event-args.js';
+export type { FtSequenceRedirectedEventArgs } from './serialization/events/ft-sequence-redirected-event-args.js';

package/src/meta/sequences/core/ft-meta-sequence-list.ts

@@ -18,12 +18,13 @@ export class FtMetaSequenceList {
     return this._list[index];
   }
 
-  getByName(name: string): FtMetaSequence {
+  getByName(name: string): FtMetaSequence | undefined {
     const index = this.indexOfName(name);
     if (index < 0) {
-      throw new Error(`Meta sequence not found: ${name}`);
+      return undefined;
+    } else {
+      return this._list[index];
     }
-    return this._list[index];
   }
 
   set(value: readonly FtMetaSequence[]): void {

package/src/meta/sequences/redirects/ft-meta-sequence-redirect-list.ts

@@ -1,7 +1,7 @@
 // Meta sequence redirect list - manages redirects for a sequence item
 
 import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
-import { FtUnreachableCaseError } from '../../../types/errors/ft-internal-error.js';
+import { FtUnreachableCaseError } from '../../../utils/ft-internal-error.js';
 import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
 import { FtBooleanMetaSequenceRedirect } from './ft-boolean-meta-sequence-redirect.js';
 import { FtCaseInsensitiveStringMetaSequenceRedirect } from './ft-case-insensitive-string-meta-sequence-redirect.js';

package/src/meta-serialization/format/ft-xml-meta-serialization.ts

@@ -1,4 +1,3 @@
-import { CommaText } from '@pbkware/js-utils';
 import XMLBuilder from 'fast-xml-builder';
 import { XMLParser } from 'fast-xml-parser';
 import { FtFieldFactory } from '../../factory/ft-field-factory.js';
@@ -27,7 +26,8 @@ import { FtNullMetaSequenceRedirect } from '../../meta/sequences/redirects/ft-nu
 import { FtMetaSubstitution } from '../../meta/substitutions/ft-meta-substitution-list.js';
 import { FtDataType } from '../../types/enums/ft-data-type.js';
 import { FtSequenceRedirectType } from '../../types/enums/ft-sequence-redirect-type.js';
-import { FtAssertError, FtUnreachableCaseError } from '../../types/errors/ft-internal-error.js';
+import { FtCommaText } from '../../utils/ft-comma-text.js';
+import { FtAssertError, FtUnreachableCaseError } from '../../utils/ft-internal-error.js';
 import { FtBooleanStylesMetaSerialization } from '../styles/ft-boolean-styles-meta-serialization.js';
 import { FtDateTimeStylesMetaSerialization } from '../styles/ft-date-time-styles-meta-serialization.js';
 import { FtNumberStylesMetaSerialization } from '../styles/ft-number-styles-meta-serialization.js';
@@ -236,9 +236,6 @@ export class FtXmlMetaSerialization {
       const sequenceNameResolver = new MetaSerializationSequenceNameResolver();
       const redirectSequenceResolver = new MetaSerializationRedirectSequenceResolver(sequenceNameResolver);
 
-      const redirectNames = new Array<MetaSerializationRedirectSequenceResolver.Rec>(sequenceCount); // We need to collect redirect names first before we can resolve them, so we create records with redirect names and resolve after deserializing all sequences
-      const sequenceNameRecs = new Array<MetaSerializationSequenceNameResolver.Rec>(sequenceCount);
-
       for (let i = 0; i < sequenceCount; i++) {
         const seqObj = objSequences[i];
         const sequenceNameRec = this.deserializeSequence(seqObj, resolvedOrderedFieldList, redirectSequenceResolver, warnings);
@@ -296,7 +293,7 @@ export class FtXmlMetaSerialization {
       '@_HeadingTruncateType': TruncateTypeMetaSerialization.serialize(field.headingTruncateType, true, meta.headingTruncateType),
       '@_HeadingTruncateChar': CharMetaSerialization.serialize(field.headingTruncateChar, meta.headingTruncateChar),
       '@_HeadingEndOfValueChar': CharMetaSerialization.serialize(field.headingEndOfValueChar, meta.headingEndOfValueChar),
-      '@_Headings': fieldHeadings.length === 0 ? undefined : StringMetaSerialization.serialize(CommaText.fromStringArray(fieldHeadings)),
+      '@_Headings': fieldHeadings.length === 0 ? undefined : StringMetaSerialization.serialize(FtCommaText.fromStringArray(fieldHeadings)),
     };
 
     // Type-specific properties
@@ -598,7 +595,7 @@ export class FtXmlMetaSerialization {
     // Headings
     if (headingLineCount > 0) {
       const headingsCommaText = StringMetaSerialization.deserialize(obj['@_Headings'], '', warnings);
-      const headingsResult = CommaText.tryToStringArray(headingsCommaText, true);
+      const headingsResult = FtCommaText.tryToStringArray(headingsCommaText, true);
       if (headingsResult.isErr()) {
         warnings.push(`Headings: Invalid: Field ${field.name}: Value: "${headingsCommaText}"`);
       } else {

package/src/meta-serialization/styles/ft-number-styles-meta-serialization.ts

@@ -1,7 +1,7 @@
 import { DotNetNumberStyles } from '@pbkware/dot-net-date-number-formatting';
 import { FtMetaDefaults } from '../../meta/ft-meta-defaults.js';
 import { FtDataType, FtNumberDataType } from '../../types/enums/ft-data-type.js';
-import { FtUnreachableCaseError } from '../../types/errors/ft-internal-error.js';
+import { FtUnreachableCaseError } from '../../utils/ft-internal-error.js';
 
 /** @public */
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class

package/src/meta-serialization/types/date-time-meta-serialization.ts

@@ -1,5 +1,5 @@
-import { parseIntStrict } from '@pbkware/js-utils';
 import { FtMetaDefaults } from '../../meta/ft-meta-defaults.js';
+import { parseIntStrict } from '../../utils/number-parse.js';
 
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export class DateTimeMetaSerialization {

package/src/meta-serialization/types/enums/meta-element-type-meta-serialization.ts

@@ -1,18 +1,18 @@
-import { Err, Ok, Result } from '@pbkware/js-utils';
 import { FtMetaElementType } from '../../../types/enums/ft-meta-element-type.js';
+import { FtErr, FtOk, FtResult } from '../../../utils/ft-result.js';
 
 export namespace MetaElementTypeMetaSerialization {
   export function serialize(value: FtMetaElementType): string {
     return serializeMap[value];
   }
 
-  export function deserialize(value: string): Result<FtMetaElementType> {
+  export function deserialize(value: string): FtResult<FtMetaElementType> {
     const deserializedValue = deserializeMap[value.trim()];
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (deserializedValue === undefined) {
-      return new Err(`MetaElementType: Value: ${value}`);
+      return new FtErr(`MetaElementType: Value: ${value}`);
     } else {
-      return new Ok(deserializedValue);
+      return new FtOk(deserializedValue);
     }
   }
 }

package/src/meta-serialization/types/enums/sequence-redirect-type-meta-serialisation.ts

@@ -1,7 +1,7 @@
 import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
 import { FtDataType } from '../../../types/enums/ft-data-type.js';
 import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
-import { FtUnreachableCaseError } from '../../../types/errors/ft-internal-error.js';
+import { FtUnreachableCaseError } from '../../../utils/ft-internal-error.js';
 
 export namespace SequenceRedirectTypeMetaSerialization {
   export const stringDefaultValue = FtMetaDefaults.StringField.SequenceRedirectType;

package/src/meta-serialization/types/float-meta-serialization.ts

@@ -1,5 +1,5 @@
-import { isDigitCharCode } from '@pbkware/js-utils';
-import { FtAssertError } from '../../types/errors/ft-internal-error.js';
+import { FtAssertError } from '../../utils/ft-internal-error.js';
+import { isDigitCharCode } from '../../utils/number-parse.js';
 
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export class FloatMetaSerialization {

package/src/meta-serialization/types/integer-float-meta-serialization.ts

@@ -1,5 +1,5 @@
-import { parseIntStrict } from '@pbkware/js-utils';
-import { FtAssertError } from '../../types/errors/ft-internal-error.js';
+import { FtAssertError } from '../../utils/ft-internal-error.js';
+import { parseIntStrict } from '../../utils/number-parse.js';
 
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export class IntegerFloatMetaSerialization {

package/src/meta-serialization/utils/implicit-explicit-index-sorter.ts

@@ -1,4 +1,8 @@
-export interface ImplicitExplicitIndexSortRec<T> {
+import { FtMetaField } from '../../meta/fields/ft-meta-field.js';
+import { FtMetaSequenceItem } from '../../meta/sequences/core/ft-meta-sequence-item.js';
+import { MetaSerializationRedirectSequenceResolver } from './meta-serialization-redirect-sequence-resolver.js';
+
+export interface ImplicitExplicitIndexSortRec<T extends FtMetaField | FtMetaSequenceItem | MetaSerializationRedirectSequenceResolver.Rec> {
   target: T;
   implicitIndex: number;
   explicitIndex: number;
@@ -7,7 +11,10 @@ export interface ImplicitExplicitIndexSortRec<T> {
 export namespace ImplicitExplicitIndexSortRec {
   export const INDEX_NOT_SET = -1;
 
-  export function compare(left: ImplicitExplicitIndexSortRec<unknown>, right: ImplicitExplicitIndexSortRec<unknown>): number {
+  export function compare<T extends FtMetaField | FtMetaSequenceItem | MetaSerializationRedirectSequenceResolver.Rec>(
+    left: ImplicitExplicitIndexSortRec<T>,
+    right: ImplicitExplicitIndexSortRec<T>,
+  ): number {
     const leftHasExplicit = left.explicitIndex !== INDEX_NOT_SET;
     const rightHasExplicit = right.explicitIndex !== INDEX_NOT_SET;
 
@@ -28,22 +35,21 @@ export namespace ImplicitExplicitIndexSortRec {
     return result;
   }
 
-  export function checkSortedArray(arr: ImplicitExplicitIndexSortRec<unknown>[], targetType: string, warnings: string[]): void {
-    let negativeWarned = false;
+  export function checkSortedArray<T extends FtMetaField | FtMetaSequenceItem | MetaSerializationRedirectSequenceResolver.Rec>(
+    arr: ImplicitExplicitIndexSortRec<T>[],
+    targetType: string,
+    warnings: string[],
+  ): void {
     let outOfBoundsWarned = false;
     let duplicateWarned = false;
 
     const count = arr.length;
     for (let i = 1; i < arr.length; i++) {
       const rec = arr[i];
-      if (rec.explicitIndex !== i) {
-        if (rec.explicitIndex < 0) {
-          if (!negativeWarned) {
-            warnings.push(`One or more negative explicit index: ${targetType}`);
-            negativeWarned = true;
-          }
-        } else {
-          if (rec.explicitIndex >= count) {
+      const explicitIndex = rec.explicitIndex;
+      if (explicitIndex >= 0) {
+        if (explicitIndex !== i) {
+          if (explicitIndex >= count) {
             if (!outOfBoundsWarned) {
               warnings.push(`One or more explicit index out of bounds: ${targetType}`);
               outOfBoundsWarned = true;

package/src/meta-serialization/utils/meta-serialization-sequence-name-resolver.ts

@@ -31,20 +31,43 @@ export class MetaSerializationSequenceNameResolver {
     const count = recs.length;
     const sequences = new Array<FtMetaSequence>(count);
 
+    let rootSequence: FtMetaSequence | undefined;
+
     for (let i = 0; i < count; i++) {
       const rec = recs[i];
-      sequences[i] = rec.sequence;
+      const sequence = rec.sequence;
+      if (sequence.root) {
+        if (rootSequence === undefined) {
+          rootSequence = sequence;
+        } else {
+          warnings.push(`Multiple root sequences found: ${rootSequence.name} and ${sequence.name}`);
+          sequence.root = false;
+        }
+      }
+      sequences[i] = sequence;
       const sequenceName = rec.name;
       if (sequenceName === undefined) {
         warnings.push(`Sequence with undefined name: ${JSON.stringify(rec.sequence)}`);
       } else {
-        const existingRec = this._recs.find((r) => r.name === sequenceName);
+        const existingRec = this._recs.find((r, findIndex) => findIndex !== i && r.name === sequenceName);
         if (existingRec !== undefined) {
           warnings.push(`Duplicate sequence name: ${sequenceName}`);
         }
         this._recs.push(rec);
       }
     }
+
+    if (rootSequence === undefined) {
+      warnings.push(`No root sequence found. Setting the first sequence as root: ${sequences[0].name}`);
+      sequences[0].root = true;
+    } else {
+      const rootIndex = sequences.indexOf(rootSequence);
+      if (rootIndex > 0) {
+        // Make sure the root sequence is first in the list
+        sequences.splice(rootIndex, 1);
+        sequences.unshift(rootSequence);
+      }
+    }
     return sequences;
   }