@aethervtt/shard-audio-editor 0.0.0-stage → 0.2.0

package/dist/panels/diagnostics.d.ts

@@ -0,0 +1,2 @@
+import { type AudioEditorMountOptions } from './common.js';
+export declare function mountAudioDiagnostics(container: HTMLElement, options: AudioEditorMountOptions): import("./common.js").AudioEditorView;

package/dist/panels/diagnostics.js

@@ -0,0 +1,7 @@
+import { mountPanel } from "./common.js";
+function mountAudioDiagnostics(container, options) {
+  return mountPanel(container, options, "diagnostics");
+}
+export {
+  mountAudioDiagnostics
+};

package/dist/panels/event.d.ts

@@ -0,0 +1,2 @@
+import { type AudioEditorMountOptions } from './common.js';
+export declare function mountAudioEvent(container: HTMLElement, options: AudioEditorMountOptions): import("./common.js").AudioEditorView;

package/dist/panels/event.js

@@ -0,0 +1,7 @@
+import { mountPanel } from "./common.js";
+function mountAudioEvent(container, options) {
+  return mountPanel(container, options, "event");
+}
+export {
+  mountAudioEvent
+};

package/dist/panels/library.d.ts

@@ -0,0 +1,2 @@
+import { type AudioEditorMountOptions } from './common.js';
+export declare function mountAudioLibrary(container: HTMLElement, options: AudioEditorMountOptions): import("./common.js").AudioEditorView;

package/dist/panels/library.js

@@ -0,0 +1,7 @@
+import { mountPanel } from "./common.js";
+function mountAudioLibrary(container, options) {
+  return mountPanel(container, options, "library");
+}
+export {
+  mountAudioLibrary
+};

package/dist/panels/mixer.d.ts

@@ -0,0 +1,2 @@
+import { type AudioEditorMountOptions } from './common.js';
+export declare function mountAudioMixer(container: HTMLElement, options: AudioEditorMountOptions): import("./common.js").AudioEditorView;

package/dist/panels/mixer.js

@@ -0,0 +1,7 @@
+import { mountPanel } from "./common.js";
+function mountAudioMixer(container, options) {
+  return mountPanel(container, options, "mixer");
+}
+export {
+  mountAudioMixer
+};

package/dist/panels/music.d.ts

@@ -0,0 +1,2 @@
+import { type AudioEditorMountOptions } from './common.js';
+export declare function mountAudioMusic(container: HTMLElement, options: AudioEditorMountOptions): import("./common.js").AudioEditorView;

package/dist/panels/music.js

@@ -0,0 +1,7 @@
+import { mountPanel } from "./common.js";
+function mountAudioMusic(container, options) {
+  return mountPanel(container, options, "music");
+}
+export {
+  mountAudioMusic
+};

package/dist/panels/parameters.d.ts

@@ -0,0 +1,2 @@
+import { type AudioEditorMountOptions } from './common.js';
+export declare function mountAudioParameters(container: HTMLElement, options: AudioEditorMountOptions): import("./common.js").AudioEditorView;

package/dist/panels/parameters.js

@@ -0,0 +1,7 @@
+import { mountPanel } from "./common.js";
+function mountAudioParameters(container, options) {
+  return mountPanel(container, options, "parameters");
+}
+export {
+  mountAudioParameters
+};

package/dist/preview-export.d.ts

@@ -0,0 +1,68 @@
+import { type JsonObject } from '@aethervtt/shard-core';
+import type { AudioAssetCatalog, AudioDocument, AudioDocumentStore } from './types.js';
+/** Resolves the existing render-plan format exclusively through the host catalog. */
+export declare function exportAudioEditorPreview(host: {
+    assets: AudioAssetCatalog;
+    documents: AudioDocumentStore;
+}, document: AudioDocument, overrides: JsonObject, signal?: AbortSignal): Promise<{
+    wav: Uint8Array<ArrayBufferLike>;
+    measured: {
+        peak: number;
+        rms: number;
+        clipped: number;
+        nonfinite: number;
+        sampleRate: number;
+        channels: number;
+        frames: number;
+        duration: number;
+    };
+    trace: {
+        zones: {
+            at: number;
+            buses: string[];
+        }[];
+        events: {
+            entries: import("@aethervtt/shard-audio").AudioEventTraceEntry[];
+            oldestCursor: number;
+            nextCursor: number;
+            truncated: boolean;
+        };
+        music: {
+            entries: import("@aethervtt/shard-audio").AudioEventTraceEntry[];
+            oldestCursor: number;
+            nextCursor: number;
+            truncated: boolean;
+        };
+        controls: {
+            index: number;
+            requestedAt: number;
+            appliedAt: number;
+        }[];
+        sources: {
+            id: number;
+            presentation: Readonly<import("@aethervtt/shard-platform").AudioPresentation> | undefined;
+        }[];
+        controlRate: number;
+        quantumFrames: number;
+    };
+    capabilities: Readonly<import("@aethervtt/shard-platform").AudioCapabilities>;
+    backend: {
+        kind: string;
+        userAgent: string;
+        sampleRate: number;
+    };
+    seed: number;
+    assets: {
+        id: string;
+        scope: string;
+        revision: string;
+        type: string;
+    }[];
+    plan: JsonObject;
+    document: {
+        id: string;
+        revision: string;
+        type: string;
+        draft: JsonObject;
+    };
+}>;

package/dist/preview-export.js

@@ -0,0 +1,143 @@
+import { AudioPreviewPlan, audioClip, validateAudioPreview } from "@aethervtt/shard-audio";
+import {
+  ShardError
+} from "@aethervtt/shard-core";
+import { renderAudioEditorBundle } from "./preview-render.js";
+import { getAudioEditorSchema, validateAudioDocument } from "./schema.js";
+async function exportAudioEditorPreview(host, document, overrides, signal) {
+  const assets = [];
+  const revisions = [];
+  const resolved = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  const scope = host.assets.scope;
+  const docsScope = host.documents.scope;
+  let serial = 0;
+  const check = () => {
+    if (signal?.aborted)
+      throw new ShardError("audio-editor/disposed", "Preview export was cancelled");
+    if (scope !== host.assets.scope || docsScope !== host.documents.scope)
+      throw new ShardError("audio-editor/asset-unavailable", "Host scope changed during export");
+  };
+  async function resolve(id, type) {
+    check();
+    const key = JSON.stringify([type, id]);
+    const existing = resolved.get(key);
+    if (existing) return existing;
+    if (pending.has(key))
+      throw new ShardError("audio-editor/invalid-document", "Export dependency cycle", { path: id });
+    pending.add(key);
+    const number = ++serial;
+    const guid = `editor-preview:${number}`;
+    const path = `editor-preview/${number}`;
+    const ref = { type, guid, path };
+    let value;
+    if (type === "AudioClip") {
+      const entry = await host.assets.get(id, signal);
+      if (entry.type !== type)
+        throw new ShardError(
+          "audio-editor/asset-unavailable",
+          "Export reference is not an audio clip",
+          { path: id }
+        );
+      const content = await host.assets.resolve(id, signal);
+      try {
+        check();
+        if (!content.bytes)
+          throw new ShardError(
+            "audio-editor/unsupported-capability",
+            "Offline export requires authorized encoded bytes",
+            { path: id }
+          );
+        if (content.settings?.mode === "stream")
+          throw new ShardError(
+            "audio-editor/unsupported-capability",
+            "Offline export requires decoded sources",
+            {
+              path: id,
+              hint: "Choose a decoded catalog asset for deterministic offline rendering."
+            }
+          );
+        value = audioClip(Uint8Array.from(content.bytes), {
+          ...content.settings,
+          id: JSON.stringify([scope, id, entry.revision])
+        });
+        revisions.push({ id, scope, revision: entry.revision, type });
+      } finally {
+        content.release?.();
+      }
+    } else {
+      const source = id === document.id ? document : await host.documents.read(id, signal);
+      if (source.type !== type)
+        throw new ShardError("audio-editor/invalid-document", `Expected ${type} document`, {
+          path: id
+        });
+      const checked = await validateAudioDocument(source, host.documents, host.assets, signal);
+      if (checked.errors.length) throw checked.errors[0];
+      const schema = getAudioEditorSchema(source.type);
+      value = await fields(schema.fields, schema.deserialize(checked.effective.value));
+      revisions.push({ id, scope: docsScope, revision: source.revision, type });
+    }
+    check();
+    assets.push({ guid, path, type, value });
+    resolved.set(key, ref);
+    pending.delete(key);
+    return ref;
+  }
+  async function field(definition, value) {
+    if (definition.kind === "handle" && value) {
+      const ref = value;
+      const id = ref.guid ?? ref.path;
+      if (!id)
+        throw new ShardError("audio-editor/asset-unavailable", "Export reference has no host ID");
+      return resolve(id, definition.assetType);
+    }
+    if (definition.kind === "list" && Array.isArray(value)) {
+      const items = [];
+      for (const item of value) items.push(await field(definition.item, item));
+      return items;
+    }
+    if (definition.kind === "struct")
+      return fields(definition.fields, value);
+    return value;
+  }
+  async function fields(definitions, values) {
+    const result2 = { ...values };
+    for (const [name, definition] of Object.entries(definitions))
+      result2[name] = await field(definition, result2[name]);
+    return result2;
+  }
+  const root = { guid: document.id };
+  const defaults = {
+    duration: 3,
+    ...document.type === "audio/AudioEvent" ? { events: [{ id: "audition", asset: root, at: 0 }] } : {},
+    ...document.type === "audio/MusicProgram" ? { music: [{ id: "audition", asset: root, at: 0 }] } : {},
+    ...document.type === "audio/AudioMixer" ? { mixer: root } : {}
+  };
+  const raw = { ...defaults, ...overrides };
+  const errors = AudioPreviewPlan.validate(raw);
+  if (errors.length) throw errors[0];
+  const plan = AudioPreviewPlan.deserialize(raw);
+  validateAudioPreview(plan);
+  const resolvedPlan = await fields(AudioPreviewPlan.fields, plan);
+  check();
+  const result = await renderAudioEditorBundle(
+    { plan: AudioPreviewPlan.serialize(resolvedPlan), assets },
+    { signal }
+  );
+  check();
+  return {
+    ...result,
+    seed: plan.seed,
+    assets: revisions,
+    plan: AudioPreviewPlan.serialize(plan),
+    document: {
+      id: document.id,
+      revision: document.revision,
+      type: document.type,
+      draft: document.value
+    }
+  };
+}
+export {
+  exportAudioEditorPreview
+};

package/dist/preview-render.d.ts

@@ -0,0 +1,2 @@
+/** Optional browser renderer shared with the CLI; independent of editor documents and DOM. */
+export { type AudioRenderBundle as AudioEditorRenderBundle, renderAudioBundle as renderAudioEditorBundle, } from '@aethervtt/shard-audio-preview';

package/dist/preview-render.js

@@ -0,0 +1,6 @@
+import {
+  renderAudioBundle
+} from "@aethervtt/shard-audio-preview";
+export {
+  renderAudioBundle as renderAudioEditorBundle
+};

package/dist/preview-runtime.d.ts

@@ -0,0 +1,114 @@
+import type { AudioBackend } from '@aethervtt/shard-platform';
+import type { AudioAssetCatalog, AudioDocument, AudioDocumentStore } from './types.js';
+/** Internal runtime is loaded only by explicit audition, and never opens a project filesystem. */
+export declare function createPreviewRuntime(options: {
+    assets: AudioAssetCatalog;
+    documents: AudioDocumentStore;
+    backend?: AudioBackend;
+    createBackend?: () => AudioBackend;
+}): Promise<{
+    unlock: () => void;
+    play(document: AudioDocument, signal?: AbortSignal): Promise<{
+        lease: number;
+        prepared: boolean;
+        instance?: undefined;
+        transport?: undefined;
+        configured?: undefined;
+        snapshot?: undefined;
+    } | {
+        lease?: undefined;
+        instance: number;
+        transport?: undefined;
+        configured?: undefined;
+        snapshot?: undefined;
+        prepared?: undefined;
+    } | {
+        lease?: undefined;
+        instance?: undefined;
+        transport: number;
+        configured?: undefined;
+        snapshot?: undefined;
+        prepared?: undefined;
+    } | {
+        lease?: undefined;
+        instance?: undefined;
+        transport?: undefined;
+        configured: boolean;
+        snapshot?: undefined;
+        prepared?: undefined;
+    } | {
+        lease?: undefined;
+        instance?: undefined;
+        transport?: undefined;
+        configured?: undefined;
+        snapshot: number;
+        prepared?: undefined;
+    } | {
+        lease?: undefined;
+        instance?: undefined;
+        transport?: undefined;
+        configured?: undefined;
+        snapshot?: undefined;
+        prepared: boolean;
+    }>;
+    command(name: string, params: Record<string, unknown>): unknown;
+    inspect(): {
+        backend: string;
+        capabilities: Readonly<import("@aethervtt/shard-platform").AudioCapabilities> | null;
+        memory: import("@aethervtt/shard-platform").AudioMemory | null;
+        context: import("@aethervtt/shard-platform").AudioContextState;
+        listener: {
+            entity: number;
+            path: string | null;
+            position: number[];
+        } | null;
+        buses: {
+            name: string;
+            volume: number;
+            userVolume: number;
+            userMuted: boolean;
+            muted: boolean;
+            parent: string;
+            gain: number;
+            ducked: number;
+            duck?: import("@aethervtt/shard-audio").AudioDuck | undefined;
+        }[];
+        voices: {
+            voice: number;
+            presentation: Readonly<import("@aethervtt/shard-platform").AudioPresentation> | null;
+            clip: string | null;
+            entity: number | null;
+            path: string | null;
+            bus: string;
+            problem?: string | undefined;
+            state: import("@aethervtt/shard-audio").VoiceState;
+            gain: number;
+            pan: number;
+            distance: number | null;
+            position: number[] | null;
+            time: number;
+            elapsed: number;
+            duration: number | null;
+            loop: boolean;
+            pitch: number;
+            priority: number;
+        }[];
+        counts: {
+            active: number;
+            virtual: number;
+            pending: number;
+            maxVoices: number;
+            maxVoicesPerClip: number;
+            dropped: number;
+        };
+        auditionError?: {
+            code: string;
+            message: string;
+            hint?: string;
+            path?: string;
+            details?: unknown[];
+        } | undefined;
+    };
+    stop: () => void;
+    dispose(): Promise<void> | undefined;
+}>;