creght-cli 0.7.6 → 0.9.0

package/README.md

@@ -2,7 +2,7 @@
 
 Creght CLI is a thin local bridge for syncing site code between a local directory and Creght.
 
-The CLI can also run a local Vite preview for pulled Creght projects. Creght remains responsible for cloud rendering, CMS, assets, and the realtime preview environment.
+Creght remains responsible for cloud rendering, CMS, assets, and the preview environment. The CLI does not render sites locally; use `creght preview` to open the canonical remote preview.
 
 ## Install
 
@@ -180,54 +180,6 @@ generated/*
 /scratch/
 ```
 
-## Local Vite Preview
-
-Creght projects pulled by the CLI usually do not have their own `package.json`
-or `node_modules`. The local preview plugin therefore uses Vite only for local
-file serving and TSX transpilation; third-party packages continue to resolve
-through the Creght import map, matching the Web editor preview model. In
-`creght dev`, the CLI serves the workspace directory, loads the platform import
-map from server system info, and passes it to the Vite plugin; the plugin's
-local map is only a fallback.
-
-Install Vite in the local project folder:
-
-```bash
-cd ./mysite
-npm init -y
-npm install -D vite esbuild creght-cli
-```
-
-Create `vite.config.mjs`:
-
-```js
-import { defineConfig } from 'vite'
-import creght from 'creght-cli/vite'
-
-export default defineConfig({
-  plugins: [
-    creght({
-      apiHost: 'https://creght.cn',
-      projectId: '<project_id>',
-      // token: process.env.CREGHT_TOKEN,
-    }),
-  ],
-})
-```
-
-Run it:
-
-```bash
-npx vite --host 0.0.0.0
-```
-
-The plugin maps `/page/Index.tsx` to `/`, `/page/About.tsx` to `/about`, starts
-from the platform import map, merges `creght.config.ts` import-map entries,
-loads `/index.css` through the Tailwind browser runtime, proxies local `/api/*`
-requests to `apiHost`, calls page `getServerSideProps()` in the browser for a
-preview-only first render, and uses Vite HMR to re-import the current page
-module after local file changes without a full page reload.
-
 ## Push Local Changes
 
 Push the current local directory snapshot to Creght and exit:
@@ -288,91 +240,130 @@ content is backed up under `.creght/backup/<timestamp>-*/`.
 `base_to_local_diff` / `base_to_remote_diff`, so agents can decide how to
 resolve without extra round-trips.
 
-## Local Web Editor Bidirectional Sync
+## Open Preview
 
-Run local files and the online Creght editor against the same cloud realtime
-files:
+Open the remote preview URL for a site in the browser:
 
 ```bash
-creght dev --site_id=<project_id>/<site_id> --dir=./mysite
+creght preview --site_id=<project_id>/<site_id>
 ```
 
-For local backend or web development:
+For local development:
 
 ```bash
-CREGHT_API_HOST=http://localhost:8433 creght dev --web=http://localhost:5173 --site_id=<project_id>/<site_id> --dir=./mysite
+CREGHT_API_HOST=http://localhost:8433 creght preview --site_id=<project_id>/<site_id>
 ```
 
-The command prints the online Web editor URL, pushes local file changes to
-Creght, and listens to the existing WebSocket collaboration channel so editor
-changes are written back to the local directory. MVP conflict handling is last
-write wins.
+## Publish Site
 
-`dev` also starts a local Vite preview by default:
+Publish a site:
 
-```text
-  VITE v8.0.14  ready in 529 ms
-  ➜  Local:   http://localhost:5173/
-Local Vite:  started (preferred http://localhost:5173; use the Vite Local URL above)
+```bash
+creght publish --site_id=<project_id>/<site_id>
 ```
 
-Use `--preview-port` or `--preview-host` to change the preferred local preview
-address. If that port is occupied, Vite uses its normal auto-port behavior and
-prints the actual URL in the terminal:
+With a publish note:
 
 ```bash
-creght dev --site_id=<project_id>/<site_id> --dir=./mysite --preview-port=5174
+creght publish --site_id=<project_id>/<site_id> --note="Update homepage copy"
 ```
 
-Disable the local preview when you only want file sync:
+For local development:
 
 ```bash
-creght dev --site_id=<project_id>/<site_id> --dir=./mysite --no-preview
+CREGHT_API_HOST=http://localhost:8433 creght publish --site_id=<project_id>/<site_id>
 ```
 
-The preview uses the bundled `creght-cli/vite` plugin. If the site directory
-has `node_modules/.bin/vite`, that local Vite is used; otherwise the CLI starts
-a hidden temporary Vite runtime under `.creght/` and installs `vite` plus
-`esbuild` there.
+`publish` reports the version it created, so you can publish it again later:
 
-Local file changes are pushed through Vite HMR as a React root re-render. This
-avoids a browser-level refresh, but it is not yet full React Fast Refresh and
-does not guarantee component state preservation.
+```text
+Published <project_id>/<site_id>
+version 14 (id 458) is live on demo.creght.cn
+```
 
-## Open Preview
+## Site Versions
 
-Open the remote preview URL for a site in the browser:
+A site version is an immutable snapshot of the site's source files — the
+platform equivalent of a git commit. Create one whenever a piece of work is
+done, then publish whichever version you want the live site to serve.
+
+Snapshots cover source files only. CMS content and the platform state under
+`/platform/**` (CMS/form/table/auth definitions) are live, so publishing an
+older version does not roll those back.
+
+Inside a pulled workspace `--site_id` is optional; the version commands
+discover `.creght/state.json` from the current directory or its parents, like
+`pull`/`push` do.
+
+Snapshot the current site source without publishing it:
 
 ```bash
-creght preview --site_id=<project_id>/<site_id>
+creght version create --note="Add pricing page"
 ```
 
-For local development:
+A version records the *remote* files, so local edits that were never pushed
+would be missing from it. `create` therefore compares the workspace against the
+site first and refuses to run while anything is unpushed:
 
-```bash
-CREGHT_API_HOST=http://localhost:8433 creght preview --site_id=<project_id>/<site_id>
+```text
+update /page/Index.tsx
+1 change is not pushed yet and would be missing from this version; run creght
+push first, or pass --allow-dirty to snapshot the remote site as it is
 ```
 
-## Publish Site
+Run `creght push` first, or pass `--allow-dirty` to snapshot the remote site as
+it is. The platform rejects a snapshot identical to the newest version, so
+repeated `create` calls never pile up duplicates.
 
-Publish a site:
+List versions, newest first:
 
 ```bash
-creght publish --site_id=<project_id>/<site_id>
+creght version list
 ```
 
-With a publish note:
+```text
+   VERSION  ID   CREATED           FROM                  NOTE
+   12       456  2026-08-05 14:31  api_generate_version  Add pricing page
+*  11       455  2026-08-05 11:02  publish               Fix nav
+   10       442  2026-08-04 18:40  agent                 -
+* live: version 11 (id 455), served by demo.creght.cn
+pinned: www.example.com -> version 12 (id 456)
+1 change is pending on the site since the newest version; run creght version create to snapshot them
+```
+
+`*` marks the version the live site serves. `VERSION` is the per-site number
+that `version publish` takes; `ID` is the platform-wide version id. Use
+`--limit=<n>` to shorten the list and `--json` to get the raw publish state,
+including every version, the pinned domains, and the exact files that changed
+since the newest version.
+
+Make an existing version live, forward to a newer one or back to an older one:
 
 ```bash
-creght publish --site_id=<project_id>/<site_id> --note="Update homepage copy"
+creght version publish 12
+creght version publish 12 --note="Roll back nav change"
 ```
 
-For local development:
+Every domain follows it except domains pinned to a specific version.
+Publishing the version already being served is a no-op that just refreshes its
+caches.
+
+Publishing a version changes only which snapshot the live site serves — it
+restores nothing. The editable site workspace and your local files are
+untouched, and `creght pull` still fetches the current workspace rather than the
+published version's files. So after rolling production back to an older version,
+the workspace still holds the newer source and the next `publish` would ship it
+again; to revert the code itself, edit locally and push.
+
+`12` is the per-site number from the `VERSION` column. To reach a version older
+than the window `version list` returns, select it by id instead:
 
 ```bash
-CREGHT_API_HOST=http://localhost:8433 creght publish --site_id=<project_id>/<site_id>
+creght version publish id:456
 ```
 
+Bare `creght version` still prints the installed CLI version.
+
 ## Manage CMS Collections
 
 List CMS collections:
@@ -508,8 +499,7 @@ The workflow is the same as for any site file:
 
 1. Run `creght pull --site_id=<project_id>/<site_id> --dir=./mysite`.
 2. Edit or create files under `./mysite/backend/func/`.
-3. Run `creght push --site_id=<project_id>/<site_id> --dir=./mysite`, or keep
-   `creght dev` running.
+3. Run `creght push --site_id=<project_id>/<site_id> --dir=./mysite`.
 
 Examples:
 
@@ -552,7 +542,7 @@ The output matches the Func HTTP response protocol: successful runs print
 top-level `ok` execution wrapper.
 
 There are no `creght func list/get/create/update/delete` commands. Manage Func
-code by editing `backend/func` files and syncing them with pull/push/dev
+code by editing `backend/func` files and syncing them with pull/push
 like any other site file; `func run` only runs sample input.
 
 ## Upload Assets
@@ -603,9 +593,11 @@ Creght, list projects and sites, pull remote site files into a local directory
 with three-way merge, push local files back to Creght, resolve conflicts, open
 the remote preview, and publish a site.
 
+It can also manage site versions: immutable snapshots of a site's source files,
+created and published like git commits.
+
 The CLI commands still use the Creght backend and web app for the canonical
-preview. The Vite plugin is a local development helper and intentionally does
-not implement full production SSR.
+preview. The CLI does not render sites locally.
 
 ```bash
 creght login [--web=https://creght.cn]
@@ -614,7 +606,6 @@ creght project list
 creght pull --site_id=<project_id>/<site_id> --dir=./mysite
 creght push --site_id=<project_id>/<site_id> --dir=./mysite
 creght resolve --list
-creght dev --site_id=<project_id>/<site_id> --dir=./mysite [--web=https://creght.cn]
 creght preview --site_id=<project_id>/<site_id>
 creght publish --site_id=<project_id>/<site_id> [--note=<note>]
 creght cms collections --site_id=<project_id>/<site_id>
@@ -628,6 +619,9 @@ creght table record create --site_id=<project_id>/<site_id> --table=<key> --data
 creght func run --site_id=<project_id>/<site_id> --key=<key.method> --input=./input.json
 creght upload --site_id=<project_id>/<site_id> --file=./image.png
 creght version
+creght version create [--note=<note>] [--allow-dirty]
+creght version list [--limit=<n>] [--json]
+creght version publish <version_no> [--note=<note>]
 ```
 
 Command meanings:
@@ -638,16 +632,15 @@ Command meanings:
 - `pull`: Download site files (including Func code under `backend/func/`) into a local workspace, three-way merging remote and local edits.
 - `push`: Push local workspace changes to the remote site/project after a three-way conflict check.
 - `resolve`: List files with conflict markers, or resolve one by keeping the local (`--ours`) or remote (`--theirs`) side.
-- `dev`: Bidirectionally sync local files with cloud realtime files and the online Web editor.
 - `preview`: Open the remote preview URL for a site in the browser.
-- `publish`: Publish a site to make the current remote site version live.
+- `publish`: Snapshot the current remote site source into a new version and make it live in one step.
 - `cms`: Manage CMS collections.
 - `content`: Manage CMS content entries.
 - `form`: Manage forms and form submissions.
 - `table`: Manage project JSON tables and records used by Func.
-- `func`: Run project Func backend code with sample input. Func code itself is edited as `backend/func` site files and synced with pull/push/dev.
+- `func`: Run project Func backend code with sample input. Func code itself is edited as `backend/func` site files and synced with pull/push.
 - `upload`: Upload a local file as a Creght site asset and print its URL.
-- `version`: Print the installed CLI version.
+- `version`: Print the installed CLI version. Subcommands manage site versions — immutable source snapshots: `version create` records one, `version list` shows them and which is live, `version publish` makes one live.
 
 ## Release
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "creght-cli",
-  "version": "0.7.6",
+  "version": "0.9.0",
   "description": "Creght CLI for syncing local site code with Creght.",
   "license": "MIT",
   "homepage": "https://github.com/creght-dev/creght-cli#readme",
@@ -14,12 +14,6 @@
   "bin": {
     "creght": "bin/creght.js"
   },
-  "exports": {
-    "./vite": {
-      "types": "./vite/index.d.ts",
-      "import": "./vite/index.js"
-    }
-  },
   "scripts": {
     "prepare:npm-binaries": "node scripts/prepare-npm-binaries.js",
     "test:npm": "node scripts/install.js --check"
@@ -27,25 +21,12 @@
   "files": [
     "bin/",
     "scripts/",
-    "vite/",
     "vendor/",
     "README.md"
   ],
   "engines": {
     "node": ">=18"
   },
-  "peerDependencies": {
-    "esbuild": ">=0.20",
-    "vite": ">=5"
-  },
-  "peerDependenciesMeta": {
-    "esbuild": {
-      "optional": true
-    },
-    "vite": {
-      "optional": true
-    }
-  },
   "os": [
     "darwin",
     "linux",

package/vite/import-map.js

@@ -1,55 +0,0 @@
-function mergeExternalDeps(externalValue, requiredDeps) {
-  try {
-    externalValue = decodeURIComponent(externalValue)
-  } catch {
-    // Keep the original value and continue merging invalid encoded external lists.
-  }
-
-  const seen = new Set()
-  const deps = externalValue
-    .split(',')
-    .map((dep) => dep.trim())
-    .filter(Boolean)
-    .filter((dep) => {
-      if (seen.has(dep)) return false
-      seen.add(dep)
-      return true
-    })
-
-  for (const dep of requiredDeps) {
-    if (seen.has(dep)) continue
-    seen.add(dep)
-    deps.push(dep)
-  }
-
-  return deps.join(',')
-}
-
-export function normalizeImportMapExternal(specifier, url) {
-  if (!/^https?:\/\//i.test(url)) return url
-  if (
-    specifier === 'react' ||
-    specifier.startsWith('react/') ||
-    specifier === 'react-dom' ||
-    specifier.startsWith('react-dom/')
-  ) {
-    return url
-  }
-
-  const requiredDeps = ['react', 'react-dom']
-  const hashIndex = url.indexOf('#')
-  const beforeHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url
-  const hash = hashIndex >= 0 ? url.slice(hashIndex) : ''
-  const hasPrefixSlash = specifier.endsWith('/') && beforeHash.endsWith('/')
-  const externalTarget = hasPrefixSlash ? beforeHash.slice(0, -1) : beforeHash
-  const externalSuffix = hasPrefixSlash ? '/' : ''
-  const externalMatch = externalTarget.match(/([?&])external=([^&#]*)/)
-
-  if (externalMatch && externalMatch.index !== undefined) {
-    const start = externalMatch.index + externalMatch[1].length + 'external='.length
-    const end = start + externalMatch[2].length
-    return `${externalTarget.slice(0, start)}${mergeExternalDeps(externalMatch[2], requiredDeps)}${externalTarget.slice(end)}${externalSuffix}${hash}`
-  }
-
-  return `${externalTarget}${hasPrefixSlash || externalTarget.includes('?') ? '&' : '?'}external=${requiredDeps.join(',')}${externalSuffix}${hash}`
-}

package/vite/index.d.ts

@@ -1,28 +0,0 @@
-import type { Plugin } from 'vite'
-
-export type CreghtVitePluginOptions = {
-  /**
-   * Local Creght project root. Defaults to Vite's root.
-   */
-  root?: string
-  /**
-   * Creght API host used by the local /api proxy at runtime.
-   */
-  apiHost?: string
-  /**
-   * Project id for runtime CMS/form requests.
-   */
-  projectId?: string
-  /**
-   * Optional CLI auth token. When set, local /api proxy sends it as Bearer.
-   */
-  token?: string
-  /**
-   * Platform import map entries. `creght dev` fills this from server system info.
-   * Manually configured entries override the built-in fallback when no server map is provided.
-   */
-  importMap?: Record<string, string>
-}
-
-export declare function creght(options?: CreghtVitePluginOptions): Plugin
-export default creght

package/vite/index.js

@@ -1,546 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { transform as esbuildTransform } from 'esbuild'
-import { normalizeImportMapExternal } from './import-map.js'
-
-const modulePrefix = '/@creght/module'
-const assetPrefix = '/@creght/asset'
-const runtimePrefix = '/@creght/runtime'
-const pageExts = ['.tsx', '.ts', '.jsx', '.js']
-const sourceExts = new Set([...pageExts, '.css'])
-
-const fallbackImportMap = {
-  react: 'https://esm.talizen.com/react@19.2.4?dev',
-  'react/': 'https://esm.talizen.com/react@19.2.4&dev/',
-  'react-dom': 'https://esm.talizen.com/react-dom@19.2.4?dev',
-  'react-dom/': 'https://esm.talizen.com/react-dom@19.2.4&dev/',
-  'react-dom/client': 'https://esm.talizen.com/react-dom@19.2.4/client?dev',
-  'class-variance-authority': 'https://esm.talizen.com/class-variance-authority@0.7.1',
-  clsx: 'https://esm.talizen.com/clsx@2.1.1',
-  'tailwind-merge': 'https://esm.talizen.com/tailwind-merge@3.5.0',
-  '@radix-ui/react-slot': 'https://esm.talizen.com/@radix-ui/react-slot@1.2.4',
-  'lucide-react': 'https://esm.talizen.com/lucide-react@0.577.0?dev&external=react,react-dom',
-  motion: 'https://esm.talizen.com/motion@12.38.0?dev',
-  'motion/react': 'https://esm.talizen.com/motion@12.38.0/react?dev&external=react,react-dom',
-  'framer-motion': 'https://esm.talizen.com/framer-motion@12.38.0?dev&external=react,react-dom',
-  three: 'https://esm.talizen.com/three@0.167.1',
-  'three/': 'https://esm.talizen.com/three@0.167.1/',
-  '@react-three/fiber': 'https://esm.talizen.com/@react-three/fiber@9.3.0?external=react,react-dom,three',
-  '@react-three/drei': 'https://esm.talizen.com/@react-three/drei@10.7.4?external=react,react-dom,three,@react-three',
-  talizen: 'https://esm.talizen.com/talizen@0.1.4',
-  'talizen/': 'https://esm.talizen.com/talizen@0.1.4/',
-}
-
-const escapeHtml = (s) => String(s)
-  .replaceAll('&', '&')
-  .replaceAll('<', '&lt;')
-  .replaceAll('>', '&gt;')
-  .replaceAll('"', '&quot;')
-
-const jsonScript = (value) => JSON.stringify(value).replaceAll('<', '\\u003c')
-
-const transformWithEsbuild = (source, filename, options) =>
-  esbuildTransform(source, { ...options, sourcefile: filename })
-
-const isRelativeSpecifier = (specifier) =>
-  specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/')
-
-const contentTypeForPath = (file) => {
-  switch (path.extname(file).toLowerCase()) {
-    case '.css':
-      return 'text/css; charset=utf-8'
-    case '.js':
-    case '.mjs':
-      return 'text/javascript; charset=utf-8'
-    case '.json':
-      return 'application/json; charset=utf-8'
-    case '.svg':
-      return 'image/svg+xml'
-    case '.png':
-      return 'image/png'
-    case '.jpg':
-    case '.jpeg':
-      return 'image/jpeg'
-    case '.gif':
-      return 'image/gif'
-    case '.webp':
-      return 'image/webp'
-    case '.woff':
-      return 'font/woff'
-    case '.woff2':
-      return 'font/woff2'
-    default:
-      return 'application/octet-stream'
-  }
-}
-
-const normalizeProjectPath = (value) => {
-  const out = path.posix.normalize('/' + value.replaceAll(path.sep, '/').replace(/^\/+/, ''))
-  if (out.startsWith('/../')) {
-    throw new Error(`unsafe Creght path: ${value}`)
-  }
-  return out
-}
-
-async function exists(file) {
-  try {
-    await fs.access(file)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function resolveFile(projectRoot, projectPath) {
-  const clean = normalizeProjectPath(projectPath)
-  const abs = path.join(projectRoot, clean.slice(1))
-  if (await exists(abs)) return { projectPath: clean, abs }
-
-  for (const ext of pageExts) {
-    if (await exists(abs + ext)) {
-      return { projectPath: clean + ext, abs: abs + ext }
-    }
-  }
-
-  for (const ext of pageExts) {
-    const indexPath = path.join(abs, 'Index' + ext)
-    if (await exists(indexPath)) {
-      return { projectPath: normalizeProjectPath(path.posix.join(clean, 'Index' + ext)), abs: indexPath }
-    }
-  }
-
-  throw new Error(`Creght module not found: ${projectPath}`)
-}
-
-async function readSiteConfig(projectRoot) {
-  for (const name of ['creght.config.ts', 'creght.config.js', 'talizen.config.ts', 'talizen.config.js', 'folia.config.ts', 'folia.config.js']) {
-    const abs = path.join(projectRoot, name)
-    if (!(await exists(abs))) continue
-
-    try {
-      const source = await fs.readFile(abs, 'utf8')
-      const transformed = await transformWithEsbuild(source, abs, {
-        loader: name.endsWith('.ts') ? 'ts' : 'js',
-        format: 'cjs',
-        target: 'es2020',
-      })
-      const module = { exports: {} }
-      const require = (specifier) => {
-        if (specifier === 'creght' || specifier === 'creght/config' || specifier === 'talizen' || specifier === 'talizen/config') {
-          return { defineConfig: (config) => config }
-        }
-        if (specifier.startsWith('creght/')) return {}
-        if (specifier.startsWith('talizen/')) return {}
-        throw new Error(`[creght.config] unsupported import: ${specifier}`)
-      }
-      const fn = new Function('module', 'exports', 'require', 'defineConfig', transformed.code)
-      fn(module, module.exports, require, (config) => config)
-      const value = module.exports?.default ?? module.exports
-      return value && typeof value === 'object' ? value : {}
-    } catch (err) {
-      console.warn(`[creght vite] failed to evaluate ${name}:`, err)
-      return {}
-    }
-  }
-
-  return {}
-}
-
-async function readIndexCss(projectRoot, config) {
-  if (typeof config.tailwindCss === 'string') return config.tailwindCss
-
-  const cssPath = path.join(projectRoot, 'index.css')
-  if (!(await exists(cssPath))) return ''
-  return fs.readFile(cssPath, 'utf8')
-}
-
-async function buildImportMap(projectRoot, options) {
-  const config = await readSiteConfig(projectRoot)
-  const userImports = config.importMap?.imports || {}
-  const imports = Object.keys(options.importMap || {}).length > 0
-    ? { ...options.importMap }
-    : { ...fallbackImportMap }
-
-  for (const [specifier, url] of Object.entries(userImports)) {
-    imports[specifier] = normalizeImportMapExternal(specifier, String(url))
-  }
-  for (const [specifier, url] of Object.entries(options.importMap || {})) {
-    imports[specifier] = normalizeImportMapExternal(specifier, String(url))
-  }
-
-  return { config, imports }
-}
-
-async function listPages(projectRoot) {
-  const pageRoot = path.join(projectRoot, 'page')
-  if (!(await exists(pageRoot))) return []
-
-  const out = []
-  async function walk(dir) {
-    const entries = await fs.readdir(dir, { withFileTypes: true })
-    for (const entry of entries) {
-      const abs = path.join(dir, entry.name)
-      if (entry.isDirectory()) {
-        await walk(abs)
-        continue
-      }
-      const ext = path.extname(entry.name)
-      if (!pageExts.includes(ext)) continue
-      if (entry.name.includes('.canvas.')) continue
-      const rel = normalizeProjectPath(path.relative(projectRoot, abs))
-      out.push({ file: rel, route: routeFromPagePath(rel) })
-    }
-  }
-  await walk(pageRoot)
-  return out.sort((a, b) => a.route.localeCompare(b.route))
-}
-
-function routeFromPagePath(file) {
-  const withoutExt = file.replace(/^\/page\//, '').replace(/\.[^.]+$/, '')
-  if (withoutExt === 'Index') return '/'
-  return '/' + withoutExt
-    .replace(/\/Index$/, '')
-    .split('/')
-    .map((segment) => segment.startsWith('[') && segment.endsWith(']') ? `:${segment.slice(1, -1)}` : segment.toLowerCase())
-    .join('/')
-}
-
-function matchRoute(routes, pathname) {
-  const normalized = pathname !== '/' ? pathname.replace(/\/+$/, '') : '/'
-  const exact = routes.find((r) => r.route === normalized)
-  if (exact) return { ...exact, params: {} }
-
-  for (const route of routes) {
-    const routeParts = route.route.split('/').filter(Boolean)
-    const pathParts = normalized.split('/').filter(Boolean)
-    if (routeParts.length !== pathParts.length) continue
-    const params = {}
-    let ok = true
-    for (let i = 0; i < routeParts.length; i++) {
-      const part = routeParts[i]
-      if (part.startsWith(':')) {
-        params[part.slice(1)] = decodeURIComponent(pathParts[i])
-        continue
-      }
-      if (part !== pathParts[i].toLowerCase()) {
-        ok = false
-        break
-      }
-    }
-    if (ok) return { ...route, params }
-  }
-
-  return { ...(routes.find((r) => r.route === '/') || routes[0]), params: {} }
-}
-
-function rewriteModuleSpecifiers(code, importerPath) {
-  const rewrite = (specifier) => {
-    if (!isRelativeSpecifier(specifier)) return specifier
-    const [rawPath, rawQuery = ''] = specifier.split('?')
-    const importerDir = path.posix.dirname(importerPath)
-    const resolved = normalizeProjectPath(path.posix.join(importerDir, rawPath))
-    const target = rawQuery ? `${resolved}?${rawQuery}` : resolved
-    return `${modulePrefix}?path=${encodeURIComponent(target)}`
-  }
-
-  return code
-    .replace(/(from\s*["'])([^"']+)(["'])/g, (_, before, specifier, after) => `${before}${rewrite(specifier)}${after}`)
-    .replace(/(import\s*["'])([^"']+)(["'])/g, (_, before, specifier, after) => `${before}${rewrite(specifier)}${after}`)
-    .replace(/(import\s*\(\s*["'])([^"']+)(["']\s*\))/g, (_, before, specifier, after) => `${before}${rewrite(specifier)}${after}`)
-}
-
-async function transformProjectModule(projectRoot, projectPath) {
-  const [pathWithoutQuery, query = ''] = projectPath.split('?')
-  const { projectPath: resolvedProjectPath, abs } = await resolveFile(projectRoot, pathWithoutQuery)
-  const ext = path.extname(abs).toLowerCase()
-
-  if (query === 'raw') {
-    const source = await fs.readFile(abs, 'utf8')
-    return `export default ${JSON.stringify(source)};\n`
-  }
-  if (query === 'url') {
-    return `export default ${JSON.stringify(`${assetPrefix}?path=${encodeURIComponent(resolvedProjectPath)}`)};\n`
-  }
-  if (!sourceExts.has(ext)) {
-    return `export default ${JSON.stringify(`${assetPrefix}?path=${encodeURIComponent(resolvedProjectPath)}`)};\n`
-  }
-
-  const source = await fs.readFile(abs, 'utf8')
-  if (abs.endsWith('.css')) {
-    return `
-const css = ${JSON.stringify(source)};
-let style = document.querySelector('style[data-talizen-css-module="${resolvedProjectPath}"]');
-if (!style) {
-  style = document.createElement('style');
-  style.dataset.talizenCssModule = ${JSON.stringify(resolvedProjectPath)};
-  document.head.appendChild(style);
-}
-style.textContent = css;
-export default css;
-`
-  }
-
-  const loader = abs.endsWith('.tsx') ? 'tsx' : abs.endsWith('.ts') ? 'ts' : abs.endsWith('.jsx') ? 'jsx' : 'js'
-  const result = await transformWithEsbuild(source, abs, {
-    loader,
-    jsx: 'automatic',
-    jsxDev: true,
-    sourcemap: 'inline',
-    target: 'es2020',
-    define: {
-      'process.env.NODE_ENV': '"development"',
-      'process.env.RENDER_ENV': '"design"',
-      'process.env.RENDER_MODE': '"design"',
-    },
-  })
-
-  return rewriteModuleSpecifiers(result.code, resolvedProjectPath)
-}
-
-function renderRuntimeScript(entryFile, params, options) {
-  const projectId = options.projectId || ''
-  const authHeaders = options.token ? { Authorization: `Bearer ${options.token}` } : {}
-
-  return `
-import React from 'react';
-import { createRoot } from 'react-dom/client';
-import { createHotContext } from '/@vite/client';
-
-const creghtRuntimeHeaders = ${jsonScript(authHeaders)};
-const creghtRuntimeFetch = window.fetch.bind(window);
-
-window.TalizenConfig = {
-  baseUrl: window.location.origin + '/api/u/v2/project/' + ${JSON.stringify(projectId)},
-  headers: creghtRuntimeHeaders,
-  fetch(input, init = {}) {
-    const headers = new Headers(init.headers || {});
-    for (const [key, value] of Object.entries(creghtRuntimeHeaders)) {
-      if (!headers.has(key)) headers.set(key, value);
-    }
-    return creghtRuntimeFetch(input, { ...init, headers });
-  },
-};
-
-const rootEl = document.getElementById('root');
-const root = createRoot(rootEl);
-let renderVersion = 0;
-
-async function loadPageModule() {
-  return import(${JSON.stringify(`${modulePrefix}?path=${encodeURIComponent(entryFile)}`)} + '&t=' + Date.now());
-}
-
-async function renderPage() {
-  const version = ++renderVersion;
-  const pageModule = await loadPageModule();
-  if (version !== renderVersion) return;
-
-  const Page = pageModule.default || pageModule.App;
-  let props = {};
-
-  if (!Page) {
-    throw new Error('Creght page has no default export: ${entryFile}');
-  }
-
-  if (typeof pageModule.getServerSideProps === 'function') {
-    const result = await pageModule.getServerSideProps({
-      query: Object.fromEntries(new URLSearchParams(window.location.search)),
-      params: ${jsonScript(params)},
-    });
-    props = result && result.props ? result.props : {};
-  }
-
-  root.render(React.createElement(Page, props));
-}
-
-const hot = createHotContext(${JSON.stringify(`${runtimePrefix}?entry=${encodeURIComponent(entryFile)}`)});
-
-await renderPage();
-
-hot.on('creght:update', () => {
-  renderPage().catch((err) => {
-    console.error('[creght vite] hot update failed', err);
-  });
-});
-`
-}
-
-async function renderHtml(projectRoot, pathname, options) {
-  const routes = await listPages(projectRoot)
-  if (routes.length === 0) {
-    return `<!doctype html><div style="font:14px system-ui;padding:24px">No Creght pages found in <code>/page</code>.</div>`
-  }
-
-  const matched = matchRoute(routes, pathname)
-  const { config, imports } = await buildImportMap(projectRoot, options)
-  const indexCss = await readIndexCss(projectRoot, config)
-  const customCode = config.customCode || {}
-
-  return `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${escapeHtml(matched.route === '/' ? 'Creght' : matched.route)}</title>
-  <script type="importmap">${jsonScript({ imports })}</script>
-  <script type="module" src="/@vite/client"></script>
-  <style type="text/tailwindcss">${indexCss}</style>
-  <script type="module" src="https://esm.talizen.com/@tailwindcss/browser@4"></script>
-  ${customCode.head || ''}
-</head>
-<body>
-  ${customCode.bodyStart || ''}
-  <div id="root"></div>
-  <script type="module" src="${runtimePrefix}?entry=${encodeURIComponent(matched.file)}&params=${encodeURIComponent(JSON.stringify(matched.params))}&t=${Date.now()}"></script>
-  ${customCode.bodyEnd || customCode.body || ''}
-</body>
-</html>`
-}
-
-export function creght(options = {}) {
-  let projectRoot = ''
-  const apiHost = (options.apiHost || 'https://creght.cn').replace(/\/+$/, '')
-
-  return {
-    name: 'creght-local-preview',
-    enforce: 'pre',
-    configResolved(config) {
-      projectRoot = path.resolve(options.root || config.root)
-    },
-    configureServer(server) {
-      const hmrTimers = new Map()
-      const sendCreghtUpdate = (file) => {
-        if (!file.startsWith(projectRoot)) return
-
-        const projectPath = normalizeProjectPath(path.relative(projectRoot, file))
-        const existing = hmrTimers.get(projectPath)
-        if (existing) clearTimeout(existing)
-
-        hmrTimers.set(projectPath, setTimeout(() => {
-          hmrTimers.delete(projectPath)
-          server.ws.send({
-            type: 'custom',
-            event: 'creght:update',
-            data: {
-              file: projectPath,
-              time: Date.now(),
-            },
-          })
-        }, 80))
-      }
-
-      server.watcher.add(path.join(projectRoot, '**/*'))
-      server.watcher.on('change', sendCreghtUpdate)
-      server.watcher.on('add', sendCreghtUpdate)
-      server.watcher.on('unlink', sendCreghtUpdate)
-
-      server.middlewares.use(async (req, res, next) => {
-        try {
-          const url = new URL(req.url || '/', 'http://localhost')
-
-          if (url.pathname.startsWith('/api/')) {
-            const headers = new Headers()
-            for (const [key, value] of Object.entries(req.headers)) {
-              if (Array.isArray(value)) {
-                headers.set(key, value.join(', '))
-              } else if (value != null) {
-                headers.set(key, value)
-              }
-            }
-            headers.set('host', new URL(apiHost).host)
-            if (options.token) {
-              headers.delete('cookie')
-              headers.set('authorization', `Bearer ${options.token}`)
-            }
-
-            const method = req.method || 'GET'
-            const body = method === 'GET' || method === 'HEAD' ? undefined : req
-            const upstream = await fetch(apiHost + url.pathname + url.search, {
-              method,
-              headers,
-              body,
-              // Required by Node fetch when the request body is a stream.
-              duplex: body ? 'half' : undefined,
-            })
-
-            res.statusCode = upstream.status
-            upstream.headers.forEach((value, key) => {
-              const lowerKey = key.toLowerCase()
-              if (lowerKey === 'content-encoding') return
-              if (lowerKey === 'content-length') return
-              if (lowerKey === 'transfer-encoding') return
-              if (lowerKey === 'connection') return
-              res.setHeader(key, value)
-            })
-            const data = Buffer.from(await upstream.arrayBuffer())
-            res.end(data)
-            return
-          }
-
-          if (url.pathname === modulePrefix) {
-            const projectPath = url.searchParams.get('path')
-            if (!projectPath) {
-              res.statusCode = 400
-              res.end('missing path')
-              return
-            }
-            const code = await transformProjectModule(projectRoot, projectPath)
-            res.setHeader('Content-Type', 'text/javascript; charset=utf-8')
-            res.end(code)
-            return
-          }
-
-          if (url.pathname === runtimePrefix) {
-            const entry = url.searchParams.get('entry')
-            const rawParams = url.searchParams.get('params') || '{}'
-            if (!entry) {
-              res.statusCode = 400
-              res.end('missing entry')
-              return
-            }
-            let params = {}
-            try {
-              params = JSON.parse(rawParams)
-            } catch {
-              params = {}
-            }
-            res.setHeader('Content-Type', 'text/javascript; charset=utf-8')
-            res.end(renderRuntimeScript(entry, params, options))
-            return
-          }
-
-          if (url.pathname === assetPrefix) {
-            const projectPath = url.searchParams.get('path')
-            if (!projectPath) {
-              res.statusCode = 400
-              res.end('missing path')
-              return
-            }
-            const { abs } = await resolveFile(projectRoot, projectPath)
-            res.setHeader('Content-Type', contentTypeForPath(abs))
-            res.end(await fs.readFile(abs))
-            return
-          }
-
-          if (req.method !== 'GET') {
-            next()
-            return
-          }
-
-          const accept = req.headers.accept || ''
-          if (!accept.includes('text/html')) {
-            next()
-            return
-          }
-
-          const html = await renderHtml(projectRoot, url.pathname, options)
-          res.setHeader('Content-Type', 'text/html; charset=utf-8')
-          res.end(html)
-        } catch (err) {
-          next(err)
-        }
-      })
-    },
-  }
-}
-
-export default creght

package/vite/index.test.mjs

@@ -1,47 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, it } from 'node:test'
-
-import { normalizeImportMapExternal } from './import-map.js'
-
-describe('normalizeImportMapExternal', () => {
-  it('adds react and react-dom externals to regular import map entries', () => {
-    assert.equal(
-      normalizeImportMapExternal('framer-motion', 'https://esm.talizen.com/framer-motion'),
-      'https://esm.talizen.com/framer-motion?external=react,react-dom',
-    )
-  })
-
-  it('merges missing externals without dropping existing entries', () => {
-    assert.equal(
-      normalizeImportMapExternal(
-        '@react-three/drei',
-        'https://esm.talizen.com/@react-three/drei?external=three,react,@react-three/fiber',
-      ),
-      'https://esm.talizen.com/@react-three/drei?external=three,react,@react-three/fiber,react-dom',
-    )
-  })
-
-  it('inserts externals before the trailing slash for prefix import map entries', () => {
-    assert.equal(
-      normalizeImportMapExternal('talizen/', 'https://esm.talizen.com/talizen@0.1.4/'),
-      'https://esm.talizen.com/talizen@0.1.4&external=react,react-dom/',
-    )
-  })
-
-  it('merges externals before the trailing slash for prefix entries', () => {
-    assert.equal(
-      normalizeImportMapExternal(
-        '@kobalte/core/',
-        'https://esm.talizen.com/@kobalte/core&external=react/',
-      ),
-      'https://esm.talizen.com/@kobalte/core&external=react,react-dom/',
-    )
-  })
-
-  it('does not modify host React runtime specifiers', () => {
-    assert.equal(
-      normalizeImportMapExternal('react-dom/client', 'https://esm.talizen.com/react-dom@19/client?dev'),
-      'https://esm.talizen.com/react-dom@19/client?dev',
-    )
-  })
-})

package/vite/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}