@treenity/core 1.0.48 → 3.0.0

package/src/chain.test.ts

@@ -0,0 +1,190 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { chain, refVal, runPathWithRefs, TypedRef } from './chain';
+
+// ── basic ──
+
+test('sync field', async () => {
+  assert.equal(await chain({ name: 'Alice' }).name, 'Alice')
+})
+
+test('sync method', async () => {
+  assert.equal(await chain({ greet: (n: string) => `hello ${n}` }).greet('Bob'), 'hello Bob')
+})
+
+test('async field', async () => {
+  assert.equal(await chain({ fetch: async () => 42 }).fetch(), 42)
+})
+
+test('deep sync chain', async () => {
+  const obj = { user: { profile: { name: 'Alice' } } }
+  assert.equal(await chain(obj).user.profile.name, 'Alice')
+})
+
+test('deep async chain', async () => {
+  const obj = {
+    user: async (id: string) => ({
+      id,
+      posts: async () => [{ title: 'Hello' }, { title: 'World' }],
+    }),
+  }
+  const posts = await chain(obj).user('123').posts()
+  assert.deepEqual(posts, [{ title: 'Hello' }, { title: 'World' }])
+})
+
+test('method chaining returns new chain', async () => {
+  const obj = {
+    add: (n: number) => ({
+      multiply: (m: number) => n * m,
+    }),
+  }
+  assert.equal(await chain(obj).add(3).multiply(4), 12)
+})
+
+test('this binding preserved', async () => {
+  const obj = { value: 42, get() { return this.value } }
+  assert.equal(await chain(obj).get(), 42)
+})
+
+test('null in chain throws', async () => {
+  await assert.rejects(
+    async () => { await chain({ user: null } as any).user.name },
+  )
+})
+
+test('same chain reusable', async () => {
+  let callCount = 0
+  const obj = { fetch: async () => { callCount++; return callCount } }
+  const c = chain(obj).fetch()
+  assert.equal(await c, 1)
+  assert.equal(await c, 2)  // no caching — executes again
+})
+
+test('async error propagates', async () => {
+  const obj = { fail: async () => { throw new Error('boom') } }
+  await assert.rejects(async () => { await chain(obj).fail() })
+})
+
+// ── demo tracker component types ──
+
+class LivePrices {
+  static $type = 'demo.live-prices'
+  feederUrl = 'ws://localhost:8090'
+  async subscribe({ slugs }: { slugs: string[] }) {
+    return slugs.map(s => ({ slug: s, bid: 0.6, ask: 0.65 }))
+  }
+}
+
+class Scanner {
+  static $type = 'demo.scanner'
+  intervalMs = 900_000
+  livePrices: TypedRef<LivePrices> = refVal(LivePrices, '/demo/live-prices')
+  depositTracker: TypedRef<DepositTracker> = refVal(DepositTracker, '/demo/deposits')
+}
+
+class DepositTracker {
+  static $type = 'demo.deposit-tracker'
+  async run() { return { added: 12, ts: Date.now() } }
+}
+
+class Profile {
+  static $type = 'demo.profile'
+  address = ''
+  async fetch({ address }: { address: string }) {
+    return { address, name: 'whale.eth', totalPnl: 50_000 }
+  }
+  async trades({ page = 1 } = {}) {
+    return { page, items: [{ hash: '0xabc', amount: 1000 }] }
+  }
+}
+
+// ── refVal ──
+
+test('refVal stores $type and $ref', () => {
+  const ref = refVal(LivePrices, '/demo/live-prices')
+  assert.equal(ref.$type, 'ref')
+  assert.equal(ref.$ref, '/demo/live-prices')
+})
+
+test('refVal default path is empty', () => {
+  const ref = refVal(LivePrices)
+  assert.equal(ref.$ref, '')
+})
+
+// ── server executor: auto-resolves refs ──
+
+function makeStore(entries: [string, any][]) {
+  const m = new Map(entries)
+  return (ref: { $ref: string }) => {
+    const node = m.get(ref.$ref)
+    if (!node) throw new Error(`Ref not found: ${ref.$ref}`)
+    return Promise.resolve(node)
+  }
+}
+
+test('runPathWithRefs: follows ref to node', async () => {
+  const live = new LivePrices()
+  const scanner = new Scanner()
+
+  const result = await runPathWithRefs(
+    scanner,
+    ['livePrices', 'subscribe', [{ slugs: ['btc-win'] }]],
+    makeStore([['/demo/live-prices', live]]),
+  )
+
+  assert.deepEqual(result, [{ slug: 'btc-win', bid: 0.6, ask: 0.65 }])
+})
+
+test('runPathWithRefs: multiple refs in one session', async () => {
+  const live = new LivePrices()
+  const deposits = new DepositTracker()
+  const scanner = new Scanner()
+  const resolve = makeStore([
+    ['/demo/live-prices', live],
+    ['/demo/deposits', deposits],
+  ])
+
+  const prices = await runPathWithRefs(scanner, ['livePrices', 'subscribe', [{ slugs: ['x'] }]], resolve)
+  const run = await runPathWithRefs(scanner, ['depositTracker', 'run', []], resolve)
+
+  assert.ok(Array.isArray(prices))
+  assert.equal(run.added, 12)
+})
+
+test('runPathWithRefs: nested refs (ref → node → ref → node)', async () => {
+  const profile = new Profile()
+  // live node has a nested ref to profile
+  const liveNode = { profile: { $type: 'ref', $ref: '/demo/profiles/0xabc' } }
+  const scanner = { live: { $type: 'ref', $ref: '/demo/live' } }
+
+  const result = await runPathWithRefs(
+    scanner,
+    ['live', 'profile', 'fetch', [{ address: '0xabc' }]],
+    makeStore([
+      ['/demo/live', liveNode],
+      ['/demo/profiles/0xabc', profile],
+    ]),
+  )
+
+  assert.deepEqual(result, { address: '0xabc', name: 'whale.eth', totalPnl: 50_000 })
+})
+
+test('runPathWithRefs: missing ref throws', async () => {
+  const scanner = new Scanner()
+  await assert.rejects(
+    () => runPathWithRefs(scanner, ['livePrices', 'subscribe', [{ slugs: [] }]], makeStore([])),
+  )
+})
+
+test('runPathWithRefs: profile trades pagination', async () => {
+  const profile = new Profile()
+  const node = { target: { $type: 'ref', $ref: '/profile' } }
+
+  const result = await runPathWithRefs(
+    node,
+    ['target', 'trades', [{ page: 2 }]],
+    makeStore([['/profile', profile]]),
+  )
+
+  assert.deepEqual(result, { page: 2, items: [{ hash: '0xabc', amount: 1000 }] })
+})

package/src/chain.ts

@@ -0,0 +1,82 @@
+// Minimal call-chain: records property/call path, resolves lazily on await.
+// Ref resolution is opt-in via runPathWithRefs — chain itself is pure.
+
+import { isRef } from '#core';
+
+export type PathSection = string | unknown[]
+
+// ── Types (mirrors call-chain library, no dep needed) ──
+
+type Primitive = undefined | null | boolean | string | number | symbol | bigint | void
+
+type ValuePromise<T> = T extends Primitive
+  ? Promise<T>
+  : T extends Promise<any>
+  ? T
+  : Chain<T>
+
+export type Chain<T> = Promise<T> & {
+  [K in keyof T]: T[K] extends (...args: infer A) => infer R
+    ? (...args: A) => ValuePromise<Awaited<NonNullable<R>>>
+    : ValuePromise<Awaited<NonNullable<T[K]>>>
+}
+
+// TypedRef: runtime $ref + phantom type T for call-chain to follow
+// _T is a phantom type — exists only for TypeScript inference, erased at runtime
+export interface TypedRef<_T> {
+  readonly $type: 'ref'
+  $ref: string
+}
+
+// Pass registered class (has .$type stamped by registerType) for TypeScript type inference.
+// Runtime only stores $ref — no class reference kept.
+export function refVal<T>(Comp: (new () => T) & { $type?: string }, defaultPath = ''): TypedRef<T> {
+  void Comp  // type-only at runtime; $type from registerType could be stored if needed
+  return { $type: 'ref', $ref: defaultPath }
+}
+
+// ── Core ──
+
+export async function runPath(target: any, path: PathSection[]): Promise<any> {
+  let cur = target, prev = target
+  for (const step of path) {
+    if (cur == null) throw new Error(`null at step: ${JSON.stringify(step)}`)
+    if (typeof step === 'string') { prev = cur; cur = cur[step] }
+    else { cur = cur.apply(prev, step as any[]) }
+    if (cur?.then) cur = await cur
+  }
+  return cur
+}
+
+// Server executor: same as runPath but auto-follows TypedRef fields
+export async function runPathWithRefs(
+  target: any,
+  path: PathSection[],
+  resolveRef: (ref: { $ref: string }) => Promise<any>,
+): Promise<any> {
+  let cur = target, prev = target
+  for (const step of path) {
+    if (cur == null) throw new Error(`null at step: ${JSON.stringify(step)}`)
+    if (typeof step === 'string') {
+      prev = cur
+      cur = cur[step]
+      if (isRef(cur)) cur = await resolveRef(cur)
+    } else {
+      cur = cur.apply(prev, step as any[])
+    }
+    if (cur?.then) cur = await cur
+  }
+  return cur
+}
+
+const make = (target: any, path: PathSection[]): any =>
+  new Proxy((() => {}) as any, {
+    get: (_, p: string | symbol) => {
+      if (p === 'then') return (res: any, rej: any) => runPath(target, path).then(res, rej)
+      if (typeof p === 'symbol') return undefined
+      return make(target, [...path, p as string])
+    },
+    apply: (_, __, args) => make(target, [...path, args]),
+  })
+
+export const chain = <T>(target: T): Chain<T> => make(target, []) as Chain<T>

package/src/client/client.test.ts

@@ -0,0 +1,192 @@
+// Treenity Client SDK — e2e tests
+// Tests createTrpcTransport + createRepathTree + t.mount.tree.trpc
+
+import { registerType } from '#comp';
+import { createNode, R, S, W } from '#core';
+import { withMounts } from '#server/mount';
+import '#server/mount-adapters';
+import { createTreenityServer } from '#server/server';
+import { createMemoryTree } from '#tree';
+import { createRepathTree } from '#tree/repath';
+import assert from 'node:assert/strict';
+import type { Socket } from 'node:net';
+import { afterEach, before, beforeEach, describe, it } from 'node:test';
+import { createTrpcTransport } from './trpc';
+
+// ── Helpers ──
+
+function listen(server: import('node:http').Server): Promise<number> {
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => {
+      resolve((server.address() as { port: number }).port);
+    });
+  });
+}
+
+// ── Test type ──
+
+class Counter {
+  count = 0;
+  increment() { this.count++; }
+}
+
+describe('Treenity Client SDK', () => {
+  let ts: ReturnType<typeof createTreenityServer>;
+  let url: string;
+  const sockets = new Set<Socket>();
+
+  before(() => {
+    registerType('counter', Counter);
+  });
+
+  beforeEach(async () => {
+    const bootstrap = createMemoryTree();
+    await bootstrap.set({
+      ...createNode('/', 'root'),
+      $acl: [{ g: 'public', p: R | W | S }],
+    });
+
+    ts = createTreenityServer(bootstrap);
+    ts.server.on('connection', (s: Socket) => {
+      sockets.add(s);
+      s.on('close', () => sockets.delete(s));
+    });
+    const port = await listen(ts.server);
+    url = `http://127.0.0.1:${port}`;
+  });
+
+  afterEach(async () => {
+    for (const s of sockets) s.destroy();
+    sockets.clear();
+    await new Promise<void>((r) => ts.server.close(() => r()));
+  });
+
+  // ── createTrpcTransport ──
+
+  describe('createTrpcTransport', () => {
+    it('tree.get + tree.set roundtrip', async () => {
+      const { tree } = createTrpcTransport({ url });
+      await tree.set(createNode('/hello', 'doc', { title: 'World' }));
+      const node = await tree.get('/hello');
+
+      assert.ok(node);
+      assert.equal(node.$type, 't.doc');
+      assert.equal((node as any).title, 'World');
+    });
+
+    it('tree.getChildren returns children', async () => {
+      const { tree } = createTrpcTransport({ url });
+      await tree.set(createNode('/items', 'dir'));
+      await tree.set(createNode('/items/a', 'doc'));
+      await tree.set(createNode('/items/b', 'doc'));
+
+      const { items } = await tree.getChildren('/items');
+      assert.equal(items.length, 2);
+    });
+
+    it('tree.remove deletes node', async () => {
+      const { tree } = createTrpcTransport({ url });
+      await tree.set(createNode('/tmp', 'doc'));
+      await tree.remove('/tmp');
+
+      assert.equal(await tree.get('/tmp'), undefined);
+    });
+
+    it('execute calls action', async () => {
+      const { tree, execute } = createTrpcTransport({ url });
+      await tree.set(createNode('/c', 'counter', { count: 0 }));
+
+      await execute('/c', 'increment');
+
+      const node = await tree.get('/c');
+      assert.equal((node as any).count, 1);
+    });
+  });
+
+  // ── createRepathTree over tRPC ──
+
+  describe('createRepathTree + tRPC', () => {
+    it('translates paths over the wire', async () => {
+      const { tree: remote } = createTrpcTransport({ url });
+
+      // Write via server at absolute path
+      await remote.set(createNode('/data/item', 'doc', { v: 42 }));
+
+      // Mount remote's /data at local /mnt
+      const mounted = createRepathTree(remote, '/mnt', '/data');
+      const node = await mounted.get('/mnt/item');
+
+      assert.ok(node);
+      assert.equal(node.$path, '/mnt/item');
+      assert.equal((node as any).v, 42);
+    });
+
+    it('set through repath writes to correct remote path', async () => {
+      const { tree: remote } = createTrpcTransport({ url });
+      const mounted = createRepathTree(remote, '/mnt', '/store');
+
+      await mounted.set(createNode('/mnt/new', 'doc', { x: 1 }));
+
+      // Verify via direct remote access
+      const node = await remote.get('/store/new');
+      assert.ok(node);
+      assert.equal(node.$path, '/store/new');
+    });
+  });
+
+  // ── t.mount.tree.trpc ──
+
+  describe('t.mount.tree.trpc', () => {
+    it('mounts remote tree with path translation', async () => {
+      // Set up content on the remote server
+      const { tree: remote } = createTrpcTransport({ url });
+      await remote.set(createNode('/strategies/alpha', 'doc', { score: 99 }));
+
+      // Create a local bootstrap with mount pointing to remote
+      const local = createMemoryTree();
+      await local.set({
+        ...createNode('/', 'root'),
+        $acl: [{ g: 'public', p: R | W | S }],
+      });
+      await local.set({
+        $path: '/remote',
+        $type: 'dir',
+        mount: { $type: 't.mount.tree.trpc' },
+        connection: { $type: 'connection', url, path: '/strategies' },
+      });
+
+      const store = withMounts(local);
+      const node = await store.get('/remote/alpha');
+
+      assert.ok(node);
+      assert.equal(node.$path, '/remote/alpha');
+      assert.equal((node as any).score, 99);
+    });
+
+    it('getChildren through mount', async () => {
+      const { tree: remote } = createTrpcTransport({ url });
+      await remote.set(createNode('/items', 'dir'));
+      await remote.set(createNode('/items/x', 'doc'));
+      await remote.set(createNode('/items/y', 'doc'));
+
+      const local = createMemoryTree();
+      await local.set({
+        ...createNode('/', 'root'),
+        $acl: [{ g: 'public', p: R | W | S }],
+      });
+      await local.set({
+        $path: '/fed',
+        $type: 'dir',
+        mount: { $type: 't.mount.tree.trpc' },
+        connection: { $type: 'connection', url, path: '/items' },
+      });
+
+      const store = withMounts(local);
+      const { items } = await store.getChildren('/fed');
+
+      assert.equal(items.length, 2);
+      const paths = items.map(n => n.$path).sort();
+      assert.deepEqual(paths, ['/fed/x', '/fed/y']);
+    });
+  });
+});

package/src/client/handle.ts

@@ -0,0 +1,53 @@
+// Client node handle — typed access to remote nodes.
+// nc(path).get(Type).method() — actions, no fetch needed.
+// nc(path).fetch(Type) — async fetch + typed proxy.
+// nc(path).sub(Type, cb) — reactive subscription with typed data.
+
+import { type Class, type TypeProxy } from '#comp';
+import { makeTypedProxy, type ExecuteFn } from '#comp/handle';
+import type { NodeData } from '#core';
+import type { TreenityClient } from './index';
+
+export function createNodeClient(client: TreenityClient) {
+  const execute: ExecuteFn = (input) =>
+    client.execute(input.path, input.action, input.data, { type: input.type, key: input.key });
+
+  return (path: string) => ({
+    /** Typed actions proxy — calls execute over network, no fetch needed */
+    get<T extends object>(cls: Class<T>, key?: string): TypeProxy<T> {
+      return makeTypedProxy<T>(undefined, cls, path, execute, undefined, key);
+    },
+
+    /** Fetch node + typed proxy (data fields + action methods) */
+    async fetch<T extends object>(cls: Class<T>, key?: string): Promise<TypeProxy<T>> {
+      const node = await client.tree.get(path);
+      return makeTypedProxy<T>(node, cls, path, execute, undefined, key);
+    },
+
+    /** Subscribe — callback with typed proxy on each change */
+    async sub<T extends object>(cls: Class<T>, cb: (data: TypeProxy<T>) => void, key?: string) {
+      let cached: NodeData | undefined;
+
+      function notify() {
+        cb(makeTypedProxy<T>(cached, cls, path, execute, undefined, key));
+      }
+
+      const { node, unsubscribe } = await client.watchPath(path, (event) => {
+        if (event.type === 'set') {
+          cached = { $path: event.path, ...event.node } as NodeData;
+          notify();
+        }
+        if (event.type === 'patch' && cached) {
+          // Re-fetch on patch (optimize with applyPatch later)
+          client.tree.get(path).then(fresh => {
+            if (fresh) { cached = fresh; notify(); }
+          });
+        }
+      });
+
+      cached = node as NodeData | undefined;
+      if (cached) notify();
+      return { unsubscribe };
+    },
+  });
+}

package/src/client/index.ts

@@ -0,0 +1,18 @@
+// Treenity Client SDK — transport-agnostic tree client interface.
+// Transports: trpc (now), ws (future), http (future).
+
+import type { Tree } from '#tree';
+
+export type WatchSub = { unsubscribe(): void };
+
+export type TreenityClient = {
+  tree: Tree;
+  execute(path: string, action: string, data?: unknown, opts?: { type?: string; key?: string }): Promise<unknown>;
+  /** Global SSE stream — all events for this user */
+  watch(onEvent: (e: any) => void): WatchSub;
+  /** Watch specific path — registers watch + filters events. Returns initial node + subscription. */
+  watchPath(path: string, onEvent: (e: any) => void): Promise<{ node: any; unsubscribe(): void }>;
+};
+
+export { createTrpcTransport } from './trpc';
+export { createNodeClient } from './handle';

package/src/client/trpc.ts

@@ -0,0 +1,91 @@
+// tRPC transport for Treenity Client.
+// HTTP batch for queries/mutations, SSE for subscriptions.
+
+import type { NodeData } from '#core';
+import type { TreeRouter } from '#server/trpc';
+import { defaultPatch } from '#tree/patch';
+import { createTRPCClient, httpBatchLink, httpSubscriptionLink, splitLink } from '@trpc/client';
+import type { TreenityClient, WatchSub } from './index';
+
+export type TrpcTransportOpts = {
+  url: string;
+  getToken?: () => string | null;
+  token?: string;
+  fetch?: (input: any, init?: any) => Promise<Response>;
+};
+
+export function createTrpcTransport(opts: TrpcTransportOpts): TreenityClient & { trpc: ReturnType<typeof createTRPCClient<TreeRouter>> } {
+  const getToken = opts.getToken ?? (() => opts.token ?? null);
+
+  const trpc = createTRPCClient<TreeRouter>({
+    links: [
+      splitLink({
+        condition: (op) => op.type === 'subscription',
+        true: httpSubscriptionLink({
+          url: `${opts.url}/trpc/`,
+          connectionParams: () => {
+            const t = getToken();
+            return t ? { token: t } : {};
+          },
+        }),
+        false: httpBatchLink({
+          url: `${opts.url}/trpc/`,
+          headers: () => {
+            const t = getToken();
+            return t ? { Authorization: `Bearer ${t}` } : {};
+          },
+          ...(opts.fetch && { fetch: opts.fetch }),
+        }),
+      }),
+    ],
+  });
+
+  // Shared SSE connection for watchPath — lazy, one per transport
+  let eventSub: WatchSub | null = null;
+  const pathCbs = new Map<string, Set<(e: any) => void>>();
+
+  function ensureSSE() {
+    if (eventSub) return;
+    eventSub = trpc.events.subscribe(undefined as void, {
+      onData: (event: any) => {
+        if ('path' in event) pathCbs.get(event.path)?.forEach(cb => cb(event));
+      },
+    });
+  }
+
+  return {
+    tree: {
+      get: (path) => trpc.get.query({ path }) as Promise<NodeData | undefined>,
+      getChildren: (path, opts) => trpc.getChildren.query({ path, ...opts }),
+      set: (node) => trpc.set.mutate({ node: node as Record<string, unknown> }),
+      remove: (path) => trpc.remove.mutate({ path }).then(() => true),
+      // TODO: add tRPC patch endpoint for single-RPC atomic patch
+      patch: (path, ops) => defaultPatch(
+        (p) => trpc.get.query({ path: p }) as Promise<NodeData | undefined>,
+        (n) => trpc.set.mutate({ node: n as Record<string, unknown> }).then(() => {}),
+        path, ops,
+      ),
+    },
+    execute: (path, action, data, o) =>
+      trpc.execute.mutate({ path, action, data, type: o?.type, key: o?.key }),
+    watch: (onEvent) =>
+      trpc.events.subscribe(undefined as void, { onData: onEvent }),
+
+    watchPath: async (path, onEvent) => {
+      const node = await trpc.get.query({ path, watch: true });
+      ensureSSE();
+      if (!pathCbs.has(path)) pathCbs.set(path, new Set());
+      pathCbs.get(path)!.add(onEvent);
+      return {
+        node,
+        unsubscribe() {
+          const set = pathCbs.get(path);
+          if (set) { set.delete(onEvent); if (!set.size) pathCbs.delete(path); }
+          if (!pathCbs.size && eventSub) { eventSub.unsubscribe(); eventSub = null; }
+        },
+      };
+    },
+
+    trpc,
+  };
+}

package/src/client.ts

@@ -0,0 +1 @@
+export * from './client/index.ts';

package/src/comp/CLAUDE.md

@@ -0,0 +1,14 @@
+## comp
+Component registration layer (L2). Bridges core primitives and server.
+
+### Файлы
+- index.ts — registerType, findCompByType, Actions<T>, TypeProxy<T> = Raw<T> & Actions<T>
+- needs.ts — sibling dependency injection: registerNeeds/resolveNeeds
+- ports.ts — action port graph: pre/post conditions as queryable edges
+- planner.ts — backward+forward chaining planner on the port graph
+
+### Конвенции
+- registerType auto-registers all public methods as action:{name}
+- Components never access siblings directly — use `needs` for injection
+- Ports declared via static metadata, planner resolves execution order
+- ExecCtx = {node, tree, signal, nc, deps} — context during action execution

package/src/comp/handle.ts

@@ -0,0 +1,36 @@
+// Shared typed proxy factory — L0, no server deps.
+// Used by: server (serverNodeHandle), client (createNodeClient), React (hooks).
+
+import { type Class, type TypeProxy } from './index';
+import { getComponent, type NodeData, normalizeType } from '#core';
+
+export type ExecuteInput = { path: string; type?: string; key?: string; action: string; data?: unknown };
+export type ExecuteFn = (input: ExecuteInput) => Promise<unknown>;
+export type StreamFn = (input: ExecuteInput) => AsyncIterable<unknown>;
+
+const AsyncGenFn = Object.getPrototypeOf(async function* () {}).constructor;
+
+/** Create TypeProxy from node data + class. Actions call execute/stream, fields read from comp. */
+export function makeTypedProxy<T extends object>(
+  node: NodeData | undefined,
+  cls: Class<T>,
+  path: string,
+  execute: ExecuteFn,
+  stream?: StreamFn,
+  key?: string,
+): TypeProxy<T> {
+  const type = normalizeType(cls);
+  const comp = node ? getComponent(node, cls, key) : undefined;
+
+  return new Proxy(comp ?? {} as T, {
+    get: (_t, prop: string) => {
+      const fn = (cls.prototype as any)[prop];
+      if (typeof fn === 'function') {
+        if (stream && fn instanceof AsyncGenFn)
+          return (data?: unknown) => stream({ path, type, key, action: prop, data });
+        return (data?: unknown) => execute({ path, type, key, action: prop, data });
+      }
+      return (comp as any)?.[prop];
+    },
+  }) as TypeProxy<T>;
+}