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

package/dist/QueryStreamKeyBounds.d.ts

@@ -0,0 +1,136 @@
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as QueryStreamKey from "./QueryStreamKey";
+import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues";
+/**
+ * One side of a range: a (possibly prefix) key and whether it's included.
+ *
+ * @experimental
+ */
+export interface KeyBound {
+    readonly keyValues: QueryStreamKeyValues.QueryStreamKeyValues;
+    readonly inclusive: boolean;
+}
+/**
+ * Bounds over a stream's key, in _ascending key space_ (`narrow` converts from
+ * stream space, where `desc` reverses which end is which).
+ *
+ * @experimental
+ */
+export interface KeyBounds {
+    readonly lower: Option.Option<KeyBound>;
+    readonly upper: Option.Option<KeyBound>;
+}
+/**
+ * Bounds in _full index-key space_: `eq`-pinned values appear as a shared
+ * prefix of both keys (`fromBounds` re-derives them as `eq` constraints). An
+ * empty key bounds nothing.
+ *
+ * @experimental
+ */
+export interface IndexBounds {
+    readonly lower: KeyBound;
+    readonly upper: KeyBound;
+}
+/**
+ * The stricter (later) of two lower bounds.
+ *
+ * @experimental
+ */
+export declare const tightestLower: (self: KeyBound, that: KeyBound) => KeyBound;
+/**
+ * The stricter (earlier) of two upper bounds.
+ *
+ * @experimental
+ */
+export declare const tightestUpper: (self: KeyBound, that: KeyBound) => KeyBound;
+/**
+ * @experimental
+ */
+export declare const intersect: (self: ParsedBounds, that: ParsedBounds) => Result.Result<ParsedBounds, QueryStreamKeyLayout.KeyLayoutMismatchError>;
+/**
+ * @experimental
+ */
+export declare const isEmpty: (indexBounds: IndexBounds) => boolean;
+/**
+ * @experimental
+ */
+export declare const intersectIndexBounds: (self: IndexBounds, that: IndexBounds) => IndexBounds;
+/**
+ * Whether a compatible key sits after the lower bound (always, when unbounded).
+ *
+ * @experimental
+ */
+export declare const admittedByLower: (parsedBounds: ParsedBounds) => (key: QueryStreamKey.Complete) => Result.Result<boolean, QueryStreamKeyLayout.KeyLayoutMismatchError>;
+/**
+ * Whether a compatible key sits before the upper bound (always, when
+ * unbounded).
+ *
+ * @experimental
+ */
+export declare const admittedByUpper: (parsedBounds: ParsedBounds) => (key: QueryStreamKey.Complete) => Result.Result<boolean, QueryStreamKeyLayout.KeyLayoutMismatchError>;
+/**
+ * At least one endpoint in stream order. Omit the other to leave that side
+ * unbounded.
+ *
+ * @experimental
+ */
+export type NarrowBounds = {
+    readonly start: KeyBound;
+    readonly end?: KeyBound | undefined;
+} | {
+    readonly start?: KeyBound | undefined;
+    readonly end: KeyBound;
+};
+/**
+ * @experimental
+ */
+export interface ParsedBound {
+    readonly key: QueryStreamKey.Prefix;
+    readonly inclusive: boolean;
+}
+declare const TypeId = "~@confect/server/QueryStreamKeyBounds";
+/**
+ * @experimental
+ */
+export interface ParsedBounds {
+    readonly [TypeId]: typeof TypeId;
+    readonly keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout;
+    readonly lower: Option.Option<ParsedBound>;
+    readonly upper: Option.Option<ParsedBound>;
+}
+/**
+ * @experimental
+ */
+export declare const unbounded: (keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout) => ParsedBounds;
+/**
+ * @experimental
+ */
+export declare const forLayout: (keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout, parsedBounds: ParsedBounds) => Result.Result<ParsedBounds, QueryStreamKeyLayout.KeyLayoutMismatchError>;
+/**
+ * @experimental
+ */
+export declare const fromParsed: (keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout, endpoints: Pick<ParsedBounds, "lower" | "upper">) => Result.Result<ParsedBounds, QueryStreamKeyLayout.KeyLayoutMismatchError>;
+/**
+ * @experimental
+ */
+export declare const tightestParsedLower: (self: ParsedBound, that: ParsedBound) => Result.Result<ParsedBound, QueryStreamKeyLayout.KeyLayoutMismatchError>;
+/**
+ * @experimental
+ */
+export declare const tightestParsedUpper: (self: ParsedBound, that: ParsedBound) => Result.Result<ParsedBound, QueryStreamKeyLayout.KeyLayoutMismatchError>;
+/**
+ * @experimental
+ */
+export declare const parseBound: (keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout, { keyValues, inclusive }: KeyBound) => Result.Result<ParsedBound, QueryStreamKey.KeyWidthMismatchError>;
+/**
+ * @experimental
+ */
+export declare const parse: (keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout, keyBounds: KeyBounds) => Result.Result<ParsedBounds, QueryStreamKey.KeyWidthMismatchError>;
+/**
+ * @experimental
+ */
+export declare const toBounds: (parsedBounds: ParsedBounds) => KeyBounds;
+export {};
+//# sourceMappingURL=QueryStreamKeyBounds.d.ts.map

package/dist/QueryStreamKeyBounds.d.ts.map

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

package/dist/QueryStreamKeyBounds.js

@@ -0,0 +1,208 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { validateEquivalence } from "./QueryStreamKeyLayout.js";
+import { prefix, values } from "./QueryStreamKey.js";
+import { Order as Order$1 } from "./QueryStreamKeyValues.js";
+import * as Option from "effect/Option";
+import * as Array from "effect/Array";
+import * as Order from "effect/Order";
+import * as Result from "effect/Result";
+import * as Data from "effect/Data";
+//#region src/QueryStreamKeyBounds.ts
+var QueryStreamKeyBounds_exports = /* @__PURE__ */ __exportAll({
+	admittedByLower: () => admittedByLower,
+	admittedByUpper: () => admittedByUpper,
+	forLayout: () => forLayout,
+	fromParsed: () => fromParsed,
+	intersect: () => intersect,
+	intersectIndexBounds: () => intersectIndexBounds,
+	isEmpty: () => isEmpty,
+	parse: () => parse,
+	parseBound: () => parseBound,
+	tightestLower: () => tightestLower,
+	tightestParsedLower: () => tightestParsedLower,
+	tightestParsedUpper: () => tightestParsedUpper,
+	tightestUpper: () => tightestUpper,
+	toBounds: () => toBounds,
+	unbounded: () => unbounded
+});
+const KeyCut = Data.taggedEnum();
+const cutRank = KeyCut.$match({
+	Predecessor: () => 0,
+	Exact: () => 1,
+	Successor: () => 2
+});
+const cutKeyValues = KeyCut.$match({
+	Predecessor: ({ keyValues }) => keyValues,
+	Exact: ({ key }) => values(key),
+	Successor: ({ keyValues }) => keyValues
+});
+const KeyCutOrder = Order.make((self, that) => {
+	const selfKeyValues = cutKeyValues(self);
+	const thatKeyValues = cutKeyValues(that);
+	const minLength = Math.min(selfKeyValues.length, thatKeyValues.length);
+	const prefixOrdering = Order$1("asc")(Array.take(selfKeyValues, minLength), Array.take(thatKeyValues, minLength));
+	if (prefixOrdering !== 0) return prefixOrdering;
+	if (selfKeyValues.length === thatKeyValues.length) return Order.Number(cutRank(self), cutRank(that));
+	const selfIsShorter = selfKeyValues.length < thatKeyValues.length;
+	const shorter = selfIsShorter ? self : that;
+	const shorterOrdering = KeyCut.$match(shorter, {
+		Predecessor: () => -1,
+		Exact: () => 1,
+		Successor: () => 1
+	});
+	return selfIsShorter ? shorterOrdering : -shorterOrdering;
+});
+const lowerCut = (bound) => bound.inclusive ? KeyCut.Predecessor({ keyValues: bound.keyValues }) : KeyCut.Successor({ keyValues: bound.keyValues });
+const upperCut = (bound) => bound.inclusive ? KeyCut.Successor({ keyValues: bound.keyValues }) : KeyCut.Predecessor({ keyValues: bound.keyValues });
+/**
+* The stricter (later) of two lower bounds.
+*
+* @experimental
+*/
+const tightestLower = (self, that) => Order.isGreaterThan(KeyCutOrder)(lowerCut(that), lowerCut(self)) ? that : self;
+/**
+* The stricter (earlier) of two upper bounds.
+*
+* @experimental
+*/
+const tightestUpper = (self, that) => Order.isLessThan(KeyCutOrder)(upperCut(that), upperCut(self)) ? that : self;
+const combineKeyBound = (self, that, combine) => Option.match(self, {
+	onNone: () => that,
+	onSome: (first) => Option.some(Option.match(that, {
+		onNone: () => first,
+		onSome: (second) => combine(first, second)
+	}))
+});
+/**
+* @experimental
+*/
+const intersect = (self, that) => Result.map(forLayout(self.keyLayout, that), () => make(self.keyLayout, {
+	lower: combineKeyBound(self.lower, that.lower, tighterLower),
+	upper: combineKeyBound(self.upper, that.upper, tighterUpper)
+}));
+/**
+* @experimental
+*/
+const isEmpty = (indexBounds) => KeyCutOrder(lowerCut(indexBounds.lower), upperCut(indexBounds.upper)) >= 0;
+/**
+* @experimental
+*/
+const intersectIndexBounds = (self, that) => ({
+	lower: tightestLower(self.lower, that.lower),
+	upper: tightestUpper(self.upper, that.upper)
+});
+/**
+* Whether a compatible key sits after the lower bound (always, when unbounded).
+*
+* @experimental
+*/
+const admittedByLower = (parsedBounds) => (key) => Result.gen(function* () {
+	yield* validateEquivalence(parsedBounds.keyLayout, key.layout);
+	return Option.match(parsedBounds.lower, {
+		onNone: () => true,
+		onSome: (bound) => KeyCutOrder(KeyCut.Exact({ key }), lowerCut(rawBound(bound))) > 0
+	});
+});
+/**
+* Whether a compatible key sits before the upper bound (always, when
+* unbounded).
+*
+* @experimental
+*/
+const admittedByUpper = (parsedBounds) => (key) => Result.gen(function* () {
+	yield* validateEquivalence(parsedBounds.keyLayout, key.layout);
+	return Option.match(parsedBounds.upper, {
+		onNone: () => true,
+		onSome: (bound) => KeyCutOrder(KeyCut.Exact({ key }), upperCut(rawBound(bound))) < 0
+	});
+});
+const TypeId = "~@confect/server/QueryStreamKeyBounds";
+const make = (keyLayout, endpoints) => ({
+	[TypeId]: TypeId,
+	keyLayout,
+	lower: endpoints.lower,
+	upper: endpoints.upper
+});
+/**
+* @experimental
+*/
+const unbounded = (keyLayout) => make(keyLayout, {
+	lower: Option.none(),
+	upper: Option.none()
+});
+/**
+* @experimental
+*/
+const forLayout = (keyLayout, parsedBounds) => Result.gen(function* () {
+	yield* validateEquivalence(keyLayout, parsedBounds.keyLayout);
+	return parsedBounds;
+});
+/**
+* @experimental
+*/
+const fromParsed = (keyLayout, endpoints) => {
+	const validateEndpoint = (endpoint) => Option.match(endpoint, {
+		onNone: () => Result.succeed(void 0),
+		onSome: ({ key }) => validateEquivalence(keyLayout, key.layout)
+	});
+	return Result.gen(function* () {
+		yield* validateEndpoint(endpoints.lower);
+		yield* validateEndpoint(endpoints.upper);
+		return make(keyLayout, endpoints);
+	});
+};
+const rawBound = (bound) => ({
+	keyValues: values(bound.key),
+	inclusive: bound.inclusive
+});
+const tighterLower = (self, that) => KeyCutOrder(lowerCut(rawBound(that)), lowerCut(rawBound(self))) > 0 ? that : self;
+const tighterUpper = (self, that) => KeyCutOrder(upperCut(rawBound(that)), upperCut(rawBound(self))) < 0 ? that : self;
+/**
+* @experimental
+*/
+const tightestParsedLower = (self, that) => Result.gen(function* () {
+	yield* validateEquivalence(self.key.layout, that.key.layout);
+	return tighterLower(self, that);
+});
+/**
+* @experimental
+*/
+const tightestParsedUpper = (self, that) => Result.gen(function* () {
+	yield* validateEquivalence(self.key.layout, that.key.layout);
+	return tighterUpper(self, that);
+});
+/**
+* @experimental
+*/
+const parseBound = (keyLayout, { keyValues, inclusive }) => Result.map(prefix(keyLayout, keyValues), (key) => ({
+	key,
+	inclusive
+}));
+/**
+* @experimental
+*/
+const parse = (keyLayout, keyBounds) => {
+	const endpoint = (bound) => Option.match(bound, {
+		onNone: () => Result.succeed(Option.none()),
+		onSome: (value) => Result.map(parseBound(keyLayout, value), Option.some)
+	});
+	return Result.gen(function* () {
+		const lower = yield* endpoint(keyBounds.lower);
+		const upper = yield* endpoint(keyBounds.upper);
+		return make(keyLayout, {
+			lower,
+			upper
+		});
+	});
+};
+/**
+* @experimental
+*/
+const toBounds = (parsedBounds) => ({
+	lower: Option.map(parsedBounds.lower, rawBound),
+	upper: Option.map(parsedBounds.upper, rawBound)
+});
+//#endregion
+export { QueryStreamKeyBounds_exports, admittedByLower, admittedByUpper, forLayout, fromParsed, intersect, intersectIndexBounds, isEmpty, parse, parseBound, tightestLower, tightestParsedLower, tightestParsedUpper, tightestUpper, toBounds, unbounded };
+
+//# sourceMappingURL=QueryStreamKeyBounds.js.map

package/dist/QueryStreamKeyBounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamKeyBounds.js","names":["QueryStreamKey.values","QueryStreamKeyValues.Order","QueryStreamKeyLayout.validateEquivalence","QueryStreamKey.prefix"],"sources":["../src/QueryStreamKeyBounds.ts"],"sourcesContent":["import * as Array from \"effect/Array\";\nimport * as Data from \"effect/Data\";\nimport * as Option from \"effect/Option\";\nimport * as Order from \"effect/Order\";\nimport * as Result from \"effect/Result\";\nimport * as QueryStreamKey from \"./QueryStreamKey\";\nimport * as QueryStreamKeyLayout from \"./QueryStreamKeyLayout\";\nimport * as QueryStreamKeyValues from \"./QueryStreamKeyValues\";\n\n// A bound's key may be a *prefix* of the full key: bounding by `[\"a\"]` means\n// bounding by the whole family of keys that start with `\"a\"`. To compare\n// bounds and keys uniformly, each is modelled as a \"cut\"—a position\n// *between* keys: the `predecessor` cut of a prefix sits just before every\n// key extending it, the `successor` cut just after, and an `exact` cut is a\n// full key itself. (This is `convex-helpers`' `compareKeys` model.)\n\n/**\n * One side of a range: a (possibly prefix) key and whether it's included.\n *\n * @experimental\n */\nexport interface KeyBound {\n  readonly keyValues: QueryStreamKeyValues.QueryStreamKeyValues;\n  readonly inclusive: boolean;\n}\n\n/**\n * Bounds over a stream's key, in _ascending key space_ (`narrow` converts from\n * stream space, where `desc` reverses which end is which).\n *\n * @experimental\n */\nexport interface KeyBounds {\n  readonly lower: Option.Option<KeyBound>;\n  readonly upper: Option.Option<KeyBound>;\n}\n\n/**\n * Bounds in _full index-key space_: `eq`-pinned values appear as a shared\n * prefix of both keys (`fromBounds` re-derives them as `eq` constraints). An\n * empty key bounds nothing.\n *\n * @experimental\n */\nexport interface IndexBounds {\n  readonly lower: KeyBound;\n  readonly upper: KeyBound;\n}\n\ntype KeyCut = Data.TaggedEnum<{\n  Predecessor: {\n    readonly keyValues: QueryStreamKeyValues.QueryStreamKeyValues;\n  };\n  Exact: { readonly key: QueryStreamKey.Complete };\n  Successor: { readonly keyValues: QueryStreamKeyValues.QueryStreamKeyValues };\n}>;\nconst KeyCut = Data.taggedEnum<KeyCut>();\n\nconst cutRank = KeyCut.$match({\n  Predecessor: () => 0,\n  Exact: () => 1,\n  Successor: () => 2,\n});\n\nconst cutKeyValues = KeyCut.$match({\n  Predecessor: ({ keyValues }) => keyValues,\n  Exact: ({ key }) => QueryStreamKey.values(key),\n  Successor: ({ keyValues }) => keyValues,\n});\n\nconst KeyCutOrder: Order.Order<KeyCut> = Order.make((self, that) => {\n  const selfKeyValues = cutKeyValues(self);\n  const thatKeyValues = cutKeyValues(that);\n  const minLength = Math.min(selfKeyValues.length, thatKeyValues.length);\n  const prefixOrdering = QueryStreamKeyValues.Order(\"asc\")(\n    Array.take(selfKeyValues, minLength),\n    Array.take(thatKeyValues, minLength),\n  );\n  if (prefixOrdering !== 0) {\n    return prefixOrdering;\n  }\n  if (selfKeyValues.length === thatKeyValues.length) {\n    return Order.Number(cutRank(self), cutRank(that));\n  }\n  // One key is a proper prefix of the other. The shorter cut sits just\n  // before (`predecessor`) or just after (`successor`) *every* key\n  // extending its prefix—the longer one included. (`exact` cuts are\n  // always full keys, so an `exact` cut is never the shorter one here.)\n  const selfIsShorter = selfKeyValues.length < thatKeyValues.length;\n  const shorter = selfIsShorter ? self : that;\n  const shorterOrdering = KeyCut.$match(shorter, {\n    Predecessor: () => -1 as const,\n    Exact: () => 1 as const,\n    Successor: () => 1 as const,\n  });\n  return selfIsShorter ? shorterOrdering : (-shorterOrdering as -1 | 1);\n});\n\nconst lowerCut = (bound: KeyBound): KeyCut =>\n  bound.inclusive\n    ? KeyCut.Predecessor({ keyValues: bound.keyValues })\n    : KeyCut.Successor({ keyValues: bound.keyValues });\n\nconst upperCut = (bound: KeyBound): KeyCut =>\n  bound.inclusive\n    ? KeyCut.Successor({ keyValues: bound.keyValues })\n    : KeyCut.Predecessor({ keyValues: bound.keyValues });\n\n/**\n * The stricter (later) of two lower bounds.\n *\n * @experimental\n */\nexport const tightestLower = (self: KeyBound, that: KeyBound): KeyBound =>\n  Order.isGreaterThan(KeyCutOrder)(lowerCut(that), lowerCut(self))\n    ? that\n    : self;\n\n/**\n * The stricter (earlier) of two upper bounds.\n *\n * @experimental\n */\nexport const tightestUpper = (self: KeyBound, that: KeyBound): KeyBound =>\n  Order.isLessThan(KeyCutOrder)(upperCut(that), upperCut(self)) ? that : self;\n\nconst combineKeyBound = (\n  self: Option.Option<ParsedBound>,\n  that: Option.Option<ParsedBound>,\n  combine: (self: ParsedBound, that: ParsedBound) => ParsedBound,\n): Option.Option<ParsedBound> =>\n  Option.match(self, {\n    onNone: () => that,\n    onSome: (first) =>\n      Option.some(\n        Option.match(that, {\n          onNone: () => first,\n          onSome: (second) => combine(first, second),\n        }),\n      ),\n  });\n\n/**\n * @experimental\n */\nexport const intersect = (\n  self: ParsedBounds,\n  that: ParsedBounds,\n): Result.Result<ParsedBounds, QueryStreamKeyLayout.KeyLayoutMismatchError> =>\n  Result.map(forLayout(self.keyLayout, that), () =>\n    make(self.keyLayout, {\n      lower: combineKeyBound(self.lower, that.lower, tighterLower),\n      upper: combineKeyBound(self.upper, that.upper, tighterUpper),\n    }),\n  );\n\n/**\n * @experimental\n */\nexport const isEmpty = (indexBounds: IndexBounds): boolean =>\n  KeyCutOrder(lowerCut(indexBounds.lower), upperCut(indexBounds.upper)) >= 0;\n\n/**\n * @experimental\n */\nexport const intersectIndexBounds = (\n  self: IndexBounds,\n  that: IndexBounds,\n): IndexBounds => ({\n  lower: tightestLower(self.lower, that.lower),\n  upper: tightestUpper(self.upper, that.upper),\n});\n\n/**\n * Whether a compatible key sits after the lower bound (always, when unbounded).\n *\n * @experimental\n */\nexport const admittedByLower =\n  (parsedBounds: ParsedBounds) =>\n  (\n    key: QueryStreamKey.Complete,\n  ): Result.Result<boolean, QueryStreamKeyLayout.KeyLayoutMismatchError> =>\n    Result.gen(function* () {\n      yield* QueryStreamKeyLayout.validateEquivalence(\n        parsedBounds.keyLayout,\n        key.layout,\n      );\n      return Option.match(parsedBounds.lower, {\n        onNone: () => true,\n        onSome: (bound) =>\n          KeyCutOrder(KeyCut.Exact({ key }), lowerCut(rawBound(bound))) > 0,\n      });\n    });\n\n/**\n * Whether a compatible key sits before the upper bound (always, when\n * unbounded).\n *\n * @experimental\n */\nexport const admittedByUpper =\n  (parsedBounds: ParsedBounds) =>\n  (\n    key: QueryStreamKey.Complete,\n  ): Result.Result<boolean, QueryStreamKeyLayout.KeyLayoutMismatchError> =>\n    Result.gen(function* () {\n      yield* QueryStreamKeyLayout.validateEquivalence(\n        parsedBounds.keyLayout,\n        key.layout,\n      );\n      return Option.match(parsedBounds.upper, {\n        onNone: () => true,\n        onSome: (bound) =>\n          KeyCutOrder(KeyCut.Exact({ key }), upperCut(rawBound(bound))) < 0,\n      });\n    });\n\n/**\n * At least one endpoint in stream order. Omit the other to leave that side\n * unbounded.\n *\n * @experimental\n */\nexport type NarrowBounds =\n  | {\n      readonly start: KeyBound;\n      readonly end?: KeyBound | undefined;\n    }\n  | {\n      readonly start?: KeyBound | undefined;\n      readonly end: KeyBound;\n    };\n\n/**\n * @experimental\n */\nexport interface ParsedBound {\n  readonly key: QueryStreamKey.Prefix;\n  readonly inclusive: boolean;\n}\n\n// Endpoints validated against a stream layout. Operations that preserve the\n// key space retain these values; coordinate changes construct new endpoints.\nconst TypeId = \"~@confect/server/QueryStreamKeyBounds\";\n\n/**\n * @experimental\n */\nexport interface ParsedBounds {\n  readonly [TypeId]: typeof TypeId;\n  readonly keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout;\n  readonly lower: Option.Option<ParsedBound>;\n  readonly upper: Option.Option<ParsedBound>;\n}\n\nconst make = (\n  keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout,\n  endpoints: Pick<ParsedBounds, \"lower\" | \"upper\">,\n): ParsedBounds => ({\n  [TypeId]: TypeId,\n  keyLayout,\n  lower: endpoints.lower,\n  upper: endpoints.upper,\n});\n\n/**\n * @experimental\n */\nexport const unbounded = (\n  keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout,\n): ParsedBounds =>\n  make(keyLayout, { lower: Option.none(), upper: Option.none() });\n\n/**\n * @experimental\n */\nexport const forLayout = (\n  keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout,\n  parsedBounds: ParsedBounds,\n): Result.Result<ParsedBounds, QueryStreamKeyLayout.KeyLayoutMismatchError> =>\n  Result.gen(function* () {\n    yield* QueryStreamKeyLayout.validateEquivalence(\n      keyLayout,\n      parsedBounds.keyLayout,\n    );\n    return parsedBounds;\n  });\n\n// Combining existing parsed endpoints still needs a shared layout, including\n// when one or both endpoints are absent.\n/**\n * @experimental\n */\nexport const fromParsed = (\n  keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout,\n  endpoints: Pick<ParsedBounds, \"lower\" | \"upper\">,\n): Result.Result<ParsedBounds, QueryStreamKeyLayout.KeyLayoutMismatchError> => {\n  const validateEndpoint = (endpoint: Option.Option<ParsedBound>) =>\n    Option.match(endpoint, {\n      onNone: () => Result.succeed(undefined),\n      onSome: ({ key }) =>\n        QueryStreamKeyLayout.validateEquivalence(keyLayout, key.layout),\n    });\n  return Result.gen(function* () {\n    yield* validateEndpoint(endpoints.lower);\n    yield* validateEndpoint(endpoints.upper);\n    return make(keyLayout, endpoints);\n  });\n};\n\nconst rawBound = (bound: ParsedBound): KeyBound => ({\n  keyValues: QueryStreamKey.values(bound.key),\n  inclusive: bound.inclusive,\n});\n\n// Select existing endpoints so intersection retains their parsed keys.\nconst tighterLower = (self: ParsedBound, that: ParsedBound): ParsedBound =>\n  KeyCutOrder(lowerCut(rawBound(that)), lowerCut(rawBound(self))) > 0\n    ? that\n    : self;\n\nconst tighterUpper = (self: ParsedBound, that: ParsedBound): ParsedBound =>\n  KeyCutOrder(upperCut(rawBound(that)), upperCut(rawBound(self))) < 0\n    ? that\n    : self;\n\n/**\n * @experimental\n */\nexport const tightestParsedLower = (\n  self: ParsedBound,\n  that: ParsedBound,\n): Result.Result<ParsedBound, QueryStreamKeyLayout.KeyLayoutMismatchError> =>\n  Result.gen(function* () {\n    yield* QueryStreamKeyLayout.validateEquivalence(\n      self.key.layout,\n      that.key.layout,\n    );\n    return tighterLower(self, that);\n  });\n\n/**\n * @experimental\n */\nexport const tightestParsedUpper = (\n  self: ParsedBound,\n  that: ParsedBound,\n): Result.Result<ParsedBound, QueryStreamKeyLayout.KeyLayoutMismatchError> =>\n  Result.gen(function* () {\n    yield* QueryStreamKeyLayout.validateEquivalence(\n      self.key.layout,\n      that.key.layout,\n    );\n    return tighterUpper(self, that);\n  });\n\n/**\n * @experimental\n */\nexport const parseBound = (\n  keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout,\n  { keyValues, inclusive }: KeyBound,\n): Result.Result<ParsedBound, QueryStreamKey.KeyWidthMismatchError> =>\n  Result.map(QueryStreamKey.prefix(keyLayout, keyValues), (key) => ({\n    key,\n    inclusive,\n  }));\n\n/**\n * @experimental\n */\nexport const parse = (\n  keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout,\n  keyBounds: KeyBounds,\n): Result.Result<ParsedBounds, QueryStreamKey.KeyWidthMismatchError> => {\n  const endpoint = (bound: Option.Option<KeyBound>) =>\n    Option.match(bound, {\n      onNone: () => Result.succeed(Option.none<ParsedBound>()),\n      onSome: (value) => Result.map(parseBound(keyLayout, value), Option.some),\n    });\n  return Result.gen(function* () {\n    const lower = yield* endpoint(keyBounds.lower);\n    const upper = yield* endpoint(keyBounds.upper);\n    return make(keyLayout, { lower, upper });\n  });\n};\n\n/**\n * @experimental\n */\nexport const toBounds = (parsedBounds: ParsedBounds): KeyBounds => ({\n  lower: Option.map(parsedBounds.lower, rawBound),\n  upper: Option.map(parsedBounds.upper, rawBound),\n});\n"],"mappings":"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"}

package/dist/QueryStreamKeyLabels.d.ts

@@ -0,0 +1,27 @@
+import * as Brand from "effect/Brand";
+/**
+ * Ordered names for the visible components of a stream's ordering key. Names
+ * may repeat, and the sequence may be empty. They are aliases, not document
+ * field paths; implicit ID positions have no visible label.
+ *
+ * @experimental
+ */
+export type QueryStreamKeyLabels<Names extends ReadonlyArray<string> = ReadonlyArray<string>> = Readonly<Names> & Brand.Brand<"@confect/server/QueryStreamKeyLabels">;
+/**
+ * @experimental
+ */
+export type Concat<LeftKeyLabels extends QueryStreamKeyLabels, RightKeyLabels extends QueryStreamKeyLabels> = LeftKeyLabels extends QueryStreamKeyLabels<infer LeftNames> ? RightKeyLabels extends QueryStreamKeyLabels<infer RightNames> ? QueryStreamKeyLabels<readonly [...LeftNames, ...RightNames]> : never : never;
+/**
+ * Mark a tuple of names as labels without changing its runtime representation.
+ *
+ * @experimental
+ */
+export declare function make<const Names extends ReadonlyArray<string>>(names: Names): QueryStreamKeyLabels<Names>;
+/**
+ * Check whether the labels start with the given prefix, including order and
+ * multiplicity. The empty prefix always matches.
+ *
+ * @experimental
+ */
+export declare const hasPrefix: (self: QueryStreamKeyLabels, prefixKeyLabels: QueryStreamKeyLabels) => boolean;
+//# sourceMappingURL=QueryStreamKeyLabels.d.ts.map

package/dist/QueryStreamKeyLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamKeyLabels.d.ts","sourceRoot":"","sources":["../src/QueryStreamKeyLabels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,CAC9B,KAAK,SAAS,aAAa,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC,MAAM,CAAC,IACzD,QAAQ,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;AAM1E;;GAEG;AACH,MAAM,MAAM,MAAM,CAChB,aAAa,SAAS,oBAAoB,EAC1C,cAAc,SAAS,oBAAoB,IAE3C,aAAa,SAAS,oBAAoB,CAAC,MAAM,SAAS,CAAC,GACvD,cAAc,SAAS,oBAAoB,CAAC,MAAM,UAAU,CAAC,GAC3D,oBAAoB,CAAC,SAAS,CAAC,GAAG,SAAS,EAAE,GAAG,UAAU,CAAC,CAAC,GAC5D,KAAK,GACP,KAAK,CAAC;AAIZ;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,KAAK,SAAS,aAAa,CAAC,MAAM,CAAC,EAC5D,KAAK,EAAE,KAAK,GACX,oBAAoB,CAAC,KAAK,CAAC,CAAC;AAK/B;;;;;GAKG;AACH,eAAO,MAAM,SAAS,SACd,oBAAoB,mBACT,oBAAoB,KACpC,OAE6D,CAAC"}

package/dist/QueryStreamKeyLabels.js

@@ -0,0 +1,22 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Brand from "effect/Brand";
+//#region src/QueryStreamKeyLabels.ts
+var QueryStreamKeyLabels_exports = /* @__PURE__ */ __exportAll({
+	hasPrefix: () => hasPrefix,
+	make: () => make
+});
+const LabelsBrand = Brand.nominal();
+function make(names) {
+	return LabelsBrand(names);
+}
+/**
+* Check whether the labels start with the given prefix, including order and
+* multiplicity. The empty prefix always matches.
+*
+* @experimental
+*/
+const hasPrefix = (self, prefixKeyLabels) => prefixKeyLabels.length <= self.length && prefixKeyLabels.every((label, index) => label === self[index]);
+//#endregion
+export { QueryStreamKeyLabels_exports, hasPrefix, make };
+
+//# sourceMappingURL=QueryStreamKeyLabels.js.map

package/dist/QueryStreamKeyLabels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStreamKeyLabels.js","names":[],"sources":["../src/QueryStreamKeyLabels.ts"],"sourcesContent":["import * as Brand from \"effect/Brand\";\n\n/**\n * Ordered names for the visible components of a stream's ordering key. Names\n * may repeat, and the sequence may be empty. They are aliases, not document\n * field paths; implicit ID positions have no visible label.\n *\n * @experimental\n */\nexport type QueryStreamKeyLabels<\n  Names extends ReadonlyArray<string> = ReadonlyArray<string>,\n> = Readonly<Names> & Brand.Brand<\"@confect/server/QueryStreamKeyLabels\">;\n\n// Tuple operations must use the underlying names: spreading a branded tuple\n// directly can widen its fixed positions into an array of element unions.\n// Defer extraction and concatenation until both label types are known to avoid\n// expanding unresolved tuple types while checking generic stream operations.\n/**\n * @experimental\n */\nexport type Concat<\n  LeftKeyLabels extends QueryStreamKeyLabels,\n  RightKeyLabels extends QueryStreamKeyLabels,\n> =\n  LeftKeyLabels extends QueryStreamKeyLabels<infer LeftNames>\n    ? RightKeyLabels extends QueryStreamKeyLabels<infer RightNames>\n      ? QueryStreamKeyLabels<readonly [...LeftNames, ...RightNames]>\n      : never\n    : never;\n\nconst LabelsBrand = Brand.nominal<QueryStreamKeyLabels>();\n\n/**\n * Mark a tuple of names as labels without changing its runtime representation.\n *\n * @experimental\n */\nexport function make<const Names extends ReadonlyArray<string>>(\n  names: Names,\n): QueryStreamKeyLabels<Names>;\nexport function make(names: ReadonlyArray<string>): QueryStreamKeyLabels {\n  return LabelsBrand(names);\n}\n\n/**\n * Check whether the labels start with the given prefix, including order and\n * multiplicity. The empty prefix always matches.\n *\n * @experimental\n */\nexport const hasPrefix = (\n  self: QueryStreamKeyLabels,\n  prefixKeyLabels: QueryStreamKeyLabels,\n): boolean =>\n  prefixKeyLabels.length <= self.length &&\n  prefixKeyLabels.every((label, index) => label === self[index]);\n"],"mappings":";;;;;;;AA8BA,MAAM,cAAc,MAAM,QAA8B;AAUxD,SAAgB,KAAK,OAAoD;CACvE,OAAO,YAAY,KAAK;AAC1B;;;;;;;AAQA,MAAa,aACX,MACA,oBAEA,gBAAgB,UAAU,KAAK,UAC/B,gBAAgB,OAAO,OAAO,UAAU,UAAU,KAAK,MAAM"}

package/dist/QueryStreamKeyLayout.d.ts

@@ -0,0 +1,179 @@
+import * as Data from "effect/Data";
+import * as Equivalence_ from "effect/Equivalence";
+import * as Result from "effect/Result";
+import type * as Types from "effect/Types";
+import * as QueryStreamKeyLabels from "./QueryStreamKeyLabels";
+/**
+ * One runtime position of a stream key. Explicit IDs and their aliases are
+ * visible; implicit ID tiebreakers have no label. Empty keys have no
+ * positions.
+ *
+ * @experimental
+ */
+export type Position = Data.TaggedEnum<{
+    Visible: {
+        readonly label: string;
+    };
+    ImplicitId: {};
+}>;
+declare const TypeId = "@confect/server/QueryStreamKeyLayout";
+/**
+ * Describes the positions in a stream's keys: their sequence, their labels, and
+ * where implicit document-ID tiebreakers occur. Every element has its own key
+ * values; the stream has one shared layout.
+ *
+ * For example, labels `["text", "_creationTime"]` describe the labeled
+ * positions in a key such as `["apple", 1, "n1"]`. Its layout also records the
+ * final implicit ID position. Joined layouts retain each component's ID, so
+ * their labels alone do not describe every key position.
+ *
+ * Layouts are compatible when they have the same total width, labels in the
+ * same positions, and implicit-ID positions. Direction is separate. Layouts
+ * contain no key values, value-type schemas, table identity, or equality-pinned
+ * values. Labels start as index field paths but may be renamed. An explicit ID,
+ * such as in `by_id`, has a label.
+ *
+ * Reuse a stream's `keyLayout` with `empty` or `flatMap`'s `innerKeyLayout`.
+ * Creating a stream to obtain its layout does not read documents. The
+ * `KeyLabels` parameter tracks only labels; implicit-ID positions are checked
+ * at runtime. Normally this type is inferred from the source stream.
+ *
+ * @experimental
+ */
+export interface QueryStreamKeyLayout<out KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels = QueryStreamKeyLabels.QueryStreamKeyLabels> {
+    readonly [TypeId]: {
+        readonly _Labels: Types.Covariant<KeyLabels>;
+        readonly positions: ReadonlyArray<Position>;
+    };
+}
+/**
+ * The runtime positions, including implicit ID tiebreakers.
+ *
+ * @experimental
+ */
+export declare const positions: (self: QueryStreamKeyLayout) => ReadonlyArray<Position>;
+/**
+ * The source field paths remaining after an equality prefix.
+ *
+ * @experimental
+ */
+export type RemainingFieldPaths<FieldPaths extends ReadonlyArray<string>, Count extends number> = Count extends unknown ? DropPrefix<FieldPaths, Count> : never;
+type DropPrefix<FieldPaths extends ReadonlyArray<string>, Count extends number, Prefix extends ReadonlyArray<unknown> = []> = number extends Count ? ReadonlyArray<string> : Prefix["length"] extends Count ? Types.Mutable<FieldPaths> : FieldPaths extends readonly [
+    string,
+    ...infer TailFieldPaths extends ReadonlyArray<string>
+] ? DropPrefix<TailFieldPaths, Count, readonly [...Prefix, unknown]> : FieldPaths extends readonly [] ? [] : ReadonlyArray<string>;
+declare const InvalidEqualityPrefixError_base: new <A extends Record<string, any> = {}>(args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "InvalidEqualityPrefixError";
+} & Readonly<A>;
+/**
+ * The equality prefix cannot select a whole number of source field paths.
+ *
+ * @experimental
+ */
+export declare class InvalidEqualityPrefixError extends InvalidEqualityPrefixError_base<{
+    readonly fieldPaths: ReadonlyArray<string>;
+    readonly eqCount: number;
+}> {
+    get message(): string;
+}
+declare const InvalidLabelPrefixError_base: new <A extends Record<string, any> = {}>(args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "InvalidLabelPrefixError";
+} & Readonly<A>;
+/**
+ * The requested labels do not form a prefix of the layout's visible labels.
+ *
+ * @experimental
+ */
+export declare class InvalidLabelPrefixError extends InvalidLabelPrefixError_base<{
+    readonly keyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels;
+    readonly prefixKeyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels;
+}> {
+    get message(): string;
+}
+declare const LabelCountMismatchError_base: new <A extends Record<string, any> = {}>(args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LabelCountMismatchError";
+} & Readonly<A>;
+/**
+ * The replacement labels cannot fill exactly the layout's visible positions.
+ *
+ * @experimental
+ */
+export declare class LabelCountMismatchError extends LabelCountMismatchError_base<{
+    readonly keyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels;
+    readonly replacementKeyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels;
+}> {
+    get message(): string;
+}
+/**
+ * Construct a scan layout from the original index field paths, before equality
+ * pinning. Only an ID absent from the end of that original key is implicit.
+ * Pinning every field of `by_id` produces a zero-width layout; pinning every
+ * visible field of another index leaves its implicit ID. Invalid equality
+ * prefix lengths return `InvalidEqualityPrefixError`.
+ *
+ * @experimental
+ */
+export declare function fromIndex<const FieldPaths extends ReadonlyArray<string>>(fieldPaths: FieldPaths): Result.Result<QueryStreamKeyLayout<QueryStreamKeyLabels.QueryStreamKeyLabels<FieldPaths>>, InvalidEqualityPrefixError>;
+/**
+ * @experimental
+ */
+export declare function fromIndex<const FieldPaths extends ReadonlyArray<string>, const Count extends number>(fieldPaths: FieldPaths, eqCount: Count): Result.Result<QueryStreamKeyLayout<QueryStreamKeyLabels.QueryStreamKeyLabels<RemainingFieldPaths<FieldPaths, Count>>>, InvalidEqualityPrefixError>;
+/**
+ * Concatenate layouts without losing component tiebreakers.
+ *
+ * @experimental
+ */
+export declare const concat: <LeftKeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels, RightKeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels>(self: QueryStreamKeyLayout<LeftKeyLabels>, that: QueryStreamKeyLayout<RightKeyLabels>) => QueryStreamKeyLayout<QueryStreamKeyLabels.Concat<LeftKeyLabels, RightKeyLabels>>;
+/**
+ * Format visible labels and implicit IDs for diagnostics.
+ *
+ * @experimental
+ */
+export declare const format: (self: QueryStreamKeyLayout) => string;
+/**
+ * The labels available to `distinct` and `renameKey`.
+ *
+ * @experimental
+ */
+export declare function visibleLabels<KeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels>(self: QueryStreamKeyLayout<KeyLabels>): KeyLabels;
+/**
+ * Number of positions in an element's runtime key.
+ *
+ * @experimental
+ */
+export declare const runtimeWidth: (self: QueryStreamKeyLayout) => number;
+/**
+ * @experimental
+ */
+export declare const Equivalence: Equivalence_.Equivalence<QueryStreamKeyLayout>;
+declare const KeyLayoutMismatchError_base: new <A extends Record<string, any> = {}>(args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "KeyLayoutMismatchError";
+} & Readonly<A>;
+/**
+ * @experimental
+ */
+export declare class KeyLayoutMismatchError extends KeyLayoutMismatchError_base<{
+    readonly expectedKeyLayout: QueryStreamKeyLayout;
+    readonly actualKeyLayout: QueryStreamKeyLayout;
+}> {
+    get message(): string;
+}
+/**
+ * @experimental
+ */
+export declare const validateEquivalence: (expectedKeyLayout: QueryStreamKeyLayout, actualKeyLayout: QueryStreamKeyLayout) => Result.Result<void, KeyLayoutMismatchError>;
+/**
+ * Parse a visible label prefix and resolve its runtime width. Implicit IDs
+ * before the last selected label are included; implicit IDs after it are not.
+ *
+ * @experimental
+ */
+export declare const resolvePrefix: (self: QueryStreamKeyLayout, prefixKeyLabels: QueryStreamKeyLabels.QueryStreamKeyLabels) => Result.Result<number, InvalidLabelPrefixError>;
+/**
+ * Relabel visible positions, preserving every implicit ID.
+ *
+ * @experimental
+ */
+export declare const rename: <ReplacementKeyLabels extends QueryStreamKeyLabels.QueryStreamKeyLabels>(self: QueryStreamKeyLayout, replacementKeyLabels: ReplacementKeyLabels) => Result.Result<QueryStreamKeyLayout<ReplacementKeyLabels>, LabelCountMismatchError>;
+export {};
+//# sourceMappingURL=QueryStreamKeyLayout.d.ts.map

package/dist/QueryStreamKeyLayout.d.ts.map

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