@openmixer/omx-contract 2.10.0 → 2.11.0

package/README.md

@@ -49,7 +49,7 @@ pkg-config --cflags omx-contract
 ```
 
 Pin one version and build against its renders instead of keeping a copy: the installed package at exactly
-that version (`pkg-config --exact-version=2.10.0 omx-contract`), else the npm tarball, unpacked, and
+that version (`pkg-config --exact-version=2.11.0 omx-contract`), else the npm tarball, unpacked, and
 `omx-contract render --target c --out build/omx-contract/include`. A kernel's controls and readouts, in their
 order, are in `share/omx-contract/omx-contract.json`; how a declaration is written is in
 [docs/kernel-files.md](docs/kernel-files.md), and what a readout is in [docs/readouts.md](docs/readouts.md).

package/data/kernels/drive.json

@@ -149,17 +149,23 @@
     {
       "name": "hfRolloff",
       "kind": "choice",
-      "doc": "The drive's post-curve HIGH-FREQUENCY ROLL-OFF corner, in Hz: the id is the corner, and 0 names no roll-off (the section does not run: `omx_drive.h`'s `struct omx_drive.hf_on` is 0). The console's drive row offers off, 12000 and 16000 (`DriveState.hfRolloff`, `DRIVE_HF_ROLLOFFS`) and comes up off, as omx-dsp's drive face does.",
+      "doc": "The drive's post-curve HIGH-FREQUENCY ROLL-OFF: `off` (the section does not run: `omx_drive.h`'s `struct omx_drive.hf_on` is 0), `12000` or `16000`, each carrying its corner in Hz as its value and `off` none (operator ruling, 2026-10-13: the choice is an enumeration and the frequency is data of each member, so no 0 Hz doubles as a sentinel). The ids are the console's drive-row wire vocabulary (`DriveState.hfRolloff`, what the drive row's OPTIONS publishes and a session stores), so the console re-exports this set; a kernel reads the corner from the id's value. It comes up off, as omx-dsp's drive face does.",
+      "unit": "Hz",
       "ids": [
-        0,
-        12000,
-        16000
+        "off",
+        "12000",
+        "16000"
       ],
-      "default": 0,
+      "default": "off",
       "labels": [
         "Off",
         "12 kHz",
         "16 kHz"
+      ],
+      "values": [
+        null,
+        12000,
+        16000
       ]
     },
     {

package/dist/ts/omx-contract.d.ts

@@ -543,10 +543,10 @@ export declare const DRIVE_AUTO_GAINS: readonly ["off", "on"];
 export declare const DRIVE_STEREO_LINKS: readonly ["off", "on"];
 
 /**
- * The drive's post-curve HIGH-FREQUENCY ROLL-OFF corner, in Hz: the id is the corner, and 0 names no roll-off (the section does not run: `omx_drive.h`'s `struct omx_drive.hf_on` is 0). The console's drive row offers off, 12000 and 16000 (`DriveState.hfRolloff`, `DRIVE_HF_ROLLOFFS`) and comes up off, as omx-dsp's drive face does.
+ * The drive's post-curve HIGH-FREQUENCY ROLL-OFF: `off` (the section does not run: `omx_drive.h`'s `struct omx_drive.hf_on` is 0), `12000` or `16000`, each carrying its corner in Hz as its value and `off` none (operator ruling, 2026-10-13: the choice is an enumeration and the frequency is data of each member, so no 0 Hz doubles as a sentinel). The ids are the console's drive-row wire vocabulary (`DriveState.hfRolloff`, what the drive row's OPTIONS publishes and a session stores), so the console re-exports this set; a kernel reads the corner from the id's value. It comes up off, as omx-dsp's drive face does.
  * @see data/kernels/drive.json
  */
-export declare const DRIVE_HF_ROLLOFFS: readonly [0, 12000, 16000];
+export declare const DRIVE_HF_ROLLOFFS: readonly ["off", "12000", "16000"];
 
 /**
  * The drive's OVERSAMPLING factor: the shaper runs inside the console's one oversampler at 1x, 2x or 4x, and the id is the factor (`omx_drive.h`'s `omx_drive_factor_of` member set, `struct omx_drive.os_factor`). A field of the console's drive row (`DriveState.oversample`, the console's DRIVE_OVERSAMPLE_FACTORS; the set is named for its control), 4 at come-up there and in omx-dsp's drive face (OMX_DRIVE_INSTANCE_FACTOR, the oversampler's largest).
@@ -2132,6 +2132,16 @@ export declare const ORACLE_FLOOR_RATES: readonly [44100, 48000, 96000, 192000];
  */
 export declare const RME_RATES: readonly [32000, 44100, 48000, 64000, 88200, 96000, 128000, 176400, 192000];
 
+/**
+ * The value each id of DRIVE_HF_ROLLOFFS carries, in "Hz"; null for an id that carries none.
+ * @see data/kernels/drive.json
+ */
+export declare const DRIVE_HF_ROLLOFFS_VALUES: {
+  readonly "12000": 12000;
+  readonly "16000": 16000;
+  readonly off: null;
+};
+
 /**
  * Every kernel's readouts, the meters a host draws, each kernel's in its declared order: the position is the
  * readout's id. Every reference is resolved.

package/dist/ts/omx-contract.js

@@ -578,13 +578,13 @@ export const DRIVE_STEREO_LINKS = [
 ];
 
 /**
- * The drive's post-curve HIGH-FREQUENCY ROLL-OFF corner, in Hz: the id is the corner, and 0 names no roll-off (the section does not run: `omx_drive.h`'s `struct omx_drive.hf_on` is 0). The console's drive row offers off, 12000 and 16000 (`DriveState.hfRolloff`, `DRIVE_HF_ROLLOFFS`) and comes up off, as omx-dsp's drive face does.
+ * The drive's post-curve HIGH-FREQUENCY ROLL-OFF: `off` (the section does not run: `omx_drive.h`'s `struct omx_drive.hf_on` is 0), `12000` or `16000`, each carrying its corner in Hz as its value and `off` none (operator ruling, 2026-10-13: the choice is an enumeration and the frequency is data of each member, so no 0 Hz doubles as a sentinel). The ids are the console's drive-row wire vocabulary (`DriveState.hfRolloff`, what the drive row's OPTIONS publishes and a session stores), so the console re-exports this set; a kernel reads the corner from the id's value. It comes up off, as omx-dsp's drive face does.
  * @see data/kernels/drive.json
  */
 export const DRIVE_HF_ROLLOFFS = [
-  0,
-  12000,
-  16000
+  "off",
+  "12000",
+  "16000"
 ];
 
 /**
@@ -2351,6 +2351,16 @@ export const RME_RATES = [
   192000
 ];
 
+/**
+ * The value each id of DRIVE_HF_ROLLOFFS carries, in "Hz"; null for an id that carries none.
+ * @see data/kernels/drive.json
+ */
+export const DRIVE_HF_ROLLOFFS_VALUES = {
+  "12000": 12000,
+  "16000": 16000,
+  "off": null
+};
+
 /**
  * Every kernel's readouts, the meters a host draws, each kernel's in its declared order: the position is the
  * readout's id. Every reference is resolved.

package/include/omxcontract/omx_contract_limits.h

@@ -690,12 +690,22 @@ enum omx_drive_curves {
 };
 #define OMX_DRIVE_CURVES_COUNT 4u
 enum omx_drive_hf_rolloffs {
-  OMX_DRIVE_HF_ROLLOFFS_0 = 0,
-  OMX_DRIVE_HF_ROLLOFFS_12000 = 12000,
-  OMX_DRIVE_HF_ROLLOFFS_16000 = 16000,
+  OMX_DRIVE_HF_ROLLOFFS_OFF = 0,
+  OMX_DRIVE_HF_ROLLOFFS_12000 = 1,
+  OMX_DRIVE_HF_ROLLOFFS_16000 = 2,
 };
 #define OMX_DRIVE_HF_ROLLOFFS_COUNT 3u
-#define OMX_DRIVE_HF_ROLLOFFS_DEFAULT OMX_DRIVE_HF_ROLLOFFS_0
+#define OMX_DRIVE_HF_ROLLOFFS_DEFAULT OMX_DRIVE_HF_ROLLOFFS_OFF
+#define OMX_DRIVE_HF_ROLLOFFS_UNIT "Hz"
+#define OMX_DRIVE_HF_ROLLOFFS_12000_VALUE 12000.0f
+#define OMX_DRIVE_HF_ROLLOFFS_16000_VALUE 16000.0f
+static inline int omx_drive_hf_rolloffs_value(int id, float *out) {
+  switch (id) {
+  case OMX_DRIVE_HF_ROLLOFFS_12000: *out = OMX_DRIVE_HF_ROLLOFFS_12000_VALUE; return 1;
+  case OMX_DRIVE_HF_ROLLOFFS_16000: *out = OMX_DRIVE_HF_ROLLOFFS_16000_VALUE; return 1;
+  default: return 0;
+  }
+}
 enum omx_drive_oversamples {
   OMX_DRIVE_OVERSAMPLES_1 = 1,
   OMX_DRIVE_OVERSAMPLES_2 = 2,

package/lib/data.mjs

@@ -262,7 +262,7 @@ export function lagrangeReadL1(order) {
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 
 /**
- * Resolve every item: `{ name, rel, kind, doc, why?, unit?, c?, shape?, default?, labels?, value }` (default and labels: a set's), where `value` has
+ * Resolve every item: `{ name, rel, kind, doc, why?, unit?, c?, shape?, default?, labels?, values?, value }` (default, labels and values: a set's), where `value` has
  * every `{ref}` and `{derive}` evaluated. The returned map also carries `kernels`, every kernel's ordered controls
  * (kernelControls) and, for a kernel that declares them, its ordered `readouts` `{ name, doc, unit, min, max, scale,
  * rateHz }` with every reference resolved, which the json render publishes beside the items.
@@ -305,6 +305,7 @@ export function resolveData(data) {
     if (item.kind === 'set') {
       if (item.default !== undefined) r.default = setDefault(item, (v) => val(v, name), name);
       if (item.labels !== undefined) r.labels = item.labels;
+      if (item.values !== undefined) r.values = val(item.values, name);
     }
     if (item.kind === 'travels') r.shape = item.fields ? 'table' : 'travel';
     r.value = val(rawValue(item), name);

package/lib/semver.mjs

@@ -7,9 +7,10 @@
  *   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
- *          or set id changed or removed; a set's default added, removed)
+ *          or set id changed or removed; a set's default added, removed; a value an id carries changed
+ *          or 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
+ *          a default moved inside its travel; a step changed; a set's values added
  *   patch  doc and why text
  *
  * A kernel's readouts (docs/readouts.md): one removed, renamed or moved, or its unit changed, is major (a removal is
@@ -23,7 +24,7 @@ const RANK = { none: 0, patch: 1, minor: 2, major: 3 };
  * The development-phase rule (omx-contract spec §3.6): while every consumer of
  * omx-contract is a FreeMixer repository named here, removing an item is MINOR. The rule ends, and
  * this becomes null so a removal is MAJOR again, in the release that names the first consumer
- * outside the list.
+ * outside the list. Until then a MAJOR class is released as a minor bump (see refusal).
  */
 export const DEVELOPMENT_PHASE = Object.freeze({ consumers: Object.freeze(['omx-dsp', 'omx-plugins', 'openmixer']) });
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
@@ -94,7 +95,8 @@ export function classify(prev, next, { developmentPhase = DEVELOPMENT_PHASE } =
       continue;
     }
     if (a.kind !== b.kind || (a.shape ?? '') !== (b.shape ?? '')) { say('major', `kind ${a.kind} -> ${b.kind}`); continue; }
-    if ((a.unit ?? '') !== (b.unit ?? '')) say('major', `unit ${JSON.stringify(a.unit)} -> ${JSON.stringify(b.unit)}`);
+    // a set that gains values gains their unit with them (minor, below); any other unit change is major
+    if ((a.unit ?? '') !== (b.unit ?? '') && !(a.kind === 'set' && a.values === undefined)) say('major', `unit ${JSON.stringify(a.unit)} -> ${JSON.stringify(b.unit)}`);
     if (a.doc !== b.doc || (a.why ?? '') !== (b.why ?? '')) say('patch', 'doc');
     if (!same(a.c?.alias, b.c?.alias)) say(a.c?.alias ? 'major' : 'minor', a.c?.alias ? 'c.alias removed or renamed' : 'c.alias added');
     if (!same(a.c?.render, b.c?.render)) say(b.c?.render === false ? 'major' : 'minor', 'C render of the list changed');
@@ -123,11 +125,18 @@ export function classify(prev, next, { developmentPhase = DEVELOPMENT_PHASE } =
       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]}`);
+          else if (b.value[i] !== v) say('major', `${name}[${i}]: ${JSON.stringify(v)} -> ${JSON.stringify(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`);
+        if (a.values === undefined && b.values !== undefined) say('minor', `${name}: values added`);
+        else if (a.values !== undefined && b.values === undefined) say('major', `${name}: values removed`);
+        else if (a.values !== undefined) {
+          a.values.forEach((v, i) => {
+            if (i < b.values.length && b.values[i] !== v) say('major', `${name}: the value of ${a.value[i]}: ${v} -> ${b.values[i]} (a constant a kernel computes with)`);
+          });
+        }
         break;
       default:
         break;
@@ -155,9 +164,16 @@ export function bumpOf(from, to) {
   return 'none';
 }
 
-/** null when bumping `from` -> `to` covers `level`, else the refusal. */
-export function refusal(level, from, to) {
+/**
+ * null when bumping `from` -> `to` covers `level`, else the refusal. In the development phase no
+ * release takes a major bump (operator ruling 2026-10-13: majors wait for the first public
+ * release), so a MAJOR class is covered by a minor bump; the classes are still reported as found.
+ */
+export function refusal(level, from, to, { developmentPhase = DEVELOPMENT_PHASE } = {}) {
   let bump;
   try { bump = bumpOf(from, to); } catch (e) { return e.message; }
-  return RANK[bump] >= RANK[level] ? null : `the changes since ${from} are ${level.toUpperCase()}, and ${from} -> ${to} is a ${bump} bump`;
+  const need = developmentPhase && level === 'major' ? 'minor' : level;
+  if (RANK[bump] >= RANK[need]) return null;
+  const phase = need === level ? '' : ' (at least a minor in the development phase)';
+  return `the changes since ${from} are ${level.toUpperCase()}, and ${from} -> ${to} is a ${bump} bump${phase}`;
 }

package/lib/validate.mjs

@@ -112,6 +112,14 @@ function semanticRules(resolved, say) {
     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`);
+      if (r.values !== undefined) {
+        if (r.values.length !== r.value.length) say(r.rel, r.name, 'set-values', `${r.values.length} values for ${r.value.length} ids`);
+        if (r.value.some((id) => typeof id !== 'string')) say(r.rel, r.name, 'set-values', 'a set of numeric ids carries no values: the id is its own value');
+        r.values.forEach((v, i) => {
+          if (v !== null && (typeof v !== 'number' || !Number.isFinite(v))) say(r.rel, r.name, 'set-values', `the value of ${JSON.stringify(r.value[i])} resolves to ${JSON.stringify(v)}`);
+        });
+        if (r.values.every((v) => v === null)) say(r.rel, r.name, 'set-values', 'no id carries a value');
+      }
     }
     const travels = r.kind === 'travels' ? (r.shape === 'table' ? Object.entries(r.value) : [['', r.value]]) : [];
     for (const [field, t] of travels) {
@@ -130,6 +138,9 @@ function semanticRules(resolved, say) {
       if (!(val('PARAM_SCALES') ?? []).includes(ro.scale)) say(rel, at, 'scale', `${at}: scale ${JSON.stringify(ro.scale)} is not an id of PARAM_SCALES`);
     }
   }
+  for (const r of resolved.values()) {
+    if (r.kind === 'set' && r.values && resolved.has(`${r.name}_VALUES`)) say(r.rel, `${r.name}_VALUES`, 'set-values', `${r.name}_VALUES is the ts render's export of ${r.name}'s values: no item may take the name`);
+  }
   if (resolved.has('READOUTS') && Object.values(resolved.kernels ?? {}).some((k) => k.readouts)) {
     say(resolved.get('READOUTS').rel, 'READOUTS', 'readouts-name', 'READOUTS is the ts render\'s export of the readouts: no item may take the name');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/omx-contract",
-  "version": "2.10.0",
+  "version": "2.11.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

@@ -43,8 +43,26 @@ export const setEnumerators = (set) => set.ids.map((id) => `OMX_${set.name}_${co
 
 /**
  * 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.
+ * ids; `OMX_<SET>_COUNT`, and `OMX_<SET>_DEFAULT` when the set names a default. A set whose ids carry values adds
+ * `OMX_<SET>_UNIT`, `OMX_<SET>_<ID>_VALUE` for each id that carries one, and `omx_<set>_value(id, &out)`, which writes
+ * the id's value and returns 1, or returns 0 for an id that carries none: a kernel reads the number from the id
+ * (the drive's roll-off corner), never a sentinel.
  */
+function genSetValues(set, names) {
+  const fn = `omx_${set.name.toLowerCase()}_value`;
+  const carried = set.ids.map((id, i) => [names[i], set.values[i]]).filter(([, v]) => v !== null);
+  return [
+    `#define OMX_${set.name}_UNIT ${cStringLiteral(set.unit)}`,
+    ...carried.map(([n, v]) => `#define ${n}_VALUE ${floatLiteral(v)}`),
+    `static inline int ${fn}(int id, float *out) {`,
+    '  switch (id) {',
+    ...carried.map(([n]) => `  case ${n}: *out = ${n}_VALUE; return 1;`),
+    '  default: return 0;',
+    '  }',
+    '}',
+  ];
+}
+
 function genDeclaredSetsEnums(sets) {
   return sets.map((set) => {
     const names = setEnumerators(set);
@@ -52,6 +70,7 @@ function genDeclaredSetsEnums(sets) {
     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)]}`);
+    if (set.values) lines.push(...genSetValues(set, names));
     return lines.join('\n');
   }).join('\n');
 }

package/render/doors.mjs

@@ -52,7 +52,7 @@ export function doors(resolved) {
     .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 }))
+    .map((r) => ({ name: r.name, ids: r.value, default: r.default, ...(r.values ? { values: r.values, unit: r.unit } : {}) }))
     .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
   const ALIASES = new Map();
   for (const r of items) {

package/render/ts.mjs

@@ -14,7 +14,7 @@ export function tsValue(r) {
 
 /** The literal type of a JSON value, every member readonly. */
 export function tsType(v, indent = '') {
-  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+  if (v === null || typeof v === 'number' || typeof v === 'boolean') return String(v);
   if (typeof v === 'string') return JSON.stringify(v);
   const inner = `${indent}  `;
   if (Array.isArray(v)) return v.length ? `readonly [${v.map((x) => tsType(x, indent)).join(', ')}]` : 'readonly []';
@@ -83,12 +83,30 @@ function readoutsExport(resolved) {
   };
 }
 
+/**
+ * The value each id of a set carries, `<SET>_VALUES`: `{ <id>: value | null }`, for every set that declares values (the
+ * drive's roll-off corners), so a reader takes the number from the id, never from its spelling. Read it by id: an
+ * object keeps no order for an id such as 12000.
+ */
+function setValuesExports(resolved) {
+  const sets = [...resolved.values()].filter((r) => r.kind === 'set' && r.values);
+  const one = (r, decl) => {
+    const value = Object.fromEntries(r.value.map((id, i) => [id, r.values[i]]));
+    const doc = `/**\n * The value each id of ${r.name} carries, in ${JSON.stringify(r.unit)}; null for an id that carries none.\n * @see ${r.rel}\n */`;
+    return decl
+      ? `\n${doc}\nexport declare const ${r.name}_VALUES: ${tsType(value)};\n`
+      : `\n${doc}\nexport const ${r.name}_VALUES = ${JSON.stringify(value, null, 2)};\n`;
+  };
+  return { js: sets.map((r) => one(r, false)).join(''), dts: sets.map((r) => one(r, true)).join('') };
+}
+
 /** Every file of the `ts` target: `[{ path, text }]`. */
 export function renderTs(resolved) {
   const items = [...resolved.values()];
   const rule = eqRule(resolved);
   const readouts = readoutsExport(resolved);
-  const js = BANNER + items.map((r) => `\n${docComment(r)}\nexport const ${r.name} = ${JSON.stringify(tsValue(r), null, 2)};\n`).join('') + readouts.js + rule.js;
-  const dts = BANNER + items.map((r) => `\n${docComment(r)}\nexport declare const ${r.name}: ${tsType(tsValue(r))};\n`).join('') + readouts.dts + rule.dts;
+  const values = setValuesExports(resolved);
+  const js = BANNER + items.map((r) => `\n${docComment(r)}\nexport const ${r.name} = ${JSON.stringify(tsValue(r), null, 2)};\n`).join('') + values.js + readouts.js + rule.js;
+  const dts = BANNER + items.map((r) => `\n${docComment(r)}\nexport declare const ${r.name}: ${tsType(tsValue(r))};\n`).join('') + values.dts + readouts.dts + rule.dts;
   return [{ path: 'omx-contract.js', text: js }, { path: 'omx-contract.d.ts', text: dts }];
 }

package/schema/omx-contract.schema.json

@@ -181,7 +181,7 @@
     },
     "set": {
       "type": "object",
-      "description": "Ordered ids with an optional default and labels. The ids and their order are the contract: all strings of letters and digits (the id is the name, its position the value; an id may start with a digit, as 4x does) or all non-negative integers (the id is the value). Labels are face text and optional. The default may be a reference to the scalar that states it: a boolean names the second id of a two-id switch when true, the first when false.",
+      "description": "Ordered ids with an optional default, labels and a value per id. The ids and their order are the contract: all strings of letters and digits (the id is the name, its position the value; an id may start with a digit, as 4x does) or all non-negative integers (the id is the value). Labels are face text and optional. The default may be a reference to the scalar that states it: a boolean names the second id of a two-id switch when true, the first when false.",
       "properties": {
         "kind": { "const": "set" },
         "since": { "$ref": "#/$defs/since" },
@@ -194,9 +194,17 @@
           ]
         },
         "default": { "oneOf": [{ "type": "string", "pattern": "^[A-Za-z0-9]+$" }, { "type": "integer", "minimum": 0 }, { "$ref": "#/$defs/ref" }] },
-        "labels": { "type": "array", "items": { "$ref": "#/$defs/text" }, "minItems": 1 }
+        "labels": { "type": "array", "items": { "$ref": "#/$defs/text" }, "minItems": 1 },
+        "unit": { "$ref": "#/$defs/unit" },
+        "values": {
+          "description": "The value each id carries, in `unit`, one per id in id order; null for an id that carries none (the drive's `off` roll-off has no corner). Only a set of named ids carries values: a numeric id is its own value.",
+          "type": "array",
+          "items": { "oneOf": [{ "$ref": "#/$defs/number" }, { "type": "null" }] },
+          "minItems": 1
+        }
       },
       "required": ["kind", "doc", "ids"],
+      "dependentRequired": { "values": ["unit"], "unit": ["values"] },
       "additionalProperties": false
     },
     "item": {

package/share/omx-contract/omx-contract.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/omx-contract",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "items": {
     "PAN_RANGE": {
       "rel": "data/kernels/balance.json",
@@ -686,17 +686,23 @@
     "DRIVE_HF_ROLLOFFS": {
       "rel": "data/kernels/drive.json",
       "kind": "set",
-      "doc": "The drive's post-curve HIGH-FREQUENCY ROLL-OFF corner, in Hz: the id is the corner, and 0 names no roll-off (the section does not run: `omx_drive.h`'s `struct omx_drive.hf_on` is 0). The console's drive row offers off, 12000 and 16000 (`DriveState.hfRolloff`, `DRIVE_HF_ROLLOFFS`) and comes up off, as omx-dsp's drive face does.",
-      "default": 0,
+      "doc": "The drive's post-curve HIGH-FREQUENCY ROLL-OFF: `off` (the section does not run: `omx_drive.h`'s `struct omx_drive.hf_on` is 0), `12000` or `16000`, each carrying its corner in Hz as its value and `off` none (operator ruling, 2026-10-13: the choice is an enumeration and the frequency is data of each member, so no 0 Hz doubles as a sentinel). The ids are the console's drive-row wire vocabulary (`DriveState.hfRolloff`, what the drive row's OPTIONS publishes and a session stores), so the console re-exports this set; a kernel reads the corner from the id's value. It comes up off, as omx-dsp's drive face does.",
+      "unit": "Hz",
+      "default": "off",
       "labels": [
         "Off",
         "12 kHz",
         "16 kHz"
       ],
-      "value": [
-        0,
+      "values": [
+        null,
         12000,
         16000
+      ],
+      "value": [
+        "off",
+        "12000",
+        "16000"
       ]
     },
     "DRIVE_OVERSAMPLES": {