@intentius/chant-lexicon-aws 0.0.2

package/src/codegen/generate.test.ts

@@ -0,0 +1,125 @@
+import { describe, test, expect } from "bun:test";
+import { generate, writeGeneratedFiles } from "./generate";
+import { NamingStrategy } from "./naming";
+import { samResources } from "./sam";
+import { fallbackResources } from "./fallback";
+import { parseCFNSchema } from "../spec/parse";
+
+describe("generate pipeline components", () => {
+  test("exports generate function", () => {
+    expect(typeof generate).toBe("function");
+  });
+
+  test("exports writeGeneratedFiles function", () => {
+    expect(typeof writeGeneratedFiles).toBe("function");
+  });
+
+  // Integration test - requires network, skip by default
+  test.skip("generates full pipeline (integration)", async () => {
+    const result = await generate({ verbose: false });
+
+    expect(result.resources).toBeGreaterThan(500);
+    expect(result.properties).toBeGreaterThan(0);
+    expect(result.lexiconJSON).toBeTruthy();
+    expect(result.typesDTS).toBeTruthy();
+    expect(result.indexTS).toBeTruthy();
+  });
+});
+
+describe("NamingStrategy", () => {
+  test("assigns priority names", () => {
+    const results = [
+      parseCFNSchema(JSON.stringify({ typeName: "AWS::S3::Bucket", properties: {}, additionalProperties: false })),
+      parseCFNSchema(JSON.stringify({ typeName: "AWS::Lambda::Function", properties: {}, additionalProperties: false })),
+      parseCFNSchema(JSON.stringify({ typeName: "AWS::IAM::Role", properties: {}, additionalProperties: false })),
+    ];
+    const ns = new NamingStrategy(results);
+
+    expect(ns.resolve("AWS::S3::Bucket")).toBe("Bucket");
+    expect(ns.resolve("AWS::Lambda::Function")).toBe("Function");
+    expect(ns.resolve("AWS::IAM::Role")).toBe("Role");
+  });
+
+  test("handles collisions with service prefix", () => {
+    const results = [
+      parseCFNSchema(JSON.stringify({ typeName: "AWS::IAM::Policy", properties: {}, additionalProperties: false })),
+      parseCFNSchema(JSON.stringify({ typeName: "AWS::S3::BucketPolicy", properties: {}, additionalProperties: false })),
+    ];
+    const ns = new NamingStrategy(results);
+
+    // IAM Policy has priority name "Policy" and alias "IamPolicy"
+    expect(ns.resolve("AWS::IAM::Policy")).toBe("Policy");
+    expect(ns.aliases("AWS::IAM::Policy")).toContain("IamPolicy");
+  });
+
+  test("handles unknown resources with short names", () => {
+    const results = [
+      parseCFNSchema(JSON.stringify({ typeName: "AWS::SomeService::SomeResource", properties: {}, additionalProperties: false })),
+    ];
+    const ns = new NamingStrategy(results);
+
+    expect(ns.resolve("AWS::SomeService::SomeResource")).toBe("SomeResource");
+  });
+});
+
+describe("SAM resources", () => {
+  test("provides 9 SAM resource definitions", () => {
+    const resources = samResources();
+
+    expect(resources.length).toBe(9);
+
+    const typeNames = resources.map((r) => r.resource.typeName);
+    expect(typeNames).toContain("AWS::Serverless::Function");
+    expect(typeNames).toContain("AWS::Serverless::Api");
+    expect(typeNames).toContain("AWS::Serverless::HttpApi");
+    expect(typeNames).toContain("AWS::Serverless::SimpleTable");
+  });
+});
+
+describe("fallback resources", () => {
+  test("provides LogGroup fallback", () => {
+    const resources = fallbackResources();
+
+    expect(resources.length).toBeGreaterThan(0);
+
+    const typeNames = resources.map((r) => r.resource.typeName);
+    expect(typeNames).toContain("AWS::Logs::LogGroup");
+  });
+});
+
+describe("offline fixture pipeline", () => {
+  test("generates from fixtures", async () => {
+    const { loadSchemaFixtures } = await import("../testdata/load-fixtures");
+    const fixtures = loadSchemaFixtures();
+    const result = await generate({ schemaSource: fixtures });
+
+    expect(result.resources).toBeGreaterThanOrEqual(5);
+    expect(result.lexiconJSON).toBeTruthy();
+    expect(result.typesDTS).toBeTruthy();
+    expect(result.indexTS).toBeTruthy();
+
+    // Verify known resource types are present in lexicon JSON
+    const lexicon = JSON.parse(result.lexiconJSON);
+    expect(lexicon["Bucket"]).toBeDefined();
+    expect(lexicon["Function"]).toBeDefined();
+    expect(lexicon["Role"]).toBeDefined();
+  });
+});
+
+describe("parseCFNSchema", () => {
+  test("parses a minimal schema", () => {
+    const result = parseCFNSchema(JSON.stringify({
+      typeName: "AWS::Test::Resource",
+      properties: {
+        Name: { type: "string" },
+      },
+      required: ["Name"],
+      additionalProperties: false,
+    }));
+
+    expect(result.resource.typeName).toBe("AWS::Test::Resource");
+    expect(result.resource.properties.length).toBe(1);
+    expect(result.resource.properties[0].name).toBe("Name");
+    expect(result.resource.properties[0].required).toBe(true);
+  });
+});

package/src/codegen/generate.ts

@@ -0,0 +1,226 @@
+/**
+ * AWS CloudFormation generation pipeline — uses core generatePipeline
+ * with AWS-specific fetch, parse, naming, and generation callbacks.
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+import {
+  generatePipeline,
+  writeGeneratedArtifacts,
+  type GenerateOptions,
+  type GenerateResult,
+  type GeneratePipelineConfig,
+  type AugmentResult,
+} from "@intentius/chant/codegen/generate";
+import { fetchSchemaZip } from "../spec/fetch";
+import { parseCFNSchema, cfnShortName, type SchemaParseResult } from "../spec/parse";
+import { fetchCfnLintPatches, applyPatches } from "./patches";
+import { fetchCfnLintExtensions, loadExtensionSchemas, type ExtensionConstraint } from "./extensions";
+import { samResources } from "./sam";
+import { fallbackResources } from "./fallback";
+import { NamingStrategy, propertyTypeName, extractDefName } from "./naming";
+import { generateLexiconJSON, lambdaRuntimeDeprecations } from "./generate-lexicon";
+import { generateTypeScriptDeclarations } from "./generate-typescript";
+import {
+  generateRuntimeIndex as coreGenerateRuntimeIndex,
+  type RuntimeIndexEntry,
+  type RuntimeIndexPropertyEntry,
+} from "@intentius/chant/codegen/generate-runtime-index";
+
+export type { GenerateOptions, GenerateResult };
+
+// AWS-specific state shared between pipeline callbacks
+let awsConstraints = new Map<string, ExtensionConstraint[]>();
+
+const awsPipelineConfig: GeneratePipelineConfig<SchemaParseResult> = {
+  fetchSchemas: async (opts) => {
+    return fetchSchemaZip(opts.force);
+  },
+
+  parseSchema: (_typeName, data) => {
+    const result = parseCFNSchema(data);
+    if (!result.resource.typeName) return null;
+    return result;
+  },
+
+  createNaming: (results) => new NamingStrategy(results),
+
+  augmentSchemas: async (schemas, opts, log) => {
+    const warnings: Array<{ file: string; error: string }> = [];
+
+    // Fetch and apply cfn-lint patches
+    try {
+      log("Fetching cfn-lint patches...");
+      const patchesDir = await fetchCfnLintPatches(opts.force);
+      const { schemas: patched, stats } = applyPatches(schemas, patchesDir);
+      schemas = patched;
+      log(`Applied ${stats.patchesApplied} patches across ${stats.resourcesFixed} resources`);
+      for (const w of stats.warnings) {
+        warnings.push({ file: `${w.typeName}/${w.patchFile}`, error: w.error.message });
+      }
+    } catch (err) {
+      log(`WARNING: failed to fetch cfn-lint patches: ${err}`);
+    }
+
+    // Fetch extension constraints (stored for use in generateRegistry)
+    try {
+      log("Fetching cfn-lint extensions...");
+      const extensionsDir = await fetchCfnLintExtensions(opts.force);
+      // We'll apply these later in generateRegistry — store them
+      // The parsedTypes set isn't available yet, so we load all and filter later
+      awsConstraints = loadExtensionSchemas(extensionsDir, new Set(schemas.keys()));
+      log(`Loaded extension constraints for ${awsConstraints.size} resource types`);
+    } catch (err) {
+      log(`WARNING: failed to fetch cfn-lint extensions: ${err}`);
+      awsConstraints = new Map();
+    }
+
+    return { schemas, warnings };
+  },
+
+  augmentResults: (results, _opts, log) => {
+    const warnings: Array<{ file: string; error: string }> = [];
+
+    // Add SAM resources
+    results.push(...samResources());
+    log("Added SAM resources");
+
+    // Add fallback resources for missing priority types
+    const parsedTypes = new Set(results.map((r) => r.resource.typeName));
+    for (const fb of fallbackResources()) {
+      if (!parsedTypes.has(fb.resource.typeName)) {
+        results.push(fb);
+        parsedTypes.add(fb.resource.typeName);
+        warnings.push({
+          file: fb.resource.typeName,
+          error: `Priority resource missing from schema zip; using fallback`,
+        });
+      }
+    }
+
+    // Re-filter extension constraints now that we have the full type set
+    // (augmentSchemas loaded them before parsing, so we already have them)
+
+    log(`Total: ${results.length} resource schemas`);
+    return { results, warnings };
+  },
+
+  generateRegistry: (results, naming) => {
+    const runtimeDeprecations = lambdaRuntimeDeprecations();
+    return generateLexiconJSON(
+      results,
+      naming as NamingStrategy,
+      awsConstraints,
+      runtimeDeprecations,
+    );
+  },
+
+  generateTypes: (results, naming) => {
+    return generateTypeScriptDeclarations(results, naming as NamingStrategy);
+  },
+
+  generateRuntimeIndex: (results, naming) => {
+    return generateRuntimeIndex(results, naming as NamingStrategy);
+  },
+};
+
+/**
+ * Run the full AWS generation pipeline.
+ */
+export async function generate(opts: GenerateOptions = {}): Promise<GenerateResult> {
+  // Reset shared state
+  awsConstraints = new Map();
+  return generatePipeline(awsPipelineConfig, opts);
+}
+
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result: GenerateResult, baseDir: string): void {
+  writeGeneratedArtifacts({
+    baseDir,
+    files: {
+      "lexicon-aws.json": result.lexiconJSON,
+      "index.d.ts": result.typesDTS,
+      "index.ts": result.indexTS,
+      "runtime.ts": [
+        "/**",
+        " * Runtime factory constructors — re-exported from core.",
+        " */",
+        'export { createResource, createProperty } from "@intentius/chant/runtime";',
+        "",
+      ].join("\n"),
+    },
+    snapshot: (generatedDir) => {
+      const { snapshotArtifacts, saveSnapshot } = require("./rollback");
+      const lexiconPath = join(generatedDir, "lexicon-aws.json");
+      if (existsSync(lexiconPath)) {
+        const snapshot = snapshotArtifacts(generatedDir);
+        if (Object.keys(snapshot.files).length > 0) {
+          const snapshotsDir = join(baseDir, ".snapshots");
+          saveSnapshot(snapshot, snapshotsDir);
+        }
+      }
+    },
+  });
+}
+
+/**
+ * Generate the runtime index.ts with factory constructor exports.
+ */
+function generateRuntimeIndex(
+  results: SchemaParseResult[],
+  naming: NamingStrategy,
+): string {
+  const resourceEntries: RuntimeIndexEntry[] = [];
+  const propertyEntries: RuntimeIndexPropertyEntry[] = [];
+
+  for (const r of results) {
+    const cfnType = r.resource.typeName;
+    const tsName = naming.resolve(cfnType);
+    if (!tsName) continue;
+
+    // Build attrs map
+    const attrs: Record<string, string> = {};
+    for (const a of r.resource.attributes) {
+      const camelName = a.name.charAt(0).toLowerCase() + a.name.slice(1);
+      attrs[camelName] = a.name;
+    }
+
+    resourceEntries.push({ tsName, resourceType: cfnType, attrs });
+
+    for (const alias of naming.aliases(cfnType)) {
+      resourceEntries.push({ tsName: alias, resourceType: cfnType, attrs });
+    }
+
+    // Property types
+    const shortName = cfnShortName(cfnType);
+    const ptAliases = naming.propertyTypeAliases(cfnType);
+    for (const pt of r.propertyTypes) {
+      const defName = extractDefName(pt.name, shortName);
+      const ptName = propertyTypeName(tsName, defName);
+      const ptCfnType = `${cfnType}.${pt.cfnType}`;
+      propertyEntries.push({ tsName: ptName, resourceType: ptCfnType });
+
+      if (ptAliases) {
+        const aliasName = ptAliases.get(defName);
+        if (aliasName) {
+          propertyEntries.push({ tsName: aliasName, resourceType: ptCfnType });
+        }
+      }
+    }
+  }
+
+  return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, {
+    lexiconName: "aws",
+    intrinsicReExports: {
+      names: ["Sub", "Ref", "GetAtt", "If", "Join", "Select", "Split", "Base64"],
+      from: "../intrinsics",
+    },
+    pseudoReExports: {
+      names: ["AWS", "StackName", "Region", "AccountId", "StackId", "URLSuffix", "NoValue", "NotificationARNs", "Partition"],
+      from: "../pseudo",
+    },
+  });
+}

package/src/codegen/idempotency.test.ts

@@ -0,0 +1,28 @@
+import { describe, test, expect } from "bun:test";
+import { generate } from "./generate";
+import { loadSchemaFixtures } from "../testdata/load-fixtures";
+
+describe("generation idempotency", () => {
+  test("two generations from same fixtures produce identical content", async () => {
+    const fixtures = loadSchemaFixtures();
+
+    const result1 = await generate({ schemaSource: fixtures });
+    const result2 = await generate({ schemaSource: fixtures });
+
+    // Content should be byte-identical
+    expect(result1.lexiconJSON).toBe(result2.lexiconJSON);
+    expect(result1.typesDTS).toBe(result2.typesDTS);
+    expect(result1.indexTS).toBe(result2.indexTS);
+  });
+
+  test("resource counts match between runs", async () => {
+    const fixtures = loadSchemaFixtures();
+
+    const result1 = await generate({ schemaSource: fixtures });
+    const result2 = await generate({ schemaSource: fixtures });
+
+    expect(result1.resources).toBe(result2.resources);
+    expect(result1.properties).toBe(result2.properties);
+    expect(result1.enums).toBe(result2.enums);
+  });
+});

package/src/codegen/naming.ts

@@ -0,0 +1,120 @@
+/**
+ * AWS-specific naming configuration for the core NamingStrategy.
+ *
+ * The algorithm lives in core; only the data tables and helper functions
+ * for extracting names from AWS CloudFormation types are defined here.
+ */
+
+import {
+  NamingStrategy as CoreNamingStrategy,
+  type NamingConfig,
+  type NamingInput,
+} from "@intentius/chant/codegen/naming";
+
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+
+import type { SchemaParseResult } from "../spec/parse";
+import { cfnShortName, cfnServiceName } from "../spec/parse";
+
+/**
+ * Fixed TypeScript class names for backward compatibility.
+ */
+const priorityNames: Record<string, string> = {
+  "AWS::S3::Bucket": "Bucket",
+  "AWS::Lambda::Function": "Function",
+  "AWS::IAM::Role": "Role",
+  "AWS::IAM::Policy": "Policy",
+  "AWS::DynamoDB::Table": "Table",
+  "AWS::SQS::Queue": "Queue",
+  "AWS::SNS::Topic": "Topic",
+  "AWS::EC2::Instance": "Instance",
+  "AWS::EC2::SecurityGroup": "SecurityGroup",
+  "AWS::EC2::VPC": "Vpc",
+  "AWS::EC2::Subnet": "Subnet",
+  "AWS::CloudFormation::Stack": "Stack",
+  "AWS::CloudWatch::Alarm": "Alarm",
+  "AWS::Events::Rule": "EventRule",
+  "AWS::Logs::LogGroup": "LogGroup",
+  "AWS::ApiGateway::RestApi": "RestApi",
+  "AWS::ApiGatewayV2::Api": "HttpApi",
+  "AWS::ECS::Cluster": "EcsCluster",
+  "AWS::ECS::Service": "EcsService",
+  "AWS::ECS::TaskDefinition": "TaskDefinition",
+  "AWS::ElasticLoadBalancingV2::LoadBalancer": "LoadBalancer",
+  "AWS::ElasticLoadBalancingV2::TargetGroup": "TargetGroup",
+  "AWS::ElasticLoadBalancingV2::Listener": "Listener",
+  "AWS::RDS::DBInstance": "DbInstance",
+  "AWS::RDS::DBCluster": "DbCluster",
+  "AWS::StepFunctions::StateMachine": "StateMachine",
+  "AWS::KMS::Key": "KmsKey",
+  "AWS::SecretsManager::Secret": "Secret",
+  "AWS::SSM::Parameter": "SsmParameter",
+  "AWS::Lambda::Permission": "Permission",
+  "AWS::Lambda::LayerVersion": "LayerVersion",
+  "AWS::IAM::ManagedPolicy": "ManagedPolicy",
+  "AWS::IAM::InstanceProfile": "InstanceProfile",
+};
+
+/**
+ * Additional TypeScript names beyond the primary priority name.
+ */
+const priorityAliases: Record<string, string[]> = {
+  "AWS::IAM::Policy": ["IamPolicy"],
+};
+
+/**
+ * Property type aliases that must always be emitted for backward compat.
+ */
+const priorityPropertyAliases: Record<string, Record<string, string>> = {
+  "AWS::S3::Bucket": {
+    ServerSideEncryptionByDefault: "ServerSideEncryptionByDefault",
+    ServerSideEncryptionRule: "ServerSideEncryptionRule",
+    BucketEncryption: "BucketEncryption",
+    VersioningConfiguration: "VersioningConfiguration",
+    PublicAccessBlockConfiguration: "PublicAccessBlockConfiguration",
+    LoggingConfiguration: "LoggingConfiguration",
+  },
+  "AWS::Lambda::Function": {
+    Code: "Code",
+    Environment: "Environment",
+  },
+};
+
+/**
+ * Service name abbreviations for collision-resolved names.
+ */
+const serviceAbbreviations: Record<string, string> = {
+  ElasticLoadBalancingV2: "Elbv2",
+  CloudFormation: "Cfn",
+  CloudWatch: "Cw",
+  ApiGateway: "Apigw",
+  ApiGatewayV2: "Apigwv2",
+  SecretsManager: "Sm",
+  StepFunctions: "Sfn",
+  CertificateManager: "Acm",
+  ElasticLoadBalancing: "Elb",
+  CloudFront: "Cf",
+  ElastiCache: "Ec",
+};
+
+const awsNamingConfig: NamingConfig = {
+  priorityNames,
+  priorityAliases,
+  priorityPropertyAliases,
+  serviceAbbreviations,
+  shortName: cfnShortName,
+  serviceName: cfnServiceName,
+};
+
+/**
+ * AWS-specific NamingStrategy — wraps the core algorithm with AWS data tables.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+  constructor(results: SchemaParseResult[]) {
+    const inputs: NamingInput[] = results.map((r) => ({
+      typeName: r.resource.typeName,
+      propertyTypes: r.propertyTypes,
+    }));
+    super(inputs, awsNamingConfig);
+  }
+}

package/src/codegen/package.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect } from "bun:test";
+import { packageLexicon } from "./package";
+import { validateManifest } from "@intentius/chant/lexicon-schema";
+
+describe("packageLexicon", () => {
+  test("produces valid BundleSpec with all artifacts", async () => {
+    const { spec, stats } = await packageLexicon();
+
+    // Manifest fields
+    expect(spec.manifest.name).toBe("aws");
+    expect(spec.manifest.version).toBeTruthy();
+    expect(spec.manifest.chantVersion).toBe(">=0.1.0");
+    expect(spec.manifest.namespace).toBe("AWS");
+
+    // Intrinsics
+    expect(spec.manifest.intrinsics).toBeDefined();
+    expect(spec.manifest.intrinsics!.length).toBeGreaterThan(0);
+    const sub = spec.manifest.intrinsics!.find((i) => i.name === "Sub");
+    expect(sub).toBeDefined();
+    expect(sub!.outputKey).toBe("Fn::Sub");
+    expect(sub!.isTag).toBe(true);
+    const ref = spec.manifest.intrinsics!.find((i) => i.name === "Ref");
+    expect(ref).toBeDefined();
+    expect(ref!.outputKey).toBe("Ref");
+
+    // Pseudo-parameters
+    expect(spec.manifest.pseudoParameters).toBeDefined();
+    expect(spec.manifest.pseudoParameters!.StackName).toBe("AWS::StackName");
+    expect(spec.manifest.pseudoParameters!.Region).toBe("AWS::Region");
+    expect(spec.manifest.pseudoParameters!.AccountId).toBe("AWS::AccountId");
+
+    // Registry (lexicon JSON)
+    expect(spec.registry.length).toBeGreaterThan(0);
+    const registry = JSON.parse(spec.registry);
+    expect(Object.keys(registry).length).toBeGreaterThan(100);
+
+    // Types
+    expect(spec.typesDTS.length).toBeGreaterThan(0);
+    expect(spec.typesDTS).toContain("export declare class");
+
+    // Rules
+    expect(spec.rules.size).toBeGreaterThan(0);
+    expect(spec.rules.has("s3-encryption.ts")).toBe(true);
+    expect(spec.rules.has("iam-wildcard.ts")).toBe(true);
+
+    // Skills
+    expect(spec.skills.size).toBeGreaterThan(0);
+
+    // Stats
+    expect(stats.resources).toBeGreaterThan(100);
+    expect(stats.ruleCount).toBeGreaterThan(0);
+  }, 120_000);
+
+  test("manifest passes validation", async () => {
+    const { spec } = await packageLexicon();
+    const validated = validateManifest(spec.manifest);
+    expect(validated.name).toBe("aws");
+    expect(validated.version).toBeTruthy();
+  }, 120_000);
+});

package/src/codegen/package.ts

@@ -0,0 +1,84 @@
+/**
+ * AWS lexicon packaging — delegates to core packagePipeline
+ * with AWS-specific manifest building and skill collection.
+ */
+
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import type { IntrinsicDef } from "@intentius/chant/lexicon";
+import {
+  packagePipeline,
+  collectSkills,
+  type PackageOptions,
+  type PackageResult,
+} from "@intentius/chant/codegen/package";
+import { generate } from "./generate";
+
+export type { PackageOptions, PackageResult };
+
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+
+/**
+ * Map intrinsic name to its CloudFormation output key.
+ */
+function intrinsicOutputKey(name: string): string {
+  switch (name) {
+    case "Ref": return "Ref";
+    default: return `Fn::${name}`;
+  }
+}
+
+/**
+ * Package the AWS lexicon into a distributable BundleSpec.
+ */
+export async function packageLexicon(opts: PackageOptions = {}): Promise<PackageResult> {
+  const pkgJson = JSON.parse(readFileSync(join(pkgDir, "..", "package.json"), "utf-8"));
+
+  return packagePipeline(
+    {
+      generate: (genOpts) => generate({ verbose: genOpts.verbose, force: genOpts.force }),
+
+      buildManifest: (_genResult) => {
+        // Lazy-import to avoid circular dependency
+        const { awsPlugin } = require("../plugin");
+
+        const intrinsics: IntrinsicDef[] = (awsPlugin.intrinsics?.() ?? []).map(
+          (i: { name: string; description: string }) => ({
+            name: i.name,
+            description: i.description,
+            outputKey: intrinsicOutputKey(i.name),
+            isTag: i.name === "Sub",
+          }),
+        );
+
+        const pseudoParams: string[] = awsPlugin.pseudoParameters?.() ?? [];
+        const pseudoParameters: Record<string, string> = {};
+        for (const p of pseudoParams) {
+          const shortName = p.split("::").pop()!;
+          pseudoParameters[shortName] = p;
+        }
+
+        return {
+          name: "aws",
+          version: pkgJson.version ?? "0.0.0",
+          chantVersion: ">=0.1.0",
+          namespace: "AWS",
+          intrinsics,
+          pseudoParameters,
+        };
+      },
+
+      srcDir: pkgDir,
+
+      collectSkills: () => {
+        const { awsPlugin } = require("../plugin");
+        const skillDefs = awsPlugin.skills?.() ?? [];
+        return collectSkills(skillDefs);
+      },
+
+      version: pkgJson.version ?? "0.0.0",
+    },
+    opts,
+  );
+}