@mokuyoaxis/dsh-iris 0.2.7 → 0.3.0-beta.1

package/lib/application-runtime.js

@@ -1,12 +1,18 @@
 'use strict';
 
 import { normalizeCoreOptions } from './core-contract.js';
-import { createCoreRuntime } from './core-runtime.js';
+import { createCoreRuntime, inspectCoreWriterLease } from './core-runtime.js';
 import { createCommandService } from './command-service.js';
 import { normalizeGenerationInput } from './generation-input.js';
 import { createProviderTaskRunner } from './provider-task-runner.js';
 import { createImageFlowService } from './image-flow.js';
 import { createLocalCreationService } from './local-creation.js';
+import { createLocalOperationService } from './local-operations.js';
+import { reservePluginOperation } from './plugin-operations.js';
+import { invokeReservedPlugin } from './plugin-execution.js';
+import { AsyncResource } from 'node:async_hooks';
+import { createApplicationWriter } from './application-writer.js';
+import { createMediaScheduler } from './media-scheduler.js';
 
 // Internal first-slice execution surface, not a public API or an HTTP allowlist.
 const COMMAND_MODES = Object.freeze({
@@ -15,7 +21,11 @@ const COMMAND_MODES = Object.freeze({
   'artifact.inspect': 'reader', 'artifact.list': 'reader', 'task.inspect': 'reader', 'task.list': 'reader',
   'flow.init': 'writer', 'flow.create': 'writer', 'flow.continue': 'writer', 'flow.select': 'writer', 'flow.export': 'writer',
   'flow.inspect': 'reader', 'flow.list': 'reader',
-  'creation.init': 'writer', 'creation.image': 'writer', 'creation.flow': 'writer'
+  'creation.init': 'writer', 'creation.image': 'writer', 'creation.flow': 'writer', 'creation.generate': 'writer',
+  'creation.audio': 'writer', 'creation.speech': 'writer', 'creation.transcribe': 'writer', 'creation.video': 'writer',
+  'creation.root': 'reader', 'creation.lookup': 'reader',
+  'execution.init': 'writer', 'operation.accept': 'writer', 'operation.transition': 'writer',
+  'operation.inspect': 'reader', 'operation.lookup': 'reader', 'operation.list': 'reader'
 });
 
 export class ApplicationRuntimeError extends Error {
@@ -31,7 +41,8 @@ function closed() {
 }
 
 /** Instance-owned FIFO and operation-scoped Core leases. No I/O until an explicit operation. */
-export function createApplicationRuntime({ dataRoot, resolveImageCandidates, resolveTaskAdapter } = {}) {
+export function createApplicationRuntime({ dataRoot, resolveImageCandidates, resolveAudioCandidates, resolveVideoCandidates, resolveTaskAdapter,
+  scheduling, scheduler: suppliedScheduler } = {}) {
   const root = normalizeCoreOptions({ dataRoot }).dataRoot;
   if (resolveImageCandidates !== undefined && typeof resolveImageCandidates !== 'function') {
     throw new TypeError('resolveImageCandidates 必须是显式候选解析函数');
@@ -39,22 +50,30 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
   if (resolveTaskAdapter !== undefined && typeof resolveTaskAdapter !== 'function') {
     throw new TypeError('resolveTaskAdapter 必须是显式 Task Provider 解析函数');
   }
+  if (resolveAudioCandidates !== undefined && typeof resolveAudioCandidates !== 'function') throw new TypeError('音频候选解析须为函数');
+  if (resolveVideoCandidates !== undefined && typeof resolveVideoCandidates !== 'function') throw new TypeError('视频候选解析须为函数');
   let state = 'open';
   const queue = [];
   const active = new Set();
   let writer = null;
   let disposePromise;
   let cleanupFailure;
+  const scheduler = suppliedScheduler || (scheduling ? createMediaScheduler(scheduling) : undefined);
+  const managedJobs = new Set();
+  const cooperative = scheduler ? createApplicationWriter({ dataRoot: root, policy: scheduler.policy, scheduler,
+    onFailure(error) { cleanupFailure ||= error; state = 'closing'; cooperative.abort(); stopAll(); } }) : undefined;
 
   function snapshot() {
     return Object.freeze({ state, queuedWrites: queue.length, activeWrites: Number(Boolean(writer)),
-      activeReaders: active.size - Number(Boolean(writer)), cleanupFailed: Boolean(cleanupFailure) });
+      activeReaders: active.size - Number(Boolean(writer)), cleanupFailed: Boolean(cleanupFailure),
+      ...(cooperative ? { ...cooperative.snapshot(), schedulingEnabled: true } : {}) });
   }
 
   function detach(job) { job.signal?.removeEventListener('abort', job.onAbort); }
 
   function rejectQueued(job, error) {
     detach(job);
+    job.resource.emitDestroy();
     job.reject(error);
   }
 
@@ -80,7 +99,16 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     try {
       runtime.start();
       result = await job.action(runtime);
-    } catch (error) { failed = true; operationError = error; }
+    } catch (error) {
+      failed = true; operationError = error;
+      if (job.mode === 'reader' && error?.code === 'IRIS_ARTIFACT_INDEX_INVALID' && error.missingFile === true) {
+        const lease = inspectCoreWriterLease(root);
+        if (lease.status === 'present' && lease.ownerStatus === 'alive') {
+          operationError = new ApplicationRuntimeError('IRIS_CORE_DATA_ROOT_BUSY', '作品读取遇到活动写入，请在写入结束后显式重试');
+          Object.defineProperty(operationError, 'cause', { value: error });
+        }
+      }
+    }
     try { await (job.disposal || runtime.dispose()); }
     catch (error) {
       cleanupFailure ||= error;
@@ -97,7 +125,7 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
 
   function start(job) {
     active.add(job);
-    job.done = Promise.resolve().then(async () => {
+    job.done = job.resource.runInAsyncScope(() => Promise.resolve().then(async () => {
       let result, error, failed = false;
       try { result = await perform(job); }
       catch (caught) { failed = true; error = caught; }
@@ -105,8 +133,9 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
       active.delete(job);
       if (writer === job) writer = null;
       if (failed) job.reject(error); else job.resolve(result);
+      job.resource.emitDestroy();
       dispatch();
-    });
+    }));
   }
 
   function dispatch() {
@@ -115,12 +144,19 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     start(writer);
   }
 
-  function schedule(mode, action, { signal } = {}) {
+  function schedule(mode, action, { signal, managed = false, transaction = false, finalize = false, key } = {}) {
     if (signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError('signal 必须是 AbortSignal');
     if (state !== 'open') return Promise.reject(closed());
     if (signal?.aborted) return Promise.reject(aborted());
+    if (mode === 'writer' && cooperative) {
+      const promise = cooperative.execute(action, { signal, managed: managed || transaction, transaction, finalize, key });
+      managedJobs.add(promise);
+      void promise.then(() => managedJobs.delete(promise), () => managedJobs.delete(promise));
+      return promise;
+    }
     let job;
-    const result = new Promise((resolve, reject) => { job = { mode, action, signal, resolve, reject, aborted: false }; });
+    const result = new Promise((resolve, reject) => { job = { mode, action, signal, resolve, reject, aborted: false,
+      resource: new AsyncResource('IrisApplicationJob') }; });
     job.onAbort = () => {
       const index = queue.indexOf(job);
       if (index >= 0) { queue.splice(index, 1); rejectQueued(job, aborted()); }
@@ -146,15 +182,19 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     const ownedInput = structuredClone(input);
     return schedule(COMMAND_MODES[name], runtime => {
       const ports = resolveTaskAdapter ? { resolveTaskAdapter: async task => {
-        const adapter = await resolveTaskAdapter(task, { signal: runtime.signal });
+        const resolve = () => resolveTaskAdapter(task, { signal: runtime.signal });
+        const adapter = await (runtime.networkWait ? runtime.networkWait(resolve, 'candidates') : resolve());
         if (runtime.signal.aborted) throw aborted();
         return adapter;
       } } : {};
-      if (name.startsWith('creation.')) return createLocalCreationService(runtime, { resolveImageCandidates,
+      if (name === 'execution.init' || name.startsWith('operation.')) return createLocalOperationService(runtime).execute(name, ownedInput);
+      if (name.startsWith('creation.')) return createLocalCreationService(runtime, { resolveImageCandidates, resolveAudioCandidates, resolveVideoCandidates,
         onPrepared: options?.onPrepared }).execute(name, ownedInput);
-      if (name.startsWith('flow.')) return createImageFlowService(runtime, { ...ports, resolveImageCandidates }).execute(name, ownedInput);
+      if (name.startsWith('flow.')) return createImageFlowService(runtime, { ...ports, resolveImageCandidates, resolveAudioCandidates, resolveVideoCandidates }).execute(name, ownedInput);
       return createCommandService(runtime, ports).execute(name, ownedInput);
-    }, options);
+    }, { ...options, managed: true,
+      key: ownedInput?.run_id ? `run:${ownedInput.run_id}` : ownedInput?.task_id ? `task:${ownedInput.task_id}`
+        : name.startsWith('creation.') && ownedInput?.key ? `creation:${name}:${ownedInput.key}` : undefined });
   }
 
   async function generateImage(input, options) {
@@ -163,18 +203,31 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
       throw new ApplicationRuntimeError('IRIS_APP_IMAGE_RESOLVER_MISSING', '图片生成需要显式提供候选解析函数');
     }
     return schedule('writer', async runtime => {
-      const candidates = await resolveImageCandidates({ modelRef: normalized.modelRef, signal: runtime.signal });
+      const resolve = () => resolveImageCandidates({ modelRef: normalized.modelRef, signal: runtime.signal });
+      const candidates = await (runtime.networkWait ? runtime.networkWait(resolve, 'candidates') : resolve());
       if (runtime.signal.aborted) throw aborted();
       return createProviderTaskRunner(runtime).submit({ capability: 'image', candidates,
         providerInput: normalized.providerInput, sourceArtifactId: normalized.sourceArtifactId });
-    }, options);
+    }, { ...options, managed: true });
+  }
+
+  /** Explicit trusted assembly only. No HTTP/MCP route or persistent Operation action is added. */
+  async function executePluginOperation(registry, id, input, { allowedOperations = [], dependency, signal } = {}) {
+    const reserved = reservePluginOperation(registry, id, input, allowedOperations, dependency);
+    try {
+      return await schedule(reserved.mode, runtime => runtime.run(reserved.mode === 'reader' ? 'inspect' : 'execute',
+        () => invokeReservedPlugin(runtime, reserved)), { signal });
+    } finally { reserved.release(); }
   }
 
   function dispose() {
     if (disposePromise) return disposePromise;
     state = 'closing';
     stopAll();
-    disposePromise = Promise.all([...active].map(job => job.done)).then(() => {
+    cooperative?.abort();
+    disposePromise = Promise.allSettled([...active].map(job => job.done).concat([...managedJobs])).then(async () => {
+      await cooperative?.dispose();
+      if (!suppliedScheduler) scheduler?.dispose();
       if (cleanupFailure) throw cleanupFailure;
       state = 'closed';
       return snapshot();
@@ -182,5 +235,8 @@ export function createApplicationRuntime({ dataRoot, resolveImageCandidates, res
     return disposePromise;
   }
 
-  return Object.freeze({ execute, generateImage, run, dispose, snapshot });
+  return Object.freeze({ execute, generateImage, executePluginOperation, run, dispose, snapshot, scheduler,
+    schedulingPhase(key) { return cooperative?.phase(key) || null; },
+    runMedia(action, options) { return schedule('writer', action, { ...options, managed: true }); },
+    transaction(action, { finalize = false } = {}) { return schedule('writer', action, { transaction: true, finalize }); } });
 }

package/lib/application-writer.js

@@ -0,0 +1,193 @@
+import { AsyncResource } from 'node:async_hooks';
+import { createCoreRuntime } from './core-runtime.js';
+import { schedulingError } from './scheduling-policy.js';
+import { performance } from 'node:perf_hooks';
+
+const aborted = () => Object.assign(schedulingError('IRIS_APP_ABORTED', 'Iris 操作已取消'), { name: 'AbortError' });
+const closed = () => schedulingError('IRIS_APP_CLOSED', 'Iris 应用运行时正在关闭或已关闭');
+
+/** Internal cooperative writer. Only known media code may loan its write turn. */
+export function createApplicationWriter({ dataRoot, policy, scheduler, onFailure }) {
+  const pending = [], active = new Set(), taskGate = {};
+  let rootRuntime, owner, closing = false, failure, retiring, disposal;
+  const snapshot = () => ({ queuedWrites: pending.filter(entry => entry.kind === 'start').length,
+    activeWrites: Number(Boolean(rootRuntime)), writeTurn: Number(Boolean(owner)),
+    managedWrites: active.size, waitingWrites: [...active].filter(job => job.parked).length, cleanupFailed: Boolean(failure) });
+
+  function remove(entry) {
+    const index = pending.indexOf(entry);
+    if (index >= 0) pending.splice(index, 1);
+    clearTimeout(entry.timer); entry.signal?.removeEventListener('abort', entry.abort);
+  }
+  function enqueue(entry) {
+    return new Promise((resolve, reject) => {
+      entry.resolve = resolve; entry.reject = reject;
+      pending.push(entry); pump();
+    });
+  }
+  async function retire() {
+    const runtime = rootRuntime;
+    try { await runtime.dispose(); }
+    catch (error) {
+      failure = error; closing = true; onFailure?.(error);
+      for (const entry of [...pending]) { remove(entry); entry.reject(error); }
+      throw error;
+    } finally { rootRuntime = null; retiring = null; pump(); }
+  }
+  function pump() {
+    if (owner || retiring) return;
+    // A waiting exclusive callback cannot block the resumes that let earlier media jobs finish.
+    let index = pending.findIndex(entry => entry.kind !== 'start' || entry.transaction);
+    if (index < 0) index = 0;
+    let entry = pending[index];
+    if (!entry) {
+      if (rootRuntime && !active.size) {
+        retiring = Promise.resolve().then(retire); void retiring.catch(() => {});
+      }
+      return;
+    }
+    if (entry.kind === 'start' && performance.now() >= entry.deadline) {
+      remove(entry); entry.reject(schedulingError('IRIS_SCHEDULER_QUEUE_TIMEOUT', '本地写入等候超时；未开始本次操作')); pump(); return;
+    }
+    if (entry.kind === 'start' && (!entry.managed && active.size || [...active].some(job => !job.managed))) return;
+    remove(entry);
+    if (entry.kind === 'start') {
+      try {
+        if (!rootRuntime) { rootRuntime = createCoreRuntime({ dataRoot, mode: 'writer' }); rootRuntime.start(); }
+      } catch (error) {
+        entry.reject(error);
+        // start may have retained a failed lease; dispose must report that failure.
+        retiring = Promise.resolve().then(retire); void retiring.catch(() => {}); return;
+      }
+      const job = entry.job;
+      active.add(job); owner = job;
+      entry.resolve();
+    } else { owner = entry.job; entry.resolve(); }
+  }
+  function release(job) {
+    if (owner !== job) throw new Error('Iris writer turn ownership mismatch');
+    owner = null;
+    let error;
+    try { scheduler?.changed(dataRoot); } catch (caught) { error = caught; }
+    pump(); return error;
+  }
+  async function networkWait(job, action, reason = 'network') {
+    if (!job.managed || job.parked) throw new Error('Iris write turn can only be loaned once by managed media');
+    job.parked = reason; const releaseError = release(job);
+    let result, error;
+    try { if (releaseError) throw releaseError; result = await action(); } catch (caught) { error = caught; }
+    // Even an aborted operation reacquires its turn before recording acceptance/terminal facts.
+    await enqueue({ kind: 'resume', job }); job.parked = null; job.phase = null;
+    if (error) throw error;
+    return result;
+  }
+  async function checkpoint(job, action) {
+    if (job.finished) throw closed();
+    const parked = job.parked;
+    if (parked) await enqueue({ kind: 'checkpoint', job });
+    if (owner !== job) throw new Error('Core checkpoint requires the current write turn');
+    try {
+      const value = action();
+      if (value && typeof value.then === 'function') throw new TypeError('Core checkpoint 必须同步完成');
+      return value;
+    } finally { if (parked) { const error = release(job); if (error) throw error; } }
+  }
+  async function execute(action, { signal, managed = false, transaction = false, finalize = false, key } = {}) {
+    if (closing) throw closed();
+    signal?.throwIfAborted();
+    if (!finalize && active.size + pending.filter(entry => entry.kind === 'start').length >= policy.queueLimit) {
+      throw schedulingError('IRIS_SCHEDULER_QUEUE_FULL', '本地写入队列已满；请查询原操作后再明确重试');
+    }
+    const resource = new AsyncResource('IrisApplicationWriter'), controller = new AbortController();
+    const job = { managed, parked: null, key, controller, cleanup: [], inFlight: new Set(), finished: false };
+    // Only the runner uses finalize for short terminal writes of already accepted Operations.
+    // They must drain under the writer even when new work has reached its admission budget.
+    const entry = { kind: 'start', job, signal, managed, transaction, deadline: finalize ? Infinity : performance.now() + policy.queueTimeoutMs };
+    // Same durable Run/creation key must not overlap even if its candidate resolver waits.
+    if (key && ([...active].some(other => other.key === key) || pending.some(other => other.job.key === key))) {
+      resource.emitDestroy(); throw schedulingError('IRIS_APP_OPERATION_BUSY', '原 Run 或创建 Key 正在执行；请查询原操作');
+    }
+    entry.abort = () => {
+      controller.abort();
+      if (!active.has(job)) { remove(entry); entry.reject(aborted()); pump(); }
+    };
+    signal?.addEventListener('abort', entry.abort, { once: true });
+    const start = enqueue(entry);
+    // Queued starts are bounded; resumes/terminal persistence never expire behind this timer.
+    if (pending.includes(entry) && !finalize) entry.timer = setTimeout(() => {
+      remove(entry); entry.reject(schedulingError('IRIS_SCHEDULER_QUEUE_TIMEOUT', '本地写入等候超时；未开始本次操作')); pump();
+    }, Math.max(1, entry.deadline - performance.now()));
+    let result, operationError;
+    try {
+      await start;
+      // The queue entry's abort listener was removed at admission; active jobs keep their own signal.
+      signal?.addEventListener('abort', entry.abort, { once: true });
+      if (signal?.aborted) controller.abort();
+      controller.signal.throwIfAborted();
+      const runtime = Object.freeze({
+        get signal() { return controller.signal; }, taskGate,
+        run(operation, callback) {
+          if (job.finished) throw closed();
+          if (owner !== job) throw new Error('Core operation requires the current write turn');
+          const promise = rootRuntime.run(operation, context => callback(Object.freeze({ ...context, signal: controller.signal })));
+          job.inFlight.add(promise);
+          void promise.then(() => job.inFlight.delete(promise), () => job.inFlight.delete(promise));
+          return promise;
+        },
+        snapshot: () => rootRuntime.snapshot(),
+        onDispose(callback) {
+          if (job.finished) throw closed();
+          if (typeof callback !== 'function') throw new TypeError('Core cleanup 必须是函数');
+          job.cleanup.push(callback); return () => { const i = job.cleanup.indexOf(callback); if (i < 0) return false; job.cleanup.splice(i, 1); return true; };
+        },
+        networkWait: (callback, reason) => networkWait(job, callback, reason),
+        checkpoint: callback => checkpoint(job, callback),
+        reportScheduling(phase) { if (job.parked) job.phase = phase; },
+        scheduler,
+        schedulingState: () => job.parked || 'writing'
+      });
+      result = await resource.runInAsyncScope(action, undefined, runtime);
+    } catch (error) { operationError = error; }
+    finally {
+      signal?.removeEventListener('abort', entry.abort);
+      if (active.has(job)) {
+        while (job.inFlight.size) await Promise.allSettled([...job.inFlight]);
+        job.finished = true; controller.abort();
+        try { for (const callback of job.cleanup.reverse()) await callback(); }
+        catch (error) {
+          failure = error; closing = true;
+          // A failed per-job cleanup keeps the same retained-lease semantics as CoreRuntime.
+          rootRuntime.onDispose(() => { throw error; });
+          onFailure?.(error); operationError ||= error;
+        }
+        active.delete(job);
+        if (owner === job) { const error = release(job); operationError ||= error; } else pump();
+        if (retiring) {
+          try { await retiring; }
+          catch (error) { operationError = operationError ? Object.assign(new AggregateError([operationError, error], '操作和写者释放均失败'), { code: error.code }) : error; }
+        }
+      }
+      resource.emitDestroy();
+    }
+    if (operationError) throw operationError;
+    return result;
+  }
+  function dispose() {
+    if (disposal) return disposal;
+    closing = true;
+    for (const entry of [...pending]) if (entry.kind === 'start') { remove(entry); entry.reject(closed()); }
+    for (const job of active) job.controller.abort();
+    disposal = (async () => {
+      // The application awaits admitted jobs before invoking this final drain.
+      if (active.size) throw new Error('Iris writer disposed before jobs drained');
+      pump(); if (retiring) await retiring;
+      if (failure) throw failure;
+    })();
+    return disposal;
+  }
+  return Object.freeze({ execute, snapshot, dispose, phase(key) { const job = [...active].find(job => job.key === key); return job?.phase || job?.parked || null; }, abort() {
+    closing = true;
+    for (const entry of [...pending]) if (entry.kind === 'start') { remove(entry); entry.reject(closed()); }
+    for (const job of active) job.controller.abort();
+  } });
+}

package/lib/audio-flow-input.js

@@ -0,0 +1,37 @@
+import { normalizeGenerationInput } from './generation-input.js';
+import { parseModelRef } from './models.js';
+
+export const AUDIO_RECIPES = Object.freeze({
+  'speech/v0': Object.freeze({ capability: 'tts', step: 'speak' }),
+  'transcribe/v0': Object.freeze({ capability: 'transcribe', step: 'transcribe' })
+});
+export const MAX_AUDIO_INPUT_BYTES = 20 * 1024 * 1024;
+export const AUDIO_TYPES = Object.freeze({ 'audio/wav': 'wav', 'audio/mpeg': 'mp3', 'audio/ogg': 'ogg', 'audio/flac': 'flac' });
+export const isAudioRecipe = recipe => Object.hasOwn(AUDIO_RECIPES, recipe);
+const invalid = message => { throw Object.assign(new Error(message), { code: 'IRIS_AUDIO_INPUT_INVALID' }); };
+
+export function normalizeAudioFlowInput(recipe, input) {
+  if (!isAudioRecipe(recipe) || !input || typeof input !== 'object' || Array.isArray(input)) invalid('不支持的音频流程输入');
+  const speech = recipe === 'speech/v0', required = speech ? ['model_ref', 'text'] : ['model_ref', 'source_artifact_id'];
+  if (Object.keys(input).some(key => ![...required, ...(speech ? ['voice'] : [])].includes(key))
+      || required.some(key => typeof input[key] !== 'string') || !parseModelRef(input.model_ref)
+      || input.voice !== undefined && typeof input.voice !== 'string') invalid('请提供明确模型和文字或当前工作区的音频作品');
+  if (speech) {
+    const normalized = normalizeGenerationInput('tts', input);
+    return { model_ref: normalized.modelRef, ...normalized.providerInput };
+  }
+  if (!/^artifact_[a-f0-9]{24}$/.test(input.source_artifact_id)) invalid('转写来源须为当前工作区的音频作品');
+  return { model_ref: input.model_ref, source_artifact_id: input.source_artifact_id };
+}
+
+/** Bounded container sniffing, not a decoder or a claim of provider compatibility. */
+export function readImportAudio(bytes, mediaType) {
+  if (!(bytes instanceof Uint8Array) || !bytes.length || bytes.length > MAX_AUDIO_INPUT_BYTES) invalid('音频须为最多20 MiB的WAV、MP3、OGG或FLAC');
+  const value = Buffer.from(bytes);
+  const actual = value.length >= 12 && value.toString('ascii', 0, 4) === 'RIFF' && value.toString('ascii', 8, 12) === 'WAVE' ? 'audio/wav'
+    : value.length >= 10 && (value.toString('ascii', 0, 3) === 'ID3' || value[0] === 0xff && (value[1] & 0xe0) === 0xe0) ? 'audio/mpeg'
+      : value.length >= 27 && value.toString('ascii', 0, 4) === 'OggS' ? 'audio/ogg'
+        : value.length >= 8 && value.toString('ascii', 0, 4) === 'fLaC' ? 'audio/flac' : null;
+  if (!actual || actual !== mediaType) invalid('音频容器与Content-Type不一致，或不是支持的格式');
+  return { bytes: value, mediaType: actual, metadata: {} };
+}

package/lib/client.d.ts

@@ -1,5 +1,5 @@
-declare const _default: {
+/** The factory registered with DSH's browser ModuleLoader, not a Node module export. */
+export interface DshClientPlugin {
   inject: string[];
   apply(ctx: any): void;
-};
-export = _default;
+}