binary-structures-values 0.1.0

package/dist/esm/data-stream-reader.js

@@ -0,0 +1,128 @@
+import { BitStreamReader } from "./bit-stream-reader";
+import { decodeSchemaString, encodeSchema } from "./schema-structure";
+import { compileReader } from "./compiler-old";
+export class DataStreamReader extends BitStreamReader {
+    constructor(schema_or_data, data_or_complete, isComplete) {
+        let initialData;
+        let schema;
+        if (schema_or_data) {
+            if (schema_or_data instanceof Uint8Array) {
+                initialData = schema_or_data;
+                isComplete = !!data_or_complete;
+            }
+            else {
+                if (typeof schema_or_data == 'string')
+                    [schema] = decodeSchemaString(schema_or_data);
+                else
+                    [schema] = decodeSchemaString(encodeSchema(schema_or_data));
+                if (data_or_complete) {
+                    if (data_or_complete instanceof Uint8Array) {
+                        initialData = data_or_complete;
+                        isComplete = !!isComplete;
+                    }
+                }
+            }
+        }
+        super(initialData, isComplete);
+        this.schema = this.schema ?? schema;
+    }
+    static compile(schema) {
+        return compileReader(schema);
+    }
+    readCompiled(compiledFn) {
+        return compiledFn(this);
+    }
+    addData(data) {
+        super.addData(data);
+        if (this.metaData === undefined && this.canReadString())
+            this.metaData = this.readString();
+        let schemaString;
+        if (!this.schema && this.canReadString() && (schemaString = this.readString())) {
+            const [schema, meta] = decodeSchemaString(schemaString);
+            this.schema = schema;
+            this.metaData = this.metaData || meta;
+        }
+    }
+    isReadyToRead() {
+        return this.metaData !== undefined && !!this.schema;
+    }
+    // if not enough bytes available to read, throws error if isComplete otherwise returns null
+    read() {
+        if (!this.schema)
+            throw new Error('Schema not found');
+        if (this.getAvailableBits() <= 0)
+            return null;
+        const savedPosition = this.bitPosition;
+        try {
+            return this.readObject(this.schema);
+        }
+        catch (e) {
+            this.bitPosition = savedPosition;
+            if (!this.isDataComplete()) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    readObject(schema) {
+        const result = {};
+        for (const key of Object.keys(schema)) {
+            const def = schema[key];
+            const isOptional = ('optional' in def && def.optional) || ('types' in def &&
+                typeof def.types[0] === 'object' && 'optional' in def.types[0] && def.types[0].optional);
+            if (isOptional && !this.readBit()) {
+                if ('default' in def && def.default !== undefined)
+                    result[key] = def.default;
+                else if ('types' in def && typeof def.types[0] === 'object' && 'default' in def.types[0] && def.types[0].default !== undefined)
+                    result[key] = def.types[0].default;
+                continue;
+            }
+            result[key] = 'types' in def ? this.readMultiType(def) : this.readSingleType(def);
+        }
+        return result;
+    }
+    readSingleType(def) {
+        if (def.type === 'null')
+            return null;
+        if (def.type === 'boolean')
+            return this.readBit();
+        if (def.type === 'string')
+            return this.readString();
+        if (def.type === 'int-8')
+            return this.readInt8();
+        if (def.type === 'int-16')
+            return this.readInt16();
+        if (def.type === 'int-32')
+            return this.readInt32();
+        if (def.type === 'bigint')
+            return this.readBigInt();
+        if (def.type === 'float-32')
+            return this.readFloat32();
+        if (def.type === 'float-64')
+            return this.readFloat64();
+        if (def.type === 'array')
+            return this.readArray(def.items);
+        if (def.type === 'object')
+            return this.readObject(def.items);
+        throw new Error(`Invalid type: ${def.type}`);
+    }
+    readMultiType(def) {
+        const noOfDefs = def.types.length;
+        const minBits = Math.ceil(Math.log2(noOfDefs));
+        const bits = this.readBits(minBits);
+        const typeIndex = bits.reduce((acc, bit, i) => acc | (bit ? 1 << i : 0), 0);
+        let selectedDef = def.types[typeIndex];
+        if (typeof selectedDef === 'string')
+            selectedDef = { type: selectedDef };
+        return this.readSingleType(selectedDef);
+    }
+    readArray(itemDef) {
+        const length = this.readInt32();
+        const items = [];
+        for (let i = 0; i < length; i++) {
+            const item = 'types' in itemDef ? this.readMultiType(itemDef) : this.readSingleType(itemDef);
+            items.push(item);
+        }
+        return items;
+    }
+}

package/dist/esm/data-stream-writer.d.ts

@@ -0,0 +1,22 @@
+import { BitStreamWriter } from "./bit-stream-writer";
+import { DataType, DataTypeValue, DataValue, MultiType, NonOptionalSingleType, SchemaBase, SingleType } from "./schema-structure";
+export declare class DataStreamWriter extends BitStreamWriter {
+    protected readonly schema: SchemaBase;
+    protected readonly schemaString: string;
+    constructor(schema: SchemaBase, includeSchemaInData: boolean, metaData?: string);
+    static compile(schema: SchemaBase): string;
+    writeCompiled(compiledFn: (writer: DataStreamWriter, data: any) => void, data: any): void;
+    intToBits(int: number, bitCount: number): (0 | 1)[];
+    protected writeArray(value: DataTypeValue[], def: {
+        type: "array";
+        items: DataType;
+        optional?: boolean;
+    } | ({
+        type: "array";
+        items: DataType;
+    })): void;
+    protected writeSingleType(value: DataTypeValue, def: NonOptionalSingleType | SingleType): void;
+    protected writeMultiType(value: DataTypeValue, def: MultiType): void;
+    protected writeObject(data: DataValue, schema: SchemaBase): void;
+    write<D extends DataValue>(data: D): void;
+}

package/dist/esm/data-stream-writer.js

@@ -0,0 +1,175 @@
+import { BitStreamWriter } from "./bit-stream-writer";
+import { decodeSchemaString, encodeSchema } from "./schema-structure";
+import { compileWriter } from "./compiler-old";
+// int8
+const INT8_MIN = Math.floor(-0xFF / 2);
+const INT8_MAX = Math.floor(0xFF / 2);
+// int16
+const INT16_MIN = Math.floor(-0xFFFF / 2);
+const INT16_MAX = Math.floor(0xFFFF / 2);
+// int32
+const INT32_MIN = Math.floor(-0xFFFFFFFF / 2);
+const INT32_MAX = Math.floor(0xFFFFFFFF / 2);
+export class DataStreamWriter extends BitStreamWriter {
+    constructor(schema, includeSchemaInData, metaData = '') {
+        super();
+        this.schemaString = encodeSchema(schema);
+        this.writeString(metaData);
+        if (includeSchemaInData)
+            this.writeString(this.schemaString);
+        else
+            this.writeString('');
+        this.schema = decodeSchemaString(this.schemaString)[0];
+    }
+    static compile(schema) {
+        return compileWriter(schema);
+    }
+    writeCompiled(compiledFn, data) {
+        compiledFn(this, data);
+    }
+    intToBits(int, bitCount) {
+        // TODO: in stead directly write in loop
+        const bits = [];
+        for (let i = 0; i < bitCount; i++) {
+            bits.push((int & (1 << i)) !== 0 ? 1 : 0);
+        }
+        return bits;
+    }
+    writeArray(value, def) {
+        const itemDef = def.items;
+        this.writeInt32(value.length);
+        if ('types' in itemDef) {
+            for (let i = 0; i < value.length; i++)
+                this.writeMultiType(value[i], itemDef);
+        }
+        else {
+            for (let i = 0; i < value.length; i++)
+                this.writeSingleType(value[i], itemDef);
+        }
+    }
+    writeSingleType(value, def) {
+        if (def.type === 'null' && value === null)
+            return;
+        if (def.type === 'boolean' && typeof value === 'boolean')
+            return this.writeBit(value ? 1 : 0);
+        if (def.type === 'string' && typeof value === 'string')
+            return this.writeString(value);
+        if (def.type === 'int-8' && typeof value === 'number')
+            return this.writeInt8(value);
+        if (def.type === 'int-16' && typeof value === 'number')
+            return this.writeInt16(value);
+        if (def.type === 'int-32' && typeof value === 'number')
+            return this.writeInt32(value);
+        if (def.type === 'bigint' && typeof value === 'bigint')
+            return this.writeBigInt(value);
+        if (def.type === 'float-32' && typeof value === 'number')
+            return this.writeFloat32(value);
+        if (def.type === 'float-64' && typeof value === 'number')
+            return this.writeFloat64(value);
+        if (def.type === 'array' && value !== null && typeof value === 'object' && Array.isArray(value))
+            return this.writeArray(value, def);
+        if (def.type === 'object' && value !== null && typeof value === 'object' && !Array.isArray(value))
+            return this.writeObject(value, def.items);
+        throw new Error(`Invalid type: ${def.type}, Value: ${value}`);
+    }
+    writeMultiType(value, def) {
+        let matchedTypes = [];
+        const noOfDefs = def.types.length;
+        const allTypes = def.types.map(t => typeof t === 'string' ? { type: t } : t);
+        // calculate min bits required to store type index
+        const minBits = Math.ceil(Math.log2(noOfDefs));
+        for (let i = 0; i < noOfDefs; i++) {
+            let typeDef = allTypes[i];
+            if (typeDef.type === 'null' && value === null)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'boolean' && typeof value === 'boolean')
+                matchedTypes.push(i);
+            else if (typeDef.type === 'string' && typeof value === 'string')
+                matchedTypes.push(i);
+            else if (typeDef.type === 'int-8' && typeof value === 'number' && value % 1 === 0 && value >= INT8_MIN && value <= INT8_MAX)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'int-16' && typeof value === 'number' && value % 1 === 0 && value >= INT16_MIN && value <= INT16_MAX)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'int-32' && typeof value === 'number' && value % 1 === 0 && value >= INT32_MIN && value <= INT32_MAX)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'bigint' && typeof value === 'bigint')
+                matchedTypes.push(i);
+            else if (typeDef.type === 'float-32' && typeof value === 'number' && Math.abs(value) <= 3.4028235e38)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'float-64' && typeof value === 'number')
+                matchedTypes.push(i);
+            else if (typeDef.type === 'array' && value !== null && typeof value === 'object' && Array.isArray(value))
+                matchedTypes.push(i);
+            else if (typeDef.type === 'object' && value !== null && typeof value === 'object') {
+                const allKeys = Object.keys(typeDef.items);
+                const optionalKeys = allKeys.filter(key => {
+                    const itemDef = typeDef.items[key];
+                    return ('optional' in itemDef && itemDef.optional) || ('types' in itemDef &&
+                        typeof itemDef.types[0] === 'object' && 'optional' in itemDef.types[0] && itemDef.types[0].optional);
+                });
+                const requiredKeys = allKeys.filter(key => {
+                    const itemDef = typeDef.items[key];
+                    return !(('optional' in itemDef && itemDef.optional) || ('types' in itemDef &&
+                        typeof itemDef.types[0] === 'object' && 'optional' in itemDef.types[0] && itemDef.types[0].optional));
+                });
+                const valueKeys = Object.keys(value);
+                // 1. has all required keys
+                if (!requiredKeys.every(key => valueKeys.includes(key)))
+                    continue;
+                const remainingValueKeys = valueKeys.filter(key => !requiredKeys.includes(key));
+                //  2. The remaining keys are in optional (no extra key allowed)
+                if (!remainingValueKeys.every(key => optionalKeys.includes(key)))
+                    continue;
+                matchedTypes.push(i);
+            }
+        }
+        if (matchedTypes.length > 1) {
+            if (typeof value === "number") {
+                //  use the least number of bytes when available
+                if (matchedTypes.some(i => allTypes[i].type === 'int-8'))
+                    matchedTypes = matchedTypes.filter(i => allTypes[i].type === 'int-8');
+                else if (matchedTypes.some(i => allTypes[i].type === 'int-16'))
+                    matchedTypes = matchedTypes.filter(i => allTypes[i].type === 'int-16');
+                else if (matchedTypes.some(i => allTypes[i].type === 'int-32'))
+                    matchedTypes = matchedTypes.filter(i => allTypes[i].type === 'int-32');
+                else if (matchedTypes.some(i => allTypes[i].type === 'float-32'))
+                    matchedTypes = matchedTypes.filter(i => allTypes[i].type === 'float-32');
+            }
+        }
+        if (matchedTypes.length === 0)
+            throw new Error(`No matching type found for value: ${value}, possibles: ${allTypes.map(a => a.type)}`);
+        if (matchedTypes.length > 1)
+            throw new Error(`Multiple matching types found for value: ${value}, types: ${matchedTypes.map(i => {
+                return allTypes[i].type;
+            }).join(', ')}`);
+        this.writeBits(this.intToBits(matchedTypes[0], minBits));
+        let selectedDef = allTypes[matchedTypes[0]];
+        return this.writeSingleType(value, selectedDef);
+    }
+    writeObject(data, schema) {
+        const keys = Object.keys(schema);
+        for (const key of keys) {
+            let def = schema[key];
+            const isOptional = ('optional' in def && def.optional) || ('types' in def &&
+                typeof def.types[0] === 'object' && 'optional' in def.types[0] && def.types[0].optional);
+            if (!(key in data)) {
+                if (isOptional) {
+                    this.writeBit(0);
+                    continue;
+                }
+                throw new Error(`Missing key: ${key}`);
+            }
+            if (isOptional) {
+                this.writeBit(1);
+            }
+            const value = data[key];
+            if ('types' in def)
+                this.writeMultiType(value, def);
+            else
+                this.writeSingleType(value, def);
+        }
+    }
+    write(data) {
+        this.writeObject(data, this.schema);
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./schema-structure";
+export * from "./data-stream-writer";
+export * from "./data-stream-reader";
+export * from "./bit-stream-reader";
+export * from "./bit-stream-writer";

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export * from "./schema-structure";
+export * from "./data-stream-writer";
+export * from "./data-stream-reader";
+export * from "./bit-stream-reader";
+export * from "./bit-stream-writer";

package/dist/esm/schema-structure.d.ts

@@ -0,0 +1,54 @@
+type CreateSingleType<T extends string, V> = ({
+    optional: true;
+    default?: V;
+} | {
+    optional?: false;
+    default?: never;
+}) & ({
+    type: T;
+});
+type AllSingleTypes = CreateSingleType<'string', string> | CreateSingleType<`int-${8 | 16 | 32}`, number> | CreateSingleType<'bigint', bigint> | CreateSingleType<`float-${32 | 64}`, number> | CreateSingleType<'boolean', boolean>;
+export type SingleType = AllSingleTypes | ({
+    type: 'null';
+    optional?: boolean;
+    default?: never;
+}) | ({
+    type: 'object';
+    items: SchemaBase;
+    optional?: boolean;
+}) | ({
+    type: 'array';
+    items: DataType;
+    optional?: boolean;
+});
+export type AllTypes = 'null' | 'string' | `int-${8 | 16 | 32}` | `float-${32 | 64}` | 'boolean' | 'bigint' | 'object' | 'array';
+export type SimpleTypes = 'null' | 'string' | `int-${8 | 16 | 32}` | `float-${32 | 64}` | 'boolean' | 'bigint';
+export type NonOptionalSingleType = ({
+    type: 'null';
+} | {
+    type: 'string' | `int-${8 | 16 | 32}` | `float-${32 | 64}` | 'boolean' | 'bigint';
+} | {
+    type: 'object';
+    items: SchemaBase;
+} | {
+    type: 'array';
+    items: DataType;
+}) & ({
+    optional?: never;
+    default?: never;
+});
+export type MultiType = {
+    types: [SingleType, ...Array<NonOptionalSingleType>] | [SimpleTypes, ...SimpleTypes[]];
+};
+export type DataType = SingleType | MultiType;
+export type SchemaBase = Record<string, DataType>;
+export type DataTypeValue = string | number | bigint | boolean | null | {
+    [key: string]: DataTypeValue;
+} | DataTypeValue[];
+export type DataValue = {
+    [key: string]: DataTypeValue;
+};
+export declare const createSchema: <S extends SchemaBase>(schema: S) => S;
+export declare const encodeSchema: <S extends SchemaBase>(schema: S) => string;
+export declare const decodeSchemaString: <S extends SchemaBase = SchemaBase>(schemaString: string) => [schema: S, metadata: string];
+export {};

package/dist/esm/schema-structure.js

@@ -0,0 +1,267 @@
+export const createSchema = (schema) => {
+    return schema;
+};
+// OPTIMIZATION 4: Improved Base62 with fast path
+const BASE62_CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const encodeBase62 = (n) => {
+    if (n < 0)
+        throw new Error('Cannot encode negative numbers');
+    if (n < 62)
+        return BASE62_CHARS[n]; // Fast path for single digit
+    const digits = [];
+    while (n > 0) {
+        digits.push(BASE62_CHARS[n % 62]);
+        n = Math.floor(n / 62);
+    }
+    return digits.reverse().join('');
+};
+const decodeBase62 = (str) => {
+    let result = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const value = BASE62_CHARS.indexOf(char);
+        if (value === -1)
+            throw new Error(`Invalid base62 character: ${char}`);
+        result = result * 62 + value;
+    }
+    return result;
+};
+// OPTIMIZATION 2: Map-based lookups for O(1) complexity
+const encodeSingleType = (type, key, keyMap, typeMap) => {
+    // Use Map for O(1) lookup instead of indexOf O(n)
+    let typeIndex = typeMap.get(type.type);
+    if (typeIndex === undefined) {
+        typeIndex = typeMap.size;
+        typeMap.set(type.type, typeIndex);
+    }
+    const typeIndexEncoded = encodeBase62(typeIndex);
+    // if (type.type === 'null') return typeIndexEncoded
+    if (type.type === 'object') {
+        const [keys, types] = encodeObjectSchema(type.items, keyMap, typeMap);
+        let typeStr = `{${types}}`;
+        if ('optional' in type && type.optional) {
+            typeStr += `?`;
+        }
+        return [`{${keys}}`, typeStr];
+    }
+    if (type.type === 'array') {
+        const [keys, types] = encodeDataType(type.items, key, keyMap, typeMap);
+        let typeStr = `[${types}]`;
+        if ('optional' in type && type.optional) {
+            typeStr += `?`;
+        }
+        return [`[${keys}]`, typeStr];
+    }
+    if (!('optional' in type))
+        return typeIndexEncoded;
+    return `${typeIndexEncoded}${type.optional ? `?${type.default !== undefined ? `${JSON.stringify(type.default)}` : ''}` : ''}`;
+};
+const encodeDataType = (datatype, key, keyMap, typeMap) => {
+    let keys = [];
+    let types = [];
+    if ("types" in datatype) {
+        const midTypes = [];
+        const midKeys = [];
+        let isFirst = true;
+        for (let valueType of datatype.types) {
+            if (typeof valueType === 'string')
+                valueType = { type: valueType };
+            if ("optional" in valueType && valueType.optional && !isFirst)
+                throw new Error(`Only first type can be optional for multi-type`);
+            isFirst = false;
+            const returnValue = encodeSingleType(valueType, key, keyMap, typeMap);
+            if (typeof returnValue === 'string') {
+                midTypes.push(returnValue);
+                midKeys.push(key);
+                continue;
+            }
+            const [vKey, vType] = returnValue;
+            midKeys.push(`${key}${vKey}`);
+            midTypes.push(`${vType}`);
+        }
+        types.push(midTypes.join('|'));
+        keys.push(midKeys.join('|'));
+    }
+    else {
+        const returnValue = encodeSingleType(datatype, key, keyMap, typeMap);
+        if (typeof returnValue === 'string') {
+            keys.push(key);
+            types.push(encodeSingleType(datatype, key, keyMap, typeMap));
+        }
+        else {
+            const [vKey, vType] = returnValue;
+            keys.push(`${key}${vKey}`);
+            types.push(`${vType}`);
+        }
+    }
+    return [keys, types];
+};
+// OPTIMIZATION 2 & 5: Map-based lookups + pre-sorted keys
+const encodeObjectSchema = (schema, keyMap, typeMap) => {
+    let keys = [];
+    let types = [];
+    // OPTIMIZATION 5: Pre-sort keys once (avoid Object.entries tuple allocation)
+    const sortedKeys = Object.keys(schema).sort();
+    for (const key of sortedKeys) {
+        const value = schema[key];
+        // OPTIMIZATION 2: Use Map for O(1) lookup instead of indexOf O(n)
+        let keyIndex = keyMap.get(key);
+        if (keyIndex === undefined) {
+            keyIndex = keyMap.size;
+            keyMap.set(key, keyIndex);
+        }
+        const keyIndexEncoded = encodeBase62(keyIndex);
+        const [k, t] = encodeDataType(value, keyIndexEncoded, keyMap, typeMap);
+        keys.push(...k);
+        types.push(...t);
+    }
+    return [keys.join(','), types.join(',')];
+};
+export const encodeSchema = (schema) => {
+    const keyMap = new Map();
+    const typeMap = new Map();
+    const [keys, types] = encodeObjectSchema(schema, keyMap, typeMap);
+    const keyList = Array.from(keyMap.entries()).sort((a, b) => a[1] - b[1]).map(([k]) => k);
+    const typeList = Array.from(typeMap.entries()).sort((a, b) => a[1] - b[1]).map(([k]) => k);
+    return `${keyList.join(',')}\n${typeList.join(',')}\n${keys}\n${types}`;
+};
+const decodeObjectSchemaFromStrings = (keyList, typeList, keysEncoded, typesEncoded) => {
+    const keyTokens = splitTopLevel(keysEncoded, ',');
+    const typeTokens = splitTopLevel(typesEncoded, ',');
+    if (keyTokens.length !== typeTokens.length) {
+        throw new Error('Invalid schema string: keys/types length mismatch');
+    }
+    const out = {};
+    for (let i = 0; i < keyTokens.length; i++) {
+        const keyToken = keyTokens[i];
+        const typeToken = typeTokens[i];
+        const [keyIndex] = parseLeadingBase62(keyToken);
+        const keyName = keyList[keyIndex];
+        if (keyName === undefined)
+            throw new Error(`Invalid schema string: unknown key index ${keyIndex}`);
+        out[keyName] = decodeDataTypeFromTokens(keyList, typeList, keyToken, typeToken);
+    }
+    return out;
+};
+const splitTopLevel = (input, separator) => {
+    if (!input)
+        return [];
+    const parts = [];
+    let start = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === '{')
+            braceDepth++;
+        else if (ch === '}')
+            braceDepth--;
+        else if (ch === '[')
+            bracketDepth++;
+        else if (ch === ']')
+            bracketDepth--;
+        if (braceDepth === 0 && bracketDepth === 0 && ch === separator) {
+            parts.push(input.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(input.slice(start));
+    return parts;
+};
+const parseLeadingBase62 = (input) => {
+    let i = 0;
+    while (i < input.length && BASE62_CHARS.indexOf(input[i]) !== -1) {
+        i++;
+    }
+    if (i === 0)
+        throw new Error(`Invalid schema token: expected leading index, got: ${input}`);
+    const encoded = input.slice(0, i);
+    return [decodeBase62(encoded), i];
+};
+const stripWrapper = (input, open, close) => {
+    if (!input.startsWith(open) || !input.endsWith(close)) {
+        throw new Error(`Invalid schema token: expected ${open}...${close}, got: ${input}`);
+    }
+    return input.slice(1, -1);
+};
+const decodeDataTypeFromTokens = (keyList, typeList, keyToken, typeToken) => {
+    const typeParts = splitTopLevel(typeToken, '|');
+    if (typeParts.length > 1) {
+        const keyParts = splitTopLevel(keyToken, '|');
+        if (keyParts.length !== typeParts.length) {
+            throw new Error('Invalid schema string: multi-type keys/types length mismatch');
+        }
+        return {
+            types: typeParts.map((t, idx) => decodeSingleTypeFromTokens(keyList, typeList, keyParts[idx], t))
+        };
+    }
+    return decodeSingleTypeFromTokens(keyList, typeList, keyToken, typeToken);
+};
+const decodeSingleTypeFromTokens = (keyList, typeList, keyToken, typeToken) => {
+    if (typeToken.startsWith('{')) {
+        const braceEnd = typeToken.lastIndexOf('}');
+        if (braceEnd === -1)
+            throw new Error(`Invalid schema token: expected } in ${typeToken}`);
+        const [keyIndex, keyIndexLen] = parseLeadingBase62(keyToken);
+        const innerKeys = stripWrapper(keyToken.slice(keyIndexLen), '{', '}');
+        const innerTypes = typeToken.slice(1, braceEnd);
+        let out = {
+            type: 'object',
+            items: decodeObjectSchemaFromStrings(keyList, typeList, innerKeys, innerTypes)
+        };
+        const optionalPart = typeToken.slice(braceEnd + 1);
+        if (optionalPart.startsWith('?')) {
+            out.optional = true;
+        }
+        return out;
+    }
+    if (typeToken.startsWith('[')) {
+        const bracketEnd = typeToken.lastIndexOf(']');
+        if (bracketEnd === -1)
+            throw new Error(`Invalid schema token: expected ] in ${typeToken}`);
+        const [keyIndex, keyIndexLen] = parseLeadingBase62(keyToken);
+        const keySuffix = keyToken.slice(keyIndexLen);
+        const innerKeys = stripWrapper(keySuffix, '[', ']');
+        const innerTypes = typeToken.slice(1, bracketEnd);
+        const innerKeyTokens = splitTopLevel(innerKeys, ',');
+        const innerTypeTokens = splitTopLevel(innerTypes, ',');
+        if (innerKeyTokens.length !== 1 || innerTypeTokens.length !== 1) {
+            throw new Error('Invalid schema string: array item encoding malformed');
+        }
+        let out = {
+            type: 'array',
+            items: decodeDataTypeFromTokens(keyList, typeList, innerKeyTokens[0], innerTypeTokens[0])
+        };
+        const optionalPart = typeToken.slice(bracketEnd + 1);
+        if (optionalPart.startsWith('?')) {
+            out.optional = true;
+        }
+        return out;
+    }
+    const [typeIndexRaw, optionalRaw] = typeToken.split('?', 2);
+    const typeIndex = decodeBase62(typeIndexRaw);
+    const resolvedType = typeList[typeIndex];
+    if (!resolvedType)
+        throw new Error(`Invalid schema string: unknown type index ${typeIndex}`);
+    if (optionalRaw === undefined)
+        return { type: resolvedType };
+    const out = { type: resolvedType, optional: true };
+    if (optionalRaw.length)
+        out.default = JSON.parse(optionalRaw);
+    return out;
+};
+export const decodeSchemaString = (schemaString) => {
+    const lines = schemaString.split(/\r?\n/);
+    if (lines.length < 4 || lines.length > 5)
+        throw new Error('Invalid schema string: expected 4 or 5 lines');
+    let metadata = '';
+    if (lines.length === 5) {
+        metadata = lines.shift();
+    }
+    const keyList = lines[0].length ? lines[0].split(',') : [];
+    const typeList = lines[1].length ? lines[1].split(',') : [];
+    const keysEncoded = lines[2] ?? '';
+    const typesEncoded = lines[3] ?? '';
+    const schema = decodeObjectSchemaFromStrings(keyList, typeList, keysEncoded, typesEncoded);
+    return [schema, metadata];
+};