@stripe/extensibility-dev-tools 0.23.5

package/dist/bin/dev-tools-rpc.cjs

@@ -0,0 +1,3874 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/bin/dev-tools-rpc.ts
+var import_extensibility_tool_utils13 = require("@stripe/extensibility-tool-utils");
+
+// src/bin/rpc/types.ts
+var RpcInvalidParamsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RpcInvalidParamsError";
+  }
+};
+function isStringKeyedRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return false;
+  if (Object.getOwnPropertySymbols(value).length > 0) return false;
+  return true;
+}
+function isRpcRequest(value) {
+  if (!isStringKeyedRecord(value)) return false;
+  if (typeof value.method !== "string") return false;
+  if (value.params !== void 0 && !isStringKeyedRecord(value.params)) return false;
+  return true;
+}
+
+// src/bin/rpc/dispatch.ts
+async function dispatch(request, methods2) {
+  if (!isRpcRequest(request)) {
+    return {
+      error: {
+        code: "INVALID_REQUEST",
+        message: 'Request must be an object with a string "method" field'
+      }
+    };
+  }
+  const { method, params } = request;
+  const handler = methods2.get(method);
+  if (!handler) {
+    return {
+      error: {
+        code: "METHOD_NOT_FOUND",
+        message: `Unknown method: ${method}`
+      }
+    };
+  }
+  try {
+    const result = await handler(params ?? {});
+    return { result };
+  } catch (err) {
+    if (err instanceof RpcInvalidParamsError) {
+      return { error: { code: "INVALID_PARAMS", message: err.message } };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      error: { code: "INTERNAL_ERROR", message }
+    };
+  }
+}
+
+// src/templates/template-manager.ts
+var import_extensibility_tool_utils = require("@stripe/extensibility-tool-utils");
+
+// src/templates/extensions/types.ts
+var _ExtensionTemplateManager = class extends import_extensibility_tool_utils._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/templates/fs/in-memory.ts
+var import_extensibility_tool_utils2 = require("@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 = (0, import_extensibility_tool_utils2._createInMemoryTemplateFS)(TEMPLATE_FS_IMAGE);
+
+// src/dependencies/index.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_child_process = require("child_process");
+var import_package_json = __toESM(require("@npmcli/package-json"), 1);
+var semver = __toESM(require("semver"), 1);
+var import_js_toml = require("js-toml");
+var import_extensibility_tool_utils3 = require("@stripe/extensibility-tool-utils");
+function _npmDep(name, version) {
+  return { type: "npm", name, version };
+}
+function _devNpmDep(name, version) {
+  return { type: "dev-npm", name, version };
+}
+function _detectPackageManager(cwd) {
+  if (import_node_fs.default.existsSync(import_node_path.default.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (import_node_fs.default.existsSync(import_node_path.default.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (import_node_fs.default.existsSync(import_node_path.default.join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  let currentDir = cwd;
+  const root = import_node_path.default.parse(currentDir).root;
+  while (currentDir !== root) {
+    const parentDir = import_node_path.default.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    if (import_node_fs.default.existsSync(import_node_path.default.join(parentDir, "pnpm-lock.yaml"))) {
+      if (import_node_fs.default.existsSync(import_node_path.default.join(parentDir, "pnpm-workspace.yaml"))) {
+        return "pnpm";
+      }
+    }
+    if (import_node_fs.default.existsSync(import_node_path.default.join(parentDir, "yarn.lock"))) {
+      return "yarn";
+    }
+    if (import_node_fs.default.existsSync(import_node_path.default.join(parentDir, "package-lock.json"))) {
+      return "npm";
+    }
+    currentDir = parentDir;
+  }
+  return "npm";
+}
+var _NpmDependencyHandler = class {
+  cwd;
+  quiet;
+  devDependencies;
+  context;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.quiet = options.quiet;
+    this.devDependencies = options.devDependencies ?? false;
+    this.context = options.context ?? (0, import_extensibility_tool_utils3._createCliContext)();
+  }
+  get dependencyKey() {
+    return this.devDependencies ? "devDependencies" : "dependencies";
+  }
+  get dependencyLabel() {
+    return this.devDependencies ? "devDependencies" : "dependencies";
+  }
+  /** Check whether the npm dependency is already present in package.json. */
+  async check(dep) {
+    const packageJsonPath = import_node_path.default.join(this.cwd, "package.json");
+    if (!import_node_fs.default.existsSync(packageJsonPath)) {
+      return {
+        satisfied: false,
+        message: `package.json not found at ${this.cwd}`
+      };
+    }
+    const pkgJson = await import_package_json.default.load(this.cwd);
+    const rawDeps = pkgJson.content[this.dependencyKey];
+    const deps = rawDeps ?? {};
+    const currentVersion = deps[dep.name];
+    if (currentVersion === void 0) {
+      return {
+        satisfied: false,
+        message: `${dep.name} not found in ${this.dependencyLabel}`
+      };
+    }
+    if (currentVersion === dep.version) {
+      return {
+        satisfied: true,
+        currentVersion,
+        message: `${dep.name}@${dep.version} already in ${this.dependencyLabel}`
+      };
+    }
+    if (this.versionsCompatible(currentVersion, dep.version)) {
+      return {
+        satisfied: true,
+        currentVersion,
+        message: `${dep.name}@${currentVersion} satisfies ${dep.version}`
+      };
+    }
+    return {
+      satisfied: false,
+      currentVersion,
+      message: `${dep.name}@${currentVersion} does not satisfy ${dep.version}`
+    };
+  }
+  /** Check whether the requested version conflicts with the currently installed version. */
+  async checkConflict(dep) {
+    const packageJsonPath = import_node_path.default.join(this.cwd, "package.json");
+    if (!import_node_fs.default.existsSync(packageJsonPath)) {
+      return { hasConflict: false };
+    }
+    const pkgJson = await import_package_json.default.load(this.cwd);
+    const rawDeps = pkgJson.content[this.dependencyKey];
+    const deps = rawDeps ?? {};
+    const existingVersion = deps[dep.name];
+    if (existingVersion === void 0) {
+      return { hasConflict: false };
+    }
+    if (existingVersion === dep.version) {
+      return { hasConflict: false };
+    }
+    const existingMajor = this.extractMajorVersion(existingVersion);
+    const requestedMajor = this.extractMajorVersion(dep.version);
+    if (existingMajor !== null && requestedMajor !== null && existingMajor !== requestedMajor) {
+      return {
+        hasConflict: true,
+        existingVersion,
+        requestedVersion: dep.version,
+        message: `Major version mismatch: existing ${existingVersion} vs requested ${dep.version}`
+      };
+    }
+    if (!this.versionsCompatible(existingVersion, dep.version)) {
+      return {
+        hasConflict: true,
+        existingVersion,
+        requestedVersion: dep.version,
+        message: `Incompatible version ranges: existing ${existingVersion} vs requested ${dep.version}`
+      };
+    }
+    return { hasConflict: false };
+  }
+  /** Add or update the npm dependency in package.json. */
+  async add(dep) {
+    const packageJsonPath = import_node_path.default.join(this.cwd, "package.json");
+    if (!import_node_fs.default.existsSync(packageJsonPath)) {
+      throw new Error(`package.json not found at ${this.cwd}`);
+    }
+    const pkgJson = await import_package_json.default.load(this.cwd);
+    const rawDeps = pkgJson.content[this.dependencyKey];
+    const deps = rawDeps ?? {};
+    const existingVersion = deps[dep.name];
+    const isUpdate = existingVersion !== void 0;
+    const update = {
+      [this.dependencyKey]: {
+        ...deps,
+        [dep.name]: dep.version
+      }
+    };
+    pkgJson.update(update);
+    await pkgJson.save();
+    const action = isUpdate ? "update" : "add";
+    const message = isUpdate ? `Updated ${dep.name} from ${existingVersion} to ${dep.version} in ${this.dependencyLabel}` : `Added ${dep.name}@${dep.version} to ${this.dependencyLabel}`;
+    if (!this.quiet) {
+      this.context.ux.log(`\u2713 ${message}`);
+    }
+    return { action, message };
+  }
+  /** Run the package manager install command in the working directory. */
+  install(_deps) {
+    const packageManager = _detectPackageManager(this.cwd);
+    if (!this.quiet) {
+      this.context.ux.log(`Running ${packageManager} install...`);
+    }
+    try {
+      (0, import_node_child_process.execSync)(`${packageManager} install`, {
+        cwd: this.cwd,
+        stdio: this.quiet ? "pipe" : "inherit"
+      });
+    } catch (error) {
+      const baseMessage = `Failed to run ${packageManager} install`;
+      if (error instanceof Error) {
+        return Promise.reject(new Error(`${baseMessage}: ${error.message}`));
+      }
+      return Promise.reject(new Error(`${baseMessage}: ${String(error)}`));
+    }
+    return Promise.resolve();
+  }
+  versionsCompatible(existing, requested) {
+    if (existing.startsWith("file:") || requested.startsWith("file:") || existing.startsWith("workspace:") || requested.startsWith("workspace:")) {
+      return existing === requested;
+    }
+    if (!semver.validRange(existing) || !semver.validRange(requested)) {
+      return existing === requested;
+    }
+    return semver.intersects(existing, requested);
+  }
+  extractMajorVersion(version) {
+    if (version.startsWith("file:") || version.startsWith("workspace:")) {
+      return null;
+    }
+    const coerced = semver.coerce(version);
+    if (coerced) {
+      return coerced.major;
+    }
+    return null;
+  }
+};
+var _StripeCliPluginHandler = class {
+  stripeConfigDir;
+  quiet;
+  context;
+  constructor(options) {
+    this.stripeConfigDir = options.stripeConfigDir;
+    this.quiet = options.quiet;
+    this.context = options.context ?? (0, import_extensibility_tool_utils3._createCliContext)();
+  }
+  /** Check whether the Stripe CLI plugin is installed and meets the minimum version. */
+  check(dep) {
+    const pluginsTomlPath = import_node_path.default.join(this.stripeConfigDir, "plugins.toml");
+    if (!import_node_fs.default.existsSync(pluginsTomlPath)) {
+      return Promise.resolve({
+        satisfied: false,
+        message: `Stripe CLI plugin '${dep.name}' is not installed (plugins.toml not found)`
+      });
+    }
+    const pluginsContent = import_node_fs.default.readFileSync(pluginsTomlPath, "utf-8");
+    const installedPlugin = this.findPluginInToml(pluginsContent, dep.name);
+    if (!installedPlugin) {
+      return Promise.resolve({
+        satisfied: false,
+        message: `Stripe CLI plugin '${dep.name}' is not installed`
+      });
+    }
+    if (dep.minVersion && installedPlugin.version) {
+      if (!this.isVersionSatisfied(installedPlugin.version, dep.minVersion)) {
+        return Promise.resolve({
+          satisfied: false,
+          currentVersion: installedPlugin.version,
+          message: `Stripe CLI plugin '${dep.name}' version ${installedPlugin.version} is below minimum ${dep.minVersion}`
+        });
+      }
+    }
+    const result = {
+      satisfied: true,
+      message: `Stripe CLI plugin '${dep.name}' is installed${installedPlugin.version ? ` (version ${installedPlugin.version})` : ""}`
+    };
+    if (installedPlugin.version) {
+      result.currentVersion = installedPlugin.version;
+    }
+    return Promise.resolve(result);
+  }
+  /** Check whether the installed plugin version conflicts with the requested minimum. */
+  async checkConflict(dep) {
+    const checkResult = await this.check(dep);
+    if (checkResult.satisfied) {
+      return { hasConflict: false };
+    }
+    if (checkResult.currentVersion && dep.minVersion) {
+      return {
+        hasConflict: true,
+        existingVersion: checkResult.currentVersion,
+        requestedVersion: dep.minVersion,
+        message: `Installed version ${checkResult.currentVersion} is below minimum ${dep.minVersion}`
+      };
+    }
+    return { hasConflict: false };
+  }
+  /** Stage a Stripe CLI plugin for installation; the actual install happens in `install`. */
+  async add(dep) {
+    const checkResult = await this.check(dep);
+    const isUpdate = checkResult.currentVersion !== void 0;
+    const action = isUpdate ? "update" : "add";
+    const message = isUpdate ? `Will update Stripe CLI plugin '${dep.name}'` : `Will install Stripe CLI plugin '${dep.name}'`;
+    return { action, message };
+  }
+  /** Install Stripe CLI plugins using `stripe plugin install`. */
+  async install(deps) {
+    for (const dep of deps) {
+      const checkResult = await this.check(dep);
+      const isUpdate = checkResult.currentVersion !== void 0;
+      try {
+        (0, import_node_child_process.execSync)(`stripe plugin install ${dep.name}`, {
+          stdio: this.quiet ? "pipe" : "inherit"
+        });
+        const message = isUpdate ? `Updated Stripe CLI plugin '${dep.name}'` : `Installed Stripe CLI plugin '${dep.name}'`;
+        if (!this.quiet) {
+          this.context.ux.log(`\u2713 ${message}`);
+        }
+      } catch (error) {
+        const baseMessage = `Failed to install Stripe CLI plugin '${dep.name}'`;
+        if (error instanceof Error) {
+          throw new Error(`${baseMessage}: ${error.message}`);
+        }
+        throw new Error(`${baseMessage}: ${String(error)}`);
+      }
+    }
+  }
+  findPluginInToml(content, pluginName) {
+    try {
+      const parsed = (0, import_js_toml.load)(content);
+      const plugins = parsed.Plugin;
+      if (!plugins || !Array.isArray(plugins)) {
+        return null;
+      }
+      const plugin = plugins.find((p) => p.Shortname === pluginName);
+      if (!plugin) {
+        return null;
+      }
+      if (plugin.Release && Array.isArray(plugin.Release) && plugin.Release.length > 0) {
+        const currentArch = import_node_os.default.arch();
+        const currentOS = import_node_os.default.platform();
+        const normalizedArch = currentArch === "x64" ? "amd64" : currentArch;
+        const normalizedOS = currentOS === "win32" ? "windows" : currentOS;
+        const platformReleases = plugin.Release.filter(
+          (r) => r.Arch === normalizedArch && r.OS === normalizedOS
+        );
+        if (platformReleases.length === 0) {
+          return null;
+        }
+        const localBuildRelease = platformReleases.find(
+          (r) => r.Version === "local.build.dev"
+        );
+        if (localBuildRelease) {
+          return { version: "local.build.dev" };
+        }
+        const versions = platformReleases.map((r) => r.Version).filter((v) => v !== void 0);
+        if (versions.length === 0) {
+          return null;
+        }
+        const sortedVersions = versions.map((v) => ({ original: v, parsed: semver.coerce(v) })).filter(
+          (v) => v.parsed !== null
+        ).sort((a, b) => semver.rcompare(a.parsed, b.parsed));
+        if (sortedVersions.length === 0) {
+          return { version: versions[0] };
+        }
+        return { version: sortedVersions[0]?.original };
+      }
+      return { version: plugin.Version };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if installed version satisfies the required minimum version.
+   *
+   * Permissive policy: Non-semver versions (e.g., "local.build.dev", "dev", "canary-abc123")
+   * always satisfy version requirements. This avoids forcing upgrades during local development
+   * when developers are using locally built plugins.
+   *
+   * For valid semver versions, uses the semver library for proper semantic version comparison.
+   *
+   * @param installed - The installed version string
+   * @param required - The required minimum version string
+   * @returns true if installed version satisfies requirement
+   */
+  isVersionSatisfied(installed, required) {
+    const installedSemver = semver.coerce(installed);
+    const requiredSemver = semver.coerce(required);
+    if (!installedSemver) {
+      return true;
+    }
+    if (!requiredSemver) {
+      return true;
+    }
+    return semver.gte(installedSemver, requiredSemver);
+  }
+};
+function dependencyKey(dep) {
+  return `${dep.type}:${dep.name}`;
+}
+var _DependencyManager = class {
+  cwd;
+  stripeConfigDir;
+  quiet;
+  context;
+  npmHandler;
+  devNpmHandler;
+  stripeCliPluginHandler;
+  /** Internal state: pending changes indexed by dependency key */
+  pendingChanges = /* @__PURE__ */ new Map();
+  /** Whether commit() has been called */
+  committed = false;
+  constructor(options = {}) {
+    this.cwd = options.cwd ?? process.cwd();
+    this.stripeConfigDir = options.stripeConfigDir ?? import_node_path.default.join(import_node_os.default.homedir(), ".config", "stripe");
+    this.quiet = options.quiet ?? false;
+    this.context = options.context ?? (0, import_extensibility_tool_utils3._createCliContext)();
+    this.npmHandler = new _NpmDependencyHandler({
+      cwd: this.cwd,
+      quiet: this.quiet,
+      devDependencies: false,
+      context: this.context
+    });
+    this.devNpmHandler = new _NpmDependencyHandler({
+      cwd: this.cwd,
+      quiet: this.quiet,
+      devDependencies: true,
+      context: this.context
+    });
+    this.stripeCliPluginHandler = new _StripeCliPluginHandler({
+      stripeConfigDir: this.stripeConfigDir,
+      quiet: this.quiet,
+      context: this.context
+    });
+  }
+  /**
+   * Analyze dependencies and accumulate changes.
+   * Can be called multiple times before commit().
+   * Returns the changes for this specific call.
+   */
+  async ensureDependencies(input) {
+    if (this.committed) {
+      throw new Error("DependencyManager has already been committed");
+    }
+    const { required, optional = [] } = input;
+    const changes = [];
+    for (const dep of [...required, ...optional]) {
+      const change = await this.analyzeDependency(dep);
+      changes.push(change);
+      this.pendingChanges.set(dependencyKey(dep), change);
+    }
+    return changes;
+  }
+  /**
+   * Resolve a conflict by marking it for force install.
+   * Throws if the dependency is not in conflict state.
+   */
+  resolveConflict(dep) {
+    if (this.committed) {
+      throw new Error("DependencyManager has already been committed");
+    }
+    const key = dependencyKey(dep);
+    const change = this.pendingChanges.get(key);
+    if (!change) {
+      throw new Error(`Dependency '${dep.name}' not found in pending changes`);
+    }
+    if (change.action !== "conflict") {
+      throw new Error(
+        `Dependency '${dep.name}' is not in conflict (action: ${change.action})`
+      );
+    }
+    change.conflictResolved = true;
+  }
+  /**
+   * Get all pending changes (accumulated across all ensureDependencies calls).
+   */
+  getPendingChanges() {
+    return Array.from(this.pendingChanges.values());
+  }
+  /**
+   * Commit all accumulated changes.
+   * - For npm deps: updates package.json, optionally runs package manager install
+   * - For Stripe CLI deps: always installs (no separate add step)
+   *
+   * @param options - Commit options. `options.runInstall`: if true, run package manager install for npm deps (default: true)
+   * @returns Summary of changes made
+   * @throws If called more than once
+   */
+  async commit(options = {}) {
+    if (this.committed) {
+      throw new Error("DependencyManager has already been committed");
+    }
+    this.committed = true;
+    const { runInstall = true } = options;
+    let added = 0;
+    let updated = 0;
+    const npmDeps = [];
+    const stripeCliDeps = [];
+    for (const change of this.pendingChanges.values()) {
+      if (change.action === "already-satisfied") {
+        continue;
+      }
+      if (change.action === "conflict" && !change.conflictResolved) {
+        continue;
+      }
+      const dep = change.dependency;
+      if (dep.type === "npm" || dep.type === "dev-npm") {
+        npmDeps.push(dep);
+      } else {
+        stripeCliDeps.push(dep);
+      }
+    }
+    for (const dep of npmDeps) {
+      const handler = dep.type === "npm" ? this.npmHandler : this.devNpmHandler;
+      const result = await handler.add(dep);
+      if (result.action === "add") {
+        added++;
+      } else {
+        updated++;
+      }
+    }
+    if (runInstall && npmDeps.length > 0) {
+      await this.npmHandler.install(npmDeps);
+    }
+    if (stripeCliDeps.length > 0) {
+      await this.stripeCliPluginHandler.install(stripeCliDeps);
+      for (const dep of stripeCliDeps) {
+        const change = this.pendingChanges.get(dependencyKey(dep));
+        if (change?.action === "add" || change?.action === "conflict" && !change.previousVersion) {
+          added++;
+        } else {
+          updated++;
+        }
+      }
+    }
+    return { added, updated };
+  }
+  async analyzeDependency(dep) {
+    const handler = this.getHandler(dep);
+    const checkResult = await handler.check(dep);
+    if (checkResult.satisfied) {
+      return {
+        dependency: dep,
+        action: "already-satisfied",
+        message: checkResult.message
+      };
+    }
+    const conflictResult = await handler.checkConflict(dep);
+    if (conflictResult.hasConflict) {
+      const result2 = {
+        dependency: dep,
+        action: "conflict",
+        message: conflictResult.message ?? "Dependency conflict detected",
+        conflict: conflictResult
+      };
+      if (conflictResult.existingVersion) {
+        result2.previousVersion = conflictResult.existingVersion;
+      }
+      return result2;
+    }
+    const isUpdate = checkResult.currentVersion !== void 0;
+    const result = {
+      dependency: dep,
+      action: isUpdate ? "update" : "add",
+      message: isUpdate ? `Will update ${dep.name} from ${String(checkResult.currentVersion)}` : `Will add ${dep.name}`
+    };
+    if (checkResult.currentVersion) {
+      result.previousVersion = checkResult.currentVersion;
+    }
+    return result;
+  }
+  getHandler(dep) {
+    switch (dep.type) {
+      case "npm":
+        return this.npmHandler;
+      case "dev-npm":
+        return this.devNpmHandler;
+      case "stripe-cli-plugin":
+        return this.stripeCliPluginHandler;
+    }
+  }
+};
+
+// src/templates/extensions/base.ts
+var import_extensibility_tool_utils4 = require("@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, (0, import_extensibility_tool_utils4._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/workspace/index.ts
+var import_zod = require("zod");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_fs2 = require("fs");
+var import_promises5 = require("fs/promises");
+var import_node_child_process2 = require("child_process");
+var import_internal = require("@stripe/extensibility-custom-objects-tools/internal");
+var import_extensibility_tool_utils11 = require("@stripe/extensibility-tool-utils");
+
+// src/manifest/stripe-app-manifest.ts
+var import_extensibility_tool_utils6 = require("@stripe/extensibility-tool-utils");
+
+// src/manifest/manifest-v1.ts
+var import_fs2 = require("fs");
+function formatCustomObjectEntry(entry) {
+  return `${entry.filePath}#${entry.className}`;
+}
+function parseCustomObjectEntry(entryString) {
+  const parts = entryString.split("#");
+  if (parts.length !== 2) {
+    throw new Error(
+      `Invalid object entry format: ${entryString}. Expected format: "path/to/file.d.ts#ClassName"`
+    );
+  }
+  const [filePath, className] = parts;
+  if (!filePath || !className) {
+    throw new Error(
+      `Invalid object entry format: ${entryString}. Expected format: "path/to/file.d.ts#ClassName"`
+    );
+  }
+  return { filePath, className };
+}
+var _ManifestV1 = class __ManifestV1 {
+  constructor(filePath, data) {
+    this.filePath = filePath;
+    this.data = data;
+  }
+  /**
+   * Load stripe-app.json from disk
+   * @param filePath - Path to stripe-app.json
+   * @throws Error if file is invalid or cannot be read
+   */
+  static load(filePath) {
+    if (!(0, import_fs2.existsSync)(filePath)) {
+      throw new Error(`Manifest file not found: ${filePath}`);
+    }
+    const content = (0, import_fs2.readFileSync)(filePath, "utf-8");
+    const data = JSON.parse(content);
+    if (!data.id) {
+      throw new Error('Manifest must contain "id" field');
+    }
+    return new __ManifestV1(filePath, data);
+  }
+  /**
+   * Get the app ID from the manifest
+   */
+  getAppId() {
+    return this.data.id;
+  }
+  /**
+   * Get the app name from the manifest
+   */
+  getAppName() {
+    return this.data.name;
+  }
+  /**
+   * Get all custom objects as structured entries
+   */
+  getCustomObjects() {
+    const entries = [];
+    if (this.data.exported_custom_objects) {
+      for (const entry of this.data.exported_custom_objects) {
+        entries.push(parseCustomObjectEntry(entry));
+      }
+    }
+    return entries;
+  }
+  /**
+   * Check if a custom object entry exists in the manifest
+   */
+  hasCustomObject(entry) {
+    const objects = this.getCustomObjects();
+    return objects.some(
+      (existing) => existing.filePath === entry.filePath && existing.className === entry.className
+    );
+  }
+  /**
+   * Add a custom object entry to the manifest
+   * Does nothing if entry already exists
+   * @returns true if entry was added, false if it already existed
+   */
+  addCustomObject(entry) {
+    if (this.hasCustomObject(entry)) {
+      return false;
+    }
+    const entryString = formatCustomObjectEntry(entry);
+    this.data.exported_custom_objects ??= [];
+    this.data.exported_custom_objects.push(entryString);
+    return true;
+  }
+  /**
+   * Remove a custom object entry from the manifest
+   * @returns true if entry was removed, false if it didn't exist
+   */
+  removeCustomObject(entry) {
+    if (!this.data.exported_custom_objects) {
+      return false;
+    }
+    const entryString = formatCustomObjectEntry(entry);
+    const originalLength = this.data.exported_custom_objects.length;
+    this.data.exported_custom_objects = this.data.exported_custom_objects.filter(
+      (e) => e !== entryString
+    );
+    if (this.data.exported_custom_objects.length === 0) {
+      delete this.data.exported_custom_objects;
+    }
+    return this.data.exported_custom_objects?.length !== originalLength;
+  }
+  /**
+   * Get the raw manifest data (for reading other fields)
+   */
+  getRawData() {
+    return this.data;
+  }
+  /**
+   * Save changes back to disk
+   */
+  save() {
+    (0, import_fs2.writeFileSync)(this.filePath, JSON.stringify(this.data, null, 2) + "\n");
+  }
+};
+
+// src/manifest/manifest-v2.ts
+var import_promises = require("fs/promises");
+var yaml = __toESM(require("yaml"), 1);
+var import_extensibility_tool_utils5 = require("@stripe/extensibility-tool-utils");
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isYamlObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateManifestV2Data(data) {
+  if (!isNonEmptyString(data.id)) {
+    throw new Error('Manifest must contain non-empty "id" field');
+  }
+  if (!isNonEmptyString(data.name)) {
+    throw new Error('Manifest must contain non-empty "name" field');
+  }
+  if (!isNonEmptyString(data.version)) {
+    throw new Error('Manifest must contain non-empty "version" field');
+  }
+  if ("extensions" in data && !Array.isArray(data.extensions)) {
+    throw new Error('Manifest field "extensions" must be an array when provided');
+  }
+  if ("custom_object_definitions" in data && !isYamlObject(data.custom_object_definitions)) {
+    throw new Error(
+      'Manifest field "custom_object_definitions" must be an object with a "definitions" array'
+    );
+  }
+  const coBlock = data.custom_object_definitions;
+  const definitions = isYamlObject(coBlock) ? coBlock.definitions : void 0;
+  if (!definitions) {
+    return;
+  }
+  if (!Array.isArray(definitions)) {
+    throw new Error(
+      'Manifest field "custom_object_definitions.definitions" must be an array'
+    );
+  }
+  for (let i = 0; i < definitions.length; i++) {
+    const def = definitions[i];
+    const prefix = `custom_object_definitions.definitions[${String(i)}]`;
+    if (!isYamlObject(def) || !isNonEmptyString(def.id)) {
+      throw new Error(
+        `${prefix}: missing or invalid "id" field. Got: ${JSON.stringify(def)}`
+      );
+    }
+    if (!isYamlObject(def.specification)) {
+      throw new Error(
+        `${prefix}: missing or invalid "specification" field. Expected: { type: "typescript", content: "path/to/file.ts" }. Got: ${JSON.stringify(def)}`
+      );
+    }
+    if (!isNonEmptyString(def.specification.type)) {
+      throw new Error(
+        `${prefix}: missing or invalid "specification.type" field. Got: ${JSON.stringify(def)}`
+      );
+    }
+    if (!isNonEmptyString(def.specification.content)) {
+      throw new Error(
+        `${prefix}: missing or invalid "specification.content" field. Got: ${JSON.stringify(def)}`
+      );
+    }
+  }
+}
+var _ManifestV2 = class __ManifestV2 {
+  constructor(filePath, data) {
+    this.filePath = filePath;
+    this.data = data;
+  }
+  /**
+   * Load stripe-app.yaml from disk
+   * @param filePath - Path to stripe-app.yaml
+   * @throws Error if file is invalid or cannot be read
+   */
+  static async load(filePath) {
+    try {
+      const content = await (0, import_promises.readFile)(filePath, "utf-8");
+      const parsed = yaml.parse(content);
+      if (!isYamlObject(parsed)) {
+        throw new Error("Invalid stripe-app.yaml format: root must be an object");
+      }
+      validateManifestV2Data(parsed);
+      const data = parsed;
+      data.extensions ??= [];
+      return new __ManifestV2(filePath, data);
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`Error reading stripe-app.yaml: ${err.message}`);
+      }
+      throw new Error(`Error reading stripe-app.yaml: ${String(err)}`);
+    }
+  }
+  /**
+   * Get the app ID from the manifest
+   */
+  getAppId() {
+    return this.data.id;
+  }
+  /**
+   * Get the app name from the manifest
+   */
+  getAppName() {
+    return this.data.name;
+  }
+  // ============================================================
+  // Custom Objects
+  // ============================================================
+  /**
+   * Get all custom object definitions, parsed into internal format.
+   * Entries are guaranteed structurally valid by load-time validation.
+   */
+  getCustomObjects() {
+    const definitions = this.data.custom_object_definitions?.definitions;
+    if (!definitions || definitions.length === 0) {
+      return [];
+    }
+    return definitions.map((def) => ({
+      id: def.id,
+      type: def.specification.type,
+      path: def.specification.content,
+      name: (0, import_extensibility_tool_utils5._toPascalCase)(def.id)
+    }));
+  }
+  /**
+   * Check if a custom object exists by id
+   */
+  hasCustomObject(id) {
+    const definitions = this.data.custom_object_definitions?.definitions;
+    if (!definitions) return false;
+    return definitions.some((def) => def.id === id);
+  }
+  /**
+   * Add a custom object definition.
+   *
+   * Identity is keyed on `id` alone. The export name is derived via
+   * `_toPascalCase(id)` at read time, so `id` should be valid snake_case
+   * (e.g., "device", "loyalty_card", "http_request").
+   *
+   * @param id - Object identifier (e.g., "device", "loyalty_card")
+   * @param content - Path to the definition file (e.g., "src/device.object.ts")
+   * @param type - Specification type, defaults to "typescript"
+   * @returns true if added, false if already exists
+   */
+  addCustomObject(id, content, type = "typescript") {
+    if (this.hasCustomObject(id)) {
+      return false;
+    }
+    this.data.custom_object_definitions ??= {};
+    this.data.custom_object_definitions.definitions ??= [];
+    this.data.custom_object_definitions.definitions.push({
+      id,
+      specification: { type, content }
+    });
+    return true;
+  }
+  /**
+   * Remove a custom object definition by id
+   * @param id - Object identifier to remove
+   * @returns true if removed, false if not found
+   */
+  removeCustomObject(id) {
+    const block = this.data.custom_object_definitions;
+    if (!block?.definitions) {
+      return false;
+    }
+    const originalLength = block.definitions.length;
+    block.definitions = block.definitions.filter((def) => def.id !== id);
+    const newLength = block.definitions.length;
+    if (newLength === 0) {
+      delete this.data.custom_object_definitions;
+    }
+    return newLength < originalLength;
+  }
+  // ============================================================
+  // Extensions
+  // ============================================================
+  /**
+   * Add a new extension or update an existing one by ID
+   * If an extension with the provided ID exists, it will be replaced entirely
+   * @param extension - Extension configuration with all required fields including id
+   * @returns The extension ID
+   */
+  addOrUpdateExtension(extension) {
+    const newExtension = {
+      id: extension.id,
+      name: extension.name,
+      interface_id: extension.interface_id,
+      version: extension.version,
+      ...extension.description !== void 0 && {
+        description: extension.description
+      },
+      ...extension.stripe_version !== void 0 && {
+        stripe_version: extension.stripe_version
+      },
+      ...extension.script_entry_point !== void 0 && {
+        script_entry_point: extension.script_entry_point
+      },
+      ...extension.script !== void 0 && { script: extension.script },
+      permissions: extension.permissions,
+      methods: extension.methods,
+      ...extension.configuration !== void 0 && {
+        configuration: extension.configuration
+      },
+      ...extension.endpoints !== void 0 && {
+        endpoints: extension.endpoints
+      }
+    };
+    this.data.extensions ??= [];
+    const existingIndex = this.data.extensions.findIndex(
+      (ext) => ext.id === extension.id
+    );
+    if (existingIndex !== -1) {
+      this.data.extensions[existingIndex] = newExtension;
+    } else {
+      this.data.extensions.push(newExtension);
+    }
+    return extension.id;
+  }
+  /**
+   * Get a read-only view of all extensions
+   */
+  getExtensions() {
+    return this.data.extensions ?? [];
+  }
+  /**
+   * Get the raw manifest data (for reading other fields)
+   */
+  getRawData() {
+    return this.data;
+  }
+  /**
+   * Save changes back to disk
+   * @throws Error if file cannot be written
+   */
+  async save() {
+    try {
+      const updatedContent = yaml.stringify(this.data);
+      await (0, import_promises.writeFile)(this.filePath, updatedContent, "utf-8");
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`Error writing stripe-app.yaml: ${err.message}`);
+      }
+      throw new Error(`Error writing stripe-app.yaml: ${String(err)}`);
+    }
+  }
+};
+
+// src/manifest/stripe-app-manifest.ts
+var _StripeAppManifest = class __StripeAppManifest {
+  constructor(manifestPath, version, v1, v2) {
+    this.manifestPath = manifestPath;
+    this.version = version;
+    this.v1 = v1;
+    this.v2 = v2;
+  }
+  /**
+   * Load a manifest file, automatically detecting the version.
+   * @param manifestPath - Path to stripe-app.json or stripe-app.yaml
+   * @returns Loaded manifest instance
+   */
+  static async load(manifestPath) {
+    const version = __StripeAppManifest.detectVersion(manifestPath);
+    if (version === "v1") {
+      const reader = _ManifestV1.load(manifestPath);
+      return new __StripeAppManifest(manifestPath, version, reader, null);
+    } else {
+      const reader = await _ManifestV2.load(manifestPath);
+      return new __StripeAppManifest(manifestPath, version, null, reader);
+    }
+  }
+  /**
+   * Detect manifest version from file path.
+   * TODO: Add content-based detection if needed.
+   */
+  static detectVersion(manifestPath) {
+    const lowerPath = manifestPath.toLowerCase();
+    if (lowerPath.endsWith(".yaml") || lowerPath.endsWith(".yml")) {
+      return "v2";
+    }
+    if (lowerPath.endsWith(".json")) {
+      return "v1";
+    }
+    throw new Error(
+      `Cannot detect manifest version from path: ${manifestPath}. Expected .json (v1) or .yaml/.yml (v2) extension.`
+    );
+  }
+  /**
+   * Get the detected manifest version
+   */
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * Get the manifest file path
+   */
+  getManifestPath() {
+    return this.manifestPath;
+  }
+  // ============================================================
+  // App Metadata (supported by both V1 and V2)
+  // ============================================================
+  /**
+   * Get the app ID from the manifest
+   */
+  getAppId() {
+    if (this.v1) {
+      return this.v1.getAppId();
+    }
+    if (this.v2) {
+      return this.v2.getAppId();
+    }
+    return void 0;
+  }
+  /**
+   * Get the app name from the manifest
+   */
+  getAppName() {
+    if (this.v1) {
+      return this.v1.getAppName();
+    }
+    if (this.v2) {
+      return this.v2.getAppName();
+    }
+    return void 0;
+  }
+  // ============================================================
+  // Custom Objects (supported by both V1 and V2)
+  // ============================================================
+  /**
+   * Get all custom objects from the manifest
+   */
+  getCustomObjects() {
+    if (this.v1) {
+      return this.v1.getCustomObjects();
+    }
+    if (this.v2) {
+      return this.v2.getCustomObjects().map((obj) => ({
+        filePath: obj.path,
+        className: obj.name
+      }));
+    }
+    return [];
+  }
+  /**
+   * Check if a custom object entry exists in the manifest.
+   *
+   * **V2 note:** Identity is keyed on `_toSnakeCase(className)` alone — `filePath`
+   * is not considered. Two entries with the same class name but different file
+   * paths are treated as the same object. The `_toSnakeCase` → `_toPascalCase`
+   * round-trip is lossless for typical class names but lossy for consecutive
+   * uppercase (e.g., `HTTPClient` → `http_client` → `HttpClient`). The manifest
+   * `id` field is the source of truth; see `_CustomObjectDefinitionYaml` docs.
+   */
+  hasCustomObject(entry) {
+    if (this.v1) {
+      return this.v1.hasCustomObject(entry);
+    }
+    if (this.v2) {
+      return this.v2.hasCustomObject((0, import_extensibility_tool_utils6._toSnakeCase)(entry.className));
+    }
+    return false;
+  }
+  /**
+   * Add a custom object entry to the manifest.
+   *
+   * **V2 note:** The manifest `id` is derived as `_toSnakeCase(className)` and
+   * `filePath` is stored as the specification `content` path. Identity/dedup
+   * is based on `id` alone — see `hasCustomObject` for details.
+   *
+   * @param entry - The custom object entry to add
+   * @returns true if entry was added, false if it already existed
+   */
+  addCustomObject(entry) {
+    if (this.v1) {
+      return this.v1.addCustomObject(entry);
+    }
+    if (this.v2) {
+      return this.v2.addCustomObject((0, import_extensibility_tool_utils6._toSnakeCase)(entry.className), entry.filePath);
+    }
+    return false;
+  }
+  /**
+   * Remove a custom object entry from the manifest.
+   *
+   * **V2 note:** Removal is keyed on `_toSnakeCase(className)` — `filePath` is
+   * not considered. See `hasCustomObject` for identity semantics.
+   *
+   * @param entry - The custom object entry to remove
+   * @returns true if entry was removed, false if it didn't exist
+   */
+  removeCustomObject(entry) {
+    if (this.v1) {
+      return this.v1.removeCustomObject(entry);
+    }
+    if (this.v2) {
+      return this.v2.removeCustomObject((0, import_extensibility_tool_utils6._toSnakeCase)(entry.className));
+    }
+    return false;
+  }
+  // ============================================================
+  // Extensions (V2 only)
+  // ============================================================
+  /**
+   * Get all extensions from the manifest
+   * @throws Error if manifest version doesn't support extensions
+   */
+  getExtensions() {
+    if (this.v2) {
+      return this.v2.getExtensions();
+    }
+    throw new Error("Extensions are not supported in V1 manifests (stripe-app.json)");
+  }
+  /**
+   * Add or update an extension in the manifest.
+   * If an extension with the same ID exists, it will be replaced.
+   *
+   * @param config - Full extension configuration
+   * @returns The extension ID
+   * @throws Error if manifest version doesn't support extensions
+   */
+  addOrUpdateExtension(config) {
+    if (this.v2) {
+      return this.v2.addOrUpdateExtension(config);
+    }
+    throw new Error("Extensions are not supported in V1 manifests (stripe-app.json)");
+  }
+  // ============================================================
+  // Persistence
+  // ============================================================
+  /**
+   * Save changes back to disk
+   */
+  async save() {
+    if (this.v1) {
+      this.v1.save();
+      return;
+    }
+    if (this.v2) {
+      await this.v2.save();
+      return;
+    }
+    throw new Error("No reader loaded - this should never happen");
+  }
+};
+
+// src/templates/simple-templates.ts
+var import_extensibility_tool_utils7 = require("@stripe/extensibility-tool-utils");
+
+// src/templates/file-writer.ts
+var import_path = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_readline = require("readline");
+var import_extensibility_tool_utils8 = require("@stripe/extensibility-tool-utils");
+
+// src/templates/fs-utils.ts
+var import_promises2 = require("fs/promises");
+async function pathExists(filePath, predicate) {
+  try {
+    const stats = await (0, import_promises2.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 = (0, import_extensibility_tool_utils8._createLogger)({ name: "file-writer" });
+async function _promptOverwrite(filePath) {
+  const prompt = `${filePath} exists. Overwrite [yNaq]? `;
+  if (!process.stdin.isTTY) {
+    const rl = (0, import_node_readline.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 = import_path.default.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 = import_path.default.join(cwd, file.path);
+    const fileDir = import_path.default.dirname(fullPath);
+    const isExisting = existing.includes(file.path);
+    if (isExisting) {
+      const existingContent = await (0, import_promises3.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 (0, import_promises3.mkdir)(fileDir, { recursive: true });
+    }
+    await (0, import_promises3.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
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/templates/diff-viewer/diff-generator.ts
+var import_diff = require("diff");
+var import_promises4 = require("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 = (0, import_diff.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 (0, import_promises4.readFile)(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
+var import_child_process = require("child_process");
+var import_string_width = __toESM(require("string-width"), 1);
+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 - (0, import_string_width.default)(prefix) - (0, import_string_width.default)(suffix);
+  let displayName = filePath;
+  if ((0, import_string_width.default)(displayName) + 1 > availableWidth) {
+    while ((0, import_string_width.default)("..." + displayName) + 1 > availableWidth && displayName.length > 0) {
+      displayName = displayName.slice(1);
+    }
+    displayName = "..." + displayName;
+  }
+  const paddingLength = Math.max(0, availableWidth - (0, import_string_width.default)(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 - (0, import_string_width.default)(prefix) - (0, import_string_width.default)(suffix);
+  const paddingLength = Math.max(0, availableWidth - (0, import_string_width.default)(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 ((0, import_string_width.default)(text) <= maxWidth) {
+    return text;
+  }
+  let truncated = text;
+  while ((0, import_string_width.default)(truncated + "...") > maxWidth && truncated.length > 0) {
+    truncated = truncated.slice(0, -1);
+  }
+  return truncated + "...";
+}
+function getTerminalSize() {
+  let columns = 80;
+  let rows = 24;
+  try {
+    const sttyOutput = (0, import_child_process.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 = (0, import_child_process.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 = (0, import_child_process.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
+var import_extensibility_tool_utils9 = require("@stripe/extensibility-tool-utils");
+var logger2 = (0, import_extensibility_tool_utils9._createLogger)({ 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 = import_node_path2.default.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/root/index.ts
+var import_extensibility_tool_utils10 = require("@stripe/extensibility-tool-utils");
+var EXTENSIBILITY_ESLINT_PLUGIN_PACKAGE_NAME = "@stripe/extensibility-eslint-plugin";
+var EXTENSIBILITY_ESLINT_PLUGIN_VERSION = `^${(0, import_extensibility_tool_utils10._workspaceVersion)(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",
+            `^${(0, import_extensibility_tool_utils10._workspaceVersion)("@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 import_extensibility_tool_utils7._SingleTemplateManager(_rootWorkspaceTemplate, _fs.scope("root"));
+
+// src/workspace/index.ts
+var _regenWorkspaceOptionsSchema = import_zod.z.object({
+  /** Workspace template ID (e.g., 'core.workflows.custom_action', 'custom-objects'). Absence means root workspace mode. */
+  templateId: import_zod.z.string().optional(),
+  /** Path to project root. Resolved relative to cwd. Defaults to cwd. */
+  root: import_zod.z.string().optional(),
+  /** Path to directory containing package.json (resolved relative to cwd). Used for reading existing metadata. If undefined, package.json is not read. */
+  packageDir: import_zod.z.string().optional(),
+  /** Workspace ID. Validated against package.json if both are present. */
+  workspaceId: import_zod.z.string().optional(),
+  /** Workspace name. Overrides package.json description if provided. */
+  workspaceName: import_zod.z.string().optional(),
+  /** Skip dependency installation */
+  skipDependencies: import_zod.z.boolean().optional(),
+  /** Skip post-generation hooks */
+  skipHooks: import_zod.z.boolean().optional(),
+  /** Force overwrite all files without prompting */
+  force: import_zod.z.boolean().optional(),
+  /** Custom object name. Required when templateId is 'custom-object'. */
+  name: import_zod.z.string().optional(),
+  /** Implementation type. When 'remote-function', only .schema.json files are written and dependencies/hooks are skipped. */
+  implementationType: import_zod.z.enum(["script", "remote-function"]).optional()
+});
+async function readPackageMetadata(dir) {
+  const pkgPath = import_node_path3.default.join(dir, "package.json");
+  try {
+    const pkgContent = await (0, import_promises5.readFile)(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgContent);
+    return {
+      ...pkg.name !== void 0 && { id: pkg.name },
+      ...pkg.description !== void 0 && { name: pkg.description },
+      ...pkg.version !== void 0 && { version: pkg.version }
+    };
+  } catch {
+    return null;
+  }
+}
+async function _resolvePackageMetadata(providedId, providedName, packageDir) {
+  let id = providedId;
+  let name = providedName;
+  let version = "0.0.1";
+  if (packageDir !== void 0) {
+    const pkgMetadata = await readPackageMetadata(packageDir);
+    if (pkgMetadata) {
+      if (id && pkgMetadata.id && id !== pkgMetadata.id) {
+        throw new Error(
+          `Workspace ID mismatch: --workspace-id "${id}" does not match package.json name "${pkgMetadata.id}"`
+        );
+      }
+      id ??= pkgMetadata.id;
+      name ??= pkgMetadata.name;
+      if (pkgMetadata.version) {
+        version = pkgMetadata.version;
+      }
+    }
+  }
+  if (!id) {
+    throw new Error(
+      "ID required: provide --workspace-id or ensure package.json has a name field"
+    );
+  }
+  name ??= id;
+  return { id, name, version };
+}
+function runPostGenerationHooks(hooks, workingDir, disabled = false, context = (0, import_extensibility_tool_utils11._createCliContext)()) {
+  if (!hooks || hooks.length === 0 || disabled) {
+    return Promise.resolve();
+  }
+  context.ux.log("\nRunning post-generation hooks...");
+  for (const hook of hooks) {
+    const description = hook.description ? ` (${hook.description})` : "";
+    let command;
+    let hookName;
+    if ("script" in hook) {
+      command = `pnpm run ${hook.script}`;
+      hookName = hook.script;
+    } else {
+      command = `pnpm exec ${hook.exec}`;
+      hookName = hook.exec;
+    }
+    context.ux.log(`
+Running: ${command}${description}`);
+    try {
+      (0, import_node_child_process2.execSync)(command, {
+        cwd: workingDir,
+        stdio: "inherit"
+      });
+      context.ux.log(`\u2713 Hook completed: ${hookName}`);
+    } catch (error) {
+      context.ux.error(`! Hook failed: ${hookName}`);
+      if (error instanceof Error) {
+        context.ux.error(`  ${error.message}`);
+      }
+    }
+  }
+  return Promise.resolve();
+}
+async function installDependencies(services, cwd, dependencies, context) {
+  if (dependencies.length === 0) {
+    return;
+  }
+  const depManager = services.createDepManager({ cwd, context });
+  const pendingChanges = await depManager.ensureDependencies({
+    required: dependencies
+  });
+  for (const pendingChange of pendingChanges) {
+    if (pendingChange.action === "conflict") {
+      depManager.resolveConflict(pendingChange.dependency);
+    }
+  }
+  await depManager.commit();
+}
+async function backfillMissingExtensionEslintConfigs(services, projectRoot) {
+  const manifestPath = import_node_path3.default.join(projectRoot, "stripe-app.yaml");
+  if (!(0, import_node_fs2.existsSync)(manifestPath)) {
+    return [];
+  }
+  const manifest = await services.loadManifest(manifestPath);
+  const extensions = manifest.getExtensions();
+  return extensions.flatMap((extension) => {
+    const eslintConfigPath = `extensions/${extension.id}/eslint.config.mts`;
+    if ((0, import_node_fs2.existsSync)(import_node_path3.default.join(projectRoot, eslintConfigPath))) {
+      return [];
+    }
+    return _createExtensionEslintConfigFile(
+      {
+        id: extension.id,
+        extensionInterfaceId: extension.interface_id
+      },
+      { fs: _fs.scope("extensions") }
+    );
+  });
+}
+function resolveMode(options, projectRoot, packageDir) {
+  if (!options.templateId) {
+    return {
+      label: "root",
+      workspaceDir: () => packageDir ?? projectRoot,
+      generate: (svc, meta) => svc.generateRoot({
+        appId: meta.id,
+        appName: meta.name,
+        version: meta.version
+      })
+    };
+  }
+  if (options.templateId === "custom-objects") {
+    return {
+      label: "custom-objects",
+      workspaceDir: () => packageDir ?? import_node_path3.default.join(projectRoot, "custom-objects"),
+      generate: async (svc) => {
+        const workspaceResult = await svc.generateCustomObjectsWorkspace({});
+        return {
+          ...workspaceResult,
+          files: workspaceResult.files.map((f) => ({ ...f, precious: true }))
+        };
+      }
+    };
+  }
+  if (options.templateId === "custom-object") {
+    const objectName = options.name;
+    if (!objectName) {
+      throw new Error("--name is required when --template-id is 'custom-object'");
+    }
+    return {
+      label: `custom-object:${objectName}`,
+      workspaceDir: () => packageDir ?? import_node_path3.default.join(projectRoot, "custom-objects"),
+      generate: async (svc) => {
+        const customObjectsWorkspaceDir = packageDir ?? import_node_path3.default.join(projectRoot, "custom-objects");
+        const workspaceExists = (0, import_node_fs2.existsSync)(import_node_path3.default.join(customObjectsWorkspaceDir, "package.json")) && (0, import_node_fs2.existsSync)(import_node_path3.default.join(customObjectsWorkspaceDir, "tsconfig.json"));
+        const objectResult = await svc.generateCustomObject({ name: objectName });
+        if (workspaceExists) {
+          return objectResult;
+        }
+        const workspaceResult = await svc.generateCustomObjectsWorkspace({});
+        return {
+          ...objectResult,
+          files: [
+            ...workspaceResult.files.map((f) => ({ ...f, precious: true })),
+            ...objectResult.files
+          ]
+        };
+      },
+      finalize: async (_svc, _meta, root, _output, context) => {
+        context.ux.log("\nUpdating stripe-app.yaml...");
+        const manifestPath = import_node_path3.default.join(root, "stripe-app.yaml");
+        const manifest = await (0, import_extensibility_tool_utils11._openStripeAppManifest)(manifestPath);
+        const apiName = (0, import_extensibility_tool_utils11._toSnakeCase)(objectName);
+        if (!manifest.hasCustomObject(apiName)) {
+          manifest.addCustomObject(apiName, `custom-objects/src/${apiName}.object.ts`);
+          const tx = (0, import_extensibility_tool_utils11._beginTransaction)();
+          tx.adopt(manifest);
+          const report = await tx.commit();
+          if (report.written.length > 0) {
+            context.ux.log("\u2713 Updated stripe-app.yaml");
+          }
+        } else {
+          context.ux.log("- Custom object already registered in stripe-app.yaml");
+        }
+      }
+    };
+  }
+  const interfaceId = options.templateId;
+  function buildRemoteFunctionMethodsAndEndpoints(extensionId, outputMethods) {
+    const methods2 = {};
+    const endpoints = Object.entries(outputMethods).map(([methodName, methodConfig]) => {
+      const endpointId = `${extensionId}.${methodName}`;
+      const customInput = typeof methodConfig === "object" && methodConfig !== null && "custom_input" in methodConfig ? Reflect.get(methodConfig, "custom_input") : void 0;
+      methods2[methodName] = {
+        implementation_type: "remote_function",
+        ...customInput !== void 0 && { custom_input: customInput },
+        endpoint_id: endpointId
+      };
+      return {
+        id: endpointId,
+        type: "remote_function",
+        live: { url: "https://example.com/" }
+      };
+    });
+    return { methods: methods2, endpoints };
+  }
+  return {
+    label: interfaceId,
+    workspaceDir: (meta) => packageDir ?? import_node_path3.default.join(projectRoot, "extensions", meta.id),
+    generate: (svc, meta) => svc.generateExtension(interfaceId, {
+      id: meta.id,
+      name: meta.name,
+      version: meta.version
+    }),
+    finalize: async (svc, meta, root, output, context) => {
+      if (!output.methods) return;
+      context.ux.log("\nUpdating stripe-app.yaml...");
+      const manifest = await svc.loadManifest(import_node_path3.default.join(root, "stripe-app.yaml"));
+      const permissions = [];
+      const baseConfig = {
+        id: meta.id,
+        name: meta.name,
+        interface_id: interfaceId,
+        version: meta.version,
+        permissions
+      };
+      if (options.implementationType === "remote-function") {
+        const { methods: methods2, endpoints } = buildRemoteFunctionMethodsAndEndpoints(
+          meta.id,
+          output.methods
+        );
+        manifest.addOrUpdateExtension({ ...baseConfig, methods: methods2, endpoints });
+      } else {
+        manifest.addOrUpdateExtension({
+          ...baseConfig,
+          script: {
+            type: "typescript",
+            content: `extensions/${meta.id}/src/index.ts`
+          },
+          methods: output.methods,
+          configuration: {
+            input_schema: {
+              type: "json_schema",
+              content: `extensions/${meta.id}/generated/config.schema.json`
+            },
+            ui_schema: {
+              type: "jsonforms",
+              content: `extensions/${meta.id}/generated/config.ui.json`
+            }
+          }
+        });
+      }
+      await manifest.save();
+    }
+  };
+}
+var _defaultServices = {
+  generateRoot: (vars) => _rootTemplateManager.generate(vars),
+  generateExtension: (key, vars) => _templateManager.generate(key, vars),
+  generateCustomObject: async (vars) => {
+    const plan = await import_internal._customObjectGenerators.plan(vars, {
+      scope: "project",
+      projectRoot: process.cwd()
+    });
+    return {
+      files: plan.files.map((f) => ({ path: f.path, content: f.content }))
+    };
+  },
+  generateCustomObjectsWorkspace: async (vars) => {
+    const runner = new import_extensibility_tool_utils11._GeneratorRunner(import_internal._customObjectsWorkspaceGenerator);
+    const plan = await runner.plan(vars, {
+      scope: "project",
+      projectRoot: process.cwd()
+    });
+    return {
+      files: plan.files.map((f) => ({ path: f.path, content: f.content }))
+    };
+  },
+  writeFiles: _writeGeneratedFiles,
+  createDepManager: ({ cwd, context }) => new _DependencyManager({ cwd, ...context !== void 0 && { context } }),
+  loadManifest: (manifestPath) => _StripeAppManifest.load(manifestPath),
+  runHooks: runPostGenerationHooks
+};
+async function _regenAppProjectWorkspace(options, services = _defaultServices, context = (0, import_extensibility_tool_utils11._createCliContext)()) {
+  const isCustomObjectMode = options.templateId === "custom-object";
+  if (!isCustomObjectMode && !options.packageDir && !options.workspaceId) {
+    throw new Error("At least one of packageDir or workspaceId is required");
+  }
+  const projectRoot = import_node_path3.default.resolve(options.root ?? ".");
+  const packageDir = options.packageDir ? import_node_path3.default.resolve(options.packageDir) : void 0;
+  const mode = resolveMode(options, projectRoot, packageDir);
+  const metadata = isCustomObjectMode ? { id: "", name: "", version: "" } : await _resolvePackageMetadata(
+    options.workspaceId,
+    options.workspaceName,
+    packageDir
+  );
+  const workspaceDir = mode.workspaceDir(metadata);
+  const isRootRegen = options.templateId === void 0;
+  context.ux.log(`Generating files from template: ${mode.label}...`);
+  const templateOutput = await mode.generate(services, metadata);
+  const allFiles = isRootRegen ? [
+    ...templateOutput.files,
+    ...await backfillMissingExtensionEslintConfigs(services, projectRoot)
+  ] : templateOutput.files;
+  const filesToWrite = options.implementationType === "remote-function" ? allFiles.filter((f) => f.path.endsWith(".schema.json")) : allFiles;
+  if (isRootRegen) {
+    const existingPkgPath = import_node_path3.default.join(projectRoot, "package.json");
+    let existingOverrides;
+    try {
+      const existingPkg = JSON.parse(await (0, import_promises5.readFile)(existingPkgPath, "utf-8"));
+      existingOverrides = existingPkg.pnpm?.overrides;
+    } catch {
+    }
+    if (existingOverrides && Object.keys(existingOverrides).length > 0) {
+      const pkgFile = filesToWrite.find((f) => f.path === "package.json");
+      if (pkgFile) {
+        let newPkg;
+        try {
+          newPkg = JSON.parse(pkgFile.content);
+        } catch (err) {
+          throw new Error(
+            `Failed to parse generated package.json while preserving pnpm.overrides: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        newPkg.pnpm = {
+          ...newPkg.pnpm,
+          overrides: { ...newPkg.pnpm?.overrides, ...existingOverrides }
+        };
+        pkgFile.content = JSON.stringify(newPkg, null, 2) + "\n";
+      }
+    }
+  }
+  if (isRootRegen) {
+    const existingPkgPath = import_node_path3.default.join(projectRoot, "package.json");
+    try {
+      const existingPkg = JSON.parse(await (0, import_promises5.readFile)(existingPkgPath, "utf-8"));
+      const existingOverrides = existingPkg.pnpm?.overrides;
+      if (existingOverrides && Object.keys(existingOverrides).length > 0) {
+        const pkgFile = filesToWrite.find((f) => f.path === "package.json");
+        if (pkgFile) {
+          const newPkg = JSON.parse(pkgFile.content);
+          newPkg.pnpm = {
+            ...newPkg.pnpm,
+            overrides: { ...newPkg.pnpm?.overrides, ...existingOverrides }
+          };
+          pkgFile.content = JSON.stringify(newPkg, null, 2) + "\n";
+        }
+      }
+    } catch {
+    }
+  }
+  context.ux.log("Writing files...");
+  const writeResult = await services.writeFiles(filesToWrite, {
+    cwd: projectRoot,
+    write: options.force ? "overwrite-all" : (path5, cwd, newContent) => _advancedDiffPrompt(path5, cwd, newContent),
+    onFileWritten: (file, wasOverwrite) => {
+      const verb = wasOverwrite ? "Updated" : "Wrote";
+      context.ux.log(`\u2713 ${verb} ${file.path}`);
+    },
+    onFileSkipped: (file) => {
+      context.ux.log(`- Skipped ${file.path}`);
+    },
+    onFileIdentical: (file) => {
+      context.ux.log(`= Identical ${file.path}`);
+    }
+  });
+  if (writeResult.aborted) {
+    context.ux.log("\nAborted by user.");
+    return;
+  }
+  if (options.implementationType !== "remote-function" && !options.skipDependencies && templateOutput.dependencies) {
+    context.ux.log("\nInstalling dependencies...");
+    const allDeps = [
+      ...templateOutput.dependencies.runtime ?? [],
+      ...templateOutput.dependencies.dev ?? []
+    ];
+    await installDependencies(services, workspaceDir, allDeps, context);
+  }
+  if (options.implementationType !== "remote-function" && !options.skipDependencies && !isRootRegen && !isCustomObjectMode) {
+    await installDependencies(
+      services,
+      projectRoot,
+      [
+        _devNpmDep(
+          EXTENSIBILITY_ESLINT_PLUGIN_PACKAGE_NAME,
+          EXTENSIBILITY_ESLINT_PLUGIN_VERSION
+        )
+      ],
+      context
+    );
+  }
+  await mode.finalize?.(services, metadata, projectRoot, templateOutput, context);
+  if (options.implementationType !== "remote-function" && !options.skipHooks) {
+    await services.runHooks(
+      templateOutput.postGenerationHooks,
+      workspaceDir,
+      false,
+      context
+    );
+  }
+  context.ux.log("\n\u2713 Regeneration complete");
+}
+
+// src/bin/rpc/handlers.ts
+var import_extensibility_tool_utils12 = require("@stripe/extensibility-tool-utils");
+function handleGetTemplateInfo() {
+  return Promise.resolve(_templateManager.getTemplateInfo().filter((t) => !t.hidden));
+}
+async function handleGenWorkspace(params) {
+  const parsed = _regenWorkspaceOptionsSchema.safeParse(params);
+  if (!parsed.success) {
+    throw new RpcInvalidParamsError(parsed.error.issues.map((i) => i.message).join("; "));
+  }
+  if (!parsed.data.packageDir && !parsed.data.workspaceId) {
+    throw new RpcInvalidParamsError(
+      "At least one of packageDir or workspaceId is required"
+    );
+  }
+  const ctx = (0, import_extensibility_tool_utils12._createCliContext)({ ux: new import_extensibility_tool_utils12._CliUx({ stdout: process.stderr }) });
+  await _regenAppProjectWorkspace(parsed.data, void 0, ctx);
+  return {};
+}
+var methods = /* @__PURE__ */ new Map([
+  ["getTemplateInfo", handleGetTemplateInfo],
+  ["genWorkspace", handleGenWorkspace]
+]);
+
+// src/bin/dev-tools-rpc.ts
+var logger3 = (0, import_extensibility_tool_utils13._createLogger)({ name: "dev-tools-rpc" });
+logger3.warn(
+  "dev-tools-rpc is deprecated and will be removed in a future release. Upgrade @stripe/stripe-cli-generate-plugin to use the new CLI tools."
+);
+var stderrWrite = (...args) => {
+  process.stderr.write(args.map(String).join(" ") + "\n");
+};
+console.log = stderrWrite;
+console.info = stderrWrite;
+console.debug = stderrWrite;
+console.warn = stderrWrite;
+function readStdin(timeoutMs = 3e4) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const timer = setTimeout(() => {
+      reject(new Error(`stdin read timed out after ${String(timeoutMs)}ms`));
+    }, timeoutMs);
+    process.stdin.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve(Buffer.concat(chunks).toString());
+    });
+    process.stdin.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+async function main() {
+  const raw = await readStdin();
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    const response2 = {
+      error: { code: "INVALID_REQUEST", message: "Invalid JSON on stdin" }
+    };
+    process.stdout.write(JSON.stringify(response2) + "\n");
+    process.exit(1);
+  }
+  const response = await dispatch(parsed, methods);
+  process.stdout.write(JSON.stringify(response) + "\n");
+  if ("error" in response) {
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  const response = {
+    error: { code: "INTERNAL_ERROR", message }
+  };
+  process.stdout.write(JSON.stringify(response) + "\n");
+  process.exit(1);
+});