2c:Ta50,diagram = htl.html``2d:T45d,apiReference = md`## API reference The whole API is two methods on \`plugins\`. **\`plugins.add(name, value, options?)\`** → \`remove()\` Add \`value\` to the set stored under \`name\` (creating the set on first use). Returns a \`remove()\` function that takes this value back out. \`options.invalidation\` (optional, may be null/omitted) is a promise — when it settles the value is removed automatically; pass a provider cell's built-in \`invalidation\` so re-running the cell replaces rather than duplicates. \`value\` is anything; for shared views it is commonly a factory \`() => element\` that each consumer calls to get its own instance. **\`plugins.get(name)\`** → Generator<value[]> Return a reactive Generator of the values currently in \`name\`'s set. It yields the current set immediately (so a late consumer still converges), then re-yields the full set on every add/remove. Use it from a cell and that cell recomputes on each change. Call it from as many consumers as you like (e.g. a module and its V2) — each call is an independent Generator that cleans up when its cell is torn down.`2e:T5a9,createPlugins = { return function createPlugins() { const sets = new Map(); // name -> Set const listeners = new Map(); // name -> Set<() => void> const notify = name => { const ls = listeners.get(name); if (ls) for (const l of [...ls]) l(); // copy: a consumer may (un)subscribe while notifying }; const add = (name, value, options) => { let set = sets.get(name); if (!set) sets.set(name, set = new Set()); set.add(value); notify(name); const remove = () => { const s = sets.get(name); if (s && s.delete(value)) { if (s.size === 0) sets.delete(name); notify(name); } }; const invalidation = options && options.invalidation; if (invalidation) Promise.resolve(invalidation).then(remove, remove); return remove; }; const get = name => Generators.observe(change => { const push = () => change([...sets.get(name) ?? []]); push(); // current set immediately → converges let ls = listeners.get(name); if (!ls) listeners.set(name, ls = new Set()); ls.add(push); return () => { ls.delete(push); if (ls.size === 0) listeners.delete(name); }; // leak-safe }); return { add, get, listenerCount: name => listeners.get(name)?.size ?? 0 }; }; }2f:[] 2a:{"title":"Plugin Registry","cells":[{"id":5,"value":"intro = md`# Plugin Registry\n\nA foundational notebook for **decoupled reactive plugin wiring**.\n\nConsumers get a realtime stream of all registered providers under a name. Providers can register themselves under a name. Neither has direct references between each other. This allows you to add more consumers and providers without changing individual providers and consumers. Useful for reactive plugin systems like audio instruments, dyamic menus, LLM tools and entity component systems.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":6,"value":"$2c","pinned":false,"hidden":false,"mode":"ojs"},{"id":7,"value":"contracts = md`## Contracts\n\n| Guarantee | How |\n|---|---|\n| **Named sets** | \\`plugins\\` maps a name → a set of values. Providers \\`add\\`, consumers \\`get\\`; they coordinate only by name. |\n| **Reactive** | \\`get(name)\\` is a Generator that yields the current set and re-yields on every add/remove for that name. |\n| **N↔M decoupling** | Providers and consumers share only \\`plugins\\`. Any number of each; a name is the whole contract. |\n| **Auto-cleanup** | \\`add\\` returns \\`remove()\\`. Pass \\`{invalidation}\\` (a cell's disposal promise) to remove automatically when the provider cell re-runs. |\n| **No leaks** | \\`get\\`'s Generator unsubscribes on disposal; per-name listeners are dropped when the last consumer leaves. |\n| **Eventual convergence** | Each consumer gets the current set immediately on \\`get\\`, then a full-set snapshot on every change — so any interleaving of add/remove/get converges. |`","pinned":false,"hidden":false,"mode":"ojs"},{"id":8,"value":"$2d","pinned":false,"hidden":false,"mode":"ojs"},{"id":9,"value":"$2e","pinned":false,"hidden":false,"mode":"ojs"},{"id":10,"value":"plugins = createPlugins()","pinned":false,"hidden":false,"mode":"ojs"},{"id":11,"value":"testsHeader = md`## Tests`","pinned":false,"hidden":false,"mode":"ojs"},{"id":13,"value":"test_get_reflects_add = (async () => {\n const p = createPlugins();\n const gen = p.get('x');\n if ((await (await gen.next()).value).length !== 0)\n throw new Error('new set should start empty');\n p.add('x', 1);\n const after = await (await gen.next()).value;\n if (after.length !== 1 || after[0] !== 1)\n throw new Error('get did not reflect the add');\n gen.return();\n return '\\u2705 get(name) yields the named set and updates on add';\n})()","pinned":false,"hidden":false,"mode":"ojs"},{"id":14,"value":"test_multi_provider_and_convergence = {\n return (async () => {\n const p = createPlugins();\n const a = p.get('x'), b = p.get('x');\n // two independent consumers\n await (await a.next()).value;\n await (await b.next()).value;\n p.add('x', 'one');\n // provider 1\n p.add('x', 'two');\n // provider 2\n const va = (await (await a.next()).value).slice().sort().join(',');\n const vb = (await (await b.next()).value).slice().sort().join(',');\n if (va !== 'one,two' || vb !== 'one,two')\n throw new Error('consumers did not converge to the full set');\n a.return();\n b.return();\n return '\\u2705 multiple providers accumulate; all consumers converge';\n })();\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":15,"value":"test_remove_and_names_isolated = (async () => {\n const p = createPlugins();\n const gx = p.get('x'), gy = p.get('y');\n await (await gx.next()).value;\n await (await gy.next()).value;\n const remove = p.add('x', 1);\n p.add('y', 2);\n if ((await (await gx.next()).value).join() !== '1')\n throw new Error('x set wrong');\n if ((await (await gy.next()).value).join() !== '2')\n throw new Error('names are not isolated');\n remove();\n if ((await (await gx.next()).value).length !== 0)\n throw new Error('remove() did not take the value out');\n gx.return();\n gy.return();\n return '\\u2705 remove() works and names are isolated';\n})()","pinned":false,"hidden":false,"mode":"ojs"},{"id":16,"value":"test_invalidation_and_no_leak = (async () => {\n const p = createPlugins();\n let settle;\n p.add('x', 1, { invalidation: new Promise(r => settle = r) });\n const gen = p.get('x');\n if ((await (await gen.next()).value).length !== 1)\n throw new Error('value should be present before invalidation');\n if (p.listenerCount('x') !== 1)\n throw new Error('get should have registered a listener');\n settle();\n await Promise.resolve();\n await Promise.resolve();\n if ((await (await gen.next()).value).length !== 0)\n throw new Error('invalidation did not remove the value');\n gen.return();\n if (p.listenerCount('x') !== 0)\n throw new Error('disposing the Generator leaked a listener');\n return '\\u2705 {invalidation} auto-removes and get() leaks no listeners';\n})()","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W2f","stdlib":"1","titling":"auto"}