@msb235/blits 0.10.0 → 0.12.0

package/dist/owner.js

@@ -1,3 +1,4 @@
+import { arcShare } from './arcs.js';
 import { backWith, clampWeight, elapsedWith, envelope, timeWith } from './clock.js';
 /** What an owner is cued with in place of a patch: it writes nothing, so no fold ever meets it. */
 export const ownerPatch = Object.freeze({
@@ -13,6 +14,35 @@ export class Holding {
     /** How many it has held, and how many of those finished their passes. */
     kids = 0;
     played = 0;
+    /**
+     * When the children that left coast, as pairs of the frame one left in and the latest coast so
+     * far, mix time: a pair only where the latest grew, so a seek back cuts it to a prefix.
+     */
+    coasts = [];
+    /** The frame the first child to leave before its passes ended left in; Infinity for none. */
+    cutSeq = Number.POSITIVE_INFINITY;
+    /** The latest coast of a child that left; -Infinity for none. */
+    get coast() {
+        const n = this.coasts.length;
+        return n === 0 ? Number.NEGATIVE_INFINITY : this.coasts[n - 1];
+    }
+    /** A child left in frame `seq`, coasting at `coast`, or before its passes ended for undefined. */
+    left(coast, seq) {
+        if (coast === undefined) {
+            if (seq < this.cutSeq)
+                this.cutSeq = seq;
+        }
+        else if (coast > this.coast)
+            this.coasts.push(seq, coast);
+    }
+    /** Forgets the children that left after frame `seq`, for a seek or read back to it. */
+    back(seq) {
+        const c = this.coasts;
+        while (c.length > 0 && c[c.length - 2] > seq)
+            c.length -= 2;
+        if (this.cutSeq > seq)
+            this.cutSeq = Number.POSITIVE_INFINITY;
+    }
 }
 /**
  * What an owner's clock reads at mix time `now`, through every owner above it: -Infinity before it
@@ -99,12 +129,19 @@ export function ownWeight(owner, now, reduced, base) {
 /** What every owner above a voice multiplies into its weight. */
 export function ownersWeight(voice, now, reduced, base) {
     let w = 1;
-    for (let o = voice.owner; o !== null; o = o.owner)
+    let child = voice;
+    for (let o = voice.owner; o !== null; child = o, o = o.owner) {
         w *= ownWeight(o, now, reduced, base);
+        if (o.arc !== null)
+            w *= arcShare(o, child, now, reduced);
+    }
     return w;
 }
-/** Points a projection's copies at each other's owners, each owner holding only copies. */
-export function relink(copies) {
+/**
+ * Points a projection's copies at each other's owners, each owner holding only copies; for a read
+ * back to frame `seq`, as its children that had left by then left it.
+ */
+export function relink(copies, seq) {
     const byId = new Map();
     for (const v of copies) {
         byId.set(v.id, v);
@@ -112,6 +149,10 @@ export function relink(copies) {
             const h = new Holding();
             h.kids = v.holding.kids;
             h.played = v.holding.played;
+            h.coasts = v.holding.coasts.slice();
+            h.cutSeq = v.holding.cutSeq;
+            if (seq !== undefined)
+                h.back(seq);
             v.holding = h;
         }
     }

package/dist/pack.d.ts

@@ -12,6 +12,7 @@ export interface PackedRecord {
     stepped: number;
     ticks: number;
     rebuilt: number;
+    copied?: true;
     /**
      * What `setting.keep` held, in the order its owners first kept it. An owner is code, which no
      * store keeps, and a voice revived from a descriptor has new ones; the same code keeps in the same

package/dist/pack.js

@@ -18,6 +18,8 @@ export function packHeld(voice, h) {
         rebuilt: h.rebuilt,
         kept: kept.length === 0 ? null : kept.map(clone),
     };
+    if (h.copied)
+        p.copied = true;
     if (h.base !== undefined)
         p.base = clone(h.base);
     if (h.slope !== undefined)
@@ -42,6 +44,7 @@ export function unpackHeld(voice, p) {
     h.stepped = p.stepped;
     h.ticks = p.ticks;
     h.rebuilt = p.rebuilt;
+    h.copied = p.copied === true;
     if (p.kept !== null)
         h.unkept = p.kept;
     if (p.base !== undefined)

package/dist/place.d.ts

@@ -10,6 +10,8 @@ export declare function mixAt<I, O>(mix: Mixer<I, O>, u: number): number;
 export declare function pin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, u: number): void;
 /** Puts each pending voice's start, given in host time, where the mix's rate now puts it. */
 export declare function repin<I, O>(mix: Mixer<I, O>): void;
+/** Moves a pending voice's start, its clock with it; false where it is already there. */
+export declare function startAt<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, start: number): boolean;
 /** Refuses a placement that names a mark twice on one side, or that waits on itself. */
 export declare function checkPlacement<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>, anchor: Placement, owner: Voice<I, O> | null): void;
 /**
@@ -18,3 +20,9 @@ export declare function checkPlacement<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I
  * last gave. Repeated so a chain of anchors settles in one sync.
  */
 export declare function place<I, O>(mix: Mixer<I, O>): void;
+/**
+ * The time an anchor answers on its voice's owner's clock, or undefined while its target has none.
+ * A time before the owner starts answers `before`: undefined, so a start waits, or -Infinity for a
+ * floor, which is no bound at all.
+ */
+export declare function resolve<I, O>(mix: Mixer<I, O>, a: number | NonNullable<Placement['start']>, self: Voice<I, O>, before?: number): number | undefined;

package/dist/place.js

@@ -5,6 +5,7 @@ import { noted } from './history.js';
 import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
 import { holders, scored, scoredGone, scoreVersion, unhold } from './scored.js';
+import { refloor } from './spans.js';
 import { none } from './voice.js';
 import { warnOnce } from './warn.js';
 /** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
@@ -35,7 +36,7 @@ export function repin(mix) {
     }
 }
 /** Moves a pending voice's start, its clock with it; false where it is already there. */
-function startAt(mix, voice, start) {
+export function startAt(mix, voice, start) {
     if (start === voice.start)
         return false;
     voice.start = start;
@@ -145,18 +146,23 @@ export function place(mix) {
             }
         }
         if (!moved)
-            return;
+            break;
     }
+    refloor(mix);
 }
-/** The time an anchor answers on its voice's owner's clock, or undefined while its target has none. */
-function resolve(mix, a, self) {
+/**
+ * The time an anchor answers on its voice's owner's clock, or undefined while its target has none.
+ * A time before the owner starts answers `before`: undefined, so a start waits, or -Infinity for a
+ * floor, which is no bound at all.
+ */
+export function resolve(mix, a, self, before) {
     const o = self.owner;
     if (typeof a === 'number')
         return o === null ? mixAt(mix, a - mix.offset) : a;
     if ('all' in a) {
         let latest = Number.NEGATIVE_INFINITY;
         for (const m of a.all) {
-            const t = member(mix, m, self);
+            const t = member(mix, m, self, before);
             if (t === undefined)
                 return undefined;
             latest = Math.max(latest, t);
@@ -169,7 +175,7 @@ function resolve(mix, a, self) {
         let earliest = Number.POSITIVE_INFINITY;
         let unknown = false;
         for (const m of a.any) {
-            const t = member(mix, m, self);
+            const t = member(mix, m, self, before);
             if (t === undefined)
                 unknown = true;
             else
@@ -205,14 +211,16 @@ function resolve(mix, a, self) {
     if (o === null)
         return t + by;
     const local = ownerReading(o, t);
+    if (local === Number.NEGATIVE_INFINITY)
+        return before;
     return Number.isFinite(local) ? local + by : undefined;
 }
 /**
  * What one member of a join answers, or the time it last gave once its target has left, as a lone
  * anchor keeps its voice where its target last put it.
  */
-function member(mix, a, self) {
-    const t = resolve(mix, a, self);
+function member(mix, a, self, before) {
+    const t = resolve(mix, a, self, before);
     if (t === undefined)
         return self.answers?.get(a);
     if (!mix.projecting) {

package/dist/placed.d.ts

@@ -0,0 +1,19 @@
+/**
+ * By subject number, the crowd voices whose rows are placed on it, so letting a number go reaches
+ * its rows without walking every crowd's. Kept by voice id, which a row keeps as a crowd closes up
+ * or is rebuilt around it.
+ */
+export declare class Placed {
+    /** By subject number, one voice placed on it; 0, which is no voice's id, for none. */
+    private one;
+    /** The others, for a subject with several; null until some subject has two. */
+    private rest;
+    /** Makes room for subject numbers below `cap`. */
+    grow(cap: number): void;
+    /** Some voice placed on the subject at `slot`, 0 for none. */
+    any(slot: number): number;
+    /** Every voice placed on the subject at `slot`, in no order: for a test to read. */
+    all(slot: number): number[];
+    add(slot: number, id: number): void;
+    remove(slot: number, id: number): void;
+}

package/dist/placed.js

@@ -0,0 +1,54 @@
+/**
+ * By subject number, the crowd voices whose rows are placed on it, so letting a number go reaches
+ * its rows without walking every crowd's. Kept by voice id, which a row keeps as a crowd closes up
+ * or is rebuilt around it.
+ */
+export class Placed {
+    /** By subject number, one voice placed on it; 0, which is no voice's id, for none. */
+    one = new Int32Array(0);
+    /** The others, for a subject with several; null until some subject has two. */
+    rest = null;
+    /** Makes room for subject numbers below `cap`. */
+    grow(cap) {
+        const one = new Int32Array(cap);
+        one.set(this.one);
+        this.one = one;
+    }
+    /** Some voice placed on the subject at `slot`, 0 for none. */
+    any(slot) {
+        return this.one[slot] | 0;
+    }
+    /** Every voice placed on the subject at `slot`, in no order: for a test to read. */
+    all(slot) {
+        const one = this.any(slot);
+        return one === 0 ? [] : [one, ...(this.rest?.get(slot) ?? [])];
+    }
+    add(slot, id) {
+        if (this.one[slot] === 0) {
+            this.one[slot] = id;
+            return;
+        }
+        this.rest ??= new Map();
+        const more = this.rest.get(slot);
+        if (more === undefined)
+            this.rest.set(slot, [id]);
+        else
+            more.push(id);
+    }
+    remove(slot, id) {
+        const more = this.rest?.get(slot);
+        if (this.one[slot] === id)
+            this.one[slot] = more === undefined ? 0 : more.pop();
+        else if (more !== undefined) {
+            const i = more.indexOf(id);
+            if (i < 0)
+                return;
+            more[i] = more[more.length - 1];
+            more.pop();
+        }
+        else
+            return;
+        if (more !== undefined && more.length === 0)
+            this.rest.delete(slot);
+    }
+}

package/dist/project.d.ts

@@ -4,9 +4,12 @@ import type { TransportProjection } from './types.js';
 import type { Subject, Voice } from './voice.js';
 /**
  * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
- * own, moved together so an anchor across mixes answers as it would live.
+ * own, moved together so an anchor across mixes answers as it would live. Ahead, they stop at each
+ * known event on the way, and a subject asked about is read at each before `t`.
  */
-export declare function projectAll(transport: Transport, t: number): TransportProjection;
+export declare function projectAll(transport: Transport, at: number | {
+    readonly frame: number;
+}): TransportProjection;
 /** Sets each copied voice's state to what its clock and fade make it at `t`. */
 export declare function stateAt<I, O>(c: Mixer<I, O>, t: number): void;
 /** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */