@pathmx/core 0.5.0

package/query/kernel.ts

@@ -0,0 +1,776 @@
+import { canonicalPath } from "../canonical.ts"
+import { dependencyKey, type Dependency } from "../dependencies.ts"
+import type { Engine } from "../host/engine.ts"
+import {
+  formatSchemaIssues,
+  type StandardSchemaV1,
+} from "../schema/standard.ts"
+import { QueryFieldCatalog, queryRecordValue, queryScalar } from "./fields.ts"
+import { QueryIndex, type IndexedBlock } from "./candidate-index.ts"
+import {
+  QueryDependencyIndex,
+  type QueryInvalidation,
+} from "./dependency-index.ts"
+import type {
+  BlockQueryRequest,
+  QueryContribution,
+  QueryDefinition,
+  QueryDefinitionInput,
+  QueryDefinitionOutput,
+  QueryRequest,
+  QueryScalar,
+  QuerySort,
+  SourceQueryRequest,
+  ViewQuery,
+} from "./model.ts"
+import type { Source } from "../source/index.ts"
+import type { BlockSummary, SourceSummary, View } from "../view/model.ts"
+import type { ApplicationSchema } from "../schema/model.ts"
+import {
+  projectBlockSummary,
+  projectSourceSummary,
+} from "../view/projection.ts"
+
+const MAX_QUERY_LIMIT = 1_000
+const MAX_RETAINED_QUERY_PLANS = 2_000
+const MAX_VIEW_CACHES_PER_QUERY = 256
+const QUERY_DEPENDENCY_PLUGIN = "query"
+
+export type PreparedQueryPlan = Readonly<{
+  query: string
+  from: string
+  input?: unknown
+  where: Readonly<Record<string, QueryScalar>>
+  sort: readonly Required<QuerySort>[]
+  limit: number
+  type?: string
+  has: readonly string[]
+  recursive: boolean
+  key: string
+}>
+
+type NormalizedRequest = PreparedQueryPlan
+
+function queryValueError(): never {
+  throw new Error("Query inputs and results must contain only JSON values.")
+}
+
+function scalarJsonValue(value: unknown) {
+  if (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "boolean"
+  ) {
+    return value
+  }
+  if (typeof value === "number" && Number.isFinite(value)) return value
+  return queryValueError()
+}
+
+function queryObject(value: object) {
+  const prototype = Object.getPrototypeOf(value)
+  if (prototype !== Object.prototype && prototype !== null) queryValueError()
+  return value as Record<string, unknown>
+}
+
+function stableValue(value: unknown, stack = new WeakSet<object>()): unknown {
+  if (value == null || typeof value !== "object") return scalarJsonValue(value)
+  if (stack.has(value)) return queryValueError()
+  stack.add(value)
+  const normalized = Array.isArray(value)
+    ? value.map((item) => stableValue(item, stack))
+    : Object.fromEntries(
+        Object.entries(queryObject(value))
+          .sort(([left], [right]) => left.localeCompare(right))
+          .map(([key, item]) => [key, stableValue(item, stack)]),
+      )
+  stack.delete(value)
+  return normalized
+}
+
+function stableStringify(value: unknown) {
+  return JSON.stringify(stableValue(value))
+}
+
+function immutableValue(
+  value: unknown,
+  stack = new WeakSet<object>(),
+): unknown {
+  if (value == null || typeof value !== "object") return scalarJsonValue(value)
+  if (stack.has(value)) return queryValueError()
+  stack.add(value)
+  if (Array.isArray(value)) {
+    const result = value.map((item) => immutableValue(item, stack))
+    stack.delete(value)
+    return Object.freeze(result)
+  }
+  const result = Object.fromEntries(
+    Object.entries(queryObject(value)).map(([key, item]) => [
+      key,
+      immutableValue(item, stack),
+    ]),
+  )
+  stack.delete(value)
+  return Object.freeze(result)
+}
+
+async function validateSchema<Schema extends StandardSchemaV1>(
+  schema: Schema,
+  value: unknown,
+  subject: string,
+): Promise<StandardSchemaV1.InferOutput<Schema>> {
+  const result = await schema["~standard"].validate(value)
+  if (result.issues) {
+    throw new Error(`${subject}: ${formatSchemaIssues(result.issues)}`)
+  }
+  return result.value
+}
+
+function normalizedScope(value: string | undefined) {
+  if (value !== undefined && typeof value !== "string") {
+    throw new Error("Query from must be a string.")
+  }
+  const scope = value?.trim() || "/"
+  if (scope.startsWith("~/")) {
+    const suffix = canonicalPath(`/${scope.slice(2)}`)
+    return `~${suffix}`
+  }
+  return canonicalPath(scope)
+}
+
+function normalizedLimit(value: number | undefined) {
+  if (value == null) return MAX_QUERY_LIMIT
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("Query limit must be a non-negative safe integer.")
+  }
+  return Math.min(value, MAX_QUERY_LIMIT)
+}
+
+function normalizedWhere(value: QueryRequest["where"]) {
+  if (
+    value !== undefined &&
+    (value === null || typeof value !== "object" || Array.isArray(value))
+  ) {
+    throw new Error("Query where must be an object.")
+  }
+  const entries = Object.entries(value ?? {}).sort(([left], [right]) =>
+    left.localeCompare(right),
+  )
+  for (const [field, expected] of entries) {
+    if (!field.trim()) throw new Error("Query filter fields cannot be empty.")
+    if (!queryScalar(expected)) {
+      throw new Error(`Query filter ${field} must compare a scalar value.`)
+    }
+  }
+  return Object.freeze(Object.fromEntries(entries))
+}
+
+function normalizedSort(value: QueryRequest["sort"]) {
+  if (value !== undefined && !Array.isArray(value)) {
+    throw new Error("Query sort must be a list.")
+  }
+  return Object.freeze(
+    (value ?? []).map((sort) => {
+      if (sort == null || typeof sort !== "object") {
+        throw new Error("Each query sort must be an object.")
+      }
+      const by = sort.by?.trim()
+      if (!by) throw new Error("Query sort fields cannot be empty.")
+      const direction = sort.direction ?? "asc"
+      if (direction !== "asc" && direction !== "desc") {
+        throw new Error(`Unsupported query sort direction: ${direction}`)
+      }
+      return Object.freeze({ by, direction })
+    }),
+  )
+}
+
+function normalizedHas(value: SourceQueryRequest["has"]) {
+  const props = value == null ? [] : typeof value === "string" ? [value] : value
+  if (!Array.isArray(props) || props.some((prop) => typeof prop !== "string")) {
+    throw new Error("Query has must be a string or list of strings.")
+  }
+  return Object.freeze(
+    [...new Set(props.map((prop) => prop.trim()))]
+      .filter(Boolean)
+      .sort((left, right) => left.localeCompare(right)),
+  )
+}
+
+function matchesWhere(
+  record: unknown,
+  where: Readonly<Record<string, QueryScalar>>,
+) {
+  return Object.entries(where).every(([field, expected]) =>
+    Object.is(queryRecordValue(record, field), expected),
+  )
+}
+
+function compareScalar(left: unknown, right: unknown) {
+  if (left === right) return 0
+  if (left === undefined || left === null) return 1
+  if (right === undefined || right === null) return -1
+  if (typeof left === "number" && typeof right === "number") {
+    return left < right ? -1 : 1
+  }
+  if (typeof left === "boolean" && typeof right === "boolean") {
+    return left === false ? -1 : 1
+  }
+  const a = String(left)
+  const b = String(right)
+  return a < b ? -1 : a > b ? 1 : 0
+}
+
+function stableRecordKey(record: unknown) {
+  if (record != null && typeof record === "object") {
+    const value = record as Record<string, unknown>
+    if (typeof value.id === "string") {
+      const source = value.source
+      if (
+        source != null &&
+        typeof source === "object" &&
+        typeof (source as Record<string, unknown>).id === "string"
+      ) {
+        return `${(source as Record<string, unknown>).id}#${value.id}`
+      }
+      return value.id
+    }
+  }
+  return stableStringify(record)
+}
+
+function orderResults(
+  results: readonly unknown[],
+  sorts: readonly Required<QuerySort>[],
+) {
+  return [...results].sort((left, right) => {
+    for (const sort of sorts) {
+      const compared = compareScalar(
+        queryRecordValue(left, sort.by),
+        queryRecordValue(right, sort.by),
+      )
+      if (compared) return sort.direction === "desc" ? -compared : compared
+    }
+    return compareScalar(stableRecordKey(left), stableRecordKey(right))
+  })
+}
+
+function within(path: string, root: string, recursive: boolean) {
+  if (root !== "/" && path !== root && !path.startsWith(`${root}/`)) {
+    return false
+  }
+  if (recursive || path === root) return true
+  const relative = root === "/" ? path.slice(1) : path.slice(root.length + 1)
+  return !relative.includes("/")
+}
+
+function queryFieldCatalog(
+  schema: ApplicationSchema,
+  plan: NormalizedRequest,
+  namedOutput?: Readonly<Record<string, unknown>>,
+) {
+  const catalog = new QueryFieldCatalog()
+  if (plan.query === "sources" || plan.query === "blocks") {
+    catalog
+      .add("id")
+      .add("type")
+      .add("href")
+      .add("meta.title")
+      .add("meta.description")
+      .add("meta.image")
+    const types = plan.type
+      ? [plan.type]
+      : plan.query === "sources"
+        ? schema.sourceTypes().map(({ type }) => type)
+        : schema.blockTypes().map(({ type }) => type)
+    const schemas = types.flatMap((type) =>
+      (plan.query === "sources"
+        ? schema.sourceSchemas(type)
+        : schema.blockSchemas(type)
+      ).map(({ outputJsonSchema }) => outputJsonSchema),
+    )
+    for (const jsonSchema of schemas) catalog.addObjectSchema(jsonSchema)
+    for (const prop of schema.props()) {
+      catalog.addObjectSchema(prop.outputJsonSchema, prop.name)
+    }
+    if (plan.query === "blocks") {
+      catalog.add("source.id").add("source.type").add("source.href")
+      catalog.add("source.meta.title")
+      for (const type of schema.sourceTypes()) {
+        for (const sourceSchema of schema.sourceSchemas(type.type)) {
+          catalog.addObjectSchema(sourceSchema.outputJsonSchema, "source")
+        }
+      }
+      for (const prop of schema.props()) {
+        catalog.addObjectSchema(prop.outputJsonSchema, `source.${prop.name}`)
+      }
+    }
+  } else if (namedOutput) {
+    catalog.addArrayOutput(namedOutput)
+  }
+  for (const field of Object.keys(plan.where)) catalog.require(field, "filter")
+  for (const sort of plan.sort) catalog.require(sort.by, "sort")
+  return catalog
+}
+
+/** @internal Normalize and validate one query for execution or authored storage. */
+export async function prepareQueryPlan(
+  schema: ApplicationSchema,
+  query: string,
+  request: QueryRequest<unknown> = {},
+) {
+  const builtIn = query === "sources" || query === "blocks"
+  const named = builtIn ? undefined : schema.query(query)
+  if (!builtIn && !named) throw new Error(`Unknown query: ${query}`)
+
+  let input = request.input
+  if (named?.input) {
+    input = immutableValue(
+      await validateSchema(
+        named.input,
+        request.input,
+        `Invalid ${query} query input`,
+      ),
+    )
+  } else if (request.input !== undefined) {
+    throw new Error(`Query ${query} does not accept input.`)
+  }
+
+  const sourceRequest = request as SourceQueryRequest
+  const allowed = new Set([
+    "from",
+    "input",
+    "where",
+    "sort",
+    "limit",
+    ...(builtIn ? ["type", "has", "recursive"] : []),
+  ])
+  for (const key of Object.keys(request)) {
+    if (!allowed.has(key))
+      throw new Error(`Unknown query request field: ${key}`)
+  }
+  if (
+    builtIn &&
+    sourceRequest.type !== undefined &&
+    typeof sourceRequest.type !== "string"
+  ) {
+    throw new Error("Query type must be a string.")
+  }
+  if (
+    builtIn &&
+    sourceRequest.recursive !== undefined &&
+    typeof sourceRequest.recursive !== "boolean"
+  ) {
+    throw new Error("Query recursive must be a boolean.")
+  }
+  const normalized = {
+    query,
+    from: normalizedScope(request.from),
+    ...(named?.input ? { input } : {}),
+    where: normalizedWhere(request.where),
+    sort: normalizedSort(request.sort),
+    limit: normalizedLimit(request.limit),
+    ...(builtIn && sourceRequest.type?.trim()
+      ? { type: sourceRequest.type.trim() }
+      : {}),
+    has: builtIn ? normalizedHas(sourceRequest.has) : Object.freeze([]),
+    recursive: builtIn ? sourceRequest.recursive !== false : true,
+  }
+  for (const prop of normalized.has) {
+    if (!schema.prop(prop)) {
+      throw new Error(`Unknown registered data prop in query has: ${prop}`)
+    }
+  }
+  const plan = Object.freeze({
+    ...normalized,
+    key: stableStringify(normalized),
+  }) satisfies PreparedQueryPlan
+  queryFieldCatalog(schema, plan, named?.outputJsonSchema)
+  return plan
+}
+
+/** @internal One coarse dependency represents the complete normalized result. */
+export function queryDependency(
+  plan: Pick<PreparedQueryPlan, "key">,
+): Dependency {
+  return { type: "plugin", plugin: QUERY_DEPENDENCY_PLUGIN, key: plan.key }
+}
+
+/** @internal Discover scalar fields from the same catalog used for operators. */
+export function queryPlanFields(
+  schema: ApplicationSchema,
+  plan: PreparedQueryPlan,
+) {
+  const named =
+    plan.query === "sources" || plan.query === "blocks"
+      ? undefined
+      : schema.query(plan.query)
+  return queryFieldCatalog(schema, plan, named?.outputJsonSchema).list()
+}
+
+export class Query {
+  private index = new QueryIndex()
+  private plans = new Map<string, NormalizedRequest>()
+  private caches = new Map<string, Map<string, Promise<readonly unknown[]>>>()
+  private dependencies = new QueryDependencyIndex(MAX_VIEW_CACHES_PER_QUERY)
+  private executingPlans = new Set<string>()
+  private registeredProps?: ReadonlySet<string>
+
+  constructor(private engine: Engine) {}
+
+  indexSource(source: Source) {
+    this.registeredProps ??= new Set(
+      this.engine.schema.props().map(({ name }) => name),
+    )
+    this.index.replace(source, this.registeredProps)
+  }
+
+  unindexSource(sourcePath: string) {
+    this.index.delete(sourcePath)
+  }
+
+  viewQuery(view: View): ViewQuery {
+    return Object.freeze({
+      sources: (request?: SourceQueryRequest) =>
+        this.execute(view, "sources", request) as Promise<
+          readonly SourceSummary[]
+        >,
+      blocks: (request?: BlockQueryRequest) =>
+        this.execute(view, "blocks", request) as Promise<
+          readonly BlockSummary[]
+        >,
+      run: <Definition extends QueryDefinition>(
+        definition: Definition,
+        request?: QueryRequest<QueryDefinitionInput<Definition>>,
+      ) =>
+        this.execute(
+          view,
+          definition as QueryContribution,
+          request as QueryRequest<unknown>,
+        ) as Promise<QueryDefinitionOutput<Definition>>,
+    })
+  }
+
+  run(
+    view: View,
+    query: string | QueryContribution,
+    request?: QueryRequest<unknown>,
+  ) {
+    return this.execute(view, query, request)
+  }
+
+  async prepare(
+    query: string | QueryContribution,
+    request: QueryRequest<unknown> = {},
+  ) {
+    const registered =
+      query === "sources" || query === "blocks"
+        ? undefined
+        : this.engine.registeredQuery(query)
+    const id = typeof query === "string" ? query : registered?.id
+    if (!id || (id !== "sources" && id !== "blocks" && !registered)) {
+      throw new Error(
+        `Unknown query: ${typeof query === "string" ? query : "unregistered definition"}`,
+      )
+    }
+    const plan = await prepareQueryPlan(this.engine.schema, id, request)
+    this.plans.delete(plan.key)
+    this.plans.set(plan.key, plan)
+    this.prunePlans(plan.key)
+    return plan
+  }
+
+  async fields(
+    query: string | QueryContribution,
+    request: QueryRequest<unknown> = {},
+  ) {
+    const plan = await this.prepare(query, request)
+    return queryPlanFields(this.engine.schema, plan)
+  }
+
+  dependency(plan: Pick<NormalizedRequest, "key">): Dependency {
+    return queryDependency(plan)
+  }
+
+  transition(before?: Source, after?: Source) {
+    const changed: QueryInvalidation[] = []
+    for (const plan of this.plans.values()) {
+      if (plan.query !== "sources" && plan.query !== "blocks") continue
+      const actors = this.transitionActors(plan, before, after)
+      if (actors === false) continue
+      changed.push({
+        key: plan.key,
+        ...(actors ? { actors: Object.freeze([...actors].sort()) } : {}),
+      })
+    }
+    return this.cascade(changed)
+  }
+
+  invalidateDependencies(dependencies: Iterable<Dependency>) {
+    const changed: QueryInvalidation[] = []
+    for (const dependency of dependencies) {
+      changed.push(...this.dependencies.dependentsOf(dependencyKey(dependency)))
+    }
+    return this.cascade(changed)
+  }
+
+  private async execute(
+    view: View,
+    query: string | QueryContribution,
+    request: QueryRequest<unknown> = {},
+    parentDependencies?: Set<string>,
+  ): Promise<readonly unknown[]> {
+    const plan = await this.prepare(query, request)
+    parentDependencies?.add(`query:${plan.key}`)
+    const scope =
+      view.principal.type === "actor"
+        ? `actor:${view.principal.actor.id}`
+        : "anonymous"
+    let byView = this.caches.get(plan.key)
+    if (!byView) {
+      byView = new Map()
+      this.caches.set(plan.key, byView)
+    }
+    const cached = byView.get(scope)
+    if (cached) {
+      byView.delete(scope)
+      byView.set(scope, cached)
+      return cached
+    }
+    this.executingPlans.add(plan.key)
+    const pending = this.resolve(view, plan, scope)
+      .then((results) =>
+        plan.query === "sources" || plan.query === "blocks"
+          ? results
+          : (immutableValue(results) as readonly unknown[]),
+      )
+      .catch((error) => {
+        byView!.delete(scope)
+        throw error
+      })
+      .finally(() => this.executingPlans.delete(plan.key))
+    byView.set(scope, pending)
+    while (byView.size > MAX_VIEW_CACHES_PER_QUERY) {
+      const oldest = byView.keys().next().value as string | undefined
+      if (oldest === undefined) break
+      byView.delete(oldest)
+      this.dependencies.deleteScope(plan.key, oldest)
+    }
+    return pending
+  }
+
+  private async resolve(view: View, plan: NormalizedRequest, scope: string) {
+    const from = this.resolvedScope(view, plan.from)
+    if (!from) return Object.freeze([])
+    if (plan.query === "sources") {
+      const results = []
+      for (const source of this.index.sourceCandidates(plan)) {
+        if (!within(source.id, from, plan.recursive)) continue
+        if (this.engine.readAccess(view.principal, source) === "denied")
+          continue
+        const projected = projectSourceSummary(source, this.engine.schema)
+        if (matchesWhere(projected, plan.where)) {
+          results.push(projected)
+        }
+      }
+      return Object.freeze(
+        orderResults(results, plan.sort).slice(0, plan.limit),
+      )
+    }
+    if (plan.query === "blocks") {
+      const results = []
+      for (const indexed of this.index.blockCandidates(plan)) {
+        if (!within(indexed.source.id, from, plan.recursive)) continue
+        if (
+          this.engine.readAccess(view.principal, indexed.source) === "denied"
+        ) {
+          continue
+        }
+        const projected = projectBlockSummary(
+          indexed.source,
+          indexed.block,
+          this.engine.schema,
+        )
+        if (matchesWhere(projected, plan.where)) {
+          results.push(projected)
+        }
+      }
+      return Object.freeze(
+        orderResults(results, plan.sort).slice(0, plan.limit),
+      )
+    }
+
+    const registered = this.engine.registeredQuery(plan.query)
+    if (!registered) throw new Error(`Unknown query: ${plan.query}`)
+    const dependencies = new Set<string>()
+    const query = Object.freeze({
+      sources: (request?: SourceQueryRequest) =>
+        this.execute(view, "sources", request, dependencies),
+      blocks: (request?: BlockQueryRequest) =>
+        this.execute(view, "blocks", request, dependencies),
+      run: (definition: QueryContribution, request?: QueryRequest<unknown>) =>
+        this.execute(view, definition, request, dependencies),
+    }) as ViewQuery
+    const resolved = await registered.definition.resolve(plan.input as never, {
+      view,
+      from,
+      query,
+      depend: (dependency: Dependency) =>
+        dependencies.add(dependencyKey(dependency)),
+      ...(this.engine.appContext(registered.plugin).database
+        ? { database: this.engine.appContext(registered.plugin).database }
+        : {}),
+    })
+    const validated = (await validateSchema(
+      registered.definition.output,
+      resolved,
+      `Invalid ${registered.id} query output`,
+    )) as readonly unknown[]
+    this.recordDependencies(plan.key, scope, dependencies)
+    return Object.freeze(
+      orderResults(
+        validated.filter((record) => matchesWhere(record, plan.where)),
+        plan.sort,
+      ).slice(0, plan.limit),
+    )
+  }
+
+  private resolvedScope(view: View, scope: string) {
+    if (!scope.startsWith("~/")) return scope
+    if (view.principal.type !== "actor") return
+    return canonicalPath(
+      this.engine.environment.path.join(
+        view.principal.actor.home,
+        scope.slice(2),
+      ),
+    )
+  }
+
+  private transitionActors(
+    plan: NormalizedRequest,
+    before?: Source,
+    after?: Source,
+  ): false | undefined | Set<string> {
+    if (!plan.from.startsWith("~/")) {
+      return this.transitionMatches(plan, before, after, plan.from)
+        ? undefined
+        : false
+    }
+    const actors = new Set<string>()
+    for (const source of [before, after]) {
+      if (!source) continue
+      const actorId = this.engine.homeActorId(source.path)
+      const actor = actorId ? this.engine.actor(actorId) : undefined
+      if (!actor) continue
+      const root = canonicalPath(
+        this.engine.environment.path.join(actor.home, plan.from.slice(2)),
+      )
+      if (this.sourceMatches(plan, source, root)) actors.add(actor.id)
+    }
+    return actors.size ? actors : false
+  }
+
+  private transitionMatches(
+    plan: NormalizedRequest,
+    before: Source | undefined,
+    after: Source | undefined,
+    root: string,
+  ) {
+    return [before, after].some(
+      (source) => source && this.sourceMatches(plan, source, root),
+    )
+  }
+
+  private sourceMatches(plan: NormalizedRequest, source: Source, root: string) {
+    if (!within(source.id, root, plan.recursive)) return false
+    if (plan.query === "sources") {
+      if (plan.type && source.type !== plan.type) return false
+      if (plan.has.some((prop) => !Object.hasOwn(source.data, prop)))
+        return false
+      const projected = projectSourceSummary(source, this.engine.schema)
+      return matchesWhere(projected, plan.where)
+    }
+    return source.blocks.some((block) => {
+      if (plan.type && block.type !== plan.type) return false
+      if (plan.has.some((prop) => !Object.hasOwn(block.data, prop)))
+        return false
+      return matchesWhere(
+        projectBlockSummary(source, block, this.engine.schema),
+        plan.where,
+      )
+    })
+  }
+
+  private recordDependencies(
+    plan: string,
+    scope: string,
+    dependencies: Set<string>,
+  ) {
+    this.dependencies.replace(plan, scope, dependencies)
+  }
+
+  private invalidateCaches(key: string, actors?: readonly string[]) {
+    if (!actors) {
+      this.caches.delete(key)
+      return
+    }
+    const byView = this.caches.get(key)
+    if (!byView) return
+    for (const actor of actors) byView.delete(`actor:${actor}`)
+    if (byView.size === 0) this.caches.delete(key)
+  }
+
+  private prunePlans(current: string) {
+    if (this.plans.size <= MAX_RETAINED_QUERY_PLANS) return
+    for (const key of this.plans.keys()) {
+      if (this.plans.size <= MAX_RETAINED_QUERY_PLANS) break
+      if (
+        key === current ||
+        this.executingPlans.has(key) ||
+        this.dependencies.hasDependents(`query:${key}`) ||
+        this.engine.dependentsOf(queryDependency({ key })).size > 0
+      ) {
+        continue
+      }
+      this.removePlan(key)
+    }
+  }
+
+  private removePlan(key: string) {
+    this.plans.delete(key)
+    this.caches.delete(key)
+    this.dependencies.clear(key)
+  }
+
+  private cascade(initial: readonly QueryInvalidation[]) {
+    const pending = [...initial]
+    const invalidated = new Map<string, Set<string> | undefined>()
+    while (pending.length) {
+      const next = pending.shift()!
+      const existing = invalidated.get(next.key)
+      if (invalidated.has(next.key) && existing === undefined) continue
+      let affected = next.actors
+      if (!affected) invalidated.set(next.key, undefined)
+      else {
+        affected = affected.filter((actor) => !existing?.has(actor))
+        if (!affected.length) continue
+        const actors = existing ?? new Set<string>()
+        for (const actor of affected) actors.add(actor)
+        invalidated.set(next.key, actors)
+      }
+      this.invalidateCaches(next.key, affected)
+      pending.push(
+        ...this.dependencies.dependentsOf(`query:${next.key}`, affected),
+      )
+      this.dependencies.clear(next.key, affected)
+    }
+    return Object.freeze(
+      [...invalidated].map(([key, actors]) =>
+        Object.freeze({
+          key,
+          ...(actors ? { actors: Object.freeze([...actors].sort()) } : {}),
+        }),
+      ),
+    )
+  }
+}