@rocicorp/zero 1.12.0-canary.0 → 1.12.0-canary.10

package/out/shared/src/record-proxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"record-proxy.js","names":["#toValue","#onMissing","#cache","#getOwnValue"],"sources":["../../../../shared/src/record-proxy.ts"],"sourcesContent":["const missing = Symbol();\n\n/**\n * A proxy handler that lazily transforms and caches record values.\n *\n * When a property is accessed, the handler transforms the source value using\n * the provided `toValue` function and caches the result. Subsequent accesses\n * return the cached value without re-transforming.\n *\n * @template Source - The type of values in the source record\n * @template Dest - The type of transformed values\n */\nclass RecordProxyHandler<Source, Dest> implements ProxyHandler<\n  Record<string, Source>\n> {\n  readonly #toValue: (source: Source, prop: string) => Dest;\n  readonly #onMissing: ((prop: string) => void) | undefined;\n  readonly #cache: Map<string, Dest | typeof missing> = new Map();\n\n  /**\n   * @param toValue - Function to transform source values to destination values\n   * @param onMissing - Optional function called when accessing a non-existent\n   *   property. Can throw an error if desired.\n   */\n  constructor(\n    toValue: (source: Source, prop: string) => Dest,\n    onMissing?: (prop: string) => void,\n  ) {\n    this.#toValue = toValue;\n    this.#onMissing = onMissing;\n  }\n\n  #getOwnValue(\n    target: Record<string, Source>,\n    prop: string,\n  ): Dest | typeof missing {\n    const v = this.#cache.get(prop);\n    if (v !== undefined) {\n      return v;\n    }\n\n    if (Object.hasOwn(target, prop)) {\n      const value = this.#toValue(target[prop], prop);\n      this.#cache.set(prop, value);\n      return value;\n    }\n    return missing;\n  }\n\n  get(target: Record<string, Source>, prop: string | symbol) {\n    if (typeof prop !== 'string') {\n      return undefined;\n    }\n    // Only transform own properties; return inherited properties as-is\n    const ownValue = this.#getOwnValue(target, prop);\n    if (ownValue !== missing) {\n      return ownValue;\n    }\n    this.#onMissing?.(prop);\n\n    // Inherited property - return without transformation\n    return target[prop];\n  }\n\n  getOwnPropertyDescriptor(\n    target: Record<string, Source>,\n    p: string | symbol,\n  ): PropertyDescriptor | undefined {\n    if (typeof p !== 'string') {\n      return undefined;\n    }\n\n    const value = this.#getOwnValue(target, p);\n    if (value === missing) {\n      return undefined;\n    }\n    const desc = Reflect.getOwnPropertyDescriptor(target, p);\n    return {...desc, value};\n  }\n}\n\n/**\n * Creates a proxy that lazily transforms and caches record values.\n *\n * @template Source - The type of values in the source record\n * @template Dest - The type of transformed values\n * @param target - The source record to proxy\n * @param toValue - Function to transform source values to destination values\n * @param onMissing - Optional function called when accessing a non-existent\n *   property. Can throw an error if desired.\n * @returns A proxy that presents transformed values\n */\nexport function recordProxy<Source, Dest>(\n  target: Record<string, Source>,\n  toValue: (source: Source, prop: string) => Dest,\n  onMissing?: (prop: string) => void,\n): Record<string, Dest> {\n  return new Proxy(\n    target,\n    new RecordProxyHandler(toValue, onMissing),\n  ) as unknown as Record<string, Dest>;\n}\n"],"mappings":";AAAA,IAAM,UAAU,OAAO;;;;;;;;;;;AAYvB,IAAM,qBAAN,MAEE;CACA;CACA;CACA,yBAAsD,IAAI,IAAI;;;;;;CAO9D,YACE,SACA,WACA;EACA,KAAKA,WAAW;EAChB,KAAKC,aAAa;CACpB;CAEA,aACE,QACA,MACuB;EACvB,MAAM,IAAI,KAAKC,OAAO,IAAI,IAAI;EAC9B,IAAI,MAAM,KAAA,GACR,OAAO;EAGT,IAAI,OAAO,OAAO,QAAQ,IAAI,GAAG;GAC/B,MAAM,QAAQ,KAAKF,SAAS,OAAO,OAAO,IAAI;GAC9C,KAAKE,OAAO,IAAI,MAAM,KAAK;GAC3B,OAAO;EACT;EACA,OAAO;CACT;CAEA,IAAI,QAAgC,MAAuB;EACzD,IAAI,OAAO,SAAS,UAClB;EAGF,MAAM,WAAW,KAAKC,aAAa,QAAQ,IAAI;EAC/C,IAAI,aAAa,SACf,OAAO;EAET,KAAKF,aAAa,IAAI;EAGtB,OAAO,OAAO;CAChB;CAEA,yBACE,QACA,GACgC;EAChC,IAAI,OAAO,MAAM,UACf;EAGF,MAAM,QAAQ,KAAKE,aAAa,QAAQ,CAAC;EACzC,IAAI,UAAU,SACZ;EAGF,OAAO;GAAC,GADK,QAAQ,yBAAyB,QAAQ,CAC3C;GAAM;EAAK;CACxB;AACF;;;;;;;;;;;;AAaA,SAAgB,YACd,QACA,SACA,WACsB;CACtB,OAAO,IAAI,MACT,QACA,IAAI,mBAAmB,SAAS,SAAS,CAC3C;AACF"}
+{"version":3,"file":"record-proxy.js","names":[],"sources":["../../../../shared/src/record-proxy.ts"],"sourcesContent":["const missing = Symbol();\n\n/**\n * A proxy handler that lazily transforms and caches record values.\n *\n * When a property is accessed, the handler transforms the source value using\n * the provided `toValue` function and caches the result. Subsequent accesses\n * return the cached value without re-transforming.\n *\n * @template Source - The type of values in the source record\n * @template Dest - The type of transformed values\n */\nclass RecordProxyHandler<Source, Dest> implements ProxyHandler<\n  Record<string, Source>\n> {\n  readonly #toValue: (source: Source, prop: string) => Dest;\n  readonly #onMissing: ((prop: string) => void) | undefined;\n  readonly #cache: Map<string, Dest | typeof missing> = new Map();\n\n  /**\n   * @param toValue - Function to transform source values to destination values\n   * @param onMissing - Optional function called when accessing a non-existent\n   *   property. Can throw an error if desired.\n   */\n  constructor(\n    toValue: (source: Source, prop: string) => Dest,\n    onMissing?: (prop: string) => void,\n  ) {\n    this.#toValue = toValue;\n    this.#onMissing = onMissing;\n  }\n\n  #getOwnValue(\n    target: Record<string, Source>,\n    prop: string,\n  ): Dest | typeof missing {\n    const v = this.#cache.get(prop);\n    if (v !== undefined) {\n      return v;\n    }\n\n    if (Object.hasOwn(target, prop)) {\n      const value = this.#toValue(target[prop], prop);\n      this.#cache.set(prop, value);\n      return value;\n    }\n    return missing;\n  }\n\n  get(target: Record<string, Source>, prop: string | symbol) {\n    if (typeof prop !== 'string') {\n      return undefined;\n    }\n    // Only transform own properties; return inherited properties as-is\n    const ownValue = this.#getOwnValue(target, prop);\n    if (ownValue !== missing) {\n      return ownValue;\n    }\n    this.#onMissing?.(prop);\n\n    // Inherited property - return without transformation\n    return target[prop];\n  }\n\n  getOwnPropertyDescriptor(\n    target: Record<string, Source>,\n    p: string | symbol,\n  ): PropertyDescriptor | undefined {\n    if (typeof p !== 'string') {\n      return undefined;\n    }\n\n    const value = this.#getOwnValue(target, p);\n    if (value === missing) {\n      return undefined;\n    }\n    const desc = Reflect.getOwnPropertyDescriptor(target, p);\n    return {...desc, value};\n  }\n}\n\n/**\n * Creates a proxy that lazily transforms and caches record values.\n *\n * @template Source - The type of values in the source record\n * @template Dest - The type of transformed values\n * @param target - The source record to proxy\n * @param toValue - Function to transform source values to destination values\n * @param onMissing - Optional function called when accessing a non-existent\n *   property. Can throw an error if desired.\n * @returns A proxy that presents transformed values\n */\nexport function recordProxy<Source, Dest>(\n  target: Record<string, Source>,\n  toValue: (source: Source, prop: string) => Dest,\n  onMissing?: (prop: string) => void,\n): Record<string, Dest> {\n  return new Proxy(\n    target,\n    new RecordProxyHandler(toValue, onMissing),\n  ) as unknown as Record<string, Dest>;\n}\n"],"mappings":";AAAA,IAAM,UAAU,OAAO;;;;;;;;;;;AAYvB,IAAM,qBAAN,MAEE;CACA;CACA;CACA,yBAAsD,IAAI,IAAI;;;;;;CAO9D,YACE,SACA,WACA;EACA,KAAK,WAAW;EAChB,KAAK,aAAa;CACpB;CAEA,aACE,QACA,MACuB;EACvB,MAAM,IAAI,KAAK,OAAO,IAAI,IAAI;EAC9B,IAAI,MAAM,KAAA,GACR,OAAO;EAGT,IAAI,OAAO,OAAO,QAAQ,IAAI,GAAG;GAC/B,MAAM,QAAQ,KAAK,SAAS,OAAO,OAAO,IAAI;GAC9C,KAAK,OAAO,IAAI,MAAM,KAAK;GAC3B,OAAO;EACT;EACA,OAAO;CACT;CAEA,IAAI,QAAgC,MAAuB;EACzD,IAAI,OAAO,SAAS,UAClB;EAGF,MAAM,WAAW,KAAK,aAAa,QAAQ,IAAI;EAC/C,IAAI,aAAa,SACf,OAAO;EAET,KAAK,aAAa,IAAI;EAGtB,OAAO,OAAO;CAChB;CAEA,yBACE,QACA,GACgC;EAChC,IAAI,OAAO,MAAM,UACf;EAGF,MAAM,QAAQ,KAAK,aAAa,QAAQ,CAAC;EACzC,IAAI,UAAU,SACZ;EAGF,OAAO;GAAC,GADK,QAAQ,yBAAyB,QAAQ,CAC3C;GAAM;EAAK;CACxB;AACF;;;;;;;;;;;;AAaA,SAAgB,YACd,QACA,SACA,WACsB;CACtB,OAAO,IAAI,MACT,QACA,IAAI,mBAAmB,SAAS,SAAS,CAC3C;AACF"}

package/out/shared/src/resolved-promises.d.ts

@@ -2,8 +2,4 @@ export declare const promiseTrue: Promise<true>;
 export declare const promiseFalse: Promise<false>;
 export declare const promiseUndefined: Promise<undefined>;
 export declare const promiseVoid: Promise<void>;
-/**
- * A promise that never resolves.
- */
-export declare const promiseNever: Promise<never>;
 //# sourceMappingURL=resolved-promises.d.ts.map

package/out/shared/src/resolved-promises.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolved-promises.d.ts","sourceRoot":"","sources":["../../../../shared/src/resolved-promises.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,eAAiC,CAAC;AAC1D,eAAO,MAAM,YAAY,gBAAkC,CAAC;AAC5D,eAAO,MAAM,gBAAgB,oBAA6B,CAAC;AAC3D,eAAO,MAAM,WAAW,eAAoB,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,YAAY,gBAA+B,CAAC"}
+{"version":3,"file":"resolved-promises.d.ts","sourceRoot":"","sources":["../../../../shared/src/resolved-promises.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,eAAiC,CAAC;AAC1D,eAAO,MAAM,YAAY,gBAAkC,CAAC;AAC5D,eAAO,MAAM,gBAAgB,oBAA6B,CAAC;AAC3D,eAAO,MAAM,WAAW,eAAoB,CAAC"}

package/out/shared/src/resolved-promises.js

@@ -3,7 +3,6 @@ var promiseTrue = Promise.resolve(true);
 var promiseFalse = Promise.resolve(false);
 Promise.resolve(void 0);
 var promiseVoid = Promise.resolve();
-new Promise(() => {});
 //#endregion
 export { promiseFalse, promiseTrue, promiseVoid };
 

package/out/shared/src/resolved-promises.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolved-promises.js","names":[],"sources":["../../../../shared/src/resolved-promises.ts"],"sourcesContent":["export const promiseTrue = Promise.resolve(true as const);\nexport const promiseFalse = Promise.resolve(false as const);\nexport const promiseUndefined = Promise.resolve(undefined);\nexport const promiseVoid = Promise.resolve();\n\n/**\n * A promise that never resolves.\n */\nexport const promiseNever = new Promise<never>(() => {});\n"],"mappings":";AAAA,IAAa,cAAc,QAAQ,QAAQ,IAAa;AACxD,IAAa,eAAe,QAAQ,QAAQ,KAAc;AAC1B,QAAQ,QAAQ,KAAA,CAAS;AACzD,IAAa,cAAc,QAAQ,QAAQ;AAKf,IAAI,cAAqB,CAAC,CAAC"}
+{"version":3,"file":"resolved-promises.js","names":[],"sources":["../../../../shared/src/resolved-promises.ts"],"sourcesContent":["export const promiseTrue = Promise.resolve(true as const);\nexport const promiseFalse = Promise.resolve(false as const);\nexport const promiseUndefined = Promise.resolve(undefined);\nexport const promiseVoid = Promise.resolve();\n"],"mappings":";AAAA,IAAa,cAAc,QAAQ,QAAQ,IAAa;AACxD,IAAa,eAAe,QAAQ,QAAQ,KAAc;AAC1B,QAAQ,QAAQ,KAAA,CAAS;AACzD,IAAa,cAAc,QAAQ,QAAQ"}

package/out/shared/src/resolver.d.ts

@@ -0,0 +1,9 @@
+export interface Resolver<R = void, E = unknown> {
+    promise: Promise<R>;
+    resolve: (res: R) => void;
+    reject: (err: E) => void;
+}
+type WithResolvers = <R = void, E = unknown>() => Resolver<R, E>;
+export declare const resolver: WithResolvers;
+export {};
+//# sourceMappingURL=resolver.d.ts.map

package/out/shared/src/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../../shared/src/resolver.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,OAAO;IAC7C,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC;CAC1B;AAED,KAAK,aAAa,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,OAAO,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEjE,eAAO,MAAM,QAAQ,EAAE,aAA6C,CAAC"}

package/out/shared/src/resolver.js

@@ -0,0 +1,6 @@
+//#region ../shared/src/resolver.ts
+var resolver = () => Promise.withResolvers();
+//#endregion
+export { resolver };
+
+//# sourceMappingURL=resolver.js.map

package/out/shared/src/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.js","names":[],"sources":["../../../../shared/src/resolver.ts"],"sourcesContent":["export interface Resolver<R = void, E = unknown> {\n  promise: Promise<R>;\n  resolve: (res: R) => void;\n  reject: (err: E) => void;\n}\n\ntype WithResolvers = <R = void, E = unknown>() => Resolver<R, E>;\n\nexport const resolver: WithResolvers = () => Promise.withResolvers();\n"],"mappings":";AAQA,IAAa,iBAAgC,QAAQ,cAAc"}

package/out/shared/src/ring-buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"ring-buffer.js","names":["#capacity","#buffer","#size","#grow","#head","#shrink"],"sources":["../../../../shared/src/ring-buffer.ts"],"sourcesContent":["const DEFAULT_INITIAL_CAPACITY = 16;\nconst MIN_CAPACITY = 16;\n\n/**\n * A FIFO ring buffer backed by a circular array. Provides:\n *\n * - `push()` — O(1) amortized (O(n) on resize)\n * - `shift()` — O(1)\n * - `size`    — O(1)\n * - `drain()` — O(n)\n *\n * The buffer grows (doubles) when full and shrinks (halves) when\n * utilization drops below 25%, bounded by {@link MIN_CAPACITY}.\n */\nexport class RingBuffer<T> {\n  #buffer: (T | undefined)[];\n  #head = 0;\n  #size = 0;\n  #capacity: number;\n\n  constructor(initialCapacity = DEFAULT_INITIAL_CAPACITY) {\n    this.#capacity = Math.max(MIN_CAPACITY, initialCapacity);\n    this.#buffer = Array.from({length: initialCapacity});\n  }\n\n  get size(): number {\n    return this.#size;\n  }\n\n  push(value: T): void {\n    if (this.#size === this.#capacity) {\n      this.#grow();\n    }\n    this.#buffer[(this.#head + this.#size) % this.#capacity] = value;\n    this.#size++;\n  }\n\n  /** Returns the front element without removing it, or `undefined` if empty. */\n  first(): T | undefined {\n    return this.#size === 0 ? undefined : this.#buffer[this.#head];\n  }\n\n  /** Returns the last element, or `undefined` if empty. */\n  last(): T | undefined {\n    return this.#size === 0\n      ? undefined\n      : this.#buffer[(this.#head + this.#size - 1) % this.#capacity];\n  }\n\n  /** Replaces the last element, or appends it if empty. */\n  replaceLast(value: T): void {\n    if (this.#size === 0) {\n      this.push(value);\n    } else {\n      this.#buffer[(this.#head + this.#size - 1) % this.#capacity] = value;\n    }\n  }\n\n  /** Removes and returns the front element, or `undefined` if empty. */\n  shift(): T | undefined {\n    if (this.#size === 0) {\n      return undefined;\n    }\n    const value = this.#buffer[this.#head];\n    this.#buffer[this.#head] = undefined; // allow GC of removed element\n    this.#head = (this.#head + 1) % this.#capacity;\n    this.#size--;\n\n    // Shrink when utilization drops below 25%, keeping a minimum capacity.\n    if (\n      this.#size > 0 &&\n      this.#size < this.#capacity >> 2 &&\n      this.#capacity > MIN_CAPACITY\n    ) {\n      this.#shrink();\n    }\n\n    return value;\n  }\n\n  /**\n   * Removes all elements matching `value` (by identity `===`).\n   *\n   * This is O(n) — suitable for rare operations like cancellation.\n   *\n   * @returns The number of elements removed.\n   */\n  delete(value: T): number {\n    if (this.#size === 0) {\n      return 0;\n    }\n    // Rebuild the buffer without matching elements.\n    const newBuffer: (T | undefined)[] = Array.from({length: this.#capacity});\n    let newSize = 0;\n    let count = 0;\n    for (let i = 0; i < this.#size; i++) {\n      const item = this.#buffer[(this.#head + i) % this.#capacity];\n      if (item === value) {\n        count++;\n      } else {\n        newBuffer[newSize++] = item;\n      }\n    }\n    this.#buffer = newBuffer;\n    this.#head = 0;\n    this.#size = newSize;\n    return count;\n  }\n\n  /**\n   * Removes and returns all elements in FIFO order, resetting the buffer.\n   */\n  drain(): T[] {\n    const result = this.toArray();\n    this.#head = 0;\n    this.#size = 0;\n    this.#buffer = Array.from({length: this.#capacity});\n    return result;\n  }\n\n  /** Copies all elements in FIFO order without removing them. */\n  toArray(): T[] {\n    const result = Array.from<T>({length: this.#size});\n    for (let i = 0; i < this.#size; i++) {\n      result[i] = this.#buffer[(this.#head + i) % this.#capacity] as T;\n    }\n    return result;\n  }\n\n  /** Removes all elements and releases extra capacity. */\n  clear(): void {\n    this.#head = 0;\n    this.#size = 0;\n    this.#capacity = MIN_CAPACITY;\n    this.#buffer = Array.from({length: this.#capacity});\n  }\n\n  /**\n   * Grows the buffer in place by doubling its length and relocating\n   * only the wrapped-around elements (those before #head) into the\n   * newly available space. No new array is allocated.\n   */\n  #grow(): void {\n    const oldLen = this.#buffer.length;\n    const newLen = oldLen * 2;\n    this.#buffer.length = newLen;\n    this.#capacity = newLen;\n\n    // Copy wrapped-around elements (indices 0..head-1) into the new space.\n    for (let i = 0; i < this.#head; i++) {\n      this.#buffer[oldLen + i] = this.#buffer[i];\n      this.#buffer[i] = undefined; // ensure gc when the element is removed\n    }\n  }\n\n  /**\n   * Shrinks the buffer in place by halving its length. Elements whose\n   * indices fall in the removed half are relocated into the lower half,\n   * then the array is truncated.\n   */\n  #shrink(): void {\n    const oldLen = this.#buffer.length;\n    const newLen = Math.max(MIN_CAPACITY, oldLen >> 1);\n\n    // Move elements that sit in the upper half down by newLen.\n    const left = Math.max(newLen, this.#head);\n    const right = Math.min(this.#head + this.#size, oldLen);\n    for (let i = left; i < right; i++) {\n      this.#buffer[i - newLen] = this.#buffer[i];\n    }\n\n    if (this.#head >= newLen) {\n      this.#head -= newLen;\n    }\n    this.#buffer.length = newLen;\n    this.#capacity = newLen;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"ring-buffer.js","names":[],"sources":["../../../../shared/src/ring-buffer.ts"],"sourcesContent":["const DEFAULT_INITIAL_CAPACITY = 16;\nconst MIN_CAPACITY = 16;\n\n/**\n * A FIFO ring buffer backed by a circular array. Provides:\n *\n * - `push()` — O(1) amortized (O(n) on resize)\n * - `shift()` — O(1)\n * - `size`    — O(1)\n * - `drain()` — O(n)\n *\n * The buffer grows (doubles) when full and shrinks (halves) when\n * utilization drops below 25%, bounded by {@link MIN_CAPACITY}.\n */\nexport class RingBuffer<T> {\n  #buffer: (T | undefined)[];\n  #head = 0;\n  #size = 0;\n  #capacity: number;\n\n  constructor(initialCapacity = DEFAULT_INITIAL_CAPACITY) {\n    this.#capacity = Math.max(MIN_CAPACITY, initialCapacity);\n    this.#buffer = Array.from({length: initialCapacity});\n  }\n\n  get size(): number {\n    return this.#size;\n  }\n\n  push(value: T): void {\n    if (this.#size === this.#capacity) {\n      this.#grow();\n    }\n    this.#buffer[(this.#head + this.#size) % this.#capacity] = value;\n    this.#size++;\n  }\n\n  /** Returns the front element without removing it, or `undefined` if empty. */\n  first(): T | undefined {\n    return this.#size === 0 ? undefined : this.#buffer[this.#head];\n  }\n\n  /** Returns the last element, or `undefined` if empty. */\n  last(): T | undefined {\n    return this.#size === 0\n      ? undefined\n      : this.#buffer[(this.#head + this.#size - 1) % this.#capacity];\n  }\n\n  /** Replaces the last element, or appends it if empty. */\n  replaceLast(value: T): void {\n    if (this.#size === 0) {\n      this.push(value);\n    } else {\n      this.#buffer[(this.#head + this.#size - 1) % this.#capacity] = value;\n    }\n  }\n\n  /** Removes and returns the front element, or `undefined` if empty. */\n  shift(): T | undefined {\n    if (this.#size === 0) {\n      return undefined;\n    }\n    const value = this.#buffer[this.#head];\n    this.#buffer[this.#head] = undefined; // allow GC of removed element\n    this.#head = (this.#head + 1) % this.#capacity;\n    this.#size--;\n\n    // Shrink when utilization drops below 25%, keeping a minimum capacity.\n    if (\n      this.#size > 0 &&\n      this.#size < this.#capacity >> 2 &&\n      this.#capacity > MIN_CAPACITY\n    ) {\n      this.#shrink();\n    }\n\n    return value;\n  }\n\n  /**\n   * Removes all elements matching `value` (by identity `===`).\n   *\n   * This is O(n) — suitable for rare operations like cancellation.\n   *\n   * @returns The number of elements removed.\n   */\n  delete(value: T): number {\n    if (this.#size === 0) {\n      return 0;\n    }\n    // Rebuild the buffer without matching elements.\n    const newBuffer: (T | undefined)[] = Array.from({length: this.#capacity});\n    let newSize = 0;\n    let count = 0;\n    for (let i = 0; i < this.#size; i++) {\n      const item = this.#buffer[(this.#head + i) % this.#capacity];\n      if (item === value) {\n        count++;\n      } else {\n        newBuffer[newSize++] = item;\n      }\n    }\n    this.#buffer = newBuffer;\n    this.#head = 0;\n    this.#size = newSize;\n    return count;\n  }\n\n  /**\n   * Removes and returns all elements in FIFO order, resetting the buffer.\n   */\n  drain(): T[] {\n    const result = this.toArray();\n    this.#head = 0;\n    this.#size = 0;\n    this.#buffer = Array.from({length: this.#capacity});\n    return result;\n  }\n\n  /** Copies all elements in FIFO order without removing them. */\n  toArray(): T[] {\n    const result = Array.from<T>({length: this.#size});\n    for (let i = 0; i < this.#size; i++) {\n      result[i] = this.#buffer[(this.#head + i) % this.#capacity] as T;\n    }\n    return result;\n  }\n\n  /** Removes all elements and releases extra capacity. */\n  clear(): void {\n    this.#head = 0;\n    this.#size = 0;\n    this.#capacity = MIN_CAPACITY;\n    this.#buffer = Array.from({length: this.#capacity});\n  }\n\n  /**\n   * Grows the buffer in place by doubling its length and relocating\n   * only the wrapped-around elements (those before #head) into the\n   * newly available space. No new array is allocated.\n   */\n  #grow(): void {\n    const oldLen = this.#buffer.length;\n    const newLen = oldLen * 2;\n    this.#buffer.length = newLen;\n    this.#capacity = newLen;\n\n    // Copy wrapped-around elements (indices 0..head-1) into the new space.\n    for (let i = 0; i < this.#head; i++) {\n      this.#buffer[oldLen + i] = this.#buffer[i];\n      this.#buffer[i] = undefined; // ensure gc when the element is removed\n    }\n  }\n\n  /**\n   * Shrinks the buffer in place by halving its length. Elements whose\n   * indices fall in the removed half are relocated into the lower half,\n   * then the array is truncated.\n   */\n  #shrink(): void {\n    const oldLen = this.#buffer.length;\n    const newLen = Math.max(MIN_CAPACITY, oldLen >> 1);\n\n    // Move elements that sit in the upper half down by newLen.\n    const left = Math.max(newLen, this.#head);\n    const right = Math.min(this.#head + this.#size, oldLen);\n    for (let i = left; i < right; i++) {\n      this.#buffer[i - newLen] = this.#buffer[i];\n    }\n\n    if (this.#head >= newLen) {\n      this.#head -= newLen;\n    }\n    this.#buffer.length = newLen;\n    this.#capacity = newLen;\n  }\n}\n"],"mappings":"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"}

package/out/shared/src/size-of-value.js

@@ -1,9 +1,6 @@
 import { hasOwn } from "./has-own.js";
 //#region ../shared/src/size-of-value.ts
 var SIZE_TAG = 1;
-var SIZE_INT32 = 4;
-var SIZE_SMI = 5;
-var SIZE_DOUBLE = 8;
 /**
 * Gives a size of a value. The size is modelled after the size used by
 * Chromium/V8's structuredClone algorithm. It does not match exactly so the
@@ -22,24 +19,24 @@ var SIZE_DOUBLE = 8;
 */
 function getSizeOfValue(value) {
 	switch (typeof value) {
-		case "string": return SIZE_TAG + SIZE_INT32 + value.length;
+		case "string": return 5 + value.length;
 		case "number":
 			if (isSmi(value)) {
-				if (value <= -(2 ** 30) || value >= 2 ** 30 - 1) return SIZE_TAG + SIZE_SMI;
-				return SIZE_TAG + SIZE_INT32;
+				if (value <= -(2 ** 30) || value >= 2 ** 30 - 1) return 6;
+				return 5;
 			}
-			return SIZE_TAG + SIZE_DOUBLE;
+			return 9;
 		case "boolean": return SIZE_TAG;
 		case "object":
 			if (value === null) return SIZE_TAG;
 			if (Array.isArray(value)) {
-				let sum = 2 * SIZE_TAG + SIZE_INT32;
+				let sum = 6;
 				for (const element of value) sum += getSizeOfValue(element);
 				return sum;
 			}
 			{
 				const val = value;
-				let sum = 2 * SIZE_TAG + SIZE_INT32;
+				let sum = 6;
 				for (const k in val) if (hasOwn(val, k)) {
 					const propertyValue = val[k];
 					if (propertyValue !== void 0) sum += getSizeOfValue(k) + getSizeOfValue(propertyValue);
@@ -52,7 +49,7 @@ function getSizeOfValue(value) {
 function isSmi(value) {
 	return value === (value | 0);
 }
-var entryFixed = 2 * SIZE_TAG + SIZE_INT32 + SIZE_TAG + SIZE_INT32;
+var entryFixed = 11;
 function getSizeOfEntry(key, value) {
 	return entryFixed + getSizeOfValue(key) + getSizeOfValue(value);
 }

package/out/shared/src/size-of-value.js.map

@@ -1 +1 @@
-{"version":3,"file":"size-of-value.js","names":[],"sources":["../../../../shared/src/size-of-value.ts"],"sourcesContent":["import {hasOwn} from './has-own.ts';\nimport type {ReadonlyJSONObject} from './json.ts';\n\nconst SIZE_TAG = 1;\nconst SIZE_INT32 = 4;\nconst SIZE_SMI = 5;\nconst SIZE_DOUBLE = 8;\n\n/**\n * Gives a size of a value. The size is modelled after the size used by\n * Chromium/V8's structuredClone algorithm. It does not match exactly so the\n * size is just an approximation.\n * https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/value-serializer.cc;l=102;drc=f0b6f7d12ea47ad7c08fb554f678c1e73801ca36;bpv=1;bpt=1\n * For example we follow JSC/Mozilla for ints and skip the varint encoding.\n *\n * Mozilla does things similarly. Main difference is that there is no varint\n * encoding and every value uses multiples of 64bits\n * https://searchfox.org/mozilla-central/source/js/src/vm/StructuredClone.cpp#94\n *\n * And JSC:\n * https://github.com/WebKit/WebKit/blob/main/Source/WebCore/bindings/js/SerializedScriptValue.cpp#L356\n * - Use 1 byte tag\n * - Numbers are either stored as Int32 or Float64\n */\nexport function getSizeOfValue(value: unknown): number {\n  switch (typeof value) {\n    case 'string':\n      // Assumes all strings are one byte strings. V8 writes OneByteString and\n      // TwoByteString. We could check the string but it would require iterating\n      // over all the characters.\n      return SIZE_TAG + SIZE_INT32 + value.length;\n    case 'number':\n      if (isSmi(value)) {\n        if (value <= -(2 ** 30) || value >= 2 ** 30 - 1) {\n          return SIZE_TAG + SIZE_SMI;\n        }\n        return SIZE_TAG + SIZE_INT32;\n      }\n      return SIZE_TAG + SIZE_DOUBLE;\n    case 'boolean':\n      return SIZE_TAG;\n    case 'object':\n      if (value === null) {\n        return SIZE_TAG;\n      }\n\n      if (Array.isArray(value)) {\n        let sum = 2 * SIZE_TAG + SIZE_INT32;\n        for (const element of value) {\n          sum += getSizeOfValue(element);\n        }\n        return sum;\n      }\n\n      {\n        const val = value as ReadonlyJSONObject;\n        let sum: number = 2 * SIZE_TAG + SIZE_INT32;\n        for (const k in val) {\n          if (hasOwn(val, k)) {\n            // Skip undefined values. undefined values in an object gets\n            // stripped if we round trip through JSON.stringif which is what we\n            // use when syncing.\n            const propertyValue = val[k];\n            if (propertyValue !== undefined) {\n              sum += getSizeOfValue(k) + getSizeOfValue(propertyValue);\n            }\n          }\n        }\n        return sum;\n      }\n  }\n\n  throw new Error(`Invalid value. type: ${typeof value}, value: ${value}`);\n}\n\nfunction isSmi(value: number): boolean {\n  return value === (value | 0);\n}\n\nconst entryFixed = 2 * SIZE_TAG + SIZE_INT32 + SIZE_TAG + SIZE_INT32;\n\nexport function getSizeOfEntry<K, V>(key: K, value: V): number {\n  // Entries are stored as [key, value, sizeOfEntry]\n  return entryFixed + getSizeOfValue(key) + getSizeOfValue(value);\n}\n"],"mappings":";;AAGA,IAAM,WAAW;AACjB,IAAM,aAAa;AACnB,IAAM,WAAW;AACjB,IAAM,cAAc;;;;;;;;;;;;;;;;;AAkBpB,SAAgB,eAAe,OAAwB;CACrD,QAAQ,OAAO,OAAf;EACE,KAAK,UAIH,OAAO,WAAW,aAAa,MAAM;EACvC,KAAK;GACH,IAAI,MAAM,KAAK,GAAG;IAChB,IAAI,SAAS,EAAE,KAAK,OAAO,SAAS,KAAK,KAAK,GAC5C,OAAO,WAAW;IAEpB,OAAO,WAAW;GACpB;GACA,OAAO,WAAW;EACpB,KAAK,WACH,OAAO;EACT,KAAK;GACH,IAAI,UAAU,MACZ,OAAO;GAGT,IAAI,MAAM,QAAQ,KAAK,GAAG;IACxB,IAAI,MAAM,IAAI,WAAW;IACzB,KAAK,MAAM,WAAW,OACpB,OAAO,eAAe,OAAO;IAE/B,OAAO;GACT;GAEA;IACE,MAAM,MAAM;IACZ,IAAI,MAAc,IAAI,WAAW;IACjC,KAAK,MAAM,KAAK,KACd,IAAI,OAAO,KAAK,CAAC,GAAG;KAIlB,MAAM,gBAAgB,IAAI;KAC1B,IAAI,kBAAkB,KAAA,GACpB,OAAO,eAAe,CAAC,IAAI,eAAe,aAAa;IAE3D;IAEF,OAAO;GACT;CACJ;CAEA,MAAM,IAAI,MAAM,wBAAwB,OAAO,MAAM,WAAW,OAAO;AACzE;AAEA,SAAS,MAAM,OAAwB;CACrC,OAAO,WAAW,QAAQ;AAC5B;AAEA,IAAM,aAAa,IAAI,WAAW,aAAa,WAAW;AAE1D,SAAgB,eAAqB,KAAQ,OAAkB;CAE7D,OAAO,aAAa,eAAe,GAAG,IAAI,eAAe,KAAK;AAChE"}
+{"version":3,"file":"size-of-value.js","names":[],"sources":["../../../../shared/src/size-of-value.ts"],"sourcesContent":["import {hasOwn} from './has-own.ts';\nimport type {ReadonlyJSONObject} from './json.ts';\n\nconst SIZE_TAG = 1;\nconst SIZE_INT32 = 4;\nconst SIZE_SMI = 5;\nconst SIZE_DOUBLE = 8;\n\n/**\n * Gives a size of a value. The size is modelled after the size used by\n * Chromium/V8's structuredClone algorithm. It does not match exactly so the\n * size is just an approximation.\n * https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/value-serializer.cc;l=102;drc=f0b6f7d12ea47ad7c08fb554f678c1e73801ca36;bpv=1;bpt=1\n * For example we follow JSC/Mozilla for ints and skip the varint encoding.\n *\n * Mozilla does things similarly. Main difference is that there is no varint\n * encoding and every value uses multiples of 64bits\n * https://searchfox.org/mozilla-central/source/js/src/vm/StructuredClone.cpp#94\n *\n * And JSC:\n * https://github.com/WebKit/WebKit/blob/main/Source/WebCore/bindings/js/SerializedScriptValue.cpp#L356\n * - Use 1 byte tag\n * - Numbers are either stored as Int32 or Float64\n */\nexport function getSizeOfValue(value: unknown): number {\n  switch (typeof value) {\n    case 'string':\n      // Assumes all strings are one byte strings. V8 writes OneByteString and\n      // TwoByteString. We could check the string but it would require iterating\n      // over all the characters.\n      return SIZE_TAG + SIZE_INT32 + value.length;\n    case 'number':\n      if (isSmi(value)) {\n        if (value <= -(2 ** 30) || value >= 2 ** 30 - 1) {\n          return SIZE_TAG + SIZE_SMI;\n        }\n        return SIZE_TAG + SIZE_INT32;\n      }\n      return SIZE_TAG + SIZE_DOUBLE;\n    case 'boolean':\n      return SIZE_TAG;\n    case 'object':\n      if (value === null) {\n        return SIZE_TAG;\n      }\n\n      if (Array.isArray(value)) {\n        let sum = 2 * SIZE_TAG + SIZE_INT32;\n        for (const element of value) {\n          sum += getSizeOfValue(element);\n        }\n        return sum;\n      }\n\n      {\n        const val = value as ReadonlyJSONObject;\n        let sum: number = 2 * SIZE_TAG + SIZE_INT32;\n        for (const k in val) {\n          if (hasOwn(val, k)) {\n            // Skip undefined values. undefined values in an object gets\n            // stripped if we round trip through JSON.stringif which is what we\n            // use when syncing.\n            const propertyValue = val[k];\n            if (propertyValue !== undefined) {\n              sum += getSizeOfValue(k) + getSizeOfValue(propertyValue);\n            }\n          }\n        }\n        return sum;\n      }\n  }\n\n  throw new Error(`Invalid value. type: ${typeof value}, value: ${value}`);\n}\n\nfunction isSmi(value: number): boolean {\n  return value === (value | 0);\n}\n\nconst entryFixed = 2 * SIZE_TAG + SIZE_INT32 + SIZE_TAG + SIZE_INT32;\n\nexport function getSizeOfEntry<K, V>(key: K, value: V): number {\n  // Entries are stored as [key, value, sizeOfEntry]\n  return entryFixed + getSizeOfValue(key) + getSizeOfValue(value);\n}\n"],"mappings":";;AAGA,IAAM,WAAW;;;;;;;;;;;;;;;;;AAqBjB,SAAgB,eAAe,OAAwB;CACrD,QAAQ,OAAO,OAAf;EACE,KAAK,UAIH,OAAO,IAAwB,MAAM;EACvC,KAAK;GACH,IAAI,MAAM,KAAK,GAAG;IAChB,IAAI,SAAS,EAAE,KAAK,OAAO,SAAS,KAAK,KAAK,GAC5C,OAAO;IAET,OAAO;GACT;GACA,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK;GACH,IAAI,UAAU,MACZ,OAAO;GAGT,IAAI,MAAM,QAAQ,KAAK,GAAG;IACxB,IAAI,MAAM;IACV,KAAK,MAAM,WAAW,OACpB,OAAO,eAAe,OAAO;IAE/B,OAAO;GACT;GAEA;IACE,MAAM,MAAM;IACZ,IAAI,MAAc;IAClB,KAAK,MAAM,KAAK,KACd,IAAI,OAAO,KAAK,CAAC,GAAG;KAIlB,MAAM,gBAAgB,IAAI;KAC1B,IAAI,kBAAkB,KAAA,GACpB,OAAO,eAAe,CAAC,IAAI,eAAe,aAAa;IAE3D;IAEF,OAAO;GACT;CACJ;CAEA,MAAM,IAAI,MAAM,wBAAwB,OAAO,MAAM,WAAW,OAAO;AACzE;AAEA,SAAS,MAAM,OAAwB;CACrC,OAAO,WAAW,QAAQ;AAC5B;AAEA,IAAM,aAAa;AAEnB,SAAgB,eAAqB,KAAQ,OAAkB;CAE7D,OAAO,aAAa,eAAe,GAAG,IAAI,eAAe,KAAK;AAChE"}

package/out/shared/src/sleep.js

@@ -1,5 +1,5 @@
+import { resolver } from "./resolver.js";
 import { AbortError } from "./abort-error.js";
-import { resolver } from "@rocicorp/resolver";
 //#region ../shared/src/sleep.ts
 var promiseVoid = Promise.resolve();
 var promiseNever = new Promise(() => void 0);

package/out/shared/src/sleep.js.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.js","names":[],"sources":["../../../../shared/src/sleep.ts"],"sourcesContent":["import {resolver} from '@rocicorp/resolver';\nimport {AbortError} from './abort-error.ts';\n\nconst promiseVoid = Promise.resolve();\nconst promiseNever = new Promise<void>(() => undefined);\n\n/**\n * Creates a promise that resolves after `ms` milliseconds. Note that if you\n * pass in `0` no `setTimeout` is used and the promise resolves immediately. In\n * other words no macro task is used in that case.\n *\n * Pass in an AbortSignal to clear the timeout.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  const newAbortError = () => new AbortError('Aborted');\n\n  if (signal?.aborted) {\n    return Promise.reject(newAbortError());\n  }\n\n  if (ms === 0) {\n    return promiseVoid;\n  }\n\n  return new Promise((resolve, reject) => {\n    let handleAbort: () => void;\n    if (signal) {\n      handleAbort = () => {\n        clearTimeout(id);\n        reject(newAbortError());\n      };\n      signal.addEventListener('abort', handleAbort, {once: true});\n    }\n\n    const id = setTimeout(() => {\n      resolve();\n      signal?.removeEventListener('abort', handleAbort);\n    }, ms);\n  });\n}\n\n/**\n * Returns a pair of promises. The first promise resolves after `ms` milliseconds\n * unless the AbortSignal is aborted. The second promise resolves when the AbortSignal\n * is aborted.\n */\nexport function sleepWithAbort(\n  ms: number,\n  signal: AbortSignal,\n): [ok: Promise<void>, aborted: Promise<void>] {\n  if (ms === 0) {\n    return [promiseVoid, promiseNever];\n  }\n\n  const {promise: abortedPromise, resolve: abortedResolve} = resolver<void>();\n\n  const sleepPromise = new Promise<void>(resolve => {\n    const handleAbort = () => {\n      clearTimeout(id);\n      abortedResolve();\n    };\n\n    const id = setTimeout(() => {\n      resolve();\n      signal.removeEventListener('abort', handleAbort);\n    }, ms);\n\n    signal.addEventListener('abort', handleAbort, {once: true});\n  });\n\n  return [sleepPromise, abortedPromise];\n}\n"],"mappings":";;;AAGA,IAAM,cAAc,QAAQ,QAAQ;AACpC,IAAM,eAAe,IAAI,cAAoB,KAAA,CAAS;;;;;;;;AAStD,SAAgB,MAAM,IAAY,QAAqC;CACrE,MAAM,sBAAsB,IAAI,WAAW,SAAS;CAEpD,IAAI,QAAQ,SACV,OAAO,QAAQ,OAAO,cAAc,CAAC;CAGvC,IAAI,OAAO,GACT,OAAO;CAGT,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,IAAI;EACJ,IAAI,QAAQ;GACV,oBAAoB;IAClB,aAAa,EAAE;IACf,OAAO,cAAc,CAAC;GACxB;GACA,OAAO,iBAAiB,SAAS,aAAa,EAAC,MAAM,KAAI,CAAC;EAC5D;EAEA,MAAM,KAAK,iBAAiB;GAC1B,QAAQ;GACR,QAAQ,oBAAoB,SAAS,WAAW;EAClD,GAAG,EAAE;CACP,CAAC;AACH;;;;;;AAOA,SAAgB,eACd,IACA,QAC6C;CAC7C,IAAI,OAAO,GACT,OAAO,CAAC,aAAa,YAAY;CAGnC,MAAM,EAAC,SAAS,gBAAgB,SAAS,mBAAkB,SAAe;CAgB1E,OAAO,CAAC,IAdiB,SAAc,YAAW;EAChD,MAAM,oBAAoB;GACxB,aAAa,EAAE;GACf,eAAe;EACjB;EAEA,MAAM,KAAK,iBAAiB;GAC1B,QAAQ;GACR,OAAO,oBAAoB,SAAS,WAAW;EACjD,GAAG,EAAE;EAEL,OAAO,iBAAiB,SAAS,aAAa,EAAC,MAAM,KAAI,CAAC;CAC5D,CAEQ,GAAc,cAAc;AACtC"}
+{"version":3,"file":"sleep.js","names":[],"sources":["../../../../shared/src/sleep.ts"],"sourcesContent":["import {AbortError} from './abort-error.ts';\nimport {resolver} from './resolver.ts';\n\nconst promiseVoid = Promise.resolve();\nconst promiseNever = new Promise<void>(() => undefined);\n\n/**\n * Creates a promise that resolves after `ms` milliseconds. Note that if you\n * pass in `0` no `setTimeout` is used and the promise resolves immediately. In\n * other words no macro task is used in that case.\n *\n * Pass in an AbortSignal to clear the timeout.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  const newAbortError = () => new AbortError('Aborted');\n\n  if (signal?.aborted) {\n    return Promise.reject(newAbortError());\n  }\n\n  if (ms === 0) {\n    return promiseVoid;\n  }\n\n  return new Promise((resolve, reject) => {\n    let handleAbort: () => void;\n    if (signal) {\n      handleAbort = () => {\n        clearTimeout(id);\n        reject(newAbortError());\n      };\n      signal.addEventListener('abort', handleAbort, {once: true});\n    }\n\n    const id = setTimeout(() => {\n      resolve();\n      signal?.removeEventListener('abort', handleAbort);\n    }, ms);\n  });\n}\n\n/**\n * Returns a pair of promises. The first promise resolves after `ms` milliseconds\n * unless the AbortSignal is aborted. The second promise resolves when the AbortSignal\n * is aborted.\n */\nexport function sleepWithAbort(\n  ms: number,\n  signal: AbortSignal,\n): [ok: Promise<void>, aborted: Promise<void>] {\n  if (ms === 0) {\n    return [promiseVoid, promiseNever];\n  }\n\n  const {promise: abortedPromise, resolve: abortedResolve} = resolver<void>();\n\n  const sleepPromise = new Promise<void>(resolve => {\n    const handleAbort = () => {\n      clearTimeout(id);\n      abortedResolve();\n    };\n\n    const id = setTimeout(() => {\n      resolve();\n      signal.removeEventListener('abort', handleAbort);\n    }, ms);\n\n    signal.addEventListener('abort', handleAbort, {once: true});\n  });\n\n  return [sleepPromise, abortedPromise];\n}\n"],"mappings":";;;AAGA,IAAM,cAAc,QAAQ,QAAQ;AACpC,IAAM,eAAe,IAAI,cAAoB,KAAA,CAAS;;;;;;;;AAStD,SAAgB,MAAM,IAAY,QAAqC;CACrE,MAAM,sBAAsB,IAAI,WAAW,SAAS;CAEpD,IAAI,QAAQ,SACV,OAAO,QAAQ,OAAO,cAAc,CAAC;CAGvC,IAAI,OAAO,GACT,OAAO;CAGT,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,IAAI;EACJ,IAAI,QAAQ;GACV,oBAAoB;IAClB,aAAa,EAAE;IACf,OAAO,cAAc,CAAC;GACxB;GACA,OAAO,iBAAiB,SAAS,aAAa,EAAC,MAAM,KAAI,CAAC;EAC5D;EAEA,MAAM,KAAK,iBAAiB;GAC1B,QAAQ;GACR,QAAQ,oBAAoB,SAAS,WAAW;EAClD,GAAG,EAAE;CACP,CAAC;AACH;;;;;;AAOA,SAAgB,eACd,IACA,QAC6C;CAC7C,IAAI,OAAO,GACT,OAAO,CAAC,aAAa,YAAY;CAGnC,MAAM,EAAC,SAAS,gBAAgB,SAAS,mBAAkB,SAAe;CAgB1E,OAAO,CAAC,IAdiB,SAAc,YAAW;EAChD,MAAM,oBAAoB;GACxB,aAAa,EAAE;GACf,eAAe;EACjB;EAEA,MAAM,KAAK,iBAAiB;GAC1B,QAAQ;GACR,OAAO,oBAAoB,SAAS,WAAW;EACjD,GAAG,EAAE;EAEL,OAAO,iBAAiB,SAAS,aAAa,EAAC,MAAM,KAAI,CAAC;CAC5D,CAEQ,GAAc,cAAc;AACtC"}

package/out/shared/src/sorted-entries.js.map

@@ -1 +1 @@
-{"version":3,"file":"sorted-entries.js","names":[],"sources":["../../../../shared/src/sorted-entries.ts"],"sourcesContent":["import {stringCompare} from './string-compare.ts';\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function sortedEntries<T extends Record<string, any>>(\n  object: T,\n): [keyof T & string, T[keyof T]][] {\n  return Object.entries(object).sort((a, b) => stringCompare(a[0], b[0]));\n}\n"],"mappings":";;AAGA,SAAgB,cACd,QACkC;CAClC,OAAO,OAAO,QAAQ,MAAM,EAAE,MAAM,GAAG,MAAM,cAAc,EAAE,IAAI,EAAE,EAAE,CAAC;AACxE"}
+{"version":3,"file":"sorted-entries.js","names":[],"sources":["../../../../shared/src/sorted-entries.ts"],"sourcesContent":["import {stringCompare} from './string-compare.ts';\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function sortedEntries<T extends Record<string, any>>(\n  object: T,\n): [keyof T & string, T[keyof T]][] {\n  return Object.entries(object).sort((a, b) => stringCompare(a[0], b[0]));\n}\n"],"mappings":";;AAGA,SAAgB,cACd,QACkC;CAClC,OAAO,OAAO,QAAQ,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,IAAI,EAAE,EAAE,CAAC;AACxE"}

package/out/shared/src/tdigest-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"tdigest-schema.js","names":[],"sources":["../../../../shared/src/tdigest-schema.ts"],"sourcesContent":["import * as v from './valita.ts';\n\n/**\n * Valita schema for TDigest JSON representation.\n * Matches the structure returned by TDigest.toJSON().\n */\n// oxlint-disable-next-line e18e/prefer-spread-syntax\nexport const tdigestSchema = v.tuple([v.number()]).concat(v.array(v.number()));\n\nexport type TDigestJSON = v.Infer<typeof tdigestSchema>;\n"],"mappings":";;;;;;AAOA,IAAa,gBAAgB,eAAE,MAAM,CAAC,eAAE,OAAO,CAAC,CAAC,EAAE,OAAO,eAAE,MAAM,eAAE,OAAO,CAAC,CAAC"}
+{"version":3,"file":"tdigest-schema.js","names":["v"],"sources":["../../../../shared/src/tdigest-schema.ts"],"sourcesContent":["import * as v from './valita.ts';\n\n/**\n * Valita schema for TDigest JSON representation.\n * Matches the structure returned by TDigest.toJSON().\n */\n// oxlint-disable-next-line e18e/prefer-spread-syntax\nexport const tdigestSchema = v.tuple([v.number()]).concat(v.array(v.number()));\n\nexport type TDigestJSON = v.Infer<typeof tdigestSchema>;\n"],"mappings":";;;;;;AAOA,IAAa,gBAAgBA,eAAE,MAAM,CAACA,eAAE,OAAO,CAAC,CAAC,CAAC,CAAC,OAAOA,eAAE,MAAMA,eAAE,OAAO,CAAC,CAAC"}

package/out/shared/src/tdigest.d.ts

@@ -59,5 +59,4 @@ export declare class TDigest {
      */
     cdf(x: number): number;
 }
-export declare function byteSizeForCompression(comp: number): number;
 //# sourceMappingURL=tdigest.d.ts.map

package/out/shared/src/tdigest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tdigest.d.ts","sourceRoot":"","sources":["../../../../shared/src/tdigest.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,QAAQ,EAAE,KAAK,YAAY,EAAC,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,qBAAqB,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACzC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CACrC;AAcD,qBAAa,OAAO;;IAClB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAqB7B;;;;;OAKG;IACH,YAAY,WAAW,GAAE,MAAY,EAOpC;IAED;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,OAAO,CASpD;IAED,KAAK,IAAI,IAAI,CASZ;IAED;;;OAGG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAU,GAAG,IAAI,CAiB1C;IAED,0DAA0D;IAC1D,eAAe,CAAC,YAAY,EAAE,YAAY,QAIzC;IAED;;;OAGG;IACH,WAAW,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,CAE7B;IAED;;;;QAII;IACJ,KAAK,CAAC,EAAE,EAAE,OAAO,QAShB;IAiHD;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,GAAE,YAAiB,GAAG,YAAY,CAO7C;IAED,KAAK,IAAI,MAAM,CAMd;IAED;;;OAGG;IACH,MAAM,IAAI,WAAW,CAOpB;IA6BD,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAqC1B;IAED;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CA2ErB;CAgBF;AAID,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB3D"}
+{"version":3,"file":"tdigest.d.ts","sourceRoot":"","sources":["../../../../shared/src/tdigest.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,QAAQ,EAAE,KAAK,YAAY,EAAC,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,qBAAqB,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACzC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CACrC;AAcD,qBAAa,OAAO;;IAClB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAqB7B;;;;;OAKG;IACH,YAAY,WAAW,GAAE,MAAY,EAOpC;IAED;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,OAAO,CASpD;IAED,KAAK,IAAI,IAAI,CASZ;IAED;;;OAGG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAU,GAAG,IAAI,CAiB1C;IAED,0DAA0D;IAC1D,eAAe,CAAC,YAAY,EAAE,YAAY,QAIzC;IAED;;;OAGG;IACH,WAAW,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,CAE7B;IAED;;;;QAII;IACJ,KAAK,CAAC,EAAE,EAAE,OAAO,QAShB;IAiHD;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,GAAE,YAAiB,GAAG,YAAY,CAO7C;IAED,KAAK,IAAI,MAAM,CAMd;IAED;;;OAGG;IACH,MAAM,IAAI,WAAW,CAOpB;IA6BD,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAqC1B;IAED;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CA2ErB;CAgBF"}

package/out/shared/src/tdigest.js.map

@@ -1 +1 @@
-{"version":3,"file":"tdigest.js","names":["#maxUnprocessed","#unprocessedMeans","#unprocessedWeights","#means","#weights","#unprocessedCount","#cumulative","#processedWeight","#unprocessedWeight","#min","#max","#grow","#process","#sortedUnprocessed","#integratedLocation","#integratedQ","#updateCumulative"],"sources":["../../../../shared/src/tdigest.ts"],"sourcesContent":["// Apache License 2.0\n// https://github.com/influxdata/tdigest\n\nimport {binarySearch} from './binary-search.ts';\nimport {Centroid, type CentroidList} from './centroid.ts';\nimport type {TDigestJSON} from './tdigest-schema.ts';\n\nexport interface ReadonlyTDigest {\n  readonly count: () => number;\n  readonly quantile: (q: number) => number;\n  readonly cdf: (x: number) => number;\n}\n\n/** Initial capacity of the buffer of unprocessed values. */\nconst INITIAL_CAPACITY = 16;\n\n// TDigest is a data structure for accurate on-line accumulation of\n// rank-based statistics such as quantiles and trimmed means.\n//\n// Unlike the Go original, centroids are kept as parallel arrays of means and\n// weights rather than as objects, so adding a value allocates nothing. New\n// values are buffered in a Float64Array and sorted with its native numeric\n// sort instead of Array.prototype.sort with a comparator. On an engine\n// without a JIT, such as Hermes in React Native, calling the comparator for\n// every comparison is what made adding values expensive.\nexport class TDigest {\n  readonly compression: number;\n\n  readonly #maxUnprocessed: number;\n\n  /** Means of the processed centroids, ascending. */\n  #means!: number[];\n  /** Weights of the processed centroids, parallel to `#means`. */\n  #weights!: number[];\n\n  /** Means of the values added since the last `#process`, in order. */\n  #unprocessedMeans: Float64Array;\n  /** Weights of the unprocessed values, parallel to `#unprocessedMeans`. */\n  #unprocessedWeights: Float64Array;\n  #unprocessedCount!: number;\n\n  #cumulative!: number[];\n  #processedWeight!: number;\n  #unprocessedWeight!: number;\n  #min!: number;\n  #max!: number;\n\n  /**\n   * A digest keeps roughly `compression` centroids, and buffers up to eight\n   * times as many values between merges. The Go original defaults to 1000;\n   * 100 keeps p50, p95 and p99 within about 0.5% for a tenth of the memory\n   * and serialized size, which is plenty for the inspector's percentiles.\n   */\n  constructor(compression: number = 100) {\n    this.compression = compression;\n    this.#maxUnprocessed = unprocessedSize(0, this.compression);\n    const capacity = Math.min(INITIAL_CAPACITY, this.#maxUnprocessed + 1);\n    this.#unprocessedMeans = new Float64Array(capacity);\n    this.#unprocessedWeights = new Float64Array(capacity);\n    this.reset();\n  }\n\n  /**\n   * fromJSON creates a TDigest from a JSON-serializable representation.\n   * The data should be an object with compression and centroids array.\n   */\n  static fromJSON(data: Readonly<TDigestJSON>): TDigest {\n    const digest = new TDigest(data[0]);\n    if (data.length % 2 !== 1) {\n      throw new Error('Invalid centroids array');\n    }\n    for (let i = 1; i < data.length; i += 2) {\n      digest.add(data[i], data[i + 1]);\n    }\n    return digest;\n  }\n\n  reset(): void {\n    this.#means = [];\n    this.#weights = [];\n    this.#unprocessedCount = 0;\n    this.#cumulative = [];\n    this.#processedWeight = 0;\n    this.#unprocessedWeight = 0;\n    this.#min = Number.MAX_VALUE;\n    this.#max = -Number.MAX_VALUE;\n  }\n\n  /**\n   * Adds a value with the given weight.\n   * Weights which are not a number or are <= 0 are ignored, as are NaN means.\n   */\n  add(mean: number, weight: number = 1): void {\n    if (Number.isNaN(mean) || weight <= 0 || !Number.isFinite(weight)) {\n      return;\n    }\n\n    const n = this.#unprocessedCount;\n    if (n === this.#unprocessedMeans.length) {\n      this.#grow();\n    }\n    this.#unprocessedMeans[n] = mean;\n    this.#unprocessedWeights[n] = weight;\n    this.#unprocessedCount = n + 1;\n    this.#unprocessedWeight += weight;\n\n    if (this.#unprocessedCount > this.#maxUnprocessed) {\n      this.#process();\n    }\n  }\n\n  /** AddCentroidList can quickly add multiple centroids. */\n  addCentroidList(centroidList: CentroidList) {\n    for (const c of centroidList) {\n      this.add(c.mean, c.weight);\n    }\n  }\n\n  /**\n   * AddCentroid adds a single centroid.\n   * Weights which are not a number or are <= 0 are ignored, as are NaN means.\n   */\n  addCentroid(c: Centroid): void {\n    this.add(c.mean, c.weight);\n  }\n\n  /**\n   *  Merges the supplied digest into this digest. Functionally equivalent to\n   * calling t.AddCentroidList(t2.Centroids(nil)), but avoids making an extra\n   * copy of the CentroidList.\n   **/\n  merge(t2: TDigest) {\n    t2.#process();\n    // #process replaces the arrays rather than changing them, so these stay\n    // intact even if t2 is this digest.\n    const means = t2.#means;\n    const weights = t2.#weights;\n    for (let i = 0; i < means.length; i++) {\n      this.add(means[i], weights[i]);\n    }\n  }\n\n  /** Doubles the unprocessed buffer, up to what `add` lets it hold. */\n  #grow(): void {\n    const capacity = Math.min(\n      this.#unprocessedMeans.length * 2,\n      this.#maxUnprocessed + 1,\n    );\n    const means = new Float64Array(capacity);\n    means.set(this.#unprocessedMeans);\n    this.#unprocessedMeans = means;\n    const weights = new Float64Array(capacity);\n    weights.set(this.#unprocessedWeights);\n    this.#unprocessedWeights = weights;\n  }\n\n  /**\n   * Merges the unprocessed values into the centroids: walks both in order of\n   * mean, folding each into the last centroid while that stays within its\n   * size limit, and starting a new centroid otherwise.\n   */\n  #process() {\n    if (this.#unprocessedCount === 0) {\n      return;\n    }\n    const [newMeans, newWeights] = this.#sortedUnprocessed();\n    const oldMeans = this.#means;\n    const oldWeights = this.#weights;\n    const n = newMeans.length;\n    const p = oldMeans.length;\n    this.#unprocessedCount = 0;\n    this.#processedWeight += this.#unprocessedWeight;\n    this.#unprocessedWeight = 0;\n    const total = this.#processedWeight;\n\n    const means: number[] = [];\n    const weights: number[] = [];\n    // The centroid being built, kept in locals rather than in the arrays,\n    // which is markedly faster without a JIT. Its weight is 0 until the first\n    // value.\n    let mean = 0;\n    let weight = 0;\n    let soFar = 0;\n    // A limit of 0 makes the first value start a centroid, whose limit then\n    // comes from the same formula as every other's. With soFar at 0 that is\n    // integratedQ(1): integratedLocation(0) is exactly 0, since\n    // Math.asin(-1) is -Math.PI / 2.\n    let limit = 0;\n    let i = 0;\n    let j = 0;\n    while (i < n || j < p) {\n      // On a tie the new value goes first, as in the original, which appended\n      // the old centroids to the new values and sorted them with a stable sort.\n      let m: number;\n      let w: number;\n      if (i < n && (j === p || newMeans[i] <= oldMeans[j])) {\n        m = newMeans[i];\n        w = newWeights[i++];\n      } else {\n        m = oldMeans[j];\n        w = oldWeights[j++];\n      }\n      if (soFar + w <= limit) {\n        // Same arithmetic as Centroid.add.\n        weight += w;\n        mean += (w * (m - mean)) / weight;\n      } else {\n        if (weight > 0) {\n          means.push(mean);\n          weights.push(weight);\n        }\n        const k = this.#integratedLocation(soFar / total);\n        limit = total * this.#integratedQ(k + 1);\n        mean = m;\n        weight = w;\n      }\n      soFar += w;\n    }\n    means.push(mean);\n    weights.push(weight);\n\n    this.#means = means;\n    this.#weights = weights;\n    this.#min = Math.min(this.#min, means[0]);\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    this.#max = Math.max(this.#max, means.at(-1)!);\n  }\n\n  /** The unprocessed means and weights, sorted by mean. */\n  #sortedUnprocessed(): [Float64Array, Float64Array] {\n    const n = this.#unprocessedCount;\n    const means = this.#unprocessedMeans.subarray(0, n);\n    const weights = this.#unprocessedWeights.subarray(0, n);\n    // fromJSON and merge add centroids in order of mean.\n    if (isSorted(means)) {\n      return [means, weights];\n    }\n    // With one weight for all the values, sorting the means alone keeps every\n    // value with its weight, and the native numeric sort needs no comparator.\n    if (allEqual(weights)) {\n      means.sort();\n      return [means, weights];\n    }\n    // A stable sort, so values with equal means stay in the order added.\n    const order = Array.from(means, (_, k) => k).sort(\n      (a, b) => means[a] - means[b],\n    );\n    return [\n      Float64Array.from(order, k => means[k]),\n      Float64Array.from(order, k => weights[k]),\n    ];\n  }\n\n  /**\n   * Centroids returns a copy of processed centroids.\n   * Useful when aggregating multiple t-digests.\n   *\n   * Centroids are appended to the passed CentroidList; if you're re-using a\n   * buffer, be sure to pass cl[:0].\n   */\n  centroids(cl: CentroidList = []): CentroidList {\n    this.#process();\n    const result = [...cl];\n    for (let i = 0; i < this.#means.length; i++) {\n      result.push(new Centroid(this.#means[i], this.#weights[i]));\n    }\n    return result;\n  }\n\n  count(): number {\n    this.#process();\n\n    // this.process always updates this.processedWeight to the total count of all\n    // centroids, so we don't need to re-count here.\n    return this.#processedWeight;\n  }\n\n  /**\n   * toJSON returns a JSON-serializable representation of the digest.\n   * This processes the digest and returns an object with compression and centroid data.\n   */\n  toJSON(): TDigestJSON {\n    this.#process();\n    const data: TDigestJSON = [this.compression];\n    for (let i = 0; i < this.#means.length; i++) {\n      data.push(this.#means[i], this.#weights[i]);\n    }\n    return data;\n  }\n\n  #updateCumulative() {\n    // Weight can only increase, so the final cumulative value will always be\n    // either equal to, or less than, the total weight. If they are the same,\n    // then nothing has changed since the last update.\n    if (\n      this.#cumulative.length > 0 &&\n      this.#cumulative.at(-1) === this.#processedWeight\n    ) {\n      return;\n    }\n    const n = this.#means.length + 1;\n    if (this.#cumulative.length > n) {\n      this.#cumulative.length = n;\n    }\n\n    let prev = 0;\n    for (let i = 0; i < this.#means.length; i++) {\n      const cur = this.#weights[i];\n      this.#cumulative[i] = prev + cur / 2;\n      prev += cur;\n    }\n    this.#cumulative[this.#means.length] = prev;\n  }\n\n  // Quantile returns the (approximate) quantile of\n  // the distribution. Accepted values for q are between 0 and 1.\n  // Returns NaN if Count is zero or bad inputs.\n  quantile(q: number): number {\n    this.#process();\n    this.#updateCumulative();\n    if (q < 0 || q > 1 || this.#means.length === 0) {\n      return NaN;\n    }\n    if (this.#means.length === 1) {\n      return this.#means[0];\n    }\n    const index = q * this.#processedWeight;\n    if (index <= this.#weights[0] / 2) {\n      return (\n        this.#min +\n        ((2 * index) / this.#weights[0]) * (this.#means[0] - this.#min)\n      );\n    }\n\n    const lower = binarySearch(\n      this.#cumulative.length,\n      (i: number) => -this.#cumulative[i] + index,\n    );\n\n    if (lower + 1 !== this.#cumulative.length) {\n      const z1 = index - this.#cumulative[lower - 1];\n      const z2 = this.#cumulative[lower] - index;\n      return weightedAverage(\n        this.#means[lower - 1],\n        z2,\n        this.#means[lower],\n        z1,\n      );\n    }\n\n    const z1 = index - this.#processedWeight - this.#weights[lower - 1] / 2;\n    const z2 = this.#weights[lower - 1] / 2 - z1;\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    return weightedAverage(this.#means.at(-1)!, z1, this.#max, z2);\n  }\n\n  /**\n   * CDF returns the cumulative distribution function for a given value x.\n   */\n  cdf(x: number): number {\n    this.#process();\n    this.#updateCumulative();\n    switch (this.#means.length) {\n      case 0:\n        return 0;\n      case 1: {\n        const width = this.#max - this.#min;\n        if (x <= this.#min) {\n          return 0;\n        }\n        if (x >= this.#max) {\n          return 1;\n        }\n        if (x - this.#min <= width) {\n          // min and max are too close together to do any viable interpolation\n          return 0.5;\n        }\n        return (x - this.#min) / width;\n      }\n    }\n\n    if (x <= this.#min) {\n      return 0;\n    }\n    if (x >= this.#max) {\n      return 1;\n    }\n    const m0 = this.#means[0];\n    // Left Tail\n    if (x <= m0) {\n      if (m0 - this.#min > 0) {\n        return (\n          (((x - this.#min) / (m0 - this.#min)) * this.#weights[0]) /\n          this.#processedWeight /\n          2\n        );\n      }\n      return 0;\n    }\n    // Right Tail\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    const mn = this.#means.at(-1)!;\n    if (x >= mn) {\n      if (this.#max - mn > 0) {\n        return (\n          1 -\n          (((this.#max - x) / (this.#max - mn)) *\n            // oxlint-disable-next-line typescript/no-non-null-assertion\n            this.#weights.at(-1)!) /\n            this.#processedWeight /\n            2\n        );\n      }\n      return 1;\n    }\n\n    const upper = binarySearch(\n      this.#means.length,\n      // Treat equals as greater than, so we can use the upper index\n      // This is equivalent to:\n      //   i => this.#means[i] > x ? -1 : 1,\n      i => x - this.#means[i] || 1,\n    );\n\n    const z1 = x - this.#means[upper - 1];\n    const z2 = this.#means[upper] - x;\n    return (\n      weightedAverage(\n        this.#cumulative[upper - 1],\n        z2,\n        this.#cumulative[upper],\n        z1,\n      ) / this.#processedWeight\n    );\n  }\n\n  #integratedQ(k: number): number {\n    return (\n      (Math.sin(\n        (Math.min(k, this.compression) * Math.PI) / this.compression -\n          Math.PI / 2,\n      ) +\n        1) /\n      2\n    );\n  }\n\n  #integratedLocation(q: number): number {\n    return (this.compression * (Math.asin(2 * q - 1) + Math.PI / 2)) / Math.PI;\n  }\n}\n\n// Calculate number of bytes needed for a tdigest of size c,\n// where c is the compression value\nexport function byteSizeForCompression(comp: number): number {\n  const c = comp | 0;\n  // // A centroid is 2 float64s, so we need 16 bytes for each centroid\n  // float_size := 8\n  // centroid_size := 2 * float_size\n\n  // // Unprocessed and processed can grow up to length c\n  // unprocessed_size := centroid_size * c\n  // processed_size := unprocessed_size\n\n  // // the cumulative field can also be of length c, but each item is a single float64\n  // cumulative_size := float_size * c // <- this could also be unprocessed_size / 2\n\n  // return unprocessed_size + processed_size + cumulative_size\n\n  // // or, more succinctly:\n  // return float_size * c * 5\n\n  // or even more succinctly\n  return c * 40;\n}\n\nfunction isSorted(values: Float64Array): boolean {\n  for (let i = 1; i < values.length; i++) {\n    if (values[i] < values[i - 1]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction allEqual(values: Float64Array): boolean {\n  for (let i = 1; i < values.length; i++) {\n    if (values[i] !== values[0]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction weightedAverage(\n  x1: number,\n  w1: number,\n  x2: number,\n  w2: number,\n): number {\n  if (x1 <= x2) {\n    return weightedAverageSorted(x1, w1, x2, w2);\n  }\n  return weightedAverageSorted(x2, w2, x1, w1);\n}\n\nfunction weightedAverageSorted(\n  x1: number,\n  w1: number,\n  x2: number,\n  w2: number,\n): number {\n  const x = (x1 * w1 + x2 * w2) / (w1 + w2);\n  return Math.max(x1, Math.min(x, x2));\n}\n\nfunction unprocessedSize(size: number, compression: number): number {\n  if (size === 0) {\n    return Math.ceil(compression) * 8;\n  }\n  return size;\n}\n"],"mappings":"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"}
+{"version":3,"file":"tdigest.js","names":[],"sources":["../../../../shared/src/tdigest.ts"],"sourcesContent":["// Apache License 2.0\n// https://github.com/influxdata/tdigest\n\nimport {binarySearch} from './binary-search.ts';\nimport {Centroid, type CentroidList} from './centroid.ts';\nimport type {TDigestJSON} from './tdigest-schema.ts';\n\nexport interface ReadonlyTDigest {\n  readonly count: () => number;\n  readonly quantile: (q: number) => number;\n  readonly cdf: (x: number) => number;\n}\n\n/** Initial capacity of the buffer of unprocessed values. */\nconst INITIAL_CAPACITY = 16;\n\n// TDigest is a data structure for accurate on-line accumulation of\n// rank-based statistics such as quantiles and trimmed means.\n//\n// Unlike the Go original, centroids are kept as parallel arrays of means and\n// weights rather than as objects, so adding a value allocates nothing. New\n// values are buffered in a Float64Array and sorted with its native numeric\n// sort instead of Array.prototype.sort with a comparator. On an engine\n// without a JIT, such as Hermes in React Native, calling the comparator for\n// every comparison is what made adding values expensive.\nexport class TDigest {\n  readonly compression: number;\n\n  readonly #maxUnprocessed: number;\n\n  /** Means of the processed centroids, ascending. */\n  #means!: number[];\n  /** Weights of the processed centroids, parallel to `#means`. */\n  #weights!: number[];\n\n  /** Means of the values added since the last `#process`, in order. */\n  #unprocessedMeans: Float64Array;\n  /** Weights of the unprocessed values, parallel to `#unprocessedMeans`. */\n  #unprocessedWeights: Float64Array;\n  #unprocessedCount!: number;\n\n  #cumulative!: number[];\n  #processedWeight!: number;\n  #unprocessedWeight!: number;\n  #min!: number;\n  #max!: number;\n\n  /**\n   * A digest keeps roughly `compression` centroids, and buffers up to eight\n   * times as many values between merges. The Go original defaults to 1000;\n   * 100 keeps p50, p95 and p99 within about 0.5% for a tenth of the memory\n   * and serialized size, which is plenty for the inspector's percentiles.\n   */\n  constructor(compression: number = 100) {\n    this.compression = compression;\n    this.#maxUnprocessed = unprocessedSize(0, this.compression);\n    const capacity = Math.min(INITIAL_CAPACITY, this.#maxUnprocessed + 1);\n    this.#unprocessedMeans = new Float64Array(capacity);\n    this.#unprocessedWeights = new Float64Array(capacity);\n    this.reset();\n  }\n\n  /**\n   * fromJSON creates a TDigest from a JSON-serializable representation.\n   * The data should be an object with compression and centroids array.\n   */\n  static fromJSON(data: Readonly<TDigestJSON>): TDigest {\n    const digest = new TDigest(data[0]);\n    if (data.length % 2 !== 1) {\n      throw new Error('Invalid centroids array');\n    }\n    for (let i = 1; i < data.length; i += 2) {\n      digest.add(data[i], data[i + 1]);\n    }\n    return digest;\n  }\n\n  reset(): void {\n    this.#means = [];\n    this.#weights = [];\n    this.#unprocessedCount = 0;\n    this.#cumulative = [];\n    this.#processedWeight = 0;\n    this.#unprocessedWeight = 0;\n    this.#min = Number.MAX_VALUE;\n    this.#max = -Number.MAX_VALUE;\n  }\n\n  /**\n   * Adds a value with the given weight.\n   * Weights which are not a number or are <= 0 are ignored, as are NaN means.\n   */\n  add(mean: number, weight: number = 1): void {\n    if (Number.isNaN(mean) || weight <= 0 || !Number.isFinite(weight)) {\n      return;\n    }\n\n    const n = this.#unprocessedCount;\n    if (n === this.#unprocessedMeans.length) {\n      this.#grow();\n    }\n    this.#unprocessedMeans[n] = mean;\n    this.#unprocessedWeights[n] = weight;\n    this.#unprocessedCount = n + 1;\n    this.#unprocessedWeight += weight;\n\n    if (this.#unprocessedCount > this.#maxUnprocessed) {\n      this.#process();\n    }\n  }\n\n  /** AddCentroidList can quickly add multiple centroids. */\n  addCentroidList(centroidList: CentroidList) {\n    for (const c of centroidList) {\n      this.add(c.mean, c.weight);\n    }\n  }\n\n  /**\n   * AddCentroid adds a single centroid.\n   * Weights which are not a number or are <= 0 are ignored, as are NaN means.\n   */\n  addCentroid(c: Centroid): void {\n    this.add(c.mean, c.weight);\n  }\n\n  /**\n   *  Merges the supplied digest into this digest. Functionally equivalent to\n   * calling t.AddCentroidList(t2.Centroids(nil)), but avoids making an extra\n   * copy of the CentroidList.\n   **/\n  merge(t2: TDigest) {\n    t2.#process();\n    // #process replaces the arrays rather than changing them, so these stay\n    // intact even if t2 is this digest.\n    const means = t2.#means;\n    const weights = t2.#weights;\n    for (let i = 0; i < means.length; i++) {\n      this.add(means[i], weights[i]);\n    }\n  }\n\n  /** Doubles the unprocessed buffer, up to what `add` lets it hold. */\n  #grow(): void {\n    const capacity = Math.min(\n      this.#unprocessedMeans.length * 2,\n      this.#maxUnprocessed + 1,\n    );\n    const means = new Float64Array(capacity);\n    means.set(this.#unprocessedMeans);\n    this.#unprocessedMeans = means;\n    const weights = new Float64Array(capacity);\n    weights.set(this.#unprocessedWeights);\n    this.#unprocessedWeights = weights;\n  }\n\n  /**\n   * Merges the unprocessed values into the centroids: walks both in order of\n   * mean, folding each into the last centroid while that stays within its\n   * size limit, and starting a new centroid otherwise.\n   */\n  #process() {\n    if (this.#unprocessedCount === 0) {\n      return;\n    }\n    const [newMeans, newWeights] = this.#sortedUnprocessed();\n    const oldMeans = this.#means;\n    const oldWeights = this.#weights;\n    const n = newMeans.length;\n    const p = oldMeans.length;\n    this.#unprocessedCount = 0;\n    this.#processedWeight += this.#unprocessedWeight;\n    this.#unprocessedWeight = 0;\n    const total = this.#processedWeight;\n\n    const means: number[] = [];\n    const weights: number[] = [];\n    // The centroid being built, kept in locals rather than in the arrays,\n    // which is markedly faster without a JIT. Its weight is 0 until the first\n    // value.\n    let mean = 0;\n    let weight = 0;\n    let soFar = 0;\n    // A limit of 0 makes the first value start a centroid, whose limit then\n    // comes from the same formula as every other's. With soFar at 0 that is\n    // integratedQ(1): integratedLocation(0) is exactly 0, since\n    // Math.asin(-1) is -Math.PI / 2.\n    let limit = 0;\n    let i = 0;\n    let j = 0;\n    while (i < n || j < p) {\n      // On a tie the new value goes first, as in the original, which appended\n      // the old centroids to the new values and sorted them with a stable sort.\n      let m: number;\n      let w: number;\n      if (i < n && (j === p || newMeans[i] <= oldMeans[j])) {\n        m = newMeans[i];\n        w = newWeights[i++];\n      } else {\n        m = oldMeans[j];\n        w = oldWeights[j++];\n      }\n      if (soFar + w <= limit) {\n        // Same arithmetic as Centroid.add.\n        weight += w;\n        mean += (w * (m - mean)) / weight;\n      } else {\n        if (weight > 0) {\n          means.push(mean);\n          weights.push(weight);\n        }\n        const k = this.#integratedLocation(soFar / total);\n        limit = total * this.#integratedQ(k + 1);\n        mean = m;\n        weight = w;\n      }\n      soFar += w;\n    }\n    means.push(mean);\n    weights.push(weight);\n\n    this.#means = means;\n    this.#weights = weights;\n    this.#min = Math.min(this.#min, means[0]);\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    this.#max = Math.max(this.#max, means.at(-1)!);\n  }\n\n  /** The unprocessed means and weights, sorted by mean. */\n  #sortedUnprocessed(): [Float64Array, Float64Array] {\n    const n = this.#unprocessedCount;\n    const means = this.#unprocessedMeans.subarray(0, n);\n    const weights = this.#unprocessedWeights.subarray(0, n);\n    // fromJSON and merge add centroids in order of mean.\n    if (isSorted(means)) {\n      return [means, weights];\n    }\n    // With one weight for all the values, sorting the means alone keeps every\n    // value with its weight, and the native numeric sort needs no comparator.\n    if (allEqual(weights)) {\n      means.sort();\n      return [means, weights];\n    }\n    // A stable sort, so values with equal means stay in the order added.\n    const order = Array.from(means, (_, k) => k).sort(\n      (a, b) => means[a] - means[b],\n    );\n    return [\n      Float64Array.from(order, k => means[k]),\n      Float64Array.from(order, k => weights[k]),\n    ];\n  }\n\n  /**\n   * Centroids returns a copy of processed centroids.\n   * Useful when aggregating multiple t-digests.\n   *\n   * Centroids are appended to the passed CentroidList; if you're re-using a\n   * buffer, be sure to pass cl[:0].\n   */\n  centroids(cl: CentroidList = []): CentroidList {\n    this.#process();\n    const result = [...cl];\n    for (let i = 0; i < this.#means.length; i++) {\n      result.push(new Centroid(this.#means[i], this.#weights[i]));\n    }\n    return result;\n  }\n\n  count(): number {\n    this.#process();\n\n    // this.process always updates this.processedWeight to the total count of all\n    // centroids, so we don't need to re-count here.\n    return this.#processedWeight;\n  }\n\n  /**\n   * toJSON returns a JSON-serializable representation of the digest.\n   * This processes the digest and returns an object with compression and centroid data.\n   */\n  toJSON(): TDigestJSON {\n    this.#process();\n    const data: TDigestJSON = [this.compression];\n    for (let i = 0; i < this.#means.length; i++) {\n      data.push(this.#means[i], this.#weights[i]);\n    }\n    return data;\n  }\n\n  #updateCumulative() {\n    // Weight can only increase, so the final cumulative value will always be\n    // either equal to, or less than, the total weight. If they are the same,\n    // then nothing has changed since the last update.\n    if (\n      this.#cumulative.length > 0 &&\n      this.#cumulative.at(-1) === this.#processedWeight\n    ) {\n      return;\n    }\n    const n = this.#means.length + 1;\n    if (this.#cumulative.length > n) {\n      this.#cumulative.length = n;\n    }\n\n    let prev = 0;\n    for (let i = 0; i < this.#means.length; i++) {\n      const cur = this.#weights[i];\n      this.#cumulative[i] = prev + cur / 2;\n      prev += cur;\n    }\n    this.#cumulative[this.#means.length] = prev;\n  }\n\n  // Quantile returns the (approximate) quantile of\n  // the distribution. Accepted values for q are between 0 and 1.\n  // Returns NaN if Count is zero or bad inputs.\n  quantile(q: number): number {\n    this.#process();\n    this.#updateCumulative();\n    if (q < 0 || q > 1 || this.#means.length === 0) {\n      return NaN;\n    }\n    if (this.#means.length === 1) {\n      return this.#means[0];\n    }\n    const index = q * this.#processedWeight;\n    if (index <= this.#weights[0] / 2) {\n      return (\n        this.#min +\n        ((2 * index) / this.#weights[0]) * (this.#means[0] - this.#min)\n      );\n    }\n\n    const lower = binarySearch(\n      this.#cumulative.length,\n      (i: number) => -this.#cumulative[i] + index,\n    );\n\n    if (lower + 1 !== this.#cumulative.length) {\n      const z1 = index - this.#cumulative[lower - 1];\n      const z2 = this.#cumulative[lower] - index;\n      return weightedAverage(\n        this.#means[lower - 1],\n        z2,\n        this.#means[lower],\n        z1,\n      );\n    }\n\n    const z1 = index - this.#processedWeight - this.#weights[lower - 1] / 2;\n    const z2 = this.#weights[lower - 1] / 2 - z1;\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    return weightedAverage(this.#means.at(-1)!, z1, this.#max, z2);\n  }\n\n  /**\n   * CDF returns the cumulative distribution function for a given value x.\n   */\n  cdf(x: number): number {\n    this.#process();\n    this.#updateCumulative();\n    switch (this.#means.length) {\n      case 0:\n        return 0;\n      case 1: {\n        const width = this.#max - this.#min;\n        if (x <= this.#min) {\n          return 0;\n        }\n        if (x >= this.#max) {\n          return 1;\n        }\n        if (x - this.#min <= width) {\n          // min and max are too close together to do any viable interpolation\n          return 0.5;\n        }\n        return (x - this.#min) / width;\n      }\n    }\n\n    if (x <= this.#min) {\n      return 0;\n    }\n    if (x >= this.#max) {\n      return 1;\n    }\n    const m0 = this.#means[0];\n    // Left Tail\n    if (x <= m0) {\n      if (m0 - this.#min > 0) {\n        return (\n          (((x - this.#min) / (m0 - this.#min)) * this.#weights[0]) /\n          this.#processedWeight /\n          2\n        );\n      }\n      return 0;\n    }\n    // Right Tail\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    const mn = this.#means.at(-1)!;\n    if (x >= mn) {\n      if (this.#max - mn > 0) {\n        return (\n          1 -\n          (((this.#max - x) / (this.#max - mn)) *\n            // oxlint-disable-next-line typescript/no-non-null-assertion\n            this.#weights.at(-1)!) /\n            this.#processedWeight /\n            2\n        );\n      }\n      return 1;\n    }\n\n    const upper = binarySearch(\n      this.#means.length,\n      // Treat equals as greater than, so we can use the upper index\n      // This is equivalent to:\n      //   i => this.#means[i] > x ? -1 : 1,\n      i => x - this.#means[i] || 1,\n    );\n\n    const z1 = x - this.#means[upper - 1];\n    const z2 = this.#means[upper] - x;\n    return (\n      weightedAverage(\n        this.#cumulative[upper - 1],\n        z2,\n        this.#cumulative[upper],\n        z1,\n      ) / this.#processedWeight\n    );\n  }\n\n  #integratedQ(k: number): number {\n    return (\n      (Math.sin(\n        (Math.min(k, this.compression) * Math.PI) / this.compression -\n          Math.PI / 2,\n      ) +\n        1) /\n      2\n    );\n  }\n\n  #integratedLocation(q: number): number {\n    return (this.compression * (Math.asin(2 * q - 1) + Math.PI / 2)) / Math.PI;\n  }\n}\n\nfunction isSorted(values: Float64Array): boolean {\n  for (let i = 1; i < values.length; i++) {\n    if (values[i] < values[i - 1]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction allEqual(values: Float64Array): boolean {\n  for (let i = 1; i < values.length; i++) {\n    if (values[i] !== values[0]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction weightedAverage(\n  x1: number,\n  w1: number,\n  x2: number,\n  w2: number,\n): number {\n  if (x1 <= x2) {\n    return weightedAverageSorted(x1, w1, x2, w2);\n  }\n  return weightedAverageSorted(x2, w2, x1, w1);\n}\n\nfunction weightedAverageSorted(\n  x1: number,\n  w1: number,\n  x2: number,\n  w2: number,\n): number {\n  const x = (x1 * w1 + x2 * w2) / (w1 + w2);\n  return Math.max(x1, Math.min(x, x2));\n}\n\nfunction unprocessedSize(size: number, compression: number): number {\n  if (size === 0) {\n    return Math.ceil(compression) * 8;\n  }\n  return size;\n}\n"],"mappings":"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"}

package/out/shared/src/valita.js

@@ -285,6 +285,6 @@ function taggedObjectUnion(key, objects, options) {
 	});
 }
 //#endregion
-export { assert, deepPartial, instanceOfAbstractType, literalUnion, openLiteralUnion, parse, readonly, readonlyArray, readonlyObject, readonlyRecord, strict, taggedObjectUnion, taggedTupleUnion, test, testOptional, toTerminals, valita_exports };
+export { assert, assertUnrecognized, deepPartial, instanceOfAbstractType, is, literalUnion, openLiteralUnion, parse, readonly, readonlyArray, readonlyObject, readonlyRecord, strict, taggedObjectUnion, taggedTupleUnion, test, testOptional, toTerminals, valita_exports };
 
 //# sourceMappingURL=valita.js.map

package/out/shared/src/valita.js.map

@@ -1 +1 @@
-{"version":3,"file":"valita.js","names":[],"sources":["../../../../shared/src/valita.ts"],"sourcesContent":["import * as v from '@badrap/valita';\n\nexport * from '@badrap/valita';\n\nfunction toDisplay(value: unknown): string {\n  switch (typeof value) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n      return JSON.stringify(value);\n    case 'undefined':\n      return 'undefined';\n    case 'bigint':\n      return value.toString() + 'n';\n    default:\n      if (value === null) {\n        return 'null';\n      }\n      if (Array.isArray(value)) {\n        return 'array';\n      }\n      return typeof value;\n  }\n}\n\ntype Key = string | number;\n\nfunction toDisplayAtPath(v: unknown, path: Key[] | undefined): string {\n  if (!path?.length) {\n    return toDisplay(v);\n  }\n\n  let cur = v;\n  for (const p of path) {\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    cur = (cur as any)[p];\n  }\n  return toDisplay(cur);\n}\n\nfunction displayList<T>(\n  word: string,\n  expected: T[],\n  toDisplay: (x: T) => string | number = x => String(x),\n): string | number {\n  if (expected.length === 1) {\n    return toDisplay(expected[0]);\n  }\n\n  const suffix = `${toDisplay(\n    expected[expected.length - 2],\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n  )} ${word} ${toDisplay(expected.at(-1)!)}`;\n  if (expected.length === 2) {\n    return suffix;\n  }\n  return `${expected.slice(0, -2).map(toDisplay).join(', ')}, ${suffix}`;\n}\n\nfunction getMessage(\n  err: v.Err,\n  v: unknown,\n  schema: v.Type | v.Optional,\n  mode: ParseOptionsMode | undefined,\n): string {\n  const firstIssue = err.issues[0];\n  const {path} = firstIssue;\n  const atPath = path?.length ? ` at ${path.join('.')}` : '';\n\n  switch (firstIssue.code) {\n    case 'invalid_type':\n      return `Expected ${displayList(\n        'or',\n        firstIssue.expected,\n      )}${atPath}. Got ${toDisplayAtPath(v, path)}`;\n    case 'missing_value': {\n      const atPath =\n        path && path.length > 1 ? ` at ${path.slice(0, -1).join('.')}` : '';\n\n      if (firstIssue.path?.length) {\n        return `Missing property ${firstIssue.path.at(-1)}${atPath}`;\n      }\n      return `TODO Unknown missing property${atPath}`;\n    }\n\n    case 'invalid_literal':\n      return `Expected literal value ${displayList(\n        'or',\n        firstIssue.expected,\n        toDisplay,\n      )}${atPath} Got ${toDisplayAtPath(v, path)}`;\n\n    case 'invalid_length': {\n      return `Expected array with length ${\n        firstIssue.minLength === firstIssue.maxLength\n          ? firstIssue.minLength\n          : `between ${firstIssue.minLength} and ${firstIssue.maxLength}`\n      }${atPath}. Got array with length ${(v as {length: number}).length}`;\n    }\n\n    case 'unrecognized_keys':\n      if (firstIssue.keys.length === 1) {\n        return `Unexpected property ${firstIssue.keys[0]}${atPath}`;\n      }\n      return `Unexpected properties ${displayList(\n        'and',\n        firstIssue.keys,\n      )}${atPath}`;\n\n    case 'invalid_union':\n      return schema.name === 'union'\n        ? getDeepestUnionParseError(v, schema as v.UnionType, mode ?? 'strict')\n        : `Invalid union value${atPath}`;\n\n    case 'custom_error':\n      return `${firstIssue.message}${atPath}. Got ${toDisplayAtPath(v, path)}`;\n  }\n}\n\ntype FailedType = {type: v.Type; err: v.Err};\n\nfunction getDeepestUnionParseError(\n  value: unknown,\n  schema: v.UnionType,\n  mode: ParseOptionsMode,\n): string {\n  const failures: FailedType[] = [];\n  for (const type of schema.options) {\n    const r = type.try(value, {mode});\n    if (!r.ok) {\n      failures.push({type, err: r});\n    }\n  }\n  if (failures.length) {\n    // compare the first and second longest-path errors\n    failures.sort(pathCmp);\n    if (failures.length === 1 || pathCmp(failures[0], failures[1]) < 0) {\n      return getMessage(failures[0].err, value, failures[0].type, mode);\n    }\n  }\n  // paths are equivalent\n  try {\n    const str = JSON.stringify(value);\n    return `Invalid union value: ${str}`;\n  } catch {\n    // fallback if the value could not be stringified\n    return `Invalid union value`;\n  }\n}\n\n// Descending-order comparison of Issue paths.\n// * [1, 'a'] sorts before [1]\n// * [1] sorts before [0]  (i.e. errors later in the tuple sort before earlier errors)\nfunction pathCmp(a: FailedType, b: FailedType) {\n  const aPath = a.err.issues[0].path;\n  const bPath = b.err.issues[0].path;\n  if (aPath.length !== bPath.length) {\n    return bPath.length - aPath.length;\n  }\n  for (let i = 0; i < aPath.length; i++) {\n    if (bPath[i] > aPath[i]) {\n      return -1;\n    }\n    if (bPath[i] < aPath[i]) {\n      return 1;\n    }\n  }\n  return 0;\n}\n\n/**\n * 'strip' allows unknown properties and removes unknown properties.\n * 'strict' errors if there are unknown properties.\n * 'passthrough' allows unknown properties.\n */\nexport type ParseOptionsMode = 'passthrough' | 'strict' | 'strip';\n\nexport function parse<T>(\n  value: unknown,\n  schema: v.Type<T>,\n  mode?: ParseOptionsMode,\n): T {\n  const res = test(value, schema, mode);\n  if (!res.ok) {\n    throw new TypeError(res.error);\n  }\n  return res.value;\n}\n\nexport function is<T>(\n  value: unknown,\n  schema: v.Type<T>,\n  mode?: ParseOptionsMode,\n): value is T {\n  return test(value, schema, mode).ok;\n}\n\nexport function assert<T>(\n  value: unknown,\n  schema: v.Type<T>,\n  mode?: ParseOptionsMode,\n): asserts value is T {\n  parse(value, schema, mode);\n}\n\ntype Result<T> = {ok: true; value: T} | {ok: false; error: string};\n\nexport function test<T>(\n  value: unknown,\n  schema: v.Type<T>,\n  mode?: ParseOptionsMode,\n): Result<T> {\n  // A Type<T> only yields undefined if T includes it.\n  return testOptional(value, schema, mode) as Result<T>;\n}\n\n/**\n * Similar to {@link test} but works for AbstractTypes such as Optional.\n * This is for advanced usage. Prefer {@link test} unless you really need\n * to operate directly on an Optional field.\n */\nexport function testOptional<T>(\n  value: unknown,\n  schema: v.Type<T> | v.Optional<T>,\n  mode?: ParseOptionsMode,\n): Result<T | undefined> {\n  const res = schema.try(value, mode ? {mode} : undefined);\n  if (!res.ok) {\n    return {ok: false, error: getMessage(res, value, schema, mode)};\n  }\n  return res;\n}\n\nconst STRICT = {mode: 'strict'} as const;\n\n/**\n * Parses `schema` in strict mode, whatever mode the enclosing parse uses. Use\n * it for the parts of a message that a reader must not silently ignore inside\n * a lenient parse.\n *\n * Wrap a field, not a union variant: a union sees the wrapped type as\n * `unknown`, so it can no longer pick the variant by its literal fields.\n */\nexport function strict<T>(schema: v.Type<T>): v.Type<T> {\n  const type = v.unknown().chain(value => schema.try(value, STRICT));\n  // A transform serializes as just its name. Show the wrapped schema too, so a\n  // change to it still changes the hash in protocol-version.test.ts.\n  return Object.assign(type, {strict: schema});\n}\n\n/**\n * Shallowly marks the schema as readonly.\n */\nexport function readonly<T extends v.Type>(t: T): v.Type<Readonly<v.Infer<T>>> {\n  return t as v.Type<Readonly<v.Infer<T>>>;\n}\n\nexport function readonlyObject<T extends Record<string, v.Type | v.Optional>>(\n  t: T,\n): v.ObjectType<Readonly<T>, undefined> {\n  return v.object(t);\n}\n\nexport function readonlyArray<T extends v.Type>(\n  t: T,\n): v.Type<readonly v.Infer<T>[]> {\n  return v.array(t);\n}\n\nexport function readonlyRecord<T extends v.Type>(\n  t: T,\n): v.Type<Readonly<Record<string, v.Infer<T>>>> {\n  return v.record(t);\n}\n\nconst AbstractType = Object.getPrototypeOf(\n  Object.getPrototypeOf(v.string().optional()),\n).constructor;\n\nexport function instanceOfAbstractType<T = unknown>(\n  obj: unknown,\n): obj is v.Type<T> | v.Optional<T> {\n  return obj instanceof AbstractType;\n}\n\n// valita does not export TerminalType.\nexport type TerminalType = Parameters<Parameters<v.Type['_toTerminals']>[0]>[0];\n\n/**\n * Calls `func` for each terminal type that `type` is composed of, looking\n * through unions, optionals and the transforms created by\n * `.optional(() => x)`, `.assert()`, `.map()` and `.chain()`.\n *\n * This is the only use of valita's internal `_toTerminals`. The public API\n * has no way to look inside a transform, so there is no alternative. The\n * `toTerminals` test in valita.test.ts pins the behavior options.ts depends\n * on, so a valita upgrade that changes it fails there instead of misparsing\n * flags.\n */\nexport function toTerminals(\n  type: v.Type | v.Optional,\n  func: (t: TerminalType) => void,\n): void {\n  type._toTerminals(func);\n}\n\ntype ObjectShape = Record<string, typeof AbstractType>;\n\n/**\n * Similar to `ObjectType.partial()` except it recurses into nested objects.\n * Rest types are not supported.\n */\nexport function deepPartial<Shape extends ObjectShape>(\n  s: v.ObjectType<Shape, undefined>,\n) {\n  const shape = {} as Record<string, unknown>;\n  for (const [key, type] of Object.entries(s.shape)) {\n    if (type.name === 'object') {\n      shape[key] = deepPartial(\n        type as v.ObjectType<ObjectShape, undefined>,\n      ).optional();\n    } else {\n      shape[key] = type.optional();\n    }\n  }\n  return v.object(shape as {[K in keyof Shape]: v.Optional<v.Infer<Shape[K]>>});\n}\n\ntype Literal = string | number | bigint | boolean;\n\nexport function literalUnion<T extends [...Literal[]]>(\n  ...literals: T\n): v.Type<T[number]> {\n  return v.union(...literals.map(v.literal));\n}\n\ndeclare const unrecognized: unique symbol;\n\n/** A value of an open enum that this build doesn't know. Keeps the raw value. */\nexport type Unrecognized<T extends Literal = string> = T & {\n  readonly [unrecognized]: true;\n};\n\n/**\n * Like {@link literalUnion}, but any string parses, so a reader accepts values\n * that a newer writer added. Unknown values keep their raw string and are typed\n * as {@link Unrecognized}.\n *\n * Use it only where a reader can ignore or display an unknown value. Never use\n * it for a value that changes what the reader computes, or for the\n * discriminator of a union.\n */\nexport function openLiteralUnion<T extends [string, ...string[]]>(\n  ..._literals: T\n): v.Type<T[number] | Unrecognized> {\n  return v.string() as v.Type<T[number] | Unrecognized>;\n}\n\n/**\n * Call in the `default` case of a `switch` over an open enum, so that a known\n * value without a `case` fails to compile.\n */\nexport function assertUnrecognized(_value: Unrecognized): void {}\n\n/** A tuple whose first element, its tag, is a literal. */\ntype TaggedTuple = v.TupleType<[v.Type<Literal>, ...v.Type[]]>;\n\n/** A tuple with a tag this build doesn't know, as {@link taggedTupleUnion} parses it. */\nexport type UnrecognizedTuple = [\n  tag: Unrecognized<Literal>,\n  ...rest: unknown[],\n];\n\n/**\n * A union of tuples tagged by a literal in their first element, such as\n * `['ping', {}]`. Unlike `union`, it picks the tuple by its tag instead of\n * trying each in turn.\n *\n * With `open`, a tuple whose tag it doesn't know, but of the same type as a\n * known tag, parses as is, typed as {@link UnrecognizedTuple}, so a reader can\n * skip kinds a newer writer added. Use `isKnown` to tell them apart:\n * TypeScript can't narrow the union by comparing the tag, because a tag\n * literal is comparable to `Unrecognized`. A closed union is not implemented\n * yet.\n */\nexport function taggedTupleUnion<T extends TaggedTuple[]>(\n  tuples: T,\n  options: {readonly open: boolean},\n): v.Type<v.Infer<T[number]> | UnrecognizedTuple> & {\n  isKnown(\n    value: v.Infer<T[number]> | UnrecognizedTuple,\n  ): value is v.Infer<T[number]>;\n} {\n  if (!options.open) {\n    throw new Error('A closed taggedTupleUnion is not implemented');\n  }\n  type Known = v.Infer<T[number]>;\n  const byTag = new Map<unknown, v.Type>();\n  const tagTypes = new Set<string>();\n  for (const tuple of tuples) {\n    toTerminals(tuple.prefix[0], t => {\n      if (t.name !== 'literal') {\n        throw new Error('Expected every tag to be a literal');\n      }\n      if (byTag.has(t.value)) {\n        throw new Error(`Duplicate tag ${toDisplay(t.value)}`);\n      }\n      byTag.set(t.value, tuple);\n      tagTypes.add(typeof t.value);\n    });\n  }\n  const expectedTag = `Expected ${displayList('or', [...tagTypes])}`;\n  const type = v\n    .unknown()\n    .chain((value, options): v.ValitaResult<Known | UnrecognizedTuple> => {\n      if (!Array.isArray(value)) {\n        return v.err('Expected array');\n      }\n      const [tag] = value;\n      const tuple = byTag.get(tag);\n      if (tuple) {\n        return tuple.try(value, options) as v.ValitaResult<Known>;\n      }\n      return tagTypes.has(typeof tag)\n        ? v.ok(value as UnrecognizedTuple)\n        : v.err({message: expectedTag, path: [0]});\n    });\n  return Object.assign(type, {\n    // A transform serializes as just its name. Show the tuples too, so a\n    // change to them still changes the hash in protocol-version.test.ts.\n    taggedTupleUnion: tuples,\n    isKnown: (value: Known | UnrecognizedTuple): value is Known =>\n      byTag.has(value[0]),\n  });\n}\n\n/** An object with a tag this build doesn't know, as {@link taggedObjectUnion} parses it. */\nexport type UnrecognizedObject<K extends string> = {\n  readonly [P in K]: Unrecognized<Literal>;\n} & {readonly [key: string]: unknown};\n\n/**\n * A union of objects told apart by a literal in their `key` property, their\n * tag, such as `{op: 'queries', id: '1'}`. Unlike `union`, it picks the object\n * by its tag instead of trying each in turn, so a bad object of a known kind\n * fails with that kind's error.\n *\n * With `open`, an object whose tag it doesn't know, but of the same type as a\n * known tag, parses as is, typed as {@link UnrecognizedObject}, so a reader\n * can answer or skip kinds a newer writer added. Use `isKnown` to tell them\n * apart. A closed union is not implemented yet.\n */\nexport function taggedObjectUnion<K extends string, T extends v.ObjectType[]>(\n  key: K,\n  objects: T,\n  options: {readonly open: boolean},\n): v.Type<v.Infer<T[number]> | UnrecognizedObject<K>> & {\n  isKnown(\n    value: v.Infer<T[number]> | UnrecognizedObject<K>,\n  ): value is v.Infer<T[number]>;\n} {\n  if (!options.open) {\n    throw new Error('A closed taggedObjectUnion is not implemented');\n  }\n  type Known = v.Infer<T[number]>;\n  const byTag = new Map<unknown, v.Type>();\n  const tagTypes = new Set<string>();\n  for (const object of objects) {\n    const tag = object.shape[key] as v.Type | v.Optional | undefined;\n    if (tag === undefined) {\n      throw new Error(`Expected every object to have ${key}`);\n    }\n    toTerminals(tag, t => {\n      if (t.name !== 'literal') {\n        throw new Error('Expected every tag to be a literal');\n      }\n      if (byTag.has(t.value)) {\n        throw new Error(`Duplicate tag ${toDisplay(t.value)}`);\n      }\n      byTag.set(t.value, object);\n      tagTypes.add(typeof t.value);\n    });\n  }\n  const expectedTag = `Expected ${displayList('or', [...tagTypes])}`;\n  const tagOf = (value: object): unknown =>\n    Object.hasOwn(value, key) ? (value as Record<K, unknown>)[key] : undefined;\n  const type = v\n    .unknown()\n    .chain((value, options): v.ValitaResult<Known | UnrecognizedObject<K>> => {\n      if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n        return v.err('Expected object');\n      }\n      const tag = tagOf(value);\n      const object = byTag.get(tag);\n      if (object) {\n        return object.try(value, options) as v.ValitaResult<Known>;\n      }\n      return tagTypes.has(typeof tag)\n        ? v.ok(value as UnrecognizedObject<K>)\n        : v.err({message: expectedTag, path: [key]});\n    });\n  return Object.assign(type, {\n    // A transform serializes as just its name. Show the objects too, so a\n    // change to them still changes the hash in protocol-version.test.ts.\n    taggedObjectUnion: {key, objects},\n    isKnown: (value: Known | UnrecognizedObject<K>): value is Known =>\n      byTag.has(tagOf(value)),\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"valita.js","names":[],"sources":["../../../../shared/src/valita.ts"],"sourcesContent":["import * as v from '@badrap/valita';\n\nexport * from '@badrap/valita';\n\nfunction toDisplay(value: unknown): string {\n  switch (typeof value) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n      return JSON.stringify(value);\n    case 'undefined':\n      return 'undefined';\n    case 'bigint':\n      return value.toString() + 'n';\n    default:\n      if (value === null) {\n        return 'null';\n      }\n      if (Array.isArray(value)) {\n        return 'array';\n      }\n      return typeof value;\n  }\n}\n\ntype Key = string | number;\n\nfunction toDisplayAtPath(v: unknown, path: Key[] | undefined): string {\n  if (!path?.length) {\n    return toDisplay(v);\n  }\n\n  let cur = v;\n  for (const p of path) {\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    cur = (cur as any)[p];\n  }\n  return toDisplay(cur);\n}\n\nfunction displayList<T>(\n  word: string,\n  expected: T[],\n  toDisplay: (x: T) => string | number = x => String(x),\n): string | number {\n  if (expected.length === 1) {\n    return toDisplay(expected[0]);\n  }\n\n  const suffix = `${toDisplay(\n    expected[expected.length - 2],\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n  )} ${word} ${toDisplay(expected.at(-1)!)}`;\n  if (expected.length === 2) {\n    return suffix;\n  }\n  return `${expected.slice(0, -2).map(toDisplay).join(', ')}, ${suffix}`;\n}\n\nfunction getMessage(\n  err: v.Err,\n  v: unknown,\n  schema: v.Type | v.Optional,\n  mode: ParseOptionsMode | undefined,\n): string {\n  const firstIssue = err.issues[0];\n  const {path} = firstIssue;\n  const atPath = path?.length ? ` at ${path.join('.')}` : '';\n\n  switch (firstIssue.code) {\n    case 'invalid_type':\n      return `Expected ${displayList(\n        'or',\n        firstIssue.expected,\n      )}${atPath}. Got ${toDisplayAtPath(v, path)}`;\n    case 'missing_value': {\n      const atPath =\n        path && path.length > 1 ? ` at ${path.slice(0, -1).join('.')}` : '';\n\n      if (firstIssue.path?.length) {\n        return `Missing property ${firstIssue.path.at(-1)}${atPath}`;\n      }\n      return `TODO Unknown missing property${atPath}`;\n    }\n\n    case 'invalid_literal':\n      return `Expected literal value ${displayList(\n        'or',\n        firstIssue.expected,\n        toDisplay,\n      )}${atPath} Got ${toDisplayAtPath(v, path)}`;\n\n    case 'invalid_length': {\n      return `Expected array with length ${\n        firstIssue.minLength === firstIssue.maxLength\n          ? firstIssue.minLength\n          : `between ${firstIssue.minLength} and ${firstIssue.maxLength}`\n      }${atPath}. Got array with length ${(v as {length: number}).length}`;\n    }\n\n    case 'unrecognized_keys':\n      if (firstIssue.keys.length === 1) {\n        return `Unexpected property ${firstIssue.keys[0]}${atPath}`;\n      }\n      return `Unexpected properties ${displayList(\n        'and',\n        firstIssue.keys,\n      )}${atPath}`;\n\n    case 'invalid_union':\n      return schema.name === 'union'\n        ? getDeepestUnionParseError(v, schema as v.UnionType, mode ?? 'strict')\n        : `Invalid union value${atPath}`;\n\n    case 'custom_error':\n      return `${firstIssue.message}${atPath}. Got ${toDisplayAtPath(v, path)}`;\n  }\n}\n\ntype FailedType = {type: v.Type; err: v.Err};\n\nfunction getDeepestUnionParseError(\n  value: unknown,\n  schema: v.UnionType,\n  mode: ParseOptionsMode,\n): string {\n  const failures: FailedType[] = [];\n  for (const type of schema.options) {\n    const r = type.try(value, {mode});\n    if (!r.ok) {\n      failures.push({type, err: r});\n    }\n  }\n  if (failures.length) {\n    // compare the first and second longest-path errors\n    failures.sort(pathCmp);\n    if (failures.length === 1 || pathCmp(failures[0], failures[1]) < 0) {\n      return getMessage(failures[0].err, value, failures[0].type, mode);\n    }\n  }\n  // paths are equivalent\n  try {\n    const str = JSON.stringify(value);\n    return `Invalid union value: ${str}`;\n  } catch {\n    // fallback if the value could not be stringified\n    return `Invalid union value`;\n  }\n}\n\n// Descending-order comparison of Issue paths.\n// * [1, 'a'] sorts before [1]\n// * [1] sorts before [0]  (i.e. errors later in the tuple sort before earlier errors)\nfunction pathCmp(a: FailedType, b: FailedType) {\n  const aPath = a.err.issues[0].path;\n  const bPath = b.err.issues[0].path;\n  if (aPath.length !== bPath.length) {\n    return bPath.length - aPath.length;\n  }\n  for (let i = 0; i < aPath.length; i++) {\n    if (bPath[i] > aPath[i]) {\n      return -1;\n    }\n    if (bPath[i] < aPath[i]) {\n      return 1;\n    }\n  }\n  return 0;\n}\n\n/**\n * 'strip' allows unknown properties and removes unknown properties.\n * 'strict' errors if there are unknown properties.\n * 'passthrough' allows unknown properties.\n */\nexport type ParseOptionsMode = 'passthrough' | 'strict' | 'strip';\n\nexport function parse<T>(\n  value: unknown,\n  schema: v.Type<T>,\n  mode?: ParseOptionsMode,\n): T {\n  const res = test(value, schema, mode);\n  if (!res.ok) {\n    throw new TypeError(res.error);\n  }\n  return res.value;\n}\n\nexport function is<T>(\n  value: unknown,\n  schema: v.Type<T>,\n  mode?: ParseOptionsMode,\n): value is T {\n  return test(value, schema, mode).ok;\n}\n\nexport function assert<T>(\n  value: unknown,\n  schema: v.Type<T>,\n  mode?: ParseOptionsMode,\n): asserts value is T {\n  parse(value, schema, mode);\n}\n\ntype Result<T> = {ok: true; value: T} | {ok: false; error: string};\n\nexport function test<T>(\n  value: unknown,\n  schema: v.Type<T>,\n  mode?: ParseOptionsMode,\n): Result<T> {\n  // A Type<T> only yields undefined if T includes it.\n  return testOptional(value, schema, mode) as Result<T>;\n}\n\n/**\n * Similar to {@link test} but works for AbstractTypes such as Optional.\n * This is for advanced usage. Prefer {@link test} unless you really need\n * to operate directly on an Optional field.\n */\nexport function testOptional<T>(\n  value: unknown,\n  schema: v.Type<T> | v.Optional<T>,\n  mode?: ParseOptionsMode,\n): Result<T | undefined> {\n  const res = schema.try(value, mode ? {mode} : undefined);\n  if (!res.ok) {\n    return {ok: false, error: getMessage(res, value, schema, mode)};\n  }\n  return res;\n}\n\nconst STRICT = {mode: 'strict'} as const;\n\n/**\n * Parses `schema` in strict mode, whatever mode the enclosing parse uses. Use\n * it for the parts of a message that a reader must not silently ignore inside\n * a lenient parse.\n *\n * Wrap a field, not a union variant: a union sees the wrapped type as\n * `unknown`, so it can no longer pick the variant by its literal fields.\n */\nexport function strict<T>(schema: v.Type<T>): v.Type<T> {\n  const type = v.unknown().chain(value => schema.try(value, STRICT));\n  // A transform serializes as just its name. Show the wrapped schema too, so a\n  // change to it still changes the hash in protocol-version.test.ts.\n  return Object.assign(type, {strict: schema});\n}\n\n/**\n * Shallowly marks the schema as readonly.\n */\nexport function readonly<T extends v.Type>(t: T): v.Type<Readonly<v.Infer<T>>> {\n  return t as v.Type<Readonly<v.Infer<T>>>;\n}\n\nexport function readonlyObject<T extends Record<string, v.Type | v.Optional>>(\n  t: T,\n): v.ObjectType<Readonly<T>, undefined> {\n  return v.object(t);\n}\n\nexport function readonlyArray<T extends v.Type>(\n  t: T,\n): v.Type<readonly v.Infer<T>[]> {\n  return v.array(t);\n}\n\nexport function readonlyRecord<T extends v.Type>(\n  t: T,\n): v.Type<Readonly<Record<string, v.Infer<T>>>> {\n  return v.record(t);\n}\n\nconst AbstractType = Object.getPrototypeOf(\n  Object.getPrototypeOf(v.string().optional()),\n).constructor;\n\nexport function instanceOfAbstractType<T = unknown>(\n  obj: unknown,\n): obj is v.Type<T> | v.Optional<T> {\n  return obj instanceof AbstractType;\n}\n\n// valita does not export TerminalType.\nexport type TerminalType = Parameters<Parameters<v.Type['_toTerminals']>[0]>[0];\n\n/**\n * Calls `func` for each terminal type that `type` is composed of, looking\n * through unions, optionals and the transforms created by\n * `.optional(() => x)`, `.assert()`, `.map()` and `.chain()`.\n *\n * This is the only use of valita's internal `_toTerminals`. The public API\n * has no way to look inside a transform, so there is no alternative. The\n * `toTerminals` test in valita.test.ts pins the behavior options.ts depends\n * on, so a valita upgrade that changes it fails there instead of misparsing\n * flags.\n */\nexport function toTerminals(\n  type: v.Type | v.Optional,\n  func: (t: TerminalType) => void,\n): void {\n  type._toTerminals(func);\n}\n\ntype ObjectShape = Record<string, typeof AbstractType>;\n\n/**\n * Similar to `ObjectType.partial()` except it recurses into nested objects.\n * Rest types are not supported.\n */\nexport function deepPartial<Shape extends ObjectShape>(\n  s: v.ObjectType<Shape, undefined>,\n) {\n  const shape = {} as Record<string, unknown>;\n  for (const [key, type] of Object.entries(s.shape)) {\n    if (type.name === 'object') {\n      shape[key] = deepPartial(\n        type as v.ObjectType<ObjectShape, undefined>,\n      ).optional();\n    } else {\n      shape[key] = type.optional();\n    }\n  }\n  return v.object(shape as {[K in keyof Shape]: v.Optional<v.Infer<Shape[K]>>});\n}\n\ntype Literal = string | number | bigint | boolean;\n\nexport function literalUnion<T extends [...Literal[]]>(\n  ...literals: T\n): v.Type<T[number]> {\n  return v.union(...literals.map(v.literal));\n}\n\ndeclare const unrecognized: unique symbol;\n\n/** A value of an open enum that this build doesn't know. Keeps the raw value. */\nexport type Unrecognized<T extends Literal = string> = T & {\n  readonly [unrecognized]: true;\n};\n\n/**\n * Like {@link literalUnion}, but any string parses, so a reader accepts values\n * that a newer writer added. Unknown values keep their raw string and are typed\n * as {@link Unrecognized}.\n *\n * Use it only where a reader can ignore or display an unknown value. Never use\n * it for a value that changes what the reader computes, or for the\n * discriminator of a union.\n */\nexport function openLiteralUnion<T extends [string, ...string[]]>(\n  ..._literals: T\n): v.Type<T[number] | Unrecognized> {\n  return v.string() as v.Type<T[number] | Unrecognized>;\n}\n\n/**\n * Call in the `default` case of a `switch` over an open enum, so that a known\n * value without a `case` fails to compile.\n */\nexport function assertUnrecognized(_value: Unrecognized): void {}\n\n/** A tuple whose first element, its tag, is a literal. */\ntype TaggedTuple = v.TupleType<[v.Type<Literal>, ...v.Type[]]>;\n\n/** A tuple with a tag this build doesn't know, as {@link taggedTupleUnion} parses it. */\nexport type UnrecognizedTuple = [\n  tag: Unrecognized<Literal>,\n  ...rest: unknown[],\n];\n\n/**\n * A union of tuples tagged by a literal in their first element, such as\n * `['ping', {}]`. Unlike `union`, it picks the tuple by its tag instead of\n * trying each in turn.\n *\n * With `open`, a tuple whose tag it doesn't know, but of the same type as a\n * known tag, parses as is, typed as {@link UnrecognizedTuple}, so a reader can\n * skip kinds a newer writer added. Use `isKnown` to tell them apart:\n * TypeScript can't narrow the union by comparing the tag, because a tag\n * literal is comparable to `Unrecognized`. A closed union is not implemented\n * yet.\n */\nexport function taggedTupleUnion<T extends TaggedTuple[]>(\n  tuples: T,\n  options: {readonly open: boolean},\n): v.Type<v.Infer<T[number]> | UnrecognizedTuple> & {\n  isKnown(\n    value: v.Infer<T[number]> | UnrecognizedTuple,\n  ): value is v.Infer<T[number]>;\n} {\n  if (!options.open) {\n    throw new Error('A closed taggedTupleUnion is not implemented');\n  }\n  type Known = v.Infer<T[number]>;\n  const byTag = new Map<unknown, v.Type>();\n  const tagTypes = new Set<string>();\n  for (const tuple of tuples) {\n    toTerminals(tuple.prefix[0], t => {\n      if (t.name !== 'literal') {\n        throw new Error('Expected every tag to be a literal');\n      }\n      if (byTag.has(t.value)) {\n        throw new Error(`Duplicate tag ${toDisplay(t.value)}`);\n      }\n      byTag.set(t.value, tuple);\n      tagTypes.add(typeof t.value);\n    });\n  }\n  const expectedTag = `Expected ${displayList('or', [...tagTypes])}`;\n  const type = v\n    .unknown()\n    .chain((value, options): v.ValitaResult<Known | UnrecognizedTuple> => {\n      if (!Array.isArray(value)) {\n        return v.err('Expected array');\n      }\n      const [tag] = value;\n      const tuple = byTag.get(tag);\n      if (tuple) {\n        return tuple.try(value, options) as v.ValitaResult<Known>;\n      }\n      return tagTypes.has(typeof tag)\n        ? v.ok(value as UnrecognizedTuple)\n        : v.err({message: expectedTag, path: [0]});\n    });\n  return Object.assign(type, {\n    // A transform serializes as just its name. Show the tuples too, so a\n    // change to them still changes the hash in protocol-version.test.ts.\n    taggedTupleUnion: tuples,\n    isKnown: (value: Known | UnrecognizedTuple): value is Known =>\n      byTag.has(value[0]),\n  });\n}\n\n/** An object with a tag this build doesn't know, as {@link taggedObjectUnion} parses it. */\nexport type UnrecognizedObject<K extends string> = {\n  readonly [P in K]: Unrecognized<Literal>;\n} & {readonly [key: string]: unknown};\n\n/**\n * A union of objects told apart by a literal in their `key` property, their\n * tag, such as `{op: 'queries', id: '1'}`. Unlike `union`, it picks the object\n * by its tag instead of trying each in turn, so a bad object of a known kind\n * fails with that kind's error.\n *\n * With `open`, an object whose tag it doesn't know, but of the same type as a\n * known tag, parses as is, typed as {@link UnrecognizedObject}, so a reader\n * can answer or skip kinds a newer writer added. Use `isKnown` to tell them\n * apart. A closed union is not implemented yet.\n */\nexport function taggedObjectUnion<K extends string, T extends v.ObjectType[]>(\n  key: K,\n  objects: T,\n  options: {readonly open: boolean},\n): v.Type<v.Infer<T[number]> | UnrecognizedObject<K>> & {\n  isKnown(\n    value: v.Infer<T[number]> | UnrecognizedObject<K>,\n  ): value is v.Infer<T[number]>;\n} {\n  if (!options.open) {\n    throw new Error('A closed taggedObjectUnion is not implemented');\n  }\n  type Known = v.Infer<T[number]>;\n  const byTag = new Map<unknown, v.Type>();\n  const tagTypes = new Set<string>();\n  for (const object of objects) {\n    const tag = object.shape[key] as v.Type | v.Optional | undefined;\n    if (tag === undefined) {\n      throw new Error(`Expected every object to have ${key}`);\n    }\n    toTerminals(tag, t => {\n      if (t.name !== 'literal') {\n        throw new Error('Expected every tag to be a literal');\n      }\n      if (byTag.has(t.value)) {\n        throw new Error(`Duplicate tag ${toDisplay(t.value)}`);\n      }\n      byTag.set(t.value, object);\n      tagTypes.add(typeof t.value);\n    });\n  }\n  const expectedTag = `Expected ${displayList('or', [...tagTypes])}`;\n  const tagOf = (value: object): unknown =>\n    Object.hasOwn(value, key) ? (value as Record<K, unknown>)[key] : undefined;\n  const type = v\n    .unknown()\n    .chain((value, options): v.ValitaResult<Known | UnrecognizedObject<K>> => {\n      if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n        return v.err('Expected object');\n      }\n      const tag = tagOf(value);\n      const object = byTag.get(tag);\n      if (object) {\n        return object.try(value, options) as v.ValitaResult<Known>;\n      }\n      return tagTypes.has(typeof tag)\n        ? v.ok(value as UnrecognizedObject<K>)\n        : v.err({message: expectedTag, path: [key]});\n    });\n  return Object.assign(type, {\n    // A transform serializes as just its name. Show the objects too, so a\n    // change to them still changes the hash in protocol-version.test.ts.\n    taggedObjectUnion: {key, objects},\n    isKnown: (value: Known | UnrecognizedObject<K>): value is Known =>\n      byTag.has(tagOf(value)),\n  });\n}\n"],"mappings":"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"}

package/out/z2s/src/compiler.js

@@ -212,9 +212,7 @@ function valueComparison(spec, valuePos, table, otherValuePos, plural) {
 		}
 		case "literal": return literalValueComparison(spec, valuePos, table, otherValuePos, plural);
 		case "static": throw new Error("Static parameters must be bound to a value before compiling to SQL");
-		default:
-			unreachable(valuePosType);
-			break;
+		default: unreachable(valuePosType);
 	}
 }
 function literalValueComparison(spec, valuePos, table, otherValuePos, plural) {
@@ -275,14 +273,14 @@ function selectIdent(server, column) {
 	if (!serverColumnSchema.isEnum) {
 		let needsNormalization = false;
 		switch (serverType) {
-			case "timestamptz":
-			case "timetz": needsNormalization = true;
+			case "timetz":
+			case "time with time zone": needsNormalization = true;
 			case "date":
 			case "time":
 			case "time without time zone":
-			case "time with time zone":
 			case "timestamp":
 			case "timestamp without time zone":
+			case "timestamptz":
 			case "timestamp with time zone": {
 				const toMs = (epochExpr) => needsNormalization ? sql`((${epochExpr})::bigint + 86400000) % 86400000` : epochExpr;
 				if (serverColumnSchema.isArray) {
@@ -338,6 +336,6 @@ function findPathToBigInt(v) {
 	}
 }
 //#endregion
-export { compile, extractZqlResult };
+export { any, compile, distinctFrom, extractZqlResult, limit, makeCorrelator, makeJunctionJoin, orderBy, pullTablesForJunction, simple, start };
 
 //# sourceMappingURL=compiler.js.map