@oomol-lab/open-flow 0.1.0-beta.73 → 0.1.0-beta.75

package/src/flow/common/webhookResponse.ts

@@ -0,0 +1,71 @@
+import type { InputPort, JsonValue, Port, PortDefinition } from './change.ts'
+
+import { httpHeaderNameIssue } from '../../http/common/headers.ts'
+
+export const webhookResponseTimeout = {
+  defaultMs: 30_000,
+  minMs: 1000,
+  maxMs: 60_000,
+} as const
+
+export const webhookStatusCodePort = { jsonSchema: { type: 'number' }, nullable: true } as const
+
+export function webhookResponseAllowsBody(status: number): boolean {
+  return status !== 204 && status !== 205 && status !== 304
+}
+
+export const webhookHeaderValuePort = { jsonSchema: { type: ['string', 'number', 'boolean'] }, nullable: true } as const
+export const webhookHeadersPort = {
+  jsonSchema: { type: 'object', additionalProperties: { type: ['string', 'number', 'boolean'] } },
+  nullable: true,
+} as const
+
+export function workflowOutputsPort(outputs: readonly Port[]): PortDefinition {
+  return {
+    jsonSchema: {
+      type: 'object',
+      properties: Object.fromEntries(outputs.map((port) => [port.handle, port.jsonSchema])),
+      additionalProperties: false,
+      required: outputs.map((port) => port.handle),
+    },
+    nullable: false,
+  } as const
+}
+
+/** Fixed inputs belong to the node, not author-supplied definitions. */
+export const webhookResponseInputs: readonly InputPort[] = [
+  { handle: 'body', jsonSchema: {}, nullable: true, value: '' },
+  { handle: 'statusCode', jsonSchema: { type: 'number' }, nullable: false, value: 200 },
+  { handle: 'headers', jsonSchema: webhookHeadersPort.jsonSchema, nullable: false, value: {} },
+]
+
+export interface WebhookResponseSnapshot {
+  readonly body: string
+  readonly contentType: string
+  readonly status: number
+  readonly headers: Readonly<Record<string, string>>
+}
+
+export function validWebhookStatus(value: unknown): value is number {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 200 && value <= 599 && webhookResponseAllowsBody(value)
+}
+
+/** Portable validation also runs in the isolated engine, which has no HTTP globals. */
+export function webhookHeaderValues(source: unknown): Readonly<Record<string, string>> | undefined {
+  if (source == null || typeof source !== 'object' || Array.isArray(source)) return
+  const headers: Record<string, string> = {}
+  const names: string[] = []
+  for (const [name, value] of Object.entries(source)) {
+    if (httpHeaderNameIssue(name, names) != null) return
+    if (typeof value !== 'string' && typeof value !== 'boolean' && !(typeof value === 'number' && Number.isFinite(value))) return
+    const text = String(value)
+    if ([...text].some((character) => character.charCodeAt(0) > 255 || /[\0\r\n]/.test(character))) return
+    names.push(name)
+    Object.defineProperty(headers, name, { value: text, enumerable: true, configurable: true })
+  }
+  return headers
+}
+
+export function encodeWebhookBody(value: JsonValue): Pick<WebhookResponseSnapshot, 'body' | 'contentType'> {
+  return typeof value === 'string' ? { body: value, contentType: 'text/plain;charset=UTF-8' } : { body: JSON.stringify(value), contentType: 'application/json' }
+}

package/src/flow/common/workflowFile.ts

@@ -0,0 +1,97 @@
+import type { GraphNode, InputMapping, JsonValue, RevisionContent } from './change.ts'
+
+import { dequal } from 'dequal/lite'
+import { z } from 'zod'
+import { clearTriggerExternalConfig } from '../../trigger/common/config.ts'
+import { decodeRevisionContent } from './changeSchema.ts'
+import { clearConditionBindings } from './condition.ts'
+import { clearNodeConnections } from './connectionUsage.ts'
+import { checkJsonDepth } from './json.ts'
+
+export interface WorkflowFile {
+  readonly kind: 'open-flow-workflow'
+  readonly version: 1
+  readonly name?: string
+  readonly content: RevisionContent
+  readonly presentation?: Readonly<Record<string, JsonValue>>
+}
+
+export interface WorkflowCleanupSummary {
+  readonly changedNodeIds: readonly string[]
+  readonly removedBindings: number
+}
+
+const envelope = z.strictObject({
+  kind: z.literal('open-flow-workflow'),
+  version: z.literal(1),
+  name: z.string().optional(),
+  content: z.unknown(),
+  presentation: z.record(z.string(), z.json()).optional(),
+})
+
+/** Structural decoding only: incomplete drafts are supported, repair is never attempted. */
+export function decodeWorkflowFile(value: unknown): WorkflowFile {
+  checkJsonDepth(value, -1)
+  const file = envelope.parse(value)
+  return { ...file, content: decodeRevisionContent(file.content) }
+}
+
+export function parseWorkflowFile(text: string): WorkflowFile {
+  return decodeWorkflowFile(JSON.parse(text))
+}
+
+function cleanInput(input: InputMapping): InputMapping {
+  if (input.kind != 'sources' || !input.sources.some((source) => source.kind == 'binding')) return input
+  const sources = input.sources.filter((source) => source.kind != 'binding')
+  return sources.length == 0 ? { kind: 'unset' } : { kind: 'sources', sources }
+}
+
+/** Clear only owned structured references, never strings in code or business values. */
+export function cleanWorkflowFile(value: unknown): { readonly file: WorkflowFile; readonly summary: WorkflowCleanupSummary } {
+  const file = decodeWorkflowFile(value)
+  const original = file.content.document.graph
+  const graph = clearNodeConnections(original)
+  const nodes = Object.fromEntries(
+    Object.entries(graph.nodes).map(([id, source]) => {
+      let node: GraphNode = source
+      if ('inputs' in node) node = { ...node, inputs: Object.fromEntries(Object.entries(node.inputs).map(([key, input]) => [key, cleanInput(input)])) }
+      if (node.kind == 'outputs')
+        node = { ...node, outputMappings: Object.fromEntries(Object.entries(node.outputMappings).map(([key, input]) => [key, cleanInput(input)])) }
+      if (node.kind == 'condition') node = clearConditionBindings(node)
+      if (node.kind == 'error' && node.sourceFlowIds != null) node = { ...node, sourceFlowIds: [] }
+      if (node.kind == 'poll' || node.kind == 'integration') node = { ...node, config: clearTriggerExternalConfig(node.definition.key, node.config) }
+      return [id, node]
+    }),
+  )
+  return {
+    file: {
+      ...file,
+      content: {
+        ...file.content,
+        document: {
+          ...file.content.document,
+          bindings: {},
+          graph: { ...graph, nodes },
+        },
+      },
+    },
+    summary: {
+      changedNodeIds: Object.keys(nodes).filter((id) => !dequal(nodes[id], original.nodes[id])),
+      removedBindings: Object.keys(file.content.document.bindings).length,
+    },
+  }
+}
+
+export function encodeWorkflowFile(file: WorkflowFile): string {
+  return `${JSON.stringify(cleanWorkflowFile(file).file, null, 2)}\n`
+}
+
+export function workflowFileName(name: string): string {
+  // Control characters are forbidden in download filenames.
+  // oxlint-disable-next-line no-control-regex
+  return `${name.replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_').replace(/[. ]+$/g, '') || 'workflow'}.openflow.json`
+}
+
+export function workflowNameFromFile(name: string): string {
+  return name.replace(/(?:\.openflow)?\.json$/i, '')
+}

package/src/http/common/authBindings.ts

@@ -0,0 +1,12 @@
+import type { FlowDocument } from '../../flow/common/change.ts'
+
+/** Never allow credentials to enter a Revision as literal node inputs. */
+export function assertHttpAuthBindings(document: FlowDocument): void {
+  for (const node of Object.values(document.graph.nodes)) {
+    if (node.kind != 'task' || !('executor' in node.task) || !['openapi', 'http-request'].includes(node.task.executor.kind)) continue
+    for (const [handle, mapping] of Object.entries(node.inputs)) {
+      if (handle.startsWith('auth.') && mapping.kind == 'value')
+        throw new TypeError('HTTP authentication accepts deployment variables and upstream outputs only.')
+    }
+  }
+}

package/src/http/common/headers.ts

@@ -0,0 +1,5 @@
+/** Header names are case-insensitive; never silently combine duplicate business fields. */
+export function httpHeaderNameIssue(name: string, names: readonly string[]): 'invalid' | 'duplicate' | undefined {
+  if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) return 'invalid'
+  if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return 'duplicate'
+}

package/src/http/common/httpRequest.ts

@@ -0,0 +1,251 @@
+import type { InputMapping, InputPort, JsonValue, ManagedTaskDefinition, TaskNode } from '../../flow/common/change.ts'
+
+import { dequal } from 'dequal/lite'
+import { z } from 'zod'
+import { remapInputMappings, renamedPort } from '../../flow/common/portChanges.ts'
+import { httpHeaderNameIssue } from './headers.ts'
+
+const parameterSchema = z.strictObject({ mode: z.enum(['fields', 'object']).default('fields'), names: z.array(z.string()).default([]) })
+export const httpRequestConfigSchema = z.strictObject({
+  method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']).default('GET'),
+  query: parameterSchema.default({ mode: 'fields', names: [] }),
+  headers: parameterSchema.default({ mode: 'fields', names: [] }),
+  bodyFormat: z.enum(['none', 'json', 'text', 'form']).default('none'),
+  authentication: z
+    .union([
+      z.strictObject({ type: z.literal('none') }),
+      z.strictObject({ type: z.enum(['bearer', 'basic']) }),
+      z.strictObject({ type: z.literal('apiKey'), name: z.string(), in: z.enum(['header', 'query']) }),
+    ])
+    .default({ type: 'none' }),
+  responseFormat: z.enum(['auto', 'json', 'text']).default('auto'),
+  statusPolicy: z.enum(['success', 'all']).default('success'),
+})
+export type HttpRequestConfig = z.infer<typeof httpRequestConfigSchema>
+export interface HttpRequestExecutor extends HttpRequestConfig {
+  readonly kind: 'http-request'
+}
+export const httpRequestExecutorSchema = httpRequestConfigSchema.extend({ kind: z.literal('http-request') })
+const scalarSchema = { type: ['string', 'number', 'boolean'] }
+const queryValueSchema = { anyOf: [scalarSchema, { type: 'array', items: scalarSchema }] }
+export const httpHeaderSchema = { type: 'object', additionalProperties: { type: 'string' } }
+export const httpQuerySchema = { type: 'object', additionalProperties: queryValueSchema }
+
+export function httpAuthHandles(config: HttpRequestConfig): string[] {
+  return config.authentication.type == 'none' ? [] : config.authentication.type == 'basic' ? ['auth.username', 'auth.password'] : ['auth.token']
+}
+// Preserve metadata on ports whose contracts did not change.
+function retain(ports: readonly InputPort[], old: ManagedTaskDefinition['inputs']): ManagedTaskDefinition['inputs'] {
+  const remaining = new Map(ports.map((port) => [port.handle, port]))
+  return [
+    ...old.flatMap((item): ManagedTaskDefinition['inputs'] => {
+      if ('group' in item) return [item]
+      const next = remaining.get(item.handle)
+      if (next == null) return []
+      remaining.delete(item.handle)
+      return [dequal(item.jsonSchema, next.jsonSchema) && item.nullable == next.nullable ? item : next]
+    }),
+    ...remaining.values(),
+  ]
+}
+export function httpRequestTask(
+  config: HttpRequestConfig = httpRequestConfigSchema.parse({}),
+  name = 'HTTP Request',
+  previous?: ManagedTaskDefinition,
+): ManagedTaskDefinition {
+  const inputs: InputPort[] = [{ handle: 'url', jsonSchema: { type: 'string' }, nullable: false }]
+  for (const group of ['query', 'headers'] as const) {
+    if (config[group].mode == 'object') inputs.push({ handle: group, jsonSchema: group == 'query' ? httpQuerySchema : httpHeaderSchema, nullable: true })
+    else
+      for (const parameterName of config[group].names.filter((value) => value.trim()))
+        inputs.push({
+          handle: `${group == 'query' ? 'query' : 'header'}.${parameterName}`,
+          jsonSchema: group == 'query' ? queryValueSchema : { type: 'string' },
+          nullable: true,
+        })
+  }
+  if (config.bodyFormat != 'none')
+    inputs.push({
+      handle: 'body',
+      jsonSchema: config.bodyFormat == 'json' ? {} : config.bodyFormat == 'text' ? { type: 'string' } : httpQuerySchema,
+      nullable: config.bodyFormat == 'json',
+    })
+  inputs.push(...httpAuthHandles(config).map((handle) => ({ handle, jsonSchema: { type: 'string' }, nullable: false })))
+  const outputs: InputPort[] = [
+    { handle: 'body', jsonSchema: config.responseFormat == 'text' ? { type: 'string' } : {}, nullable: true },
+    { handle: 'statusCode', jsonSchema: { type: 'integer' }, nullable: false },
+    { handle: 'headers', jsonSchema: httpHeaderSchema, nullable: false },
+  ]
+
+  return {
+    name,
+    executor: { ...config, kind: 'http-request' },
+    inputs: retain(inputs, previous?.inputs ?? []),
+    outputs: retain(outputs, previous?.outputs ?? []),
+  }
+}
+export interface HttpRequestIssue {
+  field: string
+  index?: number
+  code: 'bodyUnsupported' | 'parameterNamesInvalid' | 'headerNameInvalid' | 'keyNameRequired' | 'authConflict'
+  message: string
+}
+export function httpRequestIssues(config: HttpRequestConfig): HttpRequestIssue[] {
+  const issues: HttpRequestIssue[] = []
+  if (['GET', 'HEAD'].includes(config.method) && config.bodyFormat != 'none')
+    issues.push({ field: 'bodyFormat', code: 'bodyUnsupported', message: 'GET and HEAD do not support a request body.' })
+  for (const group of ['query', 'headers'] as const) {
+    if (config[group].mode != 'fields') continue
+    const seen = new Set<string>()
+    for (const [index, name] of config[group].names.entries()) {
+      const key = group == 'headers' ? name.toLowerCase() : name
+      if (!name.trim() || seen.has(key))
+        issues.push({ field: group, index, code: 'parameterNamesInvalid', message: 'Parameter names must be nonempty and unique.' })
+      seen.add(key)
+      if (group == 'headers' && httpHeaderNameIssue(name, []) === 'invalid')
+        issues.push({ field: group, index, code: 'headerNameInvalid', message: 'Invalid HTTP header name.' })
+    }
+  }
+  const auth = config.authentication
+  if (auth.type != 'none') {
+    const group = auth.type == 'apiKey' && auth.in == 'query' ? 'query' : 'headers'
+    const name = auth.type == 'apiKey' ? auth.name : 'authorization'
+    if (!name.trim()) issues.push({ field: 'authentication', code: 'keyNameRequired', message: 'API Key requires a name.' })
+    if (group == 'headers' && name.trim() && httpHeaderNameIssue(name, []) === 'invalid')
+      issues.push({ field: 'authentication', code: 'headerNameInvalid', message: 'Invalid authentication header name.' })
+    if (config[group].mode == 'fields' && config[group].names.some((item) => (group == 'headers' ? item.toLowerCase() == name.toLowerCase() : item == name)))
+      issues.push({ field: 'authentication', code: 'authConflict', message: 'Authentication conflicts with a request parameter.' })
+  }
+  return issues
+}
+function entries(value: JsonValue | undefined): [string, JsonValue][] {
+  if (value == null) return []
+  if (typeof value != 'object' || Array.isArray(value)) throw new Error('Expected a parameter object.')
+  return Object.entries(value)
+}
+function scalar(value: JsonValue): string {
+  if (typeof value != 'string' && typeof value != 'number' && typeof value != 'boolean') throw new Error('Expected a scalar parameter.')
+  return String(value)
+}
+function append(query: URLSearchParams, name: string, value: JsonValue): void {
+  for (const item of Array.isArray(value) ? value : [value]) query.append(name, scalar(item))
+}
+export function httpRequestUrl(value: unknown): URL {
+  if (typeof value != 'string' || !value.trim()) throw new Error('A URL is required.')
+  const url = new URL(value)
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) throw new Error('An HTTP(S) URL without credentials is required.')
+  return url
+}
+export function buildHttpRequest(config: HttpRequestConfig, input: Readonly<Record<string, JsonValue>>): { url: string; init: RequestInit } {
+  if (httpRequestIssues(config).length) throw new Error('Invalid HTTP request configuration.')
+  const url = httpRequestUrl(input.url)
+  const parameters = (group: 'query' | 'headers') =>
+    config[group].mode == 'object'
+      ? entries(input[group])
+      : config[group].names.flatMap((name): [string, JsonValue][] => {
+          const value = input[`${group == 'query' ? 'query' : 'header'}.${name}`]
+          return value == null ? [] : [[name, value]]
+        })
+  for (const [name, value] of parameters('query')) {
+    url.searchParams.delete(name)
+    append(url.searchParams, name, value)
+  }
+  const headers = new Headers()
+  for (const [name, value] of parameters('headers')) {
+    if (headers.has(name)) throw new Error('Duplicate HTTP header.')
+    if (typeof value != 'string') throw new Error('HTTP headers require text values.')
+    headers.set(name, value)
+  }
+  const auth = config.authentication
+  const credential = (part: string) => {
+    const value = input[`auth.${part}`]
+    if (typeof value != 'string' || !value) throw new Error('Authentication source is required.')
+    return value
+  }
+  if (auth.type != 'none') {
+    const name = auth.type == 'apiKey' ? auth.name : 'authorization'
+    if (auth.type == 'apiKey' && auth.in == 'query') {
+      if (url.searchParams.has(name)) throw new Error('Authentication conflicts with a query parameter.')
+      url.searchParams.set(name, credential('token'))
+    } else {
+      if (headers.has(name)) throw new Error('Authentication conflicts with a header.')
+      if (auth.type == 'basic') {
+        const username = credential('username')
+        if (username.includes(':')) throw new Error('Basic username cannot contain a colon.')
+        const bytes = new TextEncoder().encode(`${username}:${credential('password')}`)
+        headers.set(name, `Basic ${btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(''))}`)
+      } else headers.set(name, auth.type == 'bearer' ? `Bearer ${credential('token')}` : credential('token'))
+    }
+  }
+  let body: string | undefined
+  if (config.bodyFormat != 'none') {
+    if (!Object.hasOwn(input, 'body')) throw new Error('Request body is unset.')
+    let contentType: string
+    if (config.bodyFormat == 'json') {
+      body = JSON.stringify(input.body)
+      contentType = 'application/json'
+    } else if (config.bodyFormat == 'text') {
+      if (typeof input.body != 'string') throw new Error('Text body requires a string.')
+      body = input.body
+      contentType = 'text/plain'
+    } else {
+      if (input.body == null) throw new Error('Form body requires an object.')
+      const form = new URLSearchParams()
+      for (const [name, value] of entries(input.body)) append(form, name, value)
+      body = form.toString()
+      contentType = 'application/x-www-form-urlencoded'
+    }
+    const supplied = headers.get('content-type')
+    if (config.bodyFormat != 'text' && supplied != null && supplied.split(';')[0]!.trim().toLowerCase() != contentType)
+      throw new Error('Content-Type conflicts with body format.')
+    if (supplied == null) headers.set('content-type', contentType)
+  }
+  return { url: url.href, init: { method: config.method, headers, body, redirect: 'manual' } }
+}
+export function parseHttpResponse(config: HttpRequestConfig, status: number, headers: Headers, text: string): Record<string, JsonValue> {
+  if (config.statusPolicy == 'success' && (status < 200 || status >= 300)) throw new Error(`HTTP ${status}`)
+  let body: JsonValue = null
+  if (text && config.method != 'HEAD' && ![204, 205, 304].includes(status)) {
+    const media = (headers.get('content-type') ?? '').split(';')[0]!.trim().toLowerCase()
+    body =
+      config.responseFormat == 'json' || (config.responseFormat == 'auto' && /^application\/(json|.+\+json)$/.test(media))
+        ? (JSON.parse(text) as JsonValue)
+        : text
+  }
+  return { body, statusCode: status, headers: Object.fromEntries([...headers].filter(([name]) => name != 'set-cookie')) }
+}
+
+/** Only a named parameter rename carries a value; changing source modes is not a rename. */
+export function httpRequestInputs(
+  mappings: Readonly<Record<string, InputMapping>>,
+  previous: ManagedTaskDefinition,
+  next: ManagedTaskDefinition,
+): Record<string, InputMapping> {
+  const candidate = renamedPort(previous.inputs, next.inputs)
+  const rename = candidate != null && ['query.', 'header.'].some((prefix) => candidate.every((name) => name.startsWith(prefix))) ? candidate : undefined
+  return remapInputMappings(mappings, next.inputs, rename)
+}
+
+/** The object editor assembles named inputs without changing unrelated request settings. */
+export function withHttpParameterFields(node: TaskNode, group: 'query' | 'headers', values: Record<string, JsonValue>): TaskNode {
+  if (!('executor' in node.task) || node.task.executor.kind !== 'http-request') return node
+  const config = node.task.executor
+  const task = httpRequestTask({ ...config, [group]: { mode: 'fields', names: Object.keys(values) } }, node.task.name, node.task)
+  const inputs = httpRequestInputs(node.inputs, node.task, task)
+  const rename = renamedPort(node.task.inputs, task.inputs)
+  for (const [name, value] of Object.entries(values)) {
+    const handle = `${group === 'query' ? 'query' : 'header'}.${name}`
+    const existing = config[group].mode === 'fields' && (config[group].names.includes(name) || rename?.[1] === handle)
+    if (inputs[handle] == null && !existing) inputs[handle] = { kind: 'value', value }
+  }
+  return { ...node, task, inputs }
+}
+
+export function withHttpParameterSource(node: TaskNode, group: 'query' | 'headers', mapping?: InputMapping): TaskNode {
+  if (!('executor' in node.task) || node.task.executor.kind !== 'http-request') return node
+  const task = httpRequestTask({ ...node.task.executor, [group]: { mode: 'object', names: [] } }, node.task.name, node.task)
+  const inputs = httpRequestInputs(node.inputs, node.task, task)
+  if (mapping == null) delete inputs[group]
+  else inputs[group] = mapping
+  return { ...node, task, inputs }
+}

package/src/json-schema-subset/checker/array.ts

@@ -0,0 +1,142 @@
+import type { CompiledSchema } from '../compiler/index.ts'
+import type { ExpressionResult } from '../expression/index.ts'
+import type { Schema } from '../types.ts'
+import type { Context } from './cache.ts'
+
+import { ANY } from '../compiler/index.ts'
+import {
+  ExpressionNone,
+  ExpressionContainedBy,
+  ExpressionContaining,
+  ExpressionEquals,
+  ExpressionIntersection,
+  ExpressionRejection,
+  ExpressionSingleResult,
+} from '../expression/index.ts'
+import { createRangeSplitter, toExpressionSingleResult } from './range.ts'
+import { makeQuantum } from './tools/index.ts'
+
+const splitRange = createRangeSplitter(0)
+const quantum = makeQuantum(['hasCommon', 'hasExtra1', 'hasExtra2', 'hasRejection', 'hasCommonBroken'])
+
+export function calculateArray<E>({ calculate }: Context<E>, schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const splitResult = splitRange(schema1.minItems, schema1.maxItems, schema2.minItems, schema2.maxItems)
+  const splitExpression = toExpressionSingleResult(splitResult)
+
+  if (splitExpression === ExpressionSingleResult.Rejection) {
+    return ExpressionRejection
+  }
+  const [items1, additionalItems1] = normalizeArray(schema1)
+  const [items2, additionalItems2] = normalizeArray(schema2)
+
+  // The final slot compares additionalItems without a tuple item.
+  const itemsLength = Math.max(items1.length, items2.length) + 1
+  const length = Math.min(itemsLength, splitResult.intersection!.max)
+  const quantumVariable = quantum.variable({})
+  const minItems = Math.min(schema1.minItems ?? 0, schema2.minItems ?? 0)
+
+  for (let i = 0; i < length; i++) {
+    const subSchema1 = items1[i] ?? additionalItems1
+    const subSchema2 = items2[i] ?? additionalItems2
+    const expression = calculate(subSchema1, subSchema2)
+
+    quantumVariable.push(expression, (singleExpression, variable) => {
+      switch (singleExpression) {
+        case ExpressionSingleResult.Equals: {
+          if (!variable.hasRejection) {
+            variable.hasCommon = true
+          }
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          if (!variable.hasRejection) {
+            variable.hasCommon = true
+          }
+          variable.hasExtra1 = true
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          if (!variable.hasRejection) {
+            variable.hasCommon = true
+          }
+          variable.hasExtra2 = true
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          if (!variable.hasRejection) {
+            variable.hasCommon = true
+          }
+          variable.hasExtra1 = true
+          variable.hasExtra2 = true
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          if (i < minItems) {
+            variable.hasCommonBroken = true
+          }
+          variable.hasRejection = true
+          variable.hasExtra1 = true
+          variable.hasExtra2 = true
+          break
+        }
+      }
+    })
+  }
+  quantumVariable.update((variable) => {
+    switch (splitExpression) {
+      case ExpressionSingleResult.Containing: {
+        variable.hasExtra1 = true
+        break
+      }
+      case ExpressionSingleResult.ContainedBy: {
+        variable.hasExtra2 = true
+        break
+      }
+      case ExpressionSingleResult.Intersection: {
+        variable.hasExtra1 = true
+        variable.hasExtra2 = true
+        break
+      }
+    }
+    if (schema1.uniqueItems && !schema2.uniqueItems && (schema2.maxItems ?? Number.POSITIVE_INFINITY) > 1) variable.hasExtra2 = true
+    else if (!schema1.uniqueItems && schema2.uniqueItems && (schema1.maxItems ?? Number.POSITIVE_INFINITY) > 1) variable.hasExtra1 = true
+    if (schema1.maxItems === 0 || schema2.maxItems === 0) {
+      // An unconstrained empty array can match any array schema.
+      variable.hasCommon = true
+      if (schema1.maxItems !== 0) {
+        variable.hasExtra1 = true
+      }
+      if (schema2.maxItems !== 0) {
+        variable.hasExtra2 = true
+      }
+    }
+  })
+  let expression = ExpressionNone
+
+  for (const { hasExtra1, hasExtra2, hasCommon, hasCommonBroken } of quantumVariable) {
+    let finalHasCommon = hasCommon
+    if (hasCommonBroken) {
+      finalHasCommon = false
+    }
+    if (!finalHasCommon) {
+      expression |= ExpressionRejection
+    } else if (hasExtra1 && hasExtra2) {
+      expression |= ExpressionIntersection
+    } else if (hasExtra1) {
+      expression |= ExpressionContaining
+    } else if (hasExtra2) {
+      expression |= ExpressionContainedBy
+    } else {
+      expression |= ExpressionEquals
+    }
+  }
+  return expression
+}
+
+function normalizeArray<E>({ items, additionalItems }: CompiledSchema<E>): [readonly Schema<E>[], Schema<E>] {
+  if (Array.isArray(items)) {
+    return [items as readonly Schema<E>[], (additionalItems ?? ANY) as Schema<E>]
+  } else {
+    return [[], (items ?? ANY) as Schema<E>]
+  }
+}

package/src/json-schema-subset/checker/cache.ts

@@ -0,0 +1,57 @@
+import type { CompiledObject, CompiledSchema, CompiledValue } from '../compiler/index.ts'
+import type { ExpressionResult } from '../expression/index.ts'
+import type { ExtendsSchema } from '../extends/index.ts'
+import type { Schema } from '../types.ts'
+import type { DeepReadonly } from '../utils.ts'
+
+import { getId, isCompiledObject } from '../compiler/index.ts'
+
+export type Context<E> = {
+  readonly isEquals: EqualsChecker
+  readonly calculate: SchemaCalculator<E>
+}
+
+export type EqualsChecker = (value1: CompiledValue, value2: CompiledValue) => boolean
+export type SchemaCalculator<E> = (superSchema: Schema<E>, subSchema: Schema<E>) => ExpressionResult
+
+export function wrapEqualsCheckerWithCache(check: (object1: CompiledObject, object2: CompiledObject) => boolean): EqualsChecker {
+  const map = new Map<string, boolean>()
+
+  return (value1, value2) => {
+    const isObject1 = isCompiledObject(value1)
+    const isObject2 = isCompiledObject(value2)
+
+    if (isObject1 !== isObject2) {
+      return false
+    }
+    if (!isObject1) {
+      return value1 === value2
+    }
+    const object1 = value1 as CompiledObject
+    const object2 = value2 as CompiledObject
+
+    return getWithCache(map, object1, object2, check)
+  }
+}
+
+export function wrapSchemaCalculatorWithCache<E>(check: SchemaCalculator<E>): SchemaCalculator<E> {
+  const map = new Map<string, ExpressionResult>()
+  return (schema1, schema2) => getWithCache(map, schema1, schema2, check)
+}
+
+function getWithCache<R, E, N extends ExtendsSchema | DeepReadonly<CompiledSchema<E>> | DeepReadonly<CompiledObject>>(
+  map: Map<string, R>,
+  node1: N,
+  node2: N,
+  check: (n1: N, n2: N) => R,
+): R {
+  const id1 = getId(node1)
+  const id2 = getId(node2)
+  const key = `${id1}/${id2}`
+
+  let result = map.get(key)
+  if (result === undefined) {
+    map.set(key, (result = check(node1, node2)))
+  }
+  return result
+}