design-token-library 0.3.0 → 0.4.0

package/dist/lib/library.js

@@ -1,9 +1,9 @@
 import { COMPUTED, RECIPE, isComputed } from "./recipe.js";
 import { REF, isRef } from "./ref.js";
-import { getNotifier } from "./notifier.js";
+import { isStandardType, standardEquality } from "./equality.js";
+import { Graph } from "./graph.js";
 import { Queue } from "./queue.js";
-import { empty, isToken } from "./utilities.js";
-import { Watcher } from "./watcher.js";
+import { empty, isObject, isToken } from "./utilities.js";
 /**
  * @public
  */
@@ -12,11 +12,206 @@ export var Library;
     /**
      * @public
      */
-    Library.create = (config) => {
+    Library.create = (config, ...options) => {
         // The runtime library is untyped; its shape is guaranteed by `config`.
-        return LibraryImpl.create(config);
+        return LibraryImpl.create(config, options[0]);
     };
 })(Library || (Library = {}));
+/**
+ * Removes the scope of a collected extension from its source's.
+ */
+const extensionsOf = new FinalizationRegistry(({ source, extension }) => source.extensions.delete(extension));
+const scopeOf = (recipes, types, source, overridden = new Set()) => {
+    const own = new Set();
+    const scope = {
+        tokens: {},
+        source,
+        recipes,
+        types,
+        queue: new Queue(LibraryToken.reported),
+        subscribers: new Map(),
+        errors: null,
+        ancestral: 0,
+        callers: new Set(),
+        discovered: false,
+        made: new Map(),
+        own,
+        extensions: new Set(),
+        graph: source
+            ? new Graph(source.graph, (name) => own.has(name))
+            : new Graph(null, () => false),
+        complete: false,
+        found: new Map(),
+        cached: 0,
+        overridden,
+        origin: null,
+    };
+    if (source) {
+        const extension = new WeakRef(scope);
+        source.extensions.add(extension);
+        extensionsOf.register(scope, { source, extension });
+    }
+    return scope;
+};
+/**
+ * Calls `visit` with the path of each ref in a value, searched as
+ * {@link resolve} resolves them: in plain data and in the arguments of
+ * computed values. `resolve` walks values on its own, as it copies them, so
+ * the two must search the same values.
+ */
+const forEachRef = (value, visit) => {
+    const seen = new Set();
+    const walk = (value) => {
+        if (!isObject(value) || seen.has(value)) {
+            return;
+        }
+        seen.add(value);
+        if (isRef(value)) {
+            visit(value[REF]);
+        }
+        else if (isComputed(value)) {
+            value[COMPUTED].args.forEach(walk);
+        }
+        else if (isPlain(value)) {
+            for (const key of Reflect.ownKeys(value)) {
+                walk(Reflect.get(value, key));
+            }
+        }
+    };
+    walk(value);
+};
+/**
+ * The names of the tokens that the refs in a value are to.
+ */
+const refsOf = (value) => {
+    const names = new Set();
+    forEachRef(value, (path) => names.add(path.join(".")));
+    return names;
+};
+const none = new Set();
+const noInputs = Object.freeze([]);
+/**
+ * What a token that isn't queued for a batch has in place of the value to
+ * compare with.
+ */
+const unqueued = Symbol();
+/**
+ * The custom types of a library: those it inherits, and those it registers,
+ * which can be neither a DTCG type nor one it inherits.
+ */
+const typesOf = (types = {}, inherited = new Map()) => {
+    const registered = new Map(inherited);
+    for (const [name, options] of Object.entries(types)) {
+        if (isStandardType(name)) {
+            throw new Error(`"${name}" is a DTCG type, which has its own equality, so it can't be registered in 'types'.`);
+        }
+        if (inherited.has(name)) {
+            throw new Error(`The custom type "${name}" is registered by a library this one extends, so it can't be registered again.`);
+        }
+        if (typeof options?.isEqual !== "function") {
+            throw new Error(`The custom type "${name}" has no isEqual function.`);
+        }
+        registered.set(name, (a, b) => options.isEqual(a, b));
+    }
+    return registered;
+};
+/**
+ * The equality of a type in a library.
+ */
+const equalityOf = (scope, type) => isStandardType(type) ? standardEquality[type] : scope.types.get(type);
+/**
+ * The dependents of a token found last, with the version of its library's
+ * graph they were found in.
+ */
+const dependentsOfToken = new WeakMap();
+/**
+ * The scope that has the configured value of a token of a library: the
+ * library's, or that of the library it extends that the token inherits it
+ * from.
+ */
+const ownerOf = (scope, name) => {
+    let owner = scope;
+    while (owner.source !== undefined && !owner.own.has(name)) {
+        owner = owner.source;
+    }
+    return owner;
+};
+/**
+ * The graph of a library with the edges of every token: of each token of a
+ * library made by `create()`, and of each own token of an extension, on the
+ * graph of its source.
+ */
+const completeGraphOf = (scope) => {
+    if (!scope.complete) {
+        const { source, own, made } = scope;
+        const add = (token) => {
+            if (!scope.graph.has(token.name)) {
+                scope.graph.add(token.name, refsOf(LibraryToken.configuredValue(token)));
+            }
+        };
+        if (source) {
+            completeGraphOf(source);
+            for (const name of own) {
+                add(made.get(name));
+            }
+        }
+        else {
+            // Every token of a library made by `create()` is made, so its
+            // getter makes nothing.
+            forEachToken(scope.tokens, (_, descriptor) => add(descriptor.get()));
+        }
+        scope.complete = true;
+    }
+    return scope.graph;
+};
+/**
+ * The token of a library with a name, if it is made: an extension's token
+ * that hasn't been read isn't.
+ */
+const madeToken = (scope, name) => scope.source ? scope.made.get(name) : tokenNamed(scope, name);
+/**
+ * The token of a library with a name, made if it is an extension's token
+ * that hasn't been read.
+ */
+const tokenNamed = (scope, name) => tokenAt(scope.tokens, name.split("."));
+/**
+ * The place of each token in the order of its library, by name. The
+ * library's shape doesn't change, so it is found once.
+ */
+const orders = new WeakMap();
+const orderOf = (scope) => {
+    let order = orders.get(scope);
+    if (order === undefined) {
+        const found = new Map();
+        forEachToken(scope.tokens, (name) => found.set(name, found.size));
+        order = found;
+        orders.set(scope, order);
+    }
+    return order;
+};
+/**
+ * Calls `visit` with the name and the property of each token of a library,
+ * in its order. A group is a data property and a token an accessor, so this
+ * makes no token of an extension.
+ */
+const forEachToken = (tokens, visit) => {
+    const walk = (node, name) => {
+        for (const key of Object.keys(node)) {
+            if (!isChildKey(key)) {
+                continue;
+            }
+            const path = name.length === 0 ? key : `${name}.${key}`;
+            const descriptor = Reflect.getOwnPropertyDescriptor(node, key);
+            if ("value" in descriptor) {
+                walk(descriptor.value, path);
+            }
+            else {
+                visit(path, descriptor);
+            }
+        }
+    };
+    walk(tokens, "");
+};
 /**
  * Thrown when reading a token whose value refers back to itself through
  * one or more refs or computed values.
@@ -36,28 +231,96 @@ export class CircularReferenceError extends Error {
     }
 }
 /**
- * The changes to the configured values in a library's tokens: its own, and
- * those of the libraries it extends, whose values it takes until its tokens
- * are set.
+ * Given to a subscriber's `onError` when a token throws as a subscribed
+ * library resolves it on its own. The error thrown is its `cause`.
+ *
+ * @public
+ */
+export class TokenResolutionError extends Error {
+    name = "TokenResolutionError";
+    /**
+     * The name of the token that threw.
+     */
+    tokenName;
+    /**
+     * What threw: its type's `isEqual`, comparing the value it resolved with
+     * the one it had, or resolving its value.
+     */
+    phase;
+    constructor(tokenName, phase, cause) {
+        super(phase === "isEqual"
+            ? `The isEqual of "${tokenName}" threw.`
+            : `"${tokenName}" threw as it resolved.`, { cause });
+        this.tokenName = tokenName;
+        this.phase = phase;
+    }
+}
+/**
+ * The token that first threw the error being thrown, and what threw it,
+ * found as a read that throws unwinds. The outermost read clears it.
  */
-const configurationVersionOf = (scope) => {
-    let version = 0;
-    for (let s = scope; s; s = s.source) {
-        version += s.configurationVersion;
+let thrown = null;
+const recordThrow = (error, name, phase) => {
+    if (thrown === null || thrown.error !== error) {
+        thrown = { error, name, phase };
     }
-    return version;
 };
 /**
- * For a library's tokens, the tokens whose configured values refer to each,
- * and the configuration it was made from.
+ * Delivers the errors a subscribed library found in a microtask to its
+ * subscribers with `onError` that are told of the token's changes, by its
+ * origin: one of an extension's own tokens to those with `origin` `"own"` or
+ * `"all"`, and one that is its ancestor's to those with `"ancestor"` or
+ * `"all"`. One that no subscriber is given is thrown, as is one that
+ * `onError` throws.
  */
-const dependentsIndexes = new WeakMap();
+const deliverErrors = (scope, errors) => {
+    for (const { error, ancestors } of errors) {
+        let delivered = false;
+        for (const [subscriber, { delivered: to, ancestral },] of scope.subscribers) {
+            // Only a subscriber told of the ancestor's tokens alone is
+            // ancestral with a filter.
+            const told = ancestors
+                ? ancestral
+                : !ancestral || to === subscriber;
+            if (typeof subscriber.onError !== "function" || !told) {
+                continue;
+            }
+            delivered = true;
+            try {
+                subscriber.onError(error);
+            }
+            catch (failure) {
+                queueMicrotask(() => {
+                    throw failure;
+                });
+            }
+        }
+        if (!delivered) {
+            queueMicrotask(() => {
+                throw error;
+            });
+        }
+    }
+};
 /**
  * The tokens currently resolving their values, outermost first.
  */
 const resolving = [];
-const isObject = (value) => {
-    return typeof value === "object" && value !== null;
+/**
+ * The code of a value that is running as a token resolves, a recipe's
+ * function or a getter, if any. A token it reads other than by a ref isn't
+ * followed, so reading one there throws.
+ */
+let reading = null;
+const guarded = (token, within, read) => {
+    const previous = reading;
+    reading = { token, within };
+    try {
+        return read();
+    }
+    finally {
+        reading = previous;
+    }
 };
 const isGroup = (value) => {
     return isObject(value) && !Array.isArray(value) && !isToken(value);
@@ -93,18 +356,9 @@ const defineGroupMetadata = (group, ...sources) => {
     }
 };
 const defineToken = (library, key, get) => {
-    Reflect.defineProperty(library, key, {
-        get() {
-            const token = get();
-            // Token access is tracked because a ref reads its token from
-            // the library
-            Watcher.track(token);
-            return token;
-        },
-        enumerable: true,
-    });
+    Reflect.defineProperty(library, key, { get, enumerable: true });
 };
-const createToken = (key, name, config, scope, typeContext, queue) => {
+const createToken = (key, name, config, scope, typeContext) => {
     for (const property of Object.keys(config)) {
         if (!property.startsWith("$")) {
             throw new Error(`"${name}" has a $value, so it is a token and cannot have a child "${property}".`);
@@ -115,9 +369,18 @@ const createToken = (key, name, config, scope, typeContext, queue) => {
     if (!resolvedType) {
         throw new Error(`No '$type' found for token '${key}'. Types cannot be inferred, please add a $type to the token or to a group ancestor.`);
     }
-    return new LibraryToken(name, $value, resolvedType, scope, $description || "", $extensions || {}, $deprecated ?? false, queue);
+    if (!isStandardType(resolvedType) && !scope.types.has(resolvedType)) {
+        throw new Error(`"${name}" has the custom type "${resolvedType}", which isn't registered. Register it, with its isEqual, in the 'types' option of create() or extend().`);
+    }
+    const token = new LibraryToken(name, $value, resolvedType, scope, $description || "", $extensions || {}, $deprecated ?? false);
+    // A token that is new in an extension has a value of its own.
+    if (scope.source) {
+        scope.made.set(name, token);
+        scope.own.add(name);
+    }
+    return token;
 };
-const recurseCreate = (name, library, config, scope, typeContext, queue) => {
+const recurseCreate = (name, library, config, scope, typeContext) => {
     defineGroupMetadata(library, config);
     typeContext = config.$type || typeContext;
     for (const key in config) {
@@ -131,16 +394,16 @@ const recurseCreate = (name, library, config, scope, typeContext, queue) => {
                 value: group,
                 enumerable: true,
             });
-            recurseCreate(_name, group, config[key], scope, typeContext, queue);
+            recurseCreate(_name, group, config[key], scope, typeContext);
             Object.freeze(group);
         }
         else if (isToken(config[key])) {
-            const token = createToken(key, _name, config[key], scope, typeContext, queue);
+            const token = createToken(key, _name, config[key], scope, typeContext);
             defineToken(library, key, () => token);
         }
     }
 };
-const recurseExtend = (name, sourceTokens, extendedTokens, config, scope, typeContext, queue, inherited) => {
+const recurseExtend = (name, sourceTokens, extendedTokens, config, scope, typeContext) => {
     // An extension can restate a group's type, or give one to a group that
     // has none, but can't change it, as for a token.
     const sourceType = Reflect.get(sourceTokens, "$type");
@@ -170,128 +433,67 @@ const recurseExtend = (name, sourceTokens, extendedTokens, config, scope, typeCo
                 enumerable: true,
             });
             if (source) {
-                recurseExtend(_name, source.value, group, configValue || {}, scope, typeContext, queue, inherited);
+                recurseExtend(_name, source.value, group, configValue || {}, scope, typeContext);
             }
             else {
-                recurseCreate(_name, group, configValue, scope, typeContext, queue);
+                recurseCreate(_name, group, configValue, scope, typeContext);
             }
             Object.freeze(group);
         }
         else if (source) {
-            const token = new InheritedToken(() => untracked(() => sourceTokens[key]), scope, queue, configValue);
+            const token = new InheritedToken(() => sourceTokens[key], scope, configValue);
+            // An override has a value of its own.
+            if (configValue !== undefined && "$value" in configValue) {
+                scope.own.add(_name);
+            }
             // A token the extension configures is made now, so its config
             // is checked when the library is.
             if (configValue !== undefined) {
                 token.get();
             }
-            if (configValue === undefined || !("$value" in configValue)) {
-                inherited.push(token);
-            }
             defineToken(extendedTokens, key, () => token.get());
         }
         else if (isToken(configValue)) {
-            const token = createToken(key, _name, configValue, scope, typeContext, queue);
+            const token = createToken(key, _name, configValue, scope, typeContext);
             defineToken(extendedTokens, key, () => token);
         }
     }
 };
-/**
- * Reads without the read being tracked by the token that is resolving.
- */
-const untracked = (read) => {
-    const stopWatching = Watcher.use({ watch() { } });
-    try {
-        return read();
-    }
-    finally {
-        stopWatching();
-    }
-};
-/**
- * Unsubscribes the link of a collected {@link InheritedToken} from its
- * source token.
- */
-const links = new FinalizationRegistry((unlink) => unlink());
 /**
  * The token of an extension for a token of the library it extends. It is
  * made when it is first read, so an extension costs what it reads (#113).
  *
- * Until it is set, it has the value of its source token and follows its
- * changes, through a link on the source token that holds it weakly: the
- * library it extends doesn't keep an extension alive that nothing else
- * refers to. It follows once it is made, or once its extension has a
- * subscriber, which is told of a change to a token it hasn't read.
+ * Until it is set, it has the configured value of its source token, through
+ * its prototype. A change to the source's token reaches it through its
+ * library, which its source holds weakly, so the library it extends doesn't
+ * keep an extension alive that nothing else refers to.
  */
 class InheritedToken {
     source;
     scope;
-    queue;
     node;
     token = null;
-    unlink = null;
-    detached;
-    constructor(source, scope, queue, node) {
+    constructor(source, scope, node) {
         this.source = source;
         this.scope = scope;
-        this.queue = queue;
         this.node = node;
-        // An override has a value of its own.
-        this.detached = node !== undefined && "$value" in node;
     }
     get() {
         if (this.token !== null) {
             return this.token;
         }
-        const token = extendToken(this.source(), this.scope, this.queue, this.node, this);
+        const token = extendToken(this.source(), this.scope, this.node);
         this.token = token;
-        this.follow();
+        this.scope.made.set(token.name, token);
         return token;
     }
-    follow() {
-        if (this.unlink !== null || this.detached) {
-            return;
-        }
-        // The link holds only a weak reference, so that the registry can
-        // collect this token, and nothing that refers to it.
-        const target = new WeakRef(this);
-        const notifier = getNotifier(this.source());
-        const link = {
-            onChange() {
-                target.deref()?.get().onChange();
-            },
-        };
-        const unlink = () => notifier.unsubscribe(link);
-        notifier.subscribe(link);
-        links.register(this, unlink, link);
-        this.unlink = () => {
-            unlink();
-            links.unregister(link);
-        };
-    }
-    /**
-     * Stops following the source token, when the token is set.
-     */
-    detach() {
-        this.unlink?.();
-        this.unlink = null;
-        this.detached = true;
-    }
 }
-function extendToken(token, scope, queue, node, inherited) {
+function extendToken(token, scope, node) {
     if (node?.$type !== undefined && node.$type !== token.$type) {
         throw new Error(`An override cannot change the '$type' of token '${token.name}' from '${token.$type}' to '${node.$type}'.`);
     }
     const extendingToken = Object.create(token);
-    extendingToken.scope = scope;
-    extendingToken.cached = empty;
-    extendingToken.resolving = false;
-    extendingToken.notifying = false;
-    // Its own dependencies; sharing the source's set would let either token
-    // drop the other's subscriptions.
-    extendingToken.subscriptions = new Set();
-    extendingToken.previousSubscriptions = null;
-    extendingToken.watchContext = extendingToken;
-    extendingToken.queue = queue;
+    extendingToken.state = new TokenState(scope);
     // An extension can restate the token's metadata along with its value.
     if (node?.$description !== undefined) {
         extendingToken._description = node.$description;
@@ -310,10 +512,9 @@ function extendToken(token, scope, queue, node, inherited) {
         // which sets the extended token.
         const set = LibraryToken.prototype.set;
         extendingToken.set = (value) => {
-            inherited.detach();
-            // Own the inherited value, so set() detaches even when the
+            // Own the inherited value first, so set() detaches even when the
             // new value is identical and doesn't notify.
-            extendingToken.raw = extendingToken.raw;
+            LibraryToken.detach(extendingToken);
             set.call(extendingToken, value);
             extendingToken.set = set;
         };
@@ -366,21 +567,46 @@ const tokenAt = (tokens, path) => {
  * is frozen, so the config isn't. A getter is read once, into a data
  * property. An object that is in the value twice, or in itself, has one copy.
  * Anything else, such as a class instance or a function, is returned as it
- * is: it can't be rebuilt, so it isn't copied, searched or frozen.
+ * is: it can't be rebuilt, so it isn't copied, searched or frozen. A token
+ * read by a recipe's function or a getter, rather than by a ref, throws.
  */
-const resolve = (value, scope) => {
+const resolve = (value, token, scope, found) => {
     const copies = new Map();
+    // Within the result of a recipe, whose refs the configured value doesn't
+    // show.
+    let inResult = 0;
     const walk = (value) => {
         if (!isObject(value)) {
             return value;
         }
         if (isRef(value)) {
-            return tokenAt(scope.tokens, value[REF]).$value;
+            const name = value[REF].join(".");
+            if (inResult > 0) {
+                (found.results ??= new Set()).add(name);
+            }
+            else {
+                (found.refs ??= new Set()).add(name);
+            }
+            const token = tokenAt(scope.tokens, value[REF]);
+            const resolved = token.$value;
+            found.inputs?.push(token, resolved);
+            return resolved;
         }
         if (isComputed(value)) {
             const { recipe, args } = value[COMPUTED];
+            if (inResult > 0) {
+                (found.calls ??= new Set()).add(recipe);
+            }
             const fn = scope.recipes.get(recipe) ?? recipe[RECIPE].fn;
-            return walk(fn(...args.map(walk)));
+            const resolved = args.map(walk);
+            const result = guarded(token, `the recipe "${recipe[RECIPE].name}"`, () => fn(...resolved));
+            inResult++;
+            try {
+                return walk(result);
+            }
+            finally {
+                inResult--;
+            }
         }
         if (copies.has(value)) {
             return copies.get(value);
@@ -403,7 +629,7 @@ const resolve = (value, scope) => {
             Reflect.defineProperty(copy, key, "value" in descriptor
                 ? { ...descriptor, value: walk(descriptor.value) }
                 : {
-                    value: walk(Reflect.get(value, key)),
+                    value: walk(guarded(token, "a getter of its value", () => Reflect.get(value, key))),
                     enumerable: descriptor.enumerable,
                     writable: true,
                     configurable: true,
@@ -424,94 +650,163 @@ const assertNoRoot = (config) => {
  */
 class LibraryImpl {
     scope;
-    queue;
     tokens;
-    /**
-     * The inherited tokens of an extension. Each follows its source token
-     * once it is read, and all of them once the library has a subscriber,
-     * after which this is null.
-     */
-    inherited;
-    constructor(scope, queue, inherited = []) {
+    constructor(scope) {
         this.scope = scope;
-        this.queue = queue;
         this.tokens = scope.tokens;
-        this.inherited = inherited;
         // Groups are frozen as they are built; the root is frozen here.
         Object.freeze(this.tokens);
     }
-    subscribe(subscriber) {
-        // A subscriber is told of a change to a token of the source that the
-        // extension hasn't read.
-        if (this.inherited !== null) {
-            for (const token of this.inherited) {
-                token.follow();
-            }
-            this.inherited = null;
+    subscribe(subscriber, options = {}) {
+        const { scope } = this;
+        this.unsubscribe(subscriber);
+        const { origin = "own" } = options;
+        // A library made by `create()` has only its own tokens.
+        const ancestral = scope.source !== undefined && origin !== "own";
+        const delivered = origin === "all" || (origin === "own" && scope.source === undefined)
+            ? subscriber
+            : changesFrom(origin, subscriber);
+        const subscribed = scope.queue.subscribed;
+        scope.subscribers.set(subscriber, { delivered, ancestral });
+        scope.queue.subscribe(delivered);
+        if (ancestral) {
+            scope.ancestral++;
+        }
+        if (!subscribed) {
+            resolveOwn(scope);
+        }
+        if (ancestral && scope.ancestral === 1) {
+            resolveAncestors(scope);
         }
-        this.queue.subscribe(subscriber);
     }
     unsubscribe(subscriber) {
-        this.queue.unsubscribe(subscriber);
+        const { scope } = this;
+        const subscribed = scope.subscribers.get(subscriber);
+        if (subscribed === undefined) {
+            return;
+        }
+        scope.subscribers.delete(subscriber);
+        scope.queue.unsubscribe(subscribed.delivered);
+        if (subscribed.ancestral) {
+            scope.ancestral--;
+        }
+        if (!scope.queue.subscribed) {
+            LibraryToken.dropPrevious(scope);
+        }
+    }
+    /**
+     * The tokens of a library that are its own, in the order of the library.
+     */
+    static ownTokens(library) {
+        if (!(library instanceof LibraryImpl)) {
+            throw new Error("Not a library.");
+        }
+        const { scope } = library;
+        const origin = scope.source === undefined ? null : originOf(scope);
+        const tokens = [];
+        forEachToken(scope.tokens, (name, descriptor) => {
+            if (origin === null || origin.has(name)) {
+                tokens.push(descriptor.get());
+            }
+        });
+        return tokens;
     }
     extend(config, options = {}) {
         assertNoRoot(config);
-        const queue = new Queue();
         const recipes = new Map(this.scope.recipes);
+        const overridden = new Set();
         for (const { recipe, fn } of options.recipes ?? []) {
             recipes.set(recipe, fn);
+            overridden.add(recipe);
         }
-        const scope = {
-            tokens: {},
-            recipes,
-            configurationVersion: 0,
-            source: this.scope,
-        };
-        const inherited = [];
-        recurseExtend("", this.tokens, scope.tokens, config, scope, null, queue, inherited);
-        return new LibraryImpl(scope, queue, inherited);
+        const types = typesOf(options.types, this.scope.types);
+        const scope = scopeOf(recipes, types, this.scope, overridden);
+        recurseExtend("", this.tokens, scope.tokens, config, scope, null);
+        return new LibraryImpl(scope);
     }
-    static create(config) {
+    static create(config, options = {}) {
         assertNoRoot(config);
-        const queue = new Queue();
-        const scope = {
-            tokens: {},
-            recipes: new Map(),
-            configurationVersion: 0,
-        };
-        recurseCreate("", scope.tokens, config, scope, null, queue);
-        return new LibraryImpl(scope, queue);
+        const scope = scopeOf(new Map(), typesOf(options.types));
+        recurseCreate("", scope.tokens, config, scope, null);
+        return new LibraryImpl(scope);
     }
 }
+/**
+ * The state of a token of a library.
+ */
+class TokenState {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    cached = empty;
+    /**
+     * The value that was dropped, kept by a library with a subscriber until
+     * the token resolves again: a value equal to it is replaced by it, so
+     * it's the same object.
+     */
+    previous = empty;
+    resolving = false;
+    /**
+     * The tokens that refs in the results of recipes were to, the last time
+     * the value was resolved.
+     */
+    found = null;
+    /**
+     * The recipes that the results of recipes called, the last time the
+     * value was resolved, which the configured value doesn't show.
+     */
+    called = null;
+    /**
+     * Each token whose value the value was resolved from, followed by that
+     * value, the last time it was resolved; `null` when its library had no
+     * subscriber then, which doesn't check them.
+     */
+    inputs = null;
+    /**
+     * The cached value, unless a token it depends on may have changed since
+     * it was resolved: then it's checked against its inputs when it's read.
+     * It's the only field the getter reads for a cached value.
+     */
+    current = empty;
+    /**
+     * The value it had when a subscribed library queued it, which the batch
+     * compares with the one it has then.
+     */
+    before = unqueued;
+    /**
+     * For a token whose value is its ancestor's, the value it last had for a
+     * subscriber told of those.
+     */
+    seen = empty;
+    /**
+     * Whether it became its extension's own since its library's last batch.
+     */
+    originChanged = false;
+}
 /**
  * An individual token value in a library
  */
 class LibraryToken {
     name;
     _type;
-    scope;
     _description;
     _deprecated;
-    queue;
     raw;
-    cached = empty;
-    resolving = false;
-    notifying = false;
-    subscriptions = new Set();
     /**
-     * While resolving, the subscriptions from the previous resolution. Sources
-     * watched again keep their subscription instead of re-subscribing.
+     * What changes as the token resolves, in an object of one shape. A token
+     * of an extension has a shape of its own, since its prototype is its
+     * source's token, so its own fields are slow to read and to add.
      */
-    previousSubscriptions = null;
+    state;
     _extensions;
-    constructor(name, value, _type, scope, _description, extensions, _deprecated, queue) {
+    constructor(name, value, _type, scope, _description, extensions, _deprecated) {
         this.name = name;
         this._type = _type;
-        this.scope = scope;
         this._description = _description;
         this._deprecated = _deprecated;
-        this.queue = queue;
         this.raw = value;
+        this.state = new TokenState(scope);
         // A copy, so changing the config's top-level keys can't change the token.
         this._extensions = { ...extensions };
     }
@@ -531,38 +826,104 @@ class LibraryToken {
      * Gets the token value
      */
     get $value() {
-        if (this.cached !== empty) {
-            return this.cached;
+        // Before the cache, so a token that was read is caught too.
+        if (reading !== null) {
+            throw new Error(`"${reading.token}" read the token "${this.name}" in ${reading.within}. A token read there isn't followed, so the value would not change with it. Pass the token to it as a ref instead.`);
+        }
+        // A token whose value is its ancestor's holds none.
+        const { current } = this.state;
+        return current !== empty ? current : this.value();
+    }
+    /**
+     * Whether the value is its ancestor's: the token is a subscribed
+     * extension's and isn't its own.
+     */
+    isAncestors() {
+        const { origin, queue } = this.state.scope;
+        return origin !== null && queue.subscribed && !origin.has(this.name);
+    }
+    /**
+     * The value, resolved if it isn't cached or may have changed.
+     */
+    value() {
+        const { scope } = this.state;
+        if (resolving.length === 0) {
+            thrown = null;
+        }
+        if (this.isAncestors()) {
+            // The ancestor token has the same type.
+            const value = LibraryToken.ancestorValue(this);
+            if (scope.ancestral > 0) {
+                this.state.seen = value;
+            }
+            return value;
         }
-        if (this.resolving) {
+        if (this.state.cached !== empty) {
+            if (this.inputsAreCurrent()) {
+                return (this.state.current = this.state.cached);
+            }
+            this.uncache();
+        }
+        if (this.state.resolving) {
             const chain = resolving
                 .slice(resolving.indexOf(this))
                 .map((token) => token.name);
-            throw new CircularReferenceError([...chain, this.name]);
+            const error = new CircularReferenceError([...chain, this.name]);
+            recordThrow(error, this.name, "resolve");
+            throw error;
         }
-        const previous = this.subscriptions;
-        this.previousSubscriptions = previous;
-        this.subscriptions = new Set();
-        this.resolving = true;
+        this.state.resolving = true;
         resolving.push(this);
-        const stopWatching = Watcher.use(this);
         try {
+            const found = {
+                refs: null,
+                results: null,
+                calls: null,
+                // Only a library with a subscriber checks them.
+                inputs: scope.queue.subscribed ? [] : null,
+            };
             // The config's types guarantee what the raw value resolves to.
-            const value = resolve(this.raw, this.scope);
-            this.cached = value;
+            let value = resolve(this.raw, this.name, this.state.scope, found);
+            // Resolving found every ref of the configured value, so the
+            // graph has the token's edges before any token depends on its
+            // value.
+            ownerOf(this.state.scope, this.name).graph.add(this.name, found.refs ?? none);
+            this.setFound(found.results);
+            this.state.called = found.calls;
+            this.state.inputs =
+                found.inputs?.length === 0 ? noInputs : found.inputs;
+            const { previous } = this.state;
+            if (previous !== empty) {
+                this.state.previous = empty;
+                if (scope.queue.subscribed && this.equals(previous, value)) {
+                    value = previous;
+                }
+            }
+            this.state.cached = value;
+            this.state.current = value;
+            this.state.scope.cached++;
             return value;
         }
+        catch (error) {
+            recordThrow(error, this.name, "resolve");
+            throw error;
+        }
         finally {
-            this.resolving = false;
+            this.state.resolving = false;
             resolving.pop();
-            stopWatching();
-            this.previousSubscriptions = null;
-            // Unsubscribe from sources that were not watched this time.
-            for (const notifier of previous) {
-                if (!this.subscriptions.has(notifier)) {
-                    notifier.unsubscribe(this);
-                }
-            }
+        }
+    }
+    /**
+     * Compares two values by the token's type, recording an error that its
+     * equality throws.
+     */
+    equals(a, b) {
+        try {
+            return equalityOf(this.state.scope, this._type)(a, b);
+        }
+        catch (error) {
+            recordThrow(error, this.name, "isEqual");
+            throw error;
         }
     }
     toString() {
@@ -580,33 +941,481 @@ class LibraryToken {
             return;
         }
         this.raw = value;
-        this.scope.configurationVersion++;
-        this.onChange();
+        // A token that is set has a value of its own, so its edges are its
+        // library's. Until the graph is complete, they are added again when
+        // the token is resolved.
+        const { graph, complete } = this.state.scope;
+        if (graph.remove(this.name) && complete) {
+            graph.add(this.name, refsOf(value));
+        }
+        LibraryToken.changed(this.state.scope, this.name, this);
+    }
+    /**
+     * Drops the resolved value, and says whether there was one.
+     */
+    uncache() {
+        if (this.state.cached === empty) {
+            return false;
+        }
+        if (this.state.scope.queue.subscribed) {
+            this.state.previous = this.state.cached;
+        }
+        this.state.cached = empty;
+        this.state.current = empty;
+        this.state.scope.cached--;
+        return true;
+    }
+    /**
+     * Drops the value of each token of a subscribed extension that is its
+     * ancestor's, which it reads from its ancestor from then on.
+     */
+    static dropAncestors(scope) {
+        const origin = scope.origin;
+        for (const [name, token] of scope.made) {
+            if (!origin.has(name) && token.state.cached !== empty) {
+                token.state.cached = empty;
+                token.state.current = empty;
+                token.state.previous = empty;
+                scope.cached--;
+            }
+        }
+    }
+    /**
+     * Whether each token the value was resolved from has the value it had,
+     * as far as is known.
+     */
+    inputsAreCurrent() {
+        const { inputs } = this.state;
+        if (inputs === null) {
+            return false;
+        }
+        for (let i = 0; i < inputs.length; i += 2) {
+            try {
+                if (!Object.is(inputs[i].$value, inputs[i + 1])) {
+                    return false;
+                }
+            }
+            catch {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Queues the token for its library's next batch, with the value it has
+     * now to compare with.
+     */
+    queue() {
+        const { state } = this;
+        if (state.before === unqueued) {
+            // A token that was dropped and not resolved since had the value
+            // it keeps to compare with, and one that is its ancestor's the
+            // value its subscribers were last told of.
+            // Only a subscriber told of its ancestor's tokens queues those.
+            state.before =
+                state.scope.ancestral > 0 && this.isAncestors()
+                    ? state.seen
+                    : state.cached !== empty
+                        ? state.cached
+                        : state.previous;
+        }
+        this.state.scope.queue.add(this);
+    }
+    /**
+     * The value of a token of a subscribed extension that is its ancestor's:
+     * its ancestor's, the same object. Which tokens are its own is found when
+     * it's first subscribed, and again as changes reach it, so none that
+     * should be is read here.
+     */
+    static ancestorValue(token) {
+        const source = Object.getPrototypeOf(token);
+        return source.$value;
+    }
+    /**
+     * Whether a token of a subscribed extension that isn't its own yet, and
+     * whose configured value calls a recipe, must be: it calls a recipe the
+     * extension overrides, or a recipe's result does, or refers to a token
+     * that is the extension's own. It's resolved in the source to find out
+     * what its results do.
+     */
+    static discover(scope, name) {
+        const { overridden } = scope;
+        if (overridden.size > 0 &&
+            callsAny(LibraryToken.configuredValue(tokenNamed(scope.source, name)), overridden)) {
+            return true;
+        }
+        const resolver = resolverOf(scope, name);
+        try {
+            resolver.$value;
+        }
+        catch {
+            // An error of the source's token is reported by what follows it:
+            // the source's subscribers, and the extension's subscribers told
+            // of its ancestor's tokens, as it resolves them. Otherwise it
+            // throws when it's read.
+        }
+        const { called, found } = resolver.state;
+        const origin = scope.origin;
+        for (const recipe of called ?? []) {
+            if (overridden.has(recipe)) {
+                return true;
+            }
+        }
+        for (const name of found ?? none) {
+            if (origin.has(name)) {
+                return true;
+            }
+        }
+        return false;
     }
-    onChange() {
-        // A circular reference that threw while resolving still leaves the
-        // tokens subscribed to each other, so don't notify re-entrantly.
-        if (this.notifying) {
+    /**
+     * Finds the tokens of a subscribed extension that a change to the token
+     * named `name` makes its own: a recipe's result that the change reaches
+     * may now call a recipe the extension overrides, or refer to one of its
+     * own tokens.
+     */
+    static rediscover(scope, name) {
+        const origin = scope.origin;
+        const { callers } = scope;
+        for (const caller of callers) {
+            if (origin.has(caller)) {
+                callers.delete(caller);
+            }
+        }
+        if (callers.size === 0) {
             return;
         }
-        this.notifying = true;
+        const visited = new Set([name]);
+        const pending = [name];
+        const visit = (dependent) => {
+            if (!visited.has(dependent)) {
+                visited.add(dependent);
+                pending.push(dependent);
+            }
+        };
+        for (let i = 0; i < pending.length; i++) {
+            scope.graph.dependentsOf(pending[i], visit);
+            foundDependentsOf(scope, pending[i], visit);
+        }
+        for (const reached of pending) {
+            if (callers.has(reached) &&
+                !origin.has(reached) &&
+                LibraryToken.discover(scope, reached)) {
+                addOrigin(scope, reached);
+            }
+        }
+    }
+    /**
+     * Queues a token that becomes a subscribed extension's own, as its
+     * origin changed. It's compared with the value it had as its ancestor's,
+     * which it keeps when its own is equal.
+     */
+    static inherit(scope, name) {
+        if (scope.source === undefined || !scope.queue.subscribed) {
+            return;
+        }
+        const token = tokenNamed(scope, name);
+        if (token.state.cached === empty) {
+            try {
+                token.state.previous = tokenNamed(scope.source, name).$value;
+            }
+            catch {
+                // It throws as its ancestor's, so any value of its own is new.
+            }
+        }
+        token.state.originChanged = true;
+        token.queue();
+    }
+    /**
+     * Delivers what a batch of a subscribed library reports: each token it
+     * queued whose value isn't the one it had, which reading it brings up to
+     * date, or whose origin changed. A token that starts or stops throwing
+     * has changed. A token that is its ancestor's is compared by its type's
+     * equality, since its ancestor may not keep equal values' objects.
+     */
+    static reported(tokens) {
+        const reported = [];
+        for (const token of tokens) {
+            const { state } = token;
+            const { scope } = state;
+            const { before, originChanged } = state;
+            state.originChanged = false;
+            if (before === unqueued) {
+                reported.push(changeOf(token, true, "own", originChanged));
+                continue;
+            }
+            state.before = unqueued;
+            if (!scope.queue.subscribed) {
+                continue;
+            }
+            let after;
+            try {
+                after = token.$value;
+            }
+            catch (error) {
+                after = empty;
+                LibraryToken.report(token, error);
+            }
+            // Only a subscriber told of its ancestor's tokens queues those.
+            const ancestors = scope.ancestral > 0 && token.isAncestors();
+            let valueChanged = !Object.is(before, after);
+            if (valueChanged &&
+                ancestors &&
+                before !== empty &&
+                after !== empty) {
+                try {
+                    valueChanged = !token.equals(before, after);
+                }
+                catch (error) {
+                    LibraryToken.report(token, error);
+                }
+            }
+            if (valueChanged || originChanged) {
+                reported.push(changeOf(token, valueChanged, ancestors ? "ancestor" : "own", originChanged));
+            }
+        }
+        return reported;
+    }
+    /**
+     * Resolves a token of a subscribed library, reporting an error it throws
+     * to the library's subscribers.
+     */
+    static tryResolve(token) {
         try {
-            this.queue.add(this);
-            this.cached = empty;
-            getNotifier(this).notify();
+            token.$value;
         }
-        finally {
-            this.notifying = false;
+        catch (error) {
+            LibraryToken.report(token, error);
+        }
+    }
+    /**
+     * Queues an error a token of a subscribed library threw as the library
+     * resolved it, for its subscribers, as a {@link TokenResolutionError} of
+     * the token that threw it first. An error is reported once in a
+     * microtask, as the tokens that depend on a token that throws rethrow
+     * its error.
+     */
+    static report(token, error) {
+        const { name, phase } = thrown !== null && thrown.error === error
+            ? thrown
+            : { name: token.name, phase: "resolve" };
+        thrown = null;
+        const { scope } = token.state;
+        let errors = scope.errors;
+        if (errors === null) {
+            const pending = (errors = scope.errors = []);
+            queueMicrotask(() => {
+                scope.errors = null;
+                deliverErrors(scope, pending);
+            });
+        }
+        if (errors.some((pending) => pending.error.cause === error)) {
+            return;
+        }
+        errors.push({
+            error: new TokenResolutionError(name, phase, error),
+            ancestors: token.isAncestors(),
+        });
+    }
+    /**
+     * Resolves a token of a library that is first subscribed, if it doesn't
+     * throw. A value it resolved before has no inputs, which are the values
+     * the tokens it depends on have now, as its library dropped it when one
+     * of them changed.
+     */
+    static resolveForSubscriber(token) {
+        LibraryToken.tryResolve(token);
+        const { state } = token;
+        if (state.inputs !== null || state.cached === empty) {
+            return;
+        }
+        const { scope } = state;
+        const inputs = [];
+        const add = (name) => {
+            const dependency = tokenNamed(scope, name);
+            try {
+                inputs.push(dependency, dependency.$value);
+            }
+            catch {
+                inputs.push(dependency, empty);
+            }
+        };
+        ownerOf(scope, token.name)
+            .graph.dependenciesOf(token.name)
+            ?.forEach(add);
+        state.found?.forEach(add);
+        state.inputs = inputs.length === 0 ? noInputs : inputs;
+    }
+    /**
+     * Drops the value each token of a library kept to compare with, once the
+     * library has no subscriber, which compares values.
+     */
+    static dropPrevious(scope) {
+        const drop = (token) => {
+            token.state.previous = empty;
+        };
+        if (scope.source) {
+            // The tokens an extension hasn't made have no value.
+            scope.made.forEach(drop);
+        }
+        else {
+            forEachToken(scope.tokens, (_, descriptor) => drop(descriptor.get()));
         }
     }
-    watch(source) {
-        const notifier = getNotifier(source);
-        if (this.subscriptions.has(notifier)) {
+    setFound(names) {
+        if (this.state.found === null && names === null) {
             return;
         }
-        this.subscriptions.add(notifier);
-        if (!this.previousSubscriptions?.has(notifier)) {
-            notifier.subscribe(this);
+        const { found } = this.state.scope;
+        for (const name of this.state.found ?? []) {
+            found.get(name)?.delete(this.name);
+        }
+        for (const name of names ?? []) {
+            let dependents = found.get(name);
+            if (dependents === undefined) {
+                dependents = new Set();
+                found.set(name, dependents);
+            }
+            dependents.add(this.name);
+        }
+        this.state.found = names;
+    }
+    /**
+     * Makes an extension's token have a value of its own: the one it
+     * inherits, until it is set.
+     */
+    static detach(token) {
+        token.raw = token.raw;
+        token.state.scope.own.add(token.name);
+        token.state.scope.graph.add(token.name, refsOf(token.raw));
+        if (token.state.scope.origin !== null) {
+            addOrigin(token.state.scope, token.name);
+        }
+    }
+    /**
+     * Invalidates what a change to the token named `name` in a library
+     * changes: its value, the values that depend on it, and the same in the
+     * libraries that extend it and inherit the token. Each token whose value
+     * is dropped is queued for its library's subscribers, and so is the token
+     * itself, which a library with a subscriber makes if it hasn't.
+     *
+     * A token without a resolved value is not followed: a token that has one
+     * read the tokens it depends on as it resolved, and they have one too.
+     */
+    static changed(scope, name, token) {
+        if (scope.queue.subscribed) {
+            LibraryToken.reach(scope, name, token);
+        }
+        else {
+            LibraryToken.invalidate(scope, name, token);
+        }
+        for (const reference of scope.extensions) {
+            const extension = reference.deref();
+            if (extension !== undefined && !extension.own.has(name)) {
+                LibraryToken.changed(extension, name);
+            }
+        }
+    }
+    /**
+     * Marks what a change to the token named `name` reaches in a subscribed
+     * library, and queues it: the token, and each token that depends on it,
+     * however far, whether it was read or not. A token is resolved again
+     * when the batch is delivered, or when it's read first, and it's checked
+     * against the values it was resolved from first. An extension queues
+     * only its own tokens: its ancestor's are its ancestor's values, which it
+     * doesn't hold.
+     */
+    static reach(scope, name, token) {
+        const { origin } = scope;
+        if (origin !== null) {
+            LibraryToken.rediscover(scope, name);
+        }
+        const ancestral = scope.ancestral > 0;
+        if (!ancestral && origin !== null && origin.size === 0) {
+            // Its values are all its ancestor's, and it holds none of them.
+            return;
+        }
+        const isOwn = (name) => origin === null || origin.has(name);
+        // The tokens queued: its own, and with a subscriber told of its
+        // ancestor's, those too.
+        const isQueued = (name) => ancestral || isOwn(name);
+        const changed = token ??
+            madeToken(scope, name) ??
+            (isQueued(name) ? tokenNamed(scope, name) : undefined);
+        if (changed !== undefined) {
+            if (isQueued(name)) {
+                changed.queue();
+            }
+            changed.uncache();
+        }
+        const visited = new Set([name]);
+        const pending = [name];
+        const visit = (dependent) => {
+            if (visited.has(dependent)) {
+                return;
+            }
+            visited.add(dependent);
+            pending.push(dependent);
+            if (isOwn(dependent)) {
+                const token = tokenNamed(scope, dependent);
+                token.queue();
+                token.state.current = empty;
+            }
+            else if (ancestral) {
+                tokenNamed(scope, dependent).queue();
+            }
+            else {
+                madeToken(scope, dependent)?.uncache();
+            }
+        };
+        // In the order they're reached, so that each is resolved after the
+        // tokens it depends on, and not through them.
+        for (let i = 0; i < pending.length; i++) {
+            scope.graph.dependentsOf(pending[i], visit);
+            foundDependentsOf(scope, pending[i], visit);
+        }
+    }
+    /**
+     * Drops what a change to the token named `name` changes in a library
+     * with no subscriber: its value, and the values that depend on it.
+     *
+     * A token without a resolved value is not followed: a token that has one
+     * read the tokens it depends on as it resolved, and they have one too.
+     * An extension's ancestor's tokens are followed whatever they hold,
+     * since its own tokens may have read their ancestor's values while it was
+     * subscribed.
+     */
+    static invalidate(scope, name, token) {
+        const changed = token ??
+            madeToken(scope, name) ??
+            (scope.queue.subscribed ? tokenNamed(scope, name) : undefined);
+        if (changed !== undefined) {
+            changed.uncache();
+            scope.queue.add(changed);
+        }
+        if (scope.cached > 0) {
+            const { graph, origin } = scope;
+            const visited = new Set([name]);
+            const pending = [name];
+            const visit = (dependent) => {
+                if (visited.has(dependent)) {
+                    return;
+                }
+                visited.add(dependent);
+                const token = madeToken(scope, dependent);
+                if (token?.uncache()) {
+                    scope.queue.add(token);
+                    pending.push(dependent);
+                }
+                else if (origin !== null && !origin.has(dependent)) {
+                    pending.push(dependent);
+                }
+            };
+            while (pending.length > 0) {
+                const next = pending.pop();
+                graph.dependentsOf(next, visit);
+                scope.found.get(next)?.forEach(visit);
+            }
         }
     }
     /**
@@ -618,62 +1427,226 @@ class LibraryToken {
     }
     /**
      * The tokens that the refs in a token's configured value are to, in the
-     * token's library, searched as {@link resolve} resolves them: in plain
-     * data and in the arguments of computed values.
+     * token's library.
      */
     static dependencies(token) {
         const dependencies = new Set();
-        const seen = new Set();
-        const walk = (value) => {
-            if (!isObject(value) || seen.has(value)) {
-                return;
-            }
-            seen.add(value);
-            if (isRef(value)) {
-                dependencies.add(tokenAt(token.scope.tokens, value[REF]));
-            }
-            else if (isComputed(value)) {
-                value[COMPUTED].args.forEach(walk);
-            }
-            else if (isPlain(value)) {
-                for (const key of Reflect.ownKeys(value)) {
-                    walk(Reflect.get(value, key));
-                }
-            }
-        };
-        walk(token.raw);
+        forEachRef(token.raw, (path) => dependencies.add(tokenAt(token.state.scope.tokens, path)));
         return dependencies;
     }
     /**
-     * The tokens of the token's library whose configured values refer to it.
-     * The index is made from the library's tokens once, and again after a
-     * token is set to a different value.
+     * The tokens of the token's library whose configured values refer to it,
+     * in the order of the library.
      */
     static dependents(token) {
-        const version = configurationVersionOf(token.scope);
-        let index = dependentsIndexes.get(token.scope);
-        if (index?.version !== version) {
-            const dependents = new Map();
-            for (const entry of walkEntries(token.scope.tokens, [], {
-                whatToShow: "token",
-            })) {
-                const dependent = libraryTokenOf(entry.token);
-                for (const dependency of LibraryToken.dependencies(dependent)) {
-                    const list = dependents.get(dependency);
-                    if (list) {
-                        list.push(dependent);
-                    }
-                    else {
-                        dependents.set(dependency, [dependent]);
-                    }
-                }
+        const { scope } = token.state;
+        const version = completeGraphOf(scope).version;
+        const kept = dependentsOfToken.get(token);
+        if (kept?.version === version) {
+            return kept.dependents;
+        }
+        const names = [];
+        completeGraphOf(scope).dependentsOf(token.name, (name) => names.push(name));
+        if (names.length > 1) {
+            const order = orderOf(scope);
+            names.sort((a, b) => order.get(a) - order.get(b));
+        }
+        const dependents = names.map((name) => tokenNamed(scope, name));
+        dependentsOfToken.set(token, { version, dependents });
+        return dependents;
+    }
+}
+/**
+ * Calls `visit` with each token of a library whose value resolved a ref to
+ * the token named `name` in a recipe's result. An extension's are its own
+ * and those of its ancestors' tokens it doesn't give a value.
+ */
+function foundDependentsOf(scope, name, visit) {
+    if (scope.source !== undefined) {
+        foundDependentsOf(scope.source, name, (dependent) => {
+            if (!scope.own.has(dependent)) {
+                visit(dependent);
             }
-            index = { version, dependents };
-            dependentsIndexes.set(token.scope, index);
+        });
+    }
+    scope.found.get(name)?.forEach(visit);
+}
+/**
+ * Makes a token of a subscribed extension its own, and each token that
+ * depends on it. With `inherit`, each is compared next with the value it had
+ * as its ancestor's.
+ */
+function addOrigin(scope, name, inherit = true) {
+    const origin = scope.origin;
+    if (origin.has(name)) {
+        return;
+    }
+    // Completed when an extension first has a token of its own.
+    completeGraphOf(scope);
+    const add = (name) => {
+        origin.add(name);
+        pending.push(name);
+        if (inherit) {
+            LibraryToken.inherit(scope, name);
+        }
+    };
+    const pending = [];
+    add(name);
+    const visit = (dependent) => {
+        if (!origin.has(dependent)) {
+            add(dependent);
+        }
+    };
+    for (let i = 0; i < pending.length; i++) {
+        scope.graph.dependentsOf(pending[i], visit);
+        foundDependentsOf(scope, pending[i], visit);
+    }
+    if (!scope.discovered && scope.queue.subscribed) {
+        discoverAll(scope, inherit);
+    }
+}
+/**
+ * Finds the tokens of an extension that recipes' results make its own.
+ * What a result calls and refers to is known only once it has resolved, so
+ * each token of the source that calls a recipe is resolved: the
+ * extension's own tokens are then the same whatever the source has read.
+ */
+function discoverAll(scope, inherit) {
+    scope.discovered = true;
+    const origin = scope.origin;
+    for (const name of callersOf(scope.source)) {
+        if (!origin.has(name)) {
+            scope.callers.add(name);
+        }
+    }
+    for (const name of scope.callers) {
+        if (!origin.has(name) && LibraryToken.discover(scope, name)) {
+            addOrigin(scope, name, inherit);
         }
-        return index.dependents.get(token) ?? [];
     }
 }
+/**
+ * The token of an extension's source that resolves the value the
+ * extension's token named `name` has as its ancestor's: the source's, or,
+ * when that is its own ancestor's too, the nearest that isn't.
+ */
+const resolverOf = (scope, name) => {
+    let source = scope.source;
+    while (source.source !== undefined &&
+        source.origin !== null &&
+        source.queue.subscribed &&
+        !source.origin.has(name)) {
+        source = source.source;
+    }
+    return tokenNamed(source, name);
+};
+/**
+ * Whether a value calls one of `recipes`, or with `null` any recipe, in plain
+ * data or in the arguments of a computed value.
+ */
+const callsAny = (value, recipes, seen = new Set()) => {
+    if (!isObject(value) || seen.has(value)) {
+        return false;
+    }
+    seen.add(value);
+    if (isComputed(value)) {
+        const { recipe, args } = value[COMPUTED];
+        return (recipes === null ||
+            recipes.has(recipe) ||
+            args.some((arg) => callsAny(arg, recipes, seen)));
+    }
+    return (isPlain(value) &&
+        Reflect.ownKeys(value).some((key) => callsAny(Reflect.get(value, key), recipes, seen)));
+};
+/**
+ * Resolves the tokens of a library that is first subscribed, so a change
+ * is compared with the values they have: every token of a library made by
+ * `create()`, and an extension's own tokens, which it finds then.
+ */
+function resolveOwn(scope) {
+    if (scope.source === undefined) {
+        forEachToken(scope.tokens, (_, descriptor) => LibraryToken.resolveForSubscriber(descriptor.get()));
+        return;
+    }
+    const origin = originOf(scope);
+    LibraryToken.dropAncestors(scope);
+    for (const name of origin) {
+        LibraryToken.resolveForSubscriber(tokenNamed(scope, name));
+    }
+}
+/**
+ * Resolves the tokens of a subscribed extension that are its ancestor's,
+ * for a subscriber told of them, which is told of a change to each from the
+ * value it has then.
+ */
+function resolveAncestors(scope) {
+    const origin = originOf(scope);
+    completeGraphOf(scope);
+    forEachToken(scope.tokens, (name, descriptor) => {
+        if (!origin.has(name)) {
+            LibraryToken.tryResolve(descriptor.get());
+        }
+    });
+}
+/**
+ * The names of the tokens of a library whose configured values call a
+ * recipe.
+ */
+const callersOf = (scope) => {
+    const { source, own, made } = scope;
+    if (source === undefined) {
+        const names = [];
+        forEachToken(scope.tokens, (name, descriptor) => {
+            if (callsAny(LibraryToken.configuredValue(descriptor.get()), null)) {
+                names.push(name);
+            }
+        });
+        return names;
+    }
+    const names = callersOf(source).filter((name) => !own.has(name));
+    for (const name of own) {
+        if (callsAny(LibraryToken.configuredValue(made.get(name)), null)) {
+            names.push(name);
+        }
+    }
+    return names;
+};
+/**
+ * The tokens of an extension that are its own, found the first time they're
+ * needed: those it gives a value, and those that recipes' results make its
+ * own, which {@link discoverAll} finds once it can have any.
+ */
+function originOf(scope) {
+    let { origin } = scope;
+    if (origin === null) {
+        origin = scope.origin = new Set();
+        for (const name of scope.own) {
+            addOrigin(scope, name, false);
+        }
+    }
+    // With no token of its own and no recipe overridden, none can be, until
+    // it has one.
+    if (!scope.discovered && (origin.size > 0 || scope.overridden.size > 0)) {
+        discoverAll(scope, false);
+    }
+    return origin;
+}
+/**
+ * A change of a batch.
+ */
+const changeOf = (token, valueChanged, origin, originChanged) => Object.freeze({ token, valueChanged, origin, originChanged });
+/**
+ * A subscriber of an extension's batches that's told only of the changes to
+ * its own tokens.
+ */
+const changesFrom = (origin, subscriber) => ({
+    onChange(changes) {
+        const told = changes.filter((change) => change.origin === origin);
+        if (told.length > 0) {
+            subscriber.onChange(told.length === changes.length ? changes : Object.freeze(told));
+        }
+    },
+});
 const libraryTokenOf = (token) => {
     if (!(token instanceof LibraryToken)) {
         throw new Error(`"${token.name}" is not a token of a library.`);
@@ -784,14 +1757,12 @@ function* walkEntries(node, path, options) {
  *
  * This reads the configured values and not the values, so it resolves no
  * token, and so it is known of a library whose tokens have not been read. It
- * is found for the whole library once and kept until a token is set to a
- * different value, so each call after the first is a lookup. A value a recipe
+ * is found for the whole library once, kept as tokens are set, and shared
+ * with the libraries that extend it, so each call after the first is a
+ * lookup, and an extension makes only the tokens it lists. A value a recipe
  * reads other than through its arguments is not seen, as for
  * {@link dependenciesOf}.
  *
- * It throws when a ref in a token of the library isn't a token of it, as
- * reading the token's `$value` does.
- *
  * @example
  * ```ts
  * // hover: { $value: Recipes.darken(theme.colors.primary, 0.2) }
@@ -819,4 +1790,31 @@ export const dependentsOf = (token) =>
 Object.freeze([
     ...LibraryToken.dependents(libraryTokenOf(token)),
 ]);
+/**
+ * The tokens of a library whose values are its own, in the order of the
+ * library: every token of a library made by `create()`, and an extension's
+ * tokens that don't come from its ancestors.
+ *
+ * @remarks
+ * An extension's token is its own when it has a value of its own (one its
+ * config gives, one that is set, or a token new in it), when it calls a
+ * recipe the extension overrides, or when a token it depends on is its own.
+ * A token depends on the tokens its configured value refers to, and on
+ * those a ref in a recipe's result is to, so tokens of its ancestors that
+ * call recipes may be resolved to find them.
+ *
+ * It's what a first render of an extension writes, such as with
+ * {@link toCSS}'s `filter`.
+ *
+ * @example
+ * ```ts
+ * const own = new Set(ownTokensOf(extension));
+ * toCSS(extension, { filter: (token) => own.has(token) });
+ * ```
+ *
+ * @public
+ */
+export const ownTokensOf = (library) => 
+// The tokens of a library of shape `R`.
+Object.freeze(LibraryImpl.ownTokens(library));
 //# sourceMappingURL=library.js.map