@plitzi/sdk-schema 0.32.5 → 0.32.6

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @plitzi/sdk-schema
 
+## 0.32.6
+
+### Patch Changes
+
+- v0.32.6
+- Updated dependencies
+  - @plitzi/sdk-shared@0.32.6
+  - @plitzi/sdk-style@0.32.6
+
 ## 0.32.5
 
 ### Patch Changes

package/dist/SchemaReducer.d.ts

@@ -16,6 +16,7 @@ export declare const SchemaActions: {
     readonly SCHEMA_MOVE_ELEMENT: "SCHEMA_MOVE_ELEMENT";
     readonly SCHEMA_CLONE_ELEMENT: "SCHEMA_CLONE_ELEMENT";
     readonly SCHEMA_UPDATE_ELEMENT: "SCHEMA_UPDATE_ELEMENT";
+    readonly SCHEMA_UPDATE_ELEMENTS: "SCHEMA_UPDATE_ELEMENTS";
     readonly SCHEMA_ADD_TEMPLATE: "SCHEMA_ADD_TEMPLATE";
     readonly SCHEMA_UPDATE_SETTINGS: "SCHEMA_UPDATE_SETTINGS";
 };
@@ -81,6 +82,9 @@ export type SchemaReducerActions = SchemaReducerActionsBase & ({
 } | {
     type: 'SCHEMA_UPDATE_ELEMENT';
     element: Element;
+} | {
+    type: 'SCHEMA_UPDATE_ELEMENTS';
+    elements: Element[];
 } | {
     type: 'SCHEMA_UPDATE_SETTINGS';
     path: string;

package/dist/SchemaReducer.mjs

@@ -19,6 +19,7 @@ var a = {
 	SCHEMA_MOVE_ELEMENT: "SCHEMA_MOVE_ELEMENT",
 	SCHEMA_CLONE_ELEMENT: "SCHEMA_CLONE_ELEMENT",
 	SCHEMA_UPDATE_ELEMENT: "SCHEMA_UPDATE_ELEMENT",
+	SCHEMA_UPDATE_ELEMENTS: "SCHEMA_UPDATE_ELEMENTS",
 	SCHEMA_ADD_TEMPLATE: "SCHEMA_ADD_TEMPLATE",
 	SCHEMA_UPDATE_SETTINGS: "SCHEMA_UPDATE_SETTINGS"
 }, o = (o, s) => {
@@ -127,9 +128,15 @@ var a = {
 			});
 		}
 		case a.SCHEMA_UPDATE_ELEMENT: {
-			let { element: e } = s;
-			return i(o, (t) => {
-				r(t.flat, e.id, e);
+			let { element: t } = s;
+			return i(o, (n) => {
+				e.updateElement(n.flat, t);
+			});
+		}
+		case a.SCHEMA_UPDATE_ELEMENTS: {
+			let { elements: t } = s;
+			return i(o, (n) => {
+				t.forEach((t) => e.updateElement(n.flat, t));
 			});
 		}
 		case a.SCHEMA_UPDATE_SETTINGS: {

package/dist/helpers/FlatMap.d.ts

@@ -9,9 +9,21 @@ declare class FlatMap {
     variables: Schema['variables'];
     constructor(props?: FlatMapProps);
     addElement: (data: Element, to: Element["id"], dropPosition?: DropPosition, initialItems?: Record<Element["id"], Element>) => boolean;
+    /** Refuses a rename onto an unusable idRef: two elements answering to the same name make every binding and
+     *  interaction written against it resolve to whichever one is found first. Only a change is checked, so an
+     *  element already stored with a bad ref stays editable.
+     *
+     *  A rename that IS accepted carries its wiring with it: the idRef is the key bindings and interactions target,
+     *  so every reference to the old name across the space is repointed here. Doing it at the single point every
+     *  writer goes through is what keeps a rename from silently unwiring the element. */
     updateElement: (element?: Element) => boolean;
     moveElement: (from: Element["id"], to: Element["id"], elementId: Element["id"], dropPosition?: DropPosition) => boolean;
     getElement: (elementId: Element["id"]) => Element<Record<string, unknown>>;
+    /** Every idRef currently in use, so a newly minted one stays unique across the space. */
+    takenIdRefs: () => Set<string>;
+    /** Why an idRef cannot be used here (charset or a clash), or null when it is free. `ignoreElementId` exempts the
+     *  element being edited, so re-saving an element its own ref is not a conflict. */
+    idRefConflict: (idRef: string, ignoreElementId?: Element["id"]) => string | null;
     cloneElements: (elementId: Element["id"], parentId?: Element["id"], rootId?: Element["id"], excludeRoot?: boolean) => {
         acum: Record<Element["id"], Element>;
         item?: Element;
@@ -47,6 +59,8 @@ declare class FlatMap {
         item?: Element;
     };
     static removeElement: (flat: Schema["flat"], elementId: Element["id"], removePage?: boolean) => boolean;
+    static takenIdRefs: (flat: Schema["flat"]) => Set<string>;
+    static idRefConflict: (flat: Schema["flat"], idRef: string, ignoreElementId?: Element["id"]) => string | null;
     static addVariables: (schemaVariables: Schema["variables"], variables: Schema["variables"]) => boolean;
     static addVariable: (schemaVariables: Schema["variables"], variable: SchemaVariable) => boolean;
     static updateVariable: (schemaVariables: Schema["variables"], variable: SchemaVariable) => boolean;

package/dist/helpers/FlatMap.mjs

@@ -1,11 +1,12 @@
-import { validateSchema as e } from "./schemaValidator.mjs";
-import { get as t, set as n } from "@plitzi/plitzi-ui/helpers";
-import { generateID as r } from "@plitzi/sdk-shared/helpers/utils";
-import { EMPTY_SCHEMA as i, VARIABLE_REGEX as a } from "@plitzi/sdk-shared/schema/schemaConstants";
-import { EMPTY_STYLE_SCHEMA as o } from "@plitzi/sdk-shared/style/styleConstants";
-import s from "@plitzi/sdk-style/helpers/calculateInheriting";
+import { idRefConflict as e, idRefsUsable as t, remapClonedRefs as n, repointIdRefs as r, takenIdRefs as i } from "./idRef.mjs";
+import { validateSchema as a } from "./schemaValidator.mjs";
+import { get as o, set as s } from "@plitzi/plitzi-ui/helpers";
+import { generateID as c } from "@plitzi/sdk-shared/helpers/utils";
+import { EMPTY_SCHEMA as l, VARIABLE_REGEX as u } from "@plitzi/sdk-shared/schema/schemaConstants";
+import { EMPTY_STYLE_SCHEMA as d } from "@plitzi/sdk-shared/style/styleConstants";
+import f from "@plitzi/sdk-style/helpers/calculateInheriting";
 //#region src/helpers/FlatMap.ts
-var c = class {
+var p = class {
 	flat;
 	variables;
 	constructor(e = {}) {
@@ -13,95 +14,101 @@ var c = class {
 		if (!t) throw Error("Flat is required");
 		this.flat = t, this.variables = n ?? [];
 	}
-	addElement = (e, r, i = "inside", a = {}) => {
-		let o;
-		if (i !== "custom") {
-			if (i !== "inside") {
-				let e = this.flat[r];
+	addElement = (e, n, r = "inside", i = {}) => {
+		let a;
+		if (r !== "custom") {
+			if (r !== "inside") {
+				let e = this.flat[n];
 				if (!e) return !1;
-				e.definition.parentId && (o = this.flat[e.definition.parentId]);
-			} else o = this.flat[r];
-			if (!o) return !1;
+				e.definition.parentId && (a = this.flat[e.definition.parentId]);
+			} else a = this.flat[n];
+			if (!a) return !1;
 		}
-		if (i !== "custom" && (this.flat[e.id] || !Array.isArray(t(o, "definition.items"))) || !this.isValidElement(e)) return !1;
-		switch (n(this.flat, e.id, e), i) {
+		if (r !== "custom" && (this.flat[e.id] || !Array.isArray(o(a, "definition.items"))) || !this.isValidElement(e) || !t(this.flat, [e, ...Object.values(i)])) return !1;
+		switch (s(this.flat, e.id, e), r) {
 			case "left":
 			case "top": {
-				let i = t(o, "definition.items", []);
-				if (i.splice(i.findIndex((e) => e === r), 0, e.id), !o) return !1;
-				n(this.flat, `${o.id}.definition.items`, i), n(this.flat, `${e.id}.definition.parentId`, o.id), n(this.flat, `${e.id}.definition.rootId`, o.definition.rootId);
+				let t = o(a, "definition.items", []);
+				if (t.splice(t.findIndex((e) => e === n), 0, e.id), !a) return !1;
+				s(this.flat, `${a.id}.definition.items`, t), s(this.flat, `${e.id}.definition.parentId`, a.id), s(this.flat, `${e.id}.definition.rootId`, a.definition.rootId);
 				break;
 			}
 			case "right":
 			case "bottom": {
-				let i = t(o, "definition.items", []);
-				if (i.splice(i.findIndex((e) => e === r) + 1, 0, e.id), !o) return !1;
-				n(this.flat, `${o.id}.definition.items`, i), n(this.flat, `${e.id}.definition.parentId`, o.id), n(this.flat, `${e.id}.definition.rootId`, o.definition.rootId);
+				let t = o(a, "definition.items", []);
+				if (t.splice(t.findIndex((e) => e === n) + 1, 0, e.id), !a) return !1;
+				s(this.flat, `${a.id}.definition.items`, t), s(this.flat, `${e.id}.definition.parentId`, a.id), s(this.flat, `${e.id}.definition.rootId`, a.definition.rootId);
 				break;
 			}
 			case "inside": {
-				let i = t(o, "definition.items", []);
-				if (!o) return !1;
-				n(this.flat, `${r}.definition.items`, [...i, e.id]), n(this.flat, `${e.id}.definition.parentId`, r), n(this.flat, `${e.id}.definition.rootId`, o.definition.rootId);
+				let t = o(a, "definition.items", []);
+				if (!a) return !1;
+				s(this.flat, `${n}.definition.items`, [...t, e.id]), s(this.flat, `${e.id}.definition.parentId`, n), s(this.flat, `${e.id}.definition.rootId`, a.definition.rootId);
 				break;
 			}
 			case "custom": break;
 			default: return !1;
 		}
-		return Object.keys(a).length > 0 && Object.keys(a).forEach((e) => {
-			this.flat[e] = a[e];
+		return Object.keys(i).length > 0 && Object.keys(i).forEach((e) => {
+			this.flat[e] = i[e];
 		}), !0;
 	};
-	updateElement = (e) => !e || !this.flat[e.id] ? !1 : (this.flat[e.id] = e, !0);
-	moveElement = (e, r, i, a = "inside") => {
-		if (i === r || !this.flat[e]) return !1;
-		let o = this.flat[r];
-		if (!o) return !1;
-		let s = this.flat[r];
-		for (; s;) {
-			let e = t(s, "definition.parentId");
+	updateElement = (e) => {
+		if (!e || !this.flat[e.id]) return !1;
+		let n = this.flat[e.id].idRef, i = e.idRef !== n;
+		return i && !t(this.flat, [e]) ? !1 : i && n && e.idRef ? (this.flat[e.id] = structuredClone(e), r(this.flat, { [n]: e.idRef }), !0) : (this.flat[e.id] = e, !0);
+	};
+	moveElement = (e, t, n, r = "inside") => {
+		if (n === t || !this.flat[e]) return !1;
+		let i = this.flat[t];
+		if (!i) return !1;
+		let a = this.flat[t];
+		for (; a;) {
+			let e = o(a, "definition.parentId");
 			if (!e) break;
-			if (s.id === i) return !1;
-			s = this.flat[e];
+			if (a.id === n) return !1;
+			a = this.flat[e];
 		}
-		if (!s) return !1;
-		let c = t(this.flat, `${e}.definition.items`, []).filter((e) => e !== i);
+		if (!a) return !1;
+		let c = o(this.flat, `${e}.definition.items`, []).filter((e) => e !== n);
 		if ([
 			"left",
 			"top",
 			"right",
 			"bottom"
-		].includes(a)) {
-			if (!o.definition.parentId) return !1;
-			let s = this.flat[o.definition.parentId];
-			if (!s) return !1;
-			let l = t(s, "definition.items", []);
-			s.id === e && (l = c);
-			let u = l.findIndex((e) => e === r);
-			["right", "bottom"].includes(a) && u++, l.splice(u, 0, i), n(this.flat, `${e}.definition.items`, c), n(this.flat, `${s.id}.definition.items`, l), n(this.flat, `${i}.definition.parentId`, s.id);
-		} else if (a === "inside") {
-			if (!this.flat[r]) return !1;
-			let a = t(this.flat, `${r}.definition.items`, []);
-			e === r && (a = c), a = [...a, i], n(this.flat, `${e}.definition.items`, c), n(this.flat, `${r}.definition.items`, a), n(this.flat, `${i}.definition.parentId`, r);
+		].includes(r)) {
+			if (!i.definition.parentId) return !1;
+			let a = this.flat[i.definition.parentId];
+			if (!a) return !1;
+			let l = o(a, "definition.items", []);
+			a.id === e && (l = c);
+			let u = l.findIndex((e) => e === t);
+			["right", "bottom"].includes(r) && u++, l.splice(u, 0, n), s(this.flat, `${e}.definition.items`, c), s(this.flat, `${a.id}.definition.items`, l), s(this.flat, `${n}.definition.parentId`, a.id);
+		} else if (r === "inside") {
+			if (!this.flat[t]) return !1;
+			let r = o(this.flat, `${t}.definition.items`, []);
+			e === t && (r = c), r = [...r, n], s(this.flat, `${e}.definition.items`, c), s(this.flat, `${t}.definition.items`, r), s(this.flat, `${n}.definition.parentId`, t);
 		}
 		return !0;
 	};
-	getElement = (e) => t(this.flat, e);
-	cloneElements = (e, i = "", a = "", o = !1) => {
-		let s = {
+	getElement = (e) => o(this.flat, e);
+	takenIdRefs = () => i(this.flat);
+	idRefConflict = (t, n) => e(this.flat, t, n);
+	cloneElements = (e, t = "", r = "", i = !1) => {
+		let a = {
 			acum: {},
 			item: void 0
-		}, c = {}, l = this.flat[e];
-		if (!l) return s;
-		let u = [e, ...this.childTree(e)].reduce((e, t) => {
+		}, l = {}, u = this.flat[e];
+		if (!u) return a;
+		let d = this.takenIdRefs(), f = [e, ...this.childTree(e)].reduce((e, t) => {
 			let n = this.flat[t];
-			return n ? (c[n.id] = r(n.id), a ? {
+			return n ? (l[n.id] = c(n.id), r ? {
 				...e,
 				[n.id]: {
 					...n,
 					definition: {
 						...n.definition,
-						rootId: a
+						rootId: r
 					}
 				}
 			} : {
@@ -110,27 +117,27 @@ var c = class {
 			}) : e;
 		}, {});
 		try {
-			let t = JSON.stringify(u);
-			t = Object.keys(c).reduce((e, t) => e.replace(new RegExp(t, "g"), c[t]), t), s.acum = JSON.parse(t), s.item = s.acum[c[e]];
+			let t = JSON.stringify(f);
+			t = Object.keys(l).reduce((e, t) => e.replace(new RegExp(t, "g"), l[t]), t), a.acum = JSON.parse(t), a.item = a.acum[l[e]], n(a.acum, (e) => d.has(e));
 		} catch (e) {
 			return console.error("Error parsing elements", e), {
 				acum: {},
 				item: void 0
 			};
 		}
-		o && delete s.acum[c[e]];
-		let d = this.flat[i];
-		return (!d || !Array.isArray(t(d, "definition.items"))) && (i = t(d, "definition.parentId", t(l, "definition.parentId"))), i && n(s, "item.definition.parentId", i), s;
+		i && delete a.acum[l[e]];
+		let p = this.flat[t];
+		return (!p || !Array.isArray(o(p, "definition.items"))) && (t = o(p, "definition.parentId", o(u, "definition.parentId"))), t && s(a, "item.definition.parentId", t), a;
 	};
-	removeElement = (e, r = !1) => {
-		let i = this.flat[e];
-		if (!i || i.definition.type === "page" && !r || r && t(i, "attributes.default", !1)) return !1;
-		let a = t(i, "definition.items");
-		a && a.length > 0 && a.forEach((e) => this.removeElement(e));
-		let o = t(i, "definition.parentId"), s = o ? this.flat[o] : void 0;
-		if (o && s) {
-			let { definition: { items: t = [] } } = s;
-			n(s, "definition.items", t.filter((t) => t !== e)), this.flat[o] = s;
+	removeElement = (e, t = !1) => {
+		let n = this.flat[e];
+		if (!n || n.definition.type === "page" && !t || t && o(n, "attributes.default", !1)) return !1;
+		let r = o(n, "definition.items");
+		r && r.length > 0 && r.forEach((e) => this.removeElement(e));
+		let i = o(n, "definition.parentId"), a = i ? this.flat[i] : void 0;
+		if (i && a) {
+			let { definition: { items: t = [] } } = a;
+			s(a, "definition.items", t.filter((t) => t !== e)), this.flat[i] = a;
 		}
 		return delete this.flat[e], !0;
 	};
@@ -154,22 +161,22 @@ var c = class {
 	};
 	removeVariable = (e) => this.removeVariables([e]);
 	parentTree = (e) => {
-		let n = this.flat[e], r = [];
-		if (!n) return r;
+		let t = this.flat[e], n = [];
+		if (!t) return n;
 		do {
-			if (t(n, "definition.type") === "page") {
-				let e = t(n, "attributes.layout"), i = t(n, "attributes.layoutContainer");
-				e && i && r.push(i, ...this.parentTree(i));
+			if (o(t, "definition.type") === "page") {
+				let e = o(t, "attributes.layout"), r = o(t, "attributes.layoutContainer");
+				e && r && n.push(r, ...this.parentTree(r));
 			}
-			e !== n.id && r.push(n.id), n = t(this.flat, t(n, "definition.parentId"), void 0);
-		} while (n);
-		return r;
+			e !== t.id && n.push(t.id), t = o(this.flat, o(t, "definition.parentId"), void 0);
+		} while (t);
+		return n;
 	};
 	childTree = (e) => {
-		let n = this.flat[e];
-		if (!n) return [];
-		let r = [], i = t(n, "definition.items");
-		return i && i.forEach((e) => r.push(e, ...this.childTree(e))), r;
+		let t = this.flat[e];
+		if (!t) return [];
+		let n = [], r = o(t, "definition.items");
+		return r && r.forEach((e) => n.push(e, ...this.childTree(e))), n;
 	};
 	isValidElement = (e) => {
 		if (!e) return !1;
@@ -178,85 +185,85 @@ var c = class {
 		let { type: i, label: a, styleSelectors: o, rootId: s } = r;
 		return !(!i || a === void 0 || typeof o != "object" || s === void 0);
 	};
-	flatAsTemplate = (e, r, i = !1) => {
-		let a = {
-			...o,
+	flatAsTemplate = (e, t, n = !1) => {
+		let r = {
+			...d,
 			platform: {
 				desktop: {},
 				tablet: {},
 				mobile: {}
 			}
-		}, c = [];
-		if (!r) return {
+		}, i = [];
+		if (!t) return {
 			elements: {
 				acum: {},
 				item: void 0
 			},
-			elementsStyle: a,
-			variables: c
+			elementsStyle: r,
+			variables: i
 		};
-		let l = t(this.flat, r);
-		if (!l) return {
+		let a = o(this.flat, t);
+		if (!a) return {
 			elements: {
 				acum: {},
 				item: void 0
 			},
-			elementsStyle: a,
-			variables: c
+			elementsStyle: r,
+			variables: i
 		};
-		let u = this.cloneElements(r, l.definition.parentId);
-		return u.item ? (Object.values(u.acum).forEach((t) => {
-			let { id: r } = t;
-			if (n(u.acum, `${r}.definition.rootId`, u.item?.id), s(t, t.definition.type, this.flat, e.platform, {}, { includeSelf: !0 }).tree.forEach((t) => {
-				let { displayMode: n, name: r } = t;
-				!(r in a.platform[n]) && r in e.platform[n] && (a.platform[n][r] = e.platform[n][r]);
+		let c = this.cloneElements(t, a.definition.parentId);
+		return c.item ? (Object.values(c.acum).forEach((t) => {
+			let { id: n } = t;
+			if (s(c.acum, `${n}.definition.rootId`, c.item?.id), f(t, t.definition.type, this.flat, e.platform, {}, { includeSelf: !0 }).tree.forEach((t) => {
+				let { displayMode: n, name: i } = t;
+				!(i in r.platform[n]) && i in e.platform[n] && (r.platform[n][i] = e.platform[n][i]);
 			}), this.variables.length > 0) {
-				let t = this.getElementVariables(e, r, u.acum);
-				c = [...c, ...t];
+				let t = this.getElementVariables(e, n, c.acum);
+				i = [...i, ...t];
 			}
-		}), n(u.acum, `${u.item.id}.definition.parentId`, null), i && delete u.acum[u.item.id], c.length > 1 && (c = [...new Set(c)]), {
-			elements: u,
-			elementsStyle: a,
-			variables: c
+		}), s(c.acum, `${c.item.id}.definition.parentId`, null), n && delete c.acum[c.item.id], i.length > 1 && (i = [...new Set(i)]), {
+			elements: c,
+			elementsStyle: r,
+			variables: i
 		}) : {
 			elements: {
 				acum: {},
 				item: void 0
 			},
-			elementsStyle: a,
-			variables: c
+			elementsStyle: r,
+			variables: i
 		};
 	};
-	validate = () => e({
-		...i.schema,
+	validate = () => a({
+		...l.schema,
 		flat: this.flat,
 		variables: this.variables
 	});
 	isValid = () => this.validate().valid;
-	assertValid = (t) => {
-		let n = e({
-			...i.schema,
+	assertValid = (e) => {
+		let t = a({
+			...l.schema,
 			flat: this.flat,
 			variables: this.variables
 		});
-		if (!n.valid) {
-			let e = `Invalid schema${t ? ` (${t})` : ""}: ${n.errors.map((e) => e.message).join("; ")}`;
-			throw Error(e);
+		if (!t.valid) {
+			let n = `Invalid schema${e ? ` (${e})` : ""}: ${t.errors.map((e) => e.message).join("; ")}`;
+			throw Error(n);
 		}
 	};
-	getElementVariables = (e, n, r = this.flat, i = this.variables) => {
-		let o = [], s = t(r, `${n}.definition.styleSelectors`);
-		if (!s) return o;
-		let c = new RegExp(a, "g");
-		return Object.values(s).filter(Boolean).forEach((t) => {
+	getElementVariables = (e, t, n = this.flat, r = this.variables) => {
+		let i = [], a = o(n, `${t}.definition.styleSelectors`);
+		if (!a) return i;
+		let s = new RegExp(u, "g");
+		return Object.values(a).filter(Boolean).forEach((t) => {
 			Object.values(e.platform).forEach((e) => {
 				let n = e[t];
-				n && [...JSON.stringify(n.attributes).matchAll(c)].forEach((e) => {
-					let t = i.find((t) => t.name === e[1] || t.name === e[2]);
-					t && !o.find((e) => e.name === t.name) && o.push(t);
+				n && [...JSON.stringify(n.attributes).matchAll(s)].forEach((e) => {
+					let t = r.find((t) => t.name === e[1] || t.name === e[2]);
+					t && !i.find((e) => e.name === t.name) && i.push(t);
 				});
 			});
-		}), o;
+		}), i;
 	};
 	static getInstance = (e) => new this(e);
 	static addElement = (e, t, n, r = "inside", i = {}) => this.getInstance({ flat: e }).addElement(t, n, r, i);
@@ -265,6 +272,8 @@ var c = class {
 	static getElement = (e, t) => this.getInstance({ flat: e }).getElement(t);
 	static cloneElements = (e, t, n = "", r = "", i = !1) => this.getInstance({ flat: e }).cloneElements(t, n, r, i);
 	static removeElement = (e, t, n = !1) => this.getInstance({ flat: e }).removeElement(t, n);
+	static takenIdRefs = (e) => this.getInstance({ flat: e }).takenIdRefs();
+	static idRefConflict = (e, t, n) => this.getInstance({ flat: e }).idRefConflict(t, n);
 	static addVariables = (e, t) => this.getInstance({ variables: e }).addVariables(t);
 	static addVariable = (e, t) => this.getInstance({ variables: e }).addVariable(t);
 	static updateVariable = (e, t) => this.getInstance({ variables: e }).updateVariable(t);
@@ -287,15 +296,15 @@ var c = class {
 			variables: i
 		}).getElementVariables(t, n);
 	};
-	static validate = (t) => e(t);
-	static isValid = (t) => e(t).valid;
-	static assertValid = (t, n) => {
-		let r = e(t);
-		if (!r.valid) {
-			let e = `Invalid schema${n ? ` (${n})` : ""}: ${r.errors.map((e) => e.message).join("; ")}`;
+	static validate = (e) => a(e);
+	static isValid = (e) => a(e).valid;
+	static assertValid = (e, t) => {
+		let n = a(e);
+		if (!n.valid) {
+			let e = `Invalid schema${t ? ` (${t})` : ""}: ${n.errors.map((e) => e.message).join("; ")}`;
 			throw Error(e);
 		}
 	};
 };
 //#endregion
-export { c as default };
+export { p as default };

package/dist/helpers/idRef.d.ts

@@ -0,0 +1,34 @@
+import { Element } from '@plitzi/sdk-shared';
+/** True when an idRef is well formed: it starts with a letter and then carries letters, numbers, hyphens and
+ *  underscores. Leading letter keeps a source `<type>_<idRef>` a valid twig identifier. A '.' would split the
+ *  `<type>_<idRef>.<field>` source path and an interaction target lookup — so it is not allowed. A source name
+ *  uses the first '_' as separator between `<type>` and `<idRef>` (element types are camelCase with no underscore),
+ *  so underscores inside the idRef are unambiguous. A hyphen is allowed too: a source doubles as a twig token, and
+ *  `processTwig` resolves a hyphenated `<type>_<idRef>` through `_context` subscript access. */
+export declare const isValidIdRef: (idRef: string) => boolean;
+/** Every idRef currently in use, so a new one can be checked or minted against it. */
+export declare const takenIdRefs: (flat: Record<Element["id"], Element>) => Set<string>;
+/** Why `idRef` cannot be used in this schema, phrased for a person, or null when it is free and well formed.
+ *  `ignoreElementId` exempts the element being edited, so re-saving an element its own ref is not a conflict. */
+export declare const idRefConflict: (flat: Record<Element["id"], Element>, idRef: string, ignoreElementId?: Element["id"]) => string | null;
+/** Whether every idRef a write brings into a schema is usable: well formed, free — an element already stored never
+ *  clashes with itself — and not repeated inside the incoming set, which `idRefConflict` cannot see on its own
+ *  because those elements are not in `flat` yet. */
+export declare const idRefsUsable: (flat: Record<Element["id"], Element>, elements: Element[]) => boolean;
+/** A unique, charset-safe idRef for a new element: `<type>-<n>`, incrementing until `isTaken` says it is free.
+ *  The hyphen sits between two alphanumeric runs, so it is valid (never leading or trailing) and readable. */
+export declare const makeIdRef: (type: string, isTaken: (candidate: string) => boolean) => string;
+/** Apply an idRef renaming (old → new) across a set of elements: the idRef itself plus every reference written
+ *  against it — a binding's data `source`, its transformer params and `when`, and an interaction's target
+ *  `elementId`, params and `when`. A ref absent from the map is left alone, so references leaving this set keep
+ *  pointing outward, which is what callers want.
+ *
+ *  Ids are remapped by a blind string replace over the serialized tree (see `FlatMap.cloneElements`); that is safe
+ *  for a 24-char hex id but not for an idRef, which is short and human-readable — replacing "card-1" everywhere
+ *  would corrupt any label containing it. Hence this field-by-field pass: a plain `source` goes through
+ *  `remapSource`, embedded tokens (twig, transformer params, query-builder operands) through `remapTokensDeep`,
+ *  which only ever rewrites a full `<type>_<idRef>` token. */
+export declare const repointIdRefs: (elements: Record<Element["id"], Element>, mapRefs: Record<string, string>) => void;
+/** Give every element in a freshly cloned subtree a new idRef, so the copy wires to itself instead of to the
+ *  original it was cloned from. An element that had no idRef stays without one — a clone copies what is there. */
+export declare const remapClonedRefs: (elements: Record<Element["id"], Element>, isTaken: (ref: string) => boolean) => void;

package/dist/helpers/idRef.mjs

@@ -0,0 +1,72 @@
+//#region src/helpers/idRef.ts
+var e = /^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9_])?$/, t = (t) => e.test(t), n = (e) => {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of Object.values(e)) n.idRef && t.add(n.idRef);
+	return t;
+}, r = (e, n, r) => t(n) ? Object.values(e).find((e) => e.idRef === n && e.id !== r) ? `"${n}" is already used by another element in this space` : null : `"${n}" is not a valid reference: start with a letter, then letters, numbers, hyphens and underscores`, i = (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	for (let i of t) if (i.idRef) {
+		if (n.has(i.idRef) || r(e, i.idRef, i.id)) return !1;
+		n.add(i.idRef);
+	}
+	return !0;
+}, a = (e, t) => {
+	let n = e.replace(/[^A-Za-z0-9]/g, "") || "element", r = 1;
+	for (; t(`${n}-${r}`);) r += 1;
+	return `${n}-${r}`;
+}, o = (e, t) => {
+	let n = e.indexOf("."), r = n === -1 ? e : e.slice(0, n), i = r.indexOf("_");
+	if (i === -1) return e;
+	let a = t[r.slice(i + 1)];
+	return a ? `${r.slice(0, i + 1)}${a}${n === -1 ? "" : e.slice(n)}` : e;
+}, s = /([A-Za-z][A-Za-z0-9]*)_([A-Za-z][A-Za-z0-9_-]*)/g, c = (e, t) => e.replace(s, (e, n, r) => {
+	let i = t[r];
+	return i ? `${n}_${i}` : e;
+}), l = (e, t) => {
+	if (Array.isArray(e)) {
+		e.forEach((n, r) => {
+			if (typeof n == "string") {
+				let i = c(n, t);
+				i !== n && (e[r] = i);
+				return;
+			}
+			l(n, t);
+		});
+		return;
+	}
+	if (!e || typeof e != "object") return;
+	let n = e;
+	for (let [e, r] of Object.entries(n)) {
+		if (typeof r == "string") {
+			let i = c(r, t);
+			i !== r && (n[e] = i);
+			continue;
+		}
+		l(r, t);
+	}
+}, u = (e, t) => {
+	for (let n of Object.values(e)) {
+		n.idRef && t[n.idRef] && (n.idRef = t[n.idRef]);
+		for (let e of Object.values(n.definition.bindings ?? {})) for (let n of e) {
+			let e = o(n.source, t);
+			e !== n.source && (n.source = e), n.transformers && l(n.transformers, t), n.when && l(n.when, t);
+		}
+		for (let e of Object.values(n.definition.interactions ?? {})) {
+			if (e.elementId) {
+				let n = t[e.elementId];
+				n && (e.elementId = n);
+			}
+			l(e.params, t), e.when && l(e.when, t);
+		}
+	}
+}, d = (e, t) => {
+	let n = {}, r = /* @__PURE__ */ new Set();
+	for (let i of Object.values(e)) {
+		if (!i.idRef) continue;
+		let e = a(i.definition.type, (e) => t(e) || r.has(e));
+		r.add(e), n[i.idRef] = e;
+	}
+	u(e, n);
+};
+//#endregion
+export { r as idRefConflict, i as idRefsUsable, t as isValidIdRef, a as makeIdRef, d as remapClonedRefs, u as repointIdRefs, n as takenIdRefs };

package/dist/helpers/schemaValidator.mjs

@@ -1,111 +1,112 @@
+import { isValidIdRef as e } from "./idRef.mjs";
 //#region src/helpers/schemaValidator.ts
-var e = (e) => {
-	let t = [], n = [], { flat: r, pages: i, pageFolders: a, variables: o } = e, s = (e) => !!r[e], c = (e) => r[e], l = () => !r || typeof r != "object" ? (t.push({
+var t = (t) => {
+	let n = [], r = [], { flat: i, pages: a, pageFolders: o, variables: s } = t, c = (e) => !!i[e], l = (e) => i[e], u = () => !i || typeof i != "object" ? (n.push({
 		code: "INVALID_FLAT",
 		message: "Schema.flat must be a valid Record<string, Element>"
-	}), !1) : Array.isArray(i) ? Array.isArray(a) ? Array.isArray(o) ? !0 : (t.push({
+	}), !1) : Array.isArray(a) ? Array.isArray(o) ? Array.isArray(s) ? !0 : (n.push({
 		code: "INVALID_VARIABLES",
 		message: "Schema.variables must be an array"
-	}), !1) : (t.push({
+	}), !1) : (n.push({
 		code: "INVALID_PAGE_FOLDERS",
 		message: "Schema.pageFolders must be an array"
-	}), !1) : (t.push({
+	}), !1) : (n.push({
 		code: "INVALID_PAGES",
 		message: "Schema.pages must be an array of element IDs"
-	}), !1), u = () => {
-		Object.entries(r).forEach(([e, r]) => {
-			if (!r) {
-				t.push({
+	}), !1), d = () => {
+		Object.entries(i).forEach(([e, t]) => {
+			if (!t) {
+				n.push({
 					code: "NULL_ELEMENT",
 					message: `Element with id "${e}" is null or undefined`,
 					elementId: e
 				});
 				return;
 			}
-			if (!r.id) {
-				t.push({
+			if (!t.id) {
+				n.push({
 					code: "MISSING_ID",
 					message: `Element at key "${e}" has no id property`
 				});
 				return;
 			}
-			if (r.id !== e && t.push({
+			if (t.id !== e && n.push({
 				code: "ID_MISMATCH",
-				message: `Element id "${r.id}" doesn't match flat key "${e}"`,
+				message: `Element id "${t.id}" doesn't match flat key "${e}"`,
 				elementId: e
-			}), !r.definition) {
-				t.push({
+			}), !t.definition) {
+				n.push({
 					code: "MISSING_DEFINITION",
 					message: "Element missing definition",
 					elementId: e
 				});
 				return;
 			}
-			let { definition: i, attributes: a } = r;
-			i.type || t.push({
+			let { definition: i, attributes: a } = t;
+			i.type || n.push({
 				code: "MISSING_TYPE",
 				message: "Element missing definition.type",
 				elementId: e
-			}), i.label === void 0 && t.push({
+			}), i.label === void 0 && n.push({
 				code: "MISSING_LABEL",
 				message: "Element missing definition.label",
 				elementId: e
-			}), i.rootId || t.push({
+			}), i.rootId || n.push({
 				code: "MISSING_ROOT_ID",
 				message: "Element missing definition.rootId",
 				elementId: e
-			}), (!i.styleSelectors || typeof i.styleSelectors != "object") && t.push({
+			}), (!i.styleSelectors || typeof i.styleSelectors != "object") && n.push({
 				code: "MISSING_STYLE_SELECTORS",
 				message: "Element missing or invalid definition.styleSelectors",
 				elementId: e
-			}), a || n.push({
+			}), a || r.push({
 				code: "MISSING_ATTRIBUTES",
 				message: "Element has no attributes",
 				elementId: e
-			}), i.items && (Array.isArray(i.items) ? i.items.forEach((n, r) => {
-				s(n) || t.push({
+			}), i.items && (Array.isArray(i.items) ? i.items.forEach((t, r) => {
+				c(t) || n.push({
 					code: "ORPHANED_ITEM_REFERENCE",
-					message: `Element "${e}" references non-existent child "${n}" at items[${r}]`,
+					message: `Element "${e}" references non-existent child "${t}" at items[${r}]`,
 					elementId: e,
 					details: {
-						childId: n,
+						childId: t,
 						index: r
 					}
 				});
-			}) : t.push({
+			}) : n.push({
 				code: "INVALID_ITEMS",
 				message: "Element.definition.items must be an array",
 				elementId: e
-			})), i.parentId && !s(i.parentId) && t.push({
+			})), i.parentId && !c(i.parentId) && n.push({
 				code: "ORPHANED_PARENT_REFERENCE",
 				message: `Element "${e}" has parentId "${i.parentId}" but parent doesn't exist in flat`,
 				elementId: e,
 				details: { parentId: i.parentId }
 			});
 		});
-	}, d = () => {
-		Object.values(r).forEach((e) => {
+	}, f = () => {
+		Object.values(i).forEach((e) => {
 			if (!e?.definition) return;
-			let { id: n, definition: r } = e;
+			let { id: t, definition: r } = e;
 			if (r.items && r.items.forEach((e) => {
-				let r = c(e);
-				r?.definition && r.definition.parentId !== n && t.push({
+				let r = l(e);
+				r?.definition && r.definition.parentId !== t && n.push({
 					code: "PARENT_CHILD_MISMATCH",
-					message: `Element "${e}" is in "${n}".items but has parentId "${r.definition.parentId}"`,
+					message: `Element "${e}" is in "${t}".items but has parentId "${r.definition.parentId}"`,
 					elementId: e,
 					details: {
-						expectedParent: n,
+						expectedParent: t,
 						actualParent: r.definition.parentId
 					}
 				});
 			}), r.parentId) {
-				let e = c(r.parentId);
+				let e = l(r.parentId);
 				if (!e?.definition) return;
 				let i = e.definition.items || [];
-				i.includes(n) || t.push({
+				i.includes(t) || n.push({
 					code: "PARENT_CHILD_MISMATCH",
-					message: `Element "${n}" has parentId "${r.parentId}" but parent doesn't have it in items`,
-					elementId: n,
+					message: `Element "${t}" has parentId "${r.parentId}" but parent doesn't have it in items`,
+					elementId: t,
 					details: {
 						parentId: r.parentId,
 						parentItems: i
@@ -113,169 +114,202 @@ var e = (e) => {
 				});
 			}
 		});
-	}, f = () => {
-		let e = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), i = (r) => {
-			if (n.has(r)) return t.push({
+	}, p = () => {
+		let e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), r = (i) => {
+			if (t.has(i)) return n.push({
 				code: "CIRCULAR_REFERENCE",
-				message: `Circular reference detected involving element "${r}"`,
-				elementId: r
+				message: `Circular reference detected involving element "${i}"`,
+				elementId: i
 			}), !0;
-			if (e.has(r)) return !1;
-			e.add(r), n.add(r);
-			let a = c(r);
+			if (e.has(i)) return !1;
+			e.add(i), t.add(i);
+			let a = l(i);
 			if (a?.definition?.items) {
-				for (let e of a.definition.items) if (i(e)) return n.delete(r), !0;
+				for (let e of a.definition.items) if (r(e)) return t.delete(i), !0;
 			}
 			let o = /* @__PURE__ */ new Set(), s = a;
 			for (; s?.definition?.parentId;) {
-				if (o.has(s.id)) return t.push({
+				if (o.has(s.id)) return n.push({
 					code: "CIRCULAR_PARENT_REFERENCE",
 					message: `Circular parent reference detected involving element "${s.id}"`,
 					elementId: s.id
 				}), !0;
-				o.add(s.id), s = c(s.definition.parentId);
+				o.add(s.id), s = l(s.definition.parentId);
 			}
-			return n.delete(r), !1;
+			return t.delete(i), !1;
 		};
-		Object.keys(r).forEach((t) => {
-			e.has(t) || i(t);
+		Object.keys(i).forEach((t) => {
+			e.has(t) || r(t);
 		});
-	}, p = () => {
-		let e = /* @__PURE__ */ new Set(), r = 0;
-		i.forEach((n, i) => {
-			e.has(n) && t.push({
+	}, m = () => {
+		let e = /* @__PURE__ */ new Set(), t = 0;
+		a.forEach((r, i) => {
+			e.has(r) && n.push({
 				code: "DUPLICATE_PAGE",
-				message: `Duplicate page ID "${n}" in pages array at index ${i}`,
-				elementId: n
-			}), e.add(n);
-			let a = c(n);
+				message: `Duplicate page ID "${r}" in pages array at index ${i}`,
+				elementId: r
+			}), e.add(r);
+			let a = l(r);
 			if (!a) {
-				t.push({
+				n.push({
 					code: "INVALID_PAGE_REFERENCE",
-					message: `Page ID "${n}" in pages array doesn't exist in flat`,
-					elementId: n
+					message: `Page ID "${r}" in pages array doesn't exist in flat`,
+					elementId: r
 				});
 				return;
 			}
-			a.definition.type !== "page" && t.push({
+			a.definition.type !== "page" && n.push({
 				code: "INVALID_PAGE_TYPE",
-				message: `Element "${n}" in pages array has type "${a.definition.type}" instead of "page"`,
-				elementId: n
-			}), a.definition.rootId !== n && t.push({
+				message: `Element "${r}" in pages array has type "${a.definition.type}" instead of "page"`,
+				elementId: r
+			}), a.definition.rootId !== r && n.push({
 				code: "PAGE_ROOT_ID_MISMATCH",
-				message: `Page "${n}" has rootId "${a.definition.rootId}" instead of its own ID`,
-				elementId: n
-			}), a.attributes?.default && r++;
-		}), r === 0 && i.length > 0 ? n.push({
+				message: `Page "${r}" has rootId "${a.definition.rootId}" instead of its own ID`,
+				elementId: r
+			}), a.attributes?.default && t++;
+		}), t === 0 && a.length > 0 ? r.push({
 			code: "NO_DEFAULT_PAGE",
 			message: "No default page found in schema"
-		}) : r > 1 && n.push({
+		}) : t > 1 && r.push({
 			code: "MULTIPLE_DEFAULT_PAGES",
-			message: `Found ${r} default pages, expected 1`
+			message: `Found ${t} default pages, expected 1`
 		});
-	}, m = () => {
-		i.forEach((e) => {
-			let n = c(e);
-			if (!n) return;
-			let r = (n) => {
-				let i = c(n);
-				i?.definition && (i.definition.rootId !== e && t.push({
+	}, h = () => {
+		a.forEach((e) => {
+			let t = l(e);
+			if (!t) return;
+			let r = (t) => {
+				let i = l(t);
+				i?.definition && (i.definition.rootId !== e && n.push({
 					code: "ROOT_ID_MISMATCH",
-					message: `Element "${n}" has rootId "${i.definition.rootId}" but should be "${e}" (page's ID)`,
-					elementId: n,
+					message: `Element "${t}" has rootId "${i.definition.rootId}" but should be "${e}" (page's ID)`,
+					elementId: t,
 					details: {
 						expectedRootId: e,
 						actualRootId: i.definition.rootId
 					}
 				}), i.definition.items && i.definition.items.forEach((e) => r(e)));
 			};
-			n.definition.items && n.definition.items.forEach((e) => r(e));
+			t.definition.items && t.definition.items.forEach((e) => r(e));
 		});
-	}, h = () => {
+	}, g = () => {
 		let e = /* @__PURE__ */ new Set();
-		a.forEach((n, r) => {
-			if (!n.id) {
-				t.push({
+		o.forEach((t, r) => {
+			if (!t.id) {
+				n.push({
 					code: "INVALID_FOLDER",
 					message: `Page folder at index ${r} has no id`
 				});
 				return;
 			}
-			e.has(n.id) && t.push({
+			e.has(t.id) && n.push({
 				code: "DUPLICATE_FOLDER",
-				message: `Duplicate folder ID "${n.id}"`,
-				elementId: n.id
-			}), e.add(n.id), n.parentId && (e.has(n.parentId) || t.push({
+				message: `Duplicate folder ID "${t.id}"`,
+				elementId: t.id
+			}), e.add(t.id), t.parentId && (e.has(t.parentId) || n.push({
 				code: "ORPHANED_FOLDER_PARENT",
-				message: `Folder "${n.id}" has non-existent parent "${n.parentId}"`,
-				elementId: n.id,
-				details: { parentId: n.parentId }
+				message: `Folder "${t.id}" has non-existent parent "${t.parentId}"`,
+				elementId: t.id,
+				details: { parentId: t.parentId }
 			}));
 		});
-	}, g = (e) => {
-		let t = /* @__PURE__ */ new Set(), a = (e) => {
+	}, _ = (e) => {
+		let t = /* @__PURE__ */ new Set(), n = (e) => {
 			if (t.has(e)) return;
 			t.add(e);
-			let n = c(e);
-			n?.definition?.items && n.definition.items.forEach((e) => a(e));
+			let r = l(e);
+			r?.definition?.items && r.definition.items.forEach((e) => n(e));
 		};
-		if (!e) i.forEach((e) => {
-			a(e);
-			let t = c(e);
-			t?.attributes?.layoutContainer && a(t.attributes.layoutContainer);
+		if (!e) a.forEach((e) => {
+			n(e);
+			let t = l(e);
+			t?.attributes?.layoutContainer && n(t.attributes.layoutContainer);
 		});
 		else if (e) {
-			a(e);
-			let t = c(e);
-			t?.attributes?.layoutContainer && a(t.attributes.layoutContainer);
+			n(e);
+			let t = l(e);
+			t?.attributes?.layoutContainer && n(t.attributes.layoutContainer);
 		}
-		Object.keys(r).forEach((e) => {
-			let r = c(e);
-			r && !t.has(e) && r.definition.type !== "page" && n.push({
+		Object.keys(i).forEach((e) => {
+			let n = l(e);
+			n && !t.has(e) && n.definition.type !== "page" && r.push({
 				code: "ORPHANED_ELEMENT",
 				message: `Element "${e}" is not reachable from any page`,
 				elementId: e
 			});
 		});
-	}, _ = () => {
+	}, v = () => {
 		let e = /* @__PURE__ */ new Set();
-		o.forEach((r, i) => {
-			if (!r.name) {
-				t.push({
+		s.forEach((t, i) => {
+			if (!t.name) {
+				n.push({
 					code: "INVALID_VARIABLE",
 					message: `Variable at index ${i} has no name`
 				});
 				return;
 			}
-			e.has(r.name) && t.push({
+			e.has(t.name) && n.push({
 				code: "DUPLICATE_VARIABLE",
-				message: `Duplicate variable name "${r.name}"`,
-				details: { variableName: r.name }
-			}), e.add(r.name), r.type || n.push({
+				message: `Duplicate variable name "${t.name}"`,
+				details: { variableName: t.name }
+			}), e.add(t.name), t.type || r.push({
 				code: "MISSING_VARIABLE_TYPE",
-				message: `Variable "${r.name}" has no type`,
-				details: { variableName: r.name }
+				message: `Variable "${t.name}" has no type`,
+				details: { variableName: t.name }
+			});
+		});
+	}, y = () => {
+		let t = /* @__PURE__ */ new Map();
+		Object.values(i).forEach((r) => {
+			if (!r) return;
+			let { idRef: i } = r;
+			if (!i) {
+				r.definition.interactions && Object.keys(r.definition.interactions).length > 0 && n.push({
+					code: "INTERACTIONS_WITHOUT_ID_REF",
+					message: `Element "${r.id}" has interactions but no idRef, so none of them can fire`,
+					elementId: r.id
+				});
+				return;
+			}
+			e(i) || n.push({
+				code: "INVALID_ID_REF",
+				message: `Element "${r.id}" has idRef "${i}", which must start with a letter, then letters, numbers, hyphens and underscores (no hyphen or underscore at the start, and no hyphen at the end)`,
+				elementId: r.id
 			});
+			let a = t.get(i);
+			if (a) {
+				n.push({
+					code: "DUPLICATE_ID_REF",
+					message: `Elements "${a}" and "${r.id}" share the idRef "${i}"`,
+					elementId: r.id,
+					details: {
+						idRef: i,
+						otherElementId: a
+					}
+				});
+				return;
+			}
+			t.set(i, r.id);
 		});
 	};
 	return { validate: (e) => {
-		let { baseElementId: r } = e ?? {};
-		return l() ? (u(), d(), f(), p(), m(), h(), g(r), _(), {
-			valid: t.length === 0,
-			errors: t,
-			warnings: n
+		let { baseElementId: t } = e ?? {};
+		return u() ? (d(), f(), p(), m(), h(), g(), _(t), v(), y(), {
+			valid: n.length === 0,
+			errors: n,
+			warnings: r
 		}) : {
 			valid: !1,
-			errors: t,
-			warnings: n
+			errors: n,
+			warnings: r
 		};
 	} };
-}, t = (t, n) => e(t).validate(n), n = (e, n, r) => {
-	let i = t(e, n);
+}, n = (e, n) => t(e).validate(n), r = (e, t, r) => {
+	let i = n(e, t);
 	if (!i.valid) {
 		let e = `Invalid schema${r ? ` (${r})` : ""}: ${i.errors.map((e) => e.message).join("; ")}`;
 		throw Error(e);
 	}
-}, r = (e, n) => t(e, n).valid;
+}, i = (e, t) => n(e, t).valid;
 //#endregion
-export { n as assertSchemaValid, r as isSchemaValid, t as validateSchema };
+export { r as assertSchemaValid, i as isSchemaValid, n as validateSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-schema",
-  "version": "0.32.5",
+  "version": "0.32.6",
   "license": "AGPL-3.0",
   "files": [
     "dist"
@@ -18,6 +18,10 @@
       "types": "./dist/helpers/FlatMap.d.ts",
       "import": "./dist/helpers/FlatMap.mjs"
     },
+    "./helpers/idRef": {
+      "types": "./dist/helpers/idRef.d.ts",
+      "import": "./dist/helpers/idRef.mjs"
+    },
     "./helpers/schemaValidator": {
       "types": "./dist/helpers/schemaValidator.d.ts",
       "import": "./dist/helpers/schemaValidator.mjs"
@@ -40,15 +44,15 @@
     "build:prod": "vite build && node ../sdk-shared/scripts/generate-exports.mjs"
   },
   "dependencies": {
-    "@plitzi/plitzi-ui": "^1.6.13",
-    "@plitzi/sdk-shared": "0.32.5",
-    "@plitzi/sdk-style": "0.32.5",
+    "@plitzi/plitzi-ui": "^1.6.17",
+    "@plitzi/sdk-shared": "0.32.6",
+    "@plitzi/sdk-style": "0.32.6",
     "prop-types": "^15.8.1"
   },
   "devDependencies": {
-    "eslint": "^9.39.4",
+    "eslint": "^9.39.5",
     "typescript": "^6.0.3",
-    "vite": "^8.1.4",
+    "vite": "^8.1.5",
     "vitest": "^4.1.10"
   }
 }