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

package/out/packages/shared/src/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.js","names":[],"sources":["../../../../../shared/src/logging.ts"],"sourcesContent":["import {pid} from 'node:process';\nimport {styleText} from 'node:util';\n/* oxlint-disable no-console */\nimport {\n  type Context,\n  LogContext,\n  type LogLevel,\n  type LogSink,\n} from '@rocicorp/logger';\nimport {stringify} from './bigint-json.ts';\n\nexport type LogConfig = {\n  level: LogLevel;\n  format: 'text' | 'json';\n};\n\nfunction style(color: 'gray' | 'yellow' | 'red', args: unknown[]) {\n  return styleText(color, args.join(' '));\n}\n\nconst COLOR_DEBUG = 'gray';\nconst COLOR_WARN = 'yellow';\nconst COLOR_ERROR = 'red';\n\n/**\n * Returns an object for writing colorized output to a provided console.\n * Note this should only be used when console is a TTY (i.e., Node).\n */\nexport const colorConsole = {\n  log: (...args: unknown[]) => {\n    console.log(...args);\n  },\n  debug: (...args: unknown[]) => {\n    console.debug(style(COLOR_DEBUG, args));\n  },\n  info: (...args: unknown[]) => {\n    console.info(...args);\n  },\n  warn: (...args: unknown[]) => {\n    console.warn(style(COLOR_WARN, args));\n  },\n  error: (...args: unknown[]) => {\n    console.error(style(COLOR_ERROR, args));\n  },\n};\n\nexport const consoleSink: LogSink = {\n  log(level, context, ...args) {\n    colorConsole[level](\n      toLocalIsoString(),\n      stringifyContext(context),\n      ...args.map(stringifyValue),\n    );\n  },\n};\n\nfunction toLocalIsoString(date = new Date()) {\n  const tzo = -date.getTimezoneOffset();\n  const sign = tzo >= 0 ? '+' : '-';\n  const pad = (n: number, len = 2) => String(Math.abs(n)).padStart(len, '0');\n\n  return (\n    date.getFullYear() +\n    '-' +\n    pad(date.getMonth() + 1) +\n    '-' +\n    pad(date.getDate()) +\n    'T' +\n    pad(date.getHours()) +\n    ':' +\n    pad(date.getMinutes()) +\n    ':' +\n    pad(date.getSeconds()) +\n    '.' +\n    pad(date.getMilliseconds(), 3) +\n    sign +\n    pad(tzo / 60) +\n    ':' +\n    pad(tzo % 60)\n  );\n}\n\nexport function getLogSink(config: LogConfig): LogSink {\n  return config.format === 'json' ? consoleJsonLogSink : consoleSink;\n}\n\nexport function createLogContext(\n  {log}: {log: LogConfig},\n  context = {},\n  sink = getLogSink(log),\n): LogContext {\n  const ctx = {pid, ...context};\n  const lc = new LogContext(log.level, ctx, sink);\n  // Emit a blank line to absorb random ANSI control code garbage that\n  // for some reason gets prepended to the first log line in CloudWatch.\n  lc.info?.('');\n  return lc;\n}\n\nconst consoleJsonLogSink: LogSink = {\n  log(level: LogLevel, context: Context | undefined, ...args: unknown[]): void {\n    // If the last arg is an object or an Error, combine those fields into the message.\n    const lastObj = errorOrObject(args.at(-1));\n    if (lastObj) {\n      args.pop();\n    }\n    const message = args.length\n      ? {\n          message: args.map(stringifyValue).join(' '),\n        }\n      : undefined;\n\n    console[level](\n      stringify({\n        level: level.toUpperCase(),\n        ...context,\n        ...lastObj,\n        ...message,\n      }),\n    );\n  },\n};\n\nexport function errorOrObject(v: unknown): object | undefined {\n  if (v instanceof Error) {\n    return toErrorLogObject(v);\n  }\n  if (v && typeof v === 'object') {\n    return v;\n  }\n  return undefined;\n}\n\nfunction toErrorLogObject(v: Error) {\n  return {\n    ...v, // some properties of Error subclasses may be enumerable\n    name: v.name,\n    errorMsg: v.message,\n    stack: v.stack,\n    ...('cause' in v ? {cause: errorOrObject(v.cause)} : null),\n  };\n}\n\nfunction stringifyContext(context: Context | undefined): unknown[] {\n  const args = [];\n  for (const [k, v] of Object.entries(context ?? {})) {\n    const arg = v === undefined ? k : `${k}=${v}`;\n    args.push(arg);\n  }\n  return args;\n}\n\nfunction stringifyValue(v: unknown) {\n  if (typeof v === 'string') {\n    return v;\n  }\n  if (v instanceof Error) {\n    return stringify(toErrorLogObject(v));\n  }\n  return stringify(v);\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,39 @@
+//#region ../shared/src/map.ts
+var nativeSupport = typeof Map.prototype.getOrInsert === "function";
+/**
+* Returns the value for {@link key} in {@link map}.  If no mapping exists,
+* inserts {@link defaultValue} and returns it.
+*
+* Mirrors the ES2026 `Map.prototype.getOrInsert` proposal.
+*/
+function getOrInsertPolyfill(map, key, defaultValue) {
+	const existing = map.get(key);
+	if (existing !== void 0) return existing;
+	map.set(key, defaultValue);
+	return defaultValue;
+}
+/**
+* Returns the value for {@link key} in {@link map}.  If no mapping exists,
+* calls {@link compute} with the key, inserts the result, and returns it.
+*
+* Mirrors the ES2026 `Map.prototype.getOrInsertComputed` proposal.
+*/
+function getOrInsertComputedPolyfill(map, key, compute) {
+	const existing = map.get(key);
+	if (existing !== void 0) return existing;
+	const value = compute(key);
+	map.set(key, value);
+	return value;
+}
+function getOrInsertNative(map, key, defaultValue) {
+	return map.getOrInsert(key, defaultValue);
+}
+function getOrInsertComputedNative(map, key, compute) {
+	return map.getOrInsertComputed(key, compute);
+}
+var getOrInsert = nativeSupport ? getOrInsertNative : getOrInsertPolyfill;
+var getOrInsertComputed = nativeSupport ? getOrInsertComputedNative : getOrInsertComputedPolyfill;
+//#endregion
+export { getOrInsert, getOrInsertComputed };
+
+//# sourceMappingURL=map.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","names":[],"sources":["../../../../../shared/src/map.ts"],"sourcesContent":["const nativeSupport =\n  typeof (Map.prototype as unknown as MapES2026<unknown, unknown>)\n    .getOrInsert === 'function';\n\ninterface MapES2026<K, V> {\n  getOrInsert(key: K, defaultValue: V): V;\n  getOrInsertComputed(key: K, compute: (key: K) => V): V;\n}\n\n/**\n * Returns the value for {@link key} in {@link map}.  If no mapping exists,\n * inserts {@link defaultValue} and returns it.\n *\n * Mirrors the ES2026 `Map.prototype.getOrInsert` proposal.\n */\nfunction getOrInsertPolyfill<K, V>(map: Map<K, V>, key: K, defaultValue: V): V {\n  const existing = map.get(key);\n  if (existing !== undefined) {\n    return existing;\n  }\n  map.set(key, defaultValue);\n  return defaultValue;\n}\n\n/**\n * Returns the value for {@link key} in {@link map}.  If no mapping exists,\n * calls {@link compute} with the key, inserts the result, and returns it.\n *\n * Mirrors the ES2026 `Map.prototype.getOrInsertComputed` proposal.\n */\nfunction getOrInsertComputedPolyfill<K, V>(\n  map: Map<K, V>,\n  key: K,\n  compute: (key: K) => V,\n): V {\n  const existing = map.get(key);\n  if (existing !== undefined) {\n    return existing;\n  }\n  const value = compute(key);\n  map.set(key, value);\n  return value;\n}\n\nfunction getOrInsertNative<K, V>(map: Map<K, V>, key: K, defaultValue: V): V {\n  return (map as unknown as MapES2026<K, V>).getOrInsert(key, defaultValue);\n}\n\nfunction getOrInsertComputedNative<K, V>(\n  map: Map<K, V>,\n  key: K,\n  compute: (key: K) => V,\n): V {\n  return (map as unknown as MapES2026<K, V>).getOrInsertComputed(key, compute);\n}\n\nexport const getOrInsert = nativeSupport\n  ? getOrInsertNative\n  : getOrInsertPolyfill;\n\nexport const getOrInsertComputed = nativeSupport\n  ? getOrInsertComputedNative\n  : getOrInsertComputedPolyfill;\n"],"mappings":";AAAA,IAAM,gBACJ,OAAQ,IAAI,UACT,gBAAgB;;;;;;;AAarB,SAAS,oBAA0B,KAAgB,KAAQ,cAAoB;CAC7E,MAAM,WAAW,IAAI,IAAI,GAAG;CAC5B,IAAI,aAAa,KAAA,GACf,OAAO;CAET,IAAI,IAAI,KAAK,YAAY;CACzB,OAAO;AACT;;;;;;;AAQA,SAAS,4BACP,KACA,KACA,SACG;CACH,MAAM,WAAW,IAAI,IAAI,GAAG;CAC5B,IAAI,aAAa,KAAA,GACf,OAAO;CAET,MAAM,QAAQ,QAAQ,GAAG;CACzB,IAAI,IAAI,KAAK,KAAK;CAClB,OAAO;AACT;AAEA,SAAS,kBAAwB,KAAgB,KAAQ,cAAoB;CAC3E,OAAQ,IAAmC,YAAY,KAAK,YAAY;AAC1E;AAEA,SAAS,0BACP,KACA,KACA,SACG;CACH,OAAQ,IAAmC,oBAAoB,KAAK,OAAO;AAC7E;AAEA,IAAa,cAAc,gBACvB,oBACA;AAEJ,IAAa,sBAAsB,gBAC/B,4BACA"}

package/out/packages/shared/src/must.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"must.js","names":[],"sources":["../../../../../shared/src/must.ts"],"sourcesContent":["export function must<T>(v: T | undefined | null, msg?: string): T {\n  // oxlint-disable-next-line eqeqeq\n  if (v == null) {\n    throw new Error(msg ?? `Unexpected ${v} value`);\n  }\n  return v;\n}\n"],"mappings":";AAAA,SAAgB,KAAQ,GAAyB,KAAiB;CAEhE,IAAI,KAAK,MACP,MAAM,IAAI,MAAM,OAAO,cAAc,EAAE,OAAO;CAEhD,OAAO;AACT"}

package/out/packages/shared/src/navigator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigator.js","names":[],"sources":["../../../../../shared/src/navigator.ts"],"sourcesContent":["type Navigator = {\n  onLine: boolean;\n  userAgent: string;\n  // add more as needed\n};\n\nconst localNavigator: Navigator | undefined =\n  typeof navigator !== 'undefined' ? navigator : undefined;\n\nexport {localNavigator as navigator};\n"],"mappings":";AAMA,IAAM,iBACJ,OAAO,cAAc,cAAc,YAAY,KAAA"}

package/out/packages/shared/src/object-traversal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-traversal.js","names":[],"sources":["../../../../../shared/src/object-traversal.ts"],"sourcesContent":["type Split<\n  S extends string,\n  Sep extends string,\n> = S extends `${infer Head}${Sep}${infer Tail}`\n  ? [Head, ...Split<Tail, Sep>]\n  : S extends ''\n    ? []\n    : [S];\n\ntype GetAtPath<T, Parts extends readonly string[]> = Parts extends readonly [\n  infer Head extends string,\n  ...infer Tail extends readonly string[],\n]\n  ? Head extends keyof T\n    ? GetAtPath<T[Head], Tail>\n    : undefined\n  : T;\n\ntype ValueAtPath<Path extends string, T, Sep extends string> = GetAtPath<\n  T,\n  Split<Path, Sep>\n>;\n\nexport function getValueAtPath(obj: object, path: string, sep: RegExp): unknown;\nexport function getValueAtPath<\n  const Path extends string,\n  const T extends object,\n  const Sep extends string,\n>(obj: T, path: Path, sep: Sep): ValueAtPath<Path, T, Sep>;\nexport function getValueAtPath(\n  obj: object,\n  path: string,\n  sep: string | RegExp,\n): unknown {\n  const parts = path.split(sep);\n  let current: unknown = obj;\n  for (const part of parts) {\n    if (current && typeof current === 'object' && part in current) {\n      current = (current as Record<string, unknown>)[part];\n    } else {\n      return undefined;\n    }\n  }\n  return current;\n}\n\n/**\n * Recursively iterates over all leaf values in a nested object tree.\n * A value is considered a leaf if `isLeaf(value)` returns true,\n * or if it's not a plain object.\n *\n * @param obj - The object to iterate over\n * @param isLeaf - A function that returns true if a value should be yielded as a leaf\n */\nexport function* iterateLeaves<T>(\n  obj: object,\n  isLeaf: (value: unknown) => value is T,\n): Iterable<T> {\n  for (const key of Object.keys(obj)) {\n    const value = (obj as Record<string, unknown>)[key];\n    if (isLeaf(value)) {\n      yield value;\n    } else if (value && typeof value === 'object') {\n      yield* iterateLeaves(value, isLeaf);\n    }\n  }\n}\n"],"mappings":";AA6BA,SAAgB,eACd,KACA,MACA,KACS;CACT,MAAM,QAAQ,KAAK,MAAM,GAAG;CAC5B,IAAI,UAAmB;CACvB,KAAK,MAAM,QAAQ,OACjB,IAAI,WAAW,OAAO,YAAY,YAAY,QAAQ,SACpD,UAAW,QAAoC;MAE/C;CAGJ,OAAO;AACT;;;;;;;;;AAUA,UAAiB,cACf,KACA,QACa;CACb,KAAK,MAAM,OAAO,OAAO,KAAK,GAAG,GAAG;EAClC,MAAM,QAAS,IAAgC;EAC/C,IAAI,OAAO,KAAK,GACd,MAAM;OACD,IAAI,SAAS,OAAO,UAAU,UACnC,OAAO,cAAc,OAAO,MAAM;CAEtC;AACF"}

package/out/packages/shared/src/objects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.js","names":[],"sources":["../../../../../shared/src/objects.ts"],"sourcesContent":["export function mapValues<T extends Record<string, unknown>, U>(\n  input: T,\n  mapper: (value: T[keyof T]) => U,\n): {[K in keyof T]: U} {\n  return mapEntries(input, (k, v) => [k, mapper(v as T[keyof T])]) as {\n    [K in keyof T]: U;\n  };\n}\n\nexport function mapEntries<T, U>(\n  input: Record<string, T>,\n  mapper: (key: string, val: T) => [key: string, val: U],\n): Record<string, U> {\n  // Direct assignment is faster than Object.fromEntries()\n  // https://github.com/rocicorp/mono/pull/3927#issuecomment-2706059475\n  const output: Record<string, U> = {};\n\n  // In chrome Object.entries is faster than for-in (13x) or Object.keys (15x)\n  // https://gist.github.com/arv/1b4e113724f6a14e2d4742bcc760d1fa\n  for (const entry of Object.entries(input)) {\n    const mapped = mapper(entry[0], entry[1]);\n    output[mapped[0]] = mapped[1];\n  }\n  return output;\n}\n\nexport function mapAllEntries<T, U>(\n  input: Record<string, T>,\n  mapper: (entries: [key: string, val: T][]) => [key: string, val: U][],\n): Record<string, U> {\n  // Direct assignment is faster than Object.fromEntries()\n  // https://github.com/rocicorp/mono/pull/3927#issuecomment-2706059475\n  const output: Record<string, U> = {};\n  for (const mapped of mapper(Object.entries(input))) {\n    output[mapped[0]] = mapped[1];\n  }\n  return output;\n}\n"],"mappings":";AAAA,SAAgB,UACd,OACA,QACqB;CACrB,OAAO,WAAW,QAAQ,GAAG,MAAM,CAAC,GAAG,OAAO,CAAe,CAAC,CAAC;AAGjE;AAEA,SAAgB,WACd,OACA,QACmB;CAGnB,MAAM,SAA4B,CAAC;CAInC,KAAK,MAAM,SAAS,OAAO,QAAQ,KAAK,GAAG;EACzC,MAAM,SAAS,OAAO,MAAM,IAAI,MAAM,EAAE;EACxC,OAAO,OAAO,MAAM,OAAO;CAC7B;CACA,OAAO;AACT;AAEA,SAAgB,cACd,OACA,QACmB;CAGnB,MAAM,SAA4B,CAAC;CACnC,KAAK,MAAM,UAAU,OAAO,OAAO,QAAQ,KAAK,CAAC,GAC/C,OAAO,OAAO,MAAM,OAAO;CAE7B,OAAO;AACT"}

package/out/packages/shared/src/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","names":[],"sources":["../../../../../shared/src/options.ts"],"sourcesContent":["import {stripVTControlCharacters as stripAnsi} from 'node:util';\nimport type {OptionalLogger} from '@rocicorp/logger';\nimport {template} from 'chalk-template';\nimport type {OptionDefinition} from 'command-line-args';\nimport commandLineArgs from 'command-line-args';\nimport commandLineUsage, {type Section} from 'command-line-usage';\nimport {createDefu} from 'defu';\nimport {toKebabCase, toSnakeCase} from 'kasi';\nimport {assert} from './asserts.ts';\nimport {must} from './must.ts';\nimport type {\n  Config,\n  Group,\n  Option,\n  Options,\n  WrappedOptionType,\n} from './options-types.ts';\nimport * as v from './valita.ts';\n\nexport type {Config, Group, Option, Options, WrappedOptionType};\n\ntype Primitive = number | string | boolean;\ntype Value = Primitive | Array<Primitive>;\n\ntype RequiredOptionType =\n  | v.Type<string>\n  | v.Type<number>\n  | v.Type<boolean>\n  | v.Type<string[]>\n  | v.Type<number[]>\n  | v.Type<boolean[]>;\n\ntype OptionalOptionType =\n  | v.Optional<string>\n  | v.Optional<number>\n  | v.Optional<boolean>\n  | v.Optional<string[]>\n  | v.Optional<number[]>\n  | v.Optional<boolean[]>;\n\ntype OptionType = RequiredOptionType | OptionalOptionType;\n\n/**\n * Creates a defu instance that overrides arrays instead of merging them.\n */\nconst defu = createDefu((obj, key, value) => {\n  if (!Array.isArray(value)) return;\n\n  obj[key] = value;\n  return true;\n});\n\n/**\n * Converts an Options instance into its corresponding {@link Config} schema.\n */\nfunction configSchema<T extends Options>(\n  options: T,\n  envNamePrefix: string,\n): v.Type<Config<T>> {\n  function makeObjectType(options: Options | Group, group?: string) {\n    return v.object(\n      Object.fromEntries(\n        Object.entries(options).map(\n          ([name, value]): [string, OptionType | v.Type] => {\n            const addErrorMessage = (t: OptionType) => {\n              const {required} = getRequiredOrDefault(t);\n              if (required) {\n                // Adds an error message for required options that includes the\n                // actual name of the option.\n                const optionName = toSnakeCase(\n                  `${envNamePrefix}${group ? group + '_' : ''}${name}`,\n                ).toUpperCase();\n                return (t as v.Type<string>)\n                  .optional()\n                  .assert(\n                    val => val !== undefined,\n                    `Missing required option ${optionName}`,\n                  );\n              }\n              return t;\n            };\n            // OptionType\n            if (v.instanceOfAbstractType(value)) {\n              return [name, addErrorMessage(value)];\n            }\n            // WrappedOptionType\n            const {type} = value;\n            if (v.instanceOfAbstractType(type)) {\n              return [name, addErrorMessage(type)];\n            }\n            // OptionGroup\n            return [name, makeObjectType(value as Group, name)];\n          },\n        ),\n      ),\n    );\n  }\n  return makeObjectType(options) as v.Type<Config<T>>;\n}\n\n/**\n * Converts an Options instance into an \"env schema\", which is an object with\n * ENV names as its keys, mapped to optional or required string values\n * (corresponding to the optionality of the corresponding options).\n *\n * This is used as a format for encoding options for a multi-tenant version\n * of an app, with an envSchema for each tenant.\n */\nexport function envSchema<T extends Options>(options: T, envNamePrefix = '') {\n  const fields: [string, v.Type<string> | v.Optional<string>][] = [];\n\n  function addField(name: string, type: OptionType, group?: string) {\n    const flag = group ? `${group}_${name}` : name;\n    const env = toSnakeCase(`${envNamePrefix}${flag}`).toUpperCase();\n\n    const {required} = getRequiredOrDefault(type);\n    fields.push([env, required ? v.string() : v.string().optional()]);\n  }\n\n  function addFields(o: Options | Group, group?: string) {\n    Object.entries(o).forEach(([name, value]) => {\n      // OptionType\n      if (v.instanceOfAbstractType(value)) {\n        addField(name, value, group);\n        return;\n      }\n      // WrappedOptionType\n      const {type} = value;\n      if (v.instanceOfAbstractType(type)) {\n        addField(name, type, group);\n        return;\n      }\n      // OptionGroup\n      addFields(value as Group, name);\n    });\n  }\n\n  addFields(options);\n\n  return v.object(Object.fromEntries(fields));\n}\n\n// type TerminalType is not exported from badrap/valita\ntype TerminalType = Parameters<\n  Parameters<v.Type<unknown>['toTerminals']>[0]\n>[0];\n\nfunction getRequiredOrDefault(type: OptionType) {\n  const defaultResult = v.testOptional<Value>(undefined, type);\n  return {\n    required: !defaultResult.ok,\n    defaultValue: defaultResult.ok ? defaultResult.value : undefined,\n  };\n}\n\nexport type ParseOptions = {\n  /** Defaults to process.argv.slice(2) */\n  argv?: string[];\n\n  envNamePrefix?: string;\n\n  description?: {header: string; content: string}[];\n\n  /** Defaults to `false` */\n  allowUnknown?: boolean;\n\n  /** Defaults to `false` */\n  allowPartial?: boolean;\n\n  /** Defaults to `process.env`. */\n  env?: NodeJS.ProcessEnv;\n\n  /** Defaults to `true`. */\n  emitDeprecationWarnings?: boolean;\n\n  /** Defaults to `true`. When false, excludes default values from both config and env return values. */\n  includeDefaults?: boolean;\n\n  /** Defaults to `console` */\n  logger?: OptionalLogger;\n\n  /** Defaults to `process.exit` */\n  exit?: (code?: number | string | null) => never;\n};\n\nexport function parseOptions<T extends Options>(\n  appOptions: T,\n  opts: ParseOptions = {},\n): Config<T> {\n  return parseOptionsAdvanced(appOptions, opts).config;\n}\n\nexport function parseOptionsAdvanced<T extends Options>(\n  appOptions: T,\n  opts: ParseOptions = {},\n): {config: Config<T>; env: Record<string, string>; unknown?: string[]} {\n  const {\n    argv = process.argv.slice(2),\n    envNamePrefix = '',\n    description = [],\n    allowUnknown = false,\n    allowPartial = false,\n    env: processEnv = process.env,\n    emitDeprecationWarnings = true,\n    includeDefaults = true,\n    logger = console,\n    exit = process.exit,\n  } = opts;\n  // The main logic for converting a valita Type spec to an Option (i.e. flag) spec.\n  function addOption(field: string, option: WrappedOptionType, group?: string) {\n    const {type, desc = [], deprecated, alias, hidden} = option;\n\n    // The group name is prepended to the flag name.\n    const flag = group ? toKebabCase(`${group}-${field}`) : toKebabCase(field);\n\n    const {required, defaultValue} = getRequiredOrDefault(type);\n    let multiple = type.name === 'array';\n    const literals = new Set<string>();\n    const terminalTypes = new Set<string>();\n\n    type.toTerminals(getTerminalTypes);\n\n    function getTerminalTypes(t: TerminalType) {\n      switch (t.name) {\n        case 'undefined':\n        case 'optional':\n          break;\n        case 'array': {\n          multiple = true;\n          t.prefix.forEach(t => t.toTerminals(getTerminalTypes));\n          t.rest?.toTerminals(getTerminalTypes);\n          t.suffix.forEach(t => t.toTerminals(getTerminalTypes));\n          break;\n        }\n        case 'literal':\n          literals.add(String(t.value));\n          terminalTypes.add(typeof t.value);\n          break;\n        default:\n          terminalTypes.add(t.name);\n          break;\n      }\n    }\n    const env = toSnakeCase(`${envNamePrefix}${flag}`).toUpperCase();\n    if (terminalTypes.size > 1) {\n      throw new TypeError(`${env} has mixed types ${[...terminalTypes]}`);\n    }\n    assert(terminalTypes.size === 1, 'Expected exactly one terminal type');\n    const terminalType = [...terminalTypes][0];\n\n    if (processEnv[env]) {\n      if (multiple) {\n        // Technically not water-tight; assumes values for the string[] flag don't contain commas.\n        envArgv.push(`--${flag}`, ...processEnv[env].split(','));\n      } else {\n        envArgv.push(`--${flag}`, processEnv[env]);\n      }\n    }\n    names.set(flag, {field, env});\n\n    const spec = [\n      (required\n        ? '{italic required}'\n        : defaultValue !== undefined\n          ? `default: ${JSON.stringify(defaultValue)}`\n          : 'optional') + '\\n',\n    ];\n    if (desc) {\n      spec.push(...desc);\n    }\n\n    const typeLabel = [\n      literals.size\n        ? String(Array.from(literals, l => `{underline ${l}}`))\n        : multiple\n          ? `{underline ${terminalType}[]}`\n          : `{underline ${terminalType}}`,\n      `  ${env} env`,\n    ];\n\n    const opt = {\n      name: flag,\n      alias,\n      type: valueParser(\n        env,\n        terminalType,\n        logger,\n        emitDeprecationWarnings ? deprecated : undefined,\n      ),\n      multiple,\n      group,\n      description: spec.join('\\n') + '\\n',\n      typeLabel: typeLabel.join('\\n') + '\\n',\n      hidden: hidden === undefined ? deprecated !== undefined : hidden,\n    };\n    optsWithoutDefaults.push(opt);\n    optsWithDefaults.push({...opt, defaultValue});\n  }\n\n  const names = new Map<string, {field: string; env: string}>();\n  const optsWithDefaults: DescribedOptionDefinition[] = [];\n  const optsWithoutDefaults: DescribedOptionDefinition[] = [];\n  const envArgv: string[] = [];\n\n  try {\n    for (const [name, val] of Object.entries(appOptions)) {\n      const {type} = val as {type: unknown};\n      if (v.instanceOfAbstractType(val)) {\n        addOption(name, {type: val});\n      } else if (v.instanceOfAbstractType(type)) {\n        addOption(name, val as WrappedOptionType);\n      } else {\n        const group = name;\n        for (const [name, option] of Object.entries(val as Group)) {\n          const wrapped = v.instanceOfAbstractType(option)\n            ? {type: option}\n            : option;\n          addOption(name, wrapped, group);\n        }\n      }\n    }\n\n    const [defaults, env1, unknown] = parseArgs(optsWithDefaults, argv, names);\n    const [fromEnv, env2] = parseArgs(optsWithoutDefaults, envArgv, names);\n    const [withoutDefaults, env3] = parseArgs(optsWithoutDefaults, argv, names);\n\n    switch (unknown?.[0]) {\n      case undefined:\n        break;\n      case '--help':\n      case '-h':\n        showUsage(optsWithDefaults, description, logger);\n        exit(0);\n        break;\n      default:\n        if (!allowUnknown) {\n          logger.error?.('Invalid arguments:', unknown);\n          showUsage(optsWithDefaults, description, logger);\n          exit(0);\n        }\n        break;\n    }\n\n    const parsedArgs = includeDefaults\n      ? defu(withoutDefaults, fromEnv, defaults)\n      : defu(withoutDefaults, fromEnv);\n    const env = includeDefaults\n      ? {...env1, ...env2, ...env3}\n      : {...env2, ...env3};\n\n    let schema = configSchema(appOptions, envNamePrefix);\n    if (allowPartial || !includeDefaults) {\n      // TODO: Type configSchema() to return a v.ObjectType<...>\n      schema = v.deepPartial(schema as v.ObjectType) as v.Type<Config<T>>;\n    }\n    return {\n      config: v.parse(parsedArgs, schema),\n      env,\n      ...(unknown ? {unknown} : {}),\n    };\n  } catch (e) {\n    logger.error?.(String(e));\n    showUsage(optsWithDefaults, description, logger);\n    throw e;\n  }\n}\n\nfunction valueParser(\n  optionName: string,\n  typeName: string,\n  logger: OptionalLogger,\n  deprecated: string[] | undefined,\n) {\n  return (input: string) => {\n    if (deprecated) {\n      logger.warn?.(\n        template(\n          `\\n${optionName} is deprecated:\\n` + deprecated.join('\\n') + '\\n',\n        ),\n      );\n    }\n    switch (typeName) {\n      case 'string':\n        return input;\n      case 'boolean':\n        return parseBoolean(optionName, input);\n      case 'number': {\n        const val = Number(input);\n        if (Number.isNaN(val)) {\n          throw new TypeError(`Invalid input for ${optionName}: \"${input}\"`);\n        }\n        return val;\n      }\n      default:\n        // Should be impossible given the constraints of `Option`\n        throw new TypeError(\n          `${optionName} option has unsupported type ${typeName}`,\n        );\n    }\n  };\n}\n\nfunction parseArgs(\n  optionDefs: DescribedOptionDefinition[],\n  argv: string[],\n  names: Map<string, {field: string; env: string}>,\n) {\n  function normalizeFlagValue(value: unknown) {\n    // A --flag without value is parsed by commandLineArgs() to `null`,\n    // but this is a common convention to set a boolean flag to true.\n    return value === null ? true : value;\n  }\n\n  const {\n    _all,\n    _none: ungrouped,\n    _unknown: unknown,\n    ...config\n  } = commandLineArgs(optionDefs, {\n    argv,\n    partial: true,\n  });\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  const result: Record<string, any> = {};\n  const envObj: Record<string, string> = {};\n\n  function addFlag(flagName: string, value: unknown, group?: string) {\n    const {field, env} = must(names.get(flagName));\n    const normalized = normalizeFlagValue(value);\n    if (group) {\n      result[group][field] = normalized;\n    } else {\n      result[field] = normalized;\n    }\n    envObj[env] = String(normalized);\n  }\n\n  for (const [flagName, value] of Object.entries(ungrouped ?? {})) {\n    addFlag(flagName, value);\n  }\n\n  // Then handle (potentially) grouped flags\n  for (const [name, value] of Object.entries(config)) {\n    if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n      addFlag(name, value); // Flag, not a group\n    } else {\n      const group = name;\n      result[group] = {};\n      for (const [flagName, flagValue] of Object.entries(value)) {\n        addFlag(flagName, flagValue, group);\n      }\n    }\n  }\n\n  return [result, envObj, unknown] as const;\n}\n\nexport function flagToEnv(prefix: string, flag: string): string {\n  return toSnakeCase(prefix + flag).toUpperCase();\n}\n\nexport function parseBoolean(optionName: string, input: string) {\n  const bool = input.toLowerCase();\n  if (['true', '1'].includes(bool)) {\n    return true;\n  } else if (['false', '0'].includes(bool)) {\n    return false;\n  }\n  throw new TypeError(`Invalid input for ${optionName}: \"${input}\"`);\n}\n\nfunction showUsage(\n  optionList: DescribedOptionDefinition[],\n  description: {header: string; content: string}[] = [],\n  logger: OptionalLogger = console,\n) {\n  const hide: string[] = [];\n  let leftWidth = 35;\n  let rightWidth = 70;\n  optionList.forEach(({name, typeLabel, description, hidden}) => {\n    if (hidden) {\n      hide.push(name);\n    }\n    const text = template(`${name} ${typeLabel ?? ''}`);\n    const lines = stripAnsi(text).split('\\n');\n    for (const l of lines) {\n      leftWidth = Math.max(leftWidth, l.length + 2);\n    }\n    const desc = stripAnsi(template(description ?? '')).split('\\n');\n    for (const l of desc) {\n      rightWidth = Math.max(rightWidth, l.length + 2);\n    }\n  });\n\n  const sections: Section[] = [\n    {\n      optionList,\n      reverseNameOrder: true, // Display --flag-name before -alias\n      hide,\n      tableOptions: {\n        columns: [\n          {name: 'option', width: leftWidth},\n          {name: 'description', width: rightWidth},\n        ],\n        noTrim: true,\n      },\n    },\n  ];\n\n  if (description) {\n    sections.unshift(...description);\n  }\n\n  logger.info?.(commandLineUsage(sections));\n}\n\ntype DescribedOptionDefinition = OptionDefinition & {\n  // Additional fields recognized by command-line-usage\n  description?: string;\n  typeLabel?: string | undefined;\n  hidden?: boolean | undefined;\n};\n"],"mappings":"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"}

package/out/packages/shared/src/parse-big-int.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-big-int.js","names":[],"sources":["../../../../../shared/src/parse-big-int.ts"],"sourcesContent":["// Until there's BigInt.fromString(val, radix) ... https://github.com/tc39/proposal-number-fromstring\nexport function parseBigInt(val: string, radix: number): bigint {\n  const base = BigInt(radix);\n  let result = 0n;\n  for (let i = 0; i < val.length; i++) {\n    result *= base;\n    result += BigInt(parseInt(val[i], radix));\n  }\n  return result;\n}\n"],"mappings":";AACA,SAAgB,YAAY,KAAa,OAAuB;CAC9D,MAAM,OAAO,OAAO,KAAK;CACzB,IAAI,SAAS;CACb,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,UAAU;EACV,UAAU,OAAO,SAAS,IAAI,IAAI,KAAK,CAAC;CAC1C;CACA,OAAO;AACT"}

package/out/packages/shared/src/promise-race.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-race.js","names":[],"sources":["../../../../../shared/src/promise-race.ts"],"sourcesContent":["type PromiseRaceResult<T extends Record<string, PromiseLike<unknown>>> = {\n  [K in Extract<keyof T, string>]: {\n    key: K;\n    status: 'fulfilled';\n    result: Awaited<T[K]>;\n  };\n}[Extract<keyof T, string>];\n\nconst NO_PROMISES_MESSAGE = 'No promises to race';\n\nconst wrapPromise = <K extends string, V>(\n  key: K,\n  promise: PromiseLike<V>,\n): Promise<{key: K; status: 'fulfilled'; result: V}> =>\n  Promise.resolve(promise).then(result => ({\n    key,\n    status: 'fulfilled' as const,\n    result,\n  }));\n\n/**\n * Race a record of promises and resolve with the first resolved entry.\n *\n * @param promises Record of promises to race.\n * @returns Promise resolving to a discriminated union of key/result pairs.\n * @throws An error if the record is empty or if a promise is rejected.\n */\nexport async function promiseRace<\n  T extends Record<string, PromiseLike<unknown>>,\n>(promises: T): Promise<PromiseRaceResult<T> & {}> {\n  const keys = Object.keys(promises) as Array<Extract<keyof T, string>>;\n\n  if (keys.length === 0) {\n    throw new Error(NO_PROMISES_MESSAGE);\n  }\n\n  const wrapped = keys.map(key =>\n    wrapPromise(key, promises[key] as PromiseLike<Awaited<T[typeof key]>>),\n  );\n\n  return await Promise.race(wrapped);\n}\n"],"mappings":";AAQA,IAAM,sBAAsB;AAE5B,IAAM,eACJ,KACA,YAEA,QAAQ,QAAQ,OAAO,EAAE,MAAK,YAAW;CACvC;CACA,QAAQ;CACR;AACF,EAAE;;;;;;;;AASJ,eAAsB,YAEpB,UAAiD;CACjD,MAAM,OAAO,OAAO,KAAK,QAAQ;CAEjC,IAAI,KAAK,WAAW,GAClB,MAAM,IAAI,MAAM,mBAAmB;CAGrC,MAAM,UAAU,KAAK,KAAI,QACvB,YAAY,KAAK,SAAS,IAA2C,CACvE;CAEA,OAAO,MAAM,QAAQ,KAAK,OAAO;AACnC"}

package/out/packages/shared/src/queue.js

@@ -0,0 +1,120 @@
+import { assert } from "./asserts.js";
+import { RingBuffer } from "./ring-buffer.js";
+import { resolver } from "@rocicorp/resolver";
+//#region ../shared/src/queue.ts
+/**
+* A Queue allows the consumers to await (possibly future) values,
+* and producers to await the consumption of their values.
+*/
+var Queue = class {
+	#consumers = new RingBuffer();
+	#produced = new RingBuffer();
+	enqueue(value) {
+		const consumer = this.#consumers.shift();
+		if (consumer) {
+			consumer.resolver.resolve(value);
+			clearTimeout(consumer.timeoutID);
+			return;
+		}
+		this.#produced.push({ value });
+	}
+	enqueueRejection(reason) {
+		const consumer = this.#consumers.shift();
+		if (consumer) {
+			consumer.resolver.reject(reason);
+			clearTimeout(consumer.timeoutID);
+			return;
+		}
+		this.#produced.push({ rejection: reason });
+	}
+	/**
+	* Deletes all unconsumed entries matching the specified `value` based on identity equality.
+	* The consumed callback(s) are resolved as if the values were dequeued.
+	*
+	* Note: deletion of `undefined` values is not supported. This method will assert
+	* if `value` is undefined.
+	*
+	* @returns The number of entries deleted.
+	*/
+	delete(value) {
+		assert(value !== void 0, "Queue delete value must not be undefined");
+		const items = this.#produced.drain();
+		let count = 0;
+		for (const p of items) if (p.value === value) count++;
+		else this.#produced.push(p);
+		return count;
+	}
+	/**
+	* @param timeoutValue An optional value to resolve if `timeoutMs` is reached.
+	* @param timeoutMs The milliseconds after which the `timeoutValue` is resolved
+	*                  if nothing is produced for the consumer.
+	* @returns A Promise that resolves to the next enqueued value.
+	*/
+	dequeue(timeoutValue, timeoutMs = 0) {
+		const produced = this.#produced.shift();
+		if (produced) return produced.value ?? Promise.reject(produced.rejection);
+		const r = resolver();
+		const consumer = {
+			resolver: r,
+			timeoutID: void 0
+		};
+		consumer.timeoutID = timeoutValue === void 0 ? void 0 : setTimeout(() => {
+			if (this.#consumers.delete(consumer) > 0) consumer.resolver.resolve(timeoutValue);
+		}, timeoutMs);
+		this.#consumers.push(consumer);
+		return r.promise;
+	}
+	/**
+	* Drains the entire queue.
+	*
+	* Usage example:
+	* ```ts
+	* // A consumer that, when awoken, drains
+	* // all entries in the queue in order to
+	* // process them in a batch.
+	* for (;;) {
+	*   const value = await queue.dequeue();
+	*   const rest = queue.drain();
+	* }
+	* ```
+	*/
+	drain() {
+		return this.#produced.drain().map((p) => p.value);
+	}
+	/**
+	* @returns The instantaneous number of outstanding values waiting to be
+	*          dequeued. Note that if a value was enqueued while a consumer
+	*          was waiting (with `await dequeue()`), the value is immediately
+	*          handed to the consumer and the Queue's size remains 0.
+	*/
+	size() {
+		return this.#produced.size;
+	}
+	asAsyncIterable(cleanup = NOOP) {
+		return { [Symbol.asyncIterator]: () => this.asAsyncIterator(cleanup) };
+	}
+	asAsyncIterator(cleanup = NOOP) {
+		return {
+			next: async () => {
+				try {
+					return { value: await this.dequeue() };
+				} catch (e) {
+					cleanup();
+					throw e;
+				}
+			},
+			return: (value) => {
+				cleanup();
+				return Promise.resolve({
+					value,
+					done: true
+				});
+			}
+		};
+	}
+};
+var NOOP = () => {};
+//#endregion
+export { Queue };
+
+//# sourceMappingURL=queue.js.map

package/out/packages/shared/src/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","names":["#consumers","#produced"],"sources":["../../../../../shared/src/queue.ts"],"sourcesContent":["import {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from './asserts.ts';\nimport {RingBuffer} from './ring-buffer.ts';\n\n/**\n * A Queue allows the consumers to await (possibly future) values,\n * and producers to await the consumption of their values.\n */\nexport class Queue<T> {\n  // Consumers waiting for entries to be produced.\n  readonly #consumers = new RingBuffer<Consumer<T>>();\n  // Produced entries waiting to be consumed.\n  readonly #produced = new RingBuffer<Produced<T>>();\n\n  enqueue(value: T): void {\n    const consumer = this.#consumers.shift();\n    if (consumer) {\n      consumer.resolver.resolve(value);\n      clearTimeout(consumer.timeoutID);\n      return;\n    }\n    this.#produced.push({value});\n  }\n\n  enqueueRejection(reason?: unknown): void {\n    const consumer = this.#consumers.shift();\n    if (consumer) {\n      consumer.resolver.reject(reason);\n      clearTimeout(consumer.timeoutID);\n      return;\n    }\n    this.#produced.push({rejection: reason});\n  }\n\n  /**\n   * Deletes all unconsumed entries matching the specified `value` based on identity equality.\n   * The consumed callback(s) are resolved as if the values were dequeued.\n   *\n   * Note: deletion of `undefined` values is not supported. This method will assert\n   * if `value` is undefined.\n   *\n   * @returns The number of entries deleted.\n   */\n  delete(value: T): number {\n    assert(value !== undefined, 'Queue delete value must not be undefined');\n\n    // Drain, filter, and re-push. This is O(n) but delete() is rare.\n    const items = this.#produced.drain();\n    let count = 0;\n    for (const p of items) {\n      if (p.value === value) {\n        count++;\n      } else {\n        this.#produced.push(p);\n      }\n    }\n    return count;\n  }\n\n  /**\n   * @param timeoutValue An optional value to resolve if `timeoutMs` is reached.\n   * @param timeoutMs The milliseconds after which the `timeoutValue` is resolved\n   *                  if nothing is produced for the consumer.\n   * @returns A Promise that resolves to the next enqueued value.\n   */\n  dequeue(timeoutValue?: T, timeoutMs: number = 0): Promise<T> | T {\n    const produced = this.#produced.shift();\n    if (produced) {\n      return produced.value ?? Promise.reject(produced.rejection);\n    }\n    const r = resolver<T>();\n    const consumer: Consumer<T> = {resolver: r, timeoutID: undefined};\n    const timeoutID =\n      timeoutValue === undefined\n        ? undefined\n        : setTimeout(() => {\n            if (this.#consumers.delete(consumer) > 0) {\n              consumer.resolver.resolve(timeoutValue);\n            }\n          }, timeoutMs);\n    consumer.timeoutID = timeoutID;\n    this.#consumers.push(consumer);\n    return r.promise;\n  }\n\n  /**\n   * Drains the entire queue.\n   *\n   * Usage example:\n   * ```ts\n   * // A consumer that, when awoken, drains\n   * // all entries in the queue in order to\n   * // process them in a batch.\n   * for (;;) {\n   *   const value = await queue.dequeue();\n   *   const rest = queue.drain();\n   * }\n   * ```\n   */\n  drain(): (T | undefined)[] {\n    return this.#produced.drain().map(p => p.value);\n  }\n\n  /**\n   * @returns The instantaneous number of outstanding values waiting to be\n   *          dequeued. Note that if a value was enqueued while a consumer\n   *          was waiting (with `await dequeue()`), the value is immediately\n   *          handed to the consumer and the Queue's size remains 0.\n   */\n  size(): number {\n    return this.#produced.size;\n  }\n\n  asAsyncIterable(cleanup = NOOP): AsyncIterable<T> {\n    return {[Symbol.asyncIterator]: () => this.asAsyncIterator(cleanup)};\n  }\n\n  asAsyncIterator(cleanup = NOOP): AsyncIterator<T> {\n    return {\n      next: async () => {\n        try {\n          const value = await this.dequeue();\n          return {value};\n        } catch (e) {\n          cleanup();\n          throw e;\n        }\n      },\n      return: value => {\n        cleanup();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n}\n\nconst NOOP = () => {};\n\ntype Consumer<T> = {\n  resolver: Resolver<T>;\n  timeoutID: ReturnType<typeof setTimeout> | undefined;\n};\n\ntype Produced<T> =\n  | {value: T; rejection?: undefined}\n  | {value?: undefined; rejection: unknown};\n"],"mappings":";;;;;;;;AAQA,IAAa,QAAb,MAAsB;CAEpB,aAAsB,IAAI,WAAwB;CAElD,YAAqB,IAAI,WAAwB;CAEjD,QAAQ,OAAgB;EACtB,MAAM,WAAW,KAAKA,WAAW,MAAM;EACvC,IAAI,UAAU;GACZ,SAAS,SAAS,QAAQ,KAAK;GAC/B,aAAa,SAAS,SAAS;GAC/B;EACF;EACA,KAAKC,UAAU,KAAK,EAAC,MAAK,CAAC;CAC7B;CAEA,iBAAiB,QAAwB;EACvC,MAAM,WAAW,KAAKD,WAAW,MAAM;EACvC,IAAI,UAAU;GACZ,SAAS,SAAS,OAAO,MAAM;GAC/B,aAAa,SAAS,SAAS;GAC/B;EACF;EACA,KAAKC,UAAU,KAAK,EAAC,WAAW,OAAM,CAAC;CACzC;;;;;;;;;;CAWA,OAAO,OAAkB;EACvB,OAAO,UAAU,KAAA,GAAW,0CAA0C;EAGtE,MAAM,QAAQ,KAAKA,UAAU,MAAM;EACnC,IAAI,QAAQ;EACZ,KAAK,MAAM,KAAK,OACd,IAAI,EAAE,UAAU,OACd;OAEA,KAAKA,UAAU,KAAK,CAAC;EAGzB,OAAO;CACT;;;;;;;CAQA,QAAQ,cAAkB,YAAoB,GAAmB;EAC/D,MAAM,WAAW,KAAKA,UAAU,MAAM;EACtC,IAAI,UACF,OAAO,SAAS,SAAS,QAAQ,OAAO,SAAS,SAAS;EAE5D,MAAM,IAAI,SAAY;EACtB,MAAM,WAAwB;GAAC,UAAU;GAAG,WAAW,KAAA;EAAS;EAShE,SAAS,YAPP,iBAAiB,KAAA,IACb,KAAA,IACA,iBAAiB;GACf,IAAI,KAAKD,WAAW,OAAO,QAAQ,IAAI,GACrC,SAAS,SAAS,QAAQ,YAAY;EAE1C,GAAG,SAAS;EAElB,KAAKA,WAAW,KAAK,QAAQ;EAC7B,OAAO,EAAE;CACX;;;;;;;;;;;;;;;CAgBA,QAA2B;EACzB,OAAO,KAAKC,UAAU,MAAM,EAAE,KAAI,MAAK,EAAE,KAAK;CAChD;;;;;;;CAQA,OAAe;EACb,OAAO,KAAKA,UAAU;CACxB;CAEA,gBAAgB,UAAU,MAAwB;EAChD,OAAO,GAAE,OAAO,sBAAsB,KAAK,gBAAgB,OAAO,EAAC;CACrE;CAEA,gBAAgB,UAAU,MAAwB;EAChD,OAAO;GACL,MAAM,YAAY;IAChB,IAAI;KAEF,OAAO,EAAC,OAAA,MADY,KAAK,QAAQ,EACpB;IACf,SAAS,GAAG;KACV,QAAQ;KACR,MAAM;IACR;GACF;GACA,SAAQ,UAAS;IACf,QAAQ;IACR,OAAO,QAAQ,QAAQ;KAAC;KAAO,MAAM;IAAI,CAAC;GAC5C;EACF;CACF;AACF;AAEA,IAAM,aAAa,CAAC"}

package/out/packages/shared/src/rand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rand.js","names":[],"sources":["../../../../../shared/src/rand.ts"],"sourcesContent":["/**\n * @param min Inclusive minimum of the result.\n * @param max Inclusive maximum of the result.\n * @returns A random integer in the (inclusive) range of [`min`, `max`].\n */\nexport function randInt(min: number, max: number) {\n  min = Math.ceil(min);\n  max = Math.floor(max);\n  return Math.floor(Math.random() * (max - min + 1) + min);\n}\n"],"mappings":";;;;;;AAKA,SAAgB,QAAQ,KAAa,KAAa;CAChD,MAAM,KAAK,KAAK,GAAG;CACnB,MAAM,KAAK,MAAM,GAAG;CACpB,OAAO,KAAK,MAAM,KAAK,OAAO,KAAK,MAAM,MAAM,KAAK,GAAG;AACzD"}

package/out/packages/shared/src/random-uint64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-uint64.js","names":[],"sources":["../../../../../shared/src/random-uint64.ts"],"sourcesContent":["export function randomUint64(): bigint {\n  // Generate two random 32-bit unsigned integers using Math.random()\n  const high = Math.floor(Math.random() * 0xffffffff); // High 32 bits\n  const low = Math.floor(Math.random() * 0xffffffff); // Low 32 bits\n\n  // Combine the high and low parts to form a 64-bit unsigned integer\n  return (BigInt(high) << 32n) | BigInt(low);\n}\n"],"mappings":";AAAA,SAAgB,eAAuB;CAErC,MAAM,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,UAAU;CAClD,MAAM,MAAM,KAAK,MAAM,KAAK,OAAO,IAAI,UAAU;CAGjD,OAAQ,OAAO,IAAI,KAAK,MAAO,OAAO,GAAG;AAC3C"}

package/out/packages/shared/src/random-values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-values.js","names":[],"sources":["../../../../../shared/src/random-values.ts"],"sourcesContent":["export function getNonCryptoRandomValues(array: Uint8Array) {\n  if (array === null) {\n    throw new TypeError('array cannot be null');\n  }\n\n  // Fill the array with random values\n  for (let i = 0; i < array.length; i++) {\n    array[i] = Math.floor(Math.random() * 256); // Random byte (0-255)\n  }\n\n  return array;\n}\n\nexport function randomCharacters(length: number) {\n  let result = '';\n  const characters =\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  const charactersLength = characters.length;\n  let counter = 0;\n  while (counter < length) {\n    result += characters.charAt(Math.floor(Math.random() * charactersLength));\n    counter += 1;\n  }\n  return result;\n}\n"],"mappings":";AAAA,SAAgB,yBAAyB,OAAmB;CAC1D,IAAI,UAAU,MACZ,MAAM,IAAI,UAAU,sBAAsB;CAI5C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAChC,MAAM,KAAK,KAAK,MAAM,KAAK,OAAO,IAAI,GAAG;CAG3C,OAAO;AACT"}

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

@@ -0,0 +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"}

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

@@ -0,0 +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"}

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

@@ -0,0 +1,109 @@
+//#region ../shared/src/ring-buffer.ts
+var DEFAULT_INITIAL_CAPACITY = 16;
+var MIN_CAPACITY = 16;
+/**
+* A FIFO ring buffer backed by a circular array. Provides:
+*
+* - `push()` — O(1) amortized (O(n) on resize)
+* - `shift()` — O(1)
+* - `size`    — O(1)
+* - `drain()` — O(n)
+*
+* The buffer grows (doubles) when full and shrinks (halves) when
+* utilization drops below 25%, bounded by {@link MIN_CAPACITY}.
+*/
+var RingBuffer = class {
+	#buffer;
+	#head = 0;
+	#size = 0;
+	#capacity;
+	constructor(initialCapacity = DEFAULT_INITIAL_CAPACITY) {
+		this.#capacity = Math.max(MIN_CAPACITY, initialCapacity);
+		this.#buffer = Array.from({ length: initialCapacity });
+	}
+	get size() {
+		return this.#size;
+	}
+	push(value) {
+		if (this.#size === this.#capacity) this.#grow();
+		this.#buffer[(this.#head + this.#size) % this.#capacity] = value;
+		this.#size++;
+	}
+	/** Removes and returns the front element, or `undefined` if empty. */
+	shift() {
+		if (this.#size === 0) return;
+		const value = this.#buffer[this.#head];
+		this.#buffer[this.#head] = void 0;
+		this.#head = (this.#head + 1) % this.#capacity;
+		this.#size--;
+		if (this.#size > 0 && this.#size < this.#capacity >> 2 && this.#capacity > MIN_CAPACITY) this.#shrink();
+		return value;
+	}
+	/**
+	* Removes all elements matching `value` (by identity `===`).
+	*
+	* This is O(n) — suitable for rare operations like cancellation.
+	*
+	* @returns The number of elements removed.
+	*/
+	delete(value) {
+		if (this.#size === 0) return 0;
+		const newBuffer = Array.from({ length: this.#capacity });
+		let newSize = 0;
+		let count = 0;
+		for (let i = 0; i < this.#size; i++) {
+			const item = this.#buffer[(this.#head + i) % this.#capacity];
+			if (item === value) count++;
+			else newBuffer[newSize++] = item;
+		}
+		this.#buffer = newBuffer;
+		this.#head = 0;
+		this.#size = newSize;
+		return count;
+	}
+	/**
+	* Removes and returns all elements in FIFO order, resetting the buffer.
+	*/
+	drain() {
+		const result = Array.from({ length: this.#size });
+		for (let i = 0; i < this.#size; i++) result[i] = this.#buffer[(this.#head + i) % this.#capacity];
+		this.#head = 0;
+		this.#size = 0;
+		this.#buffer = Array.from({ length: this.#capacity });
+		return result;
+	}
+	/**
+	* Grows the buffer in place by doubling its length and relocating
+	* only the wrapped-around elements (those before #head) into the
+	* newly available space. No new array is allocated.
+	*/
+	#grow() {
+		const oldLen = this.#buffer.length;
+		const newLen = oldLen * 2;
+		this.#buffer.length = newLen;
+		this.#capacity = newLen;
+		for (let i = 0; i < this.#head; i++) {
+			this.#buffer[oldLen + i] = this.#buffer[i];
+			this.#buffer[i] = void 0;
+		}
+	}
+	/**
+	* Shrinks the buffer in place by halving its length. Elements whose
+	* indices fall in the removed half are relocated into the lower half,
+	* then the array is truncated.
+	*/
+	#shrink() {
+		const oldLen = this.#buffer.length;
+		const newLen = Math.max(MIN_CAPACITY, oldLen >> 1);
+		const left = Math.max(newLen, this.#head);
+		const right = Math.min(this.#head + this.#size, oldLen);
+		for (let i = left; i < right; i++) this.#buffer[i - newLen] = this.#buffer[i];
+		if (this.#head >= newLen) this.#head -= newLen;
+		this.#buffer.length = newLen;
+		this.#capacity = newLen;
+	}
+};
+//#endregion
+export { RingBuffer };
+
+//# sourceMappingURL=ring-buffer.js.map

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

@@ -0,0 +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  /** 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 = 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    this.#head = 0;\n    this.#size = 0;\n    this.#buffer = Array.from({length: this.#capacity});\n    return result;\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":";AAAA,IAAM,2BAA2B;AACjC,IAAM,eAAe;;;;;;;;;;;;AAarB,IAAa,aAAb,MAA2B;CACzB;CACA,QAAQ;CACR,QAAQ;CACR;CAEA,YAAY,kBAAkB,0BAA0B;EACtD,KAAKA,YAAY,KAAK,IAAI,cAAc,eAAe;EACvD,KAAKC,UAAU,MAAM,KAAK,EAAC,QAAQ,gBAAe,CAAC;CACrD;CAEA,IAAI,OAAe;EACjB,OAAO,KAAKC;CACd;CAEA,KAAK,OAAgB;EACnB,IAAI,KAAKA,UAAU,KAAKF,WACtB,KAAKG,MAAM;EAEb,KAAKF,SAAS,KAAKG,QAAQ,KAAKF,SAAS,KAAKF,aAAa;EAC3D,KAAKE;CACP;;CAGA,QAAuB;EACrB,IAAI,KAAKA,UAAU,GACjB;EAEF,MAAM,QAAQ,KAAKD,QAAQ,KAAKG;EAChC,KAAKH,QAAQ,KAAKG,SAAS,KAAA;EAC3B,KAAKA,SAAS,KAAKA,QAAQ,KAAK,KAAKJ;EACrC,KAAKE;EAGL,IACE,KAAKA,QAAQ,KACb,KAAKA,QAAQ,KAAKF,aAAa,KAC/B,KAAKA,YAAY,cAEjB,KAAKK,QAAQ;EAGf,OAAO;CACT;;;;;;;;CASA,OAAO,OAAkB;EACvB,IAAI,KAAKH,UAAU,GACjB,OAAO;EAGT,MAAM,YAA+B,MAAM,KAAK,EAAC,QAAQ,KAAKF,UAAS,CAAC;EACxE,IAAI,UAAU;EACd,IAAI,QAAQ;EACZ,KAAK,IAAI,IAAI,GAAG,IAAI,KAAKE,OAAO,KAAK;GACnC,MAAM,OAAO,KAAKD,SAAS,KAAKG,QAAQ,KAAK,KAAKJ;GAClD,IAAI,SAAS,OACX;QAEA,UAAU,aAAa;EAE3B;EACA,KAAKC,UAAU;EACf,KAAKG,QAAQ;EACb,KAAKF,QAAQ;EACb,OAAO;CACT;;;;CAKA,QAAa;EACX,MAAM,SAAS,MAAM,KAAQ,EAAC,QAAQ,KAAKA,MAAK,CAAC;EACjD,KAAK,IAAI,IAAI,GAAG,IAAI,KAAKA,OAAO,KAC9B,OAAO,KAAK,KAAKD,SAAS,KAAKG,QAAQ,KAAK,KAAKJ;EAEnD,KAAKI,QAAQ;EACb,KAAKF,QAAQ;EACb,KAAKD,UAAU,MAAM,KAAK,EAAC,QAAQ,KAAKD,UAAS,CAAC;EAClD,OAAO;CACT;;;;;;CAOA,QAAc;EACZ,MAAM,SAAS,KAAKC,QAAQ;EAC5B,MAAM,SAAS,SAAS;EACxB,KAAKA,QAAQ,SAAS;EACtB,KAAKD,YAAY;EAGjB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAKI,OAAO,KAAK;GACnC,KAAKH,QAAQ,SAAS,KAAK,KAAKA,QAAQ;GACxC,KAAKA,QAAQ,KAAK,KAAA;EACpB;CACF;;;;;;CAOA,UAAgB;EACd,MAAM,SAAS,KAAKA,QAAQ;EAC5B,MAAM,SAAS,KAAK,IAAI,cAAc,UAAU,CAAC;EAGjD,MAAM,OAAO,KAAK,IAAI,QAAQ,KAAKG,KAAK;EACxC,MAAM,QAAQ,KAAK,IAAI,KAAKA,QAAQ,KAAKF,OAAO,MAAM;EACtD,KAAK,IAAI,IAAI,MAAM,IAAI,OAAO,KAC5B,KAAKD,QAAQ,IAAI,UAAU,KAAKA,QAAQ;EAG1C,IAAI,KAAKG,SAAS,QAChB,KAAKA,SAAS;EAEhB,KAAKH,QAAQ,SAAS;EACtB,KAAKD,YAAY;CACnB;AACF"}

package/out/packages/shared/src/sentinels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentinels.js","names":[],"sources":["../../../../../shared/src/sentinels.ts"],"sourcesContent":["export function emptyFunction() {}\nexport const emptyObject = Object.freeze({});\nexport const emptyArray = Object.freeze([]);\nexport function identity<T>(x: T): T {\n  return x;\n}\n"],"mappings":";AAAA,SAAgB,gBAAgB,CAAC;AACjC,IAAa,cAAc,OAAO,OAAO,CAAC,CAAC;AAC3C,IAAa,aAAa,OAAO,OAAO,CAAC,CAAC;AAC1C,SAAgB,SAAY,GAAS;CACnC,OAAO;AACT"}

package/out/packages/shared/src/set-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-utils.js","names":[],"sources":["../../../../../shared/src/set-utils.ts"],"sourcesContent":["// TODO: Change lib to pick up this type definition\n\ninterface ReadonlySetLike<T> {\n  /**\n   * Despite its name, returns an iterator of the values in the set-like.\n   */\n  keys(): Iterator<T>;\n  /**\n   * @returns a boolean indicating whether an element with the specified value exists in the set-like or not.\n   */\n  has(value: T): boolean;\n  /**\n   * @returns the number of (unique) elements in the set-like.\n   */\n  readonly size: number;\n}\n\nexport function equals<T>(\n  a: ReadonlySetLike<T>,\n  b: ReadonlySetLike<T>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n  const iterator = a.keys();\n  for (\n    let {done, value} = iterator.next();\n    !done;\n    {done, value} = iterator.next()\n  ) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function union<T>(...sets: ReadonlySetLike<T>[]): Set<T> {\n  const result = new Set<T>();\n  for (const set of sets) {\n    const iterator = set.keys();\n    for (\n      let {done, value} = iterator.next();\n      !done;\n      {done, value} = iterator.next()\n    ) {\n      result.add(value);\n    }\n  }\n  return result;\n}\n\nexport function intersection<T>(\n  a: ReadonlySetLike<T>,\n  b: ReadonlySetLike<T>,\n): Set<T> {\n  const result = new Set<T>();\n  if (a.size > b.size) {\n    // Optimization: iterate over the smaller Set.\n    const swap = a;\n    a = b;\n    b = swap;\n  }\n  const iterator = a.keys();\n  for (\n    let {done, value} = iterator.next();\n    !done;\n    {done, value} = iterator.next()\n  ) {\n    if (b.has(value)) {\n      result.add(value);\n    }\n  }\n  return result;\n}\n\n/**\n * Returns the elements in {@linkcode a} that are not in {@linkcode b}.\n */\nexport function difference<T>(\n  a: ReadonlySetLike<T>,\n  b: ReadonlySetLike<T>,\n): Set<T> {\n  const result = new Set<T>();\n  const iterator = a.keys();\n  for (\n    let {done, value} = iterator.next();\n    !done;\n    {done, value} = iterator.next()\n  ) {\n    if (!b.has(value)) {\n      result.add(value);\n    }\n  }\n  return result;\n}\n\nexport function symmetricDifferences<T>(\n  a: ReadonlySetLike<T>,\n  b: ReadonlySetLike<T>,\n): [onlyA: Set<T>, onlyB: Set<T>] {\n  const onlyA = new Set<T>();\n  const iteratorA = a.keys();\n  for (\n    let {done, value} = iteratorA.next();\n    !done;\n    {done, value} = iteratorA.next()\n  ) {\n    onlyA.add(value);\n  }\n\n  const onlyB = new Set<T>();\n  const iteratorB = b.keys();\n  for (\n    let {done, value} = iteratorB.next();\n    !done;\n    {done, value} = iteratorB.next()\n  ) {\n    if (a.has(value)) {\n      onlyA.delete(value);\n      onlyB.delete(value);\n    } else {\n      onlyB.add(value);\n    }\n  }\n  return [onlyA, onlyB];\n}\n"],"mappings":";AAiBA,SAAgB,OACd,GACA,GACS;CACT,IAAI,EAAE,SAAS,EAAE,MACf,OAAO;CAET,MAAM,WAAW,EAAE,KAAK;CACxB,KACE,IAAI,EAAC,MAAM,UAAS,SAAS,KAAK,GAClC,CAAC,MACD,CAAC,MAAM,SAAS,SAAS,KAAK,GAE9B,IAAI,CAAC,EAAE,IAAI,KAAK,GACd,OAAO;CAGX,OAAO;AACT;AAEA,SAAgB,MAAS,GAAG,MAAoC;CAC9D,MAAM,yBAAS,IAAI,IAAO;CAC1B,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,WAAW,IAAI,KAAK;EAC1B,KACE,IAAI,EAAC,MAAM,UAAS,SAAS,KAAK,GAClC,CAAC,MACD,CAAC,MAAM,SAAS,SAAS,KAAK,GAE9B,OAAO,IAAI,KAAK;CAEpB;CACA,OAAO;AACT;AAEA,SAAgB,aACd,GACA,GACQ;CACR,MAAM,yBAAS,IAAI,IAAO;CAC1B,IAAI,EAAE,OAAO,EAAE,MAAM;EAEnB,MAAM,OAAO;EACb,IAAI;EACJ,IAAI;CACN;CACA,MAAM,WAAW,EAAE,KAAK;CACxB,KACE,IAAI,EAAC,MAAM,UAAS,SAAS,KAAK,GAClC,CAAC,MACD,CAAC,MAAM,SAAS,SAAS,KAAK,GAE9B,IAAI,EAAE,IAAI,KAAK,GACb,OAAO,IAAI,KAAK;CAGpB,OAAO;AACT;;;;AAKA,SAAgB,WACd,GACA,GACQ;CACR,MAAM,yBAAS,IAAI,IAAO;CAC1B,MAAM,WAAW,EAAE,KAAK;CACxB,KACE,IAAI,EAAC,MAAM,UAAS,SAAS,KAAK,GAClC,CAAC,MACD,CAAC,MAAM,SAAS,SAAS,KAAK,GAE9B,IAAI,CAAC,EAAE,IAAI,KAAK,GACd,OAAO,IAAI,KAAK;CAGpB,OAAO;AACT;AAEA,SAAgB,qBACd,GACA,GACgC;CAChC,MAAM,wBAAQ,IAAI,IAAO;CACzB,MAAM,YAAY,EAAE,KAAK;CACzB,KACE,IAAI,EAAC,MAAM,UAAS,UAAU,KAAK,GACnC,CAAC,MACD,CAAC,MAAM,SAAS,UAAU,KAAK,GAE/B,MAAM,IAAI,KAAK;CAGjB,MAAM,wBAAQ,IAAI,IAAO;CACzB,MAAM,YAAY,EAAE,KAAK;CACzB,KACE,IAAI,EAAC,MAAM,UAAS,UAAU,KAAK,GACnC,CAAC,MACD,CAAC,MAAM,SAAS,UAAU,KAAK,GAE/B,IAAI,EAAE,IAAI,KAAK,GAAG;EAChB,MAAM,OAAO,KAAK;EAClB,MAAM,OAAO,KAAK;CACpB,OACE,MAAM,IAAI,KAAK;CAGnB,OAAO,CAAC,OAAO,KAAK;AACtB"}

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

@@ -0,0 +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"}

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

@@ -0,0 +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"}

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

@@ -0,0 +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"}

package/out/packages/shared/src/string-compare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-compare.js","names":[],"sources":["../../../../../shared/src/string-compare.ts"],"sourcesContent":["export function stringCompare(a: string, b: string): number {\n  if (a === b) {\n    return 0;\n  }\n  if (a < b) {\n    return -1;\n  }\n  return 1;\n}\n"],"mappings":";AAAA,SAAgB,cAAc,GAAW,GAAmB;CAC1D,IAAI,MAAM,GACR,OAAO;CAET,IAAI,IAAI,GACN,OAAO;CAET,OAAO;AACT"}

package/out/packages/shared/src/subscribable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribable.js","names":[],"sources":["../../../../../shared/src/subscribable.ts"],"sourcesContent":["export class Subscribable<\n  TArgs,\n  TListener extends (obj: TArgs) => unknown = (obj: TArgs) => unknown,\n> {\n  protected _listeners = new Set<TListener>();\n\n  /**\n   * Subscribe to the subscribable.\n   *\n   * @param listener - The listener to subscribe to.\n   * @returns A function to unsubscribe from the subscribable.\n   */\n  subscribe = (listener: TListener): (() => void) => {\n    this._listeners.add(listener);\n\n    return () => {\n      this._listeners.delete(listener);\n    };\n  };\n\n  /**\n   * Notify all listeners.\n   *\n   * @param update - The update to notify listeners with.\n   */\n  notify = (update: TArgs): void => {\n    this._listeners.forEach(listener => listener(update));\n  };\n\n  hasListeners = (): boolean => this._listeners.size > 0;\n\n  /**\n   * Unsubscribe all listeners.\n   */\n  cleanup = (): void => {\n    this._listeners.clear();\n  };\n}\n"],"mappings":";AAAA,IAAa,eAAb,MAGE;CACA,6BAAuB,IAAI,IAAe;;;;;;;CAQ1C,aAAa,aAAsC;EACjD,KAAK,WAAW,IAAI,QAAQ;EAE5B,aAAa;GACX,KAAK,WAAW,OAAO,QAAQ;EACjC;CACF;;;;;;CAOA,UAAU,WAAwB;EAChC,KAAK,WAAW,SAAQ,aAAY,SAAS,MAAM,CAAC;CACtD;CAEA,qBAA8B,KAAK,WAAW,OAAO;;;;CAKrD,gBAAsB;EACpB,KAAK,WAAW,MAAM;CACxB;AACF"}

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

@@ -0,0 +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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"tdigest.js","names":["#maxProcessed","#maxUnprocessed","#processed","#unprocessed","#cumulative","#processedWeight","#unprocessedWeight","#min","#max","#process","#integratedQ","#integratedLocation","#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, sortCentroidList, 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// TDigest is a data structure for accurate on-line accumulation of\n// rank-based statistics such as quantiles and trimmed means.\nexport class TDigest {\n  readonly compression: number;\n\n  #maxProcessed: number;\n  #maxUnprocessed: number;\n  #processed!: CentroidList;\n  #unprocessed!: CentroidList;\n  #cumulative!: number[];\n  #processedWeight!: number;\n  #unprocessedWeight!: number;\n  #min!: number;\n  #max!: number;\n\n  constructor(compression: number = 1000) {\n    this.compression = compression;\n    this.#maxProcessed = processedSize(0, this.compression);\n    this.#maxUnprocessed = unprocessedSize(0, this.compression);\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.#processed = [];\n    this.#unprocessed = [];\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  add(mean: number, weight: number = 1) {\n    this.addCentroid(new Centroid(mean, weight));\n  }\n\n  /** AddCentroidList can quickly add multiple centroids. */\n  addCentroidList(centroidList: CentroidList) {\n    for (const c of centroidList) {\n      this.addCentroid(c);\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    if (\n      Number.isNaN(c.mean) ||\n      c.weight <= 0 ||\n      Number.isNaN(c.weight) ||\n      !Number.isFinite(c.weight)\n    ) {\n      return;\n    }\n\n    this.#unprocessed.push(new Centroid(c.mean, c.weight));\n    this.#unprocessedWeight += c.weight;\n\n    if (\n      this.#processed.length > this.#maxProcessed ||\n      this.#unprocessed.length > this.#maxUnprocessed\n    ) {\n      this.#process();\n    }\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    this.addCentroidList(t2.#processed);\n  }\n\n  #process() {\n    if (\n      this.#unprocessed.length > 0 ||\n      this.#processed.length > this.#maxProcessed\n    ) {\n      // Append all processed centroids to the unprocessed list and sort\n      this.#unprocessed.push(...this.#processed);\n      sortCentroidList(this.#unprocessed);\n\n      // Reset processed list with first centroid\n      this.#processed.length = 0;\n      this.#processed.push(this.#unprocessed[0]);\n\n      this.#processedWeight += this.#unprocessedWeight;\n      this.#unprocessedWeight = 0;\n      let soFar = this.#unprocessed[0].weight;\n      let limit = this.#processedWeight * this.#integratedQ(1);\n      for (let i = 1; i < this.#unprocessed.length; i++) {\n        const centroid = this.#unprocessed[i];\n        const projected = soFar + centroid.weight;\n        if (projected <= limit) {\n          soFar = projected;\n          // oxlint-disable-next-line typescript/no-non-null-assertion\n          this.#processed.at(-1)!.add(centroid);\n        } else {\n          const k1 = this.#integratedLocation(soFar / this.#processedWeight);\n          limit = this.#processedWeight * this.#integratedQ(k1 + 1);\n          soFar += centroid.weight;\n          this.#processed.push(centroid);\n        }\n      }\n      this.#min = Math.min(this.#min, this.#processed[0].mean);\n      // oxlint-disable-next-line typescript/no-non-null-assertion\n      this.#max = Math.max(this.#max, this.#processed.at(-1)!.mean);\n      this.#unprocessed.length = 0;\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    return [...cl, ...this.#processed];\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 (const centroid of this.#processed) {\n      data.push(centroid.mean, centroid.weight);\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.#processed.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.#processed.length; i++) {\n      const centroid = this.#processed[i];\n      const cur = centroid.weight;\n      this.#cumulative[i] = prev + cur / 2;\n      prev += cur;\n    }\n    this.#cumulative[this.#processed.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.#processed.length === 0) {\n      return NaN;\n    }\n    if (this.#processed.length === 1) {\n      return this.#processed[0].mean;\n    }\n    const index = q * this.#processedWeight;\n    if (index <= this.#processed[0].weight / 2) {\n      return (\n        this.#min +\n        ((2 * index) / this.#processed[0].weight) *\n          (this.#processed[0].mean - 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.#processed[lower - 1].mean,\n        z2,\n        this.#processed[lower].mean,\n        z1,\n      );\n    }\n\n    const z1 =\n      index - this.#processedWeight - this.#processed[lower - 1].weight / 2;\n    const z2 = this.#processed[lower - 1].weight / 2 - z1;\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    return weightedAverage(this.#processed.at(-1)!.mean, 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.#processed.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.#processed[0].mean;\n    // Left Tail\n    if (x <= m0) {\n      if (m0 - this.#min > 0) {\n        return (\n          (((x - this.#min) / (m0 - this.#min)) * this.#processed[0].weight) /\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.#processed.at(-1)!.mean;\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.#processed.at(-1)!.weight) /\n            this.#processedWeight /\n            2\n        );\n      }\n      return 1;\n    }\n\n    const upper = binarySearch(\n      this.#processed.length,\n      // Treat equals as greater than, so we can use the upper index\n      // This is equivalent to:\n      //   i => this.#processed[i].mean > x ? -1 : 1,\n      i => x - this.#processed[i].mean || 1,\n    );\n\n    const z1 = x - this.#processed[upper - 1].mean;\n    const z2 = this.#processed[upper].mean - 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 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 processedSize(size: number, compression: number): number {\n  if (size === 0) {\n    return Math.ceil(compression) * 2;\n  }\n  return size;\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":";;;AAeA,IAAa,UAAb,MAAa,QAAQ;CACnB;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,cAAsB,KAAM;EACtC,KAAK,cAAc;EACnB,KAAKA,gBAAgB,cAAc,GAAG,KAAK,WAAW;EACtD,KAAKC,kBAAkB,gBAAgB,GAAG,KAAK,WAAW;EAC1D,KAAK,MAAM;CACb;;;;;CAMA,OAAO,SAAS,MAAsC;EACpD,MAAM,SAAS,IAAI,QAAQ,KAAK,EAAE;EAClC,IAAI,KAAK,SAAS,MAAM,GACtB,MAAM,IAAI,MAAM,yBAAyB;EAE3C,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,GACpC,OAAO,IAAI,KAAK,IAAI,KAAK,IAAI,EAAE;EAEjC,OAAO;CACT;CAEA,QAAc;EACZ,KAAKC,aAAa,CAAC;EACnB,KAAKC,eAAe,CAAC;EACrB,KAAKC,cAAc,CAAC;EACpB,KAAKC,mBAAmB;EACxB,KAAKC,qBAAqB;EAC1B,KAAKC,OAAO,OAAO;EACnB,KAAKC,OAAO,CAAC,OAAO;CACtB;CAEA,IAAI,MAAc,SAAiB,GAAG;EACpC,KAAK,YAAY,IAAI,SAAS,MAAM,MAAM,CAAC;CAC7C;;CAGA,gBAAgB,cAA4B;EAC1C,KAAK,MAAM,KAAK,cACd,KAAK,YAAY,CAAC;CAEtB;;;;;CAMA,YAAY,GAAmB;EAC7B,IACE,OAAO,MAAM,EAAE,IAAI,KACnB,EAAE,UAAU,KACZ,OAAO,MAAM,EAAE,MAAM,KACrB,CAAC,OAAO,SAAS,EAAE,MAAM,GAEzB;EAGF,KAAKL,aAAa,KAAK,IAAI,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC;EACrD,KAAKG,sBAAsB,EAAE;EAE7B,IACE,KAAKJ,WAAW,SAAS,KAAKF,iBAC9B,KAAKG,aAAa,SAAS,KAAKF,iBAEhC,KAAKQ,SAAS;CAElB;;;;;;CAOA,MAAM,IAAa;EACjB,GAAGA,SAAS;EACZ,KAAK,gBAAgB,GAAGP,UAAU;CACpC;CAEA,WAAW;EACT,IACE,KAAKC,aAAa,SAAS,KAC3B,KAAKD,WAAW,SAAS,KAAKF,eAC9B;GAEA,KAAKG,aAAa,KAAK,GAAG,KAAKD,UAAU;GACzC,iBAAiB,KAAKC,YAAY;GAGlC,KAAKD,WAAW,SAAS;GACzB,KAAKA,WAAW,KAAK,KAAKC,aAAa,EAAE;GAEzC,KAAKE,oBAAoB,KAAKC;GAC9B,KAAKA,qBAAqB;GAC1B,IAAI,QAAQ,KAAKH,aAAa,GAAG;GACjC,IAAI,QAAQ,KAAKE,mBAAmB,KAAKK,aAAa,CAAC;GACvD,KAAK,IAAI,IAAI,GAAG,IAAI,KAAKP,aAAa,QAAQ,KAAK;IACjD,MAAM,WAAW,KAAKA,aAAa;IACnC,MAAM,YAAY,QAAQ,SAAS;IACnC,IAAI,aAAa,OAAO;KACtB,QAAQ;KAER,KAAKD,WAAW,GAAG,EAAE,EAAG,IAAI,QAAQ;IACtC,OAAO;KACL,MAAM,KAAK,KAAKS,oBAAoB,QAAQ,KAAKN,gBAAgB;KACjE,QAAQ,KAAKA,mBAAmB,KAAKK,aAAa,KAAK,CAAC;KACxD,SAAS,SAAS;KAClB,KAAKR,WAAW,KAAK,QAAQ;IAC/B;GACF;GACA,KAAKK,OAAO,KAAK,IAAI,KAAKA,MAAM,KAAKL,WAAW,GAAG,IAAI;GAEvD,KAAKM,OAAO,KAAK,IAAI,KAAKA,MAAM,KAAKN,WAAW,GAAG,EAAE,EAAG,IAAI;GAC5D,KAAKC,aAAa,SAAS;EAC7B;CACF;;;;;;;;CASA,UAAU,KAAmB,CAAC,GAAiB;EAC7C,KAAKM,SAAS;EACd,OAAO,CAAC,GAAG,IAAI,GAAG,KAAKP,UAAU;CACnC;CAEA,QAAgB;EACd,KAAKO,SAAS;EAId,OAAO,KAAKJ;CACd;;;;;CAMA,SAAsB;EACpB,KAAKI,SAAS;EACd,MAAM,OAAoB,CAAC,KAAK,WAAW;EAC3C,KAAK,MAAM,YAAY,KAAKP,YAC1B,KAAK,KAAK,SAAS,MAAM,SAAS,MAAM;EAE1C,OAAO;CACT;CAEA,oBAAoB;EAIlB,IACE,KAAKE,YAAY,SAAS,KAC1B,KAAKA,YAAY,GAAG,EAAE,MAAM,KAAKC,kBAEjC;EAEF,MAAM,IAAI,KAAKH,WAAW,SAAS;EACnC,IAAI,KAAKE,YAAY,SAAS,GAC5B,KAAKA,YAAY,SAAS;EAG5B,IAAI,OAAO;EACX,KAAK,IAAI,IAAI,GAAG,IAAI,KAAKF,WAAW,QAAQ,KAAK;GAE/C,MAAM,MADW,KAAKA,WAAW,GACZ;GACrB,KAAKE,YAAY,KAAK,OAAO,MAAM;GACnC,QAAQ;EACV;EACA,KAAKA,YAAY,KAAKF,WAAW,UAAU;CAC7C;CAKA,SAAS,GAAmB;EAC1B,KAAKO,SAAS;EACd,KAAKG,kBAAkB;EACvB,IAAI,IAAI,KAAK,IAAI,KAAK,KAAKV,WAAW,WAAW,GAC/C,OAAO;EAET,IAAI,KAAKA,WAAW,WAAW,GAC7B,OAAO,KAAKA,WAAW,GAAG;EAE5B,MAAM,QAAQ,IAAI,KAAKG;EACvB,IAAI,SAAS,KAAKH,WAAW,GAAG,SAAS,GACvC,OACE,KAAKK,OACH,IAAI,QAAS,KAAKL,WAAW,GAAG,UAC/B,KAAKA,WAAW,GAAG,OAAO,KAAKK;EAItC,MAAM,QAAQ,aACZ,KAAKH,YAAY,SAChB,MAAc,CAAC,KAAKA,YAAY,KAAK,KACxC;EAEA,IAAI,QAAQ,MAAM,KAAKA,YAAY,QAAQ;GACzC,MAAM,KAAK,QAAQ,KAAKA,YAAY,QAAQ;GAC5C,MAAM,KAAK,KAAKA,YAAY,SAAS;GACrC,OAAO,gBACL,KAAKF,WAAW,QAAQ,GAAG,MAC3B,IACA,KAAKA,WAAW,OAAO,MACvB,EACF;EACF;EAEA,MAAM,KACJ,QAAQ,KAAKG,mBAAmB,KAAKH,WAAW,QAAQ,GAAG,SAAS;EACtE,MAAM,KAAK,KAAKA,WAAW,QAAQ,GAAG,SAAS,IAAI;EAEnD,OAAO,gBAAgB,KAAKA,WAAW,GAAG,EAAE,EAAG,MAAM,IAAI,KAAKM,MAAM,EAAE;CACxE;;;;CAKA,IAAI,GAAmB;EACrB,KAAKC,SAAS;EACd,KAAKG,kBAAkB;EACvB,QAAQ,KAAKV,WAAW,QAAxB;GACE,KAAK,GACH,OAAO;GACT,KAAK,GAAG;IACN,MAAM,QAAQ,KAAKM,OAAO,KAAKD;IAC/B,IAAI,KAAK,KAAKA,MACZ,OAAO;IAET,IAAI,KAAK,KAAKC,MACZ,OAAO;IAET,IAAI,IAAI,KAAKD,QAAQ,OAEnB,OAAO;IAET,QAAQ,IAAI,KAAKA,QAAQ;GAC3B;EACF;EAEA,IAAI,KAAK,KAAKA,MACZ,OAAO;EAET,IAAI,KAAK,KAAKC,MACZ,OAAO;EAET,MAAM,KAAK,KAAKN,WAAW,GAAG;EAE9B,IAAI,KAAK,IAAI;GACX,IAAI,KAAK,KAAKK,OAAO,GACnB,QACK,IAAI,KAAKA,SAAS,KAAK,KAAKA,QAAS,KAAKL,WAAW,GAAG,SAC3D,KAAKG,mBACL;GAGJ,OAAO;EACT;EAGA,MAAM,KAAK,KAAKH,WAAW,GAAG,EAAE,EAAG;EACnC,IAAI,KAAK,IAAI;GACX,IAAI,KAAKM,OAAO,KAAK,GACnB,OACE,KACG,KAAKA,OAAO,MAAM,KAAKA,OAAO,MAE/B,KAAKN,WAAW,GAAG,EAAE,EAAG,SACxB,KAAKG,mBACL;GAGN,OAAO;EACT;EAEA,MAAM,QAAQ,aACZ,KAAKH,WAAW,SAIhB,MAAK,IAAI,KAAKA,WAAW,GAAG,QAAQ,CACtC;EAEA,MAAM,KAAK,IAAI,KAAKA,WAAW,QAAQ,GAAG;EAC1C,MAAM,KAAK,KAAKA,WAAW,OAAO,OAAO;EACzC,OACE,gBACE,KAAKE,YAAY,QAAQ,IACzB,IACA,KAAKA,YAAY,QACjB,EACF,IAAI,KAAKC;CAEb;CAEA,aAAa,GAAmB;EAC9B,QACG,KAAK,IACH,KAAK,IAAI,GAAG,KAAK,WAAW,IAAI,KAAK,KAAM,KAAK,cAC/C,KAAK,KAAK,CACd,IACE,KACF;CAEJ;CAEA,oBAAoB,GAAmB;EACrC,OAAQ,KAAK,eAAe,KAAK,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,KAAM,KAAK;CAC1E;AACF;AA0BA,SAAS,gBACP,IACA,IACA,IACA,IACQ;CACR,IAAI,MAAM,IACR,OAAO,sBAAsB,IAAI,IAAI,IAAI,EAAE;CAE7C,OAAO,sBAAsB,IAAI,IAAI,IAAI,EAAE;AAC7C;AAEA,SAAS,sBACP,IACA,IACA,IACA,IACQ;CACR,MAAM,KAAK,KAAK,KAAK,KAAK,OAAO,KAAK;CACtC,OAAO,KAAK,IAAI,IAAI,KAAK,IAAI,GAAG,EAAE,CAAC;AACrC;AAEA,SAAS,cAAc,MAAc,aAA6B;CAChE,IAAI,SAAS,GACX,OAAO,KAAK,KAAK,WAAW,IAAI;CAElC,OAAO;AACT;AAEA,SAAS,gBAAgB,MAAc,aAA6B;CAClE,IAAI,SAAS,GACX,OAAO,KAAK,KAAK,WAAW,IAAI;CAElC,OAAO;AACT"}