create-bubbles 0.1.26 → 0.1.28

package/template-vp-monorepo-react-nestjs/scripts/enterprise-qa/legacy-http.mjs

@@ -0,0 +1,140 @@
+import { spawn } from 'node:child_process'
+import { resolve } from 'node:path'
+import { setTimeout as delay } from 'node:timers/promises'
+import { createServer } from 'node:net'
+import {
+  root,
+  loadRuntime,
+  privateStatePath,
+  readPrivateState,
+  createReporter,
+  ensure,
+  randomIdentity,
+} from './runtime.mjs'
+import { apiClient, loginIdentity, registerIdentity } from './http-support.mjs'
+
+const { runtime, runtimePath } = loadRuntime(process.argv[2])
+const legacy = readPrivateState(privateStatePath(runtimePath, 'legacy'))
+ensure(
+  legacy.stage === 'upgraded' && /^enterprise_legacy_[a-z0-9]+$/.test(legacy.database),
+  '必须先完成真实旧库迁移验证',
+)
+const report = createReporter('legacy-http')
+const { database, storage } = runtime
+const databaseUrl = new URL(`postgresql://${database.host}:${database.port}/${legacy.database}`)
+databaseUrl.username = database.user
+databaseUrl.password = database.password
+const port = 3302
+const request = apiClient({ ...runtime, serverPort: port })
+let child
+
+async function assertPortFree() {
+  await new Promise((resolve, reject) => {
+    const probe = createServer()
+    probe.once('error', () => reject(new Error('3302已被占用，拒绝接管已有进程')))
+    probe.listen(port, '127.0.0.1', () => probe.close(resolve))
+  })
+}
+
+try {
+  await assertPortFree()
+  const env = {
+    ...process.env,
+    NODE_ENV: 'test',
+    HOST: '127.0.0.1',
+    PORT: String(port),
+    DATABASE_URL: databaseUrl.toString(),
+    DB_HOST: database.host,
+    DB_PORT: String(database.port),
+    DB_DATABASE: legacy.database,
+    DB_USERNAME: database.user,
+    DB_PASSWORD: database.password,
+    REDIS_HOST: '127.0.0.1',
+    REDIS_PORT: String(runtime.redisPort),
+    REDIS_DB: '2',
+    REDIS_PASSWORD: '',
+    SESSION_TOKEN_PEPPER: runtime.sessionPepper,
+    QUEUE_REDIS_HOST: '127.0.0.1',
+    QUEUE_REDIS_PORT: String(runtime.redisPort),
+    QUEUE_REDIS_DB: '3',
+    QUEUE_REDIS_USERNAME: '',
+    QUEUE_REDIS_PASSWORD: '',
+    QUEUE_PREFIX: 'enterprise:legacy:queue',
+    QUEUE_WORKER_ENABLED: 'false',
+    STORAGE_ENDPOINT: storage.endpoint,
+    STORAGE_REGION: storage.region,
+    STORAGE_ACCESS_KEY_ID: storage.accessKeyId,
+    STORAGE_SECRET_ACCESS_KEY: storage.secretAccessKey,
+    STORAGE_BUCKET: storage.bucket,
+  }
+  child = spawn(process.execPath, ['dist/src/main.js'], {
+    cwd: resolve(root, 'apps/server'),
+    env,
+    stdio: 'ignore',
+    windowsHide: true,
+  })
+  child.on('error', () => {})
+  let ready = false
+  for (let attempt = 0; attempt < 80; attempt++) {
+    if (child.exitCode !== null) break
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/`, {
+        signal: AbortSignal.timeout(500),
+      })
+      if (response.status === 200) {
+        ready = true
+        break
+      }
+    } catch {}
+    await delay(250)
+  }
+  ensure(ready, '隔离旧库HTTP实例未能启动')
+  await report.check({
+    id: 'legacy-user-real-http-login',
+    acceptance: ['AC-08'],
+    run: async () => {
+      await loginIdentity({ request, identity: legacy.identity })
+      const me = (await request({ actor: legacy.identity, path: '/auth/me' })).body
+      ensure(
+        me.id === legacy.identity.id && me.account === legacy.identity.account,
+        '旧用户登录身份未保留',
+      )
+      const spaces = (await request({ actor: legacy.identity, path: '/workspaces' })).body
+      ensure(spaces.workspaces.length === 0, '旧用户被自动分配工作空间')
+      return '旧0000/0001库账号在新服务真实登录成功，身份保留且未自动分配企业'
+    },
+  })
+  await report.check({
+    id: 'legacy-upload-owner-real-http',
+    acceptance: ['AC-08'],
+    run: async () => {
+      const upload = (
+        await request({ actor: legacy.identity, path: `/uploads/multipart/${legacy.uploadId}` })
+      ).body
+      ensure(upload.status === 'completed', '旧owner无法读取自己的完成上传记录')
+      const outsider = await registerIdentity({ request, identity: randomIdentity('legacy_other') })
+      await loginIdentity({ request, identity: outsider })
+      await request({
+        actor: outsider,
+        path: `/uploads/multipart/${legacy.uploadId}`,
+        expected: 404,
+      })
+      return '旧上传记录owner可读取、不同真实登录用户404；此夹具验证历史归属，真实对象写入另见http-upload-owner-regression'
+    },
+  })
+} catch (error) {
+  report.results.push({
+    id: 'legacy-http-environment',
+    acceptance: ['AC-08'],
+    status: 'failed',
+    evidence: error instanceof Error ? error.message : '旧库HTTP验收失败',
+  })
+  process.stdout.write('FAIL legacy-http-environment\n')
+} finally {
+  if (child && child.exitCode === null) {
+    child.kill()
+    await Promise.race([new Promise((resolve) => child.once('exit', resolve)), delay(5000)])
+  }
+  report.save()
+  if (report.results.some((item) => item.status === 'failed')) process.exitCode = 1
+}

package/template-vp-monorepo-react-nestjs/scripts/enterprise-qa/legacy.mjs

@@ -0,0 +1,196 @@
+import { readFileSync, writeFileSync, mkdirSync, mkdtempSync, existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { tmpdir } from 'node:os'
+import { randomUUID, randomBytes } from 'node:crypto'
+import {
+  root,
+  serverRequire,
+  loadRuntime,
+  databaseConfig,
+  randomIdentity,
+  ensure,
+  privateStatePath,
+  readPrivateState,
+  writePrivateState,
+  createReporter,
+} from './runtime.mjs'
+
+const { runtime, runtimePath } = loadRuntime(process.argv[2])
+const mode = process.argv[3] ?? 'verify'
+ensure(['prepare', 'verify'].includes(mode), '模式必须为 prepare 或 verify')
+const { Client } = serverRequire('pg')
+const { drizzle } = serverRequire('drizzle-orm/node-postgres')
+const { migrate } = serverRequire('drizzle-orm/node-postgres/migrator')
+const argon2 = serverRequire('argon2')
+const statePath = privateStatePath(runtimePath, 'legacy')
+const migrationsFolder = resolve(root, 'apps/server/drizzle')
+const report = createReporter('legacy')
+let state
+let client
+
+try {
+  if (!existsSync(statePath)) {
+    const database = `enterprise_legacy_${randomBytes(5).toString('hex')}`
+    ensure(/^enterprise_legacy_[a-z0-9]+$/.test(database), '无效的隔离旧库名称')
+    const admin = new Client(databaseConfig(runtime, 'postgres'))
+    await admin.connect()
+    try {
+      const duplicate = await admin.query('SELECT 1 FROM pg_database WHERE datname = $1', [
+        database,
+      ])
+      ensure(duplicate.rowCount === 0, '拒绝复用未知的已有旧库')
+      await admin.query(`CREATE DATABASE "${database}"`)
+    } finally {
+      await admin.end()
+    }
+    state = {
+      database,
+      stage: 'created',
+      identity: randomIdentity('legacy'),
+      uploadId: randomUUID(),
+    }
+    writePrivateState(statePath, state)
+  } else {
+    state = readPrivateState(statePath)
+  }
+  ensure(/^enterprise_legacy_[a-z0-9]+$/.test(state.database), '仅允许本脚本创建的明确旧库')
+  client = new Client(databaseConfig(runtime, state.database))
+  await client.connect()
+
+  if (state.stage === 'created') {
+    const journal = JSON.parse(
+      readFileSync(resolve(migrationsFolder, 'meta/_journal.json'), 'utf8'),
+    )
+    const historical = journal.entries.filter((entry) => entry.idx <= 1)
+    ensure(historical.length === 2, '必须存在两份原始历史迁移')
+    const folder = mkdtempSync(resolve(tmpdir(), 'codex-enterprise-legacy-migrations-'))
+    mkdirSync(resolve(folder, 'meta'))
+    writeFileSync(
+      resolve(folder, 'meta/_journal.json'),
+      JSON.stringify({ ...journal, entries: historical }),
+    )
+    for (const entry of historical) {
+      writeFileSync(
+        resolve(folder, `${entry.tag}.sql`),
+        readFileSync(resolve(migrationsFolder, `${entry.tag}.sql`)),
+      )
+    }
+    await migrate(drizzle(client), { migrationsFolder: folder })
+    const passwordHash = await argon2.hash(state.identity.password)
+    const user = await client.query(
+      'INSERT INTO users (name, account, password_hash) VALUES ($1, $2, $3) RETURNING id',
+      [state.identity.name, state.identity.account, passwordHash],
+    )
+    state.identity.id = user.rows[0].id
+    await client.query(
+      `INSERT INTO upload_sessions
+       (id, owner_id, client_upload_id, bucket, object_key, storage_upload_id, original_name,
+        content_type, file_size, part_size, total_parts, status, expires_at, completed_at)
+       VALUES ($1, $2, $3, $4, $5, $6, 'legacy.txt', 'text/plain', 4, 5242880, 1,
+               'completed', now() + interval '1 day', now())`,
+      [
+        state.uploadId,
+        state.identity.id,
+        randomUUID(),
+        runtime.storage.bucket,
+        `qa-legacy/${state.uploadId}`,
+        randomUUID(),
+      ],
+    )
+    state.passwordHash = passwordHash
+    state.stage = 'legacy-ready'
+    writePrivateState(statePath, state)
+  }
+
+  await report.check({
+    id: 'legacy-fixture-isolated',
+    acceptance: ['AC-08'],
+    run: async () => {
+      const { rows } = await client.query('SELECT current_database() AS database')
+      ensure(rows[0].database === state.database, '连接到了非预期测试库')
+      return '独立 enterprise_legacy_* 数据库；真实重放 0000/0001 迁移及旧用户、上传记录'
+    },
+  })
+
+  if (mode === 'prepare') {
+    report.pending({
+      id: 'legacy-upgrade',
+      acceptance: ['AC-08'],
+      reason: '旧库夹具已准备；等待新增迁移就绪后执行 verify',
+    })
+  } else {
+    const journal = JSON.parse(
+      readFileSync(resolve(migrationsFolder, 'meta/_journal.json'), 'utf8'),
+    )
+    ensure(
+      journal.entries.some((entry) => entry.idx > 1),
+      '新增管理迁移尚未生成，不能验证升级',
+    )
+    await report.check({
+      id: 'legacy-upgrade-retains-user-upload',
+      acceptance: ['AC-08'],
+      run: async () => {
+        await migrate(drizzle(client), { migrationsFolder })
+        const user = (
+          await client.query('SELECT id, account, password_hash, status FROM users WHERE id = $1', [
+            state.identity.id,
+          ])
+        ).rows[0]
+        ensure(
+          user?.account === state.identity.account && user.status === 'active',
+          '升级改变了既有用户身份或状态',
+        )
+        ensure(user.password_hash === state.passwordHash, '升级改变了既有密码散列')
+        ensure(
+          await argon2.verify(user.password_hash, state.identity.password),
+          '既有用户密码无法验证',
+        )
+        const upload = (
+          await client.query('SELECT owner_id, status FROM upload_sessions WHERE id = $1', [
+            state.uploadId,
+          ])
+        ).rows[0]
+        ensure(
+          upload?.owner_id === state.identity.id && upload.status === 'completed',
+          '上传所有者或状态未保留',
+        )
+        const membership = await client.query(
+          'SELECT count(*)::int AS count FROM company_members WHERE user_id = $1',
+          [state.identity.id],
+        )
+        ensure(membership.rows[0].count === 0, '升级自动为既有用户分配了企业')
+        return '完整新迁移保留既有用户、密码散列、上传 ownerId；不自动分配企业'
+      },
+    })
+    await report.check({
+      id: 'legacy-migration-repeat-safe',
+      acceptance: ['AC-08'],
+      run: async () => {
+        const before = await client.query(
+          'SELECT count(*)::int AS count FROM drizzle.__drizzle_migrations',
+        )
+        await migrate(drizzle(client), { migrationsFolder })
+        const after = await client.query(
+          'SELECT count(*)::int AS count FROM drizzle.__drizzle_migrations',
+        )
+        ensure(before.rows[0].count === after.rows[0].count, '重复迁移产生重复迁移记录')
+        ensure(after.rows[0].count === journal.entries.length, '迁移记录数量与源码不一致')
+        return '再次执行真实 migrator 未重复变更，迁移记录与 journal 一致'
+      },
+    })
+    state.stage = 'upgraded'
+    writePrivateState(statePath, state)
+  }
+} catch (error) {
+  report.results.push({
+    id: 'legacy-run',
+    acceptance: ['AC-08'],
+    status: 'failed',
+    evidence: error instanceof Error ? error.message : '旧库验证失败',
+  })
+  process.stdout.write('FAIL legacy-run\n')
+} finally {
+  if (client) await client.end()
+  report.save()
+  if (report.results.some((item) => item.status === 'failed')) process.exitCode = 1
+}

package/template-vp-monorepo-react-nestjs/scripts/enterprise-qa/runtime.mjs

@@ -0,0 +1,110 @@
+import { createRequire } from 'node:module'
+import { readFileSync, writeFileSync, mkdirSync, realpathSync } from 'node:fs'
+import { dirname, resolve, relative, isAbsolute } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { tmpdir } from 'node:os'
+import { randomBytes } from 'node:crypto'
+
+export const root = resolve(dirname(fileURLToPath(import.meta.url)), '../..')
+export const serverRequire = createRequire(resolve(root, 'apps/server/package.json'))
+export const evidenceDirectory = resolve(root, '.spaces/01.企业级项目级/权限与菜单/测试证据')
+export const uiDirectory = resolve(root, '.spaces/01.企业级项目级/权限与菜单/ui')
+
+export function ensure(condition, message) {
+  if (!condition) throw new Error(message)
+}
+
+function isSystemTempPath(path) {
+  const parent = realpathSync.native(dirname(resolve(path)))
+  const difference = relative(realpathSync.native(tmpdir()), parent)
+  return (
+    difference !== '..' &&
+    !difference.startsWith(`..\\`) &&
+    !difference.startsWith('../') &&
+    !isAbsolute(difference)
+  )
+}
+
+export function loadRuntime(runtimePath) {
+  ensure(runtimePath, '必须提供系统临时目录中的隔离运行配置路径')
+  const resolved = resolve(runtimePath)
+  ensure(isSystemTempPath(resolved), '运行配置必须位于系统临时目录')
+  const runtime = JSON.parse(readFileSync(resolved, 'utf8').replace(/^\uFEFF/, ''))
+  ensure(
+    ['127.0.0.1', 'localhost'].includes(runtime.database?.host) &&
+      /^enterprise_(test|legacy)(_[a-z0-9]+)?$/.test(runtime.database?.database ?? '') &&
+      runtime.database?.port === 15432 &&
+      runtime.redisPort === 16379,
+    '拒绝运行：只允许指定本机隔离 PostgreSQL 与 Redis',
+  )
+  return { runtime, runtimePath: resolved }
+}
+
+export function databaseConfig(runtime, database = runtime.database.database) {
+  const { host, port, user, password } = runtime.database
+  return { host, port, user, password, database }
+}
+
+export function randomIdentity(label) {
+  const suffix = randomBytes(6).toString('hex')
+  return {
+    account: `qa_${label}_${suffix}`.slice(0, 32),
+    name: `验收${label}`,
+    password: randomBytes(30).toString('base64url'),
+  }
+}
+
+export function privateStatePath(runtimePath, name) {
+  return resolve(dirname(runtimePath), `codex-enterprise-01a085-qa-${name}.json`)
+}
+
+export function writePrivateState(path, state) {
+  ensure(isSystemTempPath(path), '敏感测试状态只能写入系统临时目录')
+  writeFileSync(path, JSON.stringify(state), { mode: 0o600 })
+}
+
+export function readPrivateState(path) {
+  return JSON.parse(readFileSync(path, 'utf8').replace(/^\uFEFF/, ''))
+}
+
+export function writeEvidence(name, evidence) {
+  mkdirSync(evidenceDirectory, { recursive: true })
+  const path = resolve(evidenceDirectory, `${name}.json`)
+  const payload = JSON.stringify(evidence, null, 2)
+  ensure(
+    !/"(password|passwordHash|accessToken|sessionPepper|secretAccessKey|token)"\s*:/i.test(payload),
+    '证据中不得写入凭据字段',
+  )
+  writeFileSync(path, `${payload}\n`)
+  return path
+}
+
+export function createReporter(suite) {
+  const results = []
+  return {
+    results,
+    async check({ id, acceptance, run }) {
+      try {
+        const evidence = await run()
+        results.push({ id, acceptance, status: 'passed', evidence: evidence ?? '断言通过' })
+        process.stdout.write(`PASS ${id}\n`)
+        return true
+      } catch (error) {
+        results.push({
+          id,
+          acceptance,
+          status: 'failed',
+          evidence: error instanceof Error ? error.message : '测试失败',
+        })
+        process.stdout.write(`FAIL ${id}\n`)
+        return false
+      }
+    },
+    pending({ id, acceptance, reason }) {
+      results.push({ id, acceptance, status: 'unverified', evidence: reason })
+    },
+    save() {
+      return writeEvidence(suite, { suite, executedAt: new Date().toISOString(), results })
+    },
+  }
+}

package/template-vp-monorepo-react-nestjs/scripts/with-enterprise-test-env.mjs

@@ -0,0 +1,80 @@
+import { spawn } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { dirname, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// 只在明确隔离的本机环境运行验收，不读取或改写应用的开发配置。
+const [runtimePath, workingDirectory, command, ...args] = process.argv.slice(2)
+if (!runtimePath || !workingDirectory || !command) {
+  throw new Error(
+    '用法：node scripts/with-enterprise-test-env.mjs <临时配置路径> <工作目录> <命令> [...参数]',
+  )
+}
+
+const runtime = JSON.parse(readFileSync(runtimePath, 'utf8').replace(/^\uFEFF/, ''))
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const cwd = resolve(root, workingDirectory)
+if (relative(root, cwd).startsWith('..')) {
+  throw new Error('测试工作目录必须在当前工程内')
+}
+
+const { database, storage, redisPort, serverPort, sessionPepper } = runtime
+const isLocal = (host) => host === '127.0.0.1' || host === 'localhost'
+const isPort = (port) => Number.isInteger(port) && port > 1024 && port < 65536
+if (
+  !isLocal(database?.host) ||
+  !/^enterprise_(test|legacy)(_[a-z0-9]+)?$/.test(database?.database ?? '') ||
+  !isPort(database?.port) ||
+  !isPort(redisPort) ||
+  !isPort(serverPort) ||
+  !isLocal(new URL(storage?.endpoint).hostname) ||
+  !storage?.bucket?.startsWith('enterprise-test-') ||
+  typeof sessionPepper !== 'string' ||
+  sessionPepper.length < 32
+) {
+  throw new Error('拒绝运行：需要独立本机数据库、Redis、对象存储及运行期会话密钥')
+}
+
+const databaseUrl = new URL(`postgresql://${database.host}:${database.port}/${database.database}`)
+databaseUrl.username = database.user
+databaseUrl.password = database.password
+
+const env = {
+  ...process.env,
+  NODE_ENV: 'test',
+  HOST: '127.0.0.1',
+  PORT: String(serverPort),
+  DATABASE_URL: databaseUrl.toString(),
+  DB_HOST: database.host,
+  DB_PORT: String(database.port),
+  DB_DATABASE: database.database,
+  DB_USERNAME: database.user,
+  DB_PASSWORD: database.password,
+  REDIS_HOST: '127.0.0.1',
+  REDIS_PORT: String(redisPort),
+  REDIS_DB: '0',
+  REDIS_PASSWORD: '',
+  SESSION_TOKEN_PEPPER: sessionPepper,
+  QUEUE_REDIS_HOST: '127.0.0.1',
+  QUEUE_REDIS_PORT: String(redisPort),
+  QUEUE_REDIS_DB: '1',
+  QUEUE_REDIS_USERNAME: '',
+  QUEUE_REDIS_PASSWORD: '',
+  QUEUE_PREFIX: 'enterprise:test:queue',
+  STORAGE_ENDPOINT: storage.endpoint,
+  STORAGE_REGION: storage.region,
+  STORAGE_ACCESS_KEY_ID: storage.accessKeyId,
+  STORAGE_SECRET_ACCESS_KEY: storage.secretAccessKey,
+  STORAGE_BUCKET: storage.bucket,
+}
+
+const child = spawn(command, args, { cwd, env, stdio: 'inherit', shell: false })
+child.on('error', () => {
+  console.error('测试命令启动失败，请确认命令存在且允许启动子进程')
+  process.exitCode = 1
+})
+child.on('exit', (code) => {
+  process.exitCode = code ?? 1
+})
+process.on('SIGINT', () => child.kill('SIGINT'))
+process.on('SIGTERM', () => child.kill('SIGTERM'))

package/template-vp-monorepo-react-nestjs/src/types/auto-imports.d.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* oxlint-disable */
+/* oxfmt-ignore */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+// Generated by unplugin-auto-import
+// biome-ignore lint: disable
+export {}
+declare global {
+  const Activity: typeof import('react').Activity
+  const Fragment: typeof import('react').Fragment
+  const Suspense: typeof import('react').Suspense
+  const cache: typeof import('react').cache
+  const cacheSignal: typeof import('react').cacheSignal
+  const createContext: typeof import('react').createContext
+  const createPortal: typeof import('react-dom').createPortal
+  const createRef: typeof import('react').createRef
+  const flushSync: typeof import('react-dom').flushSync
+  const forwardRef: typeof import('react').forwardRef
+  const lazy: typeof import('react').lazy
+  const memo: typeof import('react').memo
+  const preconnect: typeof import('react-dom').preconnect
+  const prefetchDNS: typeof import('react-dom').prefetchDNS
+  const preinit: typeof import('react-dom').preinit
+  const preinitModule: typeof import('react-dom').preinitModule
+  const preload: typeof import('react-dom').preload
+  const preloadModule: typeof import('react-dom').preloadModule
+  const startTransition: typeof import('react').startTransition
+  const use: typeof import('react').use
+  const useActionState: typeof import('react').useActionState
+  const useCallback: typeof import('react').useCallback
+  const useContext: typeof import('react').useContext
+  const useDebugValue: typeof import('react').useDebugValue
+  const useDeferredValue: typeof import('react').useDeferredValue
+  const useEffect: typeof import('react').useEffect
+  const useEffectEvent: typeof import('react').useEffectEvent
+  const useFormStatus: typeof import('react-dom').useFormStatus
+  const useHref: typeof import('react-router').useHref
+  const useId: typeof import('react').useId
+  const useImperativeHandle: typeof import('react').useImperativeHandle
+  const useInRouterContext: typeof import('react-router').useInRouterContext
+  const useInsertionEffect: typeof import('react').useInsertionEffect
+  const useLayoutEffect: typeof import('react').useLayoutEffect
+  const useLocation: typeof import('react-router').useLocation
+  const useMemo: typeof import('react').useMemo
+  const useNavigate: typeof import('react-router').useNavigate
+  const useNavigationType: typeof import('react-router').useNavigationType
+  const useOptimistic: typeof import('react').useOptimistic
+  const useOutlet: typeof import('react-router').useOutlet
+  const useOutletContext: typeof import('react-router').useOutletContext
+  const useParams: typeof import('react-router').useParams
+  const useReducer: typeof import('react').useReducer
+  const useRef: typeof import('react').useRef
+  const useResolvedPath: typeof import('react-router').useResolvedPath
+  const useRoutes: typeof import('react-router').useRoutes
+  const useState: typeof import('react').useState
+  const useSyncExternalStore: typeof import('react').useSyncExternalStore
+  const useTransition: typeof import('react').useTransition
+}

package/template-vp-monorepo-react-nestjs/tsconfig.lib.json

@@ -2,7 +2,7 @@
   "extends": "./tsconfig.bundler.json",
   "compilerOptions": {
     "target": "ES2020",
-    "lib": ["ES2020"],
+    "lib": ["ES2020", "DOM"],
     "types": [],
     "useDefineForClassFields": true,
     "noUncheckedIndexedAccess": true

package/template-vp-react/package.json

@@ -14,26 +14,26 @@
     "@alova/adapter-axios": "^2.0.20",
     "@tailwindcss/vite": "^4.3.3",
     "alova": "^3.5.5",
-    "antd": "^6.6.3",
+    "antd": "^6.6.5",
     "axios": "^1.20.0",
     "classnames": "^2.5.1",
     "dayjs": "^1.11.23",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "react-router": "^8.3.1",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "react-router": "^8.4.0",
     "tailwindcss": "^4.3.3"
   },
   "devDependencies": {
-    "@commitlint/cli": "^21.2.2",
-    "@commitlint/config-conventional": "^21.2.2",
-    "@types/node": "^26.5.0",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.7",
-    "@vitejs/plugin-react": "^6.1.1",
+    "@commitlint/cli": "^21.2.3",
+    "@commitlint/config-conventional": "^21.2.3",
+    "@types/node": "^26.6.4",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.2",
     "typescript": "~7.0.2",
     "unplugin-auto-import": "^21.1.0",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.3.0",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
     "vite-plugin-svgr": "^5.2.0",
-    "vite-plus": "0.3.0"
+    "vite-plus": "1.1.0"
   }
 }

package/template-vp-react/src/types/auto-imports.d.ts

@@ -1,5 +1,7 @@
 /* eslint-disable */
 /* prettier-ignore */
+/* oxlint-disable */
+/* oxfmt-ignore */
 // @ts-nocheck
 // noinspection JSUnusedGlobalSymbols
 // Generated by unplugin-auto-import