@intentius/chant 0.59.0 → 0.61.0

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

@@ -0,0 +1,107 @@
+/**
+ * chant #2251 — `chant lint` resolves this invocation's declared build-time
+ * parameters before it lints.
+ *
+ * The gap this covers: `runLint` built its `LintOptions` without ever
+ * touching `chant.config.ts`'s `buildParams`, so the OPS* checks imported
+ * every `*.op.ts` file with `params` (`@intentius/chant/params`) still empty.
+ * An Op taking a step argument from `params.<name>` therefore read
+ * `undefined` and OPS012 reported the activity contract violated on source
+ * that builds and runs — reproducible on any project with an Op that reads a
+ * build parameter, `--param` and the declared `env` mapping alike (the
+ * resolution never ran at all, so no input could reach it).
+ *
+ * Mocks `lintCommand` and `loadChantConfigUpward` and drives the exported
+ * `runLint` dispatcher, the same shape ./build.test.ts uses for the matching
+ * #1108 gap in generate mode.
+ */
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import type { ParsedArgs } from "../registry";
+
+const lintCommandMock = vi.fn();
+const loadChantConfigUpwardMock = vi.fn();
+
+vi.mock("../commands/lint", async () => {
+  const actual = await vi.importActual<typeof import("../commands/lint")>("../commands/lint");
+  return {
+    ...actual,
+    lintCommand: (...args: unknown[]) => lintCommandMock(...args),
+    printLintResult: () => {},
+  };
+});
+vi.mock("../../config", async () => {
+  const actual = await vi.importActual<typeof import("../../config")>("../../config");
+  return { ...actual, loadChantConfigUpward: (...args: unknown[]) => loadChantConfigUpwardMock(...args) };
+});
+
+const { runLint } = await import("./lint");
+
+function makeArgs(overrides: Partial<ParsedArgs> = {}): ParsedArgs {
+  return {
+    command: "lint",
+    path: ".",
+    format: "",
+    fix: false,
+    watch: false,
+    verbose: false,
+    help: false,
+    live: false,
+    ...overrides,
+  };
+}
+
+describe("runLint build-time parameters (#2251)", () => {
+  beforeEach(() => {
+    lintCommandMock.mockReset().mockResolvedValue({ success: true, errorCount: 0, warningCount: 0, diagnostics: [] });
+    loadChantConfigUpwardMock.mockReset().mockResolvedValue({ config: {} });
+    vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("a project declaring no buildParams lints with an empty provenance array", async () => {
+    const exit = await runLint({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(lintCommandMock.mock.calls[0][0].buildParams).toEqual([]);
+  });
+
+  test("declared buildParams resolve from their defaults and reach lintCommand", async () => {
+    loadChantConfigUpwardMock.mockResolvedValue({
+      config: { buildParams: { env: { type: "string", default: "local" } } },
+    });
+
+    const exit = await runLint({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(lintCommandMock.mock.calls[0][0].buildParams).toEqual([
+      { name: "env", value: "local", source: "default" },
+    ]);
+  });
+
+  test("--param overrides the declared default, the same precedence chant build applies", async () => {
+    loadChantConfigUpwardMock.mockResolvedValue({
+      config: { buildParams: { env: { type: "string", default: "local" } } },
+    });
+
+    const exit = await runLint({ args: makeArgs({ param: ["env=pr-42"] }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(0);
+    expect(lintCommandMock.mock.calls[0][0].buildParams).toEqual([
+      { name: "env", value: "pr-42", source: "cli" },
+    ]);
+  });
+
+  test("an unresolvable parameter exits non-zero without linting", async () => {
+    loadChantConfigUpwardMock.mockResolvedValue({
+      config: { buildParams: { env: { type: "string", required: true } } },
+    });
+
+    const exit = await runLint({ args: makeArgs(), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    expect(lintCommandMock).not.toHaveBeenCalled();
+  });
+});

package/src/cli/handlers/lint.ts

@@ -1,6 +1,31 @@
+import { resolve } from "node:path";
 import { lintCommand, lintCommandWatch, printLintResult } from "../commands/lint";
 import { formatError, formatInfo } from "../format";
 import type { CommandContext } from "../registry";
+import { commandBuildParams } from "../build-params-cli";
+import { loadChantConfigUpward, type ChantConfig } from "../../config";
+
+/**
+ * chant #2251 — `chant lint` resolves this invocation's declared build-time
+ * parameters (`chant.config.ts`'s `buildParams`) before it lints, the same
+ * way `chant build` and the lifecycle family do (`commandBuildParams`,
+ * ../build-params-cli.ts).
+ *
+ * The OPS* checks import every `*.op.ts` file to read the Op it declares
+ * (../commands/lint.ts's `runOpCheckDiagnostics`), and an Op that takes a
+ * step argument from `params.<name>` (`@intentius/chant/params`) evaluates
+ * that read at module load. With no parameters resolved, `params` is the
+ * empty object every such argument reads `undefined` out of, and OPS012
+ * reports the activity contract violated — `args.env: expected string,
+ * received undefined` — for source that builds and runs correctly. The
+ * config is loaded by walking up from the lint path, so linting a
+ * subdirectory still sees the project root's declarations.
+ */
+async function lintBuildParams(args: { path: string; param?: string[]; paramsFile?: string }) {
+  const { config } = await loadChantConfigUpward(resolve(args.path)).catch(() => ({ config: {} as ChantConfig }));
+  if (!config.buildParams) return [];
+  return commandBuildParams(config.buildParams, args);
+}
 
 export async function runLint(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
@@ -11,12 +36,16 @@ export async function runLint(ctx: CommandContext): Promise<number> {
     return 1;
   }
 
+  const buildParams = await lintBuildParams(args);
+  if (buildParams === undefined) return 1;
+
   if (args.watch) {
     const cleanup = lintCommandWatch({
       path: args.path,
       fix: args.fix,
       format: lintFormat,
       sandbox: args.sandbox,
+      buildParams,
     });
     process.on("SIGINT", () => {
       cleanup();
@@ -31,6 +60,7 @@ export async function runLint(ctx: CommandContext): Promise<number> {
     fix: args.fix,
     format: lintFormat,
     sandbox: args.sandbox,
+    buildParams,
   });
 
   printLintResult(result);

package/src/codegen/json-schema.test.ts

@@ -110,6 +110,91 @@ describe("resolvePropertyType", () => {
     };
     expect(resolvePropertyType({ $ref: "#/definitions/Foo" }, schema, null)).toBe("any");
   });
+
+  // chant #2205 — a branch list beside a real `type` relaxes that type.
+  test("reads the sibling type through a oneOf", () => {
+    const prop: JsonSchemaProperty = {
+      type: "string",
+      oneOf: [{ pattern: "^a" }, { pattern: "^b" }],
+    };
+    expect(resolvePropertyType(prop, emptySchema, defName)).toBe("string");
+  });
+
+  test("reads the sibling $ref through an anyOf", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: { Foo: { properties: { bar: { type: "string" } } } },
+    };
+    const prop: JsonSchemaProperty = {
+      $ref: "#/definitions/Foo",
+      anyOf: [{ required: ["bar"] }],
+    };
+    expect(resolvePropertyType(prop, schema, defName)).toBe("Test_Foo");
+  });
+
+  test("an anyOf branch carrying an enum narrows a string property to that union", () => {
+    // AWS::AmazonMQ::Broker.EngineType: the enum branch beside case-insensitive
+    // patterns for the same two values.
+    const prop: JsonSchemaProperty = {
+      type: "string",
+      anyOf: [
+        { type: "string", enum: ["ACTIVEMQ", "RABBITMQ"] },
+        { pattern: "^[Aa][Cc][Tt][Ii][Vv][Ee][Mm][Qq]$" },
+        { pattern: "^[Rr][Aa][Bb][Bb][Ii][Tt][Mm][Qq]$" },
+      ],
+    };
+    expect(resolvePropertyType(prop, emptySchema, defName)).toBe('"ACTIVEMQ" | "RABBITMQ"');
+  });
+
+  test("a non-string enum branch is left alone", () => {
+    const prop: JsonSchemaProperty = {
+      type: "object",
+      anyOf: [{ enum: ["a", "b"] }],
+    };
+    expect(resolvePropertyType(prop, emptySchema, defName)).toBe("Record<string, any>");
+  });
+
+  test("a branch list with nothing beside it stays 'any'", () => {
+    const prop: JsonSchemaProperty = {
+      oneOf: [
+        { type: "object", properties: { Fixed: { type: "string" } } },
+        { type: "object", properties: { Below: { type: "string" } } },
+      ],
+    };
+    expect(resolvePropertyType(prop, emptySchema, defName)).toBe("any");
+  });
+
+  // chant #2205 — allOf of one $ref and an annotation types as that $ref.
+  test("resolves an allOf of a single $ref plus an annotation", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: { ProtocolType: { type: "string", enum: ["MCP"] } },
+    };
+    const prop: JsonSchemaProperty = {
+      allOf: [{ $ref: "#/definitions/ProtocolType" }, { default: "MCP" }],
+    };
+    expect(resolvePropertyType(prop, schema, defName)).toBe("Test_ProtocolType");
+  });
+
+  test("leaves an allOf that intersects two real shapes as 'any'", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: {
+        A: { properties: { a: { type: "string" } } },
+        B: { properties: { b: { type: "string" } } },
+      },
+    };
+    const prop: JsonSchemaProperty = {
+      allOf: [{ $ref: "#/definitions/A" }, { $ref: "#/definitions/B" }],
+    };
+    expect(resolvePropertyType(prop, schema, defName)).toBe("any");
+  });
+
+  // chant #2205 — `[]` binds tighter than `|`.
+  test("parenthesizes a union inside an array", () => {
+    const prop: JsonSchemaProperty = {
+      type: "array",
+      items: { type: "string", enum: ["arm64", "x86_64"] },
+    };
+    expect(resolvePropertyType(prop, emptySchema, defName)).toBe('("arm64" | "x86_64")[]');
+  });
 });
 
 describe("resolveRef", () => {
@@ -129,6 +214,80 @@ describe("resolveRef", () => {
     };
     expect(resolveRef("#/definitions/Count", schema, defName)).toBe("number");
   });
+
+  // chant #2205 — CloudFormation names its list shapes, and a `$ref` to one
+  // used to fall through to "any".
+  test("resolves an array definition through its items", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: {
+        TagList: { type: "array", items: { $ref: "#/definitions/Tag" } },
+        Tag: { properties: { Key: { type: "string" }, Value: { type: "string" } } },
+      },
+    };
+    expect(resolveRef("#/definitions/TagList", schema, defName)).toBe("Test_Tag[]");
+  });
+
+  test("resolves an array definition of scalars", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: { Names: { type: "array", items: { type: "string" } } },
+    };
+    expect(resolveRef("#/definitions/Names", schema, defName)).toBe("string[]");
+  });
+
+  test("resolves an array definition with no items to 'any[]'", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: { Loose: { type: "array" } },
+    };
+    expect(resolveRef("#/definitions/Loose", schema, defName)).toBe("any[]");
+  });
+
+  test("parenthesizes a union inside an array definition", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: { Modes: { type: "array", items: { type: "string", enum: ["b", "a"] } } },
+    };
+    expect(resolveRef("#/definitions/Modes", schema, defName)).toBe('("a" | "b")[]');
+  });
+
+  test("a list definition that reaches itself terminates", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: { Tree: { type: "array", items: { $ref: "#/definitions/Tree" } } },
+    };
+    expect(resolveRef("#/definitions/Tree", schema, defName)).toBe("any[]");
+  });
+
+  test("a definition that is an allOf of one $ref resolves as that $ref", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: {
+        Wrapped: { allOf: [{ $ref: "#/definitions/Inner" }, { default: "x" }] },
+        Inner: { properties: { a: { type: "string" } } },
+      },
+    };
+    expect(resolveRef("#/definitions/Wrapped", schema, defName)).toBe("Test_Inner");
+  });
+
+  test("a definition that is a sum of object branches stays 'any'", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: {
+        FieldPosition: {
+          oneOf: [
+            { type: "object", properties: { Fixed: { type: "string" } } },
+            { type: "object", properties: { Below: { type: "string" } } },
+          ],
+        },
+      },
+    };
+    expect(resolveRef("#/definitions/FieldPosition", schema, defName)).toBe("any");
+  });
+
+  test("a nested list definition resolves through both hops", () => {
+    const schema: JsonSchemaDocument = {
+      definitions: {
+        Matrix: { type: "array", items: { $ref: "#/definitions/Row" } },
+        Row: { type: "array", items: { type: "number" } },
+      },
+    };
+    expect(resolveRef("#/definitions/Matrix", schema, defName)).toBe("number[][]");
+  });
 });
 
 describe("extractConstraints", () => {

package/src/codegen/json-schema.ts

@@ -20,6 +20,7 @@ export interface JsonSchemaProperty {
   items?: JsonSchemaProperty;
   oneOf?: JsonSchemaProperty[];
   anyOf?: JsonSchemaProperty[];
+  allOf?: JsonSchemaProperty[];
   properties?: Record<string, JsonSchemaProperty>;
   required?: string[];
   enum?: string[];
@@ -54,6 +55,9 @@ export interface PropertyConstraints {
 
 // --- Functions ---
 
+/** Shared empty cycle guard, so the common call allocates nothing. */
+const EMPTY_SEEN: ReadonlySet<string> = new Set<string>();
+
 /**
  * Get the primary type from a type field that can be string or string[].
  * Returns first non-"null" type, or "any" if empty.
@@ -67,6 +71,66 @@ export function primaryType(type: string | string[] | undefined): string {
   return type.length > 0 ? type[0] : "any";
 }
 
+/** The branch list a property carries under `oneOf` or `anyOf`, or undefined. */
+function branchesOf(prop: JsonSchemaProperty): JsonSchemaProperty[] | undefined {
+  if (prop.oneOf && prop.oneOf.length > 0) return prop.oneOf;
+  if (prop.anyOf && prop.anyOf.length > 0) return prop.anyOf;
+  return undefined;
+}
+
+/** A union of string literals, sorted, from a list of enum values. */
+function enumUnion(values: string[]): string {
+  return [...values].sort().map((v) => JSON.stringify(v)).join(" | ");
+}
+
+/**
+ * `T[]`, parenthesized when `T` is a union.
+ *
+ * `[]` binds tighter than `|`, so an unparenthesized `"a" | "b"[]` reads as
+ * `"a" | ("b"[])`: it accepts the bare string `"a"` and rejects `["a"]`.
+ */
+function arrayOf(itemType: string): string {
+  return itemType.includes(" | ") ? `(${itemType})[]` : `${itemType}[]`;
+}
+
+/**
+ * The branch of a `oneOf`/`anyOf` that narrows a string property to an enum.
+ *
+ * CloudFormation writes several string properties as a `type: "string"` beside
+ * a branch list whose first branch is the real enum and whose other branches
+ * are case-insensitive `pattern`s for the same values (`AWS::AmazonMQ::Broker`'s
+ * `EngineType`). The branch list relaxes the enum rather than summing shapes, so
+ * the enum is the useful type. Only strings qualify: anything else is a real sum.
+ */
+function relaxedEnumBranch(
+  prop: JsonSchemaProperty,
+  branches: JsonSchemaProperty[],
+): string[] | undefined {
+  if (prop.type !== undefined && primaryType(prop.type) !== "string") return undefined;
+  for (const b of branches) {
+    if (!b.enum || b.enum.length === 0) continue;
+    if (b.type !== undefined && primaryType(b.type) !== "string") return undefined;
+    if (!b.enum.every((v) => typeof v === "string")) return undefined;
+    return b.enum;
+  }
+  return undefined;
+}
+
+/**
+ * The single content-bearing branch of an `allOf`, when that is the whole shape.
+ *
+ * Every `allOf` in the CloudFormation Registry is one `$ref` beside an
+ * annotation object (`{ "default": "MCP" }`), which types exactly as the `$ref`
+ * alone. An `allOf` that intersects two real shapes has no single answer and is
+ * left to the caller.
+ */
+function soleTypedBranch(branches: JsonSchemaProperty[]): JsonSchemaProperty | undefined {
+  const typed = branches.filter(
+    (b) => b.$ref || b.type || b.properties || b.items || (b.enum && b.enum.length > 0) || branchesOf(b),
+  );
+  return typed.length === 1 ? typed[0] : undefined;
+}
+
 /**
  * Resolve a schema property to its TypeScript type string.
  *
@@ -75,28 +139,43 @@ export function primaryType(type: string | string[] | undefined): string {
  * @param resolveDefName - Callback to produce a TypeScript name from a definition.
  *   Receives (defName: string) and should return the TS type name for that definition.
  *   When null, $ref to object definitions resolves to "any".
+ * @param seen - Definition names already on the current resolution path, so a
+ *   list definition that reaches itself terminates instead of recursing forever.
  */
 export function resolvePropertyType(
   prop: JsonSchemaProperty | undefined,
   schema: JsonSchemaDocument,
   resolveDefName: ((defName: string) => string) | null,
+  seen: ReadonlySet<string> = EMPTY_SEEN,
 ): string {
   if (!prop) return "any";
 
-  // Handle oneOf/anyOf → any
-  if ((prop.oneOf && prop.oneOf.length > 0) || (prop.anyOf && prop.anyOf.length > 0)) {
-    return "any";
+  // `allOf` of one real branch and some annotations types as that branch.
+  if (prop.allOf && prop.allOf.length > 0 && !prop.$ref && !prop.type && !prop.enum) {
+    const sole = soleTypedBranch(prop.allOf);
+    if (sole) return resolvePropertyType(sole, schema, resolveDefName, seen);
+  }
+
+  const branches = branchesOf(prop);
+  if (branches) {
+    // A branch list beside a `type` relaxes that type; the enum branch, when
+    // there is one, is the narrowest reading of it.
+    const relaxed = relaxedEnumBranch(prop, branches);
+    if (relaxed) return enumUnion(relaxed);
+    // With nothing beside it the branch list is a sum of shapes, which this
+    // emitter does not express yet (chant #2278).
+    if (!prop.$ref && !prop.type && !(prop.enum && prop.enum.length > 0)) return "any";
+    // Otherwise fall through and read the sibling keywords.
   }
 
   // Handle $ref
   if (prop.$ref) {
-    return resolveRef(prop.$ref, schema, resolveDefName);
+    return resolveRef(prop.$ref, schema, resolveDefName, seen);
   }
 
   // Inline enum → union of string literals
   if (prop.enum && prop.enum.length > 0) {
-    const sorted = [...prop.enum].sort();
-    return sorted.map((v) => JSON.stringify(v)).join(" | ");
+    return enumUnion(prop.enum);
   }
 
   const pt = primaryType(prop.type);
@@ -111,8 +190,7 @@ export function resolvePropertyType(
       return "boolean";
     case "array":
       if (prop.items) {
-        const itemType = resolvePropertyType(prop.items, schema, resolveDefName);
-        return `${itemType}[]`;
+        return arrayOf(resolvePropertyType(prop.items, schema, resolveDefName, seen));
       }
       return "any[]";
     case "object":
@@ -134,6 +212,7 @@ export function resolveRef(
   ref: string,
   schema: JsonSchemaDocument,
   resolveDefName: ((defName: string) => string) | null,
+  seen: ReadonlySet<string> = EMPTY_SEEN,
 ): string {
   const prefix = "#/definitions/";
   if (!ref.startsWith(prefix)) return "any";
@@ -141,6 +220,8 @@ export function resolveRef(
   const defName = ref.slice(prefix.length);
   const def = schema.definitions?.[defName];
   if (!def) return "any";
+  // A list definition whose items reach it again would recurse without end.
+  if (seen.has(defName)) return "any";
 
   // String enum → named type (via resolveDefName) or string
   if (isEnumDefinition(def)) {
@@ -161,9 +242,26 @@ export function resolveRef(
       case "number": return "number";
       case "boolean": return "boolean";
       case "object": return "Record<string, any>";
+      // CloudFormation names its list shapes: `Tags` is a `$ref` to a `TagList`
+      // definition whose items are the `Tag` definition one hop away. Resolve
+      // through `items` the way the inline `array` case does. (chant #2205)
+      case "array": {
+        if (!def.items) return "any[]";
+        const nested = new Set(seen);
+        nested.add(defName);
+        return arrayOf(resolvePropertyType(def.items, schema, resolveDefName, nested));
+      }
     }
   }
 
+  // An `allOf`/`oneOf`/`anyOf` definition types as its property form would.
+  if (def.allOf || def.oneOf || def.anyOf) {
+    const nested = new Set(seen);
+    nested.add(defName);
+    const viaBranches = resolvePropertyType(def, schema, resolveDefName, nested);
+    if (viaBranches !== "any") return viaBranches;
+  }
+
   return "any";
 }
 

package/src/components/SPRAWL-VALIDATION.md

@@ -16,16 +16,16 @@ generic `runInterpretDriver` (#556, [`../driver.ts`](./driver.ts)), unchanged.
 ## Before / after: the ALB/ECS pipeline glue this replaces
 
 The component model's whole reason for existing is visible in one concrete
-diff. [`examples/gitlab-aws-alb-api/src/pipeline.ts`](../../../../examples/gitlab-aws-alb-api/src/pipeline.ts)
-hand-rolls a `deployService` job that shells out to CloudFormation and greps
+diff. [`examples/gitlab-aws-alb-services/src/pipeline.ts`](../../../../examples/gitlab-aws-alb-services/src/pipeline.ts)
+hand-rolls a `deployServices` job that shells out to CloudFormation and greps
 its own infra stack's outputs before it can deploy:
 
 ```ts
-// before — examples/gitlab-aws-alb-api/src/pipeline.ts (deployService job)
+// before — examples/gitlab-aws-alb-services/src/pipeline.ts (deployServices job)
 `OUTPUTS=$(aws cloudformation describe-stacks --stack-name ${INFRA_STACK} --query 'Stacks[0].Outputs' --output json)`,
 `PARAMS=$(echo "$OUTPUTS" | jq -r '[(.[] | select(.OutputKey == "ClusterArn") | "clusterArn=" + .OutputValue), (.[] | select(.OutputKey == "ListenerArn") | "listenerArn=" + .OutputValue), ...] | join(" ")')`,
-`IMAGE_URI=$(echo "$OUTPUTS" | jq -r '.[] | select(.OutputKey == "ApiRepoUri") | .OutputValue'):${CI_COMMIT_REF_SLUG}`,
-`aws cloudformation deploy --template-file templates/template.json --stack-name ${STACK_NAME} ... --parameter-overrides $PARAMS image=$IMAGE_URI`,
+`API_IMAGE_URI=$(echo "$OUTPUTS" | jq -r '.[] | select(.OutputKey == "ApiRepoUri") | .OutputValue'):${CI_COMMIT_REF_SLUG}`,
+`aws cloudformation deploy --template-file templates/template.json --stack-name ${STACK_NAME} ... --parameter-overrides $PARAMS apiImage=$API_IMAGE_URI uiImage=$UI_IMAGE_URI`,
 ```
 
 That `describe-stacks | jq` line is bespoke per pipeline: every component that

package/src/components/pilots/README.md

@@ -13,7 +13,7 @@ The epic ([#551](https://github.com/INTENTIUS/chant/issues/551)) picked these th
 |---|---|---|---|---|---|---|
 | **Neo4j per-instance fan-out** | [`neo4j-fanout.pilot.ts`](./neo4j-fanout.pilot.ts) / [`neo4j-fanout.json`](../__fixtures__/neo4j-fanout.json) | no-build (`infra`, applies pre-built templates) | **fan-out** — one component composes 3 per-instance mini-compositions (`cfn-deploy` + `code-deploy` + `wait-cluster-healthy`), seed-first then rolling, gated at node 1 | simple apply (no `onReplace`/`stageGsi` — no sticky CFN concerns here) | none (self-contained cluster, no shared-stack imports) | **auto** — `code-deploy` (AWS CodeDeploy) rollback is native/automatic on failure, declared once inside the capability, never scripted per node |
 | **DynamoDB table** | [`dynamodb.pilot.ts`](./dynamodb.pilot.ts) / [`dynamodb-infra.json`](../__fixtures__/dynamodb-infra.json) | no-build (`infra`, applies an existing table template) | single (one `cfn-deploy`, no fan-out) | **sticky** — `onReplace: "block"` refuses a replacing changeset (data loss guard); `stageGsi: true` stages the GSI add→backfill→remove instead of an in-place replace | none | no rollback declared — a blocked replacement is not something to compensate, it is a stop |
-| **ALB/ECS target** | [`alb-ecs.pilot.ts`](./alb-ecs.pilot.ts) / [`alb-ecs-service.json`](../__fixtures__/alb-ecs-service.json) | **build** — `docker-build` → `publish-image` (promote by digest at deploy time) | single (one service, one `cfn-deploy` + `ecs-update-service`) | simple apply (no replacement-sensitive resource here) | **cross-stack** — imports `shared-alb`'s `ListenerArn`/`ClusterArn`/`Subnets` via `stackOutput()`, replacing the `describe-stacks \| jq` glue in [`examples/gitlab-aws-alb-api/src/pipeline.ts`](../../../../../examples/gitlab-aws-alb-api/src/pipeline.ts) | **no** (component-declared) — `ecs-update-service`/`cfn-deploy` have no native automatic rollback for an already-running service swap, so the component supplies an explicit `rollback` phase (`rollback-previous`) rather than relying on capability compensation |
+| **ALB/ECS target** | [`alb-ecs.pilot.ts`](./alb-ecs.pilot.ts) / [`alb-ecs-service.json`](../__fixtures__/alb-ecs-service.json) | **build** — `docker-build` → `publish-image` (promote by digest at deploy time) | single (one service, one `cfn-deploy` + `ecs-update-service`) | simple apply (no replacement-sensitive resource here) | **cross-stack** — imports `shared-alb`'s `ListenerArn`/`ClusterArn`/`Subnets` via `stackOutput()`, replacing the `describe-stacks \| jq` glue in [`examples/gitlab-aws-alb-services/src/pipeline.ts`](../../../../../examples/gitlab-aws-alb-services/src/pipeline.ts) | **no** (component-declared) — `ecs-update-service`/`cfn-deploy` have no native automatic rollback for an already-running service swap, so the component supplies an explicit `rollback` phase (`rollback-previous`) rather than relying on capability compensation |
 
 Read together, the three cover every cell at least once: build only shows up for ALB/ECS, fan-out only for Neo4j, sticky-apply only for DynamoDB, cross-stack only for ALB/ECS, and both rollback styles (capability-native vs component-declared) appear once each.
 

package/src/components/pilots/alb-ecs.pilot.ts

@@ -9,8 +9,8 @@
  * `ecs-update-service` → `wait-steady-state` + `health-gate`.
  *
  * This is the direct component-native replacement for the hand-rolled GitLab
- * pipeline in `examples/gitlab-aws-alb-api/src/pipeline.ts`: the
- * `describe-stacks`/`jq` glue in that pipeline's `deployService` job is
+ * pipeline in `examples/gitlab-aws-alb-services/src/pipeline.ts`: the
+ * `describe-stacks`/`jq` glue in that pipeline's `deployServices` job is
  * exactly the cross-stack `stackOutput()` wiring below, and its
  * `docker build`/`docker push` steps are the `docker-build` + `publish-image`
  * capabilities. `service` archetype: build → publish → apply → verify, the

package/src/config.ts

@@ -481,10 +481,10 @@ export async function loadChantConfig(dir: string): Promise<ResolvedConfig> {
  * lives at the project root, one or more levels up. Before this, callers
  * either read `startDir` alone or bolted on a single `dirname()` fallback —
  * fine for a one-level-deep stack, silently blind to anything deeper
- * (loomster's `src/<stack>` layout is exactly one level too deep: `buildParams`'
- * declared `env:` mappings never resolved, so `LOOM_TIER`/`LOOM_ENV` were inert
- * under every `npm run synth:*` for two releases — loomster#162). Uses the
- * same walk `chant lint`/`chant graph` already used ({@link findProjectConfig},
+ * (a `src/<stack>` layout is exactly one level too deep: `buildParams`' declared
+ * `env:` mappings never resolved, so the env vars they named were inert under
+ * every `npm run synth:*` for two releases). Uses the same walk `chant
+ * lint`/`chant graph` already used ({@link findProjectConfig},
  * shared with `./lint/config.ts`'s `findProjectRoot`) — one config-discovery
  * contract for the whole CLI.
  *

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

@@ -1009,7 +1009,7 @@ describe("tryFoldFile — build-time parameters (chant #1064)", () => {
     expect((entity as unknown as { props: { name: unknown } }).props.name).toBe("staging");
   });
 
-  test("a nullish-coalesced default still folds to a literal (loomster's `params.x ?? \"default\"` pattern)", async () => {
+  test("a nullish-coalesced default still folds to a literal (the `params.x ?? \"default\"` pattern)", async () => {
     const file = join(testDir, "main.ts");
     await writeFile(
       file,

package/src/discovery/fold-import.ts

@@ -1697,9 +1697,9 @@ async function resolveCallArguments(
 //  4. **Its body is a single expression, or a block of `const` declarations
 //     followed by one `return`** — and nothing else. No `if`, no `throw`, no
 //     loop, no `let`/`var`, no nested function declaration, no bare expression
-//     statement. This is the line loomster's `composites/*.ts` fall outside
-//     (module-level `buildXxx()` helpers with `if`/`throw` and `.map()`), and
-//     they are meant to: they keep invoking, exactly as before.
+//     statement. This is the line a project's hand-rolled composite modules
+//     fall outside (module-level `buildXxx()` helpers with `if`/`throw` and
+//     `.map()`), and they are meant to: they keep invoking, exactly as before.
 //  5. **Every expression in it is inside the fold subset, extended with the
 //     two things a factory body exists to do**: `new Type(...)` in ANY value
 //     position (a member, a nested property object, an array element), and a