@treenity/react 3.0.1 → 3.0.2

package/src/mods/editor-ui/default-edit.tsx

@@ -1,3 +1,5 @@
+import { Checkbox } from '#components/ui/checkbox';
+import { Input } from '#components/ui/input';
 import { useSchema } from '#schema-loader';
 import { type ComponentData, isRef, register, resolve } from '@treenity/core';
 import { createElement } from 'react';
@@ -57,12 +59,12 @@ function DefaultEditForm({ value, onChange }: { value: ComponentData; onChange?:
               <FieldLabel label={k} value={v} onChange={onCh} />
               {typeof v === 'boolean' ? (
                 <label className="flex items-center gap-2 cursor-pointer">
-                  <input type="checkbox" checked={!!data[k]} className="w-auto"
-                    onChange={(e) => setData((prev) => ({ ...prev, [k]: e.target.checked }))} />
+                  <Checkbox checked={!!data[k]}
+                    onChange={(e) => setData((prev) => ({ ...prev, [k]: (e.target as HTMLInputElement).checked }))} />
                   {data[k] ? 'true' : 'false'}
                 </label>
               ) : typeof v === 'number' ? (
-                <input type="number" value={String(data[k] ?? 0)}
+                <Input type="number" className="h-7 text-xs" value={String(data[k] ?? 0)}
                   onChange={(e) => setData((prev) => ({ ...prev, [k]: Number(e.target.value) }))} />
               ) : Array.isArray(v) ? (
                 <StringArrayField value={data[k] as unknown[]}
@@ -78,7 +80,7 @@ function DefaultEditForm({ value, onChange }: { value: ComponentData; onChange?:
                     : <pre className="text-[11px] font-mono text-foreground/60">{JSON.stringify(data[k], null, 2)}</pre>;
                 })()
               ) : (
-                <input value={String(data[k] ?? '')}
+                <Input className="h-7 text-xs" value={String(data[k] ?? '')}
                   onChange={(e) => setData((prev) => ({ ...prev, [k]: e.target.value }))} />
               )}
             </div>

package/src/mods/editor-ui/form-field.tsx

@@ -1,5 +1,6 @@
 import { Button } from '#components/ui/button';
 import { Input } from '#components/ui/input';
+import { Textarea } from '#components/ui/textarea';
 import { isRef, resolveExact } from '@treenity/core';
 import { createElement, useState } from 'react';
 import { FieldLabel, RefEditor } from './FieldLabel';
@@ -42,7 +43,7 @@ export function renderField(
   const handler = resolveExact(fieldSchema.type, ctx) ?? resolveExact('string', ctx);
   if (!handler)
     return (
-      <div key={name} className="text-[--danger] text-xs">
+      <div key={name} className="text-destructive text-xs">
         No form handler: {fieldSchema.type}
       </div>
     );
@@ -91,7 +92,8 @@ export function StringArrayField({
 
   if (!isStrings) {
     return (
-      <textarea
+      <Textarea
+        className="min-h-16 text-xs font-mono"
         value={JSON.stringify(value, null, 2)}
         onChange={(e) => {
           try {

package/src/mods/editor-ui/type-picker.tsx

@@ -1,6 +1,7 @@
 import { Button } from '#components/ui/button';
 import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from '#components/ui/command';
 import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from '#components/ui/dialog';
+import { Input } from '#components/ui/input';
 import { trpc } from '#trpc';
 import { isOfType, type NodeData } from '@treenity/core';
 import { useEffect, useRef, useState } from 'react';
@@ -123,9 +124,9 @@ export function TypePicker({
         </Command>
 
         <div className="px-4 py-3 border-t border-border">
-          <input
+          <Input
             ref={nameRef}
-            className="w-full"
+            className="h-8 text-sm"
             placeholder={nameLabel}
             value={name}
             onChange={(e) => { setName(e.target.value); setNameManual(true); }}

package/src/mods/treenity/preview.tsx

@@ -1,5 +1,6 @@
 // Reusable type preview — Storybook-like: context switcher + live render + schema form editor
 
+import { Button } from '#components/ui/button';
 import { Render, RenderContext } from '#context';
 import { type ComponentData, getContextsForType, type NodeData } from '@treenity/core';
 import { useMemo, useState } from 'react';
@@ -94,17 +95,15 @@ export function TypePreview({ typeName, properties }: {
     <div>
       <div className="flex gap-1.5 mb-2">
         {reactContexts.map(c => (
-          <button
+          <Button
             key={c}
+            variant={previewCtx === c ? 'default' : 'outline'}
+            size="sm"
+            className="h-auto rounded-full px-2.5 py-0.5 text-xs font-mono"
             onClick={() => setPreviewCtx(prev => prev === c ? null : c)}
-            className={`px-2.5 py-0.5 rounded-full text-xs font-mono border cursor-pointer transition-colors ${
-              previewCtx === c
-                ? 'bg-primary text-primary-foreground border-primary'
-                : 'bg-muted border-border text-muted-foreground hover:border-primary/50'
-            }`}
           >
             {c}
-          </button>
+          </Button>
         ))}
       </div>
 

package/src/mods/treenity/ref-view.tsx

@@ -1,5 +1,6 @@
 // Ref node/component view — shows target path, resolve button, inline preview
 
+import { Button } from '#components/ui/button';
 import { Render } from '#context';
 import { usePath } from '#hooks';
 import { type NodeData, register } from '@treenity/core';
@@ -45,20 +46,24 @@ function RefDisplay({ target, onSelect }: { target: string; onSelect?: (p: strin
         <span className="text-sm font-mono text-primary">{target}</span>
 
         {onSelect && (
-          <button
-            className="text-xs px-2 py-0.5 rounded bg-muted hover:bg-muted/80 text-foreground border border-border"
+          <Button
+            variant="outline"
+            size="sm"
+            className="h-auto px-2 py-0.5 text-xs"
             onClick={() => onSelect(target)}
           >
             Go to
-          </button>
+          </Button>
         )}
 
-        <button
-          className="text-xs px-2 py-0.5 rounded bg-muted hover:bg-muted/80 text-foreground border border-border"
+        <Button
+          variant="outline"
+          size="sm"
+          className="h-auto px-2 py-0.5 text-xs"
           onClick={() => setResolved(!resolved)}
         >
           {resolved ? 'Collapse' : 'Resolve'}
-        </button>
+        </Button>
       </div>
 
       {/* Resolved target */}

package/src/mods/treenity/seed.ts

@@ -1,9 +1,9 @@
-import { type NodeData, R, S } from '@treenity/core';
+import { type NodeData, A, R, S, W } from '@treenity/core';
 import { registerPrefab } from '@treenity/core/mod';
 
 registerPrefab('core', 'seed', [
   { $path: 'sys', $type: 'treenity.system' },
-  { $path: 'auth', $type: 'dir' },
+  { $path: 'auth', $type: 'dir', $acl: [{ g: 'admins', p: R | W | A | S }, { g: 'public', p: 0 }] },
   { $path: 'auth/users', $type: 'mount-point',
     connection: { $type: 'connection', db: 'treenity', collection: 'users' },
     mount: { $type: 't.mount.mongo' },
@@ -20,6 +20,7 @@ registerPrefab('core', 'seed', [
   { $path: 'auth/sessions', $type: 'mount-point',
     connection: { $type: 'connection', db: 'treenity', collection: 'sessions' },
     mount: { $type: 't.mount.mongo' },
+    $acl: [{ g: 'admins', p: R | W | A | S }, { g: 'authenticated', p: 0 }, { g: 'public', p: 0 }],
   },
   { $path: 'mnt', $type: 'dir' },
   { $path: 'mnt/orders', $type: 't.mount.mongo',

package/src/symbols.ts

@@ -1,18 +1,25 @@
 // Symbol-based component location metadata.
-// Stamped on deserialization (cache.put). Survive spread, invisible to JSON/keys/entries.
+// Stamped on deserialization (cache.put). Non-enumerable so they're
+// invisible to structuredClone, spread, and JSON/keys/entries.
 
 import { isComponent, type NodeData } from '@treenity/core';
 
 export const $key = Symbol.for('treenity.$key');
 export const $node = Symbol.for('treenity.$node');
 
+function hide(obj: object, sym: symbol, value: unknown): void {
+  Object.defineProperty(obj, sym, { value, enumerable: false, writable: false, configurable: true });
+}
+
 export function stampNode(node: NodeData): void {
-  (node as any)[$key] = '';
-  (node as any)[$node] = node;
+  if ((node as any)[$node] === node) return;
+
+  hide(node, $key, '');
+  hide(node, $node, node);
 
   for (const [k, v] of Object.entries(node)) {
     if (k.startsWith('$') || !isComponent(v)) continue;
-    (v as any)[$key] = k;
-    (v as any)[$node] = node;
+    hide(v, $key, k);
+    hide(v, $node, node);
   }
 }

package/src/bind/bind.test.ts

@@ -1,316 +0,0 @@
-import type { NodeData } from '@treenity/core';
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import { clearComputed, getComputed, setComputed, subscribeComputed } from './computed';
-import { evaluateRef, extractArgPaths, hasOnce, isCollectionRef } from './eval';
-import { isRefArg, parseMapExpr } from './parse';
-
-// ── Parser ──
-
-describe('parseMapExpr', () => {
-  it('parses pipe with field chain', () => {
-    const expr = parseMapExpr('last().value | div(5)');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'last', args: [] },
-      { type: 'field', name: 'value' },
-      { type: 'pipe', name: 'div', args: [5] },
-    ]);
-  });
-
-  it('parses bare pipe (no parens)', () => {
-    const expr = parseMapExpr('round');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'round', args: [] },
-    ]);
-  });
-
-  it('parses multiple args', () => {
-    const expr = parseMapExpr('clamp(0, 10)');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'clamp', args: [0, 10] },
-    ]);
-  });
-
-  it('parses field-only chain', () => {
-    const expr = parseMapExpr('.status');
-    assert.deepEqual(expr.steps, [
-      { type: 'field', name: 'status' },
-    ]);
-  });
-
-  it('parses complex chain', () => {
-    const expr = parseMapExpr('last().value | sub(20) | abs | div(10)');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'last', args: [] },
-      { type: 'field', name: 'value' },
-      { type: 'pipe', name: 'sub', args: [20] },
-      { type: 'pipe', name: 'abs', args: [] },
-      { type: 'pipe', name: 'div', args: [10] },
-    ]);
-  });
-
-  it('parses map pipe', () => {
-    const expr = parseMapExpr('map(value) | avg');
-    assert.deepEqual(expr.steps, [
-      { type: 'pipe', name: 'map', args: ['value'] },
-      { type: 'pipe', name: 'avg', args: [] },
-    ]);
-  });
-
-  it('parses #field as step (self lookup)', () => {
-    const expr = parseMapExpr('#width | mul(#height)');
-    assert.deepEqual(expr.steps, [
-      { type: 'field', name: 'width' },
-      { type: 'pipe', name: 'mul', args: [{ $ref: '.', fields: ['height'] }] },
-    ]);
-  });
-
-  it('parses #/path.field ref arg', () => {
-    const expr = parseMapExpr('#price | mul(#/config/tax.rate)');
-    const mulStep = expr.steps[1];
-    assert.equal(mulStep.type, 'pipe');
-    if (mulStep.type === 'pipe') {
-      assert.equal(isRefArg(mulStep.args[0]), true);
-      assert.deepEqual(mulStep.args[0], { $ref: '/config/tax', fields: ['rate'] });
-    }
-  });
-
-  it('parses #/path without field (whole node)', () => {
-    const expr = parseMapExpr('count(#/sensors)');
-    const step = expr.steps[0];
-    if (step.type === 'pipe') {
-      assert.deepEqual(step.args[0], { $ref: '/sensors', fields: [] });
-    }
-  });
-
-  it('parses #/path.deep.field', () => {
-    const expr = parseMapExpr('mul(#/config.tax.rate)');
-    const step = expr.steps[0];
-    if (step.type === 'pipe') {
-      assert.deepEqual(step.args[0], { $ref: '/config', fields: ['tax', 'rate'] });
-    }
-  });
-});
-
-// ── Evaluator ──
-
-describe('evaluateRef', () => {
-  const config = { $path: '/config', $type: 'config', factor: 5, tax: { rate: 0.2 } } as NodeData;
-
-  const sensors = [
-    { $path: '/s/1', $type: 'reading', value: 10, seq: 0 },
-    { $path: '/s/2', $type: 'reading', value: 20, seq: 1 },
-    { $path: '/s/3', $type: 'reading', value: 30, seq: 2 },
-  ] as NodeData[];
-
-  const selfNode = { $path: '/obj', $type: 't3d.object', width: 4, height: 3, price: 100 } as NodeData;
-
-  const allNodes = [...sensors, config, selfNode];
-
-  const ctx = {
-    getNode: (p: string) => allNodes.find(s => s.$path === p),
-    getChildren: (p: string) => p === '/s' ? sensors : [],
-  };
-
-  it('resolves plain ref (no $map)', () => {
-    const result = evaluateRef({ $ref: '/s/2' }, ctx);
-    assert.equal((result as NodeData)?.value, 20);
-  });
-
-  it('resolves last().value | div(5)', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'last().value | div(5)' }, ctx);
-    assert.equal(result, 6); // 30 / 5
-  });
-
-  it('resolves first().value', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'first().value' }, ctx);
-    assert.equal(result, 10);
-  });
-
-  it('resolves count()', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'count()' }, ctx);
-    assert.equal(result, 3);
-  });
-
-  it('resolves map + avg', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'map(value) | avg' }, ctx);
-    assert.equal(result, 20); // (10+20+30)/3
-  });
-
-  it('resolves map + sum', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'map(value) | sum' }, ctx);
-    assert.equal(result, 60);
-  });
-
-  it('resolves scalar chain', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'last().value | sub(20) | abs | div(2)' }, ctx);
-    assert.equal(result, 5); // |30-20| / 2
-  });
-
-  it('resolves clamp', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'last().value | clamp(0, 25)' }, ctx);
-    assert.equal(result, 25); // 30 clamped to 25
-  });
-
-  it('resolves single node field access (no collection)', () => {
-    const result = evaluateRef({ $ref: '/s/1', $map: '.value | mul(3)' }, ctx);
-    assert.equal(result, 30); // 10 * 3
-  });
-
-  it('returns undefined for empty children', () => {
-    const result = evaluateRef({ $ref: '/empty', $map: 'last().value' }, ctx);
-    assert.equal(result, undefined);
-  });
-
-  // ── Self-ref + #-args ──
-
-  it('resolves #field self lookup', () => {
-    const result = evaluateRef({ $ref: '/obj', $map: '#width | mul(#height)' }, ctx);
-    assert.equal(result, 12); // 4 * 3
-  });
-
-  it('resolves cross-ref #/path.field arg', () => {
-    const result = evaluateRef({ $ref: '/obj', $map: '#price | mul(#/config.tax.rate)' }, ctx);
-    assert.equal(result, 20); // 100 * 0.2
-  });
-
-  it('resolves external source + self arg via #', () => {
-    const result = evaluateRef({ $ref: '/s', $map: 'last().value | div(#/config.factor)' }, ctx);
-    assert.equal(result, 6); // 30 / 5
-  });
-
-  it('returns NaN for missing #ref node (loud failure)', () => {
-    const result = evaluateRef({ $ref: '/obj', $map: '#width | mul(#/missing.value)' }, ctx);
-    assert.equal(Number.isNaN(result), true); // 4 * undefined = NaN
-  });
-});
-
-// ── isCollectionRef ──
-
-describe('isCollectionRef', () => {
-  it('true for last()', () => {
-    assert.equal(isCollectionRef({ $ref: '/s', $map: 'last().value' }), true);
-  });
-
-  it('true for count()', () => {
-    assert.equal(isCollectionRef({ $ref: '/s', $map: 'count()' }), true);
-  });
-
-  it('false for field access', () => {
-    assert.equal(isCollectionRef({ $ref: '/s/1', $map: '.value' }), false);
-  });
-
-  it('false for #field self access', () => {
-    assert.equal(isCollectionRef({ $ref: '.', $map: '#width' }), false);
-  });
-
-  it('false for no $map', () => {
-    assert.equal(isCollectionRef({ $ref: '/s/1' }), false);
-  });
-});
-
-// ── extractArgPaths ──
-
-describe('extractArgPaths', () => {
-  it('returns external paths from #/path args', () => {
-    const paths = extractArgPaths({ $ref: '/obj', $map: '#price | mul(#/config.rate) | add(#/bonus.value)' });
-    assert.deepEqual(paths, ['/config', '/bonus']);
-  });
-
-  it('skips # self refs', () => {
-    const paths = extractArgPaths({ $ref: '.', $map: '#width | mul(#height)' });
-    assert.deepEqual(paths, []);
-  });
-
-  it('returns empty for no $map', () => {
-    assert.deepEqual(extractArgPaths({ $ref: '/x' }), []);
-  });
-});
-
-// ── hasOnce ──
-
-describe('hasOnce', () => {
-  it('true when once in pipe chain', () => {
-    assert.equal(hasOnce({ $ref: '/s', $map: 'last().value | div(5) | once' }), true);
-  });
-
-  it('true when once is only step', () => {
-    assert.equal(hasOnce({ $ref: '/s', $map: 'once' }), true);
-  });
-
-  it('false for normal pipes', () => {
-    assert.equal(hasOnce({ $ref: '/s', $map: 'last().value | div(5)' }), false);
-  });
-
-  it('false for no $map', () => {
-    assert.equal(hasOnce({ $ref: '/s' }), false);
-  });
-});
-
-// ── once pipe (identity) ──
-
-describe('once pipe in evaluation', () => {
-  const nodes = [
-    { $path: '/s/1', $type: 'r', value: 10 },
-    { $path: '/s/2', $type: 'r', value: 20 },
-  ] as NodeData[];
-
-  const ctx = {
-    getNode: (p: string) => nodes.find(n => n.$path === p),
-    getChildren: (p: string) => p === '/s' ? nodes : [],
-  };
-
-  it('once does not alter the computed value', () => {
-    const withOnce = evaluateRef({ $ref: '/s', $map: 'last().value | div(5) | once' }, ctx);
-    const without = evaluateRef({ $ref: '/s', $map: 'last().value | div(5)' }, ctx);
-    assert.equal(withOnce, without);
-    assert.equal(withOnce, 4); // 20 / 5
-  });
-});
-
-// ── Computed store ──
-
-describe('computed store', () => {
-  it('set + get', () => {
-    setComputed('/test', 'sy', 42);
-    const c = getComputed('/test');
-    assert.equal(c?.sy, 42);
-    clearComputed('/test');
-  });
-
-  it('fires subscriber on change', () => {
-    let fired = 0;
-    const unsub = subscribeComputed('/test2', () => { fired++; });
-    setComputed('/test2', 'px', 1);
-    assert.equal(fired, 1);
-    setComputed('/test2', 'px', 2);
-    assert.equal(fired, 2);
-    // No-op same value
-    setComputed('/test2', 'px', 2);
-    assert.equal(fired, 2);
-    unsub();
-    clearComputed('/test2');
-  });
-
-  it('returns new object reference on change (useSyncExternalStore compat)', () => {
-    setComputed('/ref-test', 'a', 1);
-    const snap1 = getComputed('/ref-test');
-    setComputed('/ref-test', 'a', 2);
-    const snap2 = getComputed('/ref-test');
-    // Must be different references — Object.is must see the change
-    assert.notEqual(snap1, snap2);
-    assert.equal(snap2?.a, 2);
-    // Old snapshot retains old value (immutable)
-    assert.equal(snap1?.a, 1);
-    clearComputed('/ref-test');
-  });
-
-  it('unsubscribe stops notifications', () => {
-    let fired = 0;
-    const unsub = subscribeComputed('/test3', () => { fired++; });
-    unsub();
-    setComputed('/test3', 'sy', 99);
-    assert.equal(fired, 0);
-    clearComputed('/test3');
-  });
-});

package/src/cache.test.ts

@@ -1,139 +0,0 @@
-// Cache contract tests — plain Map implementation
-
-import assert from 'node:assert';
-import { beforeEach, describe, it } from 'node:test';
-import * as cache from './cache';
-
-describe('cache', () => {
-  beforeEach(() => {
-    cache.clear();
-  });
-
-  it('put() creates entry, get() returns node', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 1 } as any);
-    const n = cache.get('/a');
-    assert.ok(n);
-    assert.strictEqual(n!.v, 1);
-  });
-
-  it('second put() updates value', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 1 } as any);
-    cache.put({ $path: '/a', $type: 'x', v: 2 } as any);
-    const n = cache.get('/a');
-    assert.strictEqual(n!.v, 2);
-  });
-
-  it('put() with fewer keys replaces node', () => {
-    cache.put({ $path: '/a', $type: 'x', old: 1, keep: 2 } as any);
-    cache.put({ $path: '/a', $type: 'x', keep: 3 } as any);
-    const n = cache.get('/a') as any;
-    assert.strictEqual(n.keep, 3);
-    assert.strictEqual('old' in n, false);
-  });
-
-  it('subscribePath fires on put()', () => {
-    let called = 0;
-    cache.subscribePath('/a', () => called++);
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    assert.strictEqual(called, 1);
-  });
-
-  it('subscribeChildren fires on child put()', () => {
-    let called = 0;
-    cache.subscribeChildren('/', () => called++);
-    cache.put({ $path: '/child', $type: 'x' } as any);
-    assert.ok(called >= 1);
-  });
-
-  it('getSnapshot() returns plain cloneable object', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 42 } as any);
-    const s = cache.getSnapshot('/a');
-    assert.ok(s);
-    assert.strictEqual(s!.v, 42);
-    const cloned = structuredClone(s);
-    assert.strictEqual(cloned.v, 42);
-  });
-
-  it('getSnapshot() returns a copy, not the same reference', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 42 } as any);
-    const s = cache.getSnapshot('/a');
-    assert.notStrictEqual(s, cache.get('/a'));
-  });
-
-  it('notifyPath fires path subs', () => {
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    let called = 0;
-    cache.subscribePath('/a', () => called++);
-    cache.notifyPath('/a');
-    assert.strictEqual(called, 1);
-  });
-
-  it('getChildren returns sorted children', () => {
-    cache.put({ $path: '/b', $type: 'x' } as any);
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    const kids = cache.getChildren('/');
-    assert.strictEqual(kids.length, 2);
-    assert.strictEqual(kids[0].$path, '/a');
-    assert.strictEqual(kids[1].$path, '/b');
-  });
-
-  it('remove() deletes node and fires subs', () => {
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    let called = 0;
-    cache.subscribePath('/a', () => called++);
-    cache.remove('/a');
-    assert.strictEqual(cache.get('/a'), undefined);
-    assert.strictEqual(called, 1);
-  });
-
-  it('putMany() stores all nodes, fires subs', () => {
-    let parentFired = 0;
-    cache.subscribeChildren('/p', () => parentFired++);
-    cache.putMany([
-      { $path: '/p/a', $type: 'x' } as any,
-      { $path: '/p/b', $type: 'x' } as any,
-    ], '/p');
-    assert.ok(cache.get('/p/a'));
-    assert.ok(cache.get('/p/b'));
-    assert.ok(parentFired >= 1);
-  });
-
-  it('direct mutation of get() result changes cached value', () => {
-    cache.put({ $path: '/a', $type: 'x', v: 1 } as any);
-    const n = cache.get('/a') as any;
-    n.v = 99;
-    assert.strictEqual(cache.get('/a')!.v, 99);
-  });
-
-  it('onNodePut callback fires on every put()', () => {
-    const paths: string[] = [];
-    cache.onNodePut((p) => paths.push(p));
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    cache.put({ $path: '/b', $type: 'x' } as any);
-    assert.deepStrictEqual(paths, ['/a', '/b']);
-  });
-
-  it('nested component update works', () => {
-    cache.put({ $path: '/a', $type: 'x', comp: { $type: 'y', count: 0, label: 'hi' } } as any);
-    cache.put({ $path: '/a', $type: 'x', comp: { $type: 'y', count: 5, label: 'hi' } } as any);
-    assert.strictEqual((cache.get('/a') as any).comp.count, 5);
-  });
-
-  it('adding a new nested component', () => {
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    cache.put({ $path: '/a', $type: 'x', comp: { $type: 'y', v: 1 } } as any);
-    assert.strictEqual((cache.get('/a') as any).comp.v, 1);
-  });
-
-  it('removing a nested component', () => {
-    cache.put({ $path: '/a', $type: 'x', comp: { $type: 'y', v: 1 } } as any);
-    cache.put({ $path: '/a', $type: 'x' } as any);
-    assert.strictEqual('comp' in (cache.get('/a') as any), false);
-  });
-
-  it('array replaced wholesale', () => {
-    cache.put({ $path: '/a', $type: 'x', items: [1, 2, 3] } as any);
-    cache.put({ $path: '/a', $type: 'x', items: [4, 5] } as any);
-    assert.deepStrictEqual([...(cache.get('/a') as any).items], [4, 5]);
-  });
-});