@stripe/extensibility-dev-tools 0.23.5

package/dist/templates/index.js

@@ -0,0 +1,2203 @@
+// src/templates/template-manager.ts
+import { _TemplateManager } from "@stripe/extensibility-tool-utils";
+
+// src/templates/fs/in-memory.ts
+import { _createInMemoryTemplateFS } from "@stripe/extensibility-tool-utils";
+
+// templates-virtual:./_impl.js
+var TEMPLATE_FS_IMAGE = [
+  {
+    path: "extensions/billing.bill.discount_calculation/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyDiscountCalculation from './index.js';
+
+describe('MyDiscountCalculation', () => {
+  let instance: MyDiscountCalculation;
+
+  beforeEach(() => {
+    instance = new MyDiscountCalculation();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyDiscountCalculation);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.bill.discount_calculation/index.ts",
+    content: `import type { Billing } from '@stripe/extensibility-sdk/extensions';
+import type { Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyDiscountCalculationConfig extends Record<string, unknown> {}
+
+export default class MyDiscountCalculation implements Billing.Bill
+  .DiscountCalculation<MyDiscountCalculationConfig> {
+  computeDiscounts(
+    request: Billing.Bill.DiscountCalculation.DiscountableItem,
+    _config: MyDiscountCalculationConfig,
+    _context: Context
+  ) {
+    // TODO: implement your discount logic here
+
+    return {
+      discount: { amount: request.grossAmount },
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/billing.customer_balance_application/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyCustomerBalanceApplication from './index.js';
+
+describe('MyCustomerBalanceApplication', () => {
+  let instance: MyCustomerBalanceApplication;
+
+  beforeEach(() => {
+    instance = new MyCustomerBalanceApplication();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyCustomerBalanceApplication);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.customer_balance_application/index.ts",
+    content: `import type { Billing, Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyCustomerBalanceApplicationConfig extends Record<string, unknown> {}
+
+export default class MyCustomerBalanceApplication implements Billing.CustomerBalanceApplication<MyCustomerBalanceApplicationConfig> {
+  computeAppliedCustomerBalance(
+    request: Billing.CustomerBalanceApplication.CustomerBalanceApplicationInput,
+    _config: MyCustomerBalanceApplicationConfig,
+    _context: Context
+  ) {
+    // TODO: implement your customer balance logic here
+
+    return {
+      appliedCustomerBalance: request.customerBalance,
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/billing.invoice_collection_setting/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyInvoiceCollectionSetting from './index.js';
+
+describe('MyInvoiceCollectionSetting', () => {
+  let instance: MyInvoiceCollectionSetting;
+
+  beforeEach(() => {
+    instance = new MyInvoiceCollectionSetting();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyInvoiceCollectionSetting);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.invoice_collection_setting/index.ts",
+    content: `import type { Billing, Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyInvoiceCollectionSettingConfig extends Record<string, unknown> {}
+
+export default class MyInvoiceCollectionSetting implements Billing.InvoiceCollectionSetting<MyInvoiceCollectionSettingConfig> {
+  collectionOverride(
+    _request: Billing.InvoiceCollectionSetting.InvoiceCollectionRequest,
+    _config: MyInvoiceCollectionSettingConfig,
+    _context: Context
+  ) {
+    // TODO: implement your collection setting logic here
+
+    return {};
+  }
+}
+`
+  },
+  {
+    path: "extensions/billing.prorations/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyProrations from './index.js';
+
+describe('MyProrations', () => {
+  let instance: MyProrations;
+
+  beforeEach(() => {
+    instance = new MyProrations();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyProrations);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.prorations/index.ts",
+    content: `import type { Billing, Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyProrationsConfig extends Record<string, unknown> {}
+
+export default class MyProrations implements Billing.Prorations<MyProrationsConfig> {
+  prorateItems(
+    _request: Billing.Prorations.ProrateItemsInput,
+    _config: MyProrationsConfig,
+    _context: Context
+  ) {
+    // TODO: implement your proration logic here
+
+    return {
+      items: [],
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/billing.recurring_billing_item_handling/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyRecurringBillingItemHandling from './index.js';
+
+describe('MyRecurringBillingItemHandling', () => {
+  let instance: MyRecurringBillingItemHandling;
+
+  beforeEach(() => {
+    instance = new MyRecurringBillingItemHandling();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyRecurringBillingItemHandling);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.recurring_billing_item_handling/index.ts",
+    content: `import type { Billing, Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyRecurringBillingItemHandlingConfig extends Record<string, unknown> {}
+
+export default class MyRecurringBillingItemHandling implements Billing.RecurringBillingItemHandling<MyRecurringBillingItemHandlingConfig> {
+  beforeItemCreation(
+    _request: Billing.RecurringBillingItemHandling.BeforeItemCreationInput,
+    _config: MyRecurringBillingItemHandlingConfig,
+    _context: Context
+  ) {
+    // TODO: implement your before-item-creation logic here
+
+    return {
+      items: [],
+    };
+  }
+
+  filterItems(
+    _request: Billing.RecurringBillingItemHandling.FilterItemsInput,
+    _config: MyRecurringBillingItemHandlingConfig,
+    _context: Context
+  ) {
+    // TODO: implement your filter-items logic here
+
+    return {
+      items: [],
+    };
+  }
+
+  groupItems(
+    _request: Billing.RecurringBillingItemHandling.GroupItemsInput,
+    _config: MyRecurringBillingItemHandlingConfig,
+    _context: Context
+  ) {
+    // TODO: implement your group-items logic here
+
+    return {
+      groups: [],
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/common/.prettierignore",
+    content: `dist
+generated
+node_modules
+`
+  },
+  {
+    path: "extensions/common/eslint.config.mts.mustache",
+    content: `import eslint from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+import eslintConfigPrettier from 'eslint-config-prettier/flat';
+
+import globals from 'globals';
+
+import stripeAppsConfig from '@stripe/extensibility-eslint-plugin';
+import extensionTypeConfig from '@stripe/extensibility-eslint-plugin/{{extensionInterfaceId}}';
+
+export default defineConfig([
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  ...stripeAppsConfig,
+  ...extensionTypeConfig,
+
+  // Global ignores
+  {
+    ignores: ['dist', 'generated', 'node_modules'],
+  },
+
+  // TypeScript source files (with type-checking)
+  {
+    name: 'sources',
+    files: ['src/**/*.ts'],
+    ignores: ['**/*.test.ts', '**/__tests__/**'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+
+  // Test files (type-checking, relaxed rules)
+  {
+    name: 'tests',
+    files: ['src/**/*.test.ts', 'src/**/__tests__/**/*.ts'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      'no-console': 'off',
+    },
+  },
+
+  // Config files
+  {
+    name: 'ts-configs',
+    files: ['*.config.m?ts', 'eslint.config.mts'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: false,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-unused-vars': 'off',
+    },
+  },
+
+  // JavaScript/MJS files (scripts, configs)
+  {
+    name: 'js-configs',
+    files: ['**/*.js', '**/*.mjs'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: false,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      'no-unused-vars': 'off',
+    },
+  },
+
+  eslintConfigPrettier,
+]);
+`
+  },
+  {
+    path: "extensions/common/package.json.mustache",
+    content: `{
+  "name": "{{id}}",
+  "version": "{{version}}",
+  "description": "{{name}}",
+  "private": true,
+  "license": "~~proprietary~~",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && pnpm build:schemas",
+    "build:schemas": "gen-schemas --root ../.. --extension-id \\"$npm_package_name\\" --out-dir generated --schema-name config",
+    "lint": "pnpm lint:types && pnpm lint:eslint && pnpm lint:format",
+    "lint:types": "tsc -p tsconfig.build.json --noEmit && tsc -p tsconfig.json --noEmit",
+    "lint:eslint": "eslint .",
+    "lint:format": "prettier --check .",
+    "fix:lint": "eslint --fix .",
+    "fix:format": "prettier --write .",
+    "test": "vitest --root ../.. run --project \\"$npm_package_name\\"",
+    "test:watch": "pnpm test --watch",
+    "dev": "concurrently -n build,lint,test -c blue,yellow,green 'tsc -p tsconfig.json -w --noEmit' 'chokidar \\"src/**/*.{ts,json}\\" -c \\"eslint .\\"' 'pnpm test --watch --no-clear-screen'",
+    "stripe:regen": "gen-workspace --root ../.. --package-dir . --template-id {{extensionInterfaceId}}"
+  },
+  "lint-staged": {
+    "*.{ts,mts,mjs,js}": ["eslint --fix", "prettier --write"],
+    "*.{json,md,yaml}": "prettier --write"
+  }
+}
+`
+  },
+  {
+    path: "extensions/common/tsconfig.build.json.mustache",
+    content: `{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": null,
+    "noLib": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": [
+    "src/**/*.ts",
+    "node_modules/@stripe/extensibility-sdk/tslibs/5.9.3/lib.es2022.{{executionProfile}}.d.ts",
+    "node_modules/@stripe/extensibility-sdk/tslibs/lib.{{executionProfile}}.globals.d.ts"
+  ],
+  "exclude": ["src/**/*.test.ts", "src/**/__tests__"]
+}
+`
+  },
+  {
+    path: "extensions/common/tsconfig.json.mustache",
+    content: `{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "plugins": [
+      {
+        "name": "@stripe/extensibility-language-server/plugin"
+      }
+    ]
+  },
+  "include": [
+    "src/**/*.ts",
+    "node_modules/@stripe/extensibility-sdk/tslibs/lib.{{executionProfile}}.globals.d.ts"
+  ],
+  "exclude": ["dist"]
+}
+`
+  },
+  {
+    path: "extensions/core.workflows.custom_action/custom_input.schema.json",
+    content: `{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {},
+  "additionalProperties": false
+}
+`
+  },
+  {
+    path: "extensions/core.workflows.custom_action/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyCustomAction from './index.js';
+
+describe('MyCustomAction', () => {
+  let instance: MyCustomAction;
+
+  beforeEach(() => {
+    instance = new MyCustomAction();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyCustomAction);
+  });
+});
+`
+  },
+  {
+    path: "extensions/core.workflows.custom_action/index.ts",
+    content: `import type { Core } from '@stripe/extensibility-sdk/extensions';
+import type { Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyCustomActionConfig extends Record<string, unknown> {}
+
+export default class MyCustomAction implements Core.Workflows
+  .CustomAction<MyCustomActionConfig> {
+  execute(
+    _request: Core.Workflows.CustomAction.ExecuteCustomActionRequest,
+    _config: MyCustomActionConfig,
+    _context: Context
+  ) {
+    // TODO: implement your action logic here
+
+    return {};
+  }
+
+  getFormState(
+    _request: Core.Workflows.CustomAction.GetFormStateRequest,
+    _config: MyCustomActionConfig,
+    _context: Context
+  ) {
+    // TODO: implement your logic here
+
+    return {
+      values: {},
+      config: {},
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/extend.workflows.custom_action/custom_input.schema.json",
+    content: `{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {},
+  "additionalProperties": false
+}
+`
+  },
+  {
+    path: "extensions/extend.workflows.custom_action/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyCustomAction from './index.js';
+
+describe('MyCustomAction', () => {
+  let instance: MyCustomAction;
+
+  beforeEach(() => {
+    instance = new MyCustomAction();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyCustomAction);
+  });
+});
+`
+  },
+  {
+    path: "extensions/extend.workflows.custom_action/index.ts",
+    content: `import type { Extend } from '@stripe/extensibility-sdk/extensions';
+import type { Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyCustomActionConfig extends Record<string, unknown> {}
+
+export default class MyCustomAction implements Extend.Workflows
+  .CustomAction<MyCustomActionConfig> {
+  execute(
+    _request: Extend.Workflows.CustomAction.ExecuteCustomActionRequest,
+    _config: MyCustomActionConfig,
+    _context: Context
+  ) {
+    // TODO: implement your action logic here
+
+    return {};
+  }
+
+  getFormState(
+    _request: Extend.Workflows.CustomAction.GetFormStateRequest,
+    _config: MyCustomActionConfig,
+    _context: Context
+  ) {
+    // TODO: implement your logic here
+
+    return {
+      values: {},
+      config: {},
+    };
+  }
+}
+`
+  },
+  {
+    path: "root/.husky/pre-commit",
+    content: `pnpm lint-staged
+`
+  },
+  {
+    path: "root/.prettierignore",
+    content: `dist
+generated
+node_modules
+pnpm-lock.yaml
+.build
+`
+  },
+  {
+    path: "root/.prettierrc",
+    content: `{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "es5",
+  "printWidth": 90
+}
+`
+  },
+  {
+    path: "root/_gitignore",
+    content: `# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+*~
+
+# dependencies
+node_modules
+dist
+
+# testing
+/coverage
+
+# production
+/.build
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+install-deps.log
+
+# generated schemas
+generated
+`
+  },
+  {
+    path: "root/custom-objects/package.json",
+    content: `{
+  "name": "custom-objects",
+  "type": "module",
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "private": true,
+  "scripts": {
+    "build": "test -d src && custom-objects-build --input src --output dist || true",
+    "lint:types": "test ! -d src || tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@stripe/extensibility-custom-objects": "0.7.4",
+    "@stripe/extensibility-sdk": "0.22.4"
+  },
+  "devDependencies": {
+    "@stripe/extensibility-custom-objects-tools": "0.40.0",
+    "@stripe/extensibility-test-helpers": "0.2.7"
+  }
+}
+`
+  },
+  {
+    path: "root/custom-objects/tsconfig.json",
+    content: `{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "types": ["vitest/globals"]
+  },
+  "exclude": ["dist"]
+}
+`
+  },
+  {
+    path: "root/eslint.config.mts",
+    content: `import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import eslint from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+import workspaces from 'eslint-plugin-workspaces';
+import eslintConfigPrettier from 'eslint-config-prettier/flat';
+
+import globals from 'globals';
+
+import stripeAppsConfig from '@stripe/extensibility-eslint-plugin';
+
+// Read additional ignore globs from package.json (written by the generate plugin
+// to exclude generated SDK directories from linting).
+let stripeGlobsToIgnore: string[] = [];
+try {
+  const configDir = dirname(fileURLToPath(import.meta.url));
+  const packageJsonPath = resolve(configDir, './package.json');
+  const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  const globs = pkg?.stripe?.eslintIgnoreGlobs;
+  if (Array.isArray(globs)) {
+    stripeGlobsToIgnore = globs.filter(
+      (g: unknown): g is string => typeof g === 'string'
+    );
+  }
+} catch {
+  // package.json not found or unparseable \u2014 ignore
+}
+
+export default defineConfig([
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  ...stripeAppsConfig,
+
+  // Global ignores
+  {
+    ignores: [
+      '.build',
+      '**/dist',
+      '**/generated',
+      '**/node_modules',
+      'extensions/**',
+      'custom-objects',
+      'ui',
+      ...stripeGlobsToIgnore,
+    ],
+  },
+
+  // Common rules for all files
+  {
+    plugins: { workspaces },
+    rules: {
+      ...workspaces.configs.recommended.rules,
+    },
+  },
+
+  // Config files (vitest.config.ts, eslint.config.ts, etc.)
+  {
+    name: 'ts-configs',
+    files: ['extensions/*/*.config.m?ts', '*.config.m?ts', 'eslint.config.mts'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: false,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-unused-vars': 'off',
+    },
+  },
+
+  // JavaScript/MJS files (scripts, configs)
+  {
+    name: 'js-configs',
+    files: ['**/*.js', '**/*.mjs'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: false,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      'no-unused-vars': 'off',
+    },
+  },
+
+  eslintConfigPrettier,
+]);
+`
+  },
+  {
+    path: "root/package.json.mustache",
+    content: `{
+  "name": "{{ appId }}",
+  "version": "{{ version }}",
+  "description": "{{ appName }}",
+  "private": true,
+  "license": "~~proprietary~~",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "packageManager": "pnpm@10.30.3",
+  "scripts": {
+    "build": "pnpm -r --if-present build",
+    "lint": "pnpm lint:types && pnpm lint:eslint && pnpm lint:format",
+    "lint:types": "pnpm -r --if-present lint:types",
+    "lint:eslint": "eslint . --ignore-pattern 'extensions/**' && pnpm -r --filter './extensions/*' --if-present lint:eslint",
+    "lint:format": "prettier --check .",
+    "fix:lint": "eslint --fix . --ignore-pattern 'extensions/**' && pnpm -r --filter './extensions/*' --if-present fix:lint",
+    "fix:format": "prettier --write .",
+    "test": "tsx tools/test.mts",
+    "test:watch": "vitest watch",
+    "check": "pnpm build && pnpm lint && pnpm test",
+    "prepare": "husky",
+    "preimage": "pnpm install --lockfile-only && pnpm build && pnpm lint:types && pnpm lint:eslint && pnpm test",
+    "image": "rm -rf .build && create-upload-image .build",
+    "postimage": "cp pnpm-lock.yaml .build/",
+    "stripe:regen": "gen-workspace --package-dir ."
+  },
+  "lint-staged": {
+    "*.{ts,mts,mjs,js}": ["eslint --fix", "prettier --write"],
+    "*.{json,md,yaml}": "prettier --write"
+  }
+}
+`
+  },
+  {
+    path: "root/pnpm-workspace.yaml",
+    content: `packages:
+  - extensions/*
+  - custom-objects
+  - ui
+
+overrides:
+  vite: ^6.0.0
+`
+  },
+  {
+    path: "root/stripe-app.yaml.mustache",
+    content: `$schema: https://stripe.com/stripe-app/v2.0.0/schema
+id: '{{ appId }}'
+name: '{{ appName }}'
+version: 0.0.1
+declarations:
+  distribution_type: private
+`
+  },
+  {
+    path: "root/tools/test.mts",
+    content: `#!/usr/bin/env tsx
+/**
+ * Runs tests across the workspace:
+ * - vitest for script extensions and custom objects (extensions/*)
+ * - jest for UI extensions (ui/)
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+
+const hasExtensions =
+  existsSync('extensions') &&
+  readdirSync('extensions').some((name) => existsSync(\`extensions/\${name}/package.json\`));
+
+const hasUI = existsSync('ui/package.json');
+
+let exitCode = 0;
+
+function run(cmd: string): void {
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+  } catch (e: unknown) {
+    exitCode = (e as NodeJS.ErrnoException & { status?: number }).status ?? 1;
+  }
+}
+
+if (hasExtensions) {
+  run('vitest run');
+}
+
+if (hasUI) {
+  try {
+    execSync('pnpm --filter "./ui" test', { stdio: 'inherit' });
+  } catch {
+    // UI test failures are non-fatal
+  }
+}
+
+process.exit(exitCode);
+`
+  },
+  {
+    path: "root/tsconfig.base.json",
+    content: `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "exactOptionalPropertyTypes": false,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "removeComments": false,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "types": [],
+    "verbatimModuleSyntax": true
+  }
+}
+`
+  },
+  {
+    path: "root/tsconfig.json",
+    content: `{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "plugins": [
+      {
+        "name": "@stripe/extensibility-language-server/plugin"
+      }
+    ],
+    "preserveWatchOutput": true,
+    "types": ["vitest/globals", "node"]
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["**/node_modules", "**/dist"]
+}
+`
+  },
+  {
+    path: "root/ui/package.json",
+    content: `{
+  "name": "ui",
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "private": true,
+  "scripts": {
+    "test": "jest --passWithNoTests"
+  },
+  "dependencies": {
+    "@stripe/ui-extension-sdk": "^9.1.0"
+  },
+  "devDependencies": {
+    "@stripe/ui-extension-tools": "^0.0.1",
+    "@types/jest": "^27.5.2",
+    "@types/react": "^17.0.2"
+  }
+}
+`
+  },
+  {
+    path: "root/vitest.config.mts",
+    content: `import { defineConfig } from 'vitest/config';
+import { existsSync, readdirSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const rootDir = dirname(fileURLToPath(import.meta.url));
+const extensionsDir = resolve(rootDir, 'extensions');
+
+const extensionProjects = existsSync(extensionsDir)
+  ? readdirSync(extensionsDir)
+      .filter((name) => existsSync(resolve(extensionsDir, name, 'package.json')))
+      .map((name) => resolve(extensionsDir, name))
+  : [];
+
+const coProjects = existsSync(resolve(rootDir, 'custom-objects/package.json'))
+  ? [resolve(rootDir, 'custom-objects')]
+  : [];
+
+const projects = [...extensionProjects, ...coProjects];
+
+if (projects.length === 0) {
+  console.debug(\`No vitest projects detected. This means either:
+- You have no extension projects defined, in which case this warning is expected.
+- There is an internal error detecting vitest projects relative to the project root
+  \${rootDir}.
+\`);
+}
+
+export default projects.length > 0
+  ? defineConfig({
+      test: {
+        projects,
+        passWithNoTests: true,
+
+        // Only run tests from src, not compiled dist
+        exclude: ['**/node_modules', '**/dist'],
+        // Place snapshots alongside test files instead of in __snapshots__
+        snapshotFormat: {
+          escapeString: false,
+          printBasicPrototype: false,
+        },
+        resolveSnapshotPath: (testPath, snapExtension) => {
+          return testPath.replace(/\\.test\\.ts$/, \`.test\${snapExtension}\`);
+        },
+      },
+    })
+  : defineConfig({ test: { passWithNoTests: true, include: [] } });
+`
+  }
+];
+var _fs = _createInMemoryTemplateFS(TEMPLATE_FS_IMAGE);
+
+// src/templates/simple-templates.ts
+import {
+  _createSimpleTemplate,
+  _SingleTemplateManager,
+  _createSimpleSingleFileTemplate
+} from "@stripe/extensibility-tool-utils";
+
+// src/templates/file-writer.ts
+import path from "path";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import { createInterface } from "readline";
+import { _createLogger } from "@stripe/extensibility-tool-utils";
+
+// src/templates/fs-utils.ts
+import { stat } from "fs/promises";
+async function pathExists(filePath, predicate) {
+  try {
+    const stats = await stat(filePath);
+    return predicate(stats);
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function fileExists(filePath) {
+  return pathExists(filePath, (stats) => stats.isFile());
+}
+async function directoryExists(dirPath) {
+  return pathExists(dirPath, (stats) => stats.isDirectory());
+}
+
+// src/templates/file-writer.ts
+var logger = _createLogger({ name: "file-writer" });
+async function _promptOverwrite(filePath) {
+  const prompt = `${filePath} exists. Overwrite [yNaq]? `;
+  if (!process.stdin.isTTY) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer) => {
+        rl.close();
+        const normalized = answer.toLowerCase().trim();
+        switch (normalized) {
+          case "y":
+          case "yes":
+            resolve("overwrite");
+            break;
+          case "n":
+          case "no":
+          case "":
+            resolve("skip");
+            break;
+          case "a":
+          case "all":
+            resolve("overwrite-all");
+            break;
+          case "q":
+          case "quit":
+            resolve("abort");
+            break;
+          default:
+            logger.warn("Invalid input '%s', treating as 'no'", answer);
+            resolve("skip");
+        }
+      });
+    });
+  }
+  process.stdout.write(prompt);
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onData = (buffer) => {
+      stdin.setRawMode(wasRaw || false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      const key = buffer.toString();
+      const code = buffer[0];
+      if (code === 3) {
+        process.stdout.write("\nCancelled.\n");
+        setTimeout(() => process.exit(0), 100);
+        return;
+      }
+      if (code === 13 || code === 10) {
+        process.stdout.write("n\n");
+        resolve("skip");
+        return;
+      }
+      const normalized = key.toLowerCase();
+      let decision;
+      switch (normalized) {
+        case "y":
+          process.stdout.write("y\n");
+          decision = "overwrite";
+          break;
+        case "n":
+          process.stdout.write("n\n");
+          decision = "skip";
+          break;
+        case "a":
+          process.stdout.write("a\n");
+          decision = "overwrite-all";
+          break;
+        case "q":
+          process.stdout.write("q\n");
+          decision = "abort";
+          break;
+        default:
+          process.stdout.write(`${key}
+`);
+          logger.warn("Invalid input '%s', treating as 'no'", key);
+          decision = "skip";
+      }
+      resolve(decision);
+    };
+    stdin.on("data", onData);
+  });
+}
+async function _writeGeneratedFiles(files, options = {}) {
+  const { cwd = process.cwd(), onFileWritten, onFileSkipped, onFileIdentical } = options;
+  let write = options.write ?? "abort-if-existing";
+  const existing = [];
+  for (const file of files) {
+    const fullPath = path.join(cwd, file.path);
+    if (await fileExists(fullPath)) {
+      existing.push(file.path);
+    }
+  }
+  if (existing.length > 0 && write === "abort-if-existing") {
+    if (onFileSkipped) {
+      for (const file of files) {
+        if (existing.includes(file.path)) {
+          onFileSkipped(file);
+        }
+      }
+    }
+    return {
+      written: [],
+      existing,
+      skipped: true,
+      aborted: false
+    };
+  }
+  const written = [];
+  for (const file of files) {
+    const fullPath = path.join(cwd, file.path);
+    const fileDir = path.dirname(fullPath);
+    const isExisting = existing.includes(file.path);
+    if (isExisting) {
+      const existingContent = await readFile(fullPath, "utf-8");
+      if (existingContent === file.content) {
+        if (onFileIdentical) {
+          onFileIdentical(file);
+        }
+        continue;
+      }
+    }
+    if (isExisting && (write === "if-missing" || file.precious)) {
+      if (onFileSkipped) {
+        onFileSkipped(file);
+      }
+      continue;
+    }
+    if (isExisting && typeof write === "function") {
+      const decision = await write(file.path, cwd, file.content);
+      switch (decision) {
+        case "skip":
+          if (onFileSkipped) {
+            onFileSkipped(file);
+          }
+          continue;
+        case "overwrite":
+          break;
+        case "overwrite-all":
+          write = "overwrite-all";
+          break;
+        case "abort":
+          return {
+            written,
+            existing,
+            skipped: false,
+            aborted: true
+          };
+      }
+    }
+    if (!await directoryExists(fileDir)) {
+      await mkdir(fileDir, { recursive: true });
+    }
+    await writeFile(fullPath, file.content, "utf-8");
+    if (onFileWritten) {
+      onFileWritten(file, isExisting);
+    }
+    written.push(file.path);
+  }
+  return {
+    written,
+    existing,
+    // Always populated; write='abort-if-existing' returns early above
+    skipped: false,
+    aborted: false
+  };
+}
+
+// src/templates/diff-viewer/diff-prompt.ts
+import path2 from "path";
+
+// src/templates/diff-viewer/diff-generator.ts
+import { createPatch } from "diff";
+import { readFile as readFile2 } from "fs/promises";
+async function generateDiff(filePath, oldContent, newContent, contextLines = 3) {
+  if (isBinary(oldContent) || isBinary(newContent)) {
+    return {
+      lines: [{ type: "header", text: "Binary file changed" }],
+      oldFileName: filePath,
+      newFileName: filePath,
+      isBinary: true
+    };
+  }
+  const patch = createPatch(filePath, oldContent, newContent, "existing", "new", {
+    context: contextLines
+  });
+  const lines = parsePatch(patch);
+  return {
+    lines,
+    oldFileName: filePath,
+    newFileName: filePath,
+    isBinary: false
+  };
+}
+function parsePatch(patch) {
+  const lines = [];
+  const patchLines = patch.split("\n");
+  let oldLine = 0;
+  let newLine = 0;
+  for (const line of patchLines) {
+    if (line.startsWith("@@")) {
+      const match = line.match(/@@ -(\d+),?\d* \+(\d+),?\d* @@/);
+      if (match !== null) {
+        oldLine = parseInt(match[1], 10);
+        newLine = parseInt(match[2], 10);
+        lines.push({ type: "header", text: line });
+      }
+    } else if (line.startsWith("+")) {
+      lines.push({ type: "add", text: line, newLine: newLine++ });
+    } else if (line.startsWith("-")) {
+      lines.push({ type: "remove", text: line, oldLine: oldLine++ });
+    } else if (line.startsWith(" ")) {
+      lines.push({
+        type: "context",
+        text: line,
+        oldLine: oldLine++,
+        newLine: newLine++
+      });
+    } else if (line.startsWith("\\")) {
+      lines.push({ type: "context", text: line });
+    }
+  }
+  return lines;
+}
+function isBinary(content) {
+  return content.includes("\0");
+}
+async function readExistingFile(resolvedPath) {
+  try {
+    return await readFile2(resolvedPath, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return "";
+    }
+    throw err;
+  }
+}
+
+// src/templates/diff-viewer/terminal-renderer.ts
+import { execSync } from "child_process";
+import stringWidth from "string-width";
+var ANSI = {
+  // Colors
+  RED: "\x1B[31m",
+  GREEN: "\x1B[32m",
+  CYAN: "\x1B[36m",
+  GRAY: "\x1B[90m",
+  RESET: "\x1B[0m",
+  // Text styles
+  BOLD: "\x1B[1m",
+  DIM: "\x1B[2m"
+};
+var BOX_HORIZONTAL = "\u2500";
+function render(state, filePath, clearPrevious = false) {
+  const maxTotalHeight = Math.floor(state.terminalHeight * 0.75);
+  const maxContentHeight = maxTotalHeight - 3;
+  const contentHeight = state.diffLines.length;
+  const windowHeight = Math.min(contentHeight, maxContentHeight);
+  const visibleLines = state.diffLines.slice(
+    state.scrollOffset,
+    state.scrollOffset + windowHeight
+  );
+  const totalLines = state.diffLines.length;
+  const startLine = state.scrollOffset + 1;
+  const endLine = state.scrollOffset + visibleLines.length;
+  if (clearPrevious && state.renderedHeight > 0) {
+    clearPreviousRender(state.renderedHeight - 1);
+  }
+  let output = "";
+  output += renderTopBar(filePath, state.terminalWidth) + "\n";
+  for (const line of visibleLines) {
+    output += colorize(line, state.terminalWidth) + "\n";
+  }
+  output += renderBottomBar(startLine, endLine, totalLines, state, state.terminalWidth) + "\n";
+  output += "\n";
+  output += `overwrite ${filePath} [yNaqd]? `;
+  state.renderedHeight = 1 + visibleLines.length + 1 + 1 + 1;
+  process.stdout.write(output);
+}
+function clearPreviousRender(lines) {
+  process.stdout.write(`\x1B[${lines}A`);
+  process.stdout.write("\r");
+  process.stdout.write("\x1B[0J");
+}
+function renderTopBar(filePath, width) {
+  const prefix = BOX_HORIZONTAL.repeat(3) + " ";
+  const suffix = " " + BOX_HORIZONTAL.repeat(3);
+  const availableWidth = width - stringWidth(prefix) - stringWidth(suffix);
+  let displayName = filePath;
+  if (stringWidth(displayName) + 1 > availableWidth) {
+    while (stringWidth("..." + displayName) + 1 > availableWidth && displayName.length > 0) {
+      displayName = displayName.slice(1);
+    }
+    displayName = "..." + displayName;
+  }
+  const paddingLength = Math.max(0, availableWidth - stringWidth(displayName) - 1);
+  const padding = BOX_HORIZONTAL.repeat(paddingLength);
+  return ANSI.CYAN + prefix + ANSI.BOLD + displayName + ANSI.RESET + " " + ANSI.CYAN + padding + suffix + ANSI.RESET;
+}
+function renderBottomBar(startLine, endLine, totalLines, _state, width) {
+  const prefix = BOX_HORIZONTAL.repeat(3) + " ";
+  const positionIndicator = `${startLine}-${endLine}/${totalLines}`;
+  const content = positionIndicator;
+  const suffix = " " + BOX_HORIZONTAL.repeat(3);
+  const availableWidth = width - stringWidth(prefix) - stringWidth(suffix);
+  const paddingLength = Math.max(0, availableWidth - stringWidth(content));
+  const padding = BOX_HORIZONTAL.repeat(paddingLength);
+  return ANSI.CYAN + prefix + ANSI.RESET + ANSI.DIM + content + ANSI.RESET + ANSI.CYAN + padding + suffix + ANSI.RESET;
+}
+function clearDiffWindow() {
+  process.stdout.write("\n");
+}
+function colorize(line, terminalWidth) {
+  const maxWidth = Math.max(10, terminalWidth - 3);
+  const text = truncateLine(line.text, maxWidth);
+  switch (line.type) {
+    case "add":
+      return ANSI.GREEN + text + ANSI.RESET;
+    case "remove":
+      return ANSI.RED + text + ANSI.RESET;
+    case "header":
+      return ANSI.CYAN + text + ANSI.RESET;
+    case "context":
+      return ANSI.GRAY + text + ANSI.RESET;
+    default:
+      return text;
+  }
+}
+function truncateLine(text, maxWidth) {
+  if (stringWidth(text) <= maxWidth) {
+    return text;
+  }
+  let truncated = text;
+  while (stringWidth(truncated + "...") > maxWidth && truncated.length > 0) {
+    truncated = truncated.slice(0, -1);
+  }
+  return truncated + "...";
+}
+function getTerminalSize() {
+  let columns = 80;
+  let rows = 24;
+  try {
+    const sttyOutput = execSync("stty size </dev/tty", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 200,
+      shell: "/bin/bash"
+    }).trim();
+    const parts = sttyOutput.split(/\s+/);
+    if (parts.length === 2) {
+      const sttyRows = parseInt(parts[0], 10);
+      const sttyCols = parseInt(parts[1], 10);
+      if (!isNaN(sttyRows) && sttyRows > 0) {
+        rows = sttyRows;
+      }
+      if (!isNaN(sttyCols) && sttyCols > 0) {
+        columns = sttyCols;
+      }
+    }
+  } catch {
+    try {
+      const tputCols = execSync("tput cols </dev/tty", {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 100,
+        shell: "/bin/bash"
+      }).trim();
+      const cols = parseInt(tputCols, 10);
+      if (!isNaN(cols) && cols > 0) {
+        columns = cols;
+      }
+    } catch {
+    }
+    try {
+      const tputRows = execSync("tput lines </dev/tty", {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 100,
+        shell: "/bin/bash"
+      }).trim();
+      const lns = parseInt(tputRows, 10);
+      if (!isNaN(lns) && lns > 0) {
+        rows = lns;
+      }
+    } catch {
+    }
+  }
+  return { rows, columns };
+}
+
+// src/templates/diff-viewer/diff-prompt.ts
+import { _createLogger as _createLogger2 } from "@stripe/extensibility-tool-utils";
+var logger2 = _createLogger2({ name: "diff-prompt" });
+function isInteractiveTerminal() {
+  if (process.env["CI"] === "true" || process.env["CI"] === "1") {
+    return false;
+  }
+  const term = process.env["TERM"];
+  if (!term || term === "dumb") {
+    return false;
+  }
+  if (typeof process.stdin.setRawMode !== "function") {
+    return false;
+  }
+  const termSize = getTerminalSize();
+  if (termSize.rows === 24 && termSize.columns === 80) {
+  }
+  return true;
+}
+async function _advancedDiffPrompt(filePath, cwd, newContent) {
+  const resolvedPath = path2.resolve(cwd, filePath);
+  if (!isInteractiveTerminal()) {
+    return await _promptOverwrite(filePath);
+  }
+  try {
+    const existingContent = await readExistingFile(resolvedPath);
+    const diffResult = await generateDiff(filePath, existingContent, newContent);
+    const termSize = getTerminalSize();
+    if (termSize.rows < 20) {
+      return await _promptOverwrite(filePath);
+    }
+    if (diffResult.lines.length > 5e3) {
+      logger2.info("Diff too large to display comfortably");
+      return await _promptOverwrite(filePath);
+    }
+    const wasRaw = process.stdin.isRaw ?? false;
+    try {
+      process.stdin.setRawMode(true);
+    } catch {
+      return await _promptOverwrite(filePath);
+    }
+    process.stdin.resume();
+    const maxTotalHeight = Math.floor(termSize.rows * 0.75);
+    const maxContentHeight = maxTotalHeight - 3;
+    const windowHeight = Math.min(diffResult.lines.length, maxContentHeight);
+    const state = {
+      scrollOffset: 0,
+      maxScroll: Math.max(0, diffResult.lines.length - windowHeight),
+      diffLines: diffResult.lines,
+      terminalHeight: termSize.rows,
+      terminalWidth: termSize.columns,
+      wasRaw,
+      renderedHeight: 0,
+      fullFileMode: false
+    };
+    render(state, filePath, false);
+    return new Promise((resolve) => {
+      const onExit = () => {
+        cleanup(state.wasRaw, onData, onExit);
+      };
+      const onData = (buffer) => {
+        handleKeypress(buffer, state, filePath, newContent, existingContent).then((result) => {
+          if (result !== "continue") {
+            cleanup(state.wasRaw, onData, onExit);
+            resolve(result);
+          }
+        }).catch((err) => {
+          cleanup(state.wasRaw, onData, onExit);
+          logger2.error({ err }, "Error handling keypress");
+          resolve("abort");
+        });
+      };
+      process.stdin.on("data", onData);
+      process.on("exit", onExit);
+    });
+  } catch (err) {
+    logger2.warn({ err }, "Error displaying diff, using basic prompt");
+    return await _promptOverwrite(filePath);
+  }
+}
+async function handleKeypress(buffer, state, filePath, newContent, existingContent) {
+  const code = buffer[0];
+  const key = buffer.toString();
+  if (code === 3) {
+    process.stdout.write("\nCancelled.\n");
+    return "abort";
+  }
+  switch (key.toLowerCase()) {
+    case "y":
+      return "overwrite";
+    case "n":
+    case "\r":
+    case "\n":
+      return "skip";
+    case "a":
+      return "overwrite-all";
+    case "q":
+      return "abort";
+    case "d":
+      await toggleDiffContext(state, filePath, newContent, existingContent);
+      return "continue";
+  }
+  if (buffer.length >= 3 && buffer[0] === 27 && buffer[1] === 91) {
+    const maxTotalHeight = Math.floor(state.terminalHeight * 0.75);
+    const maxContentHeight = maxTotalHeight - 3;
+    const windowHeight = Math.min(state.diffLines.length, maxContentHeight);
+    let scrollDelta = 0;
+    if (buffer[2] === 65) {
+      scrollDelta = -1;
+    } else if (buffer[2] === 66) {
+      scrollDelta = 1;
+    } else if (buffer[2] === 53) {
+      scrollDelta = -windowHeight;
+    } else if (buffer[2] === 54) {
+      scrollDelta = windowHeight;
+    }
+    const newScrollOffset = Math.max(
+      0,
+      Math.min(state.maxScroll, state.scrollOffset + scrollDelta)
+    );
+    if (newScrollOffset !== state.scrollOffset) {
+      state.scrollOffset = newScrollOffset;
+      render(state, filePath, true);
+    }
+  }
+  return "continue";
+}
+function cleanup(wasRaw, onData, onExit) {
+  if (process.stdin.setRawMode !== void 0) {
+    process.stdin.setRawMode(wasRaw);
+  }
+  process.stdin.pause();
+  if (onData) {
+    process.stdin.off("data", onData);
+  }
+  if (onExit) {
+    process.off("exit", onExit);
+  }
+  clearDiffWindow();
+}
+async function toggleDiffContext(state, filePath, newContent, existingContent) {
+  state.fullFileMode = !state.fullFileMode;
+  const contextLines = state.fullFileMode ? 1e4 : 3;
+  const visibleStartIndex = state.scrollOffset;
+  let referenceLineFinder = null;
+  let skippedLines = 0;
+  for (let i = visibleStartIndex; i < state.diffLines.length; i++) {
+    const line = state.diffLines[i];
+    if (line !== void 0) {
+      if (line.type === "header") {
+        skippedLines++;
+        continue;
+      }
+      if (line.newLine !== void 0) {
+        const targetNewLine = line.newLine;
+        referenceLineFinder = (dl) => dl.newLine !== void 0 && dl.newLine >= targetNewLine - skippedLines;
+        break;
+      } else if (line.oldLine !== void 0) {
+        const targetOldLine = line.oldLine;
+        referenceLineFinder = (dl) => dl.oldLine !== void 0 && dl.oldLine >= targetOldLine - skippedLines;
+        break;
+      }
+    }
+  }
+  const diffResult = await generateDiff(
+    filePath,
+    existingContent,
+    newContent,
+    contextLines
+  );
+  state.diffLines = diffResult.lines;
+  let newScrollOffset = 0;
+  if (referenceLineFinder !== null) {
+    const referenceIndex = diffResult.lines.findIndex(referenceLineFinder);
+    if (referenceIndex !== -1) {
+      newScrollOffset = Math.max(0, referenceIndex);
+    }
+  }
+  const maxTotalHeight = Math.floor(state.terminalHeight * 0.75);
+  const maxContentHeight = maxTotalHeight - 3;
+  const windowHeight = Math.min(diffResult.lines.length, maxContentHeight);
+  state.maxScroll = Math.max(0, diffResult.lines.length - windowHeight);
+  state.scrollOffset = Math.min(newScrollOffset, state.maxScroll);
+  render(state, filePath, true);
+}
+
+// src/templates/extensions/types.ts
+var _ExtensionTemplateManager = class extends _TemplateManager {
+  /**
+   * Get summary info for all registered extension templates
+   */
+  getTemplateInfo() {
+    return this.getTemplateEntries().map(([key, t]) => ({
+      key,
+      description: t.description,
+      deprecated: t.deprecated ?? false,
+      hidden: t.hidden ?? false,
+      methods: t.methods
+    }));
+  }
+};
+
+// src/dependencies/index.ts
+import path3 from "path";
+import fs from "fs";
+import os from "os";
+import { execSync as execSync2 } from "child_process";
+import PackageJson from "@npmcli/package-json";
+import * as semver from "semver";
+import { load as parseToml } from "js-toml";
+import { _createCliContext } from "@stripe/extensibility-tool-utils";
+function _npmDep(name, version) {
+  return { type: "npm", name, version };
+}
+function _devNpmDep(name, version) {
+  return { type: "dev-npm", name, version };
+}
+
+// src/templates/extensions/base.ts
+import { _workspaceVersion } from "@stripe/extensibility-tool-utils";
+var SDK_PACKAGE_NAME = "@stripe/extensibility-sdk";
+var LANGUAGE_SERVER_PACKAGE_NAME = "@stripe/extensibility-language-server";
+var LANGUAGE_SERVER_PACKAGE_VERSION = "^0.2.0";
+function _createExtensionEslintConfigFile(params, context) {
+  const { id, extensionInterfaceId } = params;
+  const { fs: fs2 } = context;
+  return {
+    path: `extensions/${id}/eslint.config.mts`,
+    content: fs2.mustache(
+      { extensionInterfaceId },
+      "common",
+      "eslint.config.mts.mustache"
+    ),
+    precious: true
+  };
+}
+function _createBaseOutput(params, context) {
+  const { id } = params;
+  const { fs: fs2 } = context;
+  return {
+    files: [
+      {
+        path: `extensions/${id}/package.json`,
+        content: fs2.mustache(params, "common", "package.json.mustache")
+      },
+      {
+        ..._createExtensionEslintConfigFile(params, context)
+      },
+      {
+        path: `extensions/${id}/tsconfig.build.json`,
+        content: fs2.mustache(params, "common", "tsconfig.build.json.mustache")
+      },
+      {
+        path: `extensions/${id}/tsconfig.json`,
+        content: fs2.mustache(params, "common", "tsconfig.json.mustache")
+      },
+      {
+        path: `extensions/${id}/.prettierignore`,
+        content: fs2.textFile("common", ".prettierignore")
+      }
+    ],
+    methods: {},
+    dependencies: {
+      // Exact pin (no caret) — the SDK is tightly coupled to dev-tools and
+      // must match the version that generated the extension scaffolding.
+      runtime: [_npmDep(SDK_PACKAGE_NAME, _workspaceVersion(SDK_PACKAGE_NAME))],
+      dev: [_devNpmDep(LANGUAGE_SERVER_PACKAGE_NAME, LANGUAGE_SERVER_PACKAGE_VERSION)]
+    },
+    postGenerationHooks: [
+      {
+        script: "build",
+        description: "Build extension"
+      },
+      {
+        exec: "prettier --write .",
+        description: "Format generated files"
+      }
+    ]
+  };
+}
+
+// src/templates/extensions/core.workflows.custom_action.ts
+var EXTENSION_INTERFACE_ID = "core.workflows.custom_action";
+var customActionTemplate = {
+  methods: {
+    execute: { implementation_types: ["script", "remote-function"] },
+    get_form_state: { implementation_types: ["script", "remote-function"] }
+  },
+  description: "Custom actions let your app define actions that users can add to their automated workflows. When a workflow triggers a custom action, Stripe calls your app to execute it.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs2 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID,
+        executionProfile: "egress"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/custom_input.schema.json`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID, "custom_input.schema.json"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        execute: {
+          implementation_type: "script",
+          custom_input: {
+            input_schema: {
+              type: "json_schema",
+              content: `extensions/${id}/src/custom_input.schema.json`
+            }
+          }
+        },
+        get_form_state: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var core_workflows_custom_action_default = {
+  [EXTENSION_INTERFACE_ID]: customActionTemplate
+};
+
+// src/templates/extensions/extend.objects.custom_objects.ts
+var EXTENSION_INTERFACE_ID2 = "extend.objects.custom_objects";
+var customObjectsTemplate = {
+  methods: {
+    execute_method: { implementation_types: ["script"] }
+  },
+  description: "Methods extension for custom object actions. Generated at build time \u2014 the transformed custom object class becomes the entry point.",
+  hidden: true,
+  generate: (params, context) => {
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID2,
+        executionProfile: "egress"
+      },
+      context
+    );
+    return {
+      ...base,
+      methods: {
+        execute_method: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var extend_objects_custom_objects_default = {
+  [EXTENSION_INTERFACE_ID2]: customObjectsTemplate
+};
+
+// src/templates/extensions/extend.workflows.custom_action.ts
+var EXTENSION_INTERFACE_ID3 = "extend.workflows.custom_action";
+var extendCustomActionTemplate = {
+  methods: {
+    execute: { implementation_types: ["script", "remote-function"] },
+    get_form_state: { implementation_types: ["script", "remote-function"] }
+  },
+  description: "Custom actions let your app define actions that users can add to their automated workflows. When a workflow triggers a custom action, Stripe calls your app to execute it.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs2 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID3,
+        executionProfile: "egress"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID3, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/custom_input.schema.json`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID3, "custom_input.schema.json"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID3, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        execute: {
+          implementation_type: "script",
+          custom_input: {
+            input_schema: {
+              type: "json_schema",
+              content: `extensions/${id}/src/custom_input.schema.json`
+            }
+          }
+        },
+        get_form_state: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var extend_workflows_custom_action_default = {
+  [EXTENSION_INTERFACE_ID3]: extendCustomActionTemplate
+};
+
+// src/templates/extensions/billing.customer_balance_application.ts
+var EXTENSION_INTERFACE_ID4 = "billing.customer_balance_application";
+var customerBalanceApplicationTemplate = {
+  methods: {
+    compute_applied_customer_balance: { implementation_types: ["script"] }
+  },
+  description: "Implement custom logic to control when and how much customer balance is applied to subscription invoices using scripts.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs2 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID4,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID4, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID4, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        compute_applied_customer_balance: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_customer_balance_application_default = {
+  [EXTENSION_INTERFACE_ID4]: customerBalanceApplicationTemplate
+};
+
+// src/templates/extensions/billing.bill.discount_calculation.ts
+var EXTENSION_INTERFACE_ID5 = "billing.bill.discount_calculation";
+var discountCalculationTemplate = {
+  hidden: true,
+  methods: {
+    compute_discounts: { implementation_types: ["script"] }
+  },
+  description: "Create coupons with custom scripting logic for dynamic discounts based on subscription attributes, customer metadata, and complex business rules.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs2 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID5,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID5, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID5, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        compute_discounts: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_bill_discount_calculation_default = {
+  [EXTENSION_INTERFACE_ID5]: discountCalculationTemplate
+};
+
+// src/templates/extensions/billing.invoice_collection_setting.ts
+var EXTENSION_INTERFACE_ID6 = "billing.invoice_collection_setting";
+var invoiceCollectionSettingTemplate = {
+  hidden: true,
+  methods: {
+    collection_override: { implementation_types: ["script"] }
+  },
+  description: "Use Stripe Scripts to create custom invoice collection logic that controls how your integration handles invoices generated from subscriptions.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs2 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID6,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID6, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID6, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        collection_override: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_invoice_collection_setting_default = {
+  [EXTENSION_INTERFACE_ID6]: invoiceCollectionSettingTemplate
+};
+
+// src/templates/extensions/billing.prorations.ts
+var EXTENSION_INTERFACE_ID7 = "billing.prorations";
+var prorationsTemplate = {
+  methods: {
+    prorate_items: { implementation_types: ["script"] }
+  },
+  description: "Create custom proration logic for subscriptions using scripts to handle upgrades, downgrades, and mid-cycle changes.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs2 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID7,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID7, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID7, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        prorate_items: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_prorations_default = {
+  [EXTENSION_INTERFACE_ID7]: prorationsTemplate
+};
+
+// src/templates/extensions/billing.recurring_billing_item_handling.ts
+var EXTENSION_INTERFACE_ID8 = "billing.recurring_billing_item_handling";
+var template = {
+  methods: {
+    before_item_creation: { implementation_types: ["script"] },
+    filter_items: { implementation_types: ["script"] },
+    group_items: { implementation_types: ["script"] }
+  },
+  description: "Customize how recurring billing items are filtered, grouped, and created during subscription billing runs.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs2 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID8,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID8, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs2.textFile(EXTENSION_INTERFACE_ID8, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        before_item_creation: {
+          implementation_type: "script"
+        },
+        filter_items: {
+          implementation_type: "script"
+        },
+        group_items: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_recurring_billing_item_handling_default = {
+  [EXTENSION_INTERFACE_ID8]: template
+};
+
+// src/templates/extensions/registry.ts
+var DEFAULT_TEMPLATES = {
+  ...core_workflows_custom_action_default,
+  ...extend_objects_custom_objects_default,
+  ...extend_workflows_custom_action_default,
+  ...billing_customer_balance_application_default,
+  ...billing_bill_discount_calculation_default,
+  ...billing_invoice_collection_setting_default,
+  ...billing_prorations_default,
+  ...billing_recurring_billing_item_handling_default
+};
+var registry_default = DEFAULT_TEMPLATES;
+
+// src/templates/extensions/index.ts
+var _templateManager = new _ExtensionTemplateManager(
+  registry_default,
+  _fs.scope("extensions")
+);
+
+// src/templates/root/index.ts
+import { _workspaceVersion as _workspaceVersion2 } from "@stripe/extensibility-tool-utils";
+var EXTENSIBILITY_ESLINT_PLUGIN_PACKAGE_NAME = "@stripe/extensibility-eslint-plugin";
+var EXTENSIBILITY_ESLINT_PLUGIN_VERSION = `^${_workspaceVersion2(EXTENSIBILITY_ESLINT_PLUGIN_PACKAGE_NAME)}`;
+var _rootWorkspaceTemplate = {
+  generate: (params, context) => {
+    const { fs: fs2 } = context;
+    return {
+      files: [
+        {
+          path: "stripe-app.yaml",
+          content: fs2.mustache(params, "stripe-app.yaml.mustache"),
+          precious: true
+        },
+        {
+          path: "package.json",
+          content: fs2.mustache(params, "package.json.mustache")
+        },
+        {
+          path: ".husky/pre-commit",
+          content: fs2.textFile(".husky/pre-commit")
+        },
+        {
+          path: "tsconfig.base.json",
+          content: fs2.textFile("tsconfig.base.json")
+        },
+        {
+          path: "tsconfig.json",
+          content: fs2.textFile("tsconfig.json")
+        },
+        {
+          path: "eslint.config.mts",
+          content: fs2.textFile("eslint.config.mts")
+        },
+        {
+          path: "vitest.config.mts",
+          content: fs2.textFile("vitest.config.mts")
+        },
+        {
+          path: ".gitignore",
+          content: fs2.textFile("_gitignore")
+        },
+        {
+          path: "pnpm-workspace.yaml",
+          content: fs2.textFile("pnpm-workspace.yaml")
+        },
+        {
+          path: ".prettierrc",
+          content: fs2.textFile(".prettierrc")
+        },
+        {
+          path: ".prettierignore",
+          content: fs2.textFile(".prettierignore")
+        },
+        {
+          path: "custom-objects/package.json",
+          content: fs2.textFile("custom-objects/package.json"),
+          precious: true
+        },
+        {
+          path: "custom-objects/tsconfig.json",
+          content: fs2.textFile("custom-objects/tsconfig.json"),
+          precious: true
+        },
+        {
+          path: "ui/package.json",
+          content: fs2.textFile("ui/package.json"),
+          precious: true
+        },
+        {
+          path: "tools/test.mts",
+          content: fs2.textFile("tools/test.mts")
+        },
+        {
+          // temporarily add dummy JSON manifest until stripe apps plugin is fixed
+          path: "stripe-app.json",
+          content: "{}\n"
+        }
+      ],
+      dependencies: {
+        dev: [
+          _devNpmDep("@eslint/js", "^9.0.0"),
+          _devNpmDep(
+            EXTENSIBILITY_ESLINT_PLUGIN_PACKAGE_NAME,
+            EXTENSIBILITY_ESLINT_PLUGIN_VERSION
+          ),
+          _devNpmDep(LANGUAGE_SERVER_PACKAGE_NAME, LANGUAGE_SERVER_PACKAGE_VERSION),
+          _devNpmDep("@types/node", "^20.19.0"),
+          _devNpmDep(
+            "@stripe/extensibility-dev-tools",
+            `^${_workspaceVersion2("@stripe/extensibility-dev-tools")}`
+          ),
+          _devNpmDep("concurrently", "^9.2.1"),
+          _devNpmDep("eslint", "^9.0.0"),
+          _devNpmDep("eslint-config-prettier", "^10.1.8"),
+          _devNpmDep("eslint-plugin-workspaces", "^0.12.1"),
+          _devNpmDep("globals", "^17.4.0"),
+          _devNpmDep("husky", "^9.1.7"),
+          _devNpmDep("jiti", "^2.6.1"),
+          _devNpmDep("lint-staged", "^16.2.7"),
+          _devNpmDep("chokidar-cli", "^3.0.0"),
+          _devNpmDep("prettier", "^3.8.1"),
+          _devNpmDep("ts-node", "^10.9.2"),
+          _devNpmDep("tsx", "^4.21.0"),
+          _devNpmDep("typescript", "^5.9.3"),
+          _devNpmDep("typescript-eslint", "^8.54.0"),
+          _devNpmDep("vitest", "^3.0.0")
+        ]
+      },
+      postGenerationHooks: [
+        {
+          exec: "prettier --write .",
+          description: "Format generated files"
+        }
+      ]
+    };
+  }
+};
+var _rootTemplateManager = new _SingleTemplateManager(_rootWorkspaceTemplate, _fs.scope("root"));
+export {
+  _ExtensionTemplateManager,
+  _SingleTemplateManager,
+  _TemplateManager,
+  _advancedDiffPrompt,
+  _createExtensionEslintConfigFile,
+  _createSimpleSingleFileTemplate,
+  _createSimpleTemplate,
+  _fs,
+  _promptOverwrite,
+  _rootTemplateManager,
+  _rootWorkspaceTemplate,
+  _templateManager,
+  _writeGeneratedFiles
+};