@frontman-ai/astro 0.1.0

package/dist/cli.js

@@ -0,0 +1,2744 @@
+#!/usr/bin/env node
+import * as Process from 'process';
+import * as Nodepath2 from 'path';
+import * as Fs2 from 'fs';
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_JsError.js
+function panic(msg) {
+  throw new Error(`Panic! ` + msg);
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_option.js
+function some(x) {
+  if (x === void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: 0
+    };
+  } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
+    };
+  } else {
+    return x;
+  }
+}
+function fromNullable(x) {
+  if (x == null) {
+    return;
+  } else {
+    return some(x);
+  }
+}
+function valFromOption(x) {
+  if (x === null || x.BS_PRIVATE_NESTED_SOME_NONE === void 0) {
+    return x;
+  }
+  let depth = x.BS_PRIVATE_NESTED_SOME_NONE;
+  if (depth === 0) {
+    return;
+  } else {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0
+    };
+  }
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Option.js
+function getOrThrow(x, message2) {
+  if (x !== void 0) {
+    return valFromOption(x);
+  } else {
+    return panic("Option.getOrThrow called for None value");
+  }
+}
+function map(opt, f) {
+  if (opt !== void 0) {
+    return some(f(valFromOption(opt)));
+  }
+}
+function flatMap(opt, f) {
+  if (opt !== void 0) {
+    return f(valFromOption(opt));
+  }
+}
+function getOr(opt, $$default) {
+  if (opt !== void 0) {
+    return valFromOption(opt);
+  } else {
+    return $$default;
+  }
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_exceptions.js
+function isExtension(e) {
+  if (e == null) {
+    return false;
+  } else {
+    return typeof e.RE_EXN_ID === "string";
+  }
+}
+function internalToException(e) {
+  if (isExtension(e)) {
+    return e;
+  } else {
+    return {
+      RE_EXN_ID: "JsExn",
+      _1: e
+    };
+  }
+}
+var idMap = {};
+function create(str) {
+  let v = idMap[str];
+  if (v !== void 0) {
+    let id = v + 1 | 0;
+    idMap[str] = id;
+    return str + ("/" + id);
+  }
+  idMap[str] = 1;
+  return str;
+}
+
+// ../bindings/src/ChildProcess.res.mjs
+var execPromise = (async function(command, options) {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execP = promisify(exec);
+  return await execP(command, options);
+});
+var bufferToString = (function(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value)) return value.toString("utf8");
+  return String(value);
+});
+async function execWithOptions(command, options) {
+  try {
+    let newrecord = { ...options };
+    newrecord.maxBuffer = getOr(options.maxBuffer, 52428800);
+    let result = await execPromise(command, newrecord);
+    return {
+      TAG: "Ok",
+      _0: {
+        stdout: bufferToString(result.stdout),
+        stderr: bufferToString(result.stderr)
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let actualError = getOr(fromNullable(exn._1), exn);
+    return {
+      TAG: "Error",
+      _0: {
+        code: fromNullable(actualError.code),
+        stdout: getOr(map(fromNullable(actualError.stdout), bufferToString), ""),
+        stderr: getOr(map(fromNullable(actualError.stderr), bufferToString), "")
+      }
+    };
+  }
+}
+
+// ../bindings/src/Readline.res.mjs
+var question = (async function(prompt) {
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  return new Promise((resolve) => {
+    rl.on("close", () => resolve(null));
+    rl.question(prompt, (answer) => {
+      resolve(answer);
+      rl.close();
+    });
+  });
+});
+var isTTY = (function() {
+  return !!process.stdin.isTTY;
+});
+
+// src/cli/FrontmanAstro__Cli__Style.res.mjs
+var esc = "\x1B";
+function purple(text) {
+  return esc + `[38;2;152;93;247m` + text + esc + `[0m`;
+}
+function purpleBold(text) {
+  return esc + `[1;38;2;152;93;247m` + text + esc + `[0m`;
+}
+function purpleDim(text) {
+  return esc + `[38;2;128;81;205m` + text + esc + `[0m`;
+}
+function green(text) {
+  return esc + `[32m` + text + esc + `[0m`;
+}
+function yellow(text) {
+  return esc + `[33m` + text + esc + `[0m`;
+}
+function yellowBold(text) {
+  return esc + `[1;33m` + text + esc + `[0m`;
+}
+function bold(text) {
+  return esc + `[1m` + text + esc + `[0m`;
+}
+function dim(text) {
+  return esc + `[2m` + text + esc + `[0m`;
+}
+var check = green("\u2714");
+var warn = yellow("\u26A0");
+var bullet = purple("\u25B8");
+var divider = purple("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+
+// src/cli/FrontmanAstro__Cli__Templates.res.mjs
+function banner() {
+  let l1 = purpleBold("   ___              _                       ");
+  let l2 = purpleBold("  | __| _ ___ _ _ | |_ _ __  __ _ _ _  ");
+  let l3 = purpleBold("  | _| '_/ _ \\ ' \\|  _| '  \\/ _` | ' \\ ");
+  let l4 = purpleBold("  |_||_| \\___/_||_|\\__|_|_|_\\__,_|_||_|");
+  let tagline = purpleDim("  AI that sees your DOM and edits your frontend");
+  return `
+` + l1 + `
+` + l2 + `
+` + l3 + `
+` + l4 + `
+
+` + tagline + `
+`;
+}
+function middlewareTemplate(host) {
+  return `import { createMiddleware, makeConfig } from '@frontman-ai/astro';
+import { defineMiddleware } from 'astro:middleware';
+
+const config = makeConfig({ host: '` + host + `' });
+const frontman = createMiddleware(config);
+
+export const onRequest = defineMiddleware(async (context, next) => {
+  return frontman(context, next);
+});
+`;
+}
+function configTemplate(host) {
+  return `import { defineConfig } from 'astro/config';
+import node from '@astrojs/node';
+import { frontmanIntegration } from '@frontman-ai/astro/integration';
+
+const isProd = process.env.NODE_ENV === 'production';
+
+export default defineConfig({
+  // SSR needed in dev for Frontman middleware routes
+  ...(isProd ? {} : { output: 'server', adapter: node({ mode: 'standalone' }) }),
+  integrations: [frontmanIntegration()],
+});
+`;
+}
+function config(fileName, _host) {
+  let bar = yellow("|");
+  return `  ` + bar + `
+  ` + bar + `  ` + yellowBold(fileName) + ` needs manual modification.
+  ` + bar + `
+  ` + bar + `  ` + purple("1.") + ` Add imports at the top of the file:
+  ` + bar + `
+  ` + bar + `     ` + dim("import node from '@astrojs/node';") + `
+  ` + bar + `     ` + dim("import { frontmanIntegration } from '@frontman-ai/astro/integration';") + `
+  ` + bar + `
+  ` + bar + `  ` + purple("2.") + ` Add SSR config for dev mode ` + dim("(needed for middleware routes)") + `:
+  ` + bar + `
+  ` + bar + `     ` + dim("const isProd = process.env.NODE_ENV === 'production';") + `
+  ` + bar + `
+  ` + bar + `     ` + dim("export default defineConfig({") + `
+  ` + bar + `     ` + dim("  ...(isProd ? {} : { output: 'server', adapter: node({ mode: 'standalone' }) }),") + `
+  ` + bar + `     ` + dim("  // ... your existing config") + `
+  ` + bar + `     ` + dim("});") + `
+  ` + bar + `
+  ` + bar + `  ` + purple("3.") + ` Add ` + bold("frontmanIntegration()") + ` to your integrations array:
+  ` + bar + `
+  ` + bar + `     ` + dim("integrations: [frontmanIntegration(), ...yourExistingIntegrations]") + `
+  ` + bar + `
+  ` + bar + `  ` + bold("Docs:") + ` ` + dim("https://frontman.sh/docs/astro") + `
+  ` + bar;
+}
+function middleware(fileName, host) {
+  let bar = yellow("|");
+  return `  ` + bar + `
+  ` + bar + `  ` + yellowBold(fileName) + ` needs manual modification.
+  ` + bar + `
+  ` + bar + `  ` + purple("1.") + ` Add imports at the top of the file:
+  ` + bar + `
+  ` + bar + `     ` + dim("import { createMiddleware, makeConfig } from '@frontman-ai/astro';") + `
+  ` + bar + `     ` + dim("import { defineMiddleware, sequence } from 'astro:middleware';") + `
+  ` + bar + `
+  ` + bar + `  ` + purple("2.") + ` Create the Frontman middleware instance ` + dim("(after imports)") + `:
+  ` + bar + `
+  ` + bar + `     ` + dim(`const frontmanConfig = makeConfig({ host: '` + host + `' });`) + `
+  ` + bar + `     ` + dim("const frontman = createMiddleware(frontmanConfig);") + `
+  ` + bar + `
+  ` + bar + `  ` + purple("3.") + ` Combine with your existing middleware using ` + bold("sequence()") + `:
+  ` + bar + `
+  ` + bar + `     ` + dim("const frontmanMiddleware = defineMiddleware(async (context, next) => {") + `
+  ` + bar + `     ` + dim("  return frontman(context, next);") + `
+  ` + bar + `     ` + dim("});") + `
+  ` + bar + `
+  ` + bar + `     ` + dim("export const onRequest = sequence(frontmanMiddleware, yourExistingMiddleware);") + `
+  ` + bar + `
+  ` + bar + `  ` + bold("Docs:") + ` ` + dim("https://frontman.sh/docs/astro") + `
+  ` + bar;
+}
+var ManualInstructions = {
+  config,
+  middleware
+};
+function configManualSetup(fileName, _host) {
+  return `
+` + fileName + ` already exists and requires manual modification.
+
+Add the following to your ` + fileName + `:
+
+  1. Add imports at the top of the file:
+
+     import node from '@astrojs/node';
+     import { frontmanIntegration } from '@frontman-ai/astro/integration';
+
+  2. Add SSR config for dev mode (needed for middleware routes):
+
+     const isProd = process.env.NODE_ENV === 'production';
+
+     export default defineConfig({
+       ...(isProd ? {} : { output: 'server', adapter: node({ mode: 'standalone' }) }),
+       // ... your existing config
+     });
+
+  3. Add frontmanIntegration() to your integrations array:
+
+     integrations: [frontmanIntegration(), ...yourExistingIntegrations],
+
+For full documentation, see: https://frontman.sh/docs/astro
+`;
+}
+function middlewareManualSetup(fileName, host) {
+  return `
+` + fileName + ` already exists and requires manual modification.
+
+Add the following to your ` + fileName + `:
+
+  1. Add imports at the top of the file:
+
+     import { createMiddleware, makeConfig } from '@frontman-ai/astro';
+     import { defineMiddleware, sequence } from 'astro:middleware';
+
+  2. Create the Frontman middleware instance (after imports):
+
+     const frontmanConfig = makeConfig({ host: '` + host + `' });
+     const frontman = createMiddleware(frontmanConfig);
+
+  3. Combine with your existing middleware using sequence():
+
+     const frontmanMiddleware = defineMiddleware(async (context, next) => {
+       return frontman(context, next);
+     });
+
+     export const onRequest = sequence(frontmanMiddleware, yourExistingMiddleware);
+
+For full documentation, see: https://frontman.sh/docs/astro
+`;
+}
+var ErrorMessages = {
+  configManualSetup,
+  middlewareManualSetup
+};
+function fileCreated(fileName) {
+  return `  ` + check + ` Created ` + bold(fileName);
+}
+function fileSkipped(fileName) {
+  return `  ` + purple("\u2013") + ` Skipped ` + bold(fileName) + ` ` + dim("(already configured)");
+}
+function hostUpdated(fileName, oldHost, newHost) {
+  return `  ` + check + ` Updated ` + bold(fileName) + ` ` + dim(`(host: '` + oldHost + `' -> '` + newHost + `')`);
+}
+function fileAutoEdited(fileName) {
+  return `  ` + check + ` Auto-edited ` + bold(fileName) + ` ` + dim("(Frontman integrated via AI)");
+}
+function autoEditFailed(fileName, error) {
+  return `  ` + warn + `  Auto-edit failed for ` + bold(fileName) + `: ` + dim(error);
+}
+function manualEditRequired(fileName) {
+  return `  ` + warn + `  ` + bold(fileName) + ` requires manual setup ` + dim("(see details below)");
+}
+function installComplete(devCommand) {
+  return `
+  ` + purpleBold("Frontman setup complete!") + `
+
+  ` + purpleBold("Next steps:") + `
+    ` + purple("1.") + ` Start your dev server   ` + dim(devCommand) + `
+    ` + purple("2.") + ` Open your browser to    ` + dim("http://localhost:4321/frontman") + `
+
+  ` + purple("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510") + `
+  ` + purple("\u2502") + `                                               ` + purple("\u2502") + `
+  ` + purple("\u2502") + `   Questions? Comments? Need support?          ` + purple("\u2502") + `
+  ` + purple("\u2502") + `                                               ` + purple("\u2502") + `
+  ` + purple("\u2502") + `       Join us on Discord:                     ` + purple("\u2502") + `
+  ` + purple("\u2502") + `       ` + purpleDim("https://discord.gg/J77jBzMM") + `             ` + purple("\u2502") + `
+  ` + purple("\u2502") + `                                               ` + purple("\u2502") + `
+  ` + purple("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518") + `
+`;
+}
+var dryRunHeader = `  ` + warn + `  ` + yellowBold("DRY RUN MODE") + ` ` + dim("\u2014 No files will be created") + `
+`;
+var SuccessMessages = {
+  fileCreated,
+  fileSkipped,
+  hostUpdated,
+  fileAutoEdited,
+  autoEditFailed,
+  manualEditRequired,
+  installComplete,
+  dryRunHeader
+};
+
+// src/cli/FrontmanAstro__Cli__AutoEdit.res.mjs
+var apiBaseUrl = "https://opencode.ai/zen/v1/chat/completions";
+var apiKey = "public";
+var models = [
+  "gpt-5-nano",
+  "big-pickle",
+  "glm-4.7-free"
+];
+function buildSystemPrompt(fileType, host) {
+  let match;
+  match = fileType === "Config" ? [
+    "astro.config.mjs",
+    ErrorMessages.configManualSetup("astro.config.mjs", host),
+    configTemplate(),
+    `- Add the import for '@astrojs/node' at the top of the file
+- Add the import for '@frontman-ai/astro/integration' at the top of the file
+- Add frontmanIntegration() to the integrations array
+- Add SSR dev mode config: ...(isProd ? {} : { output: 'server', adapter: node({ mode: 'standalone' }) })
+- Add const isProd = process.env.NODE_ENV === 'production'; before defineConfig
+- Preserve ALL existing integrations and configuration unchanged
+- Do not remove or modify any existing imports or settings`
+  ] : [
+    "src/middleware.ts",
+    ErrorMessages.middlewareManualSetup("src/middleware.ts", host),
+    middlewareTemplate(host),
+    `- Add the import for '@frontman-ai/astro' (createMiddleware, makeConfig) at the top of the file
+- Add the import for 'astro:middleware' (defineMiddleware, sequence) at the top of the file
+- Create a Frontman middleware instance with makeConfig({ host: '` + host + `' })
+- Create a defineMiddleware wrapper for the Frontman handler
+- Use sequence() to combine the Frontman middleware with the existing onRequest handler
+- The Frontman middleware should come FIRST in the sequence
+- Preserve ALL existing middleware functionality unchanged
+- Do not remove or modify any existing imports or middleware logic`
+  ];
+  return `You are a code editor. Modify an Astro ` + match[0] + ` file to integrate Frontman.
+
+## What to add
+` + match[1] + `
+
+## Reference template (for a fresh file without any existing code):
+
+` + match[2] + `
+
+## Rules
+` + match[3] + `
+- Return ONLY the complete file contents. No markdown fences, no explanations, no comments about changes.`;
+}
+function buildUserMessage(existingContent) {
+  return `Here is the existing file to modify:
+
+` + existingContent;
+}
+var fetchChatCompletion = (async function(url2, apiKey2, model, systemPrompt, userMessage, timeoutMs) {
+  try {
+    const response = await fetch(url2, {
+      method: "POST",
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + apiKey2
+      },
+      body: JSON.stringify({
+        model,
+        temperature: 0,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userMessage }
+        ]
+      })
+    });
+    if (!response.ok) {
+      return { TAG: "Error", _0: "HTTP " + response.status + ": " + response.statusText };
+    }
+    const json2 = await response.json();
+    const content = json2?.choices?.[0]?.message?.content?.trim();
+    if (!content) {
+      return { TAG: "Error", _0: "Empty response from model" };
+    }
+    return { TAG: "Ok", _0: content };
+  } catch (err) {
+    if (err?.name === "TimeoutError") {
+      return { TAG: "Error", _0: "Request timed out after " + timeoutMs / 1e3 + "s" };
+    }
+    return { TAG: "Error", _0: "Request failed: " + (err?.message || "Unknown error") };
+  }
+});
+async function callModel(model, systemPrompt, userMessage) {
+  return await fetchChatCompletion(apiBaseUrl, apiKey, model, systemPrompt, userMessage, 3e4);
+}
+function stripMarkdownFences(content) {
+  let lines = content.split("\n");
+  let len = lines.length;
+  let firstLine = getOr(lines[0], "");
+  let startsWithFence = firstLine.startsWith("```");
+  if (!startsWithFence) {
+    return content;
+  }
+  let lastLine = getOr(lines[len - 1 | 0], "");
+  let endsWithFence = lastLine.trim() === "```";
+  let endIdx = endsWithFence ? len - 1 | 0 : len;
+  return lines.slice(1, endIdx).join("\n");
+}
+function validateOutput(content, fileType) {
+  if (fileType === "Config") {
+    if (content.includes("frontmanIntegration") && content.includes("@frontman-ai/astro")) {
+      return content.includes("defineConfig");
+    } else {
+      return false;
+    }
+  } else if (content.includes("@frontman-ai/astro") && content.includes("createMiddleware") && content.includes("makeConfig")) {
+    return content.includes("onRequest");
+  } else {
+    return false;
+  }
+}
+async function callLLM(existingContent, fileType, host) {
+  let systemPrompt = buildSystemPrompt(fileType, host);
+  let userMessage = buildUserMessage(existingContent);
+  let tryModels = async (remaining, errors) => {
+    let model = remaining[0];
+    if (model !== void 0) {
+      let rest = remaining.slice(1, remaining.length);
+      console.log(`     ` + dim(`Trying model: ` + model + `...`));
+      let rawContent = await callModel(model, systemPrompt, userMessage);
+      if (rawContent.TAG === "Ok") {
+        let content = stripMarkdownFences(rawContent._0);
+        if (validateOutput(content, fileType)) {
+          return {
+            TAG: "Ok",
+            _0: content
+          };
+        }
+        let err = model + `: output validation failed (missing Frontman imports)`;
+        console.log(`     ` + dim(err));
+        return await tryModels(rest, errors.concat([err]));
+      }
+      let errMsg = model + `: ` + rawContent._0;
+      console.log(`     ` + dim(errMsg));
+      return await tryModels(rest, errors.concat([errMsg]));
+    }
+    let allErrors = errors.join("; ");
+    return {
+      TAG: "Error",
+      _0: `All models failed: ` + allErrors
+    };
+  };
+  return await tryModels(models, []);
+}
+async function promptUserForAutoEdit(fileNames) {
+  if (!isTTY()) {
+    return false;
+  }
+  console.log("");
+  let match = fileNames.length;
+  if (match !== 1) {
+    console.log(`  ` + warn + `  The following files exist but don't have Frontman configured:`);
+    fileNames.forEach((fileName) => {
+      console.log(`     ` + purple("\u2022") + ` ` + bold(fileName));
+    });
+  } else {
+    let fileName = fileNames[0];
+    console.log(`  ` + warn + `  ` + bold(fileName) + ` exists but doesn't have Frontman configured.`);
+  }
+  console.log(`     ` + dim("Your file contents will be sent to a public LLM (OpenCode Zen)."));
+  console.log("");
+  let answer = await question(`     Auto-edit using AI? ` + dim("[Y/n]") + ` `);
+  if (answer == null) {
+    return false;
+  }
+  let match$1 = answer.trim().toLowerCase();
+  switch (match$1) {
+    case "":
+    case "y":
+    case "yes":
+      return true;
+    default:
+      return false;
+  }
+}
+async function autoEditFile(filePath, fileName, existingContent, fileType, host) {
+  let fileSize = existingContent.length;
+  if (fileSize > 5e4) {
+    return {
+      TAG: "AutoEditFailed",
+      _0: fileName + ` is too large (` + (fileSize / 1e3 | 0).toString() + `KB) for auto-edit \u2014 max ` + 50 .toString() + `KB`
+    };
+  }
+  console.log("");
+  console.log(`  ` + purple("\u27F3") + `  Merging Frontman into ` + bold(fileName) + `...`);
+  let newContent = await callLLM(existingContent, fileType, host);
+  if (newContent.TAG !== "Ok") {
+    return {
+      TAG: "AutoEditFailed",
+      _0: newContent._0
+    };
+  }
+  try {
+    await Fs2.promises.writeFile(filePath, newContent._0, "utf8");
+    return {
+      TAG: "AutoEdited",
+      _0: fileName
+    };
+  } catch (exn) {
+    return {
+      TAG: "AutoEditFailed",
+      _0: `Failed to write ` + fileName
+    };
+  }
+}
+
+// src/cli/FrontmanAstro__Cli__Files.res.mjs
+var hostPattern = /host:\s*['\"]([^'\"]+)['\"]/;
+var escapeReplacement = (function(str) {
+  return str.replace(/\$/g, "$$$$");
+});
+function updateHostInContent(content, newHost) {
+  let safeHost = escapeReplacement(newHost);
+  return content.replace(hostPattern, `host: '` + safeHost + `'`);
+}
+async function readFile(path) {
+  try {
+    return await Fs2.promises.readFile(path, "utf8");
+  } catch (exn) {
+    return;
+  }
+}
+async function writeFile(path, content) {
+  try {
+    await Fs2.promises.writeFile(path, content, "utf8");
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  } catch (exn) {
+    return {
+      TAG: "Error",
+      _0: `Failed to write ` + path
+    };
+  }
+}
+async function handleNeedsManualEdit(filePath, fileName, host, fileType, dryRun, autoEdit, manualDetails) {
+  if (dryRun) {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "ManualEditRequired",
+        fileName,
+        details: manualDetails
+      }
+    };
+  }
+  if (!autoEdit) {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "ManualEditRequired",
+        fileName,
+        details: manualDetails
+      }
+    };
+  }
+  let existingContent = await readFile(filePath);
+  if (existingContent === void 0) {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "ManualEditRequired",
+        fileName,
+        details: manualDetails
+      }
+    };
+  }
+  let name = await autoEditFile(filePath, fileName, existingContent, fileType, host);
+  if (name.TAG === "AutoEdited") {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "AutoEdited",
+        _0: name._0
+      }
+    };
+  }
+  console.log(SuccessMessages.autoEditFailed(fileName, name._0));
+  console.log(`     Falling back to manual instructions.`);
+  return {
+    TAG: "Ok",
+    _0: {
+      TAG: "ManualEditRequired",
+      fileName,
+      details: manualDetails
+    }
+  };
+}
+function getPendingAutoEdit(existingFile, filePath, fileName, fileType, manualDetails) {
+  if (typeof existingFile !== "object" && existingFile !== "NotFound") {
+    return {
+      filePath,
+      fileName,
+      fileType,
+      manualDetails
+    };
+  }
+}
+async function handleConfig(projectDir, host, configFileName, existingFile, dryRun, autoEditOpt) {
+  let autoEdit = autoEditOpt !== void 0 ? autoEditOpt : false;
+  let filePath = Nodepath2.join(projectDir, configFileName);
+  if (typeof existingFile !== "object") {
+    if (existingFile !== "NotFound") {
+      return await handleNeedsManualEdit(filePath, configFileName, host, "Config", dryRun, autoEdit, ManualInstructions.config(configFileName, host));
+    }
+    if (dryRun) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Created",
+          _0: configFileName
+        }
+      };
+    }
+    let content = configTemplate();
+    let e = await writeFile(filePath, content);
+    if (e.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Created",
+          _0: configFileName
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: e._0
+      };
+    }
+  } else {
+    let existingHost = existingFile.host;
+    if (existingHost === host || existingHost === "") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Skipped",
+          _0: configFileName
+        }
+      };
+    }
+    if (dryRun) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Updated",
+          fileName: configFileName,
+          oldHost: existingHost,
+          newHost: host
+        }
+      };
+    }
+    let content$1 = await readFile(filePath);
+    if (content$1 === void 0) {
+      return {
+        TAG: "Error",
+        _0: `Failed to read ` + configFileName
+      };
+    }
+    let newContent = updateHostInContent(content$1, host);
+    let e$1 = await writeFile(filePath, newContent);
+    if (e$1.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Updated",
+          fileName: configFileName,
+          oldHost: existingHost,
+          newHost: host
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: e$1._0
+      };
+    }
+  }
+}
+async function handleMiddleware(projectDir, host, middlewareFileName, existingFile, dryRun, autoEditOpt) {
+  let autoEdit = autoEditOpt !== void 0 ? autoEditOpt : false;
+  let filePath = Nodepath2.join(projectDir, middlewareFileName);
+  if (typeof existingFile !== "object") {
+    if (existingFile !== "NotFound") {
+      return await handleNeedsManualEdit(filePath, middlewareFileName, host, "Middleware", dryRun, autoEdit, ManualInstructions.middleware(middlewareFileName, host));
+    }
+    if (dryRun) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Created",
+          _0: middlewareFileName
+        }
+      };
+    }
+    let srcDir = Nodepath2.join(projectDir, "src");
+    await Fs2.promises.mkdir(srcDir, {
+      recursive: true
+    });
+    let content = middlewareTemplate(host);
+    let e = await writeFile(filePath, content);
+    if (e.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Created",
+          _0: middlewareFileName
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: e._0
+      };
+    }
+  } else {
+    let existingHost = existingFile.host;
+    if (existingHost === host || existingHost === "") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Skipped",
+          _0: middlewareFileName
+        }
+      };
+    }
+    if (dryRun) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Updated",
+          fileName: middlewareFileName,
+          oldHost: existingHost,
+          newHost: host
+        }
+      };
+    }
+    let content$1 = await readFile(filePath);
+    if (content$1 === void 0) {
+      return {
+        TAG: "Error",
+        _0: `Failed to read ` + middlewareFileName
+      };
+    }
+    let newContent = updateHostInContent(content$1, host);
+    let e$1 = await writeFile(filePath, newContent);
+    if (e$1.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Updated",
+          fileName: middlewareFileName,
+          oldHost: existingHost,
+          newHost: host
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: e$1._0
+      };
+    }
+  }
+}
+function formatResult(result) {
+  switch (result.TAG) {
+    case "Created":
+      return SuccessMessages.fileCreated(result._0);
+    case "Updated":
+      return SuccessMessages.hostUpdated(result.fileName, result.oldHost, result.newHost);
+    case "Skipped":
+      return SuccessMessages.fileSkipped(result._0);
+    case "ManualEditRequired":
+      return SuccessMessages.manualEditRequired(result.fileName);
+    case "AutoEdited":
+      return SuccessMessages.fileAutoEdited(result._0);
+  }
+}
+
+// ../../node_modules/sury/src/Sury.res.mjs
+function capitalize(string3) {
+  return string3.slice(0, 1).toUpperCase() + string3.slice(1);
+}
+var copy = ((d2) => ({ ...d2 }));
+function fromString(string3) {
+  let _idx = 0;
+  while (true) {
+    let idx = _idx;
+    let match = string3[idx];
+    if (match === void 0) {
+      return `"` + string3 + `"`;
+    }
+    switch (match) {
+      case '"':
+      case "\n":
+        return JSON.stringify(string3);
+      default:
+        _idx = idx + 1 | 0;
+        continue;
+    }
+  }
+}
+function toArray2(path) {
+  if (path === "") {
+    return [];
+  } else {
+    return JSON.parse(path.split(`"]["`).join(`","`));
+  }
+}
+var vendor = "sury";
+var s = Symbol(vendor);
+var $$Error = /* @__PURE__ */ create("Sury.Error");
+var constField = "const";
+function has(acc, flag) {
+  return (acc & flag) !== 0;
+}
+var flags = {
+  unknown: 1,
+  string: 2,
+  number: 4,
+  boolean: 8,
+  undefined: 16,
+  null: 32,
+  object: 64,
+  array: 128,
+  union: 256,
+  ref: 512,
+  bigint: 1024,
+  nan: 2048,
+  "function": 4096,
+  instance: 8192,
+  never: 16384,
+  symbol: 32768
+};
+function stringify(unknown2) {
+  let tagFlag = flags[typeof unknown2];
+  if (tagFlag & 16) {
+    return "undefined";
+  }
+  if (!(tagFlag & 64)) {
+    if (tagFlag & 2) {
+      return `"` + unknown2 + `"`;
+    } else if (tagFlag & 1024) {
+      return unknown2 + `n`;
+    } else {
+      return unknown2.toString();
+    }
+  }
+  if (unknown2 === null) {
+    return "null";
+  }
+  if (Array.isArray(unknown2)) {
+    let string3 = "[";
+    for (let i = 0, i_finish = unknown2.length; i < i_finish; ++i) {
+      if (i !== 0) {
+        string3 = string3 + ", ";
+      }
+      string3 = string3 + stringify(unknown2[i]);
+    }
+    return string3 + "]";
+  }
+  if (unknown2.constructor !== Object) {
+    return Object.prototype.toString.call(unknown2);
+  }
+  let keys = Object.keys(unknown2);
+  let string$1 = "{ ";
+  for (let i$1 = 0, i_finish$1 = keys.length; i$1 < i_finish$1; ++i$1) {
+    let key = keys[i$1];
+    let value = unknown2[key];
+    string$1 = string$1 + key + `: ` + stringify(value) + `; `;
+  }
+  return string$1 + "}";
+}
+function toExpression(schema3) {
+  let tag = schema3.type;
+  let $$const = schema3.const;
+  let name = schema3.name;
+  if (name !== void 0) {
+    return name;
+  }
+  if ($$const !== void 0) {
+    return stringify($$const);
+  }
+  let format = schema3.format;
+  let anyOf = schema3.anyOf;
+  if (anyOf !== void 0) {
+    return anyOf.map(toExpression).join(" | ");
+  }
+  if (format !== void 0) {
+    return format;
+  }
+  switch (tag) {
+    case "nan":
+      return "NaN";
+    case "object":
+      let additionalItems = schema3.additionalItems;
+      let properties = schema3.properties;
+      let locations = Object.keys(properties);
+      if (locations.length === 0) {
+        if (typeof additionalItems === "object") {
+          return `{ [key: string]: ` + toExpression(additionalItems) + `; }`;
+        } else {
+          return `{}`;
+        }
+      } else {
+        return `{ ` + locations.map((location) => location + `: ` + toExpression(properties[location]) + `;`).join(" ") + ` }`;
+      }
+    default:
+      if (schema3.b) {
+        return tag;
+      }
+      switch (tag) {
+        case "instance":
+          return schema3.class.name;
+        case "array":
+          let additionalItems$1 = schema3.additionalItems;
+          let items = schema3.items;
+          if (typeof additionalItems$1 !== "object") {
+            return `[` + items.map((item) => toExpression(item.schema)).join(", ") + `]`;
+          }
+          let itemName = toExpression(additionalItems$1);
+          return (additionalItems$1.type === "union" ? `(` + itemName + `)` : itemName) + "[]";
+        default:
+          return tag;
+      }
+  }
+}
+var SuryError = class extends Error {
+  constructor(code, flag, path) {
+    super();
+    this.flag = flag;
+    this.code = code;
+    this.path = path;
+  }
+};
+var d = Object.defineProperty;
+var p = SuryError.prototype;
+d(p, "message", {
+  get() {
+    return message(this);
+  }
+});
+d(p, "reason", {
+  get() {
+    return reason(this);
+  }
+});
+d(p, "name", { value: "SuryError" });
+d(p, "s", { value: s });
+d(p, "_1", {
+  get() {
+    return this;
+  }
+});
+d(p, "RE_EXN_ID", {
+  value: $$Error
+});
+var Schema = function(type) {
+  this.type = type;
+};
+var sp = /* @__PURE__ */ Object.create(null);
+d(sp, "with", {
+  get() {
+    return (fn, ...args) => fn(this, ...args);
+  }
+});
+Schema.prototype = sp;
+function getOrRethrow(exn) {
+  if (exn && exn.s === s) {
+    return exn;
+  }
+  throw exn;
+}
+function reason(error, nestedLevelOpt) {
+  let nestedLevel = nestedLevelOpt !== void 0 ? nestedLevelOpt : 0;
+  let reason$1 = error.code;
+  if (typeof reason$1 !== "object") {
+    return "Encountered unexpected async transform or refine. Use parseAsyncOrThrow operation instead";
+  }
+  switch (reason$1.TAG) {
+    case "OperationFailed":
+      return reason$1._0;
+    case "InvalidOperation":
+      return reason$1.description;
+    case "InvalidType":
+      let unionErrors = reason$1.unionErrors;
+      let m = `Expected ` + toExpression(reason$1.expected) + `, received ` + stringify(reason$1.received);
+      if (unionErrors !== void 0) {
+        let lineBreak = `
+` + " ".repeat(nestedLevel << 1);
+        let reasonsDict = {};
+        for (let idx = 0, idx_finish = unionErrors.length; idx < idx_finish; ++idx) {
+          let error$1 = unionErrors[idx];
+          let reason$2 = reason(error$1, nestedLevel + 1);
+          let nonEmptyPath = error$1.path;
+          let location = nonEmptyPath === "" ? "" : `At ` + nonEmptyPath + `: `;
+          let line = `- ` + location + reason$2;
+          if (!reasonsDict[line]) {
+            reasonsDict[line] = 1;
+            m = m + lineBreak + line;
+          }
+        }
+      }
+      return m;
+    case "UnsupportedTransformation":
+      return `Unsupported transformation from ` + toExpression(reason$1.from) + ` to ` + toExpression(reason$1.to);
+    case "ExcessField":
+      return `Unrecognized key "` + reason$1._0 + `"`;
+    case "InvalidJsonSchema":
+      return toExpression(reason$1._0) + ` is not valid JSON`;
+  }
+}
+function message(error) {
+  let op = error.flag;
+  let text = "Failed ";
+  if (op & 2) {
+    text = text + "async ";
+  }
+  text = text + (op & 1 ? op & 4 ? "asserting" : "parsing" : "converting");
+  if (op & 8) {
+    text = text + " to JSON" + (op & 16 ? " string" : "");
+  }
+  let nonEmptyPath = error.path;
+  let tmp = nonEmptyPath === "" ? "" : ` at ` + nonEmptyPath;
+  return text + tmp + `: ` + reason(error, void 0);
+}
+var globalConfig = {
+  a: "strip"};
+var shakenRef = "as";
+var shakenTraps = {
+  get: (target, prop) => {
+    let l = target[shakenRef];
+    if (l === void 0) {
+      return target[prop];
+    }
+    if (prop === shakenRef) {
+      return target[prop];
+    }
+    let l$1 = valFromOption(l);
+    let message2 = `Schema S.` + l$1 + ` is not enabled. To start using it, add S.enable` + capitalize(l$1) + `() at the project root.`;
+    throw new Error(`[Sury] ` + message2);
+  }
+};
+function shaken(apiName) {
+  let mut = new Schema("never");
+  mut[shakenRef] = apiName;
+  return new Proxy(mut, shakenTraps);
+}
+var unknown = new Schema("unknown");
+var string = new Schema("string");
+var int = new Schema("number");
+int.format = "int32";
+var unit = new Schema("undefined");
+unit.const = void 0;
+var copyWithoutCache = ((schema3) => {
+  let c = new Schema(schema3.type);
+  for (let k in schema3) {
+    if (k > "a" || k === "$ref" || k === "$defs") {
+      c[k] = schema3[k];
+    }
+  }
+  return c;
+});
+function updateOutput(schema3, fn) {
+  let root = copyWithoutCache(schema3);
+  let mut = root;
+  while (mut.to) {
+    let next = copyWithoutCache(mut.to);
+    mut.to = next;
+    mut = next;
+  }
+  fn(mut);
+  return root;
+}
+function embed(b, value) {
+  let e = b.g.e;
+  let l = e.length;
+  e[l] = value;
+  return `e[` + l + `]`;
+}
+function inlineConst(b, schema3) {
+  let tagFlag = flags[schema3.type];
+  let $$const = schema3.const;
+  if (tagFlag & 16) {
+    return "void 0";
+  } else if (tagFlag & 2) {
+    return fromString($$const);
+  } else if (tagFlag & 1024) {
+    return $$const + "n";
+  } else if (tagFlag & 45056) {
+    return embed(b, schema3.const);
+  } else {
+    return $$const;
+  }
+}
+function inlineLocation(b, location) {
+  let key = `"` + location + `"`;
+  let i = b.g[key];
+  if (i !== void 0) {
+    return i;
+  }
+  let inlinedLocation = fromString(location);
+  b.g[key] = inlinedLocation;
+  return inlinedLocation;
+}
+function secondAllocate(v) {
+  let b = this;
+  b.l = b.l + "," + v;
+}
+function initialAllocate(v) {
+  let b = this;
+  b.l = v;
+  b.a = secondAllocate;
+}
+function rootScope(flag, defs) {
+  let global2 = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    v: -1,
+    o: flag,
+    f: "",
+    e: [],
+    d: defs
+  };
+  global2.g = global2;
+  return global2;
+}
+function allocateScope(b) {
+  delete b.a;
+  let varsAllocation = b.l;
+  if (varsAllocation === "") {
+    return b.f + b.c;
+  } else {
+    return b.f + `let ` + varsAllocation + `;` + b.c;
+  }
+}
+function varWithoutAllocation(global2) {
+  let newCounter = global2.v + 1;
+  global2.v = newCounter;
+  return `v` + newCounter;
+}
+function _var(_b) {
+  return this.i;
+}
+function _notVar(b) {
+  let val2 = this;
+  let v = varWithoutAllocation(b.g);
+  let i = val2.i;
+  if (i === "") {
+    val2.b.a(v);
+  } else if (b.a !== void 0) {
+    b.a(v + `=` + i);
+  } else {
+    b.c = b.c + (v + `=` + i + `;`);
+    b.g.a(v);
+  }
+  val2.v = _var;
+  val2.i = v;
+  return v;
+}
+function allocateVal(b, schema3) {
+  let v = varWithoutAllocation(b.g);
+  b.a(v);
+  return {
+    b,
+    v: _var,
+    i: v,
+    f: 0,
+    type: schema3.type
+  };
+}
+function val(b, initial, schema3) {
+  return {
+    b,
+    v: _notVar,
+    i: initial,
+    f: 0,
+    type: schema3.type
+  };
+}
+function constVal(b, schema3) {
+  return {
+    b,
+    v: _notVar,
+    i: inlineConst(b, schema3),
+    f: 0,
+    type: schema3.type,
+    const: schema3.const
+  };
+}
+function objectJoin(inlinedLocation, value) {
+  return inlinedLocation + `:` + value + `,`;
+}
+function arrayJoin(_inlinedLocation, value) {
+  return value + ",";
+}
+function make(b, isArray) {
+  return {
+    b,
+    v: _notVar,
+    i: "",
+    f: 0,
+    type: isArray ? "array" : "object",
+    properties: {},
+    additionalItems: "strict",
+    j: isArray ? arrayJoin : objectJoin,
+    c: 0,
+    r: ""
+  };
+}
+function add(objectVal, location, val2) {
+  let inlinedLocation = inlineLocation(objectVal.b, location);
+  objectVal.properties[location] = val2;
+  if (val2.f & 2) {
+    objectVal.r = objectVal.r + val2.i + ",";
+    objectVal.i = objectVal.i + objectVal.j(inlinedLocation, `a[` + objectVal.c++ + `]`);
+  } else {
+    objectVal.i = objectVal.i + objectVal.j(inlinedLocation, val2.i);
+  }
+}
+function complete(objectVal, isArray) {
+  objectVal.i = isArray ? "[" + objectVal.i + "]" : "{" + objectVal.i + "}";
+  if (objectVal.c) {
+    objectVal.f = objectVal.f | 2;
+    objectVal.i = `Promise.all([` + objectVal.r + `]).then(a=>(` + objectVal.i + `))`;
+  }
+  objectVal.additionalItems = "strict";
+  return objectVal;
+}
+function set(b, input, val2) {
+  if (input === val2) {
+    return "";
+  }
+  let inputVar = input.v(b);
+  let match = input.f & 2;
+  let match$1 = val2.f & 2;
+  if (match) {
+    if (!match$1) {
+      return inputVar + `=Promise.resolve(` + val2.i + `)`;
+    }
+  } else if (match$1) {
+    input.f = input.f | 2;
+    return inputVar + `=` + val2.i;
+  }
+  return inputVar + `=` + val2.i;
+}
+function get(b, targetVal, location) {
+  let properties = targetVal.properties;
+  let val2 = properties[location];
+  if (val2 !== void 0) {
+    return val2;
+  }
+  let schema3 = targetVal.additionalItems;
+  let schema$1;
+  if (schema3 === "strip" || schema3 === "strict") {
+    if (schema3 === "strip") {
+      throw new Error(`[Sury] The schema doesn't have additional items`);
+    }
+    throw new Error(`[Sury] The schema doesn't have additional items`);
+  } else {
+    schema$1 = schema3;
+  }
+  let val$1 = {
+    b,
+    v: _notVar,
+    i: targetVal.v(b) + (`[` + fromString(location) + `]`),
+    f: 0,
+    type: schema$1.type
+  };
+  properties[location] = val$1;
+  return val$1;
+}
+function setInlined(b, input, inlined) {
+  return input.v(b) + `=` + inlined;
+}
+function map2(inlinedFn, input) {
+  return {
+    b: input.b,
+    v: _notVar,
+    i: inlinedFn + `(` + input.i + `)`,
+    f: 0,
+    type: "unknown"
+  };
+}
+function $$throw(b, code, path) {
+  throw new SuryError(code, b.g.o, path);
+}
+function failWithArg(b, path, fn, arg) {
+  return embed(b, (arg2) => $$throw(b, fn(arg2), path)) + `(` + arg + `)`;
+}
+function withPathPrepend(b, input, path, maybeDynamicLocationVar, appendSafe, fn) {
+  if (path === "" && maybeDynamicLocationVar === void 0) {
+    return fn(b, input, path);
+  }
+  try {
+    let $$catch = (b2, errorVar2) => {
+      b2.c = errorVar2 + `.path=` + fromString(path) + `+` + (maybeDynamicLocationVar !== void 0 ? `'["'+` + maybeDynamicLocationVar + `+'"]'+` : "") + errorVar2 + `.path`;
+    };
+    let fn$1 = (b2) => fn(b2, input, "");
+    let prevCode = b.c;
+    b.c = "";
+    let errorVar = varWithoutAllocation(b.g);
+    let maybeResolveVal = $$catch(b, errorVar);
+    let catchCode = `if(` + (errorVar + `&&` + errorVar + `.s===s`) + `){` + b.c;
+    b.c = "";
+    let bb = {
+      c: "",
+      l: "",
+      a: initialAllocate,
+      f: "",
+      g: b.g
+    };
+    let fnOutput = fn$1(bb);
+    b.c = b.c + allocateScope(bb);
+    let isNoop = fnOutput.i === input.i && b.c === "";
+    if (appendSafe !== void 0) ;
+    if (isNoop) {
+      return fnOutput;
+    }
+    let isAsync2 = fnOutput.f & 2;
+    let output = input === fnOutput ? input : appendSafe !== void 0 ? fnOutput : {
+      b,
+      v: _notVar,
+      i: "",
+      f: isAsync2 ? 2 : 0,
+      type: "unknown"
+    };
+    let catchCode$1 = maybeResolveVal !== void 0 ? (catchLocation) => catchCode + (catchLocation === 1 ? `return ` + maybeResolveVal.i : set(b, output, maybeResolveVal)) + (`}else{throw ` + errorVar + `}`) : (param) => catchCode + `}throw ` + errorVar;
+    b.c = prevCode + (`try{` + b.c + (isAsync2 ? setInlined(b, output, fnOutput.i + `.catch(` + errorVar + `=>{` + catchCode$1(1) + `})`) : set(b, output, fnOutput)) + `}catch(` + errorVar + `){` + catchCode$1(0) + `}`);
+    return output;
+  } catch (exn) {
+    let error = getOrRethrow(exn);
+    throw new SuryError(error.code, error.flag, path + "[]" + error.path);
+  }
+}
+function validation(b, inputVar, schema3, negative) {
+  let eq = "!==" ;
+  let and_ = "||" ;
+  let exp = "!" ;
+  let tag = schema3.type;
+  let tagFlag = flags[tag];
+  if (tagFlag & 2048) {
+    return exp + (`Number.isNaN(` + inputVar + `)`);
+  }
+  if (constField in schema3) {
+    return inputVar + eq + inlineConst(b, schema3);
+  }
+  if (tagFlag & 4) {
+    return `typeof ` + inputVar + eq + `"` + tag + `"`;
+  }
+  if (tagFlag & 64) {
+    return `typeof ` + inputVar + eq + `"` + tag + `"` + and_ + exp + inputVar;
+  }
+  if (tagFlag & 128) {
+    return exp + `Array.isArray(` + inputVar + `)`;
+  }
+  if (!(tagFlag & 8192)) {
+    return `typeof ` + inputVar + eq + `"` + tag + `"`;
+  }
+  let c = inputVar + ` instanceof ` + embed(b, schema3.class);
+  {
+    return `!(` + c + `)`;
+  }
+}
+function refinement(b, inputVar, schema3, negative) {
+  let eq = "!==" ;
+  let and_ = "||" ;
+  let not_ = "" ;
+  let lt = ">" ;
+  let gt = "<" ;
+  let match = schema3.type;
+  let tag;
+  let exit2 = 0;
+  let match$1 = schema3.const;
+  if (match$1 !== void 0) {
+    return "";
+  }
+  let match$2 = schema3.format;
+  if (match$2 !== void 0) {
+    switch (match$2) {
+      case "int32":
+        return and_ + inputVar + lt + `2147483647` + and_ + inputVar + gt + `-2147483648` + and_ + inputVar + `%1` + eq + `0`;
+      case "port":
+      case "json":
+        exit2 = 2;
+        break;
+    }
+  } else {
+    exit2 = 2;
+  }
+  if (exit2 === 2) {
+    switch (match) {
+      case "number":
+        {
+          return and_ + not_ + `Number.isNaN(` + inputVar + `)`;
+        }
+      case "array":
+      case "object":
+        tag = match;
+        break;
+      default:
+        return "";
+    }
+  }
+  let additionalItems = schema3.additionalItems;
+  let items = schema3.items;
+  let length2 = items.length;
+  let code = tag === "array" ? additionalItems === "strip" || additionalItems === "strict" ? additionalItems === "strip" ? and_ + inputVar + `.length` + gt + length2 : and_ + inputVar + `.length` + eq + length2 : "" : additionalItems === "strip" ? "" : and_ + not_ + `Array.isArray(` + inputVar + `)`;
+  for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+    let match$3 = items[idx];
+    let location = match$3.location;
+    let item = match$3.schema;
+    let itemCode;
+    if (constField in item || schema3.unnest) {
+      let inlinedLocation = inlineLocation(b, location);
+      itemCode = validation(b, inputVar + (`[` + inlinedLocation + `]`), item);
+    } else if (item.items) {
+      let inlinedLocation$1 = inlineLocation(b, location);
+      let inputVar$1 = inputVar + (`[` + inlinedLocation$1 + `]`);
+      itemCode = validation(b, inputVar$1, item) + refinement(b, inputVar$1, item);
+    } else {
+      itemCode = "";
+    }
+    if (itemCode !== "") {
+      code = code + and_ + itemCode;
+    }
+  }
+  return code;
+}
+function makeRefinedOf(b, input, schema3) {
+  let mut = {
+    b,
+    v: input.v,
+    i: input.i,
+    f: input.f,
+    type: schema3.type
+  };
+  let loop = (mut2, schema4) => {
+    if (constField in schema4) {
+      mut2.const = schema4.const;
+    }
+    let items = schema4.items;
+    if (items === void 0) {
+      return;
+    }
+    let properties = {};
+    items.forEach((item) => {
+      let schema5 = item.schema;
+      let isConst = constField in schema5;
+      if (!(isConst || schema5.items)) {
+        return;
+      }
+      let tmp;
+      if (isConst) {
+        tmp = inlineConst(b, schema5);
+      } else {
+        let inlinedLocation = inlineLocation(b, item.location);
+        tmp = mut2.v(b) + (`[` + inlinedLocation + `]`);
+      }
+      let mut$1 = {
+        b: mut2.b,
+        v: _notVar,
+        i: tmp,
+        f: 0,
+        type: schema5.type
+      };
+      loop(mut$1, schema5);
+      properties[item.location] = mut$1;
+    });
+    mut2.properties = properties;
+    mut2.additionalItems = unknown;
+  };
+  loop(mut, schema3);
+  return mut;
+}
+function typeFilterCode(b, schema3, input, path) {
+  if (schema3.noValidation || flags[schema3.type] & 17153) {
+    return "";
+  }
+  let inputVar = input.v(b);
+  return `if(` + validation(b, inputVar, schema3) + refinement(b, inputVar, schema3) + `){` + failWithArg(b, path, (input2) => ({
+    TAG: "InvalidType",
+    expected: schema3,
+    received: input2
+  }), inputVar) + `}`;
+}
+function unsupportedTransform(b, from, target, path) {
+  return $$throw(b, {
+    TAG: "UnsupportedTransformation",
+    from,
+    to: target
+  }, path);
+}
+function noopOperation(i) {
+  return i;
+}
+function setHas(has2, tag) {
+  has2[tag === "union" || tag === "ref" ? "unknown" : tag] = true;
+}
+var jsonName = `JSON`;
+var jsonString = shaken("jsonString");
+function inputToString(b, input) {
+  return val(b, `""+` + input.i, string);
+}
+function parse(prevB, schema3, inputArg, path) {
+  let b = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    f: "",
+    g: prevB.g
+  };
+  if (schema3.$defs) {
+    b.g.d = schema3.$defs;
+  }
+  let input = inputArg;
+  let isFromLiteral = constField in input;
+  let isSchemaLiteral = constField in schema3;
+  let isSameTag = input.type === schema3.type;
+  let schemaTagFlag = flags[schema3.type];
+  let inputTagFlag = flags[input.type];
+  let isUnsupported = false;
+  if (!(schemaTagFlag & 257 || schema3.format === "json")) {
+    if (schema3.name === jsonName && !(inputTagFlag & 1)) {
+      if (!(inputTagFlag & 14)) {
+        if (inputTagFlag & 1024) {
+          input = inputToString(b, input);
+        } else {
+          isUnsupported = true;
+        }
+      }
+    } else if (isSchemaLiteral) {
+      if (isFromLiteral) {
+        if (input.const !== schema3.const) {
+          input = constVal(b, schema3);
+        }
+      } else if (inputTagFlag & 2 && schemaTagFlag & 3132) {
+        let inputVar = input.v(b);
+        b.f = schema3.noValidation ? "" : input.i + `==="` + schema3.const + `"||` + failWithArg(b, path, (input2) => ({
+          TAG: "InvalidType",
+          expected: schema3,
+          received: input2
+        }), inputVar) + `;`;
+        input = constVal(b, schema3);
+      } else if (schema3.noValidation) {
+        input = constVal(b, schema3);
+      } else {
+        b.f = typeFilterCode(prevB, schema3, input, path);
+        input.type = schema3.type;
+        input.const = schema3.const;
+      }
+    } else if (isFromLiteral && !isSchemaLiteral) {
+      if (!isSameTag) {
+        if (schemaTagFlag & 2 && inputTagFlag & 3132) {
+          let $$const = "" + input.const;
+          input = {
+            b,
+            v: _notVar,
+            i: `"` + $$const + `"`,
+            f: 0,
+            type: "string",
+            const: $$const
+          };
+        } else {
+          isUnsupported = true;
+        }
+      }
+    } else if (inputTagFlag & 1) {
+      let ref = schema3.$ref;
+      if (ref !== void 0) {
+        let defs = b.g.d;
+        let identifier = ref.slice(8);
+        let def = defs[identifier];
+        let flag = schema3.noValidation ? (b.g.o | 1) ^ 1 : b.g.o;
+        let fn = def[flag];
+        let recOperation;
+        if (fn !== void 0) {
+          let fn$1 = valFromOption(fn);
+          recOperation = fn$1 === 0 ? embed(b, def) + (`[` + flag + `]`) : embed(b, fn$1);
+        } else {
+          def[flag] = 0;
+          let fn$2 = internalCompile(def, flag, b.g.d);
+          def[flag] = fn$2;
+          recOperation = embed(b, fn$2);
+        }
+        input = withPathPrepend(b, input, path, void 0, void 0, (param, input2, param$1) => {
+          let output = map2(recOperation, input2);
+          if (def.isAsync === void 0) {
+            let defsMut = copy(defs);
+            defsMut[identifier] = unknown;
+            isAsyncInternal(def, defsMut);
+          }
+          if (def.isAsync) {
+            output.f = output.f | 2;
+          }
+          return output;
+        });
+        input.v(b);
+      } else {
+        if (b.g.o & 1) {
+          b.f = typeFilterCode(prevB, schema3, input, path);
+        }
+        let refined = makeRefinedOf(b, input, schema3);
+        input.type = refined.type;
+        input.i = refined.i;
+        input.v = refined.v;
+        input.additionalItems = refined.additionalItems;
+        input.properties = refined.properties;
+        if (constField in refined) {
+          input.const = refined.const;
+        }
+      }
+    } else if (schemaTagFlag & 2 && inputTagFlag & 1036) {
+      input = inputToString(b, input);
+    } else if (!isSameTag) {
+      if (inputTagFlag & 2) {
+        let inputVar$1 = input.v(b);
+        if (schemaTagFlag & 8) {
+          let output = allocateVal(b, schema3);
+          b.c = b.c + (`(` + output.i + `=` + inputVar$1 + `==="true")||` + inputVar$1 + `==="false"||` + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema3,
+            received: input2
+          }), inputVar$1) + `;`);
+          input = output;
+        } else if (schemaTagFlag & 4) {
+          let output$1 = val(b, `+` + inputVar$1, schema3);
+          let outputVar = output$1.v(b);
+          let match = schema3.format;
+          b.c = b.c + (match !== void 0 ? `(` + refinement(b, outputVar, schema3).slice(2) + `)` : `Number.isNaN(` + outputVar + `)`) + (`&&` + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema3,
+            received: input2
+          }), inputVar$1) + `;`);
+          input = output$1;
+        } else if (schemaTagFlag & 1024) {
+          let output$2 = allocateVal(b, schema3);
+          b.c = b.c + (`try{` + output$2.i + `=BigInt(` + inputVar$1 + `)}catch(_){` + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema3,
+            received: input2
+          }), inputVar$1) + `}`);
+          input = output$2;
+        } else {
+          isUnsupported = true;
+        }
+      } else if (inputTagFlag & 4 && schemaTagFlag & 1024) {
+        input = val(b, `BigInt(` + input.i + `)`, schema3);
+      } else {
+        isUnsupported = true;
+      }
+    }
+  }
+  if (isUnsupported) {
+    unsupportedTransform(b, input, schema3, path);
+  }
+  let compiler = schema3.compiler;
+  if (compiler !== void 0) {
+    input = compiler(b, input, schema3, path);
+  }
+  if (input.t !== true) {
+    let refiner = schema3.refiner;
+    if (refiner !== void 0) {
+      b.c = b.c + refiner(b, input.v(b), schema3, path);
+    }
+  }
+  let to2 = schema3.to;
+  if (to2 !== void 0) {
+    let parser = schema3.parser;
+    if (parser !== void 0) {
+      input = parser(b, input, schema3, path);
+    }
+    if (input.t !== true) {
+      input = parse(b, to2, input, path);
+    }
+  }
+  prevB.c = prevB.c + allocateScope(b);
+  return input;
+}
+function isAsyncInternal(schema3, defs) {
+  try {
+    let b = rootScope(2, defs);
+    let input = {
+      b,
+      v: _var,
+      i: "i",
+      f: 0,
+      type: "unknown"
+    };
+    let output = parse(b, schema3, input, "");
+    let isAsync2 = has(output.f, 2);
+    schema3.isAsync = isAsync2;
+    return isAsync2;
+  } catch (exn) {
+    getOrRethrow(exn);
+    return false;
+  }
+}
+function internalCompile(schema3, flag, defs) {
+  let b = rootScope(flag, defs);
+  if (flag & 8) {
+    let output = reverse(schema3);
+    jsonableValidation(output, output, "", flag);
+  }
+  let input = {
+    b,
+    v: _var,
+    i: "i",
+    f: 0,
+    type: "unknown"
+  };
+  let schema$1 = flag & 4 ? updateOutput(schema3, (mut) => {
+    let t = new Schema(unit.type);
+    t.const = unit.const;
+    t.noValidation = true;
+    mut.to = t;
+  }) : flag & 16 ? updateOutput(schema3, (mut) => {
+    mut.to = jsonString;
+  }) : schema3;
+  let output$1 = parse(b, schema$1, input, "");
+  let code = allocateScope(b);
+  let isAsync2 = has(output$1.f, 2);
+  schema$1.isAsync = isAsync2;
+  if (code === "" && output$1 === input && !(flag & 2)) {
+    return noopOperation;
+  }
+  let inlinedOutput = output$1.i;
+  if (flag & 2 && !isAsync2 && !defs) {
+    inlinedOutput = `Promise.resolve(` + inlinedOutput + `)`;
+  }
+  let inlinedFunction = `i=>{` + code + `return ` + inlinedOutput + `}`;
+  let ctxVarValue1 = b.g.e;
+  return new Function("e", "s", `return ` + inlinedFunction)(ctxVarValue1, s);
+}
+function reverse(schema3) {
+  let reversedHead;
+  let current = schema3;
+  while (current) {
+    let mut = copyWithoutCache(current);
+    let next = mut.to;
+    let to2 = reversedHead;
+    if (to2 !== void 0) {
+      mut.to = to2;
+    } else {
+      delete mut.to;
+    }
+    let parser = mut.parser;
+    let serializer = mut.serializer;
+    if (serializer !== void 0) {
+      mut.parser = serializer;
+    } else {
+      delete mut.parser;
+    }
+    if (parser !== void 0) {
+      mut.serializer = parser;
+    } else {
+      delete mut.serializer;
+    }
+    let fromDefault = mut.fromDefault;
+    let $$default = mut.default;
+    if ($$default !== void 0) {
+      mut.fromDefault = $$default;
+    } else {
+      delete mut.fromDefault;
+    }
+    if (fromDefault !== void 0) {
+      mut.default = fromDefault;
+    } else {
+      delete mut.default;
+    }
+    let items = mut.items;
+    if (items !== void 0) {
+      let properties = {};
+      let newItems = new Array(items.length);
+      for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+        let item = items[idx];
+        let reversed_schema = reverse(item.schema);
+        let reversed_location = item.location;
+        let reversed = {
+          schema: reversed_schema,
+          location: reversed_location
+        };
+        if (item.r) {
+          reversed.r = item.r;
+        }
+        properties[item.location] = reversed_schema;
+        newItems[idx] = reversed;
+      }
+      mut.items = newItems;
+      let match = mut.properties;
+      if (match !== void 0) {
+        mut.properties = properties;
+      }
+    }
+    if (typeof mut.additionalItems === "object") {
+      mut.additionalItems = reverse(mut.additionalItems);
+    }
+    let anyOf = mut.anyOf;
+    if (anyOf !== void 0) {
+      let has2 = {};
+      let newAnyOf = [];
+      for (let idx$1 = 0, idx_finish$1 = anyOf.length; idx$1 < idx_finish$1; ++idx$1) {
+        let s2 = anyOf[idx$1];
+        let reversed$1 = reverse(s2);
+        newAnyOf.push(reversed$1);
+        setHas(has2, reversed$1.type);
+      }
+      mut.has = has2;
+      mut.anyOf = newAnyOf;
+    }
+    let defs = mut.$defs;
+    if (defs !== void 0) {
+      let reversedDefs = {};
+      for (let idx$2 = 0, idx_finish$2 = Object.keys(defs).length; idx$2 < idx_finish$2; ++idx$2) {
+        let key = Object.keys(defs)[idx$2];
+        reversedDefs[key] = reverse(defs[key]);
+      }
+      mut.$defs = reversedDefs;
+    }
+    reversedHead = mut;
+    current = next;
+  }
+  return reversedHead;
+}
+function jsonableValidation(output, parent, path, flag) {
+  let tagFlag = flags[output.type];
+  if (tagFlag & 48129 || tagFlag & 16 && parent.type !== "object") {
+    throw new SuryError({
+      TAG: "InvalidJsonSchema",
+      _0: parent
+    }, flag, path);
+  }
+  if (tagFlag & 256) {
+    output.anyOf.forEach((s2) => jsonableValidation(s2, parent, path, flag));
+    return;
+  }
+  if (!(tagFlag & 192)) {
+    return;
+  }
+  let additionalItems = output.additionalItems;
+  if (additionalItems === "strip" || additionalItems === "strict") ; else {
+    jsonableValidation(additionalItems, parent, path, flag);
+  }
+  let p2 = output.properties;
+  if (p2 !== void 0) {
+    let keys = Object.keys(p2);
+    for (let idx = 0, idx_finish = keys.length; idx < idx_finish; ++idx) {
+      let key = keys[idx];
+      jsonableValidation(p2[key], parent, path, flag);
+    }
+    return;
+  }
+  output.items.forEach((item) => jsonableValidation(item.schema, output, path + (`[` + fromString(item.location) + `]`), flag));
+}
+function operationFn(s2, o) {
+  if (o in s2) {
+    return s2[o];
+  }
+  let f = internalCompile(s2, o, 0);
+  s2[o] = f;
+  return f;
+}
+d(sp, "~standard", {
+  get: function() {
+    let schema3 = this;
+    return {
+      version: 1,
+      vendor,
+      validate: (input) => {
+        try {
+          return {
+            value: operationFn(schema3, 1)(input)
+          };
+        } catch (exn) {
+          let error = getOrRethrow(exn);
+          return {
+            issues: [{
+              message: reason(error, void 0),
+              path: error.path === "" ? void 0 : toArray2(error.path)
+            }]
+          };
+        }
+      }
+    };
+  }
+});
+function parseOrThrow(any, schema3) {
+  return operationFn(schema3, 1)(any);
+}
+function parseJsonStringOrThrow(jsonString2, schema3) {
+  let tmp;
+  try {
+    tmp = JSON.parse(jsonString2);
+  } catch (exn) {
+    throw new SuryError({
+      TAG: "OperationFailed",
+      _0: exn.message
+    }, 1, "");
+  }
+  return parseOrThrow(tmp, schema3);
+}
+var $$null = new Schema("null");
+$$null.const = null;
+function parse$1(value) {
+  if (value === null) {
+    return $$null;
+  }
+  let $$typeof = typeof value;
+  let schema3;
+  if ($$typeof === "object") {
+    let i = new Schema("instance");
+    i.class = value.constructor;
+    schema3 = i;
+  } else {
+    schema3 = $$typeof === "undefined" ? unit : $$typeof === "number" ? Number.isNaN(value) ? new Schema("nan") : new Schema($$typeof) : new Schema($$typeof);
+  }
+  schema3.const = value;
+  return schema3;
+}
+var nullAsUnit = new Schema("null");
+nullAsUnit.const = null;
+nullAsUnit.to = unit;
+function neverBuilder(b, input, selfSchema, path) {
+  b.c = b.c + failWithArg(b, path, (input2) => ({
+    TAG: "InvalidType",
+    expected: selfSchema,
+    received: input2
+  }), input.i) + ";";
+  return input;
+}
+var never = new Schema("never");
+never.compiler = neverBuilder;
+shaken("json");
+function objectStrictModeCheck(b, input, items, selfSchema, path) {
+  if (!(selfSchema.type === "object" && selfSchema.additionalItems === "strict" && b.g.o & 1)) {
+    return;
+  }
+  let key = allocateVal(b, unknown);
+  let keyVar = key.i;
+  b.c = b.c + (`for(` + keyVar + ` in ` + input.v(b) + `){if(`);
+  if (items.length !== 0) {
+    for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+      let match = items[idx];
+      if (idx !== 0) {
+        b.c = b.c + "&&";
+      }
+      b.c = b.c + (keyVar + `!==` + inlineLocation(b, match.location));
+    }
+  } else {
+    b.c = b.c + "true";
+  }
+  b.c = b.c + (`){` + failWithArg(b, path, (exccessFieldName) => ({
+    TAG: "ExcessField",
+    _0: exccessFieldName
+  }), keyVar) + `}}`);
+}
+function schemaCompiler(b, input, selfSchema, path) {
+  let additionalItems = selfSchema.additionalItems;
+  let items = selfSchema.items;
+  let isArray = flags[selfSchema.type] & 128;
+  if (b.g.o & 64) {
+    let objectVal = make(b, isArray);
+    for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+      let match = items[idx];
+      let location = match.location;
+      add(objectVal, location, input.properties[location]);
+    }
+    return complete(objectVal, isArray);
+  }
+  let objectVal$1 = make(b, isArray);
+  for (let idx$1 = 0, idx_finish$1 = items.length; idx$1 < idx_finish$1; ++idx$1) {
+    let match$1 = items[idx$1];
+    let location$1 = match$1.location;
+    let itemInput = get(b, input, location$1);
+    let inlinedLocation = inlineLocation(b, location$1);
+    let path$1 = path + (`[` + inlinedLocation + `]`);
+    add(objectVal$1, location$1, parse(b, match$1.schema, itemInput, path$1));
+  }
+  objectStrictModeCheck(b, input, items, selfSchema, path);
+  if ((additionalItems !== "strip" || b.g.o & 32) && items.every((item) => objectVal$1.properties[item.location] === input.properties[item.location])) {
+    input.additionalItems = "strip";
+    return input;
+  } else {
+    return complete(objectVal$1, isArray);
+  }
+}
+function definitionToSchema(definition) {
+  if (typeof definition !== "object" || definition === null) {
+    return parse$1(definition);
+  }
+  if (definition["~standard"]) {
+    return definition;
+  }
+  if (Array.isArray(definition)) {
+    for (let idx = 0, idx_finish = definition.length; idx < idx_finish; ++idx) {
+      let schema3 = definitionToSchema(definition[idx]);
+      let location = idx.toString();
+      definition[idx] = {
+        schema: schema3,
+        location
+      };
+    }
+    let mut = new Schema("array");
+    mut.items = definition;
+    mut.additionalItems = "strict";
+    mut.compiler = schemaCompiler;
+    return mut;
+  }
+  let cnstr = definition.constructor;
+  if (cnstr && cnstr !== Object) {
+    return {
+      type: "instance",
+      const: definition,
+      class: cnstr
+    };
+  }
+  let fieldNames = Object.keys(definition);
+  let length2 = fieldNames.length;
+  let items = [];
+  for (let idx$1 = 0; idx$1 < length2; ++idx$1) {
+    let location$1 = fieldNames[idx$1];
+    let schema$1 = definitionToSchema(definition[location$1]);
+    let item = {
+      schema: schema$1,
+      location: location$1
+    };
+    definition[location$1] = schema$1;
+    items[idx$1] = item;
+  }
+  let mut$1 = new Schema("object");
+  mut$1.items = items;
+  mut$1.properties = definition;
+  mut$1.additionalItems = globalConfig.a;
+  mut$1.compiler = schemaCompiler;
+  return mut$1;
+}
+function matches(schema3) {
+  return schema3;
+}
+var ctx = {
+  m: matches
+};
+function factory$4(definer) {
+  return definitionToSchema(definer(ctx));
+}
+var schema = factory$4;
+
+// ../../node_modules/sury/src/S.res.mjs
+var string2 = string;
+var parseJsonStringOrThrow2 = parseJsonStringOrThrow;
+var schema2 = schema;
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Int.js
+function fromString2(x, radix) {
+  let maybeInt = parseInt(x);
+  if (Number.isNaN(maybeInt) || maybeInt > 2147483647 || maybeInt < -2147483648) {
+    return;
+  } else {
+    return maybeInt | 0;
+  }
+}
+
+// src/cli/FrontmanAstro__Cli__Detect.res.mjs
+async function fileExists(path) {
+  try {
+    await Fs2.promises.access(path);
+    return true;
+  } catch (exn) {
+    return false;
+  }
+}
+async function readFile2(path) {
+  try {
+    return await Fs2.promises.readFile(path, "utf8");
+  } catch (exn) {
+    return;
+  }
+}
+var astroPkgJsonSchema = schema2((s2) => ({
+  version: s2.m(string2)
+}));
+async function detectAstroVersion(projectDir) {
+  let astroPkgPath = Nodepath2.join(projectDir, "node_modules", "astro", "package.json");
+  let content = await readFile2(astroPkgPath);
+  if (content === void 0) {
+    return;
+  }
+  try {
+    let pkg = parseJsonStringOrThrow2(content, astroPkgJsonSchema);
+    let version = pkg.version;
+    let parts = version.split(".");
+    let match = parts[0];
+    let match$1 = parts[1];
+    if (match === void 0) {
+      return;
+    }
+    if (match$1 === void 0) {
+      return;
+    }
+    let major = getOrThrow(fromString2(match, void 0), void 0);
+    let minorClean = match$1.split("-")[0];
+    let minor = getOrThrow(fromString2(minorClean, void 0), void 0);
+    return {
+      major,
+      minor,
+      raw: version
+    };
+  } catch (exn) {
+    return;
+  }
+}
+async function detectConfigFile(projectDir) {
+  let variants = [
+    "astro.config.mjs",
+    "astro.config.ts",
+    "astro.config.mts",
+    "astro.config.js"
+  ];
+  let check2 = async (remaining) => {
+    let name = remaining[0];
+    if (name === void 0) {
+      return;
+    }
+    let path = Nodepath2.join(projectDir, name);
+    if (await fileExists(path)) {
+      return name;
+    }
+    let rest = remaining.slice(1, remaining.length);
+    return await check2(rest);
+  };
+  return await check2(variants);
+}
+var frontmanImportPattern = /@frontman-ai\/astro|@frontman\/frontman-astro|frontman-astro\/integration/;
+var hostPattern2 = /host:\s*['\"]([^'\"]+)['\"]/;
+async function analyzeFile(filePath) {
+  let content = await readFile2(filePath);
+  if (content === void 0) {
+    return "NotFound";
+  }
+  if (!frontmanImportPattern.test(content)) {
+    return "NeedsManualEdit";
+  }
+  let result = hostPattern2.exec(content);
+  if (result == null) {
+    return {
+      TAG: "HasFrontman",
+      host: ""
+    };
+  }
+  let maybeHost = flatMap(result.slice(1)[0], (x) => x);
+  if (maybeHost !== void 0) {
+    return {
+      TAG: "HasFrontman",
+      host: maybeHost
+    };
+  } else {
+    return {
+      TAG: "HasFrontman",
+      host: ""
+    };
+  }
+}
+async function detectPackageManager(projectDir) {
+  let checkDir = async (dir) => {
+    let lockFiles = [
+      [
+        Nodepath2.join(dir, "bun.lockb"),
+        "Bun"
+      ],
+      [
+        Nodepath2.join(dir, "bun.lock"),
+        "Bun"
+      ],
+      [
+        Nodepath2.join(dir, "deno.lock"),
+        "Deno"
+      ],
+      [
+        Nodepath2.join(dir, "pnpm-lock.yaml"),
+        "Pnpm"
+      ],
+      [
+        Nodepath2.join(dir, "yarn.lock"),
+        "Yarn"
+      ],
+      [
+        Nodepath2.join(dir, "package-lock.json"),
+        "Npm"
+      ]
+    ];
+    let check2 = async (remaining) => {
+      let match = remaining[0];
+      if (match === void 0) {
+        return;
+      }
+      if (await fileExists(match[0])) {
+        return match[1];
+      }
+      let rest = remaining.slice(1, remaining.length);
+      return await check2(rest);
+    };
+    return await check2(lockFiles);
+  };
+  let parentDir = Nodepath2.dirname(projectDir);
+  let grandparentDir = Nodepath2.dirname(parentDir);
+  let dirsToCheck = [
+    projectDir,
+    parentDir,
+    grandparentDir
+  ].filter((d2) => {
+    if (d2 !== projectDir) {
+      return true;
+    } else {
+      return d2 === projectDir;
+    }
+  });
+  let seen = {};
+  let uniqueDirs = dirsToCheck.filter((d2) => {
+    let match = seen[d2];
+    if (match !== void 0) {
+      return false;
+    } else {
+      seen[d2] = true;
+      return true;
+    }
+  });
+  let tryDirs = async (remaining) => {
+    let dir = remaining[0];
+    if (dir === void 0) {
+      return "Npm";
+    }
+    let pm = await checkDir(dir);
+    if (pm !== void 0) {
+      return pm;
+    }
+    let rest = remaining.slice(1, remaining.length);
+    return await tryDirs(rest);
+  };
+  return await tryDirs(uniqueDirs);
+}
+async function hasPackageJson(projectDir) {
+  return await fileExists(Nodepath2.join(projectDir, "package.json"));
+}
+async function detect(projectDir) {
+  let hasPackage = await hasPackageJson(projectDir);
+  if (!hasPackage) {
+    return {
+      TAG: "Error",
+      _0: "No package.json found. Please run from your Astro project root."
+    };
+  }
+  let astroVersion = await detectAstroVersion(projectDir);
+  if (astroVersion === void 0) {
+    return {
+      TAG: "Error",
+      _0: "Could not find Astro in node_modules. Please run 'npm install' first or verify this is an Astro project."
+    };
+  }
+  let name = await detectConfigFile(projectDir);
+  let configFileName = name !== void 0 ? name : "astro.config.mjs";
+  let configPath = Nodepath2.join(projectDir, configFileName);
+  let config2 = await analyzeFile(configPath);
+  let middlewareTsPath = Nodepath2.join(projectDir, "src", "middleware.ts");
+  let middlewareJsPath = Nodepath2.join(projectDir, "src", "middleware.js");
+  let match = await fileExists(middlewareTsPath) ? [
+    await analyzeFile(middlewareTsPath),
+    "src/middleware.ts"
+  ] : await fileExists(middlewareJsPath) ? [
+    await analyzeFile(middlewareJsPath),
+    "src/middleware.js"
+  ] : [
+    "NotFound",
+    "src/middleware.ts"
+  ];
+  let packageManager = await detectPackageManager(projectDir);
+  return {
+    TAG: "Ok",
+    _0: {
+      astroVersion,
+      config: config2,
+      middleware: match[0],
+      configFileName,
+      middlewareFileName: match[1],
+      packageManager
+    }
+  };
+}
+function getPackageManagerCommand(pm) {
+  switch (pm) {
+    case "Npm":
+      return "npm";
+    case "Yarn":
+      return "npx yarn";
+    case "Pnpm":
+      return "npx pnpm";
+    case "Bun":
+      return "bun";
+    case "Deno":
+      return "deno";
+  }
+}
+function getDevCommand(pm) {
+  switch (pm) {
+    case "Npm":
+      return "npm run dev";
+    case "Yarn":
+      return "yarn dev";
+    case "Pnpm":
+      return "pnpm dev";
+    case "Bun":
+      return "bun dev";
+    case "Deno":
+      return "deno task dev";
+  }
+}
+function getInstallArgs(pm, isDevOpt) {
+  switch (pm) {
+    case "Npm":
+      {
+        return ["install"];
+      }
+    case "Yarn":
+      {
+        return ["add"];
+      }
+    case "Pnpm":
+      {
+        return ["add"];
+      }
+  }
+  {
+    return ["add"];
+  }
+}
+
+// src/cli/FrontmanAstro__Cli__Install.res.mjs
+async function installDependencies(projectDir, packageManager, dryRun) {
+  let pm = getPackageManagerCommand(packageManager);
+  let args = getInstallArgs(packageManager);
+  let packages = [
+    "@frontman-ai/astro",
+    "@astrojs/node"
+  ];
+  let packages$1;
+  packages$1 = packageManager === "Deno" ? packages.map((p2) => "npm:" + p2) : packages;
+  let cmd = pm + ` ` + args.join(" ") + ` ` + packages$1.join(" ");
+  if (dryRun) {
+    console.log(`  ` + dim(`Would run: ` + cmd));
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+  console.log(`  ` + purple("Installing dependencies with " + pm + "..."));
+  let err = await execWithOptions(cmd, {
+    cwd: projectDir
+  });
+  if (err.TAG === "Ok") {
+    console.log(`  ` + check + ` Dependencies installed`);
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+  let err$1 = err._0;
+  let stderr = err$1.stderr === "" ? "Unknown error" : err$1.stderr;
+  return {
+    TAG: "Error",
+    _0: `Failed to install dependencies: ` + stderr
+  };
+}
+function processFileResult(result, manualSteps) {
+  if (result.TAG === "Ok") {
+    let fileResult = result._0;
+    console.log(formatResult(fileResult));
+    if (fileResult.TAG === "ManualEditRequired") {
+      manualSteps.push(fileResult.details);
+    }
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+  let msg = result._0;
+  console.error(`  ` + warn + `  ` + bold("Error:") + ` ` + msg);
+  return {
+    TAG: "Error",
+    _0: msg
+  };
+}
+function collectPendingAutoEdits(projectDir, host, info) {
+  let pending = [];
+  let p2 = getPendingAutoEdit(info.config, Nodepath2.join(projectDir, info.configFileName), info.configFileName, "Config", ManualInstructions.config(info.configFileName, host));
+  if (p2 !== void 0) {
+    pending.push(p2);
+  }
+  let p$1 = getPendingAutoEdit(info.middleware, Nodepath2.join(projectDir, info.middlewareFileName), info.middlewareFileName, "Middleware", ManualInstructions.middleware(info.middlewareFileName, host));
+  if (p$1 !== void 0) {
+    pending.push(p$1);
+  }
+  return pending;
+}
+async function run(options) {
+  let projectDir = getOr(options.prefix, process.cwd());
+  let host = options.server;
+  console.log(banner());
+  console.log(`  ` + bullet + ` ` + bold("Server:") + `   ` + host);
+  if (options.dryRun) {
+    console.log("");
+    console.log(SuccessMessages.dryRunHeader);
+  }
+  let msg = await detect(projectDir);
+  if (msg.TAG === "Ok") {
+    let info = msg._0;
+    let version = getOrThrow(info.astroVersion).raw;
+    console.log(`  ` + bullet + ` ` + bold("Detected:") + ` Astro ` + version);
+    console.log("");
+    if (!options.skipDeps) {
+      let msg$1 = await installDependencies(projectDir, info.packageManager, options.dryRun);
+      if (msg$1.TAG !== "Ok") {
+        console.error(`  ` + warn + `  ` + msg$1._0);
+      }
+      console.log("");
+    }
+    let pendingEdits = collectPendingAutoEdits(projectDir, host, info);
+    let match = pendingEdits.length !== 0;
+    let match$1 = options.dryRun;
+    let shouldAutoEdit;
+    if (match && !match$1) {
+      let fileNames = pendingEdits.map((p2) => p2.fileName);
+      shouldAutoEdit = await promptUserForAutoEdit(fileNames);
+    } else {
+      shouldAutoEdit = false;
+    }
+    let manualSteps = [];
+    let configResult = await handleConfig(projectDir, host, info.configFileName, info.config, options.dryRun, shouldAutoEdit);
+    let msg$2 = processFileResult(configResult, manualSteps);
+    if (msg$2.TAG !== "Ok") {
+      return {
+        TAG: "Failure",
+        _0: msg$2._0
+      };
+    }
+    let middlewareResult = await handleMiddleware(projectDir, host, info.middlewareFileName, info.middleware, options.dryRun, shouldAutoEdit);
+    let msg$3 = processFileResult(middlewareResult, manualSteps);
+    if (msg$3.TAG !== "Ok") {
+      return {
+        TAG: "Failure",
+        _0: msg$3._0
+      };
+    }
+    if (manualSteps.length !== 0) {
+      console.log("");
+      console.log(`  ` + divider);
+      console.log("");
+      console.log(`  ` + yellowBold("Manual steps required:"));
+      console.log("");
+      manualSteps.forEach((step) => {
+        console.log(step);
+      });
+      console.log("");
+      return {
+        TAG: "PartialSuccess",
+        manualStepsRequired: manualSteps
+      };
+    }
+    if (!options.dryRun) {
+      let devCommand = getDevCommand(info.packageManager);
+      console.log("");
+      console.log(`  ` + divider);
+      console.log(SuccessMessages.installComplete(devCommand));
+    }
+    return "Success";
+  }
+  let msg$4 = msg._0;
+  console.error(`  ` + warn + `  ` + bold("Error:") + ` ` + msg$4);
+  return {
+    TAG: "Failure",
+    _0: msg$4
+  };
+}
+
+// src/cli/FrontmanAstro__Cli.res.mjs
+var helpText = `
+Frontman Astro CLI
+
+Usage:
+  frontman-ai-astro <command> [options]
+
+Commands:
+  install    Install Frontman in an Astro project
+
+Options:
+  --server <host>   Frontman server host (default: api.frontman.sh)
+  --prefix <path>   Target directory (default: current directory)
+  --dry-run         Preview changes without writing files
+  --skip-deps       Skip dependency installation
+  --help            Show this help message
+
+Examples:
+  npx @frontman-ai/astro install
+  npx @frontman-ai/astro install --server frontman.company.com
+  npx @frontman-ai/astro install --dry-run
+`;
+function parseArgs(argv) {
+  let args = argv.slice(2, argv.length);
+  let _remaining = args;
+  let _result = {
+    command: void 0,
+    server: void 0,
+    prefix: void 0,
+    dryRun: false,
+    skipDeps: false,
+    help: false
+  };
+  while (true) {
+    let result = _result;
+    let remaining = _remaining;
+    let arg = remaining[0];
+    if (arg === void 0) {
+      return result;
+    }
+    let rest = remaining.slice(1, remaining.length);
+    switch (arg) {
+      case "--dry-run":
+        _result = {
+          command: result.command,
+          server: result.server,
+          prefix: result.prefix,
+          dryRun: true,
+          skipDeps: result.skipDeps,
+          help: result.help
+        };
+        _remaining = rest;
+        continue;
+      case "--prefix":
+        let value = rest[0];
+        let nextRest = rest.slice(1, rest.length);
+        _result = {
+          command: result.command,
+          server: result.server,
+          prefix: value,
+          dryRun: result.dryRun,
+          skipDeps: result.skipDeps,
+          help: result.help
+        };
+        _remaining = nextRest;
+        continue;
+      case "--server":
+        let value$1 = rest[0];
+        let nextRest$1 = rest.slice(1, rest.length);
+        _result = {
+          command: result.command,
+          server: value$1,
+          prefix: result.prefix,
+          dryRun: result.dryRun,
+          skipDeps: result.skipDeps,
+          help: result.help
+        };
+        _remaining = nextRest$1;
+        continue;
+      case "--skip-deps":
+        _result = {
+          command: result.command,
+          server: result.server,
+          prefix: result.prefix,
+          dryRun: result.dryRun,
+          skipDeps: true,
+          help: result.help
+        };
+        _remaining = rest;
+        continue;
+      case "--help":
+      case "-h":
+        break;
+      case "install":
+        _result = {
+          command: "install",
+          server: result.server,
+          prefix: result.prefix,
+          dryRun: result.dryRun,
+          skipDeps: result.skipDeps,
+          help: result.help
+        };
+        _remaining = rest;
+        continue;
+      default:
+        _remaining = rest;
+        continue;
+    }
+    _result = {
+      command: result.command,
+      server: result.server,
+      prefix: result.prefix,
+      dryRun: result.dryRun,
+      skipDeps: result.skipDeps,
+      help: true
+    };
+    _remaining = rest;
+    continue;
+  }
+}
+async function main() {
+  let args = parseArgs(process.argv);
+  if (args.help) {
+    console.log(helpText);
+    Process.exit(0);
+  }
+  let cmd = args.command;
+  if (cmd !== void 0) {
+    if (cmd === "install") {
+      let s2 = args.server;
+      let server = s2 !== void 0 ? s2 : "api.frontman.sh";
+      let result = await run({
+        server,
+        prefix: args.prefix,
+        dryRun: args.dryRun,
+        skipDeps: args.skipDeps
+      });
+      if (typeof result !== "object") {
+        Process.exit(0);
+        return;
+      }
+      if (result.TAG === "PartialSuccess") {
+        Process.exit(0);
+        return;
+      }
+      Process.exit(1);
+      return;
+    } else {
+      console.error(`Unknown command: ` + cmd);
+      console.log(helpText);
+      Process.exit(1);
+      return;
+    }
+  } else {
+    console.log(helpText);
+    Process.exit(0);
+    return;
+  }
+}
+main();