@dereekb/dbx-cli 13.16.0 → 13.17.0

package/generate-route-manifest/main.js

@@ -0,0 +1,1137 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+
+// packages/dbx-cli/generate-route-manifest/src/generate-route-manifest/main.ts
+import { glob as fsGlob, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname as dirname2, isAbsolute, relative, resolve } from "node:path";
+
+// packages/dbx-cli/src/lib/route/route-extract.ts
+import { Node, Project, SyntaxKind } from "ts-morph";
+var ROUTE_MODEL_TAG_PREFIX = "dbxRouteModel";
+function extractFile(source) {
+  const project = new Project({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+  const sourceFile = project.createSourceFile(source.name, source.text, { overwrite: true });
+  const issues = [];
+  const objectLiteralsByName = collectStateConsts(sourceFile);
+  const collected = /* @__PURE__ */ new Map();
+  collectTypedStateConsts({ source, objectLiteralsByName, collected, issues });
+  collectArrayLiteralStates({ source, sourceFile, objectLiteralsByName, collected, issues });
+  const importedFromRelative = collectRelativeImports(sourceFile, source.name);
+  const result = {
+    nodes: Array.from(collected.values()),
+    issues,
+    importedFromRelative
+  };
+  return result;
+}
+function collectTypedStateConsts(input) {
+  const { source, objectLiteralsByName, collected, issues } = input;
+  for (const [name, info] of objectLiteralsByName) {
+    if (!info.typedAsState) continue;
+    addNode({ file: source.name, literal: info.literal, fallbackConstName: name, jsDocTags: info.jsDocTags, into: collected, issues });
+  }
+}
+function collectArrayLiteralStates(input) {
+  const { source, sourceFile, objectLiteralsByName, collected, issues } = input;
+  for (const arrayLit of findStateArrayLiterals(sourceFile)) {
+    for (const element of arrayLit.getElements()) {
+      collectArrayElement({ element, source, objectLiteralsByName, collected, issues });
+    }
+  }
+}
+function collectArrayElement(input) {
+  const { element, source, objectLiteralsByName, collected, issues } = input;
+  if (Node.isObjectLiteralExpression(element)) {
+    addNode({ file: source.name, literal: element, fallbackConstName: void 0, jsDocTags: void 0, into: collected, issues });
+    return;
+  }
+  if (Node.isIdentifier(element)) {
+    const ref = objectLiteralsByName.get(element.getText());
+    if (ref) {
+      addNode({ file: source.name, literal: ref.literal, fallbackConstName: element.getText(), jsDocTags: ref.jsDocTags, into: collected, issues });
+    }
+  }
+}
+function collectStateConsts(sourceFile) {
+  const out = /* @__PURE__ */ new Map();
+  for (const stmt of sourceFile.getVariableStatements()) {
+    const jsDocTags = collectRouteModelTags(stmt.getJsDocs());
+    for (const decl of stmt.getDeclarations()) {
+      const initializer = decl.getInitializer();
+      if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+        continue;
+      }
+      const typeNode = decl.getTypeNode();
+      const typedAsState = typeNode ? typeNode.getText() === "Ng2StateDeclaration" : false;
+      out.set(decl.getName(), { literal: initializer, typedAsState, jsDocTags });
+    }
+  }
+  return out;
+}
+function collectRouteModelTags(jsDocs) {
+  const out = [];
+  for (const jsDoc of jsDocs) {
+    for (const tag of jsDoc.getTags()) {
+      const name = tag.getTagName();
+      if (name.startsWith(ROUTE_MODEL_TAG_PREFIX)) {
+        out.push({ name, text: tag.getCommentText()?.trim() ?? "" });
+      }
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function findStateArrayLiterals(sourceFile) {
+  const arrays = [];
+  collectTopLevelStateArrays(sourceFile, arrays);
+  collectProvideStatesArrays(sourceFile, arrays);
+  return arrays;
+}
+function collectTopLevelStateArrays(sourceFile, arrays) {
+  for (const stmt of sourceFile.getVariableStatements()) {
+    for (const decl of stmt.getDeclarations()) {
+      const initializer = decl.getInitializer();
+      if (initializer && Node.isArrayLiteralExpression(initializer) && declarationIsStateArray(stmt, decl.getName(), initializer)) {
+        arrays.push(initializer);
+      }
+    }
+  }
+}
+function collectProvideStatesArrays(sourceFile, arrays) {
+  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    if (!isProvideStatesCall(call.getExpression().getText())) continue;
+    for (const arg of call.getArguments()) {
+      if (!Node.isObjectLiteralExpression(arg)) continue;
+      collectStatesArrayFromObjectArg(arg, sourceFile, arrays);
+    }
+  }
+}
+function isProvideStatesCall(exprText) {
+  if (exprText === "provideStates") return true;
+  return exprText.endsWith(".forChild") || exprText.endsWith(".forRoot");
+}
+function collectStatesArrayFromObjectArg(arg, sourceFile, arrays) {
+  const statesProp = arg.getProperty("states");
+  if (!statesProp || !Node.isPropertyAssignment(statesProp)) return;
+  const initializer = statesProp.getInitializer();
+  if (!initializer) return;
+  if (Node.isArrayLiteralExpression(initializer)) {
+    arrays.push(initializer);
+    return;
+  }
+  if (Node.isIdentifier(initializer)) {
+    const referenced = findArrayLiteralForIdentifier(sourceFile, initializer);
+    if (referenced) {
+      arrays.push(referenced);
+    }
+  }
+}
+function declarationIsStateArray(stmt, name, literal) {
+  const decl = stmt.getDeclarations().find((d) => d.getName() === name);
+  const typeNode = decl?.getTypeNode();
+  if (typeNode?.getText() === "Ng2StateDeclaration[]") {
+    return true;
+  }
+  for (const element of literal.getElements()) {
+    if (Node.isObjectLiteralExpression(element) && hasStringNameProperty(element)) {
+      return true;
+    }
+    if (Node.isIdentifier(element)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasStringNameProperty(literal) {
+  const nameProp = literal.getProperty("name");
+  if (!nameProp || !Node.isPropertyAssignment(nameProp)) {
+    return false;
+  }
+  const initializer = nameProp.getInitializer();
+  return initializer !== void 0 && (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer));
+}
+function findArrayLiteralForIdentifier(sourceFile, identifier) {
+  const name = identifier.getText();
+  for (const stmt of sourceFile.getVariableStatements()) {
+    for (const decl of stmt.getDeclarations()) {
+      if (decl.getName() !== name) {
+        continue;
+      }
+      const initializer = decl.getInitializer();
+      if (initializer && Node.isArrayLiteralExpression(initializer)) {
+        return initializer;
+      }
+    }
+  }
+  return void 0;
+}
+function addNode(options) {
+  const { file, literal, fallbackConstName, jsDocTags, into, issues } = options;
+  const stringField = (key) => stringPropertyValue(literal, key);
+  const name = stringField("name");
+  const line = literal.getStartLineNumber();
+  if (!name) {
+    issues.push({
+      code: "DYNAMIC_STATE_NAME",
+      severity: "info",
+      message: fallbackConstName ? `State \`${fallbackConstName}\` has no string-literal \`name\` field; skipping.` : `State at line ${line} has no string-literal \`name\` field; skipping.`,
+      file,
+      line,
+      stateName: void 0
+    });
+    return;
+  }
+  const futureState = name.endsWith(".**");
+  const explicitParent = stringField("parent");
+  const url = stringField("url");
+  const redirectTo = stringField("redirectTo");
+  const abstract = booleanPropertyValue(literal, "abstract") ?? false;
+  const component = identifierPropertyValue(literal, "component");
+  const paramKeys = objectPropertyKeys(literal, "params");
+  const resolveKeys = collectResolveKeys(literal);
+  const node = {
+    name,
+    url,
+    component,
+    explicitParent,
+    redirectTo,
+    abstract,
+    futureState,
+    paramKeys,
+    resolveKeys,
+    file,
+    line,
+    declaredAs: fallbackConstName,
+    jsDocTags
+  };
+  if (!into.has(name)) {
+    into.set(name, node);
+  }
+}
+function stringPropertyValue(literal, key) {
+  const prop = literal.getProperty(key);
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    return void 0;
+  }
+  const initializer = prop.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) {
+    return initializer.getLiteralText();
+  }
+  return void 0;
+}
+function booleanPropertyValue(literal, key) {
+  const prop = literal.getProperty(key);
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    return void 0;
+  }
+  const initializer = prop.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.getKind() === SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  return void 0;
+}
+function identifierPropertyValue(literal, key) {
+  const prop = literal.getProperty(key);
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    return void 0;
+  }
+  const initializer = prop.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (Node.isIdentifier(initializer)) {
+    return initializer.getText();
+  }
+  if (Node.isPropertyAccessExpression(initializer)) {
+    return initializer.getText();
+  }
+  return void 0;
+}
+function objectPropertyKeys(literal, key) {
+  const prop = literal.getProperty(key);
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    return [];
+  }
+  const initializer = prop.getInitializer();
+  if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+    return [];
+  }
+  const out = [];
+  for (const member of initializer.getProperties()) {
+    if (Node.isPropertyAssignment(member) || Node.isShorthandPropertyAssignment(member) || Node.isMethodDeclaration(member)) {
+      const nameNode = member.getNameNode();
+      if (nameNode) {
+        out.push(nameNode.getText());
+      }
+    }
+  }
+  return out;
+}
+function collectResolveKeys(literal) {
+  const prop = literal.getProperty("resolve");
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    return [];
+  }
+  const initializer = prop.getInitializer();
+  if (!initializer) {
+    return [];
+  }
+  if (Node.isObjectLiteralExpression(initializer)) {
+    return collectResolveKeysFromObject(initializer);
+  }
+  if (Node.isArrayLiteralExpression(initializer)) {
+    return collectResolveKeysFromArray(initializer);
+  }
+  return [];
+}
+function collectResolveKeysFromObject(initializer) {
+  const keys = [];
+  for (const member of initializer.getProperties()) {
+    if (!Node.isPropertyAssignment(member) && !Node.isShorthandPropertyAssignment(member) && !Node.isMethodDeclaration(member)) continue;
+    const nameNode = member.getNameNode();
+    if (nameNode) {
+      keys.push(nameNode.getText());
+    }
+  }
+  return keys;
+}
+function collectResolveKeysFromArray(initializer) {
+  const keys = [];
+  for (const element of initializer.getElements()) {
+    if (!Node.isObjectLiteralExpression(element)) continue;
+    const token = readResolveTokenValue(element);
+    if (token !== void 0) {
+      keys.push(token);
+    }
+  }
+  return keys;
+}
+function readResolveTokenValue(element) {
+  const tokenProp = element.getProperty("token");
+  if (!tokenProp || !Node.isPropertyAssignment(tokenProp)) return void 0;
+  const tokenInit = tokenProp.getInitializer();
+  if (!tokenInit || !Node.isStringLiteral(tokenInit) && !Node.isIdentifier(tokenInit)) return void 0;
+  return tokenInit.getText().replaceAll(/^['"]|['"]$/g, "");
+}
+function collectRelativeImports(sourceFile, fileName) {
+  const out = [];
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const specifier = decl.getModuleSpecifierValue();
+    if (specifier.startsWith(".")) {
+      out.push({ moduleSpecifier: specifier, file: fileName });
+    }
+  }
+  return out;
+}
+
+// packages/dbx-cli/src/lib/route/route-build-tree.ts
+// @__NO_SIDE_EFFECTS__
+function buildRouteTree(nodes, extractIssues) {
+  const issues = [...extractIssues];
+  const byName = /* @__PURE__ */ new Map();
+  insertNodes(nodes, byName, issues);
+  wireParentLinks(byName, issues);
+  detectCycles(byName, issues);
+  composeFullUrls(byName);
+  const roots = collectRoots(byName);
+  sortChildren(byName, roots);
+  const { frozen, frozenRoots } = freezeTree(roots);
+  const result = {
+    roots: frozenRoots,
+    byName: frozen,
+    issues,
+    filesChecked: 0,
+    nodeCount: byName.size
+  };
+  return result;
+}
+function insertNodes(nodes, byName, issues) {
+  for (const node of nodes) {
+    if (byName.has(node.name)) {
+      issues.push({
+        code: "DUPLICATE_STATE_NAME",
+        severity: "error",
+        message: `State \`${node.name}\` is declared in multiple places. Keeping the first declaration.`,
+        file: node.file,
+        line: node.line,
+        stateName: node.name
+      });
+      continue;
+    }
+    byName.set(node.name, { data: node, fullUrl: void 0, parent: void 0, children: [] });
+  }
+}
+function wireParentLinks(byName, issues) {
+  for (const treeNode of byName.values()) {
+    const parentName = resolveParentName(treeNode.data, byName);
+    if (!parentName) continue;
+    const parent = byName.get(parentName);
+    if (!parent) {
+      issues.push({
+        code: "ORPHAN_STATE",
+        severity: "warning",
+        message: `State \`${treeNode.data.name}\` references parent \`${parentName}\` which is not declared in the analyzed sources.`,
+        file: treeNode.data.file,
+        line: treeNode.data.line,
+        stateName: treeNode.data.name
+      });
+      continue;
+    }
+    treeNode.parent = parent;
+    parent.children.push(treeNode);
+  }
+}
+function detectCycles(byName, issues) {
+  for (const treeNode of byName.values()) {
+    if (!treeNode.parent) continue;
+    detectCycleFor(treeNode, issues);
+  }
+}
+function detectCycleFor(treeNode, issues) {
+  const seen = /* @__PURE__ */ new Set();
+  seen.add(treeNode.data.name);
+  let cursor = treeNode.parent;
+  while (cursor) {
+    if (seen.has(cursor.data.name)) {
+      issues.push({
+        code: "CYCLE_DETECTED",
+        severity: "error",
+        message: `Cycle detected involving \`${treeNode.data.name}\` and \`${cursor.data.name}\`. Severing the parent link.`,
+        file: treeNode.data.file,
+        line: treeNode.data.line,
+        stateName: treeNode.data.name
+      });
+      detachFromParent(treeNode);
+      return;
+    }
+    seen.add(cursor.data.name);
+    cursor = cursor.parent;
+  }
+}
+function detachFromParent(treeNode) {
+  if (!treeNode.parent) return;
+  const idx = treeNode.parent.children.indexOf(treeNode);
+  if (idx >= 0) {
+    treeNode.parent.children.splice(idx, 1);
+  }
+  treeNode.parent = void 0;
+}
+function composeFullUrls(byName) {
+  for (const treeNode of byName.values()) {
+    treeNode.fullUrl = composeFullUrl(treeNode);
+  }
+}
+function collectRoots(byName) {
+  const roots = [];
+  for (const treeNode of byName.values()) {
+    if (!treeNode.parent) {
+      roots.push(treeNode);
+    }
+  }
+  return roots;
+}
+function sortChildren(byName, roots) {
+  for (const treeNode of byName.values()) {
+    treeNode.children.sort(compareByName);
+  }
+  roots.sort(compareByName);
+}
+function freezeTree(roots) {
+  const frozen = /* @__PURE__ */ new Map();
+  const freeze = (mut) => {
+    const existing = frozen.get(mut.data.name);
+    if (existing) return existing;
+    const placeholder = {
+      data: mut.data,
+      fullUrl: mut.fullUrl,
+      parent: void 0,
+      children: []
+    };
+    frozen.set(mut.data.name, placeholder);
+    placeholder.parent = mut.parent ? freeze(mut.parent) : void 0;
+    placeholder.children = mut.children.map(freeze);
+    return placeholder;
+  };
+  const frozenRoots = roots.map(freeze);
+  return { frozen, frozenRoots };
+}
+function resolveParentName(node, byName) {
+  if (node.explicitParent) {
+    return node.explicitParent;
+  }
+  const lookupName = node.name.endsWith(".**") ? node.name.slice(0, -3) : node.name;
+  const lastDot = lookupName.lastIndexOf(".");
+  if (lastDot < 0) {
+    return void 0;
+  }
+  const candidate = lookupName.slice(0, lastDot);
+  if (byName.has(candidate)) {
+    return candidate;
+  }
+  return candidate;
+}
+function composeFullUrl(node) {
+  const segments = [];
+  let cursor = node;
+  while (cursor) {
+    if (cursor.data.url !== void 0) {
+      segments.unshift(cursor.data.url);
+    }
+    cursor = cursor.parent;
+  }
+  if (segments.length === 0) {
+    return void 0;
+  }
+  const joined = segments.join("");
+  const collapsed = joined.replaceAll(/\/{2,}/g, "/");
+  return collapsed.length === 0 ? "/" : collapsed;
+}
+function compareByName(a, b) {
+  if (a.data.name < b.data.name) {
+    return -1;
+  }
+  if (a.data.name > b.data.name) {
+    return 1;
+  }
+  return 0;
+}
+
+// packages/dbx-cli/src/lib/route/route-resolve-sources.ts
+function resolveRouteSources(sources) {
+  const nodes = [];
+  const issues = [];
+  for (const source of sources) {
+    const extracted = extractFile(source);
+    for (const node of extracted.nodes) {
+      nodes.push(node);
+    }
+    for (const issue of extracted.issues) {
+      issues.push(issue);
+    }
+  }
+  const result = {
+    nodes,
+    issues,
+    filesChecked: sources.length
+  };
+  return result;
+}
+
+// packages/dbx-cli/src/lib/route/route-load-tree.ts
+function loadRouteTree(args) {
+  const resolved = resolveRouteSources(args.sources);
+  const tree = buildRouteTree(resolved.nodes, resolved.issues);
+  const result = {
+    roots: tree.roots,
+    byName: tree.byName,
+    issues: tree.issues,
+    filesChecked: resolved.filesChecked,
+    nodeCount: tree.nodeCount
+  };
+  return result;
+}
+
+// packages/dbx-cli/src/lib/route/url-match.ts
+function extractUrlParamKeys(fullUrl) {
+  if (fullUrl === void 0 || fullUrl.length === 0) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const keys = [];
+  for (const segment of fullUrl.split("/")) {
+    const key = extractParamKeyFromSegment(segment);
+    if (key !== void 0 && !seen.has(key)) {
+      seen.add(key);
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+function extractParamKeyFromSegment(segment) {
+  if (segment.startsWith(":")) {
+    const key = segment.slice(1);
+    return key.length > 0 ? key : void 0;
+  }
+  if (segment.startsWith("{") && segment.endsWith("}")) {
+    const inner = segment.slice(1, -1);
+    const colonIdx = inner.indexOf(":");
+    const rawKey = colonIdx >= 0 ? inner.slice(0, colonIdx) : inner;
+    const key = rawKey.trim();
+    return key.length > 0 ? key : void 0;
+  }
+  return void 0;
+}
+
+// packages/dbx-cli/src/lib/route/component-resolve.ts
+import { dirname, join, normalize } from "node:path/posix";
+var TRY_EXTENSIONS = [".ts", ".tsx", "/index.ts", "/index.tsx"];
+function resolveComponentSourceFromSources(input) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const source of input.sources) {
+    byName.set(source.name, source);
+  }
+  const routerSource = byName.get(input.routerFile);
+  let result;
+  if (routerSource !== void 0) {
+    const specifier = findImportSpecifier(routerSource.text, input.component);
+    if (specifier !== void 0) {
+      result = resolveSpecifier(specifier, input.routerFile, byName);
+    }
+  }
+  return result;
+}
+function resolveSpecifier(specifier, routerFile, byName) {
+  let result;
+  if (specifier.startsWith(".")) {
+    const base = normalize(join(dirname(routerFile), specifier));
+    let resolved;
+    for (const ext of TRY_EXTENSIONS) {
+      const candidate = base + ext;
+      if (byName.has(candidate)) {
+        resolved = candidate;
+        break;
+      }
+    }
+    result = { path: resolved ?? specifier, moduleSpecifier: specifier };
+  } else {
+    result = { path: specifier, moduleSpecifier: specifier };
+  }
+  return result;
+}
+function findImportSpecifier(text, component) {
+  const importRegex = /import\s+[^'"]+from\s+['"]([^'"]+)['"]/gu;
+  let result;
+  let match = importRegex.exec(text);
+  while (match !== null) {
+    if (containsImportedSymbol(match[0], component)) {
+      result = match[1];
+      break;
+    }
+    match = importRegex.exec(text);
+  }
+  return result;
+}
+function containsImportedSymbol(importStatement, symbol) {
+  const braceStart = importStatement.indexOf("{");
+  const braceEnd = importStatement.indexOf("}");
+  let result = false;
+  if (braceStart >= 0 && braceEnd > braceStart) {
+    const inside = importStatement.slice(braceStart + 1, braceEnd);
+    for (const raw of inside.split(",")) {
+      const cleaned = raw.replace(/\s+as\s+\w+/u, "").trim();
+      if (cleaned === symbol) {
+        result = true;
+        break;
+      }
+    }
+  }
+  if (!result) {
+    const defaultRegex = new RegExp(String.raw`^import\s+(?:type\s+)?(${symbol})\s+from\s+`, "u");
+    result = defaultRegex.test(importStatement);
+  }
+  return result;
+}
+
+// packages/dbx-cli/src/lib/route/route-model-tag.ts
+var MODEL_TYPE_RE = /^[a-zA-Z][a-zA-Z0-9]*$/u;
+var LITERAL_SEGMENT_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/u;
+var AUTH_UID_PLACEHOLDER = "{authUid}";
+var ROUTE_MODEL_TAG = "dbxRouteModel";
+var ROUTE_MODEL_LIST_TAG = "dbxRouteModelList";
+function parseRouteModelTag(tag) {
+  const dashIdx = tag.text.indexOf(" - ");
+  const head = (dashIdx >= 0 ? tag.text.slice(0, dashIdx) : tag.text).trim();
+  const description = dashIdx >= 0 ? tag.text.slice(dashIdx + 3).trim() : void 0;
+  const tokens = head.split(/\s+/u).filter((t) => t.length > 0);
+  let result;
+  if (tag.name === ROUTE_MODEL_LIST_TAG) {
+    result = parseListTag(tokens, description);
+  } else if (tag.name === ROUTE_MODEL_TAG) {
+    result = parseModelTag(tokens, description);
+  } else {
+    result = { ok: false, message: `Unknown route-model tag \`@${tag.name}\`. Expected \`@${ROUTE_MODEL_TAG}\` or \`@${ROUTE_MODEL_LIST_TAG}\`.` };
+  }
+  return result;
+}
+function parseListTag(tokens, description) {
+  let result;
+  if (tokens.length !== 1) {
+    result = { ok: false, message: `\`@${ROUTE_MODEL_LIST_TAG}\` expects a single \`<modelType>\` token; got ${tokens.length}.` };
+  } else if (MODEL_TYPE_RE.test(tokens[0])) {
+    result = { ok: true, model: { modelType: tokens[0], kind: "list", description, routeParams: [] } };
+  } else {
+    result = { ok: false, message: `\`@${ROUTE_MODEL_LIST_TAG}\` model type \`${tokens[0]}\` is not a valid identifier.` };
+  }
+  return result;
+}
+function parseModelTag(tokens, description) {
+  let result;
+  if (tokens.length !== 2) {
+    result = { ok: false, message: `\`@${ROUTE_MODEL_TAG}\` expects \`<modelType> <keyTemplate>\`; got ${tokens.length} token(s).` };
+  } else if (MODEL_TYPE_RE.test(tokens[0])) {
+    const parsedKey = parseKeyTemplate(tokens[1]);
+    if (parsedKey.ok) {
+      result = { ok: true, model: { modelType: tokens[0], kind: parsedKey.kind, keyTemplate: tokens[1], description, routeParams: parsedKey.routeParams } };
+    } else {
+      result = { ok: false, message: parsedKey.message };
+    }
+  } else {
+    result = { ok: false, message: `\`@${ROUTE_MODEL_TAG}\` model type \`${tokens[0]}\` is not a valid identifier.` };
+  }
+  return result;
+}
+function parseKeyTemplate(keyTemplate) {
+  const segments = keyTemplate.split("/");
+  let result;
+  if (segments.length === 1) {
+    result = parseSingleSegmentKey(segments[0], keyTemplate);
+  } else if (segments.length % 2 === 0) {
+    result = parseAlternatingKey(segments, keyTemplate);
+  } else {
+    result = { ok: false, message: `Key template \`${keyTemplate}\` must be a single placeholder or an even number of literal/placeholder segments.` };
+  }
+  return result;
+}
+function parseSingleSegmentKey(segment, keyTemplate) {
+  const placeholder = placeholderParam(segment);
+  let result;
+  if (placeholder === void 0) {
+    result = { ok: false, message: `Single-segment key template \`${keyTemplate}\` must be a placeholder (\`:param\` or \`${AUTH_UID_PLACEHOLDER}\`).` };
+  } else {
+    result = { ok: true, kind: "id", routeParams: placeholder.routeParam === void 0 ? [] : [placeholder.routeParam] };
+  }
+  return result;
+}
+function parseAlternatingKey(segments, keyTemplate) {
+  const routeParams = [];
+  let message;
+  for (const [i, segment] of segments.entries()) {
+    if (i % 2 === 0) {
+      if (!LITERAL_SEGMENT_RE.test(segment)) {
+        message = `Key template \`${keyTemplate}\` segment \`${segment}\` must be a literal collection name.`;
+        break;
+      }
+    } else {
+      const placeholder = placeholderParam(segment);
+      if (placeholder === void 0) {
+        message = `Key template \`${keyTemplate}\` segment \`${segment}\` must be a placeholder (\`:param\` or \`${AUTH_UID_PLACEHOLDER}\`).`;
+        break;
+      }
+      if (placeholder.routeParam !== void 0) {
+        routeParams.push(placeholder.routeParam);
+      }
+    }
+  }
+  return message === void 0 ? { ok: true, kind: "key", routeParams } : { ok: false, message };
+}
+function placeholderParam(segment) {
+  let result;
+  if (segment.startsWith(":") && segment.length > 1) {
+    result = { routeParam: segment.slice(1) };
+  } else if (segment === AUTH_UID_PLACEHOLDER) {
+    result = { routeParam: void 0 };
+  } else {
+    result = void 0;
+  }
+  return result;
+}
+
+// packages/dbx-cli/src/lib/route/route-models-extract.ts
+function extractComponentRouteModelTags(sourceFile, component) {
+  const cls = sourceFile.getClass(component);
+  return cls === void 0 ? [] : collectRouteModelTags2(cls.getJsDocs());
+}
+function collectRouteModelTags2(jsDocs) {
+  const out = [];
+  for (const jsDoc of jsDocs) {
+    for (const tag of jsDoc.getTags()) {
+      const name = tag.getTagName();
+      if (name.startsWith(ROUTE_MODEL_TAG)) {
+        out.push({ name, text: tag.getCommentText()?.trim() ?? "" });
+      }
+    }
+  }
+  return out;
+}
+
+// packages/dbx-cli/src/lib/route/route-manifest.ts
+import { Project as Project2 } from "ts-morph";
+var ROUTE_MANIFEST_VERSION = 1;
+function buildRouteManifest(input, now = /* @__PURE__ */ new Date()) {
+  const warnings = [];
+  const tree = loadRouteTree({ sources: input.sources });
+  const project = buildSourceProject(input.sources);
+  const modelTypeSet = input.modelTypes == null ? void 0 : new Set(input.modelTypes);
+  const realNames = collectRealStateNames(tree);
+  warnDroppedFutureStates(tree, realNames, warnings);
+  const ownModelsByName = /* @__PURE__ */ new Map();
+  for (const node of tree.byName.values()) {
+    if (node.data.futureState) {
+      continue;
+    }
+    ownModelsByName.set(node.data.name, computeOwnModels({ node, project, sources: input.sources, modelTypeSet, warnings }));
+  }
+  const states = [];
+  for (const node of tree.byName.values()) {
+    if (node.data.futureState) {
+      continue;
+    }
+    states.push(buildStateEntry({ node, ownModelsByName, sources: input.sources }));
+  }
+  states.sort((a, b) => a.name.localeCompare(b.name));
+  detectMissingRouteModels(states, warnings);
+  const manifest = {
+    version: ROUTE_MANIFEST_VERSION,
+    generatedAt: now.toISOString(),
+    app: input.app.baseUrl == null ? { name: input.app.name } : { name: input.app.name, baseUrl: input.app.baseUrl },
+    states
+  };
+  return { manifest, warnings };
+}
+function buildSourceProject(sources) {
+  const project = new Project2({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+  for (const source of sources) {
+    project.createSourceFile(source.name, source.text, { overwrite: true });
+  }
+  return project;
+}
+function collectRealStateNames(tree) {
+  const names = /* @__PURE__ */ new Set();
+  for (const node of tree.byName.values()) {
+    if (!node.data.futureState) {
+      names.add(node.data.name);
+    }
+  }
+  return names;
+}
+function warnDroppedFutureStates(tree, realNames, warnings) {
+  for (const node of tree.byName.values()) {
+    if (!node.data.futureState) {
+      continue;
+    }
+    const prefix = node.data.name.slice(0, -3);
+    const hasRealSubtree = realNames.has(prefix) || [...realNames].some((name) => name.startsWith(`${prefix}.`));
+    if (!hasRealSubtree) {
+      warnings.push({ kind: "dropped-future-state", severity: "warning", message: `Future state \`${node.data.name}\` was dropped and has no real subtree under \`${prefix}\`; its page will not match any URL.`, stateName: node.data.name });
+    }
+  }
+}
+function computeOwnModels(input) {
+  const { node, project, sources, modelTypeSet, warnings } = input;
+  const componentModels = parseComponentModels({ node, project, sources, warnings });
+  const stateModels = parseStateModels({ node, warnings });
+  const overriddenTypes = new Set(stateModels.map((m) => m.modelType));
+  const merged = [...componentModels.filter((m) => !overriddenTypes.has(m.modelType)), ...stateModels];
+  const urlParamKeys = new Set(extractUrlParamKeys(node.fullUrl));
+  const deduped = dedupeModels({ models: merged, stateName: node.data.name, warnings });
+  return deduped.map((m) => finalizeModel({ model: m, stateName: node.data.name, urlParamKeys, modelTypeSet, warnings }));
+}
+function parseComponentModels(input) {
+  const { node, project, sources, warnings } = input;
+  const component = node.data.component;
+  if (component == null) {
+    return [];
+  }
+  const resolved = resolveComponentSourceFromSources({ routerFile: node.data.file, component, sources });
+  const componentFile = resolved?.path;
+  if (componentFile == null) {
+    return [];
+  }
+  const sourceFile = project.getSourceFile(componentFile);
+  if (sourceFile == null) {
+    return [];
+  }
+  return parseTags({ tags: extractComponentRouteModelTags(sourceFile, component), stateName: node.data.name, warnings });
+}
+function parseStateModels(input) {
+  const tags = input.node.data.jsDocTags ?? [];
+  return parseTags({ tags, stateName: input.node.data.name, warnings: input.warnings });
+}
+function parseTags(input) {
+  const out = [];
+  for (const tag of input.tags) {
+    const parsed = parseRouteModelTag(tag);
+    if (parsed.ok) {
+      out.push(parsed.model);
+    } else {
+      input.warnings.push({ kind: "malformed-tag", severity: "error", message: parsed.message, stateName: input.stateName });
+    }
+  }
+  return out;
+}
+function dedupeModels(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const model of input.models) {
+    const key = modelDedupeKey(model.modelType, model.keyTemplate);
+    if (seen.has(key)) {
+      const keyPart = model.keyTemplate == null ? "" : ` ${model.keyTemplate}`;
+      input.warnings.push({ kind: "duplicate-route-model", severity: "warning", message: `State \`${input.stateName}\` declares \`${model.modelType}\`${keyPart} more than once; keeping the first.`, stateName: input.stateName, modelType: model.modelType });
+      continue;
+    }
+    seen.add(key);
+    out.push(model);
+  }
+  return out;
+}
+function finalizeModel(input) {
+  const { model, stateName, urlParamKeys, modelTypeSet, warnings } = input;
+  for (const routeParam of model.routeParams) {
+    if (!urlParamKeys.has(routeParam)) {
+      warnings.push({ kind: "unknown-route-param", severity: "warning", message: `State \`${stateName}\` model \`${model.modelType}\` references route param \`:${routeParam}\` not present in the composed URL.`, stateName, modelType: model.modelType });
+    }
+  }
+  if (modelTypeSet != null && !modelTypeSet.has(model.modelType)) {
+    warnings.push({ kind: "unknown-model-type", severity: "warning", message: `State \`${stateName}\` references unknown model type \`${model.modelType}\`.`, stateName, modelType: model.modelType });
+  }
+  return {
+    modelType: model.modelType,
+    kind: model.kind,
+    ...model.keyTemplate == null ? {} : { keyTemplate: model.keyTemplate },
+    ...model.description == null ? {} : { description: model.description }
+  };
+}
+function modelDedupeKey(modelType, keyTemplate) {
+  return `${modelType}#${keyTemplate ?? ""}`;
+}
+function buildStateEntry(input) {
+  const { node, ownModelsByName, sources } = input;
+  const models = flattenInheritedModels(node, ownModelsByName);
+  const componentFile = resolveComponentFilePath(node, sources);
+  const parentName = node.parent != null && !node.parent.data.futureState ? node.parent.data.name : void 0;
+  const urlParamKeys = extractUrlParamKeys(node.fullUrl);
+  return {
+    name: node.data.name,
+    ...node.data.url == null ? {} : { url: node.data.url },
+    ...node.fullUrl == null ? {} : { fullUrl: node.fullUrl },
+    ...parentName == null ? {} : { parentName },
+    paramKeys: node.data.paramKeys,
+    urlParamKeys,
+    ...node.data.component == null ? {} : { component: node.data.component },
+    ...componentFile == null ? {} : { componentFile },
+    ...node.data.abstract ? { abstract: true } : {},
+    ...node.data.redirectTo == null ? {} : { redirectTo: node.data.redirectTo },
+    models
+  };
+}
+function flattenInheritedModels(node, ownModelsByName) {
+  const out = [...ownModelsByName.get(node.data.name) ?? []];
+  const seen = new Set(out.map((m) => modelDedupeKey(m.modelType, m.keyTemplate)));
+  let cursor = node.parent;
+  while (cursor) {
+    if (!cursor.data.futureState) {
+      for (const model of ownModelsByName.get(cursor.data.name) ?? []) {
+        const key = modelDedupeKey(model.modelType, model.keyTemplate);
+        if (!seen.has(key)) {
+          seen.add(key);
+          out.push({ ...model, from: cursor.data.name });
+        }
+      }
+    }
+    cursor = cursor.parent;
+  }
+  return out;
+}
+function resolveComponentFilePath(node, sources) {
+  const component = node.data.component;
+  if (component == null) {
+    return void 0;
+  }
+  const resolved = resolveComponentSourceFromSources({ routerFile: node.data.file, component, sources });
+  if (resolved == null) {
+    return void 0;
+  }
+  return sources.some((s) => s.name === resolved.path) ? resolved.path : void 0;
+}
+var ID_LIKE_ROUTE_PARAM_RE = /(?:id|uid)$/iu;
+function isIdLikeRouteParam(name) {
+  return ID_LIKE_ROUTE_PARAM_RE.test(name);
+}
+function routeParamsFromKeyTemplate(keyTemplate) {
+  if (keyTemplate == null) {
+    return [];
+  }
+  return keyTemplate.split("/").filter((segment) => segment.startsWith(":") && segment.length > 1).map((segment) => segment.slice(1));
+}
+function detectMissingRouteModels(states, warnings) {
+  for (const state of states) {
+    if (state.abstract) {
+      continue;
+    }
+    const covered = /* @__PURE__ */ new Set();
+    for (const model of state.models) {
+      for (const param of routeParamsFromKeyTemplate(model.keyTemplate)) {
+        covered.add(param);
+      }
+    }
+    for (const param of state.urlParamKeys) {
+      if (isIdLikeRouteParam(param) && !covered.has(param)) {
+        warnings.push({ kind: "missing-route-model", severity: "warning", message: `State \`${state.name}\` has id-like route param \`:${param}\` but no \`@dbxRouteModel\` binding covers it; annotate the component class or state.`, stateName: state.name, param });
+      }
+    }
+  }
+}
+
+// packages/dbx-cli/generate-route-manifest/src/generate-route-manifest/render.ts
+function renderRouteManifest(input, now = /* @__PURE__ */ new Date()) {
+  return buildRouteManifest({ app: input.app, sources: input.sources, ...input.modelTypes == null ? {} : { modelTypes: input.modelTypes } }, now);
+}
+function formatRouteManifestWarning(warning) {
+  return `[generate-route-manifest] ${warning.severity}: ${warning.kind}: ${warning.message}`;
+}
+function countRouteManifestGenerationErrors(input) {
+  return input.warnings.filter((warning) => warning.severity === "error" || input.strict && warning.severity === "warning").length;
+}
+function extractModelTypesFromModelsInput(parsed) {
+  const models = parsed?.models;
+  const out = [];
+  if (Array.isArray(models)) {
+    for (const model of models) {
+      const modelType = model?.modelType;
+      if (typeof modelType === "string" && modelType.length > 0) {
+        out.push(modelType);
+      }
+    }
+  }
+  return out;
+}
+
+// packages/dbx-cli/generate-route-manifest/src/generate-route-manifest/main.ts
+var WORKSPACE_ROOT = process.cwd();
+async function main() {
+  const flags = parseFlags(process.argv.slice(2));
+  if (flags.src.length === 0 || flags.app == null || flags.output == null) {
+    printUsageAndExit();
+    return;
+  }
+  const outputPath = resolveWorkspacePath(flags.output);
+  const sources = await loadSources(flags.src);
+  if (sources.length === 0) {
+    console.error(`generate-route-manifest: no source files matched ${describePatterns(flags.src)}.`);
+    process.exit(1);
+  }
+  const modelTypes = await maybeLoadModelTypes(flags.modelsInput);
+  const app = flags.baseUrl == null ? { name: flags.app } : { name: flags.app, baseUrl: flags.baseUrl };
+  const { manifest, warnings } = renderRouteManifest({ app, sources, ...modelTypes == null ? {} : { modelTypes } });
+  for (const warning of warnings) {
+    console.error(formatRouteManifestWarning(warning));
+  }
+  if (manifest.states.length === 0) {
+    console.error(`generate-route-manifest: 0 states extracted from ${describePatterns(flags.src)}; not writing ${relative(WORKSPACE_ROOT, outputPath)}.`);
+    process.exit(1);
+  }
+  const errorCount = countRouteManifestGenerationErrors({ warnings, strict: flags.strict });
+  if (errorCount > 0) {
+    console.error(`generate-route-manifest: ${errorCount} error-severity issue(s)${flags.strict ? " (--strict)" : ""}; not writing ${relative(WORKSPACE_ROOT, outputPath)}.`);
+    process.exit(1);
+  }
+  const serialized = `${JSON.stringify(manifest, null, 2)}
+`;
+  await ensureOutputDir(dirname2(outputPath));
+  const tmpPath = `${outputPath}.tmp`;
+  await writeFile(tmpPath, serialized);
+  await rename(tmpPath, outputPath);
+  const modelCount = manifest.states.reduce((sum, state) => sum + state.models.length, 0);
+  console.log(`[wrote] ${relative(WORKSPACE_ROOT, outputPath)} \u2014 ${manifest.states.length} states, ${modelCount} model bindings, ${warnings.length} warning(s)`);
+}
+async function loadSources(patterns) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const pattern of patterns) {
+    for await (const match of fsGlob(pattern, { cwd: WORKSPACE_ROOT })) {
+      const name = normalizeName(match);
+      if (!byName.has(name)) {
+        const text = await readFile(resolve(WORKSPACE_ROOT, match), "utf8");
+        byName.set(name, { name, text });
+      }
+    }
+  }
+  return Array.from(byName.values());
+}
+async function maybeLoadModelTypes(modelsInput) {
+  if (modelsInput == null) {
+    return void 0;
+  }
+  const path = resolveWorkspacePath(modelsInput);
+  if (!existsSync(path)) {
+    console.error(`[generate-route-manifest] --models-input not found: ${relative(WORKSPACE_ROOT, path)}; skipping unknown-model-type validation.`);
+    return void 0;
+  }
+  const parsed = JSON.parse(await readFile(path, "utf8"));
+  return extractModelTypesFromModelsInput(parsed);
+}
+function normalizeName(match) {
+  return match.split("\\").join("/");
+}
+function describePatterns(patterns) {
+  return patterns.map((pattern) => `\`${pattern}\``).join(", ");
+}
+async function ensureOutputDir(outputDir) {
+  if (!existsSync(outputDir)) {
+    await mkdir(outputDir, { recursive: true });
+  }
+}
+function resolveWorkspacePath(value) {
+  return isAbsolute(value) ? value : resolve(WORKSPACE_ROOT, value);
+}
+function parseFlags(argv) {
+  const src = [];
+  let app;
+  let baseUrl;
+  let output;
+  let modelsInput;
+  let strict = false;
+  for (const arg of argv) {
+    if (arg.startsWith("--src=")) {
+      src.push(arg.slice("--src=".length));
+    } else if (arg.startsWith("--app=")) {
+      app = arg.slice("--app=".length);
+    } else if (arg.startsWith("--base-url=")) {
+      baseUrl = arg.slice("--base-url=".length);
+    } else if (arg.startsWith("--output=")) {
+      output = arg.slice("--output=".length);
+    } else if (arg.startsWith("--models-input=")) {
+      modelsInput = arg.slice("--models-input=".length);
+    } else if (arg === "--strict") {
+      strict = true;
+    }
+  }
+  return { src, app, baseUrl, output, modelsInput, strict };
+}
+function printUsageAndExit() {
+  console.error(String.raw`generate-route-manifest
+
+Usage:
+  node dist/packages/dbx-cli/generate-route-manifest/main.js \
+    --src='apps/demo/src/**/*.ts' \
+    --app=demo \
+    --output=dist/apps/demo-api/route.manifest.json
+
+Required flags:
+  --src=<glob>               Source glob (repeatable), e.g. 'apps/demo/src/**/*.ts'.
+  --app=<slug>               App name stamped onto the manifest.
+  --output=<path>            Path to the route manifest JSON to write (workspace-relative ok).
+
+Optional:
+  --base-url=<url>           Public base URL stamped onto the manifest.
+  --models-input=<path>      MCP manifest JSON whose models[].modelType seed the
+                             unknown-model-type validation.
+  --strict                   Promote all warnings to errors for the exit decision
+                             (any finding then fails generation).`);
+  process.exit(1);
+}
+try {
+  await main();
+} catch (e) {
+  console.error(e);
+  process.exit(1);
+}