@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/build-externalize-repeated.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Lift inline blobs that repeat across pages, whatever they are.
+ *
+ * `build-externalize` handles the three blobs stx knows by name — the signals
+ * runtime, the router, and the generated stylesheet. Everything else it emits
+ * inline stays inline, and on a real multi-page site that is where the bytes
+ * actually are: the ts-cloud dashboard ships 54 pages at 12.5MB, of which
+ * 10.3MB is byte-identical `<script data-stx-scoped>` and unattributed
+ * `<style>` blocks repeated page after page. None of it is cacheable across a
+ * navigation, and it is 4x the size of the three named blobs combined.
+ *
+ * The rule here needs no allowlist: a blob that appears byte-for-byte on two
+ * or more pages is shared by construction, so hoisting it into one
+ * content-addressed file is a pure win — every page that referenced it now
+ * downloads it once for the whole site instead of once per page. A blob that
+ * appears on exactly one page is left alone, because turning it into a second
+ * request would make that page slower, not smaller.
+ *
+ * Requires the whole output directory, which is why it is a separate pass from
+ * the pure per-document `externalizeHtml`: "does this appear elsewhere" is not
+ * a question one document can answer, and SSR (which shares that function) has
+ * no elsewhere to look at.
+ *
+ * @module build-externalize-repeated
+ */
+import { type ExternalizeResult } from './build-externalize';
+/**
+ * Hoist every inline script/style body that appears on more than one page.
+ *
+ * Runs after {@link externalizeSharedAssets}, over the same directory, and is
+ * equally safe to run twice: the second pass sees `src`/`href` references with
+ * no inline body and matches nothing.
+ */
+export declare function externalizeRepeatedAssets(outDir: string): ExternalizeResult;

package/dist/build-externalize-repeated.js

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import path from "node:path";
+import { EXTERNALIZED_ASSET_DIR } from "./build-externalize.js";
+const MIN_BLOB_BYTES = 1024, INLINE_BLOB = /<(script|style)\b([^>]*)>([\s\S]*?)<\/\1>/gi, JS_TYPES = new Set(["", "module", "text/javascript", "application/javascript", "module/javascript"]);
+function contentHash(source) {
+  return Bun.hash(source).toString(16).slice(0, 8);
+}
+function listHtmlFiles(dir) {
+  const found = [], walk = (current) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: !0 })) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory())
+        walk(full);
+      else if (entry.isFile() && full.endsWith(".html"))
+        found.push(full);
+    }
+  };
+  if (fs.existsSync(dir))
+    walk(dir);
+  return found;
+}
+function attrValue(attrs, name) {
+  const match = attrs.match(new RegExp(`\\b${name}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s>]+))`, "i"));
+  if (!match)
+    return;
+  return match[2] ?? match[3] ?? match[4] ?? "";
+}
+function isExternalizable(tag, attrs, body) {
+  if (body.length < MIN_BLOB_BYTES)
+    return !1;
+  if (/\b(?:src|href)\s*=/i.test(attrs))
+    return !1;
+  if (tag.toLowerCase() === "script") {
+    if (!JS_TYPES.has((attrValue(attrs, "type") ?? "").trim().toLowerCase()))
+      return !1;
+    return !0;
+  }
+  return !0;
+}
+function templateRanges(html) {
+  const ranges = [];
+  for (const match of html.matchAll(/<template\b[^>]*>[\s\S]*?<\/template>/gi))
+    ranges.push([match.index, match.index + match[0].length]);
+  return ranges;
+}
+export function externalizeRepeatedAssets(outDir) {
+  const result = { pages: 0, assets: 0, bytesInlined: 0 }, files = listHtmlFiles(outDir);
+  if (files.length < 2)
+    return result;
+  const sources = new Map, occurrences = new Map;
+  for (const file of files) {
+    const html = fs.readFileSync(file, "utf8");
+    sources.set(file, html);
+    const templates = templateRanges(html);
+    for (const match of html.matchAll(INLINE_BLOB)) {
+      const [whole, tag, attrs, body] = match;
+      if (!isExternalizable(tag, attrs, body))
+        continue;
+      if (templates.some(([start, end]) => match.index >= start && match.index < end))
+        continue;
+      const key = `${tag.toLowerCase()}\x00${body}`, list = occurrences.get(key);
+      if (list)
+        list.push({ file, whole, tag, attrs, body });
+      else
+        occurrences.set(key, [{ file, whole, tag, attrs, body }]);
+    }
+  }
+  const shared = [...occurrences.values()].filter((list) => new Set(list.map((o) => o.file)).size > 1);
+  if (shared.length === 0)
+    return result;
+  const assetDir = path.join(outDir, EXTERNALIZED_ASSET_DIR), rewrites = new Map(sources), bytesPerFile = new Map, assets = [];
+  for (const list of shared) {
+    const { tag, body } = list[0], isScript = tag.toLowerCase() === "script", filename = `${isScript ? "chunk" : "style"}.${contentHash(body)}.${isScript ? "js" : "css"}`;
+    assets.push({
+      filename,
+      contents: body,
+      contentType: isScript ? "text/javascript; charset=utf-8" : "text/css; charset=utf-8"
+    });
+    const href = `/${EXTERNALIZED_ASSET_DIR}/${filename}`;
+    for (const occurrence of list) {
+      const replacement = isScript ? `<script${occurrence.attrs} src="${href}"></script>` : `<link${occurrence.attrs} rel="stylesheet" href="${href}">`, current = rewrites.get(occurrence.file), next = current.replace(occurrence.whole, () => replacement);
+      if (next === current)
+        continue;
+      rewrites.set(occurrence.file, next);
+      bytesPerFile.set(occurrence.file, (bytesPerFile.get(occurrence.file) ?? 0) + occurrence.body.length);
+    }
+  }
+  fs.mkdirSync(assetDir, { recursive: !0 });
+  for (const asset of assets) {
+    fs.writeFileSync(path.join(assetDir, asset.filename), asset.contents);
+    result.assets++;
+  }
+  for (const [file, html] of rewrites) {
+    if (html === sources.get(file))
+      continue;
+    fs.writeFileSync(file, html);
+    result.pages++;
+    result.bytesInlined += bytesPerFile.get(file) ?? 0;
+  }
+  return result;
+}

package/dist/build-externalize.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Lift shared inline blobs out of built HTML into content-hashed assets.
+ *
+ * The static build inlines the whole signals runtime and the whole generated
+ * stylesheet into every page. On a 35-page site that is ~118KB of
+ * byte-identical runtime per page and a separate copy of the reset in each one,
+ * none of it cacheable across a navigation, and `find dist -name '*.js'`
+ * returns nothing at all (stacksjs/stx#1865, #1878).
+ *
+ * Done as a post-pass over the emitted HTML rather than by threading
+ * `buildMode` through the renderer, deliberately. The existing `compile` branch
+ * emits `/__stx/runtime.__STX_HASH__.js`, a placeholder only the production
+ * builder knows how to rewrite, and setting that mode also suppresses the
+ * document shell — so reusing it on the SSG path produces pages that reference
+ * a 404 and lose their `<html>` wrapper. A post-pass needs neither.
+ *
+ * Content-addressed, so identical blobs across pages collapse to one file: the
+ * runtime is byte-identical everywhere and becomes a single asset, while
+ * per-page CSS dedupes only where pages genuinely share a stylesheet.
+ *
+ * The rewrite itself is `externalizeHtml`, which touches no filesystem. SSR has
+ * the same problem in a worse form — a static build inlines the runtime once
+ * per page, a server inlines it once per *request* — and it cannot use a
+ * post-pass over a directory because there are no files. Sharing the pure
+ * function means the two paths cannot drift into rewriting HTML differently.
+ *
+ * @module build-externalize
+ */
+/** Where externalized assets are written, relative to the output directory. */
+export declare const EXTERNALIZED_ASSET_DIR = "_stx";
+export interface ExternalizeResult {
+    /** HTML files rewritten. */
+    pages: number;
+    /** Distinct asset files written. */
+    assets: number;
+    /** Bytes removed from HTML (before any compression). */
+    bytesInlined: number;
+}
+/** A blob lifted out of the HTML, ready to be written or served. */
+export interface ExternalizedAsset {
+    /** Content-addressed filename, e.g. `runtime.1a2b3c4d.js`. */
+    filename: string;
+    contents: string;
+    /** MIME type, so a server can respond without re-deriving it from the name. */
+    contentType: string;
+}
+export interface ExternalizeHtmlResult {
+    html: string;
+    /** Distinct assets this page referenced. Deduped within the page. */
+    assets: ExternalizedAsset[];
+    /** Bytes removed from the HTML, before any compression. */
+    bytesInlined: number;
+}
+/**
+ * Lift the shared blobs out of one HTML document.
+ *
+ * Pure: returns the rewritten HTML and the assets it extracted, and writes
+ * nothing. Callers decide whether those assets become files on disk or entries
+ * in a server's cache.
+ *
+ * Safe to run twice — a tag that is already a `src`/`href` reference has no
+ * inline body to match, so a second pass extracts nothing and returns the input
+ * unchanged.
+ */
+export declare function externalizeHtml(html: string, basePath?: string): ExternalizeHtmlResult;
+/**
+ * Rewrite every HTML file under `outDir`, moving the signals runtime and the
+ * generated stylesheet into `_stx/` and linking to them.
+ *
+ * Safe to run twice: a page whose runtime is already a `src=` reference has no
+ * inline body to match, so a second pass is a no-op.
+ */
+export declare function externalizeSharedAssets(outDir: string): ExternalizeResult;

package/dist/build-externalize.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import path from "node:path";
+export const EXTERNALIZED_ASSET_DIR = "_stx";
+function contentHash(source) {
+  return Bun.hash(source).toString(16).slice(0, 8);
+}
+function listHtmlFiles(dir) {
+  const found = [], walk = (current) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: !0 })) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory())
+        walk(full);
+      else if (entry.isFile() && full.endsWith(".html"))
+        found.push(full);
+    }
+  };
+  if (fs.existsSync(dir))
+    walk(dir);
+  return found;
+}
+const BLOB_KINDS = [
+  {
+    pattern: /<script\b([^>]*\bdata-stx-runtime\b[^>]*)>([\s\S]*?)<\/script>/gi,
+    prefix: "runtime",
+    extension: "js",
+    contentType: "text/javascript; charset=utf-8",
+    replace: (href) => `<script data-stx-runtime src="${href}"></script>`
+  },
+  {
+    pattern: /<script\b([^>]*\bdata-stx-router\b[^>]*)>([\s\S]*?)<\/script>/gi,
+    prefix: "router",
+    extension: "js",
+    contentType: "text/javascript; charset=utf-8",
+    replace: (href) => `<script data-stx-router src="${href}"></script>`
+  },
+  {
+    pattern: /<style\b([^>]*\bdata-css=(?:"generated"|'generated')[^>]*)>([\s\S]*?)<\/style>/gi,
+    prefix: "css",
+    extension: "css",
+    contentType: "text/css; charset=utf-8",
+    replace: (href) => `<link data-css="generated" rel="stylesheet" href="${href}">`
+  }
+];
+export function externalizeHtml(html, basePath = `/${EXTERNALIZED_ASSET_DIR}`) {
+  const assets = [], seen = new Set;
+  let bytesInlined = 0, out = html;
+  for (const kind of BLOB_KINDS)
+    out = out.replace(kind.pattern, (whole, attrs, body) => {
+      if (/\b(?:src|href)\s*=/.test(attrs) || !body.trim())
+        return whole;
+      const filename = `${kind.prefix}.${contentHash(body)}.${kind.extension}`;
+      if (!seen.has(filename)) {
+        seen.add(filename);
+        assets.push({ filename, contents: body, contentType: kind.contentType });
+      }
+      bytesInlined += body.length;
+      return kind.replace(`${basePath}/${filename}`);
+    });
+  return { html: out, assets, bytesInlined };
+}
+export function externalizeSharedAssets(outDir) {
+  const result = { pages: 0, assets: 0, bytesInlined: 0 }, assetDir = path.join(outDir, EXTERNALIZED_ASSET_DIR), written = new Set;
+  for (const file of listHtmlFiles(outDir)) {
+    const original = fs.readFileSync(file, "utf8"), { html, assets, bytesInlined } = externalizeHtml(original);
+    if (html === original)
+      continue;
+    for (const asset of assets) {
+      if (written.has(asset.filename))
+        continue;
+      written.add(asset.filename);
+      fs.mkdirSync(assetDir, { recursive: !0 });
+      fs.writeFileSync(path.join(assetDir, asset.filename), asset.contents);
+      result.assets++;
+    }
+    fs.writeFileSync(file, html);
+    result.bytesInlined += bytesInlined;
+    result.pages++;
+  }
+  return result;
+}

package/dist/build-id.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Per-process build identity, used to detect runtime/fragment skew
+ * (stacksjs/stx#1772).
+ *
+ * Under `bun --watch`, a loaded page holds the client runtime from build N. A
+ * file save restarts the server, and the next SPA navigation fetches a fragment
+ * rendered by build N+1. Fragments legitimately carry preserved `{{ }}`
+ * moustaches for client-side binding, so any drift in the scoped-script or
+ * binding format between the two builds leaves the OLD runtime unable to
+ * hydrate the NEW fragment: literal moustaches on screen, dead `:show`, stale
+ * canvas. It is sporadic and never reproduces from a clean boot, which is
+ * exactly its signature.
+ *
+ * Stamping the identity on both sides lets the router notice the mismatch and
+ * fall back to a full page navigation — the same thing Next and Vite's HMR
+ * clients do on a version mismatch. It does not fix format drift; it makes the
+ * whole class of skew symptoms impossible to observe.
+ *
+ * The comparison is deliberately conservative: the router only acts when BOTH
+ * sides are known. A missing id means "no information", never "mismatch".
+ * That keeps statically hosted output (no headers to send) and any consumer on
+ * an older server working exactly as before.
+ *
+ * @module build-id
+ */
+/** `<meta name="stx-build">` on every rendered page. */
+export declare const BUILD_ID_META = "stx-build";
+/** Response header carrying the id that rendered an SPA fragment. */
+export declare const BUILD_ID_HEADER = "X-STX-Build";
+/**
+ * The current process's build id.
+ *
+ * Stable for the lifetime of the process, which is the unit that matters: a
+ * `bun --watch` restart produces a new process and therefore a new id, while a
+ * production build stamps every page it renders with one value.
+ *
+ * `STX_BUILD_ID` overrides it, for deployments that render across several
+ * processes and need them to agree.
+ */
+export declare function getBuildId(): string;
+/** @internal test-only — force the id, or with `null` restore generation. */
+export declare function __setBuildIdForTest(id: string | null): void;
+/**
+ * Add `<meta name="stx-build">` to `<head>` if it isn't already there.
+ *
+ * Idempotent, and a no-op for output with no `<head>` — SPA fragments carry the
+ * id in a response header instead, since they have nowhere to put a meta.
+ */
+export declare function injectBuildId(html: string, buildId?: string): string;
+/**
+ * The same decision as `injectBuildId`, without the splice (stacksjs/stx#1945).
+ *
+ * Returns what belongs immediately after the `<head>` open tag, or null when
+ * the id is already stamped or the document has no head -- an SPA fragment
+ * carries it in a response header instead, having nowhere to put a meta.
+ */
+export declare function buildIdFragment(html: string, buildId?: string): string | null;

package/dist/build-id.js

@@ -0,0 +1,25 @@
+export const BUILD_ID_META = "stx-build", BUILD_ID_HEADER = "X-STX-Build";
+let cached = null;
+export function getBuildId() {
+  if (cached === null)
+    cached = process.env.STX_BUILD_ID || `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+  return cached;
+}
+export function __setBuildIdForTest(id) {
+  cached = id;
+}
+export function injectBuildId(html, buildId = getBuildId()) {
+  const fragment = buildIdFragment(html, buildId);
+  if (fragment === null)
+    return html;
+  const headOpen = /<head\b[^>]*>/i.exec(html), insertAt = headOpen.index + headOpen[0].length;
+  return `${html.slice(0, insertAt)}${fragment}${html.slice(insertAt)}`;
+}
+export function buildIdFragment(html, buildId = getBuildId()) {
+  if (html.includes(`name="${BUILD_ID_META}"`))
+    return null;
+  if (!/<head\b[^>]*>/i.test(html))
+    return null;
+  return `
+  <meta name="${BUILD_ID_META}" content="${buildId}">`;
+}

package/dist/build-message.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Make a Bun build failure say where it happened (stacksjs/stx#1810).
+ *
+ * A single unparseable view produced `BuildMessage: Unexpected ===` and nothing
+ * else — no path, no line — leaving the reporter to binary-search the scanned
+ * views by hand.
+ *
+ * The location was never missing. Bun computes it and puts it on
+ * `BuildMessage.position`; it is `.message` and `.toString()` that omit it. And
+ * because `BuildMessage` is not an `instanceof Error` and carries no `.stack`,
+ * the usual `error instanceof Error ? error.message : String(error)` idiom —
+ * which this codebase uses in a dozen places — reduces it to exactly that bare
+ * string.
+ *
+ * Two further wrinkles this handles:
+ *
+ *  - `Bun.build()` does not throw a BuildMessage. It throws an AggregateError
+ *    whose `.errors` holds them, so the useful detail is one level down.
+ *  - `Bun.Transpiler.transformSync()` reports `position.file` as its synthetic
+ *    entry name, never the real path. The caller knows the real one, so it is
+ *    threaded in rather than trusted from the message.
+ */
+/**
+ * One failure, with its position kept separate rather than baked into a string.
+ *
+ * A terminal wants `path:line:col: message`; a dev-server overlay wants to draw
+ * a code frame and put a caret under the column. Both are rendered from this,
+ * so the two cannot drift into disagreeing about where the error is (#1884).
+ */
+export interface BuildFailureDetail {
+    file?: string;
+    line?: number;
+    column?: number;
+    message: string;
+    /** The offending source line, when Bun reported one. */
+    lineText?: string;
+}
+/**
+ * Pull every failure out of whatever was thrown, with positions intact.
+ *
+ * @param error whatever was thrown — BuildMessage, AggregateError, Error, or
+ * anything else
+ * @param sourcePath the real file being compiled. Preferred over the position's
+ * own `file`, which is a synthetic entry name on the transpiler path.
+ */
+export declare function describeBuildFailure(error: unknown, sourcePath?: string): BuildFailureDetail[];
+/**
+ * Render a build failure as `path:line:column: message`, falling back to the
+ * plain message when no position is available.
+ */
+export declare function formatBuildFailure(error: unknown, sourcePath?: string): string;
+/**
+ * Find a failure's line in the ORIGINAL source.
+ *
+ * The client-script bundler compiles a temp entry under `.stx/bundle-tmp`, so
+ * Bun's `position.line` counts lines in THAT file — for a `<script client>`
+ * block halfway down a page it is off by however many lines precede the block,
+ * and for an unresolved import it comes back as `-1`. Pointing an overlay at
+ * that line is worse than pointing at none: it sends the reader to code that is
+ * fine.
+ *
+ * `lineText` is the one thing that survives the move. If it occurs exactly once
+ * in the source, that is the line. Ambiguous or absent yields nothing, which the
+ * caller renders as a message with no frame.
+ */
+export declare function locateFailureLine(source: string, lineText?: string): number | undefined;
+/** One line of a code frame. */
+export interface CodeFrameLine {
+    number: number;
+    text: string;
+    /** The line the error is on. */
+    isError: boolean;
+}
+/**
+ * The lines around a failure, for an overlay to draw.
+ *
+ * Returns the offending line plus `context` lines either side, which is what
+ * turns "Could not resolve" into something a reader can act on without opening
+ * the file. Empty when there is no line to centre on.
+ */
+export declare function buildCodeFrame(source: string, line?: number, context?: number): CodeFrameLine[];

package/dist/build-message.js

@@ -0,0 +1,65 @@
+function isBuildMessageLike(value) {
+  if (!value || typeof value !== "object")
+    return !1;
+  const candidate = value;
+  return typeof candidate.message === "string" && (candidate.name === "BuildMessage" || candidate.name === "ResolveMessage" || ("position" in candidate));
+}
+function unwrap(error) {
+  if (error && typeof error === "object" && Array.isArray(error.errors))
+    return error.errors;
+  return [error];
+}
+export function describeBuildFailure(error, sourcePath) {
+  const details = [];
+  for (const item of unwrap(error)) {
+    if (isBuildMessageLike(item)) {
+      const position = item.position || void 0;
+      details.push({
+        file: sourcePath || position?.file,
+        line: position?.line,
+        column: position?.column,
+        message: item.message ?? "",
+        lineText: position?.lineText
+      });
+      continue;
+    }
+    details.push({
+      file: sourcePath,
+      message: item instanceof Error ? item.message : String(item)
+    });
+  }
+  return details;
+}
+export function formatBuildFailure(error, sourcePath) {
+  return describeBuildFailure(error, sourcePath).map((detail) => {
+    const where = detail.file ? `${detail.file}${detail.line ? `:${detail.line}${detail.column ? `:${detail.column}` : ""}` : ""}` : "", snippet = detail.lineText ? `
+    ${detail.lineText.trim()}` : "";
+    return where ? `${where}: ${detail.message}${snippet}` : `${detail.message}${snippet}`;
+  }).join(`
+`);
+}
+export function locateFailureLine(source, lineText) {
+  const needle = lineText?.trim();
+  if (!needle)
+    return;
+  const lines = source.split(`
+`);
+  let found;
+  for (let i = 0;i < lines.length; i++) {
+    if (lines[i].trim() !== needle)
+      continue;
+    if (found !== void 0)
+      return;
+    found = i + 1;
+  }
+  return found;
+}
+export function buildCodeFrame(source, line, context = 2) {
+  if (!line || line < 1)
+    return [];
+  const lines = source.split(`
+`), start = Math.max(1, line - context), end = Math.min(lines.length, line + context), frame = [];
+  for (let n = start;n <= end; n++)
+    frame.push({ number: n, text: lines[n - 1] ?? "", isError: n === line });
+  return frame;
+}

package/dist/build-mode-detector.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Scan all `.stx` files in the project and determine the build mode.
+ *
+ * - Zero `<script server>` tags → `'ssg'` (static site, flat HTML in `dist/`)
+ * - Any `<script server>` tag  → `'ssr'` (server bundle in `.output/`)
+ */
+export declare function detectBuildMode(root?: string): Promise<BuildModeDetectionResult>;
+/**
+ * Validate that components don't mix `<script server>` and `<script client>`.
+ *
+ * Components should be server OR client — compose them via props/slots.
+ * Pages are allowed to have both (e.g. `<script server>` for SEO +
+ * `<script client>` for interactivity).
+ */
+export declare function validateComponentScripts(root?: string): Promise<ComponentValidationError[]>;
+export declare interface BuildModeDetectionResult {
+  mode: BuildMode
+  serverScriptFiles: string[]
+  totalFilesScanned: number
+  scanDurationMs: number
+}
+export declare interface ComponentValidationError {
+  file: string
+  message: string
+}
+export type BuildMode = 'ssg' | 'ssr';

package/dist/build-mode-detector.js

@@ -0,0 +1,50 @@
+import path from "node:path";
+import { loadStxConfig } from "./config.js";
+const SERVER_SCRIPT_RE = /<script\b[^>]*\bserver\b/i, CLIENT_SCRIPT_RE = /<script\b[^>]*\bclient\b/i;
+export async function detectBuildMode(root) {
+  const start = performance.now(), config = await loadStxConfig(root), projectRoot = root || config.root || process.cwd(), dirs = [
+    config.build?.pagesDir || config.pagesDir || "pages",
+    config.componentsDir || "components",
+    config.layoutsDir || "layouts",
+    config.partialsDir || "partials"
+  ].map((d) => path.resolve(projectRoot, d)), serverScriptFiles = [];
+  let totalFilesScanned = 0;
+  for (const dir of dirs) {
+    const stxFiles = await collectStxFiles(dir);
+    for (const file of stxFiles) {
+      totalFilesScanned++;
+      const content = await Bun.file(file).text();
+      if (SERVER_SCRIPT_RE.test(content))
+        serverScriptFiles.push(path.relative(projectRoot, file));
+    }
+  }
+  return {
+    mode: serverScriptFiles.length > 0 ? "ssr" : "ssg",
+    serverScriptFiles,
+    totalFilesScanned,
+    scanDurationMs: Math.round(performance.now() - start)
+  };
+}
+export async function validateComponentScripts(root) {
+  const config = await loadStxConfig(root), projectRoot = root || config.root || process.cwd(), componentsDir = path.resolve(projectRoot, config.componentsDir || "components"), errors = [], stxFiles = await collectStxFiles(componentsDir);
+  for (const file of stxFiles) {
+    const content = await Bun.file(file).text(), hasServer = SERVER_SCRIPT_RE.test(content), hasClient = CLIENT_SCRIPT_RE.test(content) || /<script\b(?![^>]*\bserver\b)[^>]*>/i.test(content) && !hasServer;
+    if (hasServer && hasClient) {
+      const relative = path.relative(projectRoot, file);
+      errors.push({
+        file: relative,
+        message: `Component "${relative}" has both <script server> and <script client>. ` + "Components should be server OR client \u2014 compose them via props/slots."
+      });
+    }
+  }
+  return errors;
+}
+async function collectStxFiles(dir) {
+  const files = [];
+  try {
+    const glob = new Bun.Glob("**/*.stx");
+    for await (const file of glob.scan({ cwd: dir, absolute: !0 }))
+      files.push(file);
+  } catch {}
+  return files;
+}