@treenity/core 1.0.48 → 3.0.1

package/src/server/errors.ts

@@ -0,0 +1,11 @@
+// Domain errors for server operations.
+// Transport-agnostic: tRPC, HTTP, MCP each map these to their own format.
+
+export type ErrorCode = 'NOT_FOUND' | 'BAD_REQUEST' | 'CONFLICT' | 'FORBIDDEN';
+
+export class OpError extends Error {
+  override readonly name = 'OpError';
+  constructor(public readonly code: ErrorCode, message: string) {
+    super(message);
+  }
+}

package/src/server/factory.ts

@@ -0,0 +1,121 @@
+// treenity() — universal server factory
+// Single entry point: loads infrastructure, mods, builds pipeline, wires logging.
+
+import '#contexts/schema/index';
+import '#contexts/text/index';
+import '#schema/load';
+import './mount-adapters';
+
+import { type ServiceHandle, startServices } from '#contexts/service/index';
+import { A, createNode, type NodeData, R, S, W } from '#core';
+import { addOnLog, makeLogPath } from '#log';
+import { loadAllMods } from '#mod';
+import { createMemoryTree, type Tree } from '#tree';
+import type { Server } from 'node:http';
+import { deploySeedPrefabs } from './prefab';
+import { createEnsure, type Ensure } from './seed';
+import { createHttpServer, createPipeline, type Pipeline } from './server';
+
+export type TreenityConfig = {
+  rootNode?: NodeData;
+  dataDir?: string;
+  modsDir?: string | false;
+  seed?: (store: Tree, ensure: Ensure) => Promise<void>;
+  autostart?: boolean;
+};
+
+export type ListenOpts = {
+  host?: string;
+  allowedOrigins?: string[];
+  staticDir?: string;
+};
+
+export type TreenityInstance = Pipeline & {
+  stop(): Promise<void>;
+};
+
+export type TreenityServer = TreenityInstance & {
+  listen(port?: number, opts?: ListenOpts): Promise<Server>;
+};
+
+export async function treenity(config?: TreenityConfig): Promise<TreenityServer> {
+  const dataDir = config?.dataDir ?? './data';
+  const autostart = config?.autostart ?? true;
+
+  // 1. Load mods
+  if (config?.modsDir !== false) {
+    const extraDirs = config?.modsDir ? [config.modsDir] : [];
+    await loadAllMods('server', ...extraDirs);
+  }
+
+  // 2. Bootstrap: root node
+  const bootstrap = createMemoryTree();
+  let rootNode: NodeData;
+  if (config?.rootNode) {
+    rootNode = config.rootNode;
+  } else {
+    rootNode = createNode('/', 'root', {}, {
+      mount: { $type: 't.mount.overlay', layers: ['base', 'work'] },
+      base: { $type: 't.mount.fs', root: dataDir + '/base' },
+      work: { $type: 't.mount.fs', root: dataDir + '/work' },
+    });
+    rootNode.$acl = [
+      { g: 'authenticated', p: R | S },
+      { g: 'admins', p: R | W | A | S },
+    ];
+  }
+  await bootstrap.set(rootNode);
+
+  // 3. Build pipeline
+  const pipeline = createPipeline(bootstrap);
+  const { store, mountable } = pipeline;
+
+  // 4. Seed — if rootNode declares seeds, only deploy those mods
+  if (config?.seed) {
+    await config.seed(mountable, createEnsure(mountable));
+  } else {
+    const seedFilter = (rootNode as Record<string, unknown>).seeds as string[] | undefined;
+    await deploySeedPrefabs(mountable, seedFilter);
+  }
+
+  // 5. Wire log → tree
+  addOnLog(entry => {
+    const p = makeLogPath()
+    // process.stderr.write(`[log→tree] ${p} ${entry.level}: ${entry.msg.slice(0, 60)}\n`)
+    mountable.set({ $path: p, $type: 't.log', ...entry })
+      .catch(e => process.stderr.write(`[log write err] ${e.message}\n`))
+  })
+
+  // 6. Autostart services
+  let serviceHandle: ServiceHandle | null = null;
+  if (autostart) {
+    serviceHandle = await startServices(store, store.subscribe.bind(store) as import('#contexts/service/index').ServiceCtx['subscribe']);
+  }
+
+  const stop = async () => {
+    await serviceHandle?.stop();
+  };
+
+  return {
+    store: pipeline.store,
+    mountable: pipeline.mountable,
+    watcher: pipeline.watcher,
+    router: pipeline.router,
+    createContext: pipeline.createContext,
+    stop,
+
+    async listen(port = 3211, opts?: ListenOpts) {
+      const host = opts?.host ?? '127.0.0.1';
+      const server = createHttpServer(pipeline, {
+        allowedOrigins: opts?.allowedOrigins,
+        staticDir: opts?.staticDir,
+      });
+      return new Promise<Server>((resolve) => {
+        server.listen(port, host, () => {
+          console.log(`treenity ${host}:${port}`);
+          resolve(server);
+        });
+      });
+    },
+  };
+}

package/src/server/main.ts

@@ -0,0 +1,24 @@
+import 'dotenv/config';
+import { type NodeData } from '#core';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { treenity } from './factory';
+
+// Lock CWD — no library may change it
+process.chdir = () => { throw new Error('process.chdir is forbidden'); };
+
+const rootPath = resolve(process.argv[2] || 'root.json');
+const rootNode = JSON.parse(await readFile(rootPath, 'utf-8')) as NodeData;
+
+const t = await treenity({ rootNode });
+const port = Number(process.env.PORT) || 3211;
+const host = process.env.HOST || '127.0.0.1';
+const server = await t.listen(port, { host });
+
+process.on('unhandledRejection', (err) => console.error('[UNHANDLED]', err));
+
+process.on('SIGTERM', async () => {
+  await t.stop();
+  server.close();
+  process.exit(0);
+});

package/src/server/migrate.test.ts

@@ -0,0 +1,123 @@
+import { createNode, register, unregister } from '#core';
+import { createMemoryTree } from '#tree';
+import assert from 'node:assert/strict';
+import { afterEach, describe, it } from 'node:test';
+import { withMigration } from './migrate';
+
+const TEST_TYPE = 'test.migrated';
+
+describe('withMigration', () => {
+  afterEach(() => {
+    unregister(TEST_TYPE, 'migrate');
+  });
+
+  it('passes through nodes without migrations', async () => {
+    const inner = createMemoryTree();
+    const store = withMigration(inner);
+    const node = createNode('/a', 'dir', { label: 'hi' });
+    await inner.set(node);
+
+    const got = await store.get('/a');
+    assert.equal(got?.label, 'hi');
+    assert.equal((got as any).$v, undefined);
+  });
+
+  it('runs migration chain on read for v0 node', async () => {
+    register(TEST_TYPE, 'migrate', () => ({
+      1: (n: any) => { n.items = Array.isArray(n.items) ? n.items : []; },
+      2: (n: any) => { n.label ??= 'default'; },
+    }));
+
+    const inner = createMemoryTree();
+    const store = withMigration(inner);
+    await inner.set(createNode('/a', TEST_TYPE, { items: 'old-string' }));
+
+    const got = await store.get('/a');
+    assert.deepEqual(got?.items, []);
+    assert.equal(got?.label, 'default');
+    assert.equal((got as any).$v, 2);
+  });
+
+  it('skips already-applied migrations', async () => {
+    let ran1 = false;
+    register(TEST_TYPE, 'migrate', () => ({
+      1: (_n: any) => { ran1 = true; },
+      2: (n: any) => { n.upgraded = true; },
+    }));
+
+    const inner = createMemoryTree();
+    const store = withMigration(inner);
+    await inner.set({ ...createNode('/a', TEST_TYPE), $v: 1 } as any);
+
+    const got = await store.get('/a');
+    assert.equal(ran1, false);
+    assert.equal(got?.upgraded, true);
+    assert.equal((got as any).$v, 2);
+  });
+
+  it('returns node unchanged when already at current version', async () => {
+    register(TEST_TYPE, 'migrate', () => ({
+      1: (n: any) => { n.touched = true; },
+    }));
+
+    const inner = createMemoryTree();
+    const store = withMigration(inner);
+    await inner.set({ ...createNode('/a', TEST_TYPE), $v: 1 } as any);
+
+    const got = await store.get('/a');
+    assert.equal(got?.touched, undefined);
+    assert.equal((got as any).$v, 1);
+  });
+
+  it('stamps $v on set()', async () => {
+    register(TEST_TYPE, 'migrate', () => ({
+      1: (_n: any) => {},
+      2: (_n: any) => {},
+    }));
+
+    const inner = createMemoryTree();
+    const store = withMigration(inner);
+    const node = createNode('/a', TEST_TYPE, { x: 1 });
+    await store.set(node);
+
+    // Read from inner store to see what was actually persisted
+    const raw = await inner.get('/a');
+    assert.equal((raw as any).$v, 2);
+  });
+
+  it('migrates children in getChildren()', async () => {
+    register(TEST_TYPE, 'migrate', () => ({
+      1: (n: any) => { n.fixed = true; },
+    }));
+
+    const inner = createMemoryTree();
+    const store = withMigration(inner);
+    await inner.set(createNode('/parent', 'dir'));
+    await inner.set(createNode('/parent/a', TEST_TYPE, { val: 1 }));
+    await inner.set(createNode('/parent/b', TEST_TYPE, { val: 2 }));
+
+    const { items } = await store.getChildren('/parent');
+    assert.equal(items.length, 2);
+    for (const item of items) {
+      assert.equal(item.fixed, true);
+      assert.equal((item as any).$v, 1);
+    }
+  });
+
+  it('does not mutate the original stored node', async () => {
+    register(TEST_TYPE, 'migrate', () => ({
+      1: (n: any) => { n.data = 'migrated'; },
+    }));
+
+    const inner = createMemoryTree();
+    const store = withMigration(inner);
+    await inner.set(createNode('/a', TEST_TYPE, { data: 'old' }));
+
+    await store.get('/a');
+
+    // Inner store should still have original data
+    const raw = await inner.get('/a');
+    assert.equal(raw?.data, 'old');
+    assert.equal((raw as any).$v, undefined);
+  });
+});

package/src/server/migrate.ts

@@ -0,0 +1,62 @@
+// Per-type schema migration — normalizes nodes on read, stamps $v on write.
+// Migrations registered via: register(type, 'migrate', { 1: fn, 2: fn })
+// Absent $v = version 0. Migration functions mutate the node clone in-place.
+// NOTE: not wired into pipeline yet — will be added between validated and subscriptions
+
+import { type NodeData, resolveExact } from '#core';
+import type { Tree } from '#tree';
+
+type Migrator = (node: Record<string, unknown>) => void;
+type Migrations = Record<number, Migrator>;
+
+function getMigrations(type: string): { migrations: Migrations; version: number } | null {
+  const handler = resolveExact(type, 'migrate');
+  if (!handler) return null;
+  const migrations = handler() as Migrations;
+  const keys = Object.keys(migrations).map(Number).sort((a, b) => a - b);
+  if (!keys.length) return null;
+  return { migrations, version: keys[keys.length - 1] };
+}
+
+function migrateNode(node: NodeData): NodeData {
+  const m = getMigrations(node.$type);
+  if (!m) return node;
+
+  const nodeV = (node['$v'] as number) ?? 0;
+  if (nodeV >= m.version) return node;
+
+  const clone = structuredClone(node);
+  for (const [v, fn] of Object.entries(m.migrations).sort(([a], [b]) => +a - +b)) {
+    if (+v > nodeV) fn(clone as Record<string, unknown>);
+  }
+  clone['$v'] = m.version;
+  return clone;
+}
+
+function stampVersion(node: NodeData): void {
+  const m = getMigrations(node.$type);
+  if (!m) return;
+  node['$v'] = m.version;
+}
+
+export function withMigration(store: Tree): Tree {
+  return {
+    ...store,
+
+    async get(path, ctx) {
+      const node = await store.get(path, ctx);
+      if (!node) return node;
+      return migrateNode(node);
+    },
+
+    async getChildren(path, opts, ctx) {
+      const page = await store.getChildren(path, opts, ctx);
+      return { ...page, items: page.items.map(migrateNode) };
+    },
+
+    async set(node, ctx) {
+      stampVersion(node);
+      return store.set(node, ctx);
+    },
+  };
+}

package/src/server/mod-catalog.ts

@@ -0,0 +1,59 @@
+// Mod Catalog — synthesizes rich mod info from loader + tracking + TypeCatalog + prefabs
+// Pure functions, no store deps.
+
+import { getLoadedMods } from '#mod/loader';
+import { getModPrefabs, getRegisteredMods } from '#mod/prefab';
+import { getTypesForMod, inferModFromType } from '#mod/tracking';
+import type { ModState } from '#mod/types';
+import type { CatalogEntry } from '#schema/catalog';
+import { TypeCatalog } from '#schema/catalog';
+
+export type ModInfo = {
+  name: string;
+  state: ModState;
+  error?: string;
+  types: CatalogEntry[];
+  prefabs: string[];
+};
+
+const catalog = new TypeCatalog();
+
+/** Get rich info for a single mod (works for loader AND prefab-only mods) */
+export function getModInfo(name: string): ModInfo {
+  const loaded = getLoadedMods().find(m => m.name === name);
+  return buildModInfo(name, loaded?.state ?? 'loaded', loaded?.error);
+}
+
+/** Get info for all known mods (loader + prefab registry) */
+export function getAllMods(): ModInfo[] {
+  const names = new Set(getLoadedMods().map(m => m.name));
+  for (const n of getRegisteredMods()) names.add(n);
+  return [...names].map(n => getModInfo(n));
+}
+
+function buildModInfo(name: string, state: ModState, error?: Error): ModInfo {
+  // Tracked types first
+  const tracked = getTypesForMod(name);
+  const trackedSet = new Set(tracked);
+
+  // Convention fallback: catalog types whose inferred mod matches
+  const allTypes = catalog.list();
+  const conventionTypes = allTypes.filter(
+    e => !trackedSet.has(e.name) && inferModFromType(e.name) === name,
+  );
+
+  const types = [
+    ...allTypes.filter(e => trackedSet.has(e.name)),
+    ...conventionTypes,
+  ];
+
+  const prefabs = getModPrefabs(name).map(([n]) => n);
+
+  return {
+    name,
+    state,
+    ...(error ? { error: error.message } : {}),
+    types,
+    prefabs,
+  };
+}

package/src/server/mods-mount.ts

@@ -0,0 +1,177 @@
+// Treenity Mods Mount — Layer 4
+// Virtual read-only store exposing loaded mods as rich catalog nodes.
+// Sources: mod loader (all loaded mods) + tracking + TypeCatalog + prefab registry.
+//
+// Tree structure:
+//   /sys/mods/                           → dir (list all loaded mods)
+//   /sys/mods/{mod}                      → t.mod node (name, state, types, prefabs)
+//   /sys/mods/{mod}/types/               → dir (list type CatalogEntries)
+//   /sys/mods/{mod}/types/{typeName}     → CatalogEntry node
+//   /sys/mods/{mod}/prefabs/             → dir (list prefabs)
+//   /sys/mods/{mod}/prefabs/{name}/      → prefab root (dir)
+//   /sys/mods/{mod}/prefabs/{name}/{...} → prefab nodes
+
+import { createNode, type NodeData } from '#core';
+import { getLoadedMods } from '#mod/loader';
+import { getModPrefabs, getPrefab, getRegisteredMods } from '#mod/prefab';
+import { paginate, type Tree } from '#tree';
+import { getModInfo } from './mod-catalog';
+
+type ParsedPath = {
+  mod?: string;
+  sub?: 'types' | 'prefabs';
+  name?: string;   // type name or prefab name
+  rest?: string;    // prefab sub-path
+};
+
+export function createModsStore(_backingStore: Tree, modsPath = '/sys/mods'): Tree {
+  // Union: loader registry + prefab registry (some mods have prefabs but aren't in loader, e.g. tests)
+  function allModNames(): Set<string> {
+    const names = new Set(getLoadedMods().map(m => m.name));
+    for (const n of getRegisteredMods()) names.add(n);
+    return names;
+  }
+
+  function parsePath(path: string): ParsedPath {
+    const rel = path.slice(modsPath.length);
+    if (!rel || rel === '/') return {};
+    const parts = rel.slice(1).split('/');
+
+    if (parts.length === 1) return { mod: parts[0] };
+
+    const sub = parts[1] as 'types' | 'prefabs';
+    if (sub !== 'types' && sub !== 'prefabs') return { mod: parts[0] };
+
+    if (parts.length === 2) return { mod: parts[0], sub };
+    const name = parts[2];
+
+    if (sub === 'types') return { mod: parts[0], sub, name };
+
+    // prefabs: may have deeper paths
+    const rest = parts.length > 3 ? parts.slice(3).join('/') : undefined;
+    return { mod: parts[0], sub: 'prefabs', name, rest };
+  }
+
+  return {
+    async get(path) {
+      const p = parsePath(path);
+
+      // /sys/mods
+      if (!p.mod) return createNode(path, 'dir');
+
+      if (!allModNames().has(p.mod)) return undefined;
+
+      // /sys/mods/{mod} → t.mod node
+      if (!p.sub) {
+        const info = getModInfo(p.mod);
+        return {
+          $path: path,
+          $type: 't.mod',
+          name: info.name,
+          state: info.state,
+          ...(info.error ? { error: info.error } : {}),
+          types: info.types.map(t => t.name),
+          prefabs: info.prefabs,
+        } as unknown as NodeData;
+      }
+
+      // /sys/mods/{mod}/types
+      if (p.sub === 'types' && !p.name) return createNode(path, 'dir');
+
+      // /sys/mods/{mod}/types/{typeName}
+      if (p.sub === 'types' && p.name) {
+        const info = getModInfo(p.mod);
+        const entry = info?.types.find(t => t.name === p.name);
+        if (!entry) return undefined;
+        return {
+          $path: path,
+          $type: 'type',
+          name: entry.name,
+          ...(entry.title ? { title: entry.title } : {}),
+          properties: entry.properties,
+          actions: entry.actions,
+        } as unknown as NodeData;
+      }
+
+      // /sys/mods/{mod}/prefabs
+      if (p.sub === 'prefabs' && !p.name) return createNode(path, 'dir');
+
+      // /sys/mods/{mod}/prefabs/{name}
+      const prefab = getPrefab(p.mod, p.name!);
+      if (!prefab) return undefined;
+
+      if (!p.rest) return createNode(path, 'dir');
+
+      // /sys/mods/{mod}/prefabs/{name}/{rest}
+      const found = prefab.nodes.find(n => {
+        const np = n.$path.startsWith('.') ? n.$path.slice(1) : n.$path;
+        const clean = np.startsWith('/') ? np.slice(1) : np;
+        return clean === p.rest;
+      });
+      return found ? { ...found, $path: path } : undefined;
+    },
+
+    async getChildren(path, opts) {
+      const p = parsePath(path);
+      const items: NodeData[] = [];
+
+      if (!p.mod) {
+        // List all known mods (loader + prefab registry)
+        for (const name of allModNames()) {
+          items.push(createNode(`${modsPath}/${name}`, 't.mod'));
+        }
+      } else if (!p.sub) {
+        // Mod children: /types + /prefabs (if non-empty)
+        const info = getModInfo(p.mod);
+        if (info) {
+          if (info.types.length > 0) items.push(createNode(`${path}/types`, 'dir'));
+          if (info.prefabs.length > 0) items.push(createNode(`${path}/prefabs`, 'dir'));
+        }
+      } else if (p.sub === 'types' && !p.name) {
+        // List types for mod
+        const info = getModInfo(p.mod);
+        if (info) {
+          for (const t of info.types) {
+            items.push({
+              $path: `${path}/${t.name}`,
+              $type: 'type',
+              name: t.name,
+              ...(t.title ? { title: t.title } : {}),
+              properties: t.properties,
+              actions: t.actions,
+            } as unknown as NodeData);
+          }
+        }
+      } else if (p.sub === 'prefabs' && !p.name) {
+        // List prefabs for mod
+        for (const [name] of getModPrefabs(p.mod)) {
+          items.push(createNode(`${path}/${name}`, 'dir'));
+        }
+      } else if (p.sub === 'prefabs' && p.name) {
+        // List prefab nodes (direct children only)
+        const prefab = getPrefab(p.mod, p.name);
+        if (prefab) {
+          for (const node of prefab.nodes) {
+            if (node.$path === '.' || node.$path.startsWith('/')) continue;
+            if (node.$path.includes('/')) continue;
+            items.push({ ...node, $path: `${path}/${node.$path}` });
+          }
+        }
+      }
+
+      return paginate(items, opts);
+    },
+
+    async set() {
+      throw new Error('Mods mount is read-only');
+    },
+
+    async remove() {
+      throw new Error('Mods mount is read-only');
+    },
+
+    async patch() {
+      throw new Error('Mods mount is read-only');
+    },
+  };
+}

package/src/server/mount-adapters.ts

@@ -0,0 +1,87 @@
+// Mount adapter registrations — type "mount" context handlers
+// Naming: t.mount.{name} — system infrastructure adapters
+
+import { createTrpcTransport } from '#client';
+import { getComponent, isComponent, type NodeData, register, resolve } from '#core';
+import { createMemoryTree, createOverlayTree, type Tree } from '#tree';
+import { createFsTree } from '#tree/fs';
+import { createRawFsStore } from '#tree/mimefs';
+import { createMongoTree } from '#tree/mongo';
+import { createQueryTree } from '#tree/query';
+import { createRepathTree } from '#tree/repath';
+import { createModsStore } from './mods-mount';
+import { createTypesStore } from './types-mount';
+
+export type MountAdapter = (config: NodeData, parentStore: Tree, ctx?: any, globalStore?: Tree) => Tree | Promise<Tree>;
+
+declare module '#core/context' {
+  interface ContextHandlers {
+    mount: MountAdapter;
+  }
+}
+
+register('t.mount.mongo', 'mount', async (config: NodeData) => {
+  const conn = getComponent<{ uri?: string; db?: string; collection?: string }>(config, 'connection');
+  if (!conn) throw new Error("t.mount.mongo requires 'connection' component");
+  const uri = conn.uri ?? process.env.MONGO_URI;
+  if (!uri) throw new Error('t.mount.mongo: no uri and MONGO_URI not set');
+  return createMongoTree(uri, conn.db ?? 'treenity', conn.collection ?? 'nodes');
+});
+
+// deps = parent store (used as backing for registry types)
+register('t.mount.types', 'mount', (_node, deps) => createTypesStore(deps));
+
+register('t.mount.mods', 'mount', (_node, deps) => createModsStore(deps));
+
+register('t.mount.memory', 'mount', () => createMemoryTree());
+
+register('t.mount.query', 'mount', (config: NodeData, parentStore, ctx, globalStore) => {
+  const query = getComponent<{ source: string; match: Record<string, unknown> }>(config, 'query');
+  if (!query?.source || !query?.match) throw new Error("t.mount.query requires 'query' component with source and match");
+  return createQueryTree({ source: query.source, match: query.match }, globalStore || parentStore);
+});
+
+register('t.mount.fs', 'mount', async (config: NodeData) => {
+  const root = config['root'] as string | undefined;
+  if (!root) throw new Error('t.mount.fs: root required');
+  const tree = await createFsTree(root);
+  // shared: true — full tree paths (multiple mount points into one dir)
+  // default: dedicated — repath to local /
+  return config['shared'] ? tree : createRepathTree(tree, config.$path, '/');
+});
+
+register('t.mount.rawfs', 'mount', async (config: NodeData) => {
+  const root = config['root'] as string | undefined;
+  if (!root) throw new Error('t.mount.rawfs: root required');
+  const tree = await createRawFsStore(root);
+  return config['shared'] ? tree : createRepathTree(tree, config.$path, '/');
+});
+
+// Federation: mount a remote Treenity instance's tree via tRPC.
+// connection.url = remote server, connection.path = remote subtree root (default '/'),
+// connection.token = auth token. Path translation handled by createRepathTree.
+register('t.mount.tree.trpc', 'mount', async (config: NodeData) => {
+  const conn = getComponent<{ url?: string; path?: string; token?: string }>(config, 'connection');
+  if (!conn?.url) throw new Error('t.mount.trpc: connection.url required');
+  const { tree } = createTrpcTransport({ url: conn.url, token: conn.token });
+  return createRepathTree(tree, config.$path, conn.path ?? '/');
+});
+
+register('t.mount.overlay', 'mount', async (config: NodeData, parentStore, ctx, globalStore) => {
+  const mount = getComponent<{ layers?: string[] }>(config, 't.mount.overlay', 'mount');
+  if (!mount?.layers?.length) throw new Error('t.mount.overlay: layers required');
+  const stores: Tree[] = [];
+  for (const name of mount.layers) {
+    const comp = config[name];
+    if (!isComponent(comp)) throw new Error(`t.mount.overlay: component "${name}" not found`);
+    const adapter = resolve(comp.$type, 'mount');
+    if (!adapter) throw new Error(`No mount adapter for "${comp.$type}"`);
+    // Propagate parent $path so sub-adapters can repath correctly
+    const subConfig = { ...comp, $path: config.$path } as NodeData;
+    stores.push(await adapter(subConfig, stores[0] ?? ({} as Tree), ctx, globalStore));
+  }
+  // First = lower (base), last = upper (writes go here)
+  let result = stores[0];
+  for (let i = 1; i < stores.length; i++) result = createOverlayTree(stores[i], result);
+  return result;
+});