owndesign 0.1.4 → 0.1.8

package/dist/server/index.js

@@ -8037,10 +8037,10 @@ var init_chunkify = __esm({
 // ../../node_modules/.pnpm/trash@10.1.1/node_modules/trash/lib/chunked-exec.js
 import { promisify as promisify2 } from "node:util";
 import { execFile } from "node:child_process";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 async function chunkedExec(binary3, paths, maxPaths) {
   for (const chunk of chunkify(paths, maxPaths)) {
-    await pExecFile(fileURLToPath3(binary3), chunk);
+    await pExecFile(fileURLToPath4(binary3), chunk);
   }
 }
 var pExecFile;
@@ -11133,7 +11133,7 @@ var require_utils6 = __commonJS({
       openSync,
       readSync,
       closeSync,
-      readFileSync: readFileSync2,
+      readFileSync: readFileSync3,
       existsSync: existsSync2
     } = __require("fs");
     var tmpBufMinLen = 4096 * 2;
@@ -11168,7 +11168,7 @@ var require_utils6 = __commonJS({
       }
       return ls;
     };
-    var readBuffer = readFileSync2;
+    var readBuffer = readFileSync3;
     var exists = existsSync2;
     var readdir2 = readdirSync;
     var devIdGetMinor = (devId) => devId >> 20 << 8 | devId & 255;
@@ -56264,10 +56264,7 @@ import { randomUUID } from "node:crypto";
 // ../core/src/settings/model-utils.ts
 var DEEPSEEK_CONTEXT_SIZE_K = 1e3;
 var DEFAULT_OPENAI_COMPATIBLE_CONTEXT_SIZE_K = 200;
-var DEEPSEEK_MODELS = [
-  "deepseek-v4-flash",
-  "deepseek-v4-pro"
-];
+var DEEPSEEK_MODELS = ["deepseek-v4-flash", "deepseek-v4-pro"];
 var DEFAULT_DEEPSEEK_MODEL = DEEPSEEK_MODELS[0];
 
 // ../core/src/settings/settings-service.ts
@@ -56355,12 +56352,8 @@ var SettingsService = class _SettingsService {
   }
   async writeSettings(settings) {
     await mkdir(path.dirname(this.settingsPath), { recursive: true });
-    await writeFile(
-      this.settingsPath,
-      `${JSON.stringify(settings, null, 2)}
-`,
-      "utf8"
-    );
+    await writeFile(this.settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
     try {
       const fileStats = await stat(this.settingsPath);
       _SettingsService.cache.set(this.settingsPath, {
@@ -56399,9 +56392,7 @@ function parseStoredSettings(value) {
   return {
     defaultModelId: typeof value.defaultModelId === "string" ? value.defaultModelId : null,
     interfaceLanguage: parseInterfaceLanguage(value.interfaceLanguage),
-    modelConfigurations: Array.isArray(value.modelConfigurations) ? value.modelConfigurations.map((configuration) => parseStoredModelConfiguration(configuration)).filter(
-      (configuration) => Boolean(configuration)
-    ) : [],
+    modelConfigurations: Array.isArray(value.modelConfigurations) ? value.modelConfigurations.map((configuration) => parseStoredModelConfiguration(configuration)).filter((configuration) => Boolean(configuration)) : [],
     resources: parseStoredResourceSettings(value.resources)
   };
 }
@@ -56486,10 +56477,7 @@ function normalizeSettings(settings) {
       baseUrl: configuration.baseUrl.trim(),
       model: normalizeModelId(configuration.model.trim(), configuration.provider),
       apiKey: configuration.apiKey.trim(),
-      contextSizeK: normalizeContextSizeK(
-        configuration.contextSizeK,
-        configuration.provider
-      ),
+      contextSizeK: normalizeContextSizeK(configuration.contextSizeK, configuration.provider),
       ...providerOptions ? { providerOptions } : {}
     };
   });
@@ -56687,61 +56675,8 @@ function elapsedWallTime(startedAt) {
   return Math.max(0, Math.round((performance.now() - startedAt) * 100) / 100);
 }
 
-// ../core/src/agent/page-edit-mode.ts
-import path3 from "node:path";
-
 // ../core/src/agent/tools/cdn-guard.ts
 import path2 from "node:path";
-async function writeProjectWorkspaceFileWithCdnGuard(workspaceStore, projectId, relativePath, content, approvedCdnUrls = []) {
-  const guardedContent = await guardIndexHtmlCdnChanges(
-    workspaceStore,
-    projectId,
-    relativePath,
-    content,
-    approvedCdnUrls
-  );
-  return workspaceStore.writeProjectWorkspaceFile(
-    projectId,
-    relativePath,
-    guardedContent
-  );
-}
-async function editProjectWorkspaceFileWithCdnGuard(workspaceStore, projectId, relativePath, oldString, newString, replaceAll = false, approvedCdnUrls = []) {
-  const content = await workspaceStore.readProjectWorkspaceFile(
-    projectId,
-    relativePath
-  );
-  const updatedContent = replaceInContent(
-    content,
-    oldString,
-    newString,
-    replaceAll,
-    relativePath
-  );
-  const writeResult = await writeProjectWorkspaceFileWithCdnGuard(
-    workspaceStore,
-    projectId,
-    relativePath,
-    updatedContent,
-    approvedCdnUrls
-  );
-  return {
-    diff: writeResult.diff,
-    path: normalizeToolPath(relativePath),
-    replacements: replaceAll ? countOccurrences(content, normalizeEditNeedle(content, oldString)) : 1
-  };
-}
-async function applyProjectWorkspacePatchWithCdnGuard(workspaceStore, projectId, changes, approvedCdnUrls = []) {
-  return workspaceStore.applyProjectWorkspacePatch(projectId, changes, {
-    transformContent: async (relativePath, content) => guardIndexHtmlCdnChanges(
-      workspaceStore,
-      projectId,
-      relativePath,
-      content,
-      approvedCdnUrls
-    )
-  });
-}
 async function readProjectWorkspaceFileIfExists(workspaceStore, projectId, relativePath) {
   try {
     return await workspaceStore.readProjectWorkspaceFile(projectId, relativePath);
@@ -56752,364 +56687,15 @@ async function readProjectWorkspaceFileIfExists(workspaceStore, projectId, relat
     throw error51;
   }
 }
-function buildCdnTag(input) {
-  const attributes = [
-    'data-owndesign-approved-cdn="true"',
-    input.integrity ? `integrity="${escapeHtmlAttribute(input.integrity)}"` : "",
-    input.crossorigin ? `crossorigin="${escapeHtmlAttribute(input.crossorigin)}"` : ""
-  ].filter(Boolean);
-  const suffix = attributes.length ? ` ${attributes.join(" ")}` : "";
-  const url2 = escapeHtmlAttribute(input.url);
-  if (input.resourceType === "stylesheet") {
-    return `<link rel="stylesheet" href="${url2}"${suffix}>`;
-  }
-  if (input.resourceType === "style-import") {
-    return `<style${suffix}>
-@import url('${url2}');
-</style>`;
-  }
-  return `<script src="${url2}"${suffix}></script>`;
-}
-async function guardIndexHtmlCdnChanges(workspaceStore, projectId, relativePath, content, approvedCdnUrls) {
-  if (!isHtmlPath(relativePath)) {
-    return content;
-  }
-  const normalizedContent = normalizeConfiguredResourceCdnRefs(
-    content,
-    approvedCdnUrls
-  );
-  const approvedUrls = new Set(
-    approvedCdnUrls.map(normalizeHttpsUrl).filter(Boolean)
-  );
-  const unapprovedRefs = extractExternalCdnRefs(normalizedContent).filter(
-    ({ url: url2 }) => !approvedUrls.has(url2)
-  );
-  if (unapprovedRefs.length > 0) {
-    throw new Error(
-      `HTML files can only use CDN resources configured in settings: ${unapprovedRefs.map(({ url: url2 }) => url2).join(", ")}`
-    );
-  }
-  return normalizedContent;
-}
-function replaceInContent(content, oldString, newString, replaceAll, relativePath) {
-  if (!oldString) {
-    throw new Error("oldString must not be empty.");
-  }
-  if (oldString === newString) {
-    throw new Error("No changes to apply: oldString and newString are identical.");
-  }
-  const needle = normalizeEditNeedle(content, oldString);
-  const replacement = convertToLineEnding(newString, detectLineEnding(content));
-  const firstIndex = content.indexOf(needle);
-  if (firstIndex === -1) {
-    throw new Error(`oldString was not found in Project Workspace file: ${relativePath}`);
-  }
-  if (replaceAll) {
-    return content.split(needle).join(replacement);
-  }
-  if (content.indexOf(needle, firstIndex + needle.length) !== -1) {
-    throw new Error(
-      `oldString appears more than once in Project Workspace file: ${relativePath}`
-    );
-  }
-  return content.slice(0, firstIndex) + replacement + content.slice(firstIndex + needle.length);
-}
-function normalizeEditNeedle(content, oldString) {
-  return convertToLineEnding(oldString, detectLineEnding(content));
-}
-function detectLineEnding(text2) {
-  return text2.includes("\r\n") ? "\r\n" : "\n";
-}
-function convertToLineEnding(text2, ending) {
-  const normalized = text2.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
-  return ending === "\n" ? normalized : normalized.replaceAll("\n", "\r\n");
-}
-function countOccurrences(content, needle) {
-  if (!needle) {
-    return 0;
-  }
-  return content.split(needle).length - 1;
-}
-function extractExternalCdnRefs(html) {
-  return extractCdnTags(html).map(({ resourceType, url: url2 }) => ({
-    resourceType,
-    url: url2
-  }));
-}
-function extractCdnTags(html) {
-  const refs = [];
-  for (const match2 of html.matchAll(/<script\b[^>]*>[\s\S]*?<\/script>/gi)) {
-    const tag = match2[0];
-    const src = getHtmlAttribute(tag, "src");
-    if (src && isHttpsUrl(src)) {
-      refs.push({
-        rawUrl: src,
-        resourceType: "script",
-        tag,
-        url: normalizeUrl(src)
-      });
-    }
-  }
-  for (const match2 of html.matchAll(/<link\b[^>]*>/gi)) {
-    const tag = match2[0];
-    const href = getHtmlAttribute(tag, "href");
-    const rel = getHtmlAttribute(tag, "rel");
-    if (href && isHttpsUrl(href) && rel?.toLowerCase().split(/\s+/).includes("stylesheet")) {
-      refs.push({
-        rawUrl: href,
-        resourceType: "stylesheet",
-        tag,
-        url: normalizeUrl(href)
-      });
-    }
-  }
-  for (const match2 of html.matchAll(/<style\b[^>]*>[\s\S]*?<\/style>/gi)) {
-    const tag = match2[0];
-    for (const importMatch of tag.matchAll(
-      /@import\s+(?:url\(\s*)?(?:"([^"]+)"|'([^']+)'|([^"')\s;]+))\s*\)?/gi
-    )) {
-      const url2 = importMatch[1] ?? importMatch[2] ?? importMatch[3];
-      if (url2 && isHttpsUrl(url2)) {
-        refs.push({
-          rawUrl: url2,
-          resourceType: "style-import",
-          tag,
-          url: normalizeUrl(url2)
-        });
-      }
-    }
-  }
-  return refs;
-}
-function normalizeConfiguredResourceCdnRefs(html, approvedCdnUrls) {
-  const approvedUrls = approvedCdnUrls.map(normalizeHttpsUrl).filter((url2) => Boolean(url2));
-  const configuredFontCdn = approvedUrls.find(isGoogleFontsCss2Url);
-  let updatedHtml = html;
-  for (const ref of extractCdnTags(html)) {
-    const replacementUrl = getConfiguredReplacementUrl(ref.url, {
-      configuredFontCdn
-    });
-    if (!replacementUrl || ref.url === replacementUrl) {
-      continue;
-    }
-    if (ref.resourceType === "stylesheet" && configuredFontCdn && ref.url !== configuredFontCdn && isGoogleFontsCss2Url(ref.url)) {
-      updatedHtml = updatedHtml.replace(
-        ref.tag,
-        buildCdnTag({ resourceType: "style-import", url: configuredFontCdn })
-      );
-      continue;
-    }
-    updatedHtml = updatedHtml.split(ref.rawUrl).join(replacementUrl);
-  }
-  return updatedHtml;
-}
-function getConfiguredReplacementUrl(url2, replacements) {
-  if (replacements.configuredFontCdn && isGoogleFontsCss2Url(url2)) {
-    return replacements.configuredFontCdn;
-  }
-  return void 0;
-}
-function isGoogleFontsCss2Url(value) {
-  try {
-    const url2 = new URL(value);
-    return url2.hostname === "fonts.googleapis.com" && url2.pathname === "/css2";
-  } catch {
-    return false;
-  }
-}
-function getHtmlAttribute(tag, name21) {
-  const pattern = new RegExp(
-    `\\s${name21}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`,
-    "i"
-  );
-  const match2 = tag.match(pattern);
-  return match2?.[1] ?? match2?.[2] ?? match2?.[3];
-}
-function isHttpsUrl(value) {
-  try {
-    return new URL(value).protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-function normalizeUrl(value) {
-  return new URL(value).href;
-}
 function isHtmlPath(relativePath) {
   return normalizeToolPath(relativePath).toLowerCase().endsWith(".html");
 }
 function normalizeToolPath(relativePath) {
   return path2.posix.normalize(relativePath.replaceAll("\\", "/"));
 }
-function normalizeHttpsUrl(value) {
-  try {
-    const url2 = new URL(value);
-    return url2.protocol === "https:" ? url2.href : void 0;
-  } catch {
-    return void 0;
-  }
-}
 function isMissingPathError2(error51) {
   return error51 instanceof Error && "code" in error51 && error51.code === "ENOENT";
 }
-function escapeHtmlAttribute(value) {
-  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-
-// ../core/src/agent/page-edit-mode.ts
-var PAGE_EDIT_MODES = [
-  "auto",
-  "new_page",
-  "direct_edit",
-  "duplicate_edit"
-];
-function parsePageEditMode(value) {
-  if (value === void 0 || value === null || value === "") {
-    return "auto";
-  }
-  return PAGE_EDIT_MODES.includes(value) ? value : void 0;
-}
-async function buildPageEditModePolicy({
-  currentPreviewPath,
-  mode = "auto",
-  projectId,
-  workspaceStore
-}) {
-  if (mode === "auto") {
-    return { mode };
-  }
-  if (mode === "new_page") {
-    return {
-      currentPreviewPath: currentPreviewPath ? normalizeRequiredHtmlPath(currentPreviewPath, mode) : void 0,
-      mode
-    };
-  }
-  const sourcePath = normalizeRequiredHtmlPath(currentPreviewPath, mode);
-  await readRequiredHtmlFile(workspaceStore, projectId, sourcePath, mode);
-  if (mode === "direct_edit") {
-    return {
-      mode,
-      targetPath: sourcePath
-    };
-  }
-  const targetPath = await resolveUniqueCopyPath(
-    workspaceStore,
-    projectId,
-    sourcePath
-  );
-  return {
-    mode,
-    sourcePath,
-    targetPath
-  };
-}
-function assertCreateHtmlAllowed(policy, relativePath) {
-  assertHtmlPathOperationAllowed(policy, "create", relativePath);
-}
-function markCreatedHtmlPath(policy, relativePath) {
-  if (policy?.mode === "new_page") {
-    policy.createdHtmlPath = normalizeToolPath(relativePath);
-  }
-}
-function assertCopyFileAllowed(policy, sourcePath, targetPath) {
-  if (!policy || policy.mode !== "duplicate_edit") {
-    return;
-  }
-  const normalizedSourcePath = normalizeToolPath(sourcePath);
-  const normalizedTargetPath = normalizeToolPath(targetPath);
-  if (normalizedSourcePath !== policy.sourcePath || normalizedTargetPath !== policy.targetPath) {
-    throw new Error(
-      `Page edit mode "duplicate_edit" can only copy ${policy.sourcePath} to ${policy.targetPath}; attempted ${normalizedSourcePath} to ${normalizedTargetPath}.`
-    );
-  }
-}
-function resolveHtmlOperationPathForPageEditModePolicy(policy, operation, relativePath) {
-  if (!policy || policy.mode === "auto") {
-    return relativePath;
-  }
-  const targetPath = normalizeToolPath(relativePath);
-  if (!isHtmlPath(targetPath)) {
-    return relativePath;
-  }
-  assertHtmlPathOperationAllowed(policy, operation, targetPath);
-  return targetPath;
-}
-function assertHtmlPathOperationAllowed(policy, operation, relativePath) {
-  if (!policy || policy.mode !== "duplicate_edit") {
-    return;
-  }
-  const targetPath = normalizeToolPath(relativePath);
-  if (!isHtmlPath(targetPath)) {
-    return;
-  }
-  if (operation === "read") {
-    return;
-  }
-  if (operation === "copy" && targetPath === policy.targetPath) {
-    return;
-  }
-  if (targetPath !== policy.targetPath) {
-    throw new Error(
-      `Page edit mode "duplicate_edit" can only ${formatHtmlOperation(operation)} ${policy.targetPath}; attempted ${targetPath}.`
-    );
-  }
-}
-function formatHtmlOperation(operation) {
-  switch (operation) {
-    case "copy":
-      return "copy";
-    case "create":
-      return "create";
-    case "delete":
-      return "delete";
-    case "mutate":
-      return "edit";
-    case "preview":
-      return "preview";
-    case "read":
-      return "read";
-  }
-}
-function normalizeRequiredHtmlPath(relativePath, mode) {
-  if (!relativePath) {
-    throw new Error(`Page edit mode "${mode}" requires a current preview page.`);
-  }
-  const normalizedPath = normalizeToolPath(relativePath);
-  if (!isHtmlPath(normalizedPath)) {
-    throw new Error(
-      `Page edit mode "${mode}" requires an HTML preview page: ${normalizedPath}`
-    );
-  }
-  return normalizedPath;
-}
-async function readRequiredHtmlFile(workspaceStore, projectId, relativePath, mode) {
-  try {
-    return await workspaceStore.readProjectWorkspaceFile(projectId, relativePath);
-  } catch {
-    throw new Error(
-      `Page edit mode "${mode}" requires an existing current preview page: ${relativePath}`
-    );
-  }
-}
-async function resolveUniqueCopyPath(workspaceStore, projectId, sourcePath) {
-  const parsed = path3.posix.parse(sourcePath);
-  const directory = parsed.dir ? `${parsed.dir}/` : "";
-  const baseName = normalizeCopyBaseName(parsed.name);
-  const extension = parsed.ext || ".html";
-  for (let index = 1; index < 1e3; index += 1) {
-    const suffix = index === 1 ? "copy" : `copy-${index}`;
-    const candidatePath = `${directory}${baseName}.${suffix}${extension}`;
-    try {
-      await workspaceStore.readProjectWorkspaceFile(projectId, candidatePath);
-    } catch {
-      return candidatePath;
-    }
-  }
-  throw new Error(`Could not create a unique copy path for ${sourcePath}.`);
-}
-function normalizeCopyBaseName(baseName) {
-  return baseName.replace(/\.copy(?:-\d+)?$/, "");
-}
 
 // ../core/src/agent/tools/copy-file.ts
 function createCopyFileToolDefinition() {
@@ -57117,67 +56703,84 @@ function createCopyFileToolDefinition() {
     description: "Copy one UTF-8 text file inside the current Project Workspace to a new path. Never overwrites existing files.",
     inputSchema: external_exports.object({
       sourcePath: external_exports.string().describe("Relative source file path inside the Project Workspace."),
-      targetPath: external_exports.string().describe("Relative destination file path inside the Project Workspace. Must not already exist.")
+      targetPath: external_exports.string().describe(
+        "Relative destination file path inside the Project Workspace. Must not already exist."
+      )
     }).strict(),
     name: "copyFile",
     parallelSafe: false,
-    execute: async ({ sourcePath, targetPath }, { approvedCdnUrls, pageEditModePolicy, projectId, workspaceStore }) => {
+    execute: async ({ sourcePath, targetPath }, { projectId, workspaceStore }) => {
       const normalizedSourcePath = normalizeToolPath(sourcePath);
       const normalizedTargetPath = normalizeToolPath(targetPath);
-      assertCopyFileAllowed(
-        pageEditModePolicy,
-        normalizedSourcePath,
-        normalizedTargetPath
-      );
       const existingTarget = await readProjectWorkspaceFileIfExists(
         workspaceStore,
         projectId,
         normalizedTargetPath
       );
       if (existingTarget !== void 0) {
-        throw new Error(
-          `Project Workspace file already exists: ${normalizedTargetPath}`
-        );
+        throw new Error(`Project Workspace file already exists: ${normalizedTargetPath}`);
       }
       const sourceContent = await workspaceStore.readProjectWorkspaceFile(
         projectId,
         normalizedSourcePath
       );
-      return writeProjectWorkspaceFileWithCdnGuard(
-        workspaceStore,
-        projectId,
-        normalizedTargetPath,
-        sourceContent,
-        approvedCdnUrls
-      );
+      return workspaceStore.writeProjectWorkspaceFile(projectId, normalizedTargetPath, sourceContent);
     }
   };
 }
 
+// ../core/src/templates/index.ts
+import { readFileSync } from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+var TEMPLATE_FILES = {
+  "html/page-shell": "html/page-shell.html"
+};
+function loadTemplate(name21) {
+  const templateFile = TEMPLATE_FILES[name21];
+  if (!templateFile) {
+    throw new Error(`Unsupported template: ${String(name21)}`);
+  }
+  const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+  const candidatePaths = [
+    path3.join(currentDir, "templates", templateFile),
+    path3.join(currentDir, templateFile)
+  ];
+  for (const candidatePath of candidatePaths) {
+    try {
+      return readFileSync(candidatePath, "utf8").trim();
+    } catch (error51) {
+      if (!isNotFoundError(error51)) {
+        throw error51;
+      }
+    }
+  }
+  throw new Error(`Template "${name21}" was not found. Searched: ${candidatePaths.join(", ")}`);
+}
+function isNotFoundError(error51) {
+  return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
+}
+
 // ../core/src/agent/tools/create-html.ts
 var DEFAULT_TITLE = "OwnDesign Preview";
+var SINGLE_HTML_PATH = "index.html";
 function createCreateHtmlToolDefinition() {
   return {
-    description: "Create a new previewable HTML file from the configured resource template before designing a missing target HTML page. Never overwrites existing files.",
+    description: "Create the single previewable index.html file from the configured template before designing a missing Single HTML project. Never overwrites existing files.",
     inputSchema: external_exports.object({
-      fontLibraryName: external_exports.string().describe("Optional configured font library name. Omit to use the default font library. Pass an empty string to disable font resources.").optional(),
-      iconLibraryName: external_exports.string().describe("Optional configured icon library name. Omit to use the default icon library. Pass an empty string to disable icon resources.").optional(),
-      path: external_exports.string().describe("Relative HTML file path inside the Project Workspace, such as index.html or pages/detail.html."),
+      path: external_exports.string().describe("Relative HTML file path inside the Project Workspace. Must be index.html."),
       title: external_exports.string().describe("Optional document title. Defaults to OwnDesign Preview.").optional()
     }).strict(),
     name: "createHtml",
     parallelSafe: false,
-    execute: async (input, {
-      pageEditModePolicy,
-      projectId,
-      resources,
-      workspaceStore
-    }) => {
+    execute: async (input, { projectId, workspaceStore }) => {
       const targetPath = normalizeToolPath(input.path);
-      assertCreateHtmlAllowed(pageEditModePolicy, targetPath);
       if (!isHtmlPath(targetPath)) {
         throw new Error(`HTML initialization target must end with .html: ${targetPath}`);
       }
+      if (targetPath !== SINGLE_HTML_PATH) {
+        throw new Error(`Single HTML projects can only create ${SINGLE_HTML_PATH}: ${targetPath}`);
+      }
       const existingHtml = await readProjectWorkspaceFileIfExists(
         workspaceStore,
         projectId,
@@ -57186,94 +56789,28 @@ function createCreateHtmlToolDefinition() {
       if (existingHtml !== void 0) {
         throw new Error(`Project Workspace HTML file already exists: ${targetPath}`);
       }
-      const fontLibrary = selectLibrary(
-        resources.fontLibraries,
-        input.fontLibraryName,
-        "font"
-      );
-      const iconLibrary = selectLibrary(
-        resources.iconLibraries,
-        input.iconLibraryName,
-        "icon"
+      const title = input.title?.trim() || DEFAULT_TITLE;
+      await workspaceStore.writeProjectWorkspaceFile(
+        projectId,
+        targetPath,
+        buildSingleHtmlTemplate({ title })
       );
-      const html = buildHtmlTemplate({
-        fontLibrary,
-        iconLibrary,
-        title: input.title?.trim() || DEFAULT_TITLE
-      });
-      await workspaceStore.writeProjectWorkspaceFile(projectId, targetPath, html);
-      markCreatedHtmlPath(pageEditModePolicy, targetPath);
       return {
-        fontLibrary: formatSelectedLibrary(fontLibrary),
-        iconLibrary: formatSelectedLibrary(iconLibrary),
         path: targetPath,
-        title: input.title?.trim() || DEFAULT_TITLE
+        title
       };
     }
   };
 }
-function selectLibrary(libraries, name21, kind) {
-  if (name21 === "") {
-    return void 0;
-  }
-  if (name21 !== void 0) {
-    const library = libraries.find((item) => item.name === name21);
-    if (!library) {
-      throw new Error(`Configured ${kind} library was not found: ${name21}`);
-    }
-    return library;
-  }
-  return libraries.find((library) => library.isDefault) ?? libraries[0];
-}
-function buildHtmlTemplate({
-  fontLibrary,
-  iconLibrary,
-  title
-}) {
-  const headTags = [
-    fontLibrary?.cdn ? buildCdnTag({ resourceType: "style-import", url: fontLibrary.cdn }) : "",
-    iconLibrary?.cdn && inferIconLibraryResourceType(iconLibrary.cdn) === "stylesheet" ? buildCdnTag({ resourceType: "stylesheet", url: iconLibrary.cdn }) : ""
-  ].filter(Boolean);
-  const bodyScripts = [
-    iconLibrary?.cdn && inferIconLibraryResourceType(iconLibrary.cdn) === "script" ? buildCdnTag({ resourceType: "script", url: iconLibrary.cdn }) : "",
-    isLucideLibrary(iconLibrary) ? "  <script>window.lucide?.createIcons?.();</script>" : ""
-  ].filter(Boolean);
-  return [
-    "<!doctype html>",
-    '<html lang="zh-CN">',
-    "<head>",
-    '  <meta charset="utf-8">',
-    '  <meta name="viewport" content="width=device-width, initial-scale=1">',
-    `  <title>${escapeHtmlText(title)}</title>`,
-    ...headTags.map((tag) => indentMultiline(tag, "  ")),
-    "</head>",
-    "<body>",
-    '  <main id="app"></main>',
-    ...bodyScripts.map((tag) => indentMultiline(tag, "  ")),
-    "</body>",
-    "</html>",
-    ""
-  ].join("\n");
-}
-function inferIconLibraryResourceType(cdn) {
-  const normalized = cdn.toLowerCase();
-  return normalized.includes(".css") || normalized.includes("/css/") || normalized.includes("font-awesome") ? "stylesheet" : "script";
-}
-function isLucideLibrary(library) {
-  if (!library?.cdn) {
-    return false;
-  }
-  const value = `${library.name} ${library.cdn}`.toLowerCase();
-  return value.includes("lucide");
-}
-function formatSelectedLibrary(library) {
-  return library ? {
-    cdn: library.cdn,
-    name: library.name
-  } : void 0;
+function buildSingleHtmlTemplate({ title }) {
+  return renderTemplate(loadTemplate("html/page-shell"), {
+    lang: "zh-CN",
+    title: escapeHtmlText(title)
+  });
 }
-function indentMultiline(value, indent) {
-  return value.split("\n").map((line) => `${indent}${line}`).join("\n");
+function renderTemplate(template, values) {
+  return `${template.replace(/\{\{([a-zA-Z0-9]+)\}\}/g, (_match, key) => values[key] ?? "")}
+`;
 }
 function escapeHtmlText(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
@@ -57288,14 +56825,7 @@ function createDeleteToolDefinition() {
     }).strict(),
     name: "delete",
     parallelSafe: false,
-    execute: async ({ path: path16 }, {
-      pageEditModePolicy,
-      projectId,
-      workspaceStore
-    }) => {
-      assertHtmlPathOperationAllowed(pageEditModePolicy, "delete", path16);
-      return workspaceStore.deleteProjectWorkspacePath(projectId, path16);
-    }
+    execute: async ({ path: path16 }, { projectId, workspaceStore }) => workspaceStore.deleteProjectWorkspacePath(projectId, path16)
   };
 }
 
@@ -57311,27 +56841,7 @@ function createEditToolDefinition() {
     }).strict(),
     name: "edit",
     parallelSafe: false,
-    execute: async ({ newString, oldString, path: path16, replaceAll }, {
-      approvedCdnUrls,
-      pageEditModePolicy,
-      projectId,
-      workspaceStore
-    }) => {
-      const editPath = resolveHtmlOperationPathForPageEditModePolicy(
-        pageEditModePolicy,
-        "mutate",
-        path16
-      );
-      return editProjectWorkspaceFileWithCdnGuard(
-        workspaceStore,
-        projectId,
-        editPath,
-        oldString,
-        newString,
-        replaceAll,
-        approvedCdnUrls
-      );
-    }
+    execute: async ({ newString, oldString, path: path16, replaceAll }, { projectId, workspaceStore }) => workspaceStore.editProjectWorkspaceFile(projectId, path16, oldString, newString, replaceAll)
   };
 }
 
@@ -57345,15 +56855,8 @@ function createGlobToolDefinition() {
     }).strict(),
     name: "glob",
     parallelSafe: true,
-    execute: async ({ path: path16, pattern }, {
-      projectId,
-      workspaceStore
-    }) => {
-      return workspaceStore.globProjectWorkspace(
-        projectId,
-        pattern,
-        path16
-      );
+    execute: async ({ path: path16, pattern }, { projectId, workspaceStore }) => {
+      return workspaceStore.globProjectWorkspace(projectId, pattern, path16);
     }
   };
 }
@@ -57364,15 +56867,14 @@ function createGrepToolDefinition() {
     description: "Search UTF-8 text files in the current Project Workspace using a JavaScript regular expression.",
     inputSchema: external_exports.object({
       include: external_exports.string().describe('Optional file glob to include, such as "*.html" or "**/*.{css,js}".').optional(),
-      path: external_exports.string().describe("Optional relative file or directory path inside the Project Workspace to search.").optional(),
+      path: external_exports.string().describe(
+        "Optional relative file or directory path inside the Project Workspace to search."
+      ).optional(),
       pattern: external_exports.string().describe("JavaScript regular expression pattern to search for.")
     }).strict(),
     name: "grep",
     parallelSafe: true,
-    execute: async ({ include, path: path16, pattern }, {
-      projectId,
-      workspaceStore
-    }) => {
+    execute: async ({ include, path: path16, pattern }, { projectId, workspaceStore }) => {
       return workspaceStore.grepProjectWorkspace(projectId, pattern, {
         include,
         path: path16
@@ -57386,48 +56888,35 @@ function createPatchToolDefinition() {
   return {
     description: "Apply coordinated UTF-8 file changes inside the current Project Workspace. Supports add/write, edit, and delete changes.",
     inputSchema: external_exports.object({
-      changes: external_exports.array(external_exports.discriminatedUnion("operation", [
-        external_exports.object({
-          content: external_exports.string().describe("Complete file content for add operations."),
-          operation: external_exports.literal("add"),
-          path: external_exports.string().describe("Relative file or directory path inside the Project Workspace.")
-        }).strict(),
-        external_exports.object({
-          content: external_exports.string().describe("Complete file content for write operations."),
-          operation: external_exports.literal("write"),
-          path: external_exports.string().describe("Relative file or directory path inside the Project Workspace.")
-        }).strict(),
-        external_exports.object({
-          newString: external_exports.string().describe("Replacement text for edit operations."),
-          oldString: external_exports.string().describe("Text to replace for edit operations."),
-          operation: external_exports.literal("edit"),
-          path: external_exports.string().describe("Relative file or directory path inside the Project Workspace."),
-          replaceAll: external_exports.boolean().describe("For edit operations, replace every occurrence of oldString.").optional()
-        }).strict(),
-        external_exports.object({
-          operation: external_exports.literal("delete"),
-          path: external_exports.string().describe("Relative file or directory path inside the Project Workspace.")
-        }).strict()
-      ])).min(1)
+      changes: external_exports.array(
+        external_exports.discriminatedUnion("operation", [
+          external_exports.object({
+            content: external_exports.string().describe("Complete file content for add operations."),
+            operation: external_exports.literal("add"),
+            path: external_exports.string().describe("Relative file or directory path inside the Project Workspace.")
+          }).strict(),
+          external_exports.object({
+            content: external_exports.string().describe("Complete file content for write operations."),
+            operation: external_exports.literal("write"),
+            path: external_exports.string().describe("Relative file or directory path inside the Project Workspace.")
+          }).strict(),
+          external_exports.object({
+            newString: external_exports.string().describe("Replacement text for edit operations."),
+            oldString: external_exports.string().describe("Text to replace for edit operations."),
+            operation: external_exports.literal("edit"),
+            path: external_exports.string().describe("Relative file or directory path inside the Project Workspace."),
+            replaceAll: external_exports.boolean().describe("For edit operations, replace every occurrence of oldString.").optional()
+          }).strict(),
+          external_exports.object({
+            operation: external_exports.literal("delete"),
+            path: external_exports.string().describe("Relative file or directory path inside the Project Workspace.")
+          }).strict()
+        ])
+      ).min(1)
     }).strict(),
     name: "patch",
     parallelSafe: false,
-    execute: async ({ changes }, { approvedCdnUrls, pageEditModePolicy, projectId, workspaceStore }) => {
-      const resolvedChanges = changes.map((change) => ({
-        ...change,
-        path: resolveHtmlOperationPathForPageEditModePolicy(
-          pageEditModePolicy,
-          change.operation === "delete" ? "delete" : "mutate",
-          change.path
-        )
-      }));
-      return applyProjectWorkspacePatchWithCdnGuard(
-        workspaceStore,
-        projectId,
-        resolvedChanges,
-        approvedCdnUrls
-      );
-    }
+    execute: async ({ changes }, { projectId, workspaceStore }) => workspaceStore.applyProjectWorkspacePatch(projectId, changes)
   };
 }
 
@@ -57435,11 +56924,7 @@ function createPatchToolDefinition() {
 var KEEPALIVE_INTERVAL_MS = 15e3;
 var FrontendCommandBus = class {
   connections = /* @__PURE__ */ new Map();
-  registerConnection({
-    frontendTabId,
-    projectId,
-    signal
-  }) {
+  registerConnection({ frontendTabId, projectId, signal }) {
     const key = buildConnectionKey(projectId, frontendTabId);
     const encoder = new TextEncoder();
     let connection;
@@ -57476,9 +56961,7 @@ var FrontendCommandBus = class {
     payload,
     projectId
   }) {
-    const connection = this.connections.get(
-      buildConnectionKey(projectId, frontendTabId)
-    );
+    const connection = this.connections.get(buildConnectionKey(projectId, frontendTabId));
     if (!connection) {
       return {
         delivered: false,
@@ -57490,12 +56973,7 @@ var FrontendCommandBus = class {
       id: createCommandId(),
       payload
     };
-    enqueueSseEvent(
-      connection.controller,
-      connection.encoder,
-      "frontend-command",
-      command
-    );
+    enqueueSseEvent(connection.controller, connection.encoder, "frontend-command", command);
     return {
       command,
       delivered: true
@@ -57535,12 +57013,10 @@ function sendFrontendCommand(input) {
   return getFrontendCommandBus().sendCommand(input);
 }
 function enqueueSseEvent(controller, encoder, event, data) {
-  controller.enqueue(
-    encoder.encode(`event: ${event}
+  controller.enqueue(encoder.encode(`event: ${event}
 data: ${JSON.stringify(data)}
 
-`)
-  );
+`));
 }
 function enqueueSseComment(controller, encoder, comment) {
   controller.enqueue(encoder.encode(`: ${comment}
@@ -57585,76 +57061,24 @@ function createPreviewRefreshToolDefinition() {
   };
 }
 
-// ../core/src/agent/tools/preview-switch-html.ts
-function createPreviewSwitchHtmlToolDefinition() {
-  return {
-    description: "Switch the Preview Pane to an existing HTML file after successful previewable HTML changes.",
-    inputSchema: external_exports.object({
-      path: external_exports.string().describe("Relative HTML file path inside the Project Workspace to show in the Preview Pane.")
-    }).strict(),
-    name: "previewSwitchHtml",
-    parallelSafe: false,
-    execute: async ({ path: path16 }, context2) => {
-      if (!context2.frontendTabId) {
-        throw new Error("Frontend tab id is required to switch the preview.");
-      }
-      const targetPath = normalizeToolPath(path16);
-      if (!targetPath || targetPath === ".") {
-        throw new Error("Preview switch target path must not be empty.");
-      }
-      if (!isHtmlPath(targetPath)) {
-        throw new Error(`Preview switch target must end with .html: ${targetPath}`);
-      }
-      const previewPath = resolveHtmlOperationPathForPageEditModePolicy(
-        context2.pageEditModePolicy,
-        "preview",
-        targetPath
-      );
-      const htmlFiles = await context2.workspaceStore.listProjectHtmlFiles(
-        context2.projectId
-      );
-      if (!htmlFiles.includes(previewPath)) {
-        throw new Error(`Project Workspace HTML file was not found: ${previewPath}`);
-      }
-      const payload = { path: previewPath };
-      const result = sendFrontendCommand({
-        capability: "preview.switchHtml",
-        frontendTabId: context2.frontendTabId,
-        payload,
-        projectId: context2.projectId
-      });
-      return {
-        capability: "preview.switchHtml",
-        delivered: result?.delivered ?? false,
-        payload
-      };
-    }
-  };
-}
-
 // ../core/src/agent/tools/read.ts
 function createReadToolDefinition() {
   return {
     description: "Read one UTF-8 file or directory from the current Project Workspace. Files are returned with 1-indexed line numbers.",
     inputSchema: external_exports.object({
       limit: external_exports.number().describe("Maximum number of lines or directory entries to read. Defaults to 2000.").optional(),
-      offset: external_exports.number().describe("1-indexed line or directory-entry offset to start reading from. Defaults to 1.").optional(),
+      offset: external_exports.number().describe(
+        "1-indexed line or directory-entry offset to start reading from. Defaults to 1."
+      ).optional(),
       path: external_exports.string().describe("Relative file or directory path inside the Project Workspace.")
     }).strict(),
     name: "read",
     parallelSafe: true,
-    execute: async ({ limit, offset, path: path16 }, {
-      projectId,
-      workspaceStore
-    }) => {
-      return workspaceStore.readProjectWorkspaceEntry(
-        projectId,
-        path16,
-        {
-          limit,
-          offset
-        }
-      );
+    execute: async ({ limit, offset, path: path16 }, { projectId, workspaceStore }) => {
+      return workspaceStore.readProjectWorkspaceEntry(projectId, path16, {
+        limit,
+        offset
+      });
     }
   };
 }
@@ -57669,25 +57093,7 @@ function createWriteToolDefinition() {
     }).strict(),
     name: "write",
     parallelSafe: false,
-    execute: async ({ content, path: path16 }, {
-      approvedCdnUrls,
-      pageEditModePolicy,
-      projectId,
-      workspaceStore
-    }) => {
-      const writePath = resolveHtmlOperationPathForPageEditModePolicy(
-        pageEditModePolicy,
-        "mutate",
-        path16
-      );
-      return writeProjectWorkspaceFileWithCdnGuard(
-        workspaceStore,
-        projectId,
-        writePath,
-        content,
-        approvedCdnUrls
-      );
-    }
+    execute: async ({ content, path: path16 }, { projectId, workspaceStore }) => workspaceStore.writeProjectWorkspaceFile(projectId, path16, content)
   };
 }
 
@@ -57702,50 +57108,41 @@ function createProjectWorkspaceToolDefinitions() {
     createGrepToolDefinition(),
     createPatchToolDefinition(),
     createPreviewRefreshToolDefinition(),
-    createPreviewSwitchHtmlToolDefinition(),
     createReadToolDefinition(),
     createWriteToolDefinition()
   ];
 }
-function createProjectWorkspaceTools(context2) {
-  return createWorkspaceToolRegistry(
-    createProjectWorkspaceToolDefinitions(),
-    context2
-  );
-}
 
 // ../core/src/prompts/index.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import path4 from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var PROMPT_FILES = {
-  "agents/design-page": "agents/design-page.md",
-  "agents/turn-prompt-rewriter": "agents/turn-prompt-rewriter.md"
+  "agents/component-audit": "agents/component-audit.md",
+  "agents/design-page": "agents/design-page.md"
 };
 function loadPrompt(name21) {
   const promptFile = PROMPT_FILES[name21];
   if (!promptFile) {
     throw new Error(`Unsupported prompt: ${String(name21)}`);
   }
-  const currentDir = path4.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path4.dirname(fileURLToPath2(import.meta.url));
   const candidatePaths = [
     path4.join(currentDir, "prompts", promptFile),
     path4.join(currentDir, promptFile)
   ];
   for (const candidatePath of candidatePaths) {
     try {
-      return readFileSync(candidatePath, "utf8").trim();
+      return readFileSync2(candidatePath, "utf8").trim();
     } catch (error51) {
-      if (!isNotFoundError(error51)) {
+      if (!isNotFoundError2(error51)) {
         throw error51;
       }
     }
   }
-  throw new Error(
-    `Prompt "${name21}" was not found. Searched: ${candidatePaths.join(", ")}`
-  );
+  throw new Error(`Prompt "${name21}" was not found. Searched: ${candidatePaths.join(", ")}`);
 }
-function isNotFoundError(error51) {
+function isNotFoundError2(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
 }
 
@@ -57758,40 +57155,20 @@ var FRONTEND_CAPABILITIES = {
       properties: {},
       additionalProperties: false
     }
-  },
-  "preview.switchHtml": {
-    description: "Switch the Preview Pane to an existing HTML file.",
-    payloadSchema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "Relative HTML file path inside the Project Workspace to show in the Preview Pane."
-        }
-      },
-      required: ["path"],
-      additionalProperties: false
-    }
   }
 };
-var FRONTEND_CAPABILITY_IDS = Object.keys(
-  FRONTEND_CAPABILITIES
-);
+var FRONTEND_CAPABILITY_IDS = Object.keys(FRONTEND_CAPABILITIES);
 function buildFrontendCapabilityPrompt() {
   return [
     "## Frontend Capabilities",
     "Use preview tools only to notify the browser UI after Project Workspace file changes are complete. They do not create, edit, or validate files.",
-    "After successful previewable HTML changes, call exactly one preview tool before the final user-facing summary.",
+    "After successful previewable HTML changes, call exactly one `previewRefresh` before the final user-facing summary.",
     "Do not call a preview tool when no previewable HTML file changed or the file operation failed.",
-    "Use the current user request to decide which preview tool is needed:",
-    "- Use `previewSwitchHtml` only when the Preview Pane should move to a different existing relative `.html` file inside the Project Workspace.",
-    "- Use `previewRefresh` when the Preview Pane is already showing the correct page and only needs to reload changed HTML.",
+    "Use `previewRefresh` when `index.html` changed and should reload.",
     "Do not use workspace file tools to simulate preview switching or refreshing.",
     "Available capabilities:",
     ...FRONTEND_CAPABILITY_IDS.map((capability) => {
-      const schema = JSON.stringify(
-        FRONTEND_CAPABILITIES[capability].payloadSchema
-      );
+      const schema = JSON.stringify(FRONTEND_CAPABILITIES[capability].payloadSchema);
       return `- ${capability}: ${FRONTEND_CAPABILITIES[capability].description} Payload schema: ${schema}`;
     })
   ].join("\n");
@@ -57805,11 +57182,12 @@ var AiSdkDesignPageAgent = class {
   }
   workspaceStore;
   async generateProjectOutput(input) {
-    if (input.outputType !== "html") {
-      throw new Error(`Unsupported Project Output Type: ${input.outputType}`);
+    const projectType = normalizeProjectType(input.projectType, input.outputType);
+    if (projectType !== "single_html") {
+      throw new Error(`Unsupported Project Type: ${projectType}`);
     }
     const context2 = await createDesignPageAgentContext({
-      outputType: input.outputType,
+      projectType,
       projectId: input.projectId,
       workspaceStore: this.workspaceStore
     });
@@ -57827,36 +57205,27 @@ async function createDesignPageAgentContext({
   frontendTabId,
   modelConfigurationId,
   outputType,
-  pageEditMode = "auto",
+  projectType,
   projectId,
   providerOptionsSelection,
+  settingsPath,
   workspaceStore
 }) {
-  if (outputType !== "html") {
-    throw new Error(`Unsupported Project Output Type: ${outputType}`);
+  projectType = normalizeProjectType(projectType, outputType);
+  if (projectType !== "single_html") {
+    throw new Error(`Unsupported Project Type: ${projectType}`);
   }
-  const settingsService = createSettingsService();
+  const settingsService = createSettingsService({ settingsPath });
   const [settings, modelConfiguration] = await Promise.all([
     settingsService.getSettings(),
     settingsService.resolveModelConfiguration(modelConfigurationId)
   ]);
-  const pageEditModePolicy = await buildPageEditModePolicy({
-    currentPreviewPath,
-    mode: pageEditMode,
-    projectId,
-    workspaceStore
-  });
   return {
     currentPreviewPath,
     frontendTabId,
     model: buildLanguageModel(modelConfiguration),
-    outputType,
-    pageEditMode,
-    pageEditModePolicy,
-    providerOptions: buildProviderOptions(
-      modelConfiguration,
-      providerOptionsSelection
-    ),
+    projectType,
+    providerOptions: buildProviderOptions(modelConfiguration, providerOptionsSelection),
     projectId,
     resources: settings.resources,
     workspaceStore
@@ -57868,30 +57237,25 @@ function createDesignPageAgent(context2) {
     allowSystemInMessages: true,
     model,
     instructions: agentInstructions ?? buildDesignPageInstructions(context2),
+    maxRetries: 5,
     providerOptions,
     stopWhen: stepCountIs(50),
     tools: createDesignPageWorkspaceTools(context2)
   });
 }
-function createDesignPageWorkspaceTools({
-  projectId,
-  resources,
-  workspaceStore,
-  frontendTabId,
-  pageEditModePolicy
-}) {
-  return createProjectWorkspaceTools({
+function createDesignPageWorkspaceTools(context2) {
+  const { frontendTabId, projectId, resources, workspaceStore } = context2;
+  return createWorkspaceToolRegistry(createProjectWorkspaceToolDefinitions(), {
     approvedCdnUrls: buildApprovedCdnUrls(resources),
     frontendTabId,
-    pageEditModePolicy,
+    model: context2.model,
     projectId,
+    providerOptions: context2.providerOptions,
     resources,
     workspaceStore
   });
 }
-function buildDesignPageInstructions({
-  resources
-}) {
+function buildDesignPageInstructions({ resources }) {
   return buildDesignPageConversationInstructions(resources);
 }
 function buildLanguageModel(configuration) {
@@ -57943,6 +57307,15 @@ function buildProviderOptions(configuration, selection) {
     }
   };
 }
+function normalizeProjectType(projectType, outputType) {
+  if (projectType) {
+    return projectType;
+  }
+  if (outputType === "html") {
+    return "single_html";
+  }
+  return "single_html";
+}
 function buildDesignPageConversationInstructions(resources) {
   const sections = [
     {
@@ -57983,58 +57356,56 @@ function loadDesignPageAgentCorePrompt() {
 }
 function buildPageTargetProtocolPrompt() {
   return [
-    "## Page Target Protocol",
-    "",
-    "Resolve the target HTML page before creating or updating previewable output.",
+    "## Single HTML Target Protocol",
     "",
-    "Target resolution:",
-    "- All previewable pages must be relative workspace paths ending in `.html`.",
-    "- If the user names a file, path, or page type, use that explicit target.",
-    "- Each turn's user message has already been rewritten with the current preview page and page edit mode when those matter.",
-    '- If the user uses a relative page reference such as "this page", "current page", "here", "top", or "bottom", use the target page stated in the current user message when available.',
-    "- If the user asks for a home, main, landing, or first page, use `index.html`.",
-    "- If the user asks for a new named page, choose a semantic filename such as `login.html`, `settings.html`, or `pages/detail.html`.",
-    "- If no target is specified and no multi-page structure is evident, default to `index.html`.",
-    "- If multiple HTML files exist, no current preview page is available, and the target remains ambiguous after inspection, ask one concise follow-up question.",
-    "- Do not ask a follow-up question just because the request is brief; act when the target can be resolved from the current user message, an explicit filename, or the `index.html` default.",
+    "The project has one previewable file: `index.html`.",
     "",
-    "- Do not overwrite `index.html` for a new page unless the user intent points to the home or main page."
+    "Rules:",
+    "- Always target `index.html` for previewable output.",
+    "- Do not create `login.html`, `detail.html`, versioned HTML files, or any other HTML page.",
+    "- If the user asks for multiple pages, screens, or routes, implement them as internal views inside `index.html`.",
+    "- Use ordinary HTML, CSS, and browser JavaScript in the file.",
+    "- Do not create custom elements, component module folders, or page/component reuse metadata files.",
+    '- If `index.html` is missing, call `createHtml({ path: "index.html" })` before editing.',
+    "- If `index.html` exists, read it before editing and continue from the current design."
   ].join("\n");
 }
 function buildToolWorkflowPrompt() {
   return [
     "## Tool Workflow",
-    "Use the narrowest reliable tool for each task; inspect before writing, recover before retrying.",
+    "Use the narrowest reliable tool for each task.",
     "",
-    "Inspect before changing files:",
+    "Inspect before editing:",
     "- Use `glob` to discover files.",
     "- Use `grep` to locate relevant code or markup.",
-    "- Use `read` before editing any existing target file.",
-    "- Always inspect before coordinated edits across existing files.",
+    "- Use `read` before editing an existing file.",
     "",
-    "Choose the write tool by intent:",
+    "Choose tools by intent:",
+    "- Use `createHtml` only to create a missing `index.html` file.",
     "- Use `edit` for small, focused replacements in one existing file.",
     "- Use `patch` for coordinated changes, repeated replacements, or multi-file edits.",
-    "- Use `write` only for non-HTML files or deliberate full-file overwrites; never use it to create initial HTML pages.",
-    "- Do not use `write` for ordinary HTML page edits. Use it for HTML only when the user explicitly asks to rebuild the whole file.",
-    "- Use `delete` only after using `grep` or direct inspection to confirm the file is no longer referenced by any page or build target.",
-    "- Use `copyFile` when the current user message asks you to duplicate an existing file before editing the duplicate.",
+    "- Use `write` only for deliberate full-file replacement or non-preview support files.",
+    "- Do not use `write` to create the initial `index.html`; use `createHtml` first.",
+    "- Use `copyFile` only when the current user message explicitly asks you to duplicate an existing file.",
+    "- Use `delete` only after confirming the file is not referenced.",
     "",
-    "For HTML pages:",
-    "- Do not modify unrelated HTML files unless the requested change requires coordinated edits.",
-    "- Use `createHtml` when the target HTML file does not exist; do not create initial HTML with `write`.",
-    "- For `createHtml`, pass the resolved target path. Pass `fontLibraryName` or `iconLibraryName` only when the user explicitly names a font or icon library; otherwise omit them so the tool reads configured defaults.",
-    "- After `createHtml`, immediately use `read` on that file before editing it.",
-    "- If the target HTML file exists, use `read` before editing it; do not call `createHtml`.",
-    "- Use `edit` or `patch` for HTML changes after reading the file.",
+    "For Single HTML creation:",
+    '- Call `createHtml({ path: "index.html" })` when `index.html` is missing.',
+    "- After `createHtml`, read `index.html`.",
+    "- Replace the default placeholder markup, CSS, and script with a complete designed prototype.",
     "",
-    "Recover from tool failures:",
-    "- If `edit` cannot find the expected text, `read` the file again and retry with a smaller replacement or `patch`.",
-    "- If a write tool returns an error or produces unexpected output, read the file again before retrying.",
+    "For Single HTML updates:",
+    "- If `index.html` exists, read it before editing and do not call `createHtml`.",
+    "- Keep visible page structure, styling, and local interactions in `index.html`.",
+    "- Use internal views for multi-screen workflows instead of additional HTML files.",
     "",
-    "Resource constraints:",
-    "- Only use CDNs already listed in resource settings; do not add others.",
-    "- `write`, `edit`, and `patch` will reject HTML with unlisted CDN tags - if rejected, fall back to configured libraries, system fonts, inline SVG, or local CSS."
+    "After page changes:",
+    "- Use `previewRefresh` when the current preview page changed and should reload.",
+    "- Call exactly one `previewRefresh` after successful previewable changes.",
+    "",
+    "Recover from tool failures:",
+    "- If an edit fails, read the file again and retry with a smaller edit or patch.",
+    "- If a generated prototype becomes too large or brittle, simplify the file while preserving visible quality."
   ].join("\n");
 }
 function buildResourcePolicyPrompt(resources) {
@@ -58047,17 +57418,22 @@ function buildResourcePolicyPrompt(resources) {
     "Use these global resource settings when designing HTML preview pages.",
     defaultFontLibrary ? `Default font library: ${defaultFontLibrary.name}.` : "Default font library: none configured.",
     defaultIconLibrary ? `Default icon library: ${defaultIconLibrary.name}.` : "Default icon library: none configured.",
-    "If the user prompt explicitly names a configured font or icon library, use that named library; otherwise use the default library.",
-    "Only use configured font libraries or system fonts. Do not reference any unconfigured external font service or font CDN.",
-    "Prefer configured icon libraries for icons. Use inline SVG only when no icon library is configured or when the configured libraries cannot provide a suitable icon.",
-    "Do not reference any unconfigured external icon service or icon CDN.",
-    "When a configured library has no CDN, follow the library choice in CSS naming only and do not add a CDN tag for it.",
+    "The default HTML template already configures Inter and Noto Sans SC on the `html` element.",
+    "Unless the user explicitly asks for a different typeface, do not change `font-family`; adjust typography with size, weight, line-height, spacing, and hierarchy.",
+    "Lucide icons are already configured by the default HTML template.",
+    'Use Lucide icons with `<i data-lucide="menu"></i>` syntax, replacing `menu` with the appropriate Lucide icon name.',
+    "Do not use other icon systems, inline SVG icons, emoji icons, or decorative emoji as UI icons.",
+    "When styling Lucide icons, do not target `i`, `i[data-lucide]`, or tag selectors because Lucide replaces the placeholder with inline `svg` elements.",
+    "Give icons a semantic class or wrap them in a classed element, then style the class and child `svg`, such as `.nav-icon svg { width: 18px; height: 18px; stroke-width: 2; }`.",
+    "If JavaScript dynamically inserts markup that contains Lucide placeholders, call `lucide.createIcons()` after updating the DOM.",
+    "Prefer configured resources and local CSS before adding any external resource.",
+    "Add an extra external resource only when the user explicitly requests it or when it is necessary for the prototype quality.",
+    "When a configured library has no CDN, follow the library choice in CSS naming only.",
     "Configured font libraries:",
     fontLines.length ? fontLines.join("\n") : "- none",
     "Configured icon libraries:",
     iconLines.length ? iconLines.join("\n") : "- none",
-    "Use regular inline CSS as the primary styling method.",
-    "Do not add new CDN resources. If a needed resource is not configured, use system fonts, inline SVG, local CSS, or explain the limitation."
+    "Use regular inline CSS as the primary styling method."
   ].join("\n");
 }
 function buildApprovedCdnUrls(resources) {
@@ -58075,75 +57451,6 @@ function formatResourceLibraryList(libraries) {
   );
 }
 
-// ../core/src/agent/turn-prompt-rewriter.ts
-async function rewriteTurnPrompt({
-  model,
-  originalUserPrompt,
-  pageEditMode,
-  pageEditModePolicy,
-  previewPath,
-  providerOptions
-}) {
-  const result = await generateText({
-    model,
-    providerOptions,
-    system: buildTurnPromptRewriterSystemPrompt(),
-    prompt: buildTurnPromptRewriterPrompt({
-      originalUserPrompt,
-      pageEditMode,
-      pageEditModePolicy,
-      previewPath
-    })
-  });
-  const rewrittenPrompt = cleanRewrittenPrompt(result.text);
-  if (!rewrittenPrompt) {
-    throw new Error("TurnPromptRewriter returned an empty prompt.");
-  }
-  return { rewrittenPrompt };
-}
-function buildTurnPromptRewriterSystemPrompt() {
-  return loadPrompt("agents/turn-prompt-rewriter");
-}
-function buildTurnPromptRewriterPrompt({
-  originalUserPrompt,
-  pageEditMode,
-  pageEditModePolicy,
-  previewPath
-}) {
-  return [
-    `currentPreviewFile: ${previewPath ?? "none"}`,
-    `pageEditMode: ${pageEditMode}`,
-    formatPolicyLine(pageEditModePolicy),
-    "",
-    "Rewrite rules:",
-    "- Keep the user's requested change unchanged in meaning.",
-    "- Make the target page/action explicit when the edit mode provides one.",
-    "- For duplicate_edit, tell the agent to use copyFile to copy the source page to the target page, then modify only the target HTML page.",
-    "- For duplicate_edit, allow inspection of other files but forbid modifying any HTML page except the target page.",
-    "- For new_page, tell the agent to create a new page, but do not forbid related edits such as navigation links.",
-    "- For direct_edit, tell the agent to edit the current preview page directly.",
-    "",
-    "Original user request:",
-    originalUserPrompt
-  ].join("\n");
-}
-function formatPolicyLine(policy) {
-  if (policy.mode === "duplicate_edit") {
-    return `duplicateSourcePath: ${policy.sourcePath}
-duplicateTargetPath: ${policy.targetPath}`;
-  }
-  if (policy.mode === "direct_edit") {
-    return `targetPath: ${policy.targetPath}`;
-  }
-  if (policy.mode === "new_page") {
-    return `currentPreviewFile: ${policy.currentPreviewPath ?? "none"}`;
-  }
-  return "targetPath: none";
-}
-function cleanRewrittenPrompt(text2) {
-  return text2.trim().replace(/^```(?:text)?\s*/i, "").replace(/\s*```$/i, "").trim();
-}
-
 // ../core/src/preview/preview-server-manager.ts
 import { access, readFile as readFile2 } from "node:fs/promises";
 import path5 from "node:path";
@@ -58167,9 +57474,13 @@ var PreviewServerManager = class {
   }
   async ensure(projectId, clientId, previewPath) {
     const entry = await this.getOrStartEntry(projectId, clientId);
-    const files = await this.workspaceStore.listProjectHtmlFiles(projectId);
+    const [files, pageManifest] = await Promise.all([
+      this.workspaceStore.listProjectHtmlFiles(projectId),
+      this.workspaceStore.readProjectHtmlPageManifest(projectId)
+    ]);
     const activePath = resolveActivePreviewPath(
       files,
+      pageManifest,
       previewPath ?? entry.activePath
     );
     entry.activePath = activePath;
@@ -58178,6 +57489,7 @@ var PreviewServerManager = class {
     return {
       ...activePath ? { activePath } : {},
       files,
+      pageManifest,
       url: buildPreviewUrl(entry.baseUrl, activePath)
     };
   }
@@ -58211,9 +57523,7 @@ var PreviewServerManager = class {
     return this.entries.size;
   }
   getLeaseCount(projectId) {
-    return Array.from(this.entries.values()).filter(
-      (entry) => entry.projectId === projectId
-    ).length;
+    return Array.from(this.entries.values()).filter((entry) => entry.projectId === projectId).length;
   }
   async cleanupExpiredLeases() {
     const now2 = this.now();
@@ -58253,24 +57563,21 @@ var PreviewServerManager = class {
       key,
       projectId
     };
-    app2.get(
-      "/",
-      async () => htmlResponse(await readIndexHtmlOrEmptyPreview(workspaceDirectory, entry))
-    );
-    app2.get(
-      "/index.html",
-      async () => htmlResponse(await readIndexHtmlOrEmptyPreview(workspaceDirectory, entry))
-    );
+    app2.get("/", async () => readIndexHtmlOrNotFound(workspaceDirectory, entry));
+    app2.get("/index.html", async () => readIndexHtmlOrNotFound(workspaceDirectory, entry));
     app2.use("*", async (context2, next) => {
       context2.header("Cache-Control", PREVIEW_CACHE_CONTROL);
       await next();
     });
-    app2.use("*", serveStatic({
-      onFound: (filePath) => {
-        recordServedStaticPath(entry, workspaceDirectory, filePath);
-      },
-      root: workspaceDirectory
-    }));
+    app2.use(
+      "*",
+      serveStatic({
+        onFound: (filePath) => {
+          recordServedStaticPath(entry, workspaceDirectory, filePath);
+        },
+        root: workspaceDirectory
+      })
+    );
     const server2 = await listenOnRandomPort(app2);
     entry.server = server2.server;
     entry.baseUrl = server2.baseUrl;
@@ -58349,123 +57656,32 @@ function getPreviewServerManager(workspaceStore) {
   });
   return globalThis.__owndesignPreviewServerManager;
 }
-async function readIndexHtmlOrEmptyPreview(workspaceDirectory, entry) {
+async function readIndexHtmlOrNotFound(workspaceDirectory, entry) {
   const indexPath = path5.join(workspaceDirectory, "index.html");
   try {
     await access(indexPath);
     entry.activePath = "index.html";
-    return readFile2(indexPath, "utf8");
+    return htmlResponse(await readFile2(indexPath, "utf8"));
   } catch {
-    return buildEmptyPreviewHtml();
-  }
-}
-function buildEmptyPreviewHtml() {
-  return `<!doctype html>
-<html lang="zh-CN">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>OwnDesign Preview</title>
-  <style>
-    :root {
-      color-scheme: dark;
-      --bg-base: #0a0a0b;
-      --bg-surface: #141416;
-      --bg-elevated: #1c1c1f;
-      --border-color: #2a2a2e;
-      --border-light: #38383d;
-      --text-primary: #f0f0f2;
-      --text-secondary: #a0a0ab;
-      --text-tertiary: #6b6b76;
-      --shadow-lg: 0 18px 48px rgba(0, 0, 0, 0.45);
-    }
-    * {
-      box-sizing: border-box;
-    }
-    html {
-      height: 100%;
-      background: var(--bg-base);
-    }
-    body {
-      margin: 0;
-      min-height: 100vh;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-      padding: 24px;
-      background:
-        radial-gradient(circle at top, rgba(255,255,255,0.04), transparent 34%),
-        var(--bg-base);
-      color: var(--text-primary);
-      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Noto Sans SC", sans-serif;
-    }
-    main {
-      width: min(100%, 28rem);
-      padding: 2rem;
-      border: 1px solid var(--border-color);
-      border-radius: 24px;
-      background: var(--bg-surface);
-      text-align: center;
-      box-shadow: var(--shadow-lg);
-    }
-    .icon {
-      width: 56px;
-      height: 56px;
-      margin: 0 auto;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-      border-radius: 18px;
-      border: 1px solid var(--border-light);
-      background: var(--bg-elevated);
-      color: var(--text-secondary);
-      box-shadow: inset 0 1px 0 rgba(255,255,255,0.03);
-    }
-    .badge {
-      margin-top: 20px;
-      color: var(--text-tertiary);
-      font-size: 11px;
-      font-weight: 600;
-      letter-spacing: 0.24em;
-      text-transform: uppercase;
-    }
-    h1 {
-      margin: 8px 0 0;
-      color: var(--text-primary);
-      font-size: 1.125rem;
-      font-weight: 600;
-      letter-spacing: -0.02em;
-    }
-    p {
-      margin: 10px auto 0;
-      max-width: 22rem;
-      color: var(--text-secondary);
-      font-size: 14px;
-      line-height: 1.7;
-    }
-  </style>
-</head>
-<body>
-  <main>
-    <div class="icon" aria-hidden="true">
-      <svg viewBox="0 0 24 24" width="24" height="24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">
-        <path d="M4 7.5A2.5 2.5 0 0 1 6.5 5H10l2 2h5.5A2.5 2.5 0 0 1 20 9.5v7A2.5 2.5 0 0 1 17.5 19h-11A2.5 2.5 0 0 1 4 16.5z" />
-      </svg>
-    </div>
-    <div class="badge">Preview</div>
-    <h1>\u7B49\u5F85\u751F\u6210 HTML</h1>
-    <p>\u5728\u5DE6\u4FA7\u8F93\u5165\u201C\u8BBE\u8BA1\u4E00\u4E2A XXX \u7684\u754C\u9762\u201D\uFF0C\u751F\u6210\u7ED3\u679C\u4F1A\u663E\u793A\u5728\u8FD9\u91CC\u3002</p>
-  </main>
-</body>
-</html>`;
-}
-function resolveActivePreviewPath(files, previewPath) {
+    return new Response(null, {
+      headers: {
+        "Cache-Control": PREVIEW_CACHE_CONTROL
+      },
+      status: 404
+    });
+  }
+}
+function resolveActivePreviewPath(files, pageManifest, previewPath) {
   if (previewPath && files.includes(previewPath)) {
     return previewPath;
   }
   if (files.includes("index.html")) {
     return "index.html";
   }
+  const manifestPath = pageManifest.pages.find((page) => files.includes(page.htmlPath))?.htmlPath;
+  if (manifestPath) {
+    return manifestPath;
+  }
   return files[0];
 }
 function buildPreviewUrl(baseUrl, previewPath) {
@@ -58493,11 +57709,7 @@ function recordServedStaticPath(entry, workspaceDirectory, servedPath) {
 }
 
 // ../core/src/navigation.ts
-function buildWorkspaceHref({
-  conversationId,
-  previewPath,
-  projectId
-}) {
+function buildWorkspaceHref({ conversationId, previewPath, projectId }) {
   if (!projectId) {
     return "/";
   }
@@ -58548,11 +57760,7 @@ var ConversationService = class {
       titleManuallySet: true,
       updatedAt: this.now()
     };
-    return this.workspaceStore.updateConversation(
-      projectId,
-      conversationId,
-      updatedConversation
-    );
+    return this.workspaceStore.updateConversation(projectId, conversationId, updatedConversation);
   }
   async switchConversation(projectId, conversationId) {
     return this.workspaceStore.getConversation(projectId, conversationId);
@@ -58571,7 +57779,7 @@ var ConversationService = class {
     };
     const agentResult = await this.generateProjectOutputSafely({
       content,
-      outputType: project.outputType,
+      projectType: project.projectType ?? "single_html",
       projectId
     });
     const mockReply = {
@@ -58579,11 +57787,7 @@ var ConversationService = class {
       content: agentResult.content,
       createdAt: timestamp
     };
-    const messages = [
-      ...existingConversation.messages,
-      userMessage,
-      mockReply
-    ];
+    const messages = [...existingConversation.messages, userMessage, mockReply];
     const updatedConversation = {
       ...existingConversation,
       title: !existingConversation.titleManuallySet && existingConversation.title === DEFAULT_CONVERSATION_TITLE && existingConversation.messages.length === 0 ? summarizeConversationTitle(content) : existingConversation.title,
@@ -58596,11 +57800,7 @@ var ConversationService = class {
       updatedAt: timestamp
     };
     await this.workspaceStore.updateProject(projectId, updatedProject);
-    return this.workspaceStore.updateConversation(
-      projectId,
-      conversationId,
-      updatedConversation
-    );
+    return this.workspaceStore.updateConversation(projectId, conversationId, updatedConversation);
   }
   async saveUIMessageStream(projectId, conversationId, messages) {
     const existingConversation = await this.workspaceStore.getConversation(
@@ -58622,22 +57822,13 @@ var ConversationService = class {
       updatedAt: timestamp
     };
     await this.workspaceStore.updateProject(projectId, updatedProject);
-    return this.workspaceStore.updateConversation(
-      projectId,
-      conversationId,
-      updatedConversation
-    );
+    return this.workspaceStore.updateConversation(projectId, conversationId, updatedConversation);
   }
   async deleteConversation(projectId, conversationId, defaultTitle) {
     await this.workspaceStore.deleteConversation(projectId, conversationId);
-    let remainingConversations = await this.workspaceStore.listConversations(
-      projectId
-    );
+    let remainingConversations = await this.workspaceStore.listConversations(projectId);
     if (remainingConversations.length === 0) {
-      const replacementConversation = await this.createConversation(
-        projectId,
-        defaultTitle
-      );
+      const replacementConversation = await this.createConversation(projectId, defaultTitle);
       remainingConversations = [replacementConversation];
     }
     return remainingConversations;
@@ -58676,11 +57867,16 @@ var ProjectService = class {
     this.previewServerManager = options.previewServerManager;
   }
   async createProject(input) {
+    const projectType = input.projectType ?? "single_html";
+    if (projectType === "react") {
+      throw new Error("React project type is reserved but not supported yet.");
+    }
     const timestamp = this.now();
     const project = {
       id: this.createId(),
       name: input.name,
       description: input.description,
+      projectType,
       outputType: "html",
       createdAt: timestamp,
       updatedAt: timestamp
@@ -58694,6 +57890,11 @@ var ProjectService = class {
       messages: []
     };
     await this.workspaceStore.createProject(project);
+    await this.workspaceStore.writeProjectWorkspaceFile(
+      project.id,
+      "index.html",
+      buildSingleHtmlTemplate({ title: input.name })
+    );
     await this.workspaceStore.createConversation(conversation);
     return { conversation, project };
   }
@@ -58720,15 +57921,7 @@ var ProjectService = class {
 };
 
 // ../core/src/workspace-store/store.ts
-import {
-  lstat,
-  mkdir as mkdir2,
-  readdir,
-  readFile as readFile4,
-  rm,
-  stat as stat3,
-  writeFile as writeFile2
-} from "node:fs/promises";
+import { copyFile, lstat, mkdir as mkdir2, readdir, readFile as readFile4, rm, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
 import os5 from "node:os";
 import path13 from "node:path";
 import process12 from "node:process";
@@ -58744,7 +57937,7 @@ function normalizePositiveInteger(value, fallback, name21) {
   }
   return value;
 }
-function countOccurrences2(content, needle) {
+function countOccurrences(content, needle) {
   if (!needle) {
     return 0;
   }
@@ -58757,27 +57950,25 @@ function applyTextEdit(content, oldText, newText, replaceAll = false, relativePa
   if (oldText === newText) {
     throw new Error("No changes to apply: oldText and newText are identical.");
   }
-  const normalizedOldText = convertToLineEnding2(oldText, detectLineEnding2(content));
-  const normalizedNewText = convertToLineEnding2(newText, detectLineEnding2(content));
+  const normalizedOldText = convertToLineEnding(oldText, detectLineEnding(content));
+  const normalizedNewText = convertToLineEnding(newText, detectLineEnding(content));
   const firstIndex = content.indexOf(normalizedOldText);
   if (firstIndex === -1) {
     throw new Error(`oldText was not found in Project Workspace file: ${relativePath}`);
   }
-  const replacements = countOccurrences2(content, normalizedOldText);
+  const replacements = countOccurrences(content, normalizedOldText);
   if (!replaceAll && replacements > 1) {
-    throw new Error(
-      `oldText appears more than once in Project Workspace file: ${relativePath}`
-    );
+    throw new Error(`oldText appears more than once in Project Workspace file: ${relativePath}`);
   }
   return {
     content: replaceAll ? content.split(normalizedOldText).join(normalizedNewText) : content.slice(0, firstIndex) + normalizedNewText + content.slice(firstIndex + normalizedOldText.length),
     replacements: replaceAll ? replacements : 1
   };
 }
-function detectLineEnding2(text2) {
+function detectLineEnding(text2) {
   return text2.includes("\r\n") ? "\r\n" : "\n";
 }
-function convertToLineEnding2(text2, ending) {
+function convertToLineEnding(text2, ending) {
   const normalized = text2.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
   return ending === "\n" ? normalized : normalized.replaceAll("\n", "\r\n");
 }
@@ -58832,6 +58023,39 @@ function buildUnifiedDiff(oldContent, newContent, relativePath) {
   return lines.join("\n");
 }
 
+// ../core/src/html-page-manifest.ts
+var HTML_PAGE_MANIFEST_PATH = ".owndesign-pages.json";
+var EMPTY_HTML_PAGE_MANIFEST = {
+  pages: []
+};
+function parseHtmlPageManifest(content) {
+  if (!content) {
+    return EMPTY_HTML_PAGE_MANIFEST;
+  }
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch {
+    return EMPTY_HTML_PAGE_MANIFEST;
+  }
+  if (!isRecord2(value) || !Array.isArray(value.pages)) {
+    return EMPTY_HTML_PAGE_MANIFEST;
+  }
+  const pages = value.pages.filter(isRecord2).map((page) => ({
+    componentSource: typeof page.componentSource === "string" ? page.componentSource.trim() : "",
+    componentTag: typeof page.componentTag === "string" ? page.componentTag.trim() : "",
+    displayName: typeof page.displayName === "string" ? page.displayName.trim() : "",
+    htmlPath: typeof page.htmlPath === "string" ? page.htmlPath.trim() : "",
+    slug: typeof page.slug === "string" ? page.slug.trim() : ""
+  })).filter(
+    (page) => page.slug && page.displayName && page.htmlPath && page.componentTag && page.componentSource
+  );
+  return { pages };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
 // ../core/src/workspace-store/files.ts
 import { open, readFile as readFile3, stat as stat2 } from "node:fs/promises";
 
@@ -59153,10 +58377,10 @@ var isSymlinkSync = isTypeSync.bind(void 0, "lstatSync", "isSymbolicLink");
 // ../../node_modules/.pnpm/unicorn-magic@0.3.0/node_modules/unicorn-magic/node.js
 import { promisify } from "node:util";
 import { execFile as execFileCallback, execFileSync as execFileSyncOriginal } from "node:child_process";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 var execFileOriginal = promisify(execFileCallback);
 function toPath(urlOrPath) {
-  return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+  return urlOrPath instanceof URL ? fileURLToPath3(urlOrPath) : urlOrPath;
 }
 var TEN_MEGABYTES_IN_BYTES = 10 * 1024 * 1024;
 
@@ -59543,14 +58767,7 @@ if ($item.PSIsContainer) {
 `;
   await execFileAsync(
     "powershell.exe",
-    [
-      "-NoProfile",
-      "-NonInteractive",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-Command",
-      recycleScript
-    ],
+    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", recycleScript],
     {
       env: {
         ...process11.env,
@@ -59604,7 +58821,7 @@ var WorkspaceStore = class {
             path13.join(projectsRoot, entry.name, "project.json"),
             "utf8"
           );
-          return JSON.parse(projectJson);
+          return normalizeProjectRecord(JSON.parse(projectJson));
         })
       );
       return projects.sort(
@@ -59622,7 +58839,7 @@ var WorkspaceStore = class {
       path13.join(this.getProjectDirectory(projectId), "project.json"),
       "utf8"
     );
-    return JSON.parse(projectJson);
+    return normalizeProjectRecord(JSON.parse(projectJson));
   }
   async updateProject(projectId, project) {
     await writeFile2(
@@ -59685,6 +58902,70 @@ var WorkspaceStore = class {
     );
     return conversation;
   }
+  async createCheckpoint(input) {
+    assertSafeCheckpointId(input.id);
+    const record2 = {
+      ...input,
+      files: ["index.html"]
+    };
+    const checkpointDirectory = this.getCheckpointDirectory(input.projectId, input.id);
+    const filesDirectory = path13.join(checkpointDirectory, "files");
+    const sourceFilePath = await this.resolveProjectWorkspacePath(input.projectId, "index.html", {
+      checkTargetSymlink: true
+    });
+    await mkdir2(filesDirectory, { recursive: true });
+    await copyFile(sourceFilePath, path13.join(filesDirectory, "index.html"));
+    await writeFile2(
+      path13.join(checkpointDirectory, "meta.json"),
+      `${JSON.stringify(record2, null, 2)}
+`,
+      "utf8"
+    );
+    return record2;
+  }
+  async listCheckpoints(projectId) {
+    const checkpointsDirectory = this.getCheckpointsDirectory(projectId);
+    try {
+      const entries = await readdir(checkpointsDirectory, { withFileTypes: true });
+      const checkpoints = await Promise.all(
+        entries.filter((entry) => entry.isDirectory()).map(async (entry) => this.readCheckpoint(projectId, entry.name))
+      );
+      return checkpoints.sort(
+        (left, right) => new Date(right.createdAt).getTime() - new Date(left.createdAt).getTime()
+      );
+    } catch (error51) {
+      if (isMissingPathError3(error51)) {
+        return [];
+      }
+      throw error51;
+    }
+  }
+  async readCheckpoint(projectId, checkpointId) {
+    assertSafeCheckpointId(checkpointId);
+    const checkpointJson = await readFile4(
+      path13.join(this.getCheckpointDirectory(projectId, checkpointId), "meta.json"),
+      "utf8"
+    );
+    const checkpoint = JSON.parse(checkpointJson);
+    if (checkpoint.projectId !== projectId || checkpoint.id !== checkpointId) {
+      throw new Error("Checkpoint metadata does not match the requested project.");
+    }
+    return checkpoint;
+  }
+  async restoreCheckpointFiles(projectId, checkpointId) {
+    const checkpoint = await this.readCheckpoint(projectId, checkpointId);
+    const checkpointDirectory = this.getCheckpointDirectory(projectId, checkpointId);
+    for (const file2 of checkpoint.files) {
+      const sourcePath = path13.join(checkpointDirectory, "files", file2);
+      const targetPath = await this.resolveProjectWorkspacePath(projectId, file2, {
+        checkTargetSymlink: true,
+        targetMayBeMissing: true
+      });
+      await mkdir2(path13.dirname(targetPath), { recursive: true });
+      await copyFile(sourcePath, targetPath);
+    }
+    return checkpoint;
+  }
   async writeProjectOutput(projectId, outputType, content) {
     const outputPath = this.getProjectOutputFilePath(projectId, outputType);
     await mkdir2(path13.dirname(outputPath), { recursive: true });
@@ -59721,18 +59002,24 @@ var WorkspaceStore = class {
       return left.localeCompare(right);
     });
   }
+  async readProjectHtmlPageManifest(projectId) {
+    try {
+      return parseHtmlPageManifest(
+        await this.readProjectWorkspaceFile(projectId, HTML_PAGE_MANIFEST_PATH)
+      );
+    } catch (error51) {
+      if (isMissingPathError3(error51)) {
+        return parseHtmlPageManifest(void 0);
+      }
+      throw error51;
+    }
+  }
   async readProjectWorkspaceEntry(projectId, relativePath, options = {}) {
     const offset = normalizePositiveInteger(options.offset, 1, "offset");
-    const limit = normalizePositiveInteger(
-      options.limit,
-      DEFAULT_READ_LIMIT,
-      "limit"
-    );
-    const targetPath = relativePath === "." ? this.getProjectWorkspaceDirectory(projectId) : await this.resolveProjectWorkspacePath(
-      projectId,
-      relativePath,
-      { checkTargetSymlink: true }
-    );
+    const limit = normalizePositiveInteger(options.limit, DEFAULT_READ_LIMIT, "limit");
+    const targetPath = relativePath === "." ? this.getProjectWorkspaceDirectory(projectId) : await this.resolveProjectWorkspacePath(projectId, relativePath, {
+      checkTargetSymlink: true
+    });
     const targetStats = await lstat(targetPath);
     const normalizedPath = normalizeWorkspaceRelativePath(relativePath);
     if (targetStats.isSymbolicLink()) {
@@ -59752,15 +59039,11 @@ var WorkspaceStore = class {
             return void 0;
           }
           return {
-            path: normalizeWorkspaceRelativePath(
-              path13.relative(rootPath, absolutePath)
-            ),
+            path: normalizeWorkspaceRelativePath(path13.relative(rootPath, absolutePath)),
             type: entryStats.isDirectory() ? "directory" : "file"
           };
         })
-      )).filter(
-        (entry) => Boolean(entry)
-      ).sort((left, right) => left.path.localeCompare(right.path));
+      )).filter((entry) => Boolean(entry)).sort((left, right) => left.path.localeCompare(right.path));
       const start2 = offset - 1;
       const sliced = visibleEntries.slice(start2, start2 + limit);
       return {
@@ -59833,20 +59116,16 @@ var WorkspaceStore = class {
     const startPath = relativePath && relativePath !== "." ? relativePath : "";
     const matcher = globToRegExp(pattern);
     const matches = [];
-    await this.walkProjectWorkspace(
-      projectId,
-      startPath,
-      async (entry) => {
-        const pathFromStart = startPath ? normalizeWorkspaceRelativePath(path13.relative(startPath, entry.path)) : entry.path;
-        if (matcher.test(pathFromStart) || matcher.test(path13.basename(entry.path))) {
-          matches.push({
-            path: entry.path,
-            type: entry.type,
-            updatedAt: entry.updatedAt
-          });
-        }
+    await this.walkProjectWorkspace(projectId, startPath, async (entry) => {
+      const pathFromStart = startPath ? normalizeWorkspaceRelativePath(path13.relative(startPath, entry.path)) : entry.path;
+      if (matcher.test(pathFromStart) || matcher.test(path13.basename(entry.path))) {
+        matches.push({
+          path: entry.path,
+          type: entry.type,
+          updatedAt: entry.updatedAt
+        });
       }
-    );
+    });
     const sortedMatches = matches.sort(
       (left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime()
     );
@@ -59944,11 +59223,7 @@ var WorkspaceStore = class {
     if (!changes.length) {
       throw new Error("Project Workspace patch must include at least one change.");
     }
-    const prepared = await this.prepareProjectWorkspacePatch(
-      projectId,
-      changes,
-      options
-    );
+    const prepared = await this.prepareProjectWorkspacePatch(projectId, changes, options);
     for (const change of prepared) {
       if (change.operation === "delete") {
         await rm(change.absolutePath, { force: false, recursive: true });
@@ -59978,26 +59253,14 @@ var WorkspaceStore = class {
     }) : this.getProjectWorkspaceDirectory(projectId);
     const startStats = await stat3(startPath);
     if (startStats.isFile()) {
-      await this.searchWorkspaceFile(
-        projectId,
-        startPath,
-        query,
-        matches,
-        skippedFiles
-      );
+      await this.searchWorkspaceFile(projectId, startPath, query, matches, skippedFiles);
     } else if (startStats.isDirectory()) {
       await this.walkProjectWorkspace(
         projectId,
         relativePath === "." ? "" : relativePath,
         async (entry, absolutePath) => {
           if (entry.type === "file") {
-            await this.searchWorkspaceFile(
-              projectId,
-              absolutePath,
-              query,
-              matches,
-              skippedFiles
-            );
+            await this.searchWorkspaceFile(projectId, absolutePath, query, matches, skippedFiles);
           }
         }
       );
@@ -60011,11 +59274,9 @@ var WorkspaceStore = class {
     };
   }
   async readProjectWorkspaceFile(projectId, relativePath) {
-    const filePath = await this.resolveProjectWorkspacePath(
-      projectId,
-      relativePath,
-      { checkTargetSymlink: true }
-    );
+    const filePath = await this.resolveProjectWorkspacePath(projectId, relativePath, {
+      checkTargetSymlink: true
+    });
     const fileStats = await stat3(filePath);
     if (!fileStats.isFile()) {
       throw new Error(`Project Workspace path is not a file: ${relativePath}`);
@@ -60023,11 +59284,9 @@ var WorkspaceStore = class {
     return readFile4(filePath, "utf8");
   }
   async readProjectWorkspaceFileBuffer(projectId, relativePath) {
-    const filePath = await this.resolveProjectWorkspacePath(
-      projectId,
-      relativePath,
-      { checkTargetSymlink: true }
-    );
+    const filePath = await this.resolveProjectWorkspacePath(projectId, relativePath, {
+      checkTargetSymlink: true
+    });
     const fileStats = await stat3(filePath);
     if (!fileStats.isFile()) {
       throw new Error(`Project Workspace path is not a file: ${relativePath}`);
@@ -60035,11 +59294,10 @@ var WorkspaceStore = class {
     return readFile4(filePath);
   }
   async writeProjectWorkspaceFile(projectId, relativePath, content) {
-    const filePath = await this.resolveProjectWorkspacePath(
-      projectId,
-      relativePath,
-      { checkTargetSymlink: true, targetMayBeMissing: true }
-    );
+    const filePath = await this.resolveProjectWorkspacePath(projectId, relativePath, {
+      checkTargetSymlink: true,
+      targetMayBeMissing: true
+    });
     const previousContent = await readTextFileIfExists(filePath);
     await mkdir2(path13.dirname(filePath), { recursive: true });
     await writeFile2(filePath, content, "utf8");
@@ -60074,21 +59332,15 @@ var WorkspaceStore = class {
     );
     await this.writeProjectWorkspaceFile(projectId, relativePath, updatedContent);
     return {
-      diff: buildUnifiedDiff(
-        content,
-        updatedContent,
-        normalizeWorkspaceRelativePath(relativePath)
-      ),
+      diff: buildUnifiedDiff(content, updatedContent, normalizeWorkspaceRelativePath(relativePath)),
       path: normalizeWorkspaceRelativePath(relativePath),
       replacements: replaceAll ? replacements : 1
     };
   }
   async deleteProjectWorkspacePath(projectId, relativePath) {
-    const targetPath = await this.resolveProjectWorkspacePath(
-      projectId,
-      relativePath,
-      { checkTargetSymlink: true }
-    );
+    const targetPath = await this.resolveProjectWorkspacePath(projectId, relativePath, {
+      checkTargetSymlink: true
+    });
     await rm(targetPath, { force: false, recursive: true });
     return {
       deleted: true,
@@ -60096,9 +59348,7 @@ var WorkspaceStore = class {
     };
   }
   async deleteConversation(projectId, conversationId) {
-    await this.moveToTrash(
-      this.getConversationFilePath(projectId, conversationId)
-    );
+    await this.moveToTrash(this.getConversationFilePath(projectId, conversationId));
   }
   async deleteProject(projectId) {
     await this.moveToTrash(this.getProjectDirectory(projectId));
@@ -60112,17 +59362,17 @@ var WorkspaceStore = class {
   getConversationsDirectory(projectId) {
     return path13.join(this.getProjectDirectory(projectId), "conversations");
   }
+  getCheckpointsDirectory(projectId) {
+    return path13.join(this.getProjectDirectory(projectId), "checkpoints");
+  }
+  getCheckpointDirectory(projectId, checkpointId) {
+    return path13.join(this.getCheckpointsDirectory(projectId), checkpointId);
+  }
   getProjectOutputFilePath(projectId, outputType) {
-    return path13.join(
-      this.getProjectWorkspaceDirectory(projectId),
-      `index.${outputType}`
-    );
+    return path13.join(this.getProjectWorkspaceDirectory(projectId), `index.${outputType}`);
   }
   getConversationFilePath(projectId, conversationId) {
-    return path13.join(
-      this.getConversationsDirectory(projectId),
-      `${conversationId}.json`
-    );
+    return path13.join(this.getConversationsDirectory(projectId), `${conversationId}.json`);
   }
   async walkProjectWorkspace(projectId, relativePath, visit2) {
     const rootPath = this.getProjectWorkspaceDirectory(projectId);
@@ -60224,25 +59474,20 @@ var WorkspaceStore = class {
       if (state.has(relativePath)) {
         return state.get(relativePath);
       }
-      const absolutePath = await this.resolveProjectWorkspacePath(
-        projectId,
-        relativePath,
-        { checkTargetSymlink: true, targetMayBeMissing: true }
-      );
+      const absolutePath = await this.resolveProjectWorkspacePath(projectId, relativePath, {
+        checkTargetSymlink: true,
+        targetMayBeMissing: true
+      });
       const content = await readTextFileIfExists(absolutePath);
       state.set(relativePath, content);
       return content;
     };
     for (const change of changes) {
       const relativePath = normalizeWorkspaceRelativePath(change.path);
-      const absolutePath = await this.resolveProjectWorkspacePath(
-        projectId,
-        relativePath,
-        {
-          checkTargetSymlink: true,
-          targetMayBeMissing: change.operation !== "delete"
-        }
-      );
+      const absolutePath = await this.resolveProjectWorkspacePath(projectId, relativePath, {
+        checkTargetSymlink: true,
+        targetMayBeMissing: change.operation !== "delete"
+      });
       if (change.operation === "delete") {
         const targetStats = await lstat(absolutePath);
         const previousContent2 = targetStats.isFile() ? await readCurrentContent(relativePath) : void 0;
@@ -60313,11 +59558,7 @@ var WorkspaceStore = class {
     if (!relativeFromWorkspace || relativeFromWorkspace.startsWith("..") || path13.isAbsolute(relativeFromWorkspace)) {
       throw new Error(`Project Workspace path escapes workspace: ${relativePath}`);
     }
-    await this.assertNoWorkspaceSymlinkPath(
-      workspaceDirectory,
-      relativeFromWorkspace,
-      options
-    );
+    await this.assertNoWorkspaceSymlinkPath(workspaceDirectory, relativeFromWorkspace, options);
     return targetPath;
   }
   async assertNoWorkspaceSymlinkPath(workspaceDirectory, relativeFromWorkspace, options) {
@@ -60341,6 +59582,17 @@ var WorkspaceStore = class {
     }
   }
 };
+function normalizeProjectRecord(project) {
+  return {
+    ...project,
+    projectType: project.projectType ?? "single_html"
+  };
+}
+function assertSafeCheckpointId(checkpointId) {
+  if (!/^[A-Za-z0-9_-]+$/.test(checkpointId)) {
+    throw new Error(`Invalid checkpoint id: ${checkpointId}`);
+  }
+}
 
 // src/services.ts
 function createWorkspaceStore(options = {}) {
@@ -60371,9 +59623,7 @@ function createOwnDesignServices(options = {}) {
 function sanitizePublicConversation(conversation) {
   return {
     ...conversation,
-    messages: Array.isArray(conversation.messages) ? conversation.messages.map(
-      (message) => sanitizePublicUIMessage(message)
-    ) : conversation.messages
+    messages: Array.isArray(conversation.messages) ? conversation.messages.map((message) => sanitizePublicUIMessage(message)) : conversation.messages
   };
 }
 function sanitizePublicUIMessage(message) {
@@ -60592,10 +59842,14 @@ var ChatRunManager = class {
       } else {
         run.status = "failed";
         this.flushPendingLiveChunks(run);
-        this.publish(run, {
-          errorText: error51 instanceof Error ? error51.message : "\u751F\u6210\u5931\u8D25\uFF1AUnknown error",
-          type: "error"
-        }, { immediate: true });
+        this.publish(
+          run,
+          {
+            errorText: error51 instanceof Error ? error51.message : "\u751F\u6210\u5931\u8D25\uFF1AUnknown error",
+            type: "error"
+          },
+          { immediate: true }
+        );
       }
     } finally {
       run.completedAt = run.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
@@ -60615,10 +59869,7 @@ var ChatRunManager = class {
       message: getLastAssistantMessage(run.initialMessages),
       stream: stream2
     })) {
-      run.latestMessages = mergeResponseMessage(
-        run.initialMessages,
-        responseMessage
-      );
+      run.latestMessages = mergeResponseMessage(run.initialMessages, responseMessage);
       if (isRunAtResumableBoundary(run)) {
         run.safeMessages = run.latestMessages;
         run.safeSnapshotChunkIndex = run.safeResumeChunkIndex;
@@ -60812,25 +60063,19 @@ function createOwnDesignApp(options = {}) {
       activeConversationId: activeConversation?.id,
       activeProject,
       activeRun: activeProject ? chatRunManager.getActiveRun(activeProject.id) : void 0,
-      conversations: conversationState.conversations.map(
-        sanitizePublicConversation
-      ),
+      conversations: conversationState.conversations.map(sanitizePublicConversation),
       projects: projectState.projects,
       settings
     });
   });
   app2.get("/api/settings", async (context2) => {
-    return context2.json(
-      await createOwnDesignServices(options).settingsService.getPublicSettings()
-    );
+    return context2.json(await createOwnDesignServices(options).settingsService.getPublicSettings());
   });
   app2.put("/api/settings", async (context2) => {
     try {
       const body = await context2.req.json();
       return context2.json(
-        await createOwnDesignServices(options).settingsService.updatePublicSettings(
-          body
-        )
+        await createOwnDesignServices(options).settingsService.updatePublicSettings(body)
       );
     } catch (error51) {
       return context2.text(
@@ -60872,17 +60117,20 @@ function createOwnDesignApp(options = {}) {
   app2.post("/api/projects", async (context2) => {
     const body = await context2.req.json();
     const trimmedName = asNonEmptyString(body.name);
-    if (!trimmedName) {
+    const projectType = parseProjectType(body.projectType);
+    if (!trimmedName || !projectType) {
       return context2.json({}, 400);
     }
+    if (projectType === "react") {
+      return context2.text("React project type is reserved but not supported yet.", 400);
+    }
     const services = createOwnDesignServices(options);
     const settings = await services.settingsService.getSettings();
     const result = await services.projectService.createProject({
-      defaultConversationTitle: getDefaultConversationTitle(
-        settings.interfaceLanguage
-      ),
+      defaultConversationTitle: getDefaultConversationTitle(settings.interfaceLanguage),
       name: trimmedName,
-      description: asNonEmptyString(body.description)
+      description: asNonEmptyString(body.description),
+      projectType
     });
     return context2.json({
       href: buildWorkspaceHref({
@@ -60909,9 +60157,7 @@ function createOwnDesignApp(options = {}) {
     await createProjectService(options).deleteProject(projectId);
     const projectState = await createProjectService(options).getProjectState();
     const fallbackProject = projectState.projects[0];
-    const fallbackConversation = fallbackProject ? (await createConversationService(options).getConversationState(
-      fallbackProject.id
-    )).conversations[0] : void 0;
+    const fallbackConversation = fallbackProject ? (await createConversationService(options).getConversationState(fallbackProject.id)).conversations[0] : void 0;
     return context2.json({
       href: buildWorkspaceHref({
         conversationId: fallbackConversation?.id,
@@ -60934,76 +60180,58 @@ function createOwnDesignApp(options = {}) {
       })
     });
   });
-  app2.post(
-    "/api/projects/:projectId/conversations/:conversationId/select",
-    async (context2) => {
-      const projectId = context2.req.param("projectId");
-      const conversationId = context2.req.param("conversationId");
-      await createConversationService(options).switchConversation(
-        projectId,
-        conversationId
-      );
-      return context2.json({
-        href: buildWorkspaceHref({
-          conversationId,
-          projectId
-        })
-      });
-    }
-  );
-  app2.patch(
-    "/api/projects/:projectId/conversations/:conversationId",
-    async (context2) => {
-      const projectId = context2.req.param("projectId");
-      const conversationId = context2.req.param("conversationId");
-      const body = await context2.req.json();
-      const trimmedTitle = asNonEmptyString(body.title);
-      if (!trimmedTitle) {
-        return context2.json({}, 400);
-      }
-      await createConversationService(options).renameConversation(
-        projectId,
-        conversationId,
-        { title: trimmedTitle }
-      );
-      return context2.json({});
-    }
-  );
-  app2.delete(
-    "/api/projects/:projectId/conversations/:conversationId",
-    async (context2) => {
-      const projectId = context2.req.param("projectId");
-      const conversationId = context2.req.param("conversationId");
-      const currentConversationId = context2.req.query("currentConversationId");
-      const services = createOwnDesignServices(options);
-      const settings = await services.settingsService.getSettings();
-      const remainingConversations = await services.conversationService.deleteConversation(
-        projectId,
+  app2.post("/api/projects/:projectId/conversations/:conversationId/select", async (context2) => {
+    const projectId = context2.req.param("projectId");
+    const conversationId = context2.req.param("conversationId");
+    await createConversationService(options).switchConversation(projectId, conversationId);
+    return context2.json({
+      href: buildWorkspaceHref({
         conversationId,
-        getDefaultConversationTitle(settings.interfaceLanguage)
-      );
-      const nextConversationId = currentConversationId === conversationId ? remainingConversations[0]?.id : currentConversationId;
-      return context2.json({
-        href: buildWorkspaceHref({
-          conversationId: nextConversationId,
-          projectId
-        })
-      });
+        projectId
+      })
+    });
+  });
+  app2.patch("/api/projects/:projectId/conversations/:conversationId", async (context2) => {
+    const projectId = context2.req.param("projectId");
+    const conversationId = context2.req.param("conversationId");
+    const body = await context2.req.json();
+    const trimmedTitle = asNonEmptyString(body.title);
+    if (!trimmedTitle) {
+      return context2.json({}, 400);
     }
-  );
+    await createConversationService(options).renameConversation(projectId, conversationId, {
+      title: trimmedTitle
+    });
+    return context2.json({});
+  });
+  app2.delete("/api/projects/:projectId/conversations/:conversationId", async (context2) => {
+    const projectId = context2.req.param("projectId");
+    const conversationId = context2.req.param("conversationId");
+    const currentConversationId = context2.req.query("currentConversationId");
+    const services = createOwnDesignServices(options);
+    const settings = await services.settingsService.getSettings();
+    const remainingConversations = await services.conversationService.deleteConversation(
+      projectId,
+      conversationId,
+      getDefaultConversationTitle(settings.interfaceLanguage)
+    );
+    const nextConversationId = currentConversationId === conversationId ? remainingConversations[0]?.id : currentConversationId;
+    return context2.json({
+      href: buildWorkspaceHref({
+        conversationId: nextConversationId,
+        projectId
+      })
+    });
+  });
   app2.post("/api/chat", async (context2) => {
     const body = await context2.req.json();
     const projectId = asNonEmptyString(body.projectId);
     const conversationId = asNonEmptyString(body.conversationId);
     const requestedPreviewPath = asNonEmptyString(body.previewPath);
-    const pageEditMode = parsePageEditMode(body.pageEditMode);
     const currentUserMessage = createCurrentUserMessage(body.message);
     if (!projectId || !conversationId || !currentUserMessage) {
       return context2.text("Invalid chat request.", 400);
     }
-    if (!pageEditMode) {
-      return context2.text("Invalid page edit mode.", 400);
-    }
     const workspaceStore = createWorkspaceStore(options);
     const project = await workspaceStore.getProject(projectId);
     const previewPath = await resolveExistingPreviewPath(
@@ -61014,29 +60242,29 @@ function createOwnDesignApp(options = {}) {
     if (chatRunManager.getActiveRun(projectId)) {
       return context2.text("\u5F53\u524D\u9879\u76EE\u5DF2\u6709\u4EFB\u52A1\u6B63\u5728\u6267\u884C\u3002", 409);
     }
-    let conversation = await workspaceStore.getConversation(
+    await workspaceStore.createCheckpoint({
+      id: createCheckpointId(),
+      conversationId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       projectId,
-      conversationId
-    );
+      userMessageId: currentUserMessage.id,
+      userPrompt: getUIMessageText(currentUserMessage)
+    });
+    let conversation = await workspaceStore.getConversation(projectId, conversationId);
     const storedMessages = normalizeConversationMessages(
       conversation.messages
     );
-    let messages = [
-      ...storedMessages,
-      currentUserMessage
-    ];
+    let messages = [...storedMessages, currentUserMessage];
     let agentContext;
     try {
       agentContext = await createDesignPageAgentContext({
         currentPreviewPath: previewPath,
         frontendTabId: asNonEmptyString(body.frontendTabId),
         modelConfigurationId: asNonEmptyString(body.modelConfigurationId),
-        outputType: project.outputType,
-        pageEditMode,
+        projectType: project.projectType ?? "single_html",
         projectId,
-        providerOptionsSelection: parseProviderOptionsSelection(
-          body.providerOptionsSelection
-        ),
+        providerOptionsSelection: parseProviderOptionsSelection(body.providerOptionsSelection),
+        settingsPath: options.settingsPath,
         workspaceStore
       });
     } catch (error51) {
@@ -61046,33 +60274,13 @@ function createOwnDesignApp(options = {}) {
       );
     }
     if (!conversation.agentInstructions) {
-      conversation = await workspaceStore.updateConversation(
-        projectId,
-        conversationId,
-        {
-          ...conversation,
-          agentInstructions: buildDesignPageConversationInstructions(
-            agentContext.resources
-          ),
-          agentPromptVersion: DESIGN_PAGE_AGENT_PROMPT_VERSION
-        }
-      );
-    }
-    agentContext.agentInstructions = conversation.agentInstructions;
-    try {
-      messages = await rewriteLastUserMessageForDesignAgent({
-        messages,
-        pageEditMode,
-        pageEditModePolicy: agentContext.pageEditModePolicy ?? { mode: "auto" },
-        previewPath,
-        agentContext
+      conversation = await workspaceStore.updateConversation(projectId, conversationId, {
+        ...conversation,
+        agentInstructions: buildDesignPageConversationInstructions(agentContext.resources),
+        agentPromptVersion: DESIGN_PAGE_AGENT_PROMPT_VERSION
       });
-    } catch (error51) {
-      return context2.text(
-        error51 instanceof Error ? error51.message : "Failed to rewrite user prompt.",
-        500
-      );
     }
+    agentContext.agentInstructions = conversation.agentInstructions;
     const agent = createDesignPageAgent(agentContext);
     let latestStepUsage;
     const run = chatRunManager.startRun({
@@ -61124,6 +60332,49 @@ function createOwnDesignApp(options = {}) {
     }
     return createChatRunStreamResponse(run.stream);
   });
+  app2.get("/api/projects/:projectId/checkpoints", async (context2) => {
+    const workspaceStore = createWorkspaceStore(options);
+    const projectId = context2.req.param("projectId");
+    await workspaceStore.getProject(projectId);
+    return context2.json(await workspaceStore.listCheckpoints(projectId));
+  });
+  app2.post("/api/projects/:projectId/checkpoints/:checkpointId/restore", async (context2) => {
+    const workspaceStore = createWorkspaceStore(options);
+    const projectId = context2.req.param("projectId");
+    const checkpointId = context2.req.param("checkpointId");
+    const body = await readJson(context2.req.raw);
+    const mode = parseCheckpointRestoreMode(body?.mode);
+    if (!mode) {
+      return context2.text("Invalid checkpoint restore request.", 400);
+    }
+    if (chatRunManager.getActiveRun(projectId)) {
+      return context2.text("\u5F53\u524D\u9879\u76EE\u5DF2\u6709\u4EFB\u52A1\u6B63\u5728\u6267\u884C\u3002", 409);
+    }
+    try {
+      const checkpoint = mode === "conversation" ? await workspaceStore.readCheckpoint(projectId, checkpointId) : await workspaceStore.restoreCheckpointFiles(projectId, checkpointId);
+      if (mode === "conversation" || mode === "both") {
+        await restoreCheckpointConversation({
+          options,
+          workspaceStore,
+          checkpoint
+        });
+      }
+      return context2.json({
+        href: buildWorkspaceHref({
+          conversationId: checkpoint.conversationId,
+          projectId
+        })
+      });
+    } catch (error51) {
+      if (isMissingPathError4(error51)) {
+        return context2.text("Checkpoint not found.", 404);
+      }
+      return context2.text(
+        error51 instanceof Error ? error51.message : "Checkpoint restore failed.",
+        400
+      );
+    }
+  });
   app2.get("/api/projects/:projectId/runs/active", async (context2) => {
     const activeRun = chatRunManager.getActiveRun(context2.req.param("projectId"));
     if (!activeRun) {
@@ -61132,9 +60383,7 @@ function createOwnDesignApp(options = {}) {
     return context2.json(activeRun);
   });
   app2.delete("/api/projects/:projectId/runs/active", async (context2) => {
-    const activeRun = chatRunManager.cancelActiveRun(
-      context2.req.param("projectId")
-    );
+    const activeRun = chatRunManager.cancelActiveRun(context2.req.param("projectId"));
     if (!activeRun) {
       return new Response(null, { status: 204 });
     }
@@ -61143,10 +60392,7 @@ function createOwnDesignApp(options = {}) {
   app2.get(
     "/api/projects/:projectId/conversations/:conversationId/runs/active/stream",
     async (context2) => {
-      const afterChunkIndex = Number.parseInt(
-        context2.req.query("after") ?? "0",
-        10
-      );
+      const afterChunkIndex = Number.parseInt(context2.req.query("after") ?? "0", 10);
       const stream2 = chatRunManager.subscribeActiveRun(
         context2.req.param("projectId"),
         context2.req.param("conversationId"),
@@ -61197,57 +60443,51 @@ function createOwnDesignApp(options = {}) {
     await manager.release(context2.req.param("projectId"), clientId);
     return new Response(null, { status: 204 });
   });
-  app2.post(
-    "/api/projects/:projectId/preview-session/heartbeat",
-    async (context2) => {
-      const body = await readJson(context2.req.raw);
-      const clientId = asNonEmptyString(body?.clientId);
-      if (!clientId) {
-        return context2.text("Invalid preview heartbeat request.", 400);
-      }
-      const workspaceStore = createWorkspaceStore(options);
-      const manager = getPreviewServerManager(workspaceStore);
-      const session = await manager.heartbeat(
-        context2.req.param("projectId"),
-        clientId,
-        asNonEmptyString(body?.previewPath)
-      );
-      return context2.json(session);
+  app2.post("/api/projects/:projectId/preview-session/heartbeat", async (context2) => {
+    const body = await readJson(context2.req.raw);
+    const clientId = asNonEmptyString(body?.clientId);
+    if (!clientId) {
+      return context2.text("Invalid preview heartbeat request.", 400);
     }
-  );
-  app2.get(
-    "/api/projects/:projectId/frontend-capabilities/stream",
-    async (context2) => {
-      const projectId = context2.req.param("projectId");
-      const tabId = context2.req.query("tabId")?.trim();
-      if (!tabId) {
-        return context2.text("Invalid frontend capability stream request.", 400);
-      }
-      await createWorkspaceStore(options).getProject(projectId);
-      context2.header("Cache-Control", "no-cache, no-transform");
-      context2.header("Connection", "keep-alive");
-      context2.header("Content-Type", "text/event-stream; charset=utf-8");
-      return stream(context2, async (streamApi) => {
-        const commandStream = registerFrontendConnection({
-          frontendTabId: tabId,
-          projectId,
-          signal: context2.req.raw.signal
-        });
-        const reader = commandStream.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              break;
-            }
-            await streamApi.write(value);
+    const workspaceStore = createWorkspaceStore(options);
+    const manager = getPreviewServerManager(workspaceStore);
+    const session = await manager.heartbeat(
+      context2.req.param("projectId"),
+      clientId,
+      asNonEmptyString(body?.previewPath)
+    );
+    return context2.json(session);
+  });
+  app2.get("/api/projects/:projectId/frontend-capabilities/stream", async (context2) => {
+    const projectId = context2.req.param("projectId");
+    const tabId = context2.req.query("tabId")?.trim();
+    if (!tabId) {
+      return context2.text("Invalid frontend capability stream request.", 400);
+    }
+    await createWorkspaceStore(options).getProject(projectId);
+    context2.header("Cache-Control", "no-cache, no-transform");
+    context2.header("Connection", "keep-alive");
+    context2.header("Content-Type", "text/event-stream; charset=utf-8");
+    return stream(context2, async (streamApi) => {
+      const commandStream = registerFrontendConnection({
+        frontendTabId: tabId,
+        projectId,
+        signal: context2.req.raw.signal
+      });
+      const reader = commandStream.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
           }
-        } finally {
-          reader.releaseLock();
+          await streamApi.write(value);
         }
-      });
-    }
-  );
+      } finally {
+        reader.releaseLock();
+      }
+    });
+  });
   app2.get("/api/projects/:projectId/download", async (context2) => {
     const workspaceStore = createWorkspaceStore(options);
     const projectId = context2.req.param("projectId");
@@ -61327,15 +60567,10 @@ async function downloadCurrentHtml(workspaceStore, projectId, previewPath) {
     return new Response("Invalid download request.", { status: 400 });
   }
   try {
-    const content = await workspaceStore.readProjectWorkspaceFileBuffer(
-      projectId,
-      previewPath
-    );
+    const content = await workspaceStore.readProjectWorkspaceFileBuffer(projectId, previewPath);
     return new Response(content, {
       headers: {
-        "Content-Disposition": createAttachmentDisposition(
-          path14.basename(previewPath)
-        ),
+        "Content-Disposition": createAttachmentDisposition(path14.basename(previewPath)),
         "Content-Type": "text/html; charset=utf-8"
       },
       status: 200
@@ -61348,15 +60583,10 @@ async function downloadWorkspaceZip(workspaceStore, projectId) {
   let tempDirectory;
   try {
     const project = await workspaceStore.getProject(projectId);
-    tempDirectory = await mkdtemp(
-      path14.join(os6.tmpdir(), "owndesign-project-download-")
-    );
+    tempDirectory = await mkdtemp(path14.join(os6.tmpdir(), "owndesign-project-download-"));
     const zipPath = path14.join(tempDirectory, "workspace.zip");
     await writeWorkspaceZip(workspaceStore, projectId, zipPath);
-    const [zipStats, zipBuffer] = await Promise.all([
-      stat4(zipPath),
-      readFile5(zipPath)
-    ]);
+    const [zipStats, zipBuffer] = await Promise.all([stat4(zipPath), readFile5(zipPath)]);
     await rm2(tempDirectory, { force: true, recursive: true });
     tempDirectory = void 0;
     return new Response(zipBuffer, {
@@ -61391,10 +60621,7 @@ async function writeWorkspaceZip(workspaceStore, projectId, zipPath) {
     if (entry.type !== "file") {
       continue;
     }
-    const content = await workspaceStore.readProjectWorkspaceFileBuffer(
-      projectId,
-      entry.path
-    );
+    const content = await workspaceStore.readProjectWorkspaceFileBuffer(projectId, entry.path);
     zipFile.addBuffer(content, entry.path);
   }
   zipFile.end();
@@ -61448,16 +60675,13 @@ async function readJson(request) {
   }
 }
 function createCurrentUserMessage(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return void 0;
   }
   const id = asNonEmptyString(value.id);
   const text2 = typeof value.text === "string" ? value.text : "";
   const files = Array.isArray(value.files) ? value.files.filter(isFileUIPart2) : [];
-  const parts = [
-    ...text2 ? [{ text: text2, type: "text" }] : [],
-    ...files
-  ];
+  const parts = [...text2 ? [{ text: text2, type: "text" }] : [], ...files];
   if (!id || parts.length === 0) {
     return void 0;
   }
@@ -61468,93 +60692,9 @@ function createCurrentUserMessage(value) {
   };
 }
 function isFileUIPart2(value) {
-  return isRecord2(value) && value.type === "file";
-}
-async function rewriteLastUserMessageForDesignAgent({
-  agentContext,
-  messages,
-  pageEditMode,
-  pageEditModePolicy,
-  previewPath
-}) {
-  const lastUserMessageIndex = findLastUserMessageIndex(messages);
-  if (lastUserMessageIndex < 0) {
-    return messages;
-  }
-  const lastUserMessage = messages[lastUserMessageIndex];
-  if (!lastUserMessage || hasPromptRewriteMetadata(lastUserMessage)) {
-    return messages;
-  }
-  const originalUserPrompt = getUIMessageText(lastUserMessage);
-  const { rewrittenPrompt } = await rewriteTurnPrompt({
-    model: agentContext.model,
-    originalUserPrompt,
-    pageEditMode,
-    pageEditModePolicy,
-    previewPath,
-    providerOptions: agentContext.providerOptions
-  });
-  const metadata = createTurnPromptRewriteMetadata({
-    originalUserPrompt,
-    pageEditMode,
-    pageEditModePolicy,
-    previewPath
-  });
-  const rewrittenMessage = {
-    ...lastUserMessage,
-    metadata: {
-      ...isRecord2(lastUserMessage.metadata) ? lastUserMessage.metadata : {},
-      ...metadata
-    },
-    parts: [
-      {
-        text: rewrittenPrompt,
-        type: "text"
-      },
-      ...lastUserMessage.parts.filter((part) => part.type !== "text")
-    ]
-  };
-  return [
-    ...messages.slice(0, lastUserMessageIndex),
-    rewrittenMessage,
-    ...messages.slice(lastUserMessageIndex + 1)
-  ];
-}
-function findLastUserMessageIndex(messages) {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message?.role === "user") {
-      return index;
-    }
-  }
-  return -1;
-}
-function createTurnPromptRewriteMetadata({
-  originalUserPrompt,
-  pageEditMode,
-  pageEditModePolicy,
-  previewPath
-}) {
-  return {
-    originalUserPrompt,
-    promptRewrite: {
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      kind: "turn-prompt-rewriter",
-      pageEditMode,
-      previewFileExists: Boolean(previewPath),
-      ...previewPath ? { previewPath } : {},
-      ...pageEditModePolicy.mode === "duplicate_edit" ? {
-        duplicateSourcePath: pageEditModePolicy.sourcePath,
-        duplicateTargetPath: pageEditModePolicy.targetPath
-      } : {}
-    }
-  };
-}
-function hasPromptRewriteMetadata(message) {
-  const metadata = message.metadata;
-  return isRecord2(metadata) && isRecord2(metadata.promptRewrite) && metadata.promptRewrite.kind === "turn-prompt-rewriter";
+  return isRecord3(value) && value.type === "file";
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 async function resolveExistingPreviewPath(workspaceStore, projectId, previewPath) {
@@ -61567,8 +60707,20 @@ async function resolveExistingPreviewPath(workspaceStore, projectId, previewPath
 function asNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function parseProjectType(value) {
+  if (value === void 0 || value === null || value === "") {
+    return "single_html";
+  }
+  if (value === "single_html" || value === "react") {
+    return value;
+  }
+  return void 0;
+}
+function parseCheckpointRestoreMode(value) {
+  return value === "files" || value === "conversation" || value === "both" ? value : void 0;
+}
 function parseProviderOptionsSelection(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return void 0;
   }
   const deepseek2 = parseDeepSeekThinkingMode(value.deepseek);
@@ -61581,6 +60733,36 @@ function parseProviderOptionsSelection(value) {
     ...deepseek2 ? { deepseek: deepseek2 } : {}
   };
 }
+function createCheckpointId() {
+  const id = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  return `cp_${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
+}
+async function restoreCheckpointConversation({
+  checkpoint,
+  options,
+  workspaceStore
+}) {
+  const conversation = await workspaceStore.getConversation(
+    checkpoint.projectId,
+    checkpoint.conversationId
+  );
+  const messages = normalizeConversationMessages(conversation.messages);
+  const targetIndex = messages.findIndex((message) => message.id === checkpoint.userMessageId);
+  if (targetIndex < 0) {
+    throw new Error("Checkpoint user message was not found in the conversation.");
+  }
+  const nextMessages = messages.slice(0, targetIndex);
+  const settings = await createOwnDesignServices(options).settingsService.getSettings();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const lastMessage = nextMessages.at(-1);
+  await workspaceStore.updateConversation(checkpoint.projectId, checkpoint.conversationId, {
+    ...conversation,
+    lastMessageAt: lastMessage ? timestamp : void 0,
+    messages: nextMessages,
+    title: !conversation.titleManuallySet && nextMessages.length === 0 ? getDefaultConversationTitle(settings.interfaceLanguage) : conversation.title,
+    updatedAt: timestamp
+  });
+}
 
 // src/index.ts
 var DEFAULT_HOST = "127.0.0.1";