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

package/src/flow/common/portChanges.ts

@@ -0,0 +1,36 @@
+import type { InputMapping } from './change.ts'
+
+export function renamedPort(
+  previous: readonly ({ readonly handle: string } | { readonly group: string })[],
+  next: readonly ({ readonly handle: string } | { readonly group: string })[],
+): readonly [oldName: string, newName: string] | undefined {
+  const previousNames = new Set(previous.flatMap((port) => ('handle' in port ? [port.handle] : [])))
+  const nextNames = new Set(next.flatMap((port) => ('handle' in port ? [port.handle] : [])))
+  const removed = [...previousNames].filter((name) => !nextNames.has(name))
+  const added = [...nextNames].filter((name) => !previousNames.has(name))
+  return removed.length == 1 && added.length == 1 ? [removed[0]!, added[0]!] : undefined
+}
+
+export function renameOutputMapping(mapping: InputMapping, nodeIds: ReadonlySet<string>, rename: readonly [string, string] | undefined): InputMapping {
+  if (rename == null || mapping.kind != 'sources') return mapping
+  const sources = mapping.sources.map((source) =>
+    source.kind == 'node' && !source.system && nodeIds.has(source.nodeId) && source.output == rename[0] ? { ...source, output: rename[1] } : source,
+  )
+  return sources.every((source, index) => source === mapping.sources[index]) ? mapping : { kind: 'sources', sources }
+}
+
+/** Carry saved mappings through a field rename and remove only fields absent from the new contract. */
+export function remapInputMappings(
+  mappings: Readonly<Record<string, InputMapping>>,
+  ports: readonly ({ readonly handle: string } | { readonly group: string })[],
+  rename: readonly [string, string] | undefined,
+): Record<string, InputMapping> {
+  const inputs = { ...mappings }
+  if (rename != null && Object.hasOwn(inputs, rename[0])) {
+    Object.defineProperty(inputs, rename[1], { value: inputs[rename[0]], enumerable: true, configurable: true, writable: true })
+    delete inputs[rename[0]]
+  }
+  const names = new Set(ports.flatMap((port) => ('handle' in port ? [port.handle] : [])))
+  for (const name of Object.keys(inputs)) if (!names.has(name)) delete inputs[name]
+  return inputs
+}

package/src/flow/common/promptTemplate.ts

@@ -0,0 +1,15 @@
+import type { JsonValue } from './change.ts'
+
+export const promptReferencePattern = /\{\{\s*([^{}\s]+)\s*\}\}/g
+
+export function renderPrompt(template: string, input: Readonly<Record<string, JsonValue>>): string {
+  return template.replace(promptReferencePattern, (match, name: string) => {
+    if (!Object.hasOwn(input, name)) return match
+    const value = input[name]!
+    return typeof value == 'string' ? value : JSON.stringify(value)
+  })
+}
+
+export function renamePromptInput(template: string, before: string, after: string): string {
+  return template.replace(promptReferencePattern, (match, name: string) => (name == before ? '{{' + after + '}}' : match))
+}

package/src/flow/common/retry.ts

@@ -0,0 +1,20 @@
+import type { GraphNode } from './change.ts'
+
+import { z } from 'zod'
+
+export interface RetryConfiguration {
+  readonly maxRetries: number
+  readonly intervalMs: number
+}
+
+export const retryNodeTypes = ['code', 'connector', 'openapi', 'http-request', 'llm', 'decision'] as const
+export const nodeRetryLimits = { maxRetries: 5, minIntervalMs: 1000, maxIntervalMs: 60000, intervalStepMs: 1000 } as const
+export const defaultNodeRetry: RetryConfiguration = { maxRetries: 2, intervalMs: 2000 }
+export const retryConfigurationSchema = z.strictObject({
+  maxRetries: z.number().int().min(0).max(nodeRetryLimits.maxRetries),
+  intervalMs: z.number().int().min(nodeRetryLimits.minIntervalMs).max(nodeRetryLimits.maxIntervalMs).multipleOf(nodeRetryLimits.intervalStepMs),
+})
+
+export function supportsNodeRetry(node: GraphNode): boolean {
+  return node.kind == 'task' && retryNodeTypes.some((type) => type == ('moduleId' in node.task ? 'code' : node.task.executor.kind))
+}

package/src/flow/common/schema.ts

@@ -0,0 +1,162 @@
+import type { Schema, SchemaDraft } from '@cfworker/json-schema'
+import type { JsonValue, PortDefinition } from '../../types/index.ts'
+import type { SchemaKeyword, SchemaMismatch } from './schemaKeywords.ts'
+
+import { Validator } from '@cfworker/json-schema'
+import { compareJSONSchema, normalizeNullableSchemaPath } from './schemaCompare.ts'
+import { isSchemaKeyword } from './schemaKeywords.ts'
+
+function jsonEqual(left: JsonValue, right: JsonValue): boolean {
+  if (left === right) return true
+  if (left == null || right == null || typeof left != 'object' || typeof right != 'object') return false
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length == right.length && left.every((value, index) => jsonEqual(value, right[index]!))
+  }
+  const leftEntries = Object.entries(left)
+  const rightRecord = right as Readonly<Record<string, JsonValue>>
+  return (
+    leftEntries.length == Object.keys(rightRecord).length &&
+    leftEntries.every(([key, value]) => Object.hasOwn(rightRecord, key) && jsonEqual(value, rightRecord[key]!))
+  )
+}
+
+export function schemaObject(schema: JsonValue): Readonly<Record<string, JsonValue>> | undefined {
+  return schema != null && typeof schema == 'object' && !Array.isArray(schema) ? (schema as Readonly<Record<string, JsonValue>>) : undefined
+}
+
+export function schemaList(value: JsonValue | undefined): readonly JsonValue[] | undefined {
+  return Array.isArray(value) ? value : undefined
+}
+
+const validators = new WeakMap<object, Validator>()
+
+export function matchesSchema(value: JsonValue, schema: JsonValue): boolean {
+  return schemaValidationErrors(value, schema).length == 0
+}
+
+export function schemaValidationErrors(value: JsonValue, schema: JsonValue): readonly string[] {
+  if (typeof schema == 'boolean') return schema ? [] : ['The schema does not allow any value.']
+  const source = schemaObject(schema)
+  if (source == null || (source.properties != null && schemaObject(source.properties) == null)) return ['Invalid output schema.']
+  try {
+    let validator = validators.get(source)
+    if (validator == null) {
+      const declaration = typeof source.$schema == 'string' ? source.$schema : ''
+      const draft: SchemaDraft = declaration.includes('draft-04')
+        ? '4'
+        : declaration.includes('draft-07')
+          ? '7'
+          : declaration.includes('2020-12')
+            ? '2020-12'
+            : '2019-09'
+      // The validator attaches reference metadata, so it must not receive the Revision object.
+      validator = new Validator(structuredClone(source) as Schema, draft)
+      validators.set(source, validator)
+    }
+    const result = validator.validate(value)
+    return result.valid ? [] : result.errors.map((issue) => `${issue.instanceLocation || '/'}: ${issue.error}`)
+  } catch {
+    return ['Output schema validation failed.']
+  }
+}
+
+interface IncompatibleCompareResult {
+  readonly kind: 'incompatible'
+  readonly error?: string
+  readonly errorPath?: readonly (string | number)[]
+}
+
+type SchemaCompareResult = { readonly kind: 'compatible' } | { readonly kind: 'compare-error'; readonly message: string } | IncompatibleCompareResult
+
+export type PortCompareResult =
+  | { readonly kind: 'compatible' }
+  | { readonly kind: 'compare-error'; readonly message: string }
+  | { readonly kind: 'incompatible'; readonly mismatch: SchemaMismatch }
+
+function compareSchemas(sourceSchema: JsonValue, targetSchema: JsonValue, sourceNullable = false, targetNullable = false): SchemaCompareResult {
+  if (targetSchema === true) return { kind: 'compatible' }
+  if (sourceSchema === false || targetSchema === false) return { kind: 'incompatible' }
+  const source = sourceSchema === true ? {} : schemaObject(sourceSchema)
+  const target = schemaObject(targetSchema)
+  if (source == null || target == null) return { kind: 'compare-error', message: 'Port schema must be an object or boolean.' }
+  const result = compareJSONSchema(
+    { nullable: sourceNullable, packageId: undefined, schema: source },
+    { nullable: targetNullable, packageId: undefined, schema: target },
+  )
+  return result.kind == 'incompatible' ? { ...result, errorPath: normalizeNullableSchemaPath(result.errorPath, targetNullable) } : result
+}
+
+function schemaValue(schema: JsonValue, path: readonly (string | number)[]): JsonValue | undefined {
+  let value: JsonValue | undefined = schema
+  for (const part of path) {
+    if (value == null || typeof value != 'object') return
+    value = Array.isArray(value) ? value[Number(part)] : schemaObject(value)?.[String(part)]
+  }
+  return value
+}
+
+function schemaMismatch(source: PortDefinition, target: PortDefinition, result: IncompatibleCompareResult): SchemaMismatch {
+  if (source.nullable && !target.nullable) return { kind: 'nullable' }
+  if (result.error == 'edgeError.binDiffType') return { kind: 'binary' }
+  if (result.error == 'edgeError.artifactDiffType') return { kind: 'artifact' }
+  const sourceSchema = schemaObject(source.jsonSchema)
+  const targetSchema = schemaObject(target.jsonSchema)
+  const fallbackKeyword = result.errorPath == null && sourceSchema != null && targetSchema != null ? rootMismatchKeyword(sourceSchema, targetSchema) : undefined
+  const path = fallbackKeyword == null ? result.errorPath : [fallbackKeyword]
+  const keyword = path?.at(-1)
+  if (typeof keyword != 'string' || !isSchemaKeyword(keyword)) return { kind: 'schema', path }
+  const ownerPath = path!.slice(0, -1)
+  return {
+    kind: 'keyword',
+    keyword,
+    path: ownerPath,
+    source: schemaValue(source.jsonSchema, [...ownerPath, keyword]),
+    target: schemaValue(target.jsonSchema, [...ownerPath, keyword]),
+  }
+}
+
+function rootMismatchKeyword(source: Readonly<Record<string, JsonValue>>, target: Readonly<Record<string, JsonValue>>): SchemaKeyword | undefined {
+  if (!jsonEqual(source.type, target.type)) return 'type'
+  if (target.const !== undefined && !jsonEqual(source.const, target.const)) return 'const'
+  if (target.enum !== undefined && !jsonEqual(source.enum, target.enum)) return 'enum'
+  const sourceRequired = new Set(Array.isArray(source.required) ? source.required : [])
+  if (Array.isArray(target.required) && target.required.some((name) => typeof name == 'string' && !sourceRequired.has(name))) return 'required'
+  for (const keyword of schemaConstraintKeywords) if (target[keyword] !== undefined && !jsonEqual(source[keyword], target[keyword])) return keyword
+}
+
+const schemaConstraintKeywords: readonly SchemaKeyword[] = [
+  'minLength',
+  'maxLength',
+  'pattern',
+  'minimum',
+  'exclusiveMinimum',
+  'maximum',
+  'exclusiveMaximum',
+  'multipleOf',
+  'minItems',
+  'maxItems',
+  'minProperties',
+  'maxProperties',
+]
+
+export function comparePorts(source: PortDefinition, target: PortDefinition): PortCompareResult {
+  const result = compareSchemas(source.jsonSchema, target.jsonSchema, source.nullable, target.nullable)
+  return result.kind == 'incompatible' ? { kind: 'incompatible', mismatch: schemaMismatch(source, target, result) } : result
+}
+
+export function portsAssignable(source: PortDefinition, target: PortDefinition): boolean {
+  return comparePorts(source, target).kind == 'compatible'
+}
+
+export function variableInputCompatible(jsonSchema: JsonValue): boolean {
+  const schema = schemaObject(jsonSchema)
+  const types = schemaList(schema?.type)
+  if (schema != null && types?.includes('string')) return compareSchemas({ type: 'string' }, { ...schema, type: 'string' }).kind == 'compatible'
+  return compareSchemas({ type: 'string' }, jsonSchema).kind == 'compatible'
+}
+
+export function hasRetiredRef(value: unknown): boolean {
+  if (value == null || typeof value != 'object') return false
+  const source = value as Readonly<Record<string, unknown>>
+  return source.contentMediaType == 'oomol/ref' || Object.values(source).some(hasRetiredRef)
+}

package/src/flow/common/schemaCompare.ts

@@ -0,0 +1,176 @@
+import { SubsetCompareResult } from '../../json-schema-subset/index.ts'
+import { createSchemaComparer } from './schemaComparer.ts'
+
+export interface CompareSchemaInfo {
+  readonly nullable?: boolean
+  readonly schema: object
+  readonly packageId: string | undefined
+}
+
+export interface CompatibleCompareResult {
+  readonly kind: 'compatible'
+}
+
+export interface IncompatibleCompareResult {
+  readonly kind: 'incompatible'
+  readonly error?: string
+  readonly errorPath?: readonly (string | number)[]
+}
+
+export interface CompareErrorResult {
+  readonly kind: 'compare-error'
+  readonly message: string
+}
+
+export type CompareResult = CompatibleCompareResult | IncompatibleCompareResult | CompareErrorResult
+
+const comparer = createSchemaComparer()
+
+function nullableSchema(schema: object, nullable: boolean | undefined): object {
+  return nullable ? { anyOf: [schema, { type: 'null' }] } : schema
+}
+
+export function normalizeNullableSchemaPath(
+  path: readonly (string | number)[] | undefined,
+  nullable: boolean | undefined,
+): readonly (string | number)[] | undefined {
+  if (path == null || !nullable || path.length === 0 || path[0] !== 'anyOf') return path
+  return path[1] === 0 ? path.slice(2) : undefined
+}
+
+export function compareJSONSchema(fromSchema: CompareSchemaInfo, toSchema: CompareSchemaInfo): CompareResult {
+  try {
+    const error: { message?: string } = {}
+    const fromResolved = resolveLocalRefs(fromSchema.schema)
+    const toResolved = resolveLocalRefs(toSchema.schema)
+    assertComparableSchema(fromResolved)
+    assertComparableSchema(toResolved)
+    const from = comparer.compile(nullableSchema(fromResolved, fromSchema.nullable), { ...fromSchema, error })
+    const to = comparer.compile(nullableSchema(toResolved, toSchema.nullable), { ...toSchema, error })
+    const { result, errorPath } = comparer.isSubset(from, to)
+    if (result == SubsetCompareResult.True) {
+      return { kind: 'compatible' }
+    } else {
+      return { kind: 'incompatible', error: error.message, errorPath }
+    }
+  } catch (error) {
+    return { kind: 'compare-error', message: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+const unsupportedComparisonKeywords: ReadonlySet<string> = new Set([
+  'contains',
+  'dependencies',
+  'dependentRequired',
+  'dependentSchemas',
+  'else',
+  'if',
+  'maxContains',
+  'minContains',
+  'prefixItems',
+  'then',
+  'unevaluatedItems',
+  'unevaluatedProperties',
+])
+
+function assertComparableSchema(schema: object): void {
+  function visit(value: unknown, path: readonly (string | number)[]): void {
+    if (value == null || typeof value != 'object' || Array.isArray(value)) return
+    const source = value as Readonly<Record<string, unknown>>
+    for (const keyword of unsupportedComparisonKeywords) {
+      if (Object.hasOwn(source, keyword)) throw new TypeError(`Unsupported schema comparison keyword at ${schemaPath([...path, keyword])}.`)
+    }
+    for (const keyword of ['additionalItems', 'additionalProperties', 'not', 'propertyNames'] as const) visit(source[keyword], [...path, keyword])
+    const items = source.items
+    if (Array.isArray(items)) items.forEach((item, index) => visit(item, [...path, 'items', index]))
+    else visit(items, [...path, 'items'])
+    for (const keyword of ['allOf', 'anyOf', 'oneOf'] as const) {
+      const variants = source[keyword]
+      if (Array.isArray(variants)) variants.forEach((item, index) => visit(item, [...path, keyword, index]))
+    }
+    for (const keyword of ['patternProperties', 'properties'] as const) {
+      const entries = source[keyword]
+      if (entries == null || typeof entries != 'object' || Array.isArray(entries)) continue
+      for (const [name, child] of Object.entries(entries)) visit(child, [...path, keyword, name])
+    }
+  }
+  visit(schema, [])
+}
+
+function schemaPath(path: readonly (string | number)[]): string {
+  return path.length == 0 ? '#' : `#/${path.map((part) => String(part).replaceAll('~', '~0').replaceAll('/', '~1')).join('/')}`
+}
+
+function resolveLocalRefs(schema: object): object {
+  function target(reference: string): unknown {
+    if (!reference.startsWith('#')) return
+    const pointer = decodeURIComponent(reference.slice(1))
+    if (pointer == '') return schema
+    if (!pointer.startsWith('/')) return
+    let value: unknown = schema
+    for (const encoded of pointer.slice(1).split('/')) {
+      if (value == null || typeof value != 'object' || Array.isArray(value)) return
+      const token = encoded.replaceAll('~1', '/').replaceAll('~0', '~')
+      if (!Object.hasOwn(value, token)) return
+      value = (value as Readonly<Record<string, unknown>>)[token]
+    }
+    return value
+  }
+
+  function visit(value: unknown, references: ReadonlySet<string>): unknown {
+    if (Array.isArray(value)) return value.map((item) => visit(item, references))
+    if (value == null || typeof value != 'object') return value
+    const source = value as Readonly<Record<string, unknown>>
+    const reference = typeof source.$ref == 'string' && source.$ref.startsWith('#') ? source.$ref : undefined
+    if (reference != null) {
+      if (references.has(reference)) throw new TypeError(`Cyclic local JSON Schema reference "${reference}".`)
+      const resolved = target(reference)
+      if (resolved === undefined) throw new TypeError(`Local JSON Schema reference "${reference}" does not exist.`)
+      const nextReferences = new Set(references)
+      nextReferences.add(reference)
+      const siblings = Object.fromEntries(Object.entries(source).filter(([key]) => key != '$ref' && key != '$defs' && key != 'definitions'))
+      const result = visit(resolved, nextReferences)
+      return Object.keys(siblings).length == 0 ? result : { allOf: [result, visit(siblings, references)] }
+    }
+    return Object.fromEntries(
+      Object.entries(source)
+        .filter(([key]) => key != '$defs' && key != 'definitions')
+        .map(([key, item]) => {
+          switch (key) {
+            case 'additionalItems':
+            case 'additionalProperties':
+            case 'contains':
+            case 'else':
+            case 'if':
+            case 'not':
+            case 'propertyNames':
+            case 'then': {
+              return [key, visit(item, references)]
+            }
+            case 'items': {
+              return [key, Array.isArray(item) ? item.map((entry) => visit(entry, references)) : visit(item, references)]
+            }
+            case 'allOf':
+            case 'anyOf':
+            case 'oneOf': {
+              return [key, Array.isArray(item) ? item.map((entry) => visit(entry, references)) : item]
+            }
+            case 'patternProperties':
+            case 'properties': {
+              if (item == null || typeof item != 'object' || Array.isArray(item)) return [key, item]
+              return [key, Object.fromEntries(Object.entries(item).map(([name, entry]) => [name, visit(entry, references)]))]
+            }
+            case 'dependencies': {
+              if (item == null || typeof item != 'object' || Array.isArray(item)) return [key, item]
+              return [key, Object.fromEntries(Object.entries(item).map(([name, entry]) => [name, Array.isArray(entry) ? entry : visit(entry, references)]))]
+            }
+            default: {
+              return [key, item]
+            }
+          }
+        }),
+    )
+  }
+
+  return visit(schema, new Set()) as object
+}

package/src/flow/common/schemaComparer.ts

@@ -0,0 +1,178 @@
+import type { ExtendsSchema, SubsetCompare } from '../../json-schema-subset/index.ts'
+
+import { isString, toPlainObject } from '@wopjs/cast'
+import { CompiledKind, getKind, isCompiledSchema } from '../../json-schema-subset/compiler/index.ts'
+import { ExpressionSingleResult, makeSubsetCompare } from '../../json-schema-subset/index.ts'
+
+export interface SchemaCompareContext {
+  readonly packageId?: string
+  readonly error: { message?: string }
+}
+
+interface StringSchemaValue {
+  readonly type: 'string'
+}
+
+function isStringLikeSchema(value: unknown): value is StringSchemaValue {
+  return toPlainObject(value)?.type === 'string'
+}
+
+function assertSchemaCompareContext(value: unknown): asserts value is SchemaCompareContext {
+  const context = toPlainObject(value)
+  const error = toPlainObject(context?.error)
+  if (context == null || error == null || (context.packageId != null && !isString(context.packageId)) || (error.message != null && !isString(error.message))) {
+    throw new TypeError('Invalid schema comparison context.')
+  }
+}
+
+function parseSchemaCompareContext(value: unknown): SchemaCompareContext {
+  if (value == null) return { error: {} }
+  assertSchemaCompareContext(value)
+  return value
+}
+
+abstract class SpecialSchema<T = unknown> implements ExtendsSchema {
+  public static setError(fromSchema: unknown, toSchema: unknown, message: string): void {
+    if (fromSchema instanceof SpecialSchema) {
+      fromSchema.context.error.message = message
+    } else if (toSchema instanceof SpecialSchema) {
+      toSchema.context.error.message = message
+    }
+  }
+
+  public readonly id: number
+  public readonly value: T
+  public readonly context: SchemaCompareContext
+
+  protected constructor(id: number, value: T, context?: unknown) {
+    this.id = id
+    this.value = value
+    this.context = parseSchemaCompareContext(context)
+  }
+
+  public compare(other: unknown): readonly ExpressionSingleResult[] {
+    if (isCompiledSchema(other) && getKind(other) === CompiledKind.Any) return [ExpressionSingleResult.ContainedBy]
+    return this.compareImpl(other)
+  }
+
+  protected abstract compareImpl(other: unknown): readonly ExpressionSingleResult[]
+
+  public abstract equals(other: unknown): boolean
+}
+
+interface SingleSelectSchemaValue {
+  readonly enum: readonly string[]
+}
+
+class SingleSelectSchema extends SpecialSchema<SingleSelectSchemaValue> {
+  public static isMatch(value: unknown): value is SingleSelectSchemaValue {
+    const enumValues = toPlainObject(value)?.enum
+    return Array.isArray(enumValues) && enumValues.every((v) => isString(v))
+  }
+
+  public constructor(id: number, value: unknown, context?: unknown) {
+    if (!SingleSelectSchema.isMatch(value)) throw new TypeError('Invalid single-select schema.')
+    super(id, value, context)
+  }
+
+  protected compareImpl(other: unknown): readonly ExpressionSingleResult[] {
+    if (isStringLikeSchema(other)) {
+      return [ExpressionSingleResult.ContainedBy]
+    }
+
+    if (other instanceof SingleSelectSchema) {
+      const f = new Set(this.value.enum)
+      let result: ExpressionSingleResult = ExpressionSingleResult.Equals
+      for (const v of other.value.enum) {
+        if (!f.has(v)) {
+          result = ExpressionSingleResult.ContainedBy
+        }
+        f.delete(v)
+      }
+      if (f.size === 0) {
+        return [result]
+      }
+      if (f.size === this.value.enum.length) {
+        return [ExpressionSingleResult.Rejection]
+      }
+      return [ExpressionSingleResult.Intersection]
+    }
+
+    return [ExpressionSingleResult.Rejection]
+  }
+
+  public equals(other: unknown): boolean {
+    if (other instanceof SingleSelectSchema) {
+      const f = new Set(this.value.enum)
+      for (const v of other.value.enum) {
+        if (!f.has(v)) {
+          return false
+        }
+        f.delete(v)
+      }
+      return f.size === 0
+    }
+    return false
+  }
+}
+
+interface BinarySchemaValue {
+  readonly contentMediaType: 'oomol/bin'
+}
+
+class BinarySchema extends SpecialSchema<BinarySchemaValue> {
+  public static isMatch(value: unknown): value is BinarySchemaValue {
+    return toPlainObject(value)?.contentMediaType === 'oomol/bin'
+  }
+
+  public constructor(id: number, value: unknown, context?: unknown) {
+    if (!BinarySchema.isMatch(value)) throw new TypeError('Invalid binary schema.')
+    super(id, value, context)
+  }
+
+  protected compareImpl(other: unknown): readonly ExpressionSingleResult[] {
+    if (other instanceof BinarySchema) {
+      return [ExpressionSingleResult.Equals]
+    } else {
+      SpecialSchema.setError(this, other, 'edgeError.binDiffType')
+      return [ExpressionSingleResult.Rejection]
+    }
+  }
+
+  public equals(other: unknown): boolean {
+    return other instanceof BinarySchema
+  }
+}
+
+interface ArtifactSchemaValue {
+  readonly contentMediaType: 'oomol/artifact'
+}
+
+class ArtifactSchema extends SpecialSchema<ArtifactSchemaValue> {
+  public static isMatch(value: unknown): value is ArtifactSchemaValue {
+    return toPlainObject(value)?.contentMediaType === 'oomol/artifact'
+  }
+
+  public constructor(id: number, value: unknown, context?: unknown) {
+    if (!ArtifactSchema.isMatch(value)) throw new TypeError('Invalid Artifact schema.')
+    super(id, value, context)
+  }
+
+  protected compareImpl(other: unknown): readonly ExpressionSingleResult[] {
+    if (other instanceof ArtifactSchema) return [ExpressionSingleResult.Equals]
+    SpecialSchema.setError(this, other, 'edgeError.artifactDiffType')
+    return [ExpressionSingleResult.Rejection]
+  }
+
+  public equals(other: unknown): boolean {
+    return other instanceof ArtifactSchema
+  }
+}
+
+export function createSchemaComparer(): SubsetCompare<unknown> {
+  const comparer = makeSubsetCompare({
+    extendsSchemaClasses: [SingleSelectSchema, BinarySchema, ArtifactSchema],
+  })
+
+  return comparer
+}

package/src/flow/common/schemaKeywords.ts

@@ -0,0 +1,53 @@
+import type { JsonValue } from '../../types/index.ts'
+
+export type SchemaKeyword =
+  | 'const'
+  | 'enum'
+  | 'exclusiveMaximum'
+  | 'exclusiveMinimum'
+  | 'maximum'
+  | 'maxItems'
+  | 'maxLength'
+  | 'maxProperties'
+  | 'minimum'
+  | 'minItems'
+  | 'minLength'
+  | 'minProperties'
+  | 'multipleOf'
+  | 'pattern'
+  | 'required'
+  | 'type'
+
+export type SchemaMismatch =
+  | { readonly kind: 'artifact' | 'binary' | 'nullable' }
+  | {
+      readonly kind: 'keyword'
+      readonly keyword: SchemaKeyword
+      readonly path: readonly (string | number)[]
+      readonly source: JsonValue | undefined
+      readonly target: JsonValue | undefined
+    }
+  | { readonly kind: 'schema'; readonly path?: readonly (string | number)[] }
+
+const schemaKeywords: ReadonlySet<string> = new Set<SchemaKeyword>([
+  'const',
+  'enum',
+  'exclusiveMaximum',
+  'exclusiveMinimum',
+  'maximum',
+  'maxItems',
+  'maxLength',
+  'maxProperties',
+  'minimum',
+  'minItems',
+  'minLength',
+  'minProperties',
+  'multipleOf',
+  'pattern',
+  'required',
+  'type',
+])
+
+export function isSchemaKeyword(value: string): value is SchemaKeyword {
+  return schemaKeywords.has(value)
+}