@litlab/audx 0.5.5 → 0.8.5

package/README.md

@@ -37,58 +37,58 @@ beep();
 click();
 ```
 
-### Sound patches (React)
+### Sound themes (React)
 
 ```tsx
-import { usePatch } from "@litlab/audx/react";
+import { useTheme } from "@litlab/audx/react";
 
 function App() {
-  const patch = usePatch("/patches/core.json");
+  const theme = useTheme("/themes/core.json");
 
   return (
-    <button onClick={() => patch.play("click")} disabled={!patch.ready}>
+    <button onClick={() => theme.play("click")} disabled={!theme.ready}>
       Click me
     </button>
   );
 }
 ```
 
-### Sound patches (vanilla)
+### Sound themes (vanilla)
 
 ```ts
-import { loadPatch } from "@litlab/audx";
+import { loadTheme } from "@litlab/audx";
 
-const patch = await loadPatch("/patches/core.json");
-patch.play("click");
+const theme = await loadTheme("/themes/core.json");
+theme.play("click");
 ```
 
 ## CLI
 
 ```bash
-# Browse and install patches from the registry
+# Browse and install themes from the registry
 npx @litlab/audx add
 
-# Install patches from a GitHub repo
+# Install themes from a GitHub repo
 npx @litlab/audx add user/repo
 
-# Create a new sound patch
+# Create a new sound theme
 npx @litlab/audx init
 
-# List installed patches
+# List installed themes
 npx @litlab/audx list
 
-# Remove installed patches
+# Remove installed themes
 npx @litlab/audx remove
 ```
 
-## Patch authoring
+## Theme authoring
 
-Create a patch JSON file with `npx @litlab/audx init`, then add sound definitions to the `sounds` object:
+Create a theme JSON file with `npx @litlab/audx init`, then add sound definitions to the `sounds` object:
 
 ```json
 {
-  "$schema": "node_modules/@litlab/audx/schemas/patch.schema.json",
-  "name": "my-patch",
+  "$schema": "node_modules/@litlab/audx/schemas/theme.schema.json",
+  "name": "my-theme",
   "sounds": {
     "click": {
       "source": { "type": "noise", "color": "white" },
@@ -116,9 +116,9 @@ npx @litlab/audx add your-username/your-repo
 | `square(freq, decay)` | Shorthand for square oscillator |
 | `sawtooth(freq, decay)` | Shorthand for sawtooth oscillator |
 | `noise(color, decay)` | Shorthand for noise generator |
-| `loadPatch(url)` | Load a sound patch from a URL |
-| `definePatch(json)` | Create a patch from a JSON object |
-| `usePatch(url)` | React hook for loading and playing patches |
+| `loadTheme(url)` | Load a sound theme from a URL |
+| `defineTheme(json)` | Create a theme from a JSON object |
+| `useTheme(url)` | React hook for loading and playing themes |
 
 ## Documentation
 

package/dist/bin.js

@@ -1,10 +1,9 @@
-#!/usr/bin/env node
 import * as p from '@clack/prompts';
+import { a as _object_without_properties_loose, _ as _extends } from './cc-zJdVkWBV.js';
 import { existsSync, mkdirSync } from 'node:fs';
 import { readdir, readFile, writeFile, unlink } from 'node:fs/promises';
 import __node_cjsPath, { resolve, join, basename, isAbsolute } from 'node:path';
 import pc from 'picocolors';
-import { _ as _object_without_properties_loose } from './cc-DgCkkqq8.js';
 import __node_cjsModule from 'node:module';
 import __node_cjsUrl from 'node:url';
 
@@ -97,7 +96,7 @@ function normalizeConfigOutput(output, context) {
     }
     return normalized;
 }
-function getPatchesDir() {
+function getThemesDir() {
     var _ref;
     const config = getConfig();
     const output = (_ref = config == null ? void 0 : config.output) != null ? _ref : "src/audio";
@@ -132,7 +131,7 @@ function parseGitHubSource(source) {
     }
     return null;
 }
-async function discoverPatchesFromGitHub(source) {
+async function discoverThemesFromGitHub(source) {
     const parsed = parseGitHubSource(source);
     if (!parsed) {
         throw new Error(`Invalid source: ${source}. Use owner/repo or a GitHub URL.`);
@@ -157,15 +156,15 @@ async function discoverPatchesFromGitHub(source) {
         if (item.path.includes(".changeset/")) return false;
         return true;
     });
-    const patches = [];
+    const themes = [];
     for (const file of jsonFiles){
         const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${file.path}`;
         try {
             const r = await fetch(rawUrl);
             if (!r.ok) continue;
             const data = await r.json();
-            if (!validatePatch(data)) continue;
-            patches.push({
+            if (!validateTheme(data)) continue;
+            themes.push({
                 name: data.name,
                 path: file.path,
                 downloadUrl: rawUrl,
@@ -174,7 +173,7 @@ async function discoverPatchesFromGitHub(source) {
             });
         } catch (unused) {}
     }
-    return patches;
+    return themes;
 }
 function isGitHubSource(source) {
     return parseGitHubSource(source) !== null;
@@ -186,13 +185,13 @@ function isLocalSource(source) {
     const abs = isAbsolute(source) ? source : resolve(process.cwd(), source);
     return existsSync(abs);
 }
-async function discoverPatchesFromLocal(source) {
+async function discoverThemesFromLocal(source) {
     const abs = isAbsolute(source) ? source : resolve(process.cwd(), source);
     if (abs.endsWith(".json")) {
         const raw = await readFile(abs, "utf-8");
         const data = JSON.parse(raw);
-        if (!validatePatch(data)) {
-            throw new Error(`${source} is not a valid sound patch.`);
+        if (!validateTheme(data)) {
+            throw new Error(`${source} is not a valid sound theme.`);
         }
         return [
             {
@@ -205,15 +204,15 @@ async function discoverPatchesFromLocal(source) {
         ];
     }
     const files = await readdir(abs);
-    const patches = [];
+    const themes = [];
     for (const file of files){
         if (!file.endsWith(".json") || file === "index.json") continue;
         try {
             const filePath = join(abs, file);
             const raw = await readFile(filePath, "utf-8");
             const data = JSON.parse(raw);
-            if (!validatePatch(data)) continue;
-            patches.push({
+            if (!validateTheme(data)) continue;
+            themes.push({
                 name: data.name,
                 path: filePath,
                 downloadUrl: filePath,
@@ -222,26 +221,26 @@ async function discoverPatchesFromLocal(source) {
             });
         } catch (unused) {}
     }
-    return patches;
+    return themes;
 }
-async function fetchPatchIndex() {
-    const res = await fetch(`${REGISTRY_BASE}/patches`);
+async function fetchThemeIndex() {
+    const res = await fetch(`${REGISTRY_BASE}/audio/themes`);
     if (!res.ok) {
-        throw new Error(`Failed to fetch patch index: ${res.status}`);
+        throw new Error(`Failed to fetch theme index: ${res.status}`);
     }
     return res.json();
 }
-async function fetchPatchJson(nameOrUrl) {
-    const url = nameOrUrl.startsWith("http") ? nameOrUrl : `${REGISTRY_BASE}/patch/${nameOrUrl}`;
+async function fetchThemeJson(nameOrUrl) {
+    const url = nameOrUrl.startsWith("http") ? nameOrUrl : `${REGISTRY_BASE}/audio/theme/${nameOrUrl}`;
     const res = await fetch(url);
     if (!res.ok) {
-        throw new Error(`Failed to fetch patch: ${res.status}`);
+        throw new Error(`Failed to fetch theme: ${res.status}`);
     }
     return res.json();
 }
-async function registerPatch(url) {
+async function registerTheme(url) {
     try {
-        await fetch(`${REGISTRY_BASE}/patches`, {
+        await fetch(`${REGISTRY_BASE}/audio/themes`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json"
@@ -252,30 +251,30 @@ async function registerPatch(url) {
         });
     } catch (unused) {}
 }
-function validatePatch(data) {
+function validateTheme(data) {
     return typeof data.name === "string" && typeof data.sounds === "object" && data.sounds !== null;
 }
-async function getInstalledPatches() {
-    const dir = getPatchesDir();
+async function getInstalledThemes() {
+    const dir = getThemesDir();
     if (!existsSync(dir)) return [];
     const files = await readdir(dir);
-    const patches = [];
+    const themes = [];
     for (const file of files){
         if (!file.endsWith(".ts") || file === "index.ts") continue;
         try {
             var _raw_match, _ref;
             const raw = await readFile(join(dir, file), "utf-8");
-            const nameMatch = raw.match(/^\/\/ patch: (.+)$/m);
+            const nameMatch = raw.match(/^\/\/ theme: (.+)$/m);
             const exportCount = ((_raw_match = raw.match(/^export const /gm)) != null ? _raw_match : []).length;
             const name = (_ref = nameMatch == null ? void 0 : nameMatch[1]) != null ? _ref : basename(file, ".ts");
-            patches.push({
+            themes.push({
                 file,
                 name,
                 soundCount: Math.max(0, exportCount - 1)
             });
         } catch (unused) {}
     }
-    return patches;
+    return themes;
 }
 const RESERVED = new Set([
     "break",
@@ -335,7 +334,7 @@ function generateModule(data) {
     const ids = entries.map(([key])=>toCamelCase(key));
     const lines = [
         `// ${data.name} — generated by @litlab/audx (do not edit)`,
-        `// patch: ${data.name}`,
+        `// theme: ${data.name}`,
         `import type { SoundDefinition, SoundPatch } from "@litlab/audx";`,
         ""
     ];
@@ -384,8 +383,12 @@ function parseAddOptions(args) {
             options.yes = true;
         } else if (arg === "-l" || arg === "--list") {
             options.list = true;
-        } else if (arg === "--patch") {
-            options.patch = args[++i];
+        } else if (arg === "--theme") {
+            options.theme = args[++i];
+        } else if (arg === "--data") {
+            options.data = args[++i];
+        } else if (arg === "--tune") {
+            options.tune = args[++i];
         } else if (arg && !arg.startsWith("-")) {
             source = arg;
         }
@@ -399,9 +402,21 @@ async function add(args) {
     const { source, options } = parseAddOptions(args);
     p.intro("@litlab/audx add");
     if (!source) {
+        if (options.data || options.tune) {
+            p.log.error("--data and --tune require a sound name.");
+            process.exit(1);
+        }
         await addFromRegistry(options);
         return;
     }
+    if (options.data) {
+        await addEncodedSound(source, options);
+        return;
+    }
+    if (options.tune) {
+        await addTunedSound(source, options);
+        return;
+    }
     if (isLocalSource(source)) {
         await addFromLocal(source, options);
         return;
@@ -416,108 +431,280 @@ async function add(args) {
     }
     await addSoundFromRegistry(source, options);
 }
+const WAVEFORM_CODES = {
+    o: "original",
+    s: "sine",
+    t: "triangle",
+    q: "square",
+    w: "sawtooth"
+};
+function decodeSoundCustomization(value) {
+    const [version, pitch, duration, gain, pan, waveform, ...extra] = value.split(".");
+    if (version !== "1" || extra.length > 0 || !pitch || !duration || !gain || !pan || !waveform) {
+        throw new Error("unsupported tuning token");
+    }
+    const settings = {
+        pitch: Number.parseInt(pitch, 36) - 12,
+        duration: Number.parseInt(duration, 36) / 20,
+        gain: Number.parseInt(gain, 36) / 20,
+        pan: (Number.parseInt(pan, 36) - 20) / 20,
+        waveform: WAVEFORM_CODES[waveform]
+    };
+    if (!Number.isInteger(settings.pitch) || settings.pitch < -12 || settings.pitch > 12 || !Number.isFinite(settings.duration) || settings.duration < 0.25 || settings.duration > 3 || !Number.isFinite(settings.gain) || settings.gain < 0 || settings.gain > 2 || !Number.isFinite(settings.pan) || settings.pan < -1 || settings.pan > 1 || !settings.waveform) {
+        throw new Error("invalid tuning values");
+    }
+    return settings;
+}
+async function addTunedSound(soundName, options) {
+    if (!options.theme) {
+        p.log.error("--tune requires --theme <name>.");
+        process.exit(1);
+    }
+    let settings;
+    try {
+        var _options_tune;
+        settings = decodeSoundCustomization((_options_tune = options.tune) != null ? _options_tune : "");
+    } catch (err) {
+        p.log.error(`Invalid tuning token: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    const s = p.spinner();
+    s.start(`Fetching "${soundName}" from ${options.theme}...`);
+    try {
+        const theme = await fetchThemeJson(options.theme);
+        if (!validateTheme(theme)) throw new Error("invalid theme");
+        const match = Object.entries(theme.sounds).find(([name])=>name.toLowerCase() === soundName.toLowerCase());
+        if (!match) throw new Error(`sound not found in theme "${options.theme}"`);
+        const definition = customizeDefinition(match[1], settings);
+        if (!validateSoundDefinition(definition)) {
+            throw new Error("theme returned an invalid sound definition");
+        }
+        s.stop(`Customized "${soundName}" from ${theme.name}`);
+        await writeSound(soundName, definition, options);
+        p.note(`  - ${soundName}`, "Installed customized sound");
+        p.outro("Done!");
+    } catch (err) {
+        s.stop("Failed to install customized sound.");
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+function customizeDefinition(value, settings) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+    const definition = value;
+    if (Array.isArray(definition.layers)) {
+        return _extends({}, definition, {
+            layers: definition.layers.map((layer)=>customizeDefinition(layer, settings)),
+            effects: scaleEffects(definition.effects, settings.duration)
+        });
+    }
+    const source = customizeSource(definition.source, settings);
+    const envelope = definition.envelope && typeof definition.envelope === "object" && !Array.isArray(definition.envelope) ? scaleEnvelope(definition.envelope, settings.duration) : undefined;
+    const gain = typeof definition.gain === "number" ? definition.gain : 0.5;
+    const delay = typeof definition.delay === "number" ? definition.delay : 0;
+    return _extends({}, definition, {
+        source,
+        envelope,
+        gain: clamp(gain * settings.gain, 0, 1)
+    }, "panner" in definition ? {} : {
+        pan: clamp((typeof definition.pan === "number" ? definition.pan : 0) + settings.pan, -1, 1)
+    }, {
+        delay: delay * settings.duration,
+        effects: scaleEffects(definition.effects, settings.duration)
+    });
+}
+function customizeSource(value, settings) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+    const source = value;
+    const frequencyScale = 2 ** (settings.pitch / 12);
+    if (source.type === "sine" || source.type === "triangle" || source.type === "square" || source.type === "sawtooth" || source.type === "wavetable") {
+        return _extends({}, source, source.type === "wavetable" || settings.waveform === "original" ? {} : {
+            type: settings.waveform
+        }, {
+            frequency: scaleFrequency(source.frequency, frequencyScale)
+        });
+    }
+    if (source.type === "sample") {
+        return _extends({}, source, {
+            detune: (typeof source.detune === "number" ? source.detune : 0) + settings.pitch * 100
+        });
+    }
+    return source;
+}
+function scaleFrequency(value, scale) {
+    if (typeof value === "number") return value * scale;
+    if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+    const frequency = value;
+    if (typeof frequency.start !== "number" || typeof frequency.end !== "number") {
+        return value;
+    }
+    return {
+        start: frequency.start * scale,
+        end: frequency.end * scale
+    };
+}
+function scaleEnvelope(envelope, duration) {
+    return _extends({}, envelope, {
+        attack: (typeof envelope.attack === "number" ? envelope.attack : 0) * duration,
+        decay: (typeof envelope.decay === "number" ? envelope.decay : 0) * duration,
+        release: (typeof envelope.release === "number" ? envelope.release : 0) * duration
+    });
+}
+function scaleEffects(value, duration) {
+    if (!Array.isArray(value)) return undefined;
+    return value.map((effect)=>{
+        if (!effect || typeof effect !== "object" || Array.isArray(effect)) {
+            return effect;
+        }
+        const item = effect;
+        if (item.type === "delay") {
+            return _extends({}, item, {
+                time: (typeof item.time === "number" ? item.time : 0.25) * duration
+            });
+        }
+        if (item.type === "reverb") {
+            return _extends({}, item, {
+                decay: (typeof item.decay === "number" ? item.decay : 0.5) * duration,
+                preDelay: (typeof item.preDelay === "number" ? item.preDelay : 0) * duration
+            });
+        }
+        return item;
+    });
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+async function addEncodedSound(soundName, options) {
+    let definition;
+    try {
+        var _options_data;
+        definition = decodeSoundDefinition((_options_data = options.data) != null ? _options_data : "");
+    } catch (err) {
+        p.log.error(`Invalid customized sound data: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    if (!validateSoundDefinition(definition)) {
+        p.log.error("Invalid customized sound definition.");
+        process.exit(1);
+    }
+    await writeSound(soundName, definition, options);
+    p.note(`  - ${soundName}`, "Installed customized sound");
+    p.outro("Done!");
+}
+function decodeSoundDefinition(value) {
+    if (!value) throw new Error("missing value");
+    return JSON.parse(Buffer.from(value, "base64url").toString("utf-8"));
+}
+function validateSoundDefinition(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+    const definition = value;
+    if (Array.isArray(definition.layers)) {
+        return definition.layers.length > 0 && definition.layers.every(validateSoundDefinition);
+    }
+    return !!definition.source && typeof definition.source === "object" && !Array.isArray(definition.source);
+}
 async function addFromLocal(source, options) {
     const s = p.spinner();
-    s.start("Scanning local path for patches...");
+    s.start("Scanning local path for themes...");
     let discovered;
     try {
-        discovered = await discoverPatchesFromLocal(source);
-        s.stop(`Found ${discovered.length} patch(es)`);
+        discovered = await discoverThemesFromLocal(source);
+        s.stop(`Found ${discovered.length} theme(es)`);
     } catch (err) {
         s.stop("Failed to scan local path.");
         p.log.error(String(err));
         process.exit(1);
     }
     if (discovered.length === 0) {
-        p.log.warn("No valid sound patches found at this path.");
-        p.outro("Patches must be JSON files with a name and sounds object.");
+        p.log.warn("No valid sound themes found at this path.");
+        p.outro("Themes must be JSON files with a name and sounds object.");
         return;
     }
     if (options.list) {
-        printPatchList(discovered);
+        printThemeList(discovered);
         return;
     }
-    const toInstall = selectPatches(discovered, options);
+    const toInstall = selectThemes(discovered, options);
     if (!toInstall || toInstall.length === 0) return;
-    const installed = await getInstalledPatches();
+    const installed = await getInstalledThemes();
     const installedNames = new Set(installed.map((p)=>p.name));
-    const final = options.yes ? toInstall : await confirmOverwrites(toInstall, installedNames);
+    const final = options.yes ? toInstall : await confirmThemeOverwrites(toInstall, installedNames);
     if (!final || final.length === 0) return;
     const dl = p.spinner();
-    dl.start(`Installing ${final.length} patch(es)...`);
+    dl.start(`Installing ${final.length} theme(es)...`);
     const results = [];
-    for (const patch of final){
+    for (const theme of final){
         try {
-            const raw = await readFile(patch.downloadUrl, "utf-8");
+            const raw = await readFile(theme.downloadUrl, "utf-8");
             const data = JSON.parse(raw);
-            if (!validatePatch(data)) {
-                p.log.warn(`Skipping ${patch.name}: invalid patch format`);
+            if (!validateTheme(data)) {
+                p.log.warn(`Skipping ${theme.name}: invalid theme format`);
                 continue;
             }
-            await writePatch(patch.name, data);
+            await writeTheme(theme.name, data);
             results.push(data.name);
         } catch (err) {
-            p.log.warn(`Failed to install ${patch.name}: ${err}`);
+            p.log.warn(`Failed to install ${theme.name}: ${err}`);
         }
     }
-    dl.stop(`Installed ${results.length} patch(es)`);
-    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed patches");
+    dl.stop(`Installed ${results.length} theme(es)`);
+    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed themes");
     p.outro("Done!");
 }
 async function addFromGitHub(source, options) {
     const s = p.spinner();
-    s.start("Scanning repository for patches...");
+    s.start("Scanning repository for themes...");
     let discovered;
     try {
-        discovered = await discoverPatchesFromGitHub(source);
-        s.stop(`Found ${discovered.length} patch(es)`);
+        discovered = await discoverThemesFromGitHub(source);
+        s.stop(`Found ${discovered.length} theme(es)`);
     } catch (err) {
         s.stop("Failed to scan repository.");
         p.log.error(String(err));
         process.exit(1);
     }
     if (discovered.length === 0) {
-        p.log.warn("No valid sound patches found in this repository.");
-        p.outro("Patches must be JSON files with a name and sounds object.");
+        p.log.warn("No valid sound themes found in this repository.");
+        p.outro("Themes must be JSON files with a name and sounds object.");
         return;
     }
     if (options.list) {
-        printPatchList(discovered);
+        printThemeList(discovered);
         return;
     }
-    const installed = await getInstalledPatches();
+    const installed = await getInstalledThemes();
     const installedNames = new Set(installed.map((p)=>p.name));
-    const toInstall = await resolvePatchSelection(discovered, installedNames, options);
+    const toInstall = await resolveThemeSelection(discovered, installedNames, options);
     if (!toInstall || toInstall.length === 0) return;
     const dl = p.spinner();
-    dl.start(`Installing ${toInstall.length} patch(es)...`);
+    dl.start(`Installing ${toInstall.length} theme(es)...`);
     const results = [];
-    for (const patch of toInstall){
+    for (const theme of toInstall){
         try {
-            const data = await fetchPatchJson(patch.downloadUrl);
-            if (!validatePatch(data)) {
-                p.log.warn(`Skipping ${patch.name}: invalid patch format`);
+            const data = await fetchThemeJson(theme.downloadUrl);
+            if (!validateTheme(data)) {
+                p.log.warn(`Skipping ${theme.name}: invalid theme format`);
                 continue;
             }
-            await writePatch(patch.name, data);
-            registerPatch(patch.downloadUrl);
+            await writeTheme(theme.name, data);
+            registerTheme(theme.downloadUrl);
             results.push(data.name);
         } catch (err) {
-            p.log.warn(`Failed to install ${patch.name}: ${err}`);
+            p.log.warn(`Failed to install ${theme.name}: ${err}`);
         }
     }
-    dl.stop(`Installed ${results.length} patch(es)`);
-    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed patches");
+    dl.stop(`Installed ${results.length} theme(es)`);
+    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed themes");
     p.outro("Done!");
 }
 async function addFromUrl(url, options) {
     const s = p.spinner();
-    s.start("Fetching patch...");
+    s.start("Fetching theme...");
     try {
-        const data = await fetchPatchJson(url);
-        if (!validatePatch(data)) {
-            s.stop("Invalid patch format.");
-            p.log.error("The fetched JSON is not a valid sound patch (missing name or sounds).");
+        const data = await fetchThemeJson(url);
+        if (!validateTheme(data)) {
+            s.stop("Invalid theme format.");
+            p.log.error("The fetched JSON is not a valid sound theme (missing name or sounds).");
             process.exit(1);
         }
         s.stop(`Fetched "${data.name}"`);
@@ -526,23 +713,23 @@ async function addFromUrl(url, options) {
             console.log();
             return;
         }
-        await writePatch(data.name, data);
-        registerPatch(url);
+        await writeTheme(data.name, data);
+        registerTheme(url);
     } catch (err) {
-        s.stop("Failed to fetch patch.");
+        s.stop("Failed to fetch theme.");
         p.log.error(String(err));
         process.exit(1);
     }
 }
 async function addFromRegistry(options) {
     const s = p.spinner();
-    s.start("Fetching available patches...");
+    s.start("Fetching available themes...");
     let index;
     try {
-        index = await fetchPatchIndex();
-        s.stop(`Found ${index.length} patches`);
+        index = await fetchThemeIndex();
+        s.stop(`Found ${index.length} themes`);
     } catch (err) {
-        s.stop("Failed to fetch patch index.");
+        s.stop("Failed to fetch theme index.");
         p.log.error(String(err));
         process.exit(1);
     }
@@ -554,24 +741,24 @@ async function addFromRegistry(options) {
         console.log();
         return;
     }
-    const installed = await getInstalledPatches();
+    const installed = await getInstalledThemes();
     const installedNames = new Set(installed.map((p)=>p.name));
     let names;
-    if (options.patch) {
-        const patchName = options.patch;
+    if (options.theme) {
+        const themeName = options.theme;
         names = [
-            patchName
+            themeName
         ];
-        const match = index.find((e)=>e.name.toLowerCase() === patchName.toLowerCase());
+        const match = index.find((e)=>e.name.toLowerCase() === themeName.toLowerCase());
         if (!match) {
-            p.log.error(`Patch "${patchName}" not found in registry.`);
+            p.log.error(`Theme "${themeName}" not found in registry.`);
             process.exit(1);
         }
     } else if (options.yes) {
         names = index.map((e)=>e.name);
     } else {
         const selected = await p.multiselect({
-            message: "Select patches to install",
+            message: "Select themes to install",
             options: index.map((entry)=>({
                     value: entry.name,
                     label: `${entry.name}${installedNames.has(entry.name) ? " (installed)" : ""}`,
@@ -584,7 +771,7 @@ async function addFromRegistry(options) {
         }
         names = selected;
         if (names.length === 0) {
-            p.outro("No patches selected.");
+            p.outro("No themes selected.");
             return;
         }
     }
@@ -592,7 +779,7 @@ async function addFromRegistry(options) {
         const existing = names.filter((n)=>installedNames.has(n));
         if (existing.length > 0) {
             const overwrite = await p.confirm({
-                message: `${existing.length} patch(es) already installed. Overwrite?`
+                message: `${existing.length} theme(es) already installed. Overwrite?`
             });
             if (p.isCancel(overwrite) || !overwrite) {
                 p.cancel("Cancelled.");
@@ -601,23 +788,23 @@ async function addFromRegistry(options) {
         }
     }
     const dl = p.spinner();
-    dl.start(`Downloading ${names.length} patch(es)...`);
+    dl.start(`Downloading ${names.length} theme(es)...`);
     const results = [];
     for (const name of names){
         try {
-            const data = await fetchPatchJson(name);
-            if (!validatePatch(data)) {
-                p.log.warn(`Skipping ${name}: invalid patch format`);
+            const data = await fetchThemeJson(name);
+            if (!validateTheme(data)) {
+                p.log.warn(`Skipping ${name}: invalid theme format`);
                 continue;
             }
-            await writePatch(name, data);
+            await writeTheme(name, data);
             results.push(data.name);
         } catch (err) {
             p.log.warn(`Failed to download ${name}: ${err}`);
         }
     }
-    dl.stop(`Downloaded ${results.length} patch(es)`);
-    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed patches");
+    dl.stop(`Downloaded ${results.length} theme(es)`);
+    p.note(results.map((n)=>`  - ${n}`).join("\n"), "Installed themes");
     p.outro("Done!");
 }
 async function addSoundFromRegistry(soundName, options) {
@@ -629,7 +816,7 @@ async function addSoundFromRegistry(soundName, options) {
     s.start(`Finding "${soundName}"...`);
     let index;
     try {
-        index = await fetchPatchIndex();
+        index = await fetchThemeIndex();
     } catch (err) {
         s.stop("Failed to fetch theme index.");
         p.log.error(String(err));
@@ -638,8 +825,8 @@ async function addSoundFromRegistry(soundName, options) {
     let found;
     for (const entry of index){
         try {
-            const data = await fetchPatchJson(entry.name);
-            if (!validatePatch(data)) continue;
+            const data = await fetchThemeJson(entry.name);
+            if (!validateTheme(data)) continue;
             const match = Object.entries(data.sounds).find(([name])=>name.toLowerCase() === soundName.toLowerCase());
             if (match) {
                 found = {
@@ -660,20 +847,20 @@ async function addSoundFromRegistry(soundName, options) {
     p.note(`  - ${soundName}`, "Installed sound");
     p.outro("Done!");
 }
-function printPatchList(patches) {
+function printThemeList(themes) {
     console.log();
-    for (const patch of patches){
-        const desc = patch.description ? `  ${pc.dim(patch.description)}` : "";
-        console.log(`  ${pc.bold(patch.name)}  ${pc.dim(`${patch.soundCount} sounds`)}${desc}`);
+    for (const theme of themes){
+        const desc = theme.description ? `  ${pc.dim(theme.description)}` : "";
+        console.log(`  ${pc.bold(theme.name)}  ${pc.dim(`${theme.soundCount} sounds`)}${desc}`);
     }
     console.log();
 }
-function selectPatches(discovered, options) {
-    if (options.patch) {
-        const patchName = options.patch;
-        const match = discovered.filter((d)=>d.name.toLowerCase() === patchName.toLowerCase());
+function selectThemes(discovered, options) {
+    if (options.theme) {
+        const themeName = options.theme;
+        const match = discovered.filter((d)=>d.name.toLowerCase() === themeName.toLowerCase());
         if (match.length === 0) {
-            p.log.error(`Patch "${patchName}" not found.`);
+            p.log.error(`Theme "${themeName}" not found.`);
             process.exit(1);
         }
         return match;
@@ -681,27 +868,27 @@ function selectPatches(discovered, options) {
     if (options.yes) return discovered;
     return discovered;
 }
-async function resolvePatchSelection(discovered, installedNames, options) {
-    if (options.patch) {
-        const patchName = options.patch;
-        const match = discovered.filter((d)=>d.name.toLowerCase() === patchName.toLowerCase());
+async function resolveThemeSelection(discovered, installedNames, options) {
+    if (options.theme) {
+        const themeName = options.theme;
+        const match = discovered.filter((d)=>d.name.toLowerCase() === themeName.toLowerCase());
         if (match.length === 0) {
-            p.log.error(`Patch "${patchName}" not found.`);
+            p.log.error(`Theme "${themeName}" not found.`);
             process.exit(1);
         }
         return match;
     }
     if (options.yes) return discovered;
     if (discovered.length === 1) return discovered;
-    return await promptPatchSelection(discovered, installedNames);
+    return await promptThemeSelection(discovered, installedNames);
 }
-async function promptPatchSelection(discovered, installedNames) {
+async function promptThemeSelection(discovered, installedNames) {
     const selected = await p.multiselect({
-        message: "Select patches to install",
-        options: discovered.map((patch)=>({
-                value: patch.name,
-                label: `${patch.name}${installedNames.has(patch.name) ? " (installed)" : ""}`,
-                hint: patch.description ? `${patch.soundCount} sounds — ${patch.description}` : `${patch.soundCount} sounds`
+        message: "Select themes to install",
+        options: discovered.map((theme)=>({
+                value: theme.name,
+                label: `${theme.name}${installedNames.has(theme.name) ? " (installed)" : ""}`,
+                hint: theme.description ? `${theme.soundCount} sounds — ${theme.description}` : `${theme.soundCount} sounds`
             }))
     });
     if (p.isCancel(selected)) {
@@ -711,21 +898,21 @@ async function promptPatchSelection(discovered, installedNames) {
     const names = new Set(selected);
     return discovered.filter((d)=>names.has(d.name));
 }
-async function confirmOverwrites(patches, installedNames) {
-    const existing = patches.filter((patch)=>installedNames.has(patch.name));
-    if (existing.length === 0) return patches;
+async function confirmThemeOverwrites(themes, installedNames) {
+    const existing = themes.filter((theme)=>installedNames.has(theme.name));
+    if (existing.length === 0) return themes;
     const overwrite = await p.confirm({
-        message: `${existing.length} patch(es) already installed. Overwrite?`
+        message: `${existing.length} theme(es) already installed. Overwrite?`
     });
     if (p.isCancel(overwrite) || !overwrite) {
         p.cancel("Cancelled.");
         process.exit(0);
     }
-    return patches;
+    return themes;
 }
-async function writePatch(filename, data) {
+async function writeTheme(filename, data) {
     await ensureConfig("themes");
-    const dir = getPatchesDir();
+    const dir = getThemesDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, {
             recursive: true
@@ -761,18 +948,18 @@ async function writeSound(name, definition, options) {
 
 async function check(_args) {
     p.intro("@litlab/audx check");
-    const installed = await getInstalledPatches();
+    const installed = await getInstalledThemes();
     if (installed.length === 0) {
-        p.log.warn("No patches installed.");
-        p.outro("Install patches with npx @litlab/audx add");
+        p.log.warn("No themes installed.");
+        p.outro("Install themes with npx @litlab/audx add");
         return;
     }
     const s = p.spinner();
     s.start("Checking for updates...");
     let registry;
     try {
-        registry = await fetchPatchIndex();
-        s.stop(`Checked ${registry.length} registry patch(es)`);
+        registry = await fetchThemeIndex();
+        s.stop(`Checked ${registry.length} registry theme(es)`);
     } catch (err) {
         s.stop("Failed to fetch registry.");
         p.log.error(String(err));
@@ -793,14 +980,14 @@ async function check(_args) {
         }
     }
     if (available.length === 0) {
-        p.log.warn("No installed patches found in the registry.");
+        p.log.warn("No installed themes found in the registry.");
         p.outro("");
         return;
     }
-    p.note(available.map((name)=>`  ↑ ${name}`).join("\n"), `${available.length} patch(es) available`);
+    p.note(available.map((name)=>`  ↑ ${name}`).join("\n"), `${available.length} theme(es) available`);
     if (notInRegistry.length > 0) {
         p.log.warn([
-            `${notInRegistry.length} patch(es) not found in registry:`,
+            `${notInRegistry.length} theme(es) not found in registry:`,
             ...notInRegistry.map((name)=>`  • ${name}`)
         ].join("\n"));
     }
@@ -814,15 +1001,15 @@ async function find(args) {
     s.start("Fetching registry...");
     let index;
     try {
-        index = await fetchPatchIndex();
-        s.stop(`Found ${index.length} patch(es) in registry`);
+        index = await fetchThemeIndex();
+        s.stop(`Found ${index.length} theme(es) in registry`);
     } catch (err) {
         s.stop("Failed to fetch registry.");
         p.log.error(String(err));
         process.exit(1);
     }
     if (index.length === 0) {
-        p.log.warn("No patches available in the registry.");
+        p.log.warn("No themes available in the registry.");
         p.outro("");
         return;
     }
@@ -832,11 +1019,11 @@ async function find(args) {
         return haystack.includes(query);
     }) : index;
     if (matches.length === 0) {
-        p.log.warn(`No patches found for "${query}"`);
+        p.log.warn(`No themes found for "${query}"`);
         p.outro("");
         return;
     }
-    p.log.info("Install with npx @litlab/audx add --patch <name>");
+    p.log.info("Install with npx @litlab/audx add --theme <name>");
     for (const entry of matches){
         const tags = entry.tags && entry.tags.length > 0 ? `  ${entry.tags.join(", ")}` : "";
         const desc = entry.description ? `\n  ${entry.description}` : "";
@@ -857,8 +1044,8 @@ async function init(args) {
 async function themeInit(_args) {
     p.intro("@litlab/audx theme init");
     const name = await p.text({
-        message: "Patch name",
-        placeholder: "my-patch",
+        message: "Theme name",
+        placeholder: "my-theme",
         validate: (v)=>v.length === 0 ? "Name is required" : undefined
     });
     if (p.isCancel(name)) {
@@ -875,7 +1062,7 @@ async function themeInit(_args) {
     }
     const description = await p.text({
         message: "Description",
-        placeholder: "What does this patch sound like?"
+        placeholder: "What does this theme sound like?"
     });
     if (p.isCancel(description)) {
         p.cancel("Cancelled.");
@@ -899,8 +1086,8 @@ async function themeInit(_args) {
             process.exit(0);
         }
     }
-    const patch = {
-        $schema: "../../node_modules/@litlab/audx/schemas/patch.schema.json",
+    const theme = {
+        $schema: "../../node_modules/@litlab/audx/schemas/theme.schema.json",
         name: name,
         author: author || undefined,
         version: "1.0.0",
@@ -908,64 +1095,64 @@ async function themeInit(_args) {
         tags: [],
         sounds: {}
     };
-    await writeFile(target, `${JSON.stringify(patch, null, 2)}\n`, "utf-8");
+    await writeFile(target, `${JSON.stringify(theme, null, 2)}\n`, "utf-8");
     p.log.success(`Created .audx/themes/${filename}`);
     p.outro("Add sounds to the `sounds` object to get started.");
 }
 
 async function list(_args) {
     p.intro("@litlab/audx list");
-    const patches = await getInstalledPatches();
-    if (patches.length === 0) {
-        p.log.warn(`No patches found in ${getPatchesDir()}`);
-        p.outro("Run `@litlab/audx add` to install patches.");
+    const themes = await getInstalledThemes();
+    if (themes.length === 0) {
+        p.log.warn(`No themes found in ${getThemesDir()}`);
+        p.outro("Run `@litlab/audx add` to install themes.");
         return;
     }
-    const rows = patches.map((patch)=>{
-        var _patch_description;
-        return `  ${patch.name.padEnd(16)} ${String(patch.soundCount).padStart(3)} sounds   ${(_patch_description = patch.description) != null ? _patch_description : ""}`;
+    const rows = themes.map((theme)=>{
+        var _theme_description;
+        return `  ${theme.name.padEnd(16)} ${String(theme.soundCount).padStart(3)} sounds   ${(_theme_description = theme.description) != null ? _theme_description : ""}`;
     });
-    p.note(rows.join("\n"), `${patches.length} patch(es) installed`);
-    p.outro(getPatchesDir());
+    p.note(rows.join("\n"), `${themes.length} theme(es) installed`);
+    p.outro(getThemesDir());
 }
 
 function parseRemoveOptions(args) {
     const options = {};
-    const patches = [];
+    const themes = [];
     for(let i = 0; i < args.length; i++){
         const arg = args[i];
         if (arg === "-y" || arg === "--yes") {
             options.yes = true;
         } else if (arg && !arg.startsWith("-")) {
-            patches.push(arg);
+            themes.push(arg);
         }
     }
     return {
-        patches,
+        themes,
         options
     };
 }
 async function remove(args) {
-    const { patches: patchNames, options } = parseRemoveOptions(args);
+    const { themes: themeNames, options } = parseRemoveOptions(args);
     p.intro("@litlab/audx remove");
-    const patches = await getInstalledPatches();
-    if (patches.length === 0) {
-        p.log.warn("No patches installed.");
+    const themes = await getInstalledThemes();
+    if (themes.length === 0) {
+        p.log.warn("No themes installed.");
         p.outro("Nothing to remove.");
         return;
     }
     let files;
-    if (patchNames.length > 0) {
-        const matched = patches.filter((pk)=>patchNames.some((n)=>n.toLowerCase() === pk.name.toLowerCase()));
+    if (themeNames.length > 0) {
+        const matched = themes.filter((pk)=>themeNames.some((n)=>n.toLowerCase() === pk.name.toLowerCase()));
         if (matched.length === 0) {
-            p.log.error(`No matching patches found for: ${patchNames.join(", ")}`);
+            p.log.error(`No matching themes found for: ${themeNames.join(", ")}`);
             return;
         }
         files = matched.map((pk)=>pk.file);
     } else {
         const selected = await p.multiselect({
-            message: "Select patches to remove",
-            options: patches.map((pk)=>({
+            message: "Select themes to remove",
+            options: themes.map((pk)=>({
                     value: pk.file,
                     label: pk.name,
                     hint: `${pk.soundCount} sounds`
@@ -977,50 +1164,50 @@ async function remove(args) {
         }
         files = selected;
         if (files.length === 0) {
-            p.outro("No patches selected.");
+            p.outro("No themes selected.");
             return;
         }
     }
     if (!options.yes) {
         const confirmed = await p.confirm({
-            message: `Remove ${files.length} patch(es)?`
+            message: `Remove ${files.length} theme(es)?`
         });
         if (p.isCancel(confirmed) || !confirmed) {
             p.cancel("Cancelled.");
             process.exit(0);
         }
     }
-    const dir = getPatchesDir();
+    const dir = getThemesDir();
     const removed = [];
     for (const file of files){
         try {
             var _ref;
             await unlink(join(dir, file));
-            const pk = patches.find((item)=>item.file === file);
+            const pk = themes.find((item)=>item.file === file);
             removed.push((_ref = pk == null ? void 0 : pk.name) != null ? _ref : file);
         } catch (err) {
             p.log.warn(`Failed to remove ${file}: ${err}`);
         }
     }
     await regenerateIndex(dir);
-    p.note(removed.map((n)=>`  - ${n}`).join("\n"), "Removed patches");
+    p.note(removed.map((n)=>`  - ${n}`).join("\n"), "Removed themes");
     p.outro("Done!");
 }
 
 async function update(_args) {
     p.intro("@litlab/audx update");
-    const installed = await getInstalledPatches();
+    const installed = await getInstalledThemes();
     if (installed.length === 0) {
-        p.log.warn("No patches installed.");
-        p.outro("Install patches with npx @litlab/audx add");
+        p.log.warn("No themes installed.");
+        p.outro("Install themes with npx @litlab/audx add");
         return;
     }
     const s = p.spinner();
     s.start("Fetching registry...");
     let registry;
     try {
-        registry = await fetchPatchIndex();
-        s.stop(`Found ${registry.length} registry patch(es)`);
+        registry = await fetchThemeIndex();
+        s.stop(`Found ${registry.length} registry theme(es)`);
     } catch (err) {
         s.stop("Failed to fetch registry.");
         p.log.error(String(err));
@@ -1032,15 +1219,15 @@ async function update(_args) {
         ]));
     const toUpdate = installed.filter((pk)=>registryMap.has(pk.name.toLowerCase()));
     if (toUpdate.length === 0) {
-        p.log.warn("No installed patches found in the registry.");
+        p.log.warn("No installed themes found in the registry.");
         p.outro("");
         return;
     }
     const dl = p.spinner();
-    dl.start(`Updating ${toUpdate.length} patch(es)...`);
+    dl.start(`Updating ${toUpdate.length} theme(es)...`);
     let successCount = 0;
     let failCount = 0;
-    const dir = getPatchesDir();
+    const dir = getThemesDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, {
             recursive: true
@@ -1048,8 +1235,8 @@ async function update(_args) {
     }
     for (const entry of toUpdate){
         try {
-            const data = await fetchPatchJson(entry.name);
-            if (!validatePatch(data)) {
+            const data = await fetchThemeJson(entry.name);
+            if (!validateTheme(data)) {
                 failCount++;
                 continue;
             }
@@ -1063,9 +1250,9 @@ async function update(_args) {
         }
     }
     await regenerateIndex(dir);
-    dl.stop(`Updated ${successCount} patch(es)`);
+    dl.stop(`Updated ${successCount} theme(es)`);
     if (failCount > 0) {
-        p.log.warn(`Failed to update ${failCount} patch(es)`);
+        p.log.warn(`Failed to update ${failCount} theme(es)`);
     }
     p.outro("Done!");
 }
@@ -1100,19 +1287,19 @@ const COMMANDS = {
 };
 function showBanner() {
     p.intro("@litlab/audx");
-    p.log.message("Manage sound patches for your project.");
+    p.log.message("Manage sound themes for your project.");
     p.log.message([
-        "Patches",
+        "Themes",
         "  add [sound]     Install an individual sound",
         "  add             Browse and install themes",
-        "  find [query]    Search for patches",
-        "  list            List installed patches",
-        "  remove          Remove installed patches"
+        "  find [query]    Search for themes",
+        "  list            List installed themes",
+        "  remove          Remove installed themes"
     ].join("\n"));
     p.log.message([
         "Updates",
         "  check           Check for updates",
-        "  update          Update installed patches"
+        "  update          Update installed themes"
     ].join("\n"));
     p.log.message([
         "Project",
@@ -1126,17 +1313,17 @@ function showHelp() {
     p.log.message([
         "Usage: @litlab/audx <command> [options]",
         "",
-        "Manage Patches:",
+        "Manage Themes:",
         "  add [sound]     Install an individual sound",
         "  add             Browse and install themes",
         "  add <source>    Install themes from a source",
-        "  find [query]    Search for patches in the registry",
-        "  list, ls        List installed patches",
-        "  remove, rm      Remove installed patches",
+        "  find [query]    Search for themes in the registry",
+        "  list, ls        List installed themes",
+        "  remove, rm      Remove installed themes",
         "",
         "Updates:",
         "  check           Check for available updates",
-        "  update          Update all installed patches",
+        "  update          Update all installed themes",
         "",
         "Project:",
         "  init            Set up AudX and install themes",
@@ -1144,9 +1331,11 @@ function showHelp() {
     ].join("\n"));
     p.log.message([
         "Add Options:",
-        "  -l, --list      Preview available patches without installing",
+        "  -l, --list      Preview available themes without installing",
         "  -y, --yes       Skip confirmation prompts",
-        "  --patch <name>  Install a specific patch by name",
+        "  --theme <name>  Install a specific theme by name",
+        "  --data <value>  Install an encoded customized sound definition",
+        "  --tune <token>  Apply compact editor settings (requires --theme)",
         "",
         "Remove Options:",
         "  -y, --yes       Skip confirmation prompts"
@@ -1156,7 +1345,7 @@ function showHelp() {
         "  ./local/path                    Local file or directory",
         "  owner/repo                      GitHub shorthand",
         "  https://github.com/user/repo    Full GitHub URL",
-        "  https://...patch.json           Direct URL to a patch file",
+        "  https://...theme.json           Direct URL to a theme file",
         "  (no argument)                   Browse the registry"
     ].join("\n"));
     p.log.message([
@@ -1168,7 +1357,7 @@ function showHelp() {
         "  @litlab/audx add ommgh/audio",
         "  @litlab/audx add ./.themes/",
         "  @litlab/audx add ommgh/audio --list",
-        "  @litlab/audx add --patch core -y",
+        "  @litlab/audx add --theme core -y",
         "  @litlab/audx remove core -y",
         "  @litlab/audx find ambient",
         "  @litlab/audx check",

package/dist/{cc-DgCkkqq8.js → cc-zJdVkWBV.js}

@@ -1,3 +1,14 @@
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
 function _object_without_properties_loose(source, excluded) {
     if (source == null) return {};
     var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
@@ -10,4 +21,4 @@ function _object_without_properties_loose(source, excluded) {
     return target;
 }
 
-export { _object_without_properties_loose as _ };
+export { _extends as _, _object_without_properties_loose as a };

package/dist/index.js

@@ -1293,7 +1293,9 @@ function createPatchInstance(data) {
  * @throws {Error} If the network request fails
  */ async function loadPatch(source) {
     if (typeof source === "string") {
-        const response = await fetch(source);
+        const response = await fetch(source, {
+            cache: "no-store"
+        });
         if (!response.ok) throw new Error(`Failed to load patch from ${source}: ${response.status}`);
         const data = await response.json();
         return createPatchInstance(data);

package/dist/react.js

@@ -1149,7 +1149,9 @@ function createPatchInstance(data) {
  * @throws {Error} If the network request fails
  */ async function loadPatch(source) {
     if (typeof source === "string") {
-        const response = await fetch(source);
+        const response = await fetch(source, {
+            cache: "no-store"
+        });
         if (!response.ok) throw new Error(`Failed to load patch from ${source}: ${response.status}`);
         const data = await response.json();
         return createPatchInstance(data);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@litlab/audx",
-	"version": "0.5.5",
+	"version": "0.8.5",
 	"description": "Core Engine For Semantic Web Audio",
 	"author": "Om Mishra",
 	"license": "MIT",

package/schemas/pack.schema.json

@@ -1,4 +1,4 @@
 {
 	"$schema": "https://json-schema.org/draft/2020-12/schema",
-	"$ref": "./patch.schema.json"
+	"$ref": "./theme.schema.json"
 }

package/schemas/{patch.schema.json → theme.schema.json}

@@ -1,8 +1,8 @@
 {
 	"$schema": "https://json-schema.org/draft/2020-12/schema",
-	"$id": "https://audx.site/schemas/patch.schema.json",
-	"title": "@litlab/audx Sound Patch",
-	"description": "Schema for @litlab/audx sound patch JSON files",
+	"$id": "https://audx.site/schemas/theme.schema.json",
+	"title": "@litlab/audx Sound Theme",
+	"description": "Schema for @litlab/audx sound theme JSON files",
 	"type": "object",
 	"required": ["name", "sounds"],
 	"properties": {
@@ -11,7 +11,7 @@
 		},
 		"name": {
 			"type": "string",
-			"description": "Display name of the patch"
+			"description": "Display name of the theme"
 		},
 		"author": {
 			"type": "string"