@voidhash/mimic 1.0.0-beta.16 → 1.0.0-beta.18

package/dist/OperationDefinition.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"OperationDefinition.d.mts","names":[],"sources":["../src/OperationDefinition.ts"],"sourcesContent":[],"mappings":";;;;;;KAEK,aAAa,UAAU,yBAAyB,MAAM,6BAA6B,IAAI,EAAE;UAE7E,4CAA4C,MAAA,CAAO,MAAA,CAAO,qBAAqB,MAAA,CAAO,MAAA,CAAO;iBAC3F;oBACG;mBACD;EALhB,SAAA,YAAO,CAAA,EAAA,OAAA;;AAAgB,cASf,IATe,EAAA,CAAA,KAAA,EAAA,iBASiB,MAAA,CAAO,MAAA,CAAO,GAT/B,EAAA,gBASoD,MAAA,CAAO,MAAA,CAAO,GATlE,CAAA,CAAA,OAAA,EAAA;EAA+B,SAAA,IAAA,EAUxC,KAVwC;EAAN,SAAA,OAAA,EAW/B,QAX+B;EAAmC,SAAA,MAAA,EAYnE,OAZmE;EAAI,SAAA,KAAA,EAAA,CAAA,OAAA,EAa9D,MAAA,CAAO,MAAA,CAAO,IAbgD,CAa3C,QAb2C,CAAA,EAAA,MAAA,EAaxB,OAbwB,CAahB,MAAA,CAAO,MAAA,CAAO,IAbE,CAaG,OAbH,CAAA,CAAA,EAAA,GAAA,IAAA;EAAE,SAAA,YAAA,CAAA,EAAA,OAAA;CAAC,EAAA,GAAA;EAE9E,SAAA,YAAA,CAAmB,EAAA,OAAA,GAAA,SAAA;EAAyB,SAAO,IAAO,OAAA;EAAqB,SAAO,OAAO,UAAA;EAC3F,SAAA,MAAA,SAAA;EACG,SAAA,KAAA,EAAA,CAAA,OAAA,EASQ,MAAA,CAAO,MAAA,CAAO,IATtB,CAS2B,QAT3B,CAAA,EAAA,MAAA,EAS8C,OAT9C,CASsD,MAAA,CAAO,MAAA,CAAO,IATpE,CASyE,OATzE,CAAA,CAAA,EAAA,GAAA,IAAA;CACD"}
+{"version":3,"file":"OperationDefinition.d.mts","names":[],"sources":["../src/OperationDefinition.ts"],"sourcesContent":[],"mappings":";;;;;;KAEK,aAAa,UAAU,yBAAyB,MAAM,6BAA6B,IAAI,EAAE;UAE7E,4CAA4C,MAAA,CAAO,qBAAqB,MAAA,CAAO;iBAC7E;oBACG;mBACD;EALhB,SAAA,YAAO,CAAA,EAAA,OAAA;;AAAgB,cASf,IATe,EAAA,CAAA,KAAA,EAAA,iBASiB,MAAA,CAAO,GATxB,EAAA,gBAS6C,MAAA,CAAO,GATpD,CAAA,CAAA,OAAA,EAAA;EAA+B,SAAA,IAAA,EAUxC,KAVwC;EAAN,SAAA,OAAA,EAW/B,QAX+B;EAAmC,SAAA,MAAA,EAYnE,OAZmE;EAAI,SAAA,KAAA,EAAA,CAAA,OAAA,EAa9D,MAAA,CAAO,MAAA,CAAO,IAbgD,CAa3C,QAb2C,CAAA,EAAA,MAAA,EAaxB,OAbwB,CAahB,MAAA,CAAO,MAAA,CAAO,IAbE,CAaG,OAbH,CAAA,CAAA,EAAA,GAAA,IAAA;EAAE,SAAA,YAAA,CAAA,EAAA,OAAA;CAAC,EAAA,GAAA;EAE9E,SAAA,YAAA,CAAmB,EAAA,OAAA,GAAA,SAAA;EAAyB,SAAO,IAAA,OAAA;EAAqB,SAAO,OAAA,UAAA;EAC7E,SAAA,MAAA,SAAA;EACG,SAAA,KAAA,EAAA,CAAA,OAAA,EASQ,MAAA,CAAO,MAAA,CAAO,IATtB,CAS2B,QAT3B,CAAA,EAAA,MAAA,EAS8C,OAT9C,CASsD,MAAA,CAAO,MAAA,CAAO,IATpE,CASyE,OATzE,CAAA,CAAA,EAAA,GAAA,IAAA;CACD"}

package/dist/OperationDefinition.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"OperationDefinition.mjs","names":[],"sources":["../src/OperationDefinition.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\ntype Mutable<T> = T extends ReadonlyArray<infer U> ? Array<U> : { -readonly [K in keyof T]: T[K] };\n\nexport interface OperationDefinition<TKind, TPayload extends Schema.Schema.Any, TTarget extends Schema.Schema.Any> {\n    readonly kind: TKind\n    readonly payload: TPayload\n    readonly target: TTarget\n    readonly deduplicable?: boolean\n}\n\nexport const make = <TKind, TPayload extends Schema.Schema.Any, TTarget extends Schema.Schema.Any>(options: {\n    readonly kind: TKind\n    readonly payload: TPayload\n    readonly target: TTarget\n    readonly apply: (payload: Schema.Schema.Type<TPayload>, target: Mutable<Schema.Schema.Type<TTarget>>) => void\n    readonly deduplicable?: boolean\n}) => {\n    return {\n        kind: options.kind,\n        payload: options.payload,\n        target: options.target,\n        apply: options.apply,\n        ...(options.deduplicable !== undefined ? { deduplicable: options.deduplicable } : {}),\n    } as const;\n}"],"mappings":";;;;;AAWA,MAAa,QAAsF,YAM7F;AACF;EACI,MAAM,QAAQ;EACd,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EAChB,OAAO,QAAQ;IACX,QAAQ,iBAAiB,SAAY,EAAE,cAAc,QAAQ,cAAc,GAAG,EAAE"}
+{"version":3,"file":"OperationDefinition.mjs","names":[],"sources":["../src/OperationDefinition.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\ntype Mutable<T> = T extends ReadonlyArray<infer U> ? Array<U> : { -readonly [K in keyof T]: T[K] };\n\nexport interface OperationDefinition<TKind, TPayload extends Schema.Top, TTarget extends Schema.Top> {\n    readonly kind: TKind\n    readonly payload: TPayload\n    readonly target: TTarget\n    readonly deduplicable?: boolean\n}\n\nexport const make = <TKind, TPayload extends Schema.Top, TTarget extends Schema.Top>(options: {\n    readonly kind: TKind\n    readonly payload: TPayload\n    readonly target: TTarget\n    readonly apply: (payload: Schema.Schema.Type<TPayload>, target: Mutable<Schema.Schema.Type<TTarget>>) => void\n    readonly deduplicable?: boolean\n}) => {\n    return {\n        kind: options.kind,\n        payload: options.payload,\n        target: options.target,\n        apply: options.apply,\n        ...(options.deduplicable !== undefined ? { deduplicable: options.deduplicable } : {}),\n    } as const;\n}"],"mappings":";;;;;AAWA,MAAa,QAAwE,YAM/E;AACF;EACI,MAAM,QAAQ;EACd,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EAChB,OAAO,QAAQ;IACX,QAAQ,iBAAiB,SAAY,EAAE,cAAc,QAAQ,cAAc,GAAG,EAAE"}

package/dist/Presence.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Presence.mjs","names":[],"sources":["../src/Presence.ts"],"sourcesContent":["/**\n * @since 0.0.1\n * Presence module for ephemeral per-connection state.\n * Used by both client and server for schema validation.\n */\nimport * as Schema from \"effect/Schema\";\n\n// =============================================================================\n// Presence Types\n// =============================================================================\n\n/**\n * A Presence schema wrapper that holds an Effect Schema for validation.\n * This is used by both client and server to validate presence data.\n */\nexport interface Presence<TData> {\n  readonly _tag: \"Presence\";\n  /** The Effect Schema used for validation */\n  readonly schema: Schema.Schema<TData>;\n  /** Branded type marker for inference */\n  readonly _Data: TData;\n}\n\n/**\n * Options for creating a Presence instance.\n */\nexport interface PresenceOptions<TData> {\n  /** The Effect Schema defining the presence data structure */\n  readonly schema: Schema.Schema<TData>;\n}\n\n/**\n * Infer the data type from a Presence instance.\n */\nexport type Infer<P extends Presence<any>> = P[\"_Data\"];\n\n/**\n * Any Presence type (for generic constraints).\n */\nexport type AnyPresence = Presence<any>;\n\n// =============================================================================\n// Presence Entry (for storage/transport)\n// =============================================================================\n\n/**\n * A presence entry as stored/transmitted.\n */\nexport interface PresenceEntry<TData = unknown> {\n  /** The presence data */\n  readonly data: TData;\n  /** Optional user ID from authentication */\n  readonly userId?: string;\n}\n\n// =============================================================================\n// Factory Function\n// =============================================================================\n\n/**\n * Creates a new Presence schema wrapper.\n *\n * @example\n * ```typescript\n * import { Presence } from \"@voidhash/mimic\";\n * import { Schema } from \"effect\";\n *\n * const CursorPresence = Presence.make({\n *   schema: Schema.Struct({\n *     name: Schema.String,\n *     cursor: Schema.Struct({\n *       x: Schema.Number,\n *       y: Schema.Number,\n *     }),\n *   }),\n * });\n * ```\n */\nexport const make = <TData,>(options: PresenceOptions<TData>): Presence<TData> => ({\n  _tag: \"Presence\",\n  schema: options.schema,\n  _Data: undefined as unknown as TData,\n});\n\n// =============================================================================\n// Validation Functions\n// =============================================================================\n\n/**\n * Validates unknown data against a Presence schema.\n * Throws a ParseError if validation fails.\n *\n * @param presence - The Presence instance with the schema\n * @param data - Unknown data to validate\n * @returns The validated and typed data\n * @throws ParseError if validation fails\n */\nexport const validate = <TData,>(\n  presence: Presence<TData>,\n  data: unknown\n): TData => {\n  return Schema.decodeUnknownSync(presence.schema)(data);\n};\n\n/**\n * Safely validates unknown data against a Presence schema.\n * Returns undefined if validation fails instead of throwing.\n *\n * @param presence - The Presence instance with the schema\n * @param data - Unknown data to validate\n * @returns The validated data or undefined if invalid\n */\nexport const validateSafe = <TData,>(\n  presence: Presence<TData>,\n  data: unknown\n): TData | undefined => {\n  try {\n    return Schema.decodeUnknownSync(presence.schema)(data);\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Checks if unknown data is valid according to a Presence schema.\n *\n * @param presence - The Presence instance with the schema\n * @param data - Unknown data to check\n * @returns true if valid, false otherwise\n */\nexport const isValid = <TData,>(\n  presence: Presence<TData>,\n  data: unknown\n): data is TData => {\n  try {\n    Schema.decodeUnknownSync(presence.schema)(data);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,MAAa,QAAgB,aAAsD;CACjF,MAAM;CACN,QAAQ,QAAQ;CAChB,OAAO;CACR;;;;;;;;;;AAeD,MAAa,YACX,UACA,SACU;AACV,QAAO,OAAO,kBAAkB,SAAS,OAAO,CAAC,KAAK;;;;;;;;;;AAWxD,MAAa,gBACX,UACA,SACsB;AACtB,KAAI;AACF,SAAO,OAAO,kBAAkB,SAAS,OAAO,CAAC,KAAK;mBAChD;AACN;;;;;;;;;;AAWJ,MAAa,WACX,UACA,SACkB;AAClB,KAAI;AACF,SAAO,kBAAkB,SAAS,OAAO,CAAC,KAAK;AAC/C,SAAO;oBACD;AACN,SAAO"}
+{"version":3,"file":"Presence.mjs","names":[],"sources":["../src/Presence.ts"],"sourcesContent":["/**\n * @since 0.0.1\n * Presence module for ephemeral per-connection state.\n * Used by both client and server for schema validation.\n */\nimport * as Schema from \"effect/Schema\";\n\n// =============================================================================\n// Presence Types\n// =============================================================================\n\n/**\n * A Presence schema wrapper that holds an Effect Schema for validation.\n * This is used by both client and server to validate presence data.\n */\nexport interface Presence<TData> {\n  readonly _tag: \"Presence\";\n  /** The Effect Schema used for validation */\n  readonly schema: Schema.Schema<TData>;\n  /** Branded type marker for inference */\n  readonly _Data: TData;\n}\n\n/**\n * Options for creating a Presence instance.\n */\nexport interface PresenceOptions<TData> {\n  /** The Effect Schema defining the presence data structure */\n  readonly schema: Schema.Schema<TData>;\n}\n\n/**\n * Infer the data type from a Presence instance.\n */\nexport type Infer<P extends Presence<any>> = P[\"_Data\"];\n\n/**\n * Any Presence type (for generic constraints).\n */\nexport type AnyPresence = Presence<any>;\n\n// =============================================================================\n// Presence Entry (for storage/transport)\n// =============================================================================\n\n/**\n * A presence entry as stored/transmitted.\n */\nexport interface PresenceEntry<TData = unknown> {\n  /** The presence data */\n  readonly data: TData;\n  /** Optional user ID from authentication */\n  readonly userId?: string;\n}\n\n// =============================================================================\n// Factory Function\n// =============================================================================\n\n/**\n * Creates a new Presence schema wrapper.\n *\n * @example\n * ```typescript\n * import { Presence } from \"@voidhash/mimic\";\n * import { Schema } from \"effect\";\n *\n * const CursorPresence = Presence.make({\n *   schema: Schema.Struct({\n *     name: Schema.String,\n *     cursor: Schema.Struct({\n *       x: Schema.Number,\n *       y: Schema.Number,\n *     }),\n *   }),\n * });\n * ```\n */\nexport const make = <TData,>(options: PresenceOptions<TData>): Presence<TData> => ({\n  _tag: \"Presence\",\n  schema: options.schema,\n  _Data: undefined as unknown as TData,\n});\n\n// =============================================================================\n// Validation Functions\n// =============================================================================\n\n/**\n * Validates unknown data against a Presence schema.\n * Throws a ParseError if validation fails.\n *\n * @param presence - The Presence instance with the schema\n * @param data - Unknown data to validate\n * @returns The validated and typed data\n * @throws ParseError if validation fails\n */\nexport const validate = <TData,>(\n  presence: Presence<TData>,\n  data: unknown\n): TData => {\n  return Schema.decodeUnknownSync(presence.schema as any)(data);\n};\n\n/**\n * Safely validates unknown data against a Presence schema.\n * Returns undefined if validation fails instead of throwing.\n *\n * @param presence - The Presence instance with the schema\n * @param data - Unknown data to validate\n * @returns The validated data or undefined if invalid\n */\nexport const validateSafe = <TData,>(\n  presence: Presence<TData>,\n  data: unknown\n): TData | undefined => {\n  try {\n    return Schema.decodeUnknownSync(presence.schema as any)(data);\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Checks if unknown data is valid according to a Presence schema.\n *\n * @param presence - The Presence instance with the schema\n * @param data - Unknown data to check\n * @returns true if valid, false otherwise\n */\nexport const isValid = <TData,>(\n  presence: Presence<TData>,\n  data: unknown\n): data is TData => {\n  try {\n    Schema.decodeUnknownSync(presence.schema as any)(data);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,MAAa,QAAgB,aAAsD;CACjF,MAAM;CACN,QAAQ,QAAQ;CAChB,OAAO;CACR;;;;;;;;;;AAeD,MAAa,YACX,UACA,SACU;AACV,QAAO,OAAO,kBAAkB,SAAS,OAAc,CAAC,KAAK;;;;;;;;;;AAW/D,MAAa,gBACX,UACA,SACsB;AACtB,KAAI;AACF,SAAO,OAAO,kBAAkB,SAAS,OAAc,CAAC,KAAK;mBACvD;AACN;;;;;;;;;;AAWJ,MAAa,WACX,UACA,SACkB;AAClB,KAAI;AACF,SAAO,kBAAkB,SAAS,OAAc,CAAC,KAAK;AACtD,SAAO;oBACD;AACN,SAAO"}

package/dist/SchemaJSON.cjs

@@ -0,0 +1,305 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_objectSpread2 = require('./_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+const require_String = require('./primitives/String.cjs');
+const require_Struct = require('./primitives/Struct.cjs');
+const require_Boolean = require('./primitives/Boolean.cjs');
+const require_Number = require('./primitives/Number.cjs');
+const require_Literal = require('./primitives/Literal.cjs');
+const require_Array = require('./primitives/Array.cjs');
+const require_Lazy = require('./primitives/Lazy.cjs');
+const require_Union = require('./primitives/Union.cjs');
+const require_Either = require('./primitives/Either.cjs');
+const require_TreeNode = require('./primitives/TreeNode.cjs');
+const require_Tree = require('./primitives/Tree.cjs');
+require('./Primitive.cjs');
+
+//#region src/SchemaJSON.ts
+var SchemaJSON_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	fromJSON: () => fromJSON,
+	toJSON: () => toJSON
+});
+function getSchema(primitive) {
+	return primitive._schema;
+}
+function serializeValidators(validators) {
+	const serializable = validators.filter((v) => v.kind != null);
+	if (serializable.length === 0) return void 0;
+	return serializable.map((v) => {
+		const json = { kind: v.kind };
+		if (v.params !== void 0) return require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, json), {}, { params: v.params });
+		return json;
+	});
+}
+function collectTreeNodes(node, visited) {
+	if (visited.has(node.type)) return;
+	visited.set(node.type, node);
+	for (const child of node.children) collectTreeNodes(child, visited);
+}
+function toJSON(primitive) {
+	if (primitive instanceof require_Lazy.LazyPrimitive) return toJSON(primitive._resolve());
+	const schema = getSchema(primitive);
+	if (primitive instanceof require_String.StringPrimitive) {
+		const json = {
+			type: "string",
+			required: schema.required
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		const validators = serializeValidators(schema.validators);
+		if (validators) json.validators = validators;
+		return json;
+	}
+	if (primitive instanceof require_Number.NumberPrimitive) {
+		const json = {
+			type: "number",
+			required: schema.required
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		const validators = serializeValidators(schema.validators);
+		if (validators) json.validators = validators;
+		return json;
+	}
+	if (primitive instanceof require_Boolean.BooleanPrimitive) {
+		const json = {
+			type: "boolean",
+			required: schema.required
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof require_Literal.LiteralPrimitive) {
+		const json = {
+			type: "literal",
+			value: primitive.literal,
+			required: schema.required
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof require_Struct.StructPrimitive) {
+		const fields = {};
+		const structFields = primitive.fields;
+		for (const key in structFields) fields[key] = toJSON(structFields[key]);
+		const json = {
+			type: "struct",
+			required: schema.required,
+			fields
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof require_Array.ArrayPrimitive) {
+		const json = {
+			type: "array",
+			required: schema.required,
+			element: toJSON(primitive.element)
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		const validators = serializeValidators(schema.validators);
+		if (validators) json.validators = validators;
+		return json;
+	}
+	if (primitive instanceof require_Union.UnionPrimitive) {
+		const variants = {};
+		const unionVariants = primitive.variants;
+		for (const key in unionVariants) variants[key] = toJSON(unionVariants[key]);
+		const json = {
+			type: "union",
+			required: schema.required,
+			discriminator: primitive.discriminator,
+			variants
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof require_Either.EitherPrimitive) {
+		const variants = primitive.variants;
+		const json = {
+			type: "either",
+			required: schema.required,
+			variants: variants.map((v) => toJSON(v))
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof require_Tree.TreePrimitive) {
+		const root = primitive.root;
+		const nodeMap = /* @__PURE__ */ new Map();
+		collectTreeNodes(root, nodeMap);
+		const nodes = {};
+		for (const [nodeType, node] of nodeMap) nodes[nodeType] = {
+			type: "treeNode",
+			nodeType,
+			data: toJSON(node.data),
+			children: node.children.map((c) => c.type)
+		};
+		const json = {
+			type: "tree",
+			required: schema.required,
+			root: root.type,
+			nodes
+		};
+		if (schema.defaultInput !== void 0) json.default = schema.defaultInput;
+		return json;
+	}
+	throw new Error(`Unknown primitive type: ${primitive._tag}`);
+}
+function applyStringValidators(p, validators) {
+	let result = p;
+	for (const v of validators) {
+		const params = v.params;
+		switch (v.kind) {
+			case "min":
+				result = result.min(params.value);
+				break;
+			case "max":
+				result = result.max(params.value);
+				break;
+			case "length":
+				result = result.length(params.value);
+				break;
+			case "regex":
+				result = result.regex(new RegExp(params.pattern, params.flags));
+				break;
+			case "email":
+				result = result.email();
+				break;
+			case "url":
+				result = result.url();
+				break;
+		}
+	}
+	return result;
+}
+function applyNumberValidators(p, validators) {
+	let result = p;
+	for (const v of validators) {
+		const params = v.params;
+		switch (v.kind) {
+			case "min":
+				result = result.min(params.value);
+				break;
+			case "max":
+				result = result.max(params.value);
+				break;
+			case "positive":
+				result = result.positive();
+				break;
+			case "negative":
+				result = result.negative();
+				break;
+			case "int":
+				result = result.int();
+				break;
+		}
+	}
+	return result;
+}
+function applyArrayValidators(p, validators) {
+	let result = p;
+	for (const v of validators) {
+		const params = v.params;
+		switch (v.kind) {
+			case "minLength":
+				result = result.minLength(params.value);
+				break;
+			case "maxLength":
+				result = result.maxLength(params.value);
+				break;
+		}
+	}
+	return result;
+}
+function fromJSON(json) {
+	const obj = json;
+	switch (obj.type) {
+		case "string": {
+			let p = require_String.String();
+			if (obj.validators) p = applyStringValidators(p, obj.validators);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "number": {
+			let p = require_Number.Number();
+			if (obj.validators) p = applyNumberValidators(p, obj.validators);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "boolean": {
+			let p = require_Boolean.Boolean();
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "literal": {
+			let p = require_Literal.Literal(obj.value);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "struct": {
+			const fields = {};
+			for (const key in obj.fields) fields[key] = fromJSON(obj.fields[key]);
+			let p = require_Struct.Struct(fields);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "array": {
+			const element = fromJSON(obj.element);
+			let p = require_Array.Array(element);
+			if (obj.validators) p = applyArrayValidators(p, obj.validators);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "union": {
+			const variants = {};
+			for (const key in obj.variants) variants[key] = fromJSON(obj.variants[key]);
+			let p = require_Union.Union({
+				discriminator: obj.discriminator,
+				variants
+			});
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "either": {
+			const variants = obj.variants.map((v) => fromJSON(v));
+			let p = require_Either.Either(...variants);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "tree": {
+			const treeJSON = obj;
+			const nodeMap = /* @__PURE__ */ new Map();
+			const nodeJSONMap = /* @__PURE__ */ new Map();
+			for (const nodeType in treeJSON.nodes) nodeJSONMap.set(nodeType, treeJSON.nodes[nodeType]);
+			for (const [nodeType, nodeJSON] of nodeJSONMap) {
+				const data = fromJSON(nodeJSON.data);
+				const childTypes = nodeJSON.children;
+				const node = require_TreeNode.TreeNode(nodeType, {
+					data,
+					children: () => childTypes.map((ct) => nodeMap.get(ct))
+				});
+				nodeMap.set(nodeType, node);
+			}
+			const root = nodeMap.get(treeJSON.root);
+			let p = require_Tree.Tree({ root });
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		default: throw new Error(`Unknown JSON schema type: ${obj.type}`);
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'SchemaJSON_exports', {
+  enumerable: true,
+  get: function () {
+    return SchemaJSON_exports;
+  }
+});

package/dist/SchemaJSON.d.cts

@@ -0,0 +1,11 @@
+import { AnyPrimitive } from "./primitives/shared.cjs";
+
+//#region src/SchemaJSON.d.ts
+declare namespace SchemaJSON_d_exports {
+  export { fromJSON, toJSON };
+}
+declare function toJSON(primitive: AnyPrimitive): unknown;
+declare function fromJSON(json: unknown): AnyPrimitive;
+//#endregion
+export { SchemaJSON_d_exports };
+//# sourceMappingURL=SchemaJSON.d.cts.map

package/dist/SchemaJSON.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaJSON.d.cts","names":[],"sources":["../src/SchemaJSON.ts"],"sourcesContent":[],"mappings":";;;;;;iBAyHgB,MAAA,YAAkB;iBAsKlB,QAAA,iBAAyB"}

package/dist/SchemaJSON.d.mts

@@ -0,0 +1,11 @@
+import { AnyPrimitive } from "./primitives/shared.mjs";
+
+//#region src/SchemaJSON.d.ts
+declare namespace SchemaJSON_d_exports {
+  export { fromJSON, toJSON };
+}
+declare function toJSON(primitive: AnyPrimitive): unknown;
+declare function fromJSON(json: unknown): AnyPrimitive;
+//#endregion
+export { SchemaJSON_d_exports };
+//# sourceMappingURL=SchemaJSON.d.mts.map

package/dist/SchemaJSON.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaJSON.d.mts","names":[],"sources":["../src/SchemaJSON.ts"],"sourcesContent":[],"mappings":";;;;;;iBAyHgB,MAAA,YAAkB;iBAsKlB,QAAA,iBAAyB"}

package/dist/SchemaJSON.mjs

@@ -0,0 +1,301 @@
+import { __export } from "./_virtual/rolldown_runtime.mjs";
+import { _objectSpread2 } from "./_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.mjs";
+import { String, StringPrimitive } from "./primitives/String.mjs";
+import { Struct, StructPrimitive } from "./primitives/Struct.mjs";
+import { Boolean, BooleanPrimitive } from "./primitives/Boolean.mjs";
+import { Number, NumberPrimitive } from "./primitives/Number.mjs";
+import { Literal, LiteralPrimitive } from "./primitives/Literal.mjs";
+import { Array, ArrayPrimitive } from "./primitives/Array.mjs";
+import { LazyPrimitive } from "./primitives/Lazy.mjs";
+import { Union, UnionPrimitive } from "./primitives/Union.mjs";
+import { Either, EitherPrimitive } from "./primitives/Either.mjs";
+import { TreeNode } from "./primitives/TreeNode.mjs";
+import { Tree, TreePrimitive } from "./primitives/Tree.mjs";
+import "./Primitive.mjs";
+
+//#region src/SchemaJSON.ts
+var SchemaJSON_exports = /* @__PURE__ */ __export({
+	fromJSON: () => fromJSON,
+	toJSON: () => toJSON
+});
+function getSchema(primitive) {
+	return primitive._schema;
+}
+function serializeValidators(validators) {
+	const serializable = validators.filter((v) => v.kind != null);
+	if (serializable.length === 0) return void 0;
+	return serializable.map((v) => {
+		const json = { kind: v.kind };
+		if (v.params !== void 0) return _objectSpread2(_objectSpread2({}, json), {}, { params: v.params });
+		return json;
+	});
+}
+function collectTreeNodes(node, visited) {
+	if (visited.has(node.type)) return;
+	visited.set(node.type, node);
+	for (const child of node.children) collectTreeNodes(child, visited);
+}
+function toJSON(primitive) {
+	if (primitive instanceof LazyPrimitive) return toJSON(primitive._resolve());
+	const schema = getSchema(primitive);
+	if (primitive instanceof StringPrimitive) {
+		const json = {
+			type: "string",
+			required: schema.required
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		const validators = serializeValidators(schema.validators);
+		if (validators) json.validators = validators;
+		return json;
+	}
+	if (primitive instanceof NumberPrimitive) {
+		const json = {
+			type: "number",
+			required: schema.required
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		const validators = serializeValidators(schema.validators);
+		if (validators) json.validators = validators;
+		return json;
+	}
+	if (primitive instanceof BooleanPrimitive) {
+		const json = {
+			type: "boolean",
+			required: schema.required
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof LiteralPrimitive) {
+		const json = {
+			type: "literal",
+			value: primitive.literal,
+			required: schema.required
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof StructPrimitive) {
+		const fields = {};
+		const structFields = primitive.fields;
+		for (const key in structFields) fields[key] = toJSON(structFields[key]);
+		const json = {
+			type: "struct",
+			required: schema.required,
+			fields
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof ArrayPrimitive) {
+		const json = {
+			type: "array",
+			required: schema.required,
+			element: toJSON(primitive.element)
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		const validators = serializeValidators(schema.validators);
+		if (validators) json.validators = validators;
+		return json;
+	}
+	if (primitive instanceof UnionPrimitive) {
+		const variants = {};
+		const unionVariants = primitive.variants;
+		for (const key in unionVariants) variants[key] = toJSON(unionVariants[key]);
+		const json = {
+			type: "union",
+			required: schema.required,
+			discriminator: primitive.discriminator,
+			variants
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof EitherPrimitive) {
+		const variants = primitive.variants;
+		const json = {
+			type: "either",
+			required: schema.required,
+			variants: variants.map((v) => toJSON(v))
+		};
+		if (schema.defaultValue !== void 0) json.default = schema.defaultValue;
+		return json;
+	}
+	if (primitive instanceof TreePrimitive) {
+		const root = primitive.root;
+		const nodeMap = /* @__PURE__ */ new Map();
+		collectTreeNodes(root, nodeMap);
+		const nodes = {};
+		for (const [nodeType, node] of nodeMap) nodes[nodeType] = {
+			type: "treeNode",
+			nodeType,
+			data: toJSON(node.data),
+			children: node.children.map((c) => c.type)
+		};
+		const json = {
+			type: "tree",
+			required: schema.required,
+			root: root.type,
+			nodes
+		};
+		if (schema.defaultInput !== void 0) json.default = schema.defaultInput;
+		return json;
+	}
+	throw new Error(`Unknown primitive type: ${primitive._tag}`);
+}
+function applyStringValidators(p, validators) {
+	let result = p;
+	for (const v of validators) {
+		const params = v.params;
+		switch (v.kind) {
+			case "min":
+				result = result.min(params.value);
+				break;
+			case "max":
+				result = result.max(params.value);
+				break;
+			case "length":
+				result = result.length(params.value);
+				break;
+			case "regex":
+				result = result.regex(new RegExp(params.pattern, params.flags));
+				break;
+			case "email":
+				result = result.email();
+				break;
+			case "url":
+				result = result.url();
+				break;
+		}
+	}
+	return result;
+}
+function applyNumberValidators(p, validators) {
+	let result = p;
+	for (const v of validators) {
+		const params = v.params;
+		switch (v.kind) {
+			case "min":
+				result = result.min(params.value);
+				break;
+			case "max":
+				result = result.max(params.value);
+				break;
+			case "positive":
+				result = result.positive();
+				break;
+			case "negative":
+				result = result.negative();
+				break;
+			case "int":
+				result = result.int();
+				break;
+		}
+	}
+	return result;
+}
+function applyArrayValidators(p, validators) {
+	let result = p;
+	for (const v of validators) {
+		const params = v.params;
+		switch (v.kind) {
+			case "minLength":
+				result = result.minLength(params.value);
+				break;
+			case "maxLength":
+				result = result.maxLength(params.value);
+				break;
+		}
+	}
+	return result;
+}
+function fromJSON(json) {
+	const obj = json;
+	switch (obj.type) {
+		case "string": {
+			let p = String();
+			if (obj.validators) p = applyStringValidators(p, obj.validators);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "number": {
+			let p = Number();
+			if (obj.validators) p = applyNumberValidators(p, obj.validators);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "boolean": {
+			let p = Boolean();
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "literal": {
+			let p = Literal(obj.value);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "struct": {
+			const fields = {};
+			for (const key in obj.fields) fields[key] = fromJSON(obj.fields[key]);
+			let p = Struct(fields);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "array": {
+			const element = fromJSON(obj.element);
+			let p = Array(element);
+			if (obj.validators) p = applyArrayValidators(p, obj.validators);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "union": {
+			const variants = {};
+			for (const key in obj.variants) variants[key] = fromJSON(obj.variants[key]);
+			let p = Union({
+				discriminator: obj.discriminator,
+				variants
+			});
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "either": {
+			const variants = obj.variants.map((v) => fromJSON(v));
+			let p = Either(...variants);
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		case "tree": {
+			const treeJSON = obj;
+			const nodeMap = /* @__PURE__ */ new Map();
+			const nodeJSONMap = /* @__PURE__ */ new Map();
+			for (const nodeType in treeJSON.nodes) nodeJSONMap.set(nodeType, treeJSON.nodes[nodeType]);
+			for (const [nodeType, nodeJSON] of nodeJSONMap) {
+				const data = fromJSON(nodeJSON.data);
+				const childTypes = nodeJSON.children;
+				const node = TreeNode(nodeType, {
+					data,
+					children: () => childTypes.map((ct) => nodeMap.get(ct))
+				});
+				nodeMap.set(nodeType, node);
+			}
+			const root = nodeMap.get(treeJSON.root);
+			let p = Tree({ root });
+			if (obj.required) p = p.required();
+			if (obj.default !== void 0) p = p.default(obj.default);
+			return p;
+		}
+		default: throw new Error(`Unknown JSON schema type: ${obj.type}`);
+	}
+}
+
+//#endregion
+export { SchemaJSON_exports };
+//# sourceMappingURL=SchemaJSON.mjs.map