@openmixer/omx-contract 2.10.1 → 2.12.0

package/include/omxcontract/omx_contract_limits.h

@@ -387,6 +387,26 @@
 #define OMX_GROWTH_MIN_DB_PER_FRAME_DOUBLE 0.8
 #define OMX_GROWTH_MIN_TOTAL_RISE_DB 6
 #define OMX_GROWTH_WINDOW_FRAMES 5
+#define OMX_HOSTED_STAGE_AUX_INPUTS 8
+#define OMX_HOSTED_STAGE_AUX_OUTPUTS 8
+#define OMX_HOSTED_STAGE_CLAMP_DBFS 24
+#define OMX_HOSTED_STAGE_EVENTS_PER_BLOCK 64
+#define OMX_HOSTED_STAGE_LATENCY_HOLD_MS 250
+#define OMX_HOSTED_STAGE_LOG_BYTES 256
+#define OMX_HOSTED_STAGE_MAIN_PORT_CHANNELS 2
+#define OMX_HOSTED_STAGE_NON_FINITE_STRIKES 3
+#define OMX_HOSTED_STAGE_NOTES_PER_BLOCK 256
+#define OMX_HOSTED_STAGE_PARAM_COUNT_MAX 2048
+#define OMX_HOSTED_STAGE_PARAM_QUEUE_DEPTH 256
+#define OMX_HOSTED_STAGE_ROLE_POLL_US 1000
+#define OMX_HOSTED_STAGE_ROLE_TIMEOUT_US 200000
+#define OMX_HOSTED_STAGE_STATE_MAX_BYTES 1048576
+#define OMX_HOSTED_STAGE_UNPUBLISH_POLL_US 100
+#define OMX_HOSTED_STAGE_UNPUBLISH_TIMEOUT_US 2000000
+#define OMX_HOSTED_STAGE_WARMUP_BLOCKS 64
+#define OMX_HOSTED_STAGE_WARMUP_LEVEL_DBFS -6
+#define OMX_HOSTED_STAGE_WORKER_POLL_US 1000
+#define OMX_HOSTED_STAGE_WORKER_RING_BYTES 16384
 #define OMX_HPF_FREQ_RANGE_MAX 1000
 #define OMX_HPF_FREQ_RANGE_MIN 20
 #define OMX_HPF_FREQ_RANGE_STEP 10
@@ -690,12 +710,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

@@ -203,11 +203,12 @@ export function rawValue(item) {
     case 'sheet': return item.value;
     case 'list': return item.values;
     case 'set': return item.ids;
+    case 'codes': return item.codes;
     default: return undefined;
   }
 }
 
-/** The closed list of derivations (spec §3.3). A new one is a change here with its own test. */
+/** The closed list of derivations. A new one is a change here with its own test. */
 export const DERIVATIONS = {
   count: (d, val) => {
     const v = val(typeof d.of === 'string' ? { ref: d.of } : d.of);
@@ -262,7 +263,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.
@@ -302,9 +303,11 @@ export function resolveData(data) {
     if (item.why !== undefined) r.why = item.why;
     if (item.unit !== undefined) r.unit = item.unit;
     if (item.c !== undefined) r.c = item.c;
+    if (item.docs !== undefined) r.docs = item.docs;
     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/fmt.mjs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 /**
- * The one formatting of a data file (spec §3.2): two-space indent, one key per line, keys in schema
+ * The one formatting of a data file: two-space indent, one key per line, keys in schema
  * order, a trailing newline. Names (items, fields, sheet keys) keep the order the author gave them:
  * a travels table's field order is its C block order. A kernel file's sections come in their order (controls,
  * readouts, tables, aggregates, constants), its controls and readouts in the author's order, each one's keys in
@@ -12,7 +12,7 @@ const ORDER = {
   control: ['name', 'kind', 'global', 'table', 'rearms', 'since', 'doc', 'why', 'unit', 'ids', 'default', 'labels', 'travel', 'c'],
   sections: ['controls', 'readouts', 'tables', 'aggregates', 'constants'],
   readout: ['name', 'doc', 'unit', 'min', 'max', 'scale', 'rateHz'],
-  item: ['kind', 'since', 'doc', 'why', 'unit', 'value', 'values', 'ids', 'default', 'labels', 'fields', 'travel', 'c'],
+  item: ['kind', 'since', 'doc', 'why', 'unit', 'value', 'docs', 'values', 'ids', 'default', 'labels', 'fields', 'travel', 'codes', 'c'],
   travel: ['min', 'max', 'step', 'unit', 'default', 'defaultFrom', 'scale', 'byKind', 'doc', 'why'],
   c: ['alias', 'render'],
   alias: ['fact', 'field'],
@@ -48,6 +48,7 @@ function item(it) {
   if (!isObj(it)) return it;
   const o = ordered(it, ORDER.item);
   if ('value' in o) o.value = o.kind === 'sheet' ? sheet(o.value) : number(o.value);
+  if (isObj(o.codes)) o.codes = Object.fromEntries(Object.entries(o.codes).map(([k, c]) => [k, ordered(c, ['code', 'doc'])]));
   if (isObj(o.fields)) o.fields = Object.fromEntries(Object.entries(o.fields).map(([k, t]) => [k, isObj(t) ? travel(t) : t]));
   if (isObj(o.travel)) o.travel = travel(o.travel);
   if (isObj(o.c)) {

package/lib/semver.mjs

@@ -1,15 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 /**
- * `omx-contract semver`: classify every change between two resolved declarations (spec §3.6) and
+ * `omx-contract semver`: classify every change between two resolved declarations and
  * refuse a version whose bump is shorter than the largest class found.
  *
  *   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
@@ -20,7 +21,7 @@
 const RANK = { none: 0, patch: 1, minor: 2, major: 3 };
 
 /**
- * The development-phase rule (omx-contract spec §3.6): while every consumer of
+ * The development-phase rule: 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. Until then a MAJOR class is released as a minor bump (see refusal).
@@ -94,8 +95,9 @@ 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)}`);
-    if (a.doc !== b.doc || (a.why ?? '') !== (b.why ?? '')) say('patch', 'doc');
+    // 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 ?? '') || !same(a.docs, b.docs)) 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');
     switch (a.kind) {
@@ -123,11 +125,26 @@ 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;
+      case 'codes':
+        for (const k of Object.keys(a.value)) {
+          if (!(k in b.value)) say('major', `${name}.${k} removed`);
+          else if (a.value[k].code !== b.value[k].code) say('major', `${name}.${k}: ${JSON.stringify(a.value[k].code)} -> ${JSON.stringify(b.value[k].code)} (a code is read by verdicts, never reworded)`);
+          else if ((a.value[k].doc ?? '') !== (b.value[k].doc ?? '')) say('patch', `${name}.${k}: doc`);
+        }
+        for (const k of Object.keys(b.value)) if (!(k in a.value)) say('minor', `${name}.${k} added`);
         break;
       default:
         break;

package/lib/validate.mjs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 /**
- * `omx-contract validate`: the schema, then the checks a schema cannot express (spec §3.3): every
+ * `omx-contract validate`: the schema, then the checks a schema cannot express: every
  * reference resolves with no cycle; every default inside its travel; every C name the render spells
  * is unique; an item's `c.alias` names no other item. Each failure names file, item and rule.
  */
@@ -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) {
@@ -119,6 +127,26 @@ function semanticRules(resolved, say) {
     }
   }
 
+  // A sheet's prose names fields the sheet has; a code is declared once.
+  for (const r of resolved.values()) {
+    if (r.kind === 'sheet' && r.docs !== undefined) {
+      for (const f of Object.keys(r.docs)) if (!(f in r.value)) say(r.rel, r.name, 'sheet-docs', `docs.${f} describes no field of ${r.name}`);
+    }
+    if (r.kind === 'codes') {
+      const seenCodes = new Map();
+      for (const [k, c] of Object.entries(r.value)) {
+        if (seenCodes.has(c.code)) say(r.rel, r.name, 'code-unique', `${k} and ${seenCodes.get(c.code)} both carry ${JSON.stringify(c.code)}`);
+        seenCodes.set(c.code, k);
+      }
+    }
+  }
+
+  // The hosted stage's limits are finite numbers, the header of the CLAP core reads each as a define.
+  const stage = resolved.get('HOSTED_STAGE_LIMITS');
+  if (stage) {
+    for (const [f, v] of Object.entries(stage.value)) if (typeof v !== 'number' || !Number.isFinite(v)) say(stage.rel, stage.name, 'finite', `HOSTED_STAGE_LIMITS.${f} resolves to ${JSON.stringify(v)}`);
+  }
+
   // A readout's numbers are finite, its range runs upward, its rate is positive and its scale is a PARAM_SCALES id.
   for (const [k, { readouts }] of Object.entries(resolved.kernels ?? {})) {
     for (const ro of readouts ?? []) {
@@ -130,6 +158,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.1",
+  "version": "2.12.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/clap-host-limits.mjs

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * `clap_host_limits.h`: the header the CLAP core (omx-clap-core) builds against and installs, rendered from
+ * `HOSTED_STAGE_LIMITS` and `HOSTING_CODES`. It is the library's API documentation too, so every define carries
+ * the prose declared beside its number or code as a trailing `///<` comment; the frame below is the only prose
+ * here. The fields named `worker*` are the LV2 adapter's and are not rendered.
+ */
+
+const constCase = (s) => String(s).replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+
+/** The licence block every source file of omx-clap-core opens with: the SPDX line, the GPL notice, the copyright line, a blank line. */
+const LICENCE = `/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * This file is part of omx-clap-host.
+ *
+ * omx-clap-host is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * omx-clap-host is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with omx-clap-host.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+ */
+
+`;
+
+const isLevel = (field) => field.endsWith('Dbfs');
+
+/** A define with its prose as a trailing member comment; a one-line prose only, or the rest would be read as C. */
+function documented(define, prose, where) {
+  if (prose === undefined) return define;
+  if (typeof prose !== 'string' || prose.length === 0 || /[\n\r]/.test(prose)) throw new Error(`clap-host-limits: ${where} is no one-line description`);
+  return `${define}  ///< ${prose}`;
+}
+
+/** The header of the resolved items `HOSTED_STAGE_LIMITS` and `HOSTING_CODES`. */
+export function renderClapHostLimits(stage, codes) {
+  const numbers = Object.entries(stage.value)
+    .filter(([field]) => !field.startsWith('worker'))
+    .map(([field, v]) => {
+      if (typeof v !== 'number' || !Number.isFinite(v)) throw new Error(`clap-host-limits: HOSTED_STAGE_LIMITS.${field} is not a finite number`);
+      const literal = isLevel(field) ? `${Number.isInteger(v) ? `${v}.0` : v}f` : Number.isInteger(v) && v >= 0 ? `${v}u` : null;
+      if (literal === null) throw new Error(`clap-host-limits: HOSTED_STAGE_LIMITS.${field} is neither a level (Dbfs) nor a non-negative integer`);
+      return documented(`#define CLAP_HOST_${constCase(field)} ${literal}`, stage.docs?.[field], `HOSTED_STAGE_LIMITS.docs.${field}`);
+    });
+  const refusals = Object.entries(codes.value)
+    .map(([name, c]) => documented(`#define CLAP_HOST_CODE_${constCase(name)} ${JSON.stringify(c.code)}`, c.doc, `HOSTING_CODES.${name}.doc`));
+  return `${LICENCE}#ifndef CLAP_HOST_LIMITS_H
+#define CLAP_HOST_LIMITS_H
+/*
+ * GENERATED — DO NOT EDIT BY HAND.
+ * Rendered by \`omx-contract render --target c\` from FreeMixer/omx-contract's HOSTED_STAGE_LIMITS and
+ * HOSTING_CODES. The rendered file is kept in this repository so the library builds on its own; the numbers
+ * and codes are changed where they are declared and the file is re-rendered, never edited here.
+ */
+
+/** @file
+ * @brief The limits and refusal codes of the hosting code. */
+
+#include <stddef.h>
+
+/** the stage and the host: every number the core reads */
+${numbers.join('\n')}
+
+/** the refusals the core returns, as the hosting codes the console's verdicts use */
+${refusals.join('\n')}
+
+#endif /* CLAP_HOST_LIMITS_H */
+`;
+}

package/render/c.mjs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 /**
- * The `c` target: `omxcontract/omx_contract_limits.h`. Every define is spelled by openmixer's
+ * The `c` target: `omxcontract/omx_contract_limits.h`, and `omxcontract/clap_host_limits.h` where the data declares the hosting limits and codes (docs/hosting.md). Every define is spelled by the console engine'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, by reference to the items here.
@@ -10,11 +10,12 @@ import {
   cStringLiteral, genCoreLimitBlock, genDeclaredListsBlock, genDeclaredRates, genDeclaredScalarsBlock, genLimitBlock, renderContractLimits,
   scalarLiteral,
 } from './c/contract-limits-render.mjs';
+import { renderClapHostLimits } from './c/clap-host-limits.mjs';
 import { doors } from './doors.mjs';
 
 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. */
+/** The rate tail of the console engine's header, outside the include guard, byte for byte. */
 function ratesTail(rates) {
   return `
 /* The sample rates the console declares (core's STANDARD_SAMPLE_RATES, row-codecs.ts): the set a
@@ -43,8 +44,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 +71,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');
 }
@@ -174,12 +194,16 @@ ${d.STANDARD_SAMPLE_RATES ? ratesTail(d.STANDARD_SAMPLE_RATES) : ''}`;
 
 /** Every file of the `c` target: `[{ path, text }]`, paths relative to the output directory. */
 export function renderC(resolved) {
-  return [{ path: 'omxcontract/omx_contract_limits.h', text: renderLimitsHeader(resolved) }];
+  const files = [{ path: 'omxcontract/omx_contract_limits.h', text: renderLimitsHeader(resolved) }];
+  const stage = resolved.get('HOSTED_STAGE_LIMITS');
+  const codes = resolved.get('HOSTING_CODES');
+  if (stage && codes) files.push({ path: 'omxcontract/clap_host_limits.h', text: renderClapHostLimits(stage, codes) });
+  return files;
 }
 
 /**
- * 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).
+ * The `c` target of a frozen sheet (test/fixtures/frozen-limits-sheet.json): `{ sheet }` rendered by the moved
+ * renderer, for the round-trip proof.
  */
 export function renderSheetC(fixture) {
   const s = fixture.sheet;

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

@@ -4,7 +4,7 @@ import { eqDefaultBands, eqDefaultCentres, eqDefaultParams, eqDefaultTypes } fro
 
 /**
  * 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.
+ * name with its literal type (`as const`), so a consumer's re-export keeps names, values and types.
  */
 
 /** The value a TypeScript reader sees for one resolved item. */
@@ -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

@@ -12,7 +12,7 @@
   "$defs": {
     "unit": {
       "description": "The closed list of units the items use; \"x\" is a multiplier, \"\" is a ratio or a fraction.",
-      "enum": ["dB", "dBFS", "ms", "s", "min", "Hz", "oct", "cents", "%", "x", ""]
+      "enum": ["dB", "dBFS", "ms", "s", "min", "Hz", "oct", "cents", "st", "%", "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/." },
@@ -156,7 +156,14 @@
         "since": { "$ref": "#/$defs/since" },
         "doc": { "$ref": "#/$defs/text" },
         "why": { "$ref": "#/$defs/text" },
-        "value": { "$ref": "#/$defs/sheetValue" }
+        "value": { "$ref": "#/$defs/sheetValue" },
+        "docs": {
+          "description": "One line of prose per top-level field of `value`, rendered beside the field's define in a header that documents it. A field without one has none.",
+          "type": "object",
+          "propertyNames": { "pattern": "^[a-z][A-Za-z0-9]*$" },
+          "additionalProperties": { "$ref": "#/$defs/text" },
+          "minProperties": 1
+        }
       },
       "required": ["kind", "doc", "value"],
       "additionalProperties": false
@@ -179,9 +186,35 @@
       "required": ["kind", "doc", "unit", "values"],
       "additionalProperties": false
     },
+    "codes": {
+      "type": "object",
+      "description": "Refusal codes: a lowerCamel name per code, the code itself (`hosting.<group>.<reason>`, lower case, read by verdicts and never reworded) and optionally one line of prose.",
+      "properties": {
+        "kind": { "const": "codes" },
+        "since": { "$ref": "#/$defs/since" },
+        "doc": { "$ref": "#/$defs/text" },
+        "why": { "$ref": "#/$defs/text" },
+        "codes": {
+          "type": "object",
+          "propertyNames": { "pattern": "^[a-z][A-Za-z0-9]*$" },
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "code": { "type": "string", "pattern": "^hosting(\\.[a-z0-9]+(-[a-z0-9]+)*){2,}$" },
+              "doc": { "$ref": "#/$defs/text" }
+            },
+            "required": ["code"],
+            "additionalProperties": false
+          },
+          "minProperties": 1
+        }
+      },
+      "required": ["kind", "doc", "codes"],
+      "additionalProperties": false
+    },
     "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,21 +227,30 @@
           ]
         },
         "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": {
       "type": "object",
       "required": ["kind"],
-      "properties": { "kind": { "enum": ["scalar", "travels", "sheet", "list", "set"] } },
+      "properties": { "kind": { "enum": ["scalar", "travels", "sheet", "list", "set", "codes"] } },
       "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": "set" } } }, "then": { "$ref": "#/$defs/set" } }
+        { "if": { "properties": { "kind": { "const": "set" } } }, "then": { "$ref": "#/$defs/set" } },
+        { "if": { "properties": { "kind": { "const": "codes" } } }, "then": { "$ref": "#/$defs/codes" } }
       ]
     }
   }