@msb235/blits 0.15.1 → 0.16.1

package/dist/everyone.d.ts

@@ -65,11 +65,22 @@ export declare function unsight<I, O>(voice: Voice<I, O>, slot: number): void;
  * positions take their own records now, since each held the one.
  */
 export declare function unshare<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, kept?: boolean, keeper?: I): void;
-/**
- * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
- * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
- * `foldWith` asks one number.
- */
-export declare function detour<I, O>(mix: Mixer<I, O>): void;
 /** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
 export declare function inherit<I, O>(voice: Voice<I, O>, held: Subject<unknown>, slot: number): void;
+/** What the general path calls on a sharing voice, reached through `Lanes`, so a lean bundle leaves it out. */
+export declare const share: {
+    shares: typeof shares;
+    outgrow: typeof outgrow;
+    everyoneOf: typeof everyoneOf;
+    sighted: typeof sighted;
+    sight: typeof sight;
+    weightAt: typeof weightAt;
+    weighAt: typeof weighAt;
+    open: typeof open;
+    shut: typeof shut;
+    restamp: typeof restamp;
+    unsight: typeof unsight;
+    unshare: typeof unshare;
+    inherit: typeof inherit;
+};
+export type Share = typeof share;

package/dist/everyone.js

@@ -1,6 +1,7 @@
 import { headOf } from './chain.js';
 import { numericOf } from './channels.js';
 import { record } from './record.js';
+import { detour } from './roster.js';
 /**
  * Whether a voice can keep one record for every subject, decided when it is cued. A record holds
  * what a voice knows of one subject; where the voice is over every subject with no stagger, keeps
@@ -263,17 +264,25 @@ export function unshare(mix, voice, kept = false, keeper) {
     detour(mix);
     mix.lanes?.refill();
 }
-/**
- * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
- * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
- * `foldWith` asks one number.
- */
-export function detour(mix) {
-    mix.detours = mix.roleVoices + mix.sharers.length + (mix.unshared ? 1 : 0);
-}
 /** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
 export function inherit(voice, held, slot) {
     held.weight = weightAt(voice, slot);
     open(voice, held, slot);
     unsight(voice, slot);
 }
+/** What the general path calls on a sharing voice, reached through `Lanes`, so a lean bundle leaves it out. */
+export const share = {
+    shares,
+    outgrow,
+    everyoneOf,
+    sighted,
+    sight,
+    weightAt,
+    weighAt,
+    open,
+    shut,
+    restamp,
+    unsight,
+    unshare,
+    inherit,
+};

package/dist/fade.d.ts

@@ -3,7 +3,11 @@ import type { Left, Parted, Parting } from './subject.js';
 import type { Voice } from './voice.js';
 /** Starts one subject's ramp out of a voice, or takes it out at once for a ramp of 0. */
 export declare function fadeSubject<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, over?: number): void;
-/** What a subject's own ramp out of a voice leaves of its weight this frame, 0..1. */
+/**
+ * What a subject's own ramp out of a voice leaves of its weight this frame. It also holds the
+ * voice's fade in where the ramp began, as a fade out of the whole voice does, so it is a ratio to
+ * the fade in the voice's envelope gives.
+ */
 export declare function parting<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number): number;
 /**
  * Takes a subject out of one voice for good, as of mix time `at`: the voice forgets its record,
@@ -30,7 +34,19 @@ export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
     at?: 'rest';
     deadline?: number;
     back?: boolean;
+    stays?: boolean;
 }, at?: number): void;
+/**
+ * Keeps a voice faded at the end of its passes with its owner, live and quiet, rather than letting
+ * it leave; the owner, where it holds no child still playing, leaves at `at`, or stays quiet in
+ * turn where an owner holds it.
+ */
+export declare function stay<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at: number): void;
+/**
+ * Lets an owner holding no child still playing leave at `at`; under history one an owner holds
+ * stays with it instead, quiet while its children are.
+ */
+export declare function release<I, O>(mix: Mixer<I, O>, owner: Voice<I, O>, at: number): void;
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
  * curve, at the whole curve per `over` ms. A fade waiting for rest is taken back at once. A voice
@@ -44,5 +60,10 @@ export declare function beginRise<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
  * exactly there; at or behind now, the fade began then and is partway.
  */
 export declare function fadeAt<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at: number, over: number | undefined): void;
+/**
+ * Brings back a voice kept quiet past its passes, its clock back in them by mix time `now`: it
+ * climbs from nothing over the fade it left over, from when its clock reached them.
+ */
+export declare function rouse<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, now: number): void;
 /** Removes a voice, recording that it left at `at`, default now. */
 export declare function retire<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at?: number): void;

package/dist/fade.js

@@ -1,10 +1,10 @@
 import { changed, headOf, unlink } from './chain.js';
-import { envelope } from './clock.js';
+import { envelope, fadeInAt } from './clock.js';
 import { schedule } from './due.js';
-import { unshare, unsight } from './everyone.js';
 import { leave, noted, releasing } from './history.js';
 import { markOf } from './marks.js';
-import { orphan, ownerReading } from './owner.js';
+import { startedAt } from './origin.js';
+import { orphan, ownerReading, plays } from './owner.js';
 import { startOf } from './place.js';
 import { isRested } from './record.js';
 import { scoreTouched } from './scored.js';
@@ -14,7 +14,7 @@ import { unreach } from './unreached.js';
 export function fadeSubject(mix, voice, subject, over) {
     if (voice.state === 'done' || voice.parted?.has(subject) || voice.parts?.has(subject))
         return;
-    unshare(mix, voice);
+    mix.share?.unshare(mix, voice);
     mix.stir();
     const ms = mix.reduced ? 0 : (over ?? voice.fade.out ?? 0);
     const at = Number.isNaN(mix.now) ? startOf(voice) : mix.now;
@@ -28,12 +28,26 @@ export function fadeSubject(mix, voice, subject, over) {
     schedule(mix, voice);
     mix.lanes?.refill();
 }
-/** What a subject's own ramp out of a voice leaves of its weight this frame, 0..1. */
+/**
+ * What a subject's own ramp out of a voice leaves of its weight this frame. It also holds the
+ * voice's fade in where the ramp began, as a fade out of the whole voice does, so it is a ratio to
+ * the fade in the voice's envelope gives.
+ */
 export function parting(voice, subject, now) {
     const r = voice.parts?.get(subject);
     if (r === undefined)
         return 1;
-    return envelope(0, { at: r.at, over: r.over, rest: false }, voice.ease, this.reducedNow, now, 0);
+    const reduced = this.reducedNow;
+    const w = envelope(0, { at: r.at, over: r.over, rest: false }, voice.ease, reduced, now, 0);
+    const fadeIn = voice.fade.in ?? 0;
+    const since = voice.subjects.get(subject)?.shown;
+    if (!(fadeIn > 0) || reduced || since === undefined || !(r.at < now))
+        return w;
+    const out = voice.out;
+    const climbing = fadeInAt(fadeIn, out, voice.ease, now, since, voice.stalls);
+    if (!(climbing > 0))
+        return w;
+    return w * (fadeInAt(fadeIn, out, voice.ease, now, since, voice.stalls, r.at) / climbing);
 }
 /**
  * Takes a subject out of one voice for good, as of mix time `at`: the voice forgets its record,
@@ -104,7 +118,7 @@ function forgetIn(mix, voice, subject) {
     if (head !== undefined && head.slot >= 0) {
         unreach(voice, head.slot, false);
         // What the voice kept for the subject while it shared one record, which `weightOf` reads.
-        unsight(voice, head.slot);
+        mix.share?.unsight(voice, head.slot);
     }
     const held = voice.subjects.get(subject);
     if (held !== undefined) {
@@ -135,7 +149,7 @@ export function beginFade(mix, voice, opts, at) {
     // A fade at rest marks each subject's record as it comes to rest, at its next read: one already
     // read this frame is read again, as after `touch`.
     if (opts.at === 'rest') {
-        unshare(mix, voice);
+        mix.share?.unshare(mix, voice);
         voice.seeks++;
     }
     voice.state = 'fading';
@@ -148,14 +162,49 @@ export function beginFade(mix, voice, opts, at) {
     };
     if (opts.back)
         voice.out.back = true;
+    if (opts.stays)
+        voice.out.stays = true;
     noted(mix, voice);
     // A fade at rest, from a voice's start, or of a voice yet to start takes it off its lane.
     if (opts.at === 'rest' || opts.back || waiting)
         mix.lanes?.invalidate();
     else
         mix.lanes?.refill();
-    if (over === 0 && opts.at !== 'rest')
-        retire(mix, voice, voice.out.at);
+    if (over === 0 && opts.at !== 'rest') {
+        if (opts.stays)
+            stay(mix, voice, voice.out.at);
+        else
+            retire(mix, voice, voice.out.at);
+    }
+}
+/**
+ * Keeps a voice faded at the end of its passes with its owner, live and quiet, rather than letting
+ * it leave; the owner, where it holds no child still playing, leaves at `at`, or stays quiet in
+ * turn where an owner holds it.
+ */
+export function stay(mix, voice, at) {
+    voice.state = 'live';
+    mix.lanes?.refill();
+    const owner = voice.owner;
+    if (owner.state === 'done')
+        return;
+    const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
+    if (plays(owner, now) || lingers(owner, at)) {
+        if (owner.fitting !== null && !voice.skipped)
+            refit(mix, owner, at);
+    }
+    else
+        release(mix, owner, at);
+}
+/**
+ * Lets an owner holding no child still playing leave at `at`; under history one an owner holds
+ * stays with it instead, quiet while its children are.
+ */
+export function release(mix, owner, at) {
+    if (owner.owner !== null && owner.state === 'live' && mix.opts.history !== undefined)
+        beginFade(mix, owner, { over: 0, stays: true }, at);
+    else
+        retire(mix, owner, at);
 }
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
@@ -184,7 +233,12 @@ export function beginRise(mix, voice, opts) {
     voice.out = null;
     voice.outAt = Number.POSITIVE_INFINITY;
     voice.state = waiting ? 'pending' : 'live';
+    if (waiting)
+        voice.begunSeq = Number.POSITIVE_INFINITY;
     voice.back = over > 0 && from < 1 ? { from, at, over } : null;
+    // Its fade in stood still from where the fade out began, and climbs on from where it stood.
+    if (!out.rest && out.at < at)
+        voice.stalls = [...(voice.stalls ?? []), out.at, at];
     if (waiting)
         changed(mix, voice);
     noted(mix, voice);
@@ -202,7 +256,7 @@ export function fadeAt(mix, voice, at, over) {
         return;
     const now = Number.isNaN(mix.now) ? startOf(voice) : mix.now;
     if (at <= now) {
-        beginFade(mix, voice, { over }, Math.max(startOf(voice), at));
+        beginFade(mix, voice, { over }, Math.max(startedAt(voice), at));
         mix.stir();
         return;
     }
@@ -211,6 +265,21 @@ export function fadeAt(mix, voice, at, over) {
     voice.outSet = true;
     noted(mix, voice);
 }
+/**
+ * Brings back a voice kept quiet past its passes, its clock back in them by mix time `now`: it
+ * climbs from nothing over the fade it left over, from when its clock reached them.
+ */
+export function rouse(mix, voice, now) {
+    const out = voice.out;
+    const edge = out.back === true ? voice.soonest : voice.span + voice.latest;
+    const reached = voice.reaches(edge);
+    const at = Math.max(out.at + out.over, reached <= now ? reached : now);
+    const over = mix.reduced ? 0 : out.over;
+    voice.out = null;
+    voice.back = over > 0 ? { from: 0, at, over } : null;
+    noted(mix, voice);
+    mix.lanes?.refill();
+}
 /** Whether a motion patch still asks this voice of this mix for its time. */
 function asks(mix, motion, voice) {
     return motion.owner === mix.owner && motion.ownerId === voice.id;
@@ -248,7 +317,7 @@ export function retire(mix, voice, at) {
     if (voice.owner !== null) {
         const span = voice.owner;
         leaving(mix, voice);
-        const owner = orphan(voice);
+        const owner = orphan(voice, now);
         if (owner !== null && !lingers(owner, voice.doneAt))
             retire(mix, owner, voice.doneAt);
         // A child the fit skipped had no time in it, so the rest of the fit stands: fitting again

package/dist/fill.js

@@ -472,7 +472,8 @@ export function call(voice, chans, rec, slot) {
         rec.delta = null;
         rec.probed = this.now;
         rec.seeks = voice.seeks;
-        return false;
+        // A role member is one at weight 0 too, unasked, and holds its role's place as on the general path.
+        return voice.spec.role !== undefined;
     }
     const kept = reading.kept;
     host.ready(voice, subject, rec);

package/dist/fit.js

@@ -50,6 +50,14 @@ function least(lo, hi, ok) {
         return lo;
     if (!ok(hi))
         return hi;
+    // An unbounded `hi`, as an `Infinity` hint gives, is brought to a finite one before halving.
+    if (hi === Number.POSITIVE_INFINITY) {
+        hi = Math.max(lo, 1) * 2;
+        while (!ok(hi)) {
+            lo = hi;
+            hi *= 2;
+        }
+    }
     for (let i = 0; i < 60; i++) {
         const mid = (lo + hi) / 2;
         if (ok(mid))

package/dist/fold.js

@@ -1,10 +1,7 @@
 import { foldNumber } from './channels.js';
 import { copy as copyValue, first } from './clone.js';
-import { open as openRecord, shut as shutRecord, weighAt } from './everyone.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
 const copy = copyValue;
-const open = openRecord;
-const shut = shutRecord;
 /** A record's band state, made when a rest-less channel first asks. */
 function bandsFor(held, n) {
     const bands = new Uint8Array(n);
@@ -107,9 +104,9 @@ export function shared(voice, slot, rec, q) {
         // A projection numbers no subject, and keeps nothing by subject.
         if (slot < 0)
             return q;
-        const cap = this.lanes.cap;
-        weighAt(voice, slot, rec.weight, cap);
-        shut(voice, rec, slot, cap);
+        const lanes = this.lanes;
+        this.share.weighAt(voice, slot, rec.weight, lanes.cap);
+        this.share.shut(voice, rec, slot, lanes.cap);
         return q;
     }
     const sharers = this.sharers;
@@ -265,7 +262,7 @@ export function foldSharers(pose, subject, head, q, before, laned, dry, except,
             continue;
         if (voice.id === except || voice.state === 'done')
             continue;
-        open(voice, rec, head.slot);
+        this.share.open(voice, rec, head.slot);
         const delta = this.read(voice, subject, now, dry, rec);
         if (owed >= 0 && voice.laned)
             this.lanes.paid(voice.id, owed, rec.weight);

package/dist/gone.js

@@ -77,6 +77,7 @@ export function goneIndex(mix) {
 /** Hands voices let go of from `gone` to the departed index, noting the latest that left. */
 function forgot(mix, out) {
     for (const v of out) {
+        mix.parters.delete(v);
         mix.departed.add(mix, v);
         if (v.doneAt > mix.transport.forgotTo)
             mix.transport.forgotTo = v.doneAt;

package/dist/handle.d.ts

@@ -11,7 +11,7 @@ export interface HandleHost<I, O> {
      * The voice's clock jumped: for an owner, so did every clock it holds. With `rebuild`, their
      * state is made again for where they now are. How sure that leaves it.
      */
-    sought(voice: Voice<I, O>, rebuild: boolean): Doubt;
+    sought(voice: Voice<I, O>, rebuild: boolean, ahead: boolean): Doubt;
     fade(voice: Voice<I, O>, opts: FadeOptions<I> | undefined): void;
     rise(voice: Voice<I, O>, opts: {
         over?: number;

package/dist/handle.js

@@ -115,14 +115,16 @@ export class VoiceHandle {
             return 'exact';
         voice.written = true;
         // A pending voice's clock is anchored at its start, so it starts there on time.
+        let ahead = false;
         if (voice.state !== 'pending') {
             const u = this.#host.nowFor(voice);
             leave(voice, u, true);
             voice.rebase(u);
+            ahead = elapsed > voice.anchorElapsed;
         }
         voice.anchorElapsed = elapsed;
         voice.seeks++;
-        const doubt = this.#host.sought(voice, opts?.state !== 'keep');
+        const doubt = this.#host.sought(voice, opts?.state !== 'keep', ahead);
         this.#host.changed(voice);
         if (this.#host.taping())
             this.#host.record(this, 'seek', (h) => h.seek(elapsed, opts));

package/dist/held.d.ts

@@ -22,7 +22,8 @@ export declare function sinceOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, del
 /**
  * The mix time a subject's fade in counts from: `since`, but no earlier than its voice starts,
  * where a voice sought ahead of its start has a subject's delay run out before it; and from when
- * the voice first showed, for one freezing before.
+ * the voice first showed, for one freezing before. Its start is where its owners' clocks first
+ * read it, as `since` is, not where they would by their controls now.
  */
 export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, since: number): number;
 /** Lists a record whose origin is still ahead of `now`, for a later change to the clock to move. */

package/dist/held.js

@@ -2,9 +2,7 @@ import { changed } from './chain.js';
 import { stepOf } from './clock.js';
 import { delayOf } from './delay.js';
 import { schedule } from './due.js';
-import { everyoneOf, inherit, sighted } from './everyone.js';
-import { originOf } from './origin.js';
-import { startOf } from './place.js';
+import { originOf, startedAt } from './origin.js';
 import { record } from './record.js';
 import { unreach, unreached } from './unreached.js';
 /** The record a voice gives every subject it does not reach. */
@@ -24,7 +22,7 @@ export function unreachedOf(voice, now) {
  */
 export function held(voice, subject, slot, guess = null) {
     if (voice.sharing) {
-        const all = everyoneOf(this, voice);
+        const all = this.share.everyoneOf(this, voice);
         if (all !== null)
             return all;
     }
@@ -67,8 +65,8 @@ export function held(voice, subject, slot, guess = null) {
     voice.subjects.set(subject, held);
     waits(voice, held, now);
     // A subject a voice saw while it shared one record was counted then.
-    if (sighted(voice, slot))
-        inherit(voice, held, slot);
+    if (voice.sighted !== null && this.share?.sighted(voice, slot))
+        this.share.inherit(voice, held, slot);
     else
         voice.seen++;
     if (delay > voice.latest) {
@@ -119,13 +117,21 @@ export function sinceOf(voice, delay) {
 /**
  * The mix time a subject's fade in counts from: `since`, but no earlier than its voice starts,
  * where a voice sought ahead of its start has a subject's delay run out before it; and from when
- * the voice first showed, for one freezing before.
+ * the voice first showed, for one freezing before. Its start is where its owners' clocks first
+ * read it, as `since` is, not where they would by their controls now.
  */
 export function shownOf(voice, since) {
-    const start = startOf(voice);
+    const start = startedAt(voice);
     const from = since < start ? start : since;
     return voice.freezesBefore && voice.opened < from ? voice.opened : from;
 }
+/**
+ * Whether a listed record stays listed at `now`: its origin is ahead, or it is a motion voice's,
+ * unread since its origin, which `still` asks after since the motion has no run for it yet.
+ */
+function stillEarly(voice, held, now) {
+    return !(held.since <= now) || (voice.motion !== undefined && !(held.probed >= held.since));
+}
 /** Lists a record whose origin is still ahead of `now`, for a later change to the clock to move. */
 export function waits(voice, held, now) {
     if (held.since <= now)
@@ -136,7 +142,7 @@ export function waits(voice, held, now) {
     if (early.length >= 64 && (early.length & (early.length - 1)) === 0) {
         let kept = 0;
         for (const h of early)
-            if (!(h.since <= now))
+            if (stillEarly(voice, h, now))
                 early[kept++] = h;
         early.length = kept;
     }
@@ -148,6 +154,7 @@ export function waits(voice, held, now) {
  */
 export function begin(mix, voice, now) {
     voice.state = 'live';
+    voice.begunSeq = mix.transport.seq;
     if (voice.anchorElapsed !== 0) {
         voice.seeks++;
         voice.rebuilds++;
@@ -179,7 +186,7 @@ export function reorigin(mix, voice, now) {
     let kept = 0;
     for (const held of early) {
         origin(mix, voice, held);
-        if (!(held.since <= now))
+        if (stillEarly(voice, held, now))
             early[kept++] = held;
     }
     early.length = kept;

package/dist/hosts.d.ts

@@ -4,6 +4,13 @@ import type { Booker, BookOptions, Handle } from './types.js';
 import type { Voice } from './voice.js';
 export declare function book<I, O>(mix: Mixer<I, O>, opts: BookOptions<unknown, I>): Booker;
 export declare function laneHost<I, O>(mix: Mixer<I, O>): LaneHost<I, O>;
+/**
+ * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
+ * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
+ * write several, and joins the crowd of voices writing those same channels. A motion going round
+ * an `ink` color's hue stays out, since a crowd solves its stretches straight across each axis.
+ */
+export declare function crowdable<I, O>(v: Voice<I, O>): boolean;
 /**
  * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has
  * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;

package/dist/hosts.js

@@ -3,9 +3,7 @@ import { Book } from './book.js';
 import { headOf } from './chain.js';
 import { numericOf } from './channels.js';
 import { stepOf } from './clock.js';
-import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
-import { unshare, unsight, weightAt } from './everyone.js';
 import { beginFade, beginRise, fadeAt, fadeSubject } from './fade.js';
 import { goneIndex } from './gone.js';
 import { VoiceHandle } from './handle.js';
@@ -67,7 +65,7 @@ export function laneHost(mix) {
             for (const voice of mix.general) {
                 unreach(voice, slot, false);
                 if (voice.sighted !== null)
-                    unsight(voice, slot);
+                    mix.share?.unsight(voice, slot);
             }
             for (const voice of goneIndex(mix).general)
                 unreach(voice, slot, false);
@@ -110,6 +108,19 @@ export function laneHost(mix) {
         kept: (voice) => stateful(mix, voice),
     };
 }
+/**
+ * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
+ * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
+ * write several, and joins the crowd of voices writing those same channels. A motion going round
+ * an `ink` color's hue stays out, since a crowd solves its stretches straight across each axis.
+ */
+export function crowdable(v) {
+    return (v.named !== null &&
+        v.named.size === 1 &&
+        v.spec.role === undefined &&
+        (v.slots.length === 1 || v.motion === undefined) &&
+        v.motion?.round !== true);
+}
 /**
  * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has
  * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;
@@ -181,7 +192,7 @@ export function stateful(mix, voice) {
     voice.keeping = true;
     // The call that kept state was for the subject last sent to, whose record the state is on.
     if (voice.sharing)
-        unshare(mix, voice, true, mix.sending.subject);
+        mix.share?.unshare(mix, voice, true, mix.sending.subject);
     mix.lanes?.invalidate();
 }
 export function handle(mix, voice) {
@@ -205,7 +216,11 @@ function handleHost(mix) {
             mix.lanes?.refill();
         },
         // A delta read before an owner's seek, or a hit booked, is not taken as standing after it.
-        sought: (voice, rebuild) => {
+        sought: (voice, rebuild, ahead) => {
+            if (ahead && voice.holding !== null && !mix.projecting) {
+                mix.leapt ??= new Set();
+                mix.leapt.add(voice);
+            }
             if (rebuild)
                 voice.rebuilds++;
             let doubt = seekDoubt(mix, voice, rebuild);
@@ -248,7 +263,9 @@ function handleHost(mix) {
                 ? undefined
                 : voice.subjects.get(subject);
             // A voice that stopped sharing makes a subject's record at its next read, from what it kept.
-            return held !== undefined ? held.weight : weightAt(voice, slot);
+            if (held !== undefined)
+                return held.weight;
+            return mix.share === null ? 0 : mix.share.weightAt(voice, slot);
         },
         taping: () => taping(mix),
         record: (h, label, again) => record(mix, label, (stage) => {

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export type { LastOptions, NumberOptions, NumberTuple, Vec } from './channels.js';
 export { kit, last, max, mul, sum, vec } from './channels.js';
 export type { ColorOptions } from './color.js';
-export { color, css, mixHex, oklab, toHex } from './color.js';
+export { color, css, ink, mixHex, oklab, toHex } from './color.js';
 export type { Curve } from './easing.js';
 export { curve } from './easing.js';
 export type { Claim, Fit, FitPlan, Layout, Order, OverrunOptions, SpanClaim, Strength, } from './fit.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { kit, last, max, mul, sum, vec } from './channels.js';
-export { color, css, mixHex, oklab, toHex } from './color.js';
+export { color, css, ink, mixHex, oklab, toHex } from './color.js';
 export { curve } from './easing.js';
 export { conclude, condense, lax, layout, overrun, pipe, plain, shed, } from './fit.js';
 export { mix, mixer } from './mixer.js';

package/dist/lane.d.ts

@@ -185,6 +185,8 @@ export declare class Lane<I, O> implements Positions<I, O> {
      * checked against every lane up to some epoch has met this one if this one's is no later.
      */
     epoch: number;
+    /** The lanes' probe count when it was made: a probe no later read its subject elsewhere. */
+    made: number;
     /**
      * Per position, `STRIDE` numbers side by side, so one subject's are one read from memory: its
      * delay, its `since`, its weight at the last fill, its weight at the last fill a probe read, a

package/dist/lane.js

@@ -37,6 +37,8 @@ export class Lane {
      * checked against every lane up to some epoch has met this one if this one's is no later.
      */
     epoch = 0;
+    /** The lanes' probe count when it was made: a probe no later read its subject elsewhere. */
+    made = 0;
     /**
      * Per position, `STRIDE` numbers side by side, so one subject's are one read from memory: its
      * delay, its `since`, its weight at the last fill, its weight at the last fill a probe read, a

package/dist/lanes.d.ts

@@ -1,4 +1,4 @@
-import type { Column } from './columns.js';
+import { flush, pullRun, writeLater } from './columns.js';
 import { type Copier, copy } from './copyout.js';
 import { type Crowd, row } from './crowd.js';
 import { call, foldKeys, one, parting, readKeyed, reset, run, runEveryone, signalled, subjectAt } from './fill.js';
@@ -7,6 +7,8 @@ import { type Lane, type Laned, type Role } from './lane.js';
 import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import { Placed } from './placed.js';
+import type { Column } from './pull.js';
+import { renumber } from './renumber.js';
 import { type Seat } from './seat.js';
 import type { Watcher } from './stretch.js';
 import type { Subject } from './subject.js';
@@ -64,6 +66,29 @@ export interface LaneHost<I, O> {
  */
 export declare class Lanes<I, O> implements Watcher {
     readonly host: LaneHost<I, O>;
+    /** What the general path calls on a sharing voice, given to a mix by its engine so a lean bundle leaves it out. */
+    static readonly share: {
+        shares: typeof import("./everyone.js").shares;
+        outgrow: typeof import("./everyone.js").outgrow;
+        everyoneOf: typeof import("./everyone.js").everyoneOf;
+        sighted: typeof import("./everyone.js").sighted;
+        sight: typeof import("./everyone.js").sight;
+        weightAt: typeof import("./everyone.js").weightAt;
+        weighAt: typeof import("./everyone.js").weighAt;
+        open: typeof import("./everyone.js").open;
+        shut: typeof import("./everyone.js").shut;
+        restamp: typeof import("./everyone.js").restamp;
+        unsight: typeof import("./everyone.js").unsight;
+        unshare: typeof import("./everyone.js").unshare;
+        inherit: typeof import("./everyone.js").inherit;
+    };
+    /** What `pull` calls on lanes alone. */
+    readonly pulls: {
+        pullRun: typeof pullRun;
+        writeLater: typeof writeLater;
+        flush: typeof flush;
+        renumber: typeof renumber;
+    };
     readonly numbers: Numbers<I>;
     lanes: Lane<I, O>[];
     /** The lanes over every subject that have started playing, by epoch. */