@ontrails/warden 1.0.0-beta.23 → 1.0.0-beta.29

package/src/rules/trail-versioning-source.ts

@@ -2,6 +2,22 @@ import {
   findBlazeBodies,
   findConfigProperty,
   findTrailDefinitions,
+  getNodeArgument,
+  getNodeArguments,
+  getNodeCallee,
+  getNodeElements,
+  getNodeExpression,
+  getNodeId,
+  getNodeInit,
+  getNodeKey,
+  getNodeLeft,
+  getNodeName,
+  getNodeObject,
+  getNodeParams,
+  getNodeProperties,
+  getNodeProperty,
+  getNodeValue,
+  getNodeValueNode,
   isMemberAccessNonComputed,
   offsetToLine,
   parse,
@@ -148,14 +164,14 @@ const diagnostic = (
 
 const staticPropertyKeyName = (node: AstNode | undefined): string | null => {
   if (node?.type === 'Identifier') {
-    return (node as unknown as { name?: string }).name ?? null;
+    return getNodeName(node) ?? null;
   }
   if (
     node?.type === 'Literal' ||
     node?.type === 'StringLiteral' ||
     node?.type === 'NumericLiteral'
   ) {
-    const { value } = node as unknown as { value?: unknown };
+    const value = getNodeValue(node);
     return typeof value === 'string' || typeof value === 'number'
       ? String(value)
       : null;
@@ -164,22 +180,17 @@ const staticPropertyKeyName = (node: AstNode | undefined): string | null => {
 };
 
 const objectProperties = (node: AstNode | undefined): readonly AstNode[] =>
-  node?.type === 'ObjectExpression'
-    ? ((node as unknown as { properties?: readonly AstNode[] }).properties ??
-      [])
-    : [];
+  node?.type === 'ObjectExpression' ? (getNodeProperties(node) ?? []) : [];
 
 const propertyName = (node: AstNode): string | null =>
-  node.type === 'Property'
-    ? staticPropertyKeyName((node as unknown as { key?: AstNode }).key)
-    : null;
+  node.type === 'Property' ? staticPropertyKeyName(getNodeKey(node)) : null;
 
 const hasProperty = (node: AstNode, name: string): boolean =>
   objectProperties(node).some((property) => propertyName(property) === name);
 
 const propertyValue = (property: AstNode | null): AstNode | undefined =>
   property?.type === 'Property'
-    ? ((property as unknown as { value?: AstNode }).value ?? undefined)
+    ? (getNodeValueNode(property) ?? undefined)
     : undefined;
 
 const trailIsVersioned = (config: AstNode): boolean =>
@@ -194,9 +205,7 @@ const versionEntries = (config: AstNode): readonly AstNode[] => {
 };
 
 const identifierName = (node: AstNode | undefined): string | undefined =>
-  node?.type === 'Identifier'
-    ? (node as unknown as { name?: string }).name
-    : undefined;
+  node?.type === 'Identifier' ? getNodeName(node) : undefined;
 
 const schemaBindingInitializer = (
   schemaBindings: SchemaBindings,
@@ -221,18 +230,16 @@ const schemaBindingInitializer = (
 
 const memberObject = (node: AstNode | undefined): AstNode | undefined =>
   node !== undefined && isMemberAccessNonComputed(node)
-    ? (node as unknown as { object?: AstNode }).object
+    ? getNodeObject(node)
     : undefined;
 
 const memberPropertyName = (node: AstNode | undefined): string | undefined =>
   node !== undefined && isMemberAccessNonComputed(node)
-    ? identifierName((node as unknown as { property?: AstNode }).property)
+    ? identifierName(getNodeProperty(node))
     : undefined;
 
 const callCallee = (node: AstNode): AstNode | undefined =>
-  node.type === 'CallExpression'
-    ? (node as unknown as { callee?: AstNode }).callee
-    : undefined;
+  node.type === 'CallExpression' ? getNodeCallee(node) : undefined;
 
 const isZodSchemaReceiver = (
   node: AstNode | undefined,
@@ -272,9 +279,7 @@ const isZodSchemaCallee = (
   node !== undefined && isZodSchemaReceiver(memberObject(node), schemaBindings);
 
 const callArguments = (node: AstNode): readonly AstNode[] =>
-  node.type === 'CallExpression'
-    ? ((node as unknown as { arguments?: readonly AstNode[] }).arguments ?? [])
-    : [];
+  node.type === 'CallExpression' ? (getNodeArguments(node) ?? []) : [];
 
 const unwrapExpression = (node: AstNode | undefined): AstNode | undefined => {
   let current = node;
@@ -283,7 +288,7 @@ const unwrapExpression = (node: AstNode | undefined): AstNode | undefined => {
     current?.type === 'TSSatisfiesExpression' ||
     current?.type === 'TSNonNullExpression'
   ) {
-    current = (current as unknown as { expression?: AstNode }).expression;
+    current = getNodeExpression(current);
   }
   return current;
 };
@@ -291,10 +296,7 @@ const unwrapExpression = (node: AstNode | undefined): AstNode | undefined => {
 const arrayExpressionLength = (node: AstNode | undefined): number => {
   const expression = unwrapExpression(node);
   return expression?.type === 'ArrayExpression'
-    ? (
-        (expression as unknown as { elements?: readonly unknown[] }).elements ??
-        []
-      ).length
+    ? (getNodeElements(expression) ?? []).length
     : 0;
 };
 
@@ -320,18 +322,14 @@ const literalExpressionIsJsonLossy = (expression: AstNode): boolean => {
   ) {
     return true;
   }
-  const literal = expression as unknown as {
-    readonly bigint?: unknown;
-    readonly regex?: unknown;
-    readonly value?: unknown;
-  };
-  if (literal.bigint !== undefined || literal.regex !== undefined) {
+  if (expression['bigint'] !== undefined || expression['regex'] !== undefined) {
     return true;
   }
-  if (literal.value instanceof RegExp) {
+  const value = getNodeValue(expression);
+  if (value instanceof RegExp) {
     return true;
   }
-  return typeof literal.value === 'number' && !Number.isFinite(literal.value);
+  return typeof value === 'number' && !Number.isFinite(value);
 };
 
 const expressionIsJsonLossy = (node: AstNode | undefined): boolean => {
@@ -350,9 +348,7 @@ const expressionIsJsonLossy = (node: AstNode | undefined): boolean => {
   }
 
   if (expression.type === 'UnaryExpression') {
-    return expressionIsJsonLossy(
-      (expression as unknown as { argument?: AstNode }).argument
-    );
+    return expressionIsJsonLossy(getNodeArgument(expression));
   }
 
   if (expression.type === 'Literal' || expression.type === 'NumericLiteral') {
@@ -360,9 +356,7 @@ const expressionIsJsonLossy = (node: AstNode | undefined): boolean => {
   }
 
   if (expression.type === 'ArrayExpression') {
-    const elements =
-      (expression as unknown as { elements?: readonly (AstNode | null)[] })
-        .elements ?? [];
+    const elements = getNodeElements(expression);
     return elements.some((element) =>
       expressionIsJsonLossy(element ?? undefined)
     );
@@ -435,10 +429,9 @@ const isReferenceValuedLiteralCall = (
   if (value?.type !== 'ArrayExpression') {
     return false;
   }
-  return (
-    (value as unknown as { elements?: readonly (AstNode | null)[] }).elements ??
-    []
-  ).some((element) => expressionIsReferenceValued(element ?? undefined));
+  return (getNodeElements(value) ?? []).some((element) =>
+    expressionIsReferenceValued(element ?? undefined)
+  );
 };
 
 const isJsonLossyEnumCall = (
@@ -486,10 +479,9 @@ const isReferenceValuedEnumCall = (
   const [rawOptions] = callArguments(node);
   const options = unwrapExpression(rawOptions);
   if (options?.type === 'ArrayExpression') {
-    return (
-      (options as unknown as { elements?: readonly (AstNode | null)[] })
-        .elements ?? []
-    ).some((element) => expressionIsReferenceValued(element ?? undefined));
+    return getNodeElements(options).some((element) =>
+      expressionIsReferenceValued(element ?? undefined)
+    );
   }
   if (options?.type !== 'ObjectExpression') {
     return false;
@@ -583,10 +575,9 @@ const nestedSchemaArguments = (node: AstNode): readonly AstNode[] => {
   const [rawOptions] = callArguments(node);
   const options = unwrapExpression(rawOptions);
   return options?.type === 'ArrayExpression'
-    ? (
-        (options as unknown as { elements?: readonly (AstNode | null)[] })
-          .elements ?? []
-      ).filter((element): element is AstNode => element !== null)
+    ? getNodeElements(options).filter(
+        (element): element is AstNode => element !== null
+      )
     : [];
 };
 
@@ -689,7 +680,7 @@ const isMemberCallNamed = (
 
 const bindingName = (node: AstNode): string | undefined =>
   node.type === 'VariableDeclarator'
-    ? identifierName((node as unknown as { id?: AstNode }).id)
+    ? identifierName(getNodeId(node))
     : undefined;
 
 const lexicalScopeTypes = new Set([
@@ -716,20 +707,15 @@ const addPatternBindingNames = (
     return;
   }
   if (node.type === 'AssignmentPattern') {
-    addPatternBindingNames((node as unknown as { left?: AstNode }).left, into);
+    addPatternBindingNames(getNodeLeft(node), into);
     return;
   }
   if (node.type === 'RestElement') {
-    addPatternBindingNames(
-      (node as unknown as { argument?: AstNode }).argument,
-      into
-    );
+    addPatternBindingNames(getNodeArgument(node), into);
     return;
   }
   if (node.type === 'ArrayPattern') {
-    const elements =
-      (node as unknown as { elements?: readonly (AstNode | null)[] })
-        .elements ?? [];
+    const elements = getNodeElements(node);
     for (const element of elements) {
       addPatternBindingNames(element ?? undefined, into);
     }
@@ -738,17 +724,13 @@ const addPatternBindingNames = (
   if (node.type !== 'ObjectPattern') {
     return;
   }
-  const properties =
-    (node as unknown as { properties?: readonly AstNode[] }).properties ?? [];
+  const properties = getNodeProperties(node) ?? [];
   for (const property of properties) {
     if (property.type === 'RestElement') {
       addPatternBindingNames(property, into);
       continue;
     }
-    addPatternBindingNames(
-      (property as unknown as { value?: AstNode }).value,
-      into
-    );
+    addPatternBindingNames(getNodeValueNode(property), into);
   }
 };
 
@@ -757,8 +739,7 @@ const parameterBindingNames = (node: AstNode): readonly string[] => {
     return [];
   }
   const names = new Set<string>();
-  const params =
-    (node as unknown as { params?: readonly AstNode[] }).params ?? [];
+  const params = getNodeParams(node) ?? [];
   for (const param of params) {
     addPatternBindingNames(param, names);
   }
@@ -767,7 +748,7 @@ const parameterBindingNames = (node: AstNode): readonly string[] => {
 
 const variableInitializer = (node: AstNode): AstNode | undefined =>
   node.type === 'VariableDeclarator'
-    ? ((node as unknown as { init?: AstNode }).init ?? undefined)
+    ? (getNodeInit(node) ?? undefined)
     : undefined;
 
 const isZodSchemaExpression = (
@@ -887,22 +868,19 @@ const composeCallHasVersionPin = (node: AstNode): boolean => {
   if (node.type !== 'CallExpression') {
     return false;
   }
-  const { arguments: args, callee } = node as unknown as {
-    arguments?: readonly AstNode[];
-    callee?: AstNode;
-  };
+  const args = getNodeArguments(node);
+  const callee = getNodeCallee(node);
   if (!callee || !args) {
     return false;
   }
 
   const isComposeIdentifier =
-    callee.type === 'Identifier' &&
-    (callee as unknown as { name?: string }).name === 'compose';
-  const { property } = callee as unknown as { property?: AstNode };
+    callee.type === 'Identifier' && getNodeName(callee) === 'compose';
+  const property = getNodeProperty(callee);
   const isComposeMember =
     isMemberAccessNonComputed(callee) &&
     property?.type === 'Identifier' &&
-    (property as unknown as { name?: string }).name === 'compose';
+    getNodeName(property) === 'compose';
 
   return (isComposeIdentifier || isComposeMember) && hasVersionOption(args[2]);
 };

package/src/rules/types.ts

@@ -245,6 +245,8 @@ export interface ProjectContext {
   readonly crudTableIds?: ReadonlySet<string>;
   /** All known trail IDs in the project */
   readonly knownTrailIds: ReadonlySet<string>;
+  /** Trail IDs registered in configured app topo targets. */
+  readonly topoTrailIds?: ReadonlySet<string>;
   /** Declared contour references keyed by source contour name. */
   readonly contourReferencesByName?: ReadonlyMap<string, readonly string[]>;
   /** All known resource IDs in the project */

package/src/rules/unreachable-detour-shadowing.ts

@@ -4,6 +4,13 @@ import {
   extractStringLiteral,
   findConfigProperty,
   findTrailDefinitions,
+  getNodeId,
+  getNodeImported,
+  getNodeInit,
+  getNodeLocal,
+  getNodeSource,
+  getNodeSpecifiers,
+  getNodeSuperClass,
   identifierName,
   offsetToLine,
   parse,
@@ -46,7 +53,7 @@ const resolveKnownErrorName = (
 ): string => aliases.get(name) ?? name;
 
 const coreImportSource = (node: AstNode): string | null =>
-  extractStringLiteral((node as unknown as { source?: AstNode }).source);
+  extractStringLiteral(getNodeSource(node));
 
 const collectImportSpecifierAliases = (
   specifiers: readonly AstNode[] | undefined,
@@ -57,13 +64,9 @@ const collectImportSpecifierAliases = (
       continue;
     }
 
-    const localName = identifierName(
-      (specifier as unknown as { local?: AstNode }).local
-    );
+    const localName = identifierName(getNodeLocal(specifier));
     const importedName =
-      identifierName(
-        (specifier as unknown as { imported?: AstNode }).imported
-      ) ?? localName;
+      identifierName(getNodeImported(specifier)) ?? localName;
 
     if (localName && importedName && knownErrorConstructors.has(importedName)) {
       aliases.set(localName, importedName);
@@ -85,9 +88,7 @@ const collectKnownErrorAliases = (
       return;
     }
 
-    const { specifiers } = node as unknown as {
-      specifiers?: readonly AstNode[];
-    };
+    const specifiers = getNodeSpecifiers(node);
     collectImportSpecifierAliases(specifiers, aliases);
   });
 
@@ -116,15 +117,13 @@ const collectClassExpressionParent = (
     return;
   }
 
-  const { init } = node as unknown as { init?: AstNode };
+  const init = getNodeInit(node);
   if (!init || init.type !== 'ClassExpression') {
     return;
   }
 
-  const className = identifierName((node as unknown as { id?: AstNode }).id);
-  const parentName = identifierName(
-    (init as unknown as { superClass?: AstNode }).superClass
-  );
+  const className = identifierName(getNodeId(node));
+  const parentName = identifierName(getNodeSuperClass(init));
   recordLocalErrorParent(parents, aliases, className, parentName);
 };
 
@@ -136,12 +135,8 @@ const collectLocalErrorParents = (
 
   walk(ast, (node) => {
     if (node.type === 'ClassDeclaration') {
-      const className = identifierName(
-        (node as unknown as { id?: AstNode }).id
-      );
-      const parentName = identifierName(
-        (node as unknown as { superClass?: AstNode }).superClass
-      );
+      const className = identifierName(getNodeId(node));
+      const parentName = identifierName(getNodeSuperClass(node));
       recordLocalErrorParent(parents, aliases, className, parentName);
       return;
     }

package/src/rules/valid-describe-refs.ts

@@ -1,5 +1,8 @@
 import {
   extractStringOrTemplateLiteral,
+  getNodeName,
+  getNodeProperty,
+  getNodeValue,
   offsetToLine,
   parse,
   walk,
@@ -35,11 +38,8 @@ const isDescribeMemberCallee = (callee: AstNode | undefined): boolean => {
   if (!callee || !MEMBER_CALLEE_TYPES.has(callee.type)) {
     return false;
   }
-  const prop = (callee as unknown as { property?: AstNode }).property;
-  return (
-    prop?.type === 'Identifier' &&
-    (prop as unknown as { name?: string }).name === 'describe'
-  );
+  const prop = getNodeProperty(callee);
+  return prop?.type === 'Identifier' && getNodeName(prop) === 'describe';
 };
 
 const hasStringLiteralFirstArg = (node: AstNode): boolean => {
@@ -87,14 +87,16 @@ const isDescribeCall = (node: AstNode): boolean => {
  * missing an `@see` token.
  */
 const extractQuasiText = (quasi: AstNode): string | null => {
-  const { value } = quasi as unknown as {
-    value?: { cooked?: unknown; raw?: unknown };
-  };
-  if (typeof value?.cooked === 'string') {
-    return value.cooked;
+  const value = getNodeValue(quasi);
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+  const record = value as Record<string, unknown>;
+  if (typeof record['cooked'] === 'string') {
+    return record['cooked'];
   }
-  if (typeof value?.raw === 'string') {
-    return value.raw;
+  if (typeof record['raw'] === 'string') {
+    return record['raw'];
   }
   return null;
 };

package/src/rules/warden-export-symmetry.ts

@@ -16,7 +16,26 @@
  */
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { walk, offsetToLine, parse } from './ast.js';
+import {
+  getNodeArgument,
+  getNodeDeclaration,
+  getNodeDeclarations,
+  getNodeElements,
+  getNodeExportKind,
+  getNodeExported,
+  getNodeId,
+  getNodeKey,
+  getNodeLeft,
+  getNodeLocal,
+  getNodeName,
+  getNodeProperties,
+  getNodeSource,
+  getNodeValue,
+  getNodeValueNode,
+  offsetToLine,
+  parse,
+  walk,
+} from './ast.js';
 import type { AstNode } from './ast.js';
 import { registeredRuleNames } from './registry-names.js';
 import type { WardenDiagnostic, WardenRule } from './types.js';
@@ -61,10 +80,10 @@ const readIdentifierOrStringName = (
     return null;
   }
   if (node.type === 'Identifier') {
-    return (node as unknown as { name?: string }).name ?? null;
+    return getNodeName(node) ?? null;
   }
   if (node.type === 'Literal' || node.type === 'StringLiteral') {
-    const { value } = node as unknown as { value?: unknown };
+    const value = getNodeValue(node);
     return typeof value === 'string' ? value : null;
   }
   return null;
@@ -73,10 +92,8 @@ const readIdentifierOrStringName = (
 const extractSpecifierNames = (
   specifier: AstNode
 ): { readonly name: string; readonly localName: string } | null => {
-  const { exported, local } = specifier as unknown as {
-    exported?: AstNode;
-    local?: AstNode;
-  };
+  const exported = getNodeExported(specifier);
+  const local = getNodeLocal(specifier);
   const name = readIdentifierOrStringName(exported);
   if (!name) {
     return null;
@@ -86,7 +103,7 @@ const extractSpecifierNames = (
 };
 
 const isTypeExportSpecifier = (specifier: AstNode): boolean =>
-  (specifier as unknown as { exportKind?: string }).exportKind === 'type';
+  getNodeExportKind(specifier) === 'type';
 
 const specifierSite = (specifier: AstNode): ExportSite | null => {
   if (
@@ -129,7 +146,7 @@ const siteFromSimpleBinding = (
     return name ? { localName: name, name, start } : null;
   }
   if (node.type === 'AssignmentPattern') {
-    const { left } = node as unknown as { left?: AstNode };
+    const left = getNodeLeft(node);
     return left ? siteFromSimpleBinding(left, start) : null;
   }
   return null;
@@ -172,16 +189,14 @@ const sitesFromObjectProperty = (
   recurse: PatternSitesFn
 ): readonly ExportSite[] => {
   if (prop.type === 'RestElement') {
-    const { argument } = prop as unknown as { argument?: AstNode };
+    const argument = getNodeArgument(prop);
     return recurse(argument, start);
   }
   if (prop.type !== 'Property') {
     return [];
   }
-  const { key, value } = prop as unknown as {
-    key?: AstNode;
-    value?: AstNode;
-  };
+  const key = getNodeKey(prop);
+  const value = getNodeValueNode(prop);
   if (isNestedPatternValue(value)) {
     return recurse(value, start);
   }
@@ -198,7 +213,7 @@ const sitesFromArrayElement = (
     return [];
   }
   if (element.type === 'RestElement') {
-    const { argument } = element as unknown as { argument?: AstNode };
+    const argument = getNodeArgument(element);
     return recurse(argument, start);
   }
   return recurse(element, start);
@@ -209,9 +224,7 @@ const sitesFromObjectPattern = (
   start: number,
   recurse: PatternSitesFn
 ): readonly ExportSite[] => {
-  const properties =
-    (pattern as unknown as { properties?: readonly AstNode[] }).properties ??
-    [];
+  const properties = getNodeProperties(pattern) ?? [];
   return properties.flatMap((prop) =>
     sitesFromObjectProperty(prop, start, recurse)
   );
@@ -222,9 +235,7 @@ const sitesFromArrayPattern = (
   start: number,
   recurse: PatternSitesFn
 ): readonly ExportSite[] => {
-  const elements =
-    (pattern as unknown as { elements?: readonly (AstNode | null)[] })
-      .elements ?? [];
+  const elements = getNodeElements(pattern);
   return elements.flatMap((element) =>
     sitesFromArrayElement(element, start, recurse)
   );
@@ -262,16 +273,14 @@ const sitesForDeclaration = (declaration: AstNode): readonly ExportSite[] => {
     declaration.type === 'FunctionDeclaration' ||
     declaration.type === 'ClassDeclaration'
   ) {
-    const { id } = declaration as unknown as { id?: AstNode };
+    const id = getNodeId(declaration);
     const site = namedSiteFromDeclId(id, declaration.start);
     return site ? [site] : [];
   }
   if (declaration.type === 'VariableDeclaration') {
-    const declarations =
-      (declaration as unknown as { declarations?: readonly AstNode[] })
-        .declarations ?? [];
+    const declarations = getNodeDeclarations(declaration);
     return declarations.flatMap((declarator) => {
-      const { id } = declarator as unknown as { id?: AstNode };
+      const id = getNodeId(declarator);
       return sitesFromPattern(id, declarator.start);
     });
   }
@@ -282,10 +291,10 @@ const sitesForExportNode = (node: AstNode): readonly ExportSite[] => {
   if (node.type !== 'ExportNamedDeclaration') {
     return [];
   }
-  if ((node as unknown as { exportKind?: string }).exportKind === 'type') {
+  if (getNodeExportKind(node) === 'type') {
     return [];
   }
-  const { declaration } = node as unknown as { declaration?: AstNode };
+  const declaration = getNodeDeclaration(node);
   if (declaration) {
     return sitesForDeclaration(declaration);
   }
@@ -324,15 +333,13 @@ const collectNamespaceReexports = (
     // Mirror the `ExportNamedDeclaration` guard: `export type * from ...` and
     // `export type * as ns from ...` propagate types only, never runtime
     // identifiers, so they cannot leak raw rule objects and must be allowed.
-    if ((node as unknown as { exportKind?: string }).exportKind === 'type') {
+    if (getNodeExportKind(node) === 'type') {
       return;
     }
-    const { source, exported } = node as unknown as {
-      source?: { value?: unknown };
-      exported?: AstNode;
-    };
-    const target =
-      typeof source?.value === 'string' ? source.value : '<unknown>';
+    const source = getNodeSource(node);
+    const exported = getNodeExported(node);
+    const sourceValue = getNodeValue(source);
+    const target = typeof sourceValue === 'string' ? sourceValue : '<unknown>';
     // `export * as <alias> from '...'` exposes the alias as an
     // `IdentifierName` / string-literal node on `exported`. Bare `export *`
     // has `exported === null`.