@intentius/chant 0.0.5 → 0.0.9

package/src/composite.test.ts

@@ -151,8 +151,8 @@ describe("expandComposite", () => {
 
     const expanded = expandComposite("storage", MyComp({}));
     expect(expanded.size).toBe(2);
-    expect(expanded.get("storage_bucket")?.entityType).toBe("Bucket");
-    expect(expanded.get("storage_role")?.entityType).toBe("Role");
+    expect(expanded.get("storageBucket")?.entityType).toBe("Bucket");
+    expect(expanded.get("storageRole")?.entityType).toBe("Role");
   });
 
   test("handles nested composites", () => {
@@ -167,8 +167,8 @@ describe("expandComposite", () => {
 
     const expanded = expandComposite("app", Outer({}));
     expect(expanded.size).toBe(2);
-    expect(expanded.get("app_bucket")?.entityType).toBe("Bucket");
-    expect(expanded.get("app_nested_table")?.entityType).toBe("Table");
+    expect(expanded.get("appBucket")?.entityType).toBe("Bucket");
+    expect(expanded.get("appNestedTable")?.entityType).toBe("Table");
   });
 
   test("preserves Declarable identity (same object reference)", () => {
@@ -176,7 +176,7 @@ describe("expandComposite", () => {
     const MyComp = Composite<{}>(() => ({ bucket }));
 
     const expanded = expandComposite("s", MyComp({}));
-    expect(expanded.get("s_bucket")).toBe(bucket);
+    expect(expanded.get("sBucket")).toBe(bucket);
   });
 
   test("handles empty composite", () => {
@@ -230,6 +230,22 @@ describe("resource() helper", () => {
     const instance = resource(MockResource, {});
     expect(instance.arn).toBeInstanceOf(AttrRef);
   });
+
+  test("forwards attributes as second constructor argument", () => {
+    // MockResource doesn't store attributes, so use createResource which does
+    const { createResource } = require("./runtime");
+    const TestRes = createResource("Test::Resource", "test", { arn: "Arn" });
+    const attrs = { DependsOn: ["Other"], Condition: "IsProd" };
+    const instance = resource(TestRes as any, { name: "test" }, attrs);
+    expect((instance as any).attributes).toEqual(attrs);
+  });
+
+  test("without attributes, resource() creates instance with empty attributes", () => {
+    const { createResource } = require("./runtime");
+    const TestRes = createResource("Test::Resource", "test", { arn: "Arn" });
+    const instance = resource(TestRes as any, { name: "test" });
+    expect((instance as any).attributes).toEqual({});
+  });
 });
 
 function mockDeclarableWithProps(type: string, props: Record<string, unknown>): Declarable {
@@ -313,6 +329,57 @@ describe("withDefaults", () => {
     expect(CompositeRegistry.size).toBe(1);
   });
 
+  test("function-based defaults receive caller props", () => {
+    let receivedByFn: Partial<{ name: string; timeout: number }> | undefined;
+    const Base = Composite<{ name: string; timeout: number }>((props) => ({
+      item: mockDeclarable(props.name),
+    }));
+
+    const Wrapped = withDefaults(Base, (props) => {
+      receivedByFn = props;
+      return { timeout: 30 } as { timeout: number };
+    });
+    Wrapped({ name: "test" });
+    expect(receivedByFn).toEqual({ name: "test" });
+  });
+
+  test("user props override computed defaults", () => {
+    let received: { timeout: number } | undefined;
+    const Base = Composite<{ timeout: number }>((props) => {
+      received = props;
+      return { item: mockDeclarable() };
+    });
+
+    const Wrapped = withDefaults(Base, () => ({ timeout: 30 }) as { timeout: number });
+    Wrapped({ timeout: 60 });
+    expect(received!.timeout).toBe(60);
+  });
+
+  test("stacking: withDefaults(withDefaults(base, static), fn) works", () => {
+    let received: { a: number; b: number; c: number } | undefined;
+    const Base = Composite<{ a: number; b: number; c: number }>((props) => {
+      received = props;
+      return { item: mockDeclarable() };
+    });
+
+    const Step1 = withDefaults(Base, { a: 1 });
+    const Step2 = withDefaults(Step1, (props) => ({ b: (props.c ?? 0) + 10 }) as { b: number });
+    Step2({ c: 3 });
+    expect(received).toEqual({ a: 1, b: 13, c: 3 });
+  });
+
+  test("undefined computed values don't overwrite user props", () => {
+    let received: { name: string; timeout: number } | undefined;
+    const Base = Composite<{ name: string; timeout: number }>((props) => {
+      received = props;
+      return { item: mockDeclarable() };
+    });
+
+    const Wrapped = withDefaults(Base, () => ({ timeout: undefined }) as unknown as { timeout: number });
+    Wrapped({ name: "test", timeout: 42 });
+    expect(received!.timeout).toBe(42);
+  });
+
   test("expandComposite works identically on defaulted composites", () => {
     const Base = Composite<{ name: string; timeout: number }>((props) => ({
       fn: mockDeclarable(`Fn-${props.name}`),
@@ -323,8 +390,8 @@ describe("withDefaults", () => {
     const expanded = expandComposite("api", Wrapped({ name: "test" }));
 
     expect(expanded.size).toBe(2);
-    expect(expanded.get("api_fn")?.entityType).toBe("Fn-test");
-    expect(expanded.get("api_role")?.entityType).toBe("Role-test");
+    expect(expanded.get("apiFn")?.entityType).toBe("Fn-test");
+    expect(expanded.get("apiRole")?.entityType).toBe("Role-test");
   });
 });
 
@@ -342,8 +409,8 @@ describe("propagate", () => {
     const instance = propagate(MyComp({}), { env: "prod" });
     const expanded = expandComposite("s", instance);
 
-    const bucketProps = (expanded.get("s_bucket") as any).props;
-    const roleProps = (expanded.get("s_role") as any).props;
+    const bucketProps = (expanded.get("sBucket") as any).props;
+    const roleProps = (expanded.get("sRole") as any).props;
     expect(bucketProps.env).toBe("prod");
     expect(roleProps.env).toBe("prod");
   });
@@ -359,7 +426,7 @@ describe("propagate", () => {
       tags: [{ key: "env", value: "prod" }],
     });
     const expanded = expandComposite("s", instance);
-    const tags = (expanded.get("s_bucket") as any).props.tags;
+    const tags = (expanded.get("sBucket") as any).props.tags;
 
     expect(tags).toEqual([
       { key: "env", value: "prod" },
@@ -374,7 +441,7 @@ describe("propagate", () => {
 
     const instance = propagate(MyComp({}), { region: "eu-west-1" });
     const expanded = expandComposite("s", instance);
-    expect((expanded.get("s_bucket") as any).props.region).toBe("us-west-2");
+    expect((expanded.get("sBucket") as any).props.region).toBe("us-west-2");
   });
 
   test("undefined values in shared props are stripped", () => {
@@ -384,7 +451,7 @@ describe("propagate", () => {
 
     const instance = propagate(MyComp({}), { name: undefined, extra: "yes" });
     const expanded = expandComposite("s", instance);
-    const props = (expanded.get("s_bucket") as any).props;
+    const props = (expanded.get("sBucket") as any).props;
     expect(props.name).toBe("data");
     expect(props.extra).toBe("yes");
   });
@@ -402,8 +469,8 @@ describe("propagate", () => {
     const instance = propagate(Outer({}), { env: "prod" });
     const expanded = expandComposite("app", instance);
 
-    expect((expanded.get("app_bucket") as any).props.env).toBe("prod");
-    expect((expanded.get("app_nested_table") as any).props.env).toBe("prod");
+    expect((expanded.get("appBucket") as any).props.env).toBe("prod");
+    expect((expanded.get("appNestedTable") as any).props.env).toBe("prod");
   });
 
   test("expanded declarables are same object references", () => {
@@ -412,7 +479,7 @@ describe("propagate", () => {
 
     const instance = propagate(MyComp({}), { env: "prod" });
     const expanded = expandComposite("s", instance);
-    expect(expanded.get("s_bucket")).toBe(bucket);
+    expect(expanded.get("sBucket")).toBe(bucket);
   });
 
   test("composites without propagate work unchanged", () => {
@@ -421,6 +488,6 @@ describe("propagate", () => {
     }));
 
     const expanded = expandComposite("s", MyComp({}));
-    expect((expanded.get("s_bucket") as any).props.name).toBe("data");
+    expect((expanded.get("sBucket") as any).props.name).toBe("data");
   });
 });

package/src/composite.ts

@@ -123,7 +123,7 @@ export function expandComposite(
   const shared = (instance as any)[SHARED_PROPS] as Record<string, unknown> | undefined;
 
   for (const [memberName, member] of Object.entries(instance.members)) {
-    const fullName = `${prefix}_${memberName}`;
+    const fullName = `${prefix}${memberName[0].toUpperCase()}${memberName.slice(1)}`;
 
     if (isCompositeInstance(member)) {
       const nested = expandComposite(fullName, member);
@@ -182,10 +182,11 @@ type Simplify<T> = { [K in keyof T]: T[K] };
  */
 export function withDefaults<P, M extends CompositeMembers, D extends Partial<P>>(
   definition: CompositeDefinition<P, M>,
-  defaults: D,
+  defaults: D | ((props: Partial<P>) => D),
 ): CompositeDefinition<Simplify<PartialByDefault<P, D>>, M> {
   const wrapped = ((props: Simplify<PartialByDefault<P, D>>) => {
-    return definition({ ...defaults, ...props } as P);
+    const resolved = typeof defaults === "function" ? defaults(props as Partial<P>) : defaults;
+    return definition({ ...resolved, ...props } as P);
   }) as CompositeDefinition<Simplify<PartialByDefault<P, D>>, M>;
 
   Object.defineProperty(wrapped, "compositeName", {
@@ -236,8 +237,9 @@ export function propagate<M extends CompositeMembers>(
  * Exists so lint tooling can validate composite member construction (EVL005).
  */
 export function resource<T extends Declarable, P>(
-  Type: new (props: P) => T,
+  Type: new (props: P, attributes?: Record<string, unknown>) => T,
   props: P,
+  attributes?: Record<string, unknown>,
 ): T {
-  return new Type(props);
+  return new Type(props, attributes);
 }

package/src/config.ts

@@ -7,6 +7,7 @@ import type { LintConfig } from "./lint/config";
  * Zod schema for ChantConfig validation.
  */
 export const ChantConfigSchema = z.object({
+  runtime: z.enum(["bun", "node"]).optional(),
   lexicons: z.array(z.string().min(1)).optional(),
   lint: z.record(z.string(), z.unknown()).optional(),
 }).passthrough();
@@ -17,6 +18,9 @@ export const ChantConfigSchema = z.object({
  * Loaded from `chant.config.ts` (preferred) or `chant.config.json`.
  */
 export interface ChantConfig {
+  /** JS runtime to use for spawned commands: "bun" (default) or "node" */
+  runtime?: "bun" | "node";
+
   /** Lexicon package names to load (e.g. ["aws"]) */
   lexicons?: string[];
 

package/src/detectLexicon.test.ts

@@ -213,7 +213,7 @@ describe("detectLexicons", () => {
   });
 
   test("detects lexicon from export statement", async () => {
-    const file = join(testDir, "barrel.ts");
+    const file = join(testDir, "reexport.ts");
     await writeFile(
       file,
       'export * from "@intentius/chant-lexicon-testdom";\nimport * as core from "@intentius/chant";'
@@ -224,7 +224,7 @@ describe("detectLexicons", () => {
   });
 
   test("detects lexicon from export with curly braces", async () => {
-    const file = join(testDir, "barrel.ts");
+    const file = join(testDir, "reexport.ts");
     await writeFile(
       file,
       'export { Bucket, Interpolate } from "@intentius/chant-lexicon-testdom";'

package/src/discovery/collect.test.ts

@@ -262,8 +262,8 @@ describe("collectEntities with composites", () => {
       { file: "test.ts", exports: { myComp: instance } },
     ]);
 
-    expect(entities.has("myComp_a")).toBe(true);
-    expect(entities.has("myComp_b")).toBe(true);
+    expect(entities.has("myCompA")).toBe(true);
+    expect(entities.has("myCompB")).toBe(true);
     expect(entities.has("myComp")).toBe(false);
   });
 });

package/src/discovery/collect.ts

@@ -23,7 +23,7 @@ export function collectEntities(
     for (const [name, value] of Object.entries(exports)) {
       if (isDeclarable(value)) {
         if (entities.has(name)) {
-          // Same object re-exported from multiple files (e.g. barrel re-exports) is fine
+          // Same object re-exported from multiple files (e.g. re-exports from multiple files) is fine
           if (entities.get(name) !== value) {
             throw new DiscoveryError(
               file,

package/src/index.ts

@@ -47,11 +47,12 @@ export * from "./codegen/fetch";
 export * from "./codegen/generate";
 export * from "./codegen/package";
 export * from "./codegen/typecheck";
-export * from "./codegen/rollback";
 export * from "./codegen/coverage";
 export * from "./codegen/validate";
 export * from "./codegen/docs";
 export * from "./runtime";
+export * from "./runtime-adapter";
+export * from "./resource-attributes";
 export * from "./stack-output";
 export * from "./child-project";
 export * from "./lsp/types";

package/src/lexicon-integrity.ts

@@ -2,18 +2,19 @@
  * Content hashing and integrity verification for lexicon artifacts.
  */
 import type { BundleSpec } from "./lexicon";
+import { getRuntime } from "./runtime-adapter";
 
 export interface ArtifactIntegrity {
-  algorithm: "xxhash64";
+  algorithm: string;
   artifacts: Record<string, string>;
   composite: string;
 }
 
 /**
- * Hash a single artifact's content using xxhash64.
+ * Hash a single artifact's content using the runtime's hash algorithm.
  */
 export function hashArtifact(content: string): string {
-  return Bun.hash(content).toString(16);
+  return getRuntime().hash(content);
 }
 
 /**
@@ -39,7 +40,7 @@ export function computeIntegrity(spec: BundleSpec): ArtifactIntegrity {
   const compositeInput = sorted.map(([k, v]) => `${k}:${v}`).join("\n");
   const composite = hashArtifact(compositeInput);
 
-  return { algorithm: "xxhash64", artifacts, composite };
+  return { algorithm: getRuntime().hashAlgorithm, artifacts, composite };
 }
 
 /**

package/src/lexicon-schema.ts

@@ -72,6 +72,14 @@ export const LexiconEntrySchema = z.object({
   createOnly: z.array(z.string()).optional(),
   writeOnly: z.array(z.string()).optional(),
   primaryIdentifier: z.array(z.string()).optional(),
+  deprecatedProperties: z.array(z.string()).optional(),
+  conditionalCreateOnly: z.array(z.string()).optional(),
+  replacementStrategy: z.enum(["delete_then_create", "create_then_delete"]).optional(),
+  tagging: z.object({
+    taggable: z.boolean(),
+    tagOnCreate: z.boolean(),
+    tagUpdatable: z.boolean(),
+  }).optional(),
   runtimeDeprecations: z.record(z.string(), z.string()).optional(),
 });
 

package/src/lexicon.ts

@@ -97,11 +97,23 @@ export interface IntrinsicDef {
   readonly isTag?: boolean;
 }
 
+/**
+ * Structured init template output from a lexicon plugin.
+ */
+export interface InitTemplateSet {
+  /** Source files written to src/ */
+  src: Record<string, string>;
+  /** Application scaffold files written to project root */
+  root?: Record<string, string>;
+  /** Scripts merged into generated package.json */
+  scripts?: Record<string, string>;
+}
+
 /**
  * Plugin interface for lexicon packages.
  *
  * Required lifecycle methods enforce consistency: every lexicon must support
- * generate, validate, coverage, package, and rollback operations.
+ * generate, validate, coverage, and package operations.
  */
 export interface LexiconPlugin {
   // ── Required ──────────────────────────────────────────────
@@ -123,9 +135,6 @@ export interface LexiconPlugin {
   /** Package lexicon into distributable tarball */
   package(options?: { verbose?: boolean; force?: boolean }): Promise<void>;
 
-  /** List or restore generation snapshots */
-  rollback(options?: { restore?: string; verbose?: boolean }): Promise<void>;
-
   // ── Optional extensions ───────────────────────────────────
   /** Return lint rules provided by this lexicon */
   lintRules?(): LintRule[];
@@ -159,7 +168,7 @@ export interface LexiconPlugin {
   skills?(): SkillDefinition[];
 
   /** Return source file templates for `chant init` project scaffolding */
-  initTemplates?(): Record<string, string>;
+  initTemplates?(template?: string): InitTemplateSet;
 
   /** Optional initialization hook */
   init?(): void | Promise<void>;
@@ -206,7 +215,6 @@ export function isLexiconPlugin(value: unknown): value is LexiconPlugin {
     typeof obj.generate === "function" &&
     typeof obj.validate === "function" &&
     typeof obj.coverage === "function" &&
-    typeof obj.package === "function" &&
-    typeof obj.rollback === "function"
+    typeof obj.package === "function"
   );
 }

package/src/lint/config.ts

@@ -1,13 +1,15 @@
 import { readFileSync, existsSync } from "fs";
 import { join, dirname, resolve } from "path";
+import { createRequire } from "module";
 import { z } from "zod";
 import type { Severity, RuleConfig } from "./rule";
+import { moduleDir, getRuntime } from "../runtime-adapter";
 import strictPreset from "./presets/strict.json";
 
 /** Mapping of built-in preset names to their file paths */
 const BUILTIN_PRESETS: Record<string, string> = {
-  "@intentius/chant/lint/presets/strict": resolve(import.meta.dir, "presets/strict.json"),
-  "@intentius/chant/lint/presets/relaxed": resolve(import.meta.dir, "presets/relaxed.json"),
+  "@intentius/chant/lint/presets/strict": resolve(moduleDir(import.meta.url), "presets/strict.json"),
+  "@intentius/chant/lint/presets/relaxed": resolve(moduleDir(import.meta.url), "presets/relaxed.json"),
 };
 
 // ── Zod schemas for lint config validation ─────────────────────────
@@ -307,11 +309,12 @@ function loadConfigFile(configPath: string, visited: Set<string> = new Set()): L
  * @returns Loaded and merged configuration, or default config if not found
  */
 export function loadConfig(dir: string): LintConfig {
-  // Try chant.config.ts first — Bun supports synchronous require() for .ts
+  // Try chant.config.ts first — Bun has native require() for .ts, Node uses tsx's loader
   const tsConfigPath = join(dir, "chant.config.ts");
   if (existsSync(tsConfigPath)) {
     try {
-      const mod = require(tsConfigPath);
+      const _require = createRequire(join(dir, "package.json"));
+      const mod = _require(tsConfigPath);
       const config = mod.default ?? mod.config ?? mod;
       if (typeof config === "object" && config !== null) {
         // ChantConfig format: extract lint property
@@ -362,8 +365,7 @@ export function resolveRulesForFile(config: LintConfig, filePath: string): Recor
 
   for (const override of config.overrides) {
     const matches = override.files.some((pattern) => {
-      const glob = new Bun.Glob(pattern);
-      return glob.match(filePath);
+      return getRuntime().globMatch(pattern, filePath);
     });
 
     if (matches) {

package/src/lint/declarative.ts

@@ -39,6 +39,10 @@ export interface RuleSpec {
   severity: Severity;
   /** Category for grouping */
   category: Category;
+  /** Human-readable description of what this rule checks */
+  description?: string;
+  /** Link to rule documentation */
+  helpUri?: string;
   /** Selector name (or compound) to find target nodes */
   selector: string;
   /** Optional match condition to further filter nodes */
@@ -61,6 +65,8 @@ export function rule(spec: RuleSpec): LintRule {
     id: spec.id,
     severity: spec.severity,
     category: spec.category,
+    description: spec.description,
+    helpUri: spec.helpUri,
     check(context: LintContext): LintDiagnostic[] {
       const diagnostics: LintDiagnostic[] = [];
       const sf = context.sourceFile;