@msb235/blits 0.3.0 → 0.5.0

package/dist/move.d.ts

@@ -0,0 +1,9 @@
+import type { Mixer } from './mixer.js';
+/** The next frame among every mix's. */
+export declare function nextFrame(): number;
+/** Whether a sync that leaves the mix clock where it was still has something to land. */
+export declare function waits<I, O>(mix: Mixer<I, O>): boolean;
+/** Moves the mix clock to `now`: voices start, finite loops end, and fades finish. */
+export declare function move<I, O>(mix: Mixer<I, O>, now: number): void;
+/** Lets go of the voices that have left and that history no longer reaches. */
+export declare function forget<I, O>(mix: Mixer<I, O>, now: number): void;

package/dist/move.js

@@ -0,0 +1,190 @@
+import { changed, unindex } from './chain.js';
+import { popDue, schedule } from './due.js';
+import { beginFade, part, retire } from './fade.js';
+import { started } from './held.js';
+import { ownerReading } from './owner.js';
+import { mixAt, place, repin, startOf } from './place.js';
+import { unplay } from './strays.js';
+/** Numbers every mix's frames apart, so a blend's read is never taken for another mix's or frame's. */
+let frames = 0;
+/** The next frame among every mix's. */
+export function nextFrame() {
+    return ++frames;
+}
+/** Whether a sync that leaves the mix clock where it was still has something to land. */
+export function waits(mix) {
+    return mix.stirred || mix.anchored > 0 || (mix.pins !== null && mix.pins.size > 0);
+}
+/** Moves the mix clock to `now`: voices start, finite loops end, and fades finish. */
+export function move(mix, now) {
+    mix.moving = true;
+    try {
+        moveTo(mix, now);
+    }
+    finally {
+        mix.moving = false;
+    }
+}
+function moveTo(mix, now) {
+    mix.now = now;
+    mix.frame = nextFrame();
+    mix.reducedNow = mix.reduced;
+    for (const a of mix.announced)
+        if (Number.isNaN(a.at))
+            a.at = mix.u;
+    if (mix.pins !== null && mix.pins.size > 0)
+        repin(mix);
+    if (mix.anchored > 0)
+        place(mix);
+    if (mix.announced.length > 0) {
+        // Kept while still ahead, or while history reaches it; anchors waiting on one were placed above.
+        const reach = now - (mix.opts.history?.ms ?? 0);
+        mix.announced = mix.announced.filter((a) => mixAt(mix, a.at) >= reach);
+    }
+    // A live mix visits only the voices due by now; a projection, which copies few, visits all.
+    const visit = mix.projecting || mix.walkAll ? mix.cued : popDue(mix, now);
+    for (const voice of visit) {
+        if (voice.state === 'done')
+            continue;
+        if (Number.isNaN(voice.opened))
+            voice.opened = now;
+        if ((voice.state === 'live' || voice.state === 'held') && voice.outAt <= now)
+            beginFade(mix, voice, {}, Math.max(startOf(voice), voice.outAt));
+        if (voice.state === 'pending' &&
+            (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start) {
+            voice.state = 'live';
+            started(mix, voice);
+            changed(mix, voice);
+        }
+        if (voice.state !== 'pending' && Number.isFinite(voice.span)) {
+            const end = voice.span + voice.latest;
+            if (voice.elapsedAt(now) >= end) {
+                voice.play(true);
+                // The fade starts when the last pass ended, not at the frame that noticed, so it plays
+                // the same at any frame rate and a read at another time can find it.
+                if (voice.state === 'live') {
+                    if (voice.holdsAfter)
+                        voice.state = 'held';
+                    else
+                        beginFade(mix, voice, {}, Math.max(startOf(voice), Math.min(now, voice.timeAt(end))));
+                }
+            }
+            else if (voice.state === 'held')
+                voice.state = 'live';
+        }
+        // A projection reads a finished ramp as weight 0, and leaves the live voice's subjects be.
+        if (voice.parts !== null && !mix.projecting)
+            for (const [subject, r] of voice.parts)
+                if (now - r.at >= r.over)
+                    part(mix, voice, subject, r.at + r.over);
+        if (voice.state === 'fading' && voice.out) {
+            const { at, over, rest, deadline } = voice.out;
+            const spent = now - at;
+            if (rest) {
+                const out = deadline !== undefined && spent >= deadline;
+                const settled = voice.seen > 0 && voice.restedCount >= voice.seen;
+                if (out)
+                    retire(mix, voice, at + deadline);
+                else if (settled)
+                    retire(mix, voice);
+            }
+            else if (spent >= over)
+                retire(mix, voice, at + over);
+        }
+        if (!mix.projecting)
+            schedule(mix, voice);
+    }
+    mix.stirred = false;
+    if (mix.retired.length > 0)
+        prune(mix);
+    forget(mix, now);
+}
+/** Past this many voices retiring in one frame, one pass over the list beats a search for each. */
+const SEARCHED = 8;
+/**
+ * Takes the voices retired since the last prune out of the list, in list order. A few are found by
+ * their id, which the list is in order of, so the voices still in it are not read.
+ */
+function prune(mix) {
+    const retired = mix.retired;
+    mix.retired = [];
+    const voices = mix.cued;
+    let at = null;
+    // A projection's list holds copies of voices gone before it, which only a pass takes out.
+    if (retired.length <= SEARCHED && !mix.projecting) {
+        if (retired.length > 1)
+            retired.sort((a, b) => a.id - b.id);
+        at = [];
+        for (let k = 0; k < retired.length; k++) {
+            const voice = retired[k];
+            const i = voice === retired[k - 1] ? -1 : indexOf(voices, voice);
+            if (i < 0) {
+                at = null;
+                break;
+            }
+            at.push(i);
+        }
+    }
+    let pruned = false;
+    if (at !== null) {
+        for (const voice of retired)
+            pruned = leave(mix, voice) || pruned;
+        for (let k = at.length - 1; k >= 0; k--)
+            voices.splice(at[k], 1);
+    }
+    else {
+        let kept = 0;
+        for (let i = 0; i < voices.length; i++) {
+            const voice = voices[i];
+            if (voice.state !== 'done')
+                voices[kept++] = voice;
+            else
+                pruned = leave(mix, voice) || pruned;
+        }
+        voices.length = kept;
+    }
+    if (pruned)
+        mix.general = mix.general.filter((v) => v.state !== 'done');
+}
+/** The voice's place in a list in id order, or -1 where it is not there. */
+function indexOf(voices, voice) {
+    let lo = 0;
+    let hi = voices.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >>> 1;
+        const id = voices[mid].id;
+        if (id === voice.id)
+            return voices[mid] === voice ? mid : -1;
+        if (id < voice.id)
+            lo = mid + 1;
+        else
+            hi = mid - 1;
+    }
+    return -1;
+}
+/** Lets go of a retired voice's place in the mix; whether it was among the voices naming no subject. */
+function leave(mix, voice) {
+    if (mix.opts.history)
+        mix.gone.push(voice);
+    else
+        mix.parters.delete(voice);
+    unplay(mix, voice);
+    changed(mix, voice);
+    if (voice.named !== null)
+        unindex(mix, voice);
+    if (voice.holding !== null && mix.owners !== null)
+        mix.owners = mix.owners.filter((v) => v !== voice);
+    if (voice.spec.locus !== undefined)
+        mix.loci--;
+    if (voice.spec.anchor !== undefined)
+        mix.anchored--;
+    return voice.named === null;
+}
+/** Lets go of the voices that have left and that history no longer reaches. */
+export function forget(mix, now) {
+    const history = mix.opts.history;
+    if (history && mix.gone.length > 0) {
+        const reach = now - history.ms;
+        mix.gone = mix.gone.filter((v) => v.doneAt >= reach);
+    }
+}

package/dist/named.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The subjects a voice's `subjects` names, once each in the order first named. Most voices name
+ * one, which a `Set` per voice spends its smallest table on.
+ */
+export declare class Named<I> {
+    readonly list: readonly I[];
+    private readonly set;
+    constructor(subjects: Iterable<I>);
+    get size(): number;
+    has(subject: I): boolean;
+    [Symbol.iterator](): Iterator<I>;
+}

package/dist/named.js

@@ -0,0 +1,39 @@
+/** Past this many, `has` looks in a set rather than down the list. */
+const FEW = 8;
+/**
+ * The subjects a voice's `subjects` names, once each in the order first named. Most voices name
+ * one, which a `Set` per voice spends its smallest table on.
+ */
+export class Named {
+    list;
+    set;
+    constructor(subjects) {
+        const list = [];
+        let set = null;
+        for (const s of subjects) {
+            if (set !== null) {
+                if (!set.has(s)) {
+                    set.add(s);
+                    list.push(s);
+                }
+            }
+            else if (!list.includes(s)) {
+                list.push(s);
+                if (list.length > FEW)
+                    set = new Set(list);
+            }
+        }
+        // Exactly as long as it is: a list grown by push keeps room for 17.
+        this.list = list.slice();
+        this.set = set;
+    }
+    get size() {
+        return this.list.length;
+    }
+    has(subject) {
+        return this.set === null ? this.list.includes(subject) : this.set.has(subject);
+    }
+    [Symbol.iterator]() {
+        return this.list[Symbol.iterator]();
+    }
+}

package/dist/numbers.d.ts

@@ -6,14 +6,26 @@ export declare const absent: unique symbol;
  * them, so numbering one never keeps it alive.
  */
 export declare class Numbers<I> {
-    private readonly gone;
+    private readonly owner;
     private next;
-    private readonly free;
+    /** Numbers released for reuse; null until one is, as most patches never release one. */
+    private free;
+    /** By number: the subject, a weak reference to it, or undefined for a number not in use. */
     private readonly refs;
-    private live;
-    private readonly tokens;
-    private readonly registry;
-    constructor(gone: (slot: number) => void);
+    /**
+     * Made at the second object numbered, when the first is registered too: a motion patch per voice
+     * holds a `Numbers`, mostly for one subject, whose collection frees nothing worth a registry.
+     * Each object's weak reference is also its token, so a number reused after its subject is
+     * released never hears of the old one's collection.
+     */
+    private registry;
+    /** The one object numbered before there was a registry, and its number. */
+    private lone;
+    private loneSlot;
+    /** Takes the owner rather than a callback, which would cost a closure and its context per patch. */
+    constructor(owner: {
+        forget(slot: number): void;
+    });
     /** One past the highest number handed out, so a loop over 0..size meets every live one. */
     get size(): number;
     take(subject: I): number;

package/dist/numbers.js

@@ -1,47 +1,73 @@
 /** What a number's subject is once it has none: released, or let go by the host. */
 export const absent = Symbol('absent');
+/** What `refs` holds for a subject that is itself `undefined`, the unit subject of some mixes. */
+const unit = Symbol('unit');
 /**
  * Hands each subject a small number to index flat arrays by, and takes it back when the subject is
  * released or, for an object, when the host lets it go. Objects are held weakly, as `Store` holds
  * them, so numbering one never keeps it alive.
  */
 export class Numbers {
-    gone;
+    owner;
     next = 0;
-    free = [];
-    refs = [];
-    live = new Uint8Array(0);
-    tokens = [];
-    registry = new FinalizationRegistry((slot) => this.release(slot));
-    constructor(gone) {
-        this.gone = gone;
+    /** Numbers released for reuse; null until one is, as most patches never release one. */
+    free = null;
+    /** By number: the subject, a weak reference to it, or undefined for a number not in use. */
+    // Room for one: an empty array written at 0 reserves 17, and most patches number one subject.
+    refs = [undefined];
+    /**
+     * Made at the second object numbered, when the first is registered too: a motion patch per voice
+     * holds a `Numbers`, mostly for one subject, whose collection frees nothing worth a registry.
+     * Each object's weak reference is also its token, so a number reused after its subject is
+     * released never hears of the old one's collection.
+     */
+    registry = null;
+    /** The one object numbered before there was a registry, and its number. */
+    lone = null;
+    loneSlot = -1;
+    /** Takes the owner rather than a callback, which would cost a closure and its context per patch. */
+    constructor(owner) {
+        this.owner = owner;
     }
     /** One past the highest number handed out, so a loop over 0..size meets every live one. */
     get size() {
         return this.next;
     }
     take(subject) {
-        const slot = this.free.pop() ?? this.next++;
-        if (slot >= this.live.length) {
-            const grown = new Uint8Array(Math.max(64, this.live.length * 2, slot + 1));
-            grown.set(this.live);
-            this.live = grown;
-        }
-        this.live[slot] = 1;
+        const slot = this.free?.pop() ?? this.next++;
+        let dead = -1;
         if (typeof subject === 'object' && subject !== null) {
-            this.refs[slot] = new WeakRef(subject);
-            const token = {};
-            this.tokens[slot] = token;
-            this.registry.register(subject, slot, token);
+            const ref = new WeakRef(subject);
+            this.refs[slot] = ref;
+            if (this.registry === null) {
+                if (this.lone === null) {
+                    this.lone = ref;
+                    this.loneSlot = slot;
+                    return slot;
+                }
+                this.registry = new FinalizationRegistry((slot) => this.release(slot));
+                const first = this.lone.deref();
+                if (first !== undefined)
+                    this.registry.register(first, this.loneSlot, this.lone);
+                // Collected with no registry to hear of it: released here, once this subject is numbered.
+                else
+                    dead = this.loneSlot;
+                this.lone = null;
+            }
+            this.registry.register(subject, slot, ref);
         }
         else
-            this.refs[slot] = subject;
+            this.refs[slot] = subject === undefined ? unit : subject;
+        if (dead >= 0)
+            this.release(dead);
         return slot;
     }
     subject(slot) {
-        if (this.live[slot] !== 1)
-            return absent;
         const ref = this.refs[slot];
+        if (ref === undefined)
+            return absent;
+        if (ref === unit)
+            return undefined;
         if (ref instanceof WeakRef) {
             const s = ref.deref();
             return s === undefined ? absent : s;
@@ -49,16 +75,18 @@ export class Numbers {
         return ref;
     }
     release(slot) {
-        if (this.live[slot] !== 1)
+        const ref = this.refs[slot];
+        if (ref === undefined)
             return;
-        this.live[slot] = 0;
-        const token = this.tokens[slot];
-        if (token !== undefined) {
-            this.registry.unregister(token);
-            this.tokens[slot] = undefined;
-        }
+        if (ref === this.lone)
+            this.lone = null;
+        else if (ref instanceof WeakRef)
+            this.registry?.unregister(ref);
         this.refs[slot] = undefined;
-        this.gone(slot);
-        this.free.push(slot);
+        this.owner.forget(slot);
+        if (this.free === null)
+            this.free = [slot];
+        else
+            this.free.push(slot);
     }
 }

package/dist/owed.d.ts

@@ -0,0 +1,24 @@
+/**
+ * By subject number, the laned voices whose first meeting with the subject its probes fold on the
+ * general path this fill, after the lanes' values. Subjects meeting the same voices share one list.
+ */
+export declare class Owed {
+    /** By subject number, the fill it owes in, and which of `lists` it owes. */
+    private fill;
+    private at;
+    private readonly lists;
+    /** The fill now under way. */
+    private now;
+    /** A fill begins: nobody owes anything. */
+    begin(fill: number): void;
+    /** Makes room for subject numbers below `cap`. */
+    grow(cap: number): void;
+    /** Whether the subject at `slot` owes some laned voice this fill. */
+    owes(slot: number): boolean;
+    /** Whether the subject at `slot` owes voice `id` this fill. */
+    owesVoice(slot: number, id: number): boolean;
+    /** The subject at `slot` owes the voices `met`, which the caller may reuse after. */
+    owe(slot: number, met: readonly number[]): void;
+    /** Whether `met` is the last list a subject came to owe this fill. */
+    last(met: readonly number[]): boolean;
+}

package/dist/owed.js

@@ -0,0 +1,51 @@
+/**
+ * By subject number, the laned voices whose first meeting with the subject its probes fold on the
+ * general path this fill, after the lanes' values. Subjects meeting the same voices share one list.
+ */
+export class Owed {
+    /** By subject number, the fill it owes in, and which of `lists` it owes. */
+    fill = new Int32Array(0);
+    at = new Int32Array(0);
+    lists = [];
+    /** The fill now under way. */
+    now = 0;
+    /** A fill begins: nobody owes anything. */
+    begin(fill) {
+        this.now = fill;
+        this.lists.length = 0;
+    }
+    /** Makes room for subject numbers below `cap`. */
+    grow(cap) {
+        const fill = new Int32Array(cap);
+        fill.set(this.fill);
+        this.fill = fill;
+        const at = new Int32Array(cap);
+        at.set(this.at);
+        this.at = at;
+    }
+    /** Whether the subject at `slot` owes some laned voice this fill. */
+    owes(slot) {
+        return this.lists.length > 0 && this.fill[slot] === this.now;
+    }
+    /** Whether the subject at `slot` owes voice `id` this fill. */
+    owesVoice(slot, id) {
+        return this.lists[this.at[slot]].includes(id);
+    }
+    /** The subject at `slot` owes the voices `met`, which the caller may reuse after. */
+    owe(slot, met) {
+        if (!this.last(met))
+            this.lists.push(met.slice());
+        this.fill[slot] = this.now;
+        this.at[slot] = this.lists.length - 1;
+    }
+    /** Whether `met` is the last list a subject came to owe this fill. */
+    last(met) {
+        const last = this.lists[this.lists.length - 1];
+        if (last === undefined || last.length !== met.length)
+            return false;
+        for (let i = 0; i < met.length; i++)
+            if (last[i] !== met[i])
+                return false;
+        return true;
+    }
+}

package/dist/owner.d.ts

@@ -0,0 +1,43 @@
+import type { Patch } from './types.js';
+import type { Voice } from './voice.js';
+/** What an owner is cued with in place of a patch: it writes nothing, so no fold ever meets it. */
+export declare const ownerPatch: Patch<unknown, unknown, unknown>;
+/** What an owner keeps of the voices it holds. */
+export declare class Holding<V> {
+    /** Its children still in the mix, in cue order. */
+    children: V[];
+    /** How many it has held, and how many of those finished their passes. */
+    kids: number;
+    played: number;
+}
+/**
+ * What an owner's clock reads at mix time `now`, through every owner above it: -Infinity before it
+ * starts, where its children show nothing.
+ */
+export declare function ownerReading<I, O>(owner: Voice<I, O>, now: number): number;
+/** What a voice an owner holds reads at mix time `now`: -Infinity before the owner starts. */
+export declare function ownedElapsed<I, O>(voice: Voice<I, O>, owner: Voice<I, O>, now: number): number;
+/** The mix time an owner's clock reads `t`, by its controls now; Infinity where it never will. */
+export declare function mixTime<I, O>(owner: Voice<I, O>, t: number): number;
+/** Takes a child into its owner. */
+export declare function adopt<I, O>(owner: Voice<I, O>, child: Voice<I, O>): void;
+/** A child left: its owner, where that was its last child and it should leave too. */
+export declare function orphan<I, O>(child: Voice<I, O>): Voice<I, O> | null;
+/** A child finished its passes: its owner has played once every child it held has. */
+export declare function childPlayed<I, O>(owner: Voice<I, O>): void;
+/** Every voice an owner holds, its children's children included. */
+export declare function descendants<I, O>(owner: Voice<I, O>, visit: (v: Voice<I, O>) => void): void;
+/** Whether any owner above a voice reads a signal for its weight, which lanes cannot fill. */
+export declare function signalled<I, O>(voice: Voice<I, O>): boolean;
+/** Whether any owner above a voice weighs it by input from outside the clock. */
+export declare function heldByInput<I, O>(voice: Voice<I, O>): boolean;
+/**
+ * What one owner multiplies into its children's weight for a subject at mix time `now`: its weight,
+ * or its signal's read by `base`, times its own fade, held to 0..1. Its fade in counts from when it
+ * started, or from when it first showed where it holds before.
+ */
+export declare function ownWeight<I, O>(owner: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
+/** What every owner above a voice multiplies into its weight. */
+export declare function ownersWeight<I, O>(voice: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
+/** Points a projection's copies at each other's owners, each owner holding only copies. */
+export declare function relink<I, O>(copies: readonly Voice<I, O>[]): void;

package/dist/owner.js

@@ -0,0 +1,117 @@
+import { 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({
+    form: 'fn',
+    duration: 0,
+    writes: [],
+    at: () => ({}),
+});
+/** What an owner keeps of the voices it holds. */
+export class Holding {
+    /** Its children still in the mix, in cue order. */
+    children = [];
+    /** How many it has held, and how many of those finished their passes. */
+    kids = 0;
+    played = 0;
+}
+/**
+ * What an owner's clock reads at mix time `now`, through every owner above it: -Infinity before it
+ * starts, where its children show nothing.
+ */
+export function ownerReading(owner, now) {
+    const t = owner.owner === null ? now : ownerReading(owner.owner, now);
+    return t >= owner.start ? elapsedWith(owner, t) : Number.NEGATIVE_INFINITY;
+}
+/** What a voice an owner holds reads at mix time `now`: -Infinity before the owner starts. */
+export function ownedElapsed(voice, owner, now) {
+    const t = ownerReading(owner, now);
+    return t === Number.NEGATIVE_INFINITY ? t : elapsedWith(voice, t);
+}
+/** The mix time an owner's clock reads `t`, by its controls now; Infinity where it never will. */
+export function mixTime(owner, t) {
+    const up = timeWith(owner, t);
+    return owner.owner === null ? up : mixTime(owner.owner, up);
+}
+/** Takes a child into its owner. */
+export function adopt(owner, child) {
+    const h = owner.holding;
+    h.children.push(child);
+    h.kids++;
+}
+/** A child left: its owner, where that was its last child and it should leave too. */
+export function orphan(child) {
+    const owner = child.owner;
+    const h = owner.holding;
+    const i = h.children.indexOf(child);
+    if (i >= 0)
+        h.children.splice(i, 1);
+    return h.children.length === 0 && owner.state !== 'done' ? owner : null;
+}
+/** A child finished its passes: its owner has played once every child it held has. */
+export function childPlayed(owner) {
+    const h = owner.holding;
+    if (++h.played === h.kids)
+        owner.play(true);
+}
+/** Every voice an owner holds, its children's children included. */
+export function descendants(owner, visit) {
+    for (const child of owner.holding.children) {
+        visit(child);
+        if (child.holding !== null)
+            descendants(child, visit);
+    }
+}
+/** Whether any owner above a voice reads a signal for its weight, which lanes cannot fill. */
+export function signalled(voice) {
+    for (let o = voice.owner; o !== null; o = o.owner)
+        if (typeof o.spec.weight === 'function')
+            return true;
+    return false;
+}
+/** Whether any owner above a voice weighs it by input from outside the clock. */
+export function heldByInput(voice) {
+    for (let o = voice.owner; o !== null; o = o.owner) {
+        const w = o.spec.weight;
+        if (typeof w === 'function' && w.input)
+            return true;
+    }
+    return false;
+}
+/**
+ * What one owner multiplies into its children's weight for a subject at mix time `now`: its weight,
+ * or its signal's read by `base`, times its own fade, held to 0..1. Its fade in counts from when it
+ * started, or from when it first showed where it holds before.
+ */
+export function ownWeight(owner, now, reduced, base) {
+    const b = typeof owner.spec.weight === 'function' ? base(owner) : owner.weight;
+    const start = owner.owner === null ? owner.start : mixTime(owner.owner, owner.start);
+    const since = owner.holdsBefore && owner.opened < start ? owner.opened : start;
+    return clampWeight(b * envelope(owner.fade.in ?? 0, owner.out, owner.ease, reduced, now, since));
+}
+/** 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)
+        w *= ownWeight(o, now, reduced, base);
+    return w;
+}
+/** Points a projection's copies at each other's owners, each owner holding only copies. */
+export function relink(copies) {
+    const byId = new Map();
+    for (const v of copies) {
+        byId.set(v.id, v);
+        if (v.holding !== null) {
+            const h = new Holding();
+            h.kids = v.holding.kids;
+            h.played = v.holding.played;
+            v.holding = h;
+        }
+    }
+    for (const v of copies) {
+        const o = v.owner === null ? undefined : byId.get(v.owner.id);
+        if (o === undefined)
+            continue;
+        v.owner = o;
+        o.holding.children.push(v);
+    }
+}