@voidhash/mimic 0.0.2 → 0.0.3

package/dist/Document.d.mts

@@ -0,0 +1,68 @@
+import { Operation } from "./Operation.mjs";
+import { Transaction } from "./Transaction.mjs";
+import { AnyPrimitive, InferProxy, InferSnapshot, InferState } from "./primitives/shared.mjs";
+import "./Primitive.mjs";
+
+//#region src/Document.d.ts
+declare namespace Document_d_exports {
+  export { Document, DocumentOptions, NestedTransactionError, OperationError, make };
+}
+/**
+ * Error thrown when attempting to start a nested transaction.
+ */
+declare class NestedTransactionError extends Error {
+  readonly _tag = "NestedTransactionError";
+  constructor();
+}
+/**
+ * Error thrown when an operation fails to apply.
+ */
+declare class OperationError extends Error {
+  readonly _tag = "OperationError";
+  constructor(message: string);
+}
+/**
+ * A Document manages state for a primitive-based schema with transaction support.
+ */
+interface Document<TSchema extends AnyPrimitive> {
+  /** The schema defining this document's structure */
+  readonly schema: TSchema;
+  /** Root proxy for accessing and modifying document data */
+  readonly root: InferProxy<TSchema>;
+  /** Returns the current document state */
+  get(): InferState<TSchema> | undefined;
+  /**
+   * Returns a readonly snapshot of the entire document state for rendering.
+   * The snapshot is a type-safe, readonly structure where:
+   * - Required fields and fields with defaults are guaranteed to be defined
+   * - Optional fields may be undefined
+   */
+  toSnapshot(): InferSnapshot<TSchema>;
+  /**
+   * Runs a function within a transaction.
+   * All operations are collected and applied atomically.
+   * If the function throws, all changes are rolled back.
+   * @returns The return value of the function
+   */
+  transaction<R>(fn: (root: InferProxy<TSchema>) => R): R;
+  /**
+   * Applies external operations (e.g., from server/peers) to the document.
+   * These operations are NOT added to pending operations.
+   */
+  apply(ops: ReadonlyArray<Operation<any, any, any>>): void;
+  /**
+   * Returns pending local operations as a Transaction and clears the buffer.
+   */
+  flush(): Transaction;
+}
+interface DocumentOptions<TSchema extends AnyPrimitive> {
+  /** Initial state for the document */
+  readonly initial?: InferState<TSchema>;
+}
+/**
+ * Creates a new Document for the given schema.
+ */
+declare const make: <TSchema extends AnyPrimitive>(schema: TSchema, options?: DocumentOptions<TSchema>) => Document<TSchema>;
+//#endregion
+export { Document_d_exports };
+//# sourceMappingURL=Document.d.mts.map

package/dist/Document.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Document.d.mts","names":[],"sources":["../src/Document.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;cAaa,sBAAA,SAA+B,KAAA;;;;;;;cAW/B,cAAA,SAAuB,KAAA;EAXvB,SAAA,IAAA,GAAA,gBAAuB;EAWvB,WAAA,CAAA,OAAe,EAAA,MAAA;AAe5B;;;;AAKiB,UALA,QAKA,CAAA,gBALyB,YAKzB,CAAA,CAAA;EAGa;EAArB,SAAA,MAAA,EANU,OAMV;EAQ+B;EAAxB,SAAA,IAAA,EAXC,UAWD,CAXsB,OAWtB,CAAA;EAQiC;EAArB,GAAA,EAAA,EAhBnB,UAgBmB,CAhBE,OAgBF,CAAA,GAAA,SAAA;EAAkC;;;;;;EAkB7C,UAAA,EAAA,EA1BD,aA0BgB,CA1BQ,OA0BR,CAAA;EAAiB;;;;AAYjD;;EACU,WAAA,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,IAAA,EA/BkB,UA+BlB,CA/BuC,OA+BvC,CAAA,EAAA,GA/BoD,CA+BpD,CAAA,EA/BwD,CA+BxD;EACkB;;;;EACjB,KAAA,CAAA,GAAA,EA3BE,aA2BF,CA3BgB,SA2BhB,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA,CAAA,CAAA,EAAA,IAAA;;;;WAtBA;;UAOM,gCAAgC;;qBAE5B,WAAqB;;;;;cAU7B,uBAAwB,sBAC3B,mBACE,gBAAgB,aACzB,SAAS"}

package/dist/Document.mjs

@@ -0,0 +1,147 @@
+import { __export } from "./_virtual/rolldown_runtime.mjs";
+import { _defineProperty } from "./_virtual/_@oxc-project_runtime@0.103.0/helpers/defineProperty.mjs";
+import { make as make$1 } from "./OperationPath.mjs";
+import { make as make$2 } from "./ProxyEnvironment.mjs";
+import { make as make$3 } from "./Transaction.mjs";
+
+//#region src/Document.ts
+var Document_exports = /* @__PURE__ */ __export({
+	NestedTransactionError: () => NestedTransactionError,
+	OperationError: () => OperationError,
+	make: () => make
+});
+/**
+* Error thrown when attempting to start a nested transaction.
+*/
+var NestedTransactionError = class extends Error {
+	constructor() {
+		super("Nested transactions are not supported");
+		_defineProperty(this, "_tag", "NestedTransactionError");
+		this.name = "NestedTransactionError";
+	}
+};
+/**
+* Error thrown when an operation fails to apply.
+*/
+var OperationError = class extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "_tag", "OperationError");
+		this.name = "OperationError";
+	}
+};
+/**
+* Creates a new Document for the given schema.
+*/
+const make = (schema, options) => {
+	var _options$initial;
+	let _state = (_options$initial = options === null || options === void 0 ? void 0 : options.initial) !== null && _options$initial !== void 0 ? _options$initial : schema._internal.getInitialState();
+	let _pending = [];
+	let _inTransaction = false;
+	let _txOps = [];
+	let _txBaseState = void 0;
+	/**
+	* Gets state at the given path.
+	*/
+	const getStateAtPath = (path) => {
+		const tokens = path.toTokens().filter((t) => t !== "");
+		if (tokens.length === 0) return _state;
+		let current = _state;
+		for (const token of tokens) {
+			if (current === null || current === void 0) return;
+			if (typeof current === "object") {
+				if (Array.isArray(current)) {
+					const entry = current.find((e) => e.id === token);
+					if (entry) {
+						current = entry.value;
+						continue;
+					}
+				}
+				current = current[token];
+			} else return;
+		}
+		return current;
+	};
+	/**
+	* Applies a single operation to the current state.
+	*/
+	const applyOperation = (op) => {
+		try {
+			_state = schema._internal.applyOperation(_state, op);
+		} catch (error) {
+			if (error instanceof Error) throw new OperationError(error.message);
+			throw new OperationError(String(error));
+		}
+	};
+	/**
+	* Handles an operation from a proxy.
+	* In transaction mode: collects operations, applies to state immediately for subsequent reads.
+	* Outside transaction mode: auto-wraps in a single-operation transaction.
+	*/
+	const handleOperation = (op) => {
+		if (_inTransaction) {
+			_txOps.push(op);
+			applyOperation(op);
+		} else {
+			const baseState = _state;
+			try {
+				applyOperation(op);
+				_pending.push(op);
+			} catch (error) {
+				_state = baseState;
+				throw error;
+			}
+		}
+	};
+	/**
+	* Creates a ProxyEnvironment for the document.
+	*/
+	const createEnv = () => {
+		return make$2({
+			onOperation: handleOperation,
+			getState: getStateAtPath
+		});
+	};
+	const env = createEnv();
+	const rootProxy = schema._internal.createProxy(env, make$1(""));
+	return {
+		schema,
+		root: rootProxy,
+		get: () => {
+			return _state;
+		},
+		toSnapshot: () => {
+			return rootProxy.toSnapshot();
+		},
+		transaction: (fn) => {
+			if (_inTransaction) throw new NestedTransactionError();
+			_inTransaction = true;
+			_txOps = [];
+			_txBaseState = _state;
+			try {
+				const result = fn(rootProxy);
+				_pending.push(..._txOps);
+				return result;
+			} catch (error) {
+				_state = _txBaseState;
+				throw error;
+			} finally {
+				_inTransaction = false;
+				_txOps = [];
+				_txBaseState = void 0;
+			}
+		},
+		apply: (ops) => {
+			for (const op of ops) applyOperation(op);
+		},
+		flush: () => {
+			const tx = make$3(_pending);
+			_pending = [];
+			return tx;
+		}
+	};
+};
+
+//#endregion
+export { Document_exports, make };
+//# sourceMappingURL=Document.mjs.map

package/dist/Document.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Document.mjs","names":["_state: Primitive.InferState<TSchema> | undefined","_pending: Operation.Operation<any, any, any>[]","_txOps: Operation.Operation<any, any, any>[]","_txBaseState: Primitive.InferState<TSchema> | undefined","current: unknown","ProxyEnvironment.make","OperationPath.make","Transaction.make"],"sources":["../src/Document.ts"],"sourcesContent":["import * as Operation from \"./Operation\";\nimport * as OperationPath from \"./OperationPath\";\nimport * as ProxyEnvironment from \"./ProxyEnvironment\";\nimport * as Transaction from \"./Transaction\";\nimport type * as Primitive from \"./Primitive\";\n\n// =============================================================================\n// Document Errors\n// =============================================================================\n\n/**\n * Error thrown when attempting to start a nested transaction.\n */\nexport class NestedTransactionError extends Error {\n  readonly _tag = \"NestedTransactionError\";\n  constructor() {\n    super(\"Nested transactions are not supported\");\n    this.name = \"NestedTransactionError\";\n  }\n}\n\n/**\n * Error thrown when an operation fails to apply.\n */\nexport class OperationError extends Error {\n  readonly _tag = \"OperationError\";\n  constructor(message: string) {\n    super(message);\n    this.name = \"OperationError\";\n  }\n}\n\n// =============================================================================\n// Document Interface\n// =============================================================================\n\n/**\n * A Document manages state for a primitive-based schema with transaction support.\n */\nexport interface Document<TSchema extends Primitive.AnyPrimitive> {\n  /** The schema defining this document's structure */\n  readonly schema: TSchema;\n  \n  /** Root proxy for accessing and modifying document data */\n  readonly root: Primitive.InferProxy<TSchema>;\n  \n  /** Returns the current document state */\n  get(): Primitive.InferState<TSchema> | undefined;\n  \n  /**\n   * Returns a readonly snapshot of the entire document state for rendering.\n   * The snapshot is a type-safe, readonly structure where:\n   * - Required fields and fields with defaults are guaranteed to be defined\n   * - Optional fields may be undefined\n   */\n  toSnapshot(): Primitive.InferSnapshot<TSchema>;\n  \n  /**\n   * Runs a function within a transaction.\n   * All operations are collected and applied atomically.\n   * If the function throws, all changes are rolled back.\n   * @returns The return value of the function\n   */\n  transaction<R>(fn: (root: Primitive.InferProxy<TSchema>) => R): R;\n  \n  /**\n   * Applies external operations (e.g., from server/peers) to the document.\n   * These operations are NOT added to pending operations.\n   */\n  apply(ops: ReadonlyArray<Operation.Operation<any, any, any>>): void;\n  \n  /**\n   * Returns pending local operations as a Transaction and clears the buffer.\n   */\n  flush(): Transaction.Transaction;\n}\n\n// =============================================================================\n// Document Options\n// =============================================================================\n\nexport interface DocumentOptions<TSchema extends Primitive.AnyPrimitive> {\n  /** Initial state for the document */\n  readonly initial?: Primitive.InferState<TSchema>;\n}\n\n// =============================================================================\n// Document Implementation\n// =============================================================================\n\n/**\n * Creates a new Document for the given schema.\n */\nexport const make = <TSchema extends Primitive.AnyPrimitive>(\n  schema: TSchema,\n  options?: DocumentOptions<TSchema>\n): Document<TSchema> => {\n  // Internal state\n  let _state: Primitive.InferState<TSchema> | undefined = \n    options?.initial ?? schema._internal.getInitialState();\n  \n  // Pending operations buffer (local changes not yet flushed)\n  let _pending: Operation.Operation<any, any, any>[] = [];\n  \n  // Transaction state\n  let _inTransaction = false;\n  let _txOps: Operation.Operation<any, any, any>[] = [];\n  let _txBaseState: Primitive.InferState<TSchema> | undefined = undefined;\n\n  /**\n   * Gets state at the given path.\n   */\n  const getStateAtPath = (path: OperationPath.OperationPath): unknown => {\n    const tokens = path.toTokens().filter(t => t !== \"\");\n    \n    if (tokens.length === 0) {\n      return _state;\n    }\n    \n    let current: unknown = _state;\n    for (const token of tokens) {\n      if (current === null || current === undefined) {\n        return undefined;\n      }\n      \n      if (typeof current === \"object\") {\n        // Handle array entries (which have { id, pos, value } structure)\n        if (Array.isArray(current)) {\n          // Try to find by ID in array entries\n          const entry = current.find((e: any) => e.id === token);\n          if (entry) {\n            current = entry.value;\n            continue;\n          }\n        }\n        \n        // Handle regular object property access\n        current = (current as Record<string, unknown>)[token];\n      } else {\n        return undefined;\n      }\n    }\n    \n    return current;\n  };\n\n  /**\n   * Applies a single operation to the current state.\n   */\n  const applyOperation = (op: Operation.Operation<any, any, any>): void => {\n    try {\n      _state = schema._internal.applyOperation(_state, op);\n    } catch (error) {\n      if (error instanceof Error) {\n        throw new OperationError(error.message);\n      }\n      throw new OperationError(String(error));\n    }\n  };\n\n  /**\n   * Handles an operation from a proxy.\n   * In transaction mode: collects operations, applies to state immediately for subsequent reads.\n   * Outside transaction mode: auto-wraps in a single-operation transaction.\n   */\n  const handleOperation = (op: Operation.Operation<any, any, any>): void => {\n    if (_inTransaction) {\n      // In transaction: collect op and apply immediately for subsequent reads\n      _txOps.push(op);\n      applyOperation(op);\n    } else {\n      // Not in transaction: auto-wrap in single-operation transaction\n      const baseState = _state;\n      try {\n        applyOperation(op);\n        _pending.push(op);\n      } catch (error) {\n        // Rollback on error\n        _state = baseState;\n        throw error;\n      }\n    }\n  };\n\n  /**\n   * Creates a ProxyEnvironment for the document.\n   */\n  const createEnv = (): ProxyEnvironment.ProxyEnvironment => {\n    return ProxyEnvironment.make({\n      onOperation: handleOperation,\n      getState: getStateAtPath,\n    });\n  };\n\n  // Create the root proxy\n  const env = createEnv();\n  const rootProxy = schema._internal.createProxy(env, OperationPath.make(\"\")) as Primitive.InferProxy<TSchema>;\n\n  // Document implementation\n  const document: Document<TSchema> = {\n    schema,\n    root: rootProxy,\n    \n    get: (): Primitive.InferState<TSchema> | undefined => {\n      return _state;\n    },\n    \n    toSnapshot: (): Primitive.InferSnapshot<TSchema> => {\n      return (rootProxy as { toSnapshot(): Primitive.InferSnapshot<TSchema> }).toSnapshot();\n    },\n    \n    transaction: <R,>(fn: (root: Primitive.InferProxy<TSchema>) => R): R => {\n      if (_inTransaction) {\n        throw new NestedTransactionError();\n      }\n      \n      // Start transaction\n      _inTransaction = true;\n      _txOps = [];\n      _txBaseState = _state;\n      \n      try {\n        // Execute the transaction function\n        const result = fn(rootProxy);\n        \n        // Commit: add transaction ops to pending\n        _pending.push(..._txOps);\n        \n        return result;\n      } catch (error) {\n        // Rollback: restore base state\n        _state = _txBaseState;\n        throw error;\n      } finally {\n        // Clean up transaction state\n        _inTransaction = false;\n        _txOps = [];\n        _txBaseState = undefined;\n      }\n    },\n    \n    apply: (ops: ReadonlyArray<Operation.Operation<any, any, any>>): void => {\n      for (const op of ops) {\n        applyOperation(op);\n      }\n    },\n    \n    flush: (): Transaction.Transaction => {\n      const tx = Transaction.make(_pending);\n      _pending = [];\n      return tx;\n    },\n  };\n\n  return document;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAaA,IAAa,yBAAb,cAA4C,MAAM;CAEhD,cAAc;AACZ,QAAM,wCAAwC;wBAFvC,QAAO;AAGd,OAAK,OAAO;;;;;;AAOhB,IAAa,iBAAb,cAAoC,MAAM;CAExC,YAAY,SAAiB;AAC3B,QAAM,QAAQ;wBAFP,QAAO;AAGd,OAAK,OAAO;;;;;;AAiEhB,MAAa,QACX,QACA,YACsB;;CAEtB,IAAIA,+EACF,QAAS,sEAAW,OAAO,UAAU,iBAAiB;CAGxD,IAAIC,WAAiD,EAAE;CAGvD,IAAI,iBAAiB;CACrB,IAAIC,SAA+C,EAAE;CACrD,IAAIC,eAA0D;;;;CAK9D,MAAM,kBAAkB,SAA+C;EACrE,MAAM,SAAS,KAAK,UAAU,CAAC,QAAO,MAAK,MAAM,GAAG;AAEpD,MAAI,OAAO,WAAW,EACpB,QAAO;EAGT,IAAIC,UAAmB;AACvB,OAAK,MAAM,SAAS,QAAQ;AAC1B,OAAI,YAAY,QAAQ,YAAY,OAClC;AAGF,OAAI,OAAO,YAAY,UAAU;AAE/B,QAAI,MAAM,QAAQ,QAAQ,EAAE;KAE1B,MAAM,QAAQ,QAAQ,MAAM,MAAW,EAAE,OAAO,MAAM;AACtD,SAAI,OAAO;AACT,gBAAU,MAAM;AAChB;;;AAKJ,cAAW,QAAoC;SAE/C;;AAIJ,SAAO;;;;;CAMT,MAAM,kBAAkB,OAAiD;AACvE,MAAI;AACF,YAAS,OAAO,UAAU,eAAe,QAAQ,GAAG;WAC7C,OAAO;AACd,OAAI,iBAAiB,MACnB,OAAM,IAAI,eAAe,MAAM,QAAQ;AAEzC,SAAM,IAAI,eAAe,OAAO,MAAM,CAAC;;;;;;;;CAS3C,MAAM,mBAAmB,OAAiD;AACxE,MAAI,gBAAgB;AAElB,UAAO,KAAK,GAAG;AACf,kBAAe,GAAG;SACb;GAEL,MAAM,YAAY;AAClB,OAAI;AACF,mBAAe,GAAG;AAClB,aAAS,KAAK,GAAG;YACV,OAAO;AAEd,aAAS;AACT,UAAM;;;;;;;CAQZ,MAAM,kBAAqD;AACzD,SAAOC,OAAsB;GAC3B,aAAa;GACb,UAAU;GACX,CAAC;;CAIJ,MAAM,MAAM,WAAW;CACvB,MAAM,YAAY,OAAO,UAAU,YAAY,KAAKC,OAAmB,GAAG,CAAC;AA0D3E,QAvDoC;EAClC;EACA,MAAM;EAEN,WAAsD;AACpD,UAAO;;EAGT,kBAAoD;AAClD,UAAQ,UAAiE,YAAY;;EAGvF,cAAkB,OAAsD;AACtE,OAAI,eACF,OAAM,IAAI,wBAAwB;AAIpC,oBAAiB;AACjB,YAAS,EAAE;AACX,kBAAe;AAEf,OAAI;IAEF,MAAM,SAAS,GAAG,UAAU;AAG5B,aAAS,KAAK,GAAG,OAAO;AAExB,WAAO;YACA,OAAO;AAEd,aAAS;AACT,UAAM;aACE;AAER,qBAAiB;AACjB,aAAS,EAAE;AACX,mBAAe;;;EAInB,QAAQ,QAAiE;AACvE,QAAK,MAAM,MAAM,IACf,gBAAe,GAAG;;EAItB,aAAsC;GACpC,MAAM,KAAKC,OAAiB,SAAS;AACrC,cAAW,EAAE;AACb,UAAO;;EAEV"}

package/dist/EffectSchema.cjs

@@ -0,0 +1,180 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let effect = require("effect");
+
+//#region src/EffectSchema.ts
+/**
+* Effect.Schema utilities for converting Mimic primitives to Effect.Schema schemas.
+* 
+* @since 0.0.1
+*/
+var EffectSchema_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	TreeNodeStateSchema: () => TreeNodeStateSchema,
+	toSetSchema: () => toSetSchema,
+	toUpdateSchema: () => toUpdateSchema
+});
+/**
+* Schema for a tree node state (flat storage format).
+*/
+const TreeNodeStateSchema = effect.Schema.Struct({
+	id: effect.Schema.String,
+	type: effect.Schema.String,
+	parentId: effect.Schema.NullOr(effect.Schema.String),
+	pos: effect.Schema.String,
+	data: effect.Schema.Unknown
+});
+/**
+* Check if a field is required for set operations.
+* A field is required if: TRequired is true AND THasDefault is false.
+* 
+* We determine this by checking the primitive's schema properties.
+*/
+function isRequiredForSet(primitive) {
+	const schema = primitive._schema;
+	if (!schema) return false;
+	return schema.required === true && schema.defaultValue === void 0;
+}
+/**
+* Get the base Effect.Schema for a primitive type (without optional wrapper).
+*/
+function getBaseSchema(primitive) {
+	switch (primitive._tag) {
+		case "StringPrimitive": return effect.Schema.String;
+		case "NumberPrimitive": return effect.Schema.Number;
+		case "BooleanPrimitive": return effect.Schema.Boolean;
+		case "LiteralPrimitive": {
+			var _schema$literal, _schema;
+			const literalPrimitive = primitive;
+			const literalValue = (_schema$literal = (_schema = literalPrimitive._schema) === null || _schema === void 0 ? void 0 : _schema.literal) !== null && _schema$literal !== void 0 ? _schema$literal : literalPrimitive.literal;
+			return effect.Schema.Literal(literalValue);
+		}
+		case "StructPrimitive": return buildStructSetSchema(primitive);
+		case "ArrayPrimitive": {
+			const elementSchema = buildElementSetSchema(primitive.element);
+			return effect.Schema.Array(elementSchema);
+		}
+		case "UnionPrimitive": return buildUnionSetSchema(primitive);
+		case "EitherPrimitive": return buildEitherSchema(primitive);
+		case "LazyPrimitive": {
+			var _resolve, _resolve2;
+			const lazyPrimitive = primitive;
+			return getBaseSchema((_resolve = (_resolve2 = lazyPrimitive._resolve) === null || _resolve2 === void 0 ? void 0 : _resolve2.call(lazyPrimitive)) !== null && _resolve !== void 0 ? _resolve : lazyPrimitive._thunk());
+		}
+		case "TreeNodePrimitive": return buildStructSetSchema(primitive.data);
+		case "TreePrimitive": return effect.Schema.Array(TreeNodeStateSchema);
+		default: return effect.Schema.Unknown;
+	}
+}
+/**
+* Build the set schema for a struct primitive.
+* Required fields (required=true, no default) are non-optional.
+* Other fields are wrapped with Schema.optional.
+*/
+function buildStructSetSchema(structPrimitive) {
+	const fields = structPrimitive.fields;
+	const schemaFields = {};
+	for (const key in fields) {
+		const fieldPrimitive = fields[key];
+		const baseSchema = getBaseSchema(fieldPrimitive);
+		if (isRequiredForSet(fieldPrimitive)) schemaFields[key] = baseSchema;
+		else schemaFields[key] = effect.Schema.optional(baseSchema);
+	}
+	return effect.Schema.Struct(schemaFields);
+}
+/**
+* Build the update schema for a struct primitive.
+* All fields are optional for partial updates.
+*/
+function buildStructUpdateSchema(structPrimitive) {
+	const fields = structPrimitive.fields;
+	const schemaFields = {};
+	for (const key in fields) {
+		const fieldPrimitive = fields[key];
+		let fieldSchema;
+		if (fieldPrimitive._tag === "StructPrimitive") fieldSchema = buildStructUpdateSchema(fieldPrimitive);
+		else fieldSchema = getBaseSchema(fieldPrimitive);
+		schemaFields[key] = effect.Schema.optional(fieldSchema);
+	}
+	return effect.Schema.Struct(schemaFields);
+}
+/**
+* Build the set schema for an array element.
+* For struct elements, uses the struct's set input schema.
+*/
+function buildElementSetSchema(elementPrimitive) {
+	if (elementPrimitive._tag === "StructPrimitive") return buildStructSetSchema(elementPrimitive);
+	return getBaseSchema(elementPrimitive);
+}
+/**
+* Build the set schema for a union primitive.
+* Creates a Schema.Union of all variant schemas.
+*/
+function buildUnionSetSchema(unionPrimitive) {
+	const variants = unionPrimitive.variants;
+	const variantSchemas = [];
+	for (const key in variants) {
+		const variantPrimitive = variants[key];
+		variantSchemas.push(buildStructSetSchema(variantPrimitive));
+	}
+	if (variantSchemas.length === 0) return effect.Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return effect.Schema.Union(...variantSchemas);
+}
+/**
+* Build the schema for an either primitive.
+* Creates a Schema.Union of all scalar variant types.
+*/
+function buildEitherSchema(eitherPrimitive) {
+	const variants = eitherPrimitive.variants;
+	const variantSchemas = [];
+	for (const variant of variants) variantSchemas.push(getBaseSchema(variant));
+	if (variantSchemas.length === 0) return effect.Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return effect.Schema.Union(...variantSchemas);
+}
+/**
+* Build the update schema for a union primitive.
+* Creates a Schema.Union of all variant update schemas.
+*/
+function buildUnionUpdateSchema(unionPrimitive) {
+	const variants = unionPrimitive.variants;
+	const variantSchemas = [];
+	for (const key in variants) {
+		const variantPrimitive = variants[key];
+		variantSchemas.push(buildStructUpdateSchema(variantPrimitive));
+	}
+	if (variantSchemas.length === 0) return effect.Schema.Unknown;
+	if (variantSchemas.length === 1) return variantSchemas[0];
+	return effect.Schema.Union(...variantSchemas);
+}
+/**
+* Get the update schema for a primitive.
+* For structs, all fields are optional (partial updates).
+* For simple primitives, same as set schema.
+*/
+function getUpdateSchema(primitive) {
+	switch (primitive._tag) {
+		case "StructPrimitive": return buildStructUpdateSchema(primitive);
+		case "UnionPrimitive": return buildUnionUpdateSchema(primitive);
+		case "TreeNodePrimitive": return buildStructUpdateSchema(primitive.data);
+		case "LazyPrimitive": {
+			var _resolve3, _resolve4;
+			const lazyPrimitive = primitive;
+			return getUpdateSchema((_resolve3 = (_resolve4 = lazyPrimitive._resolve) === null || _resolve4 === void 0 ? void 0 : _resolve4.call(lazyPrimitive)) !== null && _resolve3 !== void 0 ? _resolve3 : lazyPrimitive._thunk());
+		}
+		default: return getBaseSchema(primitive);
+	}
+}
+function toSetSchema(primitive) {
+	return getBaseSchema(primitive);
+}
+function toUpdateSchema(primitive) {
+	return getUpdateSchema(primitive);
+}
+
+//#endregion
+Object.defineProperty(exports, 'EffectSchema_exports', {
+  enumerable: true,
+  get: function () {
+    return EffectSchema_exports;
+  }
+});

package/dist/EffectSchema.d.cts

@@ -0,0 +1,84 @@
+import { AnyPrimitive, InferSetInput, InferUpdateInput } from "./primitives/shared.cjs";
+import { AnyTreeNodePrimitive } from "./primitives/TreeNode.cjs";
+import { Schema } from "effect";
+
+//#region src/EffectSchema.d.ts
+declare namespace EffectSchema_d_exports {
+  export { ToSetSchema, ToTreeNodeSetSchema, ToTreeNodeUpdateSchema, ToUpdateSchema, TreeNodeStateSchema, toSetSchema, toUpdateSchema };
+}
+/**
+ * Infer the Effect.Schema type for a primitive's set input.
+ */
+type ToSetSchema<T extends AnyPrimitive> = Schema.Schema<InferSetInput<T>>;
+/**
+ * Infer the Effect.Schema type for a primitive's update input.
+ */
+type ToUpdateSchema<T extends AnyPrimitive> = Schema.Schema<InferUpdateInput<T>>;
+/**
+ * Type for TreeNode set schema - uses the node's data set input type
+ */
+type ToTreeNodeSetSchema<T extends AnyTreeNodePrimitive> = Schema.Schema<InferSetInput<T["data"]>>;
+/**
+ * Type for TreeNode update schema - uses the node's data update input type
+ */
+type ToTreeNodeUpdateSchema<T extends AnyTreeNodePrimitive> = Schema.Schema<InferUpdateInput<T["data"]>>;
+/**
+ * Schema for a tree node state (flat storage format).
+ */
+declare const TreeNodeStateSchema: Schema.Struct<{
+  id: typeof Schema.String;
+  type: typeof Schema.String;
+  parentId: Schema.NullOr<typeof Schema.String>;
+  pos: typeof Schema.String;
+  data: typeof Schema.Unknown;
+}>;
+/**
+ * Convert a Mimic primitive to an Effect.Schema for set operations.
+ *
+ * The resulting schema:
+ * - For structs: required fields (required=true, no default) are non-optional, others are optional
+ * - For arrays: uses the element's set schema
+ * - For unions: creates a Schema.Union of variant schemas
+ * - For TreeNode: delegates to the node's data struct schema
+ * - For Tree: returns Schema.Array of TreeNodeState
+ *
+ * @example
+ * ```typescript
+ * const UserSchema = Primitive.Struct({
+ *   name: Primitive.String().required(),
+ *   age: Primitive.Number().default(0),
+ *   email: Primitive.String(),
+ * });
+ *
+ * const SetSchema = toSetSchema(UserSchema);
+ * // { name: string, age?: number, email?: string }
+ * ```
+ */
+declare function toSetSchema<T extends AnyPrimitive>(primitive: T): ToSetSchema<T>;
+declare function toSetSchema<T extends AnyTreeNodePrimitive>(primitive: T): ToTreeNodeSetSchema<T>;
+/**
+ * Convert a Mimic primitive to an Effect.Schema for update operations.
+ *
+ * The resulting schema:
+ * - For structs: all fields are optional (partial updates)
+ * - For unions: all variant fields are optional
+ * - For TreeNode: delegates to the node's data struct update schema
+ * - For simple primitives: same as set schema
+ *
+ * @example
+ * ```typescript
+ * const UserSchema = Primitive.Struct({
+ *   name: Primitive.String().required(),
+ *   age: Primitive.Number().default(0),
+ *   email: Primitive.String(),
+ * });
+ *
+ * const UpdateSchema = toUpdateSchema(UserSchema);
+ * // { name?: string, age?: string, email?: string }
+ * ```
+ */
+declare function toUpdateSchema<T extends AnyPrimitive>(primitive: T): ToUpdateSchema<T>;
+declare function toUpdateSchema<T extends AnyTreeNodePrimitive>(primitive: T): ToTreeNodeUpdateSchema<T>;
+//#endregion
+export { EffectSchema_d_exports };
+//# sourceMappingURL=EffectSchema.d.cts.map

package/dist/EffectSchema.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectSchema.d.cts","names":[],"sources":["../src/EffectSchema.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;KAsBY,sBAAsB,gBAAgB,MAAA,CAAO,OAAO,cAAc;;;;AAAlE,KAKA,cALW,CAAA,UAKc,YALd,CAAA,GAK8B,MAAA,CAAO,MALrC,CAK4C,gBAL5C,CAK6D,CAL7D,CAAA,CAAA;;;;AAA2B,KAUtC,mBAV6C,CAAA,UAUf,oBAVe,CAAA,GAUS,MAAA,CAAO,MAVhB,CAUuB,aAVvB,CAUqC,CAVrC,CAAA,MAAA,CAAA,CAAA,CAAA;;AAKzD;;AAAoF,KAUxE,sBAVwE,CAAA,UAUvC,oBAVuC,CAAA,GAUf,MAAA,CAAO,MAVQ,CAUD,gBAVC,CAUgB,CAVhB,CAAA,MAAA,CAAA,CAAA,CAAA;;;;AAKxE,cAcC,mBAdkB,EAcC,MAAA,CAAA,MAdD,CAAA;EAAW,EAAA,EAAA,oBAAA;EAAoD,IAAA,EAAA,oBAAA;EAAd,QAAA,eAAA,CAAA,oBAAA,CAAA;EAAd,GAAA,EAAO,oBAAA;EAAM,IAAA,EAAA,qBAAA;AAK/E,CAAA,CAAA;;;;;;AASA;;;;;;;;;AAwSA;;;;;;AACA;;AAAuE,iBADvD,WACuD,CAAA,UADjC,YACiC,CAAA,CAAA,SAAA,EADR,CACQ,CAAA,EADJ,WACI,CADQ,CACR,CAAA;AAAwB,iBAA/E,WAA+E,CAAA,UAAzD,oBAAyD,CAAA,CAAA,SAAA,EAAxB,CAAwB,CAAA,EAApB,mBAAoB,CAAA,CAAA,CAAA;;;AA0B/F;;;;;;AACA;;;;;;;;;;;;;iBADgB,yBAAyB,yBAAyB,IAAI,eAAe;iBACrE,yBAAyB,iCAAiC,IAAI,uBAAuB"}

package/dist/EffectSchema.d.mts

@@ -0,0 +1,84 @@
+import { AnyPrimitive, InferSetInput, InferUpdateInput } from "./primitives/shared.mjs";
+import { AnyTreeNodePrimitive } from "./primitives/TreeNode.mjs";
+import { Schema } from "effect";
+
+//#region src/EffectSchema.d.ts
+declare namespace EffectSchema_d_exports {
+  export { ToSetSchema, ToTreeNodeSetSchema, ToTreeNodeUpdateSchema, ToUpdateSchema, TreeNodeStateSchema, toSetSchema, toUpdateSchema };
+}
+/**
+ * Infer the Effect.Schema type for a primitive's set input.
+ */
+type ToSetSchema<T extends AnyPrimitive> = Schema.Schema<InferSetInput<T>>;
+/**
+ * Infer the Effect.Schema type for a primitive's update input.
+ */
+type ToUpdateSchema<T extends AnyPrimitive> = Schema.Schema<InferUpdateInput<T>>;
+/**
+ * Type for TreeNode set schema - uses the node's data set input type
+ */
+type ToTreeNodeSetSchema<T extends AnyTreeNodePrimitive> = Schema.Schema<InferSetInput<T["data"]>>;
+/**
+ * Type for TreeNode update schema - uses the node's data update input type
+ */
+type ToTreeNodeUpdateSchema<T extends AnyTreeNodePrimitive> = Schema.Schema<InferUpdateInput<T["data"]>>;
+/**
+ * Schema for a tree node state (flat storage format).
+ */
+declare const TreeNodeStateSchema: Schema.Struct<{
+  id: typeof Schema.String;
+  type: typeof Schema.String;
+  parentId: Schema.NullOr<typeof Schema.String>;
+  pos: typeof Schema.String;
+  data: typeof Schema.Unknown;
+}>;
+/**
+ * Convert a Mimic primitive to an Effect.Schema for set operations.
+ *
+ * The resulting schema:
+ * - For structs: required fields (required=true, no default) are non-optional, others are optional
+ * - For arrays: uses the element's set schema
+ * - For unions: creates a Schema.Union of variant schemas
+ * - For TreeNode: delegates to the node's data struct schema
+ * - For Tree: returns Schema.Array of TreeNodeState
+ *
+ * @example
+ * ```typescript
+ * const UserSchema = Primitive.Struct({
+ *   name: Primitive.String().required(),
+ *   age: Primitive.Number().default(0),
+ *   email: Primitive.String(),
+ * });
+ *
+ * const SetSchema = toSetSchema(UserSchema);
+ * // { name: string, age?: number, email?: string }
+ * ```
+ */
+declare function toSetSchema<T extends AnyPrimitive>(primitive: T): ToSetSchema<T>;
+declare function toSetSchema<T extends AnyTreeNodePrimitive>(primitive: T): ToTreeNodeSetSchema<T>;
+/**
+ * Convert a Mimic primitive to an Effect.Schema for update operations.
+ *
+ * The resulting schema:
+ * - For structs: all fields are optional (partial updates)
+ * - For unions: all variant fields are optional
+ * - For TreeNode: delegates to the node's data struct update schema
+ * - For simple primitives: same as set schema
+ *
+ * @example
+ * ```typescript
+ * const UserSchema = Primitive.Struct({
+ *   name: Primitive.String().required(),
+ *   age: Primitive.Number().default(0),
+ *   email: Primitive.String(),
+ * });
+ *
+ * const UpdateSchema = toUpdateSchema(UserSchema);
+ * // { name?: string, age?: string, email?: string }
+ * ```
+ */
+declare function toUpdateSchema<T extends AnyPrimitive>(primitive: T): ToUpdateSchema<T>;
+declare function toUpdateSchema<T extends AnyTreeNodePrimitive>(primitive: T): ToTreeNodeUpdateSchema<T>;
+//#endregion
+export { EffectSchema_d_exports };
+//# sourceMappingURL=EffectSchema.d.mts.map

package/dist/EffectSchema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectSchema.d.mts","names":[],"sources":["../src/EffectSchema.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;KAsBY,sBAAsB,gBAAgB,MAAA,CAAO,OAAO,cAAc;;;;AAAlE,KAKA,cALW,CAAA,UAKc,YALd,CAAA,GAK8B,MAAA,CAAO,MALrC,CAK4C,gBAL5C,CAK6D,CAL7D,CAAA,CAAA;;;;AAA2B,KAUtC,mBAV6C,CAAA,UAUf,oBAVe,CAAA,GAUS,MAAA,CAAO,MAVhB,CAUuB,aAVvB,CAUqC,CAVrC,CAAA,MAAA,CAAA,CAAA,CAAA;;AAKzD;;AAAoF,KAUxE,sBAVwE,CAAA,UAUvC,oBAVuC,CAAA,GAUf,MAAA,CAAO,MAVQ,CAUD,gBAVC,CAUgB,CAVhB,CAAA,MAAA,CAAA,CAAA,CAAA;;;;AAKxE,cAcC,mBAdkB,EAcC,MAAA,CAAA,MAdD,CAAA;EAAW,EAAA,EAAA,oBAAA;EAAoD,IAAA,EAAA,oBAAA;EAAd,QAAA,eAAA,CAAA,oBAAA,CAAA;EAAd,GAAA,EAAO,oBAAA;EAAM,IAAA,EAAA,qBAAA;AAK/E,CAAA,CAAA;;;;;;AASA;;;;;;;;;AAwSA;;;;;;AACA;;AAAuE,iBADvD,WACuD,CAAA,UADjC,YACiC,CAAA,CAAA,SAAA,EADR,CACQ,CAAA,EADJ,WACI,CADQ,CACR,CAAA;AAAwB,iBAA/E,WAA+E,CAAA,UAAzD,oBAAyD,CAAA,CAAA,SAAA,EAAxB,CAAwB,CAAA,EAApB,mBAAoB,CAAA,CAAA,CAAA;;;AA0B/F;;;;;;AACA;;;;;;;;;;;;;iBADgB,yBAAyB,yBAAyB,IAAI,eAAe;iBACrE,yBAAyB,iCAAiC,IAAI,uBAAuB"}