@vobs/vobs 0.3.0 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 vobsjs
+Copyright (c) 2026 vobs contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,89 @@
+# @vobs/vobs
+
+The umbrella package of the vobs framework: reactivity + runtime + DOM renderer in a single import, plus application bootstrap (`createVobs`), context (`provide`/`inject`), and the JSX runtime.
+
+## Install
+
+```bash
+npm install @vobs/vobs
+```
+
+Pair with [`@vobs/vite-plugin`](../vite-plugin) to compile TSX.
+
+## Quick start
+
+```tsx
+import { createVobs, createInjectionKey, state, inject, provide } from '@vobs/vobs'
+
+const GreetingKey = createInjectionKey<string>('greeting')
+
+function Hello() {
+  const greeting = injectRequired(GreetingKey)
+  return <h1>{greeting}</h1>
+}
+
+const app = createVobs({
+  render: () => <Hello />,
+  plugins: []
+})
+
+app.mount('#app')          // or app.hydrate('#app') for SSR markup
+```
+
+Plugins receive an app context and can provide values, register router/auth/etc., and return a cleanup function that runs on `app.destroy()`.
+
+### Context
+
+```tsx
+import { createInjectionKey, provide, inject } from '@vobs/vobs'
+
+const ThemeKey = createInjectionKey<'dark' | 'light'>('theme')
+
+function Toolbar() {
+  provide(ThemeKey, 'dark')               // scoped to the current owner subtree
+  const theme = inject(ThemeKey, 'light') // read with fallback
+}
+```
+
+### Reactivity and rendering
+
+Everything from `@vobs/reactivity` (`state`, `memo`, `effect`, `batch`, owner APIs) and the rendering primitives from `@vobs/runtime` (`insertDynamic`, `insertList`, boundaries, refs) are re-exported, with the DOM renderer pre-registered:
+
+```tsx
+import { state, ErrorBoundary } from '@vobs/vobs'
+
+function Counter() {
+  const count = state(0)
+  return <button onClick={() => count.value++}>Count: {count.value}</button>
+}
+
+<ErrorBoundary fallback={error => <span>failed: {error.message}</span>}>
+  <Counter />
+</ErrorBoundary>
+```
+
+## App lifecycle
+
+| Member | Description |
+| --- | --- |
+| `app.mount(target)` | Clears the target and renders into it. |
+| `app.hydrate(target)` | Claims server-rendered markup instead of clearing it; mismatched nodes are replaced with a reported error. |
+| `app.update()` | Flushes pending scheduler work synchronously (used by HMR and tests). |
+| `app.use(plugin)` | Installs a plugin before or after mount. |
+| `app.provide(key, value, options?)` | Provides a value into the root owner. |
+| `app.destroy()` | Runs plugin cleanups, then disposes the owner tree and clears the container. |
+
+## API highlights
+
+| Signature | Description |
+| --- | --- |
+| `createVobs(options)` | Creates an app (`render`, `plugins`). |
+| `createInjectionKey(description)` | Typed injection key (`Symbol`-based). |
+| `provide(key, value, options?)` / `inject(key, fallback?)` / `injectRequired(key)` | Owner-scoped context. |
+| `Fragment` / `Vobs` | JSX fragment and runtime entry points (`jsx-runtime`, `jsx-dev-runtime`). |
+| `createDOMRenderer()` | The built-in DOM renderer. |
+| re-exports | Full `@vobs/reactivity` + runtime ops, bindings, lists, boundaries, HMR. |
+
+## Types
+
+`VobsApp`, `VobsPlugin`, `VobsPluginContext`, `InjectionKey<T>`, plus all re-exported reactivity/runtime types.

package/package.json

@@ -1,54 +1,23 @@
 {
-  "name": "@vobs/vobs",
-  "version": "0.3.0",
-  "description": "The default application entry for the vobs frontend framework.",
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
   "license": "MIT",
-  "author": "vobsjs",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vobsjs/vobs.git",
-    "directory": "packages/framework/vobs"
-  },
-  "bugs": {
-    "url": "https://github.com/vobsjs/vobs/issues"
-  },
-  "homepage": "https://github.com/vobsjs/vobs#readme",
-  "dependencies": {
-    "@vobs/router": "0.3.0",
-    "@vobs/reactivity": "0.3.0",
-    "@vobs/runtime-dom": "0.3.0"
-  },
   "files": [
-    "dist"
+    "src",
+    "README.md",
+    "LICENSE"
   ],
+  "name": "@vobs/vobs",
+  "version": "1.1.0",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./reactivity": {
-      "types": "./dist/reactivity.d.ts",
-      "import": "./dist/reactivity.js"
-    },
-    "./router": {
-      "types": "./dist/router.d.ts",
-      "import": "./dist/router.js"
-    },
-    "./runtime-dom": {
-      "types": "./dist/runtime-dom.d.ts",
-      "import": "./dist/runtime-dom.js"
-    },
-    "./package.json": "./package.json"
+    ".": "./src/index.ts",
+    "./jsx-runtime": "./src/jsx-runtime.ts",
+    "./jsx-dev-runtime": "./src/jsx-dev-runtime.ts"
   },
-  "types": "./dist/index.d.ts",
-  "module": "./dist/index.js",
-  "main": "./dist/index.js",
-  "sideEffects": false,
-  "engines": {
-    "node": ">=22.12.0"
+  "dependencies": {
+    "@vobs/reactivity": "1.1.0",
+    "@vobs/dom": "1.1.0",
+    "@vobs/runtime": "1.1.0"
   }
 }

package/src/app.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { effect } from '@vobs/reactivity'
+import {
+  createDOMRenderer,
+  createComponent,
+  createInjectionKey,
+  createElement,
+  createText,
+  createVobs,
+  inject,
+  injectRequired,
+  provide,
+  setRenderer,
+  addEventListener,
+  type VobsLocatedError,
+  type VobsPlugin
+} from './index'
+
+describe('createVobs', () => {
+  beforeEach(() => {
+    setRenderer(createDOMRenderer())
+  })
+
+  it('没有 render 时抛错', () => {
+    expect(() => createVobs({} as any)).toThrow()
+  })
+
+  it('支持应用级错误观察器且不会覆盖原始异常', () => {
+    const errors: unknown[] = []
+    const app = createVobs({
+      render: () => { throw new Error('render failed') },
+      onError: error => errors.push(error)
+    })
+    expect(() => app.mount(document.createElement('div'))).toThrow('render failed')
+    expect(errors[0]).toBeInstanceOf(Error)
+    expect((errors[0] as Error).message).toBe('render failed')
+  })
+
+  it('挂载后 mounted 为 true', () => {
+    const app = createVobs({
+      render: () => {
+        return createText('hello')
+      }
+    })
+
+    const container = document.createElement('div')
+    app.mount(container)
+
+    expect(app.mounted).toBe(true)
+    expect(container.textContent).toBe('hello')
+
+    app.destroy()
+    expect(app.mounted).toBe(false)
+    expect(container.innerHTML).toBe('')
+  })
+
+  it('按依赖顺序安装插件，并逆序清理', () => {
+    const calls: string[] = []
+    const dependency = {
+      name: 'dependency',
+      install: () => {
+        calls.push('install-dependency')
+        return () => calls.push('cleanup-dependency')
+      }
+    }
+    const plugin: VobsPlugin = {
+      name: 'plugin',
+      requires: [dependency],
+      install: () => {
+        calls.push('install-plugin')
+        return () => calls.push('cleanup-plugin')
+      }
+    }
+
+    const app = createVobs({ render: () => createText(''), plugins: [plugin] })
+    app.destroy()
+
+    expect(calls).toEqual([
+      'install-dependency',
+      'install-plugin',
+      'cleanup-plugin',
+      'cleanup-dependency'
+    ])
+  })
+
+  it('注入项默认不可被静默覆盖', () => {
+    const key = createInjectionKey<string>('test.value')
+    const plugin: VobsPlugin = {
+      name: 'context',
+      install: context => {
+        context.provide(key, 'first')
+        expect(() => context.provide(key, 'second')).toThrow('已存在')
+        context.provide(key, 'second', { override: true })
+        expect(context.inject(key)).toBe('second')
+      }
+    }
+
+    createVobs({ render: () => createText(''), plugins: [plugin] }).destroy()
+  })
+
+  it('插件可访问 app、注册销毁回调并声明可选依赖', () => {
+    const calls: string[] = []
+    let contextApp: ReturnType<typeof createVobs> | undefined
+    const optional: VobsPlugin = {
+      name: 'optional',
+      install: () => { calls.push('optional-install') }
+    }
+    const plugin: VobsPlugin = {
+      name: 'lifecycle',
+      version: '0.1.0',
+      optional: [optional],
+      install(context) {
+        contextApp = context.app
+        context.onDestroy(() => { calls.push('on-destroy') })
+        return () => { calls.push('cleanup') }
+      }
+    }
+
+    const app = createVobs({ render: () => createText(''), plugins: [plugin] })
+    expect(contextApp).toBe(app)
+    expect(calls).toEqual([])
+
+    app.destroy()
+    expect(calls).toEqual(['cleanup', 'on-destroy'])
+  })
+
+  it('组件 provide/inject 按 Owner 层级查找，并可覆盖父级值', () => {
+    const key = createInjectionKey<string>('test.component-context')
+    let injected: string | undefined
+    let nestedInjected: string | undefined
+
+    function Child(): ReturnType<typeof createText> {
+      injected = inject(key)
+      provide(key, 'child')
+      nestedInjected = inject(key)
+      return createText('child')
+    }
+
+    function Parent(): ReturnType<typeof createText> {
+      provide(key, 'parent')
+      return createComponent(Child, {}) as ReturnType<typeof createText>
+    }
+
+    const app = createVobs({ render: () => createComponent(Parent, {}) })
+    app.mount(document.createElement('div'))
+
+    expect(injected).toBe('parent')
+    expect(nestedInjected).toBe('child')
+    app.destroy()
+  })
+
+  it('组件外调用 provide 会给出作用域错误', () => {
+    const key = createInjectionKey<string>('test.outside-context')
+    expect(() => provide(key, 'value')).toThrow('Owner 作用域')
+  })
+
+  it('inject 支持默认值和必需注入校验', () => {
+    const key = createInjectionKey<string>('test.optional')
+    expect(inject(key, 'fallback')).toBe('fallback')
+    expect(() => injectRequired(key, 'test.optional')).toThrow('必需注入项')
+    const app = createVobs({
+      render: () => {
+        provide(key, 'provided')
+        return createText(`${injectRequired(key)}:${inject(key, 'fallback')}`)
+      }
+    })
+    const container = document.createElement('div')
+    app.mount(container)
+    expect(container.textContent).toBe('provided:provided')
+    app.destroy()
+  })
+
+  it('插件可以观察启动错误，但不能吞掉原始错误', () => {
+    const failure = new Error('install failed')
+    let reported: unknown
+    const observer: VobsPlugin = {
+      name: 'observer',
+      install(context) {
+        context.onError(error => { reported = error })
+      }
+    }
+    const broken: VobsPlugin = {
+      name: 'broken',
+      install() {
+        throw failure
+      }
+    }
+
+    expect(() => createVobs({ render: () => createText(''), plugins: [observer, broken] }))
+      .toThrow(failure)
+    expect(reported).toBe(failure)
+  })
+
+  it('组件错误保留编译器提供的源码位置', () => {
+    const failure = new Error('render failed')
+    const app = createVobs({
+      render: () => createComponent(() => { throw failure }, {}, {
+        file: 'src/Page.tsx',
+        line: 12,
+        column: 7
+      })
+    })
+
+    expect(() => app.mount(document.createElement('div'))).toThrow(failure)
+    expect((failure as VobsLocatedError).vobsSource).toEqual({
+      file: 'src/Page.tsx',
+      line: 12,
+      column: 7
+    })
+  })
+
+  it('组件 effect 错误也保留源码位置并继续向应用传播', () => {
+    const failure = new Error('effect failed')
+    const app = createVobs({
+      render: () => createComponent(() => {
+        effect(() => { throw failure })
+        return createText('ready')
+      }, {}, { file: 'src/EffectPage.tsx', line: 8, column: 3 })
+    })
+
+    expect(() => app.mount(document.createElement('div'))).toThrow(failure)
+    expect((failure as VobsLocatedError).vobsSource).toEqual({
+      file: 'src/EffectPage.tsx',
+      line: 8,
+      column: 3
+    })
+  })
+
+  it('组件 Owner 销毁时自动移除事件监听器', () => {
+    let button!: HTMLButtonElement
+    let clicks = 0
+    const app = createVobs({
+      render: () => createComponent(() => {
+        button = createElement('button') as HTMLButtonElement
+        addEventListener(button, 'click', () => { clicks++ })
+        return button
+      }, {})
+    })
+    app.mount(document.createElement('div'))
+    button.dispatchEvent(new Event('click'))
+    app.destroy()
+    button.dispatchEvent(new Event('click'))
+    expect(clicks).toBe(1)
+  })
+})

package/src/app.ts

@@ -0,0 +1,264 @@
+import { createOwner, scheduler, setOwnerDebugName, type Owner } from '@vobs/reactivity'
+import { createDOMRenderer } from '@vobs/dom'
+import { insertBefore as insertRuntimeNode, setRenderer, type VobsFragment, type VobsRenderer } from '@vobs/runtime'
+import { injectFromOwner, provideToOwner } from './context'
+
+export type InjectionKey<T> = symbol & {
+  readonly __vobsType?: T
+}
+
+export interface ProvideOptions {
+  override?: boolean
+}
+
+export interface VobsPlugin {
+  name: string
+  version?: string
+  requires?: readonly VobsPlugin[]
+  optional?: readonly VobsPlugin[]
+  install?: (ctx: VobsContext) => void | (() => void)
+}
+
+export interface VobsContext {
+  readonly app: VobsApp
+  provide<T>(key: InjectionKey<T>, value: T, options?: ProvideOptions): void
+  inject<T>(key: InjectionKey<T>): T | undefined
+  injectRequired<T>(key: InjectionKey<T>, description?: string): T
+  onDestroy(cleanup: () => void): void
+  onError(handler: (error: unknown) => void): () => void
+}
+
+export interface VobsConfig<
+  NodeType = Node,
+  TextNode extends NodeType = NodeType,
+  ElementNode extends NodeType = NodeType,
+  CommentNode extends NodeType = NodeType
+> {
+  render: () => NodeType | VobsFragment | Node | null | undefined
+  renderer?: VobsRenderer<NodeType, TextNode, ElementNode, CommentNode>
+  plugins?: VobsPlugin[]
+  /** Optional application-level error observer. Observers are isolated from the app. */
+  onError?: (error: unknown) => void
+}
+
+export interface VobsApp<NodeType = Node> {
+  readonly mounted: boolean
+  readonly destroyed: boolean
+  use(plugin: VobsPlugin): VobsApp<NodeType>
+  mount(target: string | NodeType): void
+  hydrate(target: string | NodeType): void
+  update(): void
+  destroy(): void
+}
+
+export function createInjectionKey<T>(description: string): InjectionKey<T> {
+  return Symbol(description) as InjectionKey<T>
+}
+
+export function createVobs(
+  config: VobsConfig<Node, Text, Element, Comment>
+): VobsApp<Node>
+export function createVobs<
+  NodeType = Node,
+  TextNode extends NodeType = NodeType,
+  ElementNode extends NodeType = NodeType,
+  CommentNode extends NodeType = NodeType
+>(
+  config: VobsConfig<NodeType, TextNode, ElementNode, CommentNode> & {
+    renderer: VobsRenderer<NodeType, TextNode, ElementNode, CommentNode>
+  }
+): VobsApp<NodeType>
+export function createVobs(
+  config: VobsConfig<any, any, any, any>
+): VobsApp<any> {
+  if (!config.render) throw new Error('createVobs: render 不能为空')
+
+  const renderer = config.renderer ?? createDOMRenderer()
+  const rootOwner: Owner = createOwner()
+  setOwnerDebugName(rootOwner, 'App')
+  const cleanups: Array<() => void> = []
+  const errorHandlers = new Set<(error: unknown) => void>()
+  const installed = new Set<string>()
+  const installing = new Set<string>()
+  let mounted = false
+  let destroyed = false
+  let container: any = null
+  let app!: VobsApp<any>
+
+  if (config.onError) {
+    errorHandlers.add(config.onError)
+    cleanups.push(() => errorHandlers.delete(config.onError!))
+  }
+
+  const context: VobsContext = {
+    get app(): VobsApp<any> {
+      return app
+    },
+
+    provide<T>(key: InjectionKey<T>, value: T, options: ProvideOptions = {}): void {
+      provideToOwner(rootOwner, key, value, options)
+    },
+
+    inject<T>(key: InjectionKey<T>): T | undefined {
+      return injectFromOwner(rootOwner, key)
+    },
+
+    injectRequired<T>(key: InjectionKey<T>, description?: string): T {
+      const value = injectFromOwner(rootOwner, key)
+      if (value === undefined) {
+        throw new Error(`Vobs: 找不到必需注入项${description ? ` ${description}` : ''}`)
+      }
+      return value
+    },
+
+    onDestroy(cleanup: () => void): void {
+      cleanups.push(cleanup)
+    },
+
+    onError(handler: (error: unknown) => void): () => void {
+      errorHandlers.add(handler)
+      const remove = () => errorHandlers.delete(handler)
+      cleanups.push(remove)
+      return remove
+    }
+  }
+
+  function notifyError(error: unknown): void {
+    for (const handler of [...errorHandlers]) {
+      try {
+        handler(error)
+      } catch {
+        // 错误处理器不能覆盖触发它的原始错误。
+      }
+    }
+  }
+
+  function installPlugin(plugin: VobsPlugin): void {
+    if (installed.has(plugin.name)) return
+    if (installing.has(plugin.name)) {
+      throw new Error(`Vobs: 插件依赖存在循环：${plugin.name}`)
+    }
+
+    installing.add(plugin.name)
+    try {
+      for (const dependency of plugin.requires ?? []) installPlugin(dependency)
+      const cleanup = plugin.install?.(context)
+      if (cleanup) cleanups.push(cleanup)
+      installed.add(plugin.name)
+    } finally {
+      installing.delete(plugin.name)
+    }
+  }
+
+  function cleanup(clearContainer = true): unknown {
+    let firstError: unknown
+    for (let index = cleanups.length - 1; index >= 0; index--) {
+      try {
+        cleanups[index]()
+      } catch (error) {
+        firstError ??= error
+      }
+    }
+    cleanups.length = 0
+
+    try {
+      rootOwner.dispose()
+    } catch (error) {
+      firstError ??= error
+    }
+
+    if (container && clearContainer) {
+      try {
+        renderer.clear(container)
+      } catch (error) {
+        firstError ??= error
+      }
+    }
+    return firstError
+  }
+
+  function start(target: string | any, hydrating: boolean): void {
+    if (destroyed) throw new Error('Vobs: 已销毁的应用不能挂载')
+    if (mounted) return
+
+    container = typeof target === 'string' ? document.querySelector(target) : target
+    if (!container) throw new Error(`mount: 目标不存在: ${target}`)
+    if (hydrating && !renderer.beginHydration) {
+      throw new Error('Vobs: 当前渲染器不支持 Hydration')
+    }
+
+    setRenderer(renderer)
+    try {
+      if (hydrating) renderer.beginHydration?.()
+      const rootNode = rootOwner.run(config.render)
+      if (!hydrating) renderer.clear(container)
+      if (rootNode) insertRuntimeNode(container, rootNode as any, null)
+      if (hydrating) renderer.completeHydration?.()
+      mounted = true
+    } catch (error) {
+      notifyError(error)
+      const cleanupError = cleanup(!hydrating)
+      destroyed = true
+      throw cleanupError ?? error
+    }
+  }
+
+  app = {
+    get mounted(): boolean {
+      return mounted
+    },
+
+    get destroyed(): boolean {
+      return destroyed
+    },
+
+    use(plugin: VobsPlugin): VobsApp<any> {
+      if (destroyed) throw new Error('Vobs: 已销毁的应用不能安装插件')
+      installPlugin(plugin)
+      return app
+    },
+
+    mount(target: string | any): void {
+      start(target, false)
+    },
+
+    hydrate(target: string | any): void {
+      start(target, true)
+    },
+
+    update(): void {
+      if (destroyed) throw new Error('Vobs: 已销毁的应用不能更新')
+      try {
+        scheduler.flush()
+      } catch (error) {
+        notifyError(error)
+        throw error
+      }
+    },
+
+    destroy(): void {
+      if (destroyed) return
+      try {
+        const cleanupError = cleanup()
+        if (cleanupError) {
+          notifyError(cleanupError)
+          throw cleanupError
+        }
+      } finally {
+        mounted = false
+        destroyed = true
+      }
+    }
+  }
+
+  try {
+    for (const plugin of config.plugins ?? []) app.use(plugin)
+  } catch (error) {
+    notifyError(error)
+    cleanup()
+    destroyed = true
+    throw error
+  }
+
+  return app
+}

package/src/context.ts

@@ -0,0 +1,54 @@
+import { getCurrentOwner, type Owner } from '@vobs/reactivity'
+import type { InjectionKey, ProvideOptions } from './app'
+
+const ownerProviders = new WeakMap<Owner, Map<InjectionKey<unknown>, unknown>>()
+
+export function provide<T>(key: InjectionKey<T>, value: T, options: ProvideOptions = {}): void {
+  const owner = getCurrentOwner()
+  if (!owner) throw new Error('Vobs: provide 必须在组件或 Owner 作用域内调用')
+  provideToOwner(owner, key, value, options)
+}
+
+export function inject<T>(key: InjectionKey<T>): T | undefined
+export function inject<T>(key: InjectionKey<T>, fallback: T): T
+export function inject<T>(key: InjectionKey<T>, fallback?: T): T | undefined {
+  const owner = getCurrentOwner()
+  const value = owner ? injectFromOwner(owner, key) : undefined
+  return value === undefined ? fallback : value
+}
+
+export function injectRequired<T>(key: InjectionKey<T>, description?: string): T {
+  const value = inject(key)
+  if (value === undefined) {
+    throw new Error(`Vobs: 找不到必需注入项${description ? ` ${description}` : ''}`)
+  }
+  return value
+}
+
+export function provideToOwner<T>(
+  owner: Owner,
+  key: InjectionKey<T>,
+  value: T,
+  options: ProvideOptions = {}
+): void {
+  let providers = ownerProviders.get(owner)
+  if (!providers) {
+    providers = new Map<InjectionKey<unknown>, unknown>()
+    ownerProviders.set(owner, providers)
+    owner.onDispose(() => ownerProviders.delete(owner))
+  }
+  if (providers.has(key) && !options.override) {
+    throw new Error(`Vobs: 注入项 ${String(key)} 已存在；如需覆盖请传入 override: true`)
+  }
+  providers.set(key, value)
+}
+
+export function injectFromOwner<T>(owner: Owner, key: InjectionKey<T>): T | undefined {
+  let current: Owner | null = owner
+  while (current) {
+    const providers = ownerProviders.get(current)
+    if (providers?.has(key)) return providers.get(key) as T
+    current = current.parent
+  }
+  return undefined
+}

package/src/index.ts

@@ -0,0 +1,89 @@
+/// <reference path="./jsx.d.ts" />
+
+export * from '@vobs/reactivity'
+export { createDOMRenderer } from '@vobs/dom'
+export type { VobsRenderer } from '@vobs/runtime'
+export {
+  getRuntimeDebugContext,
+  getRuntimeDebugHooks,
+  pushRuntimeDebugContext,
+  runWithRuntimeDebugContext,
+  setRuntimeDebugHooks
+} from '@vobs/runtime'
+export type {
+  RuntimeDebugContext,
+  RuntimeDebugEnvironment,
+  RuntimeDebugHooks,
+  RuntimeDomMutation,
+  RuntimeDomMutationOperation,
+  RuntimeErrorEvent,
+  RuntimeHydrationMismatch
+} from '@vobs/runtime'
+export {
+  setRenderer,
+  getRenderer,
+  createText,
+  createElement,
+  createComment,
+  insertBefore,
+  removeChild,
+  setTextContent,
+  setProperty,
+  setAttribute,
+  setStaticProps,
+  spreadProps,
+  addEventListener,
+  removeEventListener,
+  clear,
+  createComponent,
+  createFragment,
+  isVobsFragment,
+  disposeNodeOwner
+} from '@vobs/runtime'
+export type { FragmentFactory, VobsFragment, VobsNode } from '@vobs/runtime'
+export { bindText, bindAttribute, bindProperty } from '@vobs/runtime'
+export type { ValueSource } from '@vobs/runtime'
+export { ref, setRef } from '@vobs/runtime'
+export type { Ref, RefTarget } from '@vobs/runtime'
+export { insertDynamic, insertDynamicValue, insertList, normalizeDynamicChild } from '@vobs/runtime'
+export type { DynamicChild, NodeFactory } from '@vobs/runtime'
+export { createTemplate, cloneTemplate } from '@vobs/runtime'
+export type { VobsLocatedError, VobsSourceLocation } from '@vobs/runtime'
+export {
+  VobsError,
+  createVobsError,
+  formatVobsError,
+  isVobsError,
+  normalizeVobsError
+} from '@vobs/runtime'
+export type {
+  FormatVobsErrorOptions,
+  VobsErrorDefaults,
+  VobsErrorLayer,
+  VobsErrorLocation,
+  VobsErrorOptions,
+  VobsErrorSeverity
+} from '@vobs/runtime'
+export {
+  createHmrStateStore,
+  disposeHmrModule,
+  resolveComponent,
+  updateHmrModule
+} from '@vobs/runtime'
+export type { HmrComponent, HmrInstance, HmrStateStore } from '@vobs/runtime'
+export { insertErrorBoundary } from '@vobs/runtime'
+export { ErrorBoundary, insertBoundary } from '@vobs/runtime'
+export type { BoundaryFallback, BoundaryOptions, BoundaryRetry, ErrorBoundaryFallback, ErrorBoundaryOptions, ErrorBoundaryProps } from '@vobs/runtime'
+export { AsyncBoundary, insertAsyncBoundary, Profiler, insertProfiler } from '@vobs/runtime'
+export type { AsyncBoundaryFallback, AsyncBoundaryOptions, AsyncBoundaryProps, AsyncBoundaryView, ProfilerOptions, ProfilerProps, ProfilerRenderInfo } from '@vobs/runtime'
+export { createVobs, createInjectionKey } from './app'
+export { Fragment, Vobs } from './jsx-dev-runtime'
+export { provide, inject, injectRequired } from './context'
+export type {
+  InjectionKey,
+  ProvideOptions,
+  VobsApp,
+  VobsConfig,
+  VobsPlugin,
+  VobsContext
+} from './app'

package/src/jsx-dev-runtime.ts

@@ -0,0 +1,58 @@
+import {
+  createComponent,
+  createElement,
+  createFragment,
+  insertBefore,
+  normalizeDynamicChild,
+  spreadProps,
+  type VobsNode
+} from '@vobs/runtime'
+
+export function jsxDEV(
+  tag: string | Function,
+  props: Record<string, unknown> | null,
+  _key?: unknown,
+  _isStaticChildren?: boolean,
+  _source?: unknown,
+  _self?: unknown
+): VobsNode {
+  if (typeof tag === 'function') {
+    return createComponent(tag as (props: Record<string, unknown>) => VobsNode, props ?? {})
+  }
+
+  const { children, ...attrs } = props ?? {}
+
+  const el = createElement(tag as string)
+
+  spreadProps(el, attrs)
+
+  appendChildren(el, children)
+
+  return el
+}
+
+function appendChildren(parent: Node, children: unknown, anchor: Node | null = null): void {
+  if (children === undefined || children === null) return
+
+  const childArray = Array.isArray(children) ? children : [children]
+
+  for (const child of childArray) {
+    const node = normalizeDynamicChild(child as Parameters<typeof normalizeDynamicChild>[0])
+    if (node) insertBefore(parent, node, anchor)
+  }
+}
+
+export function jsx(tag: string | Function, props: Record<string, unknown> | null): VobsNode {
+  return jsxDEV(tag, props)
+}
+
+export function jsxs(tag: string | Function, props: Record<string, unknown> | null): VobsNode {
+  return jsxDEV(tag, props)
+}
+
+export function Fragment(props: { children?: unknown }): VobsNode {
+  return createFragment((parent, anchor) => appendChildren(parent, props?.children, anchor))
+}
+
+/** Namespace for explicit built-in JSX primitives such as <Vobs.Fragment>. */
+export const Vobs = { Fragment }

package/src/jsx-runtime.ts

@@ -0,0 +1 @@
+export { Fragment, jsx, jsxs } from './jsx-dev-runtime'

package/src/jsx.d.ts

@@ -0,0 +1,97 @@
+import type { VobsNode } from './fragment'
+import type { Ref, RefTarget } from '@vobs/runtime'
+
+// JSX 类型声明
+
+type VobsEventHandler<T extends Event = Event> = (event: T) => void
+
+interface VobsHTMLAttributes {
+  ref?: RefTarget<any>
+  accessKey?: string
+  autofocus?: boolean
+  class?: string
+  className?: string
+  cols?: number
+  disabled?: boolean
+  height?: number | string
+  hidden?: boolean
+  id?: string
+  max?: number | string
+  maxLength?: number
+  min?: number | string
+  minLength?: number
+  multiple?: boolean
+  name?: string
+  placeholder?: string
+  readOnly?: boolean
+  required?: boolean
+  rows?: number
+  selected?: boolean
+  size?: number
+  src?: string
+  step?: number | string
+  style?: string | Readonly<Record<string, string | number | boolean | null | undefined>>
+  tabIndex?: number
+  title?: string
+  type?: string
+  value?: string | number | readonly string[]
+  key?: string | number
+  width?: number | string
+  children?: unknown
+  onClick?: VobsEventHandler<MouseEvent>
+  onDblClick?: VobsEventHandler<MouseEvent>
+  onFocus?: VobsEventHandler<FocusEvent>
+  onBlur?: VobsEventHandler<FocusEvent>
+  onInput?: VobsEventHandler<InputEvent>
+  onChange?: VobsEventHandler<Event>
+  onKeyDown?: VobsEventHandler<KeyboardEvent>
+  onKeyUp?: VobsEventHandler<KeyboardEvent>
+  onSubmit?: VobsEventHandler<SubmitEvent>
+  [name: `data-${string}`]: string | number | boolean | undefined
+  [name: `aria-${string}`]: string | number | boolean | undefined
+}
+
+declare global {
+  namespace JSX {
+    type Element = VobsNode
+    interface ElementChildrenAttribute { children: {} }
+    interface IntrinsicElements {
+      a: VobsHTMLAttributes
+      article: VobsHTMLAttributes
+      aside: VobsHTMLAttributes
+      button: VobsHTMLAttributes
+      code: VobsHTMLAttributes
+      div: VobsHTMLAttributes
+      footer: VobsHTMLAttributes
+      form: VobsHTMLAttributes
+      h1: VobsHTMLAttributes
+      h2: VobsHTMLAttributes
+      h3: VobsHTMLAttributes
+      header: VobsHTMLAttributes
+      img: VobsHTMLAttributes
+      input: VobsHTMLAttributes
+      label: VobsHTMLAttributes
+      li: VobsHTMLAttributes
+      main: VobsHTMLAttributes
+      nav: VobsHTMLAttributes
+      ol: VobsHTMLAttributes
+      option: VobsHTMLAttributes
+      pre: VobsHTMLAttributes
+      p: VobsHTMLAttributes
+      section: VobsHTMLAttributes
+      select: VobsHTMLAttributes
+      span: VobsHTMLAttributes
+      table: VobsHTMLAttributes
+      tbody: VobsHTMLAttributes
+      td: VobsHTMLAttributes
+      textarea: VobsHTMLAttributes
+      tfoot: VobsHTMLAttributes
+      th: VobsHTMLAttributes
+      thead: VobsHTMLAttributes
+      tr: VobsHTMLAttributes
+      ul: VobsHTMLAttributes
+    }
+  }
+}
+
+export {}

package/src/types.test.ts

@@ -0,0 +1,26 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import { createInjectionKey, inject, provide } from './index'
+import { state, type Signal } from '@vobs/reactivity'
+
+interface AuthContext {
+  readonly loggedIn: Signal<boolean>
+}
+
+describe('Vobs public types', () => {
+  it('state 保留泛型并由初始值推导', () => {
+    const count = state(0)
+    expectTypeOf(count).toEqualTypeOf<Signal<number>>()
+  })
+
+  it('InjectionKey 将 inject 和 provide 约束到同一类型', () => {
+    const key = createInjectionKey<AuthContext>('test.auth')
+    const check = (): void => {
+      const value: AuthContext | undefined = inject(key)
+      if (value) value.loggedIn.value = true
+      provide(key, { loggedIn: state(false) })
+      // @ts-expect-error The value must match the InjectionKey payload.
+      provide(key, state(false))
+    }
+    expectTypeOf(check).toBeFunction()
+  })
+})

package/dist/index.d.ts

@@ -1,7 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/vobs
- */
-export * from '@vobs/reactivity';
-export * from '@vobs/runtime-dom';
-export { RouterCapability, collectRouteNavigation, createRouteLoaderCache, createRouteNavigationScope, createRouteResolver, createRouter, loadRouteComponent, resolveActiveRouteNavigationId, resolveRoute, resolveRouteGuard, resolveRouteInitialState, } from '@vobs/router';

package/dist/index.js

@@ -1,7 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/vobs
- */
-export * from '@vobs/reactivity';
-export * from '@vobs/runtime-dom';
-export { RouterCapability, collectRouteNavigation, createRouteLoaderCache, createRouteNavigationScope, createRouteResolver, createRouter, loadRouteComponent, resolveActiveRouteNavigationId, resolveRoute, resolveRouteGuard, resolveRouteInitialState, } from '@vobs/router';

package/dist/reactivity.d.ts

@@ -1,5 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/vobs
- */
-export * from '@vobs/reactivity';

package/dist/reactivity.js

@@ -1,5 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/vobs
- */
-export * from '@vobs/reactivity';

package/dist/router.d.ts

@@ -1,5 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/vobs
- */
-export * from '@vobs/router';

package/dist/router.js

@@ -1,5 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/vobs
- */
-export * from '@vobs/router';

package/dist/runtime-dom.d.ts

@@ -1,5 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/vobs
- */
-export * from '@vobs/runtime-dom';

package/dist/runtime-dom.js

@@ -1,5 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/vobs
- */
-export * from '@vobs/runtime-dom';