copperhead 0.6.0 → 0.8.0

package/src/kicad/spice.ts

@@ -0,0 +1,399 @@
+/**
+ * Parser and assertion compiler for the opt-in SPICE verification gate.
+ *
+ * This module is deliberately pure: it reads strings and produces data or
+ * ngspice deck fragments. Process execution belongs to the wrapper in task 1.1.
+ */
+
+export type SpiceAnalysis = 'op' | 'dc' | 'ac' | 'tran';
+
+export type SimulationScope =
+  | { kind: 'sheet'; sheet: string }
+  | { kind: 'nets'; nets: string[] };
+
+export interface SpiceNumber {
+  raw: string;
+  value: number;
+  unit: string;
+}
+
+export type SpiceMeasurable =
+  | { kind: 'voltage'; target: string }
+  | { kind: 'current'; target: string }
+  | { kind: 'corner'; target: string };
+
+export type SpiceComparator =
+  | { kind: 'between'; lower: SpiceNumber; upper: SpiceNumber }
+  | { kind: 'less-than'; bound: SpiceNumber }
+  | { kind: 'greater-than'; bound: SpiceNumber };
+
+export interface SimulationAssertion {
+  raw: string;
+  line: number;
+  measurable: SpiceMeasurable;
+  comparator: SpiceComparator;
+}
+
+export interface SimulationSource {
+  port: string;
+  value: SpiceNumber;
+  line: number;
+}
+
+export interface SimulationBlock {
+  line: number;
+  scope: SimulationScope;
+  analysis: SpiceAnalysis;
+  sources: SimulationSource[];
+  assertions: SimulationAssertion[];
+}
+
+export interface CompiledSpiceAssertion {
+  valueName: string;
+  checks: Array<{
+    name: string;
+    pass: 'nonnegative' | 'positive';
+  }>;
+  lines: string[];
+  deck: string;
+}
+
+export class SimulationParseError extends Error {
+  readonly line: number;
+
+  constructor(line: number, message: string) {
+    super(`line ${line}: ${message}`);
+    this.name = 'SimulationParseError';
+    this.line = line;
+  }
+}
+
+const ANALYSES = new Set<SpiceAnalysis>(['op', 'dc', 'ac', 'tran']);
+const SAFE_TARGET = /^[A-Za-z0-9_./:+-]+$/;
+const SAFE_MEASURE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+const SI_MULTIPLIERS: Readonly<Record<string, number>> = {
+  '': 1,
+  t: 1e12,
+  g: 1e9,
+  meg: 1e6,
+  k: 1e3,
+  m: 1e-3,
+  u: 1e-6,
+  n: 1e-9,
+  p: 1e-12,
+  f: 1e-15,
+};
+
+/** Parse a SPICE-style number while preserving the original safe literal. */
+export function parseSpiceNumber(raw: string, line = 1): SpiceNumber {
+  const token = raw.trim();
+  const match =
+    /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(meg|[tgkmunpf])?([a-z]*)$/i.exec(
+      token,
+    );
+  if (!match) {
+    throw new SimulationParseError(line, `invalid SPICE number "${raw}"`);
+  }
+
+  const base = Number(match[1]);
+  const suffix = (match[2] ?? '').toLowerCase();
+  // The regex limits suffixes to keys in SI_MULTIPLIERS.
+  const multiplier = SI_MULTIPLIERS[suffix]!;
+
+  const value = base * multiplier;
+  if (!Number.isFinite(value)) {
+    throw new SimulationParseError(line, `SPICE number is out of range "${raw}"`);
+  }
+
+  return {
+    raw: token,
+    value,
+    unit: match[3] ?? '',
+  };
+}
+
+/** Parse one assertion from the closed grammar in the SPICE delta spec. */
+export function parseSpiceAssertion(raw: string, line = 1): SimulationAssertion {
+  const text = raw.trim();
+  const measurableMatch = /^(V|I|corner)\(([^()\s]+)\)\s+(.+)$/i.exec(text);
+  if (!measurableMatch) {
+    throw new SimulationParseError(line, `invalid SPICE assertion "${raw}"`);
+  }
+
+  const target = measurableMatch[2]!;
+  if (!SAFE_TARGET.test(target)) {
+    throw new SimulationParseError(line, `invalid measurable target "${target}"`);
+  }
+
+  const measurableToken = measurableMatch[1]!.toLowerCase();
+  const measurable: SpiceMeasurable =
+    measurableToken === 'v'
+      ? { kind: 'voltage', target }
+      : measurableToken === 'i'
+        ? { kind: 'current', target }
+        : { kind: 'corner', target };
+
+  const comparatorText = measurableMatch[3]!.trim();
+  const betweenMatch = /^between\s+(\S+)\s+and\s+(\S+)$/i.exec(comparatorText);
+  let comparator: SpiceComparator;
+
+  if (betweenMatch) {
+    const lower = parseSpiceNumber(betweenMatch[1]!, line);
+    const upper = parseSpiceNumber(betweenMatch[2]!, line);
+    if (lower.unit.toLowerCase() !== upper.unit.toLowerCase()) {
+      throw new SimulationParseError(line, 'between bounds use different units');
+    }
+    if (lower.value >= upper.value) {
+      throw new SimulationParseError(line, 'between lower bound must be less than upper bound');
+    }
+    comparator = { kind: 'between', lower, upper };
+  } else {
+    const singleMatch = /^([<>])\s*(\S+)$/.exec(comparatorText);
+    if (!singleMatch) {
+      throw new SimulationParseError(line, `invalid comparator "${comparatorText}"`);
+    }
+    const bound = parseSpiceNumber(singleMatch[2]!, line);
+    comparator =
+      singleMatch[1] === '<'
+        ? { kind: 'less-than', bound }
+        : { kind: 'greater-than', bound };
+  }
+
+  return { raw: text, line, measurable, comparator };
+}
+
+/**
+ * Parse every `## Simulation` section from SUBSYSTEMS.md.
+ *
+ * Fields are line-oriented so errors can always identify the source line.
+ */
+export function parseSimulationBlocks(markdown: string): SimulationBlock[] {
+  const lines = markdown.split(/\r?\n/);
+  const blocks: SimulationBlock[] = [];
+  let openFence: string | null = null;
+  let inDocumentComment = false;
+
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index]!.trim();
+    const fence = markdownFence(line);
+    if (openFence) {
+      if (fence) openFence = toggleFence(openFence, fence);
+      continue;
+    }
+    if (inDocumentComment) {
+      if (line.includes('-->')) inDocumentComment = false;
+      continue;
+    }
+    if (fence) {
+      openFence = fence;
+      continue;
+    }
+    if (line.startsWith('<!--')) {
+      if (!line.includes('-->')) inDocumentComment = true;
+      continue;
+    }
+    if (!/^##\s+Simulation\s*$/i.test(line)) continue;
+
+    const headingLine = index + 1;
+    const body: Array<{ text: string; line: number }> = [];
+    let cursor = index + 1;
+    let inComment = false;
+    let bodyFence: string | null = null;
+
+    for (; cursor < lines.length; cursor++) {
+      const text = lines[cursor]!;
+      const trimmed = text.trim();
+      const bodyFenceMarker = markdownFence(trimmed);
+      if (bodyFence) {
+        if (bodyFenceMarker) bodyFence = toggleFence(bodyFence, bodyFenceMarker);
+        continue;
+      }
+      if (inComment) {
+        if (trimmed.includes('-->')) inComment = false;
+        continue;
+      }
+      if (bodyFenceMarker) {
+        bodyFence = bodyFenceMarker;
+        continue;
+      }
+      if (/^#{1,6}\s+/.test(trimmed)) break;
+
+      if (trimmed.startsWith('<!--')) {
+        if (!trimmed.includes('-->')) inComment = true;
+        continue;
+      }
+      if (trimmed.startsWith('.') || /^[A-Za-z]+\s*:/.test(trimmed)) {
+        body.push({ text: trimmed, line: cursor + 1 });
+      }
+    }
+
+    blocks.push(parseSimulationBlock(body, headingLine));
+    index = cursor - 1;
+  }
+
+  return blocks;
+}
+
+function markdownFence(line: string): string | null {
+  return /^(`{3,}|~{3,})/.exec(line)?.[1] ?? null;
+}
+
+function toggleFence(openFence: string | null, marker: string): string | null {
+  if (!openFence) return marker;
+  if (marker[0] === openFence[0] && marker.length >= openFence.length) return null;
+  return openFence;
+}
+
+function parseSimulationBlock(
+  body: Array<{ text: string; line: number }>,
+  headingLine: number,
+): SimulationBlock {
+  let scope: SimulationScope | undefined;
+  let analysis: SpiceAnalysis | undefined;
+  const sources: SimulationSource[] = [];
+  const assertions: SimulationAssertion[] = [];
+
+  for (const entry of body) {
+    if (entry.text.startsWith('.')) {
+      throw new SimulationParseError(
+        entry.line,
+        `raw ngspice statement "${entry.text.split(/\s/, 1)[0]}" is not allowed`,
+      );
+    }
+
+    const fieldMatch = /^([A-Za-z]+)\s*:\s*(.+)$/.exec(entry.text);
+    if (!fieldMatch) {
+      throw new SimulationParseError(entry.line, `expected "field: value", got "${entry.text}"`);
+    }
+
+    const field = fieldMatch[1]!.toLowerCase();
+    const value = fieldMatch[2]!.trim();
+
+    switch (field) {
+      case 'scope':
+        if (scope) throw new SimulationParseError(entry.line, 'duplicate scope');
+        scope = parseScope(value, entry.line);
+        break;
+      case 'analysis': {
+        if (analysis) throw new SimulationParseError(entry.line, 'duplicate analysis');
+        const candidate = value.toLowerCase();
+        if (!ANALYSES.has(candidate as SpiceAnalysis)) {
+          throw new SimulationParseError(entry.line, `unsupported analysis "${value}"`);
+        }
+        analysis = candidate as SpiceAnalysis;
+        break;
+      }
+      case 'source':
+      case 'sources':
+        sources.push(parseSource(value, entry.line));
+        break;
+      case 'assert':
+        assertions.push(parseSpiceAssertion(value, entry.line));
+        break;
+      default:
+        throw new SimulationParseError(entry.line, `unknown Simulation field "${field}"`);
+    }
+  }
+
+  if (!scope) throw new SimulationParseError(headingLine, 'Simulation block is missing scope');
+  if (!analysis) throw new SimulationParseError(headingLine, 'Simulation block is missing analysis');
+  if (assertions.length === 0) {
+    throw new SimulationParseError(headingLine, 'Simulation block needs at least one assertion');
+  }
+
+  return { line: headingLine, scope, analysis, sources, assertions };
+}
+
+function parseScope(raw: string, line: number): SimulationScope {
+  const match = /^(sheet|nets)(?:\s+(.*))?$/i.exec(raw);
+  if (!match) {
+    throw new SimulationParseError(line, 'scope must be "sheet <path>" or "nets <a>, <b>"');
+  }
+
+  const scopeValue = (match[2] ?? '').trim();
+  if (match[1]!.toLowerCase() === 'sheet') {
+    if (scopeValue.length === 0) {
+      throw new SimulationParseError(line, 'sheet scope is empty');
+    }
+    return { kind: 'sheet', sheet: scopeValue };
+  }
+
+  const netList = scopeValue.replace(/^\[(.*)\]$/, '$1');
+  const nets = netList
+    .split(',')
+    .map((net) => net.trim())
+    .filter((net) => net.length > 0);
+  if (nets.length === 0 || nets.some((net) => !SAFE_TARGET.test(net))) {
+    throw new SimulationParseError(line, 'net scope must contain comma-separated net names');
+  }
+  return { kind: 'nets', nets: [...new Set(nets)] };
+}
+
+function parseSource(raw: string, line: number): SimulationSource {
+  const match = /^([A-Za-z_][A-Za-z0-9_./:+-]*)\s*=\s*(\S+)$/.exec(raw);
+  if (!match) {
+    throw new SimulationParseError(line, 'source must be "<port>=<number>"');
+  }
+  return {
+    port: match[1]!,
+    value: parseSpiceNumber(match[2]!, line),
+    line,
+  };
+}
+
+/**
+ * Compile a parsed assertion to one value measure and one or two margin
+ * measures. Inclusive bounds pass at zero; strict bounds must be positive.
+ */
+export function compileSpiceAssertion(
+  assertion: SimulationAssertion,
+  analysis: SpiceAnalysis,
+  name = `assertion_${assertion.line}`,
+): CompiledSpiceAssertion {
+  if (!SAFE_MEASURE_NAME.test(name)) {
+    throw new SimulationParseError(assertion.line, `invalid measure name "${name}"`);
+  }
+
+  let valueLine: string;
+  if (assertion.measurable.kind === 'corner') {
+    if (analysis !== 'ac') {
+      throw new SimulationParseError(assertion.line, 'corner() requires an ac analysis');
+    }
+    valueLine = `.meas ac ${name}_value WHEN vdb(${assertion.measurable.target})=-3 FALL=1`;
+  } else {
+    const expression =
+      assertion.measurable.kind === 'voltage'
+        ? `v(${assertion.measurable.target})`
+        : `i(${assertion.measurable.target})`;
+    const operation = analysis === 'op' ? 'FIND' : 'AVG';
+    valueLine = `.meas ${analysis} ${name}_value ${operation} ${expression}`;
+  }
+
+  const valueName = `${name}_value`;
+  const marginExpressions =
+    assertion.comparator.kind === 'between'
+      ? [
+          [`${name}_lower_margin`, `${valueName} - ${assertion.comparator.lower.raw}`],
+          [`${name}_upper_margin`, `${assertion.comparator.upper.raw} - ${valueName}`],
+        ]
+      : assertion.comparator.kind === 'less-than'
+        ? [[`${name}_margin`, `${assertion.comparator.bound.raw} - ${valueName}`]]
+        : [[`${name}_margin`, `${valueName} - ${assertion.comparator.bound.raw}`]];
+
+  const checks = marginExpressions.map(([checkName]) => ({
+    name: checkName!,
+    pass: assertion.comparator.kind === 'between' ? ('nonnegative' as const) : ('positive' as const),
+  }));
+  const checkLines = marginExpressions.map(
+    ([checkName, expression]) => `.meas ${analysis} ${checkName} PARAM='${expression}'`,
+  );
+  const compiledLines = [valueLine, ...checkLines];
+
+  return {
+    valueName,
+    checks,
+    lines: compiledLines,
+    deck: compiledLines.join('\n'),
+  };
+}

package/src/kicad/symlib.ts

@@ -0,0 +1,248 @@
+/**
+ * Cross-check the schematic's `lib_symbols` against the KiCad symbol libraries
+ * installed on the machine (I9).
+ *
+ * The create pipeline currently has the model hand-author every `lib_symbols`
+ * entry — pins, names, electrical types, geometry — under a `lib_id` that
+ * *claims* to be a canonical KiCad part (`Device:R`, `Connector:USB_C_...`).
+ * ERC only checks the net graph as drawn, so an entry whose pins silently
+ * diverge from the real library part (wrong pin count, a missing shield/CC pin,
+ * swapped numbers) passes every gate while being wrong. This module reads the
+ * real `(symbol …)` out of the installed `.kicad_sym` and reports divergences so
+ * the model — or a reviewer — can reconcile them.
+ *
+ * It is deliberately a *checker*, not an auto-replacer: KiCad renames symbols
+ * across versions (e.g. `USB_C_Receptacle_USB2.0` became `…_14P`/`…_16P` in
+ * KiCad 10), so blindly splicing by lib_id would fail on exactly the parts that
+ * matter most. When the exact name is absent, we surface close candidates
+ * instead of guessing.
+ */
+
+import { readFile, readdir, access } from 'node:fs/promises';
+import path from 'node:path';
+import { parseSexp, children, child, isList, type SexpNode } from './sexp.js';
+
+const tag = (n: SexpNode): string | null => (isList(n) && typeof n[0] === 'string' ? n[0] : null);
+const atomAt = (node: SexpNode[] | undefined, idx: number): string | undefined => {
+  const v = node?.[idx];
+  return typeof v === 'string' ? v : undefined;
+};
+
+// KiCad has two spellings for an unnamed pin: the legacy `~` sentinel and, in
+// newer library format, an empty string. They are semantically identical, so
+// normalize before comparing or the check floods with phantom `~` vs "" diffs.
+const normPinName = (n: string): string => (n === '~' ? '' : n);
+
+export interface LibPin {
+  number: string;
+  name: string;
+  /** electrical type: passive | power_in | bidirectional | input | … */
+  type: string;
+}
+
+/**
+ * Candidate directories holding KiCad's stock `.kicad_sym` libraries, most
+ * specific first. Env overrides win (KiCad exports these), then the standard
+ * install locations for Linux/macOS/Windows. Only existing dirs are returned.
+ */
+export async function symbolSearchDirs(env = process.env): Promise<string[]> {
+  const fromEnv = [
+    env.KICAD_SYMBOL_DIR,
+    env.KICAD10_SYMBOL_DIR,
+    env.KICAD9_SYMBOL_DIR,
+    env.KICAD8_SYMBOL_DIR,
+  ].filter((v): v is string => !!v);
+  const defaults = [
+    '/usr/share/kicad/symbols',
+    '/usr/local/share/kicad/symbols',
+    '/Applications/KiCad/KiCad.app/Contents/SharedSupport/symbols',
+    'C:/Program Files/KiCad/share/kicad/symbols',
+  ];
+  const out: string[] = [];
+  for (const dir of [...fromEnv, ...defaults]) {
+    try {
+      await access(dir);
+      if (!out.includes(dir)) out.push(dir);
+    } catch {
+      // not present on this machine; skip
+    }
+  }
+  return out;
+}
+
+/** Path to `<lib>.kicad_sym` in the first search dir that has it, or null. */
+export async function findLibraryFile(lib: string, dirs: string[]): Promise<string | null> {
+  for (const dir of dirs) {
+    const p = path.join(dir, `${lib}.kicad_sym`);
+    try {
+      await access(p);
+      return p;
+    } catch {
+      // try next dir
+    }
+  }
+  return null;
+}
+
+/** Collect pins (number, name, electrical type) from a `(symbol …)` node,
+ * including its nested unit sub-symbols. Same walk `libPinDefs` uses, plus the
+ * electrical-type atom that pin-position parsing does not need. */
+export function pinsOfSymbolNode(sym: SexpNode[]): LibPin[] {
+  const pins: LibPin[] = [];
+  const walk = (n: SexpNode): void => {
+    if (!isList(n)) return;
+    if (tag(n) === 'pin') {
+      const num = atomAt(child(n, 'number'), 1);
+      if (num !== undefined) {
+        pins.push({
+          number: num,
+          name: atomAt(child(n, 'name'), 1) ?? '~',
+          type: typeof n[1] === 'string' ? n[1] : '?',
+        });
+      }
+    }
+    for (const c of n) walk(c);
+  };
+  walk(sym);
+  return pins;
+}
+
+/** The top-level `(symbol "name" …)` entries of a parsed `.kicad_sym` root. */
+function librarySymbols(root: SexpNode[]): Map<string, SexpNode[]> {
+  const map = new Map<string, SexpNode[]>();
+  for (const sym of children(root, 'symbol')) {
+    const name = atomAt(sym, 1);
+    if (name) map.set(name, sym);
+  }
+  return map;
+}
+
+/**
+ * Resolve a `lib_id` (e.g. `Device:R`) to the real library part's pins.
+ * `extends` derived symbols inherit their base's pins, so we follow one such
+ * link (loop-guarded). Returns the pins, or — when the exact symbol is absent —
+ * the closest-named candidates so a caller can suggest the real name.
+ */
+export async function resolveLibrarySymbol(
+  libId: string,
+  dirs: string[],
+): Promise<
+  | { status: 'ok'; pins: LibPin[] }
+  | { status: 'no-symbol'; candidates: string[] }
+  | { status: 'no-library' }
+> {
+  const [lib, name] = libId.includes(':') ? [libId.slice(0, libId.indexOf(':')), libId.slice(libId.indexOf(':') + 1)] : ['', libId];
+  const file = await findLibraryFile(lib, dirs);
+  if (!file) return { status: 'no-library' };
+  const root = parseSexp(await readFile(file, 'utf8'))[0];
+  if (root === undefined || !isList(root)) return { status: 'no-library' };
+  const symbols = librarySymbols(root);
+
+  let current = name;
+  const seen = new Set<string>();
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    const sym = symbols.get(current);
+    if (!sym) break;
+    const pins = pinsOfSymbolNode(sym);
+    if (pins.length) return { status: 'ok', pins };
+    // no pins of its own → follow an `extends` base if present
+    const base = atomAt(child(sym, 'extends'), 1);
+    if (!base) return { status: 'ok', pins }; // genuinely pinless (e.g. a graphic)
+    current = base;
+  }
+
+  // exact name not found: offer near matches (case-insensitive substring both ways)
+  const q = name.toLowerCase();
+  const candidates = [...symbols.keys()]
+    .filter((k) => {
+      const lk = k.toLowerCase();
+      return lk.includes(q) || q.includes(lk);
+    })
+    .slice(0, 8);
+  return { status: 'no-symbol', candidates };
+}
+
+export interface SymbolFinding {
+  libId: string;
+  kind: 'no-library' | 'no-symbol' | 'pin-count' | 'pin-mismatch';
+  detail: string;
+}
+
+/** A schematic lib_symbols entry: its lib_id and the pins as authored. */
+function schematicLibSymbols(root: SexpNode[]): { libId: string; pins: LibPin[] }[] {
+  const libs = child(root, 'lib_symbols');
+  if (!libs) return [];
+  return children(libs, 'symbol').map((sym) => ({
+    libId: atomAt(sym, 1) ?? '',
+    pins: pinsOfSymbolNode(sym),
+  }));
+}
+
+/**
+ * Compare every lib_symbols entry in a schematic against the installed library.
+ * Returns one finding per divergence; an empty array means every resolvable
+ * symbol matched. A part whose library is not installed is reported once (so
+ * the model knows the check could not run for it) but never treated as a
+ * mismatch — absence of the library is not evidence of wrong pins.
+ */
+export async function verifySchematicSymbols(
+  schPath: string,
+  env = process.env,
+): Promise<{ findings: SymbolFinding[]; checked: number; skipped: number }> {
+  const dirs = await symbolSearchDirs(env);
+  const root = parseSexp(await readFile(schPath, 'utf8'))[0];
+  const findings: SymbolFinding[] = [];
+  if (root === undefined || !isList(root)) return { findings, checked: 0, skipped: 0 };
+
+  let checked = 0;
+  let skipped = 0;
+  for (const entry of schematicLibSymbols(root)) {
+    if (!entry.libId) continue;
+    const resolved = await resolveLibrarySymbol(entry.libId, dirs);
+    if (resolved.status === 'no-library') {
+      skipped++;
+      findings.push({
+        libId: entry.libId,
+        kind: 'no-library',
+        detail: `library for "${entry.libId}" is not installed on this machine; cannot verify its pins`,
+      });
+      continue;
+    }
+    if (resolved.status === 'no-symbol') {
+      findings.push({
+        libId: entry.libId,
+        kind: 'no-symbol',
+        detail: resolved.candidates.length
+          ? `"${entry.libId}" does not exist in the installed library — closest real symbols: ${resolved.candidates.join(', ')}. Use one of these lib_ids (KiCad renames symbols across versions).`
+          : `"${entry.libId}" does not exist in the installed library and no close match was found; confirm the lib_id.`,
+      });
+      continue;
+    }
+    checked++;
+    const real = resolved.pins;
+    const authored = entry.pins;
+    const realByNum = new Map(real.map((p) => [p.number, p]));
+    const authByNum = new Map(authored.map((p) => [p.number, p]));
+    if (real.length !== authored.length) {
+      findings.push({
+        libId: entry.libId,
+        kind: 'pin-count',
+        detail: `pin count differs: schematic has ${authored.length} pin(s) [${[...authByNum.keys()].join(',')}], the real ${entry.libId} has ${real.length} [${[...realByNum.keys()].join(',')}]`,
+      });
+    }
+    // per-pin name/type divergence on shared pin numbers
+    for (const [num, rp] of realByNum) {
+      const ap = authByNum.get(num);
+      if (!ap) continue; // count mismatch already reported the gap
+      if (normPinName(ap.name) !== normPinName(rp.name) || ap.type !== rp.type) {
+        findings.push({
+          libId: entry.libId,
+          kind: 'pin-mismatch',
+          detail: `pin ${num}: schematic has (name "${ap.name}", ${ap.type}), real part has (name "${rp.name}", ${rp.type})`,
+        });
+      }
+    }
+  }
+  return { findings, checked, skipped };
+}