@intentius/chant-lexicon-gcp 0.44.14 → 0.46.0

package/src/composites/composites.test.ts

@@ -19,35 +19,35 @@ function p(member: unknown): Record<string, any> {
 
 describe("GkeCluster", () => {
   test("returns cluster and node pool", () => {
-    const result = GkeCluster({ name: "my-cluster" });
+    const result = GkeCluster({ name: "my-cluster", projectId: "proj" });
     expect(result.cluster).toBeDefined();
     expect(result.nodePool).toBeDefined();
   });
 
   test("includes common labels", () => {
-    const result = GkeCluster({ name: "my-cluster" });
+    const result = GkeCluster({ name: "my-cluster", projectId: "proj" });
     const meta = p(result.cluster).metadata;
     expect(meta.labels["app.kubernetes.io/managed-by"]).toBe("chant");
   });
 
   test("node pool references cluster", () => {
-    const result = GkeCluster({ name: "my-cluster" });
+    const result = GkeCluster({ name: "my-cluster", projectId: "proj" });
     expect(p(result.nodePool).clusterRef.name).toBe("my-cluster");
   });
 
   test("respects maxNodeCount", () => {
-    const result = GkeCluster({ name: "c", maxNodeCount: 20 });
+    const result = GkeCluster({ name: "c", projectId: "proj", maxNodeCount: 20 });
     expect(p(result.nodePool).autoscaling.maxNodeCount).toBe(20);
   });
 
   test("sets namespace when provided", () => {
-    const result = GkeCluster({ name: "c", namespace: "infra" });
+    const result = GkeCluster({ name: "c", projectId: "proj", namespace: "infra" });
     expect(p(result.cluster).metadata.namespace).toBe("infra");
     expect(p(result.nodePool).metadata.namespace).toBe("infra");
   });
 
   test("enables workload identity by default", () => {
-    const result = GkeCluster({ name: "c" });
+    const result = GkeCluster({ name: "c", projectId: "proj" });
     expect(p(result.cluster).workloadIdentityConfig).toBeDefined();
     expect(p(result.nodePool).nodeConfig.workloadMetadataConfig).toBeDefined();
   });
@@ -59,13 +59,13 @@ describe("GkeCluster", () => {
     );
   });
 
-  test("workloadPool falls back to GCP_PROJECT_ID env var", () => {
+  test("ignores GCP_PROJECT_ID env var — projectId comes from props only", () => {
     const prev = process.env.GCP_PROJECT_ID;
     process.env.GCP_PROJECT_ID = "env-project-456";
     try {
-      const result = GkeCluster({ name: "c" });
+      const result = GkeCluster({ name: "c", projectId: "explicit-project" });
       expect(p(result.cluster).workloadIdentityConfig.workloadPool).toBe(
-        "env-project-456.svc.id.goog",
+        "explicit-project.svc.id.goog",
       );
     } finally {
       if (prev === undefined) delete process.env.GCP_PROJECT_ID;

package/src/composites/gke-cluster.ts

@@ -11,8 +11,8 @@ import { GKECluster, NodePool } from "../generated";
 export interface GkeClusterProps {
   /** Cluster name. */
   name: string;
-  /** GCP project ID for workload identity pool. Falls back to GCP_PROJECT_ID env var. */
-  projectId?: string;
+  /** GCP project ID for the workload identity pool. */
+  projectId: string;
   /** GCP region for regional cluster (default: uses GCP.Region). */
   location?: string;
   /** Initial node count per zone (default: 1). */
@@ -75,6 +75,7 @@ export interface GkeClusterProps {
  *
  * const { cluster, nodePool } = GkeCluster({
  *   name: "my-cluster",
+ *   projectId: "my-project",
  *   location: "us-central1",
  *   maxNodeCount: 10,
  * });
@@ -83,7 +84,7 @@ export interface GkeClusterProps {
 export const GkeCluster = Composite((props: GkeClusterProps) => {
   const {
     name,
-    projectId: rawProjectId,
+    projectId,
     location,
     initialNodeCount = 1,
     machineType = "e2-medium",
@@ -103,8 +104,6 @@ export const GkeCluster = Composite((props: GkeClusterProps) => {
     defaults: defs,
   } = props;
 
-  const projectId = rawProjectId ?? process.env.GCP_PROJECT_ID ?? "PROJECT_ID";
-
   const commonLabels: Record<string, string> = {
     "app.kubernetes.io/name": name,
     "app.kubernetes.io/managed-by": "chant",

package/src/composites/gke-crdb-region.ts

@@ -125,6 +125,7 @@ export const GkeCrdbRegion = Composite<GkeCrdbRegionConfig>((props) => {
 
   const { cluster, nodePool, defaultPool } = GkeCluster({
     name: clusterName,
+    projectId: project,
     location: region,
     machineType,
     diskSizeGb,

package/src/describe-resources.ts

@@ -38,7 +38,7 @@
 
 import type { ObservationResult, ResourceMetadata, UnobservedEntity } from "@intentius/chant/lexicon";
 import { observation } from "@intentius/chant/observation";
-import { hasOwnershipMarker, classifyOwnership, type ChannelKeys } from "@intentius/chant/ownership";
+import { hasOwnershipMarker, classifyOwnership, readOwnership, type ChannelKeys } from "@intentius/chant/ownership";
 import { getResource, mapperForKind, GcpReadError, isNotFound, type GcpReadClientOptions } from "./api/read-client";
 import { resolveGcpProject, parseManifest } from "./op/activities/gcp-apply";
 import { resolveGVK } from "./serializer";
@@ -272,6 +272,9 @@ export async function describeResources(options: {
         status: statusFromRest(obj),
         lastUpdated: obj.updated ?? obj.timeCreated,
         ownership: obj.labels == null ? "unknown" : classifyOwnership(obj.labels, GCP_OWNERSHIP_LABEL_KEYS),
+        // Marker identity (#1222): stack/env from the resource's own labels.
+        // Undefined when the payload carries no labels or no managed-by marker.
+        marker: readOwnership(obj.labels ?? undefined, GCP_OWNERSHIP_LABEL_KEYS),
         attributes: pruneUndefined({
           labels: obj.labels ?? undefined,
           selfLink: obj.selfLink,

package/src/lifecycle-integration.test.ts

@@ -176,5 +176,33 @@ describeObservationConformance({
         });
       },
     },
+    {
+      name: "a marker-stamped resource surfaces its stack/env identity; a foreign one surfaces none (#1222)",
+      declared: ["ownedBucket", "dataBucket"],
+      expectPresent: ["ownedBucket", "dataBucket"],
+      expectMarker: { ownedBucket: { stack: "shop", env: "prod" } },
+      expectNoMarker: ["dataBucket"],
+      run: () => {
+        fetchMock.mockImplementation((url: string) =>
+          Promise.resolve(
+            String(url).includes("owned-bucket")
+              ? restReply(200, {
+                  id: "b/owned-bucket",
+                  labels: { "managed-by": "chant", "chant-stack": "shop", "chant-env": "prod" },
+                })
+              : restReply(200, { id: "b/data-bucket", labels: { team: "data" } }),
+          ),
+        );
+        return gcpPlugin.describeResources!({
+          environment: "prod",
+          buildOutput: "",
+          entityNames: ["ownedBucket", "dataBucket"],
+          entities: new Map([
+            ["ownedBucket", { entityType: "GCP::Storage::Bucket", props: { metadata: { name: "owned-bucket" } } }],
+            ["dataBucket", { entityType: "GCP::Storage::Bucket", props: { metadata: { name: "data-bucket" } } }],
+          ]),
+        });
+      },
+    },
   ],
 });

package/src/lint/post-synth/post-synth.test.ts

@@ -1,4 +1,5 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc101 } from "./wgc101";
 import { wgc102 } from "./wgc102";
 import { wgc103 } from "./wgc103";
@@ -24,9 +25,7 @@ import { wgc402 } from "./wgc402";
 import { wgc403 } from "./wgc403";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 // ── WGC101: Missing encryption ─────────────────────────────────────

package/src/lint/post-synth/wgc101.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc101 } from "./wgc101";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC101: missing encryption", () => {

package/src/lint/post-synth/wgc102.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc102 } from "./wgc102";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC102: public IAM in output", () => {

package/src/lint/post-synth/wgc103.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc103 } from "./wgc103";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC103: missing project annotation", () => {

package/src/lint/post-synth/wgc104.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc104 } from "./wgc104";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC104: missing uniform bucket access", () => {

package/src/lint/post-synth/wgc105.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc105 } from "./wgc105";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC105: public Cloud SQL", () => {

package/src/lint/post-synth/wgc106.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc106 } from "./wgc106";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC106: missing deletion policy", () => {

package/src/lint/post-synth/wgc107.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc107 } from "./wgc107";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC107: missing versioning", () => {

package/src/lint/post-synth/wgc108.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc108 } from "./wgc108";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC108: missing backup configuration", () => {

package/src/lint/post-synth/wgc109.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc109 } from "./wgc109";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC109: open firewall", () => {

package/src/lint/post-synth/wgc110.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc110 } from "./wgc110";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC110: missing key rotation", () => {

package/src/lint/post-synth/wgc111.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc111 } from "./wgc111";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC111: dangling resource reference", () => {

package/src/lint/post-synth/wgc112.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc112 } from "./wgc112";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC112: missing or invalid apiVersion", () => {

package/src/lint/post-synth/wgc113.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc113 } from "./wgc113";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC113: alpha API version", () => {

package/src/lint/post-synth/wgc201.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc201 } from "./wgc201";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC201: missing managed-by label", () => {

package/src/lint/post-synth/wgc202.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc202 } from "./wgc202";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC202: missing workload identity", () => {

package/src/lint/post-synth/wgc203.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc203 } from "./wgc203";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC203: cloud-platform OAuth scope", () => {

package/src/lint/post-synth/wgc204.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc204 } from "./wgc204";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC204: missing shielded VM config", () => {

package/src/lint/post-synth/wgc301.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc301 } from "./wgc301";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC301: no audit logging", () => {

package/src/lint/post-synth/wgc302.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc302 } from "./wgc302";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC302: service API not enabled", () => {

package/src/lint/post-synth/wgc303.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc303 } from "./wgc303";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC303: missing VPC Service Controls", () => {

package/src/lint/post-synth/wgc401.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc401 } from "./wgc401";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC401: unknown spec field", () => {

package/src/lint/post-synth/wgc402.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc402 } from "./wgc402";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC402: missing required field", () => {

package/src/lint/post-synth/wgc403.test.ts

@@ -1,10 +1,9 @@
 import { describe, test, expect } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
 import { wgc403 } from "./wgc403";
 
 function makeCtx(yaml: string) {
-  return {
-    outputs: new Map([["gcp", yaml]]),
-  };
+  return makePostSynthCtx("gcp", yaml);
 }
 
 describe("WGC403: type/structure mismatch", () => {

package/src/op/activities/gcp-apply.test.ts

@@ -6,6 +6,7 @@ import {
   pubSubTopicBody,
   cloudRunServiceBody,
   resolveGcpProject,
+  resolveGcpEndpoint,
   applyResource,
   deleteResource,
   waitForOperation,
@@ -235,6 +236,44 @@ describe("resolveGcpProject (#711)", () => {
   });
 });
 
+describe("resolveGcpEndpoint (#1449)", () => {
+  test("an explicit endpoint arg wins", () => {
+    expect(
+      resolveGcpEndpoint({ endpoint: "http://arg:1" }, { GCP_ENDPOINT_URL: "http://env:2" } as NodeJS.ProcessEnv),
+    ).toBe("http://arg:1");
+  });
+
+  test("falls back to GCP_ENDPOINT_URL — the same variable the read path honours", () => {
+    expect(resolveGcpEndpoint({}, { GCP_ENDPOINT_URL: "http://localhost:4588" } as NodeJS.ProcessEnv))
+      .toBe("http://localhost:4588");
+  });
+
+  test("undefined when neither is set — each kind then uses its real-GCP host", () => {
+    expect(resolveGcpEndpoint({}, {} as NodeJS.ProcessEnv)).toBeUndefined();
+  });
+
+  test("gcpApply honours GCP_ENDPOINT_URL, so nativeApply({ target: 'gcp' }) reaches floci-gcp without passing an endpoint", async () => {
+    const path = "/tmp/chant-1449-endpoint-test.yaml";
+    writeFileSync(path, JSON.stringify(BUCKET));
+    const prev = process.env.GCP_ENDPOINT_URL;
+    process.env.GCP_ENDPOINT_URL = "http://localhost:4588";
+    try {
+      const urls: string[] = [];
+      const http: GcpHttp = async (_method, url) => {
+        urls.push(url);
+        return { status: 200, text: "{}" };
+      };
+      await gcpApply({ manifestPath: path, project: "p" }, undefined, http);
+      expect(urls.length).toBeGreaterThan(0);
+      for (const url of urls) expect(url.startsWith("http://localhost:4588/")).toBe(true);
+    } finally {
+      if (prev === undefined) delete process.env.GCP_ENDPOINT_URL;
+      else process.env.GCP_ENDPOINT_URL = prev;
+      unlinkSync(path);
+    }
+  });
+});
+
 describe("applyResource create/update (#706)", () => {
   function recorder(getStatus: number): { http: GcpHttp; calls: Array<{ method: string; url: string }> } {
     const calls: Array<{ method: string; url: string }> = [];

package/src/op/activities/gcp-apply.ts

@@ -427,6 +427,21 @@ export function orderByReferences(resources: GcpResource[]): GcpResource[] {
 
 // ── Resolution + HTTP ─────────────────────────────────────────────────────────
 
+/**
+ * Resolve the endpoint override (#1449): an explicit `endpoint` arg wins, then
+ * the `GCP_ENDPOINT_URL` env — the same variable the read path honours
+ * (`describe-resources`, floci-gcp), so an apply lands wherever `--live` is
+ * already looking. `undefined` means no override: each kind falls back to its
+ * real-GCP host. The same rule the aws applier applies to `AWS_ENDPOINT_URL`
+ * (#1694) and the fly applier to `FLY_FLAPS_BASE_URL`. Pure.
+ */
+export function resolveGcpEndpoint(
+  args: { endpoint?: string } = {},
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  return args.endpoint || env.GCP_ENDPOINT_URL || undefined;
+}
+
 /** Resolve the project: `GOOGLE_CLOUD_PROJECT` env, else the CNRM project-id annotation. Pure. */
 export function resolveGcpProject(resource: GcpResource, env: NodeJS.ProcessEnv = process.env): string {
   const project = env.GOOGLE_CLOUD_PROJECT || resource.metadata?.annotations?.[PROJECT_ID_ANNOTATION];
@@ -585,7 +600,8 @@ export function parseManifest(content: string, path: string): GcpResource[] {
 export interface GcpApplyArgs {
   /** Path to a built CNRM manifest (YAML multi-doc or JSON). */
   manifestPath: string;
-  /** GCS/GCP endpoint override for all kinds (e.g. floci-gcp `:4588`). Default: each kind's real-GCP host. */
+  /** GCS/GCP endpoint override for all kinds (e.g. floci-gcp `:4588`).
+   * Default: `GCP_ENDPOINT_URL` env, else each kind's real-GCP host. */
   endpoint?: string;
   /** Project override. Default: `GOOGLE_CLOUD_PROJECT` env / CNRM annotation. */
   project?: string;
@@ -742,8 +758,9 @@ export async function gcpApply(
   notPrunable: GcpNotPrunable[];
 }> {
   const resources = orderByReferences(parseManifest(readFileSync(args.manifestPath, "utf8"), args.manifestPath));
+  const endpoint = resolveGcpEndpoint(args);
   const resolve = (mapper: ResourceMapper, resource?: GcpResource) => ({
-    base: (args.endpoint ?? mapper.defaultHost).replace(/\/$/, ""),
+    base: (endpoint ?? mapper.defaultHost).replace(/\/$/, ""),
     project: args.project ?? (resource ? resolveGcpProject(resource) : ""),
   });
 
@@ -831,7 +848,7 @@ export async function gcpDelete(
       notAttempted.push({ kind, name: r.metadata?.name ?? "?", reason: "unsupported-kind" });
       continue;
     }
-    const base = (args.endpoint ?? mapper.defaultHost).replace(/\/$/, "");
+    const base = (resolveGcpEndpoint(args) ?? mapper.defaultHost).replace(/\/$/, "");
     const project = args.project ?? resolveGcpProject(r);
     safeHeartbeat({ step: "gcpDelete", kind: mapper.kind, name: r.metadata?.name });
     const result = await deleteResource(mapper, r, { base, project }, http, signal);

package/src/op/activities/index.ts

@@ -32,6 +32,7 @@ export {
   type GcpNotPrunable,
   chantOwnershipLabels,
   isChantOwned,
+  resolveGcpEndpoint,
   resolveGcpProject,
   parseManifest,
 } from "./gcp-apply";

package/src/serializer.test.ts

@@ -216,7 +216,7 @@ describe("gcpSerializer", () => {
       }),
     );
 
-    const result = gcpSerializer.serialize(entities);
+    const result = gcpSerializer.serialize(entities) as string;
     expect(result).toContain("env: prod");
     // Should not contain "dev" since explicit overrides
     const envLines = result.split("\n").filter((l: string) => l.includes("env:"));
@@ -233,7 +233,7 @@ describe("gcpSerializer", () => {
       }),
     );
 
-    const result = gcpSerializer.serialize(entities);
+    const result = gcpSerializer.serialize(entities) as string;
     // Only one document — property entities should not appear as separate docs
     expect(result.split("---").length).toBeLessThanOrEqual(2);
   });
@@ -264,7 +264,7 @@ describe("gcpSerializer", () => {
       }),
     );
 
-    const result = gcpSerializer.serialize(entities);
+    const result = gcpSerializer.serialize(entities) as string;
     const lines = result.split("\n");
     const keyLines = lines.filter((l: string) => /^\w+:/.test(l));
     const keys = keyLines.map((l: string) => l.split(":")[0]);

package/src/skills/chant-gcp-patterns.md

@@ -127,6 +127,7 @@ import { GkeCluster } from "@intentius/chant-lexicon-gcp";
 
 const { cluster, nodePool } = GkeCluster({
   name: "my-cluster",
+  projectId: "my-project",
   location: "us-central1",
   machineType: "e2-medium",
   minNodeCount: 1,