openhermes 2.8.0 → 4.0.1

package/lib/ohc/state.mjs

@@ -1,265 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import os from "node:os"
-
-const STATE_DIR = path.join(os.homedir(), ".local", "share", "opencode", "ohc")
-const LEGACY_FILE = path.join(os.homedir(), ".local", "share", "opencode", "ohc-state.json")
-
-function sessionPath(sessionId) {
-  const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_")
-  return path.join(STATE_DIR, `${safe}.json`)
-}
-
-function ensureDir() {
-  fs.mkdirSync(STATE_DIR, { recursive: true })
-}
-
-function migrateLegacy() {
-  try {
-    if (!fs.existsSync(LEGACY_FILE)) return
-    const raw = JSON.parse(fs.readFileSync(LEGACY_FILE, "utf8"))
-    if (typeof raw !== "object") return
-    ensureDir()
-    for (const [sid, data] of Object.entries(raw)) {
-      const sp = sessionPath(sid)
-      if (!fs.existsSync(sp)) {
-        fs.writeFileSync(sp, JSON.stringify({ ...data, migratedFrom: "legacy" }, null, 2), "utf8")
-      }
-    }
-    fs.renameSync(LEGACY_FILE, LEGACY_FILE + ".bak")
-  } catch {}
-}
-
-migrateLegacy()
-
-export function loadOhcState(sessionId) {
-  if (!sessionId) return null
-  try {
-    return JSON.parse(fs.readFileSync(sessionPath(sessionId), "utf8"))
-  } catch {
-    return null
-  }
-}
-
-export function saveOhcState(sessionId, data) {
-  if (!sessionId) return
-  ensureDir()
-  fs.writeFileSync(sessionPath(sessionId), JSON.stringify({ ...data, updatedAt: new Date().toISOString() }, null, 2), "utf8")
-}
-
-
-export function createSessionState() {
-  return {
-    sessionId: null,
-    isSubAgent: false,
-    manualMode: false,
-    pendingManualTrigger: null,
-    prune: {
-      tools: new Map(),
-      messages: {
-        byMessageId: new Map(),
-        blocksById: new Map(),
-        activeBlockIds: new Set(),
-        activeByAnchorMessageId: new Map(),
-        nextBlockId: 1,
-        nextRunId: 1,
-      },
-    },
-    nudges: {
-      contextLimitAnchors: new Set(),
-      turnNudgeAnchors: new Set(),
-      iterationNudgeAnchors: new Set(),
-    },
-    stats: {
-      pruneTokenCounter: 0,
-      totalPruneTokens: 0,
-    },
-    toolParameters: new Map(),
-    toolIdList: [],
-    messageIds: { byRawId: new Map(), byRef: new Map(), nextRef: 1 },
-    lastCompaction: 0,
-    currentTurn: 0,
-    modelContextLimit: undefined,
-    systemPromptTokens: undefined,
-    protectedTurns: { enabled: false, turns: 0 },
-    compressionTiming: { starts: new Map(), pendingByCallId: new Map(), lastDurationMs: 0, totalDurationMs: 0 },
-    lastNudgePct: 0,
-    lastAutoPruneAt: null,
-    prunedIds: new Set(),
-    summary: null,
-    anchorMessageId: null,
-    totalTokensSaved: 0,
-    totalMessagesRemoved: 0,
-    blockCount: 0,
-  }
-}
-
-function pruneMapToObj(map) {
-  return Object.fromEntries(map)
-}
-
-function pruneMapFromObj(obj) {
-  if (!obj || typeof obj !== "object") return new Map()
-  return new Map(Object.entries(obj))
-}
-
-function setToArr(s) {
-  return [...s]
-}
-
-function setFromArr(a) {
-  return new Set(Array.isArray(a) ? a : [])
-}
-
-export function serializeState(state) {
-  return {
-    sessionId: state.sessionId,
-    manualMode: state.manualMode,
-    lastCompaction: state.lastCompaction,
-    currentTurn: state.currentTurn,
-    modelContextLimit: state.modelContextLimit,
-    systemPromptTokens: state.systemPromptTokens,
-    stats: { ...state.stats },
-    nudges: {
-      contextLimitAnchors: setToArr(state.nudges.contextLimitAnchors),
-      turnNudgeAnchors: setToArr(state.nudges.turnNudgeAnchors),
-      iterationNudgeAnchors: setToArr(state.nudges.iterationNudgeAnchors),
-    },
-    prune: {
-      tools: pruneMapToObj(state.prune.tools),
-      messages: {
-        nextBlockId: state.prune?.messages?.nextBlockId || 1,
-        nextRunId: state.prune?.messages?.nextRunId || 1,
-        blocksById: pruneMapToObj(state.prune?.messages?.blocksById),
-        byMessageId: pruneMapToObj(state.prune?.messages?.byMessageId),
-        activeBlockIds: setToArr(state.prune?.messages?.activeBlockIds),
-      },
-    },
-    lastAutoPruneAt: state.lastAutoPruneAt,
-    totalTokensSaved: state.totalTokensSaved,
-    totalMessagesRemoved: state.totalMessagesRemoved,
-    blockCount: state.blockCount,
-    summary: state.summary,
-    anchorMessageId: state.anchorMessageId,
-    prunedIds: setToArr(state.prunedIds),
-    isSubAgent: state.isSubAgent || false,
-    messageIds: {
-      byRawId: pruneMapToObj(state.messageIds?.byRawId),
-      byRef: pruneMapToObj(state.messageIds?.byRef),
-      nextRef: state.messageIds?.nextRef || 1,
-    },
-    compressionTiming: {
-      starts: Object.fromEntries(state.compressionTiming?.starts || new Map()),
-      pendingByCallId: pruneMapToObj(state.compressionTiming?.pendingByCallId || new Map()),
-      lastDurationMs: state.compressionTiming?.lastDurationMs || 0,
-      totalDurationMs: state.compressionTiming?.totalDurationMs || 0,
-    },
-  }
-}
-
-export function deserializeState(saved) {
-  const state = createSessionState()
-  if (!saved) return state
-  state.sessionId = saved.sessionId || null
-  state.manualMode = saved.manualMode || false
-  state.lastCompaction = saved.lastCompaction || 0
-  state.currentTurn = saved.currentTurn || 0
-  state.modelContextLimit = saved.modelContextLimit
-  state.systemPromptTokens = saved.systemPromptTokens
-  if (saved.stats) Object.assign(state.stats, saved.stats)
-  if (saved.nudges) {
-    state.nudges.contextLimitAnchors = setFromArr(saved.nudges.contextLimitAnchors)
-    state.nudges.turnNudgeAnchors = setFromArr(saved.nudges.turnNudgeAnchors)
-    state.nudges.iterationNudgeAnchors = setFromArr(saved.nudges.iterationNudgeAnchors)
-  }
-  if (saved.prune?.tools) state.prune.tools = pruneMapFromObj(saved.prune.tools)
-  if (saved.prune?.messages) {
-    const pm = saved.prune.messages
-    state.prune.messages.nextBlockId = pm.nextBlockId || 1
-    state.prune.messages.nextRunId = pm.nextRunId || 1
-    state.prune.messages.blocksById = pruneMapFromObj(pm.blocksById)
-    state.prune.messages.byMessageId = pruneMapFromObj(pm.byMessageId)
-    state.prune.messages.activeBlockIds = setFromArr(pm.activeBlockIds)
-  }
-  state.lastAutoPruneAt = saved.lastAutoPruneAt || null
-  state.totalTokensSaved = saved.totalTokensSaved || 0
-  state.totalMessagesRemoved = saved.totalMessagesRemoved || 0
-  state.blockCount = saved.blockCount || 0
-  state.summary = saved.summary || null
-  state.anchorMessageId = saved.anchorMessageId || null
-    state.prunedIds = setFromArr(saved.prunedIds)
-  if (saved.compressionTiming) {
-    state.compressionTiming.starts = pruneMapFromObj(saved.compressionTiming.starts)
-    state.compressionTiming.lastDurationMs = saved.compressionTiming.lastDurationMs || 0
-    state.compressionTiming.totalDurationMs = saved.compressionTiming.totalDurationMs || 0
-  }
-  if (saved.messageIds) {
-    state.messageIds.byRawId = pruneMapFromObj(saved.messageIds.byRawId)
-    state.messageIds.byRef = pruneMapFromObj(saved.messageIds.byRef)
-    state.messageIds.nextRef = saved.messageIds.nextRef || 1
-  }
-  if (saved.isSubAgent !== undefined) state.isSubAgent = saved.isSubAgent
-  return state
-}
-
-export function buildToolIdList(state, messages) {
-  const ids = []
-  for (const msg of messages) {
-    if (!Array.isArray(msg.parts)) continue
-    for (const part of msg.parts) {
-      if (part.type === "tool" && part.callID) {
-        ids.push(part.callID)
-      }
-    }
-  }
-  state.toolIdList = ids
-  return ids
-}
-
-export function syncToolCache(state, messages) {
-  let userTurn = 0
-  for (const msg of messages) {
-    const hasUserText = msg.info?.role === "user" && msg.parts?.some(p => p.type === "text" && p.text?.trim())
-    if (hasUserText) userTurn++
-    if (!Array.isArray(msg.parts)) continue
-    for (const part of msg.parts) {
-      if (part.type !== "tool" || !part.callID) continue
-      const existing = state.toolParameters.get(part.callID)
-      if (existing) {
-        existing.status = part.state?.status || existing.status
-        continue
-      }
-      state.toolParameters.set(part.callID, {
-        tool: part.tool || "unknown",
-        parameters: part.state?.input || {},
-        status: part.state?.status || "pending",
-        turn: userTurn,
-        tokenCount: estimateToolTokens(part),
-        lastSeen: Date.now(),
-      })
-    }
-  }
-  state.currentTurn = Math.max(state.currentTurn, userTurn)
-}
-
-function estimateToolTokens(part) {
-  if (!part.state) return 0
-  let t = 0
-  if (part.state.input) t += JSON.stringify(part.state.input).length / 4
-  if (part.state.output) {
-    t += (typeof part.state.output === "string" ? part.state.output : JSON.stringify(part.state.output ?? "")).length / 4
-  }
-  return Math.ceil(t)
-}
-
-export function countTurns(state, messages) {
-  let userCount = 0
-  for (const msg of messages) {
-    if (msg.info?.role === "user") {
-      const parts = Array.isArray(msg.parts) ? msg.parts : []
-      const hasText = parts.some(p => p.type === "text" && p.text?.trim())
-      if (hasText) userCount++
-    }
-  }
-  return userCount
-}

package/lib/ohc/strategies/deduplication.mjs

@@ -1,72 +0,0 @@
-import { isToolNameProtected, getFilePathsFromParameters, isFilePathProtected } from "../protected-patterns.mjs"
-import { getTotalToolTokens } from "../token-utils.mjs"
-
-export function deduplicate(state, config, messages) {
-  if (state.manualMode && !config.manualMode?.automaticStrategies) return
-
-  if (!config.strategies?.deduplication?.enabled) return
-
-  const allIds = state.toolIdList
-  if (!allIds?.length) return
-
-  const unprunedIds = allIds.filter(id => !state.prune.tools.has(id))
-  if (!unprunedIds.length) return
-
-  const protectedTools = config.strategies.deduplication.protectedTools || []
-
-  const sigMap = new Map()
-
-  for (const id of unprunedIds) {
-    const meta = state.toolParameters.get(id)
-    if (!meta) continue
-
-    if (isToolNameProtected(meta.tool, protectedTools)) continue
-
-    const fps = getFilePathsFromParameters(meta.tool, meta.parameters)
-    if (isFilePathProtected(fps, config.protectedFilePatterns)) continue
-
-    const sig = createToolSignature(meta.tool, meta.parameters)
-    if (!sigMap.has(sig)) sigMap.set(sig, [])
-    sigMap.get(sig).push(id)
-  }
-
-  const toPrune = []
-  for (const ids of sigMap.values()) {
-    if (ids.length > 1) {
-      toPrune.push(...ids.slice(0, -1))
-    }
-  }
-
-  if (!toPrune.length) return
-
-  state.stats.totalPruneTokens += getTotalToolTokens(state, toPrune)
-  for (const id of toPrune) {
-    const entry = state.toolParameters.get(id)
-    state.prune.tools.set(id, entry?.tokenCount ?? 0)
-  }
-}
-
-function createToolSignature(tool, params) {
-  if (!params) return tool
-  const norm = normalizeParams(params)
-  const sorted = sortKeys(norm)
-  return `${tool}::${JSON.stringify(sorted)}`
-}
-
-function normalizeParams(p) {
-  if (typeof p !== "object" || p === null) return p
-  if (Array.isArray(p)) return p
-  const n = {}
-  for (const [k, v] of Object.entries(p)) {
-    if (v !== undefined && v !== null) n[k] = v
-  }
-  return n
-}
-
-function sortKeys(o) {
-  if (typeof o !== "object" || o === null) return o
-  if (Array.isArray(o)) return o.map(sortKeys)
-  const s = {}
-  for (const k of Object.keys(o).sort()) s[k] = sortKeys(o[k])
-  return s
-}

package/lib/ohc/strategies/index.mjs

@@ -1,2 +0,0 @@
-export { deduplicate } from "./deduplication.mjs"
-export { purgeErrors } from "./purge-errors.mjs"

package/lib/ohc/strategies/purge-errors.mjs

@@ -1,43 +0,0 @@
-import { isToolNameProtected, getFilePathsFromParameters, isFilePathProtected } from "../protected-patterns.mjs"
-import { getTotalToolTokens } from "../token-utils.mjs"
-
-export function purgeErrors(state, config, messages) {
-  if (state.manualMode && !config.manualMode?.automaticStrategies) return
-
-  if (!config.strategies?.purgeErrors?.enabled) return
-
-  const allIds = state.toolIdList
-  if (!allIds?.length) return
-
-  const unprunedIds = allIds.filter(id => !state.prune.tools.has(id))
-  if (!unprunedIds.length) return
-
-  const protectedTools = config.strategies.purgeErrors.protectedTools || []
-  const threshold = Math.max(1, config.strategies.purgeErrors.turns ?? 4)
-
-  const toPrune = []
-  for (const id of unprunedIds) {
-    const meta = state.toolParameters.get(id)
-    if (!meta) continue
-
-    if (isToolNameProtected(meta.tool, protectedTools)) continue
-
-    const fps = getFilePathsFromParameters(meta.tool, meta.parameters)
-    if (isFilePathProtected(fps, config.protectedFilePatterns)) continue
-
-    if (meta.status !== "error") continue
-
-    const turnAge = state.currentTurn - meta.turn
-    if (turnAge >= threshold) {
-      toPrune.push(id)
-    }
-  }
-
-  if (!toPrune.length) return
-
-  state.stats.totalPruneTokens += getTotalToolTokens(state, toPrune)
-  for (const id of toPrune) {
-    const entry = state.toolParameters.get(id)
-    state.prune.tools.set(id, entry?.tokenCount ?? 0)
-  }
-}

package/lib/ohc/token-utils.mjs

@@ -1,26 +0,0 @@
-import { totalTokens } from "./reaper.mjs"
-
-export { totalTokens }
-
-export function countTokens(value) {
-  if (typeof value === "string") return Math.ceil(value.length / 4)
-  if (typeof value === "object" && value !== null) return Math.ceil(JSON.stringify(value).length / 4)
-  return 0
-}
-
-export function getTotalToolTokens(state, toolIds) {
-  let total = 0
-  for (const id of toolIds) {
-    const entry = state.toolParameters.get(id)
-    if (entry?.tokenCount) total += entry.tokenCount
-  }
-  return total
-}
-
-function estimateToolTokenCost(part) {
-  if (part.type !== "tool") return 0
-  let t = 0
-  if (part.state?.input) t += countTokens(part.state.input)
-  if (part.state?.output) t += countTokens(part.state.output)
-  return t
-}

package/lib/ohc/updater.mjs

@@ -1,132 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import os from "node:os"
-
-const CONFIG_PATH = path.join(os.homedir(), ".config", "opencode", "opencode.json")
-const CACHE_ROOTS = [
-  path.join(os.homedir(), ".cache", "opencode", "packages"),
-  path.join(os.homedir(), ".cache", "opencode", "node_modules"),
-]
-
-function detectInstallMethod() {
-  let raw = {}
-  try {
-    raw = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"))
-  } catch {
-    return { method: "unknown", entry: null, reason: `cannot read ${CONFIG_PATH}` }
-  }
-
-  const plugins = Array.isArray(raw.plugin) ? raw.plugin : []
-  for (const p of plugins) {
-    const entry = typeof p === "string" ? p : (Array.isArray(p) && typeof p[0] === "string" ? p[0] : "")
-    if (!entry.startsWith("openhermes")) continue
-
-    if (entry.includes("@git+https://") || entry.includes("@git+ssh://")) {
-      const repoUrl = entry.replace(/^openhermes@/, "")
-      return { method: "git", entry, repoUrl }
-    }
-
-    if (entry === "openhermes") {
-      return { method: "npm", entry }
-    }
-
-    return { method: "other", entry, reason: `unrecognized format: ${entry}` }
-  }
-
-  return { method: "unknown", entry: null, reason: "openhermes not found in plugin config" }
-}
-
-function walkCacheDirs(root, results) {
-  if (!fs.existsSync(root)) return
-  if (path.basename(root).startsWith("openhermes")) {
-    results.push({ name: path.basename(root), path: root })
-  }
-  let entries = []
-  try {
-    entries = fs.readdirSync(root, { withFileTypes: true })
-  } catch {
-    return
-  }
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-    const full = path.join(root, entry.name)
-    if (entry.name.startsWith("openhermes")) {
-      results.push({ name: entry.name, path: full })
-    }
-    walkCacheDirs(full, results)
-  }
-}
-
-export function findCacheDirs({ cacheRoots = CACHE_ROOTS } = {}) {
-  const results = []
-  for (const root of cacheRoots) walkCacheDirs(root, results)
-  const seen = new Set()
-  return results.filter(dir => {
-    if (seen.has(dir.path)) return false
-    seen.add(dir.path)
-    return true
-  })
-}
-
-async function handleUpdateMe(ctx, input, output) {
-  const info = detectInstallMethod()
-
-  if (info.method === "unknown") {
-    output.parts.length = 0
-    output.parts.push({
-      type: "text",
-      text: `[Update-Me] Could not detect installation method.\n${info.reason}\n\nEnsure 'openhermes' is in your opencode.json plugin list:\n  https://github.com/nathwn12/openhermes#setup`,
-    })
-    return
-  }
-
-  const cacheDirs = findCacheDirs()
-
-  if (cacheDirs.length === 0) {
-    output.parts.length = 0
-    output.parts.push({
-      type: "text",
-      text: `[Update-Me] No OpenHermes plugin cache found.\nRestart OpenCode to redownload from ${info.method === "git" ? "git HEAD" : "npm registry"}.`,
-    })
-    return
-  }
-
-  let clearedCount = 0
-  let failedCount = 0
-  let firstError = null
-  for (const dir of cacheDirs) {
-    try {
-      fs.rmSync(dir.path, { recursive: true, force: true })
-      clearedCount++
-    } catch (e) {
-      failedCount++
-      if (!firstError) firstError = e.message
-    }
-  }
-
-  output.parts.length = 0
-  let msg = `[Update-Me] OpenHermes update (${info.method})\n`
-
-  if (clearedCount > 0) {
-    msg += `\n  ✓ Cleared OpenHermes plugin cache (${clearedCount} entr${clearedCount === 1 ? "y" : "ies"}).`
-  }
-
-  if (failedCount > 0) {
-    msg += `\n  ⚠ ${failedCount} entr${failedCount === 1 ? "y" : "ies"} could not be removed (may be locked).`
-    if (firstError) msg += `\n  ${firstError}`
-  }
-
-  msg += `\n\nRestart OpenCode to load the latest OpenHermes from ${info.method === "git" ? "git HEAD" : "npm registry"}.`
-
-  output.parts.push({ type: "text", text: msg })
-}
-
-export function UpdaterPlugin(ctx) {
-  return {
-    "command.execute.before": async (input, output) => {
-      if (input.command !== "update-me") return
-      await handleUpdateMe(ctx, input, output)
-    },
-  }
-}

package/lib/paths.mjs

@@ -1,49 +0,0 @@
-import path from "node:path"
-import os from "node:os"
-import fs from "node:fs"
-import { fileURLToPath } from "node:url"
-import { isTruthy } from "./hardening.mjs"
-
-const HOME = process.env.USERPROFILE || os.homedir()
-const DATA_ROOT = path.join(HOME, ".local", "share", "opencode", "openhermes")
-const CACHE_ROOT = path.join(HOME, ".cache", "opencode", "openhermes")
-const PKG_DIR = path.dirname(fileURLToPath(import.meta.url))
-
-function resolveRoot(envVar, fallback) {
-  if (!isTruthy(process.env.OPENCODE_ALLOW_PROJECT_HARNESS)) return fallback
-  const cwd = process.cwd()
-  const project = path.join(cwd, ".opencode", "openhermes")
-  try { fs.accessSync(path.join(project, "memory")); return project } catch {}
-  return fallback
-}
-
-
-export function getDataRoot() {
-  return resolveRoot("OPENCODE_ALLOW_PROJECT_HARNESS", DATA_ROOT)
-}
-
-export function getCacheRoot() {
-  return CACHE_ROOT
-}
-
-export function getMemoryRoot() {
-  return path.join(getDataRoot(), "memory")
-}
-
-export function getRuntimeRoot() {
-  return path.join(getDataRoot(), "runtime")
-}
-
-export function getRecallRoot() {
-  return path.join(getCacheRoot(), "recall")
-}
-
-export function getArchiveRoot() {
-  return path.join(getDataRoot(), "archive")
-}
-
-export function getSchemaRoot() {
-  return path.resolve(PKG_DIR, "..", "schemas")
-}
-
-

package/lib/schema-validator.mjs

@@ -1,79 +0,0 @@
-import { isPlainObject } from "./hardening.mjs"
-
-const SUPPORTED_SCHEMA_KEYS = new Set(["type", "const", "enum", "format", "minimum", "maximum", "required", "properties", "items"])
-const SCHEMA_METADATA_KEYS = new Set(["$schema", "title", "description", "default"])
-
-function matchesType(type, value) {
-  if (type === "null") return value === null
-  if (type === "array") return Array.isArray(value)
-  if (type === "object") return isPlainObject(value)
-  if (type === "integer") return Number.isInteger(value)
-  if (type === "number") return typeof value === "number" && Number.isFinite(value)
-  return typeof value === type
-}
-
-function validateNode(schema, value, at, errors) {
-  if (!isPlainObject(schema) || value === undefined) return
-  if (schema.const !== undefined && JSON.stringify(value) !== JSON.stringify(schema.const)) errors.push(`${at} must equal ${JSON.stringify(schema.const)}`)
-  if (Array.isArray(schema.enum) && !schema.enum.some(option => JSON.stringify(option) === JSON.stringify(value))) errors.push(`${at} must be one of ${schema.enum.map(option => JSON.stringify(option)).join(", ")}`)
-
-  const types = Array.isArray(schema.type) ? schema.type : (schema.type ? [schema.type] : [])
-  if (types.length && !types.some(type => matchesType(type, value))) {
-    errors.push(`${at} must be ${types.join(" or ")}`)
-    return
-  }
-
-  if (typeof value === "string" && schema.format === "date-time" && Number.isNaN(Date.parse(value))) errors.push(`${at} must be a valid date-time string`)
-  if (typeof value === "number") {
-    if (schema.minimum !== undefined && value < schema.minimum) errors.push(`${at} must be >= ${schema.minimum}`)
-    if (schema.maximum !== undefined && value > schema.maximum) errors.push(`${at} must be <= ${schema.maximum}`)
-  }
-
-  if (Array.isArray(value)) {
-    value.forEach((item, index) => validateNode(schema.items, item, `${at}[${index}]`, errors))
-    return
-  }
-
-  if (isPlainObject(value)) {
-    for (const key of Array.isArray(schema.required) ? schema.required : []) {
-      if (value[key] === undefined) errors.push(`${at}.${key} is required`)
-    }
-    for (const [key, child] of Object.entries(isPlainObject(schema.properties) ? schema.properties : {})) {
-      if (value[key] !== undefined) validateNode(child, value[key], `${at}.${key}`, errors)
-    }
-  }
-}
-
-function validateSchema(schema, value, at = "$") {
-  const errors = []
-  validateNode(schema, value, at, errors)
-  return errors
-}
-
-function visitSchemaNode(schema, at, unsupported) {
-  if (!isPlainObject(schema)) return
-  for (const [key, value] of Object.entries(schema)) {
-    if (key === "properties") {
-      if (!isPlainObject(value)) unsupported.push(`${at}.properties must be an object`)
-      else for (const [propertyName, propertySchema] of Object.entries(value)) visitSchemaNode(propertySchema, `${at}.properties.${propertyName}`, unsupported)
-      continue
-    }
-    if (key === "items") {
-      visitSchemaNode(value, `${at}.items`, unsupported)
-      continue
-    }
-    if (key === "$defs" || key === "definitions") {
-      if (isPlainObject(value)) for (const defName of Object.keys(value)) visitSchemaNode(value[defName], `${at}.${key}.${defName}`, unsupported)
-      continue
-    }
-    if (!SUPPORTED_SCHEMA_KEYS.has(key) && !SCHEMA_METADATA_KEYS.has(key)) unsupported.push(`${at} uses unsupported schema keyword "${key}"`)
-  }
-}
-
-function findUnsupportedSchemaKeywords(schema) {
-  const unsupported = []
-  visitSchemaNode(schema, "$", unsupported)
-  return unsupported
-}
-
-export { findUnsupportedSchemaKeywords, isPlainObject, validateSchema }