@openmixer/omx-contract 1.2.1 → 2.0.0

package/lib/semver.mjs

@@ -7,8 +7,8 @@
  *   major  a field or alias removed; an item removed (MINOR in the development phase, below); a
  *          unit or kind changed; a travel narrowed; a constant a kernel computes with changed (a
  *          scalar, sheet leaf or derived value that is not a travel bound or default; a list member
- *          changed or removed)
- *   minor  an item, field, sheet leaf or list member added (appended); a travel widened;
+ *          or set id changed or removed; a set's default added, removed)
+ *   minor  an item, field, sheet leaf, list member or set id added (appended); a travel widened;
  *          a default moved inside its travel; a step changed
  *   patch  doc and why text
  */
@@ -32,6 +32,7 @@ function travelChanges(at, a, b, say) {
   if (a.default !== b.default) say(a.default === undefined || b.default === undefined ? 'major' : 'minor', `${at}: default ${a.default} -> ${b.default}`);
   if (a.step !== b.step) say('minor', `${at}: step ${a.step} -> ${b.step}`);
   if (a.defaultFrom !== b.defaultFrom) say('minor', `${at}: defaultFrom ${a.defaultFrom} -> ${b.defaultFrom}`);
+  if (a.scale !== b.scale) say('minor', `${at}: scale ${a.scale} -> ${b.scale}`);
   const ka = a.byKind ?? {};
   const kb = b.byKind ?? {};
   for (const k of Object.keys(ka)) if (!(k in kb)) say('major', `${at}.byKind.${k} removed`);
@@ -92,6 +93,15 @@ export function classify(prev, next, { developmentPhase = DEVELOPMENT_PHASE } =
         });
         if (b.value.length > a.value.length) say('minor', `${name}: ${b.value.length - a.value.length} member(s) appended`);
         break;
+      case 'set':
+        a.value.forEach((v, i) => {
+          if (i >= b.value.length) say('major', `${name}[${i}] removed`);
+          else if (b.value[i] !== v) say('major', `${name}[${i}]: ${v} -> ${b.value[i]}`);
+        });
+        if (b.value.length > a.value.length) say('minor', `${name}: ${b.value.length - a.value.length} id(s) appended`);
+        if (a.default !== b.default) say(a.default === undefined || b.default === undefined ? 'major' : 'minor', `${name}: default ${a.default} -> ${b.default}`);
+        if (!same(a.labels, b.labels)) say('patch', `${name}: labels`);
+        break;
       default:
         break;
     }

package/lib/validate.mjs

@@ -8,12 +8,47 @@
 import { readFileSync } from 'node:fs';
 import { posix } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020.js';
-import { resolveData } from './data.mjs';
+import { KERNEL_SECTIONS, entriesOf, isKernelFile, resolveData } from './data.mjs';
+import { eqDefaultBands, eqDefaultParams } from './eq-defaults.mjs';
 import { renderC } from '../render/c.mjs';
 import { renderTs } from '../render/ts.mjs';
 
 const SCHEMA = JSON.parse(readFileSync(new URL('../schema/omx-contract.schema.json', import.meta.url), 'utf8'));
 let compiled;
+/**
+ * The kernel-file shape (2.0.0), which the item schema cannot see: only the four sections at the top; every control
+ * named, of kind travel or choice, unique by name, a travel carrying a `travel` and a choice its `ids`; a control's
+ * `table` declared under `tables`; an aggregate's fields naming controls; a constant a scalar, a list or a sheet.
+ * A kernel file written as a flat item map (the 1.x shape) is refused as a whole. Any other data file returns [].
+ */
+export function shapeProblems(rel, doc) {
+  if (!isKernelFile(rel)) return [];
+  const sections = KERNEL_SECTIONS;
+  const keys = Object.keys(doc).filter((k) => k !== '$schema');
+  if (keys.length && !keys.some((k) => sections.includes(k))) {
+    return [`${rel} is a flat item map (the 1.x shape): a kernel file declares its items under ${sections.join(', ')}`];
+  }
+  const out = [];
+  for (const k of keys) if (!sections.includes(k)) out.push(`unknown top-level key ${k}: a kernel file holds ${sections.join(', ')}`);
+  const controls = doc.controls ?? [];
+  if (!Array.isArray(controls)) return [...out, 'controls must be a list'];
+  const seen = new Set();
+  for (const [i, c] of controls.entries()) {
+    if (typeof c.name !== 'string' || !/^[a-z][A-Za-z0-9]*$/.test(c.name)) out.push(`controls[${i}]: name ${JSON.stringify(c.name)} is not a lowerCamel identifier`);
+    if (seen.has(c.name)) out.push(`controls[${i}]: name ${c.name} declared twice`);
+    seen.add(c.name);
+    if (c.kind === 'travel' && !c.travel) out.push(`controls[${i}] ${c.name}: a travel without "travel"`);
+    else if (c.kind === 'choice' && !Array.isArray(c.ids)) out.push(`controls[${i}] ${c.name}: a choice without "ids"`);
+    else if (c.kind !== 'travel' && c.kind !== 'choice') out.push(`controls[${i}] ${c.name}: kind ${JSON.stringify(c.kind)} is neither travel nor choice`);
+    if (c.table && !(doc.tables && c.table in doc.tables)) out.push(`controls[${i}] ${c.name}: table ${c.table} is not declared`);
+  }
+  for (const [n, a] of Object.entries(doc.aggregates ?? {})) for (const f of a.fields ?? []) if (!seen.has(f)) out.push(`aggregate ${n}: field ${f} names no control`);
+  for (const [n, it] of Object.entries(doc.constants ?? {})) {
+    if (!['scalar', 'list', 'sheet'].includes(it?.kind)) out.push(`constant ${n}: kind ${JSON.stringify(it?.kind)} is not scalar, list or sheet (a travel or a set is a control)`);
+  }
+  return out;
+}
+
 /** The compiled schema validator. */
 export function schemaValidator() {
   if (!compiled) compiled = new Ajv2020({ allErrors: true, strict: true, strictRequired: false, allowUnionTypes: true }).compile(SCHEMA);
@@ -22,6 +57,62 @@ export function schemaValidator() {
 
 const constCase = (s) => s.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
 
+/**
+ * The rules about the meaning of the numbers, not their shape (they live with the data they judge):
+ * a set's default and labels; a travel's scale is a PARAM_SCALES id; the EQ band counts and budget; the
+ * default EQ rule's inputs.
+ */
+function semanticRules(resolved, say) {
+  const val = (name) => resolved.get(name)?.value;
+  for (const r of resolved.values()) {
+    if (r.kind === 'set') {
+      if (r.default !== undefined && !r.value.includes(r.default)) say(r.rel, r.name, 'set-default', `default ${JSON.stringify(r.default)} is not one of ${JSON.stringify(r.value)}`);
+      if (r.labels !== undefined && r.labels.length !== r.value.length) say(r.rel, r.name, 'set-labels', `${r.labels.length} labels for ${r.value.length} ids`);
+    }
+    const travels = r.kind === 'travels' ? (r.shape === 'table' ? Object.entries(r.value) : [['', r.value]]) : [];
+    for (const [field, t] of travels) {
+      if (t.scale !== undefined && !(val('PARAM_SCALES') ?? []).includes(t.scale)) say(r.rel, r.name, 'scale', `${field ? `${r.name}.${field}` : r.name}: scale ${JSON.stringify(t.scale)} is not an id of PARAM_SCALES`);
+    }
+  }
+
+  // The EQ band budget (ruling 2026-10-08): what the operator keeps, what the feedback suppressor plants
+  // and what the ring correction plants all fit in the band maximum.
+  const reserve = val('OPERATOR_EQ_BANDS_RESERVE');
+  if (reserve !== undefined) {
+    const need = reserve + val('FBS_DEFAULT_MAX_AUTO_BANDS') + val('HRP_DEFAULT_MAX_AUTO_BANDS');
+    const cap = val('EQ_MAX_BANDS');
+    if (!(need <= cap)) say(resolved.get('OPERATOR_EQ_BANDS_RESERVE').rel, 'OPERATOR_EQ_BANDS_RESERVE', 'eq-band-budget',
+      `OPERATOR_EQ_BANDS_RESERVE ${reserve} + FBS_DEFAULT_MAX_AUTO_BANDS ${val('FBS_DEFAULT_MAX_AUTO_BANDS')} + HRP_DEFAULT_MAX_AUTO_BANDS ${val('HRP_DEFAULT_MAX_AUTO_BANDS')} = ${need} exceeds EQ_MAX_BANDS ${cap}`);
+  }
+  const counts = val('EQ_BAND_COUNTS');
+  if (counts) {
+    const rel = resolved.get('EQ_BAND_COUNTS').rel;
+    for (const [strip, c] of Object.entries(counts)) {
+      for (const k of ['default', 'max']) if (!Number.isInteger(c[k]) || c[k] < 1) say(rel, 'EQ_BAND_COUNTS', 'eq-band-counts', `${strip}.${k} ${c[k]} is not a positive integer`);
+      if (c.default > c.max) say(rel, 'EQ_BAND_COUNTS', 'eq-band-counts', `${strip}: default ${c.default} exceeds max ${c.max}`);
+    }
+  }
+
+  // The default EQ rule: its inputs are consistent and it answers for every declared default count.
+  if (resolved.has('EQ_DEFAULT_CENTRES_FOUR_BAND_HZ')) {
+    const rel = resolved.get('EQ_DEFAULT_CENTRES_FOUR_BAND_HZ').rel;
+    const bad = (rule, message) => say(rel, 'EQ_DEFAULT_CENTRES_FOUR_BAND_HZ', rule, message);
+    let p;
+    try { p = eqDefaultParams(resolved); } catch (e) { bad('eq-default-rule', e.message); return; }
+    const [r10, r20] = p.series;
+    if (p.four.length !== 4) bad('eq-default-rule', `the four-band set holds ${p.four.length} centres`);
+    for (const [name, list] of [['four-band set', p.four], ['R10', r10], ['R20', r20]]) {
+      if (!list.every((f, i) => f >= p.lo && f <= p.hi && (i === 0 || f > list[i - 1]))) bad('eq-default-rule', `the ${name} is not ascending inside [${p.lo}, ${p.hi}] Hz`);
+    }
+    for (const f of [...p.four, ...r10]) if (!r20.includes(f)) bad('eq-default-rule', `${f} Hz is not in the R20 series: R10 and the four-band set are preferred values of it`);
+    const types = val('EQ_BAND_TYPES') ?? [];
+    for (const id of ['bell', 'lowShelf', 'highShelf']) if (!types.includes(id)) bad('eq-default-rule', `EQ_BAND_TYPES lacks ${id}, which the default rule uses`);
+    for (const [strip, c] of Object.entries(counts ?? {})) {
+      try { eqDefaultBands(c.default, p); } catch (e) { bad('eq-default-rule', `${strip}: ${e.message}`); }
+    }
+  }
+}
+
 /** Every problem of the loaded data: `[{ file, item, rule, message }]`; empty is valid. */
 export function validateData(data) {
   const problems = [];
@@ -31,7 +122,10 @@ export function validateData(data) {
     const depth = f.rel.split('/').length - 1;
     const want = posix.join(...Array(depth).fill('..'), 'schema/omx-contract.schema.json');
     if (f.doc.$schema !== want) say(f.rel, '-', 'schema-path', `"$schema" must be "${want}"`);
-    if (!validate(f.doc)) {
+    for (const m of shapeProblems(f.rel, f.doc)) say(f.rel, '-', 'shape', m);
+    // The schema reads items: a kernel file is checked as the items it expands to, so no rule is lost.
+    const items = { $schema: f.doc.$schema, ...Object.fromEntries(entriesOf(f.rel, f.doc)) };
+    if (!validate(items)) {
       for (const e of validate.errors) {
         const item = e.instancePath.split('/')[1] || '-';
         say(f.rel, item, 'schema', `${e.instancePath || '/'} ${e.message}${e.params?.allowedValues ? ` (${e.params.allowedValues.join(', ')})` : ''}`);
@@ -71,6 +165,8 @@ export function validateData(data) {
     if (typeof r.doc !== 'string' || !r.doc.trim()) say(r.rel, r.name, 'doc', 'every item carries its doc');
   }
 
+  semanticRules(resolved, say);
+
   for (const [target, files] of [['c', () => renderC(resolved)], ['ts', () => renderTs(resolved)]]) {
     let out;
     try {
@@ -82,7 +178,7 @@ export function validateData(data) {
     if (target !== 'c') continue;
     for (const f of out) {
       const seen = new Map();
-      for (const m of f.text.matchAll(/^#define (\w+)/gm)) {
+      for (const m of f.text.matchAll(/^(?:#define |  )(OMX_\w+)(?= = |\s)/gm)) {
         if (seen.has(m[1])) say('-', m[1], 'c-name-unique', `${f.path} defines ${m[1]} twice`);
         seen.set(m[1], true);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/omx-contract",
-  "version": "1.2.1",
+  "version": "2.0.0",
   "description": "The FreeMixer declarations as data: a JSON Schema, the data, and one CLI that renders them into C, TypeScript and JSON",
   "type": "module",
   "license": "GPL-3.0-or-later",

package/render/c.mjs

@@ -4,17 +4,13 @@
  * The `c` target: `omxcontract/omx_contract_limits.h`. Every define is spelled by openmixer's
  * renderer, moved unchanged (c/contract-limits-render.mjs); only the frame (banner, section
  * comments) is this repository's. A plugin's parameter header is rendered by omx-plugins from its
- * declaration; c/params-generate.mjs stays here only for renderSheetC, the frozen fixture of the
- * round-trip proof.
+ * declaration, by reference to the items here.
  */
-import { readFileSync } from 'node:fs';
 import {
   genCoreLimitBlock, genDeclaredListsBlock, genDeclaredRates, genDeclaredScalarsBlock, genLimitBlock, renderContractLimits,
 } from './c/contract-limits-render.mjs';
-import { generate } from './c/params-generate.mjs';
 import { doors } from './doors.mjs';
 
-const PLUGIN_PARAM_H = readFileSync(new URL('./c/omx_plugin_param.h', import.meta.url), 'utf8');
 const defined = (text) => new Set([...text.matchAll(/^#define (OMX_\w+)/gm)].map((m) => m[1]));
 
 /** The rate tail of openmixer's header, outside the include guard, byte for byte. */
@@ -39,6 +35,71 @@ static inline int omx_declared_rates_multiple_of(unsigned base, int *out, int ca
 `;
 }
 
+const constCase = (s) => String(s).replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+
+/** The enumerator names of one set, in order: `OMX_<SET>_<ID>`. */
+export const setEnumerators = (set) => set.ids.map((id) => `OMX_${set.name}_${constCase(id)}`);
+
+/**
+ * Every set as a C enum: the id's position is its value for named ids, the number itself for numeric
+ * ids; `OMX_<SET>_COUNT`, and `OMX_<SET>_DEFAULT` when the set names a default.
+ */
+function genDeclaredSetsEnums(sets) {
+  return sets.map((set) => {
+    const names = setEnumerators(set);
+    const numeric = typeof set.ids[0] === 'number';
+    const members = set.ids.map((id, i) => `  ${names[i]} = ${numeric ? id : i},`);
+    const lines = [`enum omx_${set.name.toLowerCase()} {`, ...members, '};', `#define OMX_${set.name}_COUNT ${set.ids.length}u`];
+    if (set.default !== undefined) lines.push(`#define OMX_${set.name}_DEFAULT ${names[set.ids.indexOf(set.default)]}`);
+    return lines.join('\n');
+  }).join('\n');
+}
+
+/**
+ * The default band centres of an EQ (lib/eq-defaults.mjs is the rule; this is its C spelling, held
+ * equal to it for every count by test/eq-defaults.test.mjs). Writes \`count\` centres to \`out\` and returns
+ * \`count\`, or returns 0 for a count that is 0 or has no distinct preferred centres.
+ */
+function eqCentresFunction() {
+  return `static inline unsigned omx_eq_default_centres(unsigned count, float *out) {
+  static const double r10[] = OMX_ISO_THIRD_OCTAVE_CENTRES_HZ_INIT;
+  static const double r20[] = OMX_EQ_CENTRE_SERIES_R20_HZ_INIT;
+  static const double four[] = OMX_EQ_DEFAULT_CENTRES_FOUR_BAND_HZ_INIT;
+  if (count == 0) return 0;
+  if (count == 4) {
+    for (unsigned i = 0; i < 4; i++) out[i] = (float)four[i];
+    return 4;
+  }
+  const double lo = log((double)OMX_EQ_FREQ_RANGE_MIN);
+  const double span = log((double)OMX_EQ_FREQ_RANGE_MAX / (double)OMX_EQ_FREQ_RANGE_MIN);
+  for (unsigned s = 0; s < 2; s++) {
+    const double *series = s ? r20 : r10;
+    const unsigned n = s ? OMX_EQ_CENTRE_SERIES_R20_HZ_COUNT : OMX_ISO_THIRD_OCTAVE_CENTRES_HZ_COUNT;
+    int distinct = count <= n;
+    for (unsigned i = 0; distinct && i < count; i++) {
+      const double t = lo + span * ((double)i + 0.5) / (double)count;
+      unsigned best = 0;
+      double best_d = 1e300;
+      for (unsigned k = 0; k < n; k++) {
+        const double d = fabs(log(series[k]) - t);
+        if (d < best_d) { best_d = d; best = k; }
+      }
+      out[i] = (float)series[best];
+      if (i > 0 && out[i] == out[i - 1]) distinct = 0;
+    }
+    if (distinct) return count;
+  }
+  return 0;
+}
+
+/* The default type of band \`index\` of an EQ with \`count\` bands: a low shelf first, a high shelf last, bells
+ * between (a single band is a bell). An OMX_EQ_BAND_TYPES_* member. */
+static inline int omx_eq_default_type(unsigned index, unsigned count) {
+  if (count < 2) return OMX_EQ_BAND_TYPES_BELL;
+  return index == 0 ? OMX_EQ_BAND_TYPES_LOW_SHELF : index == count - 1 ? OMX_EQ_BAND_TYPES_HIGH_SHELF : OMX_EQ_BAND_TYPES_BELL;
+}`;
+}
+
 /** The limits header of the resolved data. */
 export function renderLimitsHeader(resolved) {
   const d = doors(resolved);
@@ -48,6 +109,8 @@ export function renderLimitsHeader(resolved) {
   const above = defined([tables, aliases].join('\n'));
   const scalars = d.DECLARED_SCALARS.length ? genDeclaredScalarsBlock(d.DECLARED_SCALARS, above) : '';
   const lists = d.DECLARED_LISTS.length ? genDeclaredListsBlock(d.DECLARED_LISTS, defined([tables, aliases, scalars].join('\n'))) : '';
+  const sets = d.DECLARED_SET_ITEMS.length ? genDeclaredSetsEnums(d.DECLARED_SET_ITEMS) : '';
+  const centres = resolved.has('EQ_DEFAULT_CENTRES_FOUR_BAND_HZ') ? eqCentresFunction() : '';
   const sections = [
     [tables, `/* Per-parameter numeric travel, one block per \`travels\` table named <PREFIX>_LIMITS:
  * OMX_<PREFIX>_<FIELD>_MIN/_MAX/_DEFAULT, float literals. */`],
@@ -56,11 +119,16 @@ export function renderLimitsHeader(resolved) {
     [scalars, `/* Every scalar, sheet leaf and single travel's numbers, one block sorted by macro. An integer value
  * is an integer literal, any other a float literal AND its OMX_<macro>_DOUBLE spelling. */`],
     [lists, `/* Every list rendered to C, sorted by list: OMX_<LIST>_COUNT and OMX_<LIST>_INIT { a, b, … }. */`],
+    [sets, `/* Every set rendered to C, sorted by set: an enum of the ids (a named id's position, or a numeric id's number), \`OMX_<SET>_COUNT\` and,
+ * where the set names a default, \`OMX_<SET>_DEFAULT\`. */`],
+    [centres, `/* The default bands of an EQ with \`count\` bands: THE one rule, for every strip, host and count (omx-contract's
+ * lib/eq-defaults.mjs; the ts render exports the same as eqDefaultCentres and eqDefaultTypes). Needs -lm. */`],
   ].filter(([body]) => body);
   return `// SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 #ifndef OMX_CONTRACT_LIMITS_H
 #define OMX_CONTRACT_LIMITS_H
+#include <math.h>
 /*
  * GENERATED — DO NOT EDIT BY HAND.
  * Produced by \`omx-contract render --target c\` from FreeMixer/omx-contract's data/, the declaration
@@ -82,13 +150,11 @@ export function renderC(resolved) {
 }
 
 /**
- * The `c` target of a frozen openmixer sheet (test/fixtures/): `{ sheet, plugins: [{ header, prefix,
- * source, params }] }` rendered by openmixer's own renderer, for the round-trip proof (spec §4.4 step 1).
+ * The `c` target of a frozen openmixer sheet (test/fixtures/): `{ sheet }` rendered by openmixer's own
+ * renderer, for the round-trip proof (spec §4.4 step 1).
  */
 export function renderSheetC(fixture) {
   const s = fixture.sheet;
   const sheet = { ...s, CORE_LIMITS: new Map(Object.entries(s.CORE_LIMITS)) };
-  const files = [{ path: 'omxcontract/omx_contract_limits.h', text: renderContractLimits(sheet) }];
-  for (const p of fixture.plugins) files.push({ path: `omxcontract/params/${p.header}`, text: generate(p, p.params) });
-  return files;
+  return [{ path: 'omxcontract/omx_contract_limits.h', text: renderContractLimits(sheet) }];
 }

package/render/doors.mjs

@@ -5,7 +5,7 @@
  * (packages/core/src/native-limit-tables.ts, declared-scalars.ts, declared-lists.ts): a `travels`
  * table named <PREFIX>_LIMITS is a native table; every scalar, sheet and single travel is scalars
  * (its finite-number leaves, a travel's `unit`/`defaultFrom` labels skipped); a list is a declared
- * list unless its item says `"c": { "render": false }`; a `c.alias` is the core-limit spelling.
+ * list unless its item says `"c": { "render": false }`; a set is an enum; a `c.alias` is the core-limit spelling.
  */
 
 const constantCase = (key) => key.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
@@ -38,7 +38,7 @@ export function doors(resolved) {
     .sort(([a], [b]) => a.localeCompare(b));
   const byMacro = new Map();
   for (const r of items) {
-    if (isNativeTable(r) || r.kind === 'list') continue;
+    if (isNativeTable(r) || r.kind === 'list' || r.kind === 'set') continue;
     const leaves = numberLeaves(r.value, r.name, r.name.replace(/_(KERNEL|LIMITS)$/, ''));
     if (leaves === undefined) continue;
     for (const s of leaves) {
@@ -51,6 +51,9 @@ export function doors(resolved) {
   const DECLARED_LISTS = items.filter((r) => r.kind === 'list' && r.c?.render !== false)
     .map((r) => ({ name: r.name, values: r.value }))
     .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  const DECLARED_SET_ITEMS = items.filter((r) => r.kind === 'set')
+    .map((r) => ({ name: r.name, ids: r.value, default: r.default }))
+    .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
   const ALIASES = new Map();
   for (const r of items) {
     if (!r.c?.alias) continue;
@@ -59,5 +62,5 @@ export function doors(resolved) {
     ALIASES.get(fact)[field] = r.value;
   }
   const STANDARD_SAMPLE_RATES = resolved.get('STANDARD_SAMPLE_RATES')?.value;
-  return { NATIVE_LIMIT_TABLES, DECLARED_SCALARS, DECLARED_LISTS, ALIASES, STANDARD_SAMPLE_RATES };
+  return { NATIVE_LIMIT_TABLES, DECLARED_SCALARS, DECLARED_LISTS, DECLARED_SET_ITEMS, ALIASES, STANDARD_SAMPLE_RATES };
 }

package/render/ts.mjs

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+import { eqDefaultBands, eqDefaultCentres, eqDefaultParams, eqDefaultTypes } from '../lib/eq-defaults.mjs';
+
 /**
  * The `ts` target: one ESM module and its type declarations, every item exported under its own
  * name with its literal type (`as const`), so a re-export in openmixer keeps names, values and types.
@@ -32,10 +34,46 @@ const BANNER = `// SPDX-License-Identifier: GPL-3.0-or-later
 // GENERATED by \`omx-contract render --target ts\` from FreeMixer/omx-contract's data/ — do not edit.
 `;
 
+/**
+ * The default EQ rule (lib/eq-defaults.mjs) as functions of the module: the library's own source,
+ * with the declared parameters bound, so the ts reader runs the code the tests hold equal to the c one.
+ */
+function eqRule(resolved) {
+  if (!resolved.has('EQ_DEFAULT_CENTRES_FOUR_BAND_HZ')) return { js: '', dts: '' };
+  const bound = JSON.stringify(eqDefaultParams(resolved), null, 2);
+  const fn = (f, as) => f.toString().replace(`function ${f.name}(`, `function ${as}(`);
+  const js = `
+/** The declared parameters of the default EQ rule: the four-band set, the preferred series, the band frequency travel, the band gain and Q. */
+const EQ_DEFAULT_RULE = ${bound};
+${fn(eqDefaultCentres, 'centres')}
+${fn(eqDefaultTypes, 'types')}
+${fn(eqDefaultBands, 'bands')}
+
+/** The default band centres (Hz) of an EQ with \`count\` bands: THE one rule, for every strip, host and count. */
+export function eqDefaultCentres(count) { return centres(count, EQ_DEFAULT_RULE); }
+
+/** The default band types, by EQ_BAND_TYPES id: a low shelf, bells, a high shelf (a single band is a bell). */
+export function eqDefaultTypes(count) { return types(count); }
+
+/** Every default band of an EQ with \`count\` bands: type, centre, gain and Q. */
+export function eqDefaultBands(count) { return bands(count, EQ_DEFAULT_RULE); }
+`;
+  const dts = `
+/** The default band centres (Hz) of an EQ with \`count\` bands: THE one rule, for every strip, host and count. */
+export declare function eqDefaultCentres(count: number): number[];
+/** The default band types, by EQ_BAND_TYPES id: a low shelf, bells, a high shelf (a single band is a bell). */
+export declare function eqDefaultTypes(count: number): string[];
+/** Every default band of an EQ with \`count\` bands: type, centre, gain and Q. */
+export declare function eqDefaultBands(count: number): { type: string; freqHz: number; gainDb: number; q: number }[];
+`;
+  return { js, dts };
+}
+
 /** Every file of the `ts` target: `[{ path, text }]`. */
 export function renderTs(resolved) {
   const items = [...resolved.values()];
-  const js = BANNER + items.map((r) => `\n${docComment(r)}\nexport const ${r.name} = ${JSON.stringify(tsValue(r), null, 2)};\n`).join('');
-  const dts = BANNER + items.map((r) => `\n${docComment(r)}\nexport declare const ${r.name}: ${tsType(tsValue(r))};\n`).join('');
+  const rule = eqRule(resolved);
+  const js = BANNER + items.map((r) => `\n${docComment(r)}\nexport const ${r.name} = ${JSON.stringify(tsValue(r), null, 2)};\n`).join('') + rule.js;
+  const dts = BANNER + items.map((r) => `\n${docComment(r)}\nexport declare const ${r.name}: ${tsType(tsValue(r))};\n`).join('') + rule.dts;
   return [{ path: 'omx-contract.js', text: js }, { path: 'omx-contract.d.ts', text: dts }];
 }

package/schema/omx-contract.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/FreeMixer/omx-contract/raw/main/schema/omx-contract.schema.json",
   "title": "omx-contract data file",
-  "description": "A map from an export name to one item: a scalar, a travels table or travel, a sheet or a list. GPL-3.0-or-later.",
+  "description": "A map from an export name to one item: a scalar, a travels table or travel, a sheet, a list or a set. GPL-3.0-or-later.",
   "type": "object",
   "properties": {
     "$schema": { "type": "string" }
@@ -15,6 +15,7 @@
       "enum": ["dB", "dBFS", "ms", "s", "min", "Hz", "oct", "cents", "%", "x", ""]
     },
     "text": { "type": "string", "minLength": 1 },
+    "since": { "type": "string", "pattern": "^\\d+\\.\\d+\\.\\d+$", "description": "The release that first carried an item declared outside the kernels (rates.json, primitives.json); a kernel's items record it in recipes/answers/." },
     "name": { "type": "string", "pattern": "^[A-Z][A-Z0-9_]*$" },
     "ref": {
       "type": "object",
@@ -37,6 +38,15 @@
           "required": ["derive", "of"],
           "additionalProperties": false
         },
+        {
+          "type": "object",
+          "properties": {
+            "derive": { "const": "ceilSum" },
+            "of": { "type": "array", "items": { "$ref": "#/$defs/number" }, "minItems": 2 }
+          },
+          "required": ["derive", "of"],
+          "additionalProperties": false
+        },
         {
           "type": "object",
           "properties": {
@@ -58,6 +68,7 @@
         "unit": { "$ref": "#/$defs/unit" },
         "default": { "$ref": "#/$defs/number" },
         "defaultFrom": { "enum": ["desk"] },
+        "scale": { "type": "string", "pattern": "^[a-z]+$", "description": "How a host draws the travel: an id of PARAM_SCALES." },
         "byKind": {
           "type": "object",
           "propertyNames": { "pattern": "^[a-z][A-Za-z0-9]*$" },
@@ -80,6 +91,7 @@
       "type": "object",
       "properties": {
         "kind": { "const": "scalar" },
+        "since": { "$ref": "#/$defs/since" },
         "doc": { "$ref": "#/$defs/text" },
         "why": { "$ref": "#/$defs/text" },
         "unit": { "$ref": "#/$defs/unit" },
@@ -92,6 +104,7 @@
       "type": "object",
       "properties": {
         "kind": { "const": "travels" },
+        "since": { "$ref": "#/$defs/since" },
         "doc": { "$ref": "#/$defs/text" },
         "why": { "$ref": "#/$defs/text" },
         "fields": {
@@ -125,6 +138,7 @@
       "type": "object",
       "properties": {
         "kind": { "const": "sheet" },
+        "since": { "$ref": "#/$defs/since" },
         "doc": { "$ref": "#/$defs/text" },
         "why": { "$ref": "#/$defs/text" },
         "value": { "$ref": "#/$defs/sheetValue" }
@@ -136,6 +150,7 @@
       "type": "object",
       "properties": {
         "kind": { "const": "list" },
+        "since": { "$ref": "#/$defs/since" },
         "doc": { "$ref": "#/$defs/text" },
         "why": { "$ref": "#/$defs/text" },
         "unit": { "$ref": "#/$defs/unit" },
@@ -149,15 +164,36 @@
       "required": ["kind", "doc", "unit", "values"],
       "additionalProperties": false
     },
+    "set": {
+      "type": "object",
+      "description": "Ordered ids with an optional default and labels. The ids and their order are the contract: all strings (the id is the name, its position the value) or all non-negative integers (the id is the value). Labels are face text and optional.",
+      "properties": {
+        "kind": { "const": "set" },
+        "since": { "$ref": "#/$defs/since" },
+        "doc": { "$ref": "#/$defs/text" },
+        "why": { "$ref": "#/$defs/text" },
+        "ids": {
+          "oneOf": [
+            { "type": "array", "items": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9]*$" }, "minItems": 1, "uniqueItems": true },
+            { "type": "array", "items": { "type": "integer", "minimum": 0 }, "minItems": 1, "uniqueItems": true }
+          ]
+        },
+        "default": { "oneOf": [{ "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9]*$" }, { "type": "integer", "minimum": 0 }] },
+        "labels": { "type": "array", "items": { "$ref": "#/$defs/text" }, "minItems": 1 }
+      },
+      "required": ["kind", "doc", "ids"],
+      "additionalProperties": false
+    },
     "item": {
       "type": "object",
       "required": ["kind"],
-      "properties": { "kind": { "enum": ["scalar", "travels", "sheet", "list"] } },
+      "properties": { "kind": { "enum": ["scalar", "travels", "sheet", "list", "set"] } },
       "allOf": [
         { "if": { "properties": { "kind": { "const": "scalar" } } }, "then": { "$ref": "#/$defs/scalar" } },
         { "if": { "properties": { "kind": { "const": "travels" } } }, "then": { "$ref": "#/$defs/travels" } },
         { "if": { "properties": { "kind": { "const": "sheet" } } }, "then": { "$ref": "#/$defs/sheet" } },
-        { "if": { "properties": { "kind": { "const": "list" } } }, "then": { "$ref": "#/$defs/list" } }
+        { "if": { "properties": { "kind": { "const": "list" } } }, "then": { "$ref": "#/$defs/list" } },
+        { "if": { "properties": { "kind": { "const": "set" } } }, "then": { "$ref": "#/$defs/set" } }
       ]
     }
   }