@voidhash/mimic 0.0.2 → 0.0.3

package/dist/Operation.mjs

@@ -0,0 +1,46 @@
+import { __export } from "./_virtual/rolldown_runtime.mjs";
+import { decode as decode$1, encode as encode$1 } from "./OperationPath.mjs";
+
+//#region src/Operation.ts
+var Operation_exports = /* @__PURE__ */ __export({
+	decode: () => decode,
+	encode: () => encode,
+	fromDefinition: () => fromDefinition
+});
+const fromDefinition = (operationPath, definition, payload) => {
+	return {
+		kind: definition.kind,
+		path: operationPath,
+		payload
+	};
+};
+/**
+* Encodes an Operation to a JSON-serializable format for network transport.
+* @param operation - The operation to encode.
+* @returns The encoded representation.
+*/
+const encode = (operation) => {
+	return {
+		kind: operation.kind,
+		path: encode$1(operation.path),
+		payload: operation.payload
+	};
+};
+/**
+* Decodes an encoded operation back to an Operation.
+* Note: This returns a partial operation without the definition methods.
+* The caller must have the operation definitions to fully reconstruct if needed.
+* @param encoded - The encoded representation.
+* @returns The decoded Operation (without definition-specific methods).
+*/
+const decode = (encoded) => {
+	return {
+		kind: encoded.kind,
+		path: decode$1(encoded.path),
+		payload: encoded.payload
+	};
+};
+
+//#endregion
+export { Operation_exports, decode, encode, fromDefinition };
+//# sourceMappingURL=Operation.mjs.map

package/dist/Operation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Operation.mjs","names":["OperationPath.encode","OperationPath.decode"],"sources":["../src/Operation.ts"],"sourcesContent":["\nimport * as OperationPath from \"./OperationPath\"\nimport * as OperationDefinition from \"./OperationDefinition\"\nimport { Schema } from \"effect\";\n\n\nexport type Operation<TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>> = {\n    readonly kind: TKind\n    readonly path: OperationPath.OperationPath\n    readonly payload: Schema.Schema.Type<TPayload>,\n\n} & TDef\n\nexport const fromDefinition = <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>>(operationPath: OperationPath.OperationPath, definition: TDef, payload: Schema.Schema.Type<TPayload>): Operation<TKind, TPayload, TDef> => {\n    return {\n        kind: definition.kind,\n        path: operationPath,\n        payload: payload,\n    } as Operation<TKind, TPayload, TDef>\n}\n\n/**\n * Encoded representation of an Operation for network transport.\n */\nexport interface EncodedOperation {\n    readonly kind: unknown\n    readonly path: OperationPath.EncodedOperationPath\n    readonly payload: unknown\n}\n\n/**\n * Encodes an Operation to a JSON-serializable format for network transport.\n * @param operation - The operation to encode.\n * @returns The encoded representation.\n */\nexport const encode = <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>>(\n    operation: Operation<TKind, TPayload, TDef>\n): EncodedOperation => {\n    return {\n        kind: operation.kind,\n        path: OperationPath.encode(operation.path),\n        payload: operation.payload,\n    }\n}\n\n/**\n * Decodes an encoded operation back to an Operation.\n * Note: This returns a partial operation without the definition methods.\n * The caller must have the operation definitions to fully reconstruct if needed.\n * @param encoded - The encoded representation.\n * @returns The decoded Operation (without definition-specific methods).\n */\nexport const decode = (encoded: EncodedOperation): Operation<unknown, Schema.Schema.Any, any> => {\n    return {\n        kind: encoded.kind,\n        path: OperationPath.decode(encoded.path),\n        payload: encoded.payload,\n    } as Operation<unknown, Schema.Schema.Any, any>\n}"],"mappings":";;;;;;;;;AAaA,MAAa,kBAAyI,eAA4C,YAAkB,YAA4E;AAC5R,QAAO;EACH,MAAM,WAAW;EACjB,MAAM;EACG;EACZ;;;;;;;AAiBL,MAAa,UACT,cACmB;AACnB,QAAO;EACH,MAAM,UAAU;EAChB,MAAMA,SAAqB,UAAU,KAAK;EAC1C,SAAS,UAAU;EACtB;;;;;;;;;AAUL,MAAa,UAAU,YAA0E;AAC7F,QAAO;EACH,MAAM,QAAQ;EACd,MAAMC,SAAqB,QAAQ,KAAK;EACxC,SAAS,QAAQ;EACpB"}

package/dist/OperationDefinition.cjs

@@ -0,0 +1,13 @@
+
+//#region src/OperationDefinition.ts
+const make = (options) => {
+	return {
+		kind: options.kind,
+		payload: options.payload,
+		target: options.target,
+		apply: options.apply
+	};
+};
+
+//#endregion
+exports.make = make;

package/dist/OperationDefinition.d.cts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+
+//#region src/OperationDefinition.d.ts
+
+interface OperationDefinition<TKind, TPayload extends Schema.Schema.Any, TTarget extends Schema.Schema.Any> {
+  readonly kind: TKind;
+  readonly payload: TPayload;
+  readonly target: TTarget;
+}
+//#endregion
+export { OperationDefinition };
+//# sourceMappingURL=OperationDefinition.d.cts.map

package/dist/OperationDefinition.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationDefinition.d.cts","names":[],"sources":["../src/OperationDefinition.ts"],"sourcesContent":[],"mappings":";;;;AAI6D,UAA5C,mBAA0D,CAAA,KAAA,EAAA,iBAAd,MAAA,CAAO,MAAA,CAAO,GAAA,EAAA,gBAAqB,MAAA,CAAO,MAAA,CAAO,GAAnC,CAAA,CAAA;EAAqB,SAAO,IAAO,EAC3F,KAD2F;EAC3F,SAAA,OAAA,EACG,QADH;EACG,SAAA,MAAA,EACD,OADC"}

package/dist/OperationDefinition.d.mts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+
+//#region src/OperationDefinition.d.ts
+
+interface OperationDefinition<TKind, TPayload extends Schema.Schema.Any, TTarget extends Schema.Schema.Any> {
+  readonly kind: TKind;
+  readonly payload: TPayload;
+  readonly target: TTarget;
+}
+//#endregion
+export { OperationDefinition };
+//# sourceMappingURL=OperationDefinition.d.mts.map

package/dist/OperationDefinition.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationDefinition.d.mts","names":[],"sources":["../src/OperationDefinition.ts"],"sourcesContent":[],"mappings":";;;;AAI6D,UAA5C,mBAA0D,CAAA,KAAA,EAAA,iBAAd,MAAA,CAAO,MAAA,CAAO,GAAA,EAAA,gBAAqB,MAAA,CAAO,MAAA,CAAO,GAAnC,CAAA,CAAA;EAAqB,SAAO,IAAO,EAC3F,KAD2F;EAC3F,SAAA,OAAA,EACG,QADH;EACG,SAAA,MAAA,EACD,OADC"}

package/dist/OperationDefinition.mjs

@@ -0,0 +1,13 @@
+//#region src/OperationDefinition.ts
+const make = (options) => {
+	return {
+		kind: options.kind,
+		payload: options.payload,
+		target: options.target,
+		apply: options.apply
+	};
+};
+
+//#endregion
+export { make };
+//# sourceMappingURL=OperationDefinition.mjs.map

package/dist/OperationDefinition.mjs.map

@@ -0,0 +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}\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}) => {\n    return {\n        kind: options.kind,\n        payload: options.payload,\n        target: options.target,\n        apply: options.apply\n    } as const;\n}"],"mappings":";AAUA,MAAa,QAAsF,YAK7F;AACF,QAAO;EACH,MAAM,QAAQ;EACd,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EAChB,OAAO,QAAQ;EAClB"}

package/dist/OperationPath.cjs

@@ -0,0 +1,148 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+
+//#region src/OperationPath.ts
+var OperationPath_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	decode: () => decode,
+	encode: () => encode,
+	fromTokens: () => fromTokens,
+	getRelativePath: () => getRelativePath,
+	isPrefix: () => isPrefix,
+	make: () => make,
+	pathsEqual: () => pathsEqual,
+	pathsOverlap: () => pathsOverlap
+});
+const parseStringPath = (stringPath) => {
+	return stringPath.split("/");
+};
+const makeStringPathFromTokens = (tokens) => {
+	return tokens.join("/");
+};
+/**
+* Creates a new operation path.
+* @param stringPath - The string path to create the path from.
+* @returns The new operation path.
+*/
+function make(stringPath) {
+	const tokensInternal = stringPath ? parseStringPath(stringPath) : [];
+	/**
+	* Returns the tokens of the path.
+	* @returns The tokens of the path.
+	*/
+	const toTokens = () => {
+		return tokensInternal;
+	};
+	/**
+	* Concatenates two paths.
+	* @param other - The other path to concatenate.
+	* @returns The new path.
+	*/
+	const concat = (other) => {
+		return make(makeStringPathFromTokens(toTokens().concat(other.toTokens())));
+	};
+	/**
+	* Appends a token to the path.
+	* @param token - The token to append.
+	* @returns The new path.
+	*/
+	const append = (token) => {
+		return make(makeStringPathFromTokens(toTokens().concat([token])));
+	};
+	/**
+	* Removes the last token from the path.
+	* @returns The new path.
+	*/
+	const pop = () => {
+		return make(makeStringPathFromTokens(toTokens().slice(0, -1)));
+	};
+	/**
+	* Removes the first token from the path.
+	* @returns The new path.
+	*/
+	const shift = () => {
+		return make(makeStringPathFromTokens(toTokens().slice(1)));
+	};
+	return {
+		_tag: "OperationPath",
+		toTokens,
+		concat,
+		append,
+		pop,
+		shift
+	};
+}
+/**
+* Creates a new operation path from tokens.
+* @param tokens - The tokens to create the path from.
+* @returns The new operation path.
+*/
+function fromTokens(tokens) {
+	return make(makeStringPathFromTokens(tokens));
+}
+/**
+* Checks if two operation paths overlap (one is prefix of the other or equal).
+*/
+const pathsOverlap = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	const minLength = Math.min(tokensA.length, tokensB.length);
+	for (let i = 0; i < minLength; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).
+*/
+const isPrefix = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	if (tokensA.length > tokensB.length) return false;
+	for (let i = 0; i < tokensA.length; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Checks if two paths are exactly equal.
+*/
+const pathsEqual = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	if (tokensA.length !== tokensB.length) return false;
+	for (let i = 0; i < tokensA.length; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Gets the relative path of pathB with respect to pathA.
+* Assumes pathA is a prefix of pathB.
+*/
+const getRelativePath = (basePath, fullPath) => {
+	const baseTokens = basePath.toTokens().filter((t) => t !== "");
+	return fullPath.toTokens().filter((t) => t !== "").slice(baseTokens.length);
+};
+/**
+* Encodes an OperationPath to a string for network transport.
+* @param path - The operation path to encode.
+* @returns The encoded string representation.
+*/
+const encode = (path) => {
+	return makeStringPathFromTokens(path.toTokens());
+};
+/**
+* Decodes an encoded string back to an OperationPath.
+* @param encoded - The encoded string representation.
+* @returns The decoded OperationPath.
+*/
+const decode = (encoded) => {
+	return make(encoded);
+};
+
+//#endregion
+Object.defineProperty(exports, 'OperationPath_exports', {
+  enumerable: true,
+  get: function () {
+    return OperationPath_exports;
+  }
+});
+exports.decode = decode;
+exports.encode = encode;
+exports.isPrefix = isPrefix;
+exports.make = make;
+exports.pathsEqual = pathsEqual;
+exports.pathsOverlap = pathsOverlap;

package/dist/OperationPath.d.cts

@@ -0,0 +1,60 @@
+declare namespace OperationPath_d_exports {
+  export { EncodedOperationPath, OperationPath, OperationPathToken, decode, encode, fromTokens, getRelativePath, isPrefix, make, pathsEqual, pathsOverlap };
+}
+type OperationPathToken = string;
+interface OperationPath {
+  readonly _tag: "OperationPath";
+  readonly toTokens: () => ReadonlyArray<OperationPathToken>;
+  readonly concat: (other: OperationPath) => OperationPath;
+  readonly append: (token: OperationPathToken) => OperationPath;
+  readonly pop: () => OperationPath;
+  readonly shift: () => OperationPath;
+}
+/**
+ * Creates a new operation path.
+ * @param stringPath - The string path to create the path from.
+ * @returns The new operation path.
+ */
+declare function make(stringPath?: string): OperationPath;
+/**
+ * Creates a new operation path from tokens.
+ * @param tokens - The tokens to create the path from.
+ * @returns The new operation path.
+ */
+declare function fromTokens(tokens: ReadonlyArray<OperationPathToken>): OperationPath;
+/**
+ * Checks if two operation paths overlap (one is prefix of the other or equal).
+ */
+declare const pathsOverlap: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).
+ */
+declare const isPrefix: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Checks if two paths are exactly equal.
+ */
+declare const pathsEqual: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Gets the relative path of pathB with respect to pathA.
+ * Assumes pathA is a prefix of pathB.
+ */
+declare const getRelativePath: (basePath: OperationPath, fullPath: OperationPath) => string[];
+/**
+ * Encoded representation of an OperationPath for network transport.
+ */
+type EncodedOperationPath = string;
+/**
+ * Encodes an OperationPath to a string for network transport.
+ * @param path - The operation path to encode.
+ * @returns The encoded string representation.
+ */
+declare const encode: (path: OperationPath) => EncodedOperationPath;
+/**
+ * Decodes an encoded string back to an OperationPath.
+ * @param encoded - The encoded string representation.
+ * @returns The decoded OperationPath.
+ */
+declare const decode: (encoded: EncodedOperationPath) => OperationPath;
+//#endregion
+export { EncodedOperationPath, OperationPath, OperationPath_d_exports };
+//# sourceMappingURL=OperationPath.d.cts.map

package/dist/OperationPath.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationPath.d.cts","names":[],"sources":["../src/OperationPath.ts"],"sourcesContent":[],"mappings":";;;KACY,kBAAA;UAEK,aAAA;;2BAEY,cAAc;2BACd,kBAAkB;2BAClB,uBAAuB;sBAC5B;wBACE;;;;;;;iBAgBV,IAAA,uBAA2B;;AAxB3C;AAEA;;;AAG6B,iBAgFb,UAAA,CAhFa,MAAA,EAgFM,aAhFN,CAgFoB,kBAhFpB,CAAA,CAAA,EAgF0C,aAhF1C;;;;AAEL,cAyFX,YAzFW,EAAA,CAAA,KAAA,EA0Ff,aA1Fe,EAAA,KAAA,EA2Ff,aA3Fe,EAAA,GAAA,OAAA;;;AAiBxB;AA6DgB,cAgCH,QAhCa,EAAA,CAAA,KAAA,EAiCjB,aAjCiB,EAAA,KAAA,EAkCjB,aAlCiB,EAAA,GAAA,OAAA;;;;AAA0D,cAuDvE,UAvDuE,EAAA,CAAA,KAAA,EAwD3E,aAxD2E,EAAA,KAAA,EAyD3E,aAzD2E,EAAA,GAAA,OAAA;AAWpF;AAqBA;AAuBA;AAwBA;AAaY,cAbC,eAamB,EAAA,CAAA,QAAA,EAZpB,aAYoB,EAAA,QAAA,EAXpB,aAWoB,EAAA,GAAA,MAAA,EAAA;AAOhC;AASA;;KAhBY,oBAAA;;;;;;cAOC,eAAgB,kBAAgB;;;;;;cAShC,kBAAmB,yBAAuB"}

package/dist/OperationPath.d.mts

@@ -0,0 +1,60 @@
+declare namespace OperationPath_d_exports {
+  export { EncodedOperationPath, OperationPath, OperationPathToken, decode, encode, fromTokens, getRelativePath, isPrefix, make, pathsEqual, pathsOverlap };
+}
+type OperationPathToken = string;
+interface OperationPath {
+  readonly _tag: "OperationPath";
+  readonly toTokens: () => ReadonlyArray<OperationPathToken>;
+  readonly concat: (other: OperationPath) => OperationPath;
+  readonly append: (token: OperationPathToken) => OperationPath;
+  readonly pop: () => OperationPath;
+  readonly shift: () => OperationPath;
+}
+/**
+ * Creates a new operation path.
+ * @param stringPath - The string path to create the path from.
+ * @returns The new operation path.
+ */
+declare function make(stringPath?: string): OperationPath;
+/**
+ * Creates a new operation path from tokens.
+ * @param tokens - The tokens to create the path from.
+ * @returns The new operation path.
+ */
+declare function fromTokens(tokens: ReadonlyArray<OperationPathToken>): OperationPath;
+/**
+ * Checks if two operation paths overlap (one is prefix of the other or equal).
+ */
+declare const pathsOverlap: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).
+ */
+declare const isPrefix: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Checks if two paths are exactly equal.
+ */
+declare const pathsEqual: (pathA: OperationPath, pathB: OperationPath) => boolean;
+/**
+ * Gets the relative path of pathB with respect to pathA.
+ * Assumes pathA is a prefix of pathB.
+ */
+declare const getRelativePath: (basePath: OperationPath, fullPath: OperationPath) => string[];
+/**
+ * Encoded representation of an OperationPath for network transport.
+ */
+type EncodedOperationPath = string;
+/**
+ * Encodes an OperationPath to a string for network transport.
+ * @param path - The operation path to encode.
+ * @returns The encoded string representation.
+ */
+declare const encode: (path: OperationPath) => EncodedOperationPath;
+/**
+ * Decodes an encoded string back to an OperationPath.
+ * @param encoded - The encoded string representation.
+ * @returns The decoded OperationPath.
+ */
+declare const decode: (encoded: EncodedOperationPath) => OperationPath;
+//#endregion
+export { EncodedOperationPath, OperationPath, OperationPath_d_exports };
+//# sourceMappingURL=OperationPath.d.mts.map

package/dist/OperationPath.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationPath.d.mts","names":[],"sources":["../src/OperationPath.ts"],"sourcesContent":[],"mappings":";;;KACY,kBAAA;UAEK,aAAA;;2BAEY,cAAc;2BACd,kBAAkB;2BAClB,uBAAuB;sBAC5B;wBACE;;;;;;;iBAgBV,IAAA,uBAA2B;;AAxB3C;AAEA;;;AAG6B,iBAgFb,UAAA,CAhFa,MAAA,EAgFM,aAhFN,CAgFoB,kBAhFpB,CAAA,CAAA,EAgF0C,aAhF1C;;;;AAEL,cAyFX,YAzFW,EAAA,CAAA,KAAA,EA0Ff,aA1Fe,EAAA,KAAA,EA2Ff,aA3Fe,EAAA,GAAA,OAAA;;;AAiBxB;AA6DgB,cAgCH,QAhCa,EAAA,CAAA,KAAA,EAiCjB,aAjCiB,EAAA,KAAA,EAkCjB,aAlCiB,EAAA,GAAA,OAAA;;;;AAA0D,cAuDvE,UAvDuE,EAAA,CAAA,KAAA,EAwD3E,aAxD2E,EAAA,KAAA,EAyD3E,aAzD2E,EAAA,GAAA,OAAA;AAWpF;AAqBA;AAuBA;AAwBA;AAaY,cAbC,eAamB,EAAA,CAAA,QAAA,EAZpB,aAYoB,EAAA,QAAA,EAXpB,aAWoB,EAAA,GAAA,MAAA,EAAA;AAOhC;AASA;;KAhBY,oBAAA;;;;;;cAOC,eAAgB,kBAAgB;;;;;;cAShC,kBAAmB,yBAAuB"}

package/dist/OperationPath.mjs

@@ -0,0 +1,138 @@
+import { __export } from "./_virtual/rolldown_runtime.mjs";
+
+//#region src/OperationPath.ts
+var OperationPath_exports = /* @__PURE__ */ __export({
+	decode: () => decode,
+	encode: () => encode,
+	fromTokens: () => fromTokens,
+	getRelativePath: () => getRelativePath,
+	isPrefix: () => isPrefix,
+	make: () => make,
+	pathsEqual: () => pathsEqual,
+	pathsOverlap: () => pathsOverlap
+});
+const parseStringPath = (stringPath) => {
+	return stringPath.split("/");
+};
+const makeStringPathFromTokens = (tokens) => {
+	return tokens.join("/");
+};
+/**
+* Creates a new operation path.
+* @param stringPath - The string path to create the path from.
+* @returns The new operation path.
+*/
+function make(stringPath) {
+	const tokensInternal = stringPath ? parseStringPath(stringPath) : [];
+	/**
+	* Returns the tokens of the path.
+	* @returns The tokens of the path.
+	*/
+	const toTokens = () => {
+		return tokensInternal;
+	};
+	/**
+	* Concatenates two paths.
+	* @param other - The other path to concatenate.
+	* @returns The new path.
+	*/
+	const concat = (other) => {
+		return make(makeStringPathFromTokens(toTokens().concat(other.toTokens())));
+	};
+	/**
+	* Appends a token to the path.
+	* @param token - The token to append.
+	* @returns The new path.
+	*/
+	const append = (token) => {
+		return make(makeStringPathFromTokens(toTokens().concat([token])));
+	};
+	/**
+	* Removes the last token from the path.
+	* @returns The new path.
+	*/
+	const pop = () => {
+		return make(makeStringPathFromTokens(toTokens().slice(0, -1)));
+	};
+	/**
+	* Removes the first token from the path.
+	* @returns The new path.
+	*/
+	const shift = () => {
+		return make(makeStringPathFromTokens(toTokens().slice(1)));
+	};
+	return {
+		_tag: "OperationPath",
+		toTokens,
+		concat,
+		append,
+		pop,
+		shift
+	};
+}
+/**
+* Creates a new operation path from tokens.
+* @param tokens - The tokens to create the path from.
+* @returns The new operation path.
+*/
+function fromTokens(tokens) {
+	return make(makeStringPathFromTokens(tokens));
+}
+/**
+* Checks if two operation paths overlap (one is prefix of the other or equal).
+*/
+const pathsOverlap = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	const minLength = Math.min(tokensA.length, tokensB.length);
+	for (let i = 0; i < minLength; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).
+*/
+const isPrefix = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	if (tokensA.length > tokensB.length) return false;
+	for (let i = 0; i < tokensA.length; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Checks if two paths are exactly equal.
+*/
+const pathsEqual = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	if (tokensA.length !== tokensB.length) return false;
+	for (let i = 0; i < tokensA.length; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Gets the relative path of pathB with respect to pathA.
+* Assumes pathA is a prefix of pathB.
+*/
+const getRelativePath = (basePath, fullPath) => {
+	const baseTokens = basePath.toTokens().filter((t) => t !== "");
+	return fullPath.toTokens().filter((t) => t !== "").slice(baseTokens.length);
+};
+/**
+* Encodes an OperationPath to a string for network transport.
+* @param path - The operation path to encode.
+* @returns The encoded string representation.
+*/
+const encode = (path) => {
+	return makeStringPathFromTokens(path.toTokens());
+};
+/**
+* Decodes an encoded string back to an OperationPath.
+* @param encoded - The encoded string representation.
+* @returns The decoded OperationPath.
+*/
+const decode = (encoded) => {
+	return make(encoded);
+};
+
+//#endregion
+export { OperationPath_exports, decode, encode, isPrefix, make, pathsEqual, pathsOverlap };
+//# sourceMappingURL=OperationPath.mjs.map

package/dist/OperationPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationPath.mjs","names":["tokensInternal: ReadonlyArray<OperationPathToken>"],"sources":["../src/OperationPath.ts"],"sourcesContent":["// export type OperationPath = string\nexport type OperationPathToken = string\n\nexport interface OperationPath {\n    readonly _tag: \"OperationPath\"\n    readonly toTokens: () => ReadonlyArray<OperationPathToken>\n    readonly concat: (other: OperationPath) => OperationPath\n    readonly append: (token: OperationPathToken) => OperationPath\n    readonly pop: () => OperationPath\n    readonly shift: () => OperationPath\n}\n\nconst parseStringPath = (stringPath: string): ReadonlyArray<OperationPathToken> => {\n    return stringPath.split(\"/\")\n}\n\nconst makeStringPathFromTokens = (tokens: ReadonlyArray<OperationPathToken>): string => {\n    return tokens.join(\"/\")\n}\n\n/**\n * Creates a new operation path.\n * @param stringPath - The string path to create the path from.\n * @returns The new operation path.\n */\nexport function make(stringPath?: string): OperationPath {\n\n    const tokensInternal: ReadonlyArray<OperationPathToken> = stringPath ? parseStringPath(stringPath) : []\n\n    /**\n     * Returns the tokens of the path.\n     * @returns The tokens of the path.\n     */\n    const toTokens = () => {\n        return tokensInternal\n    }\n\n    /**\n     * Concatenates two paths.\n     * @param other - The other path to concatenate.\n     * @returns The new path.\n     */\n    const concat = (other: OperationPath): OperationPath => {\n        return make(makeStringPathFromTokens(toTokens().concat(other.toTokens())))\n    }\n\n    /**\n     * Appends a token to the path.\n     * @param token - The token to append.\n     * @returns The new path.\n     */\n    const append = (token: OperationPathToken): OperationPath => {\n        return make(makeStringPathFromTokens(toTokens().concat([token])))\n    }\n\n    /**\n     * Removes the last token from the path.\n     * @returns The new path.\n     */\n    const pop = (): OperationPath => {\n        return make(makeStringPathFromTokens(toTokens().slice(0, -1)))\n    }\n\n    /**\n     * Removes the first token from the path.\n     * @returns The new path.\n     */\n    const shift = (): OperationPath => {\n        return make(makeStringPathFromTokens(toTokens().slice(1)))\n    }\n\n    return {\n        _tag: \"OperationPath\",\n        toTokens,\n        concat,\n        append,\n        pop,\n        shift\n    } as const\n}\n\n/**\n * Creates a new operation path from tokens.\n * @param tokens - The tokens to create the path from.\n * @returns The new operation path.\n */\nexport function fromTokens(tokens: ReadonlyArray<OperationPathToken>): OperationPath {\n    return make(makeStringPathFromTokens(tokens))\n}\n\n// =============================================================================\n// Path Utility Functions\n// =============================================================================\n\n/**\n * Checks if two operation paths overlap (one is prefix of the other or equal).\n */\nexport const pathsOverlap = (\n  pathA: OperationPath,\n  pathB: OperationPath\n): boolean => {\n  const tokensA = pathA.toTokens().filter((t) => t !== \"\");\n  const tokensB = pathB.toTokens().filter((t) => t !== \"\");\n\n  const minLength = Math.min(tokensA.length, tokensB.length);\n\n  for (let i = 0; i < minLength; i++) {\n    if (tokensA[i] !== tokensB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).\n */\nexport const isPrefix = (\n  pathA: OperationPath,\n  pathB: OperationPath\n): boolean => {\n  const tokensA = pathA.toTokens().filter((t) => t !== \"\");\n  const tokensB = pathB.toTokens().filter((t) => t !== \"\");\n\n  if (tokensA.length > tokensB.length) {\n    return false;\n  }\n\n  for (let i = 0; i < tokensA.length; i++) {\n    if (tokensA[i] !== tokensB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Checks if two paths are exactly equal.\n */\nexport const pathsEqual = (\n  pathA: OperationPath,\n  pathB: OperationPath\n): boolean => {\n  const tokensA = pathA.toTokens().filter((t) => t !== \"\");\n  const tokensB = pathB.toTokens().filter((t) => t !== \"\");\n\n  if (tokensA.length !== tokensB.length) {\n    return false;\n  }\n\n  for (let i = 0; i < tokensA.length; i++) {\n    if (tokensA[i] !== tokensB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Gets the relative path of pathB with respect to pathA.\n * Assumes pathA is a prefix of pathB.\n */\nexport const getRelativePath = (\n  basePath: OperationPath,\n  fullPath: OperationPath\n): string[] => {\n  const baseTokens = basePath.toTokens().filter((t) => t !== \"\");\n  const fullTokens = fullPath.toTokens().filter((t) => t !== \"\");\n\n  return fullTokens.slice(baseTokens.length);\n};\n\n/**\n * Encoded representation of an OperationPath for network transport.\n */\nexport type EncodedOperationPath = string;\n\n/**\n * Encodes an OperationPath to a string for network transport.\n * @param path - The operation path to encode.\n * @returns The encoded string representation.\n */\nexport const encode = (path: OperationPath): EncodedOperationPath => {\n  return makeStringPathFromTokens(path.toTokens());\n};\n\n/**\n * Decodes an encoded string back to an OperationPath.\n * @param encoded - The encoded string representation.\n * @returns The decoded OperationPath.\n */\nexport const decode = (encoded: EncodedOperationPath): OperationPath => {\n  return make(encoded);\n};"],"mappings":";;;;;;;;;;;;;AAYA,MAAM,mBAAmB,eAA0D;AAC/E,QAAO,WAAW,MAAM,IAAI;;AAGhC,MAAM,4BAA4B,WAAsD;AACpF,QAAO,OAAO,KAAK,IAAI;;;;;;;AAQ3B,SAAgB,KAAK,YAAoC;CAErD,MAAMA,iBAAoD,aAAa,gBAAgB,WAAW,GAAG,EAAE;;;;;CAMvG,MAAM,iBAAiB;AACnB,SAAO;;;;;;;CAQX,MAAM,UAAU,UAAwC;AACpD,SAAO,KAAK,yBAAyB,UAAU,CAAC,OAAO,MAAM,UAAU,CAAC,CAAC,CAAC;;;;;;;CAQ9E,MAAM,UAAU,UAA6C;AACzD,SAAO,KAAK,yBAAyB,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;;;;;;CAOrE,MAAM,YAA2B;AAC7B,SAAO,KAAK,yBAAyB,UAAU,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;;;;;;CAOlE,MAAM,cAA6B;AAC/B,SAAO,KAAK,yBAAyB,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;;AAG9D,QAAO;EACH,MAAM;EACN;EACA;EACA;EACA;EACA;EACH;;;;;;;AAQL,SAAgB,WAAW,QAA0D;AACjF,QAAO,KAAK,yBAAyB,OAAO,CAAC;;;;;AAUjD,MAAa,gBACX,OACA,UACY;CACZ,MAAM,UAAU,MAAM,UAAU,CAAC,QAAQ,MAAM,MAAM,GAAG;CACxD,MAAM,UAAU,MAAM,UAAU,CAAC,QAAQ,MAAM,MAAM,GAAG;CAExD,MAAM,YAAY,KAAK,IAAI,QAAQ,QAAQ,QAAQ,OAAO;AAE1D,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,IAC7B,KAAI,QAAQ,OAAO,QAAQ,GACzB,QAAO;AAIX,QAAO;;;;;AAMT,MAAa,YACX,OACA,UACY;CACZ,MAAM,UAAU,MAAM,UAAU,CAAC,QAAQ,MAAM,MAAM,GAAG;CACxD,MAAM,UAAU,MAAM,UAAU,CAAC,QAAQ,MAAM,MAAM,GAAG;AAExD,KAAI,QAAQ,SAAS,QAAQ,OAC3B,QAAO;AAGT,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,IAClC,KAAI,QAAQ,OAAO,QAAQ,GACzB,QAAO;AAIX,QAAO;;;;;AAMT,MAAa,cACX,OACA,UACY;CACZ,MAAM,UAAU,MAAM,UAAU,CAAC,QAAQ,MAAM,MAAM,GAAG;CACxD,MAAM,UAAU,MAAM,UAAU,CAAC,QAAQ,MAAM,MAAM,GAAG;AAExD,KAAI,QAAQ,WAAW,QAAQ,OAC7B,QAAO;AAGT,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,IAClC,KAAI,QAAQ,OAAO,QAAQ,GACzB,QAAO;AAIX,QAAO;;;;;;AAOT,MAAa,mBACX,UACA,aACa;CACb,MAAM,aAAa,SAAS,UAAU,CAAC,QAAQ,MAAM,MAAM,GAAG;AAG9D,QAFmB,SAAS,UAAU,CAAC,QAAQ,MAAM,MAAM,GAAG,CAE5C,MAAM,WAAW,OAAO;;;;;;;AAa5C,MAAa,UAAU,SAA8C;AACnE,QAAO,yBAAyB,KAAK,UAAU,CAAC;;;;;;;AAQlD,MAAa,UAAU,YAAiD;AACtE,QAAO,KAAK,QAAQ"}

package/dist/{Presence-gWrmGBeu.cjs → Presence.cjs}

@@ -1,38 +1,14 @@
-const require_Document = require('./Document-ChuFrTk1.cjs');
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 let effect_Schema = require("effect/Schema");
-effect_Schema = require_Document.__toESM(effect_Schema);
+effect_Schema = require_rolldown_runtime.__toESM(effect_Schema);
 
-//#region \0@oxc-project+runtime@0.103.0/helpers/objectSpread2.js
-function ownKeys(e, r) {
-	var t = Object.keys(e);
-	if (Object.getOwnPropertySymbols) {
-		var o = Object.getOwnPropertySymbols(e);
-		r && (o = o.filter(function(r$1) {
-			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
-		})), t.push.apply(t, o);
-	}
-	return t;
-}
-function _objectSpread2(e) {
-	for (var r = 1; r < arguments.length; r++) {
-		var t = null != arguments[r] ? arguments[r] : {};
-		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
-			require_Document._defineProperty(e, r$1, t[r$1]);
-		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
-			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
-		});
-	}
-	return e;
-}
-
-//#endregion
 //#region src/Presence.ts
 /**
 * @since 0.0.1
 * Presence module for ephemeral per-connection state.
 * Used by both client and server for schema validation.
 */
-var Presence_exports = /* @__PURE__ */ require_Document.__export({
+var Presence_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
 	isValid: () => isValid,
 	make: () => make,
 	validate: () => validate,
@@ -112,15 +88,4 @@ Object.defineProperty(exports, 'Presence_exports', {
     return Presence_exports;
   }
 });
-Object.defineProperty(exports, '_objectSpread2', {
-  enumerable: true,
-  get: function () {
-    return _objectSpread2;
-  }
-});
-Object.defineProperty(exports, 'validate', {
-  enumerable: true,
-  get: function () {
-    return validate;
-  }
-});
+exports.validate = validate;

package/dist/{Presence-N8u7Eppr.d.mts → Presence.d.cts}

@@ -87,5 +87,5 @@ declare const validateSafe: <TData>(presence: Presence<TData>, data: unknown) =>
  */
 declare const isValid: <TData>(presence: Presence<TData>, data: unknown) => data is TData;
 //#endregion
-export { Presence_d_exports as i, Infer as n, PresenceEntry as r, AnyPresence as t };
-//# sourceMappingURL=Presence-N8u7Eppr.d.mts.map
+export { AnyPresence, Infer, PresenceEntry, Presence_d_exports };
+//# sourceMappingURL=Presence.d.cts.map

package/dist/Presence.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Presence.d.cts","names":[],"sources":["../src/Presence.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAeiB;;;mBAGE,MAAA,CAAO,OAAO;;EAHhB,SAAA,KAAQ,EAKP,KALO;;;;;AAWR,UAAA,eAAe,CAAA,KAAA,CAEC,CAAA;EAMrB;EAKA,SAAA,MAAW,EAXJ,MAAA,CAAO,MAWA,CAXO,KAWC,CAAA;AASlC;AA8BA;;;AAAwE,KA5C5D,KA4C4D,CAAA,UA5C5C,QA4C4C,CAAA,GAAA,CAAA,CAAA,GA5C3B,CA4C2B,CAAA,OAAA,CAAA;;;AAmBxE;AACqB,KA3DT,WAAA,GAAc,QA2DL,CAAA,GAAA,CAAA;;;;AAcR,UAhEI,aAyEhB,CAAA,QAAA,OAAA,CAAA,CAAA;EARoB;EAAT,SAAA,IAAA,EA/DK,KA+DL;EAET;EAAK,SAAA,MAAA,CAAA,EAAA,MAAA;AAeR;;;;;;;;;;;;;;;;;;;;cApDa,uBAAyB,gBAAgB,WAAS,SAAS;;;;;;;;;;cAmB3D,4BACD,SAAS,0BAElB;;;;;;;;;cAYU,gCACD,SAAS,0BAElB;;;;;;;;cAeU,2BACD,SAAS,kCAEV"}

package/dist/{Presence-DKKP4v5X.d.cts → Presence.d.mts}

@@ -87,5 +87,5 @@ declare const validateSafe: <TData>(presence: Presence<TData>, data: unknown) =>
  */
 declare const isValid: <TData>(presence: Presence<TData>, data: unknown) => data is TData;
 //#endregion
-export { Presence_d_exports as i, Infer as n, PresenceEntry as r, AnyPresence as t };
-//# sourceMappingURL=Presence-DKKP4v5X.d.cts.map
+export { AnyPresence, Infer, PresenceEntry, Presence_d_exports };
+//# sourceMappingURL=Presence.d.mts.map

package/dist/Presence.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Presence.d.mts","names":[],"sources":["../src/Presence.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAeiB;;;mBAGE,MAAA,CAAO,OAAO;;EAHhB,SAAA,KAAQ,EAKP,KALO;;;;;AAWR,UAAA,eAAe,CAAA,KAAA,CAEC,CAAA;EAMrB;EAKA,SAAA,MAAW,EAXJ,MAAA,CAAO,MAWA,CAXO,KAWC,CAAA;AASlC;AA8BA;;;AAAwE,KA5C5D,KA4C4D,CAAA,UA5C5C,QA4C4C,CAAA,GAAA,CAAA,CAAA,GA5C3B,CA4C2B,CAAA,OAAA,CAAA;;;AAmBxE;AACqB,KA3DT,WAAA,GAAc,QA2DL,CAAA,GAAA,CAAA;;;;AAcR,UAhEI,aAyEhB,CAAA,QAAA,OAAA,CAAA,CAAA;EARoB;EAAT,SAAA,IAAA,EA/DK,KA+DL;EAET;EAAK,SAAA,MAAA,CAAA,EAAA,MAAA;AAeR;;;;;;;;;;;;;;;;;;;;cApDa,uBAAyB,gBAAgB,WAAS,SAAS;;;;;;;;;;cAmB3D,4BACD,SAAS,0BAElB;;;;;;;;;cAYU,gCACD,SAAS,0BAElB;;;;;;;;cAeU,2BACD,SAAS,kCAEV"}