@moonsjs/vite 0.0.0-stage → 0.1.1

package/dist/index-fg6nqart.js

@@ -0,0 +1,776 @@
+// src/transform.ts
+import { MoonsError, computeFnHash, fnRegistryKey } from "@moonsjs/core";
+import { parse } from "@babel/parser";
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+var SERVER_SPECIFIER = /\.server(\.(ts|tsx|js|jsx|mts|cts|mjs|cjs))?$/i;
+var CONTRACT_SERVER_FILE = /\.server\.(ts|tsx)$/i;
+var NON_CONTRACT_SERVER_FILE = /\.server\.(js|jsx|mts|cts|mjs|cjs)$/i;
+function isServerFilePath2(path) {
+  return CONTRACT_SERVER_FILE.test(stripQuery2(path));
+}
+function isNonContractServerFile2(path) {
+  return NON_CONTRACT_SERVER_FILE.test(stripQuery2(path));
+}
+function isServerSpecifier2(specifier) {
+  return SERVER_SPECIFIER.test(specifier);
+}
+function resolveServerSpecifierSync2(importerFile, specifier) {
+  if (!isServerSpecifier2(specifier)) {
+    return null;
+  }
+  const base = specifier.startsWith(".") ? resolve(dirname(importerFile), specifier) : isAbsolute(specifier) ? specifier : null;
+  if (base === null) {
+    return null;
+  }
+  for (const candidate of [base, `${base}.ts`, `${base}.tsx`]) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function stripQuery2(id) {
+  const queryIndex = id.indexOf("?");
+  return queryIndex === -1 ? id : id.slice(0, queryIndex);
+}
+function parseModule(code, filename) {
+  return parse(code, {
+    sourceType: "module",
+    plugins: filename.endsWith(".tsx") ? ["typescript", "jsx"] : ["typescript"],
+    errorRecovery: false
+  });
+}
+function walk(node, visit, ancestors = []) {
+  if (node === null || typeof node !== "object") {
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      walk(item, visit, ancestors);
+    }
+    return;
+  }
+  const candidate = node;
+  if (typeof candidate.type !== "string" || typeof candidate.start !== "number") {
+    return;
+  }
+  visit(candidate, ancestors);
+  const nextAncestors = [...ancestors, candidate];
+  for (const key of Object.keys(candidate)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "extra") {
+      continue;
+    }
+    walk(candidate[key], visit, nextAncestors);
+  }
+}
+function topLevelStatements(ast) {
+  const program = ast["program"];
+  return program?.body ?? [];
+}
+function keyName(node) {
+  const key = node;
+  if (key?.type === "Identifier") {
+    return key["name"];
+  }
+  if (key?.type === "StringLiteral") {
+    return key["value"];
+  }
+  return null;
+}
+function extractServerFnInit(init) {
+  const call = init;
+  if (call?.type !== "CallExpression") {
+    return null;
+  }
+  const callee = call["callee"];
+  if (callee?.type !== "Identifier" || callee["name"] !== "serverFn") {
+    return null;
+  }
+  const args = call["arguments"] ?? [];
+  const first = args[0];
+  if (first?.type !== "ObjectExpression") {
+    return null;
+  }
+  const properties = new Map;
+  for (const property of first["properties"] ?? []) {
+    if (property.type !== "ObjectProperty") {
+      continue;
+    }
+    const name = keyName(property["key"]);
+    if (name !== null) {
+      properties.set(name, property);
+    }
+  }
+  const input = properties.get("input")?.["value"];
+  const output = properties.get("output")?.["value"];
+  if (input?.start == null || input.end == null || output?.start == null || output.end == null) {
+    return null;
+  }
+  return {
+    input: { start: input.start, end: input.end },
+    output: { start: output.start, end: output.end },
+    line: call.loc?.start.line ?? 1,
+    objectStart: first.start ?? 0
+  };
+}
+function analyzeServerFile2(source, filename, projectRoot) {
+  const ast = parseModule(source, filename);
+  const serverFns = [];
+  const exportNames = [];
+  const reExports = [];
+  const exportAllFrom = [];
+  for (const statement of topLevelStatements(ast)) {
+    if (statement.type === "ExportNamedDeclaration") {
+      const declaration = statement["declaration"];
+      if (declaration?.type === "VariableDeclaration") {
+        for (const declarator of declaration["declarations"] ?? []) {
+          const id = declarator["id"];
+          if (id?.type !== "Identifier") {
+            continue;
+          }
+          const name = id["name"];
+          exportNames.push(name);
+          const info = extractServerFnInit(declarator["init"]);
+          if (info !== null) {
+            serverFns.push({
+              name,
+              hash: computeFnHash(projectRoot, filename, name),
+              line: info.line,
+              input: info.input,
+              output: info.output,
+              objectStart: info.objectStart
+            });
+          }
+        }
+      } else if (declaration?.type === "FunctionDeclaration") {
+        const id = declaration["id"];
+        if (id?.type === "Identifier") {
+          exportNames.push(id["name"]);
+        }
+      }
+      for (const specifier of statement["specifiers"] ?? []) {
+        const exported = specifier["exported"];
+        if (exported?.type === "Identifier") {
+          exportNames.push(exported["name"]);
+        }
+      }
+      const sourceNode = statement["source"];
+      if (sourceNode?.type === "StringLiteral" && isServerSpecifier2(sourceNode["value"])) {
+        reExports.push({
+          source: sourceNode["value"],
+          names: (statement["specifiers"] ?? []).map((specifier) => ({
+            local: specifier["local"]?.["name"] ?? "",
+            exported: specifier["exported"]?.["name"] ?? ""
+          }))
+        });
+      }
+    } else if (statement.type === "ExportDefaultDeclaration") {
+      exportNames.push("default");
+    } else if (statement.type === "ExportAllDeclaration") {
+      const sourceNode = statement["source"];
+      if (sourceNode?.type === "StringLiteral" && isServerSpecifier2(sourceNode["value"])) {
+        exportAllFrom.push(sourceNode["value"]);
+      }
+    }
+  }
+  return { file: filename, serverFns, exportNames, reExports, exportAllFrom };
+}
+function serverFnExportNames2(analysis, analyzeTarget, seen = new Set) {
+  const names = new Set(analysis.serverFns.map((fn) => fn.name));
+  for (const reExport of analysis.reExports) {
+    const target = analyzeTarget(reExport.source);
+    if (target === null || seen.has(reExport.source)) {
+      continue;
+    }
+    seen.add(reExport.source);
+    const targetNames = serverFnExportNames2(target, analyzeTarget, seen);
+    for (const { local, exported } of reExport.names) {
+      if (local === "*" || targetNames.has(local)) {
+        names.add(exported);
+      }
+    }
+  }
+  for (const specifier of analysis.exportAllFrom) {
+    const target = analyzeTarget(specifier);
+    if (target === null || seen.has(specifier)) {
+      continue;
+    }
+    seen.add(specifier);
+    for (const name of serverFnExportNames2(target, analyzeTarget, seen)) {
+      names.add(name);
+    }
+  }
+  return names;
+}
+function collectRetainedText(source, analysis) {
+  return analysis.serverFns.map((fn) => `${source.slice(fn.input.start, fn.input.end)}
+${source.slice(fn.output.start, fn.output.end)}`).join(`
+`);
+}
+function isUsed(name, retainedText) {
+  return new RegExp(`(^|[^\\w$])${escapeRegExp(name)}([^\\w$]|$)`).test(retainedText);
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function renderServerFnStub2(source, filename, analysis, dependencies) {
+  const ast = parseModule(source, filename);
+  const retainedText = collectRetainedText(source, analysis);
+  const importLines = [];
+  const referenced = [];
+  let needsCreateStub = analysis.serverFns.length > 0;
+  for (const statement of topLevelStatements(ast)) {
+    if (statement.type !== "ImportDeclaration") {
+      continue;
+    }
+    const sourceNode = statement["source"];
+    const specifier = sourceNode["value"];
+    if (/^@moons\/server(\/|$)/.test(specifier)) {
+      continue;
+    }
+    if (specifier.startsWith("node:") || specifier.startsWith("bun:")) {
+      continue;
+    }
+    const specifiers = statement["specifiers"] ?? [];
+    const kept = [];
+    if (isServerSpecifier2(specifier)) {
+      referenced.push(specifier);
+      for (const item of specifiers) {
+        if (item.type === "ImportDefaultSpecifier" || item.type === "ImportNamespaceSpecifier") {
+          continue;
+        }
+        const local = item["local"]?.["name"] ?? "";
+        if (local.length > 0 && isUsed(local, retainedText)) {
+          kept.push(item);
+        }
+      }
+    } else {
+      for (const item of specifiers) {
+        const local = item["local"]?.["name"] ?? "";
+        if (local.length > 0 && isUsed(local, retainedText)) {
+          kept.push(item);
+        }
+      }
+    }
+    if (kept.length === 0) {
+      continue;
+    }
+    const keptText = kept.map((item) => source.slice(item.start ?? 0, item.end ?? 0)).join(", ");
+    importLines.push(`import { ${keptText} } from ${JSON.stringify(specifier)};`);
+  }
+  if (needsCreateStub) {
+    importLines.push('import { __moons_createStub } from "@moonsjs/server/client";');
+  }
+  const exportLines = [];
+  for (const fn of analysis.serverFns) {
+    const input = source.slice(fn.input.start, fn.input.end);
+    const output = source.slice(fn.output.start, fn.output.end);
+    exportLines.push(`export const ${fn.name} = __moons_createStub({ hash: ${JSON.stringify(fn.hash)}, input: ${input}, output: ${output} });`);
+  }
+  for (const reExport of analysis.reExports) {
+    const target = dependencies.analyzeSpecifier(filename, reExport.source);
+    if (target === null) {
+      throw new MoonsError({
+        code: "E_SERVER_IMPORT_IN_CLIENT",
+        file: filename,
+        message: `tidak bisa me-resolve \`${reExport.source}\` untuk re-export`,
+        details: "Re-export dari `*.server.ts` harus bisa di-resolve statis (PRD §12.6).",
+        suggestions: ["Perbaiki path re-export", "Hindari re-export dinamis dari file server"]
+      });
+    }
+    const targetNames = serverFnExportNames2(target, (specifier) => dependencies.analyzeSpecifier(filename, specifier));
+    const keptNames = reExport.names.filter(({ local }) => local !== "" && targetNames.has(local));
+    if (keptNames.length > 0) {
+      const specifiers = keptNames.map(({ local, exported }) => local === exported ? local : `${local} as ${exported}`).join(", ");
+      exportLines.push(`export { ${specifiers} } from ${JSON.stringify(reExport.source)};`);
+    }
+  }
+  for (const specifier of analysis.exportAllFrom) {
+    const target = dependencies.analyzeSpecifier(filename, specifier);
+    if (target === null) {
+      throw new MoonsError({
+        code: "E_SERVER_IMPORT_IN_CLIENT",
+        file: filename,
+        message: `\`export *\` dari \`${specifier}\` tidak bisa di-resolve`,
+        details: "`export *` dari `*.server.ts` wajib bisa di-expand statis (PRD §12.6).",
+        suggestions: ["Perbaiki path re-export", "Ganti menjadi named re-export"]
+      });
+    }
+    const targetNames = serverFnExportNames2(target, (nested) => dependencies.analyzeSpecifier(filename, nested));
+    if (targetNames.size > 0) {
+      exportLines.push(`export { ${[...targetNames].join(", ")} } from ${JSON.stringify(specifier)};`);
+    }
+  }
+  if (importLines.length === 0 && exportLines.length === 0) {
+    return { code: `// @moons: tidak ada serverFn yang di-export
+export {};
+`, referenced };
+  }
+  return { code: `${[...importLines, "", ...exportLines].join(`
+`)}
+`, referenced };
+}
+function injectServerFnMeta2(source, analysis, projectRoot) {
+  let output = source;
+  const inserts = [...analysis.serverFns].sort((a, b) => b.objectStart - a.objectStart);
+  for (const fn of inserts) {
+    const meta = ` __hash: ${JSON.stringify(fn.hash)},` + ` __file: ${JSON.stringify(fnRegistryKey(projectRoot, analysis.file, fn.name).split("#")[0])},` + ` __line: ${fn.line},` + ` __exportName: ${JSON.stringify(fn.name)},`;
+    const at = fn.objectStart + 1;
+    output = output.slice(0, at) + meta + output.slice(at);
+  }
+  return output;
+}
+async function serverFnExportNamesAsync(analysis, analyzeSpecifier, seen = new Set) {
+  const names = new Set(analysis.serverFns.map((fn) => fn.name));
+  for (const reExport of analysis.reExports) {
+    const key = `${analysis.file}\x00${reExport.source}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    const target = await analyzeSpecifier(reExport.source, analysis.file);
+    if (target === null) {
+      continue;
+    }
+    const targetNames = await serverFnExportNamesAsync(target, analyzeSpecifier, seen);
+    for (const { local, exported } of reExport.names) {
+      if (local === "*" || targetNames.has(local)) {
+        names.add(exported);
+      }
+    }
+  }
+  for (const specifier of analysis.exportAllFrom) {
+    const key = `${analysis.file}\x00${specifier}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    const target = await analyzeSpecifier(specifier, analysis.file);
+    if (target === null) {
+      continue;
+    }
+    for (const name of await serverFnExportNamesAsync(target, analyzeSpecifier, seen)) {
+      names.add(name);
+    }
+  }
+  return names;
+}
+function nonContractServerFileError2(file, projectRoot) {
+  return new MoonsError({
+    code: "E_SERVER_IMPORT_IN_CLIENT",
+    file: toRelative(projectRoot, file),
+    message: "file server memakai ekstensi di luar kontrak §12",
+    details: "Transform zero-trust hanya menangani `*.server.ts`/`*.server.tsx`; file server dengan ekstensi lain tidak bisa di-stub dan tidak boleh masuk graph client.",
+    suggestions: [
+      "Ganti nama file menjadi `*.server.ts`/`*.server.tsx` dan taruh `serverFn` di dalamnya",
+      "Atau pindahkan nilai yang dibutuhkan ke file non-server"
+    ]
+  });
+}
+async function checkClientModuleImports2(context) {
+  const { file, code, projectRoot, resolve, analyze } = context;
+  const ast = parseModule(code, file);
+  const relativeFile = toRelative(projectRoot, file);
+  const resolveSafe = async (specifier, importer) => {
+    try {
+      const result = await resolve(specifier, importer);
+      if (result === null) {
+        return null;
+      }
+      const clean = stripQuery2(result);
+      try {
+        return realpathSync(clean);
+      } catch {
+        return clean;
+      }
+    } catch {
+      return null;
+    }
+  };
+  const analyzeResolved = async (specifier, importer) => {
+    const absolute = await resolveSafe(specifier, importer);
+    return absolute === null ? null : analyze(absolute);
+  };
+  const isAllowedServerFnImport = async (resolvedTarget, specifier, name) => {
+    const target = resolvedTarget === null ? await analyzeResolved(specifier, file) : analyze(resolvedTarget);
+    if (target === null) {
+      return false;
+    }
+    const names = await serverFnExportNamesAsync(target, (nested, importer) => analyzeResolved(nested, importer));
+    return names.has(name);
+  };
+  const reject = (line, message, details) => {
+    throw new MoonsError({
+      code: "E_SERVER_IMPORT_IN_CLIENT",
+      file: relativeFile,
+      line,
+      message,
+      details,
+      suggestions: [
+        "Buat server function yang mengembalikan data yang dibutuhkan, atau",
+        "Pindahkan nilai itu ke file yang tidak berakhiran .server.ts"
+      ]
+    });
+  };
+  const rejectForbidden = (line, specifier) => {
+    throw new MoonsError({
+      code: "E_FORBIDDEN_SERVER_IMPORT",
+      file: relativeFile,
+      line,
+      message: `mengimpor \`${specifier}\` di modul client`,
+      details: "Modul server-only hanya boleh di-import dari *.server.ts.",
+      suggestions: [
+        "Pindahkan operasi tersebut ke serverFn, atau",
+        "Hapus import tersebut"
+      ]
+    });
+  };
+  for (const statement of topLevelStatements(ast)) {
+    if (statement.type === "ImportDeclaration" || statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") {
+      const sourceNode = statement["source"];
+      if (sourceNode?.type !== "StringLiteral") {
+        continue;
+      }
+      const rawSpecifier = sourceNode["value"];
+      const specifier = stripQuery2(rawSpecifier);
+      const line = statement.loc?.start.line ?? 1;
+      if (specifier.startsWith("node:") || specifier.startsWith("bun:")) {
+        rejectForbidden(line, specifier);
+      }
+      const resolvedTarget = await resolveSafe(specifier, file);
+      if (resolvedTarget !== null && isNonContractServerFile2(resolvedTarget)) {
+        throw nonContractServerFileError2(resolvedTarget, projectRoot);
+      }
+      const serverBySpecifier = isServerSpecifier2(specifier);
+      const serverByResolve = resolvedTarget !== null && isServerFilePath2(resolvedTarget);
+      if (!serverBySpecifier && !serverByResolve) {
+        continue;
+      }
+      const targetRelative = resolvedTarget === null ? rawSpecifier : toRelative(projectRoot, resolvedTarget);
+      if (statement.type === "ExportAllDeclaration") {
+        if (resolvedTarget === null) {
+          reject(line, `\`export *\` dari \`${targetRelative}\` tidak bisa di-resolve`, "Re-export dari `*.server.ts` wajib bisa di-resolve statis (PRD §12.6).");
+        }
+        continue;
+      }
+      const specifiers = statement["specifiers"] ?? [];
+      for (const item of specifiers) {
+        if (item.type === "ImportDefaultSpecifier") {
+          reject(line, `mengimpor default dari ${targetRelative}`, "Default export dari file server tidak boleh menyeberang ke client.");
+        }
+        if (item.type === "ImportNamespaceSpecifier") {
+          reject(line, `mengimpor namespace (\`* as\`) dari ${targetRelative}`, "Import namespace dari file server tidak boleh menyeberang ke client.");
+        }
+        const name = item["local"]?.["name"] ?? "";
+        const kind = item["importKind"] ?? statement["importKind"];
+        if (kind === "type") {
+          reject(line, `mengimpor type \`${name}\` dari ${targetRelative}`, "Import dari file server tidak diizinkan di modul client (PRD §12.4).");
+        }
+        if (name.length > 0 && !await isAllowedServerFnImport(resolvedTarget, specifier, name)) {
+          reject(line, `mengimpor \`${name}\` dari ${targetRelative}`, "Kode server tidak boleh muncul di client.\nHanya `serverFn` yang diizinkan menyeberang.");
+        }
+      }
+    }
+  }
+  const envBindings = new Set;
+  for (const statement of topLevelStatements(ast)) {
+    if (statement.type !== "ImportDeclaration") {
+      continue;
+    }
+    const sourceNode = statement["source"];
+    const specifier = sourceNode?.type === "StringLiteral" ? sourceNode["value"] : "";
+    if (specifier !== "@moonsjs/server" && !specifier.startsWith("@moonsjs/server/")) {
+      continue;
+    }
+    for (const item of statement["specifiers"] ?? []) {
+      if (item.type !== "ImportSpecifier") {
+        continue;
+      }
+      const imported = item["imported"];
+      const local = item["local"];
+      if (imported?.type === "Identifier" && imported["name"] === "env" && local?.type === "Identifier") {
+        envBindings.add(local["name"]);
+      }
+    }
+  }
+  if (envBindings.size > 0) {
+    walk(ast, (node) => {
+      if (node.type !== "CallExpression") {
+        return;
+      }
+      const callee = node["callee"];
+      if (callee?.type !== "Identifier" || !envBindings.has(callee["name"])) {
+        return;
+      }
+      const callText = code.slice(node.start ?? 0, node.end ?? 0).replace(/\s+/g, " ").slice(0, 80);
+      throw new MoonsError({
+        code: "E_ENV_IN_CLIENT",
+        file: relativeFile,
+        line: node.loc?.start.line ?? 1,
+        message: `memanggil \`${callText}\` di modul yang masuk client`,
+        details: "`env()` hanya legal di server.",
+        suggestions: [
+          "Pindahkan pemanggilan ke dalam serverFn, atau",
+          "Gunakan import.meta.env untuk nilai publik"
+        ]
+      });
+    });
+  }
+  const dynamicRequests = [];
+  walk(ast, (node, ancestors) => {
+    const request = dynamicImportRequest(node);
+    if (request !== null) {
+      dynamicRequests.push({
+        request,
+        guarded: ancestors.some((ancestor) => isDevGuard(ancestor))
+      });
+    }
+  });
+  for (const { request, guarded } of dynamicRequests) {
+    if (guarded) {
+      continue;
+    }
+    const specifier = stripQuery2(request.text);
+    const resolvedTarget = await resolveSafe(specifier, file);
+    if (resolvedTarget !== null && isNonContractServerFile2(resolvedTarget)) {
+      throw nonContractServerFileError2(resolvedTarget, projectRoot);
+    }
+    const serverBySpecifier = isServerSpecifier2(specifier);
+    const serverByResolve = resolvedTarget !== null && isServerFilePath2(resolvedTarget);
+    if (!serverBySpecifier && !serverByResolve) {
+      continue;
+    }
+    const targetRelative = resolvedTarget === null ? request.text : toRelative(projectRoot, resolvedTarget);
+    reject(request.node.loc?.start.line ?? 1, `mengimpor (dynamic) \`${request.text}\` dari ${targetRelative}`, "Client tidak boleh melakukan dynamic import ke `*.server.ts` (PRD §12.7).");
+  }
+  walk(ast, (node) => {
+    if (node.type !== "CallExpression") {
+      return;
+    }
+    const callee = node["callee"];
+    if (callee?.type !== "MemberExpression") {
+      return;
+    }
+    const object = callee["object"];
+    const property = callee["property"];
+    if (object?.type !== "MetaProperty" || property?.type !== "Identifier" || property["name"] !== "glob") {
+      return;
+    }
+    for (const pattern of globPatterns((node["arguments"] ?? [])[0])) {
+      if (!isServerSpecifier2(pattern)) {
+        continue;
+      }
+      throw new MoonsError({
+        code: "E_SERVER_IMPORT_IN_CLIENT",
+        file: relativeFile,
+        line: node.loc?.start.line ?? 1,
+        message: `mengimpor (glob) \`${pattern}\` di modul client`,
+        details: "`import.meta.glob` yang mencakup `*.server.ts` dilarang di client (PRD §12.7).",
+        suggestions: [
+          "Import statis `serverFn` dari `*.server.ts` (hanya itu yang boleh menyeberang), atau",
+          "Pindahkan kebutuhan data ke dalam server function"
+        ]
+      });
+    }
+  });
+}
+function dynamicImportRequest(node) {
+  let sourceNode = null;
+  if (node.type === "ImportExpression") {
+    sourceNode = node["source"] ?? null;
+  } else if (node.type === "CallExpression") {
+    const callee = node["callee"];
+    if (callee?.type !== "Import") {
+      return null;
+    }
+    sourceNode = (node["arguments"] ?? [])[0] ?? null;
+  }
+  if (sourceNode === null) {
+    return null;
+  }
+  if (sourceNode.type === "StringLiteral") {
+    return { text: sourceNode["value"], node: sourceNode };
+  }
+  if (sourceNode.type === "TemplateLiteral") {
+    const text = (sourceNode["quasis"] ?? []).map((quasi) => quasi["value"]?.cooked ?? "").join("*");
+    return { text, node: sourceNode };
+  }
+  return null;
+}
+function globPatterns(node) {
+  if (node?.type === "StringLiteral") {
+    return [node["value"]];
+  }
+  if (node?.type === "ArrayExpression") {
+    return (node["elements"] ?? []).filter((element) => element?.type === "StringLiteral").map((element) => element["value"]);
+  }
+  return [];
+}
+function isDevGuard(node) {
+  if (node.type !== "IfStatement") {
+    return false;
+  }
+  const test = node["test"];
+  return isImportMetaFlag(test, "DEV") || isNegatedImportMetaFlag(test, "PROD");
+}
+function isImportMetaFlag(node, flag) {
+  const member = node;
+  if (member?.type !== "MemberExpression") {
+    return false;
+  }
+  const property = member["property"];
+  if (property?.type !== "Identifier" || property["name"] !== flag) {
+    return false;
+  }
+  const object = member["object"];
+  return isImportMetaEnv(object);
+}
+function isNegatedImportMetaFlag(node, flag) {
+  if (node?.type !== "UnaryExpression" || node["operator"] !== "!") {
+    return false;
+  }
+  return isImportMetaFlag(node["argument"], flag);
+}
+function isImportMetaEnv(node) {
+  if (node?.type !== "MemberExpression") {
+    return false;
+  }
+  const property = node["property"];
+  if (property?.type !== "Identifier" || property["name"] !== "env") {
+    return false;
+  }
+  const object = node["object"];
+  return object?.type === "MetaProperty";
+}
+function toRelative(projectRoot, file) {
+  const relative = file.startsWith(projectRoot) ? file.slice(projectRoot.length).replace(/^[/\\]/, "") : file;
+  return relative.split("\\").join("/");
+}
+function checkRouteModuleExports2(context) {
+  const { file, code, routesDir, projectRoot } = context;
+  if (!file.startsWith(routesDir) || !file.endsWith(".tsx")) {
+    return;
+  }
+  const base = file.slice(file.lastIndexOf("/") + 1);
+  if (base.startsWith("_") && base !== "_layout.tsx" && base !== "_error.tsx" && base !== "_404.tsx") {
+    return;
+  }
+  const allowed = base === "_layout.tsx" ? ["default", "loader"] : base === "_error.tsx" || base === "_404.tsx" ? ["default"] : ["default", "loader", "meta"];
+  const allowedText = `Hanya ${allowed.map((name) => `\`${name}\``).join(", ")} yang boleh di-export.`;
+  const relativeFile = toRelative(projectRoot, file);
+  const ast = parseModule(code, file);
+  const declarations = [];
+  let hasDefault = false;
+  for (const statement of topLevelStatements(ast)) {
+    if (statement.type === "ExportDefaultDeclaration") {
+      hasDefault = true;
+      continue;
+    }
+    if (statement.type === "ExportAllDeclaration") {
+      throw new MoonsError({
+        code: "E_ROUTE_EXPORT_INVALID",
+        file: relativeFile,
+        line: statement.loc?.start.line ?? 1,
+        message: "`export *` tidak diizinkan di modul route",
+        details: allowedText,
+        suggestions: [
+          `Pindahkan isi file ke luar ${toRelative(projectRoot, routesDir)}/, atau`,
+          "Hapus `export *` tersebut"
+        ]
+      });
+    }
+    if (statement.type !== "ExportNamedDeclaration") {
+      continue;
+    }
+    const declaration = statement["declaration"];
+    if (declaration !== null && declaration !== undefined) {
+      for (const name of declarationNames(declaration)) {
+        declarations.push({ name, line: declaration.loc?.start.line ?? 1 });
+      }
+    }
+    for (const item of statement["specifiers"] ?? []) {
+      const exported = item["exported"];
+      const name = exported?.type === "Identifier" ? exported["name"] : exported?.type === "StringLiteral" ? exported["value"] : null;
+      if (name !== null) {
+        declarations.push({ name, line: item.loc?.start.line ?? statement.loc?.start.line ?? 1 });
+      }
+    }
+  }
+  for (const entry of declarations) {
+    if (!allowed.includes(entry.name)) {
+      throw new MoonsError({
+        code: "E_ROUTE_EXPORT_INVALID",
+        file: relativeFile,
+        line: entry.line,
+        message: `export \`${entry.name}\` tidak diizinkan di modul route`,
+        details: allowedText,
+        suggestions: [
+          `Pindahkan \`${entry.name}\` ke file di luar ${toRelative(projectRoot, routesDir)}/, atau`,
+          "Hapus export tersebut"
+        ]
+      });
+    }
+  }
+  if (!hasDefault) {
+    throw new MoonsError({
+      code: "E_ROUTE_EXPORT_INVALID",
+      file: relativeFile,
+      message: "modul route wajib mengekspor `default`",
+      details: "Setiap file route harus punya `export default` berupa komponen React (PRD §11.2).",
+      suggestions: ["Tambahkan `export default function Page() { ... }`"]
+    });
+  }
+}
+function declarationNames(declaration) {
+  switch (declaration.type) {
+    case "VariableDeclaration":
+      return (declaration["declarations"] ?? []).map((declarator) => declarator["id"]?.["name"] ?? "").filter((name) => name.length > 0);
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSEnumDeclaration":
+      return [declaration["id"]?.["name"] ?? ""].filter((name) => name.length > 0);
+    default:
+      return [];
+  }
+}
+function scanServerFiles2(projectRoot) {
+  const excluded = new Set(["node_modules", "dist", ".moons", ".git"]);
+  const result = [];
+  const walkDir = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (excluded.has(entry.name)) {
+          continue;
+        }
+        walkDir(join(dir, entry.name));
+      } else if (entry.isFile() && isServerFilePath2(entry.name)) {
+        result.push(join(dir, entry.name));
+      }
+    }
+  };
+  walkDir(projectRoot);
+  return result.sort();
+}
+function buildFnRegistry2(projectRoot, files) {
+  const registry = {};
+  for (const file of files) {
+    let source;
+    try {
+      source = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const analysis = analyzeServerFile2(source, file, projectRoot);
+    for (const fn of analysis.serverFns) {
+      registry[fnRegistryKey(projectRoot, file, fn.name)] = fn.hash;
+    }
+  }
+  return registry;
+}
+
+export { isServerFilePath2, isNonContractServerFile2, isServerSpecifier2, resolveServerSpecifierSync2, stripQuery2, analyzeServerFile2, serverFnExportNames2, renderServerFnStub2, injectServerFnMeta2, nonContractServerFileError2, checkClientModuleImports2, checkRouteModuleExports2, scanServerFiles2, buildFnRegistry2 };
+
+//# debugId=A2B4D23CAFD2B11164756E2164756E21