kennel 0.2.0 → 0.2.2

package/kernel/packages/schemas/src/data/fields.ts

@@ -0,0 +1,96 @@
+import type { CoreCollection } from "./contract.ts"
+
+export function fieldValue(
+  fields: Record<string, unknown>,
+  field: string,
+): unknown {
+  let value: unknown = fields
+  for (const segment of field.split(".")) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      return undefined
+    value = (value as Record<string, unknown>)[segment]
+  }
+  return value
+}
+
+export function fieldText(value: unknown): string {
+  if (value === null || value === undefined) return ""
+  if (Array.isArray(value)) return value.map(fieldText).join(", ")
+  return typeof value === "object" ? JSON.stringify(value) : String(value)
+}
+
+export function filterOptions(
+  collection: Pick<CoreCollection, "records">,
+  field: string,
+): string[] {
+  return [
+    ...new Set(
+      collection.records
+        .map((record) => fieldText(fieldValue(record.fields, field)))
+        .filter(Boolean),
+    ),
+  ].sort()
+}
+
+const schemeUri = /^[a-z][a-z0-9+.-]*:/i
+const email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+
+function schemaProperties(
+  schema: unknown,
+): Record<string, { format?: unknown }> {
+  const properties =
+    schema && typeof schema === "object"
+      ? (schema as { properties?: unknown }).properties
+      : undefined
+  return properties &&
+    typeof properties === "object" &&
+    !Array.isArray(properties)
+    ? (properties as Record<string, { format?: unknown }>)
+    : {}
+}
+
+function disallowedSchemaFormat(schema: unknown, field: string) {
+  const property = schemaProperties(schema)[field]
+  return typeof property?.format === "string"
+    ? ["uri", "email", "date"].includes(property.format)
+    : false
+}
+
+function isGuardedValue(value: unknown) {
+  if (value === null || value === undefined) return false
+  if (Array.isArray(value)) return true
+  if (typeof value === "object") return true
+  if (typeof value !== "string") return false
+  return value.length > 80 || schemeUri.test(value) || email.test(value)
+}
+
+function everyNonNullValueIsUnique(values: unknown[]) {
+  const nonNull = values.filter(
+    (value) => value !== null && value !== undefined,
+  )
+  if (!nonNull.length) return true
+  return new Set(nonNull.map(fieldText)).size === nonNull.length
+}
+
+export function expandAllFilters(
+  collection: Pick<CoreCollection, "records"> & {
+    ui: Omit<CoreCollection["ui"], "filters"> & { filters: string | string[] }
+  },
+  schema: unknown,
+): string[] {
+  if (Array.isArray(collection.ui.filters)) return collection.ui.filters
+  const fields: string[] = []
+  for (const record of collection.records) {
+    for (const field of Object.keys(record.fields)) {
+      if (!fields.includes(field)) fields.push(field)
+    }
+  }
+  return fields.filter((field) => {
+    const values = collection.records.map((record) => record.fields[field])
+    return (
+      !disallowedSchemaFormat(schema, field) &&
+      !values.some(isGuardedValue) &&
+      !everyNonNullValueIsUnique(values)
+    )
+  })
+}

package/kernel/packages/schemas/src/data/icon-image.ts

@@ -0,0 +1,53 @@
+import { constants } from "node:fs"
+import { open } from "node:fs/promises"
+import sharp from "sharp"
+
+export const maxIconBytes = 512 * 1024
+
+/** Bound reads on the opened file, rejecting symlinks and non-regular files. */
+export async function readIconFile(path: string): Promise<Buffer | undefined> {
+  const file = await open(
+    path,
+    constants.O_RDONLY | constants.O_NOFOLLOW,
+  ).catch(() => undefined)
+  if (!file) return undefined
+  try {
+    const info = await file.stat()
+    if (!info.isFile() || !info.size || info.size > maxIconBytes)
+      return undefined
+    const data = Buffer.alloc(maxIconBytes + 1)
+    let size = 0
+    while (size < data.length) {
+      const result = await file.read(data, size, data.length - size, null)
+      if (!result.bytesRead) break
+      size += result.bytesRead
+    }
+    return size && size <= maxIconBytes ? data.subarray(0, size) : undefined
+  } finally {
+    await file.close()
+  }
+}
+
+/** Decode PNG/JPEG fully and emit a small PNG without source metadata. */
+export async function normalizeIcon(data: Buffer): Promise<Buffer | undefined> {
+  if (!data.length || data.length > maxIconBytes) return undefined
+  try {
+    const image = sharp(data, {
+      limitInputPixels: 1024 * 1024,
+      failOn: "warning",
+    })
+    const metadata = await image.metadata()
+    if (
+      !["png", "jpeg"].includes(metadata.format) ||
+      (metadata.pages ?? 1) !== 1
+    )
+      return undefined
+    const png = await image
+      .resize(64, 64, { fit: "inside", withoutEnlargement: true })
+      .png()
+      .toBuffer()
+    return png.length <= maxIconBytes ? png : undefined
+  } catch {
+    return undefined
+  }
+}

package/kernel/packages/schemas/src/data/icon.ts

@@ -0,0 +1,97 @@
+import { realpath } from "node:fs/promises"
+import { dirname, extname, isAbsolute, relative, resolve } from "node:path"
+
+import type { CoreRecordIcon } from "./contract.ts"
+import { websiteHostFromText } from "./favicon.ts"
+import { normalizeIcon, readIconFile } from "./icon-image.ts"
+
+/** Only named identity fields count; evidence links are not identity. */
+function namedField(
+  value: unknown,
+  name: string,
+  seen = new Set<object>(),
+): { value: unknown } | undefined {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    seen.has(value)
+  )
+    return undefined
+  seen.add(value)
+  const fields = value as Record<string, unknown>
+  if (Object.hasOwn(fields, name)) return { value: fields[name] }
+  for (const child of Object.values(fields)) {
+    const found = namedField(child, name, seen)
+    if (found) return found
+  }
+  return undefined
+}
+
+function bodyWebsite(body: string) {
+  let fenced = false
+  for (const raw of body.split(/\r?\n/)) {
+    if (/^\s*(```|~~~)/.test(raw)) {
+      fenced = !fenced
+      continue
+    }
+    if (fenced) continue
+    const line = raw
+      .trim()
+      .replace(/^[-*]\s+/, "")
+      .replaceAll("**", "")
+    const value = /^Website:\s*(.+)$/i.exec(line)?.[1]?.trim()
+    if (!value) continue
+    const link = /^\[[^\]]*\]\(([^\s)]+)\)$/.exec(value)?.[1]
+    return websiteHostFromText(link ?? value)
+  }
+  return undefined
+}
+
+function inside(root: string, path: string) {
+  const local = relative(root, path)
+  return local !== ".." && !local.startsWith("../") && !isAbsolute(local)
+}
+
+/** Recheck real paths on every read, not only during indexing. */
+export async function localRecordIcon(
+  path: string,
+  recordPath: string,
+  folder: string,
+) {
+  try {
+    const root = await realpath(folder)
+    const recordFolder = await realpath(dirname(recordPath))
+    const target = await realpath(path)
+    if (!inside(root, recordFolder) || !inside(recordFolder, target))
+      return undefined
+    if (![".png", ".jpg", ".jpeg"].includes(extname(target).toLowerCase()))
+      return undefined
+    const data = await readIconFile(target)
+    return data ? await normalizeIcon(data) : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** Prefer a local icon, then an explicit website field or labelled body line. */
+export async function recordIcon(
+  fields: Record<string, unknown>,
+  recordPath: string,
+  folder: string,
+  body = "",
+): Promise<CoreRecordIcon | undefined> {
+  const icon = namedField(fields, "icon")?.value
+  if (
+    typeof icon === "string" &&
+    !isAbsolute(icon) &&
+    !icon.split(/[\\/]/).includes("..")
+  ) {
+    const path = resolve(dirname(recordPath), icon)
+    if (await localRecordIcon(path, recordPath, folder))
+      return { source: "local", path }
+  }
+  const website = namedField(fields, "website")
+  const host = website ? websiteHostFromText(website.value) : bodyWebsite(body)
+  return host ? { source: "favicon", host } : undefined
+}

package/kernel/packages/schemas/src/data/load.ts

@@ -0,0 +1,161 @@
+import { createHash } from "node:crypto"
+import { readFile } from "node:fs/promises"
+import type { ValidateFunction } from "ajv"
+import AjvDefault from "ajv"
+import addFormatsDefault from "ajv-formats"
+import Ajv2020Default from "ajv/dist/2020.js"
+
+type AjvInstance = {
+  compileAsync(schema: unknown): Promise<ValidateFunction>
+  refs: Record<string, { meta?: boolean } | string>
+  removeSchema(schema: unknown): void
+  schemas: Record<string, { meta?: boolean } | string>
+}
+type AjvConstructor = new (options: Record<string, unknown>) => AjvInstance
+
+const Ajv = AjvDefault as unknown as AjvConstructor
+const Ajv2020 = Ajv2020Default as unknown as AjvConstructor
+const addFormats = addFormatsDefault as unknown as (
+  ajv: AjvInstance,
+) => AjvInstance
+
+type SchemaObject = Record<string, unknown>
+type SortEntry = { direction: "asc" | "desc"; field: string }
+
+const defaultDocuments = [{ glob: "*.md", parser: "markdown-frontmatter" }]
+
+const isObject = (value: unknown): value is SchemaObject =>
+  Boolean(value) && typeof value === "object" && !Array.isArray(value)
+
+export const hash = (value: unknown) =>
+  createHash("sha256").update(JSON.stringify(value)).digest("hex")
+
+export const text = (value: unknown) =>
+  typeof value === "string" && value.trim() ? value.trim() : undefined
+
+const remoteUrl = (value: string) => /^https?:\/\//i.test(value)
+
+const normaliseFilters = (filters: unknown) => {
+  if (filters === "all") return "all"
+  return Array.isArray(filters)
+    ? filters.filter((field) => typeof field === "string")
+    : []
+}
+
+const normaliseSort = (sort: unknown): SortEntry[] | undefined => {
+  if (!Array.isArray(sort)) return undefined
+  return sort
+    .filter(
+      (entry) =>
+        isObject(entry) &&
+        typeof entry.field === "string" &&
+        (entry.direction === "asc" || entry.direction === "desc"),
+    )
+    .map((entry) => {
+      const sort = entry as SortEntry
+      return { field: sort.field, direction: sort.direction }
+    })
+}
+
+const loadRemoteSchema = async (uri: string) => {
+  if (!remoteUrl(uri))
+    throw new Error(`Refusing to fetch non-HTTP schema reference ${uri}`)
+  const response = await fetch(uri)
+  if (!response.ok)
+    throw new Error(
+      `Failed to fetch referenced schema ${uri} (HTTP ${response.status})`,
+    )
+  return response.json()
+}
+
+/**
+ * Bare remote-$ref wrappers ({ "$ref": "https://..." }) delegate the whole
+ * schema definition to a published schema. Resolve that once so x-kennel
+ * metadata (documents, icon, ui hints) and validation come from the referenced
+ * schema, not the empty wrapper.
+ */
+export async function dereferenceSchema(schema: SchemaObject) {
+  if (typeof schema.$ref !== "string" || !remoteUrl(schema.$ref)) return schema
+  const resolved = await loadRemoteSchema(schema.$ref)
+  if (!isObject(resolved))
+    throw new Error(`Referenced schema ${schema.$ref} must be an object`)
+  return resolved
+}
+
+const ajv = addFormats(
+  new Ajv({
+    strict: false,
+    allErrors: true,
+    addUsedSchema: false,
+    loadSchema: loadRemoteSchema,
+  }),
+)
+const ajv2020 = addFormats(
+  new Ajv2020({
+    strict: false,
+    allErrors: true,
+    addUsedSchema: false,
+    loadSchema: loadRemoteSchema,
+  }),
+)
+
+export function normaliseKennelConfig(schema: SchemaObject) {
+  const config = isObject(schema["x-kennel"]) ? schema["x-kennel"] : {}
+  const documents = config.documents ?? defaultDocuments
+  if (!Array.isArray(documents))
+    throw new Error("x-kennel.documents must be an array")
+  const ui = isObject(config.ui) ? config.ui : {}
+  return {
+    title: text(config.title),
+    icon: text(config.icon),
+    documents,
+    ui: {
+      primaryField: text(ui.primaryField) ?? "title",
+      secondaryField: text(ui.secondaryField),
+      navLabel: text(ui.navLabel),
+      filters: normaliseFilters(ui.filters),
+      numericFilters: Array.isArray(ui.numericFilters)
+        ? ui.numericFilters.filter((field) => typeof field === "string")
+        : [],
+      sort: normaliseSort(ui.sort),
+    },
+  }
+}
+
+export async function compileCollectionSchema(schema: SchemaObject) {
+  const validator =
+    typeof schema.$schema === "string" && schema.$schema.includes("2020-12")
+      ? ajv2020
+      : ajv
+  try {
+    // compileAsync, not compile: remote $ref wrappers (e.g.
+    // { "$ref": "https://raggle.co/schemas/..." }) raise MissingRefError in
+    // compile; compileAsync fetches missing refs via loadSchema and retries.
+    return await validator.compileAsync(schema)
+  } finally {
+    // Rebuilds parse new objects; do not retain each version in AJV's cache.
+    validator.removeSchema(schema)
+    // compileAsync registers fetched remote schemas by URL; evict them so a
+    // later rebuild refetches instead of failing addSchema() uniqueness.
+    // Official meta-schemas (meta: true) are required and stay cached.
+    for (const store of [validator.schemas, validator.refs]) {
+      for (const key of Object.keys(store)) {
+        if (
+          remoteUrl(key) &&
+          !(store[key] as { meta?: boolean } | undefined)?.meta
+        )
+          delete store[key]
+      }
+    }
+  }
+}
+
+export async function loadCollectionSchema(schemaPath: string) {
+  let schema = JSON.parse(await readFile(schemaPath, "utf8"))
+  if (!isObject(schema)) throw new Error("Schema must be an object")
+  schema = await dereferenceSchema(schema)
+  const config = normaliseKennelConfig(schema)
+  const schemaVersion = hash(schema)
+  const validate = await compileCollectionSchema(schema)
+  return { schema, config, schemaVersion, validate }
+}

package/kernel/packages/schemas/src/data/params.ts

@@ -0,0 +1,103 @@
+export type CollectionSort = "alpha" | "recent"
+
+export type NumericRange = {
+  max?: number
+  min?: number
+}
+
+export type CollectionSearchParams = {
+  filters: Record<string, string>
+  query: string
+  ranges: Record<string, NumericRange>
+  sort?: CollectionSort
+}
+
+const filterPrefix = "f_"
+const maxPrefix = "max_"
+const minPrefix = "min_"
+const queryParam = "q"
+const sortParam = "sort"
+
+/** Read collection state from a page URL, ignoring unknown fields and empty values. */
+export function readCollectionSearchParams(
+  href: string,
+  filterFields: string[],
+  numericFields: string[],
+): CollectionSearchParams {
+  const url = new URL(href)
+  const fields = new Set(filterFields)
+  const numeric = new Set(numericFields)
+  const filters: Record<string, string> = {}
+  const ranges: Record<string, NumericRange> = {}
+  for (const [key, value] of url.searchParams) {
+    if (key.startsWith(filterPrefix) && value) {
+      const field = key.slice(filterPrefix.length)
+      if (fields.has(field)) filters[field] = value
+      continue
+    }
+    const prefix = key.startsWith(minPrefix)
+      ? minPrefix
+      : key.startsWith(maxPrefix)
+        ? maxPrefix
+        : undefined
+    if (!prefix || !value) continue
+    const field = key.slice(prefix.length)
+    const number = Number(value)
+    if (!numeric.has(field) || !Number.isFinite(number)) continue
+    ranges[field] = {
+      ...ranges[field],
+      [prefix === minPrefix ? "min" : "max"]: number,
+    }
+  }
+  return {
+    filters,
+    query: url.searchParams.get(queryParam) ?? "",
+    ranges,
+    sort: readCollectionSort(href),
+  }
+}
+
+/** Current URL order: "alpha" when set, else "recent". */
+export function readCollectionSort(href: string): CollectionSort {
+  const url = new URL(href)
+  return url.searchParams.get(sortParam) === "alpha" ? "alpha" : "recent"
+}
+
+/** URL with the order parameter set; "recent" stays default and off the URL. */
+export function collectionSortHref(href: string, sort: CollectionSort): string {
+  const url = new URL(href)
+  if (sort === "alpha") url.searchParams.set(sortParam, sort)
+  else url.searchParams.delete(sortParam)
+  return url.toString()
+}
+
+/** Build a URL with only the given collection state, preserving unrelated params. */
+export function collectionSearchParamsHref(
+  href: string,
+  params: CollectionSearchParams,
+): string {
+  const url = new URL(href)
+  url.searchParams.delete(queryParam)
+  for (const key of [...url.searchParams.keys()]) {
+    if (
+      key.startsWith(filterPrefix) ||
+      key.startsWith(minPrefix) ||
+      key.startsWith(maxPrefix)
+    )
+      url.searchParams.delete(key)
+  }
+  const query = params.query.trim()
+  if (query) url.searchParams.set(queryParam, query)
+  if (params.sort === "alpha") url.searchParams.set(sortParam, params.sort)
+  else url.searchParams.delete(sortParam)
+  for (const [field, value] of Object.entries(params.filters)) {
+    if (value) url.searchParams.set(`${filterPrefix}${field}`, value)
+  }
+  for (const [field, range] of Object.entries(params.ranges)) {
+    if (Number.isFinite(range.min))
+      url.searchParams.set(`${minPrefix}${field}`, String(range.min))
+    if (Number.isFinite(range.max))
+      url.searchParams.set(`${maxPrefix}${field}`, String(range.max))
+  }
+  return url.toString()
+}

package/kernel/packages/schemas/src/data/query.ts

@@ -0,0 +1,33 @@
+import type { CoreCollection, CoreRecord } from "./contract"
+import type { NumericRange } from "./params"
+import { fieldText, fieldValue } from "./fields"
+
+/** Records arrive sorted by the API. This pass only narrows them. */
+export function collectionRecords(
+  collection: CoreCollection,
+  filters: Record<string, string>,
+  query = "",
+  ranges: Record<string, NumericRange> = {},
+): CoreRecord[] {
+  const search = query.trim().toLocaleLowerCase()
+  return collection.records.filter(
+    (record) =>
+      (!search ||
+        `${record.title} ${Object.values(record.fields).map(fieldText).join(" ")}`
+          .toLocaleLowerCase()
+          .includes(search)) &&
+      collection.ui.filters.every(
+        (key) =>
+          !filters[key] ||
+          fieldText(fieldValue(record.fields, key)) === filters[key],
+      ) &&
+      Object.entries(ranges).every(([field, range]) => {
+        const value = fieldValue(record.fields, field)
+        return (
+          typeof value === "number" &&
+          (range.min === undefined || value >= range.min) &&
+          (range.max === undefined || value <= range.max)
+        )
+      }),
+  )
+}

package/kernel/packages/schemas/src/data/sort.ts

@@ -0,0 +1,50 @@
+import type { CoreRecord } from "./contract.ts"
+import { fieldText, fieldValue } from "./fields.ts"
+
+export type RecordSortEntry = { direction: "asc" | "desc"; field: string }
+
+export function compareDefinedField(
+  left: CoreRecord,
+  right: CoreRecord,
+  field: string,
+  direction: "asc" | "desc",
+) {
+  const leftValue = fieldValue(left.fields, field)
+  const rightValue = fieldValue(right.fields, field)
+  const leftMissing = leftValue === null || leftValue === undefined
+  const rightMissing = rightValue === null || rightValue === undefined
+  if (leftMissing || rightMissing) {
+    if (leftMissing && rightMissing) return 0
+    return leftMissing ? 1 : -1
+  }
+  const result =
+    typeof leftValue === "number" && typeof rightValue === "number"
+      ? leftValue - rightValue
+      : fieldText(leftValue).localeCompare(fieldText(rightValue))
+  return direction === "desc" ? -result : result
+}
+
+export function compareTail(left: CoreRecord, right: CoreRecord) {
+  const title = left.title.localeCompare(right.title)
+  return title === 0 ? left.id.localeCompare(right.id) : title
+}
+
+/** Declared sort order first; otherwise newest record first. Title/id break ties. */
+export function recordOrder(sort: RecordSortEntry[] | undefined) {
+  if (!Array.isArray(sort)) {
+    return (left: CoreRecord, right: CoreRecord) =>
+      right.modifiedAt - left.modifiedAt || compareTail(left, right)
+  }
+  return (left: CoreRecord, right: CoreRecord) => {
+    for (const entry of sort) {
+      const result = compareDefinedField(
+        left,
+        right,
+        entry.field,
+        entry.direction,
+      )
+      if (result) return result
+    }
+    return compareTail(left, right)
+  }
+}

package/kernel/packages/schemas/src/data/workspace.ts

@@ -0,0 +1,101 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs"
+import {
+  basename,
+  dirname,
+  isAbsolute,
+  relative,
+  resolve,
+  sep,
+} from "node:path"
+
+type SchemaDeclaration = { folder: string; schemaPath: string }
+type SchemaMatch = { schema: string; target: string }
+type Breadcrumb = { path: string; schema: boolean; title: string }
+type RaggleConfig = Record<string, unknown> & {
+  schemas?: Array<{ path?: unknown; schema?: unknown }>
+}
+
+function inside(root: string, path: string) {
+  const child = relative(root, path)
+  return (
+    child === "" ||
+    (!isAbsolute(child) && child !== ".." && !child.startsWith(`..${sep}`))
+  )
+}
+
+// Resolve declarations relative to their owner, never the currently opened child.
+export function folderWorkspace(
+  input: string,
+  { allowMissingSchemas = false }: { allowMissingSchemas?: boolean } = {},
+) {
+  const folder = realpathSync(input)
+  let schemaPath: string | undefined
+  let configPath: string | undefined
+  let config: RaggleConfig = {}
+  let root = folder
+  const schemas: SchemaDeclaration[] = []
+  const schemaRoots: string[] = []
+  for (let current = folder; ; current = dirname(current)) {
+    const localSchema = ["schema.json", "_schema.json"]
+      .map((name) => resolve(current, name))
+      .find((path) => existsSync(path) && statSync(path).isFile())
+    if (localSchema) schemaRoots.push(current)
+    schemaPath ??= localSchema
+    const candidate = resolve(current, "raggle.json")
+    if (existsSync(candidate)) {
+      const value = JSON.parse(readFileSync(candidate, "utf8")) as RaggleConfig
+      // Nearest values override parents, while schema declarations retain their owner.
+      config = { ...value, ...config }
+      configPath ??= candidate
+      root = current
+      const declarations = Array.isArray(value.schemas) ? value.schemas : []
+      const matches = declarations
+        .flatMap((entry) => {
+          if (
+            typeof entry?.path !== "string" ||
+            typeof entry?.schema !== "string"
+          )
+            return []
+          const target = resolve(current, entry.path)
+          const schema = resolve(current, entry.schema)
+          if (!inside(current, target) || !inside(current, schema))
+            throw new Error(`Schema declaration escapes ${candidate}`)
+          if (!inside(target, folder) && !inside(folder, target)) return []
+          const present = existsSync(schema) && statSync(schema).isFile()
+          if (!present && !allowMissingSchemas)
+            throw new Error(`Schema not found: ${schema}`)
+          if (present && !inside(realpathSync(current), realpathSync(schema)))
+            throw new Error(`Schema declaration escapes ${candidate}`)
+          schemaRoots.push(target)
+          if (
+            inside(folder, target) &&
+            !schemas.some((entry: SchemaDeclaration) => entry.folder === target)
+          )
+            schemas.push({ folder: target, schemaPath: schema })
+          return inside(target, folder) ? [{ target, schema }] : []
+        })
+        .sort(
+          (a: SchemaMatch, b: SchemaMatch) => b.target.length - a.target.length,
+        )
+      schemaPath ??= matches[0]?.schema
+      // A schemas owner is the workspace boundary; do not inherit unrelated ancestors.
+      if (declarations.length) break
+    }
+    if (existsSync(resolve(current, ".git")) || dirname(current) === current)
+      break
+  }
+  const breadcrumbs: Breadcrumb[] = []
+  for (
+    let current = folder;
+    inside(root, current);
+    current = dirname(current)
+  ) {
+    breadcrumbs.unshift({
+      path: current,
+      title: basename(current),
+      schema: schemaRoots.some((owner) => inside(owner, current)),
+    })
+    if (current === root) break
+  }
+  return { root, configPath, schemaPath, config, breadcrumbs, schemas }
+}