@msb235/blits 0.14.0 → 0.15.1

package/dist/meet.js

@@ -1,6 +1,8 @@
+import { open, shut } from './everyone.js';
+import { seatOf } from './seat.js';
 /**
  * Whether the lanes a probe of the subject at `slot` just met (`met`) can be folded on the general
- * path after the lanes' values: none is in a locus or a crowd, the subject owes none already this
+ * path after the lanes' values: none is in a role or a crowd, the subject owes none already this
  * fill, and each comes after every other laned voice in voice order, so folding it last folds in
  * the general path's order.
  */
@@ -88,19 +90,105 @@ export function meet(lanes, slot, subject, head, lane) {
     // after every other laned voice, the general path folds just those onto the lanes' values;
     // otherwise it reads the general path all frame.
     const o = slot * 6 /* Per.SLOT */;
-    if (lane && lanes.per[o + 2 /* Per.IDLE */] === 0 && owable(lanes, slot)) {
-        lanes.owed.owe(slot, lanes.met, lanes.metN);
-        return true;
+    if (lane && lanes.per[o + 2 /* Per.IDLE */] === 0) {
+        const again = foldsAgain(lanes, slot);
+        if (again || owable(lanes, slot)) {
+            if (!foldNow(lanes, slot, subject, again))
+                lanes.owed.owe(slot, lanes.met, lanes.metN);
+            return true;
+        }
     }
     lanes.per[o + 0 /* Per.FILLED */] = lanes.fills;
     return false;
 }
+/**
+ * Whether the subject at `slot` met the lanes the last subject `foldNow` folded met, in the same
+ * fill: `owable` and `foldNow`'s own checks then answer as they did for that one.
+ */
+function foldsAgain(lanes, slot) {
+    if (lanes.foldsFill !== lanes.fills || lanes.metCrowd || lanes.owes(slot))
+        return false;
+    const folds = lanes.folds;
+    const n = lanes.metN;
+    if (folds.length !== n)
+        return false;
+    for (let i = 0; i < n; i++)
+        if (folds[i] !== lanes.met[i])
+            return false;
+    return true;
+}
+/**
+ * Folds the lanes a probe of the subject at `slot` just met onto the lanes' values, making each
+ * one's first call or read for the subject as the general path would for this probe, where every
+ * one is a stateless fn or keys voice that ran this fill; false, leaving them owed, where any is
+ * not. The fold is last in voice order, as `owable` found, so it folds as the general path would
+ * after the fill.
+ */
+function foldNow(lanes, slot, subject, again) {
+    if (lanes.filling)
+        return false;
+    // What `unread` answers, which `one` asks before this probe's own stamp is written.
+    const lately = lanes.lately;
+    const o = slot * 6 /* Per.SLOT */;
+    if (lately >= 0 &&
+        !(lanes.per[o + 3 /* Per.LANE_PROBE */] > lately ||
+            lanes.per[o + 4 /* Per.GENERAL_PROBE */] > lately))
+        return false;
+    const met = lanes.met;
+    const n = lanes.metN;
+    for (let i = 0; i < n && !again; i++) {
+        const lane = lanes.byId.get(met[i]);
+        const v = lane.voice;
+        if (lane.ran !== lanes.fills ||
+            lane.motion !== undefined ||
+            v.keeping ||
+            typeof v.spec.weight === 'function' ||
+            (v.sharing && v.everyone === null))
+            return false;
+    }
+    if (!again) {
+        lanes.folds = met.slice(0, n);
+        lanes.foldsFill = lanes.fills;
+    }
+    // The subject is at hand: `call` would look it up again by its number.
+    if (lanes.subjects[slot] === undefined) {
+        lanes.subjects[slot] = subject;
+        lanes.holding = true;
+    }
+    lanes.meeting = true;
+    try {
+        for (let i = 0; i < n; i++) {
+            const lane = lanes.byId.get(met[i]);
+            const v = lane.voice;
+            const p = lane.positionOf(slot);
+            if (!v.sharing) {
+                lanes.one(lane, p, slot);
+                continue;
+            }
+            const rec = v.everyone;
+            open(v, rec, slot);
+            lanes.one(lane, p, slot);
+            // Its patch just made kept state, and the record is now that subject's own.
+            if (!v.keeping)
+                shut(v, rec, slot, lanes.cap);
+        }
+    }
+    finally {
+        lanes.meeting = false;
+    }
+    // A patch that just made kept state takes its voice off its lane: check the next subject again.
+    for (let i = 0; i < n; i++)
+        if (lanes.byId.get(met[i]).voice.keeping)
+            lanes.foldsFill = -1;
+    return true;
+}
 /** Places a crowd voice's row on the subject a probe met, as `Lane.add` adds a position. */
 function place(lanes, voice, slot, subject, from, head) {
-    const c = lanes.crowdOf.get(voice.id);
-    const p = c?.rowOf.get(voice.id);
-    if (c === undefined || p === undefined)
+    const s = seatOf(lanes, voice);
+    if (s === null)
         return false;
+    const c = s.crowd;
+    const p = s.row;
     const h = p * c.stride;
     const flags = c.hot[h + 0 /* Hot.FLAGS */];
     if (c.hot[h + 6 /* Hot.EPOCH */] <= from || (flags & 16 /* Flag.PLACED */) !== 0)

package/dist/mixer.d.ts

@@ -1,31 +1,40 @@
 import { type Arc } from './arcs.js';
+import { around } from './around.js';
 import { blended, laneRead, shareKept } from './blend.js';
 import type { Book } from './book.js';
 import { aims, chain, linkable, relink } from './chain.js';
 import { type LerpInto } from './channels.js';
 import type { Column } from './columns.js';
+import { baseFor, contribution, isRest, keyed, read, slopeFor, tick } from './contribution.js';
 import { DepartedIndex } from './departed.js';
-import type { Due } from './due.js';
+import { drop, forgetIn, recordDrop, releaseIn } from './drop.js';
+import { DueQueue } from './due.js';
 import { parting } from './fade.js';
-import { apply, baseFor, clamp, contribution, fold, foldDetour, folded, foldLoci, foldSharers, foldWith, isRest, type Key, keyed, linked, owedBy, passes, read, shared, slopeFor, tick } from './fold.js';
+import { apply, clamp, fold, foldDetour, folded, foldSharers, foldWith, type Key, linked, owedBy, passes, shared } from './fold.js';
 import { GoneIndex } from './gone.js';
 import type { HandleHost } from './handle.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
 import { Lanes } from './lanes.js';
-import { foldLocus, type LocusScratch } from './locus.js';
-import type { MotionOwner, Motions } from './motions.js';
+import type { Motions } from './motions.js';
 import type { Pace } from './pace.js';
 import { Keys } from './paging.js';
+import type { Places } from './places.js';
+import { moved, place, plot, put } from './plot.js';
 import { keep } from './pull.js';
 import { Steps } from './relink.js';
+import { atRest, restful, rests, restsKey, restsLaned, still } from './rests.js';
 import { Outs } from './revive.js';
+import { foldRole, type RoleScratch } from './role.js';
+import { foldRoles } from './roles.js';
 import { ScoreIndex } from './scored.js';
 import { Fitting } from './spans.js';
 import { Store } from './store.js';
+import type { MotionOwner } from './stretch.js';
+import type { Subject } from './subject.js';
 import { type Announced, Transport } from './transport.js';
-import type { ArcHandle, ArcSpec, BlendMember, Booker, BookOptions, Channel, Columns, Engine, Handle, Kit, Marked, Mix, MixOptions, OwnerSpec, Patch, Projection, Sent, Signal, SpanHandle, SpanSpec, Tape, VoiceSpec } from './types.js';
-import { type Subject, type Voice } from './voice.js';
-import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned } from './weigh.js';
+import type { ArcHandle, ArcSpec, BlendMember, Booker, BookOptions, Channel, Columns, Engine, Handle, Kit, Marked, Mix, MixOptions, OwnerSpec, Patch, Projection, Sent, Signal, SpanHandle, SpanSpec, Tape, Trace, TraceOptions, VoiceSpec } from './types.js';
+import { type Voice } from './voice.js';
+import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, primeLaned, weigh, weighOwned } from './weigh.js';
 /**
  * What a mix takes where its options say nothing. Not exported from the package: the suite turns
  * `lanes` off to run every test on the general path, which is what makes each one an equivalence check.
@@ -67,7 +76,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         fields: Record<string, unknown>;
     } | undefined;
     /** Each subject's last two poses and when they were probed, for `from: 'current'`. */
-    pose: Store<I, {
+    lastPoses: Store<I, {
         pose: O;
         at: number;
         prev: O | undefined;
@@ -91,7 +100,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
     scratch: O | undefined;
     /** Live voices by the earliest mix time `moveTo` would change each, a binary heap. */
-    due: Due<I, O>[];
+    due: DueQueue<I, O>;
     /** Voices retired since `moveTo` last pruned them, in the order they retired. */
     retired: Voice<I, O>[];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
@@ -135,6 +144,8 @@ export declare class Mixer<I, O> implements Mix<I, O> {
      */
     chains: Store<I, Subject<unknown>>;
     version: number;
+    /** The positions `plot` gave, which a voice's `within` reads: see `bound.ts`. */
+    places: Places<I> | null;
     /** What `prime` reads its clock, voice time and pass from: see `Primed`. */
     readonly primed: Float64Array<ArrayBuffer>;
     readonly steps: Steps<Voice<I, O>, I>;
@@ -166,8 +177,10 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     unshared: boolean;
     /** 0 where a fold is a walk of the chain: see `detour` in `everyone.ts`. */
     detours: number;
-    /** How many voices in the list carry a locus; with none, a fold allocates nothing. */
-    loci: number;
+    /** How many voices in the list carry a role; with none, a fold allocates nothing. */
+    roleVoices: number;
+    /** The tags the mix's options declare roles. */
+    readonly roleTags: readonly string[] | undefined;
     /** What every motion patch it plays asks for its voice's time, holding this mix weakly. */
     owner: MotionOwner | null;
     /** How many voices in the list are anchored, so a sync with none skips placing them. */
@@ -191,9 +204,9 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     readonly lerpsInto: (LerpInto | undefined)[];
     /** By slot, a stock scalar channel's arithmetic, which a fold applies without calling the channel. */
     readonly scalars: ('sum' | 'mul' | 'max' | undefined)[];
-    /** What a fold with a locus in play gathers into, one per depth of folds under way. */
-    readonly locusScratch: LocusScratch<I, O>[];
-    locusDepth: number;
+    /** What a fold with a role in play gathers into, one per depth of folds under way. */
+    readonly roleScratch: RoleScratch<I, O>[];
+    roleDepth: number;
     readonly slotOf: Map<string, number>;
     lanes: Lanes<I, O> | null;
     handles: HandleHost<I, O> | null;
@@ -209,6 +222,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     keys: Keys | null;
     /** With a history store, the voices it paged out whose handles are still held; null without one. */
     outs: Outs | null;
+    readonly pose: () => O;
     constructor(kit: Kit<O>, opts: MixOptions, 
     /** The lanes an entry was built with; null in one that leaves them out. */
     lanesOf: typeof Lanes | null);
@@ -237,7 +251,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         off: number;
     };
     cue(spec: VoiceSpec<I, O>): Handle<I>;
-    blend(members: readonly (Patch<I, O, unknown> | BlendMember<I, O>)[], by: Signal<I>, spec?: Omit<VoiceSpec<I, O>, 'patch' | 'weight' | 'locus'>): Handle<I>[];
+    blend(members: readonly (Patch<I, O, unknown> | BlendMember<I, O>)[], by: Signal<I>, spec?: Omit<VoiceSpec<I, O>, 'patch' | 'weight' | 'role' | 'locus' | 'within'>): Handle<I>[];
     owns(spec: OwnerSpec<I>): Handle<I>;
     span(spec: SpanSpec<I>): SpanHandle<I>;
     arc(spec: ArcSpec<I, O>): ArcHandle<I>;
@@ -252,6 +266,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     project(at: number | {
         readonly frame: number;
     }): Projection<I, O>;
+    trace(from: number, to: number, opts?: TraceOptions): Trace<I, O>;
     announce(name: string, opts?: {
         at?: number;
         score?: string;
@@ -260,27 +275,17 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     /** Throws for a mix taken off its transport. */
     attached(): void;
     marks(from: number, to: number): Marked[];
-    atRest(subject: I): boolean;
-    rests(pose: O): boolean;
     rebase(): void;
     voices(tag?: string): Handle<I>[];
     get live(): boolean;
     get inert(): boolean;
-    private restful;
     get rate(): number;
     set rate(r: number);
     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;
-    drop(subject: I): void;
-    /** Lets `voice` go of a dropped subject. Methods rather than closures, so a drop makes neither. */
-    private forgetIn;
-    private releaseIn;
-    private recordDrop;
     touch(subject?: I): void;
     drain<E = unknown>(tag?: string): Sent<I, E>[];
     /** Voices whose stop 0 is mid-computation, so a fold for one cannot re-enter itself. */
@@ -292,15 +297,13 @@ export declare class Mixer<I, O> implements Mix<I, O> {
      */
     restStamps: Store<I, number> | null;
     /** What a probe's record of rest is good for: moved by a new frame, version, relink, or stir. */
-    private restsEpoch;
-    private restsFrame;
-    private restsVersion;
-    private restsRelinks;
-    private restsStirs;
+    restsEpoch: number;
+    restsFrame: number;
+    restsVersion: number;
+    restsRelinks: number;
+    restsStirs: number;
     /** The pose `atRest` folds into where no probe this frame answers. */
-    private restScratch;
-    private restsLaned;
-    private restsKey;
+    restScratch: O | undefined;
 }
 declare const methods: {
     fold: typeof fold;
@@ -308,7 +311,7 @@ declare const methods: {
     linked: typeof linked;
     foldWith: typeof foldWith;
     owedBy: typeof owedBy;
-    foldLoci: typeof foldLoci;
+    foldRoles: typeof foldRoles;
     foldDetour: typeof foldDetour;
     foldSharers: typeof foldSharers;
     shared: typeof shared;
@@ -323,6 +326,7 @@ declare const methods: {
     baseFor: typeof baseFor;
     slopeFor: typeof slopeFor;
     prime: typeof prime;
+    primeLaned: typeof primeLaned;
     capped: typeof capped;
     horizonFor: typeof horizonFor;
     weigh: typeof weigh;
@@ -344,7 +348,22 @@ declare const methods: {
     sinceOf: typeof sinceOf;
     shownOf: typeof shownOf;
     keep: typeof keep;
-    foldLocus: typeof foldLocus;
+    foldRole: typeof foldRole;
+    atRest: typeof atRest;
+    rests: typeof rests;
+    restful: typeof restful;
+    still: typeof still;
+    restsLaned: typeof restsLaned;
+    restsKey: typeof restsKey;
+    plot: typeof plot;
+    place: typeof place;
+    moved: typeof moved;
+    put: typeof put;
+    around: typeof around;
+    drop: typeof drop;
+    forgetIn: typeof forgetIn;
+    releaseIn: typeof releaseIn;
+    recordDrop: typeof recordDrop;
 };
 type Methods = typeof methods;
 export interface Mixer<I, O> extends Methods {
@@ -352,13 +371,13 @@ export interface Mixer<I, O> extends Methods {
 /** Makes a mix the host asked for, with the registry's history where it names none, and lists it there. */
 export declare function made<I, O, H>(kit: Kit<O>, opts: MixOptions<H>, lanes: typeof Lanes | null): Mix<I, O, H>;
 /**
- * The one that ships: every form on the CPU, probed per subject on demand.
+ * The engine that ships, running every form on the CPU. It probes per subject on demand.
  *
  * @category engine
  */
 export declare const mixer: Engine;
 /**
- * Makes a mix over a kit, on the engine the options name or the stock one.
+ * Makes a mix over a kit. It runs on the engine the options name, or the stock one.
  *
  * @category mix
  */