entangled-worlds-orbiters-shared 2.17.0 → 3.0.0

package/src/capabilities/schema.ts

@@ -1,164 +0,0 @@
-/**
- * Tiny JSON-Schema-subset validator (shared machinery, TypeScript).
- *
- * The ONE validator both registries use (supersedes the duplicated
- * `studio/capabilities/schema.js` + `core/edit/capabilities/schema.ts`). Deliberately NOT a
- * dependency (no zod/ajv) — the app is bundle-weight sensitive and the house style is
- * lightweight guard clauses. Each capability carries an `inputSchema` literal in this subset;
- * the SAME literal is what the future agent layer hands the model as a tool definition, so
- * there is no second schema language to keep in sync.
- *
- * Supported keywords (a pragmatic subset of JSON Schema draft-07):
- *   type        'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null'
- *               (or an array of those — value matches if it satisfies any)
- *   properties  per-key subschemas (objects)
- *   required    array of keys that must be present and not undefined (objects)
- *   items       subschema applied to every array element
- *   enum        value must be one of the listed values
- *   const       value must deep-equal the given value
- *   nullable    when true, null always passes regardless of type
- *   minimum / maximum                 numbers
- *   minLength / maxLength             strings
- *   minItems / maxItems               arrays
- *   pattern     string regex source (tested with RegExp)
- *
- * A schema with no `type` accepts any value (still honouring enum/const/properties if set).
- * Unknown keywords are ignored — forward-compatible, never throws on shape it doesn't know.
- */
-
-import { ValidationError, type SchemaIssue } from './errors.js'
-
-export type JsonType = 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean' | 'null'
-
-export interface JsonSchema {
-  type?: JsonType | JsonType[]
-  properties?: Record<string, JsonSchema>
-  required?: string[]
-  items?: JsonSchema
-  enum?: unknown[]
-  const?: unknown
-  nullable?: boolean
-  minimum?: number
-  maximum?: number
-  minLength?: number
-  maxLength?: number
-  minItems?: number
-  maxItems?: number
-  pattern?: string
-}
-
-const TYPE_CHECKS: Record<JsonType, (v: unknown) => boolean> = {
-  object: (v) => v !== null && typeof v === 'object' && !Array.isArray(v),
-  array: (v) => Array.isArray(v),
-  string: (v) => typeof v === 'string',
-  number: (v) => typeof v === 'number' && Number.isFinite(v),
-  integer: (v) => typeof v === 'number' && Number.isInteger(v),
-  boolean: (v) => typeof v === 'boolean',
-  null: (v) => v === null,
-}
-
-function deepEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true
-  if (typeof a !== typeof b || a === null || b === null || typeof a !== 'object') return false
-  const ka = Object.keys(a as object)
-  const kb = Object.keys(b as object)
-  if (ka.length !== kb.length) return false
-  return ka.every((k) => deepEqual((a as Record<string, unknown>)[k], (b as Record<string, unknown>)[k]))
-}
-
-function checkType(schema: JsonSchema, value: unknown): boolean {
-  if (schema.type == null) return true
-  const types = Array.isArray(schema.type) ? schema.type : [schema.type]
-  return types.some((t) => (TYPE_CHECKS[t] ? TYPE_CHECKS[t](value) : true))
-}
-
-function describeType(value: unknown): string {
-  if (value === null) return 'null'
-  if (Array.isArray(value)) return 'array'
-  return typeof value
-}
-
-function validateNode(schema: JsonSchema | undefined, value: unknown, path: string, issues: SchemaIssue[]): void {
-  if (!schema || typeof schema !== 'object') return
-  const at = path || '(root)'
-
-  if (schema.nullable && value === null) return
-
-  if (!checkType(schema, value)) {
-    const want = Array.isArray(schema.type) ? schema.type.join('|') : schema.type
-    issues.push({ path: at, message: `expected type ${want}, got ${describeType(value)}` })
-    return // type is the gate; downstream checks would be noise
-  }
-
-  if ('const' in schema && !deepEqual(value, schema.const)) {
-    issues.push({ path: at, message: `must equal ${JSON.stringify(schema.const)}` })
-  }
-
-  if (Array.isArray(schema.enum) && !schema.enum.some((e) => deepEqual(e, value))) {
-    issues.push({ path: at, message: `must be one of ${JSON.stringify(schema.enum)}` })
-  }
-
-  if (typeof value === 'number') {
-    if (typeof schema.minimum === 'number' && value < schema.minimum) {
-      issues.push({ path: at, message: `must be >= ${schema.minimum}` })
-    }
-    if (typeof schema.maximum === 'number' && value > schema.maximum) {
-      issues.push({ path: at, message: `must be <= ${schema.maximum}` })
-    }
-  }
-
-  if (typeof value === 'string') {
-    if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
-      issues.push({ path: at, message: `must be at least ${schema.minLength} chars` })
-    }
-    if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
-      issues.push({ path: at, message: `must be at most ${schema.maxLength} chars` })
-    }
-    if (typeof schema.pattern === 'string' && !new RegExp(schema.pattern).test(value)) {
-      issues.push({ path: at, message: `must match /${schema.pattern}/` })
-    }
-  }
-
-  if (Array.isArray(value)) {
-    if (typeof schema.minItems === 'number' && value.length < schema.minItems) {
-      issues.push({ path: at, message: `must have at least ${schema.minItems} items` })
-    }
-    if (typeof schema.maxItems === 'number' && value.length > schema.maxItems) {
-      issues.push({ path: at, message: `must have at most ${schema.maxItems} items` })
-    }
-    if (schema.items) {
-      value.forEach((el, i) => validateNode(schema.items, el, `${path}[${i}]`, issues))
-    }
-  }
-
-  if (TYPE_CHECKS.object(value)) {
-    const obj = value as Record<string, unknown>
-    if (Array.isArray(schema.required)) {
-      for (const key of schema.required) {
-        if (obj[key] === undefined) issues.push({ path: path ? `${path}.${key}` : key, message: 'is required' })
-      }
-    }
-    if (schema.properties) {
-      for (const [key, sub] of Object.entries(schema.properties)) {
-        if (obj[key] !== undefined) validateNode(sub, obj[key], path ? `${path}.${key}` : key, issues)
-      }
-    }
-  }
-}
-
-/** Returns { ok, issues }. Never throws. */
-export function validate(schema: JsonSchema, value: unknown): { ok: boolean; issues: SchemaIssue[] } {
-  const issues: SchemaIssue[] = []
-  validateNode(schema ?? {}, value, '', issues)
-  return { ok: issues.length === 0, issues }
-}
-
-/** Throws ValidationError when invalid; returns the value otherwise. Used by the registry. */
-export function assertValid<T>(schema: JsonSchema, value: T, capability: string | null = null): T {
-  const { ok, issues } = validate(schema, value)
-  if (!ok) {
-    const summary = issues.map((i) => `${i.path}: ${i.message}`).join('; ')
-    throw new ValidationError(`Invalid input${capability ? ` for "${capability}"` : ''}: ${summary}`, { capability, issues })
-  }
-  return value
-}