{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "data-grid-server-query",
  "title": "Data Grid Server Query",
  "author": "gridcn",
  "description": "The server half of a server-driven gridcn grid: a column map that is the allow-list and the projection, parseQuery that turns an untrusted grid request into a bounded, typed query plan (escaping, null and blank rules, number and day bounds, limits), handleGridRequest for a route handler, and describeFilterOperators so the filter UI offers only what the server accepts. Add an ORM adapter to run the plan.",
  "dependencies": [],
  "registryDependencies": [],
  "files": [
    {
      "path": "registry/default/blocks/data-grid-server-query/column-map.ts",
      "content": "/** The cell-type names the column map understands. A custom cell type declares `kind` instead. */\r\nexport type ColumnType = \"text\" | \"number\" | \"checkbox\" | \"select\" | \"date\" | \"url\" | \"longText\";\r\nexport type ColumnKind = \"text\" | \"number\" | \"checkbox\" | \"select\" | \"date\";\r\nexport type NumericType = \"int2\" | \"int4\" | \"int8\" | \"float\" | \"decimal\";\r\nexport type DateStorage = \"native\" | \"iso-text\" | \"epoch-ms\" | \"epoch-s\";\r\nexport type AggregateReducer = \"sum\" | \"avg\" | \"min\" | \"max\" | \"count\";\r\nexport type NativeStringType = \"enum\" | \"uuid\";\r\nexport type OperatorInput = \"none\" | \"single\" | \"range\" | \"list\";\r\n\r\n/** A custom operator a column accepts next to the 15 built-ins. */\r\nexport type ColumnOperator = { id: string; label: string; input: OperatorInput };\r\n\r\n/** What a request may do with one column, and how the column is stored. */\r\nexport type ColumnSpec = {\r\n  /** Grid cell-type name. `url` and `longText` behave as `text`. A name outside the list needs `kind`. */\r\n  type: ColumnType | (string & {});\r\n  /** Behavior of a custom cell type. */\r\n  kind?: ColumnKind;\r\n  /** Physical column name when it differs from the id. */\r\n  field?: string;\r\n  primaryKey?: boolean;\r\n  /** Never selected, filtered, sorted, searched, or aggregated for the client; usable by `rowScope`. */\r\n  serverOnly?: boolean;\r\n  /** Quick search covers only columns that set this. */\r\n  searchable?: boolean;\r\n  /** `false` rejects a filter on the column. Default `true`. */\r\n  filterable?: boolean;\r\n  /** `false` rejects a sort on the column. Default `true`. */\r\n  sortable?: boolean;\r\n  /** The column is NOT NULL. */\r\n  required?: boolean;\r\n  caseSensitive?: boolean;\r\n  /** A stored `''` is a value, not empty. */\r\n  keepBlankText?: boolean;\r\n  /** A `date` column that holds instants; day-bound expansion applies to it. */\r\n  time?: boolean;\r\n  storage?: DateStorage;\r\n  /** Physical PostgreSQL type of a `text` or `select` column that is not text. */\r\n  native?: NativeStringType;\r\n  /** Physical number type. Required on every `number` column. */\r\n  numeric?: NumericType;\r\n  /** Decimal places of a `decimal` column. */\r\n  scale?: number;\r\n  choices?: readonly string[];\r\n  maxLength?: number;\r\n  aggregate?: AggregateReducer;\r\n  operators?: readonly ColumnOperator[];\r\n};\r\n\r\n/** A column after validation. */\r\nexport type PlanColumn = Readonly<{\r\n  id: string;\r\n  field: string;\r\n  kind: ColumnKind;\r\n  numeric?: NumericType;\r\n  scale?: number;\r\n  native?: NativeStringType;\r\n  time: boolean;\r\n  storage: DateStorage;\r\n  caseSensitive: boolean;\r\n  keepBlankText: boolean;\r\n  required: boolean;\r\n  primaryKey: boolean;\r\n  serverOnly: boolean;\r\n  searchable: boolean;\r\n  filterable: boolean;\r\n  sortable: boolean;\r\n  choices?: readonly string[];\r\n  maxLength?: number;\r\n  aggregate?: AggregateReducer;\r\n  operators: ReadonlyMap<string, ColumnOperator>;\r\n  type: string;\r\n}>;\r\n\r\nexport type ColumnMapOptions<Id extends string = string> = {\r\n  /** Unique, non-null, non-`serverOnly` columns that order rows when the map has no `primaryKey`. */\r\n  tieBreaker?: readonly Id[];\r\n};\r\n\r\ndeclare const columnMapBrand: unique symbol;\r\n\r\n/** The allow-list, the projection, and the semantics of the columns a request may name. */\r\nexport type ColumnMap<Id extends string = string> = {\r\n  readonly [columnMapBrand]: Id;\r\n  /** Every column, `serverOnly` included, by id. */\r\n  readonly byId: ReadonlyMap<string, PlanColumn>;\r\n  /** The columns the client sees, in map order. */\r\n  readonly visible: readonly PlanColumn[];\r\n  /** The columns that give rows a total order. */\r\n  readonly tieBreaker: readonly PlanColumn[];\r\n};\r\n\r\nexport const MAX_SEARCH_COLUMNS = 16;\r\n\r\nconst BUILT_IN_KINDS = new Map<string, ColumnKind>([\r\n  [\"text\", \"text\"],\r\n  [\"url\", \"text\"],\r\n  [\"longText\", \"text\"],\r\n  [\"number\", \"number\"],\r\n  [\"checkbox\", \"checkbox\"],\r\n  [\"select\", \"select\"],\r\n  [\"date\", \"date\"],\r\n]);\r\nconst NUMERIC_TYPES: ReadonlySet<string> = new Set<NumericType>([\"int2\", \"int4\", \"int8\", \"float\", \"decimal\"]);\r\nconst STORAGES: ReadonlySet<string> = new Set<DateStorage>([\"native\", \"iso-text\", \"epoch-ms\", \"epoch-s\"]);\r\nconst REDUCERS: ReadonlySet<string> = new Set<AggregateReducer>([\"sum\", \"avg\", \"min\", \"max\", \"count\"]);\r\nconst INPUTS: ReadonlySet<string> = new Set<OperatorInput>([\"none\", \"single\", \"range\", \"list\"]);\r\nconst BUILT_IN_OPERATOR_IDS: ReadonlySet<string> = new Set([\r\n  \"contains\", \"notContains\", \"equals\", \"notEquals\", \"startsWith\", \"endsWith\", \"empty\", \"notEmpty\",\r\n  \"gt\", \"gte\", \"lt\", \"lte\", \"isBetween\", \"isAnyOf\", \"isNoneOf\",\r\n]);\r\n\r\nexport function isBuiltInOperatorId(id: string): boolean {\r\n  return BUILT_IN_OPERATOR_IDS.has(id);\r\n}\r\n\r\nfunction fail(id: string, message: string): never {\r\n  throw new Error(`defineColumnMap: column \"${id}\" ${message}`);\r\n}\r\n\r\nfunction resolveColumn(id: string, spec: ColumnSpec): PlanColumn {\r\n  const kind = spec.kind ?? BUILT_IN_KINDS.get(spec.type);\r\n  if (kind === undefined) return fail(id, `has type \"${spec.type}\"; declare \\`kind\\` for a custom cell type`);\r\n  if (spec.field !== undefined && (typeof spec.field !== \"string\" || spec.field === \"\")) fail(id, \"has an empty field\");\r\n  if (kind === \"number\") {\r\n    if (spec.numeric === undefined || !NUMERIC_TYPES.has(spec.numeric)) fail(id, \"is a number column and needs `numeric`: int2, int4, int8, float, or decimal\");\r\n    if (spec.scale !== undefined && (spec.numeric !== \"decimal\" || !Number.isInteger(spec.scale) || spec.scale < 0)) fail(id, \"has `scale` without `numeric: \\\"decimal\\\"`, or a scale that is not a non-negative integer\");\r\n  } else if (spec.numeric !== undefined || spec.scale !== undefined) fail(id, \"sets `numeric` or `scale` on a column that is not a number\");\r\n  if (spec.native !== undefined) {\r\n    if (kind !== \"text\" && kind !== \"select\") fail(id, \"sets `native` on a column that is not text or select\");\r\n    if (spec.native === \"enum\" && (spec.choices === undefined || spec.choices.length === 0)) fail(id, \"is a native enum and needs `choices`\");\r\n  }\r\n  if (spec.storage !== undefined && !STORAGES.has(spec.storage)) fail(id, `has unknown storage \"${spec.storage}\"`);\r\n  if (spec.time && kind !== \"date\") fail(id, \"sets `time` on a column that is not a date\");\r\n  if (spec.aggregate !== undefined) {\r\n    if (!REDUCERS.has(spec.aggregate)) fail(id, `has unknown aggregate \"${spec.aggregate}\"`);\r\n    if ((spec.aggregate === \"sum\" || spec.aggregate === \"avg\") && kind !== \"number\") fail(id, `cannot ${spec.aggregate} a column that is not a number`);\r\n  }\r\n  if (spec.searchable && (kind === \"date\" || kind === \"checkbox\")) fail(id, \"is searchable but holds a date or checkbox\");\r\n  if (spec.serverOnly && spec.primaryKey) fail(id, \"is a primary key and cannot be serverOnly: rows would carry no id\");\r\n  const operators = new Map<string, ColumnOperator>();\r\n  for (const operator of spec.operators ?? []) {\r\n    if (typeof operator?.id !== \"string\" || operator.id === \"\" || BUILT_IN_OPERATOR_IDS.has(operator.id) || operators.has(operator.id)) fail(id, \"declares an operator with a missing, built-in, or duplicate id\");\r\n    if (typeof operator.label !== \"string\" || !INPUTS.has(operator.input)) fail(id, `declares operator \"${operator.id}\" without a label or a valid input`);\r\n    operators.set(operator.id, { id: operator.id, label: operator.label, input: operator.input });\r\n  }\r\n  return Object.freeze({\r\n    id,\r\n    field: spec.field ?? id,\r\n    kind,\r\n    numeric: spec.numeric,\r\n    scale: spec.scale,\r\n    native: spec.native,\r\n    time: spec.time === true,\r\n    storage: spec.storage ?? \"native\",\r\n    caseSensitive: spec.caseSensitive === true,\r\n    keepBlankText: spec.keepBlankText === true,\r\n    required: spec.required === true,\r\n    primaryKey: spec.primaryKey === true,\r\n    serverOnly: spec.serverOnly === true,\r\n    searchable: spec.searchable === true,\r\n    filterable: spec.filterable !== false,\r\n    sortable: spec.sortable !== false,\r\n    choices: spec.choices ? Object.freeze([...spec.choices]) : undefined,\r\n    maxLength: spec.maxLength,\r\n    aggregate: spec.aggregate,\r\n    operators,\r\n    type: spec.type,\r\n  });\r\n}\r\n\r\n/**\r\n * Validates the columns of a table and returns the map every query reads. A column maps to one physical column.\r\n *\r\n * @example\r\n * const columns = defineColumnMap({\r\n *   id: { type: \"number\", numeric: \"int8\", primaryKey: true },\r\n *   name: { type: \"text\", searchable: true },\r\n *   tenantId: { type: \"number\", numeric: \"int4\", serverOnly: true },\r\n * });\r\n */\r\nexport function defineColumnMap<const C extends Record<string, ColumnSpec>>(columns: C, options: ColumnMapOptions<keyof C & string> = {}): ColumnMap<keyof C & string> {\r\n  const byId = new Map<string, PlanColumn>();\r\n  for (const id of Object.keys(columns)) byId.set(id, resolveColumn(id, columns[id]!));\r\n  if (byId.size === 0) throw new Error(\"defineColumnMap: the map needs at least one column\");\r\n  const primaryKeys = [...byId.values()].filter((column) => column.primaryKey);\r\n  if (primaryKeys.length > 1) throw new Error(\"defineColumnMap: at most one primaryKey; use `tieBreaker` for a composite key\");\r\n  const tieBreakerIds = options.tieBreaker ?? [];\r\n  const tieBreaker: PlanColumn[] = [];\r\n  if (primaryKeys.length === 1 && tieBreakerIds.length === 0) tieBreaker.push(primaryKeys[0]!);\r\n  else if (tieBreakerIds.length > 0) {\r\n    if (primaryKeys.length === 1) throw new Error(\"defineColumnMap: pass `primaryKey` or `tieBreaker`, not both\");\r\n    for (const id of tieBreakerIds) {\r\n      const column = byId.get(id);\r\n      if (!column || column.serverOnly || tieBreaker.includes(column)) throw new Error(`defineColumnMap: tieBreaker \"${id}\" is unknown, serverOnly, or repeated`);\r\n      tieBreaker.push(column);\r\n    }\r\n  } else throw new Error(\"defineColumnMap: mark one column `primaryKey` or pass `tieBreaker`, so every sort is a total order\");\r\n  const searchable = [...byId.values()].filter((column) => column.searchable && !column.serverOnly);\r\n  if (searchable.length > MAX_SEARCH_COLUMNS) throw new Error(`defineColumnMap: at most ${MAX_SEARCH_COLUMNS} searchable columns`);\r\n  const visible = [...byId.values()].filter((column) => !column.serverOnly);\r\n  return Object.freeze({ byId, visible, tieBreaker }) as unknown as ColumnMap<keyof C & string>;\r\n}\r\n\r\n/** The internal view of a map; the brand type hides it from callers. */\r\nexport function mapOf(columns: ColumnMap): { byId: ReadonlyMap<string, PlanColumn>; visible: readonly PlanColumn[]; tieBreaker: readonly PlanColumn[] } {\r\n  return columns as unknown as { byId: ReadonlyMap<string, PlanColumn>; visible: readonly PlanColumn[]; tieBreaker: readonly PlanColumn[] };\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/column-map.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/create-grid-query.ts",
      "content": "import { type ColumnMap, type PlanColumn, mapOf } from \"./column-map\";\r\nimport { isDev } from \"./is-dev\";\r\nimport { QueryError } from \"./errors\";\r\nimport { type QueryLimits, resolveLimits } from \"./limits\";\r\nimport { type RowCountMode, parseQuery } from \"./parse-query\";\r\nimport type { AggregatesPlan, GroupsPlan, Operand, Predicate, RowsPlan, Test, ValuesPlan } from \"./plan\";\r\nimport { combine } from \"./plan\";\r\nimport { type RowScope, rowScopePredicate } from \"./row-scope\";\r\nimport { serializeRow, serializeValue } from \"./serialize-row\";\r\nimport { toSafeText } from \"./safe-text\";\r\n\r\n/** Largest row count an answer carries; the grid clamps to the same bound. */\r\nexport const MAX_TOTAL_ROW_COUNT = 10_000_000;\r\nconst MAX_VALUES = 1000;\r\nconst MAX_VALUE_TEXT = 256;\r\n\r\n/** What an ORM adapter can do. The conformance suite reads it to choose expected results. */\r\nexport type AdapterCapabilities = {\r\n  caseInsensitiveText: \"native\" | \"ascii\" | \"collation\";\r\n  likeEscape: boolean;\r\n  literalAsterisk: boolean;\r\n  nullsLast: \"native\" | \"emulated\";\r\n  aggregates: boolean;\r\n  groupBy: boolean;\r\n  localDayGrouping: boolean;\r\n};\r\n\r\n/** One group row as the database returns it; `aggregates` is keyed by column id. */\r\nexport type RawGroupRow = { key: unknown; count: unknown; childCount: unknown; aggregates: Record<string, unknown> };\r\n\r\n/** The part of a query layer an ORM adapter supplies: it renders plans and runs them. */\r\nexport type QueryExecutor<TWhere, TOrder> = {\r\n  capabilities: AdapterCapabilities;\r\n  selectRows(plan: RowsPlan, page: { offset: number; limit: number; signal?: AbortSignal }): Promise<Record<string, unknown>[]>;\r\n  countRows(plan: RowsPlan, signal?: AbortSignal): Promise<unknown>;\r\n  selectValues(plan: ValuesPlan, options: { limit: number; signal?: AbortSignal }): Promise<{ value: unknown; count: unknown }[]>;\r\n  aggregate(plan: AggregatesPlan, signal?: AbortSignal): Promise<Record<string, unknown>>;\r\n  /** One page of the groups of `plan.level`, in key order with the empty key last; `childCount` is the row count, or the group count of the next level. */\r\n  selectGroups(plan: GroupsPlan, page: { offset: number; limit: number; signal?: AbortSignal }): Promise<RawGroupRow[]>;\r\n  countGroups(plan: GroupsPlan, signal?: AbortSignal): Promise<unknown>;\r\n  where(plan: { where: Predicate }): TWhere;\r\n  orderBy(plan: RowsPlan): TOrder;\r\n};\r\n\r\nexport type QueryCallOptions<TContext = never> = { signal?: AbortSignal } & ([TContext] extends [never] ? { context?: undefined } : { context: TContext });\r\nexport type CallArgs<TContext> = [TContext] extends [never] ? [opts?: QueryCallOptions] : [opts: QueryCallOptions<TContext>];\r\n\r\n/** The answer `useDataGridServerRows` reads. */\r\nexport type RowsAnswer<TRow> = { rows: TRow[]; totalRowCount?: number | null; hasMore?: boolean };\r\nexport type ValuesAnswer = { values: { value: string; label?: string; count?: number }[] };\r\nexport type AggregatesAnswer = Record<string, number | string | null>;\r\nexport type GroupsAnswer = {\r\n  groups: { key: string | number | boolean | null; childCount: number; totalRowCount: number; aggregates?: Record<string, number | string | null> }[];\r\n  groupCount: number;\r\n  /** The top level: the row count of the whole result. */\r\n  totalRowCount?: number;\r\n};\r\n\r\nexport interface GridQuery<TRow, TContext = never, TWhere = unknown, TOrder = unknown> {\r\n  /** A request with `childKind: \"groups\"` answers a {@link GroupsAnswer}, every other request a {@link RowsAnswer}. */\r\n  fetchRows(input: unknown, ...opts: CallArgs<TContext>): Promise<RowsAnswer<TRow> | GroupsAnswer>;\r\n  filterValues(input: unknown, ...opts: CallArgs<TContext>): Promise<ValuesAnswer>;\r\n  aggregates(input: unknown, ...opts: CallArgs<TContext>): Promise<AggregatesAnswer>;\r\n  parse(input: unknown, ...opts: CallArgs<TContext>): RowsPlan;\r\n  /** The filter of a plan from `parse`, with `rowScope` applied, in the ORM's own type. */\r\n  where(plan: RowsPlan): TWhere;\r\n  /** The order of a plan from `parse`, in the ORM's own type. */\r\n  orderBy(plan: RowsPlan): TOrder;\r\n  capabilities: AdapterCapabilities;\r\n}\r\n\r\nexport type CreateGridQueryOptions<TContext, TWhere, TOrder> = {\r\n  columns: ColumnMap;\r\n  executor: QueryExecutor<TWhere, TOrder>;\r\n  /** Equalities on mapped columns that every query ANDs in. Needs `context` on every call. */\r\n  rowScope?: RowScope<TContext>;\r\n  /** When a rows request also counts the result. Default `\"firstBlock\"`. */\r\n  rowCount?: RowCountMode;\r\n  limits?: QueryLimits;\r\n  /** IANA zone or fixed offset of day filters on `time` columns. Default `\"UTC\"`. */\r\n  timeZone?: string;\r\n};\r\n\r\nfunction clone<T>(value: T): T {\r\n  if (Array.isArray(value)) return value.map(clone) as T;\r\n  if (typeof value === \"object\" && value !== null) {\r\n    if (isColumn(value)) return value;\r\n    const out: Record<string, unknown> = {};\r\n    for (const key of Object.keys(value)) out[key] = clone((value as Record<string, unknown>)[key]);\r\n    return out as T;\r\n  }\r\n  return value;\r\n}\r\n\r\nfunction isColumn(value: object): boolean {\r\n  return \"operators\" in value && \"serverOnly\" in value;\r\n}\r\n\r\nfunction deepFreeze<T>(value: T): T {\r\n  if (typeof value === \"object\" && value !== null && !Object.isFrozen(value)) {\r\n    Object.freeze(value);\r\n    for (const key of Object.keys(value)) deepFreeze((value as Record<string, unknown>)[key]);\r\n  }\r\n  return value;\r\n}\r\n\r\nfunction countOf(raw: unknown): number | null {\r\n  const n = typeof raw === \"bigint\" ? Number(raw) : typeof raw === \"string\" ? Number(raw) : raw;\r\n  return typeof n === \"number\" && Number.isSafeInteger(n) && n >= 0 ? Math.min(n, MAX_TOTAL_ROW_COUNT) : null;\r\n}\r\n\r\nfunction valueText(value: unknown): string {\r\n  if (value === null || value === undefined) return \"\";\r\n  return typeof value === \"string\" ? value : toSafeText(value);\r\n}\r\n\r\n/**\r\n * Builds the query methods of one table over an executor. Adapters call this; consumers call the adapter's factory.\r\n * The methods are own arrow properties, so `usersQuery.fetchRows` passes unbound.\r\n */\r\nexport function createGridQuery<TRow = Record<string, unknown>, TContext = never, TWhere = unknown, TOrder = unknown>(\r\n  options: CreateGridQueryOptions<TContext, TWhere, TOrder>,\r\n): GridQuery<TRow, TContext, TWhere, TOrder> {\r\n  const { columns, executor, rowScope, rowCount, limits, timeZone } = options;\r\n  const map = mapOf(columns);\r\n  if (isDev() && !map.visible.some((column) => column.searchable)) {\r\n    console.warn(\"gridcn query layer: no column sets `searchable`, so quick search matches every row.\");\r\n  }\r\n  const internal = new WeakMap<object, RowsPlan>();\r\n  // The grid rejects a group key longer than 1,024 characters, so no limit above that lets one through.\r\n  const groupKeyCap = Math.min(resolveLimits(limits).maxGroupKeyLength, 1024);\r\n\r\n  const scoped = (callOptions: { context?: unknown } | undefined): Predicate | undefined => {\r\n    if (!rowScope) return undefined;\r\n    if (callOptions?.context === undefined) throw new Error(\"rowScope is set and the call has no `context`\");\r\n    return rowScopePredicate(columns, rowScope(callOptions.context as TContext));\r\n  };\r\n  const withScope = <P extends { where: Predicate }>(plan: P, callOptions: { context?: unknown } | undefined): P => {\r\n    const scope = scoped(callOptions);\r\n    return scope ? { ...plan, where: combine(\"and\", [plan.where, scope]) } : plan;\r\n  };\r\n  const parse = (input: unknown, callOptions?: { context?: unknown }): RowsPlan => {\r\n    const plan = deepFreeze(withScope(parseQuery(input, { columns, request: \"rows\", rowCount, limits, timeZone }), callOptions));\r\n    internal.set(plan, deepFreeze(clone(plan)));\r\n    return plan;\r\n  };\r\n  const trusted = (plan: RowsPlan): RowsPlan => {\r\n    const known = internal.get(plan);\r\n    if (!known) throw new Error(\"This plan was not made by this query's `parse`\");\r\n    return known;\r\n  };\r\n  const alive = (signal: AbortSignal | undefined): void => signal?.throwIfAborted();\r\n\r\n  const fetchGroups = async (plan: GroupsPlan, signal: AbortSignal | undefined): Promise<GroupsAnswer> => {\r\n    if (!executor.capabilities.groupBy) throw new QueryError(\"unsupported\", [\"spec\", \"groupBy\"]);\r\n    alive(signal);\r\n    const size = plan.rowRange.end - plan.rowRange.start;\r\n    const topLevelRows: RowsPlan = { kind: \"rows\", where: plan.where, orderBy: [], rowRange: plan.rowRange, runCount: true, projection: [] };\r\n    const [found, groupCount, rowCount] = await Promise.all([\r\n      executor.selectGroups(plan, { offset: plan.rowRange.start, limit: size, signal }),\r\n      executor.countGroups(plan, signal),\r\n      plan.countRows ? executor.countRows(topLevelRows, signal) : Promise.resolve(undefined),\r\n    ]);\r\n    const groups = found.slice(0, size).map((entry) => {\r\n      const count = countOf(entry.count) ?? 0;\r\n      const key = groupKeyValue(entry.key, plan.level);\r\n      if (typeof key === \"string\" && key.length > groupKeyCap) throw new QueryError(\"limit-exceeded\", [\"spec\", \"groupBy\", plan.level.id]);\r\n      const group: GroupsAnswer[\"groups\"][number] = { key, childCount: plan.nextLevel ? (countOf(entry.childCount) ?? 0) : count, totalRowCount: count };\r\n      if (plan.aggregates.length > 0) {\r\n        group.aggregates = {};\r\n        for (const { column, reducer } of plan.aggregates) group.aggregates[column.id] = aggregateValue(Object.hasOwn(entry.aggregates, column.id) ? entry.aggregates[column.id] : null, column, reducer);\r\n      }\r\n      return group;\r\n    });\r\n    const answer: GroupsAnswer = { groups, groupCount: countOf(groupCount) ?? 0 };\r\n    if (plan.countRows) answer.totalRowCount = countOf(rowCount) ?? 0;\r\n    return answer;\r\n  };\r\n\r\n  const fetchRows = async (input: unknown, callOptions?: { signal?: AbortSignal; context?: unknown }): Promise<RowsAnswer<TRow> | GroupsAnswer> => {\r\n    const planned = deepFreeze(withScope(parseQuery(input, { columns, request: \"page\", rowCount, limits, timeZone }), callOptions));\r\n    if (planned.kind === \"groups\") return fetchGroups(planned, callOptions?.signal);\r\n    const plan = planned;\r\n    alive(callOptions?.signal);\r\n    const size = plan.rowRange.end - plan.rowRange.start;\r\n    const [rows, count] = await Promise.all([\r\n      executor.selectRows(plan, { offset: plan.rowRange.start, limit: plan.runCount ? size : size + 1, signal: callOptions?.signal }),\r\n      plan.runCount ? executor.countRows(plan, callOptions?.signal) : Promise.resolve(undefined),\r\n    ]);\r\n    const page = rows.slice(0, size).map((row) => serializeRow(row, plan.projection) as TRow);\r\n    if (plan.runCount) return { rows: page, totalRowCount: countOf(count) };\r\n    return { rows: page, hasMore: rows.length > size };\r\n  };\r\n\r\n  const filterValues = async (input: unknown, callOptions?: { signal?: AbortSignal; context?: unknown }): Promise<ValuesAnswer> => {\r\n    const plan = withScope(parseQuery(input, { columns, request: \"values\", limits, timeZone }), callOptions);\r\n    alive(callOptions?.signal);\r\n    if (plan.column.time && !executor.capabilities.localDayGrouping && (timeZone ?? \"UTC\") !== \"UTC\") throw new QueryError(\"unsupported\", [\"columnId\"]);\r\n    const found = await executor.selectValues(plan, { limit: MAX_VALUES + 1, signal: callOptions?.signal });\r\n    const merged = new Map<string, number>();\r\n    for (const entry of found) {\r\n      const text = valueText(plan.column.time ? entry.value : serializeValue(entry.value, plan.column));\r\n      const count = countOf(entry.count) ?? 0;\r\n      if (text.length > MAX_VALUE_TEXT) continue;\r\n      merged.set(text, (merged.get(text) ?? 0) + count);\r\n    }\r\n    const values = [...merged].map(([value, count]) => ({ value, count })).sort((a, b) => b.count - a.count || (a.value < b.value ? -1 : a.value > b.value ? 1 : 0));\r\n    return { values: values.slice(0, MAX_VALUES) };\r\n  };\r\n\r\n  const aggregates = async (input: unknown, callOptions?: { signal?: AbortSignal; context?: unknown }): Promise<AggregatesAnswer> => {\r\n    const plan = withScope(parseQuery(input, { columns, request: \"aggregates\", limits, timeZone }), callOptions);\r\n    if (!executor.capabilities.aggregates) throw new QueryError(\"unsupported\", []);\r\n    if (plan.columns.length === 0) return {};\r\n    alive(callOptions?.signal);\r\n    const raw = await executor.aggregate(plan, callOptions?.signal);\r\n    const out: AggregatesAnswer = {};\r\n    for (const { column, reducer } of plan.columns) {\r\n      const value = Object.hasOwn(raw, column.id) ? raw[column.id] : null;\r\n      out[column.id] = aggregateValue(value, column, reducer);\r\n    }\r\n    return out;\r\n  };\r\n\r\n  return {\r\n    fetchRows,\r\n    filterValues,\r\n    aggregates,\r\n    parse,\r\n    where: (plan: RowsPlan) => executor.where(trusted(plan)),\r\n    orderBy: (plan: RowsPlan) => executor.orderBy(trusted(plan)),\r\n    capabilities: executor.capabilities,\r\n  } as unknown as GridQuery<TRow, TContext, TWhere, TOrder>;\r\n}\r\n\r\nfunction groupKeyValue(raw: unknown, column: PlanColumn): string | number | boolean | null {\r\n  const key = serializeValue(raw, column);\r\n  return key === \"\" || key === undefined ? null : (key as string | number | boolean | null);\r\n}\r\n\r\nfunction aggregateValue(raw: unknown, column: PlanColumn, reducer: string): number | string | null {\r\n  if (raw === null || raw === undefined) return reducer === \"count\" ? 0 : null;\r\n  if (reducer === \"count\") return countOf(raw) ?? 0;\r\n  if (reducer === \"avg\") {\r\n    const n = Number(raw);\r\n    return Number.isFinite(n) ? n : null;\r\n  }\r\n  const value = serializeValue(raw, column);\r\n  return typeof value === \"number\" || typeof value === \"string\" ? value : null;\r\n}\r\n\r\n/** Throws at creation when a column declares a custom operator that has no handler, or a handler names no declared operator. */\r\nexport function assertCustomOperatorHandlers(columns: ColumnMap, handlers: Readonly<Record<string, unknown>> | undefined): void {\r\n  const declared = new Set<string>();\r\n  for (const column of mapOf(columns).byId.values()) for (const id of column.operators.keys()) declared.add(id);\r\n  const given = new Map(Object.entries(handlers ?? {}));\r\n  for (const id of declared) if (!given.has(id)) throw new Error(`customOperators: no handler for the declared operator \"${id}\"`);\r\n  for (const id of given.keys()) if (!declared.has(id)) throw new Error(`customOperators: \"${id}\" is not declared on any column`);\r\n}\r\n\r\nexport type { Operand, Test };\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/create-grid-query.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/data-grid-server-query-sdk.ts",
      "content": "/** The adapter-facing surface of the query layer. ORM adapters import this barrel; consumers import `data-grid-server-query`. */\r\nexport { parseQuery, MAX_FILTER_DEPTH, type ParseQueryOptions } from \"./parse-query\";\r\nexport { createGridQuery, assertCustomOperatorHandlers, MAX_TOTAL_ROW_COUNT, type CreateGridQueryOptions, type QueryExecutor, type RawGroupRow } from \"./create-grid-query\";\r\nexport { mapOf, isBuiltInOperatorId, type PlanColumn } from \"./column-map\";\r\nexport { escapeLike, likePattern, LIKE_ESCAPE } from \"./like\";\r\nexport { instantText, serializeValue, serializeRow } from \"./serialize-row\";\r\nexport { toSafeText } from \"./safe-text\";\r\nexport { isDev } from \"./is-dev\";\r\nexport { defaultOperatorsFor } from \"./describe-filter-operators\";\r\nexport { rowScopePredicate } from \"./row-scope\";\r\nexport { resolveLimits, DEFAULT_LIMITS, type ResolvedLimits } from \"./limits\";\r\nexport { statusForCode } from \"./errors\";\r\nexport type { Operand, Test, Predicate, OrderTerm, RowsPlan, ValuesPlan, AggregatesPlan, GroupsPlan, QueryPlan, QueryRequestKind, PlanOf } from \"./plan\";\r\nexport { createSqlRenderer, type SqlAlgebra, type CustomHandler } from \"./render-sql\";\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/data-grid-server-query-sdk.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/data-grid-server-query.ts",
      "content": "export { defineColumnMap, type ColumnSpec, type ColumnMap, type ColumnMapOptions, type ColumnType, type ColumnKind, type NumericType, type DateStorage, type AggregateReducer, type NativeStringType, type ColumnOperator, type OperatorInput } from \"./column-map\";\nexport { describeFilterOperators, type ColumnMapDescriptor, type ColumnDescriptor } from \"./describe-filter-operators\";\nexport { withColumnMap } from \"./with-column-map\";\nexport { handleGridRequest, type HandleGridRequestOptions } from \"./handle-grid-request\";\nexport { QueryError, type QueryErrorCode } from \"./errors\";\nexport { parseImportRows, type ParseImportRowsOptions, type ParsedImportRows, type ImportRowRefusal, type ImportRefusalCode, IMPORT_REFUSAL_MESSAGES } from \"./parse-import-rows\";\nexport type { QueryLimits } from \"./limits\";\nexport type { RowCountMode } from \"./parse-query\";\nexport type { GridQuery, QueryCallOptions, RowsAnswer, ValuesAnswer, AggregatesAnswer, GroupsAnswer, AdapterCapabilities } from \"./create-grid-query\";\nexport type { RowScope } from \"./row-scope\";\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/data-grid-server-query.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/describe-filter-operators.ts",
      "content": "import { type ColumnMap, type ColumnOperator, mapOf } from \"./column-map\";\r\n\r\nexport type BuiltInOperatorName =\r\n  | \"contains\" | \"notContains\" | \"equals\" | \"notEquals\" | \"startsWith\" | \"endsWith\" | \"empty\" | \"notEmpty\"\r\n  | \"gt\" | \"gte\" | \"lt\" | \"lte\" | \"isBetween\" | \"isAnyOf\" | \"isNoneOf\";\r\n\r\n/** What the client may offer for one column. */\r\nexport type ColumnDescriptor = {\r\n  operators: (BuiltInOperatorName | ColumnOperator)[];\r\n  filterable: boolean;\r\n  sortable: boolean;\r\n};\r\n\r\n/** Serializable; the columns the client sees, by id. */\r\nexport type ColumnMapDescriptor = Record<string, ColumnDescriptor>;\r\n\r\nconst TEXT: readonly BuiltInOperatorName[] = [\"contains\", \"notContains\", \"equals\", \"notEquals\", \"startsWith\", \"endsWith\", \"empty\", \"notEmpty\"];\r\nconst COMPARISON: readonly BuiltInOperatorName[] = [\"gt\", \"gte\", \"lt\", \"lte\", \"isBetween\"];\r\nconst SET: readonly BuiltInOperatorName[] = [\"isAnyOf\", \"isNoneOf\"];\r\nconst TEXT_ONLY = new Set<string>([\"contains\", \"notContains\", \"startsWith\", \"endsWith\"]);\r\nconst ORDERING = new Set<string>(COMPARISON);\r\nconst CELL_TYPES = new Set([\"text\", \"url\", \"longText\", \"number\", \"checkbox\", \"select\", \"date\"]);\r\n\r\n/** The operator list the client defaults to for a cell-type name (`operatorsForColumnType`). */\r\nexport function defaultOperatorsFor(typeName: string): BuiltInOperatorName[] {\r\n  if (typeName === \"number\" || typeName === \"date\") return [...TEXT, ...COMPARISON, ...SET];\r\n  if (typeName === \"select\" || typeName === \"text\") return [...TEXT, ...SET];\r\n  return [...TEXT];\r\n}\r\n\r\n/**\r\n * Lists, for each column the client sees, the operators the server accepts. Pass an entry's `operators` as\r\n * `ColumnDef.filterOperators`, so the filter UI offers nothing the server refuses.\r\n */\r\nexport function describeFilterOperators(columns: ColumnMap): ColumnMapDescriptor {\r\n  const out: ColumnMapDescriptor = {};\r\n  for (const column of mapOf(columns).visible) {\r\n    const typeName = CELL_TYPES.has(column.type) ? column.type : column.kind;\r\n    const operators = defaultOperatorsFor(typeName).filter((operator) => {\r\n      if ((column.kind === \"number\" || column.kind === \"date\" || column.kind === \"checkbox\") && TEXT_ONLY.has(operator)) return false;\r\n      if ((column.kind === \"checkbox\" || column.kind === \"select\" || column.native !== undefined) && ORDERING.has(operator)) return false;\r\n      return true;\r\n    });\r\n    out[column.id] = { operators: [...operators, ...column.operators.values()], filterable: column.filterable, sortable: column.sortable };\r\n  }\r\n  return out;\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/describe-filter-operators.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/errors.ts",
      "content": "export type QueryErrorCode =\r\n  | \"invalid-request\"\r\n  | \"unknown-column\"\r\n  | \"unknown-operator\"\r\n  | \"operator-not-allowed\"\r\n  | \"invalid-value\"\r\n  | \"limit-exceeded\"\r\n  | \"unsupported\"\r\n  | \"unsupported-value\"\r\n  | \"offset-too-deep\"\r\n  | \"payload-too-large\";\r\n\r\n/** Thrown for a request the query layer refuses. `path` holds field names and indices, never request text. */\r\nexport class QueryError extends Error {\r\n  readonly code: QueryErrorCode;\r\n  readonly path: readonly (string | number)[];\r\n  constructor(code: QueryErrorCode, path: readonly (string | number)[] = []) {\r\n    super(`${code}${path.length > 0 ? ` at ${path.join(\".\")}` : \"\"}`);\r\n    this.name = \"QueryError\";\r\n    this.code = code;\r\n    this.path = path;\r\n  }\r\n}\r\n\r\n/** The HTTP status `handleGridRequest` answers for `code`. */\r\nexport function statusForCode(code: QueryErrorCode): number {\r\n  if (code === \"unsupported\") return 501;\r\n  if (code === \"payload-too-large\") return 413;\r\n  return 400;\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/errors.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/handle-grid-request.ts",
      "content": "import { QueryError, statusForCode } from \"./errors\";\r\n\r\nexport type HandleGridRequestOptions = {\r\n  /** Most body bytes read before `JSON.parse`. Default 524288. */\r\n  maxBodyBytes?: number;\r\n};\r\n\r\ntype CallArgs<TContext> = [TContext] extends [never] ? [opts?: { signal?: AbortSignal }] : [opts: { signal?: AbortSignal; context: TContext }];\r\n\r\nconst DEFAULT_MAX_BODY_BYTES = 512 * 1024;\r\n\r\nconst json = (status: number, body: unknown): Response => new Response(JSON.stringify(body), { status, headers: { \"content-type\": \"application/json\" } });\r\n\r\nasync function readBody(req: Request, maxBytes: number): Promise<string | null> {\r\n  const length = Number(req.headers.get(\"content-length\"));\r\n  if (Number.isFinite(length) && length > maxBytes) return null;\r\n  if (!req.body) return \"\";\r\n  const reader = req.body.getReader();\r\n  const chunks: Uint8Array[] = [];\r\n  let total = 0;\r\n  for (;;) {\r\n    const { done, value } = await reader.read();\r\n    if (done) break;\r\n    total += value.byteLength;\r\n    if (total > maxBytes) {\r\n      await reader.cancel();\r\n      return null;\r\n    }\r\n    chunks.push(value);\r\n  }\r\n  const bytes = new Uint8Array(total);\r\n  let offset = 0;\r\n  for (const chunk of chunks) {\r\n    bytes.set(chunk, offset);\r\n    offset += chunk.byteLength;\r\n  }\r\n  return new TextDecoder().decode(bytes);\r\n}\r\n\r\n/**\r\n * Reads the JSON body with a byte cap, runs a query method, and answers JSON. A {@link QueryError} becomes a 4xx with its\r\n * code and no value; every other error becomes a 500 with no message. `req.signal` reaches the query.\r\n *\r\n * @example\r\n * export const POST = (req: Request) => handleGridRequest(req, usersQuery.fetchRows);\r\n */\r\nexport async function handleGridRequest<TContext = never, TAnswer = unknown>(\r\n  req: Request,\r\n  run: (input: unknown, ...opts: CallArgs<TContext>) => Promise<TAnswer>,\r\n  ...opts: [TContext] extends [never] ? [opts?: HandleGridRequestOptions] : [opts: HandleGridRequestOptions & { context: TContext }]\r\n): Promise<Response> {\r\n  const options = (opts[0] ?? {}) as HandleGridRequestOptions & { context?: TContext };\r\n  try {\r\n    const text = await readBody(req, options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES);\r\n    if (text === null) return json(413, { error: \"payload-too-large\" });\r\n    let body: unknown;\r\n    try {\r\n      body = JSON.parse(text);\r\n    } catch {\r\n      return json(400, { error: \"invalid-request\" });\r\n    }\r\n    const callOptions = { signal: req.signal, ...(options.context === undefined ? {} : { context: options.context }) };\r\n    const answer = await (run as (input: unknown, opts: unknown) => Promise<TAnswer>)(body, callOptions);\r\n    return json(200, answer);\r\n  } catch (error) {\r\n    if (error instanceof QueryError) return json(statusForCode(error.code), { error: error.code, path: error.path });\r\n    return json(500, { error: \"server-error\" });\r\n  }\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/handle-grid-request.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/is-dev.ts",
      "content": "// file-local declaration, so the literal below typechecks in consumers without @types/node\r\ndeclare const process: { env: { NODE_ENV?: string } };\r\n\r\n/** True outside production builds. */\r\nexport function isDev(): boolean {\r\n  // Bundlers replace only the bare literal; the catch covers a build that skips it and has no `process`.\r\n  try {\r\n    return process.env.NODE_ENV !== \"production\";\r\n  } catch {\r\n    return true;\r\n  }\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/is-dev.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/like.ts",
      "content": "/** The ESCAPE character the Drizzle and Kysely renderers declare. */\r\nexport const LIKE_ESCAPE = \"!\";\r\n\r\n/** Escapes `%`, `_`, and the escape character, so `text` matches itself inside a LIKE pattern. */\r\nexport function escapeLike(text: string, escapeChar: string = LIKE_ESCAPE): string {\r\n  let out = \"\";\r\n  for (const char of text) out += char === \"%\" || char === \"_\" || char === escapeChar ? escapeChar + char : char;\r\n  return out;\r\n}\r\n\r\n/** A LIKE pattern that matches `text` by `mode`. */\r\nexport function likePattern(mode: \"contains\" | \"startsWith\" | \"endsWith\" | \"equals\", text: string, escapeChar: string = LIKE_ESCAPE): string {\r\n  const escaped = escapeLike(text, escapeChar);\r\n  if (mode === \"contains\") return `%${escaped}%`;\r\n  if (mode === \"startsWith\") return `${escaped}%`;\r\n  if (mode === \"endsWith\") return `%${escaped}`;\r\n  return escaped;\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/like.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/limits.ts",
      "content": "/** Bounds `parseQuery` enforces on every request before it walks the filter tree. Every field is optional. */\nexport type QueryLimits = {\n  /** Most nodes in the filter tree, groups included. Default 128. */\n  maxFilterNodes?: number;\n  /** Most filter rows in the tree. Default 64. */\n  maxFilterLeaves?: number;\n  /** Most sort keys. Default 64. */\n  maxSorts?: number;\n  /** Longest text of one filter value. Default 1000. */\n  maxValueLength?: number;\n  /** Longest number text. Default 40. */\n  maxNumberLength?: number;\n  /** Most entries of one `isAnyOf` or `isNoneOf` list. Default 1000. */\n  maxListLength?: number;\n  /** Most list entries in the whole tree. Default 5000. */\n  maxTreeListValues?: number;\n  /** Most UTF-8 bytes of string content in the whole tree. Default 262144. */\n  maxTreeStringBytes?: number;\n  /** Longest quick-search phrase. Default 500. */\n  maxSearchLength?: number;\n  /** Longest value-query text. Default 128. */\n  maxValueQueryLength?: number;\n  /** Most rows of one request. Default 1000. */\n  maxPageSize?: number;\n  /** Largest `start` a request may carry. Default: none. */\n  maxOffset?: number;\n  /** Most column ids of one aggregates request. Default 10000. */\n  maxColumnIds?: number;\n  /** Most rows `parseImportRows` reads from one import request. Default 10000. */\n  maxImportRows?: number;\n  /** Most group levels of one request. Default 4. */\n  maxGroupLevels?: number;\n  /** Longest group key of a `groupPath` entry. Default 1024. */\n  maxGroupKeyLength?: number;\n  /** Most aggregate columns of one grouped request. Default 32. */\n  maxGroupAggregates?: number;\n};\n\nexport const DEFAULT_LIMITS = {\n  maxFilterNodes: 128,\n  maxFilterLeaves: 64,\n  maxSorts: 64,\n  maxValueLength: 1000,\n  maxNumberLength: 40,\n  maxListLength: 1000,\n  maxTreeListValues: 5000,\n  maxTreeStringBytes: 262_144,\n  maxSearchLength: 500,\n  maxValueQueryLength: 128,\n  maxPageSize: 1000,\n  maxOffset: Number.MAX_SAFE_INTEGER,\n  maxColumnIds: 10_000,\n  maxImportRows: 10_000,\n  maxGroupLevels: 4,\n  maxGroupKeyLength: 1024,\n  maxGroupAggregates: 32,\n} satisfies Required<QueryLimits>;\n\nexport type ResolvedLimits = Readonly<Required<QueryLimits>>;\n\nexport function resolveLimits(limits: QueryLimits | undefined): ResolvedLimits {\n  const resolved: Required<QueryLimits> = { ...DEFAULT_LIMITS };\n  if (limits) {\n    for (const key of Object.keys(DEFAULT_LIMITS) as (keyof QueryLimits)[]) {\n      const wanted = limits[key];\n      if (wanted !== undefined && Number.isFinite(wanted) && wanted >= 0) resolved[key] = wanted;\n    }\n  }\n  return Object.freeze(resolved);\n}\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/limits.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/parse-import-rows.ts",
      "content": "import { mapOf, type ColumnMap, type PlanColumn } from \"./column-map\";\r\nimport { QueryError } from \"./errors\";\r\nimport { resolveLimits, type QueryLimits } from \"./limits\";\r\nimport { decimalToString, INT_RANGE, isIntType, parseBoolean, parseDate, parseDecimal, parseInstant, parseUuid } from \"./operands\";\r\n\r\n/** The English text of each refusal code; map the `code` of a refusal to your own language. */\r\nexport const IMPORT_REFUSAL_MESSAGES = {\r\n  \"not-a-number\": \"Not a number\",\r\n  \"not-a-whole-number\": \"Not a whole number\",\r\n  \"out-of-range\": \"Out of range\",\r\n  \"too-many-decimals\": \"Too many decimal places\",\r\n  \"not-text\": \"Not text\",\r\n  \"too-long\": \"Too long\",\r\n  \"not-an-id\": \"Not a valid id\",\r\n  \"not-a-choice\": \"Not an allowed choice\",\r\n  \"not-a-date\": \"Not a date\",\r\n  \"not-a-boolean\": \"Not true or false\",\r\n  required: \"Required\",\r\n} as const;\r\n\r\nexport type ImportRefusalCode = keyof typeof IMPORT_REFUSAL_MESSAGES;\r\n\r\n/** One refusal of {@link parseImportRows}; `rowIndex` is the 0-based index into the request's `rows`, `code` names the reason. */\r\nexport type ImportRowRefusal = { rowIndex: number; columnId?: string; code?: ImportRefusalCode; message?: string };\r\n\r\n/** Options for {@link parseImportRows}. */\r\nexport type ParseImportRowsOptions = {\r\n  /** The column map that names the keys a row may carry. */\r\n  columns: ColumnMap;\r\n  /** Bounds; `maxImportRows`, `maxValueLength`, and `maxNumberLength` apply. */\r\n  limits?: QueryLimits;\r\n};\r\n\r\n/** The parsed import request. `rows` holds the rows without a refusal; `rejected` lists the others, one entry per refused cell. */\r\nexport type ParsedImportRows = { rows: Record<string, unknown>[]; rejected: ImportRowRefusal[] };\r\n\r\ntype Raw = Record<string, unknown>;\r\ntype Limits = ReturnType<typeof resolveLimits>;\r\ntype Cell = { ok: true; value: unknown } | { ok: false; code: ImportRefusalCode; message: string };\r\n\r\nconst isRecord = (value: unknown): value is Raw => typeof value === \"object\" && value !== null && !Array.isArray(value);\r\nconst ok = (value: unknown): Cell => ({ ok: true, value });\r\nconst refuse = (code: ImportRefusalCode): Cell => ({ ok: false, code, message: IMPORT_REFUSAL_MESSAGES[code] });\r\nconst isBlank = (value: unknown): boolean => value === null || value === undefined;\r\n\r\nfunction numberCell(column: PlanColumn, value: unknown, limits: Limits, path: (string | number)[]): Cell {\r\n  if (typeof value === \"number\" && !Number.isFinite(value)) return refuse(\"not-a-number\");\r\n  const text = typeof value === \"number\" ? String(value) : value;\r\n  if (typeof text !== \"string\") return refuse(\"not-a-number\");\r\n  if (text.length > limits.maxNumberLength) throw new QueryError(\"limit-exceeded\", path);\r\n  const decimal = parseDecimal(text.trim());\r\n  if (!decimal) return refuse(\"not-a-number\");\r\n  const canonical = decimalToString(decimal);\r\n  if (isIntType(column.numeric)) {\r\n    if (canonical.includes(\".\")) return refuse(\"not-a-whole-number\");\r\n    const whole = BigInt(canonical);\r\n    const [low, high] = INT_RANGE[column.numeric];\r\n    if (whole < low || whole > high) return refuse(\"out-of-range\");\r\n    return ok(typeof value === \"number\" && Number.isSafeInteger(value) ? value : canonical);\r\n  }\r\n  if (column.numeric === \"decimal\") {\r\n    if (column.scale !== undefined && (canonical.split(\".\")[1]?.length ?? 0) > column.scale) return refuse(\"too-many-decimals\");\r\n    return ok(canonical);\r\n  }\r\n  const float = Number(canonical);\r\n  return Number.isFinite(float) ? ok(float) : refuse(\"out-of-range\");\r\n}\r\n\r\nfunction textCell(column: PlanColumn, value: unknown, limits: Limits, path: (string | number)[]): Cell {\r\n  if (typeof value !== \"string\") return refuse(\"not-text\");\r\n  if (value.length > limits.maxValueLength) throw new QueryError(\"limit-exceeded\", path);\r\n  if (column.maxLength !== undefined && value.length > column.maxLength) return refuse(\"too-long\");\r\n  if (column.native === \"uuid\") {\r\n    const uuid = parseUuid(value);\r\n    return uuid === null ? refuse(\"not-an-id\") : ok(uuid);\r\n  }\r\n  if (column.native === \"enum\" || (column.kind === \"select\" && column.choices)) {\r\n    const choice = column.choices?.find((candidate) => candidate === value) ?? (column.native === \"enum\" ? column.choices?.find((candidate) => candidate.toLowerCase() === value.toLowerCase()) : undefined);\r\n    return choice === undefined ? refuse(\"not-a-choice\") : ok(choice);\r\n  }\r\n  return ok(value);\r\n}\r\n\r\nfunction dateCell(column: PlanColumn, value: unknown, limits: Limits, path: (string | number)[]): Cell {\r\n  if (typeof value !== \"string\") return refuse(\"not-a-date\");\r\n  if (value.length > limits.maxValueLength) throw new QueryError(\"limit-exceeded\", path);\r\n  const parsed = column.time ? parseInstant(value) : parseDate(value);\r\n  return parsed === null ? refuse(\"not-a-date\") : ok(parsed);\r\n}\r\n\r\nfunction checkboxCell(value: unknown): Cell {\r\n  if (typeof value === \"boolean\") return ok(value);\r\n  const parsed = typeof value === \"string\" ? parseBoolean(value) : null;\r\n  return parsed === null ? refuse(\"not-a-boolean\") : ok(parsed);\r\n}\r\n\r\nfunction readCell(column: PlanColumn, value: unknown, limits: Limits, path: (string | number)[]): Cell {\r\n  const blank = isBlank(value) || (typeof value === \"string\" && value === \"\" && column.kind !== \"checkbox\" && !column.keepBlankText);\r\n  if (blank) return column.required ? refuse(\"required\") : ok(null);\r\n  switch (column.kind) {\r\n    case \"number\":\r\n      return numberCell(column, value, limits, path);\r\n    case \"checkbox\":\r\n      return checkboxCell(value);\r\n    case \"date\":\r\n      return dateCell(column, value, limits, path);\r\n    default:\r\n      return textCell(column, value, limits, path);\r\n  }\r\n}\r\n\r\n/**\r\n * Reads the body of an import request, `{ rows: Record<string, unknown>[] }`, against the column map.\r\n * The bounds apply before any value is read: `maxImportRows` rows, only mapped columns that are not `serverOnly`,\r\n * values within `maxValueLength` and `maxNumberLength`. A request outside the bounds throws a `QueryError`.\r\n * A value that does not fit its column kind is a refusal, not an error: the row stays out of `rows` and `rejected` names the cell.\r\n */\r\nexport function parseImportRows(input: unknown, options: ParseImportRowsOptions): ParsedImportRows {\r\n  const limits = resolveLimits(options.limits);\r\n  const { byId } = mapOf(options.columns);\r\n  if (!isRecord(input) || !Array.isArray(input[\"rows\"])) throw new QueryError(\"invalid-request\", [\"rows\"]);\r\n  const source: unknown[] = input[\"rows\"];\r\n  if (source.length > limits.maxImportRows) throw new QueryError(\"limit-exceeded\", [\"rows\"]);\r\n  const rows: Raw[] = [];\r\n  const rejected: ImportRowRefusal[] = [];\r\n  for (let rowIndex = 0; rowIndex < source.length; rowIndex++) {\r\n    const row = source[rowIndex];\r\n    if (!isRecord(row)) throw new QueryError(\"invalid-request\", [\"rows\", rowIndex]);\r\n    const parsed: Raw = {};\r\n    let refused = false;\r\n    for (const key of Object.keys(row)) {\r\n      const column = byId.get(key);\r\n      if (!column || column.serverOnly) throw new QueryError(\"unknown-column\", [\"rows\", rowIndex, key]);\r\n      const cell = readCell(column, row[key], limits, [\"rows\", rowIndex, key]);\r\n      if (cell.ok) parsed[key] = cell.value;\r\n      else {\r\n        refused = true;\r\n        rejected.push({ rowIndex, columnId: key, code: cell.code, message: cell.message });\r\n      }\r\n    }\r\n    for (const column of byId.values()) {\r\n      if (!column.required || column.serverOnly || column.primaryKey || Object.hasOwn(row, column.id)) continue;\r\n      refused = true;\r\n      rejected.push({ rowIndex, columnId: column.id, code: \"required\", message: IMPORT_REFUSAL_MESSAGES.required });\r\n    }\r\n    if (!refused) rows.push(parsed);\r\n  }\r\n  return { rows, rejected };\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/parse-import-rows.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/operands.ts",
      "content": "import type { NumericType } from \"./column-map\";\r\n\r\n/** A filter value after parsing. Numbers are exact: ints are `bigint`, others are canonical decimal strings. */\r\nexport type Operand =\r\n  | { kind: \"text\"; v: string }\r\n  | { kind: \"number\"; v: string }\r\n  | { kind: \"bigint\"; v: bigint }\r\n  | { kind: \"boolean\"; v: boolean }\r\n  | { kind: \"date\"; v: string }\r\n  | { kind: \"instant\"; v: string };\r\n\r\n/** A decimal value: `(neg ? -1 : 1) * coef / 10 ** scale`. */\r\nexport type Decimal = { neg: boolean; coef: bigint; scale: number };\r\n\r\n// HTML \"valid floating-point number\", anchored; the exponent is at most 4 digits.\r\nconst NUMBER_GRAMMAR = /^-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:[eE][-+]?\\d{1,4})?$/;\r\n\r\nexport function parseDecimal(text: string): Decimal | null {\r\n  if (!NUMBER_GRAMMAR.test(text)) return null;\r\n  const match = /^(-?)(\\d*)(?:\\.(\\d*))?(?:[eE]([-+]?\\d+))?$/.exec(text);\r\n  if (!match) return null;\r\n  const [, sign = \"\", whole = \"\", fraction = \"\", exponent = \"0\"] = match;\r\n  const coef = BigInt(`${whole}${fraction}` || \"0\");\r\n  return { neg: sign === \"-\" && coef !== ZERO, coef, scale: fraction.length - Number(exponent) };\r\n}\r\n\r\n// BigInt literals and `**` need ES2020 targets; consumer apps may compile lower.\r\nconst ZERO = BigInt(0);\r\nconst ONE = BigInt(1);\r\n\r\nfunction bigPow(base: bigint, exponent: number): bigint {\r\n  let result = ONE;\r\n  let square = base;\r\n  for (let rest = exponent; rest > 0; rest = Math.floor(rest / 2)) {\r\n    if (rest % 2 === 1) result *= square;\r\n    square *= square;\r\n  }\r\n  return result;\r\n}\r\n\r\nfunction pow10(exponent: number): bigint {\r\n  return bigPow(BigInt(10), exponent);\r\n}\r\n\r\nexport function decimalToString(value: Decimal): string {\r\n  const sign = value.neg ? \"-\" : \"\";\r\n  if (value.coef === ZERO) return \"0\";\r\n  if (value.scale <= 0) return `${sign}${(value.coef * pow10(-value.scale)).toString()}`;\r\n  const digits = value.coef.toString().padStart(value.scale + 1, \"0\");\r\n  const whole = digits.slice(0, digits.length - value.scale);\r\n  const fraction = digits.slice(digits.length - value.scale).replace(/0+$/, \"\");\r\n  return `${sign}${whole}${fraction === \"\" ? \"\" : `.${fraction}`}`;\r\n}\r\n\r\n/** Whole part and whether there was a fraction. */\r\nfunction split(value: Decimal): { whole: bigint; exact: boolean } {\r\n  if (value.scale <= 0) return { whole: (value.neg ? -ONE : ONE) * value.coef * pow10(-value.scale), exact: true };\r\n  const divisor = pow10(value.scale);\r\n  const quotient = value.coef / divisor;\r\n  return { whole: value.neg ? -quotient : quotient, exact: value.coef % divisor === ZERO };\r\n}\r\n\r\nexport function isInteger(value: Decimal): boolean {\r\n  return split(value).exact;\r\n}\r\n\r\nexport function floorDecimal(value: Decimal): bigint {\r\n  const { whole, exact } = split(value);\r\n  return !exact && value.neg ? whole - ONE : whole;\r\n}\r\n\r\nexport function ceilDecimal(value: Decimal): bigint {\r\n  const { whole, exact } = split(value);\r\n  return !exact && !value.neg ? whole + ONE : whole;\r\n}\r\n\r\nexport const INT_RANGE: Readonly<Record<\"int2\" | \"int4\" | \"int8\", readonly [bigint, bigint]>> = {\r\n  int2: [-bigPow(BigInt(2), 15), bigPow(BigInt(2), 15) - ONE],\r\n  int4: [-bigPow(BigInt(2), 31), bigPow(BigInt(2), 31) - ONE],\r\n  int8: [-bigPow(BigInt(2), 63), bigPow(BigInt(2), 63) - ONE],\r\n};\r\n\r\nexport function isIntType(numeric: NumericType | undefined): numeric is \"int2\" | \"int4\" | \"int8\" {\r\n  return numeric === \"int2\" || numeric === \"int4\" || numeric === \"int8\";\r\n}\r\n\r\n/** A finite JS number from a float bound; a non-finite result clamps by sign. */\r\nexport function clampFloat(text: string): number {\r\n  const n = Number(text);\r\n  if (Number.isFinite(n)) return n;\r\n  return n < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;\r\n}\r\n\r\nexport function parseBoolean(text: string): boolean | null {\r\n  const lower = text.trim().toLowerCase();\r\n  if (lower === \"true\" || lower === \"1\") return true;\r\n  if (lower === \"false\" || lower === \"0\") return false;\r\n  return null;\r\n}\r\n\r\nconst DATE_GRAMMAR = /^(\\d{4})-(\\d{2})-(\\d{2})$/;\r\n\r\n/** A real calendar date `YYYY-MM-DD`, else `null`. */\r\nexport function parseDate(text: string): string | null {\r\n  const match = DATE_GRAMMAR.exec(text);\r\n  if (!match) return null;\r\n  const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];\r\n  const date = new Date(0);\r\n  date.setUTCFullYear(year, month - 1, day);\r\n  const valid = date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;\r\n  return valid ? text : null;\r\n}\r\n\r\nconst INSTANT_GRAMMAR = /^(\\d{4}-\\d{2}-\\d{2})[T ](\\d{2}):(\\d{2})(?::(\\d{2})(?:\\.(\\d{1,9}))?)?(Z|[-+]\\d{2}(?::?\\d{2})?)$/i;\r\n\r\n/** An ISO instant with an explicit offset as a canonical `toISOString` text, else `null`. */\r\nexport function parseInstant(text: string): string | null {\r\n  const match = INSTANT_GRAMMAR.exec(text);\r\n  if (!match || parseDate(match[1]!) === null) return null;\r\n  const [, day, hour, minute, second = \"00\", fraction = \"0\", zone = \"Z\"] = match;\r\n  if (Number(hour) > 23 || Number(minute) > 59 || Number(second) > 59) return null;\r\n  let offset = \"Z\";\r\n  if (zone.toUpperCase() !== \"Z\") {\r\n    const digits = zone.slice(1).replace(\":\", \"\");\r\n    const hours = digits.slice(0, 2);\r\n    const minutes = digits.slice(2) || \"00\";\r\n    if (Number(hours) > 23 || Number(minutes) > 59) return null;\r\n    offset = `${zone[0]}${hours}:${minutes}`;\r\n  }\r\n  const time = Date.parse(`${day}T${hour}:${minute}:${second}.${fraction.padEnd(3, \"0\").slice(0, 3)}${offset}`);\r\n  return Number.isNaN(time) ? null : new Date(time).toISOString();\r\n}\r\n\r\nconst UUID_GRAMMAR = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\r\n\r\nexport function parseUuid(text: string): string | null {\r\n  return UUID_GRAMMAR.test(text) ? text.toLowerCase() : null;\r\n}\r\n\r\nconst zoneFormats = new Map<string, Intl.DateTimeFormat>();\r\n\r\nfunction zoneFormat(timeZone: string): Intl.DateTimeFormat {\r\n  let format = zoneFormats.get(timeZone);\r\n  if (!format) {\r\n    format = new Intl.DateTimeFormat(\"en-US\", { timeZone, hourCycle: \"h23\", year: \"numeric\", month: \"2-digit\", day: \"2-digit\", hour: \"2-digit\", minute: \"2-digit\", second: \"2-digit\" });\r\n    zoneFormats.set(timeZone, format);\r\n  }\r\n  return format;\r\n}\r\n\r\n/** Throws a `RangeError` when `timeZone` is not an IANA zone or a fixed offset. */\r\nexport function assertTimeZone(timeZone: string): void {\r\n  zoneFormat(timeZone);\r\n}\r\n\r\nfunction localParts(instant: number, timeZone: string): { day: string; wall: number } {\r\n  const parts: Record<string, string> = {};\r\n  for (const part of zoneFormat(timeZone).formatToParts(new Date(instant))) parts[part.type] = part.value;\r\n  const year = parts[\"year\"]!.padStart(4, \"0\");\r\n  const wall = Date.UTC(Number(parts[\"year\"]), Number(parts[\"month\"]) - 1, Number(parts[\"day\"]), Number(parts[\"hour\"]), Number(parts[\"minute\"]), Number(parts[\"second\"]));\r\n  return { day: `${year}-${parts[\"month\"]}-${parts[\"day\"]}`, wall };\r\n}\r\n\r\nfunction offsetAt(instant: number, timeZone: string): number {\r\n  return localParts(instant, timeZone).wall - Math.floor(instant / 1000) * 1000;\r\n}\r\n\r\nconst DAY_MS = 86_400_000;\r\n\r\n/** The first instant of the local day `day` (`YYYY-MM-DD`) in `timeZone`; a DST gap at midnight starts the day at the transition. */\r\nexport function startOfLocalDay(day: string, timeZone: string): string {\r\n  const [year, month, date] = day.split(\"-\").map(Number) as [number, number, number];\r\n  const guess = new Date(0).setUTCFullYear(year, month - 1, date);\r\n  const candidates = [-DAY_MS, 0, DAY_MS].map((shift) => guess - offsetAt(guess + shift, timeZone));\r\n  const onDay = candidates.filter((instant) => localParts(instant, timeZone).day === day);\r\n  const pool = onDay.length > 0 ? onDay : candidates;\r\n  const first = pool.reduce((a, b) => (a < b ? a : b));\r\n  return new Date(first).toISOString();\r\n}\r\n\r\n/** The calendar day after `day`. */\r\nexport function nextDay(day: string): string {\r\n  const [year, month, date] = day.split(\"-\").map(Number) as [number, number, number];\r\n  const next = new Date(0);\r\n  next.setUTCFullYear(year, month - 1, date + 1);\r\n  return next.toISOString().slice(0, 10);\r\n}\r\n\r\n/** The local day of an instant in `timeZone`, as `YYYY-MM-DD`. */\r\nexport function localDayOf(instantIso: string, timeZone: string): string {\r\n  return localParts(Date.parse(instantIso), timeZone).day;\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/operands.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/parse-query.ts",
      "content": "import { type ColumnMap, type PlanColumn, isBuiltInOperatorId, mapOf } from \"./column-map\";\r\nimport { QueryError } from \"./errors\";\r\nimport { type QueryLimits, type ResolvedLimits, resolveLimits } from \"./limits\";\r\nimport {\r\n  type Decimal,\r\n  INT_RANGE,\r\n  assertTimeZone,\r\n  ceilDecimal,\r\n  clampFloat,\r\n  decimalToString,\r\n  floorDecimal,\r\n  isInteger,\r\n  isIntType,\r\n  nextDay,\r\n  parseBoolean,\r\n  parseDate,\r\n  parseDecimal,\r\n  parseInstant,\r\n  parseUuid,\r\n  startOfLocalDay,\r\n} from \"./operands\";\r\nimport { type AggregatesPlan, FALSE, type GroupsPlan, type Operand, type OrderTerm, type PlanOf, type Predicate, type QueryRequestKind, type RowsPlan, TRUE, type ValuesPlan, combine, leaf, negate } from \"./plan\";\r\n\r\n/** How often a rows request also counts the result: the first scroll block (default), every request, or never. */\r\nexport type RowCountMode = \"firstBlock\" | \"always\" | \"none\";\r\n\r\nexport type ParseQueryOptions<R extends QueryRequestKind> = {\r\n  columns: ColumnMap;\r\n  request: R;\r\n  rowCount?: RowCountMode;\r\n  limits?: QueryLimits;\r\n  /** IANA zone or fixed offset of day filters on `time` columns. Default `\"UTC\"`. */\r\n  timeZone?: string;\r\n};\r\n\r\n/** The deepest group nesting the client keeps. */\r\nexport const MAX_FILTER_DEPTH = 2;\r\n\r\ntype Budget = { nodes: number; leaves: number; listValues: number; bytes: number };\r\ntype Ctx = { map: ReturnType<typeof mapOf>; limits: ResolvedLimits; timeZone: string; budget: Budget };\r\ntype Path = readonly (string | number)[];\r\ntype Raw = Record<string, unknown>;\r\n\r\nconst isRecord = (value: unknown): value is Raw => typeof value === \"object\" && value !== null && !Array.isArray(value);\r\nconst encoder = new TextEncoder();\r\n\r\nfunction charge(ctx: Ctx, text: string, path: Path, max = ctx.limits.maxValueLength): void {\r\n  if (text.length > max) throw new QueryError(\"invalid-value\", path);\r\n  ctx.budget.bytes += encoder.encode(text).length;\r\n  if (ctx.budget.bytes > ctx.limits.maxTreeStringBytes) throw new QueryError(\"limit-exceeded\", path);\r\n}\r\n\r\n/**\r\n * Turns an untrusted request into a bounded, typed plan, or throws {@link QueryError}. `request` selects the shape:\r\n * `rows` reads `{ spec, start, end, page?, pageSize? }`, `values` reads `{ columnId, query, filters }`,\r\n * `aggregates` reads `{ spec, columnIds? }`. The plan holds no `rowScope`; the factory adds it.\r\n */\r\nexport function parseQuery<R extends QueryRequestKind>(input: unknown, options: ParseQueryOptions<R>): PlanOf<R> {\r\n  const timeZone = options.timeZone ?? \"UTC\";\r\n  assertTimeZone(timeZone);\r\n  const ctx: Ctx = { map: mapOf(options.columns), limits: resolveLimits(options.limits), timeZone, budget: { nodes: 0, leaves: 0, listValues: 0, bytes: 0 } };\r\n  if (!isRecord(input)) throw new QueryError(\"invalid-request\", []);\r\n  let plan: RowsPlan | GroupsPlan | ValuesPlan | AggregatesPlan;\r\n  if (options.request === \"rows\" || options.request === \"page\") plan = parseRows(input, ctx, options.rowCount ?? \"firstBlock\", options.request === \"page\");\r\n  else if (options.request === \"values\") plan = parseValues(input, ctx);\r\n  else plan = parseAggregates(input, ctx);\r\n  return plan as PlanOf<R>;\r\n}\r\n\r\nfunction specOf(input: Raw): Raw {\r\n  const spec = input[\"spec\"];\r\n  if (spec === undefined || spec === null) return {};\r\n  if (!isRecord(spec)) throw new QueryError(\"invalid-request\", [\"spec\"]);\r\n  return spec;\r\n}\r\n\r\nfunction rejectPivot(spec: Raw): void {\r\n  const pivot = spec[\"pivot\"];\r\n  const filled = Array.isArray(pivot) ? pivot.length > 0 : pivot !== undefined && pivot !== null && !(isRecord(pivot) && Object.keys(pivot).length === 0);\r\n  if (filled) throw new QueryError(\"unsupported\", [\"spec\"]);\r\n}\r\n\r\ntype GroupRequest = { levels: PlanColumn[]; path: Predicate[]; childKind: \"groups\" | \"rows\"; aggregates: GroupsPlan[\"aggregates\"] };\r\n\r\nconst isAbsent = (value: unknown): boolean => value === undefined || value === null;\r\n\r\nfunction parseGroupRequest(input: Raw, spec: Raw, ctx: Ctx): GroupRequest | null {\r\n  const by = spec[\"groupBy\"];\r\n  const rawPath = input[\"groupPath\"];\r\n  if (isAbsent(by) || (Array.isArray(by) && by.length === 0)) {\r\n    if (Array.isArray(rawPath) ? rawPath.length > 0 : !isAbsent(rawPath)) throw new QueryError(\"invalid-request\", [\"groupPath\"]);\r\n    if (!isAbsent(input[\"childKind\"])) throw new QueryError(\"invalid-request\", [\"childKind\"]);\r\n    return null;\r\n  }\r\n  if (!Array.isArray(by)) throw new QueryError(\"invalid-request\", [\"spec\", \"groupBy\"]);\r\n  if (by.length > ctx.limits.maxGroupLevels) throw new QueryError(\"limit-exceeded\", [\"spec\", \"groupBy\"]);\r\n  const levels: PlanColumn[] = [];\r\n  by.forEach((id: unknown, index) => {\r\n    const path = [\"spec\", \"groupBy\", index] as const;\r\n    const column = typeof id === \"string\" ? ctx.map.byId.get(id) : undefined;\r\n    if (!column || column.serverOnly || !column.sortable) throw new QueryError(\"unknown-column\", path);\r\n    if (levels.includes(column)) throw new QueryError(\"invalid-request\", path);\r\n    if (column.keepBlankText) throw new QueryError(\"unsupported\", path);\r\n    levels.push(column);\r\n  });\r\n  const segments: unknown = isAbsent(rawPath) ? [] : rawPath;\r\n  if (!Array.isArray(segments) || segments.length > levels.length) throw new QueryError(\"invalid-request\", [\"groupPath\"]);\r\n  const path = segments.map((segment: unknown, index) => {\r\n    const at = [\"groupPath\", index] as const;\r\n    if (!isRecord(segment) || segment[\"columnId\"] !== levels[index]!.id) throw new QueryError(\"invalid-request\", [...at, \"columnId\"]);\r\n    return groupEquality(levels[index]!, segment[\"key\"], [...at, \"key\"], ctx);\r\n  });\r\n  const childKind = segments.length < levels.length ? \"groups\" : \"rows\";\r\n  if (!isAbsent(input[\"childKind\"]) && input[\"childKind\"] !== childKind) throw new QueryError(\"invalid-request\", [\"childKind\"]);\r\n  return { levels, path, childKind, aggregates: parseGroupAggregates(spec[\"aggregates\"], ctx) };\r\n}\r\n\r\nfunction parseGroupAggregates(value: unknown, ctx: Ctx): GroupsPlan[\"aggregates\"] {\r\n  if (isAbsent(value)) return [];\r\n  if (!Array.isArray(value)) throw new QueryError(\"invalid-request\", [\"spec\", \"aggregates\"]);\r\n  if (value.length > ctx.limits.maxGroupAggregates) throw new QueryError(\"limit-exceeded\", [\"spec\", \"aggregates\"]);\r\n  const seen = new Set<PlanColumn>();\r\n  return value.map((entry: unknown, index) => {\r\n    const path = [\"spec\", \"aggregates\", index] as const;\r\n    if (!isRecord(entry)) throw new QueryError(\"invalid-request\", path);\r\n    const column = typeof entry[\"columnId\"] === \"string\" ? ctx.map.byId.get(entry[\"columnId\"]) : undefined;\r\n    if (!column || column.serverOnly) throw new QueryError(\"unknown-column\", [...path, \"columnId\"]);\r\n    if (column.aggregate === undefined || entry[\"reducer\"] !== column.aggregate || seen.has(column)) throw new QueryError(\"invalid-request\", path);\r\n    seen.add(column);\r\n    return { column, reducer: column.aggregate };\r\n  });\r\n}\r\n\r\n/** The test that keeps the rows of one group: the key is the stored value, `null` and `\"\"` the empty group. */\r\nfunction groupEquality(column: PlanColumn, key: unknown, path: Path, ctx: Ctx): Predicate {\r\n  if (key === null || key === \"\") return blank(column, false);\r\n  if (typeof key === \"string\") charge(ctx, key, path, ctx.limits.maxGroupKeyLength);\r\n  const equal = (value: Operand): Predicate => leaf(column, { k: \"eq\", value });\r\n  switch (column.kind) {\r\n    case \"checkbox\":\r\n      if (typeof key !== \"boolean\") throw new QueryError(\"invalid-value\", path);\r\n      return equal({ kind: \"boolean\", v: key });\r\n    case \"number\": {\r\n      if (typeof key !== \"number\" && typeof key !== \"string\") throw new QueryError(\"invalid-value\", path);\r\n      const parsed = numberText(String(key), path, ctx);\r\n      const operand = parsed ? numberOperand(column, parsed) : null;\r\n      return operand ? equal(operand) : FALSE;\r\n    }\r\n    case \"date\": {\r\n      if (typeof key !== \"string\") throw new QueryError(\"invalid-value\", path);\r\n      const v = column.time ? parseInstant(key.trim()) : parseDate(key.trim());\r\n      return v === null ? FALSE : equal({ kind: column.time ? \"instant\" : \"date\", v });\r\n    }\r\n    default: {\r\n      if (typeof key !== \"string\") throw new QueryError(\"invalid-value\", path);\r\n      const v = nativeText(column, key);\r\n      return v === null ? FALSE : equal({ kind: \"text\", v });\r\n    }\r\n  }\r\n}\r\n\r\nfunction parseWhere(spec: Raw, ctx: Ctx): Predicate {\r\n  const filters = parseFilters(spec[\"filters\"], ctx, spec[\"filterJoin\"] === \"or\" ? \"or\" : \"and\");\r\n  const search = parseSearch(spec[\"searchText\"], ctx);\r\n  return combine(\"and\", [filters, search]);\r\n}\r\n\r\nfunction parseRows(input: Raw, ctx: Ctx, rowCount: RowCountMode, allowGroups: boolean): RowsPlan | GroupsPlan {\r\n  const spec = specOf(input);\r\n  rejectPivot(spec);\r\n  const grouping = parseGroupRequest(input, spec, ctx);\r\n  if (grouping?.childKind === \"groups\" && !allowGroups) throw new QueryError(\"unsupported\", [\"childKind\"]);\r\n  const filters = parseWhere(spec, ctx);\r\n  const where = grouping ? combine(\"and\", [filters, ...grouping.path]) : filters;\r\n  const sorts = parseSorts(spec[\"sorts\"], ctx);\r\n  const { rowRange, paged } = parseRange(input, ctx);\r\n  if (grouping?.childKind === \"groups\") {\r\n    const level = grouping.levels[grouping.path.length]!;\r\n    const direction = sorts.find((term) => term.column === level)?.direction ?? \"asc\";\r\n    return { kind: \"groups\", where, level, nextLevel: grouping.levels[grouping.path.length + 1], direction, rowRange, countRows: grouping.path.length === 0, aggregates: grouping.aggregates };\r\n  }\r\n  const orderBy = grouping ? sorts.filter((term) => !grouping.levels.includes(term.column) || ctx.map.tieBreaker.includes(term.column)) : sorts;\r\n  const runCount = paged ? rowCount !== \"none\" : rowCount === \"always\" || (rowCount === \"firstBlock\" && rowRange.start === 0);\r\n  return { kind: \"rows\", where, orderBy, rowRange, runCount, projection: ctx.map.visible };\r\n}\r\n\r\nfunction parseValues(input: Raw, ctx: Ctx): ValuesPlan {\r\n  const column = lookupColumn(input[\"columnId\"], ctx, [\"columnId\"], \"filter\");\r\n  const query = input[\"query\"] === undefined || input[\"query\"] === null ? \"\" : input[\"query\"];\r\n  if (typeof query !== \"string\") throw new QueryError(\"invalid-request\", [\"query\"]);\r\n  if (query.length > ctx.limits.maxValueQueryLength) throw new QueryError(\"invalid-value\", [\"query\"]);\r\n  return { kind: \"values\", where: parseFilters(input[\"filters\"], ctx), column, query };\r\n}\r\n\r\nfunction parseAggregates(input: Raw, ctx: Ctx): AggregatesPlan {\r\n  const spec = specOf(input);\r\n  rejectPivot(spec);\r\n  const where = parseWhere(spec, ctx);\r\n  const requested = input[\"columnIds\"];\r\n  let columns: PlanColumn[];\r\n  if (requested === undefined || requested === null) columns = ctx.map.visible.filter((column) => column.aggregate !== undefined);\r\n  else {\r\n    if (!Array.isArray(requested)) throw new QueryError(\"invalid-request\", [\"columnIds\"]);\r\n    if (requested.length > ctx.limits.maxColumnIds) throw new QueryError(\"limit-exceeded\", [\"columnIds\"]);\r\n    const seen = new Set<PlanColumn>();\r\n    for (const id of requested) {\r\n      const column = typeof id === \"string\" ? ctx.map.byId.get(id) : undefined;\r\n      if (column && !column.serverOnly && column.aggregate !== undefined) seen.add(column);\r\n    }\r\n    columns = [...seen];\r\n  }\r\n  return { kind: \"aggregates\", where, columns: columns.map((column) => ({ column, reducer: column.aggregate! })) };\r\n}\r\n\r\nfunction parseRange(input: Raw, ctx: Ctx): { rowRange: { start: number; end: number }; paged: boolean } {\r\n  const whole = (value: unknown, path: string): number => {\r\n    if (typeof value !== \"number\" || !Number.isSafeInteger(value) || value < 0) throw new QueryError(\"invalid-value\", [path]);\r\n    return value;\r\n  };\r\n  const { maxPageSize, maxOffset } = ctx.limits;\r\n  let start: number;\r\n  let end: number;\r\n  const paged = input[\"page\"] !== undefined && input[\"page\"] !== null;\r\n  if (paged) {\r\n    const page = whole(input[\"page\"], \"page\");\r\n    const pageSize = whole(input[\"pageSize\"], \"pageSize\");\r\n    if (page < 1 || pageSize < 1 || pageSize > maxPageSize) throw new QueryError(\"invalid-value\", [\"pageSize\"]);\r\n    start = (page - 1) * pageSize;\r\n    if (!Number.isSafeInteger(start + pageSize)) throw new QueryError(\"invalid-value\", [\"page\"]);\r\n    if (input[\"start\"] !== undefined && input[\"start\"] !== start) throw new QueryError(\"invalid-value\", [\"start\"]);\r\n    end = start + pageSize;\r\n  } else {\r\n    start = whole(input[\"start\"], \"start\");\r\n    end = whole(input[\"end\"], \"end\");\r\n    if (end < start || end - start > maxPageSize) throw new QueryError(\"invalid-value\", [\"end\"]);\r\n  }\r\n  if (start > maxOffset) throw new QueryError(\"offset-too-deep\", [\"start\"]);\r\n  return { rowRange: { start, end }, paged };\r\n}\r\n\r\nfunction lookupColumn(id: unknown, ctx: Ctx, path: Path, use: \"filter\" | \"sort\"): PlanColumn {\r\n  const column = typeof id === \"string\" ? ctx.map.byId.get(id) : undefined;\r\n  if (!column || column.serverOnly) throw new QueryError(\"unknown-column\", path);\r\n  if (use === \"filter\" ? !column.filterable : !column.sortable) throw new QueryError(\"operator-not-allowed\", path);\r\n  return column;\r\n}\r\n\r\nfunction parseSorts(value: unknown, ctx: Ctx): OrderTerm[] {\r\n  const terms: OrderTerm[] = [];\r\n  const seen = new Set<PlanColumn>();\r\n  if (value !== undefined && value !== null) {\r\n    if (!Array.isArray(value)) throw new QueryError(\"invalid-request\", [\"spec\", \"sorts\"]);\r\n    if (value.length > ctx.limits.maxSorts) throw new QueryError(\"limit-exceeded\", [\"spec\", \"sorts\"]);\r\n    value.forEach((entry: unknown, index) => {\r\n      const path = [\"spec\", \"sorts\", index] as const;\r\n      if (!isRecord(entry)) throw new QueryError(\"invalid-request\", path);\r\n      const column = lookupColumn(entry[\"columnId\"], ctx, [...path, \"columnId\"], \"sort\");\r\n      if (entry[\"direction\"] !== \"asc\" && entry[\"direction\"] !== \"desc\") throw new QueryError(\"invalid-request\", [...path, \"direction\"]);\r\n      if (seen.has(column)) return;\r\n      seen.add(column);\r\n      terms.push({ column, direction: entry[\"direction\"] });\r\n    });\r\n  }\r\n  for (const column of ctx.map.tieBreaker) if (!seen.has(column)) terms.push({ column, direction: \"asc\" });\r\n  return terms;\r\n}\r\n\r\nfunction parseFilters(value: unknown, ctx: Ctx, join: \"and\" | \"or\" = \"and\"): Predicate {\r\n  if (value === undefined || value === null) return TRUE;\r\n  const nodes = parseNodes(value, [\"spec\", \"filters\"], 0, ctx);\r\n  return nodes.length === 0 ? TRUE : combine(join, nodes);\r\n}\r\n\r\nfunction parseNodes(value: unknown, path: Path, depth: number, ctx: Ctx): Predicate[] {\r\n  if (!Array.isArray(value)) throw new QueryError(\"invalid-request\", path);\r\n  return value.map((node: unknown, index) => {\r\n    const nodePath = [...path, index];\r\n    if (!isRecord(node)) throw new QueryError(\"invalid-request\", nodePath);\r\n    if (++ctx.budget.nodes > ctx.limits.maxFilterNodes) throw new QueryError(\"limit-exceeded\", nodePath);\r\n    if (Array.isArray(node[\"filters\"])) {\r\n      if (depth + 1 > MAX_FILTER_DEPTH) throw new QueryError(\"limit-exceeded\", nodePath);\r\n      const items = parseNodes(node[\"filters\"], [...nodePath, \"filters\"], depth + 1, ctx);\r\n      if (items.length === 0) return TRUE;\r\n      const combined = combine(node[\"join\"] === \"or\" ? \"or\" : \"and\", items);\r\n      return node[\"not\"] === true ? negate(combined) : combined;\r\n    }\r\n    if (++ctx.budget.leaves > ctx.limits.maxFilterLeaves) throw new QueryError(\"limit-exceeded\", nodePath);\r\n    return parseLeaf(node, nodePath, ctx);\r\n  });\r\n}\r\n\r\ntype Shaped = { text: string; pair: [string, string]; list: string[]; matchCase?: boolean };\r\nconst NO_SHAPE: Shaped = { text: \"\", pair: [\"\", \"\"], list: [] };\r\n\r\nfunction takeList(value: unknown, path: Path, ctx: Ctx): string[] {\r\n  if (!Array.isArray(value)) return [];\r\n  if (value.length > ctx.limits.maxListLength) throw new QueryError(\"limit-exceeded\", path);\r\n  ctx.budget.listValues += value.length;\r\n  if (ctx.budget.listValues > ctx.limits.maxTreeListValues) throw new QueryError(\"limit-exceeded\", path);\r\n  const out: string[] = [];\r\n  for (const entry of value) if (typeof entry === \"string\") out.push(entry);\r\n  out.forEach((entry, index) => charge(ctx, entry, [...path, index]));\r\n  return out;\r\n}\r\n\r\nfunction shape(operator: string, value: unknown, path: Path, ctx: Ctx): Shaped {\r\n  const valuePath = [...path, \"value\"];\r\n  if (operator === \"empty\" || operator === \"notEmpty\") return NO_SHAPE;\r\n  if (operator === \"isAnyOf\" || operator === \"isNoneOf\") return { ...NO_SHAPE, list: takeList(value, valuePath, ctx) };\r\n  if (operator === \"isBetween\") {\r\n    const pair: [string, string] = [\"\", \"\"];\r\n    if (Array.isArray(value)) {\r\n      for (const index of [0, 1] as const) {\r\n        const entry: unknown = value[index];\r\n        if (typeof entry === \"string\") {\r\n          charge(ctx, entry, [...valuePath, index]);\r\n          pair[index] = entry;\r\n        }\r\n      }\r\n    }\r\n    return { ...NO_SHAPE, pair };\r\n  }\r\n  if (typeof value !== \"string\") return NO_SHAPE;\r\n  charge(ctx, value, valuePath);\r\n  return { ...NO_SHAPE, text: value };\r\n}\r\n\r\nfunction parseLeaf(node: Raw, path: Path, ctx: Ctx): Predicate {\r\n  const column = lookupColumn(node[\"columnId\"], ctx, [...path, \"columnId\"], \"filter\");\r\n  const operator = node[\"operator\"];\r\n  if (typeof operator !== \"string\") throw new QueryError(\"invalid-request\", [...path, \"operator\"]);\r\n  if (!isBuiltInOperatorId(operator)) return parseCustom(column, operator, node[\"value\"], path, ctx);\r\n  return compile(column, operator, { ...shape(operator, node[\"value\"], path, ctx), matchCase: node[\"matchCase\"] === true }, path, ctx);\r\n}\r\n\r\nfunction parseCustom(column: PlanColumn, id: string, value: unknown, path: Path, ctx: Ctx): Predicate {\r\n  const operator = column.operators.get(id);\r\n  if (!operator) throw new QueryError(\"unknown-operator\", [...path, \"operator\"]);\r\n  const valuePath = [...path, \"value\"];\r\n  if (operator.input === \"none\") return leaf(column, { k: \"custom\", id, value: undefined });\r\n  if (operator.input === \"single\") {\r\n    if (typeof value !== \"string\") throw new QueryError(\"invalid-value\", valuePath);\r\n    charge(ctx, value, valuePath);\r\n    return leaf(column, { k: \"custom\", id, value });\r\n  }\r\n  if (operator.input === \"range\") {\r\n    if (!Array.isArray(value) || value.length !== 2 || value.some((entry) => typeof entry !== \"string\")) throw new QueryError(\"invalid-value\", valuePath);\r\n    (value as string[]).forEach((entry, index) => charge(ctx, entry, [...valuePath, index]));\r\n    return leaf(column, { k: \"custom\", id, value: [value[0], value[1]] });\r\n  }\r\n  if (!Array.isArray(value) || value.some((entry) => typeof entry !== \"string\")) throw new QueryError(\"invalid-value\", valuePath);\r\n  return leaf(column, { k: \"custom\", id, value: takeList(value, valuePath, ctx) });\r\n}\r\n\r\nconst blank = (column: PlanColumn, negate: boolean): Predicate => leaf(column, { k: \"blank\", negate });\r\nconst TEXT_ONLY = new Set([\"contains\", \"notContains\", \"startsWith\", \"endsWith\"]);\r\nconst ORDERING = new Set([\"gt\", \"gte\", \"lt\", \"lte\", \"isBetween\"]);\r\n\r\nfunction compile(column: PlanColumn, op: string, shaped: Shaped, path: Path, ctx: Ctx): Predicate {\r\n  const { text, pair, list } = shaped;\r\n  if (op === \"empty\") return blank(column, false);\r\n  if (op === \"notEmpty\") return blank(column, true);\r\n  if (op === \"equals\" && text === \"\") return blank(column, false);\r\n  if (op === \"notEquals\" && text === \"\") return blank(column, true);\r\n  if ((op === \"contains\" || op === \"startsWith\" || op === \"endsWith\") && text === \"\") return TRUE;\r\n  if (op === \"notContains\" && text === \"\") return FALSE;\r\n  if ((op === \"gt\" || op === \"gte\") && text === \"\") return FALSE;\r\n  if ((op === \"lt\" || op === \"lte\") && text === \"\") return blank(column, true);\r\n  if (op === \"isBetween\" && pair[0] === \"\" && pair[1] === \"\") return blank(column, true);\r\n  if (op === \"isAnyOf\" && list.length === 0) return FALSE;\r\n  if (op === \"isNoneOf\" && list.length === 0) return TRUE;\r\n\r\n  const { kind } = column;\r\n  const bad = (kind === \"number\" || kind === \"date\" || kind === \"checkbox\") && TEXT_ONLY.has(op);\r\n  const badOrdering = (kind === \"checkbox\" || kind === \"select\" || column.native !== undefined) && ORDERING.has(op);\r\n  if (bad || badOrdering) throw new QueryError(\"operator-not-allowed\", [...path, \"operator\"]);\r\n\r\n  if (kind === \"number\") return compileNumber(column, op, shaped, path, ctx);\r\n  if (kind === \"date\") return compileDate(column, op, shaped, ctx);\r\n  if (kind === \"checkbox\") return compileCheckbox(column, op, shaped);\r\n  return compileText(column, op, shaped);\r\n}\r\n\r\nfunction inTest(column: PlanColumn, op: string, values: Operand[], hasBlank: boolean, caseSensitive: boolean): Predicate {\r\n  const negate = op === \"isNoneOf\";\r\n  if (values.length === 0) {\r\n    if (hasBlank) return blank(column, negate);\r\n    return negate ? TRUE : FALSE;\r\n  }\r\n  return leaf(column, { k: \"in\", values, negate, blank: hasBlank, caseSensitive });\r\n}\r\n\r\nfunction nativeText(column: PlanColumn, raw: string): string | null {\r\n  if (column.native === \"uuid\") return parseUuid(raw);\r\n  if (column.native === \"enum\") return column.choices?.find((choice) => choice.toLowerCase() === raw.toLowerCase()) ?? null;\r\n  return raw;\r\n}\r\n\r\nfunction compileText(column: PlanColumn, op: string, { text, pair, list, matchCase }: Shaped): Predicate {\r\n  const caseSensitive = column.caseSensitive || matchCase === true;\r\n  if (op === \"contains\" || op === \"notContains\" || op === \"startsWith\" || op === \"endsWith\") {\r\n    return leaf(column, { k: \"text\", mode: op === \"notContains\" ? \"contains\" : op, text, negate: op === \"notContains\", caseSensitive });\r\n  }\r\n  if (op === \"equals\" || op === \"notEquals\") {\r\n    if (column.native === undefined) return leaf(column, { k: \"text\", mode: \"equals\", text, negate: op === \"notEquals\", caseSensitive });\r\n    const value = nativeText(column, text);\r\n    if (value === null) return op === \"equals\" ? FALSE : TRUE;\r\n    return leaf(column, { k: op === \"equals\" ? \"eq\" : \"ne\", value: { kind: \"text\", v: value } });\r\n  }\r\n  if (op === \"gt\" || op === \"gte\" || op === \"lt\" || op === \"lte\") return leaf(column, { k: \"cmp\", op, value: { kind: \"text\", v: text } });\r\n  if (op === \"isBetween\") {\r\n    return leaf(column, { k: \"range\", lo: pair[0] === \"\" ? undefined : { kind: \"text\", v: pair[0] }, hi: pair[1] === \"\" ? undefined : { kind: \"text\", v: pair[1] }, hiExclusive: false });\r\n  }\r\n  const values = new Map<string, Operand>();\r\n  let hasBlank = false;\r\n  for (const entry of list) {\r\n    if (entry === \"\") {\r\n      hasBlank = true;\r\n      continue;\r\n    }\r\n    const value = column.native === undefined ? entry : nativeText(column, entry);\r\n    if (value === null) continue;\r\n    const key = caseSensitive || column.native !== undefined ? value : value.toLowerCase();\r\n    if (!values.has(key)) values.set(key, { kind: \"text\", v: value });\r\n  }\r\n  return inTest(column, op, [...values.values()], hasBlank, caseSensitive || column.native !== undefined);\r\n}\r\n\r\nfunction compileCheckbox(column: PlanColumn, op: string, { text, list }: Shaped): Predicate {\r\n  if (op === \"equals\" || op === \"notEquals\") {\r\n    const value = parseBoolean(text);\r\n    if (value === null) return op === \"equals\" ? FALSE : TRUE;\r\n    return leaf(column, { k: op === \"equals\" ? \"eq\" : \"ne\", value: { kind: \"boolean\", v: value } });\r\n  }\r\n  const values = new Set<boolean>();\r\n  let hasBlank = false;\r\n  for (const entry of list) {\r\n    if (entry === \"\") hasBlank = true;\r\n    else {\r\n      const value = parseBoolean(entry);\r\n      if (value !== null) values.add(value);\r\n    }\r\n  }\r\n  return inTest(column, op, [...values].map((v) => ({ kind: \"boolean\", v })), hasBlank, true);\r\n}\r\n\r\nfunction numberText(raw: string, path: Path, ctx: Ctx): Decimal | null {\r\n  const trimmed = raw.trim();\r\n  if (trimmed.length > ctx.limits.maxNumberLength) throw new QueryError(\"invalid-value\", path);\r\n  return parseDecimal(trimmed);\r\n}\r\n\r\n/** The operand for an exact number test, or `null` when no stored value can match. */\r\nfunction numberOperand(column: PlanColumn, value: Decimal): Operand | null {\r\n  if (isIntType(column.numeric)) {\r\n    if (!isInteger(value)) return null;\r\n    const whole = floorDecimal(value);\r\n    const [min, max] = INT_RANGE[column.numeric];\r\n    return whole < min || whole > max ? null : { kind: \"bigint\", v: whole };\r\n  }\r\n  if (column.numeric === \"float\") return { kind: \"number\", v: String(clampFloat(decimalToString(value))) };\r\n  return { kind: \"number\", v: decimalToString(value) };\r\n}\r\n\r\nfunction compileNumber(column: PlanColumn, op: string, { text, pair, list }: Shaped, path: Path, ctx: Ctx): Predicate {\r\n  const valuePath = [...path, \"value\"];\r\n  if (op === \"equals\" || op === \"notEquals\") {\r\n    const parsed = numberText(text, valuePath, ctx);\r\n    const operand = parsed ? numberOperand(column, parsed) : null;\r\n    if (!operand) return op === \"equals\" ? FALSE : TRUE;\r\n    return leaf(column, { k: op === \"equals\" ? \"eq\" : \"ne\", value: operand });\r\n  }\r\n  if (op === \"gt\" || op === \"gte\" || op === \"lt\" || op === \"lte\") {\r\n    const parsed = numberText(text, valuePath, ctx);\r\n    if (!parsed) return FALSE;\r\n    return compileNumberCmp(column, op, parsed);\r\n  }\r\n  if (op === \"isBetween\") {\r\n    const lo = pair[0] === \"\" ? undefined : numberText(pair[0], valuePath, ctx);\r\n    const hi = pair[1] === \"\" ? undefined : numberText(pair[1], valuePath, ctx);\r\n    if (lo === null || hi === null) return FALSE;\r\n    return compileNumberRange(column, lo, hi);\r\n  }\r\n  const values = new Map<string, Operand>();\r\n  let hasBlank = false;\r\n  for (const entry of list) {\r\n    if (entry === \"\") {\r\n      hasBlank = true;\r\n      continue;\r\n    }\r\n    const parsed = numberText(entry, valuePath, ctx);\r\n    const operand = parsed ? numberOperand(column, parsed) : null;\r\n    if (operand) values.set(String(operand.v), operand);\r\n  }\r\n  return inTest(column, op, [...values.values()], hasBlank, true);\r\n}\r\n\r\nfunction compileNumberCmp(column: PlanColumn, op: \"gt\" | \"gte\" | \"lt\" | \"lte\", value: Decimal): Predicate {\r\n  if (!isIntType(column.numeric)) {\r\n    const operand = numberOperand(column, value) ?? { kind: \"number\" as const, v: decimalToString(value) };\r\n    return leaf(column, { k: \"cmp\", op, value: operand });\r\n  }\r\n  const [min, max] = INT_RANGE[column.numeric];\r\n  const bound = op === \"gt\" || op === \"lte\" ? floorDecimal(value) : ceilDecimal(value);\r\n  const everyRow = blank(column, true);\r\n  const outcome: Record<typeof op, Predicate | null> = {\r\n    gt: bound >= max ? FALSE : bound < min ? everyRow : null,\r\n    gte: bound > max ? FALSE : bound <= min ? everyRow : null,\r\n    lt: bound <= min ? FALSE : bound > max ? everyRow : null,\r\n    lte: bound < min ? FALSE : bound >= max ? everyRow : null,\r\n  };\r\n  return outcome[op] ?? leaf(column, { k: \"cmp\", op, value: { kind: \"bigint\", v: bound } });\r\n}\r\n\r\nfunction compileNumberRange(column: PlanColumn, lo: Decimal | undefined, hi: Decimal | undefined): Predicate {\r\n  const toOperand = (value: Decimal): Operand => numberOperand(column, value) ?? { kind: \"number\", v: decimalToString(value) };\r\n  if (!isIntType(column.numeric)) {\r\n    return leaf(column, { k: \"range\", lo: lo && toOperand(lo), hi: hi && toOperand(hi), hiExclusive: false });\r\n  }\r\n  const [min, max] = INT_RANGE[column.numeric];\r\n  let low: Operand | undefined;\r\n  let high: Operand | undefined;\r\n  if (lo) {\r\n    const bound = ceilDecimal(lo);\r\n    if (bound > max) return FALSE;\r\n    if (bound > min) low = { kind: \"bigint\", v: bound };\r\n  }\r\n  if (hi) {\r\n    const bound = floorDecimal(hi);\r\n    if (bound < min) return FALSE;\r\n    if (bound < max) high = { kind: \"bigint\", v: bound };\r\n  }\r\n  if (!low && !high) return blank(column, true);\r\n  return leaf(column, { k: \"range\", lo: low, hi: high, hiExclusive: false });\r\n}\r\n\r\ntype DateBound = { day: string } | { instant: string };\r\n\r\nfunction dateBound(column: PlanColumn, raw: string): DateBound | null {\r\n  const trimmed = raw.trim();\r\n  const day = parseDate(trimmed);\r\n  if (day) return { day };\r\n  if (!column.time) return null;\r\n  const instant = parseInstant(trimmed);\r\n  return instant ? { instant } : null;\r\n}\r\n\r\nfunction compileDate(column: PlanColumn, op: string, { text, pair, list }: Shaped, ctx: Ctx): Predicate {\r\n  const tz = ctx.timeZone;\r\n  const instantOf = (v: string): Operand => ({ kind: \"instant\", v });\r\n  const dayStart = (day: string): Operand => instantOf(startOfLocalDay(day, tz));\r\n  const plain = (bound: DateBound): Operand => (\"day\" in bound ? { kind: \"date\", v: bound.day } : instantOf(bound.instant));\r\n  const dayIncluded = (day: string): Predicate => leaf(column, { k: \"range\", lo: dayStart(day), hi: dayStart(nextDay(day)), hiExclusive: true });\r\n  const dayExcluded = (day: string): Predicate =>\r\n    combine(\"or\", [leaf(column, { k: \"cmp\", op: \"lt\", value: dayStart(day) }), leaf(column, { k: \"cmp\", op: \"gte\", value: dayStart(nextDay(day)) })]);\r\n\r\n  if (op === \"equals\" || op === \"notEquals\") {\r\n    const bound = dateBound(column, text);\r\n    if (!bound) return op === \"equals\" ? FALSE : TRUE;\r\n    if (column.time && \"day\" in bound) return op === \"equals\" ? dayIncluded(bound.day) : combine(\"or\", [blank(column, false), dayExcluded(bound.day)]);\r\n    return leaf(column, { k: op === \"equals\" ? \"eq\" : \"ne\", value: plain(bound) });\r\n  }\r\n  if (op === \"gt\" || op === \"gte\" || op === \"lt\" || op === \"lte\") {\r\n    const bound = dateBound(column, text);\r\n    if (!bound) return FALSE;\r\n    if (column.time && \"day\" in bound) {\r\n      const edge = op === \"gt\" || op === \"lte\" ? dayStart(nextDay(bound.day)) : dayStart(bound.day);\r\n      return leaf(column, { k: \"cmp\", op: op === \"gt\" || op === \"gte\" ? \"gte\" : \"lt\", value: edge });\r\n    }\r\n    return leaf(column, { k: \"cmp\", op, value: plain(bound) });\r\n  }\r\n  if (op === \"isBetween\") {\r\n    const lo = pair[0] === \"\" ? undefined : dateBound(column, pair[0]);\r\n    const hi = pair[1] === \"\" ? undefined : dateBound(column, pair[1]);\r\n    if (lo === null || hi === null) return FALSE;\r\n    const dayWise = column.time && ((lo && \"day\" in lo) || (hi && \"day\" in hi));\r\n    if (dayWise) {\r\n      const low = lo ? (\"day\" in lo ? dayStart(lo.day) : instantOf(lo.instant)) : undefined;\r\n      const high = hi ? (\"day\" in hi ? dayStart(nextDay(hi.day)) : instantOf(hi.instant)) : undefined;\r\n      return leaf(column, { k: \"range\", lo: low, hi: high, hiExclusive: true });\r\n    }\r\n    return leaf(column, { k: \"range\", lo: lo && plain(lo), hi: hi && plain(hi), hiExclusive: false });\r\n  }\r\n  const days: string[] = [];\r\n  const exact = new Map<string, Operand>();\r\n  let hasBlank = false;\r\n  for (const entry of list) {\r\n    if (entry === \"\") {\r\n      hasBlank = true;\r\n      continue;\r\n    }\r\n    const bound = dateBound(column, entry);\r\n    if (!bound) continue;\r\n    if (column.time && \"day\" in bound) days.push(bound.day);\r\n    else exact.set(JSON.stringify(plain(bound)), plain(bound));\r\n  }\r\n  if (!column.time) return inTest(column, op, [...exact.values()], hasBlank, true);\r\n  const uniqueDays = [...new Set(days)];\r\n  const included = [...uniqueDays.map(dayIncluded), ...(exact.size > 0 ? [leaf(column, { k: \"in\", values: [...exact.values()], negate: false, blank: false, caseSensitive: true })] : [])];\r\n  if (op === \"isAnyOf\") return included.length === 0 && !hasBlank ? FALSE : combine(\"or\", [...included, ...(hasBlank ? [blank(column, false)] : [])]);\r\n  const excluded = [...uniqueDays.map(dayExcluded), ...(exact.size > 0 ? [leaf(column, { k: \"in\", values: [...exact.values()], negate: true, blank: false, caseSensitive: true })] : [])];\r\n  if (excluded.length === 0) return hasBlank ? blank(column, true) : TRUE;\r\n  return hasBlank ? combine(\"and\", [blank(column, true), ...excluded]) : combine(\"or\", [blank(column, false), combine(\"and\", excluded)]);\r\n}\r\n\r\nfunction parseSearch(value: unknown, ctx: Ctx): Predicate {\r\n  if (value === undefined || value === null) return TRUE;\r\n  if (typeof value !== \"string\") throw new QueryError(\"invalid-request\", [\"spec\", \"searchText\"]);\r\n  if (value.length > ctx.limits.maxSearchLength) throw new QueryError(\"invalid-value\", [\"spec\", \"searchText\"]);\r\n  const phrase = value.trim();\r\n  if (phrase === \"\") return TRUE;\r\n  const searched = ctx.map.visible.filter((column) => column.searchable);\r\n  if (searched.length === 0) return TRUE;\r\n  const number = parseDecimal(phrase);\r\n  const items: Predicate[] = [];\r\n  for (const column of searched) {\r\n    if (column.kind === \"number\") {\r\n      const operand = number ? numberOperand(column, number) : null;\r\n      if (operand) items.push(leaf(column, { k: \"eq\", value: operand }));\r\n    } else items.push(leaf(column, { k: \"text\", mode: \"contains\", text: phrase, negate: false, caseSensitive: false }));\r\n  }\r\n  return combine(\"or\", items);\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/parse-query.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/plan.ts",
      "content": "import type { AggregateReducer, PlanColumn } from \"./column-map\";\r\nimport type { Operand } from \"./operands\";\r\n\r\nexport type { Operand } from \"./operands\";\r\n\r\n/** One test of a column. `ne`, negated text and list tests, and `blank` negations include NULL rows as the client does. */\r\nexport type Test =\r\n  | { k: \"eq\" | \"ne\"; value: Operand }\r\n  | { k: \"text\"; mode: \"contains\" | \"startsWith\" | \"endsWith\" | \"equals\"; text: string; negate: boolean; caseSensitive: boolean }\r\n  | { k: \"cmp\"; op: \"gt\" | \"gte\" | \"lt\" | \"lte\"; value: Operand }\r\n  | { k: \"range\"; lo?: Operand; hi?: Operand; hiExclusive: boolean }\r\n  | { k: \"in\"; values: readonly Operand[]; negate: boolean; blank: boolean; caseSensitive: boolean }\r\n  | { k: \"exact\"; value: Operand }\r\n  | { k: \"blank\"; negate: boolean }\r\n  | { k: \"custom\"; id: string; value: unknown };\r\n\r\nexport type Predicate =\r\n  | { t: \"true\" }\r\n  | { t: \"false\" }\r\n  | { t: \"and\" | \"or\"; items: readonly Predicate[] }\r\n  | { t: \"not\"; item: Predicate }\r\n  | { t: \"leaf\"; column: PlanColumn; test: Test };\r\n\r\nexport type OrderTerm = { column: PlanColumn; direction: \"asc\" | \"desc\" };\r\n\r\nexport type RowsPlan = {\r\n  kind: \"rows\";\r\n  where: Predicate;\r\n  /** A total order: the request's keys, then the tie-breaker. NULLs sort last. */\r\n  orderBy: readonly OrderTerm[];\r\n  rowRange: { start: number; end: number };\r\n  runCount: boolean;\r\n  projection: readonly PlanColumn[];\r\n};\r\nexport type ValuesPlan = { kind: \"values\"; where: Predicate; column: PlanColumn; query: string };\r\nexport type AggregatesPlan = { kind: \"aggregates\"; where: Predicate; columns: readonly { column: PlanColumn; reducer: AggregateReducer }[] };\r\n/** One page of the child groups of one level; `where` holds the filters, the search, and the path equalities. */\r\nexport type GroupsPlan = {\r\n  kind: \"groups\";\r\n  where: Predicate;\r\n  level: PlanColumn;\r\n  nextLevel?: PlanColumn;\r\n  direction: \"asc\" | \"desc\";\r\n  rowRange: { start: number; end: number };\r\n  /** The top level also answers the row count of the whole result. */\r\n  countRows: boolean;\r\n  aggregates: readonly { column: PlanColumn; reducer: AggregateReducer }[];\r\n};\r\nexport type QueryPlan = RowsPlan | ValuesPlan | AggregatesPlan | GroupsPlan;\r\n/** `\"rows\"` reads a rows request and refuses a grouped one; `\"page\"` reads either and yields a `GroupsPlan` or a `RowsPlan`. */\r\nexport type QueryRequestKind = \"rows\" | \"page\" | \"values\" | \"aggregates\";\r\nexport type PlanOf<R extends QueryRequestKind> = R extends \"page\" ? RowsPlan | GroupsPlan : Extract<QueryPlan, { kind: R }>;\r\n\r\nexport const TRUE: Predicate = Object.freeze({ t: \"true\" });\r\nexport const FALSE: Predicate = Object.freeze({ t: \"false\" });\r\n\r\nexport function leaf(column: PlanColumn, test: Test): Predicate {\r\n  return { t: \"leaf\", column, test };\r\n}\r\n\r\n/** The rows `item` does not match; a NULL result of `item` counts as no match. A constant folds. */\r\nexport function negate(item: Predicate): Predicate {\r\n  if (item.t === \"true\") return FALSE;\r\n  if (item.t === \"false\") return TRUE;\r\n  return item.t === \"not\" ? item.item : { t: \"not\", item };\r\n}\r\n\r\n/** Flattens, drops `true` from an `and` and `false` from an `or`, and short-circuits the other way. No adapter sees an empty group. */\r\nexport function combine(join: \"and\" | \"or\", items: readonly Predicate[]): Predicate {\r\n  const neutral = join === \"and\" ? \"true\" : \"false\";\r\n  const absorbing = join === \"and\" ? \"false\" : \"true\";\r\n  const out: Predicate[] = [];\r\n  for (const item of items) {\r\n    if (item.t === absorbing) return item;\r\n    if (item.t === neutral) continue;\r\n    if (item.t === join) out.push(...item.items);\r\n    else out.push(item);\r\n  }\r\n  if (out.length === 0) return join === \"and\" ? TRUE : FALSE;\r\n  return out.length === 1 ? out[0]! : { t: join, items: out };\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/plan.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/render-sql.ts",
      "content": "import type { PlanColumn } from \"./column-map\";\r\nimport { LIKE_ESCAPE, escapeLike } from \"./like\";\r\nimport type { Operand, OrderTerm, Predicate, Test, ValuesPlan } from \"./plan\";\r\n\r\n/**\r\n * The few SQL pieces an ORM supplies, so one renderer holds every semantic decision. `raw` takes text from the closed tables\r\n * in this file only; `param` binds a value; `column` is a qualified identifier from the column map.\r\n */\r\nexport type SqlAlgebra<S> = {\r\n  dialect: \"pg\" | \"sqlite\";\r\n  raw(text: string): S;\r\n  param(value: unknown): S;\r\n  column(column: PlanColumn): S;\r\n  /** Concatenates fragments with no separator. */\r\n  cat(...parts: S[]): S;\r\n  /** Wraps a fragment a `customOperators` handler returned in the ORM's own type. */\r\n  native(value: unknown): S;\r\n};\r\n\r\nexport type CustomHandler = (ctx: { column: PlanColumn; value: unknown }) => unknown;\r\n\r\nconst CMP_SQL = new Map<string, string>([[\"gt\", \" > \"], [\"gte\", \" >= \"], [\"lt\", \" < \"], [\"lte\", \" <= \"]]);\r\n\r\nconst isTextual = (column: PlanColumn): boolean => column.kind === \"text\" || column.kind === \"select\";\r\n\r\nexport function createSqlRenderer<S>(a: SqlAlgebra<S>, customHandlers: ReadonlyMap<string, CustomHandler>) {\r\n  const { raw, param, cat, column: ref } = a;\r\n  const pg = a.dialect === \"pg\";\r\n  const escapeClause = raw(` ESCAPE '${LIKE_ESCAPE}'`);\r\n\r\n  const join = (parts: S[], separator: string): S => cat(...parts.flatMap((part, index) => (index === 0 ? [part] : [raw(separator), part])));\r\n  const group = (inner: S): S => cat(raw(\"(\"), inner, raw(\")\"));\r\n  const subject = (column: PlanColumn): S => (pg && column.native ? cat(ref(column), raw(\"::text\")) : ref(column));\r\n\r\n  function operand(value: Operand, column: PlanColumn): S {\r\n    switch (value.kind) {\r\n      case \"text\":\r\n      case \"date\":\r\n        return param(value.v);\r\n      case \"boolean\":\r\n        return param(pg ? value.v : value.v ? 1 : 0);\r\n      case \"bigint\":\r\n        return param(column.numeric === \"int8\" ? (pg ? value.v.toString() : value.v) : Number(value.v));\r\n      case \"number\":\r\n        if (column.numeric === \"float\" || !pg) return param(Number(value.v));\r\n        return cat(param(value.v), raw(\"::numeric\"));\r\n      case \"instant\":\r\n        if (column.storage === \"epoch-ms\") return param(Date.parse(value.v));\r\n        if (column.storage === \"epoch-s\") return param(Date.parse(value.v) / 1000);\r\n        if (column.storage === \"iso-text\" || !pg) return param(value.v);\r\n        return cat(param(value.v), raw(\"::timestamptz\"));\r\n    }\r\n  }\r\n\r\n  function blank(column: PlanColumn, negate: boolean): S {\r\n    const col = ref(column);\r\n    if (!isTextual(column) || column.keepBlankText || column.native) return cat(col, raw(negate ? \" IS NOT NULL\" : \" IS NULL\"));\r\n    return negate ? group(cat(col, raw(\" IS NOT NULL AND \"), col, raw(\" <> ''\"))) : group(cat(col, raw(\" IS NULL OR \"), col, raw(\" = ''\")));\r\n  }\r\n\r\n  /** `expr LIKE pattern ESCAPE '!'` for contains/startsWith/endsWith/equals in the case policy of the column. */\r\n  function like(expr: S, mode: \"contains\" | \"startsWith\" | \"endsWith\" | \"equals\", text: string, caseSensitive: boolean): S {\r\n    if (mode === \"equals\") {\r\n      if (caseSensitive) return cat(expr, raw(\" = \"), param(text));\r\n      return pg ? cat(raw(\"lower(\"), expr, raw(\") = lower(\"), param(text), raw(\")\")) : cat(expr, raw(\" = \"), param(text), raw(\" COLLATE NOCASE\"));\r\n    }\r\n    if (caseSensitive && !pg) {\r\n      if (mode === \"contains\") return cat(raw(\"instr(\"), expr, raw(\", \"), param(text), raw(\") > 0\"));\r\n      if (mode === \"startsWith\") return cat(raw(\"substr(\"), expr, raw(\", 1, length(\"), param(text), raw(\")) = \"), param(text));\r\n      return cat(raw(\"substr(\"), expr, raw(\", -length(\"), param(text), raw(\")) = \"), param(text));\r\n    }\r\n    const escaped = escapeLike(text, LIKE_ESCAPE);\r\n    const pattern = mode === \"contains\" ? `%${escaped}%` : mode === \"startsWith\" ? `${escaped}%` : `%${escaped}`;\r\n    return cat(expr, raw(pg && !caseSensitive ? \" ILIKE \" : \" LIKE \"), param(pattern), escapeClause);\r\n  }\r\n\r\n  const withBlankGuard = (column: PlanColumn, body: S): S =>\r\n    isTextual(column) && !column.keepBlankText && !column.native ? group(cat(body, raw(\" AND \"), ref(column), raw(\" <> ''\"))) : body;\r\n\r\n  function inList(column: PlanColumn, test: Extract<Test, { k: \"in\" }>): S {\r\n    const col = ref(column);\r\n    const folded = !test.caseSensitive && isTextual(column);\r\n    const lhs = folded ? cat(raw(\"lower(\"), subject(column), raw(\")\")) : subject(column);\r\n    const list = group(join(test.values.map((value) => (folded ? cat(raw(\"lower(\"), operand(value, column), raw(\")\")) : operand(value, column))), \", \"));\r\n    const member = cat(lhs, raw(\" IN \"), list);\r\n    if (!test.negate) return test.blank ? group(cat(member, raw(\" OR \"), blank(column, false))) : member;\r\n    if (test.blank) return group(cat(lhs, raw(\" NOT IN \"), list, raw(\" AND \"), blank(column, true)));\r\n    return group(cat(col, raw(\" IS NULL OR \"), lhs, raw(\" NOT IN \"), list));\r\n  }\r\n\r\n  function test(column: PlanColumn, t: Test): S {\r\n    const col = ref(column);\r\n    switch (t.k) {\r\n      case \"eq\":\r\n      case \"exact\":\r\n        return cat(col, raw(\" = \"), operand(t.value, column));\r\n      case \"ne\":\r\n        return group(cat(col, raw(\" <> \"), operand(t.value, column), raw(\" OR \"), col, raw(\" IS NULL\")));\r\n      case \"blank\":\r\n        return blank(column, t.negate);\r\n      case \"text\": {\r\n        const body = like(subject(column), t.mode, t.text, t.caseSensitive);\r\n        return t.negate ? group(cat(col, raw(\" IS NULL OR NOT (\"), body, raw(\")\"))) : body;\r\n      }\r\n      case \"cmp\":\r\n        return withBlankGuard(column, cat(col, raw(CMP_SQL.get(t.op)!), operand(t.value, column)));\r\n      case \"range\": {\r\n        const parts: S[] = [];\r\n        if (t.lo) parts.push(cat(col, raw(\" >= \"), operand(t.lo, column)));\r\n        if (t.hi) parts.push(cat(col, raw(t.hiExclusive ? \" < \" : \" <= \"), operand(t.hi, column)));\r\n        const body = parts.length === 1 ? parts[0]! : group(join(parts, \" AND \"));\r\n        return withBlankGuard(column, body);\r\n      }\r\n      case \"in\":\r\n        return inList(column, t);\r\n      case \"custom\": {\r\n        const handler = customHandlers.get(t.id);\r\n        if (!handler) throw new Error(`customOperators: no handler for \"${t.id}\"`);\r\n        return a.native(handler({ column, value: t.value }));\r\n      }\r\n    }\r\n  }\r\n\r\n  function predicate(p: Predicate): S {\r\n    switch (p.t) {\r\n      case \"true\":\r\n        return raw(\"1 = 1\");\r\n      case \"false\":\r\n        return raw(\"1 = 0\");\r\n      case \"leaf\":\r\n        return test(p.column, p.test);\r\n      case \"not\":\r\n        return group(cat(group(predicate(p.item)), raw(\" IS NOT TRUE\")));\r\n      default:\r\n        return group(join(p.items.map(predicate), p.t === \"and\" ? \" AND \" : \" OR \"));\r\n    }\r\n  }\r\n\r\n  function orderBy(terms: readonly OrderTerm[]): S {\r\n    return join(terms.map((term) => cat(ref(term.column), raw(term.direction === \"asc\" ? \" ASC NULLS LAST\" : \" DESC NULLS LAST\"))), \", \");\r\n  }\r\n\r\n  /** The text form the set filter searches and a value query matches. */\r\n  function textForm(column: PlanColumn, timeZone?: string): S {\r\n    const col = ref(column);\r\n    if (column.kind === \"checkbox\") return pg ? cat(col, raw(\"::text\")) : cat(raw(\"CASE \"), col, raw(\" WHEN 1 THEN 'true' WHEN 0 THEN 'false' END\"));\r\n    if (column.kind === \"date\" && column.time) return dayKey(column, timeZone);\r\n    if (column.kind === \"text\" || column.kind === \"select\") return subject(column);\r\n    return cat(raw(\"CAST(\"), col, raw(\" AS text)\"));\r\n  }\r\n\r\n  /** The group key of a set value: the local day for instants, the value elsewhere. */\r\n  function dayKey(column: PlanColumn, timeZone = \"UTC\"): S {\r\n    const col = ref(column);\r\n    if (pg) {\r\n      if (column.storage !== \"native\") throw new Error(\"Set values on a time column need native timestamps on PostgreSQL\");\r\n      if (/^[+-]/.test(timeZone)) throw new Error(\"Set values on PostgreSQL need an IANA time zone, not a fixed offset\");\r\n      if (!/^[A-Za-z0-9_+\\-/:]+$/.test(timeZone)) throw new Error(\"timeZone holds characters a zone name never has\");\r\n      return cat(raw(\"(\"), col, raw(` AT TIME ZONE '${timeZone}')::date::text`));\r\n    }\r\n    if (column.storage === \"epoch-ms\") return cat(raw(\"date(\"), col, raw(\" / 1000, 'unixepoch')\"));\r\n    if (column.storage === \"epoch-s\") return cat(raw(\"date(\"), col, raw(\", 'unixepoch')\"));\r\n    return cat(raw(\"date(\"), col, raw(\")\"));\r\n  }\r\n\r\n  function valueKey(column: PlanColumn, timeZone?: string): { key: S; value: S } {\r\n    if (column.kind === \"date\" && column.time) {\r\n      const day = dayKey(column, timeZone);\r\n      return { key: day, value: day };\r\n    }\r\n    if (isTextual(column)) {\r\n      const coalesced = cat(raw(\"COALESCE(\"), subject(column), raw(\", '')\"));\r\n      if (column.caseSensitive) return { key: coalesced, value: coalesced };\r\n      return { key: cat(raw(\"lower(\"), coalesced, raw(\")\")), value: cat(raw(\"MIN(\"), coalesced, raw(\")\")) };\r\n    }\r\n    return { key: ref(column), value: ref(column) };\r\n  }\r\n\r\n  function aggregate(column: PlanColumn, reducer: string): S {\r\n    const col = ref(column);\r\n    const nonBlank = isTextual(column) && !column.keepBlankText ? cat(raw(\"NULLIF(\"), subject(column), raw(\", '')\")) : col;\r\n    switch (reducer) {\r\n      case \"sum\":\r\n        return cat(raw(\"SUM(\"), col, raw(\")\"));\r\n      case \"avg\":\r\n        return cat(raw(\"AVG(\"), col, raw(\")\"));\r\n      case \"min\":\r\n        return cat(raw(\"MIN(\"), nonBlank, raw(\")\"));\r\n      case \"max\":\r\n        return cat(raw(\"MAX(\"), nonBlank, raw(\")\"));\r\n      default:\r\n        return cat(raw(\"COUNT(\"), nonBlank, raw(\")\"));\r\n    }\r\n  }\r\n\r\n  /** The group key of a column: the stored value, with `''` folded into NULL for text. A time column keeps the full instant. */\r\n  function groupKey(column: PlanColumn): S {\r\n    return isTextual(column) ? cat(raw(\"NULLIF(\"), subject(column), raw(\", '')\")) : ref(column);\r\n  }\r\n\r\n  /** Number of groups of a key over the matched rows: distinct keys, the empty key counted once. */\r\n  function keyCount(key: S): S {\r\n    return cat(raw(\"COUNT(DISTINCT \"), key, raw(\") + COALESCE(MAX(CASE WHEN \"), key, raw(\" IS NULL THEN 1 ELSE 0 END), 0)\"));\r\n  }\r\n\r\n  /** The filter of a set-values request: the plan's filter plus the value query as an escaped substring match. */\r\n  function valuesFilter(plan: ValuesPlan, timeZone?: string): S {\r\n    const where = predicate(plan.where);\r\n    if (plan.query === \"\") return where;\r\n    return group(cat(where, raw(\" AND \"), like(textForm(plan.column, timeZone), \"contains\", plan.query, false)));\r\n  }\r\n\r\n  return { predicate, orderBy, textForm, valueKey, aggregate, like, valuesFilter, groupKey, keyCount };\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/render-sql.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/row-scope.ts",
      "content": "import { type ColumnMap, type PlanColumn, mapOf } from \"./column-map\";\r\nimport { INT_RANGE, clampFloat, decimalToString, isIntType, parseBoolean, parseDate, parseDecimal, parseInstant, parseUuid } from \"./operands\";\r\nimport { type Operand, type Predicate, combine, leaf } from \"./plan\";\r\n\r\n/** Returns equalities on mapped columns (`{ tenantId: ctx.tenantId }`) that every query of the factory ANDs in. */\r\nexport type RowScope<TContext> = (context: TContext) => Readonly<Record<string, unknown>>;\r\n\r\nfunction refuse(column: PlanColumn): never {\r\n  throw new Error(`rowScope: the value for \"${column.id}\" is missing or invalid`);\r\n}\r\n\r\nfunction numberOperand(column: PlanColumn, value: unknown): Operand {\r\n  if (isIntType(column.numeric)) {\r\n    const [min, max] = INT_RANGE[column.numeric];\r\n    let whole: bigint | null = null;\r\n    if (typeof value === \"number\" && Number.isSafeInteger(value)) whole = BigInt(value);\r\n    else if (typeof value === \"bigint\" && column.numeric === \"int8\") whole = value;\r\n    if (whole === null || whole < min || whole > max) return refuse(column);\r\n    return { kind: \"bigint\", v: whole };\r\n  }\r\n  if (typeof value !== \"number\" && !(typeof value === \"string\" && column.numeric === \"decimal\")) return refuse(column);\r\n  const parsed = parseDecimal(String(value).trim());\r\n  if (!parsed) return refuse(column);\r\n  return { kind: \"number\", v: column.numeric === \"float\" ? String(clampFloat(decimalToString(parsed))) : decimalToString(parsed) };\r\n}\r\n\r\nfunction scopeOperand(column: PlanColumn, value: unknown): Operand {\r\n  if (value === undefined || value === null || (typeof value === \"number\" && Number.isNaN(value))) return refuse(column);\r\n  if (column.kind === \"number\") return numberOperand(column, value);\r\n  if (column.kind === \"checkbox\") {\r\n    const parsed = typeof value === \"boolean\" ? value : typeof value === \"string\" ? parseBoolean(value) : null;\r\n    return parsed === null ? refuse(column) : { kind: \"boolean\", v: parsed };\r\n  }\r\n  if (typeof value !== \"string\") return refuse(column);\r\n  if (column.kind === \"date\") {\r\n    const parsed = column.time ? parseInstant(value) : parseDate(value);\r\n    return parsed === null ? refuse(column) : { kind: column.time ? \"instant\" : \"date\", v: parsed };\r\n  }\r\n  if (value.trim() === \"\") return refuse(column);\r\n  const text = column.native === \"uuid\" ? parseUuid(value) : value;\r\n  return text === null ? refuse(column) : { kind: \"text\", v: text };\r\n}\r\n\r\n/** The predicate of a `rowScope` result; throws (a 500, never a wider result) on anything that is not a plain, valid equality set. */\r\nexport function rowScopePredicate(columns: ColumnMap, scope: unknown): Predicate {\r\n  const prototype: unknown = typeof scope === \"object\" && scope !== null ? Object.getPrototypeOf(scope) : undefined;\r\n  if (typeof scope !== \"object\" || scope === null || Array.isArray(scope) || (prototype !== Object.prototype && prototype !== null)) {\r\n    throw new Error(\"rowScope: must return a plain object\");\r\n  }\r\n  const keys = Object.keys(scope);\r\n  if (keys.length === 0) throw new Error(\"rowScope: returned no keys, which would match every row; omit rowScope for that\");\r\n  const items = keys.map((key) => {\r\n    const column = mapOf(columns).byId.get(key);\r\n    if (!column) throw new Error(`rowScope: \"${key}\" is not in the column map`);\r\n    return leaf(column, { k: \"exact\", value: scopeOperand(column, (scope as Record<string, unknown>)[key]) });\r\n  });\r\n  return combine(\"and\", items);\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/row-scope.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/safe-text.ts",
      "content": "/** `String(value ?? \"\")` that falls back to `\"\"` when the conversion throws (null-prototype objects). */\r\nexport function toSafeText(value: unknown): string {\r\n  if (value == null) return \"\";\r\n  try {\r\n    return String(value);\r\n  } catch {\r\n    return \"\";\r\n  }\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/safe-text.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/serialize-row.ts",
      "content": "import type { PlanColumn } from \"./column-map\";\r\nimport { toSafeText } from \"./safe-text\";\r\n\r\nfunction dayText(value: unknown): string | null {\r\n  if (value instanceof Date) {\r\n    if (Number.isNaN(value.getTime())) return null;\r\n    return `${String(value.getFullYear()).padStart(4, \"0\")}-${String(value.getMonth() + 1).padStart(2, \"0\")}-${String(value.getDate()).padStart(2, \"0\")}`;\r\n  }\r\n  const text = toSafeText(value);\r\n  if (text === \"\") return null;\r\n  return /^\\d{4}-\\d{2}-\\d{2}/.test(text) ? text.slice(0, 10) : text;\r\n}\r\n\r\n/** A driver timestamp as an ISO text with `Z`: `Date`, epoch number, or the text PostgreSQL and SQLite return. */\r\nexport function instantText(value: unknown, column: PlanColumn): string | null {\r\n  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();\r\n  let ms: number;\r\n  if (typeof value === \"number\") ms = column.storage === \"epoch-s\" ? value * 1000 : value;\r\n  else if (typeof value === \"bigint\") ms = Number(value) * (column.storage === \"epoch-s\" ? 1000 : 1);\r\n  else {\r\n    const text = toSafeText(value).trim();\r\n    if (text === \"\") return null;\r\n    const normalized = /^\\d{4}-\\d{2}-\\d{2} \\d/.test(text) ? text.replace(\" \", \"T\") : text;\r\n    const zoned = /(?:Z|[-+]\\d{2}(?::?\\d{2})?)$/i.test(normalized) ? normalized.replace(/([-+]\\d{2})$/, \"$1:00\") : `${normalized}Z`;\r\n    ms = Date.parse(zoned);\r\n  }\r\n  return Number.isFinite(ms) ? new Date(ms).toISOString() : null;\r\n}\r\n\r\nfunction numberValue(value: unknown, column: PlanColumn): number | string | null {\r\n  if (typeof value === \"number\") return Number.isFinite(value) ? value : null;\r\n  if (typeof value === \"bigint\") {\r\n    const safe = value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER);\r\n    return safe ? Number(value) : value.toString();\r\n  }\r\n  const text = toSafeText(value).trim();\r\n  if (text === \"\") return null;\r\n  if (column.scale !== undefined) return text;\r\n  const n = Number(text);\r\n  const exact = Number.isFinite(n) && (Number.isSafeInteger(n) || column.numeric === \"float\" || column.numeric === \"decimal\");\r\n  return exact ? n : text;\r\n}\r\n\r\n/** One cell value in the wire form: JSON-safe, with numbers, dates, and booleans in the shapes the grid cells hold. */\r\nexport function serializeValue(value: unknown, column: PlanColumn): unknown {\r\n  if (value === null || value === undefined) return null;\r\n  switch (column.kind) {\r\n    case \"number\":\r\n      return numberValue(value, column);\r\n    case \"checkbox\":\r\n      if (typeof value === \"boolean\") return value;\r\n      if (value === 1 || (typeof value === \"bigint\" && value === BigInt(1)) || value === \"t\" || value === \"1\" || value === \"true\") return true;\r\n      if (value === 0 || (typeof value === \"bigint\" && value === BigInt(0)) || value === \"f\" || value === \"0\" || value === \"false\") return false;\r\n      return null;\r\n    case \"date\":\r\n      return column.time ? instantText(value, column) : dayText(value);\r\n    default:\r\n      return toSafeText(value);\r\n  }\r\n}\r\n\r\n/** A wire row from a driver row keyed by column id: only the projected columns. */\r\nexport function serializeRow(row: Record<string, unknown>, projection: readonly PlanColumn[]): Record<string, unknown> {\r\n  const out: Record<string, unknown> = {};\r\n  for (const column of projection) out[column.id] = serializeValue(Object.hasOwn(row, column.id) ? row[column.id] : null, column);\r\n  return out;\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/serialize-row.ts"
    },
    {
      "path": "registry/default/blocks/data-grid-server-query/with-column-map.ts",
      "content": "import type { ColumnMapDescriptor } from \"./describe-filter-operators\";\r\n\r\n/**\r\n * Merges `filterOperators`, `filterable`, and `sortable` of a descriptor into the grid's column definitions.\r\n * A column the descriptor lacks (computed, actions) becomes neither sortable nor filterable, so it never sends a\r\n * request the server refuses.\r\n */\r\nexport function withColumnMap<TDef extends { id: string }>(\r\n  columnDefs: readonly TDef[],\r\n  descriptor: ColumnMapDescriptor,\r\n): (TDef & { filterOperators?: ColumnMapDescriptor[string][\"operators\"]; sortable?: boolean; filterable?: boolean })[] {\r\n  return columnDefs.map((def) => {\r\n    const entry = Object.hasOwn(descriptor, def.id) ? descriptor[def.id] : undefined;\r\n    if (!entry) return { ...def, sortable: false, filterable: false };\r\n    return { ...def, filterOperators: entry.operators, filterable: entry.filterable, sortable: entry.sortable };\r\n  });\r\n}\r\n",
      "type": "registry:component",
      "target": "components/data-grid-server-query/with-column-map.ts"
    }
  ],
  "categories": [
    "data"
  ],
  "type": "registry:block"
}