@absolutejs/absolute 0.19.0-beta.1050 → 0.19.0-beta.1052

package/dist/cli/index.js

@@ -172240,23 +172240,237 @@ var init_mem = __esm(() => {
 });
 
 // src/cli/config/schema/fromType.ts
-var import_typescript3, cache;
+import {
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync16,
+  statSync as statSync2,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { resolve as resolve11 } from "path";
+var import_typescript3, VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFrameworkRepo = (cwd) => {
+  try {
+    const pkg = JSON.parse(readFileSync16(resolve11(cwd, "package.json"), "utf-8"));
+    return pkg?.name === "@absolutejs/absolute";
+  } catch {
+    return false;
+  }
+}, compilerOptionsFor = (cwd) => {
+  const tsconfigPath = import_typescript3.default.findConfigFile(cwd, import_typescript3.default.sys.fileExists, "tsconfig.json");
+  const base = tsconfigPath && import_typescript3.default.getParsedCommandLineOfConfigFile(tsconfigPath, {}, {
+    ...import_typescript3.default.sys,
+    onUnRecoverableConfigFileDiagnostic: () => {}
+  })?.options;
+  return {
+    ...base ?? import_typescript3.default.getDefaultCompilerOptions(),
+    noEmit: true,
+    skipDefaultLibCheck: true,
+    skipLibCheck: true,
+    types: []
+  };
+}, SCHEMA_VERSION = 1, packageVersion = (cwd, specifier) => {
+  const candidates = specifier === "@absolutejs/absolute" ? [
+    resolve11(cwd, "node_modules", "@absolutejs", "absolute", "package.json"),
+    resolve11(cwd, "package.json")
+  ] : [resolve11(cwd, "node_modules", ...specifier.split("/"), "package.json")];
+  for (const candidate of candidates) {
+    try {
+      const { version: version2 } = JSON.parse(readFileSync16(candidate, "utf-8"));
+      if (typeof version2 === "string")
+        return version2;
+    } catch {}
+  }
+  return "unknown";
+}, cacheSignature = (cwd, typeName, local, specifier) => {
+  let signature = `${SCHEMA_VERSION}:${specifier}:${packageVersion(cwd, specifier)}`;
+  if (local) {
+    const file = typeName === "PackageJson" ? "packageJson.ts" : "build.ts";
+    try {
+      signature += `:${statSync2(resolve11(cwd, "types", file)).mtimeMs}`;
+    } catch {}
+  }
+  return signature;
+}, cacheSlug = (specifier) => specifier.replace("@", "").split("/").join("-"), cacheFile = (cwd, typeName, specifier) => {
+  const name = specifier === "@absolutejs/absolute" ? typeName : `${typeName}.${cacheSlug(specifier)}`;
+  return resolve11(cwd, ".absolutejs", "config-schema", `${name}.json`);
+}, readDiskCache = (cwd, typeName, signature, specifier) => {
+  try {
+    const cached = JSON.parse(readFileSync16(cacheFile(cwd, typeName, specifier), "utf-8"));
+    if (cached?.signature === signature && Array.isArray(cached.fields)) {
+      return cached.fields;
+    }
+  } catch {}
+  return null;
+}, writeDiskCache = (cwd, typeName, signature, fields, specifier) => {
+  try {
+    mkdirSync7(resolve11(cwd, ".absolutejs", "config-schema"), {
+      recursive: true
+    });
+    writeFileSync6(cacheFile(cwd, typeName, specifier), JSON.stringify({ fields, signature }));
+  } catch {}
+}, docOf = (symbol, checker) => import_typescript3.default.displayPartsToString(symbol.getDocumentationComment(checker)).trim(), typeOfSymbol = (symbol, checker) => {
+  const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+  return declaration ? checker.getTypeOfSymbolAtLocation(symbol, declaration) : checker.getDeclaredTypeOfSymbol(symbol);
+}, hasFlag = (type, flag) => (type.flags & flag) !== 0, unionParts = (type) => type.isUnion() ? type.types : [type], literalChoice = (type) => {
+  if (type.isStringLiteral())
+    return type.value;
+  if (type.isNumberLiteral())
+    return type.value;
+  return null;
+}, toSchema = (type, checker, depth, seen) => {
+  const opaque = () => ({
+    kind: "opaque",
+    typeText: checker.typeToString(type)
+  });
+  if (depth > MAX_DEPTH)
+    return opaque();
+  const parts = unionParts(type).filter((part) => !hasFlag(part, import_typescript3.default.TypeFlags.Undefined) && !hasFlag(part, import_typescript3.default.TypeFlags.Null));
+  if (parts.length === 0)
+    return opaque();
+  if (parts.every((part) => hasFlag(part, import_typescript3.default.TypeFlags.BooleanLike))) {
+    return { kind: "boolean" };
+  }
+  const choices = parts.map(literalChoice);
+  if (parts.length > 1 && choices.every((choice) => choice !== null)) {
+    return { choices: choices.filter((c) => c !== null), kind: "enum" };
+  }
+  if (parts.length > 1) {
+    return {
+      kind: "union",
+      variants: parts.map((part) => single(part, checker, depth, seen))
+    };
+  }
+  const [only] = parts;
+  return only ? single(only, checker, depth, seen) : opaque();
+}, single = (type, checker, depth, seen) => {
+  const opaque = () => ({
+    kind: "opaque",
+    typeText: checker.typeToString(type)
+  });
+  if (hasFlag(type, import_typescript3.default.TypeFlags.BooleanLike))
+    return { kind: "boolean" };
+  if (hasFlag(type, import_typescript3.default.TypeFlags.NumberLike))
+    return { kind: "number" };
+  if (hasFlag(type, import_typescript3.default.TypeFlags.StringLike))
+    return { kind: "string" };
+  if (!hasFlag(type, import_typescript3.default.TypeFlags.Object))
+    return opaque();
+  if (type.getCallSignatures().length > 0)
+    return opaque();
+  const element = type.getNumberIndexType();
+  const stringIndex = type.getStringIndexType();
+  const props = checker.getPropertiesOfType(type);
+  if (element && props.length === 0) {
+    return {
+      item: toSchema(element, checker, depth + 1, seen),
+      kind: "array"
+    };
+  }
+  if (seen.has(type))
+    return opaque();
+  seen.add(type);
+  try {
+    if (props.length > 0) {
+      const fields = props.map((symbol) => ({
+        description: docOf(symbol, checker),
+        name: symbol.getName(),
+        optional: (symbol.flags & import_typescript3.default.SymbolFlags.Optional) !== 0,
+        schema: toSchema(typeOfSymbol(symbol, checker), checker, depth + 1, seen)
+      }));
+      return { fields, kind: "object" };
+    }
+    if (stringIndex) {
+      return {
+        kind: "record",
+        value: toSchema(stringIndex, checker, depth + 1, seen)
+      };
+    }
+  } finally {
+    seen.delete(type);
+  }
+  return opaque();
+}, introspectFrom = (cwd, specifier, typeName, options, exclude) => {
+  const virtualPath = resolve11(cwd, VIRTUAL_NAME);
+  const source = `import type { ${typeName} } from '${specifier}';
+declare const value: ${typeName};
+export { value };
+`;
+  const host = import_typescript3.default.createCompilerHost(options, true);
+  const getSourceFile = host.getSourceFile.bind(host);
+  host.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => fileName === virtualPath ? import_typescript3.default.createSourceFile(fileName, source, languageVersion, true) : getSourceFile(fileName, languageVersion, onError, shouldCreate);
+  const fileExists = host.fileExists.bind(host);
+  host.fileExists = (fileName) => fileName === virtualPath ? true : fileExists(fileName);
+  const readFile = host.readFile.bind(host);
+  host.readFile = (fileName) => fileName === virtualPath ? source : readFile(fileName);
+  const program = import_typescript3.default.createProgram([virtualPath], options, host);
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(virtualPath);
+  if (!sourceFile)
+    return [];
+  const nodes = [];
+  sourceFile.forEachChild((node) => {
+    if (!import_typescript3.default.isVariableStatement(node))
+      return;
+    const declaration = node.declarationList.declarations[0];
+    if (!declaration)
+      return;
+    const type = checker.getTypeAtLocation(declaration);
+    for (const symbol of checker.getPropertiesOfType(type)) {
+      const name = symbol.getName();
+      if (exclude.has(name) || name.startsWith("__"))
+        continue;
+      nodes.push({
+        description: docOf(symbol, checker),
+        name,
+        optional: (symbol.flags & import_typescript3.default.SymbolFlags.Optional) !== 0,
+        schema: toSchema(typeOfSymbol(symbol, checker), checker, 1, new Set)
+      });
+    }
+  });
+  return nodes.sort((left, right) => left.name.localeCompare(right.name));
+}, cache, introspectType = (cwd, typeName, exclude = new Set, specifier = "@absolutejs/absolute") => {
+  const cacheKey = `${specifier}:${typeName}`;
+  const cached = cache.get(cacheKey);
+  if (cached)
+    return cached;
+  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync14(resolve11(cwd, "types/index.ts"));
+  const signature = cacheSignature(cwd, typeName, local, specifier);
+  const fromDisk = readDiskCache(cwd, typeName, signature, specifier);
+  if (fromDisk) {
+    cache.set(cacheKey, fromDisk);
+    return fromDisk;
+  }
+  const options = compilerOptionsFor(cwd);
+  const specifiers = local ? [specifier, "./types"] : [specifier];
+  for (const candidate of specifiers) {
+    try {
+      const nodes = introspectFrom(cwd, candidate, typeName, options, exclude);
+      if (nodes.length > 0) {
+        cache.set(cacheKey, nodes);
+        writeDiskCache(cwd, typeName, signature, nodes, specifier);
+        return nodes;
+      }
+    } catch {}
+  }
+  cache.set(cacheKey, []);
+  return cache.get(cacheKey) ?? [];
+};
 var init_fromType = __esm(() => {
   import_typescript3 = __toESM(require_typescript(), 1);
   cache = new Map;
 });
 
 // src/cli/config/absolute/resolveAbsoluteConfig.ts
-import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
+import { resolve as resolve12 } from "path";
 var import_typescript4, CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath2 = (cwd, override) => {
   if (override) {
-    const resolved = resolve11(cwd, override);
-    return existsSync14(resolved) ? resolved : null;
+    const resolved = resolve12(cwd, override);
+    return existsSync15(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES2) {
-    const candidate = resolve11(cwd, name);
-    if (existsSync14(candidate))
+    const candidate = resolve12(cwd, name);
+    if (existsSync15(candidate))
       return candidate;
   }
   return null;
@@ -172278,7 +172492,7 @@ var import_typescript4, CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath2 = (c
   visit(sourceFile);
   return found;
 }, parseConfigObject = (configPath2) => {
-  const text = readFileSync16(configPath2, "utf-8");
+  const text = readFileSync17(configPath2, "utf-8");
   return { object: findConfigObject(parseSource(configPath2, text)), text };
 }, evalLiteral = (node) => {
   if (import_typescript4.default.isStringLiteralLike(node)) {
@@ -172490,8 +172704,8 @@ var init_frameworks = __esm(() => {
 });
 
 // src/cli/generate/context.ts
-import { dirname as dirname4, isAbsolute, join as join14, relative as relative3, resolve as resolve12 } from "path";
-var asString = (value) => typeof value === "string" ? value : undefined, isRecord3 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute(value) ? value : resolve12(cwd, value), resolveStylesDir = (cwd, config) => {
+import { dirname as dirname4, isAbsolute, join as join14, relative as relative3, resolve as resolve13 } from "path";
+var asString = (value) => typeof value === "string" ? value : undefined, isRecord3 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute(value) ? value : resolve13(cwd, value), resolveStylesDir = (cwd, config) => {
   const styles = config.stylesConfig;
   if (typeof styles === "string")
     return resolveDir(cwd, styles);
@@ -172500,10 +172714,10 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
     if (indexes)
       return resolveDir(cwd, indexes);
   }
-  return resolve12(cwd, "src/frontend/styles/indexes");
+  return resolve13(cwd, "src/frontend/styles/indexes");
 }, configuredFrameworks = (project) => FRAMEWORK_KEYS2.filter((key) => project.frameworkDirs[key] !== undefined), frontendRootFor = (project, framework) => {
   const dir = project.frameworkDirs[framework];
-  return dir ? dirname4(dir) : resolve12(project.cwd, "src/frontend");
+  return dir ? dirname4(dir) : resolve13(project.cwd, "src/frontend");
 }, resolveProject = async (cwd, configOverride) => {
   const loaded = await loadConfig(configOverride);
   const config = isRecord3(loaded) ? loaded : {};
@@ -172581,7 +172795,7 @@ var emptyOutcome = () => ({
 });
 
 // src/cli/generate/routeWiring.ts
-import { existsSync as existsSync15, readFileSync as readFileSync17, readdirSync as readdirSync4, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync18, readdirSync as readdirSync4, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname5, join as join15 } from "path";
 var import_typescript5, DEFAULT_SEPARATOR = `
 		`, BOUNDARY_USE, applyEdits = (text, edits) => {
@@ -172730,13 +172944,13 @@ ${newLines.join(`
   return lines.join(`
 `);
 }, hasChain = (path) => {
-  if (!existsSync15(path))
+  if (!existsSync16(path))
     return false;
-  const sourceFile = parse2(path, readFileSync17(path, "utf-8"));
+  const sourceFile = parse2(path, readFileSync18(path, "utf-8"));
   const found = findElysiaNew(sourceFile);
   return found !== null;
 }, firstChainFile = (pluginsDir) => {
-  if (!existsSync15(pluginsDir))
+  if (!existsSync16(pluginsDir))
     return null;
   for (const name of readdirSync4(pluginsDir)) {
     if (!name.endsWith(".ts"))
@@ -172781,7 +172995,7 @@ ${newLines.join(`
   };
   if (!hasChain(serverEntry))
     return fallback;
-  const text = readFileSync17(serverEntry, "utf-8");
+  const text = readFileSync18(serverEntry, "utf-8");
   const sourceFile = parse2(serverEntry, text);
   const newExpr = findElysiaNew(sourceFile);
   if (!newExpr)
@@ -172794,7 +173008,7 @@ ${newLines.join(`
     start: offset,
     text: `${separator}.use(${pluginName})`
   });
-  writeFileSync6(serverEntry, applyEdits(text, edits), "utf-8");
+  writeFileSync7(serverEntry, applyEdits(text, edits), "utf-8");
   return { kind: "edited", routingFile: serverEntry };
 }, wireRoute = (input) => {
   const routingFile = findRoutingFile(input.serverEntry);
@@ -172810,7 +173024,7 @@ ${newLines.join(`
 ${routeExpr}`
     };
   }
-  const text = readFileSync17(routingFile, "utf-8");
+  const text = readFileSync18(routingFile, "utf-8");
   const sourceFile = parse2(routingFile, text);
   const newExpr = findElysiaNew(sourceFile);
   if (!newExpr) {
@@ -172830,7 +173044,7 @@ ${routeExpr}`
     start: offset,
     text: `${separator}${routeExpr}`
   });
-  writeFileSync6(routingFile, applyEdits(text, edits), "utf-8");
+  writeFileSync7(routingFile, applyEdits(text, edits), "utf-8");
   return { kind: "edited", routingFile };
 };
 var init_routeWiring = __esm(() => {
@@ -172840,7 +173054,7 @@ var init_routeWiring = __esm(() => {
 });
 
 // src/cli/generate/generateApi.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname6, join as join16 } from "path";
 var apiPluginTemplate = (pluginName, base) => `import { Elysia } from 'elysia';
 
@@ -172855,12 +173069,12 @@ export const ${pluginName} = new Elysia()
   const outcome = { ...emptyOutcome(), route: base };
   const pluginsDir = join16(dirname6(project.serverEntry), "plugins");
   const fileAbs = join16(pluginsDir, `${pluginName}.ts`);
-  if (existsSync16(fileAbs)) {
+  if (existsSync17(fileAbs)) {
     outcome.notes.push(`${pluginName} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
-  mkdirSync7(pluginsDir, { recursive: true });
-  writeFileSync7(fileAbs, apiPluginTemplate(pluginName, base), "utf-8");
+  mkdirSync8(pluginsDir, { recursive: true });
+  writeFileSync8(fileAbs, apiPluginTemplate(pluginName, base), "utf-8");
   outcome.created.push(fileAbs);
   const specifier = toModuleSpecifier(dirname6(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
   const wired = wirePluginUse(project.serverEntry, pluginName, specifier);
@@ -172928,7 +173142,7 @@ var init_componentTemplates = __esm(() => {
 });
 
 // src/cli/generate/generateComponent.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname7, join as join17 } from "path";
 var generateComponent = (project, framework, rawName) => {
   const def = frameworks2[framework];
@@ -172941,12 +173155,12 @@ var generateComponent = (project, framework, rawName) => {
     return outcome;
   }
   const fileAbs = join17(frameworkDir, "components", def.componentFile({ kebab, pascal }));
-  if (existsSync17(fileAbs)) {
+  if (existsSync18(fileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
-  mkdirSync8(dirname7(fileAbs), { recursive: true });
-  writeFileSync8(fileAbs, componentTemplates[framework]({
+  mkdirSync9(dirname7(fileAbs), { recursive: true });
+  writeFileSync9(fileAbs, componentTemplates[framework]({
     kebab,
     pascal,
     title: toTitleCase(rawName)
@@ -172960,7 +173174,7 @@ var init_generateComponent = __esm(() => {
 });
 
 // src/cli/generate/cssStrategy.ts
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { join as join18 } from "path";
 var import_typescript6, CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
 	margin: 0 auto;
@@ -173008,7 +173222,7 @@ var import_typescript6, CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `
     return {
       assetKey: sharedKey,
       contents: DEFAULT_CSS,
-      create: !existsSync18(cssFileAbs2),
+      create: !existsSync19(cssFileAbs2),
       cssFileAbs: cssFileAbs2,
       shared: true
     };
@@ -173017,7 +173231,7 @@ var import_typescript6, CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `
   return {
     assetKey: `${pascal}${CSS_SUFFIX}`,
     contents: DEFAULT_CSS,
-    create: !existsSync18(cssFileAbs),
+    create: !existsSync19(cssFileAbs),
     cssFileAbs,
     shared: false
   };
@@ -173027,7 +173241,7 @@ var init_cssStrategy = __esm(() => {
 });
 
 // src/cli/generate/navData.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync19, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname8 } from "path";
 var import_typescript7, NAV_DATA_TEMPLATE = `type NavItem = {
 	href: string;
@@ -173066,9 +173280,9 @@ export const navData: NavItem[] = [];
   }
   return items;
 }, readNavItems = (navDataPath) => {
-  if (!existsSync19(navDataPath))
+  if (!existsSync20(navDataPath))
     return [];
-  const text = readFileSync18(navDataPath, "utf-8");
+  const text = readFileSync19(navDataPath, "utf-8");
   const sourceFile = import_typescript7.default.createSourceFile(navDataPath, text, import_typescript7.default.ScriptTarget.Latest, true);
   const array = findNavArray(sourceFile);
   return array ? parseNavItems(array) : [];
@@ -173103,22 +173317,22 @@ ${indentOf(text, array.getStart(sourceFile))}`;
 ${indent}${entry}`;
   return text.slice(0, insertAt) + insertion + text.slice(insertAt);
 }, upsertNavItem = (navDataPath, item) => {
-  const created = !existsSync19(navDataPath);
+  const created = !existsSync20(navDataPath);
   if (created) {
-    mkdirSync9(dirname8(navDataPath), { recursive: true });
-    writeFileSync9(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
+    mkdirSync10(dirname8(navDataPath), { recursive: true });
+    writeFileSync10(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
   }
   const existing = readNavItems(navDataPath);
   if (existing.some((candidate) => candidate.href === item.href)) {
     return { changed: created, created, items: existing };
   }
-  const text = readFileSync18(navDataPath, "utf-8");
+  const text = readFileSync19(navDataPath, "utf-8");
   const sourceFile = import_typescript7.default.createSourceFile(navDataPath, text, import_typescript7.default.ScriptTarget.Latest, true);
   const array = findNavArray(sourceFile);
   if (!array)
     return { changed: created, created, items: existing };
   const entry = `{ href: '${item.href}', label: '${item.label}' }`;
-  writeFileSync9(navDataPath, insertElement(text, array, sourceFile, entry), "utf-8");
+  writeFileSync10(navDataPath, insertElement(text, array, sourceFile, entry), "utf-8");
   return { changed: true, created, items: [...existing, item] };
 };
 var init_navData = __esm(() => {
@@ -173271,25 +173485,25 @@ var init_pageTemplates = __esm(() => {
 
 // src/cli/generate/generatePage.ts
 import {
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync19,
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync20,
   readdirSync as readdirSync5,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
 import { dirname as dirname9, join as join19, relative as relative4 } from "path";
 var writeNew = (path, contents) => {
-  mkdirSync10(dirname9(path), { recursive: true });
-  writeFileSync10(path, contents, "utf-8");
+  mkdirSync11(dirname9(path), { recursive: true });
+  writeFileSync11(path, contents, "utf-8");
 }, toHref = (fromDir, toFile) => {
   const rel = relative4(fromDir, toFile).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
-}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join19(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync20(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join19(pagesDir, name))), resyncPage = (file, items) => {
-  const html = readFileSync19(file, "utf-8");
+}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join19(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync21(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join19(pagesDir, name))), resyncPage = (file, items) => {
+  const html = readFileSync20(file, "utf-8");
   const synced = syncStaticNav(html, items);
   if (synced === null || synced === html)
     return false;
-  writeFileSync10(file, synced, "utf-8");
+  writeFileSync11(file, synced, "utf-8");
   return true;
 }, resyncStaticPages = (project, items, skipFile) => {
   const updated = [];
@@ -173313,12 +173527,12 @@ var writeNew = (path, contents) => {
     return outcome;
   }
   const pageFileAbs = join19(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
-  if (existsSync20(pageFileAbs)) {
+  if (existsSync21(pageFileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${pageFileAbs} \u2014 skipped.`);
     return outcome;
   }
   const routingFile = findRoutingFile(project.serverEntry);
-  const routingText = routingFile ? readFileSync19(routingFile, "utf-8") : "";
+  const routingText = routingFile ? readFileSync20(routingFile, "utf-8") : "";
   const css = planCss(routingText, project.stylesDir, pascal, kebab);
   const navDataPath = join19(sharedDirFor(project, framework), "navData.ts");
   const nav = upsertNavItem(navDataPath, { href: route, label: title });
@@ -173509,7 +173723,7 @@ ${indent.repeat(level)}}`;
 var init_serialize = () => {};
 
 // src/cli/config/absolute/editAbsoluteConfig.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync12 } from "fs";
 var import_typescript8, lineStartOffset = (text, position) => {
   let index = position;
   while (index > 0 && text[index - 1] !== `
@@ -173518,7 +173732,7 @@ var import_typescript8, lineStartOffset = (text, position) => {
   return index;
 }, indentBefore2 = (text, position) => text.slice(lineStartOffset(text, position), position), findProperty = (object, name) => object.properties.find((property) => import_typescript8.default.isPropertyAssignment(property) && (import_typescript8.default.isIdentifier(property.name) || import_typescript8.default.isStringLiteral(property.name)) && property.name.text === name), applyAbsoluteConfigEdit = (configPath2, request) => {
   try {
-    const text = readFileSync20(configPath2, "utf-8");
+    const text = readFileSync21(configPath2, "utf-8");
     const sourceFile = import_typescript8.default.createSourceFile(configPath2, text, import_typescript8.default.ScriptTarget.Latest, true);
     const object = findConfigObject(sourceFile);
     if (!object) {
@@ -173538,14 +173752,14 @@ var import_typescript8, lineStartOffset = (text, position) => {
       if (text[end] === `
 `)
         end += 1;
-      writeFileSync11(configPath2, text.slice(0, start2) + text.slice(end), "utf-8");
+      writeFileSync12(configPath2, text.slice(0, start2) + text.slice(end), "utf-8");
       return { message: `Removed ${request.name}`, ok: true };
     }
     const valueText = serializeValue(request.value);
     if (existing) {
       const start2 = existing.initializer.getStart(sourceFile);
       const end = existing.initializer.getEnd();
-      writeFileSync11(configPath2, text.slice(0, start2) + valueText + text.slice(end), "utf-8");
+      writeFileSync12(configPath2, text.slice(0, start2) + valueText + text.slice(end), "utf-8");
       return { message: `Updated ${request.name}`, ok: true };
     }
     const { properties } = object;
@@ -173565,14 +173779,14 @@ var import_typescript8, lineStartOffset = (text, position) => {
         at += 1;
       const insertion = `${hasComma ? "" : ","}
 ${indent}${entry}`;
-      writeFileSync11(configPath2, text.slice(0, at) + insertion + text.slice(at), "utf-8");
+      writeFileSync12(configPath2, text.slice(0, at) + insertion + text.slice(at), "utf-8");
     } else {
       const at = object.getStart(sourceFile) + 1;
       const indent = `${indentBefore2(text, object.getStart(sourceFile))}	`;
       const insertion = `
 ${indent}${entry}
 ${indentBefore2(text, object.getStart(sourceFile))}`;
-      writeFileSync11(configPath2, text.slice(0, at) + insertion + text.slice(at), "utf-8");
+      writeFileSync12(configPath2, text.slice(0, at) + insertion + text.slice(at), "utf-8");
     }
     return { message: `Updated ${request.name}`, ok: true };
   } catch (error) {
@@ -173702,14 +173916,14 @@ var init_catalog = __esm(() => {
 });
 
 // src/cli/integrations/addPlugin.ts
-import { existsSync as existsSync21, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync22 } from "fs";
 import { join as join20 } from "path";
 var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readPackageJson = (cwd) => {
   const path = join20(cwd, "package.json");
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync21(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync22(path, "utf-8"));
     return isRecord5(parsed) ? parsed : null;
   } catch {
     return null;
@@ -173805,14 +174019,707 @@ var init_addPlugin = __esm(() => {
   init_catalog();
 });
 
+// src/cli/config/auth/authScaffolds.ts
+var TODO = (message) => `async () => { throw new Error("TODO: ${message}"); }`, AUTH_SCAFFOLDS, isScaffoldableFeature = (id) => (id in AUTH_SCAFFOLDS);
+var init_authScaffolds = __esm(() => {
+  AUTH_SCAFFOLDS = {
+    audit: {
+      configKey: "audit",
+      exportName: "auditConfig",
+      fields: [
+        { name: "auditStore", value: "createInMemoryAuditSink()" },
+        { name: "getUserId", value: "(user) => user.sub" }
+      ],
+      generic: true,
+      imports: ["createInMemoryAuditSink"],
+      note: "Swap the in-memory sink for a durable store (append-only table); add `onAuditEvent` to forward to a SIEM.",
+      packages: [],
+      typeName: "AuditConfig"
+    },
+    authorization: {
+      configKey: "authorization",
+      exportName: "authorizationConfig",
+      fields: [
+        {
+          name: "hasPermission",
+          value: '({ user, permission, organizationId }) => { throw new Error("TODO: decide if user has permission"); }'
+        }
+      ],
+      generic: true,
+      imports: [],
+      note: "Pair with `createMembershipPermissionResolver` (from @absolutejs/auth) when you also use organizations + roles.",
+      packages: [],
+      typeName: "AuthorizationConfig"
+    },
+    compliance: {
+      configKey: "compliance",
+      exportName: "complianceConfig",
+      fields: [
+        { name: "deleteUserData", value: TODO("erase or anonymize the user in your stores") },
+        { name: "exportUserData", value: "async ({ user }) => ({})" },
+        { name: "getUserId", value: "(user) => user.sub" }
+      ],
+      generic: true,
+      imports: [],
+      note: "exportUserData must return everything you hold on the user; getUserId lets the route revoke sibling sessions.",
+      packages: [],
+      typeName: "ComplianceConfig"
+    },
+    credentials: {
+      configKey: "credentials",
+      exportName: "credentialsConfig",
+      fields: [
+        { name: "credentialStore", value: "createInMemoryCredentialStore()" },
+        { name: "getUserByEmail", value: TODO("look up a user by email") },
+        { name: "onCreateCredentialUser", value: TODO("create and return the user for identity.email") },
+        { name: "onSendEmail", value: TODO("send the verification / reset email containing message.token") },
+        { name: "requireEmailVerification", value: "false" }
+      ],
+      generic: true,
+      imports: ["createInMemoryCredentialStore"],
+      note: "Swap the in-memory credential store for a real one (it holds password hashes + tokens).",
+      packages: [],
+      typeName: "CredentialsConfig"
+    },
+    lockout: {
+      configKey: "lockout",
+      exportName: "lockoutConfig",
+      fields: [
+        { name: "lockoutStore", value: "createInMemoryLockoutStore()" },
+        { name: "maxAttempts", value: "5" },
+        { name: "windowMs", value: "15 * 60 * 1000" }
+      ],
+      generic: false,
+      imports: ["createInMemoryLockoutStore"],
+      note: "Throttles the credential login route; pair with the `credentials` block.",
+      packages: [],
+      typeName: "LockoutConfig"
+    },
+    mfa: {
+      configKey: "mfa",
+      exportName: "mfaConfig",
+      fields: [
+        { name: "mfaStore", value: "createInMemoryMfaStore()" },
+        { name: "getUserId", value: "(user) => user.sub" },
+        { name: "getChallengeUser", value: TODO("resolve the parked challenge identity to a user") },
+        { name: "issuer", value: "'YourApp'" }
+      ],
+      generic: true,
+      imports: ["createInMemoryMfaStore"],
+      note: "Set `encryptionKey` (base64url) to encrypt the TOTP secret at rest in any real deployment.",
+      packages: [],
+      typeName: "MfaConfig"
+    },
+    organizations: {
+      configKey: "organizations",
+      exportName: "organizationsConfig",
+      fields: [
+        { name: "getUserId", value: "(user) => user.sub" },
+        { name: "organizationStore", value: "createInMemoryOrganizationStore()" }
+      ],
+      generic: true,
+      imports: ["createInMemoryOrganizationStore"],
+      note: "Add `onSendInvitation` to deliver invite emails; otherwise the plaintext token is returned from the invite route.",
+      packages: [],
+      typeName: "OrganizationsConfig"
+    },
+    passwordless: {
+      configKey: "passwordless",
+      exportName: "passwordlessConfig",
+      fields: [
+        { name: "passwordlessTokenStore", value: "createInMemoryPasswordlessTokenStore()" },
+        { name: "getUserByEmail", value: TODO("look up a user by email") },
+        { name: "onSendMagicLink", value: TODO("email the magic link containing message.token") }
+      ],
+      generic: true,
+      imports: ["createInMemoryPasswordlessTokenStore"],
+      note: "The magic-link flow mounts when `onSendMagicLink` is set; add `onSendOtp` to also mount the email/SMS OTP flow.",
+      packages: [],
+      typeName: "PasswordlessConfig"
+    },
+    portal: {
+      configKey: "portal",
+      exportName: "portalConfig",
+      fields: [
+        { name: "setupSessionStore", value: "createInMemorySetupSessionStore()" }
+      ],
+      generic: false,
+      imports: ["createInMemorySetupSessionStore"],
+      note: "Pass the same `ssoConnectionStore` / `scimTokenStore` your sso / scim blocks use so portal edits take effect live.",
+      packages: [],
+      typeName: "PortalConfig"
+    },
+    roles: {
+      configKey: "roles",
+      exportName: "rolesConfig",
+      fields: [
+        { name: "getUserId", value: "(user) => user.sub" },
+        { name: "organizationStore", value: "createInMemoryOrganizationStore()" },
+        { name: "roleStore", value: "createInMemoryRoleStore()" }
+      ],
+      generic: true,
+      imports: ["createInMemoryOrganizationStore", "createInMemoryRoleStore"],
+      note: "Builds on the `organizations` block \u2014 reuse the same organizationStore instance there.",
+      packages: [],
+      typeName: "RolesConfig"
+    },
+    scim: {
+      configKey: "scim",
+      exportName: "scimConfig",
+      fields: [
+        { name: "scimTokenStore", value: "createInMemoryScimTokenStore()" },
+        { name: "getScimUser", value: TODO("return the SCIM user for { id, organizationId }") },
+        { name: "listScimUsers", value: "async () => []" },
+        { name: "onScimUserCreate", value: TODO("create and return the SCIM user") },
+        { name: "onScimUserDeactivate", value: TODO("deprovision the user (hard-delete or deactivate)") },
+        { name: "onScimUserReplace", value: TODO("replace and return the SCIM user (undefined if unknown)") }
+      ],
+      generic: false,
+      imports: ["createInMemoryScimTokenStore"],
+      note: "Group hooks are optional (the /Groups routes 501 without them). Mint per-org tokens with `createScimToken`.",
+      packages: [],
+      typeName: "ScimConfig"
+    },
+    sessions: {
+      configKey: "sessions",
+      exportName: "sessionsConfig",
+      fields: [{ name: "getUserId", value: "(user) => user.sub" }],
+      generic: true,
+      imports: [],
+      note: "Requires an `authSessionStore` (top-level) that can enumerate a user\u2019s sessions.",
+      packages: [],
+      typeName: "SessionsConfig"
+    },
+    sso: {
+      configKey: "sso",
+      exportName: "ssoConfig",
+      fields: [
+        { name: "ssoConnectionStore", value: "createInMemorySsoConnectionStore()" },
+        { name: "getSsoUser", value: TODO("map the verified SSO identity to your user (create on first sign-in)") }
+      ],
+      generic: true,
+      imports: ["createInMemorySsoConnectionStore"],
+      note: "OIDC works out of the box; add a `samlAdapter` (wrapping e.g. @node-saml/node-saml) to also mount SAML.",
+      packages: [],
+      typeName: "SSOConfig"
+    },
+    webauthn: {
+      configKey: "webauthn",
+      exportName: "webauthnConfig",
+      fields: [
+        { name: "credentialStore", value: "createInMemoryWebAuthnCredentialStore()" },
+        { name: "getUserId", value: "(user) => user.sub" },
+        { name: "getWebAuthnUser", value: TODO("resolve a stored credential userId back to a user") },
+        { name: "origin", value: "'http://localhost:3000'" },
+        { name: "rpId", value: "'localhost'" },
+        { name: "rpName", value: "'YourApp'" },
+        {
+          name: "webauthnAdapter",
+          value: "{} as unknown as WebAuthnAdapter"
+        }
+      ],
+      generic: true,
+      imports: ["createInMemoryWebAuthnCredentialStore", "type WebAuthnAdapter"],
+      note: "Provide a real `webauthnAdapter` wrapping a vetted library (e.g. @simplewebauthn/server); set origin/rpId/rpName for your domain.",
+      packages: [],
+      typeName: "WebAuthnConfig"
+    },
+    webhooks: {
+      configKey: "webhooks",
+      exportName: "webhooksConfig",
+      fields: [{ name: "endpoints", value: "[]" }],
+      generic: false,
+      imports: [],
+      note: "Add endpoints as { url, secret } \u2014 each event is HMAC-signed (Standard Webhooks) with that secret.",
+      packages: [],
+      typeName: "WebhooksConfig"
+    }
+  };
+});
+
+// src/cli/config/auth/authCatalog.ts
+var AUTH_FEATURES;
+var init_authCatalog = __esm(() => {
+  AUTH_FEATURES = [
+    {
+      blurb: "Email/password \u2014 register, verify-email, login, reset-password \u2014 minting the same session as OAuth.",
+      configKey: "credentials",
+      id: "credentials",
+      kind: "routes",
+      label: "Credentials"
+    },
+    {
+      blurb: "Magic links + email/SMS one-time codes; each verify route mints the same session as every other flow.",
+      configKey: "passwordless",
+      id: "passwordless",
+      kind: "routes",
+      label: "Passwordless"
+    },
+    {
+      blurb: "TOTP + backup codes; auto-wires the login MFA gate over credentials and mounts enroll/challenge routes.",
+      configKey: "mfa",
+      id: "mfa",
+      kind: "routes",
+      label: "MFA"
+    },
+    {
+      blurb: "Passkeys (WebAuthn): registration ceremony for the caller + passwordless authentication ceremony.",
+      configKey: "webauthn",
+      id: "webauthn",
+      kind: "routes",
+      label: "WebAuthn / passkeys"
+    },
+    {
+      blurb: "Per-organization enterprise SSO (OIDC + SAML); id_tokens verified in-house against the issuer JWKS.",
+      configKey: "sso",
+      id: "sso",
+      kind: "routes",
+      label: "Enterprise SSO"
+    },
+    {
+      blurb: "SCIM 2.0 directory provisioning (Okta / Azure AD) with per-org bearer-token auth.",
+      configKey: "scim",
+      id: "scim",
+      kind: "routes",
+      label: "SCIM provisioning"
+    },
+    {
+      blurb: "First-class multi-tenancy: orgs, memberships, invitations, and org-scoped roles.",
+      configKey: "organizations",
+      id: "organizations",
+      kind: "routes",
+      label: "Organizations"
+    },
+    {
+      blurb: "Org-scoped roles & permissions \u2014 list an org\u2019s roles and set a member\u2019s roles.",
+      configKey: "roles",
+      id: "roles",
+      kind: "routes",
+      label: "Roles & permissions"
+    },
+    {
+      blurb: "Headless admin-portal setup-link endpoints so a customer\u2019s IT admin self-serves their SSO/SCIM.",
+      configKey: "portal",
+      id: "portal",
+      kind: "routes",
+      label: "Admin portal"
+    },
+    {
+      blurb: "Self-service session management: list the caller\u2019s active sessions and remote-revoke by id.",
+      configKey: "sessions",
+      id: "sessions",
+      kind: "routes",
+      label: "Session management"
+    },
+    {
+      blurb: "GDPR/CCPA self-service: data export (right to access) + erasure (right to be forgotten).",
+      configKey: "compliance",
+      id: "compliance",
+      kind: "routes",
+      label: "Compliance"
+    },
+    {
+      blurb: "Built-in HTMX fragment routes (login, identities, connectors, account, signout, delete-account).",
+      configKey: "htmx",
+      id: "htmx",
+      kind: "routes",
+      label: "HTMX fragments"
+    },
+    {
+      blurb: "Append-only structured audit events (register, login, mfa_*, logout\u2026) to your store + hook. SOC 2 prerequisite.",
+      configKey: "audit",
+      id: "audit",
+      kind: "behavior",
+      label: "Audit log"
+    },
+    {
+      blurb: "HMAC-signed outbound webhooks (Standard Webhooks) for every emitted auth event.",
+      configKey: "webhooks",
+      id: "webhooks",
+      kind: "behavior",
+      label: "Webhooks"
+    },
+    {
+      blurb: "RBAC/ABAC: adds a protectPermission(check, handler) derive that delegates to your hasPermission hook.",
+      configKey: "authorization",
+      id: "authorization",
+      kind: "behavior",
+      label: "Authorization"
+    },
+    {
+      blurb: "Per-identity attempt throttling + progressive account lockout on the credential login route.",
+      configKey: "lockout",
+      id: "lockout",
+      kind: "behavior",
+      label: "Lockout"
+    }
+  ];
+});
+
+// src/cli/config/auth/resolveAuthSettings.ts
+import { existsSync as existsSync23, readFileSync as readFileSync23 } from "fs";
+import { resolve as resolve14 } from "path";
+var import_typescript9, AUTH_PACKAGE = "@absolutejs/auth", CONFIG_CANDIDATES3, findAuthSettingsPath = (cwd, override) => {
+  if (override) {
+    const resolved = resolve14(cwd, override);
+    return existsSync23(resolved) ? resolved : null;
+  }
+  for (const name of CONFIG_CANDIDATES3) {
+    const candidate = resolve14(cwd, name);
+    if (existsSync23(candidate))
+      return candidate;
+  }
+  return null;
+}, parseSource2 = (configPath2, text) => import_typescript9.default.createSourceFile(configPath2, text, import_typescript9.default.ScriptTarget.Latest, true), findAuthSettingsObject = (sourceFile) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    const [firstArgument] = import_typescript9.default.isCallExpression(node) ? node.arguments : [];
+    if (import_typescript9.default.isCallExpression(node) && import_typescript9.default.isIdentifier(node.expression) && node.expression.text === "defineAuthSettings" && firstArgument && import_typescript9.default.isObjectLiteralExpression(firstArgument)) {
+      found = firstArgument;
+      return;
+    }
+    if (import_typescript9.default.isExportAssignment(node) && import_typescript9.default.isObjectLiteralExpression(node.expression)) {
+      found = node.expression;
+      return;
+    }
+    import_typescript9.default.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}, parseAuthSettingsObject = (configPath2) => {
+  const text = readFileSync23(configPath2, "utf-8");
+  return {
+    object: findAuthSettingsObject(parseSource2(configPath2, text)),
+    text
+  };
+}, evalLiteral2 = (node) => {
+  if (import_typescript9.default.isStringLiteralLike(node))
+    return { opaque: false, value: node.text };
+  if (node.kind === import_typescript9.default.SyntaxKind.TrueKeyword) {
+    return { opaque: false, value: true };
+  }
+  if (node.kind === import_typescript9.default.SyntaxKind.FalseKeyword) {
+    return { opaque: false, value: false };
+  }
+  if (node.kind === import_typescript9.default.SyntaxKind.NullKeyword) {
+    return { opaque: false, value: null };
+  }
+  if (import_typescript9.default.isNumericLiteral(node)) {
+    return { opaque: false, value: Number(node.text) };
+  }
+  if (import_typescript9.default.isPrefixUnaryExpression(node) && node.operator === import_typescript9.default.SyntaxKind.MinusToken && import_typescript9.default.isNumericLiteral(node.operand)) {
+    return { opaque: false, value: -Number(node.operand.text) };
+  }
+  if (import_typescript9.default.isArrayLiteralExpression(node)) {
+    const items = [];
+    for (const element of node.elements) {
+      const result = evalLiteral2(element);
+      if (result.opaque)
+        return { opaque: true, value: undefined };
+      items.push(result.value);
+    }
+    return { opaque: false, value: items };
+  }
+  return { opaque: true, value: undefined };
+}, readCurrent2 = (configPath2) => {
+  const current = {};
+  const opaqueKeys = [];
+  const { object } = parseAuthSettingsObject(configPath2);
+  if (!object)
+    return { current, opaqueKeys };
+  for (const property of object.properties) {
+    if (!import_typescript9.default.isPropertyAssignment(property) || !(import_typescript9.default.isIdentifier(property.name) || import_typescript9.default.isStringLiteral(property.name))) {
+      continue;
+    }
+    const name = property.name.text;
+    const result = evalLiteral2(property.initializer);
+    if (result.opaque)
+      opaqueKeys.push(name);
+    else
+      current[name] = result.value;
+  }
+  return { current, opaqueKeys };
+}, resolveAuthSettingsState = (cwd, override) => {
+  const configPath2 = findAuthSettingsPath(cwd, override);
+  const fields = introspectType(cwd, "AuthSettings", new Set, AUTH_PACKAGE);
+  const { current, opaqueKeys } = configPath2 ? readCurrent2(configPath2) : { current: {}, opaqueKeys: [] };
+  return {
+    available: fields.length > 0,
+    configPath: configPath2,
+    current,
+    fields,
+    opaqueKeys
+  };
+};
+var init_resolveAuthSettings = __esm(() => {
+  init_fromType();
+  import_typescript9 = __toESM(require_typescript(), 1);
+  CONFIG_CANDIDATES3 = [
+    "auth.config.ts",
+    "auth.config.js",
+    "auth.config.mjs"
+  ];
+});
+
+// src/cli/config/auth/resolveAuthState.ts
+import { existsSync as existsSync24, readdirSync as readdirSync6, readFileSync as readFileSync24 } from "fs";
+import { join as join21, relative as relative6, resolve as resolve15 } from "path";
+var import_typescript10, AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutejs/absolute-auth", NPM_URL = "https://www.npmjs.com/package/@absolutejs/auth", SKIP_DIRS, MAX_FILES = 4000, SETUP_EXPORTS, isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
+  if (!existsSync24(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync24(path, "utf-8"));
+    return isRecord6(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}, stringField = (record, key) => {
+  const value = record?.[key];
+  return typeof value === "string" ? value : null;
+}, declaredVersionFor = (cwd) => {
+  const pkg = readJson(join21(cwd, "package.json"));
+  if (!pkg)
+    return null;
+  for (const field of ["dependencies", "devDependencies"]) {
+    const group = pkg[field];
+    if (!isRecord6(group))
+      continue;
+    const version2 = group[AUTH_PACKAGE2];
+    if (typeof version2 === "string")
+      return version2;
+  }
+  return null;
+}, installedVersionFor = (cwd) => stringField(readJson(join21(cwd, "node_modules", AUTH_PACKAGE2, "package.json")), "version"), SOURCE_FILE, safeReaddir = (dir) => {
+  try {
+    return readdirSync6(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}, sortEntry = (dir, entry, found, dirs) => {
+  const full = join21(dir, entry.name);
+  if (entry.isDirectory()) {
+    if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
+      return;
+    dirs.push(full);
+    return;
+  }
+  if (SOURCE_FILE.test(entry.name))
+    found.push(full);
+}, collectFrom = (dir, found, stack) => {
+  for (const entry of safeReaddir(dir))
+    sortEntry(dir, entry, found, stack);
+}, candidateFiles = (root) => {
+  const found = [];
+  const stack = [root];
+  while (stack.length > 0 && found.length < MAX_FILES) {
+    const dir = stack.pop();
+    if (dir === undefined)
+      break;
+    collectFrom(dir, found, stack);
+  }
+  return found;
+}, isAuthPackageImport = (statement) => import_typescript10.default.isImportDeclaration(statement) && import_typescript10.default.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === AUTH_PACKAGE2, addAuthNames = (statement, names) => {
+  const bindings = statement.importClause?.namedBindings;
+  if (!bindings || !import_typescript10.default.isNamedImports(bindings))
+    return;
+  for (const element of bindings.elements) {
+    const imported = element.propertyName?.text ?? element.name.text;
+    if (!SETUP_EXPORTS.has(imported))
+      continue;
+    names.add(element.name.text);
+  }
+}, authBindings = (sourceFile) => {
+  const names = new Set;
+  for (const statement of sourceFile.statements) {
+    if (isAuthPackageImport(statement))
+      addAuthNames(statement, names);
+  }
+  return names;
+}, isAuthCall = (node, bindings) => import_typescript10.default.isIdentifier(node.expression) && bindings.has(node.expression.text), providerCountOf = (property) => {
+  if (!import_typescript10.default.isPropertyAssignment(property) || !import_typescript10.default.isObjectLiteralExpression(property.initializer)) {
+    return null;
+  }
+  return property.initializer.properties.length;
+}, readConfigKeys = (object) => {
+  const keys = new Set;
+  let providerCount = null;
+  const usesSpread = object.properties.some((property) => import_typescript10.default.isSpreadAssignment(property));
+  for (const property of object.properties) {
+    const { name } = property;
+    if (name === undefined || !import_typescript10.default.isIdentifier(name))
+      continue;
+    keys.add(name.text);
+    if (name.text !== "providersConfiguration")
+      continue;
+    providerCount = providerCountOf(property);
+  }
+  return { keys, providerCount, usesSpread };
+}, matchFromCall = (node) => {
+  const [arg] = node.arguments;
+  if (arg && import_typescript10.default.isObjectLiteralExpression(arg))
+    return readConfigKeys(arg);
+  return { keys: new Set, providerCount: null, usesSpread: true };
+}, readFileOrNull = (path) => {
+  try {
+    return readFileSync24(path, "utf-8");
+  } catch {
+    return null;
+  }
+}, findSetupInFile = (path) => {
+  const text = readFileOrNull(path);
+  if (text === null || !text.includes(AUTH_PACKAGE2))
+    return null;
+  const sourceFile = import_typescript10.default.createSourceFile(path, text, import_typescript10.default.ScriptTarget.Latest, true);
+  const bindings = authBindings(sourceFile);
+  if (bindings.size === 0)
+    return null;
+  let match = null;
+  const visit = (node) => {
+    if (match)
+      return;
+    if (import_typescript10.default.isCallExpression(node) && isAuthCall(node, bindings)) {
+      match = matchFromCall(node);
+      return;
+    }
+    import_typescript10.default.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return match;
+}, featureStatuses = (keys) => AUTH_FEATURES.map((feature) => ({
+  blurb: feature.blurb,
+  configKey: feature.configKey,
+  configured: keys.has(feature.configKey),
+  id: feature.id,
+  kind: feature.kind,
+  label: feature.label,
+  scaffoldable: isScaffoldableFeature(feature.id)
+})), resolveAuthState = (cwd) => {
+  const installedVersion = installedVersionFor(cwd);
+  const root = existsSync24(join21(cwd, "src")) ? join21(cwd, "src") : cwd;
+  let match = null;
+  let setupPath = null;
+  for (const file of candidateFiles(root)) {
+    const found = findSetupInFile(file);
+    if (found === null)
+      continue;
+    match = found;
+    setupPath = relative6(cwd, resolve15(file));
+    break;
+  }
+  const keys = match?.keys ?? new Set;
+  const state = {
+    declaredVersion: declaredVersionFor(cwd),
+    features: featureStatuses(keys),
+    installed: installedVersion !== null,
+    installedVersion,
+    introspected: match !== null,
+    npmUrl: NPM_URL,
+    providerCount: match?.providerCount ?? null,
+    repoUrl: REPO_URL,
+    settings: resolveAuthSettingsState(cwd),
+    setupPath,
+    usesSpread: match?.usesSpread ?? false
+  };
+  return state;
+};
+var init_resolveAuthState = __esm(() => {
+  init_authCatalog();
+  init_authScaffolds();
+  init_resolveAuthSettings();
+  import_typescript10 = __toESM(require_typescript(), 1);
+  SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "build",
+    "dist",
+    ".absolutejs",
+    "coverage",
+    ".next"
+  ]);
+  SETUP_EXPORTS = new Set(["auth", "absoluteAuth"]);
+  SOURCE_FILE = /\.(ts|tsx|mts|cts|js|mjs)$/;
+});
+
+// src/cli/config/auth/scaffoldAuthFeature.ts
+import { existsSync as existsSync25, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname10, join as join22, relative as relative7, resolve as resolve16 } from "path";
+var renderScaffold = (scaffold) => {
+  const importNames = [...scaffold.imports, `type ${scaffold.typeName}`];
+  const importLine = `import { ${importNames.join(", ")} } from '@absolutejs/auth';`;
+  const userType = scaffold.generic ? `
+// TODO: replace with your app's user type (the one you pass to auth<User>()).
+type User = {
+	sub: string;
+};
+` : "";
+  const note = scaffold.note ? `
+// ${scaffold.note}
+` : `
+`;
+  const generic = scaffold.generic ? "<User>" : "";
+  const body = scaffold.fields.map((field) => `	${field.name}: ${field.value}`).join(`,
+`);
+  return `${importLine}
+${userType}${note}export const ${scaffold.exportName}: ${scaffold.typeName}${generic} = {
+${body}
+};
+`;
+}, targetDir = (cwd) => {
+  const { setupPath } = resolveAuthState(cwd);
+  if (setupPath)
+    return dirname10(resolve16(cwd, setupPath));
+  const src = join22(cwd, "src");
+  return existsSync25(src) ? src : cwd;
+}, spreadFor = (scaffold) => `import { ${scaffold.exportName} } from './${scaffold.exportName}';
+// add to your auth() call:
+${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
+  created: null,
+  installed: false,
+  message,
+  ok: false,
+  spreadSnippet: null
+}), scaffoldAuthFeature = (cwd, id, options = {}) => {
+  const scaffold = AUTH_SCAFFOLDS[id];
+  if (!scaffold)
+    return failure2(`Unknown auth feature "${id}".`);
+  const filePath = join22(targetDir(cwd), `${scaffold.exportName}.ts`);
+  const relPath = relative7(cwd, filePath);
+  if (existsSync25(filePath)) {
+    return {
+      created: null,
+      installed: false,
+      message: `${relPath} already exists \u2014 left untouched.`,
+      ok: true,
+      spreadSnippet: spreadFor(scaffold)
+    };
+  }
+  const install = options.install ?? true;
+  const installOk = install && scaffold.packages.length > 0 ? installPackages(cwd, scaffold.packages) : true;
+  writeFileSync13(filePath, renderScaffold(scaffold));
+  return {
+    created: relPath,
+    installed: installOk,
+    message: `Scaffolded ${relPath}.`,
+    ok: true,
+    spreadSnippet: spreadFor(scaffold)
+  };
+};
+var init_scaffoldAuthFeature = __esm(() => {
+  init_dependencies();
+  init_authScaffolds();
+  init_resolveAuthState();
+});
+
 // src/cli/htmx/install.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync12 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync12, readFileSync as readFileSync25, writeFileSync as writeFileSync14 } from "fs";
+import { join as join23 } from "path";
 var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
-  join21(import.meta.dir, "htmx.min.js"),
-  join21(import.meta.dir, "htmx", "htmx.min.js"),
-  join21(import.meta.dir, "..", "htmx", "htmx.min.js")
-].find((path) => existsSync22(path)) ?? null, detectHtmxVersion = (content) => {
+  join23(import.meta.dir, "htmx.min.js"),
+  join23(import.meta.dir, "htmx", "htmx.min.js"),
+  join23(import.meta.dir, "..", "htmx", "htmx.min.js")
+].find((path) => existsSync26(path)) ?? null, detectHtmxVersion = (content) => {
   const match = content.match(/version:"([0-9.]+)"/);
   return match ? match[1] : null;
 }, fetchHtmx = async (version2) => {
@@ -173823,17 +174730,17 @@ var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   }
   return response.text();
 }, installedHtmxVersion = (htmxDir) => {
-  const file = join21(htmxDir, "htmx.min.js");
-  if (!existsSync22(file))
+  const file = join23(htmxDir, "htmx.min.js");
+  if (!existsSync26(file))
     return null;
-  return detectHtmxVersion(readFileSync22(file, "utf-8"));
+  return detectHtmxVersion(readFileSync25(file, "utf-8"));
 }, readVendoredHtmx = () => {
   const file = vendoredHtmxFile();
-  return file ? readFileSync22(file, "utf-8") : null;
+  return file ? readFileSync25(file, "utf-8") : null;
 }, writeHtmx = (htmxDir, content) => {
-  mkdirSync11(htmxDir, { recursive: true });
-  const file = join21(htmxDir, "htmx.min.js");
-  writeFileSync12(file, content, "utf-8");
+  mkdirSync12(htmxDir, { recursive: true });
+  const file = join23(htmxDir, "htmx.min.js");
+  writeFileSync14(file, content, "utf-8");
   return file;
 };
 var init_install = () => {};
@@ -173843,7 +174750,7 @@ var exports_add = {};
 __export(exports_add, {
   runAdd: () => runAdd
 });
-import { dirname as dirname10, join as join22, relative as relative6 } from "path";
+import { dirname as dirname11, join as join24, relative as relative8 } from "path";
 var write2 = (text) => process.stdout.write(`${text}
 `), fail2 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -173854,11 +174761,11 @@ var write2 = (text) => process.stdout.write(`${text}
     return;
   write2(`  ${colors.dim}${label}${colors.reset}`);
   for (const path of paths)
-    write2(`    ${relative6(cwd, path)}`);
+    write2(`    ${relative8(cwd, path)}`);
 }, frontendRoot = (project, cwd) => {
   const [firstKey] = configuredFrameworks(project);
   const firstDir = firstKey ? project.frameworkDirs[firstKey] : undefined;
-  return firstDir ? dirname10(firstDir) : join22(cwd, "src", "frontend");
+  return firstDir ? dirname11(firstDir) : join24(cwd, "src", "frontend");
 }, addIntegrationCli = (id, install) => {
   const result = addIntegration(process.cwd(), id, { install });
   if (!result.ok) {
@@ -173875,9 +174782,29 @@ var write2 = (text) => process.stdout.write(`${text}
   }
   write2(`
   ${colors.dim}Next${colors.reset}  ${result.wired ? "run `absolute dev`" : "wire it in, then run `absolute dev`"}`);
+}, addAuthFeatureCli = (id, install) => {
+  const result = scaffoldAuthFeature(process.cwd(), id, { install });
+  if (!result.ok) {
+    fail2(result.message);
+    return;
+  }
+  write2(`${colors.green}\u2713${colors.reset} ${result.message}`);
+  if (result.spreadSnippet) {
+    write2(`
+  ${colors.dim}Wire it in${colors.reset}:`);
+    for (const line of result.spreadSnippet.split(`
+`))
+      write2(`    ${line}`);
+  }
+  write2(`
+  ${colors.dim}Next${colors.reset}  fill the TODO stubs, run \`absolute prettier --write\`, then \`absolute dev\``);
 }, runAdd = async (args) => {
   const [framework] = args.filter((arg) => !arg.startsWith("--"));
   const noInstall = args.includes("--no-install");
+  if (framework?.startsWith("auth:")) {
+    addAuthFeatureCli(framework.slice("auth:".length), !noInstall);
+    return;
+  }
   if (framework && isIntegrationId(framework)) {
     addIntegrationCli(framework, !noInstall);
     return;
@@ -173902,8 +174829,8 @@ var write2 = (text) => process.stdout.write(`${text}
     write2(`${colors.yellow}!${colors.reset} ${frameworks2[framework].label} is already configured \u2014 nothing to do.`);
     return;
   }
-  const dirAbs = join22(frontendRoot(project, cwd), framework);
-  const dirRel = `./${relative6(cwd, dirAbs).split("\\").join("/")}`;
+  const dirAbs = join24(frontendRoot(project, cwd), framework);
+  const dirRel = `./${relative8(cwd, dirAbs).split("\\").join("/")}`;
   let depNote = "Skipped dependency install (--no-install).";
   if (!noInstall) {
     write2(`${colors.dim}Installing ${frameworks2[framework].label} dependencies\u2026${colors.reset}`);
@@ -173962,6 +174889,7 @@ var init_add = __esm(() => {
   init_dependencies();
   init_addPlugin();
   init_catalog();
+  init_scaffoldAuthFeature();
   init_install();
   init_tuiPrimitives();
 });
@@ -173971,8 +174899,8 @@ var exports_analyze = {};
 __export(exports_analyze, {
   runAnalyze: () => runAnalyze
 });
-import { existsSync as existsSync23, readFileSync as readFileSync23, statSync as statSync2, writeFileSync as writeFileSync13 } from "fs";
-import { join as join23, resolve as resolve13 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync26, statSync as statSync3, writeFileSync as writeFileSync15 } from "fs";
+import { join as join25, resolve as resolve17 } from "path";
 var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_WIDTH = 16, SIZE_WIDTH = 12, CHANGE_WIDTH = 10, CATEGORY_ORDER, categoryOf = (key) => {
   if (key.startsWith("Island"))
     return "Islands";
@@ -173987,26 +174915,26 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   return "Pages";
 }, fileSize2 = (path) => {
   try {
-    return statSync2(path).size;
+    return statSync3(path).size;
   } catch {
     return 0;
   }
 }, readSizes = (manifestDir) => {
-  const manifestPath = join23(manifestDir, "manifest.json");
-  if (!existsSync23(manifestPath))
+  const manifestPath = join25(manifestDir, "manifest.json");
+  if (!existsSync27(manifestPath))
     return null;
-  const manifest = JSON.parse(readFileSync23(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync26(manifestPath, "utf-8"));
   const sizes = {};
   for (const [key, value] of Object.entries(manifest)) {
-    sizes[key] = fileSize2(join23(manifestDir, value.replace(/^\//, "")));
+    sizes[key] = fileSize2(join25(manifestDir, value.replace(/^\//, "")));
   }
   return sizes;
 }, readBaseline = (cwd) => {
-  const path = join23(cwd, BASELINE_FILE);
-  if (!existsSync23(path))
+  const path = join25(cwd, BASELINE_FILE);
+  if (!existsSync27(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync23(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync26(path, "utf-8"));
     return parsed;
   } catch {
     return null;
@@ -174084,14 +175012,14 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   const config = await loadConfig(configIndex >= 0 ? args[configIndex + 1] : undefined);
   const outdirIndex = args.indexOf("--outdir");
   const outdir = outdirIndex >= 0 ? args[outdirIndex + 1] : config.buildDirectory;
-  const sizes = readSizes(resolve13(cwd, outdir ?? "build"));
+  const sizes = readSizes(resolve17(cwd, outdir ?? "build"));
   if (sizes === null) {
     process.stdout.write(`${colors.dim}No build found. Run \`absolute build\` first.${colors.reset}
 `);
     return;
   }
   if (args.includes("--save")) {
-    writeFileSync13(join23(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
+    writeFileSync15(join25(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
 `);
     process.stdout.write(`${colors.green}\u2713${colors.reset} Saved size baseline (${Object.keys(sizes).length} entries) to ${BASELINE_FILE}
 `);
@@ -174337,8 +175265,8 @@ var exports_remove = {};
 __export(exports_remove, {
   runRemove: () => runRemove
 });
-import { existsSync as existsSync24, readFileSync as readFileSync24 } from "fs";
-import { relative as relative7 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync27 } from "fs";
+import { relative as relative9 } from "path";
 var write3 = (text) => process.stdout.write(`${text}
 `), fail3 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -174348,10 +175276,10 @@ var write3 = (text) => process.stdout.write(`${text}
   const candidates = [findRoutingFile(serverEntry), serverEntry];
   const seen = new Set;
   return candidates.filter((file) => {
-    if (file === null || seen.has(file) || !existsSync24(file))
+    if (file === null || seen.has(file) || !existsSync28(file))
       return false;
     seen.add(file);
-    return readFileSync24(file, "utf-8").includes(handler);
+    return readFileSync27(file, "utf-8").includes(handler);
   });
 }, runRemove = async (args) => {
   const [framework] = args.filter((arg) => !arg.startsWith("--"));
@@ -174387,10 +175315,10 @@ var write3 = (text) => process.stdout.write(`${text}
   }
   write3(`${colors.green}\u2713${colors.reset} Removed ${framework}Directory from absolute.config.ts
 `);
-  write3(`  ${colors.dim}Kept${colors.reset}  ${relative7(cwd, frameworkDir)} \u2014 delete its source manually if no longer needed.`);
+  write3(`  ${colors.dim}Kept${colors.reset}  ${relative9(cwd, frameworkDir)} \u2014 delete its source manually if no longer needed.`);
   const refs = referencingFiles(project.serverEntry, HANDLER_NAME[framework]);
   for (const file of refs) {
-    write3(`  ${colors.yellow}Still references${colors.reset}  ${relative7(cwd, file)} (calls ${HANDLER_NAME[framework]})`);
+    write3(`  ${colors.yellow}Still references${colors.reset}  ${relative9(cwd, file)} (calls ${HANDLER_NAME[framework]})`);
   }
   const deps = frameworkDependencyNames(framework);
   if (prune && deps.length > 0) {
@@ -174478,15 +175406,15 @@ __export(exports_env, {
   runEnv: () => runEnv,
   collectEnvVars: () => collectEnvVars
 });
-import { existsSync as existsSync25, readFileSync as readFileSync25 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync28 } from "fs";
+import { join as join26 } from "path";
 var {env: env3, Glob: Glob3 } = globalThis.Bun;
-var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync25(join24(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
+var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync29(join26(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
   const scans = scanPatterns().map((pattern) => Array.fromAsync(new Glob3(pattern).scan({ cwd: process.cwd() })));
   const files = (await Promise.all(scans)).flat();
   const usage = new Map;
   files.forEach((file) => {
-    keysInFile(readFileSync25(file, "utf-8")).forEach((key) => {
+    keysInFile(readFileSync28(file, "utf-8")).forEach((key) => {
       usage.set(key, [...usage.get(key) ?? [], file]);
     });
   });
@@ -174537,6 +175465,215 @@ var init_env = __esm(() => {
   STATUS_WIDTH2 = "missing".length;
 });
 
+// src/cli/scripts/db.ts
+var exports_db = {};
+__export(exports_db, {
+  runDb: () => runDb,
+  quoteIdent: () => quoteIdent,
+  encodeValue: () => encodeValue,
+  dependencyOrder: () => dependencyOrder,
+  conflictClause: () => conflictClause,
+  chunkRows: () => chunkRows
+});
+import { existsSync as existsSync30, mkdirSync as mkdirSync13, readFileSync as readFileSync29, writeFileSync as writeFileSync16 } from "fs";
+import { join as join27 } from "path";
+var {env: env4, spawn: spawn2, SQL } = globalThis.Bun;
+var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA_TYPES, SEED_CANDIDATES, VALUE_FLAGS, paint = (text, color) => `${color}${text}${colors.reset}`, chunkRows = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, idx) => items.slice(idx * size, idx * size + size)), quoteIdent = (name) => `"${name.replace(/"/g, '""')}"`, resolveUrl = (explicit) => {
+  const found = explicit ?? URL_ENV_KEYS.map((key) => env4[key]).find((value) => typeof value === "string" && value !== "");
+  if (found === undefined || found === "")
+    throw new Error(`No database URL found. Set ${URL_ENV_KEYS.join(" or ")}, or pass --url <url>.`);
+  return found;
+}, keepTable = (name, options) => (options.only.length === 0 || options.only.includes(name)) && !options.exclude.includes(name), listTables = async (sql) => {
+  const rows = await sql`select table_name from information_schema.tables where table_schema = ${"public"} and table_type = ${"BASE TABLE"} order by table_name`;
+  return rows.map((row) => row.table_name);
+}, columnsFor = async (sql, name) => {
+  const rows = await sql.unsafe(`select column_name, data_type from information_schema.columns where table_schema = $1 and table_name = $2 order by ordinal_position`, ["public", name]);
+  return rows.map((row) => ({
+    isJson: JSON_DATA_TYPES.includes(row.data_type),
+    name: row.column_name
+  }));
+}, primaryKeyFor = async (sql, name) => {
+  const rows = await sql.unsafe(`select a.attname as col from pg_index i join pg_attribute a on a.attrelid = i.indrelid and a.attnum = any(i.indkey) where i.indrelid = $1::regclass and i.indisprimary order by a.attnum`, [`public.${quoteIdent(name)}`]);
+  return rows.map((row) => row.col);
+}, tableMeta = async (sql, name) => {
+  const [columns, primaryKey] = await Promise.all([
+    columnsFor(sql, name),
+    primaryKeyFor(sql, name)
+  ]);
+  return { columns, name, primaryKey };
+}, foreignLinks = async (sql) => {
+  const rows = await sql.unsafe(`select tc.table_name as child, ccu.table_name as parent from information_schema.table_constraints tc join information_schema.constraint_column_usage ccu on ccu.constraint_name = tc.constraint_name and ccu.table_schema = tc.table_schema where tc.constraint_type = 'FOREIGN KEY' and tc.table_schema = $1`, ["public"]);
+  return rows.map((row) => ({
+    from: row.child,
+    to: row.parent
+  }));
+}, conflictClause = (meta) => {
+  if (meta.primaryKey.length === 0)
+    return "on conflict do nothing";
+  const target = meta.primaryKey.map(quoteIdent).join(", ");
+  const updatable = meta.columns.map((col) => col.name).filter((name) => !meta.primaryKey.includes(name));
+  if (updatable.length === 0)
+    return `on conflict (${target}) do nothing`;
+  const sets = updatable.map((name) => `${quoteIdent(name)} = excluded.${quoteIdent(name)}`).join(", ");
+  return `on conflict (${target}) do update set ${sets}`;
+}, dependencyOrder = (names, links) => {
+  const present = new Set(names);
+  const edges = links.filter((link) => present.has(link.from) && present.has(link.to) && link.from !== link.to);
+  const indegree = new Map(names.map((name) => [name, 0]));
+  edges.forEach((link) => indegree.set(link.from, (indegree.get(link.from) ?? 0) + 1));
+  const ready = names.filter((name) => (indegree.get(name) ?? 0) === 0);
+  const ordered = [];
+  const release = (parent) => edges.filter((link) => link.to === parent).forEach((link) => {
+    const next = (indegree.get(link.from) ?? 0) - 1;
+    indegree.set(link.from, next);
+    if (next === 0)
+      ready.push(link.from);
+  });
+  const drain = () => {
+    const head = ready.shift();
+    if (head === undefined)
+      return;
+    ordered.push(head);
+    release(head);
+    drain();
+  };
+  drain();
+  names.forEach((name) => {
+    if (!ordered.includes(name))
+      ordered.push(name);
+  });
+  return ordered;
+}, encodeValue = (col, value) => {
+  if (value === null || value === undefined)
+    return null;
+  if (col.isJson)
+    return JSON.stringify(value);
+  return value;
+}, insertChunk = async (sql, meta, rows) => {
+  const colNames = meta.columns.map((col) => col.name);
+  const groups = rows.map((_, rowIdx) => {
+    const base = rowIdx * colNames.length;
+    const slots = [...colNames.keys()].map((colIdx) => `$${base + colIdx + 1}`);
+    return `(${slots.join(", ")})`;
+  });
+  const params = rows.flatMap((row) => meta.columns.map((col) => encodeValue(col, row[col.name])));
+  const columnList = colNames.map(quoteIdent).join(", ");
+  const query = `insert into ${quoteIdent(meta.name)} (${columnList}) values ${groups.join(", ")} ${conflictClause(meta)}`;
+  await sql.unsafe(query, params);
+}, restoreTable = async (sql, meta, rows) => {
+  if (meta === undefined || rows.length === 0)
+    return;
+  await chunkRows(rows, RESTORE_CHUNK_ROWS).reduce(async (prev, part) => {
+    await prev;
+    return insertChunk(sql, meta, part);
+  }, Promise.resolve());
+}, truncateAll = async (sql, names) => {
+  if (names.length === 0)
+    return;
+  const list = names.map(quoteIdent).join(", ");
+  await sql.unsafe(`truncate ${list} restart identity cascade`);
+}, runBackup = async (options) => {
+  const sql = new SQL(options.url);
+  const chosen = (await listTables(sql)).filter((name) => keepTable(name, options));
+  const dumps = await Promise.all(chosen.map(async (name) => {
+    const rows = await sql.unsafe(`select * from ${quoteIdent(name)}`);
+    return [name, rows];
+  }));
+  await sql.end();
+  const tables = Object.fromEntries(dumps);
+  const payload = {
+    at: new Date().toISOString(),
+    tables,
+    v: BACKUP_FORMAT_VERSION
+  };
+  const dir = options.out ?? join27(process.cwd(), "backups");
+  mkdirSync13(dir, { recursive: true });
+  const json = JSON.stringify(payload, (_, value) => typeof value === "bigint" ? value.toString() : value);
+  const file = join27(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
+  writeFileSync16(file, json);
+  writeFileSync16(join27(dir, "latest.json"), json);
+  const total = chosen.reduce((sum, name) => sum + (tables[name]?.length ?? 0), 0);
+  console.log(paint(`\u2713 backup \u2192 ${file}`, colors.green));
+  console.log(paint(`  ${chosen.length} tables, ${total} rows`, colors.dim));
+}, runRestore = async (file, options) => {
+  if (!existsSync30(file))
+    throw new Error(`Backup not found: ${file}`);
+  const payload = JSON.parse(readFileSync29(file, "utf-8"));
+  const names = Object.keys(payload.tables).filter((name) => keepTable(name, options));
+  const sql = new SQL(options.url);
+  const order = dependencyOrder(names, await foreignLinks(sql));
+  const metas = await Promise.all(order.map((name) => tableMeta(sql, name)));
+  const metaByName = new Map(metas.map((meta) => [meta.name, meta]));
+  const aborted = options.truncate && !options.yes && prompt(paint(`\u26A0 TRUNCATE ${order.length} tables before restore? type "yes": `, colors.yellow)) !== "yes";
+  if (aborted) {
+    await sql.end();
+    console.log(paint("aborted", colors.yellow));
+    return;
+  }
+  if (options.truncate)
+    await truncateAll(sql, [...order].reverse());
+  await order.reduce(async (prev, name) => {
+    await prev;
+    return restoreTable(sql, metaByName.get(name), payload.tables[name] ?? []);
+  }, Promise.resolve());
+  await sql.end();
+  const total = order.reduce((sum, name) => sum + (payload.tables[name]?.length ?? 0), 0);
+  console.log(paint(`\u2713 restored ${order.length} tables, ${total} rows (idempotent upsert by primary key)`, colors.green));
+}, runSeed = async (entry) => {
+  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync30(join27(process.cwd(), candidate)));
+  if (target === undefined)
+    throw new Error(`No seed script found (looked for ${SEED_CANDIDATES.join(", ")}). Pass a path: absolute db seed <file>.`);
+  console.log(paint(`seeding via ${target}\u2026`, colors.cyan));
+  const proc = spawn2(["bun", "run", target], {
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  const code = await proc.exited;
+  if (code !== 0)
+    throw new Error(`Seed failed (exit ${code}).`);
+}, flagValue = (rest, flag) => {
+  const idx = rest.indexOf(flag);
+  return idx === UNFOUND_INDEX ? undefined : rest[idx + 1];
+}, listValue = (rest, flag) => (flagValue(rest, flag) ?? "").split(",").map((part) => part.trim()).filter((part) => part !== ""), parseOptions = (rest) => ({
+  exclude: listValue(rest, "--exclude"),
+  only: listValue(rest, "--only"),
+  out: flagValue(rest, "--out"),
+  truncate: rest.includes("--truncate"),
+  url: resolveUrl(flagValue(rest, "--url")),
+  yes: rest.includes("--yes") || rest.includes("-y")
+}), positionalArgs = (rest) => rest.filter((arg, idx) => !arg.startsWith("-") && !VALUE_FLAGS.includes(rest[idx - 1] ?? "")), usage = () => {
+  console.error("Usage: absolute db <backup|restore|seed> [options]");
+  console.error("  backup  [--out <dir>] [--only a,b] [--exclude a,b] [--url <url>]   Dump tables \u2192 JSON (+ latest.json)");
+  console.error("  restore [file] [--truncate] [--only a,b] [--exclude a,b] [-y]      Idempotent upsert by primary key");
+  console.error("  seed    [file]                                                     Run the project\u2019s seed script");
+  process.exit(1);
+}, runDb = async (args) => {
+  const [sub, ...rest] = args;
+  if (sub === "backup") {
+    await runBackup(parseOptions(rest));
+    return;
+  }
+  if (sub === "restore") {
+    const file = positionalArgs(rest)[0] ?? join27(process.cwd(), "backups", "latest.json");
+    await runRestore(file, parseOptions(rest));
+    return;
+  }
+  if (sub === "seed") {
+    await runSeed(positionalArgs(rest)[0]);
+    return;
+  }
+  usage();
+};
+var init_db = __esm(() => {
+  init_constants();
+  init_tuiPrimitives();
+  URL_ENV_KEYS = ["DATABASE_URL", "POSTGRES_URL", "DATABASE_URL_UNPOOLED"];
+  JSON_DATA_TYPES = ["json", "jsonb"];
+  SEED_CANDIDATES = ["db/seed.ts", "src/db/seed.ts", "seed.ts"];
+  VALUE_FLAGS = ["--out", "--url", "--only", "--exclude"];
+});
+
 // src/cli/scripts/logs.ts
 var exports_logs = {};
 __export(exports_logs, {
@@ -174544,10 +175681,10 @@ __export(exports_logs, {
 });
 import {
   closeSync as closeSync2,
-  existsSync as existsSync26,
+  existsSync as existsSync31,
   openSync as openSync4,
   readSync as readSync2,
-  statSync as statSync3,
+  statSync as statSync4,
   watchFile
 } from "fs";
 var DEFAULT_LINES = 40, POLL_MS = 250, LINES_FLAG_SPAN = 2, readFrom = (path, start2, length) => {
@@ -174562,7 +175699,7 @@ var DEFAULT_LINES = 40, POLL_MS = 250, LINES_FLAG_SPAN = 2, readFrom = (path, st
     closeSync2(descriptor);
   }
 }, tailLines = (path, maxLines) => {
-  const { size } = statSync3(path);
+  const { size } = statSync4(path);
   const start2 = Math.max(0, size - LIST_LOG_TAIL_MAX_BYTES);
   const lines = readFrom(path, start2, size - start2).split(`
 `);
@@ -174579,7 +175716,7 @@ var DEFAULT_LINES = 40, POLL_MS = 250, LINES_FLAG_SPAN = 2, readFrom = (path, st
   const cleaned = index === UNFOUND_INDEX ? args : [...args.slice(0, index), ...args.slice(index + LINES_FLAG_SPAN)];
   return cleaned.find((arg) => !arg.startsWith("-"));
 }, followFile = (path) => {
-  let offset = statSync3(path).size;
+  let offset = statSync4(path).size;
   watchFile(path, { interval: POLL_MS }, (current) => {
     if (current.size > offset) {
       process.stdout.write(readFrom(path, offset, current.size - offset));
@@ -174611,7 +175748,7 @@ var DEFAULT_LINES = 40, POLL_MS = 250, LINES_FLAG_SPAN = 2, readFrom = (path, st
     printAvailable(instances);
     return;
   }
-  if (match.logFile === null || !existsSync26(match.logFile)) {
+  if (match.logFile === null || !existsSync31(match.logFile)) {
     printDim3(`"${name}" has no captured log (untracked, or started outside the CLI).`);
     return;
   }
@@ -174634,10 +175771,10 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync27, mkdirSync as mkdirSync12, readFileSync as readFileSync26, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync14, readFileSync as readFileSync30, writeFileSync as writeFileSync17 } from "fs";
 import { createRequire } from "module";
 import { arch as arch4, platform as platform5 } from "os";
-import { join as join25 } from "path";
+import { join as join28 } from "path";
 var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
   detail,
   label,
@@ -174672,7 +175809,7 @@ var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
     return [];
   const label = `${field.replace("Directory", "")} pages`;
   return [
-    existsSync27(join25(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
+    existsSync32(join28(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
   ];
 }), envCheck = async () => {
   const vars = await collectEnvVars();
@@ -174705,7 +175842,7 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
 }, gatherChecks = async () => {
   const config = await loadConfigOrNull();
   const configCheck = config === null ? check("fail", "Config", "absolute.config.ts not found or invalid") : check("ok", "Config", "absolute.config.ts loaded");
-  const [env4, port] = await Promise.all([
+  const [env5, port] = await Promise.all([
     envCheck(),
     config === null ? check("warn", "Dev port", "skipped (no config)") : portCheck(config)
   ]);
@@ -174715,16 +175852,16 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
     checkNative(),
     configCheck,
     ...config === null ? [] : frameworkChecks(config),
-    env4,
+    env5,
     port
   ];
 }, fixFrameworkDirs = (cwd, config) => {
   const fixes = [];
   for (const field of FRAMEWORK_FIELDS2) {
     const dir = readString(config, field);
-    if (dir === undefined || existsSync27(join25(cwd, dir)))
+    if (dir === undefined || existsSync32(join28(cwd, dir)))
       continue;
-    mkdirSync12(join25(cwd, dir, "pages"), { recursive: true });
+    mkdirSync14(join28(cwd, dir, "pages"), { recursive: true });
     fixes.push(`created ${dir}/pages`);
   }
   return fixes;
@@ -174732,8 +175869,8 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const missing = (await collectEnvVars()).filter((entry) => !entry.set);
   if (missing.length === 0)
     return null;
-  const envExample = join25(cwd, ".env.example");
-  const existing = existsSync27(envExample) ? readFileSync26(envExample, "utf-8") : "";
+  const envExample = join28(cwd, ".env.example");
+  const existing = existsSync32(envExample) ? readFileSync30(envExample, "utf-8") : "";
   const existingKeys = new Set(existing.split(`
 `).map((line) => line.split("=")[0]?.trim()));
   const toAdd = missing.filter((entry) => !existingKeys.has(entry.key));
@@ -174742,7 +175879,7 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const prefix = existing === "" || existing.endsWith(`
 `) ? existing : `${existing}
 `;
-  writeFileSync14(envExample, `${prefix}${toAdd.map((entry) => `${entry.key}=`).join(`
+  writeFileSync17(envExample, `${prefix}${toAdd.map((entry) => `${entry.key}=`).join(`
 `)}
 `);
   return `added ${toAdd.length} key(s) to .env.example`;
@@ -174788,7 +175925,7 @@ var init_doctor = __esm(() => {
     "htmlDirectory",
     "htmxDirectory"
   ];
-  projectRequire = createRequire(join25(process.cwd(), "package.json"));
+  projectRequire = createRequire(join28(process.cwd(), "package.json"));
   STATUS_MARK = {
     fail: `${colors.red}\u2717${colors.reset}`,
     ok: `${colors.green}\u2713${colors.reset}`,
@@ -175092,10 +176229,10 @@ var init_inspect = __esm(() => {
 });
 
 // src/build/scanEntryPoints.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 var {Glob: Glob4 } = globalThis.Bun;
 var scanEntryPoints = async (dir, pattern) => {
-  if (!existsSync28(dir))
+  if (!existsSync33(dir))
     return [];
   const entryPaths = [];
   const glob = new Glob4(pattern);
@@ -175125,10 +176262,10 @@ var islandFrameworks, islandHydrationModes, isIslandFramework = (value) => islan
     framework,
     hydrate: hydrateCandidate && isIslandHydrate(hydrateCandidate) ? hydrateCandidate : undefined
   };
-}, normalizeUsage = (usage) => `${usage.framework}:${usage.component}:${usage.hydrate ?? ""}`, addUsage = (usageMap, usage) => {
-  if (!usage)
+}, normalizeUsage = (usage2) => `${usage2.framework}:${usage2.component}:${usage2.hydrate ?? ""}`, addUsage = (usageMap, usage2) => {
+  if (!usage2)
     return;
-  usageMap.set(normalizeUsage(usage), usage);
+  usageMap.set(normalizeUsage(usage2), usage2);
 }, addRenderCallUsage = (usageMap, match) => {
   const [, framework, component, hydrate] = match;
   if (!framework || !component || !isIslandFramework(framework)) {
@@ -175177,8 +176314,8 @@ var init_sourceMetadata = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync27 } from "fs";
-import { dirname as dirname11, resolve as resolve14 } from "path";
+import { readFileSync as readFileSync31 } from "fs";
+import { dirname as dirname12, resolve as resolve18 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -175198,27 +176335,27 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve14(dirname11(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve14(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve18(dirname12(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve18(resolvedSource));
   }
   return lookup;
-}, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
-  const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
+}, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage2) => {
+  const sourcePath = islandSourceLookup.get(`${usage2.framework}:${usage2.component}`);
   return sourcePath ? {
-    ...usage,
+    ...usage2,
     source: sourcePath
-  } : usage;
+  } : usage2;
 }), loadPageIslandFiles = async (entry, islandSourceLookup, pageMetadata) => {
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve14(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve18(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync27(filePath, "utf-8");
+    const source = readFileSync31(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve14(filePath), {
+    pageMetadata.set(resolve18(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve14(filePath)
+      pagePath: resolve18(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -175247,49 +176384,49 @@ var exports_islands = {};
 __export(exports_islands, {
   runIslands: () => runIslands
 });
-import { existsSync as existsSync29, readFileSync as readFileSync28, statSync as statSync4 } from "fs";
-import { join as join26, relative as relative8, resolve as resolve15 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync32, statSync as statSync5 } from "fs";
+import { join as join29, relative as relative10, resolve as resolve19 } from "path";
 var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.write(`${colors.dim}${message}${colors.reset}
 `), hostFrameworkOf = (pagePath, cwd, config) => {
-  const resolved = resolve15(cwd, pagePath);
+  const resolved = resolve19(cwd, pagePath);
   for (const [framework, key] of Object.entries(FRAMEWORK_DIR_KEY)) {
     const dir = config[key];
-    if (typeof dir === "string" && resolved.startsWith(resolve15(cwd, dir))) {
+    if (typeof dir === "string" && resolved.startsWith(resolve19(cwd, dir))) {
       return framework;
     }
   }
   return null;
 }, fileSize3 = (path) => {
   try {
-    return statSync4(path).size;
+    return statSync5(path).size;
   } catch {
     return 0;
   }
 }, readManifestSizes2 = (manifestDir) => {
-  const manifestPath = join26(manifestDir, "manifest.json");
-  if (!existsSync29(manifestPath))
+  const manifestPath = join29(manifestDir, "manifest.json");
+  if (!existsSync34(manifestPath))
     return null;
-  const manifest = JSON.parse(readFileSync28(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync32(manifestPath, "utf-8"));
   const sizes = new Map;
   for (const [key, value] of Object.entries(manifest)) {
-    sizes.set(key, fileSize3(join26(manifestDir, value.replace(/^\//, ""))));
+    sizes.set(key, fileSize3(join29(manifestDir, value.replace(/^\//, ""))));
   }
   return sizes;
 }, collectIslands = async (cwd, config, sizes) => {
   const registryPath = config.islands?.registry;
   if (typeof registryPath !== "string")
     return null;
-  const buildInfo = await loadIslandRegistryBuildInfo(resolve15(cwd, registryPath));
+  const buildInfo = await loadIslandRegistryBuildInfo(resolve19(cwd, registryPath));
   const pageMetadata = await loadPageIslandMetadata(config);
   const usages = [...pageMetadata.values()].flatMap((meta) => meta.islands.map((island) => ({ ...island, page: meta.pagePath })));
   return buildInfo.definitions.map((definition) => {
-    const mounts = usages.filter((usage) => usage.framework === definition.framework && usage.component === definition.component).map((usage) => {
-      const hostFramework = hostFrameworkOf(usage.page, cwd, config);
+    const mounts = usages.filter((usage2) => usage2.framework === definition.framework && usage2.component === definition.component).map((usage2) => {
+      const hostFramework = hostFrameworkOf(usage2.page, cwd, config);
       return {
         crossFramework: hostFramework !== null && hostFramework !== definition.framework,
         hostFramework,
-        hydrate: usage.hydrate ?? "load",
-        page: relative8(cwd, resolve15(cwd, usage.page))
+        hydrate: usage2.hydrate ?? "load",
+        page: relative10(cwd, resolve19(cwd, usage2.page))
       };
     });
     const key = getIslandManifestKey(definition.framework, definition.component);
@@ -175328,7 +176465,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
     `  ${color}\u2B21${colors.reset} ${colors.bold}${island.component}${colors.reset}  ${meta}${sizeText}`
   ];
   if (island.source) {
-    lines.push(`    ${colors.dim}${relative8(cwd, island.source)}${colors.reset}`);
+    lines.push(`    ${colors.dim}${relative10(cwd, island.source)}${colors.reset}`);
   }
   if (pages.length === 0) {
     lines.push(`    ${colors.dim}(registered but not mounted on any page)${colors.reset}`);
@@ -175358,7 +176495,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
   }
   const outdirIndex = args.indexOf("--outdir");
   const outdir = outdirIndex >= 0 ? args[outdirIndex + 1] : config.buildDirectory;
-  const sizes = args.includes("--sizes") ? readManifestSizes2(resolve15(cwd, outdir ?? "build")) : null;
+  const sizes = args.includes("--sizes") ? readManifestSizes2(resolve19(cwd, outdir ?? "build")) : null;
   const islands = await collectIslands(cwd, config, sizes);
   if (islands === null) {
     printDim6('No island registry configured. Set `islands: { registry: "..." }` in absolute.config.ts.');
@@ -175407,13 +176544,13 @@ var init_islands2 = __esm(() => {
 });
 
 // src/build/externalAssetPlugin.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync30, mkdirSync as mkdirSync13, statSync as statSync5 } from "fs";
-import { basename as basename6, dirname as dirname12, join as join27, resolve as resolve16 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync35, mkdirSync as mkdirSync15, statSync as statSync6 } from "fs";
+import { basename as basename6, dirname as dirname13, join as join30, resolve as resolve20 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
   setup(bld) {
     const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
-    const skipRoots = userSourceRoots.map((root) => resolve16(root));
+    const skipRoots = userSourceRoots.map((root) => resolve20(root));
     const isUserSource = (path) => skipRoots.some((root) => path.startsWith(`${root}/`));
     bld.onLoad({ filter: /\.[mc]?[jt]sx?$/ }, async (args) => {
       if (isUserSource(args.path))
@@ -175423,20 +176560,20 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         return;
       urlPattern.lastIndex = 0;
       let match;
-      const sourceDir = dirname12(args.path);
+      const sourceDir = dirname13(args.path);
       while ((match = urlPattern.exec(source)) !== null) {
         const relPath = match[1];
         if (!relPath)
           continue;
-        const assetPath = resolve16(sourceDir, relPath);
-        if (!existsSync30(assetPath))
+        const assetPath = resolve20(sourceDir, relPath);
+        if (!existsSync35(assetPath))
           continue;
-        if (!statSync5(assetPath).isFile())
+        if (!statSync6(assetPath).isFile())
           continue;
-        const targetPath = join27(outDir, basename6(assetPath));
-        if (existsSync30(targetPath))
+        const targetPath = join30(outDir, basename6(assetPath));
+        if (existsSync35(targetPath))
           continue;
-        mkdirSync13(dirname12(targetPath), { recursive: true });
+        mkdirSync15(dirname13(targetPath), { recursive: true });
         copyFileSync2(assetPath, targetPath);
       }
       return;
@@ -175451,19 +176588,19 @@ __export(exports_compile, {
   shouldEmbedCompiledAsset: () => shouldEmbedCompiledAsset,
   compile: () => compile
 });
-var {env: env4 } = globalThis.Bun;
+var {env: env5 } = globalThis.Bun;
 import {
   cpSync,
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync14,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync29,
+  existsSync as existsSync36,
+  mkdirSync as mkdirSync16,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync33,
   rmSync as rmSync5,
-  statSync as statSync6,
+  statSync as statSync7,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync18
 } from "fs";
-import { basename as basename7, dirname as dirname13, join as join28, relative as relative9, resolve as resolve17 } from "path";
+import { basename as basename7, dirname as dirname14, join as join31, relative as relative11, resolve as resolve21 } from "path";
 var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, compileBanner = (version2) => {
   const resolvedVersion = version2 || "unknown";
   console.log("");
@@ -175471,14 +176608,14 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   console.log("");
 }, collectFiles2 = (dir) => {
   const result = [];
-  let pending = readdirSync6(dir, { withFileTypes: true });
+  let pending = readdirSync7(dir, { withFileTypes: true });
   while (pending.length > 0) {
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join28(entry.parentPath, entry.name);
+    const fullPath = join31(entry.parentPath, entry.name);
     if (entry.isDirectory())
-      pending = pending.concat(readdirSync6(fullPath, { withFileTypes: true }));
+      pending = pending.concat(readdirSync7(fullPath, { withFileTypes: true }));
     else
       result.push(fullPath);
   }
@@ -175491,16 +176628,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return `./${parts.join("/")}`;
 }, collectProjectSourceFiles = (dir) => {
   const result = [];
-  let pending = readdirSync6(dir, { withFileTypes: true });
+  let pending = readdirSync7(dir, { withFileTypes: true });
   while (pending.length > 0) {
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join28(entry.parentPath, entry.name);
+    const fullPath = join31(entry.parentPath, entry.name);
     if (entry.isDirectory()) {
       if (SERVER_RUNTIME_SCAN_SKIP_DIRS.has(entry.name))
         continue;
-      pending = pending.concat(readdirSync6(fullPath, { withFileTypes: true }));
+      pending = pending.concat(readdirSync7(fullPath, { withFileTypes: true }));
     } else if (hasSourceExtension(fullPath)) {
       result.push(fullPath);
     }
@@ -175508,22 +176645,22 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return result;
 }, copyServerRuntimeAssetReferences = (outdir) => {
   const copied = new Set;
-  const normalizedOutdir = resolve17(outdir);
+  const normalizedOutdir = resolve21(outdir);
   const copyReference = (filePath, relPath) => {
-    const assetSource = resolve17(dirname13(filePath), relPath);
-    if (!existsSync31(assetSource) || !statSync6(assetSource).isFile())
+    const assetSource = resolve21(dirname14(filePath), relPath);
+    if (!existsSync36(assetSource) || !statSync7(assetSource).isFile())
       return;
-    const assetTarget = resolve17(normalizedOutdir, relPath.replace(/^\.\//, ""));
+    const assetTarget = resolve21(normalizedOutdir, relPath.replace(/^\.\//, ""));
     if (assetTarget !== normalizedOutdir && !assetTarget.startsWith(`${normalizedOutdir}/`))
       return;
     if (copied.has(assetTarget))
       return;
     copied.add(assetTarget);
-    mkdirSync14(dirname13(assetTarget), { recursive: true });
+    mkdirSync16(dirname14(assetTarget), { recursive: true });
     cpSync(assetSource, assetTarget, { force: true });
   };
   for (const filePath of collectProjectSourceFiles(process.cwd())) {
-    const source = readFileSync29(filePath, "utf-8");
+    const source = readFileSync33(filePath, "utf-8");
     SERVER_RUNTIME_ASSET_RE.lastIndex = 0;
     let match;
     while ((match = SERVER_RUNTIME_ASSET_RE.exec(source)) !== null) {
@@ -175552,7 +176689,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
 }, readPackageVersion4 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync29(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync33(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -175587,18 +176724,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return resolveBuildModule3(remaining);
 }, resolveJsxDevRuntimeCompatPath2 = () => {
   const candidates = [
-    resolve17(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve17(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve17(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
-    resolve17(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve17(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve17(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve21(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve21(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve21(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
+    resolve21(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve21(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve21(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync31(candidate))
+    if (existsSync36(candidate))
       return candidate;
   }
-  return resolve17(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
+  return resolve21(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
 }, jsxDevRuntimeCompatPath2, shouldEmbedCompiledAsset = (relativePath, skip = new Set) => {
   if (skip.has(relativePath))
     return false;
@@ -175611,11 +176748,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return true;
 }, tryReadNodePackageJson = (packageDir) => {
   try {
-    return JSON.parse(readFileSync29(join28(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(readFileSync33(join31(packageDir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
-}, resolveProjectPackageDir = (specifier) => resolve17(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
+}, resolveProjectPackageDir = (specifier) => resolve21(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
   if (seen.has(specifier))
     return;
   const srcDir = resolveProjectPackageDir(specifier);
@@ -175623,13 +176760,13 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!pkg)
     return;
   seen.add(specifier);
-  const destDir = join28(outdir, "node_modules", ...specifier.split("/"));
+  const destDir = join31(outdir, "node_modules", ...specifier.split("/"));
   rmSync5(destDir, { force: true, recursive: true });
   cpSync(srcDir, destDir, {
     force: true,
     recursive: true,
     filter(source) {
-      const rel = relative9(srcDir, source);
+      const rel = relative11(srcDir, source);
       const [firstSegment] = rel.split(/[\\/]/);
       return firstSegment !== "node_modules" && firstSegment !== ".git";
     }
@@ -175645,8 +176782,8 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
 }, copyAngularRuntimePackages = (buildConfig, outdir) => {
   if (!buildConfig.angularDirectory)
     return;
-  const angularScopeDir = resolve17(process.cwd(), "node_modules", "@angular");
-  const angularPackages = existsSync31(angularScopeDir) ? readdirSync6(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
+  const angularScopeDir = resolve21(process.cwd(), "node_modules", "@angular");
+  const angularPackages = existsSync36(angularScopeDir) ? readdirSync7(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
   const roots = new Set([...angularPackages, "rxjs", "tslib", "typescript"]);
   const seen = new Set;
   for (const specifier of roots) {
@@ -175664,16 +176801,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   copyAngularRuntimePackages(buildConfig, outdir);
   copyChunkReferencedPackages(outdir, seen);
 }, collectRuntimePackageSpecifiers = (distDir) => {
-  const nodeModulesDir = join28(distDir, "node_modules");
-  if (!existsSync31(nodeModulesDir))
+  const nodeModulesDir = join31(distDir, "node_modules");
+  if (!existsSync36(nodeModulesDir))
     return [];
   const specifiers = [];
-  for (const entry of readdirSync6(nodeModulesDir, { withFileTypes: true })) {
+  for (const entry of readdirSync7(nodeModulesDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     if (entry.name.startsWith("@")) {
-      const scopeDir = join28(nodeModulesDir, entry.name);
-      for (const scopedEntry of readdirSync6(scopeDir, {
+      const scopeDir = join31(nodeModulesDir, entry.name);
+      for (const scopedEntry of readdirSync7(scopeDir, {
         withFileTypes: true
       })) {
         if (scopedEntry.isDirectory()) {
@@ -175686,7 +176823,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   return specifiers.sort((a, b) => b.length - a.length);
 }, ensureRelativeModuleSpecifier = (fromFile, toFile) => {
-  const rel = relative9(dirname13(fromFile), toFile).replace(/\\/g, "/");
+  const rel = relative11(dirname14(fromFile), toFile).replace(/\\/g, "/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }, pickExportEntry = (value) => {
   if (typeof value === "string")
@@ -175704,21 +176841,21 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const packageSpecifier = packageSpecifiers.find((root) => specifier === root || specifier.startsWith(`${root}/`));
   if (!packageSpecifier)
     return null;
-  const packageDir = join28(distDir, "node_modules", ...packageSpecifier.split("/"));
+  const packageDir = join31(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
-  const subPackageDir = subpath ? join28(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync31(join28(subPackageDir, "package.json")) ? subPackageDir : packageDir;
-  const packageJsonPath = join28(resolvedPackageDir, "package.json");
-  if (!existsSync31(packageJsonPath))
+  const subPackageDir = subpath ? join31(packageDir, ...subpath.slice(1).split("/")) : null;
+  const resolvedPackageDir = subPackageDir && existsSync36(join31(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const packageJsonPath = join31(resolvedPackageDir, "package.json");
+  if (!existsSync36(packageJsonPath))
     return null;
-  const pkg = JSON.parse(readFileSync29(packageJsonPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync33(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir !== subPackageDir && subpath ? `.${subpath}` : ".";
   const rootExport = pkg.exports?.[exportKey];
   const entry = pickExportEntry(rootExport) ?? (resolvedPackageDir === subPackageDir || !subpath ? pkg.module ?? pkg.main ?? "index.js" : `.${subpath}`);
-  return join28(resolvedPackageDir, entry);
+  return join31(resolvedPackageDir, entry);
 }, RUNTIME_JS_EXTENSIONS, MODULE_SPECIFIER_RE, isRuntimeJsFile = (filePath) => RUNTIME_JS_EXTENSIONS.some((extension) => filePath.endsWith(extension)), isNodeModulesPath = (filePath) => filePath.split(/[\\/]/).includes("node_modules"), isFile = (filePath) => {
   try {
-    return statSync6(filePath).isFile();
+    return statSync7(filePath).isFile();
   } catch {
     return false;
   }
@@ -175728,16 +176865,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const candidates = [
     candidate,
     ...RUNTIME_JS_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-    ...RUNTIME_JS_EXTENSIONS.map((extension) => join28(candidate, `index${extension}`))
+    ...RUNTIME_JS_EXTENSIONS.map((extension) => join31(candidate, `index${extension}`))
   ];
   return candidates.find((filePath) => isRuntimeJsFile(filePath) && isFile(filePath)) ?? null;
 }, findContainingRuntimePackageDir = (filePath) => {
-  let dir = dirname13(filePath);
-  while (dir !== dirname13(dir)) {
-    if (isNodeModulesPath(dir) && existsSync31(join28(dir, "package.json"))) {
+  let dir = dirname14(filePath);
+  while (dir !== dirname14(dir)) {
+    if (isNodeModulesPath(dir) && existsSync36(join31(dir, "package.json"))) {
       return dir;
     }
-    dir = dirname13(dir);
+    dir = dirname14(dir);
   }
   return null;
 }, resolvePackageImportEntryFile = (fromFile, specifier) => {
@@ -175750,13 +176887,13 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const entry = pickExportEntry(pkg?.imports?.[specifier]);
   if (!entry)
     return null;
-  return join28(packageDir, entry);
+  return join31(packageDir, entry);
 }, collectRuntimeRewriteRoots = (distDir) => collectFiles2(distDir).filter((filePath) => isRuntimeJsFile(filePath) && !isNodeModulesPath(filePath)), toTopLevelPackage = (specifier) => specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/"), FRAMEWORK_PACKAGE_NAME = "@absolutejs/absolute", copyChunkReferencedPackages = (distDir, seen) => {
-  const distRoot = resolve17(distDir);
+  const distRoot = resolve21(distDir);
   for (const filePath of collectRuntimeRewriteRoots(distDir)) {
-    if (resolve17(dirname13(filePath)) === distRoot)
+    if (resolve21(dirname14(filePath)) === distRoot)
       continue;
-    const source = readFileSync29(filePath, "utf-8");
+    const source = readFileSync33(filePath, "utf-8");
     for (const match of source.matchAll(MODULE_SPECIFIER_RE)) {
       const specifier = match[3];
       if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || specifier.startsWith("node:") || specifier.startsWith("bun:")) {
@@ -175786,10 +176923,10 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!filePath || seen.has(filePath))
       continue;
     seen.add(filePath);
-    const source = readFileSync29(filePath, "utf-8");
+    const source = readFileSync33(filePath, "utf-8");
     const rewritten = source.replace(MODULE_SPECIFIER_RE, (match, prefix, quote, specifier) => {
       if (typeof specifier === "string" && specifier.startsWith(".")) {
-        enqueue(resolveRuntimeJsFile(resolve17(dirname13(filePath), specifier)));
+        enqueue(resolveRuntimeJsFile(resolve21(dirname14(filePath), specifier)));
         return match;
       }
       const packageImportTarget = resolveRuntimeJsFile(resolvePackageImportEntryFile(filePath, specifier) ?? "");
@@ -175804,7 +176941,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
       return `${prefix}${quote}${ensureRelativeModuleSpecifier(filePath, target)}${quote}`;
     });
     if (rewritten !== source) {
-      writeFileSync15(filePath, rewritten);
+      writeFileSync18(filePath, rewritten);
     }
   }
 }, generateEntrypoint = (distDir, serverEntry, prerenderMap, version2, buildConfig) => {
@@ -175817,25 +176954,25 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     "_compile_entrypoint.ts"
   ]);
   const embeddedFiles = allFiles.filter((file) => {
-    const rel = relative9(distDir, file);
+    const rel = relative11(distDir, file);
     if (embeddedSkip.has(rel))
       return false;
     return true;
   });
-  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative9(distDir, file), assetSkip));
+  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative11(distDir, file), assetSkip));
   const imports = [];
   const embeddedMappings = [];
   const mappings = [];
   const embeddedVarMap = new Map;
   embeddedFiles.forEach((filePath, idx) => {
-    const rel = relative9(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative11(distDir, filePath).replace(/\\/g, "/");
     const varName = `__a${idx}`;
     embeddedVarMap.set(rel, varName);
     imports.push(`import ${varName} from "./${rel}" with { type: "file" };`);
     embeddedMappings.push(`	["${rel}", ${varName}],`);
   });
   clientFiles.forEach((filePath) => {
-    const rel = relative9(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative11(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (!varName)
       return;
@@ -175849,7 +176986,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const pageVarMap = new Map;
   const prerenderEntries = Array.from(prerenderMap.entries());
   prerenderEntries.forEach(([route, filePath]) => {
-    const rel = relative9(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative11(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (varName)
       pageVarMap.set(route, varName);
@@ -175878,7 +177015,7 @@ import { websocket as elysiaWebsocket } from "elysia/ws";
 const SERVER_MODULE = (runtimeDir: string) => import(pathToFileURL(join(runtimeDir, ${JSON.stringify(serverBundleName)})).href);
 const RUNTIME_BUILD_ID = ${JSON.stringify(runtimeBuildId)};
 const RUNTIME_CONFIG_SOURCE = ${JSON.stringify(runtimeConfigSource)};
-const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve17(distDir))};
+const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve21(distDir))};
 const ORIGINAL_BUILD_DIR_NORMALIZED = ORIGINAL_BUILD_DIR.replace(/\\\\/g, "/");
 
 // \u2500\u2500 Asset URL \u2192 embedded path map \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
@@ -176255,16 +177392,16 @@ console.log(\`
   }),
   ...collectUserServerExternals(buildConfig)
 ], compile = async (serverEntry, outdir, outfile, configPath2) => {
-  const resolvedOutdir = resolve17(outdir ?? "dist");
+  const resolvedOutdir = resolve21(outdir ?? "dist");
   await withBuildDirectoryLock(resolvedOutdir, () => compileUnlocked(serverEntry, resolvedOutdir, outfile, configPath2));
 }, compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath2) => {
-  const prerenderPort = Number(env4.COMPILE_PORT) || Number(env4.PORT) || DEFAULT_PORT + 1;
+  const prerenderPort = Number(env5.COMPILE_PORT) || Number(env5.PORT) || DEFAULT_PORT + 1;
   killStaleProcesses(prerenderPort);
   const entryName = basename7(serverEntry).replace(/\.[^.]+$/, "");
-  const resolvedOutfile = resolve17(outfile ?? "compiled-server");
+  const resolvedOutfile = resolve21(outfile ?? "compiled-server");
   const absoluteVersion = resolvePackageVersion3([
-    resolve17(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve17(import.meta.dir, "..", "..", "package.json")
+    resolve21(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve21(import.meta.dir, "..", "..", "package.json")
   ]);
   compileBanner(absoluteVersion);
   const totalStart = performance.now();
@@ -176275,8 +177412,8 @@ console.log(\`
   buildConfig.mode = "production";
   try {
     const build2 = await resolveBuildModule3([
-      resolve17(import.meta.dir, "..", "..", "core", "build"),
-      resolve17(import.meta.dir, "..", "build")
+      resolve21(import.meta.dir, "..", "..", "core", "build"),
+      resolve21(import.meta.dir, "..", "build")
     ]);
     if (!build2)
       throw new Error("Could not locate build module");
@@ -176298,10 +177435,10 @@ console.log(\`
     buildConfig.htmxDirectory
   ].filter((dir) => Boolean(dir));
   const islandRegistrySpec = buildConfig.islands?.registry;
-  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve17(islandRegistrySpec))) : undefined;
+  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve21(islandRegistrySpec))) : undefined;
   const serverBundle = await Bun.build({
     define: { "process.env.NODE_ENV": '"production"' },
-    entrypoints: [resolve17(serverEntry)],
+    entrypoints: [resolve21(serverEntry)],
     external: resolveServerBundleExternals(buildConfig),
     outdir: resolvedOutdir,
     plugins: [
@@ -176322,14 +177459,14 @@ console.log(\`
     console.error(cliTag4("\x1B[31m", "Server bundle failed."));
     process.exit(1);
   }
-  const outputPath = resolve17(resolvedOutdir, `${entryName}.js`);
-  if (!existsSync31(outputPath)) {
+  const outputPath = resolve21(resolvedOutdir, `${entryName}.js`);
+  if (!existsSync36(outputPath)) {
     console.error(cliTag4("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync31(resolve17(resolvedOutdir, "angular", "vendor", "server"))) {
-    const vendorDir = resolve17(resolvedOutdir, "angular", "vendor", "server");
-    const vendorEntries = readdirSync6(vendorDir).filter((f) => f.endsWith(".js"));
+  if (existsSync36(resolve21(resolvedOutdir, "angular", "vendor", "server"))) {
+    const vendorDir = resolve21(resolvedOutdir, "angular", "vendor", "server");
+    const vendorEntries = readdirSync7(vendorDir).filter((f) => f.endsWith(".js"));
     const angularServerVendorPaths = {};
     for (const file of vendorEntries) {
       const stem = file.replace(/\.js$/, "");
@@ -176337,7 +177474,7 @@ console.log(\`
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = relative9(dirname13(outputPath), resolve17(vendorDir, file));
+      const relPath = relative11(dirname14(outputPath), resolve21(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
@@ -176349,7 +177486,7 @@ console.log(\`
   copyServerRuntimeAssetReferences(resolvedOutdir);
   const prerenderStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Pre-rendering pages"));
-  rmSync5(join28(resolvedOutdir, "_prerendered"), {
+  rmSync5(join31(resolvedOutdir, "_prerendered"), {
     force: true,
     recursive: true
   });
@@ -176368,9 +177505,9 @@ console.log(\`
   const compileStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Compiling standalone executable"));
   const entrypointCode = generateEntrypoint(resolvedOutdir, serverEntry, prerenderMap, absoluteVersion, buildConfig);
-  const entrypointPath = join28(resolvedOutdir, "_compile_entrypoint.ts");
+  const entrypointPath = join31(resolvedOutdir, "_compile_entrypoint.ts");
   await Bun.write(entrypointPath, entrypointCode);
-  mkdirSync14(dirname13(resolvedOutfile), { recursive: true });
+  mkdirSync16(dirname14(resolvedOutfile), { recursive: true });
   const result = await Bun.build({
     compile: { outfile: resolvedOutfile },
     define: { "process.env.NODE_ENV": '"production"' },
@@ -176464,11 +177601,11 @@ var exports_typecheck = {};
 __export(exports_typecheck, {
   typecheck: () => typecheck
 });
-import { resolve as resolve18, join as join29 } from "path";
-import { existsSync as existsSync32, readFileSync as readFileSync30 } from "fs";
+import { resolve as resolve22, join as join32 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync34 } from "fs";
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve18(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
-  if (!existsSync32(resolveConfigPath(configPath2))) {
+var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve22(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
+  if (!existsSync37(resolveConfigPath(configPath2))) {
     return [{}];
   }
   const rawConfig = await loadRawConfig(configPath2);
@@ -176488,8 +177625,8 @@ var isCommandService3 = (service) => service.kind === "command" || Array.isArray
   const exitCode = await proc.exited;
   return { exitCode, name, output: (stdout + stderr).trim() };
 }, shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`, runShell = async (name, command) => run(name, ["/bin/bash", "-lc", command]), findBin = (name) => {
-  const local = resolve18("node_modules", ".bin", name);
-  return existsSync32(local) ? local : null;
+  const local = resolve22("node_modules", ".bin", name);
+  return existsSync37(local) ? local : null;
 }, ANSI_COLOR_REGEX, ANSI_PURPLE_REGEX, ANSI_CYAN_REGEX, ANSI_TOKEN_END_REGEX, stripAnsi3 = (str) => str.replace(ANSI_COLOR_REGEX, ""), formatSvelteOutput = (output) => {
   const cwd = `${process.cwd()}/`;
   const summaryMatch = stripAnsi3(output).match(/svelte-check found (\d+) error/);
@@ -176536,15 +177673,15 @@ Found ${errorCount} error${suffix}.`;
   return formatted;
 }, ABSOLUTE_INTERNAL_EXCLUDES, resolveAbsoluteTypeFile = (fileName) => {
   const candidates = [
-    resolve18("node_modules/@absolutejs/absolute/dist/types", fileName),
-    resolve18(import.meta.dir, "../types", fileName),
-    resolve18(import.meta.dir, "../../types", fileName),
-    resolve18(import.meta.dir, "../../../types", fileName)
+    resolve22("node_modules/@absolutejs/absolute/dist/types", fileName),
+    resolve22(import.meta.dir, "../types", fileName),
+    resolve22(import.meta.dir, "../../types", fileName),
+    resolve22(import.meta.dir, "../../../types", fileName)
   ];
-  return candidates.find((candidate) => existsSync32(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => existsSync37(candidate)) ?? candidates[0];
 }, ABSOLUTE_TYPECHECK_FILES, readProjectTsconfig = () => {
   try {
-    return JSON.parse(readFileSync30(resolve18("tsconfig.json"), "utf-8"));
+    return JSON.parse(readFileSync34(resolve22("tsconfig.json"), "utf-8"));
   } catch {
     return {};
   }
@@ -176572,22 +177709,22 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m vue-tsc is required for Vue type checking. Install it: bun add -d vue-tsc");
     process.exit(1);
   }
-  const vueTsconfigPath = join29(cacheDir, "tsconfig.vue-check.json");
+  const vueTsconfigPath = join32(cacheDir, "tsconfig.vue-check.json");
   return writeFile(vueTsconfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve18("tsconfig.json"),
+    extends: resolve22("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("vue-tsc", [
     vueTscBin,
     "--noEmit",
     "--project",
-    resolve18(vueTsconfigPath),
+    resolve22(vueTsconfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join29(cacheDir, "vue-tsc.tsbuildinfo"),
+    join32(cacheDir, "vue-tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildAngularCheck = async (cacheDir, angularDir) => {
@@ -176596,7 +177733,7 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m @angular/compiler-cli is required for Angular type checking. Install it: bun add -d @angular/compiler-cli");
     process.exit(1);
   }
-  const angularTsconfigPath = join29(cacheDir, "tsconfig.angular-check.json");
+  const angularTsconfigPath = join32(cacheDir, "tsconfig.angular-check.json");
   await writeFile(angularTsconfigPath, JSON.stringify({
     angularCompilerOptions: {
       strictTemplates: true
@@ -176606,32 +177743,32 @@ Found ${errorCount} error${suffix}.`;
       rootDir: ".."
     },
     exclude: ABSOLUTE_INTERNAL_EXCLUDES.map(toGeneratedConfigPath),
-    extends: resolve18("tsconfig.json"),
+    extends: resolve22("tsconfig.json"),
     include: [`../${angularDir}/**/*`]
   }, null, "\t"));
-  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve18(angularTsconfigPath))}`);
+  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve22(angularTsconfigPath))}`);
 }, buildTscCheck = (cacheDir) => {
   const tscBin = findBin("tsc");
   if (!tscBin) {
     console.error("\x1B[31m\u2717\x1B[0m typescript is required for type checking. Install it: bun add -d typescript");
     process.exit(1);
   }
-  const tscConfigPath = join29(cacheDir, "tsconfig.typecheck.json");
+  const tscConfigPath = join32(cacheDir, "tsconfig.typecheck.json");
   return writeFile(tscConfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve18("tsconfig.json"),
+    extends: resolve22("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("tsc", [
     tscBin,
     "--noEmit",
     "--project",
-    resolve18(tscConfigPath),
+    resolve22(tscConfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join29(cacheDir, "tsc.tsbuildinfo"),
+    join32(cacheDir, "tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildSvelteCheck = async (cacheDir, svelteDir) => {
@@ -176640,16 +177777,16 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m svelte-check is required for Svelte type checking. Install it: bun add -d svelte-check");
     process.exit(1);
   }
-  const svelteTsconfigPath = join29(cacheDir, "tsconfig.svelte-check.json");
+  const svelteTsconfigPath = join32(cacheDir, "tsconfig.svelte-check.json");
   await writeFile(svelteTsconfigPath, JSON.stringify({
-    extends: resolve18("tsconfig.json"),
+    extends: resolve22("tsconfig.json"),
     files: ABSOLUTE_TYPECHECK_FILES,
     include: [`../${svelteDir}/**/*`]
   }, null, "\t"));
   return run("svelte-check", [
     svelteBin,
     "--tsconfig",
-    resolve18(svelteTsconfigPath),
+    resolve22(svelteTsconfigPath),
     "--threshold",
     "error",
     "--compiler-warnings",
@@ -176838,11 +177975,11 @@ var DEFAULT_RELAY_PORT = 8787, DEFAULT_REQUEST_TIMEOUT_MS = 30000, headersToObje
         url: url.pathname + url.search,
         ...bodyBytes && bodyBytes.length > 0 ? { bodyBase64: Buffer.from(bodyBytes).toString("base64") } : {}
       };
-      const responsePromise = new Promise((resolve19) => {
-        pending.set(id, resolve19);
+      const responsePromise = new Promise((resolve23) => {
+        pending.set(id, resolve23);
       });
       client.send(encodeTunnelMessage(message));
-      const timeout = new Promise((resolve19) => setTimeout(() => resolve19({ id, message: "timeout", type: "error" }), requestTimeoutMs));
+      const timeout = new Promise((resolve23) => setTimeout(() => resolve23({ id, message: "timeout", type: "error" }), requestTimeoutMs));
       const result = await Promise.race([responsePromise, timeout]);
       pending.delete(id);
       if (result.type === "error") {
@@ -180298,15 +181435,15 @@ var stripNamedArgs = (...flags) => args.filter((_, idx) => flags.every((flag) =>
 if (command === "dev") {
   sendTelemetryEvent("cli:command", { command });
   const configPath2 = parseNamedArg("--config");
-  const positionalArgs = stripNamedArgs("--config");
-  const serverEntry = positionalArgs[0] ?? DEFAULT_SERVER_ENTRY;
+  const positionalArgs2 = stripNamedArgs("--config");
+  const serverEntry = positionalArgs2[0] ?? DEFAULT_SERVER_ENTRY;
   await dev(serverEntry, configPath2);
 } else if (command === "start") {
   sendTelemetryEvent("cli:command", { command });
   const outdir = parseNamedArg("--outdir");
   const configPath2 = parseNamedArg("--config");
-  const positionalArgs = stripNamedArgs("--outdir", "--config");
-  const serverEntry = positionalArgs[0] ?? DEFAULT_SERVER_ENTRY;
+  const positionalArgs2 = stripNamedArgs("--outdir", "--config");
+  const serverEntry = positionalArgs2[0] ?? DEFAULT_SERVER_ENTRY;
   await start(serverEntry, outdir, configPath2);
 } else if (command === "build") {
   sendTelemetryEvent("cli:command", { command });
@@ -180374,6 +181511,12 @@ if (command === "dev") {
   sendTelemetryEvent("cli:command", { command: "env" });
   const { runEnv: runEnv2 } = await Promise.resolve().then(() => (init_env(), exports_env));
   await runEnv2(args);
+} else if (command === "db") {
+  sendTelemetryEvent("cli:command", {
+    command: `db:${workspaceCommand ?? "unknown"}`
+  });
+  const { runDb: runDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  await runDb2(args);
 } else if (command === "logs") {
   sendTelemetryEvent("cli:command", { command: "logs" });
   const { runLogs: runLogs2 } = await Promise.resolve().then(() => (init_logs(), exports_logs));
@@ -180405,8 +181548,8 @@ if (command === "dev") {
   const outdir = parseNamedArg("--outdir");
   const outfile = parseNamedArg("--outfile");
   const configPath2 = parseNamedArg("--config");
-  const positionalArgs = stripNamedArgs("--outdir", "--outfile", "--config");
-  const serverEntry = positionalArgs[0] ?? DEFAULT_SERVER_ENTRY;
+  const positionalArgs2 = stripNamedArgs("--outdir", "--outfile", "--config");
+  const serverEntry = positionalArgs2[0] ?? DEFAULT_SERVER_ENTRY;
   const { compile: compile2 } = await Promise.resolve().then(() => (init_compile(), exports_compile));
   await compile2(serverEntry, outdir, outfile, configPath2);
 } else if (command === "typecheck") {
@@ -180433,6 +181576,7 @@ if (command === "dev") {
   console.error("  start [entry] [--outdir dir] Start production server");
   console.error("  compile [entry] [--outdir dir] [--outfile path] Compile standalone executable");
   console.error("  config [--port n] Open the unified config UI (ESLint, tsconfig, Prettier)");
+  console.error("  db <backup|restore|seed> Backup/restore any Postgres DB (ORM-agnostic, upsert by PK) or run the seed script");
   console.error("  doctor [--fix] [--json] Diagnose the project (bun, config, framework dirs, env, port)");
   console.error("  env [--check] [--json] Report env vars the app reads (getEnv) and which are missing");
   console.error("  add <framework> [--no-install] Add a framework (deps, config, starter page)");