@gaganref/confect-server 0.0.0-stage → 10.3.1-fork.2

package/dist/QueryStreamIndexRange.d.ts

@@ -0,0 +1,193 @@
+import type { GenericDocument, FieldTypeFromFieldPath, IndexRange as ConvexIndexRange, IndexRangeBuilder as ConvexIndexRangeBuilder } from "convex/server";
+import * as Data from "effect/Data";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import type * as Types from "effect/Types";
+import * as QueryStreamIndexPrefix from "./QueryStreamIndexPrefix";
+import * as QueryStreamKeyBounds from "./QueryStreamKeyBounds";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues";
+import type * as QueryStreamOrderDirection from "./QueryStreamOrderDirection";
+type Head<FieldPaths extends ReadonlyArray<string>> = FieldPaths extends readonly [infer H extends string, ...ReadonlyArray<string>] ? H : never;
+type Tail<FieldPaths extends ReadonlyArray<string>> = FieldPaths extends readonly [
+    string,
+    ...infer Rest extends ReadonlyArray<string>
+] ? Rest : ReadonlyArray<string>;
+declare const TypeId = "~@confect/server/QueryStreamIndexRange";
+interface Equality {
+    readonly fieldPath: string;
+    readonly value: QueryStreamKeyValues.KeyValue;
+}
+interface Endpoint {
+    readonly value: QueryStreamKeyValues.KeyValue;
+    readonly inclusive: boolean;
+}
+type Interval = Data.TaggedEnum<{
+    Lower: {
+        readonly lower: Endpoint;
+    };
+    Upper: {
+        readonly upper: Endpoint;
+    };
+    Between: {
+        readonly lower: Endpoint;
+        readonly upper: Endpoint;
+    };
+}>;
+declare const Interval: {
+    readonly $is: <Tag extends "Between" | "Lower" | "Upper">(tag: Tag) => (u: unknown) => u is Extract<{
+        readonly _tag: "Between";
+        readonly lower: Endpoint;
+        readonly upper: Endpoint;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Lower";
+        readonly lower: Endpoint;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Upper";
+        readonly upper: Endpoint;
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "Between" | "Lower" | "Upper"]: (args: Extract<{
+            readonly _tag: "Between";
+            readonly lower: Endpoint;
+            readonly upper: Endpoint;
+        } | {
+            readonly _tag: "Lower";
+            readonly lower: Endpoint;
+        } | {
+            readonly _tag: "Upper";
+            readonly upper: Endpoint;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
+            readonly _tag: "Between";
+            readonly lower: Endpoint;
+            readonly upper: Endpoint;
+        } | {
+            readonly _tag: "Lower";
+            readonly lower: Endpoint;
+        } | {
+            readonly _tag: "Upper";
+            readonly upper: Endpoint;
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Between" | "Lower" | "Upper"]>>;
+        <Cases extends { readonly [Tag in "Between" | "Lower" | "Upper"]: (args: Extract<{
+            readonly _tag: "Between";
+            readonly lower: Endpoint;
+            readonly upper: Endpoint;
+        } | {
+            readonly _tag: "Lower";
+            readonly lower: Endpoint;
+        } | {
+            readonly _tag: "Upper";
+            readonly upper: Endpoint;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
+            readonly _tag: "Between";
+            readonly lower: Endpoint;
+            readonly upper: Endpoint;
+        } | {
+            readonly _tag: "Lower";
+            readonly lower: Endpoint;
+        } | {
+            readonly _tag: "Upper";
+            readonly upper: Endpoint;
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Between" | "Lower" | "Upper"]>>;
+    };
+    readonly Between: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Between";
+        readonly lower: Endpoint;
+        readonly upper: Endpoint;
+    }, "_tag">;
+    readonly Lower: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Lower";
+        readonly lower: Endpoint;
+    }, "_tag">;
+    readonly Upper: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Upper";
+        readonly upper: Endpoint;
+    }, "_tag">;
+};
+interface Constraints {
+    readonly equalities: ReadonlyArray<Equality>;
+    readonly bounded: Option.Option<{
+        readonly fieldPath: string;
+        readonly interval: Interval;
+    }>;
+}
+/**
+ * The equality prefix followed by at most one bounded field.
+ *
+ * @experimental
+ */
+export interface QueryStreamIndexRange<out RemainingFieldPaths extends ReadonlyArray<string> = ReadonlyArray<string>> {
+    readonly [TypeId]: Constraints & {
+        readonly _Remaining: Types.Covariant<RemainingFieldPaths>;
+    };
+}
+/**
+ * @experimental
+ */
+export type Remaining<IndexRange> = IndexRange extends QueryStreamIndexRange<infer RemainingFieldPaths> ? RemainingFieldPaths : never;
+/**
+ * A typed index-range builder. `eq` must target the next unpinned index field,
+ * and consumes it; `gt`/`gte`/`lt`/`lte` bound the next field without consuming
+ * it (bounded field paths still vary within the range).
+ *
+ * @experimental
+ */
+export interface Builder<ConvexDoc extends GenericDocument, FieldPaths extends ReadonlyArray<string>> extends QueryStreamIndexRange<FieldPaths> {
+    readonly eq: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => Builder<ConvexDoc, Tail<FieldPaths>>;
+    readonly gt: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => LowerBoundedBuilder<ConvexDoc, FieldPaths>;
+    readonly gte: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => LowerBoundedBuilder<ConvexDoc, FieldPaths>;
+    readonly lt: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => QueryStreamIndexRange<FieldPaths>;
+    readonly lte: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => QueryStreamIndexRange<FieldPaths>;
+}
+/**
+ * After `gt`/`gte`, only an upper bound on the same field may follow.
+ *
+ * @experimental
+ */
+export interface LowerBoundedBuilder<ConvexDoc extends GenericDocument, FieldPaths extends ReadonlyArray<string>> extends QueryStreamIndexRange<FieldPaths> {
+    readonly lt: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => QueryStreamIndexRange<FieldPaths>;
+    readonly lte: (fieldPath: Head<FieldPaths>, value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>) => QueryStreamIndexRange<FieldPaths>;
+}
+/**
+ * The initial builder handed to a range callback.
+ *
+ * @experimental
+ */
+export declare const builder: <ConvexDoc extends GenericDocument, FieldPaths extends ReadonlyArray<string>>() => Builder<ConvexDoc, FieldPaths>;
+/**
+ * Number of index fields pinned by equality constraints.
+ *
+ * @experimental
+ */
+export declare const equalityPrefixLength: (self: QueryStreamIndexRange) => number;
+/**
+ * Apply one range to Convex's index-range builder.
+ *
+ * @experimental
+ */
+export declare const apply: (self: QueryStreamIndexRange, q: ConvexIndexRangeBuilder<GenericDocument, string[]>) => ConvexIndexRange;
+/**
+ * Decompose the range between `indexBounds.lower` and `indexBounds.upper` (over
+ * the complete index `fieldPaths`, `_id` tiebreaker included) into a sequence
+ * of Convex-expressible ranges, ordered for the given direction.
+ *
+ * @experimental
+ */
+export declare const fromBounds: (fieldPaths: ReadonlyArray<string>, orderDirection: QueryStreamOrderDirection.QueryStreamOrderDirection, indexBounds: QueryStreamKeyBounds.IndexBounds) => Result.Result<ReadonlyArray<QueryStreamIndexRange>, QueryStreamIndexPrefix.IndexPrefixWidthMismatchError>;
+/**
+ * Derive full-index bounds directly from the structural range.
+ *
+ * @experimental
+ */
+export declare const toBounds: (self: QueryStreamIndexRange) => QueryStreamKeyBounds.IndexBounds;
+export {};
+//# sourceMappingURL=QueryStreamIndexRange.d.ts.map

package/dist/QueryStreamIndexRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamIndexRange.d.ts","sourceRoot":"","sources":["../src/QueryStreamIndexRange.ts"],"names":[],"mappings":"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"}

package/dist/QueryStreamIndexRange.js

@@ -0,0 +1,241 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { ValueOrder } from "./QueryStreamKeyValues.js";
+import { entries, make as make$1 } from "./QueryStreamIndexPrefix.js";
+import { isEmpty } from "./QueryStreamKeyBounds.js";
+import { identity, pipe } from "effect/Function";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Array from "effect/Array";
+import * as Result from "effect/Result";
+import * as Data from "effect/Data";
+//#region src/QueryStreamIndexRange.ts
+var QueryStreamIndexRange_exports = /* @__PURE__ */ __exportAll({
+	apply: () => apply,
+	builder: () => builder,
+	equalityPrefixLength: () => equalityPrefixLength,
+	fromBounds: () => fromBounds,
+	toBounds: () => toBounds
+});
+const TypeId = "~@confect/server/QueryStreamIndexRange";
+const Interval = Data.taggedEnum();
+const make = (constraints) => ({ [TypeId]: {
+	...constraints,
+	_Remaining: identity
+} });
+const makeBuilder = (equalities) => {
+	const upper = (inclusive) => (fieldPath, value) => make({
+		equalities,
+		bounded: Option.some({
+			fieldPath,
+			interval: Interval.Upper({ upper: {
+				value,
+				inclusive
+			} })
+		})
+	});
+	const lower = (inclusive) => (fieldPath, value) => {
+		const endpoint = {
+			value,
+			inclusive
+		};
+		const finish = (upperInclusive) => (_fieldPath, upperValue) => make({
+			equalities,
+			bounded: Option.some({
+				fieldPath,
+				interval: Interval.Between({
+					lower: endpoint,
+					upper: {
+						value: upperValue,
+						inclusive: upperInclusive
+					}
+				})
+			})
+		});
+		return {
+			...make({
+				equalities,
+				bounded: Option.some({
+					fieldPath,
+					interval: Interval.Lower({ lower: endpoint })
+				})
+			}),
+			lt: finish(false),
+			lte: finish(true)
+		};
+	};
+	return {
+		...make({
+			equalities,
+			bounded: Option.none()
+		}),
+		eq: (fieldPath, value) => makeBuilder(Array.append(equalities, {
+			fieldPath,
+			value
+		})),
+		gt: lower(false),
+		gte: lower(true),
+		lt: upper(false),
+		lte: upper(true)
+	};
+};
+/**
+* The initial builder handed to a range callback.
+*
+* @experimental
+*/
+const builder = () => makeBuilder([]);
+/**
+* Number of index fields pinned by equality constraints.
+*
+* @experimental
+*/
+const equalityPrefixLength = (self) => self[TypeId].equalities.length;
+/**
+* Apply one range to Convex's index-range builder.
+*
+* @experimental
+*/
+const apply = (self, q) => {
+	const { equalities, bounded } = self[TypeId];
+	const prefix = Array.reduce(equalities, q, (target, { fieldPath, value }) => target.eq(fieldPath, value));
+	return Option.match(bounded, {
+		onNone: () => prefix,
+		onSome: ({ fieldPath, interval }) => {
+			const lower = (target, endpoint) => target[endpoint.inclusive ? "gte" : "gt"](fieldPath, endpoint.value);
+			const upper = (target, endpoint) => target[endpoint.inclusive ? "lte" : "lt"](fieldPath, endpoint.value);
+			return Interval.$match(interval, {
+				Lower: ({ lower: endpoint }) => lower(prefix, endpoint),
+				Upper: ({ upper: endpoint }) => upper(prefix, endpoint),
+				Between: (endpoints) => upper(lower(prefix, endpoints.lower), endpoints.upper)
+			});
+		}
+	});
+};
+var TaggedBound = class extends Data.Class {};
+/**
+* Dropping a bound's last entry bounds the remaining prefix exclusively.
+*/
+const excludePrefix = (tag) => Match.value(tag).pipe(Match.whenOr("gt", "gte", () => "gt"), Match.whenOr("lt", "lte", () => "lt"), Match.exhaustive);
+/**
+* Peel a bound down to the single entry that feeds the middle range.
+*/
+const peelBound = (indexEntries, tag) => indexEntries.length <= 1 ? {
+	peeled: [],
+	final: new TaggedBound({
+		indexEntries,
+		tag
+	})
+} : pipe(peelBound(Array.dropRight(indexEntries, 1), excludePrefix(tag)), ({ final, peeled }) => ({
+	peeled: Array.prepend(peeled, new TaggedBound({
+		indexEntries,
+		tag
+	})),
+	final
+}));
+/**
+* Pin every entry but the last, which gets the bound tag.
+*/
+const rangeFor = (prefix, indexEntries, tag) => Option.match(Array.last(indexEntries), {
+	onNone: () => make({
+		equalities: prefix,
+		bounded: Option.none()
+	}),
+	onSome: ([fieldPath, value]) => make({
+		equalities: Array.appendAll(prefix, Array.map(Array.dropRight(indexEntries, 1), ([path, pinned]) => ({
+			fieldPath: path,
+			value: pinned
+		}))),
+		bounded: Option.some({
+			fieldPath,
+			interval: tag === "gt" || tag === "gte" ? Interval.Lower({ lower: {
+				value,
+				inclusive: tag === "gte"
+			} }) : Interval.Upper({ upper: {
+				value,
+				inclusive: tag === "lte"
+			} })
+		})
+	})
+});
+/**
+* Decompose the range between `indexBounds.lower` and `indexBounds.upper` (over
+* the complete index `fieldPaths`, `_id` tiebreaker included) into a sequence
+* of Convex-expressible ranges, ordered for the given direction.
+*
+* @experimental
+*/
+const fromBounds = (fieldPaths, orderDirection, indexBounds) => Result.gen(function* () {
+	const lowerIndexEntries = entries(yield* make$1(fieldPaths, indexBounds.lower.keyValues));
+	const upperIndexEntries = entries(yield* make$1(fieldPaths, indexBounds.upper.keyValues));
+	if (isEmpty(indexBounds)) return [];
+	const commonLength = pipe(Array.zip(indexBounds.lower.keyValues, indexBounds.upper.keyValues), Array.takeWhile(([lowerValue, upperValue]) => ValueOrder(lowerValue, upperValue) === 0), Array.length);
+	const equalities = pipe(Array.take(lowerIndexEntries, commonLength), Array.map(([fieldPath, value]) => ({
+		fieldPath,
+		value
+	})));
+	const lower = peelBound(Array.drop(lowerIndexEntries, commonLength), indexBounds.lower.inclusive ? "gte" : "gt");
+	const upper = peelBound(Array.drop(upperIndexEntries, commonLength), indexBounds.upper.inclusive ? "lte" : "lt");
+	const startIndexRanges = Array.map(lower.peeled, ({ indexEntries, tag }) => rangeFor(equalities, indexEntries, tag));
+	const endIndexRanges = Array.reverse(Array.map(upper.peeled, ({ indexEntries, tag }) => rangeFor(equalities, indexEntries, tag)));
+	const { indexEntries: lowerFinalIndexEntries, tag: lowerFinalTag } = lower.final;
+	const { indexEntries: upperFinalIndexEntries, tag: upperFinalTag } = upper.final;
+	const middleIndexRange = Array.isReadonlyArrayNonEmpty(lowerFinalIndexEntries) && Array.isReadonlyArrayNonEmpty(upperFinalIndexEntries) ? make({
+		equalities,
+		bounded: Option.some({
+			fieldPath: Array.headNonEmpty(lowerFinalIndexEntries)[0],
+			interval: Interval.Between({
+				lower: {
+					value: Array.headNonEmpty(lowerFinalIndexEntries)[1],
+					inclusive: lowerFinalTag === "gte"
+				},
+				upper: {
+					value: Array.headNonEmpty(upperFinalIndexEntries)[1],
+					inclusive: upperFinalTag === "lte"
+				}
+			})
+		})
+	}) : Array.isReadonlyArrayNonEmpty(lowerFinalIndexEntries) ? rangeFor(equalities, lowerFinalIndexEntries, lowerFinalTag) : rangeFor(equalities, upperFinalIndexEntries, upperFinalTag);
+	const indexRanges = Array.appendAll(Array.appendAll(startIndexRanges, Array.of(middleIndexRange)), endIndexRanges);
+	return orderDirection === "desc" ? Array.reverse(indexRanges) : indexRanges;
+});
+/**
+* Derive full-index bounds directly from the structural range.
+*
+* @experimental
+*/
+const toBounds = (self) => {
+	const { equalities, bounded } = self[TypeId];
+	const keyValues = Array.map(equalities, (equality) => equality.value);
+	const unbounded = {
+		keyValues,
+		inclusive: true
+	};
+	const endpoint = ({ value, inclusive }) => ({
+		keyValues: Array.append(keyValues, value),
+		inclusive
+	});
+	return Option.match(bounded, {
+		onNone: () => ({
+			lower: unbounded,
+			upper: unbounded
+		}),
+		onSome: ({ interval }) => Interval.$match(interval, {
+			Lower: ({ lower }) => ({
+				lower: endpoint(lower),
+				upper: unbounded
+			}),
+			Upper: ({ upper }) => ({
+				lower: unbounded,
+				upper: endpoint(upper)
+			}),
+			Between: ({ lower, upper }) => ({
+				lower: endpoint(lower),
+				upper: endpoint(upper)
+			})
+		})
+	});
+};
+//#endregion
+export { QueryStreamIndexRange_exports, apply, builder, equalityPrefixLength, fromBounds, toBounds };
+
+//# sourceMappingURL=QueryStreamIndexRange.js.map

package/dist/QueryStreamIndexRange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamIndexRange.js","names":["QueryStreamIndexPrefix.entries","QueryStreamIndexPrefix.make","QueryStreamKeyBounds.isEmpty","QueryStreamKeyValues.ValueOrder"],"sources":["../src/QueryStreamIndexRange.ts"],"sourcesContent":["import type {\n  GenericDocument,\n  FieldTypeFromFieldPath,\n  IndexRange as ConvexIndexRange,\n  IndexRangeBuilder as ConvexIndexRangeBuilder,\n} from \"convex/server\";\nimport * as Array from \"effect/Array\";\nimport * as Data from \"effect/Data\";\nimport { identity, pipe } from \"effect/Function\";\nimport * as Match from \"effect/Match\";\nimport * as Option from \"effect/Option\";\nimport * as Result from \"effect/Result\";\nimport type * as Types from \"effect/Types\";\nimport * as QueryStreamIndexPrefix from \"./QueryStreamIndexPrefix\";\nimport * as QueryStreamKeyBounds from \"./QueryStreamKeyBounds\";\nimport * as QueryStreamKeyValues from \"./QueryStreamKeyValues\";\nimport type * as QueryStreamOrderDirection from \"./QueryStreamOrderDirection\";\n\ntype Head<FieldPaths extends ReadonlyArray<string>> =\n  FieldPaths extends readonly [infer H extends string, ...ReadonlyArray<string>]\n    ? H\n    : never;\n\ntype Tail<FieldPaths extends ReadonlyArray<string>> =\n  FieldPaths extends readonly [\n    string,\n    ...infer Rest extends ReadonlyArray<string>,\n  ]\n    ? Rest\n    : ReadonlyArray<string>;\n\n// The range builder mirrors Convex's `IndexRangeBuilder`, but *consumes* the\n// index-field tuple at the type level as `eq` pins field paths. The remaining\n// tuple supplies the initial visible ordering labels of the resulting stream.\n\nconst TypeId = \"~@confect/server/QueryStreamIndexRange\";\n\ninterface Equality {\n  readonly fieldPath: string;\n  readonly value: QueryStreamKeyValues.KeyValue;\n}\n\ninterface Endpoint {\n  readonly value: QueryStreamKeyValues.KeyValue;\n  readonly inclusive: boolean;\n}\n\ntype Interval = Data.TaggedEnum<{\n  Lower: { readonly lower: Endpoint };\n  Upper: { readonly upper: Endpoint };\n  Between: { readonly lower: Endpoint; readonly upper: Endpoint };\n}>;\nconst Interval = Data.taggedEnum<Interval>();\n\ninterface Constraints {\n  readonly equalities: ReadonlyArray<Equality>;\n  readonly bounded: Option.Option<{\n    readonly fieldPath: string;\n    readonly interval: Interval;\n  }>;\n}\n\n/**\n * The equality prefix followed by at most one bounded field.\n *\n * @experimental\n */\nexport interface QueryStreamIndexRange<\n  out RemainingFieldPaths extends ReadonlyArray<string> = ReadonlyArray<string>,\n> {\n  readonly [TypeId]: Constraints & {\n    readonly _Remaining: Types.Covariant<RemainingFieldPaths>;\n  };\n}\n\n/**\n * @experimental\n */\nexport type Remaining<IndexRange> =\n  IndexRange extends QueryStreamIndexRange<infer RemainingFieldPaths>\n    ? RemainingFieldPaths\n    : never;\n\n/**\n * A typed index-range builder. `eq` must target the next unpinned index field,\n * and consumes it; `gt`/`gte`/`lt`/`lte` bound the next field without consuming\n * it (bounded field paths still vary within the range).\n *\n * @experimental\n */\nexport interface Builder<\n  ConvexDoc extends GenericDocument,\n  FieldPaths extends ReadonlyArray<string>,\n> extends QueryStreamIndexRange<FieldPaths> {\n  readonly eq: (\n    fieldPath: Head<FieldPaths>,\n    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,\n  ) => Builder<ConvexDoc, Tail<FieldPaths>>;\n  readonly gt: (\n    fieldPath: Head<FieldPaths>,\n    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,\n  ) => LowerBoundedBuilder<ConvexDoc, FieldPaths>;\n  readonly gte: (\n    fieldPath: Head<FieldPaths>,\n    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,\n  ) => LowerBoundedBuilder<ConvexDoc, FieldPaths>;\n  readonly lt: (\n    fieldPath: Head<FieldPaths>,\n    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,\n  ) => QueryStreamIndexRange<FieldPaths>;\n  readonly lte: (\n    fieldPath: Head<FieldPaths>,\n    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,\n  ) => QueryStreamIndexRange<FieldPaths>;\n}\n\n/**\n * After `gt`/`gte`, only an upper bound on the same field may follow.\n *\n * @experimental\n */\nexport interface LowerBoundedBuilder<\n  ConvexDoc extends GenericDocument,\n  FieldPaths extends ReadonlyArray<string>,\n> extends QueryStreamIndexRange<FieldPaths> {\n  readonly lt: (\n    fieldPath: Head<FieldPaths>,\n    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,\n  ) => QueryStreamIndexRange<FieldPaths>;\n  readonly lte: (\n    fieldPath: Head<FieldPaths>,\n    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,\n  ) => QueryStreamIndexRange<FieldPaths>;\n}\n\nconst make = (constraints: Constraints): QueryStreamIndexRange => ({\n  [TypeId]: {\n    ...constraints,\n    _Remaining: identity as Types.Covariant<ReadonlyArray<string>>,\n  },\n});\n\nconst makeBuilder = (\n  equalities: ReadonlyArray<Equality>,\n): Builder<GenericDocument, ReadonlyArray<string>> => {\n  const upper =\n    (inclusive: boolean) =>\n    (fieldPath: string, value: QueryStreamKeyValues.KeyValue) =>\n      make({\n        equalities,\n        bounded: Option.some({\n          fieldPath,\n          interval: Interval.Upper({ upper: { value, inclusive } }),\n        }),\n      });\n  const lower =\n    (inclusive: boolean) =>\n    (\n      fieldPath: string,\n      value: QueryStreamKeyValues.KeyValue,\n    ): LowerBoundedBuilder<GenericDocument, ReadonlyArray<string>> => {\n      const endpoint = { value, inclusive };\n      const finish =\n        (upperInclusive: boolean) =>\n        (_fieldPath: string, upperValue: QueryStreamKeyValues.KeyValue) =>\n          make({\n            equalities,\n            bounded: Option.some({\n              fieldPath,\n              interval: Interval.Between({\n                lower: endpoint,\n                upper: { value: upperValue, inclusive: upperInclusive },\n              }),\n            }),\n          });\n      return {\n        ...make({\n          equalities,\n          bounded: Option.some({\n            fieldPath,\n            interval: Interval.Lower({ lower: endpoint }),\n          }),\n        }),\n        lt: finish(false),\n        lte: finish(true),\n      };\n    };\n  return {\n    ...make({ equalities, bounded: Option.none() }),\n    eq: (fieldPath, value) =>\n      makeBuilder(Array.append(equalities, { fieldPath, value })),\n    gt: lower(false),\n    gte: lower(true),\n    lt: upper(false),\n    lte: upper(true),\n  };\n};\n\n/**\n * The initial builder handed to a range callback.\n *\n * @experimental\n */\nexport const builder = <\n  ConvexDoc extends GenericDocument,\n  FieldPaths extends ReadonlyArray<string>,\n>(): Builder<ConvexDoc, FieldPaths> =>\n  makeBuilder([]) as unknown as Builder<ConvexDoc, FieldPaths>;\n\n/**\n * Number of index fields pinned by equality constraints.\n *\n * @experimental\n */\nexport const equalityPrefixLength = (self: QueryStreamIndexRange): number =>\n  self[TypeId].equalities.length;\n\ninterface ConvexUpperBoundBuilder extends ConvexIndexRange {\n  readonly lt: (\n    fieldPath: string,\n    value: QueryStreamKeyValues.KeyValue,\n  ) => ConvexIndexRange;\n  readonly lte: (\n    fieldPath: string,\n    value: QueryStreamKeyValues.KeyValue,\n  ) => ConvexIndexRange;\n}\n\ninterface ConvexRangeBuilder extends ConvexUpperBoundBuilder {\n  readonly eq: (\n    fieldPath: string,\n    value: QueryStreamKeyValues.KeyValue,\n  ) => ConvexRangeBuilder;\n  readonly gt: (\n    fieldPath: string,\n    value: QueryStreamKeyValues.KeyValue,\n  ) => ConvexUpperBoundBuilder;\n  readonly gte: (\n    fieldPath: string,\n    value: QueryStreamKeyValues.KeyValue,\n  ) => ConvexUpperBoundBuilder;\n}\n\n/**\n * Apply one range to Convex's index-range builder.\n *\n * @experimental\n */\nexport const apply = (\n  self: QueryStreamIndexRange,\n  q: ConvexIndexRangeBuilder<GenericDocument, string[]>,\n): ConvexIndexRange => {\n  const { equalities, bounded } = self[TypeId];\n  // Convex tracks equality progress through a static field tuple. These paths\n  // are runtime data; the range model owns their ordering. Its runtime builder\n  // supports further equality calls, even when the SDK type has lost the tuple.\n  const prefix = Array.reduce(\n    equalities,\n    q as ConvexRangeBuilder,\n    (target, { fieldPath, value }) => target.eq(fieldPath, value),\n  );\n  return Option.match(bounded, {\n    onNone: () => prefix,\n    onSome: ({ fieldPath, interval }) => {\n      const lower = (\n        target: ConvexRangeBuilder,\n        endpoint: Endpoint,\n      ): ConvexUpperBoundBuilder =>\n        target[endpoint.inclusive ? \"gte\" : \"gt\"](fieldPath, endpoint.value);\n      const upper = (\n        target: ConvexUpperBoundBuilder,\n        endpoint: Endpoint,\n      ): ConvexIndexRange =>\n        target[endpoint.inclusive ? \"lte\" : \"lt\"](fieldPath, endpoint.value);\n      return Interval.$match(interval, {\n        Lower: ({ lower: endpoint }) => lower(prefix, endpoint),\n        Upper: ({ upper: endpoint }) => upper(prefix, endpoint),\n        Between: (endpoints) =>\n          upper(lower(prefix, endpoints.lower), endpoints.upper),\n      });\n    },\n  });\n};\n\n// Convex index ranges have the shape `eq(f1) … eq(fn), gt/gte(fm)?,\n// lt/lte(fm)?`—every field path pinned except the last, which may carry two\n// inequalities. An arbitrary range between two index keys therefore\n// decomposes into a *sequence* of Convex-expressible ranges (the port of\n// `convex-helpers`' `splitRange`): e.g. `(1, 2, 3) < key <= (1, 3, 2)` over\n// field paths `(f1, f2, f3)` becomes\n//\n//   1. eq(f1, 1), eq(f2, 2), gt(f3, 3)\n//   2. eq(f1, 1), gt(f2, 2), lt(f2, 3)\n//   3. eq(f1, 1), eq(f2, 3), lte(f3, 2)\n\ntype BoundTag = \"gt\" | \"gte\" | \"lt\" | \"lte\";\n\nclass TaggedBound extends Data.Class<{\n  readonly indexEntries: QueryStreamIndexPrefix.IndexEntries;\n  readonly tag: BoundTag;\n}> {}\n\n/**\n * Dropping a bound's last entry bounds the remaining prefix exclusively.\n */\nconst excludePrefix = (tag: BoundTag): BoundTag =>\n  Match.value(tag).pipe(\n    Match.whenOr(\"gt\", \"gte\", () => \"gt\" as const),\n    Match.whenOr(\"lt\", \"lte\", () => \"lt\" as const),\n    Match.exhaustive,\n  );\n\n/**\n * Peel a bound down to the single entry that feeds the middle range.\n */\nconst peelBound = (\n  indexEntries: QueryStreamIndexPrefix.IndexEntries,\n  tag: BoundTag,\n): {\n  readonly peeled: ReadonlyArray<TaggedBound>;\n  readonly final: TaggedBound;\n} =>\n  indexEntries.length <= 1\n    ? { peeled: [], final: new TaggedBound({ indexEntries, tag }) }\n    : pipe(\n        peelBound(Array.dropRight(indexEntries, 1), excludePrefix(tag)),\n        ({ final, peeled }) => ({\n          peeled: Array.prepend(peeled, new TaggedBound({ indexEntries, tag })),\n          final,\n        }),\n      );\n\n/**\n * Pin every entry but the last, which gets the bound tag.\n */\nconst rangeFor = (\n  prefix: ReadonlyArray<Equality>,\n  indexEntries: QueryStreamIndexPrefix.IndexEntries,\n  tag: BoundTag,\n): QueryStreamIndexRange =>\n  Option.match(Array.last(indexEntries), {\n    onNone: () => make({ equalities: prefix, bounded: Option.none() }),\n    onSome: ([fieldPath, value]) =>\n      make({\n        equalities: Array.appendAll(\n          prefix,\n          Array.map(Array.dropRight(indexEntries, 1), ([path, pinned]) => ({\n            fieldPath: path,\n            value: pinned,\n          })),\n        ),\n        bounded: Option.some({\n          fieldPath,\n          interval:\n            tag === \"gt\" || tag === \"gte\"\n              ? Interval.Lower({ lower: { value, inclusive: tag === \"gte\" } })\n              : Interval.Upper({ upper: { value, inclusive: tag === \"lte\" } }),\n        }),\n      }),\n  });\n\n/**\n * Decompose the range between `indexBounds.lower` and `indexBounds.upper` (over\n * the complete index `fieldPaths`, `_id` tiebreaker included) into a sequence\n * of Convex-expressible ranges, ordered for the given direction.\n *\n * @experimental\n */\nexport const fromBounds = (\n  fieldPaths: ReadonlyArray<string>,\n  orderDirection: QueryStreamOrderDirection.QueryStreamOrderDirection,\n  indexBounds: QueryStreamKeyBounds.IndexBounds,\n): Result.Result<\n  ReadonlyArray<QueryStreamIndexRange>,\n  QueryStreamIndexPrefix.IndexPrefixWidthMismatchError\n> =>\n  Result.gen(function* () {\n    const lowerIndexEntries = QueryStreamIndexPrefix.entries(\n      yield* QueryStreamIndexPrefix.make(\n        fieldPaths,\n        indexBounds.lower.keyValues,\n      ),\n    );\n    const upperIndexEntries = QueryStreamIndexPrefix.entries(\n      yield* QueryStreamIndexPrefix.make(\n        fieldPaths,\n        indexBounds.upper.keyValues,\n      ),\n    );\n    // Equal cuts are an empty range too: e.g. lower exclusive at `k` and\n    // upper inclusive at `k`—the half-open (k, k]—both cut at\n    // successor(k).\n    if (QueryStreamKeyBounds.isEmpty(indexBounds)) {\n      return [];\n    }\n\n    const commonLength = pipe(\n      Array.zip(indexBounds.lower.keyValues, indexBounds.upper.keyValues),\n      Array.takeWhile(\n        ([lowerValue, upperValue]) =>\n          QueryStreamKeyValues.ValueOrder(lowerValue, upperValue) === 0,\n      ),\n      Array.length,\n    );\n    const equalities = pipe(\n      Array.take(lowerIndexEntries, commonLength),\n      Array.map(([fieldPath, value]) => ({ fieldPath, value })),\n    );\n\n    const lower = peelBound(\n      Array.drop(lowerIndexEntries, commonLength),\n      indexBounds.lower.inclusive ? \"gte\" : \"gt\",\n    );\n    const upper = peelBound(\n      Array.drop(upperIndexEntries, commonLength),\n      indexBounds.upper.inclusive ? \"lte\" : \"lt\",\n    );\n\n    const startIndexRanges = Array.map(lower.peeled, ({ indexEntries, tag }) =>\n      rangeFor(equalities, indexEntries, tag),\n    );\n    const endIndexRanges = Array.reverse(\n      Array.map(upper.peeled, ({ indexEntries, tag }) =>\n        rangeFor(equalities, indexEntries, tag),\n      ),\n    );\n\n    const { indexEntries: lowerFinalIndexEntries, tag: lowerFinalTag } =\n      lower.final;\n    const { indexEntries: upperFinalIndexEntries, tag: upperFinalTag } =\n      upper.final;\n    const middleIndexRange =\n      Array.isReadonlyArrayNonEmpty(lowerFinalIndexEntries) &&\n      Array.isReadonlyArrayNonEmpty(upperFinalIndexEntries)\n        ? make({\n            equalities,\n            bounded: Option.some({\n              fieldPath: Array.headNonEmpty(lowerFinalIndexEntries)[0],\n              interval: Interval.Between({\n                lower: {\n                  value: Array.headNonEmpty(lowerFinalIndexEntries)[1],\n                  inclusive: lowerFinalTag === \"gte\",\n                },\n                upper: {\n                  value: Array.headNonEmpty(upperFinalIndexEntries)[1],\n                  inclusive: upperFinalTag === \"lte\",\n                },\n              }),\n            }),\n          })\n        : Array.isReadonlyArrayNonEmpty(lowerFinalIndexEntries)\n          ? rangeFor(equalities, lowerFinalIndexEntries, lowerFinalTag)\n          : rangeFor(equalities, upperFinalIndexEntries, upperFinalTag);\n\n    const indexRanges = Array.appendAll(\n      Array.appendAll(startIndexRanges, Array.of(middleIndexRange)),\n      endIndexRanges,\n    );\n    return orderDirection === \"desc\" ? Array.reverse(indexRanges) : indexRanges;\n  });\n\n/**\n * Derive full-index bounds directly from the structural range.\n *\n * @experimental\n */\nexport const toBounds = (\n  self: QueryStreamIndexRange,\n): QueryStreamKeyBounds.IndexBounds => {\n  const { equalities, bounded } = self[TypeId];\n  const keyValues = Array.map(equalities, (equality) => equality.value);\n  const unbounded = { keyValues, inclusive: true };\n  const endpoint = ({ value, inclusive }: Endpoint) => ({\n    keyValues: Array.append(keyValues, value),\n    inclusive,\n  });\n  return Option.match(bounded, {\n    onNone: () => ({ lower: unbounded, upper: unbounded }),\n    onSome: ({ interval }) =>\n      Interval.$match(interval, {\n        Lower: ({ lower }) => ({ lower: endpoint(lower), upper: unbounded }),\n        Upper: ({ upper }) => ({ lower: unbounded, upper: endpoint(upper) }),\n        Between: ({ lower, upper }) => ({\n          lower: endpoint(lower),\n          upper: endpoint(upper),\n        }),\n      }),\n  });\n};\n"],"mappings":"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"}

package/dist/QueryStreamKey.d.ts

@@ -0,0 +1,64 @@
+import * as Data from "effect/Data";
+import * as Result from "effect/Result";
+import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout";
+import type * as QueryStreamKeyValues from "./QueryStreamKeyValues";
+declare const TypeId = "~@confect/server/QueryStreamKey";
+interface Payload {
+    readonly [TypeId]: typeof TypeId;
+    readonly layout: QueryStreamKeyLayout.QueryStreamKeyLayout;
+    readonly values: QueryStreamKeyValues.QueryStreamKeyValues;
+}
+/**
+ * @experimental
+ */
+export type QueryStreamKey = Data.TaggedEnum<{
+    Complete: Payload;
+    Prefix: Payload;
+}>;
+/**
+ * @experimental
+ */
+export type Complete = Data.TaggedEnum.Value<QueryStreamKey, "Complete">;
+/**
+ * @experimental
+ */
+export type Prefix = Data.TaggedEnum.Value<QueryStreamKey, "Prefix">;
+declare const KeyWidthMismatchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "KeyWidthMismatchError";
+} & Readonly<A>;
+/**
+ * @experimental
+ */
+export declare class KeyWidthMismatchError extends KeyWidthMismatchError_base<{
+    readonly kind: "complete" | "prefix";
+    readonly width: number;
+    readonly actual: number;
+}> {
+    get message(): string;
+}
+/**
+ * @experimental
+ */
+export declare const complete: (layout: QueryStreamKeyLayout.QueryStreamKeyLayout, values: QueryStreamKeyValues.QueryStreamKeyValues) => Result.Result<Complete, KeyWidthMismatchError>;
+/**
+ * @experimental
+ */
+export declare const prefix: (layout: QueryStreamKeyLayout.QueryStreamKeyLayout, values: QueryStreamKeyValues.QueryStreamKeyValues) => Result.Result<Prefix, KeyWidthMismatchError>;
+/**
+ * @experimental
+ */
+export declare const toPrefix: (self: Complete) => Prefix;
+/**
+ * @experimental
+ */
+export declare const values: (self: QueryStreamKey) => QueryStreamKeyValues.QueryStreamKeyValues;
+/**
+ * @experimental
+ */
+export declare const layout: (self: QueryStreamKey) => QueryStreamKeyLayout.QueryStreamKeyLayout;
+/**
+ * @experimental
+ */
+export declare const isComplete: (value: unknown) => value is Complete;
+export {};
+//# sourceMappingURL=QueryStreamKey.d.ts.map

package/dist/QueryStreamKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamKey.d.ts","sourceRoot":"","sources":["../src/QueryStreamKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAEpC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,oBAAoB,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,KAAK,oBAAoB,MAAM,wBAAwB,CAAC;AAEpE,QAAA,MAAM,MAAM,oCAAoC,CAAC;AAEjD,UAAU,OAAO;IACf,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,MAAM,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC,oBAAoB,CAAC;IAC3D,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC,oBAAoB,CAAC;CAC5D;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC;IAC3C,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;AAGH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;AACzE;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;;;;AAErE;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,2BAEzC;IACA,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,WACX,oBAAoB,CAAC,oBAAoB,UACzC,oBAAoB,CAAC,oBAAoB,KAChD,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,qBAAqB,CAa/C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,WACT,oBAAoB,CAAC,oBAAoB,UACzC,oBAAoB,CAAC,oBAAoB,KAChD,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAa7C,CAAC;AAGF;;GAEG;AACH,eAAO,MAAM,QAAQ,SAAU,QAAQ,KAAG,MAKtC,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,MAAM,SACX,cAAc,KACnB,oBAAoB,CAAC,oBAAmC,CAAC;AAC5D;;GAEG;AACH,eAAO,MAAM,MAAM,SACX,cAAc,KACnB,oBAAoB,CAAC,oBAAmC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAC0B,CAAC"}

package/dist/QueryStreamKey.js

@@ -0,0 +1,69 @@
+import { runtimeWidth } from "./QueryStreamKeyLayout.js";
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import * as Data from "effect/Data";
+//#region src/QueryStreamKey.ts
+const TypeId = "~@confect/server/QueryStreamKey";
+const QueryStreamKey = Data.taggedEnum();
+/**
+* @experimental
+*/
+var KeyWidthMismatchError = class extends Data.TaggedError("KeyWidthMismatchError") {
+	get message() {
+		return `Invalid ${this.kind} key width (${this.actual}); expected ${this.kind === "complete" ? "exactly" : "at most"} ${this.width}`;
+	}
+};
+/**
+* @experimental
+*/
+const complete = (layout, values) => {
+	const width = runtimeWidth(layout);
+	return values.length === width ? Result.succeed(QueryStreamKey.Complete({
+		[TypeId]: TypeId,
+		layout,
+		values
+	})) : Result.fail(new KeyWidthMismatchError({
+		kind: "complete",
+		width,
+		actual: values.length
+	}));
+};
+/**
+* @experimental
+*/
+const prefix = (layout, values) => {
+	const width = runtimeWidth(layout);
+	return values.length <= width ? Result.succeed(QueryStreamKey.Prefix({
+		[TypeId]: TypeId,
+		layout,
+		values
+	})) : Result.fail(new KeyWidthMismatchError({
+		kind: "prefix",
+		width,
+		actual: values.length
+	}));
+};
+/**
+* @experimental
+*/
+const toPrefix = (self) => QueryStreamKey.Prefix({
+	[TypeId]: TypeId,
+	layout: self.layout,
+	values: self.values
+});
+/**
+* @experimental
+*/
+const values = (self) => self.values;
+/**
+* @experimental
+*/
+const layout = (self) => self.layout;
+/**
+* @experimental
+*/
+const isComplete = (value) => Predicate.hasProperty(value, TypeId) && QueryStreamKey.$is("Complete")(value);
+//#endregion
+export { KeyWidthMismatchError, complete, isComplete, layout, prefix, toPrefix, values };
+
+//# sourceMappingURL=QueryStreamKey.js.map

package/dist/QueryStreamKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamKey.js","names":["QueryStreamKeyLayout.runtimeWidth"],"sources":["../src/QueryStreamKey.ts"],"sourcesContent":["import * as Data from \"effect/Data\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Result from \"effect/Result\";\nimport * as QueryStreamKeyLayout from \"./QueryStreamKeyLayout\";\nimport type * as QueryStreamKeyValues from \"./QueryStreamKeyValues\";\n\nconst TypeId = \"~@confect/server/QueryStreamKey\";\n\ninterface Payload {\n  readonly [TypeId]: typeof TypeId;\n  readonly layout: QueryStreamKeyLayout.QueryStreamKeyLayout;\n  readonly values: QueryStreamKeyValues.QueryStreamKeyValues;\n}\n\n/**\n * @experimental\n */\nexport type QueryStreamKey = Data.TaggedEnum<{\n  Complete: Payload;\n  Prefix: Payload;\n}>;\nconst QueryStreamKey = Data.taggedEnum<QueryStreamKey>();\n\n/**\n * @experimental\n */\nexport type Complete = Data.TaggedEnum.Value<QueryStreamKey, \"Complete\">;\n/**\n * @experimental\n */\nexport type Prefix = Data.TaggedEnum.Value<QueryStreamKey, \"Prefix\">;\n\n/**\n * @experimental\n */\nexport class KeyWidthMismatchError extends Data.TaggedError(\n  \"KeyWidthMismatchError\",\n)<{\n  readonly kind: \"complete\" | \"prefix\";\n  readonly width: number;\n  readonly actual: number;\n}> {\n  override get message(): string {\n    return `Invalid ${this.kind} key width (${this.actual}); expected ${this.kind === \"complete\" ? \"exactly\" : \"at most\"} ${this.width}`;\n  }\n}\n\n/**\n * @experimental\n */\nexport const complete = (\n  layout: QueryStreamKeyLayout.QueryStreamKeyLayout,\n  values: QueryStreamKeyValues.QueryStreamKeyValues,\n): Result.Result<Complete, KeyWidthMismatchError> => {\n  const width = QueryStreamKeyLayout.runtimeWidth(layout);\n  return values.length === width\n    ? Result.succeed(\n        QueryStreamKey.Complete({ [TypeId]: TypeId, layout, values }),\n      )\n    : Result.fail(\n        new KeyWidthMismatchError({\n          kind: \"complete\",\n          width,\n          actual: values.length,\n        }),\n      );\n};\n\n/**\n * @experimental\n */\nexport const prefix = (\n  layout: QueryStreamKeyLayout.QueryStreamKeyLayout,\n  values: QueryStreamKeyValues.QueryStreamKeyValues,\n): Result.Result<Prefix, KeyWidthMismatchError> => {\n  const width = QueryStreamKeyLayout.runtimeWidth(layout);\n  return values.length <= width\n    ? Result.succeed(\n        QueryStreamKey.Prefix({ [TypeId]: TypeId, layout, values }),\n      )\n    : Result.fail(\n        new KeyWidthMismatchError({\n          kind: \"prefix\",\n          width,\n          actual: values.length,\n        }),\n      );\n};\n\n// A complete key already satisfies the prefix width guarantee.\n/**\n * @experimental\n */\nexport const toPrefix = (self: Complete): Prefix =>\n  QueryStreamKey.Prefix({\n    [TypeId]: TypeId,\n    layout: self.layout,\n    values: self.values,\n  });\n\n/**\n * @experimental\n */\nexport const values = (\n  self: QueryStreamKey,\n): QueryStreamKeyValues.QueryStreamKeyValues => self.values;\n/**\n * @experimental\n */\nexport const layout = (\n  self: QueryStreamKey,\n): QueryStreamKeyLayout.QueryStreamKeyLayout => self.layout;\n\n/**\n * @experimental\n */\nexport const isComplete = (value: unknown): value is Complete =>\n  Predicate.hasProperty(value, TypeId) && QueryStreamKey.$is(\"Complete\")(value);\n"],"mappings":";;;;;AAMA,MAAM,SAAS;AAef,MAAM,iBAAiB,KAAK,WAA2B;;;;AAcvD,IAAa,wBAAb,cAA2C,KAAK,YAC9C,uBACF,CAAC,CAIE;CACD,IAAa,UAAkB;EAC7B,OAAO,WAAW,KAAK,KAAK,cAAc,KAAK,OAAO,cAAc,KAAK,SAAS,aAAa,YAAY,UAAU,GAAG,KAAK;CAC/H;AACF;;;;AAKA,MAAa,YACX,QACA,WACmD;CACnD,MAAM,QAAQA,aAAkC,MAAM;CACtD,OAAO,OAAO,WAAW,QACrB,OAAO,QACL,eAAe,SAAS;GAAG,SAAS;EAAQ;EAAQ;CAAO,CAAC,CAC9D,IACA,OAAO,KACL,IAAI,sBAAsB;EACxB,MAAM;EACN;EACA,QAAQ,OAAO;CACjB,CAAC,CACH;AACN;;;;AAKA,MAAa,UACX,QACA,WACiD;CACjD,MAAM,QAAQA,aAAkC,MAAM;CACtD,OAAO,OAAO,UAAU,QACpB,OAAO,QACL,eAAe,OAAO;GAAG,SAAS;EAAQ;EAAQ;CAAO,CAAC,CAC5D,IACA,OAAO,KACL,IAAI,sBAAsB;EACxB,MAAM;EACN;EACA,QAAQ,OAAO;CACjB,CAAC,CACH;AACN;;;;AAMA,MAAa,YAAY,SACvB,eAAe,OAAO;EACnB,SAAS;CACV,QAAQ,KAAK;CACb,QAAQ,KAAK;AACf,CAAC;;;;AAKH,MAAa,UACX,SAC8C,KAAK;;;;AAIrD,MAAa,UACX,SAC8C,KAAK;;;;AAKrD,MAAa,cAAc,UACzB,UAAU,YAAY,OAAO,MAAM,KAAK,eAAe,IAAI,UAAU,CAAC,CAAC,KAAK"}