dsh-claude-motion 2.11.0 → 2.12.0

package/skills/claude-motion/artifact-type/reference/sound.md

@@ -1,106 +1,55 @@
-# Sound — a score generated from the cut
-
-The score is part of the film: `window.CUT.score(S)` declares notes and
-foley against the SAME timeline constants the picture uses, the player
-synthesizes it (a small built-in WebAudio synth — no samples, no
-soundfont) in sync with playback, and Export renders the
-identical events into the MP4's audio track. `S` only records events;
-it is deterministic data, so write it like the picture: from `TT`.
-
-## The method (what worked in review)
-
-- **Pick the tempo from the cut, not the other way round.** One beat =
-  the hard-cut cadence of your showcase run (0.63 s → 95 BPM in the
-  reference); phase the grid (`t0`) so bar lines land on the big
-  moments — the first close-up, the editor landing, the end page. If a
-  visual beat misses a downbeat by a few frames, retime the BEAT in
-  `TT`: nobody sees three frames, everybody hears an off-beat hit.
-- **Groove on the grid, foley on exact frames.** Music events take
-  beats; UI foley takes the precise t of the event it belongs to, off
-  grid: a wood-block tick per visible keystroke (your typist's
-  `times`), side-stick clicks on clicks, a double tick for a
-  double-click, pops as list items or capsules appear, a rising roll
-  while something is dragged or scrubbed with a ding when the value
-  lands, a two-note chime on Save, a whoosh under a whip-pan, a boing
-  when something drops in and squashes.
-- **Arc** (keep the dynamics; don't flatten them): near-silent title
-  (a pad, maybe one mallet note) → a light pulse under the typing →
-  the groove enters when the action starts → stabs on the hard-cut
-  section → drop to a pad for the transform → groove B under the
-  person's edit → a short build (an accelerating run) INTO the hit as
-  the end page lands → resolve and let the last chord ring; fade by the
-  last second. Stop-time before the biggest hit is free drama.
-- **Instrumentation that suits a product film**: marimba or kalimba ostinato,
-  electric piano chords, a round fingered bass, a light kit (kick, side
-  stick, closed hat, a shaker at most), a soft pad. No risers, no
-  cinematic booms, no vocal chops. Major or modal, mid-tempo, warm.
-- **Your own tune.** Write no existing song's, theme's or jingle's melody, note by note or near
-  enough to be recognised: write an original one in that mood. That you did goes in the close's one
-  sentence more (what you could not do as asked): it names the song they asked for, not your music.
-  The user's own, or in the public domain: fine. A genre, a mood, a tempo, an instrument: fine.
-- **They asked for other music: name it in a plain line**: what you wrote (a mood you aimed
-  for, two instruments in everyday words: a marimba, plucked notes, an electric piano, a
-  shaker), never how it sounds. No key, BPM or apology. Mellower, no typing ticks, other
-  instruments: a one-line change. Music off by request is `score` returning nothing; mute and
-  volume are the viewer's own.
-
-## `score(S, kit)`
-
-Runs once at load, after `init` (so typists made in `init` have
-filled `kit.typing.times`). `S` only records events — pure data.
+# Sound: a score generated from the cut
+
+The score is data. `S` only records notes and effects against the same timeline the picture uses, the player synthesizes it
+in sync, and Export renders the same events into the file.
+
+A voiceover is not part of the score. If they asked for one, or to use an audio recording or music file of theirs, the close
+says there is none, in the words of `artifact-type/reference/voice.md` (read it if it isn't in this conversation; the installed skill:
+`voice.md`, beside this page). Where the film speaks, recording.md's close stands instead of the voiceover's sentence; one
+about their recording or music file stays.
+
+## The method
+
+- **Pick the tempo from the cut.** One beat is the film's cut rhythm. Land bar lines on the big moments, and if a visual beat
+  misses a downbeat by a few frames, retime the beat: nobody sees three frames, and everybody hears an off-beat hit.
+- **Groove on the grid, effects on exact frames.** Music takes beats. An effect takes the exact `t` of the event it belongs to.
+- **Sound the world.** What the viewer sees should be heard: a `whoosh` as wind crosses, `thud` on a landing, `pop` as things
+  appear, ticks for a clock.
+- **Keep an arc.** Start near silent, bring the groove in with the action, drop back before the end, build into the hit as the
+  end card lands, then let the last chord ring. Make the hit clearly louder than the opening.
+- **Let the world pick the instruments.** A lullaby wants glockenspiel and pad, a foundry low pads and struck metal, a product
+  film marimba, electric piano, round bass and a light kit. No risers, cinematic booms or vocal chops.
+- **Your own tune.** Write no existing song's, theme's or jingle's melody, note by note or near enough to be recognised: write
+  an original one in that mood, and say so in the close's one sentence (it names the song they asked for, not your music). The
+  user's own, or the public domain, is fine. A genre, mood, tempo or instrument is fine.
+- **On a later turn, if they asked for other music, name it in a plain line:** a mood and two instruments in everyday words, with no key, BPM or
+  apology. Music off by request is a film with no score; mute and volume are the viewer's own.
+
+## `S`
 
 ```js
-score(S, kit) {
-  const BPM = 95.24, B = 60 / BPM;
-  S.tempo(BPM, { t0: TT.cut1 - 16 * B });                  // grid phased so beat 16 IS the first close-up
-  S.program('keys', 'ep'); S.program('bass', 'bass'); S.program('mallet', 'marimba'); S.program('pad', 'pad', { rev: 0.6 });
-  S.note('pad', 'D3', { beat: 0, beats: 8, vel: 30 });                   // {beat, beats} on the grid, or {t, dur} in seconds
-  S.chord('keys', ['D3', 'A3', 'D4', 'F#4'], { beat: 16, beats: 4, vel: 52 });
-  S.note('bass', 'D2', { beat: 16, beats: 1.5, vel: 78 });
-  S.pattern('mallet', 'x.x.X.xx', { from: 16, repeat: 4, pitch: ['D5', 'A4'], vel: 64 });   // step 0.5 beat; X accents
-  S.drums({ kick: 'x...x...', sidestick: '..x...x.', hat: 'oxoxoxox' }, { from: 16, repeat: 8 });   // o = ghost note
-  S.ticks(kit.typing.times, { vel: 30 });                               // one wood tick per keystroke, timbre-jittered
-  S.fx('click', TT.send); S.fx('pop', TT.chip); S.fx('roll', TT.dragA, { dur: TT.dragB - TT.dragA });   // roll lands on a ding
-  S.fx('chime', TT.saved); S.fx('whoosh', TT.whip, { dur: 0.5 }); S.fx('revswell', TT.end, { dur: 1.2 });   // swells INTO TT.end
-  S.run('mallet', ['D5', 'E5', 'F#5', 'A5', 'B5', 'D6'], { t: TT.end - 0.62, step: 0.1, vel: 50, cresc: 8 });
+kit.score(function (S, T) {
+  const B = 60 / 96;
+  S.tempo(96, { t0: T.pour - 8 * B });                   // bar lines land on the pour
+  S.program('pad', 'pad', { rev: 0.6 }); S.program('bass', 'bass'); S.program('mallet', 'marimba');
+  S.note('pad', 'D3', { t: 0, dur: 3, vel: 30 });        // {t, dur} in seconds, or {beat, beats} on the grid
+  S.chord('pad', ['D3', 'A3', 'F#4'], { beat: 8, beats: 4, vel: 52 });
+  S.pattern('mallet', 'x.x.X.xx', { from: 8, repeat: 4, pitch: ['D5', 'A4'], vel: 64 });   // step 0.5 beat; X accents
+  S.drums({ kick: 'x...x...', hat: 'oxoxoxox' }, { from: 8, repeat: 4 });                  // o is a ghost note
+  S.fx('whoosh', T.ring, { dur: 0.5 }); S.fx('chime', T.come + 0.4);
   S.master({ gain: -6, fadeOut: 1.2 });
-}
+});
 ```
 
-- `S.tempo(bpm, {t0})` sets the grid; `S.beat(n)` → seconds,
-  `S.toBeat(t)` → beats. Everything takes `{beat, beats}` (grid) or
-  `{t, dur}` (seconds).
-- `S.program(track, patch, {pan −1..1, gain dB, rev 0..1, bright
-  0..2}?)` names a track. Pitched patches: `marimba`, `vibes`,
-  `glock`, `ep` (electric piano), `keys` (soft synth), `pluck`
-  (kalimba-ish), `bass`, `pad`. Drums: `kick`, `snare`, `clap`,
-  `sidestick`, `hat`, `openhat`, `shaker`, `tamb`, `woodblock`,
-  `cowbell`, `tom`, `crash`, `ride`.
-- `S.note(track, 'F#4' | midi, {…, vel 0–127})`, `S.chord(track,
-  [pitches], {…, spread})`, `S.pattern(track, 'x.X.', {from, step =
-  0.5, repeat, pitch: [cycle], vel, dur})`, `S.run(track, [pitches],
-  {t, step, vel, cresc})`, `S.drum(name, {beat | t, vel})`,
-  `S.drums({name: 'x..o'}, {from, step, repeat, vel})` (`X` accent,
-  `o` ghost). A little humanizing is built in (`S.seed(n)` varies it).
-- Foley at exact seconds, `S.fx(name, t, {dur, vel, pitch, pan}?)`:
-  `tick` (keystroke), `click`, `doubleclick`, `pop`, `ding` (two
-  notes a fifth apart), `chime` (a small arpeggio — Save), `sparkle`,
-  `whoosh` (`{into: 1}` reverses it), `revswell` (swells INTO its
-  `t` over `dur`), `roll` (accelerating ticks over `dur`, a ding on
-  landing — drags and scrubs), `boing` (a bouncy landing), `thud`.
-  `S.ticks(times, {vel, jitter})` = one tick per time.
-- `S.master({gain dB = −6, fadeOut s = 1})`. Keep the arc: the hit
-  should be clearly louder than the intro pad.
+A film with no list of scenes has no `kit.score`: the same body goes in `window.CUT`'s `score`.
+
+`note`, `chord` and `drum` take `{beat, beats}` or `{t, dur}`. `S.beat(n)` gives seconds. Also `S.drum(name, {beat|t, vel})`,
+`S.run(track, [pitches], {t, step, vel, cresc})` and `S.ticks(times, {vel})`, one tick per time.
+
+- Pitched patches: `marimba`, `vibes`, `glock`, `ep`, `keys`, `pluck`, `bass`, `pad`. `S.program(track, patch, {pan, gain, rev, bright})`.
+- Drums: `kick`, `snare`, `clap`, `sidestick`, `hat`, `openhat`, `shaker`, `tamb`, `woodblock`, `cowbell`, `tom`, `crash`, `ride`.
+- Effects, `S.fx(name, t, {dur, vel, pitch, pan})`: `tick`, `click`, `doubleclick`, `pop`, `ding`, `chime`, `sparkle`, `whoosh`
+  (`{into: 1}` reverses it), `revswell` (swells into its `t` over `dur`), `roll`, `boing`, `thud`.
 
-`pattern`/`drums` with `repeat` happily overrun the beat you meant to
-stop at — compute the repeat count (or the step string) to fit
-[t0, t1). Unknown drum or foley names are SILENT (an unknown pitched
-patch falls back to marimba); `check.ts` lists them with the event
-count, tempo and sounding span. An event timed 0.1 s or more before 0
-is dropped without a word (one closer is moved to 0), so the sound for
-an entrance that starts early goes at 0. Listen by numbers: `export.ts --no-video --levels`
-prints loudness per second (RMS dBFS: −60 silent, −30 quiet bed, −20
-groove, −12 hit) — no second between the title and the sign-off should
-sit below about −30; `--mid score.mid` added to them writes a Standard
-MIDI File on your grid for a composer.
-Keep it small — a 35 s score is a few hundred events.
+An unknown drum or effect is silent. `pattern` and `drums` with `repeat` overrun happily, so compute the count to fit. An event
+timed 0.1 s or more before 0 is dropped, so the sound for an early entrance goes at 0. A 30 s score is a few hundred events.

package/skills/claude-motion/artifact-type/reference/voice.md

@@ -0,0 +1,63 @@
+# Asked for a voiceover
+
+This page says what to tell someone who asks for a voiceover or a narration, or to use an audio recording or music file
+of theirs, and where in the chat to say it. Also read all of `artifact-type/reference/recording.md` (the installed skill:
+`recording.md`, beside this page) if your tools can record a voice (your `Artifact` tool lists the action `speak`, or
+your tools list `mcp__claude_ai__artifact_speak`; go by the names you see, and don't search for them), or if the film
+speaks already (it holds `modules/narration.js`, or its `film/script` sets `narration`: look in its data, with a `list`
+of `modules` and a `get` of `film/script`). Where that page differs from this one or from SKILL.md, it goes first.
+Without either, Motion adds no voice and never offers one; either way, it never uses an audio recording or music file
+of theirs. **A new film is made all the same,** with the words on screen in its scenes.
+
+## What they are told
+
+| They want | Ahead of the form | In the form | In the close |
+| --- | --- | --- | --- |
+| a voiceover, a narration, anyone's voice (you can't record) | I can't add a voiceover. | There will be no voiceover: the words will be on screen. | It has no voiceover, since I can't add one: the words are on screen. |
+| their own audio recording in it, even as the voiceover (use this row, not the first) | I can't use your recording. | Your recording can't be used: the animation will have text on screen. Once it is finished, Export saves it as a video, and any video editor can add your recording to that. | I couldn't use your recording, but any video editor can add it to the video that Export saves. |
+| a music file of theirs in it | I can't use your music file. | Your music file can't be used: I'll compose a score. | I couldn't use your music file, but any video editor can add it to the video that Export saves. |
+
+Say it in their language, and as short. It is a plain fact about Motion, not a refusal: give no reason and no word of
+time or place (not even "here"), and never let it hold up the form or the film. A tip or an offer may go anywhere but
+in the line ahead of the form.
+
+## Where
+
+Chat can hide what you write ahead of a tool call. So they are told in **the last text of the turn in which they ask**:
+
+- **A mere question** ("can it do voiceover?"): "No, I can't add a voiceover to an animation." Start nothing.
+- **A film they have already seen:** do the rest of the ask as usual, and say "I can't add a voiceover." last (in a
+  close: these same words, where the close bullet puts them). You may offer to put the words on screen, if they aren't there.
+- **A question or a refusal of your own that ends the turn:** "I can't add a voiceover, so I'll put the words on
+  screen." goes with it. When kinds.md turns the whole film down, leave the voice out of that no (it is two sentences,
+  with no "can't"). If they take the film it offers, tell them as for any new film.
+- **A close** (of a film, a plan or a rough cut): a sentence of its own, after its first sentence ("Here's your animation.")
+  and the link, if there is one. It isn't the close's one short sentence more.
+
+**A new film, with the form.** That turn ends on the form, with nothing after it. So they are told in three places:
+ahead of the form, in it, and again in the next close. Each is needed; none stands in for another.
+
+- **Ahead of it:** the sentence goes into SKILL.md's one line before the form, and nothing else of yours goes there.
+
+  > I can't add a voiceover. A few quick picks, then I'll start.
+
+  Where that line opens with "Your animation is set up.", the sentence comes next:
+
+  > Your animation is set up. I can't add a voiceover. A few quick picks, then I'll start.
+
+  In any language but English the sentence is the whole line, without even "Your animation is set up.": the line must
+  stay far under 200 bytes. Write the line last, with no call or thought between it and `show_widget`, or
+  `ask_user_input_v0` (which has no such line: the sentence alone).
+- **In it:** put the form's words into questions.md's form as a `<p>`, first inside its `elicit-body`. Anything else
+  that can't wait for the close (the answer to a question of theirs, the note questions.md puts in the line before the
+  form) follows them there, never in the line.
+  With `ask_user_input_v0`, the first sentence of the form's words opens the first question's text, whichever it is:
+  "There will be no voiceover: the words will be on screen. Which style should it have?" Keep that text under about 120
+  characters. What doesn't fit, an answer to a question of theirs too, waits for the close.
+
+## Never
+
+- No speech made by code (`claude.use("tts")` is silent), no audio file as an asset, and don't ask for a recording or wait
+  for one.
+- No promise of a voice at any other time or place.
+- A push changes nothing: give the same answer.

package/skills/claude-motion/artifact-type/reference/walkthrough.md

@@ -47,15 +47,15 @@ doesn't move the story goes. Chapters become `window.CUT.chapters`
   stagger, 34 px drift), a 40 px subhead; 2.4–3.2 s. Then the quad **morphs into
   the UI window** (1.1–1.2 s) while the screen fades up inside it — no
   hard cuts from slides into UI.
-- **Personas** (multi-flow only): a 220 px flat smiley in ONE secondary
-  color (never touching the accent) whose eyes and smile are ink marks
-  that draw on and boil; name 40 px semibold, role 30 px, their need as a
+- **Personas** (multi-flow only): a 220 px flat profile, head and shoulders, in
+  ONE secondary color (never touching the accent), whose outline is an
+  ink mark that draws on and boils; name 40 px semibold, role 30 px, their need as a
   44 px display line from the right; ~3.5 s;
   then it flies down to a 72 px badge bottom-left and rides there
   through that flow's beats.
 - **No speech bubbles over UI.** When the person has something to say
   mid-flow, use an interstitial text card: the UI eases to scale 0.96 /
-  opacity 0.25, one 72 px display line (and the small smiley) scales
+  opacity 0.25, one 72 px display line (and the small profile) scales
   0.92 → 1 over 1.4 s, holds 1.6 s, the UI eases back.
 - **Closing card**: a 72 px display line from the right, one accent
   recap chip per flow tumbling in (2.5D is allowed for shapes), a tiny grey

package/skills/claude-motion/scripts/artifact.mjs

@@ -1415,8 +1415,11 @@ var ShareHost = class {
    * their own artifact; a guest comes over a LAN address (this computer's own included: that is how the owner sees
    * what a role sees).
    */
+  isLocal(request) {
+    return this.options.local ? this.options.local(request) : isLoopback(request.socket.remoteAddress);
+  }
   viewerOf(request) {
-    if (isLoopback(request.socket.remoteAddress)) return { role: "owner", user: this.options.owner };
+    if (this.isLocal(request)) return { role: "owner", user: this.options.owner };
     const guest = this.on ? this.sharing.guest(this.cookie(request)) : null;
     if (!guest) return null;
     this.sharing.seen(guest);
@@ -1510,6 +1513,7 @@ var ShareHost = class {
     const share2 = { ...this.me(viewer), noun: this.options.noun, title: this.options.title(), ...this.options.reactions ? { reactions: true } : {} };
     let js = `(function(BASE){${ROOT_SHIM}})(${script(this.page)});${SECURE_CONTEXT_SHIM}window.__baoyuShare=${script(share2)};`;
     for (const [name, value] of Object.entries(this.options.globals?.(viewer, query) ?? {})) js += `window[${script(name)}]=${script(value)};`;
+    if (this.options.agentName) js += `window.__baoyuAgentName=${script(this.options.agentName)};`;
     if (viewer.guest) js += GUEST_WATCH;
     return js;
   }
@@ -1548,7 +1552,7 @@ var ShareHost = class {
   async join(request, response, method, token2) {
     const t = this.words(request);
     const role = this.sharing.linkRole(token2);
-    const local = isLoopback(request.socket.remoteAddress);
+    const local = this.isLocal(request);
     const form = method === "POST" ? await readBody(request, 8 << 10).then((body) => body.toString("utf8"), () => "") : "";
     const title = this.options.title();
     if (!role || !local && !this.on) return this.sendPage(response, 404, t.linkGoneTitle, `<h1>${esc(t.linkGoneTitle)}</h1><p>${esc(t.linkGone)}</p>`);
@@ -3412,6 +3416,7 @@ data: ${JSON.stringify(snap)}
     if (agentHook) await runHook(agentHook);
   }
   async function runHook(command2) {
+    if (typeof command2 !== "string") return runHandler(command2);
     const doc = await readComments(root);
     for (const thread of pendingForAgent(doc)) {
       if (hookRunning.has(thread.id)) continue;
@@ -3436,15 +3441,15 @@ data: ${JSON.stringify(snap)}
         log3(`comments: the agent hook failed to start: ${error.message}`);
       });
       child.on("exit", (code) => {
-        hookRunning.delete(thread.id);
         if (code !== 0) {
+          hookRunning.delete(thread.id);
           log3(`comments: the agent hook exited with ${code} for ${thread.id}; the comment stays waiting${stderr ? `: ${stderr.trim()}` : ""}`);
           return;
         }
         void updateComments(root, (d) => {
           const t = d.threads.find((x) => x.id === thread.id);
           if (t) markDelivered(t, now(), "hook");
-        }).then(() => {
+        }).finally(() => hookRunning.delete(thread.id)).then(() => {
           log3(`comments: sent to the agent (hook): ${thread.id}`);
           return broadcast();
         }).catch((error) => log3(`comments: ${error.message}`));
@@ -3485,6 +3490,44 @@ data: ${JSON.stringify(snap)}
       });
     }
   }
+  async function runHandler(handler) {
+    for (const { id } of pendingForAgent(await readComments(root))) {
+      if (hookRunning.has(id)) continue;
+      hookRunning.add(id);
+      try {
+        const doc = await readComments(root);
+        const thread = pendingForAgent(doc).find((t) => t.id === id);
+        if (!thread) continue;
+        try {
+          await handler.thread(agentViews(doc, [thread])[0]);
+        } catch (error) {
+          log3(`comments: the agent handler failed for ${id}; the comment stays waiting: ${error.message}`);
+          continue;
+        }
+        await updateComments(root, (d) => {
+          const t = d.threads.find((x) => x.id === id);
+          if (t) markDelivered(t, now(), "hook");
+        });
+        log3(`comments: sent to the agent (handler): ${id}`);
+        await broadcast();
+      } finally {
+        hookRunning.delete(id);
+      }
+    }
+    const failed = [];
+    for (const request of requests.splice(0)) {
+      setRequestState(request.id, "working");
+      try {
+        await handler.request(request);
+        log3(`comments: sent to the agent (handler): ${request.id}`);
+      } catch (error) {
+        failed.push(request);
+        setRequestState(request.id, "queued");
+        log3(`comments: the agent handler failed for ${request.id}; the request stays waiting: ${error.message}`);
+      }
+    }
+    requests.unshift(...failed);
+  }
   let debounce;
   const changed = () => {
     clearTimeout(debounce);
@@ -3623,6 +3666,21 @@ data: ${JSON.stringify(snap)}
       } else if (parts.length === 2 && parts[0] === "agent" && parts[1] === "wait") {
         need(viewer.canSend, "Only the owner's agent waits for comments.");
         if (reading) return await wait(request, response, url);
+      } else if (parts.length === 2 && parts[0] === "agent" && parts[1] === "send-all") {
+        if (method === "POST") {
+          request.resume();
+          need(viewer.canSend, ONLY_OWNER_SENDS);
+          const result = await updateComments(root, (doc) => {
+            const open2 = doc.threads.filter((t) => t.status === "open" && t.messages.some((m) => m.author.kind === "user"));
+            const sent = open2.filter(canSendToAgent);
+            const at = now();
+            for (const t of sent) sendToAgent(t, at);
+            return { threads: sent, sent: { count: sent.length, open: open2.length } };
+          });
+          log3(`comments: ${result.sent.count} of ${result.sent.open} open thread(s) sent to the agent`);
+          sendJson2(response, 200, result);
+          return await afterChange(result.sent.count > 0);
+        }
       } else if (parts.length === 2 && parts[0] === "agent" && parts[1] === "requests") {
         need(viewer.canSend, ONLY_OWNER_SENDS);
         if (method === "POST") return await ask(request, response);
@@ -6602,6 +6660,7 @@ var BLOB_ID = /^[0-9a-f]{32}$/;
 var DATA_URI = /^data:(image\/(png|jpeg|gif|webp|svg\+xml)|font\/(woff2|woff|ttf|otf)|video\/(mp4|webm)|audio\/(mpeg|wav));base64,[A-Za-z0-9+/=]+$/;
 var MODULE_KINDS = ["js", "css", "html", "json", "text"];
 var ASSET_MIMES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/svg+xml", "font/woff2", "font/woff", "font/ttf", "font/otf", "video/mp4", "video/webm", "application/pdf", "audio/mpeg", "audio/wav"];
+var REPLACE_ONLY_DOCS = /* @__PURE__ */ new Set(["modules/fetched-fonts.json", "modules/recolored.json", "modules/retouched.json", "modules/retyped.json"]);
 var UNSPLIT_MODULES = ["edits.json", "fetched-fonts.json", "recolored.json", "recut.json", "refaced.json", "retouched.json", "retyped.json", "tweaks.json"];
 var CONTENT_TYPES = {
   html: "text/html; charset=utf-8",
@@ -6790,6 +6849,7 @@ function documentProblem(root, segs, data) {
       if (mime === "image/svg+xml") return `assets/${id}: an SVG is never uploaded; put its <svg> markup in an html module, or a data:image/svg+xml;base64,\u2026 ref.`;
       if (!fs19.existsSync(blobFile(root, blob[1]))) return `assets/${id}: ${ref} is not in this film's _blobs/. Upload the file first (${cmd("upload", root, "<file>")}) and use the url it prints.`;
     } else if (ref.startsWith("data:")) {
+      if (mime.startsWith("audio/")) return `assets/${id}: the player plays no audio stored inside the film's data (a data: ref). Upload the file (${cmd("upload", root, "<file>")}) and use the url it prints.`;
       if (!DATA_URI.test(ref)) return `assets/${id}: the data: ref is not data:<image, font, video or audio type>;base64,\u2026; the player drops it.`;
       if (!ref.startsWith(`data:${mime};`)) return `assets/${id}: mime ${mime} does not match the data: URI's own type (${ref.slice(5, ref.indexOf(";"))}).`;
     } else return `assets/${id}: ref must be this film's own /_blob/<32 hex> (from upload) or a small data:\u2026;base64, URI; never an external URL.`;
@@ -7235,6 +7295,21 @@ function check(root) {
         let seconds = 0;
         const missing = [];
         sceneDurs = /* @__PURE__ */ new Map();
+        const listIds = new Set(list.flatMap((s) => isObject7(s) && typeof s.id === "string" ? [s.id] : []));
+        const renamed = /* @__PURE__ */ new Set();
+        for (const [name, text] of texts) {
+          const m = /^(.+)\.js$/.exec(name);
+          if (!m || !listIds.has(m[1]) || texts.has(`scene-${m[1]}.js`) || ["shared", "score", "narration"].includes(m[1])) continue;
+          if (new RegExp(`\\bkit\\.scene\\s*\\(\\s*['"\`]${m[1].replace(/[^\w-]/g, "")}['"\`]`).test(text)) {
+            renamed.add(m[1]);
+            warn(`modules/${name}`, `the player runs it as scene "${m[1]}" but a scene's code belongs in modules/scene-${m[1]}.js; rename the file.`);
+          }
+        }
+        for (const name of texts.keys()) {
+          const scene = /^scene-(.+)\.js$/.exec(name);
+          if (scene && !listIds.has(scene[1])) warn(`modules/${name}`, `scene-<id>.js is for a scene of scenes.json, and "${scene[1]}" is not one; the player runs no other module so.`);
+          if (/^layer-/.test(name)) warn(`modules/${name}`, "names that begin layer- are the player's; name no module so.");
+        }
         list.forEach((s, i) => {
           const at = `${label} scenes[${i}]`;
           if (!isObject7(s)) return problem(at, "is not an object.");
@@ -7247,7 +7322,7 @@ function check(root) {
             seconds += s.dur;
             if (typeof s.id === "string") sceneDurs.set(s.id, s.dur);
           }
-          if (typeof s.id === "string" && !texts.has(`scene-${s.id}.js`)) missing.push(`${i + 1} (${s.id})`);
+          if (typeof s.id === "string" && !texts.has(`scene-${s.id}.js`) && !renamed.has(s.id)) missing.push(`${i + 1} (${s.id})`);
         });
         if (seconds > MAX_SECONDS) problem(label, `the scenes add up to ${seconds} s; a film over ${MAX_SECONDS} s won't load.`);
         scenesInfo = { stage: scenes.stage, scenes: list.length, seconds: Math.round(seconds * 1e3) / 1e3, ...missing.length ? { scenesLeft: missing } : {} };
@@ -7352,7 +7427,10 @@ function check(root) {
     const blob = BLOB_URL.exec(String(data.ref ?? ""));
     if (!blob) continue;
     const meta2 = readBlobMeta(root, blob[1]);
-    if (meta2 && meta2.contentType !== data.mime) warn(p, `mime is ${data.mime}, but the upload is ${meta2.contentType}; the player trusts mime.`);
+    if (meta2 && meta2.contentType !== data.mime) {
+      if (String(data.mime).startsWith("audio/") || String(meta2.contentType).startsWith("audio/")) problem(p, `mime is ${data.mime}, but the upload is ${meta2.contentType}; the player drops an audio asset whose mime and upload type differ. Use the upload reply's content_type, verbatim.`);
+      else warn(p, `mime is ${data.mime}, but the upload is ${meta2.contentType}; the player trusts mime.`);
+    }
   }
   const result = {
     root,
@@ -7598,7 +7676,7 @@ async function serve(root, flags) {
   print({ url: state.url, root, pid: state.pid, ...state.lan?.length ? { lan: state.lan } : {} }, true);
   return !(state.joined && background);
 }
-function mountSite(root, { log: log3, network, agentHook }) {
+function mountSite(root, { log: log3, network, agentHook, local, agentName }) {
   const dbDir = path18.join(root, "db");
   fs19.mkdirSync(dbDir, { recursive: true });
   const known = /* @__PURE__ */ new Map();
@@ -7687,6 +7765,8 @@ data: ${JSON.stringify(data)}
     title: () => filmTitle(root),
     log: log3,
     uiFile: path18.join(EDITOR_DIR, "share-ui.js"),
+    ...local ? { local } : {},
+    ...agentName ? { agentName } : {},
     globals: (viewer, query) => ({ __baoyuHistory: history.bootGlobal(viewer, query) })
   });
   const comments = createCommentsService({
@@ -7838,7 +7918,7 @@ data: ${JSON.stringify(data)}
         let write = { op: body.op, path: body.path, ...body.op === "delete" ? {} : { data: body.data } };
         let merge;
         const base2 = isObject7(body.base) ? body.base : body.base === null && body.op !== "delete" ? {} : null;
-        if ((body.op === "set" || body.op === "update" || body.op === "delete") && base2 && (body.op === "delete" || isObject7(body.data))) {
+        if ((body.op === "set" || body.op === "update" || body.op === "delete") && base2 && !REPLACE_ONLY_DOCS.has(segs.join("/")) && (body.op === "delete" || isObject7(body.data))) {
           let now = null;
           try {
             now = readDoc(root, segs.join("/"));
@@ -8381,7 +8461,7 @@ ${USAGE}
       return 2;
   }
 }
-main().then(
+if (typeof __BAOBOT_LIB__ === "undefined") main().then(
   (code) => {
     if (code >= 0) process.exitCode = code;
   },
@@ -8391,3 +8471,10 @@ main().then(
     process.exitCode = 2;
   }
 );
+export {
+  applyWrites,
+  check,
+  mountSite,
+  readDb,
+  upload
+};