@vibes.diy/prompts 0.0.0-dev-fresh-data

package/llms/types.d.ts

@@ -0,0 +1,10 @@
+export interface LlmConfig {
+    name: string;
+    label: string;
+    module: string;
+    description: string;
+    importModule: string;
+    importName: string;
+    importType?: "named" | "namespace" | "default";
+    llmsTxtUrl?: string;
+}

package/llms/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/llms/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../jsr/llms/types.ts"],"names":[],"mappings":""}

package/llms/web-audio.d.ts

@@ -0,0 +1,2 @@
+import type { LlmConfig } from "./types.js";
+export declare const webAudioConfig: LlmConfig;

package/llms/web-audio.js

@@ -0,0 +1,9 @@
+export const webAudioConfig = {
+    name: "web-audio",
+    label: "Web Audio API",
+    module: "web-audio",
+    description: "Web Audio fundamentals; echo/delay with effects in the feedback path; mic monitoring with a metronome; audio‑clock scheduling; timing design for multi‑channel drum machines and MIDI synths with accurate voice overlap.",
+    importModule: "web-audio",
+    importName: "WebAudioAPI",
+};
+//# sourceMappingURL=web-audio.js.map

package/llms/web-audio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-audio.js","sourceRoot":"","sources":["../../jsr/llms/web-audio.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,cAAc,GAAc;IACvC,IAAI,EAAE,WAAW;IACjB,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,WAAW;IACnB,WAAW,EACT,+NAA2N;IAC7N,YAAY,EAAE,WAAW;IACzB,UAAU,EAAE,aAAa;CAC1B,CAAC"}

package/llms/web-audio.txt

@@ -0,0 +1,220 @@
+# Web Audio API: Fundamentals, Echo with FX-in-Feedback, Mic Monitoring + Metronome, and Timing Architecture
+
+Authoritative source: Issue #228 research threads — comments 3192681700, 3192696052, 3192806626.
+
+## 1) Fundamentals and Core Nodes
+
+- AudioContext — master interface and clock (`audioCtx.currentTime`). Resume on a user gesture.
+- OscillatorNode — synthesis; set `type` and `frequency`.
+- AudioBufferSourceNode — decoded-file playback; schedule with `.start(when, offset?, duration?)`.
+- GainNode — volume control and envelopes.
+- BiquadFilterNode — EQ/tonal shaping (`type`, `frequency`, `Q`, etc.).
+- AnalyserNode — FFT/time-domain visualization.
+
+Examples
+
+```js
+// 1) Context (user gesture required in many browsers)
+const audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+
+// Start/resume only in direct response to a user gesture (e.g., a Play button)
+document.querySelector('#start-audio')?.addEventListener('click', async () => {
+  if (audioCtx.state !== 'running') await audioCtx.resume();
+  // now safe to create/start nodes
+});
+
+// 2) Simple tone
+const osc = audioCtx.createOscillator();
+osc.type = 'sine';
+osc.frequency.value = 440;
+osc.connect(audioCtx.destination);
+osc.start();
+osc.stop(audioCtx.currentTime + 1);
+
+// 3) Load/decode and play a file
+const buf = await fetch('/path/audio.mp3').then(r => r.arrayBuffer()).then(b => audioCtx.decodeAudioData(b));
+const src = audioCtx.createBufferSource();
+src.buffer = buf;
+src.connect(audioCtx.destination);
+src.start();
+
+// 4) Gain and Filter in series
+const gain = audioCtx.createGain();
+gain.gain.value = 0.5;
+const filter = audioCtx.createBiquadFilter();
+filter.type = 'lowpass';
+filter.frequency.value = 1000;
+osc.disconnect();
+osc.connect(filter).connect(gain).connect(audioCtx.destination);
+```
+
+Practical: clean up disconnected nodes; check browser support; use headphones to avoid feedback when monitoring.
+
+## 2) Echo/Delay with Effects Inside the Feedback Loop
+
+Graph (node names are exact):
+
+- Dry: `source → dryGain:GainNode → destination`
+- Wet: `source → delay:DelayNode → wetGain:GainNode → destination`
+- Feedback loop with FX: `delay → filter:BiquadFilterNode → distortion:WaveShaperNode → reverb:ConvolverNode → feedbackGain:GainNode → delay`
+
+Parameters to expose
+
+- `delay.delayTime` (s), `feedbackGain.gain` (0–1, keep < 1.0)
+- `filter.type`, `filter.frequency`
+- `distortion.curve` (Float32Array)
+- `convolver.buffer` (IR AudioBuffer)
+- `wetGain.gain`, `dryGain.gain`
+
+Notes: Prevent runaway by capping feedback below 1.0; `ConvolverNode` requires a loaded impulse response; zero-delay cycles are disallowed.
+
+```js
+const delay = audioCtx.createDelay(5.0);
+const feedbackGain = audioCtx.createGain();
+const filter = audioCtx.createBiquadFilter();
+const distortion = audioCtx.createWaveShaper();
+const reverb = audioCtx.createConvolver();
+const wetGain = audioCtx.createGain();
+const dryGain = audioCtx.createGain();
+
+delay.delayTime.value = 0.35;
+feedbackGain.gain.value = 0.5;      // < 1.0
+filter.type = 'lowpass';
+filter.frequency.value = 8000;
+// distortion.curve = yourFloat32Curve;
+// reverb.buffer = yourImpulseResponseAudioBuffer;
+wetGain.gain.value = 0.4;
+dryGain.gain.value = 1.0;
+
+// Dry and wet
+source.connect(dryGain).connect(audioCtx.destination);
+source.connect(delay);
+delay.connect(wetGain).connect(audioCtx.destination);
+
+// Feedback with FX
+delay.connect(filter);
+filter.connect(distortion);
+distortion.connect(reverb);
+reverb.connect(feedbackGain);
+feedbackGain.connect(delay);
+```
+
+Helper (load IR):
+
+```js
+async function loadImpulseResponse(url) {
+  const res = await fetch(url, { mode: 'cors' });
+  if (!res.ok) throw new Error(`Failed to fetch IR ${url}: ${res.status} ${res.statusText}`);
+  const ab = await res.arrayBuffer();
+  try {
+    return await audioCtx.decodeAudioData(ab);
+  } catch (err) {
+    console.error('decodeAudioData failed for IR', url, err);
+    throw err; // Surface decoding/CORS-related failures clearly
+  }
+}
+```
+
+## 3) Microphone Monitoring + Metronome Overlay
+
+Mic capture: request permission with `navigator.mediaDevices.getUserMedia({ audio: { echoCancellation, noiseSuppression, autoGainControl } })`. Create `MediaStreamAudioSourceNode` and route to a `GainNode` → destination.
+
+Metronome: synthesize a short click (e.g., square/sine burst through a gain envelope). Schedule by audio clock at `AudioContext.currentTime` with lookahead.
+
+Mix graph: `micGain + metronomeGain → master → destination`.
+
+```js
+const master = audioCtx.createGain();
+master.connect(audioCtx.destination);
+const micGain = audioCtx.createGain();
+const metronomeGain = audioCtx.createGain();
+micGain.connect(master);
+metronomeGain.connect(master);
+
+async function initMic() {
+  const stream = await navigator.mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: false } });
+  const micSrc = audioCtx.createMediaStreamSource(stream);
+  micSrc.connect(micGain);
+}
+
+function scheduleClick(atTime, downbeat = false) {
+  const osc = audioCtx.createOscillator();
+  const env = audioCtx.createGain();
+  osc.type = 'square';
+  osc.frequency.setValueAtTime(downbeat ? 2000 : 1600, atTime);
+  env.gain.setValueAtTime(0.0001, atTime);
+  env.gain.exponentialRampToValueAtTime(1.0, atTime + 0.001);
+  env.gain.exponentialRampToValueAtTime(0.0001, atTime + 0.03);
+  osc.connect(env).connect(metronomeGain);
+  osc.start(atTime);
+  osc.stop(atTime + 0.05);
+  // Cleanup to avoid accumulating nodes during long sessions
+  osc.onended = () => {
+    try { osc.disconnect(); } catch {}
+    try { env.disconnect(); } catch {}
+  };
+}
+
+function startMetronome({ bpm = 120, beatsPerBar = 4 } = {}) {
+  const spb = 60 / bpm; // seconds per beat
+  let next = audioCtx.currentTime + 0.1;
+  let beat = 0;
+  const lookaheadMs = 25, ahead = 0.2;
+  const id = setInterval(() => {
+    while (next < audioCtx.currentTime + ahead) {
+      scheduleClick(next, beat % beatsPerBar === 0);
+      next += spb; beat = (beat + 1) % beatsPerBar;
+    }
+  }, lookaheadMs);
+  return () => clearInterval(id);
+}
+```
+
+Latency and safety: start/resume on user gesture; clean up per-tick nodes after `ended` to prevent buildup in long-running metronomes; use headphones while monitoring; mobile devices have higher base latency.
+
+## 4) Time Synchronization and Scheduling Model
+
+Clocks/time domains
+
+- Master: `AudioContext.currentTime` — sample-accurate; schedule everything on this timeline.
+- UI/high-res: `performance.now()` — for UI timers and Web MIDI timestamps.
+- Mapping: capture `(tPerf0 = performance.now(), tAudio0 = audioCtx.currentTime)`, convert MIDI/perf timestamps with `tAudio = tAudio0 + (timeStamp - tPerf0)/1000`.
+- Hints: `audioCtx.baseLatency`, `audioCtx.getOutputTimestamp?.()` — estimate DAC/output delay if aligning to “heard” time.
+
+Scheduling primitives
+
+- `AudioBufferSourceNode.start(when, offset?, duration?)` for one-shots/loops.
+- `AudioParam` automation (`setValueAtTime`, `linearRampToValueAtTime`, `setTargetAtTime`, `setValueCurveAtTime`).
+- Avoid `requestAnimationFrame`/`setTimeout` for timing; use an AudioWorklet for custom DSP/tight jitter when needed.
+
+Tempo transport and lookahead
+
+- Tempo mapping: `secondsPerBeat = 60 / bpm`; compute bars:beats:ticks → seconds on the audio clock (choose PPQ, e.g., 480/960).
+- Lookahead window: maintain ~50–200 ms rolling schedule; enqueue with absolute `when` times in audio seconds.
+
+Multi‑channel drum machine
+
+- Pre‑decode all samples; never decode on hit.
+- Per hit: create a fresh `AudioBufferSourceNode` and call `.start(when)`.
+- For phase‑aligned layers (kick+clap, etc.), schedule all sources with the same `when` to guarantee sample‑accurate overlap.
+- Routing: per‑track `GainNode`/optional FX → master bus; allow overlapping retriggers; compute flams as small `when` offsets.
+- Pattern changes: compute the next bar boundary on the audio clock and enqueue new pattern hits relative to that time.
+
+MIDI synth playback
+
+- Live input: map `MIDIMessageEvent.timeStamp` (perf.now domain) → audio clock as above; buffer a short lookahead (5–20 ms) to reduce jitter.
+- SMF playback: convert PPQ ticks using the tempo map; schedule noteOn/noteOff separately; sustain (CC64) defers noteOff until pedal release.
+- Voice management: one voice per active note; allow overlapping envelopes; define voice‑steal policy if a polyphony cap is hit.
+
+External sync and drift
+
+- For MIDI Clock/MTC, derive BPM/phase from incoming ticks, convert to audio time, and drive the transport. Correct small phase error between beats with bounded micro‑nudges—avoid discontinuities.
+
+## 5) Practical Notes
+
+- User gesture required to start/resume `AudioContext` and to access the mic.
+- Convolver IRs: host with CORS if cross‑origin; decode before use.
+- Latency budget: device `baseLatency` + your lookahead + any Worklet buffering.
+- Headphones recommended for monitoring to avoid acoustic feedback.
+
+— End —

package/load-docs.d.ts

@@ -0,0 +1,2 @@
+import { CoerceURI, Result } from "@adviser/cement";
+export declare function loadDocs(localPath: string, baseUrl: CoerceURI): Promise<Result<string>>;

package/load-docs.js

@@ -0,0 +1,17 @@
+import { Result } from "@adviser/cement";
+import { joinUrlParts } from "call-ai";
+export async function loadDocs(localPath, baseUrl) {
+    const url = joinUrlParts(baseUrl?.toString() || "", localPath);
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            return Result.Err(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+        }
+        const text = await response.text();
+        return Result.Ok(text);
+    }
+    catch (error) {
+        return Result.Err(`Error fetching ${url}: ${error}`);
+    }
+}
+//# sourceMappingURL=load-docs.js.map

package/load-docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-docs.js","sourceRoot":"","sources":["../jsr/load-docs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,SAAiB,EACjB,OAAkB,EACO;IACzB,MAAM,GAAG,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,SAAS,CAAC,CAAC;IAC/D,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,OAAO,MAAM,CAAC,GAAG,CACf,mBAAmB,GAAG,KAAK,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,EAAE,CACpE,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QACnC,OAAO,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,MAAM,CAAC,GAAG,CAAC,kBAAkB,GAAG,KAAK,KAAK,EAAE,CAAC,CAAC;IACvD,CAAC;AAAA,CACF"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@vibes.diy/prompts",
+  "version": "0.0.0-dev-fresh-data",
+  "type": "module",
+  "description": "",
+  "keywords": [
+    "ai",
+    "dom",
+    "micro-app",
+    "generator",
+    "web",
+    "esm",
+    "typescript"
+  ],
+  "contributors": [
+    "J Chris Anderson",
+    "Meno Abels"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@adviser/cement": "^0.4.53",
+    "@fireproof/core-types-base": "^0.23.15",
+    "@vibes.diy/use-vibes-types": "^0.0.0-dev-fresh-data",
+    "call-ai": "^0.0.0-dev-fresh-data"
+  },
+  "peerDependencies": {
+    "react": ">=19.1.0"
+  },
+  "devDependencies": {
+    "@fireproof/core-cli": "^0.23.15",
+    "@vitest/browser-playwright": "^4.0.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.1"
+  },
+  "scripts": {
+    "build": "core-cli tsc",
+    "test": "vitest run"
+  }
+}

package/prompts.d.ts

@@ -0,0 +1,43 @@
+import { Mocks } from "call-ai";
+import type { HistoryMessage, UserSettings } from "./settings.js";
+import { CoerceURI } from "@adviser/cement";
+import { LlmCatalogEntry } from "./json-docs.js";
+export declare const DEFAULT_CODING_MODEL: "anthropic/claude-sonnet-4.5";
+export declare const RAG_DECISION_MODEL: "openai/gpt-4o";
+export declare function defaultCodingModel(): Promise<"anthropic/claude-sonnet-4.5">;
+export declare function normalizeModelId(id: unknown): string | undefined;
+export declare function isPermittedModelId(id: unknown): id is string;
+export declare function resolveEffectiveModel(settingsDoc?: {
+    model?: string;
+}, vibeDoc?: {
+    selectedModel?: string;
+}): Promise<string>;
+export interface SystemPromptResult {
+    systemPrompt: string;
+    dependencies: string[];
+    instructionalText: boolean;
+    demoData: boolean;
+    model: string;
+}
+export interface LlmSelectionDecisions {
+    selected: string[];
+    instructionalText: boolean;
+    demoData: boolean;
+}
+export interface LlmSelectionOptions {
+    readonly appMode?: "test" | "production";
+    readonly callAiEndpoint?: CoerceURI;
+    readonly fallBackUrl?: CoerceURI;
+    readonly getAuthToken?: () => Promise<string>;
+    readonly mock?: Mocks;
+}
+export type LlmSelectionWithFallbackUrl = Omit<Omit<LlmSelectionOptions, "fallBackUrl">, "callAiEndpoint"> & {
+    readonly fallBackUrl: CoerceURI;
+    readonly callAiEndpoint?: CoerceURI;
+};
+export declare function selectLlmsAndOptions(model: string, userPrompt: string, history: HistoryMessage[], iopts: LlmSelectionOptions): Promise<LlmSelectionDecisions>;
+export declare function generateImportStatements(llms: LlmCatalogEntry[]): string;
+export declare function makeBaseSystemPrompt(model: string, sessionDoc: Partial<UserSettings> & LlmSelectionOptions): Promise<SystemPromptResult>;
+export declare const RESPONSE_FORMAT: {
+    structure: string[];
+};