@dialecte/core 0.1.22 → 0.2.1

package/dist/store/index.d.ts

@@ -1,3 +1,4 @@
-export type { Store, ChangeLogEntry, StorageOptions } from './store.types';
-export { DexieStore } from './dexie-store';
+export type { Store, ChangeLogEntry, ChangeLogMeta, RecordSchema } from './store.types';
+export * from './local';
+export { TABLE_DOCUMENTS, TABLE_CHANGELOG, TABLE_META, TABLE_RECORD_PREFIX, recordTableName, DOCUMENTS_SCHEMA, CHANGELOG_SCHEMA, META_SCHEMA, } from './store.constants';
 //# sourceMappingURL=index.d.ts.map

package/dist/store/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACvF,cAAc,SAAS,CAAA;AACvB,OAAO,EACN,eAAe,EACf,eAAe,EACf,UAAU,EACV,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,GACX,MAAM,mBAAmB,CAAA"}

package/dist/store/local/dexie-store.d.ts

@@ -0,0 +1,74 @@
+import { default as Dexie } from 'dexie';
+import { Store, ChangeLogEntry, RecordSchema } from '../store.types';
+import { DexieStoreOptions } from './types';
+import { DocumentRecord } from '../../project';
+import { AnyRawRecord, RecordPatch } from '../../types';
+/**
+ * Translate a backend-agnostic RecordSchema into Dexie's schema DSL string.
+ *
+ * Dexie format: '++primaryKey, field1, field2, [compound1+compound2], *arrayField'
+ */
+export declare function buildDexieSchema(schema: RecordSchema): string;
+/**
+ * DexieStore — IndexedDB-backed Store implementation via Dexie.
+ *
+ * Manages partitioned tables: one `xel_{documentId}` per registered file.
+ * Dynamic schema versioning via close/reopen with version bump.
+ *
+ * Constructor takes the project name and optionally a RecordSchema from the dialecte config.
+ */
+export declare class DexieStore implements Store {
+    readonly name: string;
+    private db;
+    private schemaVersion;
+    private readonly dexieRecordSchema;
+    /** In-memory file registry - avoids bootstrap connections during close/reopen */
+    private knownDocuments;
+    /** Serialization lock for schema-changing operations */
+    private schemaLock;
+    constructor(projectName: string, options?: DexieStoreOptions);
+    open(): Promise<void>;
+    close(): void;
+    destroy(): Promise<void>;
+    registerDocument(file: DocumentRecord): Promise<void>;
+    getDocument(documentId: string): Promise<DocumentRecord | undefined>;
+    getDocuments(): Promise<DocumentRecord[]>;
+    updateDocument(documentId: string, updates: Partial<Pick<DocumentRecord, 'name' | 'metadata'>>): Promise<void>;
+    removeDocument(documentId: string): Promise<void>;
+    get(id: string, documentId?: string): Promise<AnyRawRecord | undefined>;
+    getByDocumentId(documentId: string): Promise<AnyRawRecord[]>;
+    getByTagNameInDocument(tagName: string, documentId: string): Promise<AnyRawRecord[]>;
+    bulkWrite(documentId: string, ops: {
+        creates?: AnyRawRecord[];
+        updates?: RecordPatch[];
+        deletes?: string[];
+    }): Promise<void>;
+    commit(params: {
+        documentId: string;
+        creates: AnyRawRecord[];
+        updates: AnyRawRecord[];
+        deletes: string[];
+        onProgress: (current: number, total: number) => void;
+    }): Promise<void>;
+    undo(documentId: string): Promise<void>;
+    redo(documentId: string): Promise<void>;
+    getChangeLog(documentId: string): Promise<ChangeLogEntry[]>;
+    /**
+     * Expose the underlying Dexie instance.
+     * Useful for legacy compatibility layers and advanced testing.
+     */
+    getDatabaseInstance(): Dexie;
+    private getHead;
+    private setHead;
+    /** Build Dexie stores object from current knownDocuments */
+    private buildStores;
+    /** Close DB, bump version, reopen with updated schema */
+    private reopenWithNewSchema;
+    /** Serialize schema-changing operations */
+    private withSchemaLock;
+    /**
+     * Resolve the Dexie table name for a documentId.
+     */
+    private resolveTableName;
+}
+//# sourceMappingURL=dexie-store.d.ts.map

package/dist/store/local/dexie-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dexie-store.d.ts","sourceRoot":"","sources":["../../../src/store/local/dexie-store.ts"],"names":[],"mappings":"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"}

package/dist/store/local/index.d.ts

@@ -0,0 +1,3 @@
+export { DexieStore } from './dexie-store';
+export type { DexieStoreOptions } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/store/local/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/store/local/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA"}

package/dist/store/local/types.d.ts

@@ -0,0 +1,6 @@
+import { RecordSchema } from '../store.types';
+export type DexieStoreOptions = {
+    /** Backend-agnostic record schema. Comes from dialecteConfig.recordSchema */
+    recordSchema?: RecordSchema;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/store/local/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/store/local/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C,MAAM,MAAM,iBAAiB,GAAG;IAC/B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,YAAY,CAAA;CAC3B,CAAA"}

package/dist/store/resolve-store.d.ts

@@ -0,0 +1,9 @@
+import { StorageParam } from '../project/types';
+import { Store } from '.';
+import { AnyDialecteConfig } from '../types';
+/**
+ * Resolve the Store instance from open params.
+ * 'local' creates a DexieStore; 'custom' passes through the user-provided store.
+ */
+export declare function resolveStore<GenericConfig extends AnyDialecteConfig>(name: string, storage: StorageParam, config: GenericConfig): Store;
+//# sourceMappingURL=resolve-store.d.ts.map

package/dist/store/resolve-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-store.d.ts","sourceRoot":"","sources":["../../src/store/resolve-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,aAAa,SAAS,iBAAiB,EACnE,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,aAAa,GACnB,KAAK,CAMP"}

package/dist/store/store.constants.d.ts

@@ -0,0 +1,18 @@
+import { RecordSchema } from './store.types';
+/** System table: file registry */
+export declare const TABLE_DOCUMENTS = "_documents";
+/** System table: per-file changelog entries */
+export declare const TABLE_CHANGELOG = "_changeLog";
+/** System table: metadata (schema version, per-file heads) */
+export declare const TABLE_META = "_meta";
+/** Prefix for per-file record tables */
+export declare const TABLE_RECORD_PREFIX = "xel_";
+/** Derive the record table name for a given documentId */
+export declare function recordTableName(documentId: string): string;
+/** Schema for the _files registry table */
+export declare const DOCUMENTS_SCHEMA: RecordSchema;
+/** Schema for the _changeLog table */
+export declare const CHANGELOG_SCHEMA: RecordSchema;
+/** Schema for the _meta table */
+export declare const META_SCHEMA: RecordSchema;
+//# sourceMappingURL=store.constants.d.ts.map

package/dist/store/store.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.constants.d.ts","sourceRoot":"","sources":["../../src/store/store.constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAIjD,kCAAkC;AAClC,eAAO,MAAM,eAAe,eAAe,CAAA;AAE3C,+CAA+C;AAC/C,eAAO,MAAM,eAAe,eAAe,CAAA;AAE3C,8DAA8D;AAC9D,eAAO,MAAM,UAAU,UAAU,CAAA;AAEjC,wCAAwC;AACxC,eAAO,MAAM,mBAAmB,SAAS,CAAA;AAEzC,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE1D;AAID,2CAA2C;AAC3C,eAAO,MAAM,gBAAgB,EAAE,YAK9B,CAAA;AAED,sCAAsC;AACtC,eAAO,MAAM,gBAAgB,EAAE,YAM9B,CAAA;AAED,iCAAiC;AACjC,eAAO,MAAM,WAAW,EAAE,YAKzB,CAAA"}

package/dist/store/store.types.d.ts

@@ -1,44 +1,89 @@
-import { AnyRawRecord } from '../types';
+import { DocumentRecord } from '../project/types';
+import { AnyRawRecord, RecordPatch } from '../types';
+/**
+ * RecordSchema — backend-agnostic index declaration for record tables.
+ *
+ * Each dialecte declares what fields to index. Store implementations
+ * translate this into their native format (Dexie DSL, SQL DDL, Mongo indexes, etc.).
+ */
+export type RecordSchema = {
+    /** Primary key field name */
+    primaryKey: string;
+    /** Auto-increment primary key (e.g. Dexie ++id, SQL AUTOINCREMENT) */
+    autoIncrement?: boolean;
+    /** Single-field indexes */
+    indexes: string[];
+    /** Compound indexes (multiple fields queried together) */
+    compoundIndexes: string[][];
+    /** Array field indexes (per-element lookup: Dexie multi-entry, Mongo multikey, SQL junction/GIN) */
+    arrayIndexes: string[];
+};
 /**
  * Store — the database port.
  *
  * Abstracts persistence so Document/Transaction don't couple to IndexedDB.
- * Implement DexieStore for production, InMemoryStore for tests.
+ * Implement DexieStore for IndexedDB, or any other backend (SQLite, Mongo, InMemory).
  *
+ * All record operations are document-scoped via documentId.
  * Not generic on Config — stores raw records as-is.
  * Type narrowing lives in Document/Transaction, not here.
  */
 export interface Store {
     /** Unique identifier for this store — used to scope the BroadcastChannel */
-    name: string;
-    /** Get a single record by primary key */
-    get(id: string): Promise<AnyRawRecord | undefined>;
-    /** Get all records with a given tagName */
-    getByTagName(tagName: string): Promise<AnyRawRecord[]>;
-    /** Atomic commit — all-or-nothing write */
-    commit(params: {
-        creates: AnyRawRecord[];
-        updates: AnyRawRecord[];
-        deletes: string[];
-        onProgress: (current: number, total: number) => void;
-    }): Promise<void>;
-    /** Wipe all records */
-    clear(): Promise<void>;
+    readonly name: string;
     /** Open the connection (if not already open) */
     open(): Promise<void>;
     /** Close the connection */
     close(): void;
     /** Delete the database entirely (not just clear — remove from browser) */
     destroy(): Promise<void>;
-    /** Undo the last committed change. No-op when at the beginning of history. */
-    undo(): Promise<void>;
-    /** Redo the next change. No-op when at the end of history. */
-    redo(): Promise<void>;
-    /** Return all changelog entries in ascending sequenceNumber order */
-    getChangeLog(): Promise<ChangeLogEntry[]>;
+    /** Register a new document — creates its backing storage partition */
+    registerDocument(file: DocumentRecord): Promise<void>;
+    /** Get a document record by id */
+    getDocument(documentId: string): Promise<DocumentRecord | undefined>;
+    /** Get all registered documents */
+    getDocuments(): Promise<DocumentRecord[]>;
+    /** Update document metadata (name, metadata) */
+    updateDocument(documentId: string, updates: Partial<Pick<DocumentRecord, 'name' | 'metadata'>>): Promise<void>;
+    /** Remove a document and all its records (O(1) table clear) */
+    removeDocument(documentId: string): Promise<void>;
+    /** Get a single record by primary key. documentId optimizes lookup when known. */
+    get(id: string, documentId?: string): Promise<AnyRawRecord | undefined>;
+    /** Get all records belonging to a document */
+    getByDocumentId(documentId: string): Promise<AnyRawRecord[]>;
+    /** Get records matching a tagName within a specific document */
+    getByTagNameInDocument(tagName: string, documentId: string): Promise<AnyRawRecord[]>;
+    /** Bulk write - atomic creates/updates/deletes bypassing changelog. For import pipeline. */
+    bulkWrite(documentId: string, ops: {
+        creates?: AnyRawRecord[];
+        updates?: RecordPatch[];
+        deletes?: string[];
+    }): Promise<void>;
+    /** Atomic commit — all-or-nothing write scoped to a document */
+    commit(params: {
+        documentId: string;
+        creates: AnyRawRecord[];
+        updates: AnyRawRecord[];
+        deletes: string[];
+        onProgress: (current: number, total: number) => void;
+    }): Promise<void>;
+    /** Undo the last committed change for a document. No-op at beginning of history. */
+    undo(documentId: string): Promise<void>;
+    /** Redo the next change for a document. No-op at end of history. */
+    redo(documentId: string): Promise<void>;
+    /** Return changelog entries for a document in ascending sequenceNumber order */
+    getChangeLog(documentId: string): Promise<ChangeLogEntry[]>;
+    /**
+     * Expose the underlying database instance.
+     * Type depends on the implementation (e.g. Dexie for DexieStore).
+     * Cast at the call site when the concrete store type is known.
+     */
+    getDatabaseInstance(): unknown;
 }
 export type ChangeLogEntry = {
-    id: string;
+    /** Auto-increment primary key (assigned by Dexie) */
+    id: number;
+    documentId: string;
     sequenceNumber: number;
     timestamp: number;
     operations: {
@@ -50,16 +95,9 @@ export type ChangeLogEntry = {
         deletes: AnyRawRecord[];
     };
 };
-/** Single-row metadata record stored in the _meta table */
+/** Per-file head stored in _meta table */
 export type ChangeLogMeta = {
-    key: 'head';
+    key: string;
     value: number;
 };
-export type StorageOptions = {
-    type: 'local';
-    databaseName: string;
-} | {
-    type: 'custom';
-    store: Store;
-};
 //# sourceMappingURL=store.types.d.ts.map

package/dist/store/store.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.types.d.ts","sourceRoot":"","sources":["../../src/store/store.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C;;;;;;;;GAQG;AACH,MAAM,WAAW,KAAK;IACrB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAA;IAEZ,yCAAyC;IACzC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAA;IAElD,2CAA2C;IAC3C,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;IAEtD,2CAA2C;IAC3C,MAAM,CAAC,MAAM,EAAE;QACd,OAAO,EAAE,YAAY,EAAE,CAAA;QACvB,OAAO,EAAE,YAAY,EAAE,CAAA;QACvB,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;KACpD,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEjB,uBAAuB;IACvB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAEtB,gDAAgD;IAChD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAErB,2BAA2B;IAC3B,KAAK,IAAI,IAAI,CAAA;IAEb,0EAA0E;IAC1E,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAExB,8EAA8E;IAC9E,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAErB,8DAA8D;IAC9D,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAErB,qEAAqE;IACrE,YAAY,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAAA;CACzC;AAED,MAAM,MAAM,cAAc,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE;QACX,OAAO,EAAE,YAAY,EAAE,CAAA;QACvB,OAAO,EAAE;YAAE,MAAM,EAAE,YAAY,CAAC;YAAC,KAAK,EAAE,YAAY,CAAA;SAAE,EAAE,CAAA;QACxD,OAAO,EAAE,YAAY,EAAE,CAAA;KACvB,CAAA;CACD,CAAA;AAED,2DAA2D;AAC3D,MAAM,MAAM,aAAa,GAAG;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,cAAc,GACvB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAA"}
+{"version":3,"file":"store.types.d.ts","sourceRoot":"","sources":["../../src/store/store.types.ts"],"names":[],"mappings":"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"}

package/dist/test/assert-xml/assert-xml.d.ts

@@ -3,7 +3,7 @@ import { Namespace } from '../../types';
 /**
  * Creates a pair of assertion functions pre-configured with a namespace resolver
  * derived from a prefix → URI map. Intended to be instantiated once per dialecte
- * (e.g. in scl test) and re-exported alongside createTestDialecte.
+ * (e.g. in scl test) and re-exported alongside createTestProject.
  */
 export declare function createXmlAssertions(params: {
     namespaces: Record<string, Namespace>;

package/dist/test/config.d.ts

@@ -2,6 +2,13 @@ export declare const IO_CONFIG: {
     readonly supportedFileExtensions: readonly [".xml"];
 };
 export declare const DATABASE_CONFIG: {
+    readonly recordSchema: {
+        readonly primaryKey: "id";
+        readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+        readonly compoundIndexes: [["id", "tagName"]];
+        readonly arrayIndexes: ["children.id", "children.tagName"];
+    };
+    /** @deprecated - kept for old io/ pipeline until Phase 5 removes it */
     readonly tables: {
         readonly xmlElements: {
             readonly name: "xmlElements";
@@ -193,6 +200,13 @@ export declare const TEST_DIALECTE_CONFIG: {
         readonly Root: readonly [];
     };
     readonly database: {
+        readonly recordSchema: {
+            readonly primaryKey: "id";
+            readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+            readonly compoundIndexes: [["id", "tagName"]];
+            readonly arrayIndexes: ["children.id", "children.tagName"];
+        };
+        /** @deprecated - kept for old io/ pipeline until Phase 5 removes it */
         readonly tables: {
             readonly xmlElements: {
                 readonly name: "xmlElements";

package/dist/test/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/test/config.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,SAAS;;CAEO,CAAA;AAG7B,eAAO,MAAM,eAAe;;;;;;;CAQO,CAAA;AAEnC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaK,CAAA;AAEtC,MAAM,MAAM,kBAAkB,GAAG,OAAO,oBAAoB,CAAA"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/test/config.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,SAAS;;CAEO,CAAA;AAG7B,eAAO,MAAM,eAAe;;;;;;;IAO3B,uEAAuE;;;;;;;CAQrC,CAAA;AAEnC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAVhC,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBlC,CAAA;AAEtC,MAAM,MAAM,kBAAkB,GAAG,OAAO,oBAAoB,CAAA"}

package/dist/test/create-test-dialecte.d.ts

@@ -1,35 +1,35 @@
 import { TEST_DIALECTE_CONFIG } from './config';
-import { Context, Document } from '../document';
+import { Project } from '../project';
+import { Document, Context } from '../document';
 import { AnyDialecteConfig, TransactionHooks } from '../types';
 type TestDialecteConfig = typeof TEST_DIALECTE_CONFIG;
+export type TestFile<GenericConfig extends AnyDialecteConfig> = {
+    documentId: string;
+    document: Document<GenericConfig>;
+};
+export type TestProjectResult<GenericConfig extends AnyDialecteConfig> = {
+    project: Project<GenericConfig>;
+    source: TestFile<GenericConfig>;
+    target?: TestFile<GenericConfig>;
+};
 /**
- * Create a Document instance from an XML string for testing.
- * Imports the XML into an IndexedDB database and returns a configured Document.
+ * Spin up a Project with source (and optionally target) file imported.
+ * Returns project + pre-opened documents. Caller owns lifecycle via project.destroy().
  */
-export declare function createTestDialecte<GenericConfig extends AnyDialecteConfig = TestDialecteConfig>(params: {
-    xmlString: string;
+export declare function createTestProject<GenericConfig extends AnyDialecteConfig = TestDialecteConfig>(params: {
+    sourceXml: string;
+    targetXml?: string;
     dialecteConfig?: GenericConfig;
     hooks?: TransactionHooks<GenericConfig>;
-}): Promise<{
-    document: Document<GenericConfig>;
-    databaseName: string;
-    cleanup: () => Promise<void>;
-    exportCurrentTest: (params?: {
-        extension?: GenericConfig['io']['supportedFileExtensions'][number];
-        withDatabaseIds?: boolean;
-    }) => Promise<{
-        xmlDocument: XMLDocument;
-        filename: string;
-    }>;
-}>;
+}): Promise<TestProjectResult<GenericConfig>>;
 /**
  * Create a Context directly from a databaseName for testing FP query functions.
- * The store is not pre-opened — call store.open() before use if needed,
- * or use DexieStore which opens lazily on first query.
+ * Opens the store to discover existing tables.
  */
 export declare function createTestContext<GenericConfig extends AnyDialecteConfig>(params: {
     databaseName: string;
     dialecteConfig: GenericConfig;
-}): Context<GenericConfig>;
+    documentId: string;
+}): Promise<Context<GenericConfig>>;
 export {};
 //# sourceMappingURL=create-test-dialecte.d.ts.map

package/dist/test/create-test-dialecte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-test-dialecte.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAM/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAErD;;;GAGG;AACH,wBAAsB,kBAAkB,CACvC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;CACvC,GAAG,OAAO,CAAC;IACX,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5B,iBAAiB,EAAE,CAAC,MAAM,CAAC,EAAE;QAC5B,SAAS,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;QAClE,eAAe,CAAC,EAAE,OAAO,CAAA;KACzB,KAAK,OAAO,CAAC;QAAE,WAAW,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7D,CAAC,CAuDD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EAAE,MAAM,EAAE;IAClF,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,aAAa,CAAA;CAC7B,GAAG,OAAO,CAAC,aAAa,CAAC,CAQzB"}
+{"version":3,"file":"create-test-dialecte.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAErD,MAAM,MAAM,QAAQ,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAC/D,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACxE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CAChC,CAAA;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;CACvC,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CA6C5C;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACxF,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,aAAa,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAalC"}

package/dist/test/run-test-cases.d.ts

@@ -185,6 +185,12 @@ export declare const runTestCases: TestRunner<{
         readonly Root: readonly [];
     };
     readonly database: {
+        readonly recordSchema: {
+            readonly primaryKey: "id";
+            readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+            readonly compoundIndexes: [["id", "tagName"]];
+            readonly arrayIndexes: ["children.id", "children.tagName"];
+        };
         readonly tables: {
             readonly xmlElements: {
                 readonly name: "xmlElements";

package/dist/test/run-test-cases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"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"}

package/dist/test/run-test-cases.type.d.ts

@@ -10,23 +10,19 @@ export type BaseXmlTestCase = BaseTestCase & {
     unexpectedQueries?: string[];
 };
 export type TestCases<GenericTestCase extends BaseXmlTestCase> = Record<string, GenericTestCase>;
-export type TestContext<GenericConfig extends AnyDialecteConfig> = {
-    document: Document<GenericConfig>;
-    databaseName: string;
-};
 export type ActParams<GenericConfig extends AnyDialecteConfig, GenericTestCase extends BaseXmlTestCase> = {
     testCase: GenericTestCase;
-    source: TestContext<GenericConfig>;
-    target?: TestContext<GenericConfig>;
+    source: Document<GenericConfig>;
+    target?: Document<GenericConfig>;
 };
 export type ActResult = {
-    assertDatabaseName: string;
+    assertOn?: 'source' | 'target';
     withDatabaseIds?: boolean;
 };
 export type TestRunner<GenericConfig extends AnyDialecteConfig> = {
     withExport<GenericTestCase extends BaseXmlTestCase>(params: {
         testCases: TestCases<GenericTestCase>;
-        act: (params: ActParams<GenericConfig, GenericTestCase>) => Promise<ActResult>;
+        act: (params: ActParams<GenericConfig, GenericTestCase>) => Promise<ActResult | void>;
         dialecteConfig?: GenericConfig;
         hooks?: TransactionHooks<GenericConfig>;
     }): void;

package/dist/test/run-test-cases.type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-test-cases.type.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,MAAM,MAAM,YAAY,GAAG;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAA;CACd,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,eAAe,SAAS,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAEhG,MAAM,MAAM,WAAW,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAClE,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,CACpB,aAAa,SAAS,iBAAiB,EACvC,eAAe,SAAS,eAAe,IACpC;IACH,QAAQ,EAAE,eAAe,CAAA;IACzB,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,UAAU,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACjE,UAAU,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC3D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAA;QAC9E,cAAc,CAAC,EAAE,aAAa,CAAA;QAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;KACvC,GAAG,IAAI,CAAA;IACR,aAAa,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC9D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;QACzE,cAAc,CAAC,EAAE,aAAa,CAAA;QAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;KACvC,GAAG,IAAI,CAAA;IACR,OAAO,CAAC,eAAe,SAAS,YAAY,EAC3C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1C,GAAG,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GACtC,IAAI,CAAA;CACP,CAAA"}
+{"version":3,"file":"run-test-cases.type.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,MAAM,MAAM,YAAY,GAAG;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAA;CACd,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,eAAe,SAAS,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAEhG,MAAM,MAAM,SAAS,CACpB,aAAa,SAAS,iBAAiB,EACvC,eAAe,SAAS,eAAe,IACpC;IACH,QAAQ,EAAE,eAAe,CAAA;IACzB,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,QAAQ,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,UAAU,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACjE,UAAU,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC3D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAA;QACrF,cAAc,CAAC,EAAE,aAAa,CAAA;QAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;KACvC,GAAG,IAAI,CAAA;IACR,aAAa,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC9D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;QACzE,cAAc,CAAC,EAAE,aAAa,CAAA;QAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;KACvC,GAAG,IAAI,CAAA;IACR,OAAO,CAAC,eAAe,SAAS,YAAY,EAC3C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1C,GAAG,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GACtC,IAAI,CAAA;CACP,CAAA"}

package/dist/test/test-record.d.ts

@@ -210,6 +210,12 @@ export declare const createTestRecord: {
                 readonly Root: readonly [];
             };
             readonly database: {
+                readonly recordSchema: {
+                    readonly primaryKey: "id";
+                    readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+                    readonly compoundIndexes: [["id", "tagName"]];
+                    readonly arrayIndexes: ["children.id", "children.tagName"];
+                };
                 readonly tables: {
                     readonly xmlElements: {
                         readonly name: "xmlElements";
@@ -2350,6 +2356,12 @@ export declare const createTestRecord: {
             readonly Root: readonly [];
         };
         readonly database: {
+            readonly recordSchema: {
+                readonly primaryKey: "id";
+                readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+                readonly compoundIndexes: [["id", "tagName"]];
+                readonly arrayIndexes: ["children.id", "children.tagName"];
+            };
             readonly tables: {
                 readonly xmlElements: {
                     readonly name: "xmlElements";
@@ -4492,6 +4504,12 @@ export declare const createTestRecord: {
                 readonly Root: readonly [];
             };
             readonly database: {
+                readonly recordSchema: {
+                    readonly primaryKey: "id";
+                    readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+                    readonly compoundIndexes: [["id", "tagName"]];
+                    readonly arrayIndexes: ["children.id", "children.tagName"];
+                };
                 readonly tables: {
                     readonly xmlElements: {
                         readonly name: "xmlElements";
@@ -6632,6 +6650,12 @@ export declare const createTestRecord: {
             readonly Root: readonly [];
         };
         readonly database: {
+            readonly recordSchema: {
+                readonly primaryKey: "id";
+                readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+                readonly compoundIndexes: [["id", "tagName"]];
+                readonly arrayIndexes: ["children.id", "children.tagName"];
+            };
             readonly tables: {
                 readonly xmlElements: {
                     readonly name: "xmlElements";
@@ -8774,6 +8798,12 @@ export declare const createTestRecord: {
                 readonly Root: readonly [];
             };
             readonly database: {
+                readonly recordSchema: {
+                    readonly primaryKey: "id";
+                    readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+                    readonly compoundIndexes: [["id", "tagName"]];
+                    readonly arrayIndexes: ["children.id", "children.tagName"];
+                };
                 readonly tables: {
                     readonly xmlElements: {
                         readonly name: "xmlElements";
@@ -10914,6 +10944,12 @@ export declare const createTestRecord: {
             readonly Root: readonly [];
         };
         readonly database: {
+            readonly recordSchema: {
+                readonly primaryKey: "id";
+                readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+                readonly compoundIndexes: [["id", "tagName"]];
+                readonly arrayIndexes: ["children.id", "children.tagName"];
+            };
             readonly tables: {
                 readonly xmlElements: {
                     readonly name: "xmlElements";
@@ -13056,6 +13092,12 @@ export declare const createTestRecord: {
                 readonly Root: readonly [];
             };
             readonly database: {
+                readonly recordSchema: {
+                    readonly primaryKey: "id";
+                    readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+                    readonly compoundIndexes: [["id", "tagName"]];
+                    readonly arrayIndexes: ["children.id", "children.tagName"];
+                };
                 readonly tables: {
                     readonly xmlElements: {
                         readonly name: "xmlElements";
@@ -15196,6 +15238,12 @@ export declare const createTestRecord: {
             readonly Root: readonly [];
         };
         readonly database: {
+            readonly recordSchema: {
+                readonly primaryKey: "id";
+                readonly indexes: ["tagName", "parent.id", "parent.tagName"];
+                readonly compoundIndexes: [["id", "tagName"]];
+                readonly arrayIndexes: ["children.id", "children.tagName"];
+            };
             readonly tables: {
                 readonly xmlElements: {
                     readonly name: "xmlElements";