@intentius/chant 0.22.0 → 0.24.0

package/src/cli/commands/lint.ts

@@ -3,6 +3,7 @@ import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
 import { execFileSync } from "child_process";
 import { runLint, parseDisableComments } from "../../lint/engine";
 import type { LintRule, LintDiagnostic, LintFix } from "../../lint/rule";
+import type { IntrinsicDef } from "../../lexicon";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
 import { formatStylish, formatJson, formatSarif } from "../reporters/stylish";
 import { loadLocalRules } from "../../lint/rule-loader";
@@ -86,8 +87,17 @@ export async function loadPluginRules(
 
 /**
  * Load all lint rules: core COR/EVL rules, then lexicon plugin rules.
+ *
+ * Also returns the active lexicons' registered intrinsics (chant #1106) —
+ * gathered here because this is where the project's lexicon plugins are
+ * already resolved and loaded (`loadPlugins`), the same set `../commands/
+ * build.ts` reads `plugin.intrinsics?.()` off of for the fold path. Handed
+ * back alongside `rules` so `lintCommand` can thread it into every
+ * `runLint` call without loading plugins a second time.
  */
-async function loadAllPluginRules(projectPath: string): Promise<Map<string, LintRule>> {
+async function loadAllPluginRules(
+  projectPath: string,
+): Promise<{ rules: Map<string, LintRule>; intrinsics: IntrinsicDef[] }> {
   const rules = new Map<string, LintRule>();
 
   // Load core COR/EVL rules directly
@@ -106,6 +116,13 @@ async function loadAllPluginRules(projectPath: string): Promise<Map<string, Lint
   // Load only project lexicon plugins (no "chant" injection)
   const plugins = await loadPlugins(lexiconNames);
 
+  // chant #1106 — the same plugins' registered intrinsics (`Ref`, `GetAtt`,
+  // ...), so EVL001 can answer "does this call fold?" exactly like fold()
+  // does instead of flagging every call as a violation. A plugin's
+  // `intrinsics` is an optional extension (not every lexicon defines any),
+  // hence the guard.
+  const intrinsics = plugins.flatMap((plugin) => plugin.intrinsics?.() ?? []);
+
   for (const plugin of plugins) {
     if (plugin.lintRules) {
       for (const r of plugin.lintRules()) {
@@ -127,7 +144,7 @@ async function loadAllPluginRules(projectPath: string): Promise<Map<string, Lint
     rules.set(r.id, r);
   }
 
-  return rules;
+  return { rules, intrinsics };
 }
 
 /**
@@ -428,7 +445,14 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
   const hasOverrides = config.overrides && config.overrides.length > 0;
 
   // Load all rules from lexicon plugins (core "chant" + lexicon-specific)
-  let allRules = await loadAllPluginRules(projectRoot);
+  const loaded = await loadAllPluginRules(projectRoot);
+  let allRules = loaded.rules;
+  // chant #1106 — the active lexicons' registered intrinsics, threaded into
+  // every runLint() call below so EVL001 answers exactly like fold() does
+  // for a registered, opted-in call (`Ref(...)`, `GetAtt(...)`) instead of
+  // flagging it. Computed once here regardless of which branch below runs,
+  // same as `allRules`.
+  const intrinsics = loaded.intrinsics;
 
   // Merge in any config-level plugin rules (custom .ts rule files)
   if (config.plugins && config.plugins.length > 0) {
@@ -443,7 +467,7 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
   let diagnostics: LintDiagnostic[];
   let suppressed: Array<LintDiagnostic & { reason?: string }> = [];
   if (options.rules) {
-    const result = await runLint(files, options.rules, undefined);
+    const result = await runLint(files, options.rules, undefined, intrinsics);
     diagnostics = result.diagnostics;
     suppressed = result.suppressed;
   } else if (hasOverrides) {
@@ -451,13 +475,13 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
     for (const file of files) {
       const relativePath = relative(projectRoot, file);
       const { rules: fileRules, ruleOptions } = getDefaultRules(projectRoot, relativePath, allRules);
-      const result = await runLint([file], fileRules, ruleOptions);
+      const result = await runLint([file], fileRules, ruleOptions, intrinsics);
       diagnostics.push(...result.diagnostics);
       suppressed.push(...result.suppressed);
     }
   } else {
     const { rules, ruleOptions } = getDefaultRules(projectRoot, undefined, allRules);
-    const result = await runLint(files, rules, ruleOptions);
+    const result = await runLint(files, rules, ruleOptions, intrinsics);
     diagnostics = result.diagnostics;
     suppressed = result.suppressed;
   }
@@ -491,7 +515,7 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
 
     // Re-lint after fixes to get updated diagnostics
     if (options.rules) {
-      const postResult = await runLint(files, options.rules, undefined);
+      const postResult = await runLint(files, options.rules, undefined, intrinsics);
       diagnostics = postResult.diagnostics;
       suppressed = postResult.suppressed;
     } else if (hasOverrides) {
@@ -500,13 +524,13 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
       for (const file of files) {
         const relativePath = relative(projectRoot, file);
         const { rules: fileRules, ruleOptions } = getDefaultRules(projectRoot, relativePath, allRules);
-        const postResult = await runLint([file], fileRules, ruleOptions);
+        const postResult = await runLint([file], fileRules, ruleOptions, intrinsics);
         diagnostics.push(...postResult.diagnostics);
         suppressed.push(...postResult.suppressed);
       }
     } else {
       const { rules, ruleOptions } = getDefaultRules(projectRoot, undefined, allRules);
-      const postResult = await runLint(files, rules, ruleOptions);
+      const postResult = await runLint(files, rules, ruleOptions, intrinsics);
       diagnostics = postResult.diagnostics;
       suppressed = postResult.suppressed;
     }

package/src/cli/handlers/build.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Tests for `chant build --components --generate <lexicon>` (generate mode,
+ * #563) — specifically its chant #1108 build-time-parameter resolution,
+ * which was entirely missing before this fix: `generateComponentsPipeline`'s
+ * `discoverComponents` call never resolved `chant.config.ts`'s declared
+ * `buildParams`, so a `*.component.ts` file reading `params.<name>` always
+ * saw `{}` under `chant build --components --generate`, exactly like `chant
+ * run --components` (see ../handlers/run.test.ts's "build-time parameters"
+ * describe block for the equivalent local/`--temporal` coverage).
+ *
+ * Mocks `generateComponentsPipeline` and `loadChantConfigUpward` (chant
+ * #1117 — `runGenerateComponents` walks up to the project root now, same as
+ * `chant build` proper, instead of reading `args.path` alone) and exercises
+ * the public `runBuild` dispatcher (`runGenerateComponents` itself isn't
+ * exported), mirroring `run.test.ts`'s style of driving the handler through
+ * its `CommandContext` entrypoint rather than reaching into private helpers.
+ */
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import type { ParsedArgs } from "../registry";
+
+const generateComponentsPipelineMock = vi.fn();
+const loadChantConfigUpwardMock = vi.fn();
+
+vi.mock("../../components/cli-support", () => ({
+  generateComponentsPipeline: (...args: unknown[]) => generateComponentsPipelineMock(...args),
+}));
+vi.mock("../../config", async () => {
+  const actual = await vi.importActual<typeof import("../../config")>("../../config");
+  return { ...actual, loadChantConfigUpward: (...args: unknown[]) => loadChantConfigUpwardMock(...args) };
+});
+
+const { runBuild } = await import("./build");
+
+function makeArgs(overrides: Partial<ParsedArgs> = {}): ParsedArgs {
+  return {
+    command: "build",
+    path: ".",
+    format: "",
+    fix: false,
+    watch: false,
+    verbose: false,
+    help: false,
+    live: false,
+    components: true,
+    generate: "gitlab",
+    ...overrides,
+  };
+}
+
+function makeStderrSpy() {
+  const buf: string[] = [];
+  vi.spyOn(console, "error").mockImplementation((s: string) => { buf.push(s); });
+  return buf;
+}
+
+describe("runBuild --components --generate (chant #1108 build-time parameters)", () => {
+  beforeEach(() => {
+    generateComponentsPipelineMock.mockReset();
+    loadChantConfigUpwardMock.mockReset().mockResolvedValue({ config: {} });
+  });
+
+  test("no declared buildParams → generateComponentsPipeline is called with an empty provenance array", async () => {
+    generateComponentsPipelineMock.mockResolvedValue({ success: true, yaml: "stages: []", stages: [], jobs: [] });
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const exit = await runBuild({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(generateComponentsPipelineMock).toHaveBeenCalledWith(".", "gitlab", { env: undefined }, undefined, []);
+    vi.restoreAllMocks();
+  });
+
+  test("chant.config.ts's declared buildParams resolve, log, and are forwarded to generateComponentsPipeline", async () => {
+    loadChantConfigUpwardMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string", default: "light" } } },
+    });
+    generateComponentsPipelineMock.mockResolvedValue({ success: true, yaml: "stages: []", stages: [], jobs: [] });
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    const stderr = makeStderrSpy();
+
+    const exit = await runBuild({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(generateComponentsPipelineMock).toHaveBeenCalledWith(
+      ".",
+      "gitlab",
+      { env: undefined },
+      undefined,
+      [{ name: "tier", value: "light", source: "default" }],
+    );
+    expect(stderr.join("\n")).toContain("[param] tier");
+    vi.restoreAllMocks();
+  });
+
+  test("--param overrides a declared default", async () => {
+    loadChantConfigUpwardMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string", default: "light" } } },
+    });
+    generateComponentsPipelineMock.mockResolvedValue({ success: true, yaml: "stages: []", stages: [], jobs: [] });
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const exit = await runBuild({
+      args: makeArgs({ param: ["tier=production"] }),
+      plugins: [],
+      serializers: [],
+    });
+
+    expect(exit).toBe(0);
+    expect(generateComponentsPipelineMock).toHaveBeenCalledWith(
+      ".",
+      "gitlab",
+      { env: undefined },
+      undefined,
+      [{ name: "tier", value: "production", source: "cli" }],
+    );
+    vi.restoreAllMocks();
+  });
+
+  test("an unresolved required build-time parameter → exit 1, never reaches generateComponentsPipeline", async () => {
+    loadChantConfigUpwardMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string" } } },
+    });
+    const stderr = makeStderrSpy();
+
+    const exit = await runBuild({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toMatch(/"tier"/);
+    expect(generateComponentsPipelineMock).not.toHaveBeenCalled();
+  });
+
+  test("an enum violation on --param → exit 1, never reaches generateComponentsPipeline", async () => {
+    loadChantConfigUpwardMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string", enum: ["light", "production"] } } },
+    });
+    const stderr = makeStderrSpy();
+
+    const exit = await runBuild({
+      args: makeArgs({ param: ["tier=bogus"] }),
+      plugins: [],
+      serializers: [],
+    });
+
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toMatch(/"tier"/);
+    expect(stderr.join("\n")).toMatch(/bogus/);
+    expect(generateComponentsPipelineMock).not.toHaveBeenCalled();
+  });
+});

package/src/cli/handlers/build.ts

@@ -4,6 +4,8 @@ import { buildCommand, buildCommandWatch, printErrors, printWarnings, resolveBui
 import { formatError, formatInfo, formatSuccess, formatBold } from "../format";
 import type { CommandContext } from "../registry";
 import { generateComponentsPipeline } from "../../components/cli-support";
+import { loadChantConfigUpward, type ChantConfig } from "../../config";
+import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli";
 
 /**
  * `chant build --components --generate <lexicon>` — generate mode (#563,
@@ -12,11 +14,35 @@ import { generateComponentsPipeline } from "../../components/cli-support";
  * normal lexicon build: no entity discovery, no serializers, no post-synth
  * checks — those apply to lexicon resources, which is a different input to
  * a different command path (`chant build` without `--components`).
+ *
+ * chant #1108 — resolves this invocation's declared build-time parameters
+ * (`chant.config.ts`'s `buildParams`, against `--param`/`--params-file`/a
+ * declared `env` mapping) the exact same way `chant build` does
+ * (`resolveCliBuildParams`, shared with `buildCommand`), BEFORE
+ * `generateComponentsPipeline` discovers/imports any `*.component.ts` file.
+ * Before this, `params.*` (`@intentius/chant/params`) was always `{}` under
+ * this command too — generate mode shares `discoverComponents` with `chant
+ * run --components`, so it had the identical gap.
+ *
+ * chant #1117 — loads config by walking up from `args.path` to the project
+ * root (`loadChantConfigUpward`), same as `chant build` proper, instead of
+ * `args.path` alone: a components-only project built from a subdirectory
+ * otherwise never sees the root `chant.config.ts`'s `buildParams` either.
  */
 async function runGenerateComponents(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
   const lexicon = args.generate as string;
 
+  const { config } = await loadChantConfigUpward(resolve(args.path)).catch(() => ({ config: {} as ChantConfig }));
+  const paramsResolution = resolveCliBuildParams(config.buildParams, {
+    cli: parseParamFlags(args.param),
+    paramsFile: args.paramsFile,
+  });
+  if (!paramsResolution.success) {
+    for (const message of paramsResolution.errors) console.error(message);
+    return 1;
+  }
+
   // Which lexicons support generate mode is a property of the loaded lexicon
   // plugins (those implementing `generateComponentPipeline`, #688), not a
   // hard-coded core list — `generateComponentsPipeline` returns a descriptive
@@ -26,6 +52,7 @@ async function runGenerateComponents(ctx: CommandContext): Promise<number> {
     lexicon,
     { env: args.env },
     args.sandbox,
+    paramsResolution.provenance,
   );
 
   if (!result.success) {
@@ -87,14 +114,7 @@ export async function runBuild(ctx: CommandContext): Promise<number> {
   }
 
   // #1064 — `--param name=value`, repeated, into a flat { name: value } record.
-  const params = args.param?.length
-    ? Object.fromEntries(
-        args.param.map((entry) => {
-          const eq = entry.indexOf("=");
-          return eq === -1 ? [entry, ""] : [entry.slice(0, eq), entry.slice(eq + 1)];
-        }),
-      )
-    : undefined;
+  const params = parseParamFlags(args.param);
 
   if (args.watch) {
     const cleanup = buildCommandWatch({

package/src/cli/handlers/run.test.ts

@@ -878,10 +878,41 @@ describe("runOp dispatcher: --components routes to runOpComponents", () => {
     const exit = await runOp({ args: makeArgs({ path: "svc", components: true, temporal: false }), plugins: [], serializers: [] });
 
     expect(exit).toBe(0);
-    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: undefined, componentOutputs: {} });
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: undefined, componentOutputs: {}, buildParams: [] });
     expect(discoverOpsMock).not.toHaveBeenCalled();
     vi.restoreAllMocks();
   });
+
+  // chant #1116 — --report is Op/Temporal-only (reads a past workflow run);
+  // the component driver never checked it, so it was silently ignored and the
+  // command fell through to a real dispatch. Hard-error instead, before
+  // runComponents is ever reached.
+  test("--report combined with --components → exit 1 before any dispatch, no fall-through (#1116)", async () => {
+    discoverOpsMock.mockReset();
+    const stderr = makeStderrSpy();
+
+    const exit = await runOp({ args: makeArgs({ path: "svc", components: true, report: true, temporal: false }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("not supported with --components");
+    expect(stderr.join("\n")).toContain("#1116");
+    expect(discoverOpsMock).not.toHaveBeenCalled();
+    expect(runComponentsMock).not.toHaveBeenCalled();
+  });
+
+  // Plain --components (no --report) must be unaffected: it still reaches a
+  // real dispatch through runComponents — mocked here, never a real cloud call.
+  test("plain --components (no --report) still dispatches to runComponents (#1116 regression guard)", async () => {
+    discoverOpsMock.mockReset();
+    runComponentsMock.mockResolvedValue({ success: true, selected: ["svc"], run: { order: ["svc"], waves: [["svc"]], results: [{ component: "svc", ok: true, records: [] }], ok: true } });
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+
+    const exit = await runOp({ args: makeArgs({ path: "svc", components: true, report: false, temporal: false }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(runComponentsMock).toHaveBeenCalled();
+    vi.restoreAllMocks();
+  });
 });
 
 describe("runOpComponents", () => {
@@ -900,6 +931,87 @@ describe("runOpComponents", () => {
     expect(runComponentsMock).not.toHaveBeenCalled();
   });
 
+  // ── build-time parameters (chant #1108) — resolved BEFORE dispatch ────────
+
+  describe("build-time parameters", () => {
+    test("chant.config.ts's declared buildParams resolve and log before dispatching to runComponents", async () => {
+      loadChantConfigMock.mockResolvedValue({
+        config: { buildParams: { tier: { type: "string", default: "light" } } },
+      });
+      runComponentsMock.mockResolvedValue({
+        success: true,
+        selected: ["svc"],
+        run: { order: ["svc"], waves: [["svc"]], results: [{ component: "svc", ok: true, records: [] }], ok: true },
+      });
+      const stderr = makeStderrSpy();
+
+      const exit = await runOpComponents({ args: makeArgs({ path: "svc", temporal: false }), plugins: [], serializers: [] });
+
+      expect(exit).toBe(0);
+      expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", expect.objectContaining({
+        buildParams: [{ name: "tier", value: "light", source: "default" }],
+      }));
+      expect(stderr.join("\n")).toContain("[param] tier");
+    });
+
+    test("--param overrides a declared default and is threaded through to runComponents", async () => {
+      loadChantConfigMock.mockResolvedValue({
+        config: { buildParams: { tier: { type: "string", default: "light" } } },
+      });
+      runComponentsMock.mockResolvedValue({
+        success: true,
+        selected: ["svc"],
+        run: { order: ["svc"], waves: [["svc"]], results: [{ component: "svc", ok: true, records: [] }], ok: true },
+      });
+      vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+      const stderr = makeStderrSpy();
+
+      const exit = await runOpComponents({
+        args: makeArgs({ path: "svc", temporal: false, param: ["tier=production"] }),
+        plugins: [],
+        serializers: [],
+      });
+
+      expect(exit).toBe(0);
+      expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", expect.objectContaining({
+        buildParams: [{ name: "tier", value: "production", source: "cli" }],
+      }));
+      expect(stderr.join("\n")).toContain("[param] tier");
+      vi.restoreAllMocks();
+    });
+
+    test("an unresolved required build-time parameter → exit 1 with a formatted error naming it, never reaches runComponents (the previously-{} probe, now a hard stop instead)", async () => {
+      loadChantConfigMock.mockResolvedValue({
+        config: { buildParams: { tier: { type: "string" } } },
+      });
+      const stderr = makeStderrSpy();
+
+      const exit = await runOpComponents({ args: makeArgs({ path: "svc", temporal: false }), plugins: [], serializers: [] });
+
+      expect(exit).toBe(1);
+      expect(stderr.join("\n")).toMatch(/"tier"/);
+      expect(runComponentsMock).not.toHaveBeenCalled();
+    });
+
+    test("an enum violation on --param → exit 1 with a formatted error, never reaches runComponents", async () => {
+      loadChantConfigMock.mockResolvedValue({
+        config: { buildParams: { tier: { type: "string", enum: ["light", "production"] } } },
+      });
+      const stderr = makeStderrSpy();
+
+      const exit = await runOpComponents({
+        args: makeArgs({ path: "svc", temporal: false, param: ["tier=bogus"] }),
+        plugins: [],
+        serializers: [],
+      });
+
+      expect(exit).toBe(1);
+      expect(stderr.join("\n")).toMatch(/"tier"/);
+      expect(stderr.join("\n")).toMatch(/bogus/);
+      expect(runComponentsMock).not.toHaveBeenCalled();
+    });
+  });
+
   test("happy path: single component, human output, exit 0", async () => {
     runComponentsMock.mockResolvedValue({
       success: true,
@@ -916,7 +1028,7 @@ describe("runOpComponents", () => {
     const exit = await runOpComponents({ args: makeArgs({ path: "svc", temporal: false }), plugins: [], serializers: [] });
 
     expect(exit).toBe(0);
-    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: undefined, componentOutputs: {} });
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: undefined, componentOutputs: {}, buildParams: [] });
     const printed = stderrWrite.mock.calls.map((c) => String(c[0])).join("");
     expect(printed).toContain("interpret run completed");
     vi.restoreAllMocks();
@@ -928,7 +1040,7 @@ describe("runOpComponents", () => {
 
     await runOpComponents({ args: makeArgs({ path: "svc", env: "staging", temporal: false }), plugins: [], serializers: [] });
 
-    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: "staging", componentOutputs: {} });
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "svc", { env: "staging", componentOutputs: {}, buildParams: [] });
     vi.restoreAllMocks();
   });
 
@@ -994,6 +1106,7 @@ describe("runOpComponents", () => {
       env: undefined,
       componentOutputs: {},
       onProgress: undefined,
+      buildParams: [],
     });
     expect(stdoutWrite).not.toHaveBeenCalled();
     vi.restoreAllMocks();
@@ -1018,7 +1131,7 @@ describe("runOpComponents", () => {
     const exit = await runOpComponents({ args: makeArgs({ path: "all", temporal: false }), plugins: [], serializers: [] });
 
     expect(exit).toBe(0);
-    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "all", { env: undefined, componentOutputs: {} });
+    expect(runComponentsMock).toHaveBeenCalledWith(expect.any(String), "all", { env: undefined, componentOutputs: {}, buildParams: [] });
     const printed = stderrWrite.mock.calls.map((c) => String(c[0])).join("");
     expect(printed).toContain("shared-alb");
     expect(printed).toContain("search-service");
@@ -1269,7 +1382,13 @@ describe("runOpComponents: --temporal routes to the durable path", () => {
     resolveComponentTargetsMock.mockReset();
     findComponentGateMock.mockReset();
     loadComponentTemporalCodegenMock.mockReset();
-    loadChantConfigMock.mockReset();
+    // chant #1108 — runOpComponents now resolves build-time parameters (which
+    // needs chant.config.ts's declared `buildParams`) BEFORE dispatching to
+    // either the local or --temporal path, so every test in this block hits
+    // loadChantConfig at least once now, even ones that never reach the rest
+    // of the durable path (e.g. "unknown component"). Individual tests below
+    // still override this where they care about a specific config shape.
+    loadChantConfigMock.mockReset().mockResolvedValue({ config: {} });
     resolveProfileMock.mockReset();
     loadTemporalClientMock.mockReset();
     spawnChildMock.mockReset();
@@ -1297,6 +1416,73 @@ describe("runOpComponents: --temporal routes to the durable path", () => {
     expect(stderr.join("\n")).toContain('Component "missing" not found');
   });
 
+  // ── build-time parameters (chant #1108) — resolved before discovery here too ─
+
+  test("resolved build-time parameters are forwarded into resolveComponentTargets on the --temporal path", async () => {
+    process.env.LOOM_ENV = "staging";
+    resolveComponentTargetsMock.mockResolvedValue({
+      success: true,
+      targets: [{ name: "gated-svc", dependsOn: [], deploy: [] }],
+    });
+    resolveProfileMock.mockReturnValue({ address: "localhost:7233", namespace: "default", taskQueue: "q" });
+    loadComponentTemporalCodegenMock.mockResolvedValue({
+      serializeComponent: () => ({ "components/gated-svc/worker.ts": "// worker" }),
+      componentWorkflowFnName: (name: string) => `${name}ComponentWorkflow`,
+    });
+    const mockClient = createMockTemporalClient({
+      describeByWorkflowId: {
+        "chant-component-gated-svc": {
+          workflowId: "chant-component-gated-svc", runId: "r1",
+          status: { name: "COMPLETED" }, startTime: new Date(),
+          taskQueue: "gated-svc", type: { name: "gatedSvcComponentWorkflow" },
+        },
+      },
+      historyByWorkflowId: { "chant-component-gated-svc": [] },
+    });
+    // setupTemporalClient sets its own default loadChantConfigMock resolved
+    // value, so the test's own (buildParams-declaring) config must be set
+    // AFTER calling it, not before.
+    setupTemporalClient(mockClient);
+    loadChantConfigMock.mockResolvedValue({
+      config: { buildParams: { env: { type: "string", env: "LOOM_ENV", default: "dev" } } },
+    });
+    const { proc } = makeFakeChildProcess();
+    spawnChildMock.mockReturnValue(proc);
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+
+    try {
+      vi.useFakeTimers();
+      const promise = runOpComponents({ args: makeArgs({ path: "gated-svc", temporal: true }), plugins: [], serializers: [] });
+      await vi.advanceTimersByTimeAsync(5000);
+      const exit = await promise;
+
+      expect(exit).toBe(0);
+      expect(resolveComponentTargetsMock).toHaveBeenCalledWith(
+        expect.any(String),
+        "gated-svc",
+        undefined,
+        [{ name: "env", value: "staging", source: "env" }],
+      );
+    } finally {
+      vi.useRealTimers();
+      vi.restoreAllMocks();
+      delete process.env.LOOM_ENV;
+    }
+  });
+
+  test("an unresolved required build-time parameter → exit 1, never reaches resolveComponentTargets", async () => {
+    loadChantConfigMock.mockResolvedValue({
+      config: { buildParams: { tier: { type: "string" } } },
+    });
+    const stderr = makeStderrSpy();
+
+    const exit = await runOpComponents({ args: makeArgs({ path: "gated-svc", temporal: true }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toMatch(/"tier"/);
+    expect(resolveComponentTargetsMock).not.toHaveBeenCalled();
+  });
+
   test("compiles the component, spawns the worker, submits the workflow, polls to COMPLETED", async () => {
     vi.useFakeTimers();
     try {