@dialecte/core 0.1.6 → 0.1.7

package/dist/index.js

@@ -1,5 +1,5 @@
-import { D as s, a, Q as r, T as i, b as o, c as l, d, f as c, g as u, h as b, e as n, j as A, k as g, l as m, m as D, n as R, p, q as T, r as f, s as E, t as x, u as F, v as h, w as k, y as B, z as C, i as _, A as y, B as I, C as O, o as j } from "./index-Cl4q6wr5.js";
-import { E as U, t as X } from "./index-CqwLClK7.js";
+import { D as s, a, Q as r, T as i, b as o, c as l, d, f as c, g as u, h as b, e as n, j as A, k as g, l as m, m as D, n as R, p, q as T, r as f, s as E, t as x, u as F, v as h, w as k, y as B, z as C, i as _, A as y, B as I, C as O, o as j } from "./index-BcfPvtox.js";
+import { E as U, t as X } from "./index-BCraeB5h.js";
 export {
   s as DexieStore,
   a as Document,

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

@@ -1,12 +1,32 @@
 import { TEST_DIALECTE_CONFIG } from './config';
-import { BaseTestCase, TestCases, ActParams, ActResult } from './run-test-cases.type';
+import { BaseTestCase, BaseXmlTestCase, TestCases, ActParams, ActResult } from './run-test-cases.type';
 import { AnyDialecteConfig } from '../types';
 type TestDialecteConfig = typeof TEST_DIALECTE_CONFIG;
 export declare function createMockRandomUUID(): () => `${string}-${string}-${string}-${string}-${string}`;
-export declare function runTestCases<GenericTestCase extends BaseTestCase, GenericConfig extends AnyDialecteConfig = TestDialecteConfig>(params: {
+export declare function runXmlTestCases<GenericTestCase extends BaseXmlTestCase, GenericConfig extends AnyDialecteConfig = TestDialecteConfig>(params: {
     testCases: TestCases<GenericTestCase>;
     act: (params: ActParams<GenericConfig, GenericTestCase>) => Promise<ActResult>;
     dialecteConfig?: GenericConfig;
 }): void;
+export declare function runXmlTestCases<GenericTestCase extends BaseXmlTestCase, GenericConfig extends AnyDialecteConfig = TestDialecteConfig>(params: {
+    testCases: TestCases<GenericTestCase>;
+    act: (params: ActParams<GenericConfig, GenericTestCase>) => Promise<void>;
+    dialecteConfig?: GenericConfig;
+}): void;
+/**
+ * Runs a record of synchronous test cases where each key is the test description.
+ * Use for pure-function table-driven tests that need no XML or async setup.
+ *
+ * @example
+ * ```ts
+ * runTestCases<{ input: number; expected: number }>({
+ *   'positive → doubled': { input: 2, expected: 4 },
+ *   'zero → zero':        { input: 0, expected: 0 },
+ * }, ({ input, expected }) => {
+ *   expect(double(input)).toBe(expected)
+ * })
+ * ```
+ */
+export declare function runTestCases<GenericTestCase extends BaseTestCase>(testCases: Record<string, GenericTestCase>, act: (testCase: GenericTestCase) => void): void;
 export {};
 //# sourceMappingURL=run-test-cases.d.ts.map

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":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAO/C,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAC1F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAMrD,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAKhG;AAID,wBAAgB,YAAY,CAC3B,eAAe,SAAS,YAAY,EACpC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAA;IAC9E,cAAc,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,IAAI,CA0DP"}
+{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAO/C,OAAO,KAAK,EACX,YAAY,EACZ,eAAe,EACf,SAAS,EACT,SAAS,EACT,SAAS,EACT,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAMrD,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAKhG;AAID,wBAAgB,eAAe,CAC9B,eAAe,SAAS,eAAe,EACvC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAA;IAC9E,cAAc,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,IAAI,CAAA;AACR,wBAAgB,eAAe,CAC9B,eAAe,SAAS,eAAe,EACvC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACzE,cAAc,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,IAAI,CAAA;AAgFR;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,eAAe,SAAS,YAAY,EAChE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1C,GAAG,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GACtC,IAAI,CAKN"}

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

@@ -1,18 +1,20 @@
 import { Document } from '../document';
 import { AnyDialecteConfig } from '../types';
 export type BaseTestCase = {
+    only?: boolean;
+};
+export type BaseXmlTestCase = BaseTestCase & {
     sourceXml: string;
     targetXml?: string;
-    only?: boolean;
     expectedQueries?: string[];
     unexpectedQueries?: string[];
 };
-export type TestCases<GenericTestCase extends BaseTestCase> = Record<string, GenericTestCase>;
+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 BaseTestCase> = {
+export type ActParams<GenericConfig extends AnyDialecteConfig, GenericTestCase extends BaseXmlTestCase> = {
     testCase: GenericTestCase;
     source: TestContext<GenericConfig>;
     target?: TestContext<GenericConfig>;

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,MAAM,SAAS,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG;IAC1B,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,eAAe,SAAS,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAE7F,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,YAAY,IACjC;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"}
+{"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,MAAM,SAAS,CAAA;AAEhD,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"}

package/dist/test.js

@@ -1,153 +1,153 @@
-import { expect as l, it as x } from "vitest";
-import { x as E, D as b, i as X, o as q, e as f } from "./index-Cl4q6wr5.js";
-import { D as S, s as D, l as L, k as T } from "./standardizing-27Zk5ECm.js";
-function h(a) {
-  const e = w(a);
+import { expect as o, it as d } from "vitest";
+import { x as b, D as X, i as q, o as S, e as v } from "./index-BcfPvtox.js";
+import { DIALECTE_DEV_NAMESPACE as D, standardizeRecord as T, toTreeRecord as L, toTrackedRecord as w } from "./helpers.js";
+function E(a) {
+  const e = O(a);
   if (e.length === 0)
     return [a];
   const t = [];
-  for (const A of e)
-    t.push(a.slice(0, A));
+  for (const B of e)
+    t.push(a.slice(0, B));
   return t.push(a), t;
 }
-function w(a) {
+function O(a) {
   const e = [];
-  let t = 0, A = 0, B = null;
-  for (let r = 0; r < a.length; r++) {
-    const _ = a[r];
-    if (B) {
-      _ === B && (B = null);
+  let t = 0, B = 0, A = null;
+  for (let _ = 0; _ < a.length; _++) {
+    const r = a[_];
+    if (A) {
+      r === A && (A = null);
       continue;
     }
-    if (_ === '"' || _ === "'") {
-      B = _;
+    if (r === '"' || r === "'") {
+      A = r;
       continue;
     }
-    if (_ === "[") {
+    if (r === "[") {
       t++;
       continue;
     }
-    if (_ === "]") {
+    if (r === "]") {
       t--;
       continue;
     }
-    if (_ === "(") {
-      A++;
+    if (r === "(") {
+      B++;
       continue;
     }
-    if (_ === ")") {
-      A--;
+    if (r === ")") {
+      B--;
       continue;
     }
-    if (!(t > 0 || A > 0) && _ === "/") {
-      if (r === 0) {
-        a[r + 1] === "/" && r++;
+    if (!(t > 0 || B > 0) && r === "/") {
+      if (_ === 0) {
+        a[_ + 1] === "/" && _++;
         continue;
       }
-      if (e.length === 0 && r === 1 && a[0] === "/")
+      if (e.length === 0 && _ === 1 && a[0] === "/")
         continue;
-      e.push(r), a[r + 1] === "/" && r++;
+      e.push(_), a[_ + 1] === "/" && _++;
     }
   }
   return e;
 }
-function O(a) {
-  const { namespaces: e } = a, t = g(e);
+function g(a) {
+  const { namespaces: e } = a, t = R(e);
   return {
-    assertExpectedElementQueries(A) {
-      M({ ...A, nsResolver: t });
+    assertExpectedElementQueries(B) {
+      M({ ...B, nsResolver: t });
     },
-    assertUnexpectedElementQueries(A) {
-      k({ ...A, nsResolver: t });
+    assertUnexpectedElementQueries(B) {
+      k({ ...B, nsResolver: t });
     }
   };
 }
 function M(a) {
-  const { xmlDocument: e, queries: t, nsResolver: A } = a;
-  for (const B of t)
-    R({ xmlDocument: e, xpath: B, nsResolver: A });
+  const { xmlDocument: e, queries: t, nsResolver: B } = a;
+  for (const A of t)
+    V({ xmlDocument: e, xpath: A, nsResolver: B });
 }
-function g(a) {
+function R(a) {
   return (e) => e ? a[e]?.uri ?? null : null;
 }
 function k(a) {
-  const { xmlDocument: e, queries: t, nsResolver: A } = a;
-  for (const B of t)
-    V({ xmlDocument: e, xpath: B, nsResolver: A });
+  const { xmlDocument: e, queries: t, nsResolver: B } = a;
+  for (const A of t)
+    F({ xmlDocument: e, xpath: A, nsResolver: B });
 }
-function R(a) {
-  const { xmlDocument: e, xpath: t, nsResolver: A } = a, B = h(t);
-  let r = null, _ = 0;
-  for (let C = 0; C < B.length; C++) {
-    const s = B[C], c = e.evaluate(
+function V(a) {
+  const { xmlDocument: e, xpath: t, nsResolver: B } = a, A = E(t);
+  let _ = null, r = 0;
+  for (let C = 0; C < A.length; C++) {
+    const s = A[C], c = e.evaluate(
       s,
       e,
-      A ?? null,
+      B ?? null,
       XPathResult.FIRST_ORDERED_NODE_TYPE,
       null
     ).singleNodeValue;
     if (c) {
-      r = c, _ = C + 1;
+      _ = c, r = C + 1;
       continue;
     }
-    const i = C === 0 ? B[0] : t.slice(B[C - 1].length), n = _ === 0 ? `[No parent matched — failed from document root]
+    const u = C === 0 ? A[0] : t.slice(A[C - 1].length), i = r === 0 ? `[No parent matched — failed from document root]
   Document:
-${d({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${_}/${B.length}]:
-${r ? d({ xml: r.outerHTML }) : "(none)"}`;
-    l(
+${l({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${r}/${A.length}]:
+${_ ? l({ xml: _.outerHTML }) : "(none)"}`;
+    o(
       c,
       `Element not found in XML.
-  Failed at step ${C + 1}/${B.length}: ${i.trim()}
+  Failed at step ${C + 1}/${A.length}: ${u.trim()}
   Full XPath: ${t}
-  ${n}`
+  ${i}`
     ).toBeTruthy();
     return;
   }
 }
-function d(a) {
+function l(a) {
   const { xml: e } = a;
   try {
-    return E(e, { indentation: "  ", collapseContent: !0 });
+    return b(e, { indentation: "  ", collapseContent: !0 });
   } catch {
     return e;
   }
 }
-function V(a) {
-  const { xmlDocument: e, xpath: t, nsResolver: A } = a, B = h(t);
-  if (B.length > 1) {
+function F(a) {
+  const { xmlDocument: e, xpath: t, nsResolver: B } = a, A = E(t);
+  if (A.length > 1) {
     let C = null;
-    for (let s = 0; s < B.length - 1; s++) {
-      const u = B[s], i = e.evaluate(
-        u,
+    for (let s = 0; s < A.length - 1; s++) {
+      const n = A[s], u = e.evaluate(
+        n,
         e,
-        A ?? null,
+        B ?? null,
         XPathResult.FIRST_ORDERED_NODE_TYPE,
         null
-      ).singleNodeValue, n = s === 0 ? B[0] : t.slice(B[s - 1].length), v = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
-${C ? d({ xml: C.outerHTML }) : "(none)"}`;
-      l(
-        i,
+      ).singleNodeValue, i = s === 0 ? A[0] : t.slice(A[s - 1].length), m = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
+${C ? l({ xml: C.outerHTML }) : "(none)"}`;
+      o(
+        u,
         `Absent assertion is unreliable: ancestor step does not exist.
   The query passes but for the wrong reason — an ancestor is missing, not the target element.
-  Missing at step ${s + 1}/${B.length}: ${n.trim()}
+  Missing at step ${s + 1}/${A.length}: ${i.trim()}
   Full XPath: ${t}
-  ${v}`
-      ).toBeTruthy(), C = i;
+  ${m}`
+      ).toBeTruthy(), C = u;
     }
   }
-  const _ = e.evaluate(
+  const r = e.evaluate(
     t,
     e,
-    A ?? null,
+    B ?? null,
     XPathResult.FIRST_ORDERED_NODE_TYPE,
     null
   ).singleNodeValue;
-  l(
-    _,
+  o(
+    r,
     `Element should NOT exist in XML but was found.
   XPath: ${t}
   Found:
-${_ ? d({ xml: _.outerHTML }) : "(none)"}`
+${r ? l({ xml: r.outerHTML }) : "(none)"}`
   ).toBeFalsy();
 }
 const p = {
@@ -155,12 +155,12 @@ const p = {
     uri: "http://dialecte.dev/XML/DEFAULT",
     prefix: ""
   },
-  dev: S,
+  dev: D,
   ext: {
     uri: "http://dialecte.dev/XML/DEV-EXT",
     prefix: "ext"
   }
-}, ee = `xmlns="${p.default.uri}"`, te = `xmlns:${p.dev.prefix}="${p.dev.uri}"`, ae = `xmlns:${p.ext.prefix}="${p.ext.uri}"`, F = [
+}, te = `xmlns="${p.default.uri}"`, ae = `xmlns:${p.dev.prefix}="${p.dev.uri}"`, Be = `xmlns:${p.ext.prefix}="${p.ext.uri}"`, N = [
   "A",
   "AAAA_1",
   "AAAA_2",
@@ -192,7 +192,7 @@ const p = {
   "CC_2",
   "CC_3",
   "Root"
-], N = {
+], U = {
   A: ["AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -224,7 +224,7 @@ const p = {
   CC_2: ["CCC_1", "CCC_2", "CCC_3"],
   CC_3: ["CCC_1", "CCC_2", "CCC_3"],
   Root: ["A", "B", "C"]
-}, U = {
+}, y = {
   A: ["Root"],
   AAAA_1: ["AAA_1", "AAA_2", "AAA_3"],
   AAAA_2: ["AAA_1", "AAA_2", "AAA_3"],
@@ -256,7 +256,7 @@ const p = {
   CC_2: ["C"],
   CC_3: ["C"],
   Root: []
-}, y = {
+}, I = {
   A: ["AAAA_1", "AAAA_2", "AAAA_3", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -319,7 +319,7 @@ const p = {
     "CC_2",
     "CC_3"
   ]
-}, I = {
+}, $ = {
   A: ["Root"],
   AAAA_1: ["A", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3", "Root"],
   AAAA_2: ["A", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3", "Root"],
@@ -351,7 +351,7 @@ const p = {
   CC_2: ["C", "Root"],
   CC_3: ["C", "Root"],
   Root: []
-}, $ = "Root", P = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], Q = {
+}, P = "Root", Q = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], z = {
   A: {
     aA: "",
     bA: "",
@@ -506,7 +506,7 @@ const p = {
     "ext:root": "",
     root: ""
   }
-}, z = {
+}, G = {
   A: {
     tag: "A",
     namespace: { prefix: "", uri: "http://dialecte.dev/XML/DEFAULT" },
@@ -1508,49 +1508,49 @@ const p = {
       }
     ]
   }
-}, G = {
-  supportedFileExtensions: [".xml"]
 }, H = {
+  supportedFileExtensions: [".xml"]
+}, Y = {
   tables: {
     xmlElements: {
       name: "xmlElements",
       schema: "id, tagName, [id+tagName], parent.id, parent.tagName, *children.id, *children.tagName"
     }
   }
-}, o = {
-  rootElementName: $,
-  singletonElements: P,
-  elements: F,
+}, x = {
+  rootElementName: P,
+  singletonElements: Q,
+  elements: N,
   namespaces: p,
-  attributes: Q,
-  children: N,
-  parents: U,
-  descendants: y,
-  ancestors: I,
-  database: H,
-  io: G,
-  definition: z,
+  attributes: z,
+  children: U,
+  parents: y,
+  descendants: I,
+  ancestors: $,
+  database: Y,
+  io: H,
+  definition: G,
   hooks: {}
 };
-async function m(a) {
-  const { xmlString: e, dialecteConfig: t = o } = a, A = `test-${crypto.randomUUID()}.xml`, B = new File([e], A, { type: "text/xml" }), _ = (await X({
-    files: [B],
+async function h(a) {
+  const { xmlString: e, dialecteConfig: t = x } = a, B = `test-${crypto.randomUUID()}.xml`, A = new File([e], B, { type: "text/xml" }), r = (await q({
+    files: [A],
     dialecteConfig: t,
     useCustomRecordsIds: !0
-  }))[0], C = q({
+  }))[0], C = S({
     config: t,
-    storage: { type: "local", databaseName: _ }
+    storage: { type: "local", databaseName: r }
   });
   return {
     document: C,
-    databaseName: _,
+    databaseName: r,
     exportCurrentTest: async (c) => {
-      const { extension: i = t.io.supportedFileExtensions[0], withDatabaseIds: n = !1 } = c || {};
-      return f({
+      const { extension: u = t.io.supportedFileExtensions[0], withDatabaseIds: i = !1 } = c || {};
+      return v({
         dialecteConfig: t,
-        databaseName: _,
-        extension: i,
-        withDatabaseIds: n
+        databaseName: r,
+        extension: u,
+        withDatabaseIds: i
       });
     },
     cleanup: async () => {
@@ -1558,87 +1558,99 @@ async function m(a) {
     }
   };
 }
-function Be(a) {
+function Ae(a) {
   const { databaseName: e, dialecteConfig: t } = a;
   return {
-    store: new b(e, t),
+    store: new X(e, t),
     recordCache: /* @__PURE__ */ new Map(),
     stagedOperations: []
   };
 }
-const Y = crypto.randomUUID.bind(crypto);
-function j() {
+const j = crypto.randomUUID.bind(crypto);
+function Z() {
   let a = 0;
   return function() {
     return `${a++}`;
   };
 }
-function Ae(a) {
+function Ce(a) {
   const {
     testCases: e,
     act: t,
-    dialecteConfig: A = o
-  } = a, { assertExpectedElementQueries: B, assertUnexpectedElementQueries: r } = O({
-    namespaces: A.namespaces
+    dialecteConfig: B = x
+  } = a, { assertExpectedElementQueries: A, assertUnexpectedElementQueries: _ } = g({
+    namespaces: B.namespaces
   });
-  for (const [_, C] of Object.entries(e))
-    (C.only ? x.only : x)(_, async () => {
-      crypto.randomUUID = Y;
-      const u = await m({
+  for (const [r, C] of Object.entries(e))
+    (C.only ? d.only : d)(r, async () => {
+      crypto.randomUUID = j;
+      const n = await h({
         xmlString: C.sourceXml,
-        dialecteConfig: A
-      }), c = C.targetXml ? await m({ xmlString: C.targetXml, dialecteConfig: A }) : void 0;
+        dialecteConfig: B
+      }), c = C.targetXml ? await h({ xmlString: C.targetXml, dialecteConfig: B }) : void 0;
       try {
-        crypto.randomUUID = j();
-        const { assertDatabaseName: i } = await t({
+        crypto.randomUUID = Z();
+        const i = (await t({
           testCase: C,
-          source: { document: u.document, databaseName: u.databaseName },
+          source: { document: n.document, databaseName: n.databaseName },
           target: c ? { document: c.document, databaseName: c.databaseName } : void 0
-        }), { xmlDocument: n } = await f({
-          dialecteConfig: A,
-          databaseName: i,
-          extension: A.io.supportedFileExtensions[0],
-          withDatabaseIds: !0
-        });
-        C.expectedQueries?.length && B({ xmlDocument: n, queries: C.expectedQueries }), C.unexpectedQueries?.length && r({ xmlDocument: n, queries: C.unexpectedQueries });
+        }))?.assertDatabaseName;
+        if (C.expectedQueries?.length || C.unexpectedQueries?.length) {
+          if (!i)
+            throw new Error(
+              `Test "${r}": assertDatabaseName is required when expectedQueries or unexpectedQueries are defined`
+            );
+          const { xmlDocument: f } = await v({
+            dialecteConfig: B,
+            databaseName: i,
+            extension: B.io.supportedFileExtensions[0],
+            withDatabaseIds: !0
+          });
+          C.expectedQueries?.length && A({ xmlDocument: f, queries: C.expectedQueries }), C.unexpectedQueries?.length && _({ xmlDocument: f, queries: C.unexpectedQueries });
+        }
       } finally {
-        await u.cleanup(), await c?.cleanup();
+        await n.cleanup(), await c?.cleanup();
       }
     });
 }
-function Z(a) {
+function re(a, e) {
+  for (const [t, B] of Object.entries(a))
+    (B.only ? d.only : d)(t, () => e(B));
+}
+function J(a) {
   function e(t) {
-    const { record: A, type: B = "raw" } = t, r = D({ record: A, dialecteConfig: a });
-    switch (B) {
+    const { record: B, type: A = "raw" } = t, _ = T({ record: B, dialecteConfig: a });
+    switch (A) {
       case "raw":
-        return r;
+        return _;
       case "tracked":
-        return T({ record: r });
+        return w({ record: _ });
       case "tree":
-        return L({ record: r });
+        return L({ record: _ });
       default:
-        throw new Error(`Unsupported record type: ${B}`);
+        throw new Error(`Unsupported record type: ${A}`);
     }
   }
   return e;
 }
-const Ce = Z(o);
+const _e = J(x);
 export {
-  H as DATABASE_CONFIG,
+  Y as DATABASE_CONFIG,
   p as DIALECTE_NAMESPACES,
-  G as IO_CONFIG,
-  o as TEST_DIALECTE_CONFIG,
-  ee as XMLNS_DEFAULT_NAMESPACE,
-  te as XMLNS_DEV_NAMESPACE,
-  ae as XMLNS_EXT_NAMESPACE,
+  H as IO_CONFIG,
+  x as TEST_DIALECTE_CONFIG,
+  te as XMLNS_DEFAULT_NAMESPACE,
+  ae as XMLNS_DEV_NAMESPACE,
+  Be as XMLNS_EXT_NAMESPACE,
   M as assertExpectedElementQueries,
   k as assertUnexpectedElementQueries,
-  j as createMockRandomUUID,
-  Be as createTestContext,
-  m as createTestDialecte,
-  Ce as createTestRecord,
-  Z as createTestRecordFactory,
-  O as createXmlAssertions,
-  Ae as runTestCases,
-  h as splitXpathIntoSteps
+  Z as createMockRandomUUID,
+  Ae as createTestContext,
+  h as createTestDialecte,
+  _e as createTestRecord,
+  J as createTestRecordFactory,
+  g as createXmlAssertions,
+  re as runTestCases,
+  Ce as runXmlTestCases,
+  E as splitXpathIntoSteps
 };

package/dist/types/dialecte-config.d.ts

@@ -2,7 +2,7 @@ import { AnyDefinition } from './definition';
 import { ImportOptions, ExportOptions, IOHooks } from './io';
 import { Operation } from './operations';
 import { Namespace, RawRecord, TreeRecord } from './records';
-import { Context } from '../document';
+import { Context, CloneMapping } from '../document';
 export type RawDialecteConfig<GenericElementNames extends readonly string[], GenericRootElement extends GenericElementNames[number], GenericAttributes extends Record<string, any>, GenericChildren extends Record<string, readonly string[]>, GenericParents extends Record<string, readonly string[]>, GenericDescendants extends Record<string, readonly string[]>, GenericAncestors extends Record<string, readonly string[]>> = {
     rootElementName: GenericRootElement;
     singletonElements?: readonly GenericElementNames[number][];
@@ -51,6 +51,34 @@ export type TransactionHooks = {
         parentRecord: RawRecord<GenericConfig, GenericParentElement>;
         context: Context<GenericConfig>;
     }) => Promise<Operation<GenericConfig>[]>;
+    /**
+     * Called after deepClone completes all recursive cloning.
+     * Receives the full source→target mapping. Return additional operations to stage
+     */
+    afterDeepClone?: <GenericConfig extends AnyDialecteConfig>(params: {
+        mappings: CloneMapping<GenericConfig>[];
+        context: Context<GenericConfig>;
+    }) => Promise<Operation<GenericConfig>[]>;
+    /**
+     * Called after a record is updated (attributes or value changed).
+     * Return additional operations to stage (e.g., update path attrs on dependent refs).
+     */
+    afterUpdated?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+        oldRecord: RawRecord<GenericConfig, GenericElement>;
+        newRecord: RawRecord<GenericConfig, GenericElement>;
+        context: Context<GenericConfig>;
+    }) => Promise<Operation<GenericConfig>[]>;
+    /**
+     * Called before a record and its subtree are staged for deletion.
+     * Root and all descendants are still live in context at this point.
+     *
+     * Return additional operations to stage (e.g., clear or delete ref elements
+     * pointing to this record or any of its descendants).
+     */
+    beforeDelete?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+        record: RawRecord<GenericConfig, GenericElement>;
+        context: Context<GenericConfig>;
+    }) => Promise<Operation<GenericConfig>[]>;
 };
 export type DatabaseConfig = Readonly<{
     tables: {