@vessel-dsp/runtime 0.6.3 → 0.12.0

package/dist/worklet/v2-audio-worklet.js

@@ -1360,6 +1360,77 @@ function reverbCombGain(delaySeconds, decaySeconds) {
   return Math.min(0.999, 10 ** (-3 * delaySeconds / decaySeconds));
 }
 var DEFAULT_NEWTON_MAX_ITERATIONS = 1024;
+function ldrTableResistanceOhms(currentsAmps, ohms, currentAmps, minOhms, maxOhms) {
+  if (!(currentAmps > 0)) {
+    return maxOhms;
+  }
+  const n = currentsAmps.length;
+  let lo = 0;
+  let hi = 1;
+  if (currentAmps <= currentsAmps[0]) {
+    lo = 0;
+    hi = 1;
+  } else if (currentAmps >= currentsAmps[n - 1]) {
+    lo = n - 2;
+    hi = n - 1;
+  } else {
+    for (let i = 0; i < n - 1; i++) {
+      if (currentAmps >= currentsAmps[i] && currentAmps <= currentsAmps[i + 1]) {
+        lo = i;
+        hi = i + 1;
+        break;
+      }
+    }
+  }
+  const iA = currentsAmps[lo];
+  const iB = currentsAmps[hi];
+  const rA = ohms[lo];
+  const rB = ohms[hi];
+  const lnI = Math.log(currentAmps);
+  const lnI0 = Math.log(iA);
+  const lnI1 = Math.log(iB);
+  const lnR0 = Math.log(rA);
+  const lnR1 = Math.log(rB);
+  const slope = (lnR1 - lnR0) / (lnI1 - lnI0);
+  const raw = Math.exp(lnR0 + (lnI - lnI0) * slope);
+  return Math.min(Math.max(raw, minOhms), maxOhms);
+}
+function dbxVcaGainLinear(gainDb) {
+  return Math.pow(10, gainDb / 20);
+}
+function dbxVcaRestTerms(vControl, sustainGain, sustainRef) {
+  return sustainGain * (vControl - sustainRef);
+}
+function dbxVcaEnvelopeTerms(inputAmps, slopeVoltsPerNeper, kneeVolts) {
+  const absIn = Math.abs(inputAmps);
+  if (!(absIn > 0)) return 0;
+  return Math.max(0, slopeVoltsPerNeper * Math.log(absIn * 1e6) + kneeVolts);
+}
+function dbxVcaKneeVolts(vControl, kneeBaseVolts, kneeTrack) {
+  return kneeBaseVolts + kneeTrack * (vControl - 4.65);
+}
+function dbxVcaReleaseTc(depth01, baseSeconds, slowdown) {
+  const depth = Math.min(1, Math.max(0, depth01));
+  return baseSeconds * Math.pow(slowdown, depth);
+}
+function dbxVcaPrimeTarget(inputAmps, refCurrentAmps) {
+  return Math.abs(inputAmps) > refCurrentAmps ? 0 : 1;
+}
+function dbxVcaShutdownTarget(peakTargetVolts, edgeThreshVolts, primed01, gainPerVolt) {
+  const excess = peakTargetVolts - edgeThreshVolts;
+  if (!(excess > 0) || !(primed01 > 0)) return 0;
+  const primed = Math.min(1, primed01);
+  return gainPerVolt * excess * excess * primed;
+}
+function dbxVcaVictimTc(primed01, fastSeconds, slowSeconds) {
+  const primed = Math.min(1, Math.max(0, primed01));
+  return primed > 0.05 ? slowSeconds : fastSeconds;
+}
+function dbxVcaEnvelopeK(tcSeconds, sampleRate2) {
+  const denom = tcSeconds * sampleRate2;
+  if (!(denom > 0)) return 1;
+  return 1 - Math.exp(-1 / denom);
+}
 var NEWTON_UNPRODUCTIVE_ITERATIONS = 64;
 var NEWTON_UNPRODUCTIVE_PROBATION_SAMPLES = 1024;
 var NEWTON_RELATIVE_TOLERANCE = 1e-3;
@@ -1542,7 +1613,10 @@ var IMPLEMENTED_OPERATORS = {
   "clock-driver": true,
   comparator: true,
   // Linear-control VCA cell. Reads the control node, draws nothing.
-  "linear-vca": true
+  "linear-vca": true,
+  // dbx-style VCA cell (uPC1252H2). Bounded sigmoidal gain in the
+  // control voltage. Reads the control node, draws nothing.
+  "dbx-vca": true
 };
 function unimplementedOperators(required) {
   return required.filter(
@@ -5376,7 +5450,15 @@ var ReferenceRuntime = class {
         rhs[stamp.ledCathode] = (rhs[stamp.ledCathode] ?? 0) + ledEquivalent;
         const alpha = 1e3;
         let rLdr;
-        if (stamp.ldrPowerLawCoefficientOhms !== void 0 && stamp.ldrPowerLawExponent !== void 0) {
+        if (stamp.ldrTableCurrentAmps !== void 0 && stamp.ldrTableOhms !== void 0 && stamp.ldrTableCurrentAmps.length === stamp.ldrTableOhms.length && stamp.ldrTableCurrentAmps.length >= 2) {
+          rLdr = ldrTableResistanceOhms(
+            stamp.ldrTableCurrentAmps,
+            stamp.ldrTableOhms,
+            ledCurrent,
+            stamp.ldrMinOhms,
+            stamp.ldrMaxOhms
+          );
+        } else if (stamp.ldrPowerLawCoefficientOhms !== void 0 && stamp.ldrPowerLawExponent !== void 0) {
           const powerLawCurrent = Math.max(ledCurrent, 0);
           const raw = stamp.ldrPowerLawCoefficientOhms * Math.pow(powerLawCurrent, stamp.ldrPowerLawExponent);
           rLdr = Math.min(Math.max(raw, stamp.ldrMinOhms), stamp.ldrMaxOhms);
@@ -6103,6 +6185,106 @@ var ReferenceRuntime = class {
         }
         break;
       }
+      case "dbx-vca": {
+        const dbxBaseIdx = stamp.stateIndex;
+        const ctrlKey = `${block.id}_dbxc_${dbxBaseIdx}`;
+        if (this.elapsedSamples !== (this.lastShiftedSample.get(ctrlKey) ?? -1)) {
+          this.lastShiftedSample.set(ctrlKey, this.elapsedSamples);
+          const vCtrlNow = solution[stamp.control] ?? 0;
+          const ctrlPrev = state[dbxBaseIdx] ?? 0;
+          const ctrlTc = vCtrlNow > ctrlPrev ? stamp.attackSeconds : stamp.releaseSeconds;
+          const ctrlK = dbxVcaEnvelopeK(ctrlTc, this.sampleRate);
+          state[dbxBaseIdx] = ctrlPrev + (vCtrlNow - ctrlPrev) * ctrlK;
+        }
+        const vCtrlHeld = state[dbxBaseIdx] ?? 0;
+        const restHeld = dbxVcaRestTerms(
+          vCtrlHeld,
+          stamp.sustainGain,
+          stamp.sustainRef
+        );
+        const kneeHeld = dbxVcaKneeVolts(
+          vCtrlHeld,
+          stamp.kneeBaseVolts,
+          stamp.kneeTrack
+        );
+        const vInInstDbx = (solution[stamp.plus] ?? 0) - (solution[stamp.minus] ?? 0);
+        const iInInstDbx = vInInstDbx * stamp.inputSiemens;
+        const primeKey = `${block.id}_dbxp_${dbxBaseIdx}`;
+        if (this.elapsedSamples !== (this.lastShiftedSample.get(primeKey) ?? -1)) {
+          this.lastShiftedSample.set(primeKey, this.elapsedSamples);
+          const primeTarget = dbxVcaPrimeTarget(
+            iInInstDbx,
+            stamp.primeRefCurrent
+          );
+          const primePrev = state[dbxBaseIdx + 2] ?? 0;
+          const primeTc = primeTarget > primePrev ? stamp.primeRiseSeconds : stamp.primeFallSeconds;
+          const primeK = dbxVcaEnvelopeK(primeTc, this.sampleRate);
+          state[dbxBaseIdx + 2] = primePrev + (primeTarget - primePrev) * primeK;
+        }
+        const primeHeld = state[dbxBaseIdx + 2] ?? 0;
+        const envKey = `${block.id}_dbxe_${dbxBaseIdx}`;
+        if (this.elapsedSamples !== (this.lastShiftedSample.get(envKey) ?? -1)) {
+          this.lastShiftedSample.set(envKey, this.elapsedSamples);
+          const envTarget = dbxVcaEnvelopeTerms(
+            iInInstDbx,
+            stamp.envelopeSlope,
+            kneeHeld
+          );
+          const envPrev = state[dbxBaseIdx + 1] ?? 0;
+          const envDepth = Math.min(1, Math.max(0, envPrev / 0.15));
+          const envTc = envTarget > envPrev ? stamp.attackSeconds : dbxVcaReleaseTc(envDepth, stamp.releaseSeconds, stamp.releaseSlowdown);
+          const envK = dbxVcaEnvelopeK(envTc, this.sampleRate);
+          state[dbxBaseIdx + 1] = envPrev + (envTarget - envPrev) * envK;
+        }
+        const envHeld = state[dbxBaseIdx + 1] ?? 0;
+        const shutKey = `${block.id}_dbxs_${dbxBaseIdx}`;
+        if (this.elapsedSamples !== (this.lastShiftedSample.get(shutKey) ?? -1)) {
+          this.lastShiftedSample.set(shutKey, this.elapsedSamples);
+          const peakTarget = dbxVcaEnvelopeTerms(
+            iInInstDbx,
+            stamp.envelopeSlope,
+            kneeHeld
+          );
+          const shutTarget = dbxVcaShutdownTarget(
+            peakTarget,
+            stamp.shutdownEdgeVolts,
+            primeHeld,
+            stamp.shutdownGain
+          );
+          const shutPrev = state[dbxBaseIdx + 3] ?? 0;
+          const shutTc = shutTarget > shutPrev ? stamp.shutdownAttackSeconds : dbxVcaVictimTc(
+            primeHeld,
+            stamp.shutdownFastSeconds,
+            stamp.shutdownSlowSeconds
+          );
+          const shutK = dbxVcaEnvelopeK(shutTc, this.sampleRate);
+          state[dbxBaseIdx + 3] = shutPrev + (shutTarget - shutPrev) * shutK;
+        }
+        const shutHeld = state[dbxBaseIdx + 3] ?? 0;
+        const termsHeld = restHeld + envHeld;
+        const rawDb = -termsHeld / 59e-4;
+        const gainDb = Math.min(stamp.maxGainDb, Math.max(stamp.minGainDb, rawDb));
+        const totalDb = Math.max(-100, gainDb - shutHeld / 59e-4);
+        const gain = dbxVcaGainLinear(totalDb);
+        const vPlus = solution[stamp.plus] ?? 0;
+        const vMinus = solution[stamp.minus] ?? 0;
+        const vIn = vPlus - vMinus;
+        const iIn = vIn * stamp.inputSiemens;
+        const iOut = iIn * gain;
+        const gIn = gain * stamp.inputSiemens;
+        const leaving = -iOut;
+        const equivalent = leaving - (-gIn * vPlus + gIn * vMinus);
+        if (stamp.output !== 0) {
+          if (stamp.plus !== 0) {
+            matrix[stamp.output][stamp.plus] += -gIn;
+          }
+          if (stamp.minus !== 0) {
+            matrix[stamp.output][stamp.minus] += gIn;
+          }
+          rhs[stamp.output] = (rhs[stamp.output] ?? 0) - equivalent;
+        }
+        break;
+      }
       case "spring-reverb": {
         const conductance = 1 / Math.max(stamp.inputOhms, MIN_STAMP_OHMS);
         matrix[stamp.inputPlus][stamp.inputPlus] += conductance;

package/package.json

@@ -1,66 +1,66 @@
 {
-	"name": "@vessel-dsp/runtime",
-	"version": "0.6.3",
-	"description": "Real-time MNA simulation runtime and solver console for VesselDSP Program ROMs.",
-	"keywords": [
-		"guitar-pedal",
-		"electronics",
-		"simulation",
-		"dsp",
-		"runtime",
-		"solver",
-		"mna"
-	],
-	"homepage": "https://vessel-dsp.github.io/core/",
-	"bugs": {
-		"url": "https://github.com/vessel-dsp/core/issues"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/vessel-dsp/core.git"
-	},
-	"license": "MIT",
-	"sideEffects": false,
-	"type": "module",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"bun": "./dist/index.js",
-			"import": "./dist/index.js"
-		},
-		"./package.json": {
-			"default": "./package.json"
-		},
-		"./wasm/*": {
-			"default": "./dist/wasm/*"
-		},
-		"./worklet.js": {
-			"default": "./dist/worklet/v2-audio-worklet.js"
-		}
-	},
-	"main": "./dist/index.js",
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"files": [
-		"dist",
-		"README.md",
-		"LICENSE.md"
-	],
-	"scripts": {
-		"build": "tsc -p tsconfig.build.json && bun run ../../scripts/fix-dist-imports.ts dist && rm -rf dist/wasm && cp -r src/wasm dist/wasm && bun scripts/build-worklet.ts",
-		"clean": "rm -rf dist",
-		"prepack": "bun run --cwd ../core build && bun run --cwd ../compiler build && bun run build:wasm && bun run build",
-		"pack:dry-run": "npm pack --dry-run",
-		"typecheck": "tsc --noEmit -p tsconfig.json",
-		"build:wasm": "bash scripts/build-wasm.sh",
-		"build:worklet": "bun scripts/build-worklet.ts",
-		"test": "bun test tests",
-		"generate-kernels": "bun scripts/generate-kernels.ts"
-	},
-	"dependencies": {
-		"@vessel-dsp/compiler": "0.8.1"
-	},
-	"publishConfig": {
-		"access": "public"
-	}
+  "name": "@vessel-dsp/runtime",
+  "version": "0.12.0",
+  "description": "Real-time MNA simulation runtime and solver console for VesselDSP Program ROMs.",
+  "keywords": [
+    "guitar-pedal",
+    "electronics",
+    "simulation",
+    "dsp",
+    "runtime",
+    "solver",
+    "mna"
+  ],
+  "homepage": "https://vessel-dsp.github.io/core/",
+  "bugs": {
+    "url": "https://github.com/vessel-dsp/core/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vessel-dsp/core.git"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./dist/index.js",
+      "import": "./dist/index.js"
+    },
+    "./package.json": {
+      "default": "./package.json"
+    },
+    "./wasm/*": {
+      "default": "./dist/wasm/*"
+    },
+    "./worklet.js": {
+      "default": "./dist/worklet/v2-audio-worklet.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && bun run ../../scripts/fix-dist-imports.ts dist && rm -rf dist/wasm && cp -r src/wasm dist/wasm && bun scripts/build-worklet.ts",
+    "clean": "rm -rf dist",
+    "prepack": "bun run --cwd ../core build && bun run --cwd ../compiler build && bun run build:wasm && bun run build",
+    "pack:dry-run": "npm pack --dry-run",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "build:wasm": "bash scripts/build-wasm.sh",
+    "build:worklet": "bun scripts/build-worklet.ts",
+    "test": "bun test tests",
+    "generate-kernels": "bun scripts/generate-kernels.ts"
+  },
+  "dependencies": {
+    "@vessel-dsp/compiler": "0.14.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }