@msb235/blits 0.12.0 → 0.12.1

package/CHANGELOG.md

@@ -4,6 +4,19 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. Each release lists its changes as **Breaking**, **Added** and
 **Fixed**, and the release workflow refuses a tag with no section here.
 
+## 0.12.1
+
+### Added
+
+- `mix.close()`: takes a mix off the list debuggers read, for a host tearing it down, where it would
+  otherwise stay listed until collected. It stops every debugger watching it, and frees a debugger's
+  hold unless another listed mix shares its transport.
+
+### Fixed
+
+- An arc not yet started, cued late or under an owner yet to start, no longer shows its enter's
+  first frame from the moment it is cued.
+
 ## 0.12.0
 
 ### Added

package/dist/arcs.js

@@ -68,8 +68,10 @@ function rampOf(s, e, end, blend, t) {
  */
 export function arcShare(arcVoice, child, now, reduced) {
     const arc = arcVoice.arc;
-    const read = ownerReading(arcVoice, now);
-    const t = read > 0 ? read : 0;
+    const t = ownerReading(arcVoice, now);
+    // Its parts freeze on their first frames, so an arc yet to start has to silence them itself.
+    if (!(t >= 0))
+        return 0;
     const segs = segments(arc, arcVoice.hold);
     const end = arc.enter + arcVoice.hold + arc.exit;
     const blend = reduced ? 0 : arc.blend;

package/dist/mixer.d.ts

@@ -264,6 +264,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     ramp(rate: number, over: number): void;
     /** Whether a voice will change no pose from `now` on, short of a change made to it. */
     still(voice: Voice<I, O>, now: number): boolean;
+    close(): void;
     mute(opts?: {
         over?: number;
     }): void;

package/dist/mixer.js

@@ -28,7 +28,7 @@ import { record, unplayable } from './tape.js';
 import { touch } from './touch.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.js';
-import { gave, historyFor, register } from './watch.js';
+import { gave, historyFor, register, unregister } from './watch.js';
 import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned, } from './weigh.js';
 /**
  * What a mix takes where its options say nothing. Not exported from the package: the suite turns
@@ -508,6 +508,9 @@ export class Mixer {
         const motion = voice.motion;
         return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
     }
+    close() {
+        unregister(this);
+    }
     mute(opts) {
         for (const voice of this.cued) {
             voice.written = true;

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.12.0";
+export declare const release = "0.12.1";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.12.0';
+export const release = '0.12.1';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/types/mix.d.ts

@@ -313,6 +313,12 @@ export interface Mix<I, O, H = unknown> {
      * A frame loop sleeping on `inert` subscribes here to wake.
      */
     onWake(fn: () => void): () => void;
+    /**
+     * Takes the mix off the list debuggers read (see `watched`), for a host done with it, where it
+     * would otherwise stay until collected. Stops every watcher, and frees a hold no other listed mix
+     * on its transport shares. It still plays if synced.
+     */
+    close(): void;
     /** Fades every voice out: over `over` when given, over each voice's own `fade.out` otherwise. */
     mute(opts?: {
         over?: number;

package/dist/watch.d.ts

@@ -23,4 +23,6 @@ export declare function historyFor(opts: {
 export declare function gave(transport: object): void;
 /** Lists a mix the host made, under an entry this copy builds. */
 export declare function register(mix: Any): void;
+/** Unlists a mix, telling every listener it is gone; one not listed is left alone. */
+export declare function unregister(mix: Any): void;
 export {};

package/dist/watch.js

@@ -100,10 +100,27 @@ export function register(mix) {
     };
     r.entries_.set(mix, entry);
     r.refs.set(id, new WeakRef(mix));
-    r.gone.register(mix, id);
+    r.gone.register(mix, id, mix);
     for (const fn of [...r.fns])
         fn({ kind: 'add', entry });
 }
+/** Unlists a mix, telling every listener it is gone; one not listed is left alone. */
+export function unregister(mix) {
+    const r = registry();
+    const entry = r.entries_.get(mix);
+    if (entry === undefined || !r.refs.has(entry.id))
+        return;
+    r.refs.delete(entry.id);
+    r.gone.unregister(mix);
+    untap(mix);
+    const t = mix.transport;
+    const held = ctlOf(t).held;
+    const listed = (m) => r.refs.has(r.entries_.get(m)?.id ?? -1);
+    if (held !== null && !t.members.some(listed))
+        held.free();
+    for (const fn of [...r.fns])
+        fn({ kind: 'gone', id: entry.id });
+}
 function labelOf(mix, subject) {
     const own = mix.opts.labelOf?.(subject);
     return own ?? guess(subject);
@@ -251,12 +268,19 @@ function stopper(ref, fn) {
         const own = m === undefined ? undefined : taps.get(m);
         if (m === undefined || own === undefined || !own.fns.delete(fn) || own.fns.size > 0)
             return;
-        own.untap();
-        taps.delete(m);
-        ctlOf(m.transport).tapped--;
-        fit(m.transport);
+        untap(m);
     };
 }
+/** Puts back what watching `mix` swapped, whoever is still watching. */
+function untap(mix) {
+    const own = taps.get(mix);
+    if (own === undefined)
+        return;
+    own.untap();
+    taps.delete(mix);
+    ctlOf(mix.transport).tapped--;
+    fit(mix.transport);
+}
 /** The frame a read lands in, handing the last one over where the mix has moved on since. */
 function frameOf(mix) {
     const t = taps.get(mix);
@@ -375,6 +399,7 @@ function hold(t) {
             host = ts;
             at();
         },
+        free: () => handle.free(),
     };
     fit(t);
     t.woke();
@@ -382,7 +407,7 @@ function hold(t) {
         if (freed)
             throw new Error('blits: that hold was freed');
     };
-    return {
+    const handle = {
         get mixes() {
             return [...t.members];
         },
@@ -438,4 +463,5 @@ function hold(t) {
             }
         },
     };
+    return handle;
 }

package/docs/schema.html

@@ -857,7 +857,7 @@ phase.result;   <span class="cm">// { budget, length, over, skipped, fell }</spa
 <pre><code>const phase = mix.span({ name: 'phase', order: 'queue', duration: 2000 });
 mix.cue({ patch: writeChange(change), owner: phase, rank: change.line,
           earliest: { of: { name: `orb ${change.id}`, score: 'orbs' }, mark: 'end' } });</code></pre></li>
-  <li id="arcs"><b>Arcs.</b> <code>mix.arc(spec)</code> cues an owner holding an ordered chain of three parts that hand over on its clock: <code>enter</code>, then <code>active</code> for the <code>hold</code>, then <code>exit</code>. It is klieg's <code>fire(text, { enter, active, exit, hold, blendMs })</code> as a blits primitive, with the same part names so the two line up, and it replaces a host adding up starts by hand: the marquee's program is a span queueing arcs. Built 2026-10-22.
+  <li id="arcs"><b>Arcs.</b> <code>mix.arc(spec)</code> cues an owner holding an ordered chain of three parts that hand over on its clock: <code>enter</code>, then <code>active</code> for the <code>hold</code>, then <code>exit</code>. It is klieg's <code>fire(text, { enter, active, exit, hold, blendMs })</code> as a blits primitive, with the same part names so the two line up, and it replaces a host adding up starts by hand: bree's marquee runs its program as a span queueing arcs. Built 2026-10-22.
 <pre><code>const word = mix.arc({
   name: 'JACKPOT',
   enter: { patch: rise, stagger: byLetter, duration: 600 },   <span class="cm">// a voice's spec, or several layered</span>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msb235/blits",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Concurrent effects: each on its own clock with its own state and weight, folded into one value per subject per frame",
   "keywords": [
     "animation",