@tir.jp/asg3 0.1.20260404-ALPHA

package/LICENSE

@@ -0,0 +1,19 @@
+zlib License
+
+(C) 2026 ayamada
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

package/dist/asg3.min.mjs

@@ -0,0 +1 @@
+var de,B=(e=521288629)=>de=e;B();var ye=Number.EPSILON*2,ge=1-Number.EPSILON*2,ve=e=>Math.max(ye,Math.min(e,ge));var $=(e,t=521288629)=>{let n=t+Math.imul(e+1|0,1831565813)|0;return xe(n)},xe=e=>{let t=Math.imul(e^e>>>15,e|1);return t=t+Math.imul(t^t>>>7,t|61)^t,ve(((t^t>>>14)>>>0)/4294967296)};var j=e=>7040*2**((e-69)/12-4),X=(e,t=4)=>{let n=e.length;if(t*2<n)for(let o=0;o<t;o++){let r=o/t;e[o]*=r,e[n-1-o]*=r}},H=(e,t,n,o=1)=>{if(o<=0)return e+(t-e)*n;let r;if(o===1)r=(1-Math.cos(n*Math.PI))*.5;else{let i=-Math.cos(n*Math.PI),c=i;o>1&&(c=Math.sign(i)*Math.pow(Math.abs(i),1/o));let s=(c+1)*.5;o<1?r=n*(1-o)+s*o:r=s}return e+(t-e)*r},O=(e,t,n)=>.5*(e+t-(t-e)*Math.cos(n*Math.PI)),V=(e,t,n,o)=>O(e,t,Math.min(1,n*Math.max(1,o)));var Z=(e,t,n)=>{let o=n*e.length,r=Math.floor(o),i=o%1,c=e[r%e.length],s=e[(r+1)%e.length],l=.5/e.length/t;return V(c,s,i,l)},b=.95,Fe=e=>{let t=e.lapProgress*4,n=t<1?t:t<3?2-t:t-4,o=Math.abs(n)-b;if(o<=0)return n;let r=o/(1-b),i=r*(1-r*.5);return Math.sign(n)*(b+i*(1-b))},J=e=>{let t=1-e*2,n=-b,o=b;if(n<=t&&t<=o)return t;let r=t<0?t+2:t,i=n+2,c=o,s=(r-i)/(c-i);return O(n,o,s)},v=(e,t)=>$(t*2+(e.seedOffset||0)),ke=e=>v(e,e.tick)*2-1,Me=e=>v(e,e.tick)>=.5?1:-1,Ne=e=>v(e,e.lapCount)*2-1,Q=e=>v(e,e.lapCount)>=.5?1:-1,be=e=>{let t=v(e,e.lapCount)*2-1,n=e.lapCount?v(e,e.lapCount-1)*2-1:t;return V(n,t,e.lapProgress,1)},Le=e=>{let t=v(e,e.lapCount)>=.5?1:-1,n=e.lapCount?v(e,e.lapCount-1)>=.5?1:-1:t;return V(n,t,e.lapProgress,1)},Ie=(e,t,n)=>{let o=[],r=0;for(let i=e;i<=t;i++){let c=n(i);o.push(c),r+=c}return i=>{let c=i.lapCount+i.lapProgress,s=0;for(let l=e;l<=t;l++){let u=2**l,a=Math.floor(c*u)*13+l,f=v(i,a)*2-1;s+=f*o[l-e]}return s/r}},Te=e=>.8**Math.abs(e),We=Ie(-4,4,Te),Y={sine:e=>Math.sin(e.lapProgress*2*Math.PI),saw:e=>J(e.lapProgress),"saw-reverse":e=>J(1-e.lapProgress),square:(e=>Z([1,-1],e.noteFreqByTick,e.lapProgress)),triangle:Fe,noise:Q,"noise-binary":Q,"noise-white":Ne,"noise-binary-rounded":Le,"noise-white-rounded":be,"noise-binary-frequencyless":Me,"noise-white-frequencyless":ke,"noise-fractal":We},Ae=(e,t)=>e?.constructor===String||e?.constructor===Function||Array.isArray(e)&&e.every(Number.isFinite)?e:t,C=(e,t)=>{if(e=Ae(e,t),e instanceof Function)return e;if(Array.isArray(e))return(o=>Z(e,o.noteFreqByTick,o.lapProgress));let n;return e?.constructor===String&&(n=Y[e]),n||(n=Y["noise-binary-frequencyless"]),n};var Se=1,U=["envelope","sweep","vibrato","tremolo","lfo","morph"],M=(e,t,n=0)=>{let o=[{x:0,v:n}],r=0;if(Number.isFinite(e))return()=>e;if(e&&e.length>0)for(let s of e){let l=Array.isArray(s)&&Number.isFinite(s[0])?s[0]:0,u=Array.isArray(s)&&Number.isFinite(s[1])?s[1]:n,p=Array.isArray(s)&&Number.isFinite(s[2])?s[2]:Se;r+=l,o.push({x:r,v:u,interpolationIntensity:p})}else return()=>n;let i=r||1,c=0;return s=>{let l=s/Math.max(1,t-1)*i;for(;c<o.length-1&&o[c+1].x<=l;)c++;for(;c>0&&o[c].x>l;)c--;let u=o[c],p=o[c+1];if(!p)return u.v;let a=p.x-u.x;if(a<=1e-9)return p.v;let f=(l-u.x)/a;return H(u.v,p.v,f,p.interpolationIntensity)}},Pe=e=>{let t=0;if(e){let n=0;for(let o=0;o<e.length;o++){let r=e[o],i=Array.isArray(r)&&Number.isFinite(r[0])?r[0]:0;n<i&&(t=o,n=i)}}return t},ee=(e,t,n=void 0)=>{if(e.duration===void 0||e.duration===t)return e;let o=null;for(let a of U)if(Array.isArray(e[a])&&e[a].length>0){o=e[a];break}if(n===void 0&&(n=e.preferredScaleGraphTargetIdx??Pe(o)),!o||!o[n])return{...e,duration:t};let r=o.reduce((a,f)=>{let h=Array.isArray(f)&&Number.isFinite(f[0])?f[0]:0;return a+h},0);if(r<=0)return{...e,duration:t};let i=Array.isArray(o[n])&&Number.isFinite(o[n][0])?o[n][0]:0,c=t/e.duration,s=r*c,l=i+(s-r),u=t;if(l<0){l=0;let a=r-i;u=e.duration*(a/r)}let p={...e,duration:u};for(let a of U)Array.isArray(p[a])&&(p[a]=p[a].map((f,h)=>h===n?[l,f[1]]:f));return p};var Ce=[[0,1],[1,0]],te="triangle",qe="sine",ne=(e,t)=>{let n=e.lapProgress+t,o=Math.floor(n);e.lapCount+=o,e.lapProgress=n-o},W=(e,t)=>{let n=Number.isFinite(t.noteNumber)?t.noteNumber:69,o=Number.isFinite(t.velocity)?t.velocity:100,r=Number.isFinite(t.duration)?t.duration:1,i=C(t.waveform,te),c=t.morphWaveform?C(t.morphWaveform,te):null,s=C(t.lfoWaveform,qe);B();let l=Math.max(4,Math.ceil(r*e)),u=new Float32Array(l),p=M(t.envelope||Ce,l,t.envelope?.length?0:1),a=M(t.sweep,l,0),f=M(t.vibrato,l,0),h=M(t.tremolo,l,0),N=M(t.lfo,l,4),d=M(t.morph,l,0),m={tick:0,lapProgress:0,lapCount:0,noteFreqByTick:0,seedOffset:0},y={tick:0,lapProgress:0,lapCount:0,noteFreqByTick:0,seedOffset:1},A=o/127;for(;m.tick<l;){y.tick=m.tick;let w=p(m.tick),L=a(m.tick),g=f(m.tick),I=h(m.tick),S=N(m.tick),k=d(m.tick);y.noteFreqByTick=S/e,ne(y,y.noteFreqByTick);let T=s(y),q=I*T,R=g*T,me=j(n+L+R);m.noteFreqByTick=me/e,ne(m,m.noteFreqByTick);let P=i(m);if(c&&k>0)if(k>=1)P=c(m);else{let he=c(m);P=P*(1-k)+he*k}u[m.tick]=P*A*w*Math.max(0,1+q),m.tick++}return X(u),[u]};var Be=(e=69,t=69)=>e+t-69,Oe=(e=100,t=100)=>e*t/100,D=(e,t)=>({noteNumber:Be(e.noteNumber,t.noteNumber),velocity:Oe(e.velocity,t.velocity),duration:e.duration,graphScaleIdx:e.graphScaleIdx}),E=(e,t)=>`${e}-${t.noteNumber}-${t.velocity}-${t.duration}-${t.graphScaleIdx}`,_e=e=>Number.isInteger(e),oe=(e,t)=>{let n=new Map;for(let c of e)for(let s of c)if(!_e(s)){let l=s.calibrateParams||{},u=D(l,t),p=s.inst||0,a=E(p,u);n.set(a,(n.get(a)||0)+1)}let o=[];for(let[c,s]of n.entries())s>=2&&o.push({key:c,count:s});o.sort((c,s)=>s.count-c.count);let r=Math.floor(o.length*.2);o.length>0&&r===0&&(r=1);let i=new Set;for(let c=0;c<r;c++)i.add(o[c].key);return i};var re=(e,t,n)=>(console.log("niy"),t),se=e=>(console.log("niy"),e);var ce=e=>Number.isInteger(e),De=e=>Math.max(8,Math.floor(e*.001)),ie=(e,t,n)=>{let o=Math.min(n,e.length-t);for(let r=0;r<o;r++)t+r<0||(e[t+r]*=r/n)},le=(e,t,n)=>{let o=Math.min(n,t);for(let r=0;r<o;r++)t-r-1<0||(e[t-r-1]*=r/n)},ae=(e,t,n,o)=>{let r=Math.min(n.length,e.length-t);if(!(r<=0))if(o===1)e.set(n.subarray(0,r),t);else for(let i=0;i<r;i++)t+i<0||(e[t+i]=n[i]*o)},ue=(e,t,n,o,r,i,c)=>{let s,l=0;for(let d of n)ce(d)?l+=d:s??=l;s??=0;let u=s,p=l-s,a=new Float32Array(p),f=new Float32Array(p),h=-u,N=De(e);for(let d of n)if(ce(d))h+=d;else{le(a,h,N),le(f,h,N);let m=d.calibrateParams||{},y=D(m,o),A=d.inst||0,w=t[A],L=E(A,y),g;r.has(L)?(g=i.get(L),g||(g=c(e,y,w),i.set(L,g))):g=c(e,y,w);let I=g[0],S=g[1]||I;ie(a,h+I.length,N),ie(f,h+S.length,N);let k=d.amp??1,T=d.pan||0,q=k*Math.min(1,1-T),R=k*Math.min(1,1+T);ae(a,h,I,q),ae(f,h,S,R)}return{offsetTick:u,bufL:a,bufR:f}};var Ee=e=>{let r=0;for(let s=0;s<e.length;s++){let l=e[s],u=l.length;for(let p=0;p<u;p+=11){let a=l[p];a<0&&(a=-a),r<a&&(r=a)}}let c=(()=>{let s=r;return s<1?r:(s=(s-1)/3+1,s<2||(s=(s-2)/3+2),s)})();if(.96<c){let s=.96/c;for(let l=0;l<e.length;l++){let u=e[l],p=u.length;for(let a=0;a<p;a++){let f=u[a];f>=1?(f=(f-1)/3+1,f>=2&&(f=(f-2)/3+2)):f<=-1&&(f=(f+1)/3-1,f<=-2&&(f=(f+2)/3-2)),u[a]=f*s}}}},fe=e=>{let t=Math.max(4,...e.map(({offsetTick:i,bufL:c})=>i+c.length)),n=new Float32Array(t),o=new Float32Array(t);e.forEach(({offsetTick:i,bufL:c,bufR:s})=>{let l=c.length;for(let u=0;u<l;u++)n[i+u]+=c[u],o[i+u]+=s[u]});let r=[n,o];return Ee(r),r};var Ge=(e,t,n={})=>{if(n.type==="M")return G(e,n,t);{let r={noteNumber:69,velocity:100,duration:1,...n};if(t.noteNumber!=null&&(r.noteNumber+=t.noteNumber-69),t.velocity!=null&&(r.velocity*=t.velocity/100),t.duration!=null){let i=r.duration,c=t.duration;c!=null&&i!=c&&(r=ee(r,c,t.graphScaleIdx))}return W(e,r)}},G=(e,t,n={})=>{let o=Array.isArray(t.instruments)?t.instruments:[],r=Array.isArray(t.musicScore)?t.musicScore:[],i=t.fullyResolvedLanes;i||=re(e,se(r),n);let c=oe(i,n),s=new Map,l=i.map(u=>ue(e,o,u,n,c,s,Ge));return fe(l)};var ze=48e3,$e=e=>{let t=Number.isFinite(e)?e:ze;return Math.max(8e3,Math.min(96e3,t))},Ke={I:W,M:G},z=e=>{let t=$e(e.sampleRate),n=e.name,r=(Ke[e.type]||W)(t,e);return{sampleRate:t,channels:r,name:n}};var dt="0.1.20260404-ALPHA";function pe(e){let t=[];if(e&&Array.isArray(e.channels))for(let n of e.channels)n&&n.buffer instanceof ArrayBuffer&&t.push(n.buffer);return t}typeof self<"u"&&typeof self.postMessage=="function"&&typeof window>"u"?self.onmessage=e=>{let t=z(e.data);self.postMessage(t,pe(t))}:typeof process<"u"&&process.versions&&process.versions.node&&import("node:worker_threads").then(({isMainThread:e,parentPort:t})=>{!e&&t&&t.on("message",n=>{let o=z(n);t.postMessage(o,pe(o))})}).catch(()=>{});export{z as render,dt as version};

package/dist/asg3.mjs

@@ -0,0 +1,646 @@
+// src/render/instrument/prng.mjs
+var bit32 = 2 ** 32;
+var seedDefault = 521288629;
+var acc;
+var reset = (seed = seedDefault) => acc = seed;
+reset();
+var roundMinVal = Number.EPSILON * 2;
+var roundMaxVal = 1 - Number.EPSILON * 2;
+var roundForSafety = (v) => Math.max(roundMinVal, Math.min(v, roundMaxVal));
+var emulatedMathRandomIndexed = (index, seed = seedDefault) => {
+  const indexedAcc = seed + Math.imul(index + 1 | 0, 1831565813) | 0;
+  return emulatedMathRandomByAcc(indexedAcc);
+};
+var emulatedMathRandomByAcc = (a) => {
+  let t = Math.imul(a ^ a >>> 15, a | 1);
+  t = t + Math.imul(t ^ t >>> 7, t | 61) ^ t;
+  return roundForSafety(((t ^ t >>> 14) >>> 0) / bit32);
+};
+
+// src/render/instrument/math.mjs
+var standardNoteNumber = 69;
+var standardVelocity = 100;
+var maxVelocity = 127;
+var standardDuration = 1;
+var standardNoteNumberFrequency = 440;
+var correctOctave = 4;
+var calculateNoteFreq = (noteNumber) => standardNoteNumberFrequency * 2 ** correctOctave * 2 ** ((noteNumber - standardNoteNumber) / 12 - correctOctave);
+var postProcessSample = (sample, level = 4) => {
+  const totalTick = sample.length;
+  if (level * 2 < totalTick) {
+    for (let i = 0; i < level; i++) {
+      const fadePower = i / level;
+      sample[i] *= fadePower;
+      sample[totalTick - 1 - i] *= fadePower;
+    }
+  }
+};
+var trigonometricallyInterpolate = (a, b, progress, intensity = 1) => {
+  if (intensity <= 0) {
+    return a + (b - a) * progress;
+  }
+  let modulatedProgress;
+  if (intensity === 1) {
+    modulatedProgress = (1 - Math.cos(progress * Math.PI)) * 0.5;
+  } else {
+    const cosVal = -Math.cos(progress * Math.PI);
+    let powed = cosVal;
+    if (intensity > 1) {
+      powed = Math.sign(cosVal) * Math.pow(Math.abs(cosVal), 1 / intensity);
+    }
+    const normalized = (powed + 1) * 0.5;
+    if (intensity < 1) {
+      modulatedProgress = progress * (1 - intensity) + normalized * intensity;
+    } else {
+      modulatedProgress = normalized;
+    }
+  }
+  return a + (b - a) * modulatedProgress;
+};
+var cosineComplement = (a, b, progress) => 0.5 * (a + b - (b - a) * Math.cos(progress * Math.PI));
+var roundedSquareComplement = (a, b, progress, div) => cosineComplement(a, b, Math.min(1, progress * Math.max(1, div)));
+
+// src/render/instrument/waveform.mjs
+var calculateWaveformValueFromWaveformArray = (waveformArray, noteFreqByTick, progress) => {
+  const lapTotal = progress * waveformArray.length;
+  const lapCount = Math.floor(lapTotal);
+  const lapProgress = lapTotal % 1;
+  const a = waveformArray[lapCount % waveformArray.length];
+  const b = waveformArray[(lapCount + 1) % waveformArray.length];
+  const div = 0.5 / waveformArray.length / noteFreqByTick;
+  return roundedSquareComplement(a, b, lapProgress, div);
+};
+var chamferThreshold = 0.95;
+var triangleFn = (state) => {
+  const p = state.lapProgress * 4;
+  const v = p < 1 ? p : p < 3 ? 2 - p : p - 4;
+  const vertexPower = Math.abs(v) - chamferThreshold;
+  if (vertexPower <= 0) {
+    return v;
+  }
+  const normalizedVertexPower = vertexPower / (1 - chamferThreshold);
+  const chamferedNormalizedVertexPower = normalizedVertexPower * (1 - normalizedVertexPower * 0.5);
+  return Math.sign(v) * (chamferThreshold + chamferedNormalizedVertexPower * (1 - chamferThreshold));
+};
+var calculateSawWaveFromLapProgress = (lapProgress) => {
+  const v = 1 - lapProgress * 2;
+  const lesserSawWaveThresholdV = -chamferThreshold;
+  const greaterSawWaveThresholdV = chamferThreshold;
+  if (lesserSawWaveThresholdV <= v && v <= greaterSawWaveThresholdV) {
+    return v;
+  }
+  const shiftedV = v < 0 ? v + 2 : v;
+  const start = lesserSawWaveThresholdV + 2;
+  const end = greaterSawWaveThresholdV;
+  const cosineProgress = (shiftedV - start) / (end - start);
+  return cosineComplement(lesserSawWaveThresholdV, greaterSawWaveThresholdV, cosineProgress);
+};
+var getIndexedRandom = (state, index) => emulatedMathRandomIndexed(index * 2 + (state.seedOffset || 0));
+var noiseWhiteFrequencylessFn = (state) => getIndexedRandom(state, state.tick) * 2 - 1;
+var noiseBinaryFrequencylessFn = (state) => getIndexedRandom(state, state.tick) >= 0.5 ? 1 : -1;
+var noiseWhiteFn = (state) => getIndexedRandom(state, state.lapCount) * 2 - 1;
+var noiseBinaryFn = (state) => getIndexedRandom(state, state.lapCount) >= 0.5 ? 1 : -1;
+var noiseWhiteRoundedFn = (state) => {
+  const currentValue = getIndexedRandom(state, state.lapCount) * 2 - 1;
+  const prevValue = state.lapCount ? getIndexedRandom(state, state.lapCount - 1) * 2 - 1 : currentValue;
+  return roundedSquareComplement(prevValue, currentValue, state.lapProgress, 1);
+};
+var noiseBinaryRoundedFn = (state) => {
+  const currentValue = getIndexedRandom(state, state.lapCount) >= 0.5 ? 1 : -1;
+  const prevValue = state.lapCount ? getIndexedRandom(state, state.lapCount - 1) >= 0.5 ? 1 : -1 : currentValue;
+  return roundedSquareComplement(prevValue, currentValue, state.lapProgress, 1);
+};
+var createFractalNoiseFn = (octavesDown, octavesUp, weightFn) => {
+  const weights = [];
+  let totalWeight = 0;
+  for (let i = octavesDown; i <= octavesUp; i++) {
+    const w = weightFn(i);
+    weights.push(w);
+    totalWeight += w;
+  }
+  return (state) => {
+    const lapTotal = state.lapCount + state.lapProgress;
+    let sum = 0;
+    for (let i = octavesDown; i <= octavesUp; i++) {
+      const scale = 2 ** i;
+      const index = Math.floor(lapTotal * scale);
+      const uniqueIndex = index * 13 + i;
+      const val = getIndexedRandom(state, uniqueIndex) * 2 - 1;
+      sum += val * weights[i - octavesDown];
+    }
+    return sum / totalWeight;
+  };
+};
+var octaveWeightFn = (i) => 0.8 ** Math.abs(i);
+var noiseFractalFn = createFractalNoiseFn(-4, 4, octaveWeightFn);
+var resolveEmbedWaveformFnFromName = {
+  "sine": (state) => Math.sin(state.lapProgress * 2 * Math.PI),
+  "saw": (state) => calculateSawWaveFromLapProgress(state.lapProgress),
+  "saw-reverse": (state) => calculateSawWaveFromLapProgress(1 - state.lapProgress),
+  "square": ((state) => calculateWaveformValueFromWaveformArray([1, -1], state.noteFreqByTick, state.lapProgress)),
+  "triangle": triangleFn,
+  // ノイズ
+  "noise": noiseBinaryFn,
+  // short name alias
+  "noise-binary": noiseBinaryFn,
+  "noise-white": noiseWhiteFn,
+  // 角丸めノイズ
+  "noise-binary-rounded": noiseBinaryRoundedFn,
+  "noise-white-rounded": noiseWhiteRoundedFn,
+  // 周波数なし(sampleRate固定)ノイズ
+  "noise-binary-frequencyless": noiseBinaryFrequencylessFn,
+  "noise-white-frequencyless": noiseWhiteFrequencylessFn,
+  // フラクタルノイズ
+  "noise-fractal": noiseFractalFn
+};
+var waveformOrFallback = (waveform, fallbackWaveform2) => waveform?.constructor === String || waveform?.constructor === Function || Array.isArray(waveform) && waveform.every(Number.isFinite) ? waveform : fallbackWaveform2;
+var resolveWaveformFn = (waveform, fallbackWaveform2) => {
+  waveform = waveformOrFallback(waveform, fallbackWaveform2);
+  if (waveform instanceof Function) {
+    return waveform;
+  }
+  if (Array.isArray(waveform)) {
+    return ((state) => calculateWaveformValueFromWaveformArray(waveform, state.noteFreqByTick, state.lapProgress));
+  }
+  let resultFn;
+  if (waveform?.constructor === String) {
+    resultFn = resolveEmbedWaveformFnFromName[waveform];
+  }
+  if (!resultFn) {
+    resultFn = resolveEmbedWaveformFnFromName["noise-binary-frequencyless"];
+  }
+  return resultFn;
+};
+
+// src/render/instrument/graph.mjs
+var fallbackInterpolationIntensity = 1;
+var graphKeys = ["envelope", "sweep", "vibrato", "tremolo", "lfo", "morph"];
+var createGraphInterpolator = (nodes, totalTick, defaultValue = 0) => {
+  const points = [{ x: 0, v: defaultValue }];
+  let currentX = 0;
+  if (Number.isFinite(nodes)) {
+    return () => nodes;
+  } else if (nodes && nodes.length > 0) {
+    for (const node of nodes) {
+      const w = Array.isArray(node) && Number.isFinite(node[0]) ? node[0] : 0;
+      const v = Array.isArray(node) && Number.isFinite(node[1]) ? node[1] : defaultValue;
+      const interpolationIntensity = Array.isArray(node) && Number.isFinite(node[2]) ? node[2] : fallbackInterpolationIntensity;
+      currentX += w;
+      points.push({ x: currentX, v, interpolationIntensity });
+    }
+  } else {
+    return () => defaultValue;
+  }
+  const totalW = currentX || 1;
+  let nodeIdx = 0;
+  return (tick) => {
+    const targetX = tick / Math.max(1, totalTick - 1) * totalW;
+    while (nodeIdx < points.length - 1 && points[nodeIdx + 1].x <= targetX) {
+      nodeIdx++;
+    }
+    while (nodeIdx > 0 && points[nodeIdx].x > targetX) {
+      nodeIdx--;
+    }
+    const p1 = points[nodeIdx];
+    const p2 = points[nodeIdx + 1];
+    if (!p2) return p1.v;
+    const segmentW = p2.x - p1.x;
+    if (segmentW <= 1e-9) return p2.v;
+    const progress = (targetX - p1.x) / segmentW;
+    return trigonometricallyInterpolate(p1.v, p2.v, progress, p2.interpolationIntensity);
+  };
+};
+var guessScaleGraphTargetIdx = (firstGraph) => {
+  let resultIdx = 0;
+  if (firstGraph) {
+    let lastW = 0;
+    for (let i = 0; i < firstGraph.length; i++) {
+      const node = firstGraph[i];
+      const w = Array.isArray(node) && Number.isFinite(node[0]) ? node[0] : 0;
+      if (lastW < w) {
+        resultIdx = i;
+        lastW = w;
+      }
+    }
+  }
+  return resultIdx;
+};
+var adjustInstrumentDuration = (data, newDuration, targetIdx = void 0) => {
+  if (data["duration"] === void 0 || data["duration"] === newDuration) {
+    return data;
+  }
+  let firstGraph = null;
+  for (const key of graphKeys) {
+    if (Array.isArray(data[key]) && data[key].length > 0) {
+      firstGraph = data[key];
+      break;
+    }
+  }
+  if (targetIdx === void 0) {
+    targetIdx = data["preferredScaleGraphTargetIdx"] ?? guessScaleGraphTargetIdx(firstGraph);
+  }
+  if (!firstGraph || !firstGraph[targetIdx]) {
+    return { ...data, ["duration"]: newDuration };
+  }
+  const oldTotalW = firstGraph.reduce((sum, node) => {
+    const w = Array.isArray(node) && Number.isFinite(node[0]) ? node[0] : 0;
+    return sum + w;
+  }, 0);
+  if (oldTotalW <= 0) {
+    return { ...data, ["duration"]: newDuration };
+  }
+  const oldTargetW = Array.isArray(firstGraph[targetIdx]) && Number.isFinite(firstGraph[targetIdx][0]) ? firstGraph[targetIdx][0] : 0;
+  const ratio = newDuration / data["duration"];
+  const newTotalW = oldTotalW * ratio;
+  let newTargetW = oldTargetW + (newTotalW - oldTotalW);
+  let actualNewDuration = newDuration;
+  if (newTargetW < 0) {
+    newTargetW = 0;
+    const actualNewTotalW = oldTotalW - oldTargetW;
+    actualNewDuration = data["duration"] * (actualNewTotalW / oldTotalW);
+  }
+  const newData = { ...data, ["duration"]: actualNewDuration };
+  for (const key of graphKeys) {
+    if (Array.isArray(newData[key])) {
+      newData[key] = newData[key].map(
+        (node, i) => i === targetIdx ? [newTargetW, node[1]] : node
+      );
+    }
+  }
+  return newData;
+};
+
+// src/render/instrument.mjs
+var fallbackEnvelopeGraph = [[0, 1], [1, 0]];
+var fallbackWaveform = "triangle";
+var fallbackLfoWaveform = "sine";
+var advanceLap = (state, delta) => {
+  const total = state.lapProgress + delta;
+  const count = Math.floor(total);
+  state.lapCount += count;
+  state.lapProgress = total - count;
+};
+var renderInstrument = (sampleRate, data) => {
+  const noteNumber = Number.isFinite(data["noteNumber"]) ? data["noteNumber"] : standardNoteNumber;
+  const velocity = Number.isFinite(data["velocity"]) ? data["velocity"] : standardVelocity;
+  const duration = Number.isFinite(data["duration"]) ? data["duration"] : standardDuration;
+  const waveformFn = resolveWaveformFn(data["waveform"], fallbackWaveform);
+  const morphWaveformFn = data["morphWaveform"] ? resolveWaveformFn(data["morphWaveform"], fallbackWaveform) : null;
+  const lfoWaveformFn = resolveWaveformFn(data["lfoWaveform"], fallbackLfoWaveform);
+  reset();
+  const totalTick = Math.max(4, Math.ceil(duration * sampleRate));
+  const sample = new Float32Array(totalTick);
+  const nextEnv = createGraphInterpolator(data["envelope"] || fallbackEnvelopeGraph, totalTick, data["envelope"]?.length ? 0 : 1);
+  const nextSwe = createGraphInterpolator(data["sweep"], totalTick, 0);
+  const nextVib = createGraphInterpolator(data["vibrato"], totalTick, 0);
+  const nextTre = createGraphInterpolator(data["tremolo"], totalTick, 0);
+  const nextLfo = createGraphInterpolator(data["lfo"], totalTick, 4);
+  const nextMorph = createGraphInterpolator(data["morph"], totalTick, 0);
+  const state = {
+    tick: 0,
+    lapProgress: 0,
+    lapCount: 0,
+    noteFreqByTick: 0,
+    seedOffset: 0
+  };
+  const lfoState = {
+    tick: 0,
+    lapProgress: 0,
+    lapCount: 0,
+    noteFreqByTick: 0,
+    seedOffset: 1
+    // LFO用の乱数系列を分ける
+  };
+  const velValue = velocity / maxVelocity;
+  while (state.tick < totalTick) {
+    lfoState.tick = state.tick;
+    const envPower = nextEnv(state.tick);
+    const swePower = nextSwe(state.tick);
+    const vibPower = nextVib(state.tick);
+    const trePower = nextTre(state.tick);
+    const lfoFreq = nextLfo(state.tick);
+    const morphPower = nextMorph(state.tick);
+    lfoState.noteFreqByTick = lfoFreq / sampleRate;
+    advanceLap(lfoState, lfoState.noteFreqByTick);
+    const lfoWaveformValue = lfoWaveformFn(lfoState);
+    const treCurrent = trePower * lfoWaveformValue;
+    const vibCurrent = vibPower * lfoWaveformValue;
+    const noteFreq = calculateNoteFreq(noteNumber + swePower + vibCurrent);
+    state.noteFreqByTick = noteFreq / sampleRate;
+    advanceLap(state, state.noteFreqByTick);
+    let waveformValue = waveformFn(state);
+    if (morphWaveformFn && morphPower > 0) {
+      if (morphPower >= 1) {
+        waveformValue = morphWaveformFn(state);
+      } else {
+        const morphWaveformValue = morphWaveformFn(state);
+        waveformValue = waveformValue * (1 - morphPower) + morphWaveformValue * morphPower;
+      }
+    }
+    sample[state.tick] = waveformValue * velValue * envPower * Math.max(0, 1 + treCurrent);
+    state.tick++;
+  }
+  postProcessSample(sample);
+  return [sample];
+};
+
+// src/render/music/cache.mjs
+var mergeNoteNumber = (nn1 = standardNoteNumber, nn2 = standardNoteNumber) => nn1 + nn2 - standardNoteNumber;
+var mergeVelocity = (v1 = standardVelocity, v2 = standardVelocity) => v1 * v2 / standardVelocity;
+var getMergedCalibrateParams = (calibrateParams, parentCalibrateParams) => {
+  return {
+    noteNumber: mergeNoteNumber(calibrateParams.noteNumber, parentCalibrateParams.noteNumber),
+    velocity: mergeVelocity(calibrateParams.velocity, parentCalibrateParams.velocity),
+    duration: calibrateParams.duration,
+    // NB: これは親の値を参照してはいけない
+    graphScaleIdx: calibrateParams.graphScaleIdx
+    // NB: これは親の値を参照してはいけない
+  };
+};
+var getCacheKey = (inst, mergedCalibrateParams) => {
+  return `${inst}-${mergedCalibrateParams.noteNumber}-${mergedCalibrateParams.velocity}-${mergedCalibrateParams.duration}-${mergedCalibrateParams.graphScaleIdx}`;
+};
+var isRestTick = (op) => Number.isInteger(op);
+var analyzeCacheTargets = (fullyResolvedLanes, parentCalibrateParams) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const lane of fullyResolvedLanes) {
+    for (const playOrRestTick of lane) {
+      if (!isRestTick(playOrRestTick)) {
+        const calibrateParams = playOrRestTick.calibrateParams || {};
+        const mergedCalibrateParams = getMergedCalibrateParams(calibrateParams, parentCalibrateParams);
+        const inst = playOrRestTick.inst || 0;
+        const key = getCacheKey(inst, mergedCalibrateParams);
+        counts.set(key, (counts.get(key) || 0) + 1);
+      }
+    }
+  }
+  const candidates = [];
+  for (const [key, count] of counts.entries()) {
+    if (count >= 2) {
+      candidates.push({ key, count });
+    }
+  }
+  candidates.sort((a, b) => b.count - a.count);
+  let targetCount = Math.floor(candidates.length * 0.2);
+  if (candidates.length > 0 && targetCount === 0) {
+    targetCount = 1;
+  }
+  const targets = /* @__PURE__ */ new Set();
+  for (let i = 0; i < targetCount; i++) {
+    targets.add(candidates[i].key);
+  }
+  return targets;
+};
+
+// src/render/music/score.mjs
+var resolveOpmapsInLanes = (_sampleRate, extractedMusicLanes, _calibrateParams) => {
+  console.log("niy");
+  return extractedMusicLanes;
+};
+var extractMusicLanes = (musicScore) => {
+  console.log("niy");
+  return musicScore;
+};
+
+// src/render/music/lane.mjs
+var isRestTick2 = (op) => Number.isInteger(op);
+var getFadeStep = (sampleRate) => Math.max(8, Math.floor(sampleRate * 1e-3));
+var fadeInAfterCursor = (buf, cursor, fadeStep) => {
+  const len = Math.min(fadeStep, buf.length - cursor);
+  for (let i = 0; i < len; i++) {
+    if (cursor + i < 0) continue;
+    buf[cursor + i] *= i / fadeStep;
+  }
+};
+var fadeOutBeforeCursor = (buf, cursor, fadeStep) => {
+  const len = Math.min(fadeStep, cursor);
+  for (let i = 0; i < len; i++) {
+    if (cursor - i - 1 < 0) continue;
+    buf[cursor - i - 1] *= i / fadeStep;
+  }
+};
+var overwriteBuf = (buf, pos, samples, amp) => {
+  const len = Math.min(samples.length, buf.length - pos);
+  if (len <= 0) return;
+  if (amp === 1) {
+    buf.set(samples.subarray(0, len), pos);
+  } else {
+    for (let i = 0; i < len; i++) {
+      if (pos + i < 0) continue;
+      buf[pos + i] = samples[i] * amp;
+    }
+  }
+};
+var renderLane = (sampleRate, instruments, lane, parentCalibrateParams, cacheTargets, cachePool, buildSamplesInternalCallback) => {
+  let startTick;
+  let endTick = 0;
+  for (const playOrRestTick of lane) {
+    if (isRestTick2(playOrRestTick)) {
+      endTick += playOrRestTick;
+    } else {
+      startTick ??= endTick;
+    }
+  }
+  startTick ??= 0;
+  const offsetTick = startTick;
+  const len = endTick - startTick;
+  const bufL = new Float32Array(len);
+  const bufR = new Float32Array(len);
+  let cursor = -offsetTick;
+  const fadeStep = getFadeStep(sampleRate);
+  for (const playOrRestTick of lane) {
+    if (isRestTick2(playOrRestTick)) {
+      cursor += playOrRestTick;
+    } else {
+      fadeOutBeforeCursor(bufL, cursor, fadeStep);
+      fadeOutBeforeCursor(bufR, cursor, fadeStep);
+      const calibrateParams = playOrRestTick.calibrateParams || {};
+      const mergedCalibrateParams = getMergedCalibrateParams(calibrateParams, parentCalibrateParams);
+      const inst = playOrRestTick.inst || 0;
+      const instrumentDefinition = instruments[inst];
+      const cacheKey = getCacheKey(inst, mergedCalibrateParams);
+      let samples;
+      if (cacheTargets.has(cacheKey)) {
+        samples = cachePool.get(cacheKey);
+        if (!samples) {
+          samples = buildSamplesInternalCallback(sampleRate, mergedCalibrateParams, instrumentDefinition);
+          cachePool.set(cacheKey, samples);
+        }
+      } else {
+        samples = buildSamplesInternalCallback(sampleRate, mergedCalibrateParams, instrumentDefinition);
+      }
+      const sampleL = samples[0];
+      const sampleR = samples[1] || sampleL;
+      fadeInAfterCursor(bufL, cursor + sampleL.length, fadeStep);
+      fadeInAfterCursor(bufR, cursor + sampleR.length, fadeStep);
+      const amp = playOrRestTick.amp ?? 1;
+      const pan = playOrRestTick.pan || 0;
+      const powerL = amp * Math.min(1, 1 - pan);
+      const powerR = amp * Math.min(1, 1 + pan);
+      overwriteBuf(bufL, cursor, sampleL, powerL);
+      overwriteBuf(bufR, cursor, sampleR, powerR);
+    }
+  }
+  return { offsetTick, bufL, bufR };
+};
+
+// src/render/music/merge.mjs
+var compressStereoSamples = (samples) => {
+  const peakLevel = 0.96;
+  const keepLevel1 = 1;
+  const keepLevel2 = 2;
+  let maxLevel = 0;
+  for (let c = 0; c < samples.length; c++) {
+    const sample = samples[c];
+    const len = sample.length;
+    for (let i = 0; i < len; i += 11) {
+      let v = sample[i];
+      if (v < 0) v = -v;
+      if (maxLevel < v) {
+        maxLevel = v;
+      }
+    }
+  }
+  const getFixedMaxLevel = () => {
+    let absV = maxLevel;
+    if (absV < keepLevel1) {
+      return maxLevel;
+    }
+    absV = (absV - keepLevel1) / 3 + keepLevel1;
+    if (absV < keepLevel2) {
+      return absV;
+    }
+    absV = (absV - keepLevel2) / 3 + keepLevel2;
+    return absV;
+  };
+  const fixedMaxLevel = getFixedMaxLevel();
+  if (peakLevel < fixedMaxLevel) {
+    const rate = peakLevel / fixedMaxLevel;
+    for (let c = 0; c < samples.length; c++) {
+      const sample = samples[c];
+      const len = sample.length;
+      for (let i = 0; i < len; i++) {
+        let v = sample[i];
+        if (v >= keepLevel1) {
+          v = (v - keepLevel1) / 3 + keepLevel1;
+          if (v >= keepLevel2) v = (v - keepLevel2) / 3 + keepLevel2;
+        } else if (v <= -keepLevel1) {
+          v = (v + keepLevel1) / 3 - keepLevel1;
+          if (v <= -keepLevel2) v = (v + keepLevel2) / 3 - keepLevel2;
+        }
+        sample[i] = v * rate;
+      }
+    }
+  }
+};
+var mergeLanes = (renderedLanes) => {
+  const totalTick = Math.max(4, ...renderedLanes.map(({ offsetTick, bufL }) => offsetTick + bufL.length));
+  const resultL = new Float32Array(totalTick);
+  const resultR = new Float32Array(totalTick);
+  renderedLanes.forEach(({ offsetTick, bufL, bufR }) => {
+    const len = bufL.length;
+    for (let i = 0; i < len; i++) {
+      resultL[offsetTick + i] += bufL[i];
+      resultR[offsetTick + i] += bufR[i];
+    }
+  });
+  const result = [resultL, resultR];
+  compressStereoSamples(result);
+  return result;
+};
+
+// src/render/music.mjs
+var buildSamplesInternal = (sampleRate, calibrateParams, instrument = {}) => {
+  const isM = instrument.type === "M";
+  if (isM) {
+    return renderMusic(sampleRate, instrument, calibrateParams);
+  } else {
+    let transformedInstrument = {
+      noteNumber: standardNoteNumber,
+      velocity: standardVelocity,
+      duration: standardDuration,
+      ...instrument
+    };
+    if (calibrateParams.noteNumber != null) {
+      transformedInstrument.noteNumber += calibrateParams.noteNumber - standardNoteNumber;
+    }
+    if (calibrateParams.velocity != null) {
+      transformedInstrument.velocity *= calibrateParams.velocity / standardVelocity;
+    }
+    if (calibrateParams.duration != null) {
+      const oldDuration = transformedInstrument.duration;
+      const newDuration = calibrateParams.duration;
+      if (newDuration != null && oldDuration != newDuration) {
+        transformedInstrument = adjustInstrumentDuration(transformedInstrument, newDuration, calibrateParams.graphScaleIdx);
+      }
+    }
+    return renderInstrument(sampleRate, transformedInstrument);
+  }
+};
+var renderMusic = (sampleRate, data, calibrateParams = {}) => {
+  const instruments = Array.isArray(data["instruments"]) ? data["instruments"] : [];
+  const musicScore = Array.isArray(data["musicScore"]) ? data["musicScore"] : [];
+  let fullyResolvedLanes = data["fullyResolvedLanes"];
+  fullyResolvedLanes ||= resolveOpmapsInLanes(sampleRate, extractMusicLanes(musicScore), calibrateParams);
+  const cacheTargets = analyzeCacheTargets(fullyResolvedLanes, calibrateParams);
+  const cachePool = /* @__PURE__ */ new Map();
+  const renderedLanes = fullyResolvedLanes.map((lane) => renderLane(sampleRate, instruments, lane, calibrateParams, cacheTargets, cachePool, buildSamplesInternal));
+  return mergeLanes(renderedLanes);
+};
+
+// src/render.mjs
+var defaultSampleRate = 48e3;
+var reformSampleRate = (sampleRate) => {
+  const sr = Number.isFinite(sampleRate) ? sampleRate : defaultSampleRate;
+  return Math.max(8e3, Math.min(96e3, sr));
+};
+var renderTable = {
+  "I": renderInstrument,
+  "M": renderMusic
+};
+var render = (data) => {
+  const sampleRate = reformSampleRate(data["sampleRate"]);
+  const name = data["name"];
+  const renderFn = renderTable[data["type"]] || renderInstrument;
+  const channels = renderFn(sampleRate, data);
+  return {
+    sampleRate,
+    channels,
+    name
+    // TODO: add more meta data
+  };
+};
+
+// src/index.mjs
+var version = true ? "0.1.20260404-ALPHA" : "0.0.0-DEV";
+function getTransferList(data) {
+  const transfer = [];
+  if (data && Array.isArray(data.channels)) {
+    for (const item of data.channels) {
+      if (item && item.buffer instanceof ArrayBuffer) {
+        transfer.push(item.buffer);
+      }
+    }
+  }
+  return transfer;
+}
+if (typeof self !== "undefined" && typeof self.postMessage === "function" && typeof window === "undefined") {
+  self.onmessage = (event) => {
+    const result = render(event.data);
+    self.postMessage(result, getTransferList(result));
+  };
+} else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+  import("node:worker_threads").then(({ isMainThread, parentPort }) => {
+    if (!isMainThread && parentPort) {
+      parentPort.on("message", (data) => {
+        const result = render(data);
+        parentPort.postMessage(result, getTransferList(result));
+      });
+    }
+  }).catch(() => {
+  });
+}
+export {
+  render,
+  version
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@tir.jp/asg3",
+  "version": "0.1.20260404-ALPHA",
+  "description": "",
+  "keywords": [],
+  "type": "module",
+  "main": "dist/asg3.min.mjs",
+  "module": "dist/asg3.min.mjs",
+  "exports": {
+    ".": "./dist/asg3.min.mjs",
+    "./full": "./dist/asg3.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "esbuild": "0.28.0",
+    "oxlint": "1.58.0"
+  },
+  "scripts": {
+    "test": "npm run build && node --test tests/*.test.mjs",
+    "build": "node scripts/build.mjs",
+    "lint": "oxlint ."
+  },
+  "author": "ayamada",
+  "contributors": [
+    "mac"
+  ],
+  "license": "Zlib",
+  "publishConfig": {
+    "access": "public"
+  }
+}