@ontrails/warden 1.0.0-beta.13 → 1.0.0-beta.15

package/src/rules/{provision-declarations.ts → resource-declarations.ts}

@@ -1,14 +1,14 @@
 /**
- * Validates that provision access matches the declared `provisions` array.
+ * Validates that resource access matches the declared `resources` array.
  *
  * Statically analyzes trail `blaze` functions to find `db.from(ctx)` and
- * `ctx.provision('db.main')` calls and compares them against the declared
- * `provisions: [...]` array in the trail config. Reports errors for undeclared
+ * `ctx.resource('db.main')` calls and compares them against the declared
+ * `resources: [...]` array in the trail config. Reports errors for undeclared
  * access and warnings for unused declarations.
  */
 
 import {
-  collectNamedProvisionIds,
+  collectNamedResourceIds,
   extractFirstStringArg,
   findConfigProperty,
   findBlazeBodies,
@@ -25,15 +25,15 @@ import { isTestFile } from './scan.js';
 import type { WardenDiagnostic, WardenRule } from './types.js';
 
 // ---------------------------------------------------------------------------
-// Provision declaration extraction
+// Resource declaration extraction
 // ---------------------------------------------------------------------------
 
-interface DeclaredProvision {
+interface DeclaredResource {
   readonly id: string | null;
   readonly name: string | null;
 }
 
-interface CalledProvisions {
+interface CalledResources {
   readonly fromNames: ReadonlySet<string>;
   readonly lookupIds: ReadonlySet<string>;
   readonly lookupNames: ReadonlySet<string>;
@@ -59,25 +59,25 @@ const extractMemberPair = (
   return objName && propName ? { objName, propName } : null;
 };
 
-/** Check if a node is an inline `provision('id', ...)` call. */
-const isInlineProvisionCall = (node: AstNode): boolean => {
+/** Check if a node is an inline `resource('id', ...)` call. */
+const isInlineResourceCall = (node: AstNode): boolean => {
   if (node.type !== 'CallExpression') {
     return false;
   }
   return (
     identifierName((node as unknown as { callee?: AstNode }).callee) ===
-    'provision'
+    'resource'
   );
 };
 
-/** Get `provisions` array elements from a trail config. */
-const getProvisionElements = (config: AstNode): readonly AstNode[] => {
-  const provisionsProp = findConfigProperty(config, 'provisions');
-  if (!provisionsProp) {
+/** Get `resources` array elements from a trail config. */
+const getResourceElements = (config: AstNode): readonly AstNode[] => {
+  const resourcesProp = findConfigProperty(config, 'resources');
+  if (!resourcesProp) {
     return [];
   }
 
-  const arrayNode = provisionsProp.value;
+  const arrayNode = resourcesProp.value;
   if (!arrayNode || (arrayNode as AstNode).type !== 'ArrayExpression') {
     return [];
   }
@@ -88,15 +88,15 @@ const getProvisionElements = (config: AstNode): readonly AstNode[] => {
   return elements ?? [];
 };
 
-/** Extract one declared provision from a `provisions` array element. */
-const extractDeclaredProvision = (
+/** Extract one declared resource from a `resources` array element. */
+const extractDeclaredResource = (
   element: AstNode,
-  provisionIdsByName: ReadonlyMap<string, string>
-): DeclaredProvision | null => {
+  resourceIdsByName: ReadonlyMap<string, string>
+): DeclaredResource | null => {
   if (element.type === 'Identifier') {
     const name = identifierName(element);
     return {
-      id: name ? (provisionIdsByName.get(name) ?? null) : null,
+      id: name ? (resourceIdsByName.get(name) ?? null) : null,
       name,
     };
   }
@@ -105,39 +105,113 @@ const extractDeclaredProvision = (
     return { id: getStringValue(element), name: null };
   }
 
-  if (isInlineProvisionCall(element)) {
+  if (isInlineResourceCall(element)) {
     return { id: extractFirstStringArg(element), name: null };
   }
 
   return null;
 };
 
-/** Extract declared provisions from a trail config's `provisions` array. */
-const extractDeclaredProvisions = (
+/** Extract declared resources from a trail config's `resources` array. */
+const extractDeclaredResources = (
   config: AstNode,
-  provisionIdsByName: ReadonlyMap<string, string>
-): readonly DeclaredProvision[] =>
-  getProvisionElements(config).flatMap((element) => {
-    const provision = extractDeclaredProvision(element, provisionIdsByName);
-    return provision ? [provision] : [];
+  resourceIdsByName: ReadonlyMap<string, string>
+): readonly DeclaredResource[] =>
+  getResourceElements(config).flatMap((element) => {
+    const resource = extractDeclaredResource(element, resourceIdsByName);
+    return resource ? [resource] : [];
   });
 
 // ---------------------------------------------------------------------------
-// Called service extraction
+// Called resource extraction
 // ---------------------------------------------------------------------------
 
-/** Extract the second parameter name from a blaze function node. */
-const extractContextParamName = (blazeBody: AstNode): string | null => {
+/** Extract the raw second parameter node from a blaze function. */
+const extractContextParamNode = (blazeBody: AstNode): AstNode | null => {
   const params = blazeBody['params'] as readonly AstNode[] | undefined;
   if (!params || params.length < 2) {
     return null;
   }
-  return identifierName(params[1]);
+  return params[1] ?? null;
+};
+
+/**
+ * Extract the second parameter name from a blaze function node.
+ *
+ * Returns null when the parameter is not a plain Identifier (e.g. when the
+ * author destructures `{ resource }` in the parameter list). Parameter-level
+ * destructuring is handled separately by `collectParamResourceAliases`.
+ *
+ * Also handles defaulted parameters like `(input, ctx = fallback) => ...`
+ * (AssignmentPattern whose `.left` is the Identifier). Without this, valid
+ * signatures would silently drop out of ctx-access analysis.
+ */
+const extractContextParamName = (blazeBody: AstNode): string | null => {
+  const param = extractContextParamNode(blazeBody);
+  if (!param) {
+    return null;
+  }
+  if (param.type === 'AssignmentPattern') {
+    const { left } = param as unknown as { left?: AstNode };
+    return identifierName(left);
+  }
+  return identifierName(param);
+};
+
+/** Extract the alias name from a Property node whose key is `resource`. */
+const extractResourceAlias = (property: AstNode): string | null => {
+  if (property.type !== 'Property') {
+    return null;
+  }
+  const keyName = identifierName(
+    (property as unknown as { key?: AstNode }).key
+  );
+  if (keyName !== 'resource') {
+    return null;
+  }
+  return (
+    identifierName((property as unknown as { value?: AstNode }).value) ??
+    keyName
+  );
 };
 
-/** Build the set of context parameter names to match against. */
+/**
+ * Collect `resource` aliases bound via parameter-level destructuring.
+ *
+ * Recognizes `(input, { resource }) => ...` and `(input, { resource: r }) => ...`.
+ * When the blaze author destructures in the parameter list, there is no
+ * enclosing `ctx` identifier to track — we seed the resource alias set directly
+ * from the ObjectPattern in `params[1]`.
+ */
+const collectParamResourceAliases = (body: AstNode): ReadonlySet<string> => {
+  const param = extractContextParamNode(body);
+  if (!param || param.type !== 'ObjectPattern') {
+    return new Set();
+  }
+  const aliases = new Set<string>();
+  const properties = param['properties'] as readonly AstNode[] | undefined;
+  for (const property of properties ?? []) {
+    const alias = extractResourceAlias(property);
+    if (alias) {
+      aliases.add(alias);
+    }
+  }
+  return aliases;
+};
+
+/**
+ * Build the set of context parameter names to match against.
+ *
+ * Returns ONLY the actual second-parameter name from the blaze signature.
+ * No seeded defaults: if the blaze has no second parameter, the returned set
+ * is empty and no `ctx.resource(...)` / `context.resource(...)` calls are
+ * tracked for that blaze. An unrelated closure-scoped `ctx` identifier is not
+ * the trail context and must not be treated as one.
+ *
+ * Mirrors `fires-declarations.ts` `buildCtxNames` for the same reason.
+ */
 const buildCtxNames = (body: AstNode): ReadonlySet<string> => {
-  const ctxNames = new Set(['ctx', 'context']);
+  const ctxNames = new Set<string>();
   const paramName = extractContextParamName(body);
   if (paramName) {
     ctxNames.add(paramName);
@@ -189,63 +263,63 @@ const extractFromCallName = (
     : null;
 };
 
-/** Check if a callee is a member-style `ctx.provision(...)` call. */
-const isMemberProvisionCall = (
+/** Check if a callee is a member-style `ctx.resource(...)` call. */
+const isMemberResourceCall = (
   callee: AstNode,
   ctxNames: ReadonlySet<string>
 ): boolean => {
   const pair = extractMemberPair(callee);
-  return !!pair && ctxNames.has(pair.objName) && pair.propName === 'provision';
+  return !!pair && ctxNames.has(pair.objName) && pair.propName === 'resource';
 };
 
-/** Extract `ctx.provision(db)` and destructured `provision(db)` lookup names. */
-const extractLookupProvisionName = (
+/** Extract `ctx.resource(db)` and destructured `resource(db)` lookup names. */
+const extractLookupResourceName = (
   node: AstNode,
   ctxNames: ReadonlySet<string>,
-  provisionAliases: ReadonlySet<string>
+  resourceAliases: ReadonlySet<string>
 ): string | null => {
   const callee = extractCallCallee(node);
   if (!callee) {
     return null;
   }
 
-  if (isMemberProvisionCall(callee, ctxNames)) {
+  if (isMemberResourceCall(callee, ctxNames)) {
     return extractFirstIdentifierArg(node);
   }
 
-  if (provisionAliases.has(identifierName(callee) ?? '')) {
+  if (resourceAliases.has(identifierName(callee) ?? '')) {
     return extractFirstIdentifierArg(node);
   }
 
   return null;
 };
 
-/** Extract `ctx.provision('id')` and destructured `provision('id')` lookup IDs. */
-const extractLookupProvisionId = (
+/** Extract `ctx.resource('id')` and destructured `resource('id')` lookup IDs. */
+const extractLookupResourceId = (
   node: AstNode,
   ctxNames: ReadonlySet<string>,
-  provisionAliases: ReadonlySet<string>
+  resourceAliases: ReadonlySet<string>
 ): string | null => {
   const callee = extractCallCallee(node);
   if (!callee) {
     return null;
   }
 
-  if (isMemberProvisionCall(callee, ctxNames)) {
+  if (isMemberResourceCall(callee, ctxNames)) {
     return extractFirstStringArg(node);
   }
 
   const calleeName = identifierName(callee);
   const args = node['arguments'] as readonly AstNode[] | undefined;
-  if (calleeName && provisionAliases.has(calleeName) && args?.length === 1) {
+  if (calleeName && resourceAliases.has(calleeName) && args?.length === 1) {
     return extractFirstStringArg(node);
   }
 
   return null;
 };
 
-/** Collect local aliases for the provision accessor (e.g. `const { provision } = ctx`). */
-const collectProvisionAliases = (
+/** Collect local aliases for the resource accessor (e.g. `const { resource } = ctx`). */
+const collectResourceAliases = (
   body: AstNode,
   ctxNames: ReadonlySet<string>
 ): ReadonlySet<string> => {
@@ -267,7 +341,7 @@ const collectProvisionAliases = (
       const keyName = identifierName(
         (property as unknown as { key?: AstNode }).key
       );
-      if (keyName !== 'provision') {
+      if (keyName !== 'resource') {
         return [];
       }
 
@@ -300,15 +374,17 @@ const collectProvisionAliases = (
   return aliases;
 };
 
-/** Walk blaze bodies and collect provision access that can be resolved statically. */
-const extractCalledProvisions = (config: AstNode): CalledProvisions => {
+/** Walk blaze bodies and collect resource access that can be resolved statically. */
+const extractCalledResources = (config: AstNode): CalledResources => {
   const fromNames = new Set<string>();
   const lookupIds = new Set<string>();
   const lookupNames = new Set<string>();
 
   for (const body of findBlazeBodies(config)) {
     const ctxNames = buildCtxNames(body);
-    const provisionAliases = collectProvisionAliases(body, ctxNames);
+    const paramAliases = collectParamResourceAliases(body);
+    const bodyAliases = collectResourceAliases(body, ctxNames);
+    const resourceAliases = new Set([...paramAliases, ...bodyAliases]);
 
     walkScope(body, (node) => {
       const fromName = extractFromCallName(node, ctxNames);
@@ -316,19 +392,15 @@ const extractCalledProvisions = (config: AstNode): CalledProvisions => {
         fromNames.add(fromName);
       }
 
-      const lookupId = extractLookupProvisionId(
-        node,
-        ctxNames,
-        provisionAliases
-      );
+      const lookupId = extractLookupResourceId(node, ctxNames, resourceAliases);
       if (lookupId) {
         lookupIds.add(lookupId);
       }
 
-      const lookupName = extractLookupProvisionName(
+      const lookupName = extractLookupResourceName(
         node,
         ctxNames,
-        provisionAliases
+        resourceAliases
       );
       if (lookupName) {
         lookupNames.add(lookupName);
@@ -343,58 +415,58 @@ const extractCalledProvisions = (config: AstNode): CalledProvisions => {
 // Diagnostics
 // ---------------------------------------------------------------------------
 
-const renderDeclaredProvision = (provision: DeclaredProvision): string =>
-  provision.name ?? provision.id ?? '<unknown>';
+const renderDeclaredResource = (resource: DeclaredResource): string =>
+  resource.name ?? resource.id ?? '<unknown>';
 
 const buildUndeclaredFromDiagnostic = (
   trailId: string,
-  provisionName: string,
+  resourceName: string,
   filePath: string,
   line: number
 ): WardenDiagnostic => ({
   filePath,
   line,
-  message: `Trail "${trailId}": ${provisionName}.from(ctx) called but '${provisionName}' is not declared in provisions`,
-  rule: 'provision-declarations',
+  message: `Trail "${trailId}": ${resourceName}.from(ctx) called but '${resourceName}' is not declared in resources`,
+  rule: 'resource-declarations',
   severity: 'error',
 });
 
 const buildUndeclaredLookupDiagnostic = (
   trailId: string,
-  provisionId: string,
+  resourceId: string,
   filePath: string,
   line: number
 ): WardenDiagnostic => ({
   filePath,
   line,
-  message: `Trail "${trailId}": ctx.provision('${provisionId}') called but '${provisionId}' is not declared in provisions`,
-  rule: 'provision-declarations',
+  message: `Trail "${trailId}": ctx.resource('${resourceId}') called but '${resourceId}' is not declared in resources`,
+  rule: 'resource-declarations',
   severity: 'error',
 });
 
 const buildUndeclaredLookupNameDiagnostic = (
   trailId: string,
-  provisionName: string,
+  resourceName: string,
   filePath: string,
   line: number
 ): WardenDiagnostic => ({
   filePath,
   line,
-  message: `Trail "${trailId}": ctx.provision(${provisionName}) called but '${provisionName}' is not declared in provisions`,
-  rule: 'provision-declarations',
+  message: `Trail "${trailId}": ctx.resource(${resourceName}) called but '${resourceName}' is not declared in resources`,
+  rule: 'resource-declarations',
   severity: 'error',
 });
 
 const buildUnusedDiagnostic = (
   trailId: string,
-  declaredProvision: DeclaredProvision,
+  declaredResource: DeclaredResource,
   filePath: string,
   line: number
 ): WardenDiagnostic => ({
   filePath,
   line,
-  message: `Trail "${trailId}": '${renderDeclaredProvision(declaredProvision)}' declared in provisions but never used`,
-  rule: 'provision-declarations',
+  message: `Trail "${trailId}": '${renderDeclaredResource(declaredResource)}' declared in resources but never used`,
+  rule: 'resource-declarations',
   severity: 'warn',
 });
 
@@ -402,21 +474,21 @@ const buildUnusedDiagnostic = (
 // Comparison
 // ---------------------------------------------------------------------------
 
-const provisionWasUsed = (
-  declaredProvision: DeclaredProvision,
-  calledProvisions: CalledProvisions
+const resourceWasUsed = (
+  declaredResource: DeclaredResource,
+  calledResources: CalledResources
 ): boolean => {
   if (
-    declaredProvision.name &&
-    (calledProvisions.fromNames.has(declaredProvision.name) ||
-      calledProvisions.lookupNames.has(declaredProvision.name))
+    declaredResource.name &&
+    (calledResources.fromNames.has(declaredResource.name) ||
+      calledResources.lookupNames.has(declaredResource.name))
   ) {
     return true;
   }
 
   if (
-    declaredProvision.id &&
-    calledProvisions.lookupIds.has(declaredProvision.id)
+    declaredResource.id &&
+    calledResources.lookupIds.has(declaredResource.id)
   ) {
     return true;
   }
@@ -425,35 +497,33 @@ const provisionWasUsed = (
 };
 
 const buildDeclaredNames = (
-  declaredProvisions: readonly DeclaredProvision[]
+  declaredResources: readonly DeclaredResource[]
 ): ReadonlySet<string> =>
   new Set(
-    declaredProvisions.flatMap((provision) =>
-      provision.name ? [provision.name] : []
+    declaredResources.flatMap((resource) =>
+      resource.name ? [resource.name] : []
     )
   );
 
 const buildDeclaredIds = (
-  declaredProvisions: readonly DeclaredProvision[]
+  declaredResources: readonly DeclaredResource[]
 ): ReadonlySet<string> =>
   new Set(
-    declaredProvisions.flatMap((provision) =>
-      provision.id ? [provision.id] : []
-    )
+    declaredResources.flatMap((resource) => (resource.id ? [resource.id] : []))
   );
 
 const reportUndeclaredFromCalls = (
   trailId: string,
   filePath: string,
   line: number,
-  calledProvisions: CalledProvisions,
+  calledResources: CalledResources,
   declaredNames: ReadonlySet<string>,
   diagnostics: WardenDiagnostic[]
 ): void => {
-  for (const provisionName of calledProvisions.fromNames) {
-    if (!declaredNames.has(provisionName)) {
+  for (const resourceName of calledResources.fromNames) {
+    if (!declaredNames.has(resourceName)) {
       diagnostics.push(
-        buildUndeclaredFromDiagnostic(trailId, provisionName, filePath, line)
+        buildUndeclaredFromDiagnostic(trailId, resourceName, filePath, line)
       );
     }
   }
@@ -463,19 +533,19 @@ const reportUndeclaredLookupCalls = (
   trailId: string,
   filePath: string,
   line: number,
-  calledProvisions: CalledProvisions,
+  calledResources: CalledResources,
   declaredIds: ReadonlySet<string>,
   declaredNames: ReadonlySet<string>,
   diagnostics: WardenDiagnostic[]
 ): void => {
-  for (const provisionName of calledProvisions.lookupNames) {
-    // Name-based lookup checks remain reliable even when an imported provision ID
+  for (const resourceName of calledResources.lookupNames) {
+    // Name-based lookup checks remain reliable even when an imported resource ID
     // cannot be resolved locally.
-    if (!declaredNames.has(provisionName)) {
+    if (!declaredNames.has(resourceName)) {
       diagnostics.push(
         buildUndeclaredLookupNameDiagnostic(
           trailId,
-          provisionName,
+          resourceName,
           filePath,
           line
         )
@@ -483,10 +553,10 @@ const reportUndeclaredLookupCalls = (
     }
   }
 
-  for (const provisionId of calledProvisions.lookupIds) {
-    if (!declaredIds.has(provisionId)) {
+  for (const resourceId of calledResources.lookupIds) {
+    if (!declaredIds.has(resourceId)) {
       diagnostics.push(
-        buildUndeclaredLookupDiagnostic(trailId, provisionId, filePath, line)
+        buildUndeclaredLookupDiagnostic(trailId, resourceId, filePath, line)
       );
     }
   }
@@ -496,54 +566,54 @@ const reportUnusedDeclarations = (
   trailId: string,
   filePath: string,
   line: number,
-  declaredProvisions: readonly DeclaredProvision[],
-  calledProvisions: CalledProvisions,
+  declaredResources: readonly DeclaredResource[],
+  calledResources: CalledResources,
   diagnostics: WardenDiagnostic[]
 ): void => {
-  for (const declaredProvision of declaredProvisions) {
-    if (provisionWasUsed(declaredProvision, calledProvisions)) {
+  for (const declaredResource of declaredResources) {
+    if (resourceWasUsed(declaredResource, calledResources)) {
       continue;
     }
 
-    if (declaredProvision.name && declaredProvision.id === null) {
+    if (declaredResource.name && declaredResource.id === null) {
       continue;
     }
 
     diagnostics.push(
-      buildUnusedDiagnostic(trailId, declaredProvision, filePath, line)
+      buildUnusedDiagnostic(trailId, declaredResource, filePath, line)
     );
   }
 };
 
-const hasNoProvisionActivity = (
-  declaredProvisions: readonly DeclaredProvision[],
-  calledProvisions: CalledProvisions
+const hasNoResourceActivity = (
+  declaredResources: readonly DeclaredResource[],
+  calledResources: CalledResources
 ): boolean =>
-  declaredProvisions.length === 0 &&
-  calledProvisions.fromNames.size === 0 &&
-  calledProvisions.lookupIds.size === 0 &&
-  calledProvisions.lookupNames.size === 0;
+  declaredResources.length === 0 &&
+  calledResources.fromNames.size === 0 &&
+  calledResources.lookupIds.size === 0 &&
+  calledResources.lookupNames.size === 0;
 
 const analyzeTrailServices = (
   def: { config: AstNode; start: number },
   sourceCode: string,
-  provisionIdsByName: ReadonlyMap<string, string>
+  resourceIdsByName: ReadonlyMap<string, string>
 ): {
-  readonly calledProvisions: CalledProvisions;
+  readonly calledResources: CalledResources;
   readonly declaredIds: ReadonlySet<string>;
   readonly declaredNames: ReadonlySet<string>;
-  readonly declaredProvisions: readonly DeclaredProvision[];
+  readonly declaredResources: readonly DeclaredResource[];
   readonly line: number;
 } => {
-  const declaredProvisions = extractDeclaredProvisions(
+  const declaredResources = extractDeclaredResources(
     def.config,
-    provisionIdsByName
+    resourceIdsByName
   );
   return {
-    calledProvisions: extractCalledProvisions(def.config),
-    declaredIds: buildDeclaredIds(declaredProvisions),
-    declaredNames: buildDeclaredNames(declaredProvisions),
-    declaredProvisions,
+    calledResources: extractCalledResources(def.config),
+    declaredIds: buildDeclaredIds(declaredResources),
+    declaredNames: buildDeclaredNames(declaredResources),
+    declaredResources,
     line: offsetToLine(sourceCode, def.start),
   };
 };
@@ -552,18 +622,18 @@ const checkTrailDefinition = (
   def: { id: string; config: AstNode; start: number },
   filePath: string,
   sourceCode: string,
-  provisionIdsByName: ReadonlyMap<string, string>,
+  resourceIdsByName: ReadonlyMap<string, string>,
   diagnostics: WardenDiagnostic[]
 ): void => {
   const {
-    calledProvisions,
+    calledResources,
     declaredIds,
     declaredNames,
-    declaredProvisions,
+    declaredResources,
     line,
-  } = analyzeTrailServices(def, sourceCode, provisionIdsByName);
+  } = analyzeTrailServices(def, sourceCode, resourceIdsByName);
 
-  if (hasNoProvisionActivity(declaredProvisions, calledProvisions)) {
+  if (hasNoResourceActivity(declaredResources, calledResources)) {
     return;
   }
 
@@ -571,7 +641,7 @@ const checkTrailDefinition = (
     def.id,
     filePath,
     line,
-    calledProvisions,
+    calledResources,
     declaredNames,
     diagnostics
   );
@@ -579,7 +649,7 @@ const checkTrailDefinition = (
     def.id,
     filePath,
     line,
-    calledProvisions,
+    calledResources,
     declaredIds,
     declaredNames,
     diagnostics
@@ -588,8 +658,8 @@ const checkTrailDefinition = (
     def.id,
     filePath,
     line,
-    declaredProvisions,
-    calledProvisions,
+    declaredResources,
+    calledResources,
     diagnostics
   );
 };
@@ -599,9 +669,9 @@ const checkTrailDefinition = (
 // ---------------------------------------------------------------------------
 
 /**
- * Validates that provision access aligns with declared `provisions` arrays.
+ * Validates that resource access aligns with declared `resources` arrays.
  */
-export const provisionDeclarations: WardenRule = {
+export const resourceDeclarations: WardenRule = {
   check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
     if (isTestFile(filePath)) {
       return [];
@@ -613,14 +683,14 @@ export const provisionDeclarations: WardenRule = {
     }
 
     const diagnostics: WardenDiagnostic[] = [];
-    const provisionIdsByName = collectNamedProvisionIds(ast);
+    const resourceIdsByName = collectNamedResourceIds(ast);
 
     for (const def of findTrailDefinitions(ast)) {
       checkTrailDefinition(
         def,
         filePath,
         sourceCode,
-        provisionIdsByName,
+        resourceIdsByName,
         diagnostics
       );
     }
@@ -628,7 +698,7 @@ export const provisionDeclarations: WardenRule = {
     return diagnostics;
   },
   description:
-    'Ensure provision.from(ctx) and ctx.provision() calls match the declared provisions array in trail definitions.',
-  name: 'provision-declarations',
+    'Ensure resource.from(ctx) and ctx.resource() calls match the declared resources array in trail definitions.',
+  name: 'resource-declarations',
   severity: 'error',
 };