@macedon-technologies/batman 1.17.2 → 1.18.0

package/CLAUDE.md

@@ -0,0 +1,44 @@
+<!-- BEGIN swamp managed section - DO NOT EDIT -->
+# Project
+
+This repository is managed with [swamp](https://github.com/swamp-club/swamp).
+
+## Rules
+
+1. **Search before you build.** When automating AWS, APIs, or any external service: (a) search community extensions with `swamp extension search <query>` — prefer `@swamp/*` official extensions first, (b) search local/installed types with `swamp model type search <query>`, (c) if a community extension exists, install it with `swamp extension pull <package>` instead of building from scratch, (d) extend an existing type if it covers the domain but lacks the method you need, (e) only create a custom extension model in `extensions/models/` as a last resort. Use the `swamp` skill for guidance. The `command/shell` model is ONLY for ad-hoc one-off shell commands, NEVER for wrapping CLI tools or building integrations.
+2. **Extend, don't be clever.** When a model covers the domain but lacks the method you need, extend it with `export const extension` — don't bypass it with shell scripts, CLI tools, or multi-step hacks. One method, one purpose. Use `swamp model type describe <type> --json` to check available methods.
+3. **Use the data model.** Once data exists in a model (via `lookup`, `start`, `sync`, etc.), reference it with CEL expressions. Don't re-fetch data that's already available.
+4. **CEL expressions everywhere.** Wire models together with CEL expressions. Always prefer `data.latest("<name>", "<dataName>").attributes.<field>` over the deprecated `model.<name>.resource.<spec>.<instance>.attributes.<field>` pattern.
+5. **Verify before destructive operations.** Always `swamp model get <name> --json` and verify resource IDs before running delete/stop/destroy methods.
+6. **Prefer fan-out methods over loops.** When operating on multiple targets, use a single method that handles all targets internally (factory pattern) rather than looping N separate `swamp model method run` calls against the same model. Multiple parallel calls against the same model contend on the per-model lock, causing timeouts. A single fan-out method acquires the lock once and produces all outputs in one execution. Check `swamp model type describe` for methods that accept filters or produce multiple outputs.
+7. **Extension npm deps are bundled, not lockfile-tracked.** Swamp's bundler inlines all npm packages (except zod) into extension bundles at bundle time. `deno.lock` and `package.json` do NOT cover extension model dependencies — this is by design. Always pin explicit versions in `npm:` import specifiers (e.g., `npm:lodash-es@4.17.21`).
+8. **Reports for reusable data pipelines.** When the task involves building a repeatable pipeline to transform, aggregate, or analyze model output (security reports, cost analysis, compliance checks, summaries), create a report extension. Use the `swamp` skill for guidance.
+9. **"Workflow" means a swamp workflow.** In this repository the word "workflow" (and "create/run/execute/validate/debug workflow", "automate", "orchestrate", "automated/nightly job") refers to a swamp workflow — a declarative YAML DAG of model-method steps authored via `swamp workflow create`. Load and follow the `swamp` skill for these requests. Do NOT interpret these as a request to build an agent task list, spin up worktrees, or schedule a cron/remote agent. Only use those orchestration mechanisms when the user explicitly names one (e.g. "task list", "subagent", "worktree", "cron", "remote agent") or explicitly asks you to do the work yourself step by step rather than author a swamp workflow.
+10. **Use swamp, don't bypass it.** Always work through swamp commands — don't go around them with raw shell tools. Use `swamp data query` to find data, not `grep`/`find` on `.swamp/` files. Use model methods to interact with resources, not `curl`/`aws`/`gcloud`/`kubectl` when a model type already wraps that API — check with `swamp model type search`. Use `swamp help` for CLI discovery, not guesswork. Composing with swamp output is fine (e.g. piping `--json` through `jq`) — the anti-pattern is bypassing swamp entirely.
+11. **Inspect reports after failures.** When a model method or workflow run fails, inspect its generated reports before retrying or changing definitions. Reports run even on failure and capture structured diagnostics — error messages, execution status, arguments, and data output pointers. Use `swamp report get @swamp/method-summary --model <model> --json` for method failures or `swamp report get @swamp/workflow-summary --workflow <workflow> --json` for workflow failures. Run `swamp help report get` to confirm current retrieval syntax.
+
+## Skills
+
+**IMPORTANT:** Always load swamp skills, even when in plan mode. The skills provide
+essential context for working with this repository.
+
+- `swamp` - Swamp CLI — models, workflows, data, vaults, extensions, publishing, repos, reports, issues, and troubleshooting
+- `swamp-getting-started` - Interactive onboarding for new swamp users
+
+## Getting Started
+
+**IMPORTANT:** At the start of every conversation, run
+`swamp model search --json`. If no models are returned (empty result), you MUST
+immediately invoke the `swamp-getting-started` skill before doing anything else.
+This walks new users through an interactive onboarding tutorial.
+
+If models already exist, start by using the `swamp` skill to work with
+swamp models.
+
+## Commands
+
+Use `swamp --help` to see available commands. For a machine-readable JSON
+schema of the CLI (commands, options, arguments) intended for agent
+consumption, run `swamp help [<command>...]` — e.g. `swamp help` returns
+the full tree, and `swamp help model method run` scopes to a subtree.
+<!-- END swamp managed section -->

package/architecture-rules/README.md

@@ -0,0 +1,42 @@
+# Architecture rules
+
+A data-driven registry of architectural constraints, enforced by
+`pnpm validate:architecture` and run as part of the pre-PR verification
+workflow (`workflows/workflow-pre-pr-verify.yaml`) before the swamp factory
+opens a PR. New rules are new entries in `rules.json`, not new code — the
+engine (`check.ts`) only needs a new case in `evaluateRule()` when a rule
+needs a genuinely new kind of check.
+
+## Rule shape
+
+```json
+{
+  "id": "unique-id",
+  "description": "What this enforces and why.",
+  "enabled": true,
+  "severity": "low" | "medium" | "high" | "critical",
+  "check": {
+    "type": "forbidden-import",
+    "from": ["glob patterns selecting files this rule inspects"],
+    "forbid": ["glob patterns those files may not import from"]
+  }
+}
+```
+
+`enabled: false` rules are skipped (reported as "deferred") rather than
+evaluated — use this for a rule you've named and described but don't yet
+have a concrete convention to check.
+
+## Current rules
+
+None yet — `rules.json` ships empty. Add rules as your domain module
+conventions solidify (e.g. an event-sourced/CQRS module layout under
+`src/domains/<name>/{commands,events,aggregates,projections}/`).
+
+## Adding a check type
+
+`forbidden-import` is the only implemented `check.type`. If a future rule
+needs something it can't express (e.g. "every aggregate file must have a
+matching events file"), add a new `type` value, a matching interface, and a
+case in `evaluateRule()` in `check.ts` — keep the engine itself generic;
+rule-specific knowledge belongs in `rules.json`.

package/architecture-rules/check.ts

@@ -0,0 +1,162 @@
+/**
+ * Generic architecture-rule engine. Rules live entirely in rules.json — this
+ * file only knows how to evaluate the check "types" that rules can declare.
+ * Add a new rule by adding a rules.json entry; add a new check type by adding
+ * a case in evaluateRule().
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import rulesFile from './rules.json';
+
+interface ForbiddenImportCheck {
+  type: 'forbidden-import';
+  // Glob patterns (relative to repo root) selecting the files this rule inspects.
+  from: string[];
+  // Glob patterns (relative to repo root) that "from" files may not import from.
+  forbid: string[];
+}
+
+interface Rule {
+  id: string;
+  description: string;
+  enabled: boolean;
+  severity: 'low' | 'medium' | 'high' | 'critical';
+  check: ForbiddenImportCheck;
+}
+
+interface Violation {
+  ruleId: string;
+  severity: string;
+  message: string;
+}
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);
+
+// Minimal glob -> RegExp: supports "*", "**", "**/" and literal path segments.
+// No new dependency for this — the only pattern shapes rules.json ever needs
+// are directory-prefix globs like "src/domains/*/commands/**".
+function globToRegExp(glob: string): RegExp {
+  let out = '';
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === '*' && glob[i + 1] === '*') {
+      i++;
+      if (glob[i + 1] === '/') {
+        out += '(?:.*/)?';
+        i++;
+      } else {
+        out += '.*';
+      }
+    } else if (c === '*') {
+      out += '[^/]*';
+    } else if (c === '?') {
+      out += '[^/]';
+    } else if ('.+^${}()|[]\\'.includes(c)) {
+      out += `\\${c}`;
+    } else {
+      out += c;
+    }
+  }
+  return new RegExp(`^${out}$`);
+}
+
+function matchesAny(relFile: string, globs: string[]): boolean {
+  return globs.some((glob) => globToRegExp(glob).test(relFile));
+}
+
+function toRepoRelative(absPath: string): string {
+  return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');
+}
+
+function walk(dir: string, acc: string[] = []): string[] {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (IGNORED_DIRS.has(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(full, acc);
+    } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {
+      acc.push(full);
+    }
+  }
+  return acc;
+}
+
+const RELATIVE_IMPORT_RE = /(?:import|export)\s+(?:[^'";]*?\bfrom\s+)?['"](\.[^'"]+)['"]/g;
+
+function findRelativeImports(source: string): string[] {
+  const specs: string[] = [];
+  RELATIVE_IMPORT_RE.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = RELATIVE_IMPORT_RE.exec(source))) {
+    specs.push(match[1]);
+  }
+  return specs;
+}
+
+// An import spec resolves to a module, not a specific file extension, so a
+// forbid glob is checked against the bare resolved path plus its .ts/index.ts
+// variants.
+function resolvedCandidates(fromFile: string, spec: string): string[] {
+  const resolved = toRepoRelative(path.normalize(path.join(path.dirname(fromFile), spec)));
+  return [resolved, `${resolved}.ts`, `${resolved}/index.ts`];
+}
+
+function evaluateForbiddenImport(rule: Rule): Violation[] {
+  const { from, forbid } = rule.check;
+  if (from.length === 0 || forbid.length === 0) return [];
+
+  const violations: Violation[] = [];
+  for (const file of walk(REPO_ROOT)) {
+    const relFile = toRepoRelative(file);
+    if (!matchesAny(relFile, from)) continue;
+
+    const source = fs.readFileSync(file, 'utf8');
+    for (const spec of findRelativeImports(source)) {
+      const candidates = resolvedCandidates(file, spec);
+      if (candidates.some((candidate) => matchesAny(candidate, forbid))) {
+        violations.push({
+          ruleId: rule.id,
+          severity: rule.severity,
+          message: `${relFile} imports "${spec}", which resolves under a path forbidden by rule "${rule.id}"`,
+        });
+      }
+    }
+  }
+  return violations;
+}
+
+function evaluateRule(rule: Rule): Violation[] {
+  switch (rule.check.type) {
+    case 'forbidden-import':
+      return evaluateForbiddenImport(rule);
+    default:
+      throw new Error(`architecture-rules: unknown check.type "${(rule.check as { type: string }).type}" on rule "${rule.id}"`);
+  }
+}
+
+function main(): number {
+  const rules = (rulesFile as { rules: Rule[] }).rules;
+  let evaluated = 0;
+  let deferred = 0;
+  const violations: Violation[] = [];
+
+  for (const rule of rules) {
+    if (!rule.enabled) {
+      deferred++;
+      console.log(`[deferred] ${rule.id}: ${rule.description}`);
+      continue;
+    }
+    evaluated++;
+    violations.push(...evaluateRule(rule));
+  }
+
+  console.log(`\narchitecture-rules: ${evaluated} rule(s) evaluated, ${deferred} deferred, ${violations.length} violation(s)`);
+  for (const violation of violations) {
+    console.error(`  [${violation.severity}] ${violation.ruleId}: ${violation.message}`);
+  }
+
+  return violations.length > 0 ? 1 : 0;
+}
+
+process.exit(main());

package/architecture-rules/rules.json

@@ -0,0 +1,3 @@
+{
+  "rules": []
+}

package/architecture-rules/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": "."
+  },
+  "include": [
+    "*.ts",
+    "*.json"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/attestation/manifest.ts

@@ -0,0 +1,40 @@
+/**
+ * Single source of truth for which files' content determines "was this PR
+ * actually verified against the rules it claims." Hashed by both the
+ * pre-pr-verify workflow (to embed in the PR's attestation) and the
+ * verify-attestation GitHub Action (to check nothing drifted since). Keeping
+ * one list in one file is what keeps generator and checker from disagreeing
+ * about what "the config" even is.
+ */
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const MANIFEST_FILES: readonly string[] = [
+  'workflows/workflow-pre-pr-verify.yaml',
+  'workflows/workflow-openspec-plan-verify.yaml',
+  'workflows/workflow-openspec-tasks-verify.yaml',
+  'models/@swamp/software-factory/platform-common-factory.yaml',
+  'architecture-rules/rules.json',
+  'architecture-rules/check.ts',
+  'openspec-gates/check-tasks-complete.ts',
+  'CLAUDE.md',
+];
+
+export interface Manifest {
+  generatedAt: string;
+  files: Record<string, string>;
+}
+
+export function computeManifest(repoRoot: string = join(__dirname, '..')): Manifest {
+  const files: Record<string, string> = {};
+  for (const relativePath of MANIFEST_FILES) {
+    const contents = readFileSync(join(repoRoot, relativePath));
+    files[relativePath] = createHash('sha256').update(contents).digest('hex');
+  }
+  return { generatedAt: new Date().toISOString(), files };
+}
+
+if (require.main === module) {
+  console.log(JSON.stringify(computeManifest(), null, 2));
+}

package/attestation/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": "."
+  },
+  "include": [
+    "*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/attestation/verify.ts

@@ -0,0 +1,142 @@
+/**
+ * Checks the `<!-- attestation-manifest ... -->` block a factory-opened PR
+ * embeds in its body (see the open-pr stage in
+ * models/@swamp/software-factory/platform-common-factory.yaml) against reality at the
+ * commit being merged. Per stack72.dev/ai-broke-the-assumptions-behind-ci/:
+ * this proves the verification-relevant config hasn't drifted since the
+ * attestation was generated — it does NOT independently prove the tests
+ * in that attestation actually ran. That's an accepted limitation, not an
+ * oversight; see the article and attestation/manifest.ts's own comment.
+ */
+import { readFileSync } from 'node:fs';
+import { computeManifest, type Manifest } from './manifest';
+
+const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+// Global, and deliberately loose about what's *between* the marker and the
+// block's own closing "-->" — PR bodies can (and, it turns out, do) mention
+// the literal "<!-- attestation-manifest -->" syntax in prose describing
+// this mechanism. Each match is independently validated below; a mention
+// with no JSON inside it is skipped rather than treated as a parse error.
+const MANIFEST_BLOCK_RE = /<!--\s*attestation-manifest([\s\S]*?)-->/g;
+
+interface EmbeddedManifest extends Manifest {
+  commit: string;
+  status: string;
+}
+
+function isEmbeddedManifest(value: unknown): value is EmbeddedManifest {
+  const candidate = value as Partial<EmbeddedManifest> | null;
+  return (
+    typeof candidate === 'object' &&
+    candidate !== null &&
+    typeof candidate.commit === 'string' &&
+    typeof candidate.status === 'string' &&
+    typeof candidate.generatedAt === 'string' &&
+    typeof candidate.files === 'object' &&
+    candidate.files !== null
+  );
+}
+
+// Balanced-brace scan rather than a regex for the JSON itself: the manifest
+// has nested objects (files: {...}), so a non-greedy `\{.*?\}` would stop at
+// the first inner "}" instead of the real end of the object.
+function extractBalancedJson(text: string): string | null {
+  const start = text.indexOf('{');
+  if (start === -1) return null;
+  let depth = 0;
+  for (let i = start; i < text.length; i++) {
+    if (text[i] === '{') depth++;
+    else if (text[i] === '}') {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+
+function extractEmbeddedManifest(body: string): EmbeddedManifest {
+  let matchedAnyBlock = false;
+  for (const match of body.matchAll(MANIFEST_BLOCK_RE)) {
+    matchedAnyBlock = true;
+    const jsonText = extractBalancedJson(match[1]);
+    if (!jsonText) continue;
+    try {
+      const parsed = JSON.parse(jsonText);
+      if (isEmbeddedManifest(parsed)) return parsed;
+    } catch {
+      // Not this one — keep looking at the next attestation-manifest mention.
+    }
+  }
+  throw new Error(
+    matchedAnyBlock
+      ? 'Found <!-- attestation-manifest --> mention(s) in the PR body, but none contained a complete, valid manifest.'
+      : 'No <!-- attestation-manifest --> block found in the PR body. This PR was never verified by ' +
+        'pre-pr-verify (or the block was removed) — run the factory\'s pre-pr-verify workflow and re-open/update the PR.',
+  );
+}
+
+function verify(prBody: string, expectedCommit: string): string[] {
+  let embedded: EmbeddedManifest;
+  try {
+    embedded = extractEmbeddedManifest(prBody);
+  } catch (err) {
+    return [err instanceof Error ? err.message : String(err)];
+  }
+
+  const errors: string[] = [];
+
+  if (embedded.commit !== expectedCommit) {
+    errors.push(
+      `Attestation is for commit ${embedded.commit}, but the PR's head commit is ${expectedCommit}. ` +
+      'New commits were pushed without re-running pre-pr-verify.',
+    );
+  }
+
+  if (embedded.status !== 'succeeded') {
+    errors.push(`Attestation status is "${embedded.status}", not "succeeded".`);
+  }
+
+  const ageMs = Date.now() - Date.parse(embedded.generatedAt);
+  if (!Number.isFinite(ageMs)) {
+    errors.push(`Attestation generatedAt ("${embedded.generatedAt}") is not a parseable timestamp.`);
+  } else if (ageMs > MAX_AGE_MS) {
+    errors.push(`Attestation is ${Math.floor(ageMs / (24 * 60 * 60 * 1000))} days old (max ${MAX_AGE_MS / (24 * 60 * 60 * 1000)}) — re-run pre-pr-verify.`);
+  }
+
+  const actual = computeManifest();
+  for (const file of Object.keys(actual.files)) {
+    if (embedded.files[file] !== actual.files[file]) {
+      errors.push(`${file} has changed since the attestation was generated (expected ${embedded.files[file] ?? 'missing'}, got ${actual.files[file]}).`);
+    }
+  }
+  for (const file of Object.keys(embedded.files)) {
+    if (!(file in actual.files)) {
+      errors.push(`${file} is in the attestation manifest but no longer in the current file list (attestation/manifest.ts's MANIFEST_FILES changed).`);
+    }
+  }
+
+  return errors;
+}
+
+function parseArgs(argv: string[]): { bodyFile: string; commit: string } {
+  const bodyFile = argv[argv.indexOf('--body-file') + 1];
+  const commit = argv[argv.indexOf('--commit') + 1];
+  if (!bodyFile || !commit) {
+    throw new Error('Usage: verify.ts --body-file <path> --commit <sha>');
+  }
+  return { bodyFile, commit };
+}
+
+if (require.main === module) {
+  const { bodyFile, commit } = parseArgs(process.argv.slice(2));
+  const prBody = readFileSync(bodyFile, 'utf8');
+  const errors = verify(prBody, commit);
+  if (errors.length > 0) {
+    console.error('Attestation verification failed:\n');
+    for (const error of errors) {
+      console.error(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+  console.log(`Attestation verified: commit ${commit}, all ${Object.keys(computeManifest().files).length} tracked files match.`);
+}

package/build-tools/scan-generated-workflows.ts

@@ -1,14 +1,14 @@
 /**
- * Synthesizes a representative BatmanProject and scans the GitHub Actions
- * workflows it generates for downstream consumer repos with zizmor, so
- * regressions in PrDeployWorkflow.ts/PrCleanupWorkflow.ts/etc. are caught
- * here rather than shipping to every consumer of this construct.
+ * Synthesizes a representative BatmanProject and scans every GitHub Actions
+ * workflow it generates for downstream consumer repos with zizmor, so
+ * regressions in PrDeployWorkflow.ts/PrCleanupWorkflow.ts/ProjenWorkflowHardening.ts/etc.
+ * are caught here rather than shipping to every consumer of this construct.
  *
- * Only scans the workflow files this package hand-authors (pr-deploy.yml,
- * pr-cleanup.yml, staging-deploy.yml, production-deploy.yml). Other files
- * BatmanProject generates (e.g. upgrade.yml) come from AwsCdkTypeScriptApp's
- * built-in GithubWorkflow defaults, which use unpinned action tags we don't
- * control here — overriding those is out of scope for this scan.
+ * This includes upgrade.yml and pull-request-lint.yml, which AwsCdkTypeScriptApp
+ * generates on its own with unpinned action tags and (for pull-request-lint.yml) a
+ * pull_request_target trigger — see macedon-technologies/exman#13, where those
+ * defaults leaked into a consumer repo unpinned. `Application` corrects both via
+ * `hardenProjenGeneratedWorkflows`, and this scan is what would have caught it.
  */
 import { execFileSync } from 'child_process';
 import { mkdtempSync, rmSync } from 'fs';
@@ -42,8 +42,15 @@ try {
     prod: ENV,
   });
   project.synth();
-  const HAND_AUTHORED_WORKFLOWS = ['pr-deploy.yml', 'pr-cleanup.yml', 'staging-deploy.yml', 'production-deploy.yml'];
-  const paths = HAND_AUTHORED_WORKFLOWS.map((f) => join(outdir, '.github', 'workflows', f));
+  const GENERATED_WORKFLOWS = [
+    'pr-deploy.yml',
+    'pr-cleanup.yml',
+    'staging-deploy.yml',
+    'production-deploy.yml',
+    'upgrade.yml',
+    'pull-request-lint.yml',
+  ];
+  const paths = GENERATED_WORKFLOWS.map((f) => join(outdir, '.github', 'workflows', f));
   execFileSync('uvx', [`zizmor@${ZIZMOR_VERSION}`, ...paths], { stdio: 'inherit' });
 } finally {
   rmSync(outdir, { recursive: true, force: true });

package/lib/Application.js

@@ -13,6 +13,7 @@ const MainTestFile_1 = require("./MainTestFile");
 const PrCleanupWorkflow_1 = require("./PrCleanupWorkflow");
 const PrDeployWorkflow_1 = require("./PrDeployWorkflow");
 const ProductionDeployWorkflow_1 = require("./ProductionDeployWorkflow");
+const ProjenWorkflowHardening_1 = require("./ProjenWorkflowHardening");
 const StagingDeployWorkflow_1 = require("./StagingDeployWorkflow");
 const StaticWebsiteConstructFile_1 = require("./StaticWebsiteConstructFile");
 const WorkflowAutoDiscover_1 = require("./WorkflowAutoDiscover");
@@ -81,7 +82,11 @@ class Application {
             clerkPublishableKey: options.prod.clerkPublishableKey,
             actionVersions: options.actionVersions,
         });
+        // Harden the workflows AwsCdkTypeScriptApp generates on its own (upgrade.yml,
+        // pull-request-lint.yml), which otherwise ship with unpinned actions and a
+        // pull_request_target trigger zizmor flags on every consumer of this construct.
+        (0, ProjenWorkflowHardening_1.hardenProjenGeneratedWorkflows)(project, options.actionVersions);
     }
 }
 exports.Application = Application;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Application.js","sourceRoot":"","sources":["../src/Application.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';\nimport { ApiFiles } from './Api/ApiFiles';\nimport { ApiConstructFile } from './ApiConstructFile';\nimport { ApplicationStackFile } from './ApplicationStackFile';\nimport { BaseApplicationStackFile } from './BaseApplicationStackFile';\nimport { CodeRabbitFile } from './CodeRabbitFile';\nimport { GitHubRolesStackFile } from './GitHubRolesStackFile';\nimport { LocalDevFiles } from './LocalDevFiles';\nimport { EnvironmentConfig, MainFile } from './MainFile';\nimport { MainTestFile } from './MainTestFile';\nimport { PrCleanupWorkflow } from './PrCleanupWorkflow';\nimport { PrDeployWorkflow } from './PrDeployWorkflow';\nimport { ProductionDeployWorkflow } from './ProductionDeployWorkflow';\nimport { StagingDeployWorkflow } from './StagingDeployWorkflow';\nimport { StaticWebsiteConstructFile } from './StaticWebsiteConstructFile';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\nimport { WorkflowAutoDiscover } from './WorkflowAutoDiscover';\nimport { WorkflowProviderFile } from './WorkflowProvider';\n\nexport interface ApplicationEnvironmentConfig extends EnvironmentConfig {\n  readonly githubActionRoleArn: `arn:aws:iam::${string}:role/${string}`;\n}\n\nexport interface ApplicationOptions {\n  readonly githubRepository: string;\n  readonly dev: ApplicationEnvironmentConfig;\n  readonly staging: ApplicationEnvironmentConfig;\n  readonly prod: ApplicationEnvironmentConfig;\n  readonly additionalTags?: { [key: string]: string };\n  readonly n8nWorkflows?: boolean;\n\n  /**\n   * Overrides for the pinned action versions used by the generated GitHub Actions workflows.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n\n  /**\n   * Overrides the pinned S3 object version of the clerk-authorizer Lambda deployment package.\n   *\n   * @default - the default pinned in ApiConstructFile\n   */\n  readonly authorizerObjectVersion?: string;\n}\n\n/**\n * Application construct that creates all standard project files\n */\nexport class Application {\n  constructor(project: AwsCdkTypeScriptApp, options: ApplicationOptions) {\n    // Create main entry point files\n\n    new MainFile(project, {\n      projectName: project.name,\n      dev: options.dev,\n      staging: options.staging,\n      prod: options.prod,\n      additionalTags: options.additionalTags,\n    });\n\n    new LocalDevFiles(project, {\n      projectName: project.name,\n      dev: options.dev,\n    });\n\n    // Create stack files\n    new GitHubRolesStackFile(project, {\n      githubRepository: options.githubRepository,\n    });\n\n    new BaseApplicationStackFile(project);\n    new ApplicationStackFile(project);\n\n    // Create construct files\n    new ApiConstructFile(project, { authorizerObjectVersion: options.authorizerObjectVersion });\n    new StaticWebsiteConstructFile(project);\n\n    // n8n workflow files\n    if (options.n8nWorkflows === undefined || options.n8nWorkflows) {\n      new WorkflowProviderFile(project);\n      new WorkflowAutoDiscover(project);\n    }\n\n    // Create handler files and API backend logic files\n    new ApiFiles(project);\n\n    // Create test files\n    new MainTestFile(project);\n\n    // Create config files\n    new CodeRabbitFile(project);\n\n    // Create GitHub Actions workflows\n    new PrDeployWorkflow(project, {\n      roleArn: options.dev.githubActionRoleArn,\n      awsRegion: options.dev.region,\n      clerkPublishableKey: options.dev.clerkPublishableKey,\n      actionVersions: options.actionVersions,\n    });\n\n    new PrCleanupWorkflow(project, {\n      roleArn: options.dev.githubActionRoleArn,\n      awsRegion: options.dev.region,\n      projectName: project.name,\n      actionVersions: options.actionVersions,\n    });\n\n    new StagingDeployWorkflow(project, {\n      roleArn: options.staging.githubActionRoleArn,\n      awsRegion: options.staging.region,\n      projectName: project.name,\n      clerkPublishableKey: options.staging.clerkPublishableKey,\n      actionVersions: options.actionVersions,\n    });\n\n    new ProductionDeployWorkflow(project, {\n      roleArn: options.prod.githubActionRoleArn,\n      awsRegion: options.prod.region,\n      projectName: project.name,\n      clerkPublishableKey: options.prod.clerkPublishableKey,\n      actionVersions: options.actionVersions,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Application.js","sourceRoot":"","sources":["../src/Application.ts"],"names":[],"mappings":";;;AACA,6CAA0C;AAC1C,yDAAsD;AACtD,iEAA8D;AAC9D,yEAAsE;AACtE,qDAAkD;AAClD,iEAA8D;AAC9D,mDAAgD;AAChD,yCAAyD;AACzD,iDAA8C;AAC9C,2DAAwD;AACxD,yDAAsD;AACtD,yEAAsE;AACtE,uEAA2E;AAC3E,mEAAgE;AAChE,6EAA0E;AAE1E,iEAA8D;AAC9D,yDAA0D;AA2B1D;;GAEG;AACH,MAAa,WAAW;IACtB,YAAY,OAA4B,EAAE,OAA2B;QACnE,gCAAgC;QAEhC,IAAI,mBAAQ,CAAC,OAAO,EAAE;YACpB,WAAW,EAAE,OAAO,CAAC,IAAI;YACzB,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,cAAc,EAAE,OAAO,CAAC,cAAc;SACvC,CAAC,CAAC;QAEH,IAAI,6BAAa,CAAC,OAAO,EAAE;YACzB,WAAW,EAAE,OAAO,CAAC,IAAI;YACzB,GAAG,EAAE,OAAO,CAAC,GAAG;SACjB,CAAC,CAAC;QAEH,qBAAqB;QACrB,IAAI,2CAAoB,CAAC,OAAO,EAAE;YAChC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;SAC3C,CAAC,CAAC;QAEH,IAAI,mDAAwB,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,2CAAoB,CAAC,OAAO,CAAC,CAAC;QAElC,yBAAyB;QACzB,IAAI,mCAAgB,CAAC,OAAO,EAAE,EAAE,uBAAuB,EAAE,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAAC;QAC5F,IAAI,uDAA0B,CAAC,OAAO,CAAC,CAAC;QAExC,qBAAqB;QACrB,IAAI,OAAO,CAAC,YAAY,KAAK,SAAS,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;YAC/D,IAAI,uCAAoB,CAAC,OAAO,CAAC,CAAC;YAClC,IAAI,2CAAoB,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED,mDAAmD;QACnD,IAAI,mBAAQ,CAAC,OAAO,CAAC,CAAC;QAEtB,oBAAoB;QACpB,IAAI,2BAAY,CAAC,OAAO,CAAC,CAAC;QAE1B,sBAAsB;QACtB,IAAI,+BAAc,CAAC,OAAO,CAAC,CAAC;QAE5B,kCAAkC;QAClC,IAAI,mCAAgB,CAAC,OAAO,EAAE;YAC5B,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB;YACxC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM;YAC7B,mBAAmB,EAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB;YACpD,cAAc,EAAE,OAAO,CAAC,cAAc;SACvC,CAAC,CAAC;QAEH,IAAI,qCAAiB,CAAC,OAAO,EAAE;YAC7B,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB;YACxC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM;YAC7B,WAAW,EAAE,OAAO,CAAC,IAAI;YACzB,cAAc,EAAE,OAAO,CAAC,cAAc;SACvC,CAAC,CAAC;QAEH,IAAI,6CAAqB,CAAC,OAAO,EAAE;YACjC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,mBAAmB;YAC5C,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,MAAM;YACjC,WAAW,EAAE,OAAO,CAAC,IAAI;YACzB,mBAAmB,EAAE,OAAO,CAAC,OAAO,CAAC,mBAAmB;YACxD,cAAc,EAAE,OAAO,CAAC,cAAc;SACvC,CAAC,CAAC;QAEH,IAAI,mDAAwB,CAAC,OAAO,EAAE;YACpC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,mBAAmB;YACzC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM;YAC9B,WAAW,EAAE,OAAO,CAAC,IAAI;YACzB,mBAAmB,EAAE,OAAO,CAAC,IAAI,CAAC,mBAAmB;YACrD,cAAc,EAAE,OAAO,CAAC,cAAc;SACvC,CAAC,CAAC;QAEH,8EAA8E;QAC9E,2EAA2E;QAC3E,gFAAgF;QAChF,IAAA,wDAA8B,EAAC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IAClE,CAAC;CACF;AAhFD,kCAgFC","sourcesContent":["import { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';\nimport { ApiFiles } from './Api/ApiFiles';\nimport { ApiConstructFile } from './ApiConstructFile';\nimport { ApplicationStackFile } from './ApplicationStackFile';\nimport { BaseApplicationStackFile } from './BaseApplicationStackFile';\nimport { CodeRabbitFile } from './CodeRabbitFile';\nimport { GitHubRolesStackFile } from './GitHubRolesStackFile';\nimport { LocalDevFiles } from './LocalDevFiles';\nimport { EnvironmentConfig, MainFile } from './MainFile';\nimport { MainTestFile } from './MainTestFile';\nimport { PrCleanupWorkflow } from './PrCleanupWorkflow';\nimport { PrDeployWorkflow } from './PrDeployWorkflow';\nimport { ProductionDeployWorkflow } from './ProductionDeployWorkflow';\nimport { hardenProjenGeneratedWorkflows } from './ProjenWorkflowHardening';\nimport { StagingDeployWorkflow } from './StagingDeployWorkflow';\nimport { StaticWebsiteConstructFile } from './StaticWebsiteConstructFile';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\nimport { WorkflowAutoDiscover } from './WorkflowAutoDiscover';\nimport { WorkflowProviderFile } from './WorkflowProvider';\n\nexport interface ApplicationEnvironmentConfig extends EnvironmentConfig {\n  readonly githubActionRoleArn: `arn:aws:iam::${string}:role/${string}`;\n}\n\nexport interface ApplicationOptions {\n  readonly githubRepository: string;\n  readonly dev: ApplicationEnvironmentConfig;\n  readonly staging: ApplicationEnvironmentConfig;\n  readonly prod: ApplicationEnvironmentConfig;\n  readonly additionalTags?: { [key: string]: string };\n  readonly n8nWorkflows?: boolean;\n\n  /**\n   * Overrides for the pinned action versions used by the generated GitHub Actions workflows.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n\n  /**\n   * Overrides the pinned S3 object version of the clerk-authorizer Lambda deployment package.\n   *\n   * @default - the default pinned in ApiConstructFile\n   */\n  readonly authorizerObjectVersion?: string;\n}\n\n/**\n * Application construct that creates all standard project files\n */\nexport class Application {\n  constructor(project: AwsCdkTypeScriptApp, options: ApplicationOptions) {\n    // Create main entry point files\n\n    new MainFile(project, {\n      projectName: project.name,\n      dev: options.dev,\n      staging: options.staging,\n      prod: options.prod,\n      additionalTags: options.additionalTags,\n    });\n\n    new LocalDevFiles(project, {\n      projectName: project.name,\n      dev: options.dev,\n    });\n\n    // Create stack files\n    new GitHubRolesStackFile(project, {\n      githubRepository: options.githubRepository,\n    });\n\n    new BaseApplicationStackFile(project);\n    new ApplicationStackFile(project);\n\n    // Create construct files\n    new ApiConstructFile(project, { authorizerObjectVersion: options.authorizerObjectVersion });\n    new StaticWebsiteConstructFile(project);\n\n    // n8n workflow files\n    if (options.n8nWorkflows === undefined || options.n8nWorkflows) {\n      new WorkflowProviderFile(project);\n      new WorkflowAutoDiscover(project);\n    }\n\n    // Create handler files and API backend logic files\n    new ApiFiles(project);\n\n    // Create test files\n    new MainTestFile(project);\n\n    // Create config files\n    new CodeRabbitFile(project);\n\n    // Create GitHub Actions workflows\n    new PrDeployWorkflow(project, {\n      roleArn: options.dev.githubActionRoleArn,\n      awsRegion: options.dev.region,\n      clerkPublishableKey: options.dev.clerkPublishableKey,\n      actionVersions: options.actionVersions,\n    });\n\n    new PrCleanupWorkflow(project, {\n      roleArn: options.dev.githubActionRoleArn,\n      awsRegion: options.dev.region,\n      projectName: project.name,\n      actionVersions: options.actionVersions,\n    });\n\n    new StagingDeployWorkflow(project, {\n      roleArn: options.staging.githubActionRoleArn,\n      awsRegion: options.staging.region,\n      projectName: project.name,\n      clerkPublishableKey: options.staging.clerkPublishableKey,\n      actionVersions: options.actionVersions,\n    });\n\n    new ProductionDeployWorkflow(project, {\n      roleArn: options.prod.githubActionRoleArn,\n      awsRegion: options.prod.region,\n      projectName: project.name,\n      clerkPublishableKey: options.prod.clerkPublishableKey,\n      actionVersions: options.actionVersions,\n    });\n\n    // Harden the workflows AwsCdkTypeScriptApp generates on its own (upgrade.yml,\n    // pull-request-lint.yml), which otherwise ship with unpinned actions and a\n    // pull_request_target trigger zizmor flags on every consumer of this construct.\n    hardenProjenGeneratedWorkflows(project, options.actionVersions);\n  }\n}\n"]}

package/lib/BatmanProject.js

@@ -8,10 +8,11 @@ const Application_1 = require("./Application");
 const CodeOwnersFile_1 = require("./CodeOwnersFile");
 const DataDogAspectFile_1 = require("./DataDogAspectFile");
 const GitHubRolesFile_1 = require("./GitHubRolesFile");
+const SoftwareFactoryFiles_1 = require("./SoftwareFactoryFiles");
 const utils_1 = require("./utils");
 const ViteReactProject_1 = require("./ViteReactProject");
 class BatmanProject extends awscdk_1.AwsCdkTypeScriptApp {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BatmanProject", version: "1.17.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BatmanProject", version: "1.18.0" };
     constructor(options) {
         super({
             ...options,
@@ -96,6 +97,11 @@ class BatmanProject extends awscdk_1.AwsCdkTypeScriptApp {
             additionalOwners: options.additionalCodeOwners,
         });
         new DataDogAspectFile_1.DataDogAspectFile(this);
+        new SoftwareFactoryFiles_1.SoftwareFactoryFiles(this, {
+            repoName: options.name,
+            baseBranch: options.defaultReleaseBranch,
+            actionVersions: options.actionVersions,
+        });
         const viteReact = new ViteReactProject_1.ViteReactProject({
             name: options.name,
             defaultReleaseBranch: 'main',
@@ -118,4 +124,4 @@ class BatmanProject extends awscdk_1.AwsCdkTypeScriptApp {
     }
 }
 exports.BatmanProject = BatmanProject;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BatmanProject.js","sourceRoot":"","sources":["../src/BatmanProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsCdkTypeScriptApp, AwsCdkTypeScriptAppOptions } from 'projen/lib/awscdk';\nimport { GithubCredentials } from 'projen/lib/github';\nimport { Application, ApplicationEnvironmentConfig } from './Application';\nimport { CodeOwnersFile } from './CodeOwnersFile';\nimport { DataDogAspectFile } from './DataDogAspectFile';\nimport { GitHubRolesFile } from './GitHubRolesFile';\nimport { readmeContents } from './utils';\nimport { ViteReactProject } from './ViteReactProject';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\n\nexport interface BatmanProjectOptions extends AwsCdkTypeScriptAppOptions {\n\n  /**\n   * Development environment configuration\n   */\n  readonly dev: ApplicationEnvironmentConfig;\n\n  /**\n   * Development environment configuration\n   */\n  readonly staging: ApplicationEnvironmentConfig;\n\n  /**\n   * Production environment configuration\n   */\n  readonly prod: ApplicationEnvironmentConfig;\n\n  /**\n   * Additional tags to apply to all stacks\n   */\n  readonly additionalTags?: { [key: string]: string };\n\n  /**\n   * Enable n8n workflow auto-discovery and WorkflowProvider generation\n   */\n  readonly n8nWorkflows?: boolean;\n\n  /**\n   * Additional code owners to add to the CODEOWNERS file\n   */\n  readonly additionalCodeOwners?: string[];\n\n  /**\n   * Website dependencies\n   */\n  readonly websiteDeps?: string[];\n\n  /**\n   * Overrides for the pinned action versions used by the generated GitHub Actions workflows.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n\n  /**\n   * Overrides the pinned S3 object version of the clerk-authorizer Lambda deployment package.\n   *\n   * @default - the default pinned in ApiConstructFile\n   */\n  readonly authorizerObjectVersion?: string;\n}\n\n\nexport class BatmanProject extends AwsCdkTypeScriptApp {\n  constructor(options: BatmanProjectOptions) {\n    super({\n      ...options,\n      cdkVersion: options.cdkVersion || '2.224.0',\n      defaultReleaseBranch: options.defaultReleaseBranch || 'main',\n      name: options.name,\n      projenrcTs: true,\n      buildWorkflow: false,\n      deps: [\n        '@types/aws-lambda',\n        '@types/express',\n        '@types/pg',\n        'pg',\n        '@aws-sdk/rds-signer',\n        '@matthewbonig/secret',\n        'datadog-cdk-constructs-v2',\n        '@cdklabs/aws-lambda-rust',\n        '@aws-lambda-powertools/parameters',\n        'jsonwebtoken',\n        '@aws-sdk/client-secrets-manager',\n        'express',\n        'serverless-http',\n        ...options.deps || [],\n      ],\n      devDeps: [\n        '@types/jsonwebtoken',\n        'nodemon',\n        'concurrently',\n        '@macedon-technologies/batman@^1.0.0',\n        ...options.devDeps || [],\n      ],\n      gitignore: [\n        'src/constructs/handler/clerk-authorizer/target/**',\n        '**/.DS_Store',\n        ...options.gitignore || [],\n      ],\n      tsconfig: {\n        ...options.tsconfig,\n        compilerOptions: {\n          ...options.tsconfig?.compilerOptions,\n          isolatedModules: true,\n          allowImportingTsExtensions: true,\n        },\n      },\n      sampleCode: false,\n      minNodeVersion: options.minNodeVersion || '22',\n      depsUpgradeOptions: {\n        workflowOptions: {\n          projenCredentials: GithubCredentials.fromPersonalAccessToken({\n            secret: 'GITHUB_TOKEN',\n          }),\n        },\n      },\n      readme: {\n        contents: readmeContents(options.name),\n      },\n    });\n\n\n    // Create standard project files\n    const PRIMARY_ACCOUNT = '015955817263';\n    const PRIMARY_REGION = 'us-east-1';\n\n    new Application(this, {\n      githubRepository: `macedon-technologies/${options.name}`,\n      dev: {\n        ...options.dev,\n      },\n      staging: {\n        ...options.staging,\n      },\n      prod: {\n        ...options.dev,\n      },\n      additionalTags: options.additionalTags,\n      n8nWorkflows: options.n8nWorkflows,\n      actionVersions: options.actionVersions,\n      authorizerObjectVersion: options.authorizerObjectVersion,\n    });\n\n    new GitHubRolesFile(this, {\n      account: PRIMARY_ACCOUNT,\n      primaryRegion: PRIMARY_REGION,\n    });\n\n    new CodeOwnersFile(this, {\n      additionalOwners: options.additionalCodeOwners,\n    });\n\n    new DataDogAspectFile(this);\n\n    const viteReact = new ViteReactProject({\n      name: options.name,\n      defaultReleaseBranch: 'main',\n      parent: this,\n      outdir: 'web',\n      deps: options.websiteDeps,\n    });\n    viteReact.addConfigField('something', 'number');\n    viteReact.addConfigField('somethingElse', 'string');\n\n    const concurrently = (...args: string[]) => {\n      return `concurrently ${args.map(a => `\"${a}\"`).join(' ')}`;\n    };\n\n    this.addTask('dev', {\n      exec: concurrently(\n        'nodemon --watch ./src/constructs/handler --watch ./local/dev.ts ./local/dev.ts',\n        viteReact.devCommand,\n      ),\n    });\n\n    this.addTask('cdk:dev', {\n      exec: 'cdk -a \"npx ts-node -P tsconfig.json --prefer-ts-exts src/LocalDevApp.ts\"',\n      receiveArgs: true,\n    });\n\n\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BatmanProject.js","sourceRoot":"","sources":["../src/BatmanProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsCdkTypeScriptApp, AwsCdkTypeScriptAppOptions } from 'projen/lib/awscdk';\nimport { GithubCredentials } from 'projen/lib/github';\nimport { Application, ApplicationEnvironmentConfig } from './Application';\nimport { CodeOwnersFile } from './CodeOwnersFile';\nimport { DataDogAspectFile } from './DataDogAspectFile';\nimport { GitHubRolesFile } from './GitHubRolesFile';\nimport { SoftwareFactoryFiles } from './SoftwareFactoryFiles';\nimport { readmeContents } from './utils';\nimport { ViteReactProject } from './ViteReactProject';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\n\nexport interface BatmanProjectOptions extends AwsCdkTypeScriptAppOptions {\n\n  /**\n   * Development environment configuration\n   */\n  readonly dev: ApplicationEnvironmentConfig;\n\n  /**\n   * Development environment configuration\n   */\n  readonly staging: ApplicationEnvironmentConfig;\n\n  /**\n   * Production environment configuration\n   */\n  readonly prod: ApplicationEnvironmentConfig;\n\n  /**\n   * Additional tags to apply to all stacks\n   */\n  readonly additionalTags?: { [key: string]: string };\n\n  /**\n   * Enable n8n workflow auto-discovery and WorkflowProvider generation\n   */\n  readonly n8nWorkflows?: boolean;\n\n  /**\n   * Additional code owners to add to the CODEOWNERS file\n   */\n  readonly additionalCodeOwners?: string[];\n\n  /**\n   * Website dependencies\n   */\n  readonly websiteDeps?: string[];\n\n  /**\n   * Overrides for the pinned action versions used by the generated GitHub Actions workflows.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n\n  /**\n   * Overrides the pinned S3 object version of the clerk-authorizer Lambda deployment package.\n   *\n   * @default - the default pinned in ApiConstructFile\n   */\n  readonly authorizerObjectVersion?: string;\n}\n\n\nexport class BatmanProject extends AwsCdkTypeScriptApp {\n  constructor(options: BatmanProjectOptions) {\n    super({\n      ...options,\n      cdkVersion: options.cdkVersion || '2.224.0',\n      defaultReleaseBranch: options.defaultReleaseBranch || 'main',\n      name: options.name,\n      projenrcTs: true,\n      buildWorkflow: false,\n      deps: [\n        '@types/aws-lambda',\n        '@types/express',\n        '@types/pg',\n        'pg',\n        '@aws-sdk/rds-signer',\n        '@matthewbonig/secret',\n        'datadog-cdk-constructs-v2',\n        '@cdklabs/aws-lambda-rust',\n        '@aws-lambda-powertools/parameters',\n        'jsonwebtoken',\n        '@aws-sdk/client-secrets-manager',\n        'express',\n        'serverless-http',\n        ...options.deps || [],\n      ],\n      devDeps: [\n        '@types/jsonwebtoken',\n        'nodemon',\n        'concurrently',\n        '@macedon-technologies/batman@^1.0.0',\n        ...options.devDeps || [],\n      ],\n      gitignore: [\n        'src/constructs/handler/clerk-authorizer/target/**',\n        '**/.DS_Store',\n        ...options.gitignore || [],\n      ],\n      tsconfig: {\n        ...options.tsconfig,\n        compilerOptions: {\n          ...options.tsconfig?.compilerOptions,\n          isolatedModules: true,\n          allowImportingTsExtensions: true,\n        },\n      },\n      sampleCode: false,\n      minNodeVersion: options.minNodeVersion || '22',\n      depsUpgradeOptions: {\n        workflowOptions: {\n          projenCredentials: GithubCredentials.fromPersonalAccessToken({\n            secret: 'GITHUB_TOKEN',\n          }),\n        },\n      },\n      readme: {\n        contents: readmeContents(options.name),\n      },\n    });\n\n\n    // Create standard project files\n    const PRIMARY_ACCOUNT = '015955817263';\n    const PRIMARY_REGION = 'us-east-1';\n\n    new Application(this, {\n      githubRepository: `macedon-technologies/${options.name}`,\n      dev: {\n        ...options.dev,\n      },\n      staging: {\n        ...options.staging,\n      },\n      prod: {\n        ...options.dev,\n      },\n      additionalTags: options.additionalTags,\n      n8nWorkflows: options.n8nWorkflows,\n      actionVersions: options.actionVersions,\n      authorizerObjectVersion: options.authorizerObjectVersion,\n    });\n\n    new GitHubRolesFile(this, {\n      account: PRIMARY_ACCOUNT,\n      primaryRegion: PRIMARY_REGION,\n    });\n\n    new CodeOwnersFile(this, {\n      additionalOwners: options.additionalCodeOwners,\n    });\n\n    new DataDogAspectFile(this);\n\n    new SoftwareFactoryFiles(this, {\n      repoName: options.name,\n      baseBranch: options.defaultReleaseBranch,\n      actionVersions: options.actionVersions,\n    });\n\n    const viteReact = new ViteReactProject({\n      name: options.name,\n      defaultReleaseBranch: 'main',\n      parent: this,\n      outdir: 'web',\n      deps: options.websiteDeps,\n    });\n    viteReact.addConfigField('something', 'number');\n    viteReact.addConfigField('somethingElse', 'string');\n\n    const concurrently = (...args: string[]) => {\n      return `concurrently ${args.map(a => `\"${a}\"`).join(' ')}`;\n    };\n\n    this.addTask('dev', {\n      exec: concurrently(\n        'nodemon --watch ./src/constructs/handler --watch ./local/dev.ts ./local/dev.ts',\n        viteReact.devCommand,\n      ),\n    });\n\n    this.addTask('cdk:dev', {\n      exec: 'cdk -a \"npx ts-node -P tsconfig.json --prefer-ts-exts src/LocalDevApp.ts\"',\n      receiveArgs: true,\n    });\n\n\n  }\n}\n"]}