xml-model 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/index.js

@@ -1,7 +1,7 @@
 import { DATA, isModel, model } from "./model.js";
 import XML, { ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode } from "./xml/xml-js.js";
 import { xml } from "./xml/schema-meta.js";
-import { normalizeCodecOptions, registerDefault } from "./xml/codec.js";
-import { xmlModel } from "./xml/model.js";
+import { XMLCodecError, normalizeCodecOptions, registerDefault } from "./xml/codec.js";
+import { XMLBase, XMLBaseWithSource, xmlModel } from "./xml/model.js";
 import "./xml/index.js";
-export { DATA, XML, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode, isModel, model, normalizeCodecOptions, registerDefault, xml, xmlModel };
+export { DATA, XML, XMLBase, XMLBaseWithSource, XMLCodecError, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode, isModel, model, normalizeCodecOptions, registerDefault, xml, xmlModel };

package/dist/node_modules/sax/lib/sax.js

@@ -49,6 +49,7 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 			clearBuffers(parser);
 			parser.q = parser.c = "";
 			parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
+			parser.encoding = null;
 			parser.opt = opt || {};
 			parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
 			parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
@@ -146,6 +147,19 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 		function createStream(strict, opt) {
 			return new SAXStream(strict, opt);
 		}
+		function determineBufferEncoding(data, isEnd) {
+			if (data.length >= 2) {
+				if (data[0] === 255 && data[1] === 254) return "utf-16le";
+				if (data[0] === 254 && data[1] === 255) return "utf-16be";
+			}
+			if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191) return "utf8";
+			if (data.length >= 4) {
+				if (data[0] === 60 && data[1] === 0 && data[2] === 63 && data[3] === 0) return "utf-16le";
+				if (data[0] === 0 && data[1] === 60 && data[2] === 0 && data[3] === 63) return "utf-16be";
+				return "utf8";
+			}
+			return isEnd ? "utf8" : null;
+		}
 		function SAXStream(strict, opt) {
 			if (!(this instanceof SAXStream)) return new SAXStream(strict, opt);
 			Stream.apply(this);
@@ -161,6 +175,7 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 				me._parser.error = null;
 			};
 			this._decoder = null;
+			this._decoderBuffer = null;
 			streamWraps.forEach(function(ev) {
 				Object.defineProperty(me, "on" + ev, {
 					get: function() {
@@ -180,10 +195,30 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 			});
 		}
 		SAXStream.prototype = Object.create(Stream.prototype, { constructor: { value: SAXStream } });
+		SAXStream.prototype._decodeBuffer = function(data, isEnd) {
+			if (this._decoderBuffer) {
+				data = Buffer.concat([this._decoderBuffer, data]);
+				this._decoderBuffer = null;
+			}
+			if (!this._decoder) {
+				var encoding = determineBufferEncoding(data, isEnd);
+				if (!encoding) {
+					this._decoderBuffer = data;
+					return "";
+				}
+				this._parser.encoding = encoding;
+				this._decoder = new TextDecoder(encoding);
+			}
+			return this._decoder.decode(data, { stream: !isEnd });
+		};
 		SAXStream.prototype.write = function(data) {
-			if (typeof Buffer === "function" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(data)) {
-				if (!this._decoder) this._decoder = new TextDecoder("utf8");
-				data = this._decoder.decode(data, { stream: true });
+			if (typeof Buffer === "function" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(data)) data = this._decodeBuffer(data, false);
+			else if (this._decoderBuffer) {
+				var remaining = this._decodeBuffer(Buffer.alloc(0), true);
+				if (remaining) {
+					this._parser.write(remaining);
+					this.emit("data", remaining);
+				}
 			}
 			this._parser.write(data.toString());
 			this.emit("data", data);
@@ -191,7 +226,13 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 		};
 		SAXStream.prototype.end = function(chunk) {
 			if (chunk && chunk.length) this.write(chunk);
-			if (this._decoder) {
+			if (this._decoderBuffer) {
+				var finalChunk = this._decodeBuffer(Buffer.alloc(0), true);
+				if (finalChunk) {
+					this._parser.write(finalChunk);
+					this.emit("data", finalChunk);
+				}
+			} else if (this._decoder) {
 				var remaining = this._decoder.decode();
 				if (remaining) {
 					this._parser.write(remaining);
@@ -548,6 +589,26 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 		function emit(parser, event, data) {
 			parser[event] && parser[event](data);
 		}
+		function getDeclaredEncoding(body) {
+			var match = body && body.match(/(?:^|\s)encoding\s*=\s*(['"])([^'"]+)\1/i);
+			return match ? match[2] : null;
+		}
+		function normalizeEncodingName(encoding) {
+			if (!encoding) return null;
+			return encoding.toLowerCase().replace(/[^a-z0-9]/g, "");
+		}
+		function encodingsMatch(detectedEncoding, declaredEncoding) {
+			const detected = normalizeEncodingName(detectedEncoding);
+			const declared = normalizeEncodingName(declaredEncoding);
+			if (!detected || !declared) return true;
+			if (declared === "utf16") return detected === "utf16le" || detected === "utf16be";
+			return detected === declared;
+		}
+		function validateXmlDeclarationEncoding(parser, data) {
+			if (!parser.strict || !parser.encoding || !data || data.name !== "xml") return;
+			var declaredEncoding = getDeclaredEncoding(data.body);
+			if (declaredEncoding && !encodingsMatch(parser.encoding, declaredEncoding)) strictFail(parser, "XML declaration encoding " + declaredEncoding + " does not match detected stream encoding " + parser.encoding.toUpperCase());
+		}
 		function emitNode(parser, nodeType, data) {
 			if (parser.textNode) closeText(parser);
 			emit(parser, nodeType, data);
@@ -1014,10 +1075,12 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 						continue;
 					case S.PROC_INST_ENDING:
 						if (c === ">") {
-							emitNode(parser, "onprocessinginstruction", {
+							const procInstEndData = {
 								name: parser.procInstName,
 								body: parser.procInstBody
-							});
+							};
+							validateXmlDeclarationEncoding(parser, procInstEndData);
+							emitNode(parser, "onprocessinginstruction", procInstEndData);
 							parser.procInstName = parser.procInstBody = "";
 							parser.state = S.TEXT;
 						} else {

package/dist/util/zod.js

@@ -9,6 +9,8 @@ function getParentSchema(schema) {
 		if (isZodType(schema.def.in)) parent = schema.def.in;
 	} else if (schema instanceof z.ZodOptional) {
 		if (isZodType(schema.def.innerType)) parent = schema.def.innerType;
+	} else if (schema instanceof z.ZodDefault) {
+		if (isZodType(schema.def.innerType)) parent = schema.def.innerType;
 	} else if (schema instanceof z.ZodLazy) {
 		const value = schema.def.getter();
 		if (isZodType(value)) parent = value;

package/dist/xml/codec.d.ts

@@ -1,5 +1,10 @@
 import { z } from 'zod';
 import { XMLElement } from './xml-js';
+export declare class XMLCodecError extends Error {
+    readonly path: readonly (string | number)[];
+    readonly rawMessage: string;
+    constructor(rawMessage: string, path?: readonly (string | number)[], options?: ErrorOptions);
+}
 export declare function assertSingleElement(xml: XMLElement[]): asserts xml is [XMLElement];
 export declare function assertSingleRoot(xml: XMLElement[]): asserts xml is [XMLElement & {
     elements: XMLElement[];
@@ -32,8 +37,8 @@ export interface CodecOptions<S extends z.ZodType> {
  */
 export type UserCodecOptions<S extends z.ZodType = z.ZodType> = {
     tagname?: string | CodecOptions<S>["tagname"];
-    decode?: CodecOptions<S>["decode"];
-    encode?: CodecOptions<S>["encode"];
+    decode?: (ctx: RootDecodingContext<S>, next: () => z.input<S>) => z.input<S>;
+    encode?: (ctx: RootEncodingContext<S>, next: () => XMLElement) => XMLElement;
     propertyTagname?: string | CodecOptions<S>["propertyTagname"];
     inlineProperty?: boolean;
     propertyMatch?: RegExp | CodecOptions<S>["propertyMatch"];
@@ -71,13 +76,40 @@ export declare function normalizeCodecOptions<S extends z.ZodType>(schema: S, op
 type OrderEntry = string | XMLElement;
 export interface XMLState {
     /** Preserves element ordering and unknown elements across a decode → encode round-trip. */
-    fieldOrder: OrderEntry[];
+    sequence: OrderEntry[];
+    /** Present when xmlStateSchema({ source: true }) is used: the original XMLElement. */
+    source?: XMLElement;
 }
 /**
- * Non-enumerable Symbol attached to decoded data objects (and forwarded to model instances).
- * Groups all XML codec round-trip state under a single key.
+ * String key used to store XML round-trip state on decoded data objects.
+ * Using a string (rather than a Symbol) allows Zod's schema.parse() to
+ * preserve it naturally when the key is included in the schema via xmlStateSchema().
+ */
+export declare const XML_STATE_KEY: "__xml_state";
+/**
+ * Schema for the XML round-trip state field.
+ *
+ * Include in your base model schema under `XML_STATE_KEY` to preserve element ordering
+ * and unknown elements through Zod's `schema.parse()` for nested model instances.
+ *
+ * Pass `{ source: true }` to also record the original `XMLElement` on each instance.
+ *
+ * @example
+ * class XMLBase extends xmlModel(z.object({
+ *   [XML_STATE_KEY]: xmlStateSchema(),
+ * }), { tagname: "base" }) {}
+ *
+ * // With source recording:
+ * class XMLBase extends xmlModel(z.object({
+ *   [XML_STATE_KEY]: xmlStateSchema({ source: true }),
+ * }), { tagname: "base" }) {}
  */
-export declare const XML_STATE: unique symbol;
+export declare function xmlStateSchema(): z.ZodOptional<z.ZodCustom<XMLState>>;
+export declare function xmlStateSchema(options: {
+    source: true;
+}): z.ZodOptional<z.ZodCustom<XMLState & {
+    source: XMLElement;
+}>>;
 export declare function decode<S extends z.ZodType>(schema: S, xml: XMLElement): z.input<S>;
 export declare function encode<S extends z.ZodType>(schema: S, data: z.output<S>): XMLElement;
 type DefaultResolver<S extends z.ZodType = z.ZodType> = (schema: S) => CodecOptions<S> | void;

package/dist/xml/codec.js

@@ -1,9 +1,24 @@
 import XML from "./xml-js.js";
 import { isZodType } from "../util/zod.js";
-import { getUserOptions } from "./schema-meta.js";
+import { getUserOptions, prop } from "./schema-meta.js";
 import { kebabCase } from "../util/kebab-case.js";
 import { z } from "zod";
 //#region src/xml/codec.ts
+var XMLCodecError = class extends Error {
+	path;
+	rawMessage;
+	constructor(rawMessage, path = [], options) {
+		super(path.length ? `[${path.join(".")}] ${rawMessage}` : rawMessage, options);
+		this.name = "XMLCodecError";
+		this.path = path;
+		this.rawMessage = rawMessage;
+	}
+};
+function rethrow(e, segment) {
+	const cause = e instanceof XMLCodecError ? e.cause : e;
+	const path = e instanceof XMLCodecError ? [segment, ...e.path] : [segment];
+	throw new XMLCodecError(e instanceof XMLCodecError ? e.rawMessage : e instanceof Error ? e.message : String(e), path, { cause });
+}
 function assertSingleElement(xml) {
 	if (xml.length !== 1) throw new Error(`Expected single XML element, got ${xml.length}`);
 }
@@ -28,8 +43,8 @@ function normalizeCodecOptions(schema, options = {}) {
 	const result = {
 		schema,
 		tagname,
-		decode: options.decode ?? defaultOptions().decode,
-		encode: options.encode ?? defaultOptions().encode,
+		decode: options.decode ? (ctx) => options.decode(ctx, () => defaultOptions().decode(ctx)) : (ctx) => defaultOptions().decode(ctx),
+		encode: options.encode ? (ctx) => options.encode(ctx, () => defaultOptions().encode(ctx)) : (ctx) => defaultOptions().encode(ctx),
 		propertyTagname,
 		inlineProperty,
 		propertyMatch,
@@ -51,7 +66,10 @@ function normalizeCodecOptions(schema, options = {}) {
 				data: property.value
 			});
 			if (XML.isEmpty(res)) return;
-			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements);
+			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements.map((el) => el.type === "element" ? {
+				...el,
+				name: property.tagname
+			} : el));
 			else ctx.result.elements.push(res);
 		}
 	};
@@ -66,10 +84,19 @@ function resolveCodecOptions(schema) {
 	return options;
 }
 /**
-* Non-enumerable Symbol attached to decoded data objects (and forwarded to model instances).
-* Groups all XML codec round-trip state under a single key.
+* String key used to store XML round-trip state on decoded data objects.
+* Using a string (rather than a Symbol) allows Zod's schema.parse() to
+* preserve it naturally when the key is included in the schema via xmlStateSchema().
 */
-var XML_STATE = Symbol("xml-model.state");
+var XML_STATE_KEY = "__xml_state";
+function xmlStateSchema(options) {
+	return prop(z.custom().optional(), {
+		decode: options?.source ? (ctx, _next) => {
+			(ctx.result[XML_STATE_KEY] ??= {}).source = ctx.xml;
+		} : () => {},
+		encode: () => {}
+	});
+}
 function resolvePropertiesCodecOptions(schema) {
 	const shape = schema.def.shape;
 	const options = {};
@@ -103,7 +130,10 @@ function resolveDefault(schema) {
 }
 registerDefault((schema) => {
 	if (schema instanceof z.ZodArray) {
-		const elOptions = resolveCodecOptions(schema.def.element);
+		const elSchema = schema.def.element;
+		if (!isZodType(elSchema)) throw new Error(`Expected a ZodType, got ${elSchema}`);
+		const elOptions = resolveCodecOptions(elSchema);
+		const elHasOwnTagname = Boolean(getUserOptions(elSchema).tagname);
 		return normalizeCodecOptions(schema, {
 			decode(ctx) {
 				const { xml } = ctx;
@@ -116,12 +146,16 @@ registerDefault((schema) => {
 			encode(ctx) {
 				const values = ctx.data;
 				if (!Array.isArray(values)) throw new Error("expected array");
+				const elOptsForEncode = elHasOwnTagname ? elOptions : {
+					...elOptions,
+					tagname: ctx.options.tagname
+				};
 				return {
 					type: "element",
 					name: ctx.options.tagname(ctx),
 					attributes: {},
-					elements: values.map((v) => elOptions.encode({
-						options: elOptions,
+					elements: values.map((v) => elOptsForEncode.encode({
+						options: elOptsForEncode,
 						data: v
 					}))
 				};
@@ -134,12 +168,18 @@ registerDefault((schema) => {
 		const innerOptions = resolveCodecOptions(inner);
 		return normalizeCodecOptions(schema, {
 			decode(ctx) {
-				if (!ctx.xml) return void 0;
+				if (ctx.xml === null) return void 0;
 				else return innerOptions.decode(ctx);
 			},
 			encode(ctx) {
 				if (typeof ctx.data === "undefined") return {};
 				else return innerOptions.encode(ctx);
+			},
+			decodeAsProperty(ctx) {
+				if (ctx.property.xml !== null) innerOptions.decodeAsProperty(ctx);
+			},
+			encodeAsProperty(ctx) {
+				if (typeof ctx.property.value !== "undefined") innerOptions.encodeAsProperty(ctx);
 			}
 		});
 	}
@@ -181,7 +221,10 @@ registerDefault((schema) => {
 				});
 			},
 			encode(ctx) {
-				const data = outSchema.encode(ctx.data);
+				const data = schema.def.reverseTransform ? schema.def.reverseTransform(ctx.data, {
+					value: ctx.data,
+					issues: []
+				}) : outSchema.encode(ctx.data);
 				const innerOpts = ctx.options.tagname !== inputCodecOptions.tagname ? {
 					...inputCodecOptions,
 					tagname: ctx.options.tagname
@@ -238,6 +281,7 @@ registerDefault((schema) => {
 		return normalizeCodecOptions(schema, {
 			decode(ctx) {
 				const sequence = [];
+				const result = { [XML_STATE_KEY]: { sequence } };
 				const propContexts = Object.fromEntries(Object.entries(options).map(([name, propOpts]) => {
 					return [name, {
 						name,
@@ -274,7 +318,6 @@ registerDefault((schema) => {
 					} else throw new Error(`Same element was matched by multiple properties: ${matches.join(", ")}`);
 				}
 				for (const propName in options) if (!seenProperties.has(propName)) sequence.push(propName);
-				const result = {};
 				for (const prop in options) {
 					const o = options[prop];
 					const propCtx = propContexts[prop];
@@ -286,19 +329,17 @@ registerDefault((schema) => {
 							propCtx.xml = matches[0];
 						}
 					}
-					o.decodeAsProperty({
-						options: ctx.options,
-						xml: ctx.xml,
-						property: propCtx,
-						result
-					});
+					try {
+						o.decodeAsProperty({
+							options: ctx.options,
+							xml: ctx.xml,
+							property: propCtx,
+							result
+						});
+					} catch (e) {
+						rethrow(e, prop);
+					}
 				}
-				Object.defineProperty(result, XML_STATE, {
-					value: { fieldOrder: sequence },
-					enumerable: false,
-					writable: true,
-					configurable: true
-				});
 				return result;
 			},
 			encode(ctx) {
@@ -309,24 +350,28 @@ registerDefault((schema) => {
 					attributes: {},
 					elements: []
 				};
-				const sequence = data[XML_STATE]?.fieldOrder ?? Object.keys(options);
+				const sequence = data["__xml_state"]?.sequence ?? Object.keys(options);
 				for (const item of sequence) if (typeof item === "string") {
 					const o = options[item];
 					if (!o) throw new Error(`Failed to resolve property options for sequence item ${item}`);
-					o.encodeAsProperty({
-						options: ctx.options,
-						data,
-						property: {
-							name: item,
-							options: o,
-							tagname: o.propertyTagname({
+					try {
+						o.encodeAsProperty({
+							options: ctx.options,
+							data,
+							property: {
 								name: item,
-								options: o
-							}),
-							value: data[item]
-						},
-						result
-					});
+								options: o,
+								tagname: o.propertyTagname({
+									name: item,
+									options: o
+								}),
+								value: data[item]
+							},
+							result
+						});
+					} catch (e) {
+						rethrow(e, item);
+					}
 				} else result.elements.push(item);
 				return result;
 			}
@@ -334,6 +379,6 @@ registerDefault((schema) => {
 	}
 });
 //#endregion
-export { XML_STATE, decode, encode, normalizeCodecOptions, registerDefault };
+export { XMLCodecError, XML_STATE_KEY, decode, encode, normalizeCodecOptions, registerDefault, xmlStateSchema };
 
 //# sourceMappingURL=codec.js.map

package/dist/xml/examples.d.ts

@@ -1,4 +1,17 @@
 import { z } from 'zod';
+declare const Event_base: import('./model').XmlModelConstructor<z.ZodObject<{
+    title: z.ZodString;
+    publishedAt: z.ZodCodec<z.ZodString, z.ZodDate>;
+}, z.core.$strip>, {
+    title: string;
+    publishedAt?: Date;
+}>;
+/**
+ * An event with a typed `Date` field stored as an ISO 8601 string in XML.
+ * Demonstrates using `z.codec` to transform a raw XML string into a native JS type.
+ */
+export declare class Event extends Event_base {
+}
 declare const Engine_base: import('./model').XmlModelConstructor<z.ZodObject<{
     type: z.ZodString;
     horsepower: z.ZodNumber;

package/dist/xml/index.d.ts

@@ -1,6 +1,6 @@
 export * from './xml-js';
 export { xml } from './schema-meta';
-export type { UserCodecOptions } from './codec';
-export { registerDefault, normalizeCodecOptions } from './codec';
-export { xmlModel, type XmlModelConstructor } from './model';
+export type { UserCodecOptions, XMLState } from './codec';
+export { registerDefault, normalizeCodecOptions, XMLCodecError } from './codec';
+export { xmlModel, XMLBase, XMLBaseWithSource, type XmlModelConstructor } from './model';
 //# sourceMappingURL=index.d.ts.map

package/dist/xml/model.d.ts

@@ -14,5 +14,37 @@ export type XmlModelConstructor<S extends z.ZodObject<any> = z.ZodObject<any>, I
     /** Converts an instance to an XML string. */
     toXMLString(instance: z.infer<S>, options?: StringifyOptions): string;
 };
+/**
+ * Base class for xmlModel classes. Preserves element ordering and unknown elements
+ * through `schema.parse()` for nested model instances.
+ *
+ * @example
+ * class Device extends XMLBase.extend(
+ *   { name: z.string() },
+ *   xml.root({ tagname: "device" }),
+ * ) {}
+ */
+export declare const XMLBase: XmlModelConstructor<z.ZodObject<{
+    __xml_state: z.ZodOptional<z.ZodCustom<import('./codec').XMLState, unknown>>;
+}, z.core.$strip>, {
+    __xml_state?: import('./codec').XMLState;
+}>;
+/**
+ * Like {@link XMLBase}, but also records the original `XMLElement` as `.source`
+ * on each instance's XML state.
+ *
+ * @example
+ * const device = Device.fromXML(`<device>…</device>`);
+ * device[XML_STATE_KEY]?.source; // XMLElement
+ */
+export declare const XMLBaseWithSource: XmlModelConstructor<z.ZodObject<{
+    __xml_state: z.ZodOptional<z.ZodCustom<import('./codec').XMLState & {
+        source: XMLElement;
+    }, unknown>>;
+}, z.core.$strip>, {
+    __xml_state?: import('./codec').XMLState & {
+        source: XMLElement;
+    };
+}>;
 export declare function xmlModel<S extends z.ZodObject<any>>(schema: S, options?: UserCodecOptions<S>): XmlModelConstructor<S>;
 //# sourceMappingURL=model.d.ts.map

package/dist/xml/model.js

@@ -1,21 +1,36 @@
 import { model } from "../model.js";
 import XML from "./xml-js.js";
 import { root } from "./schema-meta.js";
-import { XML_STATE, decode, encode } from "./codec.js";
-import "zod";
+import { XML_STATE_KEY, decode, encode, xmlStateSchema } from "./codec.js";
+import { z } from "zod";
 //#region src/xml/model.ts
+/**
+* Base class for xmlModel classes. Preserves element ordering and unknown elements
+* through `schema.parse()` for nested model instances.
+*
+* @example
+* class Device extends XMLBase.extend(
+*   { name: z.string() },
+*   xml.root({ tagname: "device" }),
+* ) {}
+*/
+var XMLBase = xmlModel(z.object({ [XML_STATE_KEY]: xmlStateSchema() }));
+/**
+* Like {@link XMLBase}, but also records the original `XMLElement` as `.source`
+* on each instance's XML state.
+*
+* @example
+* const device = Device.fromXML(`<device>…</device>`);
+* device[XML_STATE_KEY]?.source; // XMLElement
+*/
+var XMLBaseWithSource = xmlModel(z.object({ [XML_STATE_KEY]: xmlStateSchema({ source: true }) }));
 function xmlModel(schema, options) {
 	const _schema = options ? root(schema, options) : schema;
 	return class extends model(_schema) {
 		static fromXML(input) {
 			if (typeof input === "string") input = XML.parse(input);
 			if (XML.isRoot(input)) input = XML.elementFromRoot(input);
-			const schema = this.dataSchema;
-			const inputData = decode(this.dataSchema, input);
-			const xmlState = inputData[XML_STATE];
-			const parsed = schema.parse(inputData);
-			parsed[XML_STATE] = xmlState;
-			return this.fromData(parsed);
+			return this.fromData(decode(this.dataSchema, input));
 		}
 		static toXML(instance) {
 			const data = this.toData(instance);
@@ -28,6 +43,6 @@ function xmlModel(schema, options) {
 	};
 }
 //#endregion
-export { xmlModel };
+export { XMLBase, XMLBaseWithSource, xmlModel };
 
 //# sourceMappingURL=model.js.map

package/dist/xml/schema-meta.d.ts

@@ -15,8 +15,8 @@ type UserPropOptions = {
     tagname?: string | UserCodecOptions["propertyTagname"];
     inline?: boolean;
     match?: RegExp | ((el: XMLElement) => boolean);
-    decode?: (ctx: PropertyDecodingContext) => Partial<Record<string, unknown>> | undefined;
-    encode?: (ctx: PropertyEncodingContext) => XMLElement | undefined;
+    decode?: (ctx: PropertyDecodingContext, next: () => void) => void;
+    encode?: (ctx: PropertyEncodingContext, next: () => void) => void;
 };
 export declare function root<S extends z.ZodType>(schema: S, options: UserRootOptions<S>): S;
 export declare function root(options: UserRootOptions): z.GlobalMeta;

package/dist/xml/schema-meta.js

@@ -1,3 +1,4 @@
+import XML from "./xml-js.js";
 import { getParentSchema, isZodType } from "../util/zod.js";
 import "zod";
 //#region src/xml/schema-meta.ts
@@ -19,21 +20,40 @@ function normalizePropOptions(options) {
 	if (options.decode !== void 0) {
 		const userDecode = options.decode;
 		partial.decodeAsProperty = function(ctx) {
-			const res = userDecode(ctx);
-			if (typeof res !== "undefined") Object.assign(ctx.result, res);
+			const next = () => {
+				const val = ctx.property.options.decode({
+					options: ctx.property.options,
+					xml: ctx.property.xml
+				});
+				ctx.result[ctx.property.name] = val;
+			};
+			userDecode(ctx, next);
 		};
 	}
 	if (options.encode !== void 0) {
 		const userEncode = options.encode;
 		partial.encodeAsProperty = function(ctx) {
 			const { property } = ctx;
-			const res = userEncode(ctx);
-			if (typeof res === "undefined") return;
-			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements);
-			else {
-				res.name = property.tagname;
-				ctx.result.elements.push(res);
-			}
+			const next = () => {
+				const optsWithTagname = {
+					...property.options,
+					tagname: () => property.tagname
+				};
+				const res = property.options.encode({
+					options: optsWithTagname,
+					data: property.value
+				});
+				if (XML.isEmpty(res)) return;
+				if (property.options.inlineProperty) ctx.result.elements.push(...res.elements.map((el) => el.type === "element" ? {
+					...el,
+					name: property.tagname
+				} : el));
+				else ctx.result.elements.push({
+					...res,
+					name: property.tagname
+				});
+			};
+			userEncode(ctx, next);
 		};
 	}
 	return partial;
@@ -52,7 +72,7 @@ function attr(optionsOrSchema, options) {
 		decodeAsProperty(ctx) {
 			const { name, options: propOptions } = ctx.property;
 			const attrName = opts.name ?? name;
-			const attrValue = ctx.xml?.attributes[attrName];
+			const attrValue = ctx.xml?.attributes?.[attrName];
 			ctx.result[name] = propOptions.schema.parse(attrValue);
 		},
 		encodeAsProperty(ctx) {
@@ -73,16 +93,27 @@ var xml = {
 function getOwnUserOptions(schema) {
 	return schema.meta()?.[metaKey] ?? {};
 }
+var INHERITABLE_KEYS = [
+	"tagname",
+	"propertyTagname",
+	"inlineProperty",
+	"propertyMatch",
+	"decodeAsProperty",
+	"encodeAsProperty"
+];
 function getUserOptions(schema) {
 	const own = getOwnUserOptions(schema);
 	const parentSchema = getParentSchema(schema);
 	if (!parentSchema) return own;
+	const parentOptions = getUserOptions(parentSchema);
+	const inherited = {};
+	for (const key of INHERITABLE_KEYS) if (parentOptions[key] !== void 0 && own[key] === void 0) inherited[key] = parentOptions[key];
 	return {
-		...getUserOptions(parentSchema),
+		...inherited,
 		...own
 	};
 }
 //#endregion
-export { getUserOptions, root, xml };
+export { getUserOptions, prop, root, xml };
 
 //# sourceMappingURL=schema-meta.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-model",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.6",
   "description": "allows transparent XML <-> Object conversion in typescript",
   "license": "MIT",
   "author": "MathisTLD",
@@ -34,10 +34,10 @@
     "fmt:check": "vp fmt --check",
     "prepare": "vp config"
   },
-  "dependencies": {},
   "devDependencies": {
     "@types/node": "^24.10.11",
     "marmotte": "^0.4.4",
+    "oxc-minify": "^0.121.0",
     "typescript": "^5.9.3",
     "vite-plus": "latest",
     "vitepress": "^2.0.0-alpha.16",
@@ -53,4 +53,4 @@
     "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
   },
   "packageManager": "npm@11.12.0"
-}
+}