@kubohiroya/turbowarp-asset-cache 0.2.1 → 0.3.0

package/dist/asset-cache.js

@@ -7,6 +7,421 @@
 (function (Scratch) {
   'use strict';
 
+  //#region src/audio-output.ts
+  /** Media volume handles attenuation and fades; this shared graph adds amplification. */
+  var shared;
+  var maximumFloat = 34028234663852886e22;
+  function createAudioAmplifier(audio) {
+    if (typeof globalThis.AudioContext !== "function") throw new Error("Audio amplification requires Web Audio support.");
+    if (!shared || shared.context.state === "closed") shared = {
+      context: new AudioContext(),
+      users: 0
+    };
+    const owner = shared;
+    owner.users++;
+    let source;
+    let gain;
+    let released = false;
+    const dispose = () => {
+      if (released) return;
+      released = true;
+      source?.disconnect();
+      gain?.disconnect();
+      owner.users--;
+      if (owner.users === 0) {
+        if (shared === owner) shared = void 0;
+        owner.context.close().catch(() => {});
+      }
+    };
+    try {
+      source = owner.context.createMediaElementSource(audio);
+      gain = owner.context.createGain();
+      source.connect(gain);
+      gain.connect(owner.context.destination);
+    } catch (error) {
+      dispose();
+      throw error;
+    }
+    const node = gain;
+    return {
+      setGain(value) {
+        node.gain.value = Math.min(maximumFloat, Math.max(1, value));
+      },
+      resume() {
+        return owner.context.state === "running" ? Promise.resolve() : owner.context.resume();
+      },
+      dispose
+    };
+  }
+  //#endregion
+  //#region src/audio-playback.ts
+  function playbackGain(value) {
+    const gain = value === void 0 ? 1 : value;
+    if (typeof gain !== "number" || !Number.isFinite(gain) || gain < 0) throw new TypeError("Audio gain must be a finite non-negative number.");
+    return gain;
+  }
+  function rate(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < .25 || value > 4) throw new TypeError("Audio playback rate must be from 0.25 to 4.");
+    return value;
+  }
+  function validateAudioPlaybackOptions(options) {
+    if (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((key) => ![
+      "gain",
+      "muted",
+      "playbackRate",
+      "fadeIn",
+      "fadeOut"
+    ].includes(key))) throw new TypeError("Invalid audio playback options.");
+    playbackGain(options.gain);
+    if (options.muted !== void 0 && typeof options.muted !== "boolean") throw new TypeError("Audio muted must be a boolean.");
+    rate(options.playbackRate ?? 1);
+    fadeSeconds(options.fadeIn, "fadeIn");
+    fadeSeconds(options.fadeOut, "fadeOut");
+  }
+  function fadeSeconds(value, label) {
+    const seconds = value === void 0 ? 0 : value;
+    if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) throw new TypeError(`Audio ${label} must be a finite non-negative number of seconds.`);
+    return seconds;
+  }
+  function aborted() {
+    const error = /* @__PURE__ */ new Error("Audio playback was cancelled.");
+    error.name = "AbortError";
+    return error;
+  }
+  /** One reusable native element; the caller owns source resolution and resource release. */
+  function createBrowserAudioPlayback(audio, options, release, playbackError) {
+    validateAudioPlaybackOptions(options);
+    let gain = playbackGain(options.gain);
+    audio.volume = Math.min(1, gain);
+    audio.muted = options.muted ?? false;
+    audio.playbackRate = options.playbackRate ?? 1;
+    audio.loop = false;
+    const defaultFadeIn = fadeSeconds(options.fadeIn, "fadeIn");
+    const defaultFadeOut = fadeSeconds(options.fadeOut, "fadeOut");
+    let activeFadeIn = defaultFadeIn;
+    let activeFadeOut = defaultFadeOut;
+    let envelope = 1;
+    let fadeStarted = 0;
+    let playing = false;
+    let fadeTimer;
+    let stopping;
+    let amplifier;
+    const pendingGain = /* @__PURE__ */ new Set();
+    let disposed = false;
+    let generation = 0;
+    let ended = Promise.resolve();
+    let settle;
+    let rejectStart;
+    let detachAbort;
+    const pendingMetadata = /* @__PURE__ */ new Set();
+    const requireActive = () => {
+      if (disposed) throw new Error("Audio playback is disposed.");
+    };
+    const clearFadeTimer = () => {
+      if (fadeTimer !== void 0) clearTimeout(fadeTimer);
+      fadeTimer = void 0;
+    };
+    const finish = (error) => {
+      playing = false;
+      for (const reject of pendingGain) reject(error ?? aborted());
+      pendingGain.clear();
+      clearFadeTimer();
+      const previousStop = stopping;
+      stopping = void 0;
+      previousStop?.detach();
+      previousStop?.reject(error ?? aborted());
+      generation++;
+      rejectStart?.(error ?? aborted());
+      rejectStart = void 0;
+      detachAbort?.();
+      detachAbort = void 0;
+      settle?.(error);
+      settle = void 0;
+    };
+    const writeVolume = () => {
+      audio.volume = Math.min(1, gain) * envelope;
+      amplifier?.setGain(gain);
+    };
+    const prepareAmplifier = () => {
+      if (!amplifier && gain > 1) amplifier = createAudioAmplifier(audio);
+      writeVolume();
+    };
+    const stopNow = () => {
+      const completed = stopping;
+      stopping = void 0;
+      completed?.detach();
+      audio.pause();
+      audio.loop = false;
+      audio.currentTime = 0;
+      finish();
+      envelope = 1;
+      writeVolume();
+      completed?.resolve();
+    };
+    const refreshFade = () => {
+      clearFadeTimer();
+      if (disposed || !playing && !stopping) return;
+      const now = performance.now();
+      let delay = 16;
+      if (stopping) {
+        const progress = Math.min(1, (now - stopping.started) / (stopping.seconds * 1e3));
+        envelope = stopping.from * (1 - progress);
+        writeVolume();
+        if (progress >= 1) {
+          stopNow();
+          return;
+        }
+      } else {
+        const fadeIn = activeFadeIn === 0 ? 1 : Math.min(1, (now - fadeStarted) / (activeFadeIn * 1e3));
+        const remaining = Number.isFinite(audio.duration) ? Math.max(0, audio.duration - audio.currentTime) / audio.playbackRate : Infinity;
+        const fadeOut = !audio.loop && activeFadeOut > 0 ? Math.min(1, remaining / activeFadeOut) : 1;
+        envelope = Math.max(0, Math.min(fadeIn, fadeOut));
+        writeVolume();
+        if (fadeIn >= 1) {
+          if (audio.loop || activeFadeOut === 0) return;
+          if (!Number.isFinite(remaining)) delay = 250;
+          else if (remaining > activeFadeOut) delay = Math.min(250, Math.max(16, (remaining - activeFadeOut) * 1e3));
+        }
+      }
+      fadeTimer = setTimeout(refreshFade, delay);
+    };
+    const onEnded = () => {
+      if (stopping) {
+        stopNow();
+        return;
+      }
+      finish();
+      if (activeFadeOut > 0 && !audio.loop) {
+        envelope = 0;
+        writeVolume();
+      }
+    };
+    const onError = () => {
+      audio.pause();
+      const error = playbackError(audio.error ?? /* @__PURE__ */ new Error("The browser audio element reported a playback error."));
+      finish(error);
+      for (const complete of pendingMetadata) complete(error);
+    };
+    audio.addEventListener("ended", onEnded);
+    audio.addEventListener("error", onError);
+    for (const event of [
+      "durationchange",
+      "ratechange",
+      "seeked"
+    ]) audio.addEventListener(event, refreshFade);
+    return Object.freeze({
+      get ended() {
+        return ended;
+      },
+      get currentTime() {
+        return audio.currentTime;
+      },
+      get paused() {
+        return audio.paused;
+      },
+      get loop() {
+        return audio.loop;
+      },
+      get gain() {
+        return gain;
+      },
+      get muted() {
+        return audio.muted;
+      },
+      get playbackRate() {
+        return audio.playbackRate;
+      },
+      async play(playOptions = {}) {
+        requireActive();
+        if (!playOptions || typeof playOptions !== "object" || Array.isArray(playOptions) || Object.keys(playOptions).some((key) => ![
+          "restart",
+          "loop",
+          "signal",
+          "fadeIn",
+          "fadeOut",
+          "gain"
+        ].includes(key)) || playOptions.restart !== void 0 && typeof playOptions.restart !== "boolean" || playOptions.loop !== void 0 && typeof playOptions.loop !== "boolean") throw new TypeError("Invalid audio play options.");
+        const fadeIn = fadeSeconds(playOptions.fadeIn === void 0 ? defaultFadeIn : playOptions.fadeIn, "fadeIn");
+        const fadeOut = fadeSeconds(playOptions.fadeOut === void 0 ? defaultFadeOut : playOptions.fadeOut, "fadeOut");
+        const nextGain = playOptions.gain === void 0 ? gain : playbackGain(playOptions.gain);
+        const signal = playOptions.signal;
+        if (signal?.aborted) throw aborted();
+        finish();
+        const run = generation;
+        gain = nextGain;
+        if (playOptions.restart) audio.currentTime = 0;
+        audio.loop = playOptions.loop ?? audio.loop;
+        activeFadeIn = fadeIn;
+        activeFadeOut = fadeOut;
+        envelope = fadeIn > 0 ? 0 : 1;
+        writeVolume();
+        ended = new Promise((resolve, reject) => {
+          settle = (error) => error === void 0 ? resolve() : reject(error);
+        });
+        ended.catch(() => {});
+        const onAbort = () => {
+          audio.pause();
+          finish(aborted());
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        detachAbort = () => signal?.removeEventListener("abort", onAbort);
+        try {
+          prepareAmplifier();
+          const started = audio.play();
+          const ready = amplifier ? Promise.all([started, amplifier.resume()]) : Promise.resolve(started);
+          await Promise.race([ready, new Promise((_resolve, reject) => {
+            rejectStart = reject;
+          })]);
+          if (run !== generation) throw aborted();
+          rejectStart = void 0;
+          playing = true;
+          fadeStarted = performance.now();
+          refreshFade();
+        } catch (cause) {
+          if (run !== generation) throw cause;
+          audio.pause();
+          const error = playbackError(cause);
+          finish(error);
+          throw error;
+        }
+      },
+      pause() {
+        requireActive();
+        audio.pause();
+        finish();
+      },
+      stop(stopOptions = {}) {
+        requireActive();
+        if (!stopOptions || typeof stopOptions !== "object" || Array.isArray(stopOptions) || Object.keys(stopOptions).some((key) => !["fadeOut", "signal"].includes(key))) throw new TypeError("Invalid audio stop options.");
+        const seconds = fadeSeconds(stopOptions.fadeOut === void 0 ? activeFadeOut : stopOptions.fadeOut, "fadeOut");
+        const signal = stopOptions.signal;
+        if (signal?.aborted) throw aborted();
+        if (seconds === 0 || audio.paused || !playing) {
+          stopNow();
+          return;
+        }
+        const previous = stopping;
+        stopping = void 0;
+        previous?.detach();
+        previous?.reject(aborted());
+        return new Promise((resolve, reject) => {
+          const onAbort = () => {
+            const current = stopping;
+            stopping = void 0;
+            current?.detach();
+            stopNow();
+            reject(aborted());
+          };
+          stopping = {
+            started: performance.now(),
+            seconds,
+            from: envelope,
+            resolve,
+            reject,
+            detach: () => signal?.removeEventListener("abort", onAbort)
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
+          if (signal?.aborted) onAbort();
+          else refreshFade();
+        });
+      },
+      async seek(seconds, signal) {
+        requireActive();
+        if (!Number.isFinite(seconds) || seconds < 0) throw new TypeError("Audio seek time must be non-negative.");
+        if (signal?.aborted) throw aborted();
+        if (audio.readyState < 1) await new Promise((resolve, reject) => {
+          const complete = (error) => {
+            clearTimeout(timer);
+            audio.removeEventListener("loadedmetadata", ready);
+            signal?.removeEventListener("abort", cancel);
+            pendingMetadata.delete(complete);
+            if (error === void 0) resolve();
+            else reject(error);
+          };
+          const ready = () => complete();
+          const cancel = () => complete(aborted());
+          const timer = setTimeout(() => complete(/* @__PURE__ */ new Error("Audio metadata did not become ready.")), 1e4);
+          pendingMetadata.add(complete);
+          audio.addEventListener("loadedmetadata", ready, { once: true });
+          signal?.addEventListener("abort", cancel, { once: true });
+          if (signal?.aborted) cancel();
+          else if (audio.readyState >= 1) ready();
+        });
+        requireActive();
+        if (signal?.aborted) throw aborted();
+        if (Number.isFinite(audio.duration) && seconds > audio.duration) throw new RangeError("Audio seek exceeds its duration.");
+        audio.currentTime = seconds;
+        refreshFade();
+      },
+      setGain(value) {
+        const normalized = playbackGain(value);
+        requireActive();
+        const previous = gain;
+        gain = normalized;
+        try {
+          if (playing) prepareAmplifier();
+          else writeVolume();
+        } catch (error) {
+          gain = previous;
+          writeVolume();
+          throw playbackError(error);
+        }
+        if (playing && amplifier) {
+          const run = generation;
+          let rejectResume;
+          const cancelled = new Promise((_resolve, reject) => {
+            rejectResume = reject;
+          });
+          pendingGain.add(rejectResume);
+          return Promise.race([amplifier.resume(), cancelled]).catch((cause) => {
+            if (run !== generation) throw cause;
+            audio.pause();
+            const error = playbackError(cause);
+            finish(error);
+            throw error;
+          }).finally(() => pendingGain.delete(rejectResume));
+        }
+      },
+      setMuted(value) {
+        if (typeof value !== "boolean") throw new TypeError("Audio muted must be a boolean.");
+        requireActive();
+        audio.muted = value;
+      },
+      setPlaybackRate(value) {
+        const normalized = rate(value);
+        requireActive();
+        audio.playbackRate = normalized;
+        refreshFade();
+      },
+      dispose() {
+        if (disposed) return;
+        disposed = true;
+        try {
+          audio.pause();
+          audio.currentTime = 0;
+        } catch {}
+        finish();
+        for (const complete of pendingMetadata) complete(aborted());
+        audio.removeEventListener("ended", onEnded);
+        audio.removeEventListener("error", onError);
+        for (const event of [
+          "durationchange",
+          "ratechange",
+          "seeked"
+        ]) audio.removeEventListener(event, refreshFade);
+        try {
+          audio.removeAttribute?.("src");
+          audio.load?.();
+        } finally {
+          try {
+            amplifier?.dispose();
+          } finally {
+            release();
+          }
+        }
+      }
+    });
+  }
   var block_definitions_default = {
     extensionName: "Asset Cache",
     blocks: [
@@ -287,7 +702,404 @@
     ]
   };
   //#endregion
-  //#region node_modules/.pnpm/@kubohiroya+turbowarp-named-data@0.1.0/node_modules/@kubohiroya/turbowarp-named-data/dist/composition.js
+  //#region node_modules/.pnpm/@kubohiroya+turbowarp-extension-data-editor@0.2.1_react@18.3.1/node_modules/@kubohiroya/turbowarp-extension-data-editor/dist/fixed-input-schema.js
+  var numberToken = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
+  var invalidNumber = Object.freeze({
+    kind: "invalid",
+    code: "fixed-number-input-invalid"
+  });
+  /**
+  * Parse a NEW numeric draft according to NP-finite-new-input-v1.
+  * Never apply this to opening/no-op raw values or use it as an owner validator.
+  * Keep the validated token so negative zero, precision and exponent spelling survive.
+  */
+  function parseFixedNumberInput(input) {
+    if (typeof input === "number") {
+      if (!Number.isFinite(input)) return invalidNumber;
+      return Object.freeze({
+        kind: "valid",
+        token: Object.is(input, -0) ? "-0" : String(input),
+        value: input
+      });
+    }
+    if (typeof input !== "string") return invalidNumber;
+    const token = input.trim();
+    if (!numberToken.test(token)) return invalidNumber;
+    const value = Number(token);
+    return Number.isFinite(value) ? Object.freeze({
+      kind: "valid",
+      token,
+      value
+    }) : invalidNumber;
+  }
+  var block_editor_fixed_inputs_schema_default = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://kubohiroya.github.io/turbowarp-asset-cache/schemas/block-editor-fixed-inputs.schema.json",
+    $defs: {
+      "setTextStyle": {
+        "type": "object",
+        "properties": {
+          "PROPERTY": {
+            "type": "string",
+            "enum": [
+              "animation",
+              "font",
+              "color",
+              "width",
+              "align"
+            ]
+          },
+          "VALUE": { "type": "string" }
+        },
+        "additionalProperties": false
+      },
+      "animation": {
+        "type": "string",
+        "enum": [
+          "",
+          "none",
+          "type",
+          "rainbow",
+          "zoom",
+          "shake"
+        ]
+      },
+      "font": { "type": "string" },
+      "color": {
+        "type": "string",
+        "pattern": "^(?:|#[0-9a-fA-F]{3}|#[0-9a-fA-F]{6})$"
+      },
+      "width": {
+        "type": "string",
+        "$comment": "Empty/trimmed empty resets; otherwise normalizeTextStyleValue requires Number(value) finite and positive. Preserve the existing STRING grammar, including hexadecimal and leading plus."
+      },
+      "align": {
+        "type": "string",
+        "enum": [
+          "",
+          "left",
+          "center",
+          "right"
+        ]
+      },
+      "loadingCostumeAt": {
+        "type": "object",
+        "properties": { "INDEX": { "type": "number" } },
+        "additionalProperties": false
+      }
+    }
+  };
+  //#endregion
+  //#region src/fixed-input-schema.ts
+  /** Canonical owner schema fragments; no network resources or runtime providers. */
+  function fixedInputBundle(fragment, schema) {
+    const source = {
+      repository: "turbowarp-asset-cache",
+      path: "schemas/block-editor-fixed-inputs.schema.json",
+      symbol: {
+        "setTextStyle-PROPERTY": "#/$defs/setTextStyle/properties/PROPERTY",
+        "setTextStyle-VALUE": "#/$defs/setTextStyle/properties/VALUE",
+        "loadingCostumeAt-INDEX": "#/$defs/loadingCostumeAt/properties/INDEX"
+      }[fragment] ?? `#/$defs/${fragment}`
+    };
+    return {
+      identity: {
+        ownerId: "turbowarp-asset-cache",
+        contractId: "fixed-inputs",
+        revision: "1",
+        variantId: fragment
+      },
+      dialect: "2020-12",
+      root: {
+        retrievalUri: block_editor_fixed_inputs_schema_default.$id,
+        document: schema,
+        artifact: {
+          role: "canonical-schema",
+          source
+        }
+      },
+      resources: [],
+      provenance: {
+        canonicalSources: [
+          source,
+          {
+            repository: "turbowarp-asset-cache",
+            path: "src/text-style.ts",
+            symbol: "normalizeTextStyleProperty / normalizeTextStyleValue"
+          },
+          {
+            repository: "turbowarp-asset-cache",
+            path: "src/extension.ts",
+            symbol: "getInfo / loadingCostumeAt"
+          }
+        ],
+        generatedFiles: [],
+        referenceSchemas: [],
+        generationSources: []
+      }
+    };
+  }
+  var fixedSchemas = block_editor_fixed_inputs_schema_default.$defs;
+  //#endregion
+  //#region src/text-style.ts
+  var TEXT_RUNTIME_NAMESPACE = "text";
+  var TEXT_STYLE_RUNTIME_NAMESPACE = "textStyle";
+  var TEXT_STYLE_PROPERTIES = [
+    "animation",
+    "font",
+    "color",
+    "width",
+    "align"
+  ];
+  var DEFAULT_STAGE_WIDTH = 480;
+  var DEFAULT_FONT = "Handwriting";
+  var DEFAULT_COLOR = "#ffffff";
+  var DEFAULT_ALIGNMENT = "center";
+  var DEFAULT_OUTLINE_COLOR = "#000000";
+  function textRuntimeVariableName(name) {
+    return `${TEXT_RUNTIME_NAMESPACE}:${name}`;
+  }
+  function textStyleRuntimeVariableName(name, property) {
+    return `${TEXT_STYLE_RUNTIME_NAMESPACE}:${name}:${property}`;
+  }
+  function normalizeTextStyleProperty(value) {
+    const property = String(value ?? "").trim().toLowerCase();
+    if (TEXT_STYLE_PROPERTIES.includes(property)) return property;
+    throw new Error(`Unknown text style property: ${property || "(empty)"}`);
+  }
+  /**
+  * Normalize a DSL-facing style value for runtime-variable storage.
+  * An empty value intentionally resets the property to its default.
+  */
+  function normalizeTextStyleValue(property, value) {
+    const raw = String(value ?? "").trim();
+    if (!raw) return "";
+    switch (property) {
+      case "animation": {
+        const animation = raw.toLowerCase() === "typing" ? "type" : raw.toLowerCase();
+        if (animation === "none" || animation === "type" || animation === "rainbow" || animation === "zoom" || animation === "shake") return animation;
+        throw new Error(`Invalid text animation: ${raw}`);
+      }
+      case "font": return raw;
+      case "color": {
+        if (/^#[0-9a-f]{6}$/i.test(raw)) return raw.toLowerCase();
+        const shortColor = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(raw);
+        if (shortColor) return `#${shortColor[1]}${shortColor[1]}${shortColor[2]}${shortColor[2]}${shortColor[3]}${shortColor[3]}`.toLowerCase();
+        throw new Error(`Invalid text color: ${raw}`);
+      }
+      case "width": {
+        const width = Number(raw);
+        if (!Number.isFinite(width) || width <= 0) throw new Error(`Text width must be a positive number: ${raw}`);
+        return String(width);
+      }
+      case "align": {
+        const align = raw.toLowerCase();
+        if (align === "left" || align === "center" || align === "right") return align;
+        throw new Error(`Invalid text alignment: ${raw}`);
+      }
+    }
+  }
+  function resolveTextStyle(name, stageWidth, getRuntimeVariable) {
+    const width = Number(stageWidth);
+    const defaults = {
+      animation: "none",
+      font: DEFAULT_FONT,
+      color: DEFAULT_COLOR,
+      width: Number.isFinite(width) && width > 0 ? width : DEFAULT_STAGE_WIDTH,
+      align: DEFAULT_ALIGNMENT
+    };
+    const read = (property) => normalizeTextStyleValue(property, getRuntimeVariable(textStyleRuntimeVariableName(name, property)));
+    const animation = read("animation");
+    const font = read("font");
+    const color = read("color");
+    const configuredWidth = read("width");
+    const align = read("align");
+    return {
+      animation: animation ? animation : defaults.animation,
+      font: font || defaults.font,
+      color: color || defaults.color,
+      width: configuredWidth ? Number(configuredWidth) : defaults.width,
+      align: align ? align : defaults.align
+    };
+  }
+  //#endregion
+  //#region src/fixed-input-editors.ts
+  var extensionId = "kubohiroyaassetcache";
+  var choices = (values) => values.map((value) => ({ value }));
+  var context = () => ({
+    consumerId: "turbowarp-asset-cache",
+    nowMs: 0,
+    settings: null
+  });
+  var string = (value) => {
+    if (typeof value !== "string") throw new TypeError("Expected a string literal.");
+    return value;
+  };
+  var issue = () => [{ message: "Invalid asset style value." }];
+  /** New edits preserve the candidate token; existing aliases are display projections only. */
+  function styleBinding(property) {
+    const values = property === "animation" ? [
+      "",
+      "none",
+      "type",
+      "rainbow",
+      "zoom",
+      "shake"
+    ] : property === "align" ? [
+      "",
+      "left",
+      "center",
+      "right"
+    ] : void 0;
+    return {
+      argument: "VALUE",
+      schemaBundle: fixedInputBundle(property, fixedSchemas[property]),
+      control: {
+        kind: values ? "enum" : property === "color" ? "color" : property === "width" ? "number" : "text",
+        reset: "",
+        ...values ? { choices: choices(values) } : {}
+      },
+      read(value) {
+        return normalizeTextStyleValue(property, string(value));
+      },
+      encode(value) {
+        const raw = string(value);
+        if (property !== "width" || raw === "") return raw;
+        normalizeTextStyleValue(property, raw);
+        return raw;
+      },
+      validateCandidate(value) {
+        try {
+          normalizeTextStyleValue(property, string(value));
+          return [];
+        } catch {
+          return issue();
+        }
+      }
+    };
+  }
+  var fixedInputEditors = [{
+    apiVersion: 1,
+    extensionId,
+    editorId: "text-style-fixed",
+    opcodes: [`${extensionId}_setTextStyle`],
+    contractId: "CP-asset-cache",
+    contractRevision: "1",
+    validationContext: context,
+    bindings: [{
+      argument: "PROPERTY",
+      schemaBundle: fixedInputBundle("setTextStyle-PROPERTY", fixedSchemas.setTextStyle.properties.PROPERTY),
+      control: {
+        kind: "enum",
+        choices: choices(TEXT_STYLE_PROPERTIES)
+      },
+      read(value) {
+        const raw = string(value);
+        try {
+          return normalizeTextStyleProperty(raw);
+        } catch {
+          return raw;
+        }
+      },
+      encode: (value) => string(value),
+      validateCandidate(value) {
+        try {
+          normalizeTextStyleProperty(value);
+          return [];
+        } catch {
+          return issue();
+        }
+      }
+    }, {
+      argument: "VALUE",
+      schemaBundle: fixedInputBundle("setTextStyle-VALUE", fixedSchemas.setTextStyle.properties.VALUE),
+      read: (value) => string(value),
+      encode: (value) => string(value),
+      validateCandidate: () => []
+    }],
+    dependencies: [{
+      selector: "PROPERTY",
+      dependents: ["VALUE"]
+    }],
+    branchPolicies: [{
+      selector: "PROPERTY",
+      normalize: {
+        trim: true,
+        lowercase: true
+      },
+      cases: TEXT_STYLE_PROPERTIES.map((property) => ({
+        values: [property],
+        activeDependents: ["VALUE"],
+        bindings: [styleBinding(property)]
+      }))
+    }]
+  }, {
+    apiVersion: 1,
+    extensionId,
+    editorId: "loading-costume-index-fixed",
+    opcodes: [`${extensionId}_loadingCostumeAt`],
+    contractId: "turbowarp-asset-cache/loadingCostumeAt.INDEX",
+    contractRevision: "1",
+    validationContext: context,
+    bindings: [{
+      argument: "INDEX",
+      schemaBundle: fixedInputBundle("loadingCostumeAt-INDEX", fixedSchemas.loadingCostumeAt.properties.INDEX),
+      control: { kind: "number" },
+      read(value) {
+        if (typeof value !== "number" && typeof value !== "string" || typeof value === "string" && value.trim() === "") throw new TypeError("Non-numeric index.");
+        const number = Number(value);
+        if (!Number.isFinite(number)) throw new TypeError("Nonfinite index.");
+        return number;
+      },
+      encode(value) {
+        const parsed = parseFixedNumberInput(value);
+        if (parsed.kind !== "valid") throw new TypeError("Invalid index.");
+        return parsed.token;
+      },
+      validateCandidate(value) {
+        return Number.isFinite(Number(value)) ? [] : [{ message: "Invalid index." }];
+      }
+    }]
+  }];
+  /** Per-instance, idempotent registration. Legacy hosts never acquire the fixed capability. */
+  function fixedInputRegistration(scratch) {
+    const host = scratch;
+    let active;
+    let removers = [];
+    let disposed = false;
+    const dispose = () => {
+      host.vm?.runtime?.off?.("RUNTIME_DISPOSED", shutdown);
+      for (const remove of removers.splice(0).reverse()) remove();
+      active = void 0;
+    };
+    const shutdown = () => {
+      disposed = true;
+      dispose();
+    };
+    return {
+      ensure(opcodes) {
+        const api = host.gui?.blockEditors;
+        if (disposed || api === active) return;
+        dispose();
+        if (api?.apiVersion !== 1 || typeof api.registerFixedInputEditor !== "function") return;
+        try {
+          for (const definition of fixedInputEditors) if (definition.opcodes.every((opcode) => opcodes.includes(opcode))) {
+            const remove = api.registerFixedInputEditor.call(api, definition);
+            if (typeof remove !== "function") throw new TypeError("Invalid fixed registration cleanup.");
+            removers.push(remove);
+          }
+          active = api;
+          host.vm?.runtime?.on?.("RUNTIME_DISPOSED", shutdown);
+        } catch (error) {
+          dispose();
+          throw error;
+        }
+      },
+      dispose: shutdown
+    };
+  }
+  //#endregion
+  //#region node_modules/.pnpm/@kubohiroya+turbowarp-named-data@0.3.1/node_modules/@kubohiroya/turbowarp-named-data/dist/composition.js
   var NAMED_DATA_REGISTRY_SYMBOL_KEY = "@kubohiroya/turbowarp-named-data/registry";
   var NAMED_DATA_REGISTRY_SYMBOL = Symbol.for(NAMED_DATA_REGISTRY_SYMBOL_KEY);
   var NAMED_DATA_NAMESPACE_PATTERN = /^[a-z][a-z0-9.-]{0,63}$/u;
@@ -308,6 +1120,8 @@
     "markdown",
     "raw"
   ];
+  var NAMED_DATA_SCHEMA_ID_PATTERN = /^[a-z][a-z0-9.-]{0,127}$/u;
+  var NAMED_DATA_SCHEMA_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/u;
   var NAMED_DATA_ERROR_CODES = [
     "NAMED_DATA_INVALID_REF",
     "NAMED_DATA_INVALID_REGISTRY",
@@ -316,6 +1130,9 @@
     "NAMED_DATA_NOT_FOUND",
     "NAMED_DATA_KIND_MISMATCH",
     "NAMED_DATA_SCOPE_MISMATCH",
+    "NAMED_DATA_SCHEMA_NOT_FOUND",
+    "NAMED_DATA_SCHEMA_VERSION_MISMATCH",
+    "NAMED_DATA_SCHEMA_UNRESOLVED",
     "NAMED_DATA_REPRESENTATION_UNSUPPORTED",
     "NAMED_DATA_INVALID_METADATA",
     "NAMED_DATA_BODY_TOO_LARGE",
@@ -536,9 +1353,21 @@
     if (!reference || typeof reference !== "object") throw invalidReference$1();
     requireNamespace(reference.namespace);
     if (typeof reference.name !== "string" || reference.name.length === 0 || reference.name.length > 256 || containsControlCharacter(reference.name) || !NAMED_DATA_KINDS.includes(reference.kind) || !NAMED_DATA_SCOPES.includes(reference.scope) || !NAMED_DATA_REPRESENTATIONS.includes(representation)) throw invalidReference$1();
+    if (reference.schemaRef !== void 0) validateSchemaRef(reference.kind, reference.schemaRef);
   }
   function validateMetadata(metadata, reference, representation) {
     if (metadata.representation !== representation || !isNativeRepresentation(metadata.reference.kind, metadata.nativeRepresentation) || metadata.reference.namespace !== reference.namespace || metadata.reference.name !== reference.name || metadata.reference.kind !== reference.kind || metadata.reference.scope !== reference.scope || typeof metadata.mediaType !== "string" || metadata.mediaType.length === 0 || typeof metadata.revision !== "string" || metadata.revision.length === 0 || typeof metadata.replayable !== "boolean" || metadata.byteLength !== void 0 && (!Number.isSafeInteger(metadata.byteLength) || metadata.byteLength < 0) || metadata.digest !== void 0 && !/^sha256-[A-Za-z0-9_-]+$/u.test(metadata.digest)) throw new NamedDataError("NAMED_DATA_INVALID_METADATA", "Provider returned invalid metadata.");
+    const expectedSchema = reference.schemaRef;
+    const actualSchema = metadata.schemaRef;
+    if (actualSchema !== void 0) validateSchemaRef(metadata.reference.kind, actualSchema, "NAMED_DATA_INVALID_METADATA");
+    if (metadata.reference.schemaRef !== void 0) validateSchemaRef(metadata.reference.kind, metadata.reference.schemaRef, "NAMED_DATA_INVALID_METADATA");
+    if (!sameSchemaRef(expectedSchema, actualSchema) || !sameSchemaRef(expectedSchema, metadata.reference.schemaRef)) throw new NamedDataError("NAMED_DATA_SCHEMA_VERSION_MISMATCH", "Provider schemaRef does not match the requested reference.");
+  }
+  function validateSchemaRef(kind, schemaRef, errorCode = "NAMED_DATA_INVALID_REF") {
+    if (kind !== "structured" || typeof schemaRef !== "object" || schemaRef === null || !NAMED_DATA_SCHEMA_ID_PATTERN.test(String(schemaRef.id ?? "")) || !NAMED_DATA_SCHEMA_VERSION_PATTERN.test(String(schemaRef.version ?? "")) || Object.keys(schemaRef).some((key) => key !== "id" && key !== "version")) throw new NamedDataError(errorCode, "Invalid schemaRef; schema references require a structured value, stable id, and full SemVer version.");
+  }
+  function sameSchemaRef(left, right) {
+    return left === void 0 ? right === void 0 : right !== void 0 && left.id === right.id && left.version === right.version;
   }
   function isNativeRepresentation(kind, representation) {
     if (kind === "structured") return representation === "json" || representation === "yaml";
@@ -575,7 +1404,10 @@
     const value = globalThis.__TW_NAMED_DATA_FEATURE_FLAGS__?.[name];
     return value === true || value === "true";
   }
-  Object.freeze({ NAMED_DATA_REGISTRY_MVP: configuredFlag$1("NAMED_DATA_REGISTRY_MVP") });
+  Object.freeze({
+    NAMED_DATA_REGISTRY_MVP: configuredFlag$1("NAMED_DATA_REGISTRY_MVP"),
+    NAMED_DATA_SCHEMA_REF: configuredFlag$1("NAMED_DATA_SCHEMA_REF")
+  });
   //#endregion
   //#region \0@oxc-project+runtime@0.148.0/helpers/esm/typeof.js
   function _typeof(o) {
@@ -994,88 +1826,6 @@
     if (signal?.aborted) throw namedBodyAbortError();
   }
   //#endregion
-  //#region src/text-style.ts
-  var TEXT_RUNTIME_NAMESPACE = "text";
-  var TEXT_STYLE_RUNTIME_NAMESPACE = "textStyle";
-  var TEXT_STYLE_PROPERTIES = [
-    "animation",
-    "font",
-    "color",
-    "width",
-    "align"
-  ];
-  var DEFAULT_STAGE_WIDTH = 480;
-  var DEFAULT_FONT = "Handwriting";
-  var DEFAULT_COLOR = "#ffffff";
-  var DEFAULT_ALIGNMENT = "center";
-  var DEFAULT_OUTLINE_COLOR = "#000000";
-  function textRuntimeVariableName(name) {
-    return `${TEXT_RUNTIME_NAMESPACE}:${name}`;
-  }
-  function textStyleRuntimeVariableName(name, property) {
-    return `${TEXT_STYLE_RUNTIME_NAMESPACE}:${name}:${property}`;
-  }
-  function normalizeTextStyleProperty(value) {
-    const property = String(value ?? "").trim().toLowerCase();
-    if (TEXT_STYLE_PROPERTIES.includes(property)) return property;
-    throw new Error(`Unknown text style property: ${property || "(empty)"}`);
-  }
-  /**
-  * Normalize a DSL-facing style value for runtime-variable storage.
-  * An empty value intentionally resets the property to its default.
-  */
-  function normalizeTextStyleValue(property, value) {
-    const raw = String(value ?? "").trim();
-    if (!raw) return "";
-    switch (property) {
-      case "animation": {
-        const animation = raw.toLowerCase() === "typing" ? "type" : raw.toLowerCase();
-        if (animation === "none" || animation === "type" || animation === "rainbow" || animation === "zoom" || animation === "shake") return animation;
-        throw new Error(`Invalid text animation: ${raw}`);
-      }
-      case "font": return raw;
-      case "color": {
-        if (/^#[0-9a-f]{6}$/i.test(raw)) return raw.toLowerCase();
-        const shortColor = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(raw);
-        if (shortColor) return `#${shortColor[1]}${shortColor[1]}${shortColor[2]}${shortColor[2]}${shortColor[3]}${shortColor[3]}`.toLowerCase();
-        throw new Error(`Invalid text color: ${raw}`);
-      }
-      case "width": {
-        const width = Number(raw);
-        if (!Number.isFinite(width) || width <= 0) throw new Error(`Text width must be a positive number: ${raw}`);
-        return String(width);
-      }
-      case "align": {
-        const align = raw.toLowerCase();
-        if (align === "left" || align === "center" || align === "right") return align;
-        throw new Error(`Invalid text alignment: ${raw}`);
-      }
-    }
-  }
-  function resolveTextStyle(name, stageWidth, getRuntimeVariable) {
-    const width = Number(stageWidth);
-    const defaults = {
-      animation: "none",
-      font: DEFAULT_FONT,
-      color: DEFAULT_COLOR,
-      width: Number.isFinite(width) && width > 0 ? width : DEFAULT_STAGE_WIDTH,
-      align: DEFAULT_ALIGNMENT
-    };
-    const read = (property) => normalizeTextStyleValue(property, getRuntimeVariable(textStyleRuntimeVariableName(name, property)));
-    const animation = read("animation");
-    const font = read("font");
-    const color = read("color");
-    const configuredWidth = read("width");
-    const align = read("align");
-    return {
-      animation: animation ? animation : defaults.animation,
-      font: font || defaults.font,
-      color: color || defaults.color,
-      width: configuredWidth ? Number(configuredWidth) : defaults.width,
-      align: align ? align : defaults.align
-    };
-  }
-  //#endregion
   //#region src/extension.ts
   var EXTENSION_ID = "kubohiroyaassetcache";
   var EXTENSION_VERSION = "0.14.0";
@@ -1540,6 +2290,7 @@
       _defineProperty(this, "textAssets", /* @__PURE__ */ new Map());
       _defineProperty(this, "assetRegistry", /* @__PURE__ */ new Map());
       _defineProperty(this, "displayedAssets", /* @__PURE__ */ new Map());
+      _defineProperty(this, "explicitAudio", /* @__PURE__ */ new WeakSet());
       _defineProperty(this, "playingAudio", /* @__PURE__ */ new Map());
       _defineProperty(this, "audioVoiceStops", /* @__PURE__ */ new WeakMap());
       _defineProperty(this, "registrationVersions", /* @__PURE__ */ new Map());
@@ -1581,6 +2332,7 @@
         this.unbindNamedDataRegistryLifecycle?.();
         this.unbindNamedDataRegistryLifecycle = void 0;
       });
+      _defineProperty(this, "fixedEditors", fixedInputRegistration(Scratch));
       this.featureFlags = Object.freeze({ ...featureFlags });
       if (this.featureFlags.NAMED_ASSET_BODY_PROVIDER) {
         this.namedBodyProviderValue = this.createNamedBodyProvider();
@@ -1646,6 +2398,8 @@
       return loadingCostumes[((Number.isFinite(numericIndex) ? Math.max(1, Math.trunc(numericIndex)) : 1) - 1) % loadingCostumes.length];
     }
     getInfo() {
+      const blocks = blockDefinitions.map((block) => this.toScratchBlock(block));
+      this.fixedEditors.ensure(blocks.map((block) => `${EXTENSION_ID}_${block.opcode}`));
       return {
         id: EXTENSION_ID,
         name: Scratch.translate(block_definitions_default.extensionName),
@@ -1654,9 +2408,13 @@
         color1: "#5b7cfa",
         color2: "#425ed8",
         color3: "#2f46aa",
-        blocks: blockDefinitions.map((block) => this.toScratchBlock(block))
+        blocks
       };
     }
+    /** Release only this optional editor registration; runtime data remains unchanged. */
+    dispose() {
+      this.fixedEditors.dispose();
+    }
     /**
     * Exposes the stock extension registry through a host-neutral DOM image
     * resource contract for other unsandboxed extensions.
@@ -1904,6 +2662,50 @@
       await playback.started;
       return playback.voice;
     }
+    async createAudioPlayback(source, options = {}, onDispose = () => {}) {
+      validateAudioPlaybackOptions(options);
+      if (!source || typeof source !== "object" || Array.isArray(source) || Object.keys(source).length !== 1 || Object.hasOwn(source, "asset") === Object.hasOwn(source, "url")) throw new TypeError("Audio requires exactly one asset or URL.");
+      if (Object.hasOwn(source, "url")) {
+        if (typeof source.url !== "string" || !/^https?:\/\/[^\s]+$/u.test(source.url)) throw new TypeError("Audio URL must use HTTP(S) without credentials.");
+        const url = new URL(source.url);
+        if (!url.hostname || url.username || url.password) throw new TypeError("Invalid audio URL.");
+        return this.prepareBrowserAudio("", source.url, options, onDispose, "createAudioPlayback");
+      }
+      const name = normalizeName(source.asset);
+      const version = this.registrationVersions.get(name);
+      const resource = await this.resolveAudioBytes(name);
+      if (!this.assetRegistry.has(name) || version !== this.registrationVersions.get(name)) throw new Error("Audio source was released or replaced while preparing.");
+      const bytes = resource.bytes instanceof Uint8Array ? new Uint8Array(resource.bytes).buffer : resource.bytes;
+      const url = URL.createObjectURL(new Blob([bytes], { type: resource.mimeType }));
+      return this.prepareBrowserAudio(name, url, options, () => {
+        URL.revokeObjectURL(url);
+        onDispose();
+      }, "createAudioPlayback");
+    }
+    prepareBrowserAudio(name, url, options, release, operation) {
+      let audio;
+      let controller;
+      try {
+        const directAudio = operation === "createAudioPlayback" && /^https?:/u.test(url);
+        audio = directAudio ? new Audio() : new Audio(url);
+        if (directAudio) {
+          audio.crossOrigin = "anonymous";
+          audio.src = url;
+        }
+        controller = createBrowserAudioPlayback(audio, options, () => {
+          this.playingAudio.delete(audio);
+          this.audioVoiceStops.delete(audio);
+          release();
+        }, (cause) => this.playbackError(name, cause, operation));
+      } catch (cause) {
+        release();
+        throw this.playbackError(name, cause, operation);
+      }
+      if (operation === "createAudioPlayback") this.explicitAudio.add(audio);
+      this.playingAudio.set(audio, name);
+      this.audioVoiceStops.set(audio, () => controller.dispose());
+      return controller;
+    }
     stopSound(args) {
       const name = normalizeName(args.NAME);
       const kind = this.assetRegistry.get(name);
@@ -1913,12 +2715,12 @@
         if (!asset) throw this.assetNotRegistered("stopSound", name);
         asset.mimeType = normalizeMimeType(asset.mimeType, asset.url || name);
         if (!asset.mimeType.startsWith("audio/")) throw this.assetTypeMismatch("stopSound", name, "audio", `external/${this.externalMediaKind(asset)}`);
-        for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name) this.stopExternalAudio(audio);
+        for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name && !this.explicitAudio.has(audio)) this.stopExternalAudio(audio);
         return;
       }
       if (kind === "sound") {
         const { target, sound, soundBank } = this.resolveSoundReference(name);
-        for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name) this.stopExternalAudio(audio);
+        for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name && !this.explicitAudio.has(audio)) this.stopExternalAudio(audio);
         soundBank.stop(target, sound.soundId);
         return;
       }
@@ -2166,6 +2968,7 @@
     }
     unregisterAsset(name) {
       this.cancelRegistrations(name);
+      for (const [audio, assetName] of [...this.playingAudio]) if (assetName === name) this.stopExternalAudio(audio);
       this.invalidateDOMImageResources(name);
       const kind = this.assetRegistry.get(name);
       if (!kind) return;
@@ -2981,73 +3784,33 @@
     }
     startBrowserAudioVoice(name, bytes, mimeType, initialGain, operation) {
       const blobBytes = bytes instanceof Uint8Array ? new Uint8Array(bytes).buffer : bytes;
-      const objectUrl = URL.createObjectURL(new Blob([blobBytes], { type: mimeType }));
-      let audio;
-      try {
-        audio = new Audio(objectUrl);
-        audio.volume = initialGain;
-      } catch (error) {
-        URL.revokeObjectURL(objectUrl);
-        throw this.playbackError(name, error, operation);
-      }
+      const url = URL.createObjectURL(new Blob([blobBytes], { type: mimeType }));
+      const controller = this.prepareBrowserAudio(name, url, { gain: initialGain }, () => URL.revokeObjectURL(url), operation);
       let active = true;
-      let resolveEnded;
-      let rejectEnded;
-      const ended = new Promise((resolve, reject) => {
-        resolveEnded = resolve;
-        rejectEnded = reject;
-      });
-      ended.catch(() => {});
-      const cleanup = (error) => {
-        if (!active) return;
-        active = false;
-        audio.removeEventListener("ended", handleEnded);
-        audio.removeEventListener("error", handleError);
-        this.playingAudio.delete(audio);
-        this.audioVoiceStops.delete(audio);
-        URL.revokeObjectURL(objectUrl);
-        if (error === void 0) resolveEnded();
-        else rejectEnded(error);
-      };
-      const handleEnded = () => cleanup();
-      const handleError = () => cleanup(operation === "createAudioVoice" ? this.playbackError(name, /* @__PURE__ */ new Error("The browser audio element reported a playback error."), operation) : void 0);
       const stop = () => {
         if (!active) return;
-        try {
-          audio.pause();
-          audio.currentTime = 0;
-        } catch {}
-        cleanup();
+        active = false;
+        controller.dispose();
       };
-      const voice = Object.freeze({
-        ended,
-        setGain(value) {
-          const gain = normalizeAudioVoiceGain(value);
-          if (active) audio.volume = gain;
-        },
-        stop
+      const started = controller.play();
+      const ended = controller.ended.then(() => stop(), (error) => {
+        stop();
+        if (operation === "createAudioVoice") throw error;
       });
-      audio.addEventListener("ended", handleEnded, { once: true });
-      audio.addEventListener("error", handleError, { once: true });
-      this.playingAudio.set(audio, name);
-      this.audioVoiceStops.set(audio, stop);
-      let playResult;
-      try {
-        playResult = audio.play();
-      } catch (error) {
-        const playbackError = this.playbackError(name, error, operation);
-        cleanup(playbackError);
-        return {
-          voice,
-          started: Promise.reject(playbackError)
-        };
-      }
+      ended.catch(() => {});
       return {
-        voice,
-        started: Promise.resolve(playResult).catch((error) => {
-          const playbackError = this.playbackError(name, error, operation);
-          cleanup(playbackError);
-          throw playbackError;
+        voice: Object.freeze({
+          ended,
+          setGain(value) {
+            const gain = normalizeAudioVoiceGain(value);
+            if (active) controller.setGain(gain);
+          },
+          stop
+        }),
+        started: started.catch((error) => {
+          const legacyStop = operation === "playSound" && !active && error instanceof Error && error.name === "AbortError";
+          stop();
+          if (!legacyStop) throw error;
         })
       };
     }