@intentius/chant 0.1.4 → 0.1.6

package/src/lint/rules/no-redundant-type-import.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { noRedundantTypeImportRule } from "./no-redundant-type-import";
 import type { LintContext } from "../rule";

package/src/lint/rules/no-redundant-value-cast.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { noRedundantValueCastRule } from "./no-redundant-value-cast";
 import type { LintContext } from "../rule";

package/src/lint/rules/no-string-ref.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { noStringRefRule } from "./no-string-ref";
 import type { LintContext } from "../rule";

package/src/lint/rules/no-unused-declarable-import.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { noUnusedDeclarableImportRule } from "./no-unused-declarable-import";
 import type { LintContext } from "../rule";

package/src/lint/rules/no-unused-declarable.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { noUnusedDeclarableRule } from "./no-unused-declarable";
 import type { LintContext } from "../rule";

package/src/lint/rules/single-concern-file.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { singleConcernFileRule } from "./single-concern-file";
 import type { LintContext } from "../rule";

package/src/lint/selectors.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { resolveSelector, registerSelector, collectNodes } from "./selectors";
 

package/src/op/builders.ts

@@ -0,0 +1,96 @@
+import { OpResource } from "./resource";
+import type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep } from "./types";
+
+// ── Core builders ─────────────────────────────────────────────────────────────
+
+/**
+ * Declare a named, phased Temporal workflow.
+ *
+ * @example
+ * ```ts
+ * export default Op({
+ *   name: "alb-deploy",
+ *   overview: "Build and deploy the ALB multi-service stack",
+ *   phases: [
+ *     phase("Build", [build("examples/gitlab-aws-alb-infra")], { parallel: true }),
+ *     phase("Deploy", [kubectlApply("dist/alb-infra.yaml")]),
+ *   ],
+ * });
+ * ```
+ */
+export function Op(config: OpConfig): InstanceType<typeof OpResource> {
+  return new OpResource(config as unknown as Record<string, unknown>);
+}
+
+/** Define a named execution phase containing one or more steps. */
+export function phase(
+  name: string,
+  steps: StepDefinition[],
+  opts?: { parallel?: boolean },
+): PhaseDefinition {
+  return { name, steps, ...(opts?.parallel ? { parallel: true } : {}) };
+}
+
+/** Reference a pre-built or custom activity by function name. */
+export function activity(
+  fn: string,
+  args?: Record<string, unknown>,
+  profile?: ActivityStep["profile"],
+): ActivityStep {
+  return {
+    kind: "activity",
+    fn,
+    ...(args && Object.keys(args).length > 0 ? { args } : {}),
+    ...(profile ? { profile } : {}),
+  };
+}
+
+/** Insert a human gate — the workflow pauses until the named signal is received. */
+export function gate(
+  signalName: string,
+  opts?: { timeout?: string; description?: string },
+): GateStep {
+  return {
+    kind: "gate",
+    signalName,
+    ...(opts?.timeout ? { timeout: opts.timeout } : {}),
+    ...(opts?.description ? { description: opts.description } : {}),
+  };
+}
+
+// ── Pre-built activity shortcuts ──────────────────────────────────────────────
+
+/** Run `npm run build` (or `chant build`) in the given project directory. */
+export const build = (path: string, opts?: Record<string, unknown>): ActivityStep =>
+  activity("chantBuild", { path, ...opts });
+
+/** Run `kubectl apply -f <manifest>`. Uses `longInfra` profile. */
+export const kubectlApply = (manifest: string, opts?: Record<string, unknown>): ActivityStep =>
+  activity("kubectlApply", { manifest, ...opts }, "longInfra");
+
+/** Run `helm upgrade --install`. Uses `longInfra` profile. */
+export const helmInstall = (
+  name: string,
+  chart: string,
+  opts?: { values?: string; namespace?: string; [k: string]: unknown },
+): ActivityStep => activity("helmInstall", { name, chart, ...opts }, "longInfra");
+
+/** Poll for stack readiness (kubectl rollout, CloudFormation complete, etc). Uses `k8sWait` profile. */
+export const waitForStack = (name: string, opts?: Record<string, unknown>): ActivityStep =>
+  activity("waitForStack", { name, ...opts }, "k8sWait");
+
+/** Trigger and wait for a GitLab CI pipeline to complete. Uses `longInfra` profile. */
+export const gitlabPipeline = (name: string, opts?: Record<string, unknown>): ActivityStep =>
+  activity("gitlabPipeline", { name, ...opts }, "longInfra");
+
+/** Take a chant state snapshot for the given environment. */
+export const stateSnapshot = (env: string): ActivityStep =>
+  activity("stateSnapshot", { env });
+
+/** Run an arbitrary shell command. */
+export const shell = (cmd: string, opts?: { env?: Record<string, string> }): ActivityStep =>
+  activity("shellCmd", { cmd, ...opts });
+
+/** Run `chant teardown` in the given project directory. Uses `longInfra` profile. */
+export const teardown = (path: string): ActivityStep =>
+  activity("chantTeardown", { path }, "longInfra");

package/src/op/index.ts

@@ -0,0 +1,4 @@
+export { Op, phase, activity, gate, build, kubectlApply, helmInstall, waitForStack,
+         gitlabPipeline, stateSnapshot, shell, teardown } from "./builders";
+export { OpResource } from "./resource";
+export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep, RetryPolicy } from "./types";

package/src/op/op.test.ts

@@ -0,0 +1,199 @@
+/**
+ * Core Op builder tests.
+ */
+
+import { describe, expect, it } from "vitest";
+import { Op, phase, activity, gate, build, kubectlApply, helmInstall,
+         waitForStack, gitlabPipeline, stateSnapshot, shell, teardown } from "./builders";
+import { DECLARABLE_MARKER, type Declarable } from "../declarable";
+
+// ── Op() ──────────────────────────────────────────────────────────────────────
+
+describe("Op()", () => {
+  function opProps(op: Declarable): Record<string, unknown> {
+    return (op as unknown as { props: Record<string, unknown> }).props;
+  }
+
+  it("returns a Declarable with correct lexicon and entityType", () => {
+    const op = Op({ name: "my-op", overview: "Test op", phases: [] });
+    expect(op[DECLARABLE_MARKER]).toBe(true);
+    expect(op.lexicon).toBe("temporal");
+    expect(op.entityType).toBe("Temporal::Op");
+    expect(op.kind).toBe("resource");
+  });
+
+  it("stores name and overview in props", () => {
+    const op = Op({ name: "deploy-op", overview: "Deploy infra", phases: [] });
+    const props = opProps(op);
+    expect(props.name).toBe("deploy-op");
+    expect(props.overview).toBe("Deploy infra");
+  });
+
+  it("stores phases in props", () => {
+    const p = phase("Build", [build("path/to/project")]);
+    const op = Op({ name: "op", overview: "o", phases: [p] });
+    const props = opProps(op);
+    expect(Array.isArray(props.phases)).toBe(true);
+    expect((props.phases as unknown[]).length).toBe(1);
+  });
+
+  it("stores optional depends in props", () => {
+    const op = Op({ name: "second-op", overview: "o", phases: [], depends: ["first-op"] });
+    const props = opProps(op);
+    expect(props.depends).toEqual(["first-op"]);
+  });
+
+  it("stores optional onFailure in props", () => {
+    const compensation = phase("Rollback", [shell("echo rollback")]);
+    const op = Op({ name: "op", overview: "o", phases: [], onFailure: [compensation] });
+    const props = opProps(op);
+    expect(Array.isArray(props.onFailure)).toBe(true);
+  });
+
+  it("stores optional taskQueue in props", () => {
+    const op = Op({ name: "op", overview: "o", phases: [], taskQueue: "custom-queue" });
+    const props = opProps(op);
+    expect(props.taskQueue).toBe("custom-queue");
+  });
+});
+
+// ── phase() ───────────────────────────────────────────────────────────────────
+
+describe("phase()", () => {
+  it("returns correct shape with name and steps", () => {
+    const p = phase("Deploy", [build("./")]);
+    expect(p.name).toBe("Deploy");
+    expect(p.steps).toHaveLength(1);
+  });
+
+  it("sets parallel: true when passed as option", () => {
+    const p = phase("Build", [build("a"), build("b")], { parallel: true });
+    expect(p.parallel).toBe(true);
+  });
+
+  it("omits parallel key when not set", () => {
+    const p = phase("Build", [build("a")]);
+    expect("parallel" in p).toBe(false);
+  });
+});
+
+// ── activity() ────────────────────────────────────────────────────────────────
+
+describe("activity()", () => {
+  it("returns ActivityStep with kind 'activity'", () => {
+    const a = activity("myFn");
+    expect(a.kind).toBe("activity");
+    expect(a.fn).toBe("myFn");
+  });
+
+  it("includes args when provided", () => {
+    const a = activity("myFn", { key: "val" });
+    expect(a.args).toEqual({ key: "val" });
+  });
+
+  it("omits args key when no args provided", () => {
+    const a = activity("myFn");
+    expect("args" in a).toBe(false);
+  });
+
+  it("includes profile when provided", () => {
+    const a = activity("myFn", {}, "longInfra");
+    expect(a.profile).toBe("longInfra");
+  });
+
+  it("omits profile key when not provided", () => {
+    const a = activity("myFn");
+    expect("profile" in a).toBe(false);
+  });
+});
+
+// ── gate() ────────────────────────────────────────────────────────────────────
+
+describe("gate()", () => {
+  it("returns GateStep with kind 'gate' and signalName", () => {
+    const g = gate("dns-delegation");
+    expect(g.kind).toBe("gate");
+    expect(g.signalName).toBe("dns-delegation");
+  });
+
+  it("includes timeout when provided", () => {
+    const g = gate("approval", { timeout: "24h" });
+    expect(g.timeout).toBe("24h");
+  });
+
+  it("includes description when provided", () => {
+    const g = gate("approval", { description: "Awaiting DNS delegation" });
+    expect(g.description).toBe("Awaiting DNS delegation");
+  });
+
+  it("omits timeout and description when not provided", () => {
+    const g = gate("sig");
+    expect("timeout" in g).toBe(false);
+    expect("description" in g).toBe(false);
+  });
+});
+
+// ── Pre-built shortcuts ───────────────────────────────────────────────────────
+
+describe("pre-built shortcuts", () => {
+  it("build() produces chantBuild activity with path arg", () => {
+    const a = build("./my-project");
+    expect(a.kind).toBe("activity");
+    expect(a.fn).toBe("chantBuild");
+    expect(a.args?.path).toBe("./my-project");
+  });
+
+  it("build() uses default fastIdempotent profile (no profile key)", () => {
+    const a = build("./p");
+    expect("profile" in a).toBe(false);
+  });
+
+  it("kubectlApply() produces kubectlApply activity with longInfra profile", () => {
+    const a = kubectlApply("dist/infra.yaml");
+    expect(a.fn).toBe("kubectlApply");
+    expect(a.args?.manifest).toBe("dist/infra.yaml");
+    expect(a.profile).toBe("longInfra");
+  });
+
+  it("helmInstall() produces helmInstall activity with name and chart", () => {
+    const a = helmInstall("my-release", "charts/app");
+    expect(a.fn).toBe("helmInstall");
+    expect(a.args?.name).toBe("my-release");
+    expect(a.args?.chart).toBe("charts/app");
+    expect(a.profile).toBe("longInfra");
+  });
+
+  it("waitForStack() produces waitForStack activity with k8sWait profile", () => {
+    const a = waitForStack("my-stack");
+    expect(a.fn).toBe("waitForStack");
+    expect(a.args?.name).toBe("my-stack");
+    expect(a.profile).toBe("k8sWait");
+  });
+
+  it("gitlabPipeline() produces gitlabPipeline activity with longInfra profile", () => {
+    const a = gitlabPipeline("group/project");
+    expect(a.fn).toBe("gitlabPipeline");
+    expect(a.args?.name).toBe("group/project");
+    expect(a.profile).toBe("longInfra");
+  });
+
+  it("stateSnapshot() produces stateSnapshot activity with env arg", () => {
+    const a = stateSnapshot("prod");
+    expect(a.fn).toBe("stateSnapshot");
+    expect(a.args?.env).toBe("prod");
+    expect("profile" in a).toBe(false);
+  });
+
+  it("shell() produces shellCmd activity with cmd arg", () => {
+    const a = shell("echo hello");
+    expect(a.fn).toBe("shellCmd");
+    expect(a.args?.cmd).toBe("echo hello");
+  });
+
+  it("teardown() produces chantTeardown activity with longInfra profile", () => {
+    const a = teardown("./project");
+    expect(a.fn).toBe("chantTeardown");
+    expect(a.args?.path).toBe("./project");
+    expect(a.profile).toBe("longInfra");
+  });
+});

package/src/op/resource.ts

@@ -0,0 +1,8 @@
+import { createResource } from "../runtime";
+
+/**
+ * The Declarable resource backing an Op definition.
+ * entityType: "Temporal::Op", lexicon: "temporal"
+ * Discovered automatically alongside infra files — no pipeline changes needed.
+ */
+export const OpResource = createResource("Temporal::Op", "temporal", {});

package/src/op/types.ts

@@ -0,0 +1,66 @@
+/**
+ * Op type definitions — the data model for a named, phased Temporal workflow.
+ *
+ * These types are intentionally free of Temporal SDK imports so they can live
+ * in core without pulling in @temporalio/* as a dependency.
+ */
+
+export interface OpConfig {
+  /** Kebab-case identifier. Used as the workflow function name (camelCase) and output directory name. */
+  name: string;
+  /** Human-readable description shown in `chant run list` and deployment reports. */
+  overview: string;
+  /** Temporal task queue. Defaults to `name`. */
+  taskQueue?: string;
+  /** Temporal namespace. Defaults to chant.config.ts defaultProfile's namespace. */
+  namespace?: string;
+  /** Ordered list of execution phases. */
+  phases: PhaseDefinition[];
+  /** Other Op names that must be complete before this Op can run. */
+  depends?: string[];
+  /** Compensation phases executed on terminal failure (run in reverse order). */
+  onFailure?: PhaseDefinition[];
+  /** Search attributes to upsert at workflow start. */
+  searchAttributes?: Record<string, string>;
+}
+
+export interface PhaseDefinition {
+  /** Display name shown in progress output and Temporal UI. */
+  name: string;
+  /** Ordered steps within the phase. */
+  steps: StepDefinition[];
+  /** Run all steps concurrently via Promise.all. Default: false. */
+  parallel?: boolean;
+}
+
+export type StepDefinition = ActivityStep | GateStep;
+
+export interface ActivityStep {
+  kind: "activity";
+  /** Name of the exported activity function in the pre-built activity library. */
+  fn: string;
+  /** Arguments passed to the activity function. */
+  args?: Record<string, unknown>;
+  /**
+   * Key from TEMPORAL_ACTIVITY_PROFILES controlling timeout + retry.
+   * Default: "fastIdempotent"
+   */
+  profile?: "fastIdempotent" | "longInfra" | "k8sWait" | "humanGate";
+}
+
+export interface GateStep {
+  kind: "gate";
+  /** Signal name. The generated workflow waits for this signal before continuing. */
+  signalName: string;
+  /** Temporal duration string. Default: "48h". */
+  timeout?: string;
+  /** Human-readable description of the action required to unblock this gate. */
+  description?: string;
+}
+
+export interface RetryPolicy {
+  initialInterval?: string;
+  backoffCoefficient?: number;
+  maximumAttempts?: number;
+  maximumInterval?: string;
+}

package/src/project-validation.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { validateProjectStructure } from "./project-validation";
 import { mkdirSync, writeFileSync, rmSync } from "fs";
 import { join } from "path";
 
-const TEST_DIR = join(import.meta.dir, "__test_project_validation__");
+const TEST_DIR = join(import.meta.dirname, "__test_project_validation__");
 
 beforeEach(() => {
   mkdirSync(TEST_DIR, { recursive: true });

package/src/pseudo-parameter.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, test } from "vitest";
 import { PseudoParameter, createPseudoParameters } from "./pseudo-parameter";
 import { INTRINSIC_MARKER } from "./intrinsic";
 

package/src/resource-attributes.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, spyOn } from "bun:test";
+import { describe, test, expect, vi } from "vitest";
 import { resolveDependsOn } from "./resource-attributes";
 import { DECLARABLE_MARKER, type Declarable } from "./declarable";
 
@@ -55,7 +55,7 @@ describe("resolveDependsOn", () => {
   test("warns and skips Declarable not found in entityNames", () => {
     const bucket = mockDeclarable();
     const entityNames = new Map<Declarable, string>(); // bucket not registered
-    const spy = spyOn(console, "warn").mockImplementation(() => {});
+    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
 
     const result = resolveDependsOn(bucket, entityNames, "MyResource");
     expect(result).toEqual([]);

package/src/runtime-adapter.ts

@@ -1,9 +1,8 @@
 /**
- * Runtime adapter — abstracts Bun-specific APIs so chant can run on Bun or Node.js.
+ * Runtime adapter — abstracts child-process and filesystem APIs for chant.
  *
- * Auto-detects the host runtime and delegates to the appropriate implementation.
- * The `target` parameter (from config) controls what gets spawned (bun vs node/npx/npm),
- * not which adapter class is used.
+ * The `target` parameter (from config) controls what commands get spawned
+ * (node/npx/npm), not which adapter class is used.
  */
 import { dirname } from "path";
 import { fileURLToPath } from "url";
@@ -19,16 +18,16 @@ export interface SpawnResult {
 }
 
 export interface RuntimeCommands {
-  /** Runtime binary: "bun" | "node" */
+  /** Runtime binary: "node" */
   runner: string;
-  /** Package executor: "bunx" | "npx" */
+  /** Package executor: "npx" */
   exec: string;
-  /** Pack command: ["bun", "pm", "pack"] | ["npm", "pack"] */
+  /** Pack command: ["npm", "pack"] */
   packCmd: string[];
 }
 
 export interface RuntimeAdapter {
-  readonly name: "bun" | "node";
+  readonly name: "node";
   /** Hash content and return hex string */
   hash(content: string): string;
   /** Algorithm name recorded in integrity.json */
@@ -41,44 +40,6 @@ export interface RuntimeAdapter {
   readonly commands: RuntimeCommands;
 }
 
-// ── Bun adapter ──────────────────────────────────────────────────
-
-class BunRuntimeAdapter implements RuntimeAdapter {
-  readonly name = "bun" as const;
-  readonly hashAlgorithm = "xxhash64";
-  readonly commands: RuntimeCommands;
-
-  constructor(target: "bun" | "node") {
-    this.commands =
-      target === "node"
-        ? { runner: "node", exec: "npx", packCmd: ["npm", "pack"] }
-        : { runner: "bun", exec: "bunx", packCmd: ["bun", "pm", "pack"] };
-  }
-
-  hash(content: string): string {
-    return Bun.hash(content).toString(16);
-  }
-
-  globMatch(pattern: string, filePath: string): boolean {
-    const glob = new Bun.Glob(pattern);
-    return glob.match(filePath);
-  }
-
-  async spawn(cmd: string[], opts?: { cwd?: string }): Promise<SpawnResult> {
-    const proc = Bun.spawn(cmd, {
-      cwd: opts?.cwd,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const [stdout, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ]);
-    const exitCode = await proc.exited;
-    return { stdout, stderr, exitCode };
-  }
-}
-
 // ── Node adapter ─────────────────────────────────────────────────
 
 class NodeRuntimeAdapter implements RuntimeAdapter {
@@ -86,11 +47,8 @@ class NodeRuntimeAdapter implements RuntimeAdapter {
   readonly hashAlgorithm = "sha256";
   readonly commands: RuntimeCommands;
 
-  constructor(target: "bun" | "node") {
-    this.commands =
-      target === "bun"
-        ? { runner: "bun", exec: "bunx", packCmd: ["bun", "pm", "pack"] }
-        : { runner: "node", exec: "npx", packCmd: ["npm", "pack"] };
+  constructor() {
+    this.commands = { runner: "node", exec: "npx", packCmd: ["npm", "pack"] };
   }
 
   hash(content: string): string {
@@ -107,6 +65,7 @@ class NodeRuntimeAdapter implements RuntimeAdapter {
         resolve({
           stdout: stdout ?? "",
           stderr: stderr ?? "",
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
           exitCode: err ? (err as any).code ?? 1 : 0,
         });
       });
@@ -118,29 +77,16 @@ class NodeRuntimeAdapter implements RuntimeAdapter {
 
 let _runtime: RuntimeAdapter | undefined;
 
-/**
- * Detect whether we're running under Bun.
- */
-function isBun(): boolean {
-  return typeof globalThis.Bun !== "undefined";
-}
-
 /**
  * Initialize the runtime adapter singleton.
- *
- * @param target - Which commands to spawn ("bun" or "node"). Defaults to auto-detect.
- *   Controls the `commands` property, not which adapter class is used.
  */
-export function initRuntime(target?: "bun" | "node"): RuntimeAdapter {
-  const resolvedTarget = target ?? (isBun() ? "bun" : "node");
-  _runtime = isBun()
-    ? new BunRuntimeAdapter(resolvedTarget)
-    : new NodeRuntimeAdapter(resolvedTarget);
+export function initRuntime(): RuntimeAdapter {
+  _runtime = new NodeRuntimeAdapter();
   return _runtime;
 }
 
 /**
- * Get the runtime adapter. Lazily initializes with auto-detection if not yet set.
+ * Get the runtime adapter. Lazily initializes if not yet set.
  */
 export function getRuntime(): RuntimeAdapter {
   if (!_runtime) {
@@ -151,7 +97,6 @@ export function getRuntime(): RuntimeAdapter {
 
 /**
  * Convert `import.meta.url` to a directory path.
- * Works on both Bun and Node (replaces Bun-only `import.meta.dir`).
  */
 export function moduleDir(importMetaUrl: string): string {
   return dirname(fileURLToPath(importMetaUrl));

package/src/serializer-walker.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { walkValue, type SerializerVisitor } from "./serializer-walker";
 import { DECLARABLE_MARKER, type Declarable } from "./declarable";
 import { INTRINSIC_MARKER } from "./intrinsic";
@@ -98,6 +98,7 @@ describe("walkValue", () => {
     const TestTable = createResource("Test::Table", "test", {});
     const resource = new TestTable({}) as unknown as Declarable;
     const names = new Map<Declarable, string>([[resource, "MyTable"]]);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     expect(walkValue((resource as any).Ref, names, mockVisitor)).toEqual({ __ref: "MyTable" });
   });
 

package/src/sort.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { topologicalSort } from "./sort";
 import { BuildError } from "./errors";
 

package/src/stack-output.ts

@@ -64,8 +64,8 @@ export function stackOutput(
 ): StackOutput {
   // Derive lexicon from the AttrRef's parent entity
   const parent = ref.parent.deref();
-  const lexicon = parent && typeof (parent as any).lexicon === "string"
-    ? (parent as any).lexicon
+  const lexicon = parent && typeof (parent as Record<string, unknown>).lexicon === "string"
+    ? (parent as Record<string, unknown>).lexicon as string
     : "unknown";
 
   const output: StackOutput = {

package/src/toml.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { emitTOML, parseTOML } from "./toml";
 
 describe("emitTOML", () => {
@@ -66,7 +66,7 @@ describe("emitTOML", () => {
 
   test("emits header comment", () => {
     const result = emitTOML({ name: "test" }, { header: "Generated by Chant" });
-    expect(result).toStartWith("# Generated by Chant\n");
+    expect(result.startsWith("# Generated by Chant\n")).toBe(true);
   });
 
   test("respects key ordering", () => {

package/src/types.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expectTypeOf } from "bun:test";
+import { describe, test, expectTypeOf } from "vitest";
 import type { Value, AllValues, PartialValues, RequiredProps } from "./types";
 import type { Intrinsic } from "./intrinsic";