@intentius/chant 0.66.1 → 0.68.0

package/src/discovery/fold-composite.test.ts

@@ -197,6 +197,76 @@ describe("composite factory interpretation (chant #1023)", () => {
     expect([...result.entities.keys()].sort()).toEqual(["webBucket", "webRole"]);
   });
 
+
+  // ───────────────────────────────────────────────────────────────────────
+  // The interpretation depth bound (#2370).
+  // ───────────────────────────────────────────────────────────────────────
+
+  /**
+   * A chain of composites each calling the next, `depth` links long, across
+   * separate modules so every link is a fresh `resolveInterpretableFactory`.
+   * Link 0 is the one `main.ts` calls; the last link builds a real resource.
+   */
+  async function writeChain(depth: number): Promise<void> {
+    for (let i = 0; i < depth; i++) {
+      const isLast = i === depth - 1;
+      const body = isLast
+        ? `(props) => ({ bucket: new Bucket({ BucketName: props.name }) })`
+        : `(props) => ({ inner: Link${i + 1}({ name: props.name }) })`;
+      await writeFile(
+        join(testDir, `link${i}.ts`),
+        `
+          import { Bucket } from ${JSON.stringify(LEXICON)};
+          import { Composite } from ${JSON.stringify(compositePath)};
+          ${isLast ? "" : `import { Link${i + 1} } from "./link${i + 1}";`}
+          export const Link${i} = Composite(${body}, "Link${i}");
+        `,
+      );
+    }
+    await writeFile(
+      join(srcDir, "main.ts"),
+      `
+        import { Link0 } from ${JSON.stringify(join(testDir, "link0"))};
+        export const top = Link0({ name: "deep" });
+      `,
+    );
+  }
+
+  test("a chain within the bound interprets all the way down", async () => {
+    // The control. Without this, a test asserting the deep chain falls back
+    // proves only that something went wrong somewhere.
+    await writeChain(4);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(result.errors).toEqual([]);
+    expect(result.foldDecisions.find((d) => d.file.endsWith("main.ts"))?.mode).toBe("fold");
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 4, projectFactoryInvocations: 0 });
+  });
+
+  test("exhausting the bound falls the file back to run, naming the bound", async () => {
+    // 17 links against a bound of 16. Before #2370 this returned the "not
+    // interpretable" answer, so the factory was invoked and the file was
+    // still reported folded — a different evaluation than the one reported,
+    // with nothing in the output saying so.
+    await writeChain(17);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    const decision = result.foldDecisions.find((d) => d.file.endsWith("main.ts"));
+    expect(decision?.mode).toBe("run");
+    expect(decision?.reason).toMatch(/interpretation depth exceeded 16/);
+    // The remedy half of the message: what a reader should suspect.
+    expect(decision?.reason).toMatch(/recursive/);
+    // Falling back means the estate is still built, by the other path. F-Depth
+    // asks for a fallback, not a failure.
+    expect(result.errors).toEqual([]);
+    // And it is a fallback rather than a degradation: the factory was not
+    // invoked instead. Before #2370 this read `projectFactoryInvocations: 1`
+    // with the file still reported folded.
+    expect(foldExecutionCounts()).toMatchObject({ projectFactoryInvocations: 0, factoryInvocations: 0 });
+  });
+
   test("a sibling reference inside the body is a LIVE AttrRef on the real instance", async () => {
     await writeComposite(ADMISSIBLE_BODY);
     await writeMain(CALL_WEBAPP);

package/src/discovery/fold-import.ts

@@ -1769,9 +1769,39 @@ async function resolveCallArguments(
  * inside one module's source, crossing no file boundary — so this is what
  * terminates it. Deliberately small: real composite nesting is 2-3 deep, and a
  * chain past this is a bug, not a design.
+ *
+ * Exhausting it falls the file back to run, naming this bound (#2370). That is
+ * the second half of the specification's `F-Depth`: an implementation states
+ * its bounds and, on exhaustion, falls back rather than fails. The other two —
+ * {@link MAX_RESOLUTION_DEPTH} and `fold()`'s `MAX_FUNCTION_CALL_DEPTH` —
+ * already did.
+ *
+ * It previously returned `undefined` here, which
+ * {@link resolveInterpretableFactory}'s contract defines as "not
+ * interpretable", so the caller invoked the factory instead and the file was
+ * still reported as folded. That conflated two different facts: a factory
+ * whose shape is outside the subset (invoking it is correct) and a factory we
+ * stopped looking at (invoking it is a different evaluation than the one being
+ * reported). The first is a verdict; the second was a silent degradation, and
+ * a reader comparing chant's output against the reference implementation's
+ * "fell back at depth 16" had nothing to explain the difference.
  */
 const MAX_INTERPRETATION_DEPTH = 16;
 
+/**
+ * Exhaustion of {@link MAX_INTERPRETATION_DEPTH}, as its own type so it can
+ * pass through {@link interpretCompositeFactory}'s decline.
+ *
+ * That decline — a blanket `catch { return undefined }` — is right for every
+ * other failure inside a factory body: the body turned out not to interpret,
+ * the caller invokes it instead, and the file still folds. It is wrong for
+ * this one, because giving up at a depth bound is not a statement about the
+ * body. Without a type to test, the depth error was caught by the *enclosing*
+ * interpretation, declined, and the factory invoked — which is how the bound
+ * came to be silent (#2370).
+ */
+class InterpretationDepthError extends FoldError {}
+
 /**
  * The static scope of a module that DEFINES composites — everything
  * interpreting one of its factory bodies needs, computed once per module per
@@ -1969,7 +1999,18 @@ async function resolveInterpretableFactory(
   // Rule 1 — project files only. A text check; no resolution performed for a
   // bare specifier, so this costs nothing for the (common) lexicon case.
   if (!isProjectFileSpecifier(binding.specifier)) return undefined;
-  if (ctx.interpretDepth >= MAX_INTERPRETATION_DEPTH) return undefined;
+  // Not `undefined`: that answer means "not interpretable" and would invoke
+  // the factory while still reporting the file folded. Giving up is a
+  // different fact and falls the file back to run, naming the bound (#2370).
+  if (ctx.interpretDepth >= MAX_INTERPRETATION_DEPTH) {
+    throw new InterpretationDepthError(
+      `interpretation depth exceeded ${MAX_INTERPRETATION_DEPTH} at "${binding.imported}" — a composite ` +
+        "chain this deep is almost certainly recursive. Falling back to run rather than invoking the " +
+        "factory, which would have reported this file as folded while evaluating it a different way.",
+      0,
+      0,
+    );
+  }
 
   let modulePath: string;
   try {
@@ -2346,7 +2387,12 @@ async function interpretCompositeFactory(
     const instance = definition();
     executionCounts.factoryInterpretations += 1;
     return { value: instance };
-  } catch {
+  } catch (err) {
+    // Every other failure here means "this body did not interpret" and the
+    // caller invokes instead. Exhausting the depth bound means "we stopped
+    // looking", which has to reach the file's fold verdict rather than be
+    // answered with an invocation (#2370).
+    if (err instanceof InterpretationDepthError) throw err;
     return undefined;
   }
 }

package/src/fold/fold.test.ts

@@ -66,6 +66,59 @@ describe("fold — template interpolation", () => {
   });
 });
 
+describe("fold — a symbolic value in a plain template (#2349)", () => {
+  // The bug this replaces: both paths produced "[object Object]" and agreed,
+  // so the differential harness — the thing that catches everything else —
+  // saw agreement and said nothing.
+  test("an attribute reference is refused, located, and names the entity", () => {
+    const src = `
+      const bucket = new S3Bucket({ name: "my-bucket" });
+      const x = \`\${bucket.arn}-suffix\`;
+    `;
+    expect(() => foldConst(src, "x")).toThrow(FoldError);
+    try {
+      foldConst(src, "x");
+    } catch (e) {
+      const err = e as FoldError;
+      expect(err.message).toContain("bucket.arn");
+      expect(err.message).toContain("[object Object]");
+      // The remedy, not just the complaint.
+      expect(err.message).toMatch(/Sub|intrinsic/);
+      // Located on the span, so an editor can point at it.
+      expect(err.line).toBeGreaterThan(0);
+      expect(err.column).toBeGreaterThan(0);
+    }
+  });
+
+  test("the run path refuses the same program rather than producing the wrong string", () => {
+    // The other half of #2349: a file that falls back to run must not quietly
+    // succeed where fold refused. `AttrRef.toString` throws, so the two paths
+    // now refuse together instead of agreeing on a wrong value.
+    const Bucket = createResource("S3Bucket", "aws", { arn: "arn" });
+    const bucket = new Bucket({ name: "my-bucket" }) as unknown as Declarable & { arn: AttrRef };
+    expect(() => `${bucket.arn}-suffix`).toThrow(/no string form/);
+    expect(() => "prefix" + (bucket.arn as unknown as string)).toThrow(/no string form/);
+  });
+
+  test("an ordinary value in a template still interpolates", () => {
+    const src = `
+      const region = "us-east-1";
+      const x = \`bucket-\${region}\`;
+    `;
+    expect(foldConst(src, "x")).toBe("bucket-us-east-1");
+  });
+
+  test("a tagged template is untouched — that is the documented idiom", () => {
+    // The refusal is about *plain* templates. The intrinsic form handles
+    // envelopes in its interior and must keep doing so.
+    const src = `
+      const bucket = new S3Bucket({ name: "my-bucket" });
+      const x = Sub\`\${bucket.arn}-suffix\`;
+    `;
+    expect(() => foldConst(src, "x")).not.toThrow(/no string form/);
+  });
+});
+
 describe("fold — objects and spread", () => {
   test("object literal with property and shorthand assignment", () => {
     const src = `

package/src/fold/fold.ts

@@ -151,6 +151,31 @@ export type FoldedValue =
  * invented shape: it's the existing envelope, produced without running the
  * module that would otherwise construct the real `AttrRef`.
  */
+/**
+ * Which symbolic envelope a folded value is, in words a message can use — or
+ * `undefined` for a value that has an honest string form.
+ *
+ * These are the shapes `fold()` produces for things the build resolves later:
+ * a resource attribute, a lexicon intrinsic in either of its two forms, and a
+ * registered authoring helper. None of them can be concatenated into a string
+ * here, because what they stand for is not known until the build runs.
+ */
+export function symbolicEnvelopeKind(value: unknown): string | undefined {
+  if (typeof value !== "object" || value === null) return undefined;
+  const v = value as Record<string, unknown>;
+  if ("__attrRef" in v) {
+    const ref = v.__attrRef as { entity?: unknown; attribute?: unknown } | undefined;
+    const named =
+      typeof ref?.entity === "string" && typeof ref?.attribute === "string"
+        ? ` (${ref.entity}.${ref.attribute})`
+        : "";
+    return `a resource attribute reference${named}`;
+  }
+  if ("__intrinsic" in v && typeof v.__intrinsic === "string") return `the intrinsic \`${v.__intrinsic}\``;
+  if ("__helper" in v && typeof v.__helper === "string") return `the helper \`${v.__helper}\``;
+  return undefined;
+}
+
 export interface AttrRefValue {
   __attrRef: { entity: string; attribute: string };
 }
@@ -1028,7 +1053,24 @@ export function fold(
   if (ts.isTemplateExpression(node)) {
     let out = node.head.text;
     for (const span of node.templateSpans) {
-      out += String(fold(span.expression, consts, intrinsics, externals)) + span.literal.text;
+      const value = fold(span.expression, consts, intrinsics, externals);
+      // A symbolic envelope has no string form. `String({__attrRef: …})` is
+      // `"[object Object]"`, and so is `String(attrRef)` on the run path,
+      // because `../attrref.ts` defines no `toString` — so the two paths
+      // agreed on a wrong answer and the differential saw nothing (#2349).
+      // Refused here rather than stringified, for the same reason the
+      // eager-intrinsic branch refuses a deferred envelope (#1966).
+      const symbolic = symbolicEnvelopeKind(value);
+      if (symbolic) {
+        throw foldError(
+          span.expression,
+          `${symbolic} interpolated into a plain template literal, which would stringify it as ` +
+            '"[object Object]". A symbolic value has no string form until the build resolves it, so a ' +
+            "plain template cannot carry one. Use the lexicon's own intrinsic, whose interior handles " +
+            "envelopes — `Sub`${…}`` for CloudFormation — or move the reference out of the template.",
+        );
+      }
+      out += String(value) + span.literal.text;
     }
     return out;
   }

package/src/index.ts

@@ -64,6 +64,7 @@ export * from "./apply";
 export * from "./deep-observation";
 export * from "./behaviour";
 export * from "./behaviour-http";
+export * from "./behaviour-kinds";
 export * from "./behaviour-delta";
 export * from "./claimed-fields";
 export * from "./fold-provenance";

package/src/lexicon.ts

@@ -24,6 +24,7 @@ import type { DescribeResourcesResult, UnobservedReason } from "./observation";
 import type { DescribeIdentityOptions, DescribeIdentityResult } from "./identity";
 import type { DeepNormalizationHooks, DeepObservationResult } from "./deep-observation";
 import type { BehaviourResult, PredictBehaviourOptions } from "./behaviour";
+import type { BehaviourKinds } from "./behaviour-kinds";
 import type { DisruptionQuery, DisruptionVerdict } from "./lifecycle/disruption";
 import type { OwnerChainVerdict } from "./owner-chain";
 import type { CommandGroup } from "./cli/command-group";
@@ -1459,6 +1460,25 @@ export interface LexiconPlugin {
    */
   predictBehaviour?(options: PredictBehaviourOptions): Promise<BehaviourResult>;
 
+  /**
+   * What this lexicon's own entity types are, to an engine that prices them
+   * (#2382). Rows, not a capability: core resolves and predicts, and a lexicon
+   * says only what its types mean.
+   *
+   * Optional in the way rows can safely be and a capability cannot. A lexicon
+   * that is not installed declared no entities of its types, so its absent
+   * rows describe an absent part of the estate; whereas a *capability* behind
+   * an optional install leaves a consumer with entities nobody will say
+   * anything about, and no refusal naming why — an outcome
+   * `packages/core/src/behaviour.ts` never defined.
+   *
+   * Three things can be said, and saying none is itself a statement that this
+   * lexicon has not been considered: `mapped` rows price a type, `unmapped`
+   * rows state that a real type carries no rate and why, and `nothingPriced`
+   * says it once for the whole substrate — a CI workflow is not an estate.
+   */
+  behaviourKinds?: BehaviourKinds;
+
   /**
    * Report the live status of one deploy unit by its deployed name. Opt-in.
    *

package/src/lifecycle/scenario-cost.test.ts

@@ -105,12 +105,12 @@ describe("evaluateScenario — cost against the fixture's recorded prediction",
   });
 
   test("a fixture whose prediction is a refusal fails with the refusal's reason, never a pass on nothing", () => {
-    const verdict = evaluateScenario(EMPTY, { cost: { maxPerHour: 1e9, currency: "USD" } }, { result: noBehaviourEngineRefusal("augur") });
+    const verdict = evaluateScenario(EMPTY, { cost: { maxPerHour: 1e9, currency: "USD" } }, { result: noBehaviourEngineRefusal("chant") });
     expect(verdict.pass).toBe(false);
     expect(cost(verdict).detail).toContain("the fixture's prediction is a refusal (no-engine)");
     expect(cost(verdict).detail).toContain("Set CHANT_BEHAVIOUR_ENGINE to the engine's address.");
 
-    const broke = outOfCreditBehaviourEngineRefusal("augur", { value: "engine", source: "CHANT_BEHAVIOUR_ENGINE" }, "balance 0");
+    const broke = outOfCreditBehaviourEngineRefusal("chant", { value: "engine", source: "CHANT_BEHAVIOUR_ENGINE" }, "balance 0");
     expect(cost(evaluateScenario(EMPTY, { cost: { maxPerHour: 1e9, currency: "USD" } }, { result: broke })).detail).toContain("engine-out-of-credit");
   });
 

package/src/lint/rules/evl011-symbolic-in-template.test.ts

@@ -0,0 +1,88 @@
+import { describe, test, expect } from "vitest";
+import * as ts from "typescript";
+import { evl011SymbolicInTemplateRule } from "./evl011-symbolic-in-template";
+import type { LintContext } from "../rule";
+
+function createContext(code: string, filePath = "test.ts"): LintContext {
+  const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+  return { sourceFile, entities: [], filePath, lexicon: undefined };
+}
+
+describe("EVL011: a symbolic reference in a plain template", () => {
+  test("rule metadata", () => {
+    expect(evl011SymbolicInTemplateRule.id).toBe("EVL011");
+    expect(evl011SymbolicInTemplateRule.severity).toBe("error");
+    expect(evl011SymbolicInTemplateRule.category).toBe("correctness");
+  });
+
+  test("flags a resource attribute in a plain template, at the reference", () => {
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const x = \`\${bucket.arn}-suffix\`;
+    `);
+    const found = evl011SymbolicInTemplateRule.check(ctx);
+    expect(found).toHaveLength(1);
+    expect(found[0].ruleId).toBe("EVL011");
+    expect(found[0].message).toContain("bucket.arn");
+    // The remedy, not just the complaint — the whole reason this rule exists
+    // alongside a refusal that already fails the build.
+    expect(found[0].message).toMatch(/Sub|intrinsic/);
+    expect(found[0].line).toBe(3);
+  });
+
+  test("flags every offending span, not just the first", () => {
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const queue = new Queue({ name: "q" });
+      const x = \`\${bucket.arn}/\${queue.url}\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(2);
+  });
+
+  test("allows a tagged template — that is the documented remedy", () => {
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const x = Sub\`\${bucket.arn}-suffix\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows an ordinary const in a template", () => {
+    const ctx = createContext(`
+      const region = "us-east-1";
+      const x = \`bucket-\${region}\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("allows a property access on something that is not a resource", () => {
+    // The false positive worth avoiding: this code works, and flagging it
+    // would train people to suppress the rule.
+    const ctx = createContext(`
+      const config = { region: "us-east-1" };
+      const x = \`bucket-\${config.region}\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("says nothing about a reference outside a template", () => {
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const x = bucket.arn;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+
+  test("a missed shape is a cost the refusal already covers", () => {
+    // Reached through an array rather than a plain identifier: lint sees
+    // syntax, not values, so this is not flagged — and `fold()` still refuses
+    // it (#2349). Documented as a deliberate limit rather than left to be
+    // discovered as a gap.
+    const ctx = createContext(`
+      const bucket = new S3Bucket({ name: "b" });
+      const all = [bucket];
+      const x = \`\${all[0].arn}-suffix\`;
+    `);
+    expect(evl011SymbolicInTemplateRule.check(ctx)).toHaveLength(0);
+  });
+});

package/src/lint/rules/evl011-symbolic-in-template.ts

@@ -0,0 +1,100 @@
+import * as ts from "typescript";
+import type { LintRule, LintContext, LintDiagnostic } from "../rule";
+
+/**
+ * EVL011: a symbolic reference inside a plain template literal
+ *
+ * `` `${bucket.arn}-suffix` `` cannot be evaluated to a string. A resource
+ * attribute stands for a value the build resolves later, so there is nothing
+ * to interpolate yet, and JavaScript's answer — `"[object Object]"` — is
+ * wrong on both of chant's paths.
+ *
+ * This rule is the friendly half of #2349. The unfriendly half already landed:
+ * `fold()` refuses the span with a located error and `AttrRef.toString` throws,
+ * so the program fails either way. What a rule adds is finding it at lint time
+ * with the remedy attached, rather than at build time with a stack.
+ *
+ * ## Why it is a heuristic, and why that is acceptable here
+ *
+ * Lint sees syntax, not values. `foo.bar` inside a template is a resource
+ * attribute only if `foo` is a resource, which is a fact `fold()` has and this
+ * rule does not — so the check is: a property access whose object is a
+ * plain identifier bound in this file by `new`. That is the shape #2349 was
+ * reported against and the shape a lexicon's own docs show.
+ *
+ * It therefore misses a reference reached some other way (through a parameter,
+ * an array, a helper's return) and does not flag an access on a plain object.
+ * Missing a case costs nothing, because `fold()` still refuses it; flagging a
+ * plain object would be a false positive on code that works, which is the
+ * error worth avoiding. This is the same asymmetry `../../fold/subset.ts`
+ * documents for EVL generally, pointed the other way: there EVL may be
+ * stricter than fold, here it is deliberately looser.
+ */
+
+/** Identifiers bound by `const x = new T(...)` at any depth in this file. */
+function resourceBindings(sourceFile: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  const visit = (node: ts.Node): void => {
+    if (
+      ts.isVariableDeclaration(node) &&
+      ts.isIdentifier(node.name) &&
+      node.initializer &&
+      ts.isNewExpression(node.initializer)
+    ) {
+      names.add(node.name.text);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return names;
+}
+
+function checkNode(
+  node: ts.Node,
+  context: LintContext,
+  bound: Set<string>,
+  diagnostics: LintDiagnostic[],
+): void {
+  // Untagged only: a tagged template is the documented remedy, and its
+  // interior handles envelopes.
+  if (ts.isTemplateExpression(node) && !ts.isTaggedTemplateExpression(node.parent)) {
+    for (const span of node.templateSpans) {
+      const expr = span.expression;
+      if (
+        ts.isPropertyAccessExpression(expr) &&
+        ts.isIdentifier(expr.expression) &&
+        bound.has(expr.expression.text)
+      ) {
+        const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
+          expr.getStart(context.sourceFile),
+        );
+        diagnostics.push({
+          file: context.filePath,
+          line: line + 1,
+          column: character + 1,
+          ruleId: "EVL011",
+          severity: "error",
+          message:
+            `\`${expr.expression.text}.${expr.name.text}\` is a resource attribute and has no string ` +
+            "form until the build resolves it — a plain template would stringify it as " +
+            "\"[object Object]\". Use the lexicon's own intrinsic, whose interior handles references " +
+            "(`Sub`${…}`` for CloudFormation), or move the reference out of the template.",
+        });
+      }
+    }
+  }
+
+  ts.forEachChild(node, (child) => checkNode(child, context, bound, diagnostics));
+}
+
+export const evl011SymbolicInTemplateRule: LintRule = {
+  id: "EVL011",
+  severity: "error",
+  category: "correctness",
+  description: "A resource attribute cannot be interpolated into a plain template literal",
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    checkNode(context.sourceFile, context, resourceBindings(context.sourceFile), diagnostics);
+    return diagnostics;
+  },
+};

package/src/lint/rules/index.ts

@@ -23,6 +23,7 @@ export { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body";
 export { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings";
 export { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
 export { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
+export { evl011SymbolicInTemplateRule } from "./evl011-symbolic-in-template";
 export { cor017CompositeNameMatchRule } from "./cor017-composite-name-match";
 export { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type";
 export { cor021EnvLiteralNameRule } from "./cor021-env-literal-name";
@@ -49,6 +50,7 @@ import { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body";
 import { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings";
 import { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
 import { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
+import { evl011SymbolicInTemplateRule } from "./evl011-symbolic-in-template";
 import { cor017CompositeNameMatchRule } from "./cor017-composite-name-match";
 import { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type";
 import { cor021EnvLiteralNameRule } from "./cor021-env-literal-name";
@@ -79,6 +81,7 @@ export function loadCoreRules(): LintRule[] {
     evl007InvalidSiblingsRule,
     evl009CompositeNoConstantRule,
     evl010CompositeNoTransformRule,
+    evl011SymbolicInTemplateRule,
     cor017CompositeNameMatchRule,
     cor018CompositePreferLexiconTypeRule,
     cor021EnvLiteralNameRule,

package/src/op/activities/index.ts

@@ -137,8 +137,7 @@ export {
   baseRefFrom,
   headRefFrom,
   noBaseRefMessage,
-  noPredictingLexiconMessage,
-  ambiguousPredictorMessage,
+  noContributedRowsMessage,
 } from "./predict-behaviour";
 export type {
   PredictBehaviourArgs,

package/src/op/activities/predict-behaviour.test.ts

@@ -5,6 +5,7 @@
  */
 
 import { describe, expect, test, vi } from "vitest";
+import { coverageFor, type BehaviourKinds } from "../../behaviour-kinds";
 import {
   behaviourReport,
   noBehaviourEngineRefusal,
@@ -15,14 +16,13 @@ import {
 } from "../../behaviour";
 import { commentMarker, issueMarker, type ReconcilePrArgs, type ReconcileResult } from "./reconcile";
 import {
-  ambiguousPredictorMessage,
   baseRefFrom,
   behaviourFindingMarker,
   createBehaviourFinding,
   declaredEdgeCoverage,
   headRefFrom,
   noBaseRefMessage,
-  noPredictingLexiconMessage,
+  noContributedRowsMessage,
   type BaseCheckout,
 } from "./predict-behaviour";
 
@@ -97,12 +97,25 @@ describe("declaredEdgeCoverage — never complete on the declared path", () => {
 
 describe("the refusals for a project that cannot predict", () => {
   test("no predicting lexicon names the configured ones and what to add", () => {
-    expect(noPredictingLexiconMessage(["aws", "k8s"])).toMatch(/\(aws, k8s\).*augur.*CHANT_BEHAVIOUR_ENGINE/s);
-    expect(noPredictingLexiconMessage([])).toContain("(none)");
+    // Not an error any more: with rows contributed per lexicon there is
+    // nothing to choose between, and an estate whose lexicons contribute no
+    // rows is a real state with a real answer rather than a broken command
+    // (#2382).
+    expect(noContributedRowsMessage(["aws", "k8s"])).toMatch(/\(aws, k8s\).*behaviourKinds.*CHANT_BEHAVIOUR_ENGINE/s);
+    expect(noContributedRowsMessage([])).toContain("(none)");
+    expect(noContributedRowsMessage(["aws"])).toContain("unknown-type");
   });
 
-  test("two predicting lexicons is refused rather than merged", () => {
-    expect(ambiguousPredictorMessage(["augur", "other"])).toMatch(/2 configured lexicons.*\(augur, other\)/);
+  test("two lexicons contributing rows is ordinary, not a conflict", () => {
+    // The old shape refused here, because two lexicons implementing
+    // predictBehaviour() meant two engines pricing one estate. Rows do not
+    // have that problem: each lexicon speaks only about its own entity types,
+    // so contributions are additive and there is nothing to merge.
+    const aws: BehaviourKinds = { provider: "aws", prefixes: ["AWS::"], mapped: { "AWS::S3::Bucket": { kind: "object-store" } } };
+    const k8s: BehaviourKinds = { provider: "kubernetes", prefixes: ["K8s::"], mapped: { "K8s::Core::Pod": { kind: "compute" } } };
+    expect(coverageFor([aws, k8s], "AWS::S3::Bucket").status).toBe("mapped");
+    expect(coverageFor([aws, k8s], "K8s::Core::Pod").status).toBe("mapped");
+    expect(coverageFor([k8s, aws], "AWS::S3::Bucket").status).toBe("mapped");
   });
 });
 
@@ -198,7 +211,7 @@ describe("behaviourFinding — predicts both sides, differences them, and posts
   });
 
   test("a refusal on the base side posts a finding that says no prediction, and flags the run", async () => {
-    const { run, posted } = harness({ base: noBehaviourEngineRefusal("augur"), head: report({ db: figure(0.1) }) });
+    const { run, posted } = harness({ base: noBehaviourEngineRefusal("chant"), head: report({ db: figure(0.1) }) });
     const result = await run({ environment: "prod", traffic: TRAFFIC, op: "pr-behaviour" });
     expect(result.refused).toBe(true);
     expect(result.finding.kind).toBe("no-prediction");