transone-cli 0.6.3 → 0.10.0

package/dist/index-2g3e5sjt.js

@@ -0,0 +1,3388 @@
+// @bun
+import {
+  createWebComponentContext,
+  createWebStylesPlugin
+} from "./index-d51tp4y9.js";
+import {
+  assertSafeSubdirectory,
+  assertSafeSubdirectoryDoesNotContain,
+  buildInputPaths,
+  buildOutputPath,
+  loadTypescript,
+  withBuildOutput
+} from "./index-xgn9fbc6.js";
+import {
+  PLATFORM_DEFINITIONS,
+  __require,
+  canonicalPath,
+  createComponentIndex,
+  getPlatformDefinition,
+  normalizePlatform
+} from "./index-j4h0wd27.js";
+
+// src/target/types.ts
+var TARGET_TYPES = [
+  ...new Set(PLATFORM_DEFINITIONS.map((definition) => definition.target))
+];
+function isTargetType(value) {
+  return typeof value === "string" && TARGET_TYPES.includes(value);
+}
+var MP_TARGET_TYPES = TARGET_TYPES.filter((target) => target.startsWith("mp-"));
+var APP_TARGET_TYPES = TARGET_TYPES.filter((target) => target.startsWith("app-"));
+function isAppTargetType(value) {
+  return typeof value === "string" && APP_TARGET_TYPES.includes(value);
+}
+function isMpTargetType(value) {
+  return typeof value === "string" && MP_TARGET_TYPES.includes(value);
+}
+
+// src/config.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var DEFAULT_CONFIG = {
+  entry: "src/main.ts",
+  server: {
+    host: "127.0.0.1",
+    port: 52211,
+    proxy: {}
+  },
+  build: {
+    outDir: "dist/build/h5",
+    basePath: "",
+    directoryPages: false
+  }
+};
+function defineConfig(config) {
+  return config;
+}
+async function resolveConfig(options = {}) {
+  const root = resolve(options.root ?? process.cwd());
+  const configFile = resolve(root, "transone.config.ts");
+  const hasInlineConfig = options.config !== undefined;
+  const loadedConfig = hasInlineConfig ? { exists: false } : await loadConfigFile(configFile);
+  let fileConfig = {};
+  if (loadedConfig.exists) {
+    const config2 = loadedConfig.config;
+    validateUserConfig(config2);
+    fileConfig = config2;
+  }
+  if (hasInlineConfig) {
+    validateUserConfig(options.config);
+  }
+  const inlineOverrides = toInlineOverrides(options);
+  validateUserConfig(inlineOverrides);
+  const config = mergeConfig(fileConfig, options.config ?? {}, inlineOverrides);
+  const entry = resolve(root, config.entry);
+  if (!existsSync(entry) && !config.library) {
+    throw new Error(`Entry file does not exist: ${entry}`);
+  }
+  const pages = await resolvePages(root, entry, config.pages);
+  const platform = resolvePlatform(options.target ?? config.target);
+  const target = getPlatformDefinition(platform).target;
+  const explicitOutDir = options.outDir ?? options.config?.build?.outDir ?? fileConfig.build?.outDir;
+  const webOutDir = explicitOutDir ?? (platform === "web-mobile" /* WebMobile */ || platform === "web-pc" /* WebPc */ ? `dist/build/${platform}` : config.build.outDir);
+  const mpConfig = pickMpConfig(config.mp, target);
+  const mpPages = mpConfig?.pages ? await resolvePages(root, entry, mpConfig.pages, {
+    includeEntry: false,
+    allowRoot: true
+  }) : pages;
+  const mpEnabled = config.mp !== undefined || isMpTargetType(target);
+  const appConfig = pickAppConfig(config.app, target);
+  return {
+    root,
+    ...loadedConfig.exists ? { configFile } : {},
+    entry,
+    pages,
+    target,
+    platform,
+    ...config.components ? { components: config.components } : {},
+    server: {
+      host: config.server.host,
+      port: config.server.port,
+      proxy: config.server.proxy
+    },
+    build: {
+      outDir: resolve(root, webOutDir),
+      basePath: normalizeBasePath(config.build.basePath),
+      directoryPages: config.build.directoryPages
+    },
+    ...config.library ? { library: resolveLibrary(root, config.library) } : {},
+    ...mpEnabled ? {
+      mp: resolveMiniProgram(root, options.mpOutDir ?? options.outDir, mpConfig ?? {}, mpPages, target)
+    } : {},
+    ...isAppTargetType(target) ? {
+      app: await resolveApp(root, options.outDir, appConfig ?? {}, target, pages)
+    } : {}
+  };
+}
+function isAppConfigMap(value) {
+  return isRecord(value) && APP_TARGET_TYPES.some((platform) => (platform in value));
+}
+function pickAppConfig(app, target) {
+  if (app === undefined) {
+    return;
+  }
+  if (isAppConfigMap(app)) {
+    return {
+      ...app.host !== undefined ? { host: app.host } : {},
+      ...isAppTargetType(target) ? app[target] : {}
+    };
+  }
+  return app;
+}
+async function resolveApp(root, outDirOverride, app, target, fallbackPages) {
+  return {
+    ...app.host !== undefined ? { host: app.host } : {},
+    appName: app.appName ?? "TransOne",
+    bundleId: app.bundleId ?? "com.transone.app",
+    outDir: resolve(root, outDirOverride ?? app.outDir ?? `dist/build/${target}`),
+    minPlatformVersion: app.minPlatformVersion ?? "16.0",
+    publicDir: resolve(root, app.publicDir ?? "public"),
+    pages: app.pages ? await resolvePages(root, resolve(root, app.pages["/"] ?? "src/main.ts"), app.pages, {
+      includeEntry: false,
+      allowRoot: true
+    }) : fallbackPages
+  };
+}
+var MP_DEFAULT_OUT_DIRS = {
+  "mp-weixin": "dist/build/mp-weixin",
+  "mp-alipay": "dist/build/mp-alipay",
+  "mp-bytedance": "dist/build/mp-bytedance",
+  "mp-xiaohongshu": "dist/build/mp-xiaohongshu"
+};
+function pickMpConfig(mp, target) {
+  if (mp === undefined) {
+    return;
+  }
+  const common = Object.fromEntries(Object.entries(mp).filter(([key]) => !MP_TARGET_TYPES.includes(key)));
+  const platform = isMpTargetType(target) ? mp[target] : undefined;
+  return mergeMpRecords(common, { ...platform });
+}
+function mergeMpRecords(common, overrides) {
+  const merged = { ...common };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === undefined)
+      continue;
+    const previous = Object.prototype.hasOwnProperty.call(common, key) ? common[key] : undefined;
+    const next = isRecord(previous) && isRecord(value) ? mergeMpRecords(previous, value) : value;
+    Object.defineProperty(merged, key, {
+      value: next,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return merged;
+}
+function resolveMiniProgram(root, outDirOverride, mp, pages, target) {
+  return {
+    ...mp.host !== undefined ? { host: mp.host } : {},
+    appId: mp.appId ?? "touristappid",
+    outDir: resolve(root, outDirOverride ?? mp.outDir ?? MP_DEFAULT_OUT_DIRS[target] ?? "dist/build/mp-weixin"),
+    navigationBarTitleText: mp.navigationBarTitleText ?? "TransOne",
+    pages,
+    ...mp.window !== undefined ? { window: mp.window } : {},
+    ...mp.tabBar !== undefined ? { tabBar: mp.tabBar } : {},
+    ...mp.appExtra !== undefined ? { appExtra: mp.appExtra } : {},
+    ...mp.pageExtra !== undefined ? { pageExtra: mp.pageExtra } : {},
+    lengthUnit: mp.lengthUnit ?? "px",
+    publicDir: resolve(root, mp.publicDir ?? "public"),
+    ...mp.globalData !== undefined ? { globalData: mp.globalData } : {}
+  };
+}
+function resolveLibrary(root, library) {
+  return {
+    entry: resolve(root, library.entry ?? "src/index.ts"),
+    outDir: resolve(root, library.outDir ?? "dist"),
+    external: library.external ?? [],
+    tsconfigs: (library.tsconfigs ?? ["tsconfig.build.json"]).map((path) => resolve(root, path)),
+    dts: library.dts ?? true,
+    splitting: library.splitting ?? true,
+    sourcemap: library.sourcemap ?? true,
+    minify: library.minify
+  };
+}
+function normalizeBasePath(base) {
+  const trimmed = (base ?? "").trim();
+  if (!trimmed || trimmed === "/") {
+    return "";
+  }
+  const withLeading = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return withLeading.endsWith("/") ? withLeading.slice(0, -1) : withLeading;
+}
+function resolvePlatform(target) {
+  const platform = normalizePlatform(target ?? "web" /* Web */);
+  if (platform !== undefined)
+    return platform;
+  throw new Error(`Unknown build target "${String(target)}". ` + `Available targets: ${PLATFORM_DEFINITIONS.map((definition) => definition.platform).join(", ")}.`);
+}
+async function resolvePages(root, entry, pages, options = {}) {
+  const resolved = options.includeEntry === false ? {} : { "/": entry };
+  for (const [route, pageEntry] of Object.entries(pages ?? {})) {
+    const normalized = normalizePageRoute(route, options.allowRoot);
+    const absolute = resolve(root, pageEntry);
+    if (!existsSync(absolute)) {
+      throw new Error(`Page entry file does not exist for "${normalized}": ${absolute}`);
+    }
+    resolved[normalized] = absolute;
+  }
+  return resolved;
+}
+function normalizePageRoute(route, allowRoot = false) {
+  if (route === "/") {
+    if (allowRoot) {
+      return "/";
+    }
+    throw new Error('Config pages must not redefine the root page "/"; use config.entry instead');
+  }
+  const normalized = route.replace(/\/+$/, "");
+  if (normalized === "") {
+    throw new Error(`Page route must not be empty: ${route}`);
+  }
+  return normalized;
+}
+var configLoadSequence = 0;
+async function loadConfigFile(configFile) {
+  if (!existsSync(configFile)) {
+    return { exists: false };
+  }
+  configLoadSequence += 1;
+  const module = await import(`${configFile}?transone_config=${configLoadSequence}`);
+  return { exists: true, config: module.default };
+}
+function toInlineOverrides(options) {
+  const server = {};
+  const build = {};
+  if (options.host !== undefined) {
+    server.host = options.host;
+  }
+  if (options.port !== undefined) {
+    server.port = options.port;
+  }
+  if (options.outDir !== undefined) {
+    build.outDir = options.outDir;
+  }
+  if (options.base !== undefined) {
+    build.basePath = options.base;
+  }
+  return {
+    ...Object.keys(server).length > 0 ? { server } : {},
+    ...Object.keys(build).length > 0 ? { build } : {}
+  };
+}
+function mergeConfig(...configs) {
+  return configs.reduce((merged, config) => {
+    const server = config.server;
+    const build = config.build;
+    return {
+      target: config.target ?? merged.target,
+      components: config.components ? { ...merged.components, ...config.components } : merged.components,
+      entry: config.entry ?? merged.entry,
+      pages: config.pages ?? merged.pages,
+      server: {
+        host: server?.host ?? merged.server.host,
+        port: server?.port ?? merged.server.port,
+        proxy: {
+          ...merged.server.proxy,
+          ...server?.proxy
+        }
+      },
+      build: {
+        outDir: build?.outDir ?? merged.build.outDir,
+        basePath: build?.basePath ?? merged.build.basePath,
+        directoryPages: build?.directoryPages ?? merged.build.directoryPages
+      },
+      library: config.library ?? merged.library,
+      mp: config.mp ?? merged.mp,
+      app: config.app ?? merged.app
+    };
+  }, DEFAULT_CONFIG);
+}
+function validateUserConfig(config) {
+  assertRecord(config, "Config");
+  if (config.target !== undefined && normalizePlatform(config.target) === undefined) {
+    throw new Error(`Config target is invalid: ${String(config.target)}`);
+  }
+  if (config.components !== undefined) {
+    assertRecord(config.components, "Config components");
+    for (const key of ["include", "exclude"]) {
+      if (config.components[key] !== undefined)
+        assertStringArray(config.components[key], `Config components.${key}`);
+    }
+  }
+  if (config.entry !== undefined && typeof config.entry !== "string") {
+    throw new Error("Config entry must be a string");
+  }
+  if (config.pages !== undefined) {
+    validatePagesConfig(config.pages);
+  }
+  if (config.server !== undefined) {
+    validateServerConfig(config.server);
+  }
+  if (config.build !== undefined) {
+    validateBuildConfig(config.build);
+  }
+  if (config.library !== undefined) {
+    validateLibraryConfig(config.library);
+  }
+  if (config.mp !== undefined) {
+    validateMpConfig(config.mp);
+  }
+  if (config.app !== undefined) {
+    validateAppConfig(config.app);
+  }
+}
+function validateAppConfig(app) {
+  assertRecord(app, "Config app");
+  validateApiHost(app.host, "Config app.host");
+  if (isAppConfigMap(app)) {
+    const flatKeys = [
+      "appName",
+      "bundleId",
+      "outDir",
+      "minPlatformVersion",
+      "publicDir",
+      "pages"
+    ];
+    if (flatKeys.some((key) => (key in app))) {
+      throw new Error("Config app cannot mix flat fields with platform keys");
+    }
+    for (const platform of APP_TARGET_TYPES) {
+      if (app[platform] !== undefined) {
+        validateSingleAppConfig(app[platform], `Config app.${platform}`);
+      }
+    }
+    return;
+  }
+  validateSingleAppConfig(app, "Config app");
+}
+function validateSingleAppConfig(app, label) {
+  assertRecord(app, label);
+  validateApiHost(app.host, `${label}.host`);
+  for (const key of [
+    "appName",
+    "bundleId",
+    "outDir",
+    "minPlatformVersion",
+    "publicDir"
+  ]) {
+    if (app[key] !== undefined && typeof app[key] !== "string") {
+      throw new Error(`${label}.${key} must be a string`);
+    }
+  }
+  if (app.pages !== undefined) {
+    validatePagesConfig(app.pages, `${label}.pages`);
+  }
+}
+function validateMpConfig(mp) {
+  assertRecord(mp, "Config mp");
+  validateMiniProgramConfig(mp, "Config mp");
+  for (const platform of MP_TARGET_TYPES) {
+    if (mp[platform] !== undefined) {
+      validateMiniProgramConfig(mp[platform], `Config mp.${platform}`);
+    }
+  }
+}
+function validateMiniProgramConfig(mp, label) {
+  assertRecord(mp, label);
+  validateApiHost(mp.host, `${label}.host`);
+  for (const key of [
+    "appId",
+    "outDir",
+    "navigationBarTitleText",
+    "publicDir"
+  ]) {
+    if (mp[key] !== undefined && typeof mp[key] !== "string") {
+      throw new Error(`${label}.${key} must be a string`);
+    }
+  }
+  if (mp.pages !== undefined) {
+    validatePagesConfig(mp.pages, `${label}.pages`);
+  }
+  for (const key of ["window", "tabBar", "appExtra", "globalData"]) {
+    if (mp[key] !== undefined) {
+      assertRecord(mp[key], `${label}.${key}`);
+    }
+  }
+  if (mp.pageExtra !== undefined) {
+    assertRecord(mp.pageExtra, `${label}.pageExtra`);
+    for (const [route, extra] of Object.entries(mp.pageExtra)) {
+      assertRecord(extra, `${label}.pageExtra.${route}`);
+    }
+  }
+  if (mp.lengthUnit !== undefined && mp.lengthUnit !== "px" && mp.lengthUnit !== "rpx") {
+    throw new Error(`${label}.lengthUnit must be 'px' or 'rpx'`);
+  }
+}
+function validateLibraryConfig(library) {
+  assertRecord(library, "Config library");
+  if (library.entry !== undefined && typeof library.entry !== "string") {
+    throw new Error("Config library.entry must be a string");
+  }
+  if (library.outDir !== undefined && typeof library.outDir !== "string") {
+    throw new Error("Config library.outDir must be a string");
+  }
+  if (library.external !== undefined) {
+    assertStringArray(library.external, "Config library.external");
+  }
+  if (library.tsconfigs !== undefined) {
+    assertStringArray(library.tsconfigs, "Config library.tsconfigs");
+  }
+  for (const key of ["dts", "splitting", "sourcemap", "minify"]) {
+    if (library[key] !== undefined && typeof library[key] !== "boolean") {
+      throw new Error(`Config library.${key} must be a boolean`);
+    }
+  }
+}
+function assertStringArray(value, name) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${name} must be an array of strings`);
+  }
+}
+function validatePagesConfig(pages, label = "Config pages") {
+  assertRecord(pages, label);
+  for (const [route, entry] of Object.entries(pages)) {
+    if (!route.startsWith("/")) {
+      throw new Error(`Page route must start with "/": ${route}`);
+    }
+    if (typeof entry !== "string") {
+      throw new Error(`Page entry for "${route}" must be a string`);
+    }
+  }
+}
+function validateServerConfig(server) {
+  assertRecord(server, "Config server");
+  if (server.host !== undefined && typeof server.host !== "string") {
+    throw new Error("Config server.host must be a string");
+  }
+  const port = server.port;
+  if (port !== undefined && (typeof port !== "number" || !Number.isInteger(port) || port < 0 || port > 65535)) {
+    throw new Error("Config server.port must be an integer between 0 and 65535");
+  }
+  if (server.proxy === undefined) {
+    return;
+  }
+  assertRecord(server.proxy, "Config server.proxy");
+  for (const [prefix, value] of Object.entries(server.proxy)) {
+    if (!prefix.startsWith("/")) {
+      throw new Error(`Proxy prefix must start with "/": ${prefix}`);
+    }
+    const target = getProxyTarget(value);
+    validateProxyTarget(target);
+  }
+}
+function validateBuildConfig(build) {
+  assertRecord(build, "Config build");
+  if (build.outDir !== undefined && typeof build.outDir !== "string") {
+    throw new Error("Config build.outDir must be a string");
+  }
+  if (build.basePath !== undefined && typeof build.basePath !== "string") {
+    throw new Error("Config build.basePath must be a string");
+  }
+  if (build.directoryPages !== undefined && typeof build.directoryPages !== "boolean") {
+    throw new Error("Config build.directoryPages must be a boolean");
+  }
+}
+function getProxyTarget(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  assertRecord(value, "Proxy options");
+  if (typeof value.target !== "string") {
+    throw new Error("Proxy target must be a string");
+  }
+  if (value.changeOrigin !== undefined && typeof value.changeOrigin !== "boolean") {
+    throw new Error("Proxy changeOrigin must be a boolean");
+  }
+  if (value.rewrite !== undefined && typeof value.rewrite !== "function") {
+    throw new Error("Proxy rewrite must be a function");
+  }
+  return value.target;
+}
+function validateProxyTarget(target) {
+  try {
+    const url = new URL(target);
+    if (url.protocol === "http:" || url.protocol === "https:") {
+      return;
+    }
+  } catch {}
+  throw new Error(`Proxy target must use http or https: ${target}`);
+}
+function assertRecord(value, name) {
+  if (!isRecord(value)) {
+    throw new Error(`${name} must be an object`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function validateApiHost(host, label) {
+  if (host === undefined)
+    return;
+  if (typeof host !== "string")
+    throw new Error(`${label} must be a string`);
+  try {
+    const url = new URL(host);
+    if (url.protocol === "http:" || url.protocol === "https:")
+      return;
+  } catch {}
+  throw new Error(`${label} must use http or https`);
+}
+
+// src/target/web-target.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, isAbsolute, relative, resolve as resolve4, sep } from "path";
+
+// src/build-output.ts
+function isEntryJavaScriptOutput(output) {
+  return output.kind === "entry-point" && isJavaScriptPath(output.path);
+}
+function isStylesheetOutput(output) {
+  return /\.css$/i.test(output.path);
+}
+function isJavaScriptPath(path) {
+  return /\.(?:[cm]?js)$/i.test(path);
+}
+
+// src/document-styles.ts
+import { createHash, randomUUID } from "crypto";
+import { rename, rm, writeFile } from "fs/promises";
+import { resolve as resolve2 } from "path";
+async function emitDocumentStyles(html, outDir, assetUrl, stylesheets, componentStylesheets = []) {
+  const styles = [];
+  const linked = new Set;
+  let hasHead = false;
+  let hasHtml = false;
+  let current;
+  new HTMLRewriter().on("html", {
+    element() {
+      hasHtml = true;
+    }
+  }).on("head", {
+    element() {
+      hasHead = true;
+    }
+  }).on("head link", {
+    element(element) {
+      if (!element.getAttribute("rel")?.toLowerCase().split(/\s+/).includes("stylesheet"))
+        return;
+      const href = element.getAttribute("href");
+      if (href !== null)
+        linked.add(href);
+    }
+  }).on("head style", {
+    element(element) {
+      const attributes = [...element.attributes];
+      const type = element.getAttribute("type")?.trim().toLowerCase();
+      current = {
+        css: "",
+        attributes,
+        eligible: (!type || type === "text/css") && attributes.every(([name]) => ["type", "media", "title", "nonce"].includes(name))
+      };
+      styles.push(current);
+    },
+    text(chunk) {
+      if (current)
+        current.css += chunk.text;
+    }
+  }).transform(html);
+  const replacements = new Map;
+  const assets = new Set;
+  for (const [index2, style] of styles.entries()) {
+    if (!style.eligible || !style.css.trim() || hasRelativeResources(style.css))
+      continue;
+    const hash = createHash("sha256").update(style.css).digest("hex").slice(0, 16);
+    const path = resolve2(outDir, `document-${hash}.css`);
+    await writeStylesheet(path, style.css);
+    assets.add(path);
+    const attributes = style.attributes.map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`).join("");
+    replacements.set(index2, `<link rel="stylesheet" href="${escapeAttribute(assetUrl(path))}"${attributes}>`);
+  }
+  const missing = [...new Set(stylesheets)].filter((href) => !linked.has(href));
+  const componentLinks = renderStylesheetLinks([...new Set(componentStylesheets)].filter((href) => !linked.has(href)));
+  const importedLinks = renderStylesheetLinks(missing);
+  if (!hasHead && (importedLinks || componentLinks)) {
+    const head = `<head>${importedLinks}${componentLinks}</head>`;
+    const output2 = hasHtml ? new HTMLRewriter().on("html", {
+      element(element) {
+        element.prepend(head, { html: true });
+      }
+    }).transform(html) : html.replace(/^(\s*<!doctype[^>]*>)?/i, (doctype) => doctype + head);
+    return { html: output2, assets: [...assets] };
+  }
+  let index = 0;
+  const output = new HTMLRewriter().on("head", {
+    element(element) {
+      element.prepend(importedLinks, { html: true });
+      element.append(componentLinks, { html: true });
+    }
+  }).on("head style", {
+    element(element) {
+      const replacement = replacements.get(index++);
+      if (replacement !== undefined)
+        element.replace(replacement, { html: true });
+    }
+  }).transform(html);
+  return { html: output, assets: [...assets] };
+}
+function renderStylesheetLinks(hrefs) {
+  return hrefs.map((href) => `<link rel="stylesheet" href="${escapeAttribute(href)}">`).join("");
+}
+async function emitComponentStyles(styles, outDir) {
+  const css = [...styles.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([, value]) => value).join(`
+`);
+  if (!css)
+    return [];
+  const hash = createHash("sha256").update(css).digest("hex").slice(0, 16);
+  const path = resolve2(outDir, `components-${hash}.css`);
+  await writeStylesheet(path, css);
+  return [path];
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function hasRelativeResources(css) {
+  if (/\\|@import\b|(?:-webkit-)?image(?:-set)?\(/i.test(css))
+    return true;
+  for (const match of css.matchAll(/url\(\s*(['"]?)(.*?)\1\s*\)/gi)) {
+    const url = match[2].trim();
+    if (url && !/^(?:\/|[a-z][a-z\d+.-]*:)/i.test(url))
+      return true;
+  }
+  return false;
+}
+async function writeStylesheet(path, css) {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, css);
+    await rename(temporary, path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+
+// src/bundle-inputs.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname, resolve as resolve3 } from "path";
+function createBundleInputTracker() {
+  const inputs = new Set;
+  const plugin = {
+    name: "transone-build-inputs",
+    setup(build) {
+      build.onLoad({ filter: /.*/, namespace: "file" }, ({ path }) => {
+        inputs.add(resolve3(path));
+        return;
+      });
+    }
+  };
+  return {
+    plugin,
+    paths(result) {
+      for (const [path, input] of Object.entries(result.metafile?.inputs ?? {})) {
+        const file = resolve3(path);
+        if (!existsSync2(file))
+          continue;
+        inputs.add(file);
+        for (const dependency of input.imports) {
+          const resolved = resolve3(dependency.path);
+          if (existsSync2(resolved))
+            inputs.add(resolved);
+          try {
+            const imported = Bun.resolveSync(dependency.original ?? dependency.path, dirname(file));
+            if (existsSync2(imported))
+              inputs.add(imported);
+          } catch {}
+        }
+      }
+      if (!result.metafile) {
+        for (const file of [...inputs]) {
+          if (!/\.[cm]?[jt]sx?$/i.test(file))
+            continue;
+          const loader = file.endsWith(".tsx") ? "tsx" : file.endsWith(".jsx") ? "jsx" : /\.[cm]?ts$/.test(file) ? "ts" : "js";
+          try {
+            for (const dependency of new Bun.Transpiler({ loader }).scanImports(readFileSync(file, "utf8"))) {
+              try {
+                const path = Bun.resolveSync(dependency.path, dirname(file));
+                if (existsSync2(path))
+                  inputs.add(path);
+              } catch {}
+            }
+          } catch {}
+        }
+      }
+      return [...inputs];
+    }
+  };
+}
+
+// src/web-bundle.ts
+async function buildWebBundle(options, components) {
+  const { outdir, ...inMemoryOptions } = options;
+  const inputs = createBundleInputTracker();
+  let stylesPlugin = createWebStylesPlugin(new Set, components?.transform);
+  const buildOptions = {
+    ...inMemoryOptions,
+    metafile: true,
+    ...components?.active ? { entrypoints: [components.entrypoint] } : {}
+  };
+  const plugins = () => [
+    inputs.plugin,
+    ...inMemoryOptions.plugins ?? [],
+    ...components?.active ? [components.plugin] : [],
+    stylesPlugin
+  ];
+  let result = await Bun.build({ ...buildOptions, plugins: plugins() });
+  if (result.success && stylesPlugin.styles.size && stylesPlugin.runtimeFiles.size) {
+    stylesPlugin = createWebStylesPlugin(stylesPlugin.runtimeFiles, components?.transform);
+    result = await Bun.build({ ...buildOptions, plugins: plugins() });
+  }
+  const outputs = [];
+  if (result.success) {
+    for (const output of result.outputs) {
+      const path = buildOutputPath(outdir, output.path);
+      const contents = await output.arrayBuffer();
+      await Bun.write(path, contents);
+      outputs.push({ path, kind: output.kind, type: output.type });
+    }
+  }
+  return {
+    result: { success: result.success, logs: result.logs, outputs },
+    styles: stylesPlugin.styles,
+    inputPaths: inputs.paths(result)
+  };
+}
+
+// src/target/web-target.ts
+var INVALID_OUTPUT_DIRECTORY_MESSAGE = "Build output must be a subdirectory of the project root";
+
+class WebTarget {
+  type = "web";
+  label = "\u9759\u6001\u7AD9\u70B9 / SPA\uFF08\u590D\u7528 TSone \u7B56\u7565\u5316\u6E32\u67D3\uFF09";
+  async build(config, _options) {
+    const entries = [...new Set(Object.values(config.pages))];
+    for (const entry of entries) {
+      await assertSafeSubdirectoryDoesNotContain(config.root, config.build.outDir, entry, INVALID_OUTPUT_DIRECTORY_MESSAGE);
+    }
+    const contexts = new Map(entries.map((entry) => [entry, createWebComponentContext(config, entry)]));
+    const protectedPaths = buildInputPaths(config, entries, [...contexts.values()].flatMap((context) => context.sourcePaths));
+    return withBuildOutput({
+      root: config.root,
+      outDir: config.build.outDir,
+      protectedPaths,
+      requireProjectSubdirectory: true
+    }, (outDir) => this.buildOutput({ ...config, build: { ...config.build, outDir } }, contexts, protectedPaths));
+  }
+  async buildOutput(config, contexts, protectedPaths) {
+    const entries = [...new Set(Object.values(config.pages))];
+    const { renderProjectHtml } = await import("./project-6tft5e77.js");
+    for (const [route, entry] of Object.entries(config.pages)) {
+      await renderProjectHtml(config, {}, entry, route, contexts.get(entry));
+    }
+    const builtByEntry = new Map;
+    const failures = [];
+    for (const entry of entries) {
+      const built = await buildPage(config, entry, contexts.get(entry), protectedPaths);
+      if (typeof built === "string") {
+        failures.push(built);
+        continue;
+      }
+      builtByEntry.set(entry, built);
+    }
+    if (failures.length > 0) {
+      throw buildFailure(failures);
+    }
+    const assetsBuilt = [];
+    for (const [route, entry] of Object.entries(config.pages)) {
+      const page = builtByEntry.get(entry);
+      if (!page) {
+        throw new Error(`Missing built assets for entry: ${entry}`);
+      }
+      const pageHtmlPath = htmlPath(config, route);
+      const rendered = await renderProjectHtml(config, {
+        head: page.stylesheetAssets.map((asset) => ({
+          tag: "link",
+          attributes: {
+            rel: "stylesheet",
+            href: toAssetUrl(config.build.outDir, pageHtmlPath, asset)
+          }
+        })),
+        scripts: page.javascriptAssets.map((asset) => ({
+          type: "module",
+          src: toAssetUrl(config.build.outDir, pageHtmlPath, asset)
+        }))
+      }, page.entry, route, contexts.get(entry));
+      const { html, assets: documentStyles } = await emitDocumentStyles(rendered, config.build.outDir, (asset) => toAssetUrl(config.build.outDir, pageHtmlPath, asset), page.stylesheetAssets.map((asset) => toAssetUrl(config.build.outDir, pageHtmlPath, asset)), page.componentStylesheetAssets.map((asset) => toAssetUrl(config.build.outDir, pageHtmlPath, asset)));
+      await mkdir(dirname2(pageHtmlPath), { recursive: true });
+      await writeFile2(pageHtmlPath, html);
+      assetsBuilt.push(...page.assets, ...documentStyles, pageHtmlPath);
+    }
+    return {
+      root: config.root,
+      outDir: config.build.outDir,
+      assetsBuilt: [...new Set(assetsBuilt)]
+    };
+  }
+}
+async function buildPage(config, entry, components, protectedPaths = []) {
+  let result;
+  let styles;
+  try {
+    const bundle = await buildWebBundle({
+      entrypoints: [entry],
+      outdir: config.build.outDir,
+      target: "browser",
+      format: "esm",
+      minify: process.env.TRANSONE_MINIFY !== "0",
+      naming: { entry: "[name]-[hash].[ext]", chunk: "[name]-[hash].[ext]" },
+      throw: false
+    }, components);
+    protectedPaths.push(...bundle.inputPaths);
+    result = bundle.result;
+    styles = bundle.styles;
+  } catch (error) {
+    return pageFailureReason(entry, [errorMessage(error)]);
+  }
+  const assets = result.outputs.map((output) => resolve4(output.path));
+  const javascriptAssets = result.outputs.filter(isEntryJavaScriptOutput).map((output) => resolve4(output.path));
+  const stylesheetAssets = result.outputs.filter(isStylesheetOutput).map((output) => resolve4(output.path));
+  if (!result.success || assets.length === 0 || javascriptAssets.length === 0) {
+    return pageFailureReason(entry, result.logs.map((log) => log.message), {
+      success: result.success,
+      hasOutput: assets.length > 0,
+      hasJavaScript: javascriptAssets.length > 0
+    });
+  }
+  const componentStylesheetAssets = await emitComponentStyles(styles, config.build.outDir);
+  return {
+    entry,
+    assets: [...assets, ...componentStylesheetAssets],
+    javascriptAssets,
+    stylesheetAssets,
+    componentStylesheetAssets
+  };
+}
+function pageFailureReason(entry, logs, state) {
+  const reasons = [
+    state && !state.success ? "Bun build reported failure" : "",
+    state && !state.hasOutput ? "Bun emitted no output files" : "",
+    state && !state.hasJavaScript ? "Bun emitted no JavaScript output" : "",
+    ...logs
+  ].filter((reason) => reason !== "");
+  return `${entry}: ${reasons.join(`
+`)}`;
+}
+function buildFailure(failures) {
+  if (failures.length === 1) {
+    return new Error(`Failed to build TransOne application: ${failures[0]}`);
+  }
+  return new Error(`Failed to build TransOne application:
+${failures.map((failure) => `- ${failure}`).join(`
+`)}`);
+}
+function htmlPath(config, route) {
+  if (route === "/") {
+    return buildOutputPath(config.build.outDir, "index.html");
+  }
+  const relativeRoute = route.replace(/^\/+/, "");
+  if (config.build.directoryPages) {
+    return buildOutputPath(config.build.outDir, `${relativeRoute}/index.html`);
+  }
+  return buildOutputPath(config.build.outDir, `${relativeRoute}.html`);
+}
+function toAssetUrl(outDir, fromHtmlFile, asset) {
+  const fromOutDir = relative(outDir, asset).split(sep).join("/");
+  if (fromOutDir === "" || fromOutDir === ".." || fromOutDir.startsWith("../") || isAbsolute(fromOutDir)) {
+    throw new Error(`Build asset must be inside the output directory: ${asset}`);
+  }
+  const fromHtmlDir = dirname2(fromHtmlFile);
+  const assetPath = relative(fromHtmlDir, asset).split(sep).join("/");
+  return `./${assetPath}`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/mp/dialect.ts
+function pascalEvent(eventName) {
+  return eventName.charAt(0).toUpperCase() + eventName.slice(1);
+}
+var WEIXIN_PROJECT_SETTING = {
+  es6: true,
+  postcss: true,
+  minified: true,
+  urlCheck: false
+};
+var MP_WEIXIN_DIALECT = {
+  id: "mp-weixin",
+  label: "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F\u539F\u751F\u5DE5\u7A0B\uFF08WXML / WXSS / JS \u9759\u6001\u8F6C\u6362\uFF09",
+  templateExt: "wxml",
+  styleExt: "wxss",
+  appStyleFile: "app.wxss",
+  directivePrefix: "wx:",
+  bindEvent: (event) => `bind${event}`,
+  catchEvent: (event) => `catch${event}`,
+  projectConfigFile: "project.config.json",
+  buildProjectConfig: (mp, projectName) => ({
+    appid: mp.appId,
+    projectname: projectName,
+    compileType: "miniprogram",
+    setting: { ...WEIXIN_PROJECT_SETTING }
+  }),
+  windowDefaults: (title) => ({
+    navigationBarTitleText: title,
+    navigationBarBackgroundColor: "#ffffff",
+    navigationBarTextStyle: "black",
+    backgroundTextStyle: "light"
+  }),
+  appJsonExtras: () => ({
+    lazyCodeLoading: "requiredComponents",
+    style: "v2",
+    sitemapLocation: "sitemap.json"
+  }),
+  sitemap: true,
+  componentJson: (usingComponents) => ({
+    component: true,
+    multipleSlots: true,
+    usingComponents
+  })
+};
+var MP_ALIPAY_DIALECT = {
+  id: "mp-alipay",
+  label: "\u963F\u91CC\u5C0F\u7A0B\u5E8F\u539F\u751F\u5DE5\u7A0B\uFF08AXML / ACSS / JS \u9759\u6001\u8F6C\u6362\uFF09",
+  templateExt: "axml",
+  styleExt: "acss",
+  appStyleFile: "app.acss",
+  directivePrefix: "a:",
+  bindEvent: (event) => `on${pascalEvent(event)}`,
+  catchEvent: (event) => `catch${pascalEvent(event)}`,
+  projectConfigFile: "mini.project.json",
+  buildProjectConfig: () => ({
+    miniprogramRoot: "./",
+    component2: true,
+    enableAppxNg: true,
+    compileType: "miniprogram"
+  }),
+  windowDefaults: (title) => ({
+    defaultTitle: title,
+    titleBarColor: "#ffffff"
+  }),
+  appJsonExtras: () => ({}),
+  sitemap: false,
+  componentJson: (usingComponents) => ({
+    component: true,
+    usingComponents
+  })
+};
+var MP_BYTEDANCE_DIALECT = {
+  id: "mp-bytedance",
+  label: "\u5B57\u8282\u5C0F\u7A0B\u5E8F\u539F\u751F\u5DE5\u7A0B\uFF08TTML / TTSS / JS \u9759\u6001\u8F6C\u6362\uFF09",
+  templateExt: "ttml",
+  styleExt: "ttss",
+  appStyleFile: "app.ttss",
+  directivePrefix: "tt:",
+  bindEvent: (event) => `bind${event}`,
+  catchEvent: (event) => `catch${event}`,
+  projectConfigFile: "project.config.json",
+  buildProjectConfig: (mp, projectName) => ({
+    miniprogramRoot: "./",
+    compileType: "miniprogram",
+    projectname: projectName,
+    appid: mp.appId,
+    setting: { ...WEIXIN_PROJECT_SETTING }
+  }),
+  windowDefaults: (title) => ({
+    navigationBarTitleText: title,
+    navigationBarBackgroundColor: "#ffffff",
+    navigationBarTextStyle: "black",
+    backgroundTextStyle: "light"
+  }),
+  appJsonExtras: () => ({}),
+  sitemap: false,
+  componentJson: (usingComponents) => ({
+    component: true,
+    usingComponents
+  })
+};
+var MP_XIAOHONGSHU_DIALECT = {
+  id: "mp-xiaohongshu",
+  label: "\u5C0F\u7EA2\u4E66\u5C0F\u7A0B\u5E8F\u539F\u751F\u5DE5\u7A0B\uFF08XHSML / CSS / JS \u9759\u6001\u8F6C\u6362\uFF09",
+  templateExt: "xhsml",
+  styleExt: "css",
+  appStyleFile: "app.css",
+  directivePrefix: "xhs:",
+  bindEvent: (event) => `bind${event}`,
+  catchEvent: (event) => `catch${event}`,
+  projectConfigFile: "project.config.json",
+  buildProjectConfig: (mp, projectName) => ({
+    appid: mp.appId,
+    projectname: projectName,
+    compileType: "miniprogram"
+  }),
+  windowDefaults: (title) => ({
+    navigationBarTitleText: title,
+    navigationBarBackgroundColor: "#ffffff",
+    navigationBarTextStyle: "black",
+    backgroundTextStyle: "light"
+  }),
+  appJsonExtras: () => ({}),
+  sitemap: false,
+  componentJson: (usingComponents) => ({
+    component: true,
+    multipleSlots: true,
+    usingComponents
+  })
+};
+
+// src/target/mp-target.ts
+class MpTarget {
+  dialect;
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  get type() {
+    return this.dialect.id;
+  }
+  get label() {
+    return this.dialect.label;
+  }
+  async build(config, _options) {
+    if (!config.mp) {
+      throw new Error("Mini program build requires config.mp\uFF08\u8BF7\u5728 transone.config.ts \u914D\u7F6E mp \u5B57\u6BB5\uFF0C" + "\u5982 appId / pages / outDir\uFF09");
+    }
+    const { buildMiniProgram } = await import("./build-mp-y5pwahsy.js");
+    return buildMiniProgram(config, this.dialect);
+  }
+}
+var mpWeixinTarget = new MpTarget(MP_WEIXIN_DIALECT);
+var mpAlipayTarget = new MpTarget(MP_ALIPAY_DIALECT);
+var mpBytedanceTarget = new MpTarget(MP_BYTEDANCE_DIALECT);
+var mpXiaohongshuTarget = new MpTarget(MP_XIAOHONGSHU_DIALECT);
+
+// src/app/build-app.ts
+import { cp, mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname3, resolve as resolve5 } from "path";
+
+// src/app/errors.ts
+import { basename } from "path";
+function nativeError(filePath, message) {
+  return new Error(`[transone app] ${basename(filePath)}: ${message}`);
+}
+
+// src/app/analyze.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+
+// src/app/components.ts
+import ts from "typescript";
+import { realpathSync } from "fs";
+var CONTAINERS = new Set(["view", "main", "div"]);
+var TEXT = new Set(["text", "span", "p", "h1"]);
+var STYLES = new Set([
+  "color",
+  "backgroundColor",
+  "fontSize",
+  "fontWeight",
+  "padding",
+  "margin",
+  "width",
+  "height",
+  "borderRadius",
+  "textAlign"
+]);
+function fail(node, message) {
+  const source = node.getSourceFile();
+  const point = source.getLineAndCharacterOfPosition(node.getStart());
+  throw nativeError(`${source.fileName}`, `${point.line + 1}:${point.character + 1} ${message}`);
+}
+function unwrap(node) {
+  while (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isNonNullExpression(node) || ts.isSatisfiesExpression(node))
+    node = node.expression;
+  return node;
+}
+function name(node) {
+  return ts.isIdentifier(node) || ts.isStringLiteralLike(node) || ts.isNumericLiteral(node) ? node.text : fail(node, "\u53EA\u652F\u6301\u9759\u6001\u5C5E\u6027\u540D");
+}
+function property(node, key) {
+  const item = node.properties.find((p) => !ts.isSpreadAssignment(p) && name(p.name) === key);
+  if (!item)
+    return;
+  if (ts.isPropertyAssignment(item))
+    return item.initializer;
+  if (ts.isShorthandPropertyAssignment(item))
+    return item.name;
+  return fail(item, "\u53EA\u652F\u6301\u9759\u6001\u5BF9\u8C61\u5C5E\u6027");
+}
+function object(node, label) {
+  if (!node || !ts.isObjectLiteralExpression(unwrap(node))) {
+    if (node)
+      fail(node, `${label} \u5FC5\u987B\u662F\u9759\u6001\u5BF9\u8C61`);
+    throw new Error(`[transone app] \u7F3A\u5C11 ${label}`);
+  }
+  return unwrap(node);
+}
+function returnValue(member) {
+  const declaration = member.declaration;
+  if (!ts.isMethodDeclaration(declaration) || !declaration.body || declaration.parameters.length !== 0 || declaration.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) || declaration.body.statements.length !== 1 || !ts.isReturnStatement(declaration.body.statements[0]) || !declaration.body.statements[0].expression)
+    fail(declaration, `${declaration.name?.getText()} \u53EA\u652F\u6301\u5355\u4E2A\u9759\u6001 return \u8868\u8FBE\u5F0F`);
+  return declaration.body.statements[0].expression;
+}
+function isTopLevelStartup(call) {
+  function outer(node) {
+    let value = node;
+    while (value.parent && (ts.isParenthesizedExpression(value.parent) || ts.isAsExpression(value.parent) || ts.isNonNullExpression(value.parent) || ts.isSatisfiesExpression(value.parent)))
+      value = value.parent;
+    return value;
+  }
+  let expression = outer(call);
+  const access = expression.parent;
+  if (ts.isPropertyAccessExpression(access) && access.name.text === "mount" && ts.isCallExpression(access.parent) && access.parent.expression === access && !access.parent.arguments.length)
+    expression = outer(access.parent);
+  const parent = expression.parent;
+  if (ts.isExpressionStatement(parent) || ts.isExportAssignment(parent))
+    return ts.isSourceFile(parent.parent);
+  if (ts.isVariableDeclaration(parent) && parent.initializer === expression && ts.isIdentifier(parent.name) && ts.isVariableDeclarationList(parent.parent)) {
+    const statement = parent.parent.parent;
+    return ts.isVariableStatement(statement) && ts.isSourceFile(statement.parent);
+  }
+  return false;
+}
+function validateStaticMetadata(expression) {
+  const node = unwrap(expression);
+  if (ts.isStringLiteralLike(node) || ts.isNumericLiteral(node) || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword)
+    return;
+  if (ts.isObjectLiteralExpression(node)) {
+    const seen = new Set;
+    for (const item of node.properties) {
+      if (!ts.isPropertyAssignment(item))
+        fail(item, "\u539F\u751F createApp \u6587\u6863\u914D\u7F6E\u53EA\u652F\u6301\u9759\u6001\u5B57\u9762\u91CF\u5C5E\u6027");
+      const key = name(item.name);
+      if (seen.has(key))
+        fail(item, `\u539F\u751F createApp \u6587\u6863\u914D\u7F6E\u5B58\u5728\u91CD\u590D\u5C5E\u6027 ${key}`);
+      seen.add(key);
+      validateStaticMetadata(item.initializer);
+    }
+    return;
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    for (const value of node.elements)
+      validateStaticMetadata(value);
+    return;
+  }
+  fail(node, "\u539F\u751F createApp \u6587\u6863\u914D\u7F6E\u53EA\u652F\u6301\u9759\u6001\u5B57\u9762\u91CF\u8868\u8FBE\u5F0F");
+}
+function composeNativeScreen(entry, config, onSourcePaths) {
+  const index = createComponentIndex({
+    root: config.root,
+    entrypoints: [entry],
+    platform: config.platform,
+    ...config.components
+  });
+  onSourcePaths?.(index.sources.map((source2) => source2.fileName));
+  const source = index.sources.find((s) => realpathSync(s.fileName) === realpathSync(entry));
+  if (!source)
+    throw nativeError(entry, "\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728");
+  const compiler = new NativeComposer(index);
+  const roots = [];
+  const startupCalls = [];
+  function findStartup(node) {
+    if (ts.isCallExpression(node) && compiler.frameworkCall(node, "createApp"))
+      startupCalls.push(node);
+    ts.forEachChild(node, findStartup);
+  }
+  findStartup(source);
+  function createdApp(expression, seen = new Set) {
+    const value = unwrap(expression);
+    if (seen.has(value))
+      return false;
+    seen.add(value);
+    if (ts.isCallExpression(value))
+      return compiler.frameworkCall(value, "createApp");
+    const declaration = index.symbolAt(value)?.valueDeclaration;
+    return !!declaration && ts.isVariableDeclaration(declaration) && !!declaration.initializer && createdApp(declaration.initializer, seen);
+  }
+  function rejectInstalledPlugins(node) {
+    if (ts.isFunctionLike(node) || ts.isClassLike(node))
+      return;
+    if (ts.isCallExpression(node)) {
+      const callee = unwrap(node.expression);
+      const receiver = ts.isPropertyAccessExpression(callee) ? callee.expression : ts.isElementAccessExpression(callee) ? callee.expression : undefined;
+      const method = ts.isPropertyAccessExpression(callee) ? callee.name.text : ts.isElementAccessExpression(callee) && ts.isStringLiteralLike(callee.argumentExpression) ? callee.argumentExpression.text : undefined;
+      if (method === "use" && receiver && (createdApp(receiver) || compiler.frameworkCall(node, "use")))
+        fail(node, "\u539F\u751F App \u4E0D\u652F\u6301\u8DEF\u7531\u6216\u63D2\u4EF6\u5B89\u88C5 app.use()");
+    }
+    ts.forEachChild(node, rejectInstalledPlugins);
+  }
+  rejectInstalledPlugins(source);
+  for (const call of startupCalls) {
+    if (!isTopLevelStartup(call))
+      fail(call, "\u539F\u751F createApp \u5FC5\u987B\u76F4\u63A5\u4F4D\u4E8E\u9876\u5C42\u542F\u52A8\u8BED\u53E5\uFF1B\u4E0D\u652F\u6301\u6761\u4EF6\u3001\u51FD\u6570\u6216\u52A8\u6001\u8868\u8FBE\u5F0F");
+    if (call.arguments.length !== 1)
+      fail(call, "\u539F\u751F createApp \u53EA\u652F\u6301\u4E00\u4E2A\u9759\u6001 options \u5BF9\u8C61");
+    const options = object(call.arguments[0], "createApp options");
+    const seen = new Set;
+    for (const option of options.properties) {
+      if (ts.isSpreadAssignment(option))
+        fail(option, "\u539F\u751F createApp options \u4E0D\u652F\u6301\u5BF9\u8C61\u5C55\u5F00");
+      if (!ts.isPropertyAssignment(option) && !ts.isShorthandPropertyAssignment(option))
+        fail(option, "\u539F\u751F createApp options \u53EA\u652F\u6301\u9759\u6001\u5C5E\u6027");
+      const key = name(option.name);
+      if (seen.has(key))
+        fail(option, `\u539F\u751F createApp options \u5B58\u5728\u91CD\u590D\u5C5E\u6027 ${key}`);
+      seen.add(key);
+      if (!["root", "rootProps", "document", "rootElement"].includes(key))
+        fail(option, `\u539F\u751F createApp \u4E0D\u652F\u6301 options.${key}`);
+      if (key === "document" || key === "rootElement")
+        validateStaticMetadata(ts.isPropertyAssignment(option) ? option.initializer : option.name);
+    }
+    const root = property(options, "root");
+    if (!root)
+      fail(call, "createApp \u7F3A\u5C11 root");
+    roots.push({ reference: root, props: property(options, "rootProps") });
+  }
+  if (roots.length > 1)
+    fail(roots[1].reference, "\u539F\u751F\u9875\u9762\u53EA\u652F\u6301\u4E00\u4E2A createApp \u6839\u7EC4\u4EF6");
+  let reference = roots[0] && index.resolve(roots[0].reference, source);
+  if (roots.length && (!reference || !index.isComponent(reference)))
+    fail(roots[0].reference, "root \u5FC5\u987B\u662F\u53EF\u89E3\u6790\u7684\u9759\u6001\u7EC4\u4EF6\u5F15\u7528");
+  if (!reference) {
+    const local = index.classes.filter((c) => c.source === source && index.isComponent(c));
+    const logical = local.filter((c) => index.metadata(c).platforms.length === 0);
+    const candidates = logical.length ? logical : local;
+    if (candidates.length > 1)
+      fail(candidates[1].declaration, "\u591A\u4E2A\u6839\u7EC4\u4EF6\uFF0C\u8BF7\u4F7F\u7528 createApp({ root })");
+    reference = candidates[0];
+  }
+  return reference ? compiler.screen(reference, roots[0]?.props) : undefined;
+}
+
+class NativeComposer {
+  index;
+  nextInstance = 0;
+  state = [];
+  stack = [];
+  constructor(index) {
+    this.index = index;
+  }
+  frameworkCall(call, expected) {
+    const symbol = this.index.symbolAt(call.expression);
+    return symbol?.name === expected && !!symbol.declarations?.some((d) => /(?:^|\/)transone\/(?:lib|dist)\//.test(d.getSourceFile().fileName.replace(/\\/g, "/")));
+  }
+  screen(reference, props) {
+    const bindings = new Map;
+    if (props)
+      for (const p of object(props, "rootProps").properties) {
+        if (!ts.isPropertyAssignment(p))
+          fail(p, "rootProps \u53EA\u652F\u6301\u9759\u6001\u5C5E\u6027");
+        bindings.set(name(p.name), {
+          kind: "literal",
+          value: this.literal(p.initializer)
+        });
+      }
+    const root = this.instance(reference, bindings);
+    if (root.kind !== "container")
+      fail(reference.declaration, "\u6839\u8282\u70B9\u5FC5\u987B\u662F\u5BB9\u5668\u8282\u70B9");
+    return { name: reference.className, state: this.state, root };
+  }
+  member(reference, key) {
+    return this.index.members(reference).find((m) => m.declaration.name && name(m.declaration.name) === key && !(ts.canHaveModifiers(m.declaration) && ts.getModifiers(m.declaration)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword)));
+  }
+  parent(member, key) {
+    const parent = this.index.metadata(member.owner).parent;
+    const result = parent && this.member(parent, key);
+    if (!result)
+      fail(member.declaration, `\u65E0\u6CD5\u89E3\u6790 super.${key}`);
+    return result;
+  }
+  literal(expression, seen = new Set) {
+    const node = unwrap(expression);
+    if (ts.isStringLiteralLike(node))
+      return node.text;
+    if (ts.isNumericLiteral(node))
+      return Number(node.text);
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+      return true;
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+      return false;
+    if (ts.isPrefixUnaryExpression(node) && (node.operator === ts.SyntaxKind.MinusToken || node.operator === ts.SyntaxKind.PlusToken)) {
+      const value = this.literal(node.operand, seen);
+      if (typeof value === "number")
+        return node.operator === ts.SyntaxKind.MinusToken ? -value : value;
+    }
+    if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node)) {
+      const declaration = this.index.symbolAt(node)?.valueDeclaration;
+      if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isVariableDeclarationList(declaration.parent) && declaration.parent.flags & ts.NodeFlags.Const) {
+        if (seen.has(declaration))
+          fail(node, "\u5E38\u91CF\u5F15\u7528\u5FAA\u73AF");
+        return this.literal(declaration.initializer, new Set([...seen, declaration]));
+      }
+    }
+    return fail(node, `\u4E0D\u652F\u6301\u7684\u539F\u751F\u8868\u8FBE\u5F0F: ${node.getText()}`);
+  }
+  initialState(member, active = new Set) {
+    if (active.has(member.declaration))
+      fail(member.declaration, "initState \u5FAA\u73AF");
+    active.add(member.declaration);
+    const value = object(returnValue(member), "initState()");
+    const values = new Map;
+    for (const p of value.properties) {
+      if (ts.isSpreadAssignment(p)) {
+        const call = unwrap(p.expression);
+        if (!ts.isCallExpression(call) || !ts.isPropertyAccessExpression(call.expression) || call.expression.expression.kind !== ts.SyntaxKind.SuperKeyword || call.expression.name.text !== "initState" || call.arguments.length)
+          fail(p, "state \u5C55\u5F00\u53EA\u652F\u6301 super.initState()");
+        for (const [key, value2] of this.initialState(this.parent(member, "initState"), active))
+          values.set(key, value2);
+      } else if (ts.isPropertyAssignment(p))
+        values.set(name(p.name), this.literal(p.initializer));
+      else
+        fail(p, "state \u5FC5\u987B\u4F7F\u7528\u9759\u6001\u5C5E\u6027");
+    }
+    active.delete(member.declaration);
+    return values;
+  }
+  instance(logical, props) {
+    const reference = this.index.select(logical);
+    if (this.stack.includes(reference.id))
+      fail(reference.declaration, `\u9759\u6001\u7EC4\u4EF6\u7EC4\u5408\u5FAA\u73AF: ${reference.className}`);
+    this.stack.push(reference.id);
+    this.validateInstance(reference);
+    const instance = {
+      reference,
+      prefix: `c${this.nextInstance++}_`,
+      state: new Map,
+      props
+    };
+    const init = this.member(reference, "initState");
+    if (init)
+      for (const [key, value] of this.initialState(init)) {
+        const scoped = `${instance.prefix}s${instance.state.size}_${key.replace(/[^A-Za-z0-9_]/g, "_")}`;
+        instance.state.set(key, scoped);
+        this.state.push({ key: scoped, value });
+      }
+    const styles = this.member(reference, "initStyles");
+    if (styles)
+      this.validateStyles(styles);
+    const render = this.member(reference, "render");
+    if (!render)
+      fail(reference.declaration, "\u7F3A\u5C11 render()");
+    const root = this.node(returnValue(render), instance, render);
+    this.stack.pop();
+    return root;
+  }
+  validateInstance(reference) {
+    for (const owner of this.index.hierarchy(reference))
+      for (const member of owner.declaration.members) {
+        if (ts.isConstructorDeclaration(member))
+          fail(member, "\u539F\u751F\u7EC4\u4EF6\u4E0D\u652F\u6301\u81EA\u5B9A\u4E49 constructor");
+        if (ts.isPropertyDeclaration(member) && member.initializer && !member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))
+          fail(member, "\u539F\u751F\u7EC4\u4EF6\u4E0D\u652F\u6301\u5B9E\u4F8B\u5B57\u6BB5\u521D\u59CB\u5316\uFF1B\u8BF7\u4F7F\u7528 initState");
+      }
+    for (const key of [
+      "beforeMount",
+      "onMounted",
+      "beforeUpdate",
+      "onUpdated",
+      "onPropsChange",
+      "beforeUnmount",
+      "onUnmounted",
+      "onErrorCaptured"
+    ]) {
+      const member = this.member(reference, key);
+      if (member && (!ts.isMethodDeclaration(member.declaration) || member.declaration.body?.statements.length))
+        fail(member.declaration, `\u539F\u751F\u7EC4\u4EF6\u4E0D\u652F\u6301\u751F\u547D\u5468\u671F ${key} \u4E2D\u7684 JavaScript`);
+    }
+  }
+  validateStyles(member) {
+    const declaration = member.declaration;
+    if (!ts.isMethodDeclaration(declaration) || !declaration.body)
+      fail(declaration, "\u539F\u751F initStyles \u5FC5\u987B\u5177\u6709\u9759\u6001\u65B9\u6CD5\u4F53");
+    for (const statement of declaration.body.statements) {
+      if (ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression) && ts.isPropertyAccessExpression(statement.expression.expression) && statement.expression.expression.expression.kind === ts.SyntaxKind.SuperKeyword && statement.expression.expression.name.text === "initStyles" && !statement.expression.arguments.length)
+        this.validateStyles(this.parent(member, "initStyles"));
+      else
+        fail(statement, "\u539F\u751F initStyles \u4E0D\u652F\u6301 CSS \u89C4\u5219\uFF1B\u8BF7\u4F7F\u7528 VNode \u5185\u8054 style \u6216\u8986\u76D6\u4E3A\u7A7A\u65B9\u6CD5");
+    }
+  }
+  binding(expression, instance) {
+    const node = unwrap(expression);
+    if (ts.isPropertyAccessExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.expression.kind === ts.SyntaxKind.ThisKeyword) {
+      const group = node.expression.name.text;
+      const key = node.name.text;
+      if (group === "state") {
+        const scoped = instance.state.get(key);
+        if (!scoped)
+          fail(node, `\u672A\u58F0\u660E\u7684 state.${key}`);
+        return { kind: "state", key: scoped };
+      }
+      if (group === "props") {
+        const binding = instance.props.get(key);
+        if (!binding)
+          fail(node, `\u672A\u63D0\u4F9B\u7684 props.${key}`);
+        return binding;
+      }
+    }
+    return { kind: "literal", value: this.literal(node) };
+  }
+  text(expression, instance) {
+    const value = this.binding(expression, instance);
+    if (value.kind === "state")
+      return [value];
+    if (typeof value.value !== "string")
+      return [{ kind: "literal", value: String(value.value) }];
+    const result = [];
+    const matcher = /{{([^}]+)}}/g;
+    let cursor = 0;
+    let match;
+    while (match = matcher.exec(value.value)) {
+      if (match.index > cursor)
+        result.push({
+          kind: "literal",
+          value: value.value.slice(cursor, match.index)
+        });
+      const key = match[1].trim();
+      const scoped = instance.state.get(key);
+      const prop = instance.props.get(key);
+      if (scoped)
+        result.push({ kind: "state", key: scoped });
+      else if (prop)
+        result.push(prop.kind === "state" ? prop : { kind: "literal", value: String(prop.value) });
+      else
+        fail(expression, `\u53EA\u652F\u6301\u5DF2\u58F0\u660E state/props \u7684 {{key}} \u7ED1\u5B9A: ${key}`);
+      cursor = matcher.lastIndex;
+    }
+    if (cursor < value.value.length || !result.length)
+      result.push({ kind: "literal", value: value.value.slice(cursor) });
+    return result;
+  }
+  props(node, instance) {
+    const result = new Map;
+    if (!node)
+      return result;
+    for (const p of object(node, "\u7EC4\u4EF6 props").properties) {
+      if (!ts.isPropertyAssignment(p))
+        fail(p, "\u7EC4\u4EF6 props \u53EA\u652F\u6301\u9759\u6001\u5C5E\u6027");
+      result.set(name(p.name), this.binding(p.initializer, instance));
+    }
+    return result;
+  }
+  style(props) {
+    if (!props)
+      return;
+    const p = object(props, "VNode props");
+    for (const field of p.properties)
+      if (ts.isSpreadAssignment(field) || name(field.name) !== "style")
+        fail(field, "\u539F\u751F VNode props \u53EA\u652F\u6301 style");
+    const style = property(p, "style");
+    if (!style)
+      return;
+    const out = {};
+    for (const item of object(style, "style").properties) {
+      if (!ts.isPropertyAssignment(item) || !STYLES.has(name(item.name)))
+        fail(item, "\u4E0D\u652F\u6301\u7684\u539F\u751F\u6837\u5F0F\u5C5E\u6027");
+      const key = name(item.name), value = this.literal(item.initializer);
+      if (["color", "backgroundColor", "fontWeight", "textAlign"].includes(key) && (typeof value === "string" || typeof value === "number"))
+        out[key] = value;
+      else if (typeof value === "number")
+        out[key] = value;
+      else if (typeof value === "string" && /^\d+(\.\d+)?px$/.test(value))
+        out[key] = parseFloat(value);
+      else
+        fail(item, `\u6837\u5F0F ${key} \u53EA\u652F\u6301\u6570\u5B57\u6216 px`);
+    }
+    return out;
+  }
+  node(expression, instance, owner) {
+    const node = unwrap(expression);
+    let tag, props, children, listeners;
+    if (ts.isCallExpression(node) && this.frameworkCall(node, "createComponent")) {
+      const first = node.arguments[0];
+      if (!first)
+        fail(node, "createComponent \u7F3A\u5C11\u9759\u6001\u7EC4\u4EF6");
+      if (ts.isObjectLiteralExpression(unwrap(first))) {
+        if (node.arguments.length !== 1)
+          fail(node, "createComponent options \u4E0D\u652F\u6301\u989D\u5916\u53C2\u6570/slots");
+        return this.componentNode(unwrap(first), instance);
+      }
+      if (node.arguments.length > 2)
+        fail(node, "\u539F\u751F\u7EC4\u4EF6\u4E0D\u652F\u6301 children/slots \u6216\u989D\u5916\u53C2\u6570");
+      const reference = this.index.resolve(first, first.getSourceFile());
+      if (!reference || !this.index.isComponent(reference))
+        fail(node, "createComponent \u5FC5\u987B\u5F15\u7528\u9759\u6001\u7EC4\u4EF6");
+      return this.instance(reference, this.props(node.arguments[1], instance));
+    } else if (ts.isCallExpression(node) && this.frameworkCall(node, "h")) {
+      if (node.arguments.length > 4)
+        fail(node, "h \u4E0D\u652F\u6301\u989D\u5916\u53C2\u6570/slots");
+      [tag, props, children, listeners] = node.arguments;
+    } else if (ts.isObjectLiteralExpression(node)) {
+      if (property(node, "component"))
+        return this.componentNode(node, instance);
+      for (const p of node.properties)
+        if (ts.isSpreadAssignment(p) || !["tag", "props", "children", "listeners"].includes(name(p.name)))
+          fail(p, "\u4E0D\u652F\u6301\u7684\u539F\u751F VNode \u5C5E\u6027/slots");
+      tag = property(node, "tag");
+      props = property(node, "props");
+      children = property(node, "children");
+      listeners = property(node, "listeners");
+    } else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.expression.kind === ts.SyntaxKind.SuperKeyword && node.expression.name.text === "render" && !node.arguments.length) {
+      const parent = this.parent(owner, "render");
+      return this.node(returnValue(parent), instance, parent);
+    } else
+      return fail(node, "\u53EA\u652F\u6301\u9759\u6001 h/createComponent/VNode \u8868\u8FBE\u5F0F");
+    if (!tag)
+      fail(node, "VNode \u7F3A\u5C11 tag");
+    const tagName = this.literal(tag);
+    if (typeof tagName !== "string")
+      fail(tag, "VNode tag \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+    const style = this.style(props);
+    let values = [];
+    if (children) {
+      const array = unwrap(children);
+      if (!ts.isArrayLiteralExpression(array))
+        fail(children, "children \u5FC5\u987B\u662F\u9759\u6001\u6570\u7EC4");
+      values = array.elements;
+    }
+    if (CONTAINERS.has(tagName)) {
+      if (listeners)
+        fail(listeners, "\u539F\u751F\u5BB9\u5668\u4E0D\u652F\u6301 listeners");
+      return {
+        kind: "container",
+        children: values.map((child) => this.node(child, instance, owner)),
+        ...style ? { style } : {}
+      };
+    }
+    if (!TEXT.has(tagName) && tagName !== "button")
+      fail(tag, `\u4E0D\u652F\u6301\u7684\u539F\u751F\u8282\u70B9: ${tagName}`);
+    const parts = values.flatMap((value) => this.text(value, instance));
+    if (tagName === "button")
+      return {
+        kind: "button",
+        parts,
+        action: this.click(listeners, instance),
+        ...style ? { style } : {}
+      };
+    if (listeners)
+      fail(listeners, "\u539F\u751F\u6587\u672C\u4E0D\u652F\u6301 listeners");
+    return { kind: "text", parts, ...style ? { style } : {} };
+  }
+  componentNode(options, instance) {
+    for (const p of options.properties)
+      if (ts.isSpreadAssignment(p) || !["component", "props"].includes(name(p.name)))
+        fail(p, "\u539F\u751F\u7EC4\u4EF6\u4E0D\u652F\u6301 slots\u3001emitters \u6216\u52A8\u6001 options");
+    const component = property(options, "component");
+    const reference = component && this.index.resolve(component, component.getSourceFile());
+    if (!reference || !this.index.isComponent(reference))
+      fail(options, "createComponent \u5FC5\u987B\u5F15\u7528\u9759\u6001\u7EC4\u4EF6");
+    return this.instance(reference, this.props(property(options, "props"), instance));
+  }
+  click(listeners, instance) {
+    const options = object(listeners, "button listeners.click");
+    for (const p of options.properties)
+      if (ts.isSpreadAssignment(p) || name(p.name) !== "click")
+        fail(p, "\u53EA\u652F\u6301 listeners.click");
+    const handler = property(options, "click");
+    if (!handler || !ts.isArrowFunction(handler) || handler.parameters.length)
+      fail(options, "click \u53EA\u652F\u6301 () => this.method()");
+    const body = handler.body;
+    const call = ts.isBlock(body) && body.statements.length === 1 && ts.isExpressionStatement(body.statements[0]) ? body.statements[0].expression : body;
+    if (!ts.isCallExpression(call) || !ts.isPropertyAccessExpression(call.expression) || call.expression.expression.kind !== ts.SyntaxKind.ThisKeyword || call.arguments.length)
+      fail(handler, "click \u53EA\u652F\u6301\u8C03\u7528 this.method()");
+    const member = this.member(instance.reference, call.expression.name.text);
+    if (!member)
+      fail(call, "click \u65B9\u6CD5\u4E0D\u5B58\u5728");
+    return this.action(member, instance, new Set);
+  }
+  action(member, instance, active) {
+    if (active.has(member.declaration))
+      fail(member.declaration, "\u539F\u751F\u65B9\u6CD5\u8C03\u7528\u5FAA\u73AF");
+    const declaration = member.declaration;
+    if (!ts.isMethodDeclaration(declaration) || !declaration.body || declaration.parameters.length || declaration.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
+      fail(declaration, "\u539F\u751F\u52A8\u4F5C\u53EA\u652F\u6301\u540C\u6B65\u65E0\u53C2\u6570\u65B9\u6CD5");
+    const next = new Set([...active, declaration]);
+    const actions = [];
+    for (const statement of declaration.body.statements) {
+      if (!ts.isExpressionStatement(statement))
+        fail(statement, "\u65B9\u6CD5\u4E0D\u652F\u6301\u539F\u751F\u7F16\u8BD1");
+      const expression = unwrap(statement.expression);
+      if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression) && !expression.arguments.length) {
+        const target = expression.expression;
+        let called;
+        if (target.expression.kind === ts.SyntaxKind.SuperKeyword)
+          called = this.parent(member, target.name.text);
+        else if (target.expression.kind === ts.SyntaxKind.ThisKeyword)
+          called = this.member(instance.reference, target.name.text);
+        if (!called)
+          fail(expression, "\u65B9\u6CD5\u4E0D\u652F\u6301\u539F\u751F\u7F16\u8BD1");
+        actions.push(this.action(called, instance, next));
+        continue;
+      }
+      if (ts.isBinaryExpression(expression) && ts.isPropertyAccessExpression(expression.left) && ts.isPropertyAccessExpression(expression.left.expression) && expression.left.expression.expression.kind === ts.SyntaxKind.ThisKeyword && expression.left.expression.name.text === "state") {
+        const key = instance.state.get(expression.left.name.text);
+        if (!key)
+          fail(expression.left, "\u52A8\u4F5C\u5F15\u7528\u672A\u58F0\u660E state");
+        const value = this.literal(expression.right);
+        const operator = expression.operatorToken.kind;
+        const initial = this.state.find((s) => s.key === key).value;
+        if ((operator === ts.SyntaxKind.PlusEqualsToken || operator === ts.SyntaxKind.MinusEqualsToken) && typeof value === "number" && typeof initial === "number")
+          actions.push({
+            kind: "increment",
+            key,
+            by: operator === ts.SyntaxKind.MinusEqualsToken ? -value : value
+          });
+        else if (operator === ts.SyntaxKind.EqualsToken && typeof value === typeof initial)
+          actions.push({ kind: "set-literal", key, value });
+        else
+          fail(expression, "\u539F\u751F\u52A8\u4F5C\u53EA\u652F\u6301\u540C\u7C7B\u578B\u8D4B\u503C\u6216\u6570\u503C\u589E\u51CF");
+        continue;
+      }
+      fail(expression, "\u65B9\u6CD5\u4E0D\u652F\u6301\u539F\u751F\u7F16\u8BD1");
+    }
+    if (!actions.length)
+      fail(declaration, "\u539F\u751F\u52A8\u4F5C\u4E0D\u80FD\u4E3A\u7A7A");
+    return actions.length === 1 ? actions[0] : { kind: "sequence", actions };
+  }
+}
+
+// src/app/analyze.ts
+var CONTAINERS2 = new Set(["view", "main", "div"]);
+var TEXT2 = new Set(["text", "span", "p", "h1"]);
+var STYLE_KEYS = new Set(["color", "backgroundColor", "fontSize", "fontWeight", "padding", "margin", "width", "height", "borderRadius", "textAlign"]);
+async function analyzeNativeScreen(entry, config, onSourcePaths) {
+  if (!existsSync3(entry))
+    throw nativeError(entry, "\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728");
+  if (config) {
+    const screen = composeNativeScreen(entry, config, onSourcePaths);
+    if (screen)
+      return screen;
+  }
+  const ts2 = await loadTypescript();
+  const source = ts2.createSourceFile(entry, readFileSync2(entry, "utf8"), ts2.ScriptTarget.Latest, true);
+  const component = source.statements.find((s) => ts2.isClassDeclaration(s));
+  if (!component)
+    throw nativeError(entry, "\u672A\u627E\u5230 Component \u7C7B");
+  const state = readState(ts2, component, entry);
+  const actions = new Map;
+  for (const member of component.members)
+    if (ts2.isMethodDeclaration(member) && ts2.isIdentifier(member.name)) {
+      const action = readAction(ts2, member, entry);
+      if (action)
+        actions.set(member.name.text, action);
+    }
+  const render = component.members.find((m) => ts2.isMethodDeclaration(m) && m.name.getText(source) === "render");
+  const value = render?.body?.statements.find(ts2.isReturnStatement)?.expression;
+  if (!value || !ts2.isObjectLiteralExpression(value))
+    throw nativeError(entry, "render() \u5FC5\u987B\u8FD4\u56DE\u9759\u6001 VNode \u5BF9\u8C61");
+  const root = readNode(ts2, value, entry, new Set(state.map((item) => item.key)), actions);
+  if (root.kind !== "container")
+    throw nativeError(entry, "\u6839\u8282\u70B9\u5FC5\u987B\u662F\u5BB9\u5668\u8282\u70B9");
+  return { name: component.name?.text ?? "App", state, root };
+}
+function readState(ts2, component, file) {
+  const method = component.members.find((m) => ts2.isMethodDeclaration(m) && m.name.getText() === "initState");
+  const value = method?.body?.statements.find(ts2.isReturnStatement)?.expression;
+  if (!value)
+    return [];
+  if (!ts2.isObjectLiteralExpression(value))
+    throw nativeError(file, "initState() \u5FC5\u987B\u8FD4\u56DE\u5BF9\u8C61\u5B57\u9762\u91CF");
+  return value.properties.map((item) => {
+    if (!ts2.isPropertyAssignment(item) || !ts2.isIdentifier(item.name))
+      throw nativeError(file, "state \u5FC5\u987B\u4F7F\u7528\u6807\u8BC6\u7B26\u5C5E\u6027");
+    const literal = literalValue(ts2, item.initializer);
+    if (literal === undefined)
+      throw nativeError(file, `state.${item.name.text} \u5FC5\u987B\u662F\u5B57\u9762\u91CF`);
+    return { key: item.name.text, value: literal };
+  });
+}
+function readAction(ts2, method, file) {
+  const expression = method.body?.statements[0];
+  if (!expression || !ts2.isExpressionStatement(expression) || !ts2.isBinaryExpression(expression.expression))
+    return;
+  const binary = expression.expression;
+  if (!ts2.isPropertyAccessExpression(binary.left) || !ts2.isPropertyAccessExpression(binary.left.expression) || binary.left.expression.expression.kind !== ts2.SyntaxKind.ThisKeyword || binary.left.expression.name.text !== "state")
+    return;
+  const value = literalValue(ts2, binary.right);
+  const key = binary.left.name.text;
+  if ((binary.operatorToken.kind === ts2.SyntaxKind.PlusEqualsToken || binary.operatorToken.kind === ts2.SyntaxKind.MinusEqualsToken) && typeof value === "number")
+    return { kind: "increment", key, by: binary.operatorToken.kind === ts2.SyntaxKind.MinusEqualsToken ? -value : value };
+  if (binary.operatorToken.kind === ts2.SyntaxKind.EqualsToken && value !== undefined)
+    return { kind: "set-literal", key, value };
+  throw nativeError(file, `\u65B9\u6CD5 ${method.name.getText()} \u4E0D\u652F\u6301\u539F\u751F\u7F16\u8BD1`);
+}
+function readNode(ts2, node, file, state, actions) {
+  const tag = stringValue(ts2, get(ts2, node, "tag"), file, "VNode tag");
+  const style = readStyle(ts2, get(ts2, node, "props"), file);
+  const children = get(ts2, node, "children");
+  const childNodes = children && ts2.isArrayLiteralExpression(children) ? [...children.elements].filter(ts2.isExpression) : [];
+  if (CONTAINERS2.has(tag))
+    return { kind: "container", children: childNodes.map((child) => {
+      if (!ts2.isObjectLiteralExpression(child))
+        throw nativeError(file, "\u5BB9\u5668 children \u53EA\u652F\u6301\u9759\u6001 VNode");
+      return readNode(ts2, child, file, state, actions);
+    }), ...style ? { style } : {} };
+  const parts = childNodes.flatMap((child) => readText(ts2, child, file, state));
+  if (TEXT2.has(tag))
+    return { kind: "text", parts, ...style ? { style } : {} };
+  if (tag === "button")
+    return { kind: "button", parts, action: readClick(ts2, get(ts2, node, "listeners"), file, actions), ...style ? { style } : {} };
+  throw nativeError(file, `\u4E0D\u652F\u6301\u7684\u539F\u751F\u8282\u70B9: ${tag}`);
+}
+function readText(ts2, expression, file, state) {
+  const value = literalValue(ts2, expression);
+  if (typeof value !== "string")
+    throw nativeError(file, "\u6587\u672C children \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u5B57\u9762\u91CF");
+  const result = [];
+  const matcher = /{{([^}]+)}}/g;
+  let cursor = 0;
+  let match;
+  while (match = matcher.exec(value)) {
+    if (match.index > cursor)
+      result.push({ kind: "literal", value: value.slice(cursor, match.index) });
+    const key = match[1];
+    if (!/^[A-Za-z_$][\w$]*$/.test(key) || !state.has(key))
+      throw nativeError(file, "\u53EA\u652F\u6301\u5DF2\u58F0\u660E state \u7684 {{key}} \u7ED1\u5B9A");
+    result.push({ kind: "state", key });
+    cursor = matcher.lastIndex;
+  }
+  if (cursor < value.length || result.length === 0)
+    result.push({ kind: "literal", value: value.slice(cursor) });
+  return result;
+}
+function readClick(ts2, listeners, file, actions) {
+  if (!listeners || !ts2.isObjectLiteralExpression(listeners))
+    throw nativeError(file, "button \u5FC5\u987B\u58F0\u660E listeners.click");
+  const handler = get(ts2, listeners, "click");
+  const body = handler && ts2.isArrowFunction(handler) ? handler.body : undefined;
+  const expression = body && ts2.isCallExpression(body) ? body : body && ts2.isBlock(body) && ts2.isExpressionStatement(body.statements[0]) ? body.statements[0].expression : undefined;
+  if (!expression || !ts2.isCallExpression(expression) || !ts2.isPropertyAccessExpression(expression.expression) || expression.expression.expression.kind !== ts2.SyntaxKind.ThisKeyword)
+    throw nativeError(file, "click \u53EA\u652F\u6301\u8C03\u7528 this.method()");
+  const action = actions.get(expression.expression.name.text);
+  if (!action)
+    throw nativeError(file, `click \u65B9\u6CD5 ${expression.expression.name.text} \u4E0D\u652F\u6301\u539F\u751F\u7F16\u8BD1`);
+  return action;
+}
+function readStyle(ts2, props, file) {
+  if (!props || !ts2.isObjectLiteralExpression(props))
+    return;
+  const style = get(ts2, props, "style");
+  if (!style || !ts2.isObjectLiteralExpression(style))
+    return;
+  const out = {};
+  for (const item of style.properties) {
+    if (!ts2.isPropertyAssignment(item) || !ts2.isIdentifier(item.name) || !STYLE_KEYS.has(item.name.text))
+      throw nativeError(file, "\u4E0D\u652F\u6301\u7684\u539F\u751F\u6837\u5F0F\u5C5E\u6027");
+    const value = literalValue(ts2, item.initializer);
+    const keyword = item.name.text === "color" || item.name.text === "backgroundColor" || item.name.text === "fontWeight" || item.name.text === "textAlign";
+    if (keyword && (typeof value === "string" || typeof value === "number")) {
+      out[item.name.text] = value;
+      continue;
+    }
+    if (typeof value !== "number" && !(typeof value === "string" && /^\d+(\.\d+)?px$/.test(value)))
+      throw nativeError(file, `\u6837\u5F0F ${item.name.text} \u53EA\u652F\u6301\u6570\u5B57\u6216 px`);
+    out[item.name.text] = typeof value === "string" ? Number.parseFloat(value) : value;
+  }
+  return out;
+}
+function get(ts2, node, name2) {
+  const item = node.properties.find((p) => ts2.isPropertyAssignment(p) && p.name.getText().replace(/['"]/g, "") === name2);
+  return item && ts2.isPropertyAssignment(item) ? item.initializer : undefined;
+}
+function stringValue(ts2, expression, file, label) {
+  const value = expression && literalValue(ts2, expression);
+  if (typeof value !== "string")
+    throw nativeError(file, `${label} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  return value;
+}
+function literalValue(ts2, value) {
+  if (ts2.isStringLiteral(value) || ts2.isNoSubstitutionTemplateLiteral(value))
+    return value.text;
+  if (ts2.isNumericLiteral(value))
+    return Number(value.text);
+  if (value.kind === ts2.SyntaxKind.TrueKeyword)
+    return true;
+  if (value.kind === ts2.SyntaxKind.FalseKeyword)
+    return false;
+  return;
+}
+
+// src/app/build-app.ts
+async function buildNativeApp(config, dialect) {
+  if (!config.app)
+    throw new Error("Native app build requires config.app");
+  const entries = Object.values(config.app.pages);
+  if (entries.length !== 1)
+    throw nativeError(config.entry, "\u9996\u671F\u539F\u751F App \u53EA\u652F\u6301\u4E00\u4E2A\u9875\u9762");
+  const sourcePaths = [];
+  const screen = await analyzeNativeScreen(entries[0], config, (paths) => sourcePaths.push(...paths));
+  return withBuildOutput({
+    root: config.root,
+    outDir: config.app.outDir,
+    protectedPaths: buildInputPaths(config, entries, [
+      config.app.publicDir,
+      ...sourcePaths
+    ])
+  }, (outDir) => generateNativeApp(config, dialect, outDir, screen));
+}
+async function generateNativeApp(config, dialect, outDir, screen) {
+  const app = config.app;
+  const files = dialect.generateProject(screen, app);
+  if (app.host !== undefined) {
+    files[`${dialect.resourceDirectory}/transone.config.json`] = `${JSON.stringify({ host: app.host }, null, 2)}
+`;
+  }
+  const assetsBuilt = [];
+  for (const [relative2, content] of Object.entries(files).sort(([a], [b]) => a.localeCompare(b))) {
+    const target = buildOutputPath(outDir, relative2);
+    await mkdir2(dirname3(target), { recursive: true });
+    await writeFile3(target, content, "utf8");
+    assetsBuilt.push(target);
+  }
+  if (existsSync4(app.publicDir))
+    await cp(app.publicDir, buildOutputPath(outDir, dialect.resourceDirectory), { recursive: true });
+  return { root: config.root, outDir: resolve5(outDir), assetsBuilt };
+}
+
+// src/target/app-target.ts
+class AppTarget {
+  dialect;
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  get type() {
+    return this.dialect.id;
+  }
+  get label() {
+    return this.dialect.label;
+  }
+  build(config, _options) {
+    return buildNativeApp(config, this.dialect);
+  }
+}
+
+// src/app/dialects.ts
+function text(parts, language) {
+  if (language === "swift") {
+    const value = parts.map((part) => part.kind === "literal" ? part.value : `\\(${part.key})`).join("");
+    return `"${value.replace(/"/g, "\\\"")}"`;
+  }
+  if (language === "kotlin") {
+    return JSON.stringify(parts.map((part) => part.kind === "literal" ? part.value : `$${part.key}`).join(""));
+  }
+  return parts.map((part) => part.kind === "literal" ? JSON.stringify(part.value) : `this.${part.key}`).join(" + ") || '""';
+}
+function action(node, language) {
+  return nativeAction(node.action, language);
+}
+function nativeAction(action2, language) {
+  if (action2.kind === "sequence")
+    return action2.actions.map((item) => nativeAction(item, language)).join("; ");
+  const target = language === "ark" ? `this.${action2.key}` : action2.key;
+  return action2.kind === "increment" ? `${target} ${action2.by >= 0 ? "+=" : "-="} ${Math.abs(action2.by)}` : `${target} = ${typeof action2.value === "string" ? JSON.stringify(action2.value) : action2.value}`;
+}
+function swiftNode(node, indent = "    ") {
+  if (node.kind === "container")
+    return `${indent}VStack {
+${node.children.map((child) => swiftNode(child, `${indent}  `)).join(`
+`)}
+${indent}}`;
+  if (node.kind === "text")
+    return `${indent}Text(${text(node.parts, "swift")})`;
+  return `${indent}Button(${text(node.parts, "swift")}) { ${action(node, "swift")} }`;
+}
+function kotlinNode(node, indent = "    ") {
+  if (node.kind === "container")
+    return `${indent}Column {
+${node.children.map((child) => kotlinNode(child, `${indent}  `)).join(`
+`)}
+${indent}}`;
+  if (node.kind === "text")
+    return `${indent}Text(${text(node.parts, "kotlin")})`;
+  return `${indent}Button(onClick = { ${action(node, "kotlin")} }) { Text(${text(node.parts, "kotlin")}) }`;
+}
+function arkNode(node, indent = "    ") {
+  if (node.kind === "container")
+    return `${indent}Column() {
+${node.children.map((child) => arkNode(child, `${indent}  `)).join(`
+`)}
+${indent}}`;
+  if (node.kind === "text")
+    return `${indent}Text(${text(node.parts, "ark")})`;
+  return `${indent}Button(${text(node.parts, "ark")}).onClick(() => { ${action(node, "ark")} })`;
+}
+function swiftState(screen) {
+  return screen.state.map((item) => `  @State private var ${item.key}: ${typeof item.value === "number" ? "Int" : typeof item.value === "boolean" ? "Bool" : "String"} = ${JSON.stringify(item.value)}`).join(`
+`);
+}
+function kotlinState(screen) {
+  return screen.state.map((item) => `    var ${item.key} by remember { mutableStateOf(${JSON.stringify(item.value)}) }`).join(`
+`);
+}
+function arkState(screen) {
+  return screen.state.map((item) => `  @State ${item.key}: ${typeof item.value === "number" ? "number" : typeof item.value === "boolean" ? "boolean" : "string"} = ${JSON.stringify(item.value)}`).join(`
+`);
+}
+var IOS_DIALECT = {
+  id: "app-ios",
+  label: "iOS \u539F\u751F App\uFF08SwiftUI\uFF09",
+  resourceDirectory: "TransOneApp/Assets",
+  generateProject(screen, config) {
+    return {
+      "TransOneApp/TransOneApp.swift": `import SwiftUI
+
+@main struct TransOneApp: App { var body: some Scene { WindowGroup { ContentView() } } }
+`,
+      "TransOneApp/ContentView.swift": `import SwiftUI
+
+struct ContentView: View {
+${swiftState(screen)}
+  var body: some View {
+${swiftNode(screen.root)}
+  }
+}
+`,
+      "TransOneApp.xcodeproj/project.pbxproj": xcodeProject(config),
+      "TransOneApp/Assets.xcassets/Contents.json": `{"info":{"author":"xcode","version":1}}
+`
+    };
+  }
+};
+function xcodeProject(config) {
+  const escapedName = config.appName.replace(/"/g, "\\\"");
+  return `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  classes = {};
+  objectVersion = 56;
+  objects = {
+
+/* Begin PBXBuildFile section */
+    A00100000000000000000001 /* TransOneApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = A00100000000000000000011 /* TransOneApp.swift */; };
+    A00100000000000000000002 /* ContentView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A00100000000000000000012 /* ContentView.swift */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+    A00100000000000000000011 /* TransOneApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TransOneApp.swift; sourceTree = "<group>"; };
+    A00100000000000000000012 /* ContentView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ContentView.swift; sourceTree = "<group>"; };
+    A00100000000000000000013 /* TransOneApp.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = TransOneApp.app; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXGroup section */
+    A00100000000000000000021 = {isa = PBXGroup; children = (A00100000000000000000022 /* TransOneApp */, A00100000000000000000023 /* Products */, ); sourceTree = "<group>"; };
+    A00100000000000000000022 /* TransOneApp */ = {isa = PBXGroup; children = (A00100000000000000000011 /* TransOneApp.swift */, A00100000000000000000012 /* ContentView.swift */, ); path = TransOneApp; sourceTree = "<group>"; };
+    A00100000000000000000023 /* Products */ = {isa = PBXGroup; children = (A00100000000000000000013 /* TransOneApp.app */, ); name = Products; sourceTree = "<group>"; };
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+    A00100000000000000000031 /* TransOneApp */ = {isa = PBXNativeTarget; buildConfigurationList = A00100000000000000000041 /* Build configuration list for PBXNativeTarget "TransOneApp" */; buildPhases = (A00100000000000000000032 /* Sources */, A00100000000000000000033 /* Frameworks */, A00100000000000000000034 /* Resources */, ); buildRules = (); dependencies = (); name = TransOneApp; productName = TransOneApp; productReference = A00100000000000000000013 /* TransOneApp.app */; productType = "com.apple.product-type.application"; };
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+    A00100000000000000000051 /* Project object */ = {isa = PBXProject; attributes = { LastUpgradeCheck = 2700; TargetAttributes = { A00100000000000000000031 = { CreatedOnToolsVersion = 27.0; }; }; }; buildConfigurationList = A00100000000000000000052 /* Build configuration list for PBXProject "TransOneApp" */; compatibilityVersion = "Xcode 14.0"; developmentRegion = en; hasScannedForEncodings = 0; knownRegions = (en, Base, ); mainGroup = A00100000000000000000021; productRefGroup = A00100000000000000000023; projectDirPath = ""; projectRoot = ""; targets = (A00100000000000000000031 /* TransOneApp */, ); };
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+    A00100000000000000000034 /* Resources */ = {isa = PBXResourcesBuildPhase; buildActionMask = 2147483647; files = (); runOnlyForDeploymentPostprocessing = 0; };
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+    A00100000000000000000032 /* Sources */ = {isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = (A00100000000000000000001 /* TransOneApp.swift in Sources */, A00100000000000000000002 /* ContentView.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; };
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXFrameworksBuildPhase section */
+    A00100000000000000000033 /* Frameworks */ = {isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = (); runOnlyForDeploymentPostprocessing = 0; };
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+    A00100000000000000000061 /* Debug */ = {isa = XCBuildConfiguration; buildSettings = { CLANG_ENABLE_MODULES = YES; SWIFT_VERSION = 5.0; }; name = Debug; };
+    A00100000000000000000062 /* Release */ = {isa = XCBuildConfiguration; buildSettings = { CLANG_ENABLE_MODULES = YES; SWIFT_VERSION = 5.0; }; name = Release; };
+    A00100000000000000000063 /* Debug */ = {isa = XCBuildConfiguration; buildSettings = { ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; CODE_SIGNING_ALLOWED = NO; GENERATE_INFOPLIST_FILE = YES; IPHONEOS_DEPLOYMENT_TARGET = ${config.minPlatformVersion}; PRODUCT_BUNDLE_IDENTIFIER = ${config.bundleId}; PRODUCT_NAME = "${escapedName}"; SDKROOT = iphoneos; SWIFT_VERSION = 5.0; TARGETED_DEVICE_FAMILY = "1,2"; }; name = Debug; };
+    A00100000000000000000064 /* Release */ = {isa = XCBuildConfiguration; buildSettings = { ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; CODE_SIGNING_ALLOWED = NO; GENERATE_INFOPLIST_FILE = YES; IPHONEOS_DEPLOYMENT_TARGET = ${config.minPlatformVersion}; PRODUCT_BUNDLE_IDENTIFIER = ${config.bundleId}; PRODUCT_NAME = "${escapedName}"; SDKROOT = iphoneos; SWIFT_VERSION = 5.0; TARGETED_DEVICE_FAMILY = "1,2"; }; name = Release; };
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+    A00100000000000000000041 /* Build configuration list for PBXNativeTarget "TransOneApp" */ = {isa = XCConfigurationList; buildConfigurations = (A00100000000000000000063 /* Debug */, A00100000000000000000064 /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; };
+    A00100000000000000000052 /* Build configuration list for PBXProject "TransOneApp" */ = {isa = XCConfigurationList; buildConfigurations = (A00100000000000000000061 /* Debug */, A00100000000000000000062 /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; };
+/* End XCConfigurationList section */
+  };
+  rootObject = A00100000000000000000051 /* Project object */;
+}
+`;
+}
+var ANDROID_DIALECT = {
+  id: "app-android",
+  label: "Android \u539F\u751F App\uFF08Jetpack Compose\uFF09",
+  resourceDirectory: "app/src/main/assets",
+  generateProject(screen, config) {
+    const pkg = config.bundleId.replace(/[^A-Za-z0-9_.]/g, "_");
+    const path = pkg.replace(/\./g, "/");
+    return {
+      "settings.gradle.kts": `rootProject.name = "${config.appName}"
+include(":app")
+`,
+      "build.gradle.kts": `plugins { }
+`,
+      "app/build.gradle.kts": `plugins { id("com.android.application") version "8.5.0" apply false }
+`,
+      "app/src/main/AndroidManifest.xml": `<manifest package="${pkg}" xmlns:android="http://schemas.android.com/apk/res/android"><application android:label="${config.appName}"><activity android:name=".MainActivity" android:exported="true"><intent-filter><action android:name="android.intent.action.MAIN"/><category android:name="android.intent.category.LAUNCHER"/></intent-filter></activity></application></manifest>
+`,
+      [`app/src/main/java/${path}/MainActivity.kt`]: `package ${pkg}
+
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.runtime.*
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.*
+
+class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: android.os.Bundle?) { super.onCreate(savedInstanceState); setContent {
+${kotlinState(screen)}
+${kotlinNode(screen.root)}
+} } }
+`
+    };
+  }
+};
+var HARMONY_DIALECT = {
+  id: "app-harmony",
+  label: "HarmonyOS \u539F\u751F App\uFF08ArkUI\uFF09",
+  resourceDirectory: "entry/src/main/resources/rawfile",
+  generateProject(screen, config) {
+    return {
+      "AppScope/app.json5": `{ "app": { "bundleName": "${config.bundleId}", "vendor": "TransOne", "versionCode": 1, "versionName": "1.0.0" } }
+`,
+      "AppScope/resources/base/element/string.json": `{ "string": [{ "name": "app_name", "value": "${config.appName}" }] }
+`,
+      "entry/src/main/module.json5": `{ "module": { "name": "entry", "type": "entry", "mainElement": "EntryAbility" } }
+`,
+      "entry/src/main/ets/entryability/EntryAbility.ets": `import UIAbility from '@ohos.app.ability.UIAbility';
+export default class EntryAbility extends UIAbility {}
+`,
+      "entry/src/main/ets/pages/Index.ets": `@Entry
+@Component
+struct Index {
+${arkState(screen)}
+  build() {
+${arkNode(screen.root)}
+  }
+}
+`
+    };
+  }
+};
+
+// src/target/registry.ts
+class TargetRegistry {
+  targets = new Map;
+  constructor() {
+    this.register(new WebTarget);
+    this.register(mpWeixinTarget);
+    this.register(mpAlipayTarget);
+    this.register(mpBytedanceTarget);
+    this.register(mpXiaohongshuTarget);
+    this.register(new AppTarget(IOS_DIALECT));
+    this.register(new AppTarget(ANDROID_DIALECT));
+    this.register(new AppTarget(HARMONY_DIALECT));
+  }
+  register(target) {
+    this.targets.set(target.type, target);
+  }
+  resolve(type) {
+    const target = this.targets.get(type);
+    if (!target) {
+      throw new Error(`Unknown build target: ${type}`);
+    }
+    return target;
+  }
+  getAvailableTargets() {
+    return [...this.targets.values()];
+  }
+}
+var targetRegistry = new TargetRegistry;
+
+// src/build.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname as dirname4, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve6, sep as sep2 } from "path";
+async function build(options = {}) {
+  return buildConfigured(await resolveConfig(options), options);
+}
+async function buildConfigured(config, options = {}) {
+  if (options.library) {
+    return buildLibrary(config);
+  }
+  const target = targetRegistry.resolve(config.target);
+  return target.build(config, options);
+}
+async function buildLibrary(config) {
+  const library = config.library;
+  if (!library) {
+    throw new Error("TransOne library build requires config.library");
+  }
+  const declarations = library.dts ? await Promise.all(library.tsconfigs.map(loadDeclarationProject)) : [];
+  const protectedPaths = buildInputPaths(config, [library.entry], [...library.tsconfigs, ...declarations.flatMap((project) => project.inputs)]);
+  return withBuildOutput({
+    root: config.root,
+    outDir: library.outDir,
+    protectedPaths
+  }, async (outDir) => {
+    const declarationAssets = declarations.flatMap((project) => emitDeclarations(project, library.outDir, outDir));
+    const minify = library.minify ?? process.env.TRANSONE_MINIFY !== "0";
+    const inputs = createBundleInputTracker();
+    const result = await Bun.build({
+      entrypoints: [library.entry],
+      outdir: outDir,
+      metafile: true,
+      plugins: [inputs.plugin],
+      root: dirname4(library.entry),
+      target: "browser",
+      format: "esm",
+      sourcemap: library.sourcemap ? "linked" : undefined,
+      splitting: library.splitting,
+      minify,
+      external: library.external,
+      throw: false
+    });
+    if (!result.success || result.outputs.length === 0) {
+      throw new Error(`Failed to build TransOne library:
+${result.logs.map((log) => log.message).join(`
+`)}`);
+    }
+    protectedPaths.push(...inputs.paths(result));
+    const assetsBuilt = [
+      ...declarationAssets,
+      ...result.outputs.map((output) => resolve6(output.path))
+    ];
+    return {
+      root: config.root,
+      outDir,
+      assetsBuilt: [...new Set(assetsBuilt)]
+    };
+  });
+}
+async function loadDeclarationProject(configFile) {
+  const ts2 = await loadTypescript();
+  const inputs = new Set;
+  const diagnostics = [];
+  const parsed = ts2.getParsedCommandLineOfConfigFile(configFile, {}, {
+    ...ts2.sys,
+    readFile: (path) => {
+      inputs.add(resolve6(path));
+      return ts2.sys.readFile(path);
+    },
+    onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+      diagnostics.push(diagnostic);
+    }
+  });
+  if (!parsed)
+    throw declarationError(ts2, configFile, diagnostics);
+  const program = ts2.createProgram({
+    rootNames: parsed.fileNames,
+    options: parsed.options,
+    projectReferences: parsed.projectReferences
+  });
+  for (const source of program.getSourceFiles())
+    inputs.add(resolve6(source.fileName));
+  return {
+    ts: ts2,
+    program,
+    diagnostics: [...diagnostics, ...parsed.errors],
+    inputs: [...inputs],
+    configFile
+  };
+}
+function emitDeclarations(project, finalOutDir, staging) {
+  const { ts: ts2, program, configFile } = project;
+  const diagnostics = [
+    ...project.diagnostics,
+    ...ts2.getPreEmitDiagnostics(program)
+  ];
+  if (diagnostics.some((diagnostic) => diagnostic.category === ts2.DiagnosticCategory.Error)) {
+    throw declarationError(ts2, configFile, diagnostics);
+  }
+  const assets = [];
+  const emitted = program.emit(undefined, (file, content, byteOrderMark) => {
+    const path = relative2(finalOutDir, resolve6(file));
+    if (path === "" || path === ".." || path.startsWith(`..${sep2}`) || isAbsolute2(path)) {
+      throw new Error(`TypeScript output must be inside library.outDir for recoverable publication: ${file} (${configFile})`);
+    }
+    const target = resolve6(staging, path);
+    mkdirSync(dirname4(target), { recursive: true });
+    writeFileSync(target, `${byteOrderMark ? "\uFEFF" : ""}${content}`);
+    assets.push(target);
+  });
+  if (emitted.emitSkipped || emitted.diagnostics.some((diagnostic) => diagnostic.category === ts2.DiagnosticCategory.Error)) {
+    throw declarationError(ts2, configFile, emitted.diagnostics);
+  }
+  return assets;
+}
+function declarationError(ts2, configFile, diagnostics) {
+  return new Error(`TypeScript compilation failed for ${configFile}:
+${ts2.formatDiagnostics(diagnostics, {
+    getCanonicalFileName: (file) => file,
+    getCurrentDirectory: () => dirname4(configFile),
+    getNewLine: () => `
+`
+  })}`);
+}
+
+// src/components/report.ts
+import { relative as relative3, sep as sep3 } from "path";
+async function reportComponents(options = {}) {
+  return reportConfiguredComponents(await resolveConfig(options));
+}
+function reportConfiguredComponents(config) {
+  const family = getPlatformDefinition(config.platform).family;
+  const pages = family === "miniprogram" ? config.mp?.pages ?? config.pages : family === "app" ? config.app?.pages ?? config.pages : config.pages;
+  const entries = [...new Set(Object.values(pages))];
+  const contexts = family === "web" ? entries.map((entry) => [entry]) : [entries];
+  const root = canonicalPath(config.root);
+  const sourcePath = (path) => relative3(root, canonicalPath(path)).split(sep3).join("/");
+  const location = (reference) => {
+    const point = reference.source.getLineAndCharacterOfPosition(reference.declaration.getStart(reference.source));
+    return {
+      source: sourcePath(reference.filePath),
+      className: reference.className,
+      line: point.line + 1,
+      column: point.character + 1
+    };
+  };
+  const components = [];
+  for (const context of contexts) {
+    const index = createComponentIndex({
+      root: config.root,
+      entrypoints: context,
+      platform: config.platform,
+      include: config.components?.include,
+      exclude: config.components?.exclude
+    });
+    const entrypoints = context.map(sourcePath).sort();
+    for (const reference of index.classes) {
+      if (!index.isComponent(reference) || index.metadata(reference).framework)
+        continue;
+      const decision = index.decision(reference);
+      if (decision.reason === "explicit")
+        continue;
+      components.push({
+        entrypoints,
+        component: location(reference),
+        implementation: decision.implementation ? location(decision.implementation) : null,
+        reason: decision.reason,
+        candidates: decision.candidates.map((candidate) => ({
+          ...location(candidate),
+          platforms: [...index.metadata(candidate).platforms].sort()
+        })).sort(compareLocations)
+      });
+    }
+  }
+  components.sort((left, right) => compareText(left.entrypoints.join("\x00"), right.entrypoints.join("\x00")) || compareLocations(left.component, right.component));
+  return {
+    platform: config.platform,
+    scope: "discovered-logical-components",
+    components
+  };
+}
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareLocations(left, right) {
+  return compareText(left.source, right.source) || left.line - right.line || left.column - right.column || compareText(left.className, right.className);
+}
+function formatComponentSelectionReport(report) {
+  const describe = (value) => `${value.className} (${value.source}:${value.line}:${value.column})`;
+  return [
+    `TransOne component selection: ${report.platform}`,
+    "Scope: discovered logical component mappings; runtime constructor usage is not analyzed.",
+    ...report.components.length ? report.components.flatMap((row) => [
+      `${describe(row.component)} -> ${row.implementation ? describe(row.implementation) : "(missing)"} [${row.reason}]`,
+      `  Entrypoints: ${row.entrypoints.join(", ")}`,
+      ...row.candidates.length ? [
+        `  Candidates: ${row.candidates.map((candidate) => `${describe(candidate)} [${candidate.platforms.join(", ")}]`).join("; ")}`
+      ] : []
+    ]) : ["(no logical components discovered)"]
+  ].join(`
+`);
+}
+
+// src/create.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename2, dirname as dirname5, join } from "path";
+
+// src/scaffold.ts
+var cardViews = [
+  {
+    className: "CardWebComponent",
+    decorator: "Web",
+    label: "Web Card",
+    background: "#eff6ff"
+  },
+  {
+    className: "CardMiniprogramComponent",
+    decorator: "Miniprogram",
+    label: "Miniprogram Card",
+    background: "#f0fdf4"
+  },
+  {
+    className: "CardAppComponent",
+    decorator: "App",
+    label: "App Card",
+    background: "#f8fafc"
+  },
+  {
+    className: "CardMobileComponent",
+    decorator: "WebMobile",
+    label: "Mobile Web Card",
+    background: "#f0fdf4"
+  },
+  {
+    className: "CardPcComponent",
+    decorator: "WebPc",
+    label: "PC Web Card",
+    background: "#eef2ff"
+  },
+  {
+    className: "CardWeixinComponent",
+    decorator: "MiniprogramWeixin",
+    label: "Weixin Card",
+    background: "#f0fdf4"
+  },
+  {
+    className: "CardAlipayComponent",
+    decorator: "MiniprogramAlipay",
+    label: "Alipay Card",
+    background: "#eff6ff"
+  },
+  {
+    className: "CardIosComponent",
+    decorator: "AppIos",
+    label: "iOS Card",
+    background: "#f8fafc"
+  },
+  {
+    className: "CardAndroidComponent",
+    decorator: "AppAndroid",
+    label: "Android Card",
+    background: "#f0fdf4"
+  }
+];
+function cardRender(label, background = "#ffffff") {
+  return `  protected render(): VNode {
+    return h('main', {
+      style: { padding: '16px', borderRadius: '12px', backgroundColor: '${background}' },
+    }, [
+      h('h1', { style: { fontSize: '20px' } }, [this.props.title]),
+      h('p', {}, ['${label}']),
+      h('p', {}, ['Count: {{count}}']),
+      h('button', {}, ['+1'], { click: () => this.increment() }),
+    ]);
+  }`;
+}
+function scaffoldFiles(name2, frameworkVersion, cliVersion) {
+  return [
+    {
+      path: "package.json",
+      content: JSON.stringify({
+        name: name2,
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "transone dev",
+          "dev:mobile": "transone dev --target web-mobile",
+          "dev:pc": "transone dev --target web-pc",
+          build: "transone build",
+          "build:web": "transone build --target web",
+          "build:mobile": "transone build --target web-mobile",
+          "build:pc": "transone build --target web-pc",
+          "build:weixin": "transone build --target miniprogram-weixin",
+          "build:alipay": "transone build --target miniprogram-alipay",
+          "build:bytedance": "transone build --target miniprogram-bytedance",
+          "build:xiaohongshu": "transone build --target miniprogram-xiaohongshu",
+          "build:ios": "transone build --target app-ios",
+          "build:android": "transone build --target app-android",
+          "build:harmony": "transone build --target app-harmony",
+          typecheck: "bunx tsc --noEmit"
+        },
+        dependencies: { transone: `^${frameworkVersion}` },
+        devDependencies: {
+          "transone-cli": `^${cliVersion}`,
+          typescript: "^5.3.3"
+        }
+      }, null, 2) + `
+`
+    },
+    {
+      path: "transone.config.ts",
+      content: `import { Platform } from 'transone';
+import { defineConfig } from 'transone-cli';
+
+export default defineConfig({
+  entry: 'src/main.ts',
+  target: Platform.Web,
+});
+`
+    },
+    {
+      path: "tsconfig.json",
+      content: JSON.stringify({
+        compilerOptions: {
+          target: "ESNext",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          lib: ["ESNext", "DOM", "DOM.Iterable"],
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true,
+          verbatimModuleSyntax: true
+        },
+        include: ["src/**/*", "transone.config.ts"]
+      }, null, 2) + `
+`
+    },
+    { path: ".gitignore", content: `node_modules/
+dist/
+` },
+    {
+      path: "src/main.ts",
+      content: `import { createApp } from 'transone';
+import { AppComponent } from './AppComponent';
+
+export const app = createApp({
+  root: AppComponent,
+  document: { title: 'TransOne component variants' },
+});
+app.mount();
+`
+    },
+    {
+      path: "src/AppComponent.ts",
+      content: `import { BaseComponent, createComponent, h, type VNode } from 'transone';
+import { CardComponent } from './components/card/CardComponent';
+
+export class AppComponent extends BaseComponent<object, object> {
+  protected initState(): object { return {}; }
+  protected initStyles(): void {}
+
+  protected render(): VNode {
+    return h('main', { style: { padding: '16px' } }, [
+      h('h1', {}, ['TransOne component variants']),
+      createComponent({
+        component: CardComponent,
+        props: { title: 'Shared business, platform view' },
+      }),
+    ]);
+  }
+}
+`
+    },
+    {
+      path: "src/components/card/CardComponent.ts",
+      content: `import { BaseComponent, h, type VNode } from 'transone';
+
+export interface CardProps { title: string; }
+export interface CardState { count: number; }
+
+/** Shared state and business methods; pages only import this class. */
+export class CardComponent extends BaseComponent<CardProps, CardState> {
+  protected initState(): CardState { return { count: 0 }; }
+  protected initStyles(): void {}
+  protected increment(): void { this.state.count += 1; }
+
+${cardRender("Shared Card")}
+}
+`
+    },
+    ...cardViews.map((view) => ({
+      path: `src/components/card/${view.className}.ts`,
+      content: `import { ${view.decorator}, h, type VNode } from 'transone';
+import { CardComponent } from './CardComponent';
+
+@${view.decorator}()
+export class ${view.className} extends CardComponent {
+${cardRender(view.label, view.background)}
+}
+`
+    }))
+  ];
+}
+
+// src/create.ts
+var TRANSONE_FRAMEWORK_VERSION = "0.9.0";
+var TRANSONE_CLI_VERSION = "0.10.0";
+function createProject(options = {}) {
+  const root = options.root ?? process.cwd();
+  const name2 = options.name ?? basename2(root);
+  const files = scaffoldFiles(name2, TRANSONE_FRAMEWORK_VERSION, TRANSONE_CLI_VERSION);
+  const existing = files.filter((file) => existsSync5(join(root, file.path)));
+  if (existing.length > 0) {
+    throw new Error(`Refusing to overwrite existing TransOne project files: ${existing.map((file) => file.path).join(", ")}`);
+  }
+  mkdirSync2(join(root, "src"), { recursive: true });
+  const created = [];
+  for (const file of files) {
+    mkdirSync2(dirname5(join(root, file.path)), { recursive: true });
+    writeFileSync2(join(root, file.path), file.content, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    created.push(file.path);
+  }
+  return { root, files: created };
+}
+
+// src/server.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync6, realpathSync as realpathSync2, statSync } from "fs";
+import { rm as rm2 } from "fs/promises";
+import {
+  basename as basename3,
+  dirname as dirname6,
+  extname,
+  isAbsolute as isAbsolute4,
+  relative as relative5,
+  resolve as resolve7,
+  sep as sep4
+} from "path";
+
+// src/proxy.ts
+var HOP_BY_HOP_HEADERS = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function createProxyHandler(proxy) {
+  const rules = Object.entries(proxy ?? {}).map(([prefix, options]) => toProxyRule(prefix, options)).sort((first, second) => second.prefix.length - first.prefix.length);
+  return async (request) => {
+    const sourceUrl = new URL(request.url);
+    const rule = rules.find(({ prefix }) => sourceUrl.pathname.startsWith(prefix));
+    if (!rule) {
+      return;
+    }
+    const target = createTargetUrl(rule, sourceUrl);
+    const headers = createRequestHeaders(request, sourceUrl, rule, target);
+    const body = request.method === "GET" || request.method === "HEAD" ? undefined : request.body;
+    try {
+      const upstream = await fetch(target, {
+        method: request.method,
+        headers,
+        body,
+        signal: request.signal,
+        redirect: "manual"
+      });
+      return new Response(upstream.body, {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers: filterHeaders(upstream.headers)
+      });
+    } catch {
+      return new Response("Bad Gateway", { status: 502 });
+    }
+  };
+}
+function toProxyRule(prefix, value) {
+  const options = typeof value === "string" ? { target: value } : value;
+  return {
+    prefix,
+    target: new URL(options.target),
+    changeOrigin: options.changeOrigin ?? false,
+    ...options.rewrite === undefined ? {} : { rewrite: options.rewrite }
+  };
+}
+function createTargetUrl(rule, sourceUrl) {
+  const target = new URL(rule.target);
+  const pathname = rule.rewrite?.(sourceUrl.pathname) ?? sourceUrl.pathname;
+  target.pathname = joinPathnames(target.pathname, pathname);
+  target.search = sourceUrl.search;
+  return target;
+}
+function joinPathnames(basePathname, pathname) {
+  const base = basePathname === "/" ? "" : basePathname.replace(/\/+$/, "");
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${base}${path}` || "/";
+}
+function createRequestHeaders(request, sourceUrl, rule, target) {
+  const headers = filterHeaders(request.headers);
+  const incomingHost = request.headers.get("host") ?? sourceUrl.host;
+  headers.set("host", rule.changeOrigin ? target.host : incomingHost);
+  return headers;
+}
+function filterHeaders(source) {
+  const headers = new Headers(source);
+  const connection = headers.get("connection");
+  if (connection) {
+    connection.split(",").forEach((header) => {
+      const name2 = header.trim();
+      if (name2) {
+        headers.delete(name2);
+      }
+    });
+  }
+  HOP_BY_HOP_HEADERS.forEach((header) => headers.delete(header));
+  return headers;
+}
+
+// src/watch.ts
+import { watch } from "fs";
+import { readdir, stat } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join2, relative as relative4 } from "path";
+var RECURSIVE_WATCH_UNSUPPORTED_ERROR = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+var DEFAULT_DEBOUNCE_MS = 100;
+var DEFAULT_POLL_INTERVAL_MS = 300;
+function createFileWatcher(options) {
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  let timer;
+  const disposers = [];
+  const scheduleChange = (relativePath) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = undefined;
+      options.onChange(relativePath);
+    }, debounceMs);
+  };
+  disposers.push(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  });
+  const nativeWatcher = tryCreateNativeWatcher(options.root, options.isRelevant, scheduleChange);
+  if (nativeWatcher) {
+    disposers.push(nativeWatcher);
+  } else {
+    disposers.push(createPollingWatcher(options.root, options.isRelevant, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS, scheduleChange));
+  }
+  return {
+    dispose: () => {
+      disposers.splice(0).reverse().forEach((dispose) => dispose());
+    }
+  };
+}
+function tryCreateNativeWatcher(root, isRelevant, onRelevantChange) {
+  let watcher;
+  try {
+    watcher = watch(root, { recursive: true }, (_event, filename) => {
+      if (typeof filename !== "string") {
+        return;
+      }
+      const relativePath = toRelativePath(root, filename);
+      if (relativePath === undefined || !isRelevant(relativePath)) {
+        return;
+      }
+      onRelevantChange(relativePath);
+    });
+  } catch (error) {
+    if (isRecursiveWatchUnsupported(error)) {
+      return;
+    }
+    throw error;
+  }
+  return () => watcher.close();
+}
+function createPollingWatcher(root, isRelevant, intervalMs, onRelevantChange) {
+  let running = true;
+  let snapshot = new Map;
+  let timer;
+  const scan = async () => {
+    if (!running) {
+      return;
+    }
+    const next = new Map;
+    try {
+      await collectRelevantFiles(root, isRelevant, next);
+    } catch {
+      return;
+    }
+    let changedPath;
+    for (const [relativePath, snapshotEntry] of next) {
+      const previous = snapshot.get(relativePath);
+      if (!previous || previous.mtimeMs !== snapshotEntry.mtimeMs || previous.size !== snapshotEntry.size) {
+        changedPath = relativePath;
+        break;
+      }
+    }
+    if (changedPath === undefined) {
+      for (const relativePath of snapshot.keys()) {
+        if (!next.has(relativePath)) {
+          changedPath = relativePath;
+          break;
+        }
+      }
+    }
+    snapshot = next;
+    if (changedPath !== undefined) {
+      onRelevantChange(changedPath);
+    }
+  };
+  scan();
+  timer = setInterval(() => {
+    scan();
+  }, intervalMs);
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+  return () => {
+    running = false;
+    if (timer) {
+      clearInterval(timer);
+    }
+  };
+}
+async function collectRelevantFiles(root, isRelevant, output) {
+  const pendingDirectories = [""];
+  while (pendingDirectories.length > 0) {
+    const relativeDirectory = pendingDirectories.pop();
+    if (relativeDirectory === undefined) {
+      break;
+    }
+    const absoluteDirectory = join2(root, relativeDirectory);
+    let entries;
+    try {
+      entries = await readdir(absoluteDirectory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const relativePath = relativeDirectory === "" ? entry.name : `${relativeDirectory}/${entry.name}`;
+      if (entry.isDirectory()) {
+        pendingDirectories.push(relativePath);
+        continue;
+      }
+      if (!entry.isFile() || !isRelevant(relativePath)) {
+        continue;
+      }
+      try {
+        const info = await stat(join2(root, relativePath));
+        output.set(relativePath, { mtimeMs: info.mtimeMs, size: info.size });
+      } catch {}
+    }
+  }
+}
+function toRelativePath(root, filename) {
+  const relativePath = isAbsolute3(filename) ? relative4(root, filename) : filename.split("\\").join("/");
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith("../")) {
+    return;
+  }
+  return relativePath.split("\\").join("/");
+}
+function isRecursiveWatchUnsupported(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === RECURSIVE_WATCH_UNSUPPORTED_ERROR;
+}
+
+// src/server.ts
+var DEVELOPMENT_URL_PREFIX = "/dev";
+var INVALID_DEVELOPMENT_DIRECTORY_MESSAGE = "Development output must be a subdirectory of the project root";
+var LIVE_RELOAD_PATH = "/__transone/reload";
+var DEVELOPMENT_OUTPUT_RETENTION_MS = 5000;
+var WATCHED_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".css",
+  ".html"
+]);
+var IGNORED_WATCH_SEGMENTS = new Set([
+  "dist",
+  "node_modules",
+  ".git",
+  ".worktrees"
+]);
+var LIVE_RELOAD_CLIENT_SCRIPT = [
+  '<script type="module">',
+  "const transoneReloadSource=new EventSource(",
+  JSON.stringify(LIVE_RELOAD_PATH),
+  ");",
+  'transoneReloadSource.addEventListener("reload",()=>location.reload());',
+  "</script>"
+].join("");
+async function startDevServer(options = {}) {
+  if (options.watch) {
+    return startWatchingDevServer(options);
+  }
+  const instance = await createServerInstance(options, false);
+  return createServerHandle(() => instance, () => {
+    return;
+  });
+}
+async function startWatchingDevServer(options) {
+  let instance = await createServerInstance(options, true);
+  let watcher = createProjectWatcher(instance, onChange);
+  async function onChange(changedPath) {
+    const configFile = instance.config.configFile;
+    const configRelativePath = configFile === undefined ? undefined : toRelativePath2(instance.config.root, configFile);
+    if (configRelativePath === changedPath) {
+      await restart();
+      return;
+    }
+    await rebuildAndReload();
+  }
+  async function rebuildAndReload() {
+    const entries = [...new Set(Object.values(instance.config.pages))];
+    instance.markDirty(entries);
+    for (const entry of entries) {
+      const bundle = await instance.getBundle(entry);
+      if (bundle instanceof Response) {
+        console.error("TransOne rebuild failed; keeping the last working page.");
+        return;
+      }
+    }
+    instance.liveReload?.broadcast();
+  }
+  async function restart() {
+    watcher.dispose();
+    await instance.server.stop(true);
+    await instance.dispose();
+    instance = await createServerInstance(options, true);
+    watcher = createProjectWatcher(instance, onChange);
+    console.log(`TransOne dev server restarted at http://${instance.server.hostname}:${instance.server.port}`);
+  }
+  return createServerHandle(() => instance, () => watcher.dispose());
+}
+function createProjectWatcher(instance, onChange) {
+  const root = realpathSync2(instance.config.root);
+  const watchers = [];
+  try {
+    watchers.push(createFileWatcher({
+      root,
+      isRelevant: (relativePath) => isWatchedFile(instance, relativePath),
+      onChange: (changedPath) => {
+        onChange(changedPath);
+      }
+    }));
+    for (const group of externalComponentWatchRoots(instance.config, root)) {
+      const excluded = (instance.config.components?.exclude ?? []).map((pattern) => new Bun.Glob(pattern.split(sep4).join("/")));
+      watchers.push(createFileWatcher({
+        root: group.root,
+        isRelevant: (relativePath) => {
+          const path = resolve7(group.root, relativePath);
+          if (isWithinOrEqual(root, path) || ![".ts", ".tsx"].includes(extname(path).toLowerCase()) || path.endsWith(".d.ts"))
+            return false;
+          if (path.split(sep4).some((segment) => IGNORED_WATCH_SEGMENTS.has(segment)))
+            return false;
+          const portable = path.split(sep4).join("/");
+          const fromApp = toRelativePath2(root, path);
+          return group.patterns.some((pattern) => pattern.match(portable)) && !excluded.some((pattern) => pattern.match(fromApp) || pattern.match(portable));
+        },
+        onChange: (changedPath) => {
+          onChange(toRelativePath2(root, resolve7(group.root, changedPath)));
+        }
+      }));
+    }
+  } catch (error) {
+    watchers.forEach((watcher) => watcher.dispose());
+    throw error;
+  }
+  return {
+    dispose: () => {
+      watchers.splice(0).reverse().forEach((watcher) => watcher.dispose());
+    }
+  };
+}
+function externalComponentWatchRoots(config, appRoot) {
+  const groups = [];
+  for (const include of config.components?.include ?? []) {
+    const absolute = resolve7(config.root, include);
+    const wildcard = absolute.search(/[*?\[\]{}]/);
+    const prefix = wildcard < 0 ? absolute : absolute.slice(0, wildcard);
+    const directoryPattern = wildcard < 0 && (existsSync6(absolute) && statSync(absolute).isDirectory() || !extname(absolute));
+    let directory = wildcard < 0 ? directoryPattern ? absolute : dirname6(absolute) : prefix.endsWith(sep4) ? prefix : dirname6(prefix);
+    while (!existsSync6(directory)) {
+      const parent2 = dirname6(directory);
+      if (parent2 === directory)
+        break;
+      directory = parent2;
+    }
+    if (!existsSync6(directory) || !statSync(directory).isDirectory())
+      continue;
+    const canonical = realpathSync2(directory);
+    if (isWithinOrEqual(appRoot, canonical))
+      continue;
+    const patternPath = directoryPattern ? resolve7(absolute, "**", "*") : absolute;
+    const pattern = new Bun.Glob(resolve7(canonical, relative5(directory, patternPath)).split(sep4).join("/"));
+    const parent = groups.find((group) => isWithinOrEqual(group.root, canonical));
+    if (parent) {
+      parent.patterns.push(pattern);
+      continue;
+    }
+    const nested = groups.filter((group) => isWithinOrEqual(canonical, group.root));
+    for (const group of nested)
+      groups.splice(groups.indexOf(group), 1);
+    groups.push({
+      root: canonical,
+      patterns: [pattern, ...nested.flatMap((group) => group.patterns)]
+    });
+  }
+  return groups;
+}
+async function createServerInstance(options, watch2) {
+  const config = await resolveConfig(options);
+  if (config.target !== "web") {
+    throw new Error("Development server only supports Web targets: web, web-mobile, web-pc");
+  }
+  const { renderProjectHtml } = await import("./project-6tft5e77.js");
+  for (const [route, entry] of Object.entries(config.pages)) {
+    await renderProjectHtml(config, {}, entry, route);
+  }
+  const developmentOutDir = resolve7(config.root, "dist", "dev", "h5");
+  await assertSafeSubdirectory(config.root, developmentOutDir, INVALID_DEVELOPMENT_DIRECTORY_MESSAGE);
+  const proxy = createProxyHandler(config.server.proxy);
+  const sessionId = createGenerationId();
+  const sessionOutDir = resolve7(developmentOutDir, sessionId);
+  const artifacts = new Map;
+  const buildProject = createDevelopmentBuilder(sessionId, sessionOutDir, artifacts, config);
+  const liveReload = watch2 ? createLiveReloadHub() : undefined;
+  const bundles = new Map;
+  const dirtyEntries = new Set;
+  const getBundle = async (entry, acquire = false) => {
+    const cached = bundles.get(entry);
+    if (watch2 && cached !== undefined && !dirtyEntries.has(entry)) {
+      if (acquire)
+        cached.activeRequests += 1;
+      return cached;
+    }
+    const bundle = await buildProject.build(entry);
+    if (bundle instanceof Response) {
+      if (watch2) {
+        dirtyEntries.add(entry);
+      }
+      return bundle;
+    }
+    if (watch2) {
+      bundles.set(entry, bundle);
+      dirtyEntries.delete(entry);
+    }
+    if (acquire)
+      bundle.activeRequests += 1;
+    return bundle;
+  };
+  const server = Bun.serve({
+    hostname: config.server.host,
+    port: config.server.port,
+    fetch: async (request) => {
+      const reloadResponse = liveReload?.handleRequest(request);
+      if (reloadResponse) {
+        return reloadResponse;
+      }
+      return await proxy(request) ?? serveProjectRequest(request, config, config.pages, getBundle, artifacts, liveReload);
+    }
+  });
+  return {
+    server,
+    config,
+    getBundle,
+    markDirty: (entries) => {
+      entries.forEach((entry) => dirtyEntries.add(entry));
+    },
+    dispose: buildProject.dispose,
+    liveReload
+  };
+}
+function createServerHandle(getInstance, disposeWatcher) {
+  return new Proxy({}, {
+    get(_target, property2) {
+      if (property2 === "stop") {
+        return async (closeActiveConnections) => {
+          disposeWatcher();
+          const instance = getInstance();
+          await instance.server.stop(closeActiveConnections);
+          await instance.dispose();
+        };
+      }
+      const server = getInstance().server;
+      const value = server[property2];
+      return typeof value === "function" ? value.bind(server) : value;
+    }
+  });
+}
+async function serveProjectRequest(request, config, pages, getBundle, artifacts, liveReload) {
+  const pathname = new URL(request.url).pathname;
+  const route = pageRouteForPathname(pages, pathname);
+  if (route !== undefined) {
+    const entry = pages[route];
+    const bundle = await getBundle(entry, true);
+    if (bundle instanceof Response) {
+      return bundle;
+    }
+    try {
+      const { renderProjectHtml } = await import("./project-6tft5e77.js");
+      const rendered = await renderProjectHtml(config, {
+        head: bundle.stylesheets.map(({ pathname: href }) => ({
+          tag: "link",
+          attributes: { rel: "stylesheet", href }
+        })),
+        scripts: [{ type: "module", src: bundle.entry.pathname }]
+      }, entry, route, bundle.components);
+      const html = await emitDevelopmentDocumentStyles(rendered, bundle);
+      publishDevelopmentBundle(bundle, artifacts);
+      return new Response(liveReload ? injectLiveReloadScript(html) : html, {
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": "no-store"
+        }
+      });
+    } catch (error) {
+      console.error(error);
+      return buildFailureResponse();
+    } finally {
+      releaseDevelopmentBundle(bundle);
+    }
+  }
+  if (pathname === "/bundle.js") {
+    const bundle = await getBundle(config.entry, true);
+    if (bundle instanceof Response) {
+      return bundle;
+    }
+    try {
+      publishDevelopmentBundle(bundle, artifacts);
+      return new Response(null, {
+        status: 307,
+        headers: {
+          location: bundle.entry.pathname,
+          "cache-control": "no-store"
+        }
+      });
+    } catch (error) {
+      console.error(error);
+      return buildFailureResponse();
+    } finally {
+      releaseDevelopmentBundle(bundle);
+    }
+  }
+  const artifact = artifacts.get(pathname);
+  if (artifact) {
+    return new Response(Bun.file(artifact.filePath), {
+      headers: {
+        "content-type": artifact.type,
+        "cache-control": "no-store"
+      }
+    });
+  }
+  if (pathname !== "/" && !pathname.startsWith("/api/") && !/\.[a-zA-Z0-9]+$/.test(pathname)) {
+    const bundle = await getBundle(config.entry, true);
+    if (!(bundle instanceof Response)) {
+      try {
+        const { renderProjectHtml } = await import("./project-6tft5e77.js");
+        const rendered = await renderProjectHtml(config, {
+          head: bundle.stylesheets.map(({ pathname: href }) => ({
+            tag: "link",
+            attributes: { rel: "stylesheet", href }
+          })),
+          scripts: [{ type: "module", src: bundle.entry.pathname }]
+        }, config.entry, "/", bundle.components);
+        const html = await emitDevelopmentDocumentStyles(rendered, bundle);
+        publishDevelopmentBundle(bundle, artifacts);
+        return new Response(liveReload ? injectLiveReloadScript(html) : html, {
+          headers: {
+            "content-type": "text/html; charset=utf-8",
+            "cache-control": "no-store"
+          }
+        });
+      } catch (error) {
+        console.error(error);
+        return buildFailureResponse();
+      } finally {
+        releaseDevelopmentBundle(bundle);
+      }
+    }
+  }
+  return new Response("Not found", {
+    status: 404,
+    headers: { "cache-control": "no-store" }
+  });
+}
+function pageRouteForPathname(pages, pathname) {
+  if (pages[pathname] !== undefined) {
+    return pathname;
+  }
+  if (pathname === "/index.html") {
+    return "/";
+  }
+  const candidate = pathname.length > 1 && pathname.endsWith("/") ? pathname.replace(/\/+$/, "") : pathname;
+  if (pages[candidate] !== undefined) {
+    return candidate;
+  }
+  if (candidate.endsWith("/index.html")) {
+    const base = candidate.slice(0, candidate.length - "/index.html".length);
+    if (base === "") {
+      return "/";
+    }
+    if (pages[base] !== undefined) {
+      return base;
+    }
+  }
+  return;
+}
+function injectLiveReloadScript(html) {
+  if (html.includes(LIVE_RELOAD_PATH)) {
+    return html;
+  }
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${LIVE_RELOAD_CLIENT_SCRIPT}</body>`);
+  }
+  return html + LIVE_RELOAD_CLIENT_SCRIPT;
+}
+var reloadEncoder = new TextEncoder;
+function createLiveReloadHub() {
+  const controllers = new Set;
+  function handleRequest(request) {
+    if (new URL(request.url).pathname !== LIVE_RELOAD_PATH) {
+      return;
+    }
+    let streamController;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        streamController = controller;
+        controllers.add(controller);
+        try {
+          controller.enqueue(reloadEncoder.encode(`: connected
+
+`));
+        } catch {
+          controllers.delete(controller);
+        }
+      },
+      cancel: () => {
+        if (streamController) {
+          controllers.delete(streamController);
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "content-type": "text/event-stream",
+        "cache-control": "no-store"
+      }
+    });
+  }
+  function broadcast() {
+    const message = reloadEncoder.encode(`event: reload
+data: {}
+
+`);
+    for (const controller of [...controllers]) {
+      try {
+        controller.enqueue(message);
+      } catch {
+        controllers.delete(controller);
+      }
+    }
+  }
+  return { handleRequest, broadcast };
+}
+function isWatchedFile(instance, relativePath) {
+  if (relativePath === "" || relativePath.startsWith("..")) {
+    return false;
+  }
+  const segments = relativePath.split("/");
+  if (segments.some((segment) => IGNORED_WATCH_SEGMENTS.has(segment))) {
+    return false;
+  }
+  const absolutePath = resolve7(instance.config.root, relativePath);
+  if (isWithinOrEqual(instance.config.build.outDir, absolutePath)) {
+    return false;
+  }
+  const base = basename3(absolutePath);
+  if (base.startsWith(".") && absolutePath !== instance.config.configFile) {
+    return false;
+  }
+  return WATCHED_EXTENSIONS.has(extname(base).toLowerCase());
+}
+function toRelativePath2(root, absolutePath) {
+  return relative5(root, absolutePath).split(sep4).join("/");
+}
+function isWithinOrEqual(parent, candidate) {
+  const pathFromParent = relative5(parent, candidate);
+  return pathFromParent === "" || pathFromParent !== ".." && !pathFromParent.startsWith(`..${sep4}`) && !isAbsolute4(pathFromParent);
+}
+async function emitDevelopmentDocumentStyles(rendered, bundle) {
+  const generationUrl = bundle.generationUrl;
+  const result = await emitDocumentStyles(rendered, bundle.outDir, (path) => `${generationUrl}/${basename3(path)}`, bundle.stylesheets.map((stylesheet) => stylesheet.pathname), bundle.componentStylesheets.map((stylesheet) => stylesheet.pathname));
+  for (const path of result.assets) {
+    const pathname = `${generationUrl}/${basename3(path)}`;
+    bundle.artifacts.set(pathname, {
+      filePath: path,
+      pathname,
+      type: "text/css; charset=utf-8"
+    });
+  }
+  return result.html;
+}
+function createDevelopmentBuilder(sessionId, sessionOutDir, artifacts, config) {
+  let queue = Promise.resolve();
+  let disposed = false;
+  let disposal;
+  const latestBundles = new Map;
+  const retirementTimers = new Map;
+  function retire(bundle) {
+    bundle.retire = () => {
+      const previousTimer = retirementTimers.get(bundle.outDir);
+      if (previousTimer)
+        clearTimeout(previousTimer);
+      retirementTimers.delete(bundle.outDir);
+      if (disposed || bundle.activeRequests > 0)
+        return;
+      const timer = setTimeout(() => {
+        retirementTimers.delete(bundle.outDir);
+        removeDevelopmentBundle(bundle, artifacts).catch((error) => console.error(error));
+      }, DEVELOPMENT_OUTPUT_RETENTION_MS);
+      timer.unref();
+      retirementTimers.set(bundle.outDir, timer);
+    };
+    bundle.retire();
+  }
+  function build2(entry) {
+    const result = queue.then(async () => {
+      if (disposed)
+        return buildFailureResponse();
+      const bundle = await buildProjectBundle(entry, sessionId, sessionOutDir, config);
+      if (!(bundle instanceof Response)) {
+        const previous = latestBundles.get(entry);
+        latestBundles.set(entry, bundle);
+        if (previous)
+          retire(previous);
+      }
+      return bundle;
+    });
+    queue = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  }
+  function dispose() {
+    if (disposal)
+      return disposal;
+    disposed = true;
+    retirementTimers.forEach((timer) => clearTimeout(timer));
+    retirementTimers.clear();
+    disposal = queue.then(async () => {
+      await rm2(sessionOutDir, { recursive: true, force: true });
+      latestBundles.clear();
+      artifacts.clear();
+    });
+    return disposal;
+  }
+  return { build: build2, dispose };
+}
+function releaseDevelopmentBundle(bundle) {
+  bundle.activeRequests -= 1;
+  bundle.retire?.();
+}
+async function removeDevelopmentBundle(bundle, artifacts) {
+  await rm2(bundle.outDir, { recursive: true, force: true });
+  for (const pathname of bundle.artifacts.keys()) {
+    artifacts.delete(pathname);
+  }
+}
+async function buildProjectBundle(entry, sessionId, sessionOutDir, config) {
+  const generationId = createGenerationId();
+  const generationOutDir = resolve7(sessionOutDir, generationId);
+  const generationUrl = `${DEVELOPMENT_URL_PREFIX}/${sessionId}/${generationId}`;
+  const buildOptions = {
+    entrypoints: [entry],
+    outdir: generationOutDir,
+    target: "browser",
+    format: "esm",
+    sourcemap: "inline",
+    throw: false,
+    publicPath: `${generationUrl}/`,
+    naming: {
+      entry: "[name]-[hash].[ext]",
+      chunk: "[name]-[hash].[ext]",
+      asset: "assets/[name]-[hash].[ext]"
+    }
+  };
+  let success = false;
+  try {
+    const components = createWebComponentContext(config, entry);
+    const { result, styles } = await buildWebBundle(buildOptions, components);
+    const entryArtifact = result.outputs.find(isEntryJavaScriptOutput);
+    if (!result.success || !entryArtifact) {
+      result.logs.forEach((log) => console.error(log));
+      if (!entryArtifact) {
+        console.error("Failed to build project bundle: no JavaScript output");
+      }
+      return buildFailureResponse();
+    }
+    const pendingArtifacts = new Map;
+    const outputs = new Map;
+    for (const output of result.outputs) {
+      const developmentOutput = createDevelopmentOutput(generationOutDir, generationUrl, output);
+      if (pendingArtifacts.has(developmentOutput.pathname)) {
+        throw new Error(`Development output URL collision: ${developmentOutput.pathname}`);
+      }
+      pendingArtifacts.set(developmentOutput.pathname, developmentOutput);
+      outputs.set(output, developmentOutput);
+    }
+    const entryOutput = outputs.get(entryArtifact);
+    if (!entryOutput) {
+      throw new Error("Development entry output was not indexed");
+    }
+    const componentStylesheets = (await emitComponentStyles(styles, generationOutDir)).map((filePath) => ({
+      filePath,
+      pathname: `${generationUrl}/${basename3(filePath)}`,
+      type: "text/css; charset=utf-8"
+    }));
+    for (const output of componentStylesheets)
+      pendingArtifacts.set(output.pathname, output);
+    success = true;
+    return {
+      outDir: generationOutDir,
+      components,
+      generationUrl,
+      activeRequests: 0,
+      entry: entryOutput,
+      componentStylesheets,
+      stylesheets: result.outputs.filter(isStylesheetOutput).map((output) => outputs.get(output)).filter((output) => output !== undefined),
+      artifacts: pendingArtifacts
+    };
+  } catch (error) {
+    console.error(error);
+    return buildFailureResponse();
+  } finally {
+    if (!success) {
+      await rm2(generationOutDir, { recursive: true, force: true });
+    }
+  }
+}
+function publishDevelopmentBundle(bundle, artifacts) {
+  for (const [pathname, output] of bundle.artifacts) {
+    const existing = artifacts.get(pathname);
+    if (existing) {
+      if (existing.filePath === output.filePath) {
+        continue;
+      }
+      throw new Error(`Development output URL collision: ${pathname}`);
+    }
+    artifacts.set(pathname, output);
+  }
+}
+function createDevelopmentOutput(generationOutDir, generationUrl, output) {
+  const filePath = resolve7(output.path);
+  const pathFromGeneration = relative5(generationOutDir, filePath);
+  if (pathFromGeneration === "" || pathFromGeneration === ".." || pathFromGeneration.startsWith(`..${sep4}`) || isAbsolute4(pathFromGeneration)) {
+    throw new Error(`Development output must not escape outside its generation directory: ${output.path}`);
+  }
+  const urlPath = pathFromGeneration.split(sep4).map((segment) => encodeURIComponent(segment)).join("/");
+  return {
+    filePath,
+    pathname: `${generationUrl}/${urlPath}`,
+    type: output.type
+  };
+}
+function createGenerationId() {
+  return randomUUID2().replace(/-/g, "");
+}
+function buildFailureResponse() {
+  return new Response("Failed to build project bundle", {
+    status: 500,
+    headers: { "cache-control": "no-store" }
+  });
+}
+
+export { TARGET_TYPES, isTargetType, MP_TARGET_TYPES, isMpTargetType, defineConfig, resolveConfig, WebTarget, MpTarget, mpWeixinTarget, mpAlipayTarget, mpBytedanceTarget, mpXiaohongshuTarget, TargetRegistry, targetRegistry, build, buildConfigured, reportComponents, reportConfiguredComponents, formatComponentSelectionReport, createProject, startDevServer };
+
+//# debugId=2077B6EF8001292264756E2164756E21
+//# sourceMappingURL=index-2g3e5sjt.js.map