@intentius/chant-lexicon-temporal 0.1.6 → 0.1.9

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "2bb766cde85d9582aad27502fb33c83b64fabb393c1e0ad1ad57fbac1dd62821",
+    "manifest.json": "d761ce46ec1eddb21dc7458840f24b906f9669a4f08e6c48afebb559c225ff13",
     "meta.json": "c77a3c415993bed3865e07fa6db4fb7b9e87de0afa8d8675f64eadf50f914077",
     "types/index.d.ts": "5216f5256321f084a7c8211ef66ab599f621c74751cc3485cfc2a62502b81e2f",
     "rules/tmp001.ts": "689222211a93716a7e4432f6dd6a2a2ab54020b232049fb602893872585f9978",
@@ -11,5 +11,5 @@
     "skills/chant-temporal.md": "ff929983b33bb420c49ab61851f3799c5610256cb972d6c584792bb98b0cfb22",
     "skills/chant-temporal-ops.md": "7e83bc3e6e63af4ab14b8dc07aa00132d51991cf35b1bca29560d48934bff6dc"
   },
-  "composite": "187667fff0222f3498a5063bcec56e25cd716b1de3acd51e88cad3d45b4aba05"
+  "composite": "b91b0371789bf94fcf5d1d4cb2e5da113daa0ffea29297f5879d93677a0614d3"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "temporal",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "chantVersion": ">=0.1.0",
   "namespace": "Temporal",
   "intrinsics": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-temporal",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "Temporal lexicon for chant — server deployment, namespaces, search attributes, and schedules",
   "license": "Apache-2.0",
   "type": "module",

package/src/codegen/docs.ts

@@ -10,6 +10,7 @@ export async function generateDocs(options?: { verbose?: boolean }): Promise<voi
     description: "Temporal lexicon documentation",
     distDir: "./dist",
     outDir: "./docs",
+    basePath: process.env.DOCS_BASE_PATH ?? "/chant/lexicons/temporal/",
     serviceFromType: (type: string) => type.split("::")[1] ?? type,
     resourceTypeUrl: (type: string) => `#${type}`,
   };

package/src/composites/composites.test.ts

@@ -1,10 +1,12 @@
 /**
- * Composite unit tests — TemporalDevStack, TemporalCloudStack.
+ * Composite unit tests — TemporalDevStack, TemporalCloudStack, WatchOp.
  */
 
 import { describe, test, expect } from "vitest";
 import { TemporalDevStack } from "./dev-stack";
 import { TemporalCloudStack } from "./cloud-stack";
+import { WatchOp } from "./watch-op";
+import { serializeOps } from "../op/serializer";
 import { DECLARABLE_MARKER } from "@intentius/chant/declarable";
 
 function getProps(entity: unknown): Record<string, unknown> {
@@ -129,3 +131,103 @@ describe("TemporalCloudStack: basic", () => {
     expect(getProps(ns).description).toBe("Production namespace");
   });
 });
+
+// ── WatchOp ──────────────────────────────────────────────────────────
+
+describe("WatchOp: shape", () => {
+  test("returns op + schedule resources", () => {
+    const result = WatchOp({ name: "prod-watch", env: "prod", schedule: "*/15 * * * *" });
+    expect(result.op).toBeDefined();
+    expect(result.schedule).toBeDefined();
+  });
+
+  test("op has entityType Temporal::Op", () => {
+    const { op } = WatchOp({ name: "prod-watch", env: "prod", schedule: "*/15 * * * *" });
+    expect(getEntityType(op)).toBe("Temporal::Op");
+  });
+
+  test("schedule has entityType Temporal::Schedule", () => {
+    const { schedule } = WatchOp({ name: "prod-watch", env: "prod", schedule: "*/15 * * * *" });
+    expect(getEntityType(schedule)).toBe("Temporal::Schedule");
+  });
+
+  test("both entities are Declarable", () => {
+    const { op, schedule } = WatchOp({ name: "prod-watch", env: "prod", schedule: "*/15 * * * *" });
+    expect((op as Record<symbol, unknown>)[DECLARABLE_MARKER]).toBe(true);
+    expect((schedule as Record<symbol, unknown>)[DECLARABLE_MARKER]).toBe(true);
+  });
+});
+
+describe("WatchOp: configuration", () => {
+  test("op has Snapshot + Diff phases referencing the right activities", () => {
+    const { op } = WatchOp({ name: "p", env: "prod", schedule: "*/15 * * * *" });
+    const phases = (getProps(op).phases as Array<Record<string, unknown>>) ?? [];
+    expect(phases.map((p) => p.name)).toEqual(["Snapshot", "Diff"]);
+    const snapStep = (phases[0].steps as Array<Record<string, unknown>>)[0];
+    const diffStep = (phases[1].steps as Array<Record<string, unknown>>)[0];
+    expect(snapStep.fn).toBe("stateSnapshot");
+    expect(diffStep.fn).toBe("stateDiff");
+    expect(snapStep.args).toEqual({ env: "prod" });
+    expect(diffStep.args).toEqual({ env: "prod", live: true });
+    // Drift is surfaced as a workflow search attribute via outcomeAttribute (#41)
+    expect(diffStep.outcomeAttribute).toEqual({ name: "Drift", from: "drifted" });
+  });
+
+  test("auto-emit search attrs include Watch + Env", () => {
+    const { op } = WatchOp({ name: "p", env: "prod", schedule: "* * * * *" });
+    expect(getProps(op).searchAttributes).toEqual({ Watch: "true", Env: "prod" });
+  });
+
+  test("schedule.action.workflowType is camelCase + 'Workflow'", () => {
+    const { schedule } = WatchOp({ name: "prod-watch", env: "prod", schedule: "* * * * *" });
+    const action = (getProps(schedule).action as Record<string, unknown>);
+    expect(action.workflowType).toBe("prodWatchWorkflow");
+  });
+
+  test("schedule.spec.cronExpressions carries the configured cron", () => {
+    const { schedule } = WatchOp({ name: "p", env: "prod", schedule: "0 0 * * *" });
+    const spec = (getProps(schedule).spec as Record<string, unknown>);
+    expect(spec.cronExpressions).toEqual(["0 0 * * *"]);
+  });
+
+  test("scheduleId is `${name}-schedule`", () => {
+    const { schedule } = WatchOp({ name: "prod-watch", env: "prod", schedule: "* * * * *" });
+    expect(getProps(schedule).scheduleId).toBe("prod-watch-schedule");
+  });
+
+  test("taskQueue defaults to name and is shared by op + schedule", () => {
+    const { op, schedule } = WatchOp({ name: "p-watch", env: "prod", schedule: "* * * * *" });
+    expect(getProps(op).taskQueue).toBe("p-watch");
+    expect((getProps(schedule).action as Record<string, unknown>).taskQueue).toBe("p-watch");
+  });
+
+  test("taskQueue override is honored", () => {
+    const { op, schedule } = WatchOp({ name: "p", env: "prod", schedule: "* * * * *", taskQueue: "custom-q" });
+    expect(getProps(op).taskQueue).toBe("custom-q");
+    expect((getProps(schedule).action as Record<string, unknown>).taskQueue).toBe("custom-q");
+  });
+
+  test("live: false produces a digest-only diff step", () => {
+    const { op } = WatchOp({ name: "p", env: "prod", schedule: "* * * * *", live: false });
+    const phases = getProps(op).phases as Array<Record<string, unknown>>;
+    const diffStep = (phases[1].steps as Array<Record<string, unknown>>)[0];
+    expect(diffStep.args).toEqual({ env: "prod", live: false });
+  });
+});
+
+describe("WatchOp: serialization", () => {
+  test("Op serializes into a workflow.ts containing the snapshot+diff sequence and search-attr upserts", () => {
+    const { op } = WatchOp({ name: "prod-watch", env: "prod", schedule: "*/15 * * * *" });
+    const ops = new Map([["prod-watch", op]]) as unknown as Parameters<typeof serializeOps>[0];
+    const files = serializeOps(ops);
+    const wf = files["ops/prod-watch/workflow.ts"];
+    expect(wf).toBeDefined();
+    expect(wf).toContain('upsertSearchAttributes({"OpName":["prod-watch"],"Watch":["true"],"Env":["prod"]});');
+    expect(wf).toContain('upsertSearchAttributes({ Phase: ["Snapshot"] });');
+    expect(wf).toContain('upsertSearchAttributes({ Phase: ["Diff"] });');
+    expect(wf).toContain("stateSnapshot(");
+    // Diff result captured + Drift search attribute auto-emitted
+    expect(wf).toContain("const __r0 = await stateDiff(");
+    expect(wf).toContain('upsertSearchAttributes({ "Drift": [String(__r0?.drifted)] });');
+  });
+});

package/src/composites/watch-op.ts

@@ -0,0 +1,101 @@
+/**
+ * WatchOp composite — periodic state observation via a chant Op + a
+ * TemporalSchedule.
+ *
+ * Composes existing pieces:
+ *   - The Op codegen (#7) emits a workflow that runs phases sequentially
+ *   - The auto-emit search-attribute behavior (#28) tags each phase
+ *   - The pre-built stateSnapshot + stateDiff activities (this commit)
+ *   - TemporalSchedule fires the workflow on a cron schedule
+ *
+ * @example
+ * ```typescript
+ * export const { op, schedule } = WatchOp({
+ *   name: "prod-watch",
+ *   env: "prod",
+ *   schedule: "0,15,30,45 * * * *", // every 15 minutes
+ * });
+ * ```
+ *
+ * @see #31 — Continuous observation (the issue this composite addresses)
+ */
+
+import { Op, phase, activity, OpResource } from "@intentius/chant/op";
+import { TemporalSchedule } from "../resources";
+
+function kebabToCamel(s: string): string {
+  return s.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+
+export interface WatchOpConfig {
+  /**
+   * Op name (kebab-case). Used as workflow function name (camelCase),
+   * task queue, and schedule id base.
+   */
+  name: string;
+  /** Environment to snapshot + diff (e.g. "prod"). */
+  env: string;
+  /**
+   * Cron expression controlling how often the watch runs.
+   * @example "0,15,30,45 * * * *" — every 15 minutes
+   * @example "0 * * * *" — hourly
+   */
+  schedule: string;
+  /**
+   * Override the task queue. Defaults to `name`.
+   */
+  taskQueue?: string;
+  /**
+   * Run `chant state diff --live` (queries cloud APIs) instead of the
+   * default digest-only diff. Recommended for real drift detection.
+   * @default true
+   */
+  live?: boolean;
+}
+
+export interface WatchOpResources {
+  /** Op resource — generates the snapshot+diff workflow on `chant build`. */
+  op: InstanceType<typeof OpResource>;
+  /** Temporal schedule that fires the workflow on the configured cron. */
+  schedule: InstanceType<typeof TemporalSchedule>;
+}
+
+export function WatchOp(config: WatchOpConfig): WatchOpResources {
+  const taskQueue = config.taskQueue ?? config.name;
+  const live = config.live ?? true;
+
+  const op = Op({
+    name: config.name,
+    overview: `Periodically snapshot and diff the ${config.env} environment`,
+    taskQueue,
+    searchAttributes: {
+      Watch: "true",
+      Env: config.env,
+    },
+    phases: [
+      phase("Snapshot", [activity("stateSnapshot", { env: config.env })]),
+      phase("Diff", [
+        // outcomeAttribute surfaces stateDiff's `drifted` boolean as a
+        // workflow-level Drift search attribute, making 'show me runs that
+        // detected drift' a one-filter UI query.
+        {
+          kind: "activity",
+          fn: "stateDiff",
+          args: { env: config.env, live },
+          outcomeAttribute: { name: "Drift", from: "drifted" },
+        },
+      ]),
+    ],
+  });
+
+  const schedule = new TemporalSchedule({
+    scheduleId: `${config.name}-schedule`,
+    spec: { cronExpressions: [config.schedule] },
+    action: {
+      workflowType: kebabToCamel(config.name) + "Workflow",
+      taskQueue,
+    },
+  } as Record<string, unknown>);
+
+  return { op, schedule };
+}

package/src/describe-resources.test.ts

@@ -0,0 +1,328 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+
+const loadChantConfigMock = vi.fn();
+const loadTemporalClientMock = vi.fn();
+const resolveProfileMock = vi.fn();
+
+vi.mock("@intentius/chant/config", () => ({
+  loadChantConfig: (...args: unknown[]) => loadChantConfigMock(...args),
+}));
+
+vi.mock("@intentius/chant/cli/handlers/run-client", () => ({
+  loadTemporalClient: () => loadTemporalClientMock(),
+  connectionOptions: (profile: { address: string }) => ({ address: profile.address }),
+  resolveProfile: (...args: unknown[]) => resolveProfileMock(...args),
+}));
+
+const { describeResources } = await import("./describe-resources");
+
+interface FakeNamespace {
+  name: string;
+  state?: number;
+  description?: string;
+  retentionSeconds?: number;
+  isGlobal?: boolean;
+}
+
+interface FakeSchedule {
+  scheduleId: string;
+  workflowType?: string;
+  cronExpressions?: string[];
+  paused?: boolean;
+}
+
+function fakeConnection(opts: {
+  namespaces: FakeNamespace[];
+  searchAttributesByNs?: Record<string, Record<string, number>>;
+  schedulesByNs?: Record<string, FakeSchedule[]>;
+  searchAttrThrows?: Set<string>;
+  scheduleThrows?: Set<string>;
+}) {
+  const close = vi.fn(async () => {});
+  return {
+    workflowService: {
+      listNamespaces: vi.fn(async () => ({
+        namespaces: opts.namespaces.map((n) => ({
+          namespaceInfo: {
+            name: n.name,
+            state: n.state ?? 1,
+            description: n.description,
+          },
+          config: n.retentionSeconds
+            ? { workflowExecutionRetentionTtl: { seconds: n.retentionSeconds } }
+            : null,
+          isGlobalNamespace: n.isGlobal ?? false,
+        })),
+        nextPageToken: null,
+      })),
+    },
+    operatorService: {
+      listSearchAttributes: vi.fn(async ({ namespace }: { namespace: string }) => {
+        if (opts.searchAttrThrows?.has(namespace)) {
+          throw new Error(`stubbed search-attribute failure for ${namespace}`);
+        }
+        return { customAttributes: opts.searchAttributesByNs?.[namespace] ?? {} };
+      }),
+    },
+    close,
+  };
+}
+
+function fakeClient(opts: {
+  schedulesByNs?: Record<string, FakeSchedule[]>;
+  scheduleThrows?: Set<string>;
+}) {
+  return {
+    scheduleClient: {
+      list: ({ namespace }: { namespace?: string }) => {
+        const schedules = opts.schedulesByNs?.[namespace ?? ""] ?? [];
+        const shouldThrow = !!namespace && opts.scheduleThrows?.has(namespace);
+        return (async function* () {
+          if (shouldThrow) throw new Error(`stubbed schedule list failure for ${namespace}`);
+          for (const s of schedules) {
+            yield {
+              scheduleId: s.scheduleId,
+              spec: s.cronExpressions ? { cronExpressions: s.cronExpressions } : null,
+              action: s.workflowType ? { type: "startWorkflow", workflowType: s.workflowType } : null,
+              state: s.paused ? { paused: true } : null,
+            };
+          }
+        })();
+      },
+    },
+  };
+}
+
+function setupClientMock(connection: unknown, client: unknown) {
+  loadTemporalClientMock.mockResolvedValue({
+    Connection: { connect: vi.fn(async () => connection) },
+    Client: vi.fn(() => client) as unknown as new () => unknown,
+  });
+}
+
+describe("describeResources", () => {
+  beforeEach(() => {
+    loadChantConfigMock.mockReset();
+    loadTemporalClientMock.mockReset();
+    resolveProfileMock.mockReset();
+
+    loadChantConfigMock.mockResolvedValue({ config: { temporal: { profiles: { dev: { address: "localhost:7233", namespace: "default", taskQueue: "q" } } } } });
+    resolveProfileMock.mockReturnValue({ address: "localhost:7233", namespace: "default", taskQueue: "q" });
+  });
+
+  test("emits one row per namespace + search-attr + schedule", async () => {
+    const connection = fakeConnection({
+      namespaces: [{ name: "default" }, { name: "prod" }],
+      searchAttributesByNs: {
+        default: { Project: 2 },
+        prod: { Phase: 1 },
+      },
+      schedulesByNs: {
+        default: [{ scheduleId: "daily-report", workflowType: "reportWf", cronExpressions: ["0 8 * * *"] }],
+        prod: [{ scheduleId: "weekly-backup", workflowType: "backupWf", paused: true }],
+      },
+    });
+    const client = fakeClient({
+      schedulesByNs: {
+        default: [{ scheduleId: "daily-report", workflowType: "reportWf", cronExpressions: ["0 8 * * *"] }],
+        prod: [{ scheduleId: "weekly-backup", workflowType: "backupWf", paused: true }],
+      },
+    });
+    setupClientMock(connection, client);
+
+    const result = await describeResources({ environment: "dev", buildOutput: "", entityNames: [], entities: new Map() });
+
+    expect(Object.keys(result).sort()).toEqual([
+      "namespace/default",
+      "namespace/prod",
+      "schedule/default/daily-report",
+      "schedule/prod/weekly-backup",
+      "searchAttribute/default/Project",
+      "searchAttribute/prod/Phase",
+    ]);
+  });
+
+  test("populates the resource metadata shape correctly", async () => {
+    const connection = fakeConnection({
+      namespaces: [{ name: "prod", description: "Prod namespace", retentionSeconds: 604800, isGlobal: true }],
+      searchAttributesByNs: { prod: { Project: 2 } },
+      schedulesByNs: {},
+    });
+    const client = fakeClient({
+      schedulesByNs: {
+        prod: [{ scheduleId: "daily-report", workflowType: "reportWf", cronExpressions: ["0 8 * * *"] }],
+      },
+    });
+    setupClientMock(connection, client);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: [], entities: new Map() });
+
+    expect(result["namespace/prod"]).toEqual({
+      type: "Temporal::Namespace",
+      physicalId: "prod",
+      status: "REGISTERED",
+      attributes: {
+        description: "Prod namespace",
+        isGlobalNamespace: true,
+        retentionSeconds: 604800,
+      },
+    });
+    expect(result["searchAttribute/prod/Project"]).toEqual({
+      type: "Temporal::SearchAttribute",
+      physicalId: "prod/Project",
+      status: "REGISTERED",
+      attributes: { valueType: "Keyword", namespace: "prod" },
+    });
+    expect(result["schedule/prod/daily-report"]).toEqual({
+      type: "Temporal::Schedule",
+      physicalId: "prod/daily-report",
+      status: "ACTIVE",
+      attributes: {
+        namespace: "prod",
+        workflowType: "reportWf",
+        cronExpressions: ["0 8 * * *"],
+      },
+    });
+  });
+
+  test("connection failure propagates with a clear error", async () => {
+    loadTemporalClientMock.mockResolvedValue({
+      Connection: { connect: vi.fn(async () => { throw new Error("UNAVAILABLE: connect ECONNREFUSED 127.0.0.1:7233"); }) },
+      Client: vi.fn() as unknown as new () => unknown,
+    });
+
+    await expect(describeResources({ environment: "dev", buildOutput: "", entityNames: [], entities: new Map() }))
+      .rejects.toThrow(/UNAVAILABLE/);
+  });
+
+  test("empty cluster returns empty record without throwing", async () => {
+    const connection = fakeConnection({ namespaces: [] });
+    const client = fakeClient({});
+    setupClientMock(connection, client);
+
+    const result = await describeResources({ environment: "dev", buildOutput: "", entityNames: [], entities: new Map() });
+
+    expect(result).toEqual({});
+  });
+
+  test("per-namespace failures are warn-soft and don't abort other namespaces", async () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const connection = fakeConnection({
+      namespaces: [{ name: "broken" }, { name: "ok" }],
+      searchAttributesByNs: { ok: { Project: 2 } },
+      searchAttrThrows: new Set(["broken"]),
+    });
+    const client = fakeClient({
+      schedulesByNs: {
+        ok: [{ scheduleId: "daily-report", workflowType: "reportWf" }],
+      },
+      scheduleThrows: new Set(["broken"]),
+    });
+    setupClientMock(connection, client);
+
+    const result = await describeResources({ environment: "dev", buildOutput: "", entityNames: [], entities: new Map() });
+
+    // Both namespaces present
+    expect(result["namespace/broken"]).toBeDefined();
+    expect(result["namespace/ok"]).toBeDefined();
+    // ok's children present
+    expect(result["searchAttribute/ok/Project"]).toBeDefined();
+    expect(result["schedule/ok/daily-report"]).toBeDefined();
+    // broken's children skipped
+    expect(Object.keys(result).filter((k) => k.includes("/broken/"))).toEqual([]);
+    // Warnings emitted
+    expect(warnSpy).toHaveBeenCalledTimes(2);
+    warnSpy.mockRestore();
+  });
+
+  // ── Round-trip mapping via entity props (#39) ───────────────────────────────
+
+  test("maps server-side namespace back to chant entity name when props.name matches", async () => {
+    const connection = fakeConnection({
+      namespaces: [{ name: "prod" }],
+      searchAttributesByNs: {},
+      schedulesByNs: {},
+    });
+    const client = fakeClient({});
+    setupClientMock(connection, client);
+
+    const entities = new Map<string, { entityType: string; props: Record<string, unknown> }>([
+      ["prodNs", { entityType: "Temporal::Namespace", props: { name: "prod", retention: "30d" } }],
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["prodNs"], entities });
+
+    expect(result["prodNs"]).toBeDefined();
+    expect(result["namespace/prod"]).toBeUndefined();
+    expect(result["prodNs"].physicalId).toBe("prod");
+  });
+
+  test("maps SearchAttribute back to chant entity name via props.name + props.namespace", async () => {
+    const connection = fakeConnection({
+      namespaces: [{ name: "prod" }],
+      searchAttributesByNs: { prod: { Project: 2, OtherAttr: 1 } },
+      schedulesByNs: {},
+    });
+    const client = fakeClient({});
+    setupClientMock(connection, client);
+
+    const entities = new Map<string, { entityType: string; props: Record<string, unknown> }>([
+      ["projectAttr", { entityType: "Temporal::SearchAttribute", props: { name: "Project", type: "Keyword", namespace: "prod" } }],
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["projectAttr"], entities });
+
+    expect(result["projectAttr"]).toBeDefined();
+    expect(result["searchAttribute/prod/Project"]).toBeUndefined();
+    // Undeclared attr → orphan key (server-side prefix)
+    expect(result["searchAttribute/prod/OtherAttr"]).toBeDefined();
+  });
+
+  test("maps Schedule back to chant entity name via props.scheduleId", async () => {
+    const connection = fakeConnection({
+      namespaces: [{ name: "prod" }],
+      searchAttributesByNs: {},
+      schedulesByNs: {},
+    });
+    const client = fakeClient({
+      schedulesByNs: {
+        prod: [
+          { scheduleId: "daily-report", workflowType: "reportWf" },
+          { scheduleId: "weekly-cleanup", workflowType: "cleanupWf" },
+        ],
+      },
+    });
+    setupClientMock(connection, client);
+
+    const entities = new Map<string, { entityType: string; props: Record<string, unknown> }>([
+      ["dailyReport", { entityType: "Temporal::Schedule", props: { scheduleId: "daily-report", namespace: "prod" } }],
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["dailyReport"], entities });
+
+    expect(result["dailyReport"]).toBeDefined();
+    expect(result["schedule/prod/daily-report"]).toBeUndefined();
+    expect(result["schedule/prod/weekly-cleanup"]).toBeDefined();
+  });
+
+  test("SearchAttribute without explicit namespace falls back to first declared namespace's name", async () => {
+    const connection = fakeConnection({
+      namespaces: [{ name: "prod" }],
+      searchAttributesByNs: { prod: { Project: 2 } },
+      schedulesByNs: {},
+    });
+    const client = fakeClient({});
+    setupClientMock(connection, client);
+
+    const entities = new Map<string, { entityType: string; props: Record<string, unknown> }>([
+      ["prodNs", { entityType: "Temporal::Namespace", props: { name: "prod" } }],
+      // No namespace prop on the attribute — should default to "prod"
+      ["projectAttr", { entityType: "Temporal::SearchAttribute", props: { name: "Project", type: "Keyword" } }],
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["prodNs", "projectAttr"], entities });
+
+    expect(result["projectAttr"]).toBeDefined();
+    expect(result["searchAttribute/prod/Project"]).toBeUndefined();
+  });
+});