@treenity/core 3.0.0 → 3.0.1

package/src/core/component.ts

@@ -13,25 +13,28 @@ export type ComponentData<T = Record<string, unknown>> = T & {
   $acl?: GroupPerm[];
 };
 
+export type RefEntry = { t: string; f?: string; d?: ComponentData };
+
 export type NodeData<T = Record<string, unknown>> = ComponentData<T> & {
   $path: string;
   $owner?: string;
   $rev?: number;
+  $refs?: RefEntry[];
 };
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 export type Class<T = unknown> = new (...args: any[]) => T;
 
-// Accept string, object with $type, or registered class (registerType stamps $type on constructor)
-export type TypeId<T = unknown> = string | { $type: string } | Class<T>;
+// Accept string or registered class (registerType stamps $type on constructor)
+export type TypeId<T = unknown> = string | Class<T>;
 
 // ── Type normalization ──
 // Dot-less types belong to treenity namespace: 'dir' → 't.dir', 'ref' → 't.ref'
 // Types with dots are already namespaced and returned as-is
 export function normalizeType(type: TypeId): string {
   if (typeof type === 'string') return type.includes('.') ? type : `t.${type}`;
-  if ('$type' in type && typeof (type as any).$type === 'string') return normalizeType((type as any).$type);
-  throw new Error('TypeId: object has no $type property');
+  if (typeof (type as any).$type === 'string') return normalizeType((type as any).$type);
+  throw new Error('TypeId: class not registered (missing $type)');
 }
 
 // ── Utils ──
@@ -40,17 +43,12 @@ export function isComponent(value: unknown): value is ComponentData {
   return typeof value === 'object' && value !== null && '$type' in value;
 }
 
-export function getCompByKey(node: NodeData, key: string): ComponentData | undefined {
-  const v = key === '' ? node : node[key];
-  return isComponent(v) ? v : undefined;
-}
-
-export const AnyType = { $type: 'any' };
+export const AnyType = 't.any';
 
 export function isOfType<T>(value: unknown, type: TypeId): value is ComponentData<T> {
   if (!isComponent(value)) return false;
   const t = normalizeType(type);
-  return t === 't.any' || normalizeType(value.$type) === t;
+  return t === AnyType || t === normalizeType(value.$type);
 }
 
 // ── Ref ──
@@ -72,13 +70,17 @@ export function assertNonSystemName(name: string) {
   if (name.startsWith('$')) throw new Error(`Component name cannot start with $: ${name}`);
 }
 
+export function createNode<T, C = Record<string, ComponentData<any>>>(
+  path: string, type: Class<T>, data?: Partial<T>, components?: C): NodeData<T & C>;
 export function createNode<T = any, C = Record<string, ComponentData<any>>>(
+  path: string, type: string, data?: T, components?: C): NodeData<T & C>;
+export function createNode(
   path: string,
   type: TypeId,
-  data?: T,
-  components?: C): NodeData<T & C> {
+  data?: any,
+  components?: any): NodeData {
 
-  const node: NodeData<T & C> = { $path: path, $type: normalizeType(type) } as NodeData<T & C>;
+  const node: NodeData = { $path: path, $type: normalizeType(type) } as NodeData;
   if (components) Object.keys(components).forEach(assertNonSystemName);
   if (data) Object.keys(data).forEach(assertNonSystemName);
 

package/src/core/context.ts

@@ -4,11 +4,11 @@ export type Handler = (...args: any[]) => any;
 
 // Typed context handlers — augmented by layers via declaration merging
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface ContextHandlers {
+export interface ContextHandlers<T = any> {
 }
 
-export type ContextHandler<C extends string> = C extends keyof ContextHandlers
-  ? ContextHandlers[C]
+export type ContextHandler<C extends string, T = any> = C extends keyof ContextHandlers<T>
+  ? ContextHandlers<T>[C]
   : C extends `${infer Base}:${string}`
-    ? ContextHandler<Base>
+    ? ContextHandler<Base, T>
     : Handler;

package/src/core/index.test.ts

@@ -15,9 +15,21 @@ import {
   resolve,
   unregister,
 } from './index';
+import { registerBuiltins } from '#mods/treenity/builtins';
+
+const testTypes = ['test.doc', 'test.item', 'test.session', 'test.task'];
+
+export function registerTestTypes() {
+  for (const t of testTypes)
+    register(t, 'schema', () => ({ $id: t, type: 'object' as const, title: t, properties: {} }));
+}
+
+registerTestTypes();
 
 export function clearRegistry(): void {
   mapRegistry((t, c) => unregister(t, c));
+  registerBuiltins();
+  registerTestTypes();
 }
 
 describe('Node', () => {
@@ -81,7 +93,7 @@ describe('Component access', () => {
 
   it('isComponent type guard', () => {
     assert.ok(isComponent(node['budget']));
-    assert.ok(!isComponent(node['missing']));
+    assert.ok(!isComponent((node as any)['missing']));
     assert.ok(!isComponent('string'));
     assert.ok(!isComponent(null));
   });
@@ -141,6 +153,15 @@ describe('Path utils', () => {
     assert.equal(isChildPath('/tasks', '/tasks/123/sub', false), true);
     assert.equal(isChildPath('/', '/tasks/123', false), true);
   });
+
+  // Regression: /board must not match /boards (prefix overlap without separator)
+  it('isChildPath rejects prefix overlap without separator', () => {
+    assert.equal(isChildPath('/board', '/boards'), false);
+    assert.equal(isChildPath('/board', '/boards/test'), false);
+    assert.equal(isChildPath('/board', '/boards/test', false), false);
+    assert.equal(isChildPath('/board', '/board/real'), true);
+    assert.equal(isChildPath('/board', '/board/real/deep', false), true);
+  });
 });
 
 describe('Context', () => {

package/src/core/path.ts

@@ -17,10 +17,13 @@ export function join(parent: string, name: string): string {
 }
 
 export function isChildPath(parent: string, candidate: string, directOnly = true): boolean {
-  if (!candidate.startsWith(parent) || candidate === parent) return false;
+  if (candidate === parent) return false;
+  // Must match parent + '/' to avoid /board matching /boards
+  const prefix = parent === '/' ? '/' : parent + '/';
+  if (!candidate.startsWith(prefix)) return false;
   if (directOnly) {
-    const rest = parent === '/' ? candidate.slice(1) : candidate.slice(parent.length + 1);
-    return !rest.includes('/');
+    const rest = candidate.slice(prefix.length);
+    return rest.length > 0 && !rest.includes('/');
   }
 
   return true;

package/src/core/registry.ts

@@ -1,4 +1,4 @@
-import { ComponentData, normalizeType, type TypeId } from './component';
+import { type Class, ComponentData, normalizeType, type TypeId } from './component';
 import { ContextHandler, Handler } from './context';
 
 const registry = new Map<string, Handler>();
@@ -21,12 +21,9 @@ function key(type: string, context: string): string {
   return `${type}@${context}`;
 }
 
-export function register<C extends string>(
-  type: string,
-  context: C,
-  handler: ContextHandler<C>,
-  meta?: Record<string, unknown>,
-): void {
+export function register<C extends string>(type: string, context: C, handler: ContextHandler<C>, meta?: Record<string, unknown>): void;
+export function register<T, C extends string>(type: Class<T>, context: C, handler: ContextHandler<C, T>, meta?: Record<string, unknown>): void;
+export function register(type: TypeId, context: string, handler: Handler, meta?: Record<string, unknown>): void {
   const k = key(normalizeType(type), context);
   // Sealed: no overrides. In dev (HMR) modules re-execute, so we allow silent replace.
   // In production, duplicate register = bug, caught by tests.

package/src/core.ts

@@ -1 +1 @@
-export * from './core/index.ts';
+export * from './core/index';

package/src/index.ts

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

package/src/log.ts

@@ -1,3 +1,150 @@
+// Unified logging: tree-persisted nodes + ring buffer fallback + debug filter + console intercept
+
+import dayjs from 'dayjs'
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+export interface LogEntry {
+  t: number
+  level: LogLevel
+  msg: string
+  code?: string
+  sub?: string
+  userId?: string
+  method?: string
+  path?: string
+}
+
+// ── Execution context provider — set by comp/index.ts to avoid circular imports ──
+
+type CtxProvider = () => Record<string, unknown> | null
+let _getCtx: CtxProvider = () => null
+
+export function setCtxProvider(fn: CtxProvider) { _getCtx = fn }
+
+// ── Log listeners ──
+
+type OnLog = (entry: LogEntry) => void
+const listeners: OnLog[] = []
+
+export function addOnLog(fn: OnLog) { listeners.push(fn) }
+
+// ── Timestamp ID: YYMMDD-HHmmss-mmm-NNN ──
+
+let lastMs = 0
+let seq = 0
+
+export function makeLogPath(): string {
+  const now = Date.now()
+  if (now === lastMs) {
+    seq++
+  } else {
+    lastMs = now
+    seq = 0
+  }
+
+  const stamp = dayjs(now).format('YYMMDD-HHmmss-SSS')
+  const sq = String(seq).padStart(3, '0')
+
+  return `/sys/logs/${stamp}-${sq}`
+}
+
+function notify(entry: LogEntry) {
+  for (const fn of listeners) fn(entry)
+}
+
+// ── Ring buffer (fallback before tree init) ──
+
+const MAX = 2000
+const buffer: LogEntry[] = []
+let cursor = 0
+let total = 0
+
+function push(level: LogLevel, args: unknown[]) {
+  // Extract [tag] → sub
+  let sub: string | undefined
+  if (typeof args[0] === 'string') {
+    const m = args[0].match(/^\[([^\]]+)\]$/)
+    if (m) {
+      sub = m[1]
+      args = args.slice(1)
+    }
+  }
+
+  // Extract UPPER_SNAKE code
+  let code: string | undefined
+  if (args.length > 1 && typeof args[0] === 'string' && /^[A-Z][A-Z0-9_]+$/.test(args[0])) {
+    code = args[0]
+    args = args.slice(1)
+  }
+
+  const msg = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')
+  const ctx = _getCtx()
+
+  const entry: LogEntry = {
+    t: Date.now(),
+    level,
+    msg,
+    code,
+    sub,
+    userId: ctx?.userId as string | undefined,
+    method: ctx?.method as string | undefined,
+    path: ctx?.path as string | undefined,
+  }
+
+  if (listeners.length) {
+    notify(entry)
+  } else {
+    if (total < MAX) {
+      buffer.push(entry)
+    } else {
+      buffer[cursor] = entry
+    }
+    cursor = (cursor + 1) % MAX
+    total++
+  }
+}
+
+/** Get ordered log entries from ring buffer (oldest first) */
+function getOrdered(): LogEntry[] {
+  if (total <= MAX) return buffer.slice()
+  return [...buffer.slice(cursor), ...buffer.slice(0, cursor)]
+}
+
+// ── Query (ring buffer fallback — when tree available, use sift via getChildren) ──
+
+export interface LogQuery {
+  grep?: string
+  level?: LogLevel | LogLevel[]
+  head?: number
+  tail?: number
+}
+
+export function queryLogs(opts: LogQuery = {}): LogEntry[] {
+  let entries = getOrdered()
+
+  if (opts.level) {
+    const levels = Array.isArray(opts.level) ? opts.level : [opts.level]
+    entries = entries.filter(e => levels.includes(e.level))
+  }
+
+  if (opts.grep) {
+    const re = new RegExp(opts.grep, 'i')
+    entries = entries.filter(e => re.test(e.msg))
+  }
+
+  if (opts.tail) entries = entries.slice(-opts.tail)
+  if (opts.head) entries = entries.slice(0, opts.head)
+
+  return entries
+}
+
+export function logStats() {
+  return { buffered: Math.min(total, MAX), total, max: MAX }
+}
+
+// ── Debug filter ──
+
 const enabled = new Set<string>()
 let all = false
 
@@ -15,7 +162,7 @@ if (typeof process !== 'undefined' && process.env?.DEBUG) {
   setDebug(process.env.DEBUG)
 }
 
-;(globalThis as any).setDebug = setDebug
+;(globalThis as Record<string, unknown>).setDebug = setDebug
 
 export function createLogger(name: string) {
   const tag = `[${name}]`
@@ -26,3 +173,27 @@ export function createLogger(name: string) {
     error(...args: unknown[]) { console.error(tag, ...args) },
   }
 }
+
+// ── Console intercept — call once at startup ──
+
+let intercepted = false
+
+export function interceptConsole() {
+  if (intercepted) return
+  intercepted = true
+
+  for (const level of ['debug', 'info', 'warn', 'error'] as const) {
+    const orig = console[level]
+    console[level] = (...args: unknown[]) => {
+      push(level, args)
+      orig.apply(console, args)
+    }
+  }
+
+  // console.log → info level
+  const origLog = console.log
+  console.log = (...args: unknown[]) => {
+    push('info', args)
+    origLog.apply(console, args)
+  }
+}

package/src/mod/docs/07-realtime.md

@@ -66,19 +66,23 @@ function MyRenderer({ value, onChange }) {
 ## react:list — самодостаточные list-item компоненты
 
 ```tsx
-function DefaultListItem({ value }: { value: NodeData }) {
+import type { View } from '@treenity/react/context';
+
+// View для default — value: ComponentData (базовый тип, есть $type)
+const DefaultListItem: View<ComponentData> = ({ value, ctx }) => {
+  const node = ctx!.node;
   return (
-    <div className="child-card" onClick={() => navigate(value.$path)}>
-      <span className="child-icon">{typeIcon(value.$type)}</span>
+    <div className="child-card" onClick={() => navigate(node.$path)}>
+      <span className="child-icon">{typeIcon(node.$type)}</span>
       <div className="child-info">
-        <span className="child-name">{pathName(value.$path)}</span>
-        <span className="child-type">{value.$type}</span>
+        <span className="child-name">{pathName(node.$path)}</span>
+        <span className="child-type">{node.$type}</span>
       </div>
       <span className="child-chevron">&#8250;</span>
     </div>
   );
-}
-register('default', 'react:list', DefaultListItem as any);
+};
+register('default', 'react:list', DefaultListItem);
 ```
 
 Fallback: `react:list` → `default@react:list` → strip `:list` → `react`.
@@ -88,11 +92,15 @@ Fallback: `react:list` → `default@react:list` → strip `:list` → `react`.
 Когда `node.$type` совпадает с `$type` компонента, нода **сама является** компонентом. Поля лежат плоско:
 
 ```ts
-// Правильно
-await store.set({ $path: '/bot', $type: 'brahman.bot', token: '...', alias: '@bot' } as NodeData);
+import { createNode } from '#core';
+
+// Правильно — createNode создаёт типизированную ноду
+await store.set(createNode('/bot', 'brahman.bot', { token: '...', alias: '@bot' }));
 
-// Неправильно
-await store.set({ $path: '/bot', $type: 'brahman.bot', config: { $type: 'brahman.bot', token: '...' } });
+// Неправильно — вложенный компонент с тем же $type что и нода
+await store.set(createNode('/bot', 'brahman.bot', {
+  config: { $type: 'brahman.bot', token: '...' },  // WRONG: дублирует $type
+}));
 ```
 
 ## Views — read-only

package/src/mod/docs/08-services.md

@@ -3,16 +3,16 @@
 Фоновые процессы: боты, сенсоры, воркеры. `register(type, "service", handler)` → возвращает `{ stop() }`.
 
 ```ts
-import { register, type NodeData } from '#core';
+import { register, createNode, type NodeData } from '#core';
 import { type ServiceHandle, type ServiceCtx } from '#contexts/service';
 
 register('my-worker', 'service', async (node: NodeData, ctx: ServiceCtx) => {
   const timer = setInterval(async () => {
-    await ctx.store.set({
-      $path: `${node.$path}/${Date.now()}`,
-      $type: 'tick',
-      ts: Date.now(),
-    } as NodeData);
+    await ctx.store.set(createNode(
+      `${node.$path}/${Date.now()}`,
+      'tick',
+      { ts: Date.now() },
+    ));
   }, 5000);
 
   return {
@@ -26,8 +26,10 @@ register('my-worker', 'service', async (node: NodeData, ctx: ServiceCtx) => {
 Создай ref-ноду в `/sys/autostart`:
 
 ```ts
-await store.set({ $path: '/my-worker', $type: 'my-worker' } as NodeData);
-await store.set({ $path: '/sys/autostart/my-worker', $type: 'ref', $ref: '/my-worker' } as NodeData);
+import { createNode } from '#core';
+
+await store.set(createNode('/my-worker', 'my-worker'));
+await store.set(createNode('/sys/autostart/my-worker', 'ref', { $ref: '/my-worker' }));
 ```
 
 При старте сервера `startServices(store)` обходит `/sys/autostart`, резолвит refs, вызывает service-хэндлеры.

package/src/mod/docs/10-acl.md

@@ -46,7 +46,7 @@ const validated = withValidation(store);
 import { withVolatile } from '#server/volatile';
 
 const store = withVolatile(backingStore);
-await store.set({ $path: '/temp', $type: 'session', $volatile: true } as NodeData);
+await store.set(createNode('/temp', 'session', { $volatile: true }));
 ```
 
 ## Server Pipeline

package/src/mod/docs/12-conventions.md

@@ -40,6 +40,49 @@ t.*             → treenity infrastructure: t.mount.fs, t.mount.mongo, t.llm
 | `class`         | `Class<T>`                       | Registered component class  |
 | `telegram`      | `(node, tgCtx) => void`         | Telegram-хэндлер            |
 
+## TypeScript — дисциплина типов
+
+**`as any` ЗАПРЕЩЁН.** Не "только в emergency" — НИКОГДА. Если типы не сходятся, чини типы. `as any` прячет баги, ломает inference, расползается как рак.
+
+Допустимые касты:
+- `as const` — сужение литерала
+- `as 'idle'` — сужение к известному union-варианту
+- `as SensorReading` — сужение к конкретному типу (когда ты знаешь что это он)
+
+**Создание нод — ВСЕГДА через `createNode()`:**
+```ts
+// Со строковым типом — T выводится из data:
+await store.set(createNode('/path', 'my.type', { field: 'value' }));
+
+// С Class<T> — data проверяется по полям класса (Partial<T>):
+await store.set(createNode('/sensors/temp', SensorConfig, { interval: 10, source: 'api' }));
+//                                                         ^^^^^^^^ autocomplete + type check
+
+// С компонентами:
+await store.set(createNode('/path', 'sensor', { interval: 5 }, {
+  config: { $type: 'sensor.config', source: 'api' },
+}));
+
+// ЗАПРЕЩЕНО — as NodeData убивает типизацию
+await store.set({ $path: '/path', $type: 'my.type', field: 'value' } as NodeData);
+```
+
+**Views — типизированные через `View<T>`:**
+```tsx
+import type { View } from '@treenity/react/context';
+
+// value — данные компонента. path — через ctx!.node.$path
+const MyView: View<MyType> = ({ value, ctx }) => { ... };
+
+// register принимает Class<T> — T пробрасывается автоматически
+register(MyType, 'react', MyView);
+```
+
+**Запрещённые паттерны:**
+- `value as NodeData & MyType` — value УЖЕ типизирован через View<T>
+- `(node as any).field` — используй `getComp(node, Class)` для типобезопасного доступа
+- `register('type', 'react', handler as any)` — используй `register(Class, 'react', handler)`
+
 ## Ошибки
 
 ```ts

package/src/mod/docs/13-example.md

@@ -4,8 +4,7 @@
 
 ```ts
 // src/mods/sensor/types.ts
-import { getCtx, registerComp } from '#comp';
-import { join, type NodeData } from '#core';
+import { getCtx, registerComp, getComp } from '#comp';
 
 export class SensorConfig {
   /** @title Интервал @description Секунды между замерами */
@@ -20,7 +19,10 @@ export class SensorConfig {
   async history() {
     const { node, store } = getCtx();
     const { items } = await store.getChildren(node.$path, { limit: 100 });
-    return { items: items.map(n => ({ value: (n as any).value, ts: (n as any).ts })) };
+    return { items: items.map(n => {
+      const r = getComp(n, SensorReading);
+      return r ? { value: r.value, ts: r.ts } : null;
+    }).filter(Boolean) };
   }
 }
 
@@ -38,7 +40,7 @@ registerComp('sensor.reading', SensorReading);
 
 ```ts
 // src/mods/sensor/service.ts
-import { register, type NodeData } from '#core';
+import { register, createNode, type NodeData } from '#core';
 import { getComp } from '#comp';
 import { type ServiceHandle, type ServiceCtx } from '#contexts/service';
 import { SensorConfig } from './types';
@@ -48,12 +50,11 @@ register('sensor', 'service', async (node: NodeData, ctx: ServiceCtx) => {
   const interval = (config?.interval ?? 5) * 1000;
 
   const timer = setInterval(async () => {
-    await ctx.store.set({
-      $path: `${node.$path}/${Date.now()}`,
-      $type: 'sensor.reading',
-      value: Math.random() * 100,
-      ts: Date.now(),
-    } as NodeData);
+    await ctx.store.set(createNode(
+      `${node.$path}/${Date.now()}`,
+      'sensor.reading',
+      { value: Math.random() * 100, ts: Date.now() },
+    ));
   }, interval);
 
   return { stop: async () => clearInterval(timer) } satisfies ServiceHandle;
@@ -64,34 +65,39 @@ register('sensor', 'service', async (node: NodeData, ctx: ServiceCtx) => {
 
 ```tsx
 // src/mods/sensor/view.tsx
-import { register, type ComponentData } from '#core';
-import { useCurrentNode } from '#contexts/react';
-import { useChildren } from '#front/hooks';
+import { register } from '#core';
+import type { View } from '@treenity/react/context';
+import { useChildren } from '@treenity/react/hooks';
+import { SensorConfig, SensorReading } from './types';
 
-register('sensor.config', 'react', ({ value, onChange }) => {
+// View<T> — типизированный компонент. value: T, ctx: ViewCtx
+const ConfigView: View<SensorConfig> = ({ value }) => {
   return (
     <div>
-      <label>Interval: {(value as any).interval}s</label>
-      <label>Source: {(value as any).source}</label>
+      <label>Interval: {value.interval}s</label>
+      <label>Source: {value.source}</label>
     </div>
   );
-});
+};
 
-register('sensor', 'react', ({ value }) => {
-  const node = useCurrentNode();
-  const readings = useChildren(node.$path, { limit: 10, watchNew: true });
+const SensorView: View<SensorConfig> = ({ value, ctx }) => {
+  const readings = useChildren(ctx!.node.$path, { limit: 10, watchNew: true });
 
   return (
     <div>
-      <h3>Sensor: {node.$path}</h3>
+      <h3>Sensor: {ctx!.node.$path}</h3>
       {readings.map(r => (
         <div key={r.$path}>
-          {(r as any).value?.toFixed(1)} @ {new Date((r as any).ts).toLocaleTimeString()}
+          {(r as SensorReading).value?.toFixed(1)} @ {new Date((r as SensorReading).ts).toLocaleTimeString()}
         </div>
       ))}
     </div>
   );
-});
+};
+
+// register принимает Class<T> — типы пробрасываются автоматически
+register(SensorConfig, 'react', ConfigView);
+register(SensorConfig, 'react:list', SensorView);
 ```
 
 ## 4. schemas.ts — JSON Schema
@@ -124,9 +130,13 @@ import './sensor/schemas';
 ## 6. Seed-данные
 
 ```ts
-await store.set({ $path: '/sensors/temp', $type: 'sensor',
+import { createNode } from '#core';
+
+await store.set(createNode('/sensors/temp', 'sensor', {
   config: { $type: 'sensor.config', interval: 10, source: 'internal' },
-} as NodeData);
+}));
 
-await store.set({ $path: '/sys/autostart/temp-sensor', $type: 'ref', $ref: '/sensors/temp' } as NodeData);
+await store.set(createNode('/sys/autostart/temp-sensor', 'ref', {
+  $ref: '/sensors/temp',
+}));
 ```