@aws/nx-plugin 1.0.0-rc.9 → 1.0.0-rc.90

package/src/utils/init.js

@@ -0,0 +1,300 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { generateFiles, joinPathFragments, OverwriteStrategy, readNxJson, updateJson, updateNxJson } from "@nx/devkit";
+import { initGenerator } from "@nx/js";
+import yaml from "js-yaml";
+import { SYNC_GENERATOR_NAME as TS_SYNC_GENERATOR_NAME } from "../ts/sync/generator.js";
+import { BASE_TSCONFIG_COMPILER_OPTIONS } from "./base-tsconfig.js";
+import { ensureAwsNxPluginConfig, updateAwsNxPluginConfig } from "./config/utils.js";
+import { inferContainers } from "./containers.js";
+import { forDependencies } from "./declared-dependencies.js";
+import { addDependenciesToPackageJson, detectWorkspacePackageManager } from "./dependencies.js";
+import { getDefaultBiomeConfig } from "./format.js";
+import { describeGeneratorForCatalogue, generatorsJsonEntries } from "./generators.js";
+import { configureMcpServers } from "./mcp.js";
+import { getNpmScope } from "./npm-scope.js";
+import { mergeTargetDefault, nxPluginMcpDependency, nxPluginSelfDependency } from "./nx.js";
+import { getPackageManagerDisplayCommands } from "./pkg-manager.js";
+import { workspaceGlobs } from "./project-package-json.js";
+import { withVersions } from "./versions.js";
+const WORKSPACES = [
+    'packages/*'
+];
+const NX_TYPESCRIPT_SYNC_GENERATOR = '@nx/js:typescript-sync';
+export const DEFAULT_PARALLEL = 8;
+/** Dependencies a caller must declare to apply the workspace init. */ export const INIT_DEPENDENCIES = [
+    {
+        name: 'nx'
+    },
+    {
+        name: '@nx/js'
+    },
+    {
+        name: '@nx/workspace'
+    },
+    {
+        name: 'typescript'
+    },
+    {
+        name: '@biomejs/biome'
+    }
+];
+// Built dependencies whose install scripts the generated workspace trusts.
+// `onlyBuiltDependencies` is the pnpm 10 key (silently ignored by pnpm 11);
+// pnpm 11 reads `allowBuilds` instead. Any dep NOT in this allowlist will
+// have its install scripts skipped with a warning — matching pnpm 10's
+// default behaviour. The user can opt-in later via `pnpm approve-builds`.
+export const PNPM_BUILT_DEPENDENCIES = [
+    '@swc/core',
+    'esbuild',
+    'nx',
+    'sharp'
+];
+/**
+ * Add or repair the pnpm `allowBuilds` / `onlyBuiltDependencies` allowlist for
+ * the workspace's `packages` globs, without clobbering any packages the user
+ * has already declared.
+ *
+ * A workspace not created by the preset commonly has either no
+ * `pnpm-workspace.yaml`, one missing the `packages` globs, or one carrying the
+ * broken `set this to true or false` placeholder pnpm writes when it skips a
+ * build script. This makes the file self-consistent so the first generator's
+ * install doesn't fail with `ERR_PNPM_IGNORED_BUILDS`.
+ */ const setUpPnpmWorkspace = (tree, catalogs)=>{
+    const existing = tree.exists('pnpm-workspace.yaml') ? yaml.load(tree.read('pnpm-workspace.yaml', 'utf-8') ?? '') ?? {} : {};
+    // Preserve any packages globs the user already has, ensuring ours are present.
+    const packages = Array.from(new Set([
+        ...existing.packages ?? [],
+        ...WORKSPACES
+    ]));
+    const allowBuilds = {
+        ...typeof existing.allowBuilds === 'object' && existing.allowBuilds ? existing.allowBuilds : {},
+        // Overwrite any non-boolean (e.g. the "set this to true or false"
+        // placeholder) with an explicit true for the deps we trust.
+        ...Object.fromEntries(PNPM_BUILT_DEPENDENCIES.map((dep)=>[
+                dep,
+                true
+            ]))
+    };
+    // `strict` makes `pnpm add` record new deps in the catalog; it only gates
+    // that flow, so pre-declared direct ranges (e.g. tslib) still install.
+    // Preserve an explicit user choice.
+    const catalogMode = catalogs ? existing.catalogMode ?? 'strict' : existing.catalogMode;
+    tree.write('pnpm-workspace.yaml', yaml.dump({
+        ...existing,
+        packages,
+        allowBuilds,
+        onlyBuiltDependencies: PNPM_BUILT_DEPENDENCIES,
+        ...catalogMode ? {
+            catalogMode
+        } : {}
+    }, {
+        quotingType: "'"
+    }));
+};
+/**
+ * Configure the workspace's package manager for a monorepo layout.
+ *
+ * pnpm workspaces are declared in `pnpm-workspace.yaml`; every other package
+ * manager reads the `workspaces` field of the root `package.json`.
+ */ const setUpWorkspaces = (tree, catalogs)=>{
+    if (detectWorkspacePackageManager(tree) === 'pnpm') {
+        setUpPnpmWorkspace(tree, catalogs);
+    } else {
+        updateJson(tree, 'package.json', (json)=>{
+            // The `workspaces` field may be the object form ({ "packages": [...] })
+            // accepted by yarn and bun — extend the globs while preserving the form.
+            const globs = Array.from(new Set([
+                ...workspaceGlobs(json.workspaces),
+                ...WORKSPACES
+            ]));
+            return {
+                ...json,
+                workspaces: json.workspaces !== undefined && !Array.isArray(json.workspaces) ? {
+                    ...json.workspaces,
+                    packages: globs
+                } : globs
+            };
+        });
+    }
+};
+/**
+ * Ensure the workspace has a `tsconfig.base.json`.
+ *
+ * `@nx/js` `initGenerator` (with `addTsPlugin`) normally creates this, but it
+ * short-circuits when the workspace already has a root `tsconfig.json` — in
+ * which case no base file is written and the next project generator fails with
+ * `Cannot find tsconfig.base.json`. So we create a compatible one when it's
+ * absent. An existing base is left untouched: the user may have tuned it, and
+ * rewriting shared compiler options can break other projects (see the
+ * "add to an existing workspace" guide).
+ */ const ensureBaseTsConfig = (tree)=>{
+    if (tree.exists('tsconfig.base.json')) {
+        return;
+    }
+    tree.write('tsconfig.base.json', JSON.stringify({
+        compilerOptions: {
+            ...BASE_TSCONFIG_COMPILER_OPTIONS,
+            customConditions: [
+                getNpmScope(tree)
+            ]
+        }
+    }, null, 2));
+};
+/**
+ * Ensure the workspace has a root `tsconfig.json`.
+ *
+ * Nx's `@nx/js:typescript-sync` generator hard-fails with
+ * `Missing root "tsconfig.json"` when it's absent. The plugin's TypeScript
+ * projects reference each other via this file, so we guarantee a minimal one
+ * exists (sync populates its `references`).
+ */ const ensureRootTsConfig = (tree)=>{
+    if (tree.exists('tsconfig.json')) {
+        return;
+    }
+    tree.write('tsconfig.json', JSON.stringify({
+        extends: './tsconfig.base.json',
+        files: [],
+        references: []
+    }, null, 2));
+};
+/**
+ * Transform an Nx workspace into one ready to run `@aws/nx-plugin` generators.
+ *
+ * This is the deterministic core shared by the workspace preset and the `init`
+ * generator. It is safe to re-run: every step is idempotent (config merges,
+ * keyed nx.json / package.json entries, create-if-missing files), so running
+ * it against an already-initialised workspace is a no-op.
+ *
+ * It preserves the workspace's module format: the root package.json `type`
+ * field is owned by the preset (written from its `--module` option) and left
+ * untouched here. It does NOT rewrite an existing `tsconfig.base.json`'s
+ * compiler options, migrate a workspace's package manager, or restructure
+ * existing projects — those are decisions for the user (see the "add to an
+ * existing workspace" guide).
+ */ export const applyWorkspaceInit = async (tree, { iac, containers, mcp, readmeOverwriteStrategy = OverwriteStrategy.KeepExisting, overwriteScripts = false, catalogs = true }, declaration)=>{
+    const resolvedContainers = !containers || containers === 'infer' ? inferContainers() : containers;
+    // The catalogs flag is written explicitly (even when true) so the workspace
+    // records its dependency-management choice.
+    await ensureAwsNxPluginConfig(tree);
+    await updateAwsNxPluginConfig(tree, {
+        iac: {
+            provider: iac
+        },
+        containers: {
+            engine: resolvedContainers
+        },
+        packageManager: {
+            catalogs
+        }
+    });
+    // Set up the TypeScript plugin, base tsconfig, formatter etc. `@nx/js`
+    // creates `tsconfig.base.json` when absent, but skips it when a root
+    // `tsconfig.json` already exists — so we ensure both explicitly below.
+    await initGenerator(tree, {
+        formatter: 'none',
+        addTsPlugin: true
+    });
+    ensureBaseTsConfig(tree);
+    ensureRootTsConfig(tree);
+    setUpWorkspaces(tree, catalogs);
+    const nxJson = readNxJson(tree);
+    updateNxJson(tree, {
+        ...nxJson,
+        // Preserve an explicit analytics choice in an existing workspace.
+        analytics: nxJson.analytics ?? false,
+        parallel: nxJson.parallel ?? DEFAULT_PARALLEL,
+        targetDefaults: {
+            ...nxJson.targetDefaults,
+            compile: mergeTargetDefault(nxJson.targetDefaults?.compile, (base)=>({
+                    ...base,
+                    syncGenerators: [
+                        ...(base.syncGenerators ?? []).filter((g)=>![
+                                TS_SYNC_GENERATOR_NAME,
+                                NX_TYPESCRIPT_SYNC_GENERATOR
+                            ].includes(g)),
+                        NX_TYPESCRIPT_SYNC_GENERATOR,
+                        TS_SYNC_GENERATOR_NAME
+                    ]
+                }))
+        }
+    });
+    const CONVENIENCE_SCRIPTS = {
+        dev: 'nx run-many --target dev',
+        build: 'nx run-many --target build',
+        lint: 'nx run-many --target lint --configuration=fix',
+        test: 'nx run-many --target test --all',
+        // Trivy container image scanning is not part of `build` (its result
+        // depends on the ever-changing vulnerability database); run it explicitly,
+        // e.g. in CI.
+        trivy: 'nx run-many --target trivy --all',
+        'build:skip-lint': 'nx run-many --target build --configuration=skip-lint',
+        'build:all': 'nx run-many --target build --all',
+        'affected:all': 'nx affected --target build'
+    };
+    updateJson(tree, 'package.json', (packageJson)=>({
+            ...packageJson,
+            // The root `type` field is owned by the preset (written explicitly from
+            // its `--module` option). `init` preserves an existing workspace's field
+            // as-is: an ESM workspace already carries `type: "module"` (that is how
+            // the format is inferred), and introducing a `type` into a CommonJS
+            // workspace that lacks one changes behaviour for frameworks that parse it
+            // (e.g. Next.js starts treating the app's ESM source as CJS).
+            scripts: overwriteScripts ? {
+                ...packageJson.scripts,
+                ...CONVENIENCE_SCRIPTS
+            } : {
+                ...CONVENIENCE_SCRIPTS,
+                ...packageJson.scripts
+            }
+        }));
+    // Pin the workspace's `nx` to the version the plugin's @nx/* packages are
+    // built against. A mismatched workspace nx (even a patch apart) hoists a
+    // second nested nx under @nx/js, and the two instances deadlock `nx sync`.
+    // `@nx/js` must be a root dependency for the `@nx/js:typescript-sync`
+    // generator registered in nx.json to resolve (npm doesn't hoist the
+    // plugin's own copy reliably).
+    addDependenciesToPackageJson(tree, {}, {
+        ...withVersions(forDependencies(declaration), [
+            'nx',
+            '@nx/js',
+            '@nx/workspace'
+        ]),
+        ...withVersions(forDependencies(declaration), [
+            'typescript',
+            '@biomejs/biome'
+        ]),
+        // Declare the plugin the generators are running from, plus the MCP server
+        // package the vended config runs, so both are pinned in the workspace's
+        // lockfile and upgrading them upgrades what the agents use.
+        ...nxPluginSelfDependency(tree),
+        ...nxPluginMcpDependency(tree)
+    });
+    // Write biome.json for formatting and linting
+    if (!tree.exists('biome.json')) {
+        tree.write('biome.json', JSON.stringify(getDefaultBiomeConfig(tree), null, 2));
+    }
+    generateFiles(tree, joinPathFragments(import.meta.dirname, '..', 'preset', 'files'), '.', {
+        projectName: getNpmScope(tree),
+        generators: Object.entries(generatorsJsonEntries).filter(([, info])=>!info.hidden).map(([id, info])=>({
+                name: id,
+                description: describeGeneratorForCatalogue(info)
+            })),
+        ...(()=>{
+            const cmds = getPackageManagerDisplayCommands();
+            return {
+                pkgMgrCmd: cmds.exec,
+                buildCmd: `${cmds.run} build`,
+                lintCmd: `${cmds.run} lint`
+            };
+        })()
+    }, {
+        overwriteStrategy: readmeOverwriteStrategy
+    });
+    if (mcp !== false) {
+        configureMcpServers(tree);
+    }
+};
+
+//# sourceMappingURL=init.js.map

package/src/utils/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/init.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport {\n  generateFiles,\n  joinPathFragments,\n  OverwriteStrategy,\n  readNxJson,\n  type Tree,\n  updateJson,\n  updateNxJson,\n} from '@nx/devkit';\nimport { initGenerator } from '@nx/js';\nimport { readFileSync } from 'fs';\nimport yaml from 'js-yaml';\nimport { SYNC_GENERATOR_NAME as TS_SYNC_GENERATOR_NAME } from '../ts/sync/generator.js';\nimport { BASE_TSCONFIG_COMPILER_OPTIONS } from './base-tsconfig.js';\nimport {\n  ensureAwsNxPluginConfig,\n  updateAwsNxPluginConfig,\n} from './config/utils.js';\nimport { type Containers, inferContainers } from './containers.js';\nimport {\n  type DependencyDeclaration,\n  forDependencies,\n  type MustDeclare,\n} from './declared-dependencies.js';\nimport {\n  addDependenciesToPackageJson,\n  detectWorkspacePackageManager,\n} from './dependencies.js';\nimport { getDefaultBiomeConfig } from './format.js';\nimport {\n  describeGeneratorForCatalogue,\n  generatorsJsonEntries,\n} from './generators.js';\nimport type { Iac } from './iac.js';\nimport { configureMcpServers } from './mcp.js';\nimport { getNpmScope } from './npm-scope.js';\nimport {\n  mergeTargetDefault,\n  nxPluginMcpDependency,\n  nxPluginSelfDependency,\n} from './nx.js';\nimport { getPackageManagerDisplayCommands } from './pkg-manager.js';\nimport { workspaceGlobs } from './project-package-json.js';\nimport { type ITsDepVersion, withVersions } from './versions.js';\n\nconst WORKSPACES = ['packages/*'];\nconst NX_TYPESCRIPT_SYNC_GENERATOR = '@nx/js:typescript-sync';\n\nexport const DEFAULT_PARALLEL = 8;\n\n/** Dependencies a caller must declare to apply the workspace init. */\nexport const INIT_DEPENDENCIES = [\n  { name: 'nx' },\n  { name: '@nx/js' },\n  { name: '@nx/workspace' },\n  { name: 'typescript' },\n  { name: '@biomejs/biome' },\n] as const satisfies readonly { name: ITsDepVersion }[];\n\n// Built dependencies whose install scripts the generated workspace trusts.\n// `onlyBuiltDependencies` is the pnpm 10 key (silently ignored by pnpm 11);\n// pnpm 11 reads `allowBuilds` instead. Any dep NOT in this allowlist will\n// have its install scripts skipped with a warning — matching pnpm 10's\n// default behaviour. The user can opt-in later via `pnpm approve-builds`.\nexport const PNPM_BUILT_DEPENDENCIES = ['@swc/core', 'esbuild', 'nx', 'sharp'];\n\n/**\n * Options controlling how the workspace is initialised. These mirror the\n * preset schema so a workspace created via the preset and one initialised via\n * the `init` generator end up in the same shape.\n */\nexport interface ApplyWorkspaceInitOptions {\n  /** The IaC provider to record in the plugin config. */\n  readonly iac: Iac;\n  /**\n   * The container engine to record. `undefined`/`'infer'` picks docker when\n   * installed, else finch.\n   */\n  readonly containers?: Containers | 'infer';\n  /** Whether to configure MCP servers for coding agents. Defaults to true. */\n  readonly mcp?: boolean;\n  /**\n   * How to treat the generated workspace README. The preset owns the README of\n   * a greenfield workspace (`Overwrite`); the `init` generator must not clobber\n   * an existing workspace's README (`KeepExisting`, the default).\n   */\n  readonly readmeOverwriteStrategy?: OverwriteStrategy;\n  /**\n   * Whether to overwrite root package.json scripts that already exist. The\n   * preset owns a greenfield workspace's scripts (`true`); the `init`\n   * generator must not clobber an existing workspace's scripts (`false`,\n   * the default) — it only adds the convenience scripts that are absent.\n   */\n  readonly overwriteScripts?: boolean;\n  /**\n   * Whether generators use the package manager's dependency catalog. On pnpm\n   * this also sets `catalogMode: strict` so `pnpm add` records new deps in the\n   * catalog. Defaults to true.\n   */\n  readonly catalogs?: boolean;\n}\n\n/**\n * Add or repair the pnpm `allowBuilds` / `onlyBuiltDependencies` allowlist for\n * the workspace's `packages` globs, without clobbering any packages the user\n * has already declared.\n *\n * A workspace not created by the preset commonly has either no\n * `pnpm-workspace.yaml`, one missing the `packages` globs, or one carrying the\n * broken `set this to true or false` placeholder pnpm writes when it skips a\n * build script. This makes the file self-consistent so the first generator's\n * install doesn't fail with `ERR_PNPM_IGNORED_BUILDS`.\n */\nconst setUpPnpmWorkspace = (tree: Tree, catalogs: boolean) => {\n  const existing = tree.exists('pnpm-workspace.yaml')\n    ? ((yaml.load(tree.read('pnpm-workspace.yaml', 'utf-8') ?? '') as Record<\n        string,\n        unknown\n      >) ?? {})\n    : {};\n\n  // Preserve any packages globs the user already has, ensuring ours are present.\n  const packages = Array.from(\n    new Set([...((existing.packages as string[]) ?? []), ...WORKSPACES]),\n  );\n\n  const allowBuilds = {\n    ...(typeof existing.allowBuilds === 'object' && existing.allowBuilds\n      ? (existing.allowBuilds as Record<string, unknown>)\n      : {}),\n    // Overwrite any non-boolean (e.g. the \"set this to true or false\"\n    // placeholder) with an explicit true for the deps we trust.\n    ...Object.fromEntries(PNPM_BUILT_DEPENDENCIES.map((dep) => [dep, true])),\n  };\n\n  // `strict` makes `pnpm add` record new deps in the catalog; it only gates\n  // that flow, so pre-declared direct ranges (e.g. tslib) still install.\n  // Preserve an explicit user choice.\n  const catalogMode = catalogs\n    ? (existing.catalogMode ?? 'strict')\n    : existing.catalogMode;\n\n  tree.write(\n    'pnpm-workspace.yaml',\n    yaml.dump(\n      {\n        ...existing,\n        packages,\n        allowBuilds,\n        onlyBuiltDependencies: PNPM_BUILT_DEPENDENCIES,\n        ...(catalogMode ? { catalogMode } : {}),\n      },\n      { quotingType: \"'\" },\n    ),\n  );\n};\n\n/**\n * Configure the workspace's package manager for a monorepo layout.\n *\n * pnpm workspaces are declared in `pnpm-workspace.yaml`; every other package\n * manager reads the `workspaces` field of the root `package.json`.\n */\nconst setUpWorkspaces = (tree: Tree, catalogs: boolean) => {\n  if (detectWorkspacePackageManager(tree) === 'pnpm') {\n    setUpPnpmWorkspace(tree, catalogs);\n  } else {\n    updateJson(tree, 'package.json', (json) => {\n      // The `workspaces` field may be the object form ({ \"packages\": [...] })\n      // accepted by yarn and bun — extend the globs while preserving the form.\n      const globs = Array.from(\n        new Set([...workspaceGlobs(json.workspaces), ...WORKSPACES]),\n      );\n      return {\n        ...json,\n        workspaces:\n          json.workspaces !== undefined && !Array.isArray(json.workspaces)\n            ? { ...json.workspaces, packages: globs }\n            : globs,\n      };\n    });\n  }\n};\n\n/**\n * Ensure the workspace has a `tsconfig.base.json`.\n *\n * `@nx/js` `initGenerator` (with `addTsPlugin`) normally creates this, but it\n * short-circuits when the workspace already has a root `tsconfig.json` — in\n * which case no base file is written and the next project generator fails with\n * `Cannot find tsconfig.base.json`. So we create a compatible one when it's\n * absent. An existing base is left untouched: the user may have tuned it, and\n * rewriting shared compiler options can break other projects (see the\n * \"add to an existing workspace\" guide).\n */\nconst ensureBaseTsConfig = (tree: Tree) => {\n  if (tree.exists('tsconfig.base.json')) {\n    return;\n  }\n  tree.write(\n    'tsconfig.base.json',\n    JSON.stringify(\n      {\n        compilerOptions: {\n          ...BASE_TSCONFIG_COMPILER_OPTIONS,\n          customConditions: [getNpmScope(tree)],\n        },\n      },\n      null,\n      2,\n    ),\n  );\n};\n\n/**\n * Ensure the workspace has a root `tsconfig.json`.\n *\n * Nx's `@nx/js:typescript-sync` generator hard-fails with\n * `Missing root \"tsconfig.json\"` when it's absent. The plugin's TypeScript\n * projects reference each other via this file, so we guarantee a minimal one\n * exists (sync populates its `references`).\n */\nconst ensureRootTsConfig = (tree: Tree) => {\n  if (tree.exists('tsconfig.json')) {\n    return;\n  }\n  tree.write(\n    'tsconfig.json',\n    JSON.stringify(\n      {\n        extends: './tsconfig.base.json',\n        files: [],\n        references: [],\n      },\n      null,\n      2,\n    ),\n  );\n};\n\n/**\n * Transform an Nx workspace into one ready to run `@aws/nx-plugin` generators.\n *\n * This is the deterministic core shared by the workspace preset and the `init`\n * generator. It is safe to re-run: every step is idempotent (config merges,\n * keyed nx.json / package.json entries, create-if-missing files), so running\n * it against an already-initialised workspace is a no-op.\n *\n * It preserves the workspace's module format: the root package.json `type`\n * field is owned by the preset (written from its `--module` option) and left\n * untouched here. It does NOT rewrite an existing `tsconfig.base.json`'s\n * compiler options, migrate a workspace's package manager, or restructure\n * existing projects — those are decisions for the user (see the \"add to an\n * existing workspace\" guide).\n */\nexport const applyWorkspaceInit = async <const D extends DependencyDeclaration>(\n  tree: Tree,\n  {\n    iac,\n    containers,\n    mcp,\n    readmeOverwriteStrategy = OverwriteStrategy.KeepExisting,\n    overwriteScripts = false,\n    catalogs = true,\n  }: ApplyWorkspaceInitOptions,\n  declaration: D & MustDeclare<typeof INIT_DEPENDENCIES, D>,\n) => {\n  const resolvedContainers =\n    !containers || containers === 'infer' ? inferContainers() : containers;\n\n  // The catalogs flag is written explicitly (even when true) so the workspace\n  // records its dependency-management choice.\n  await ensureAwsNxPluginConfig(tree);\n  await updateAwsNxPluginConfig(tree, {\n    iac: { provider: iac },\n    containers: { engine: resolvedContainers },\n    packageManager: { catalogs },\n  });\n\n  // Set up the TypeScript plugin, base tsconfig, formatter etc. `@nx/js`\n  // creates `tsconfig.base.json` when absent, but skips it when a root\n  // `tsconfig.json` already exists — so we ensure both explicitly below.\n  await initGenerator(tree, {\n    formatter: 'none',\n    addTsPlugin: true,\n  });\n\n  ensureBaseTsConfig(tree);\n  ensureRootTsConfig(tree);\n\n  setUpWorkspaces(tree, catalogs);\n\n  const nxJson = readNxJson(tree);\n  updateNxJson(tree, {\n    ...nxJson,\n    // Preserve an explicit analytics choice in an existing workspace.\n    analytics: (nxJson as { analytics?: boolean }).analytics ?? false,\n    parallel: nxJson.parallel ?? DEFAULT_PARALLEL,\n    targetDefaults: {\n      ...nxJson.targetDefaults,\n      compile: mergeTargetDefault(nxJson.targetDefaults?.compile, (base) => ({\n        ...base,\n        syncGenerators: [\n          ...(base.syncGenerators ?? []).filter(\n            (g) =>\n              ![TS_SYNC_GENERATOR_NAME, NX_TYPESCRIPT_SYNC_GENERATOR].includes(\n                g,\n              ),\n          ),\n          NX_TYPESCRIPT_SYNC_GENERATOR,\n          TS_SYNC_GENERATOR_NAME,\n        ],\n      })),\n    },\n  });\n\n  const CONVENIENCE_SCRIPTS = {\n    dev: 'nx run-many --target dev',\n    build: 'nx run-many --target build',\n    lint: 'nx run-many --target lint --configuration=fix',\n    test: 'nx run-many --target test --all',\n    // Trivy container image scanning is not part of `build` (its result\n    // depends on the ever-changing vulnerability database); run it explicitly,\n    // e.g. in CI.\n    trivy: 'nx run-many --target trivy --all',\n    'build:skip-lint': 'nx run-many --target build --configuration=skip-lint',\n    'build:all': 'nx run-many --target build --all',\n    'affected:all': 'nx affected --target build',\n  };\n  updateJson(tree, 'package.json', (packageJson) => ({\n    ...packageJson,\n    // The root `type` field is owned by the preset (written explicitly from\n    // its `--module` option). `init` preserves an existing workspace's field\n    // as-is: an ESM workspace already carries `type: \"module\"` (that is how\n    // the format is inferred), and introducing a `type` into a CommonJS\n    // workspace that lacks one changes behaviour for frameworks that parse it\n    // (e.g. Next.js starts treating the app's ESM source as CJS).\n    scripts: overwriteScripts\n      ? { ...packageJson.scripts, ...CONVENIENCE_SCRIPTS }\n      : { ...CONVENIENCE_SCRIPTS, ...packageJson.scripts },\n  }));\n\n  // Pin the workspace's `nx` to the version the plugin's @nx/* packages are\n  // built against. A mismatched workspace nx (even a patch apart) hoists a\n  // second nested nx under @nx/js, and the two instances deadlock `nx sync`.\n  // `@nx/js` must be a root dependency for the `@nx/js:typescript-sync`\n  // generator registered in nx.json to resolve (npm doesn't hoist the\n  // plugin's own copy reliably).\n  addDependenciesToPackageJson(\n    tree,\n    {},\n    {\n      ...withVersions(forDependencies<typeof INIT_DEPENDENCIES>(declaration), [\n        'nx',\n        '@nx/js',\n        '@nx/workspace',\n      ]),\n      ...withVersions(forDependencies<typeof INIT_DEPENDENCIES>(declaration), [\n        'typescript',\n        '@biomejs/biome',\n      ]),\n      // Declare the plugin the generators are running from, plus the MCP server\n      // package the vended config runs, so both are pinned in the workspace's\n      // lockfile and upgrading them upgrades what the agents use.\n      ...nxPluginSelfDependency(tree),\n      ...nxPluginMcpDependency(tree),\n    },\n  );\n\n  // Write biome.json for formatting and linting\n  if (!tree.exists('biome.json')) {\n    tree.write(\n      'biome.json',\n      JSON.stringify(getDefaultBiomeConfig(tree), null, 2),\n    );\n  }\n\n  generateFiles(\n    tree, // the virtual file system\n    joinPathFragments(import.meta.dirname, '..', 'preset', 'files'),\n    '.',\n    {\n      projectName: getNpmScope(tree),\n      generators: Object.entries(generatorsJsonEntries)\n        .filter(([, info]) => !info.hidden)\n        .map(([id, info]) => ({\n          name: id,\n          description: describeGeneratorForCatalogue(info),\n        })),\n      ...(() => {\n        const cmds = getPackageManagerDisplayCommands();\n        return {\n          pkgMgrCmd: cmds.exec,\n          buildCmd: `${cmds.run} build`,\n          lintCmd: `${cmds.run} lint`,\n        };\n      })(),\n    },\n    {\n      overwriteStrategy: readmeOverwriteStrategy,\n    },\n  );\n\n  if (mcp !== false) {\n    configureMcpServers(tree);\n  }\n};\n"],"names":["generateFiles","joinPathFragments","OverwriteStrategy","readNxJson","updateJson","updateNxJson","initGenerator","yaml","SYNC_GENERATOR_NAME","TS_SYNC_GENERATOR_NAME","BASE_TSCONFIG_COMPILER_OPTIONS","ensureAwsNxPluginConfig","updateAwsNxPluginConfig","inferContainers","forDependencies","addDependenciesToPackageJson","detectWorkspacePackageManager","getDefaultBiomeConfig","describeGeneratorForCatalogue","generatorsJsonEntries","configureMcpServers","getNpmScope","mergeTargetDefault","nxPluginMcpDependency","nxPluginSelfDependency","getPackageManagerDisplayCommands","workspaceGlobs","withVersions","WORKSPACES","NX_TYPESCRIPT_SYNC_GENERATOR","DEFAULT_PARALLEL","INIT_DEPENDENCIES","name","PNPM_BUILT_DEPENDENCIES","setUpPnpmWorkspace","tree","catalogs","existing","exists","load","read","packages","Array","from","Set","allowBuilds","Object","fromEntries","map","dep","catalogMode","write","dump","onlyBuiltDependencies","quotingType","setUpWorkspaces","json","globs","workspaces","undefined","isArray","ensureBaseTsConfig","JSON","stringify","compilerOptions","customConditions","ensureRootTsConfig","extends","files","references","applyWorkspaceInit","iac","containers","mcp","readmeOverwriteStrategy","KeepExisting","overwriteScripts","declaration","resolvedContainers","provider","engine","packageManager","formatter","addTsPlugin","nxJson","analytics","parallel","targetDefaults","compile","base","syncGenerators","filter","g","includes","CONVENIENCE_SCRIPTS","dev","build","lint","test","trivy","packageJson","scripts","dirname","projectName","generators","entries","info","hidden","id","description","cmds","pkgMgrCmd","exec","buildCmd","run","lintCmd","overwriteStrategy"],"mappings":"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"}

package/src/utils/install.d.ts

@@ -0,0 +1,32 @@
+import { type Tree } from '@nx/devkit';
+import type { ITsDepVersion } from './versions.js';
+/**
+ * Languages whose dependencies a generator may install.
+ */
+export type InstallLanguage = 'typescript' | 'python';
+export interface InstallDependenciesOptions {
+    /** Languages to install dependencies for. */
+    languages: InstallLanguage[];
+    /**
+     * Packages that must resolve from the workspace after this generator, because
+     * a config file it writes (e.g. `vite.config.mts`) imports them and Nx loads
+     * that config when computing the project graph. When the caller prefers to
+     * defer installing, we honour that only if these already resolve.
+     *
+     * The per-language graph deps in `LANGUAGE_GRAPH_DEPS` are always included, so
+     * callers only list packages beyond those.
+     */
+    ensureResolvable?: ITsDepVersion[];
+}
+/**
+ * Installs dependencies for the given languages.
+ *
+ * Call from a generator's returned callback:
+ * `return () => installDependencies(tree, options.preferInstallDependencies, { ... })`.
+ *
+ * `preferInstallDependencies` is a preference: when `false` the install is
+ * deferred so a batch installs once at the end — unless an `ensureResolvable`
+ * package is missing, in which case it runs anyway so the next `nx` command can
+ * still compute the project graph.
+ */
+export declare const installDependencies: (tree: Tree, preferInstallDependencies: boolean | undefined, options: InstallDependenciesOptions) => Promise<void>;

package/src/utils/install.js

@@ -0,0 +1,58 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { installPackagesTask } from "@nx/devkit";
+import { Logger, UVProvider } from "./nxlv-python.js";
+/**
+ * Packages each language always needs resolvable for Nx to compute the project
+ * graph, so a deferred install still runs whenever it would otherwise break.
+ */ const LANGUAGE_GRAPH_DEPS = {
+    typescript: [
+        'vitest'
+    ],
+    python: [
+        '@nxlv/python'
+    ]
+};
+/**
+ * Returns true if every package is linked at `<root>/node_modules/<pkg>`.
+ *
+ * This is the condition Nx's inferred plugins need when they load a generated
+ * config (e.g. `vite.config.mts`) during graph computation: the config's
+ * imports resolve from inside the workspace's own `node_modules`. We avoid
+ * `require.resolve`, which can succeed via an ancestor `node_modules` even when
+ * the package isn't linked here. `existsSync` follows symlinks, so pnpm's store
+ * links resolve, and Nx always uses a `node_modules` linker (never PnP).
+ */ const allResolvable = (root, packages)=>packages.every((pkg)=>existsSync(join(root, 'node_modules', pkg)));
+/**
+ * Installs dependencies for the given languages.
+ *
+ * Call from a generator's returned callback:
+ * `return () => installDependencies(tree, options.preferInstallDependencies, { ... })`.
+ *
+ * `preferInstallDependencies` is a preference: when `false` the install is
+ * deferred so a batch installs once at the end — unless an `ensureResolvable`
+ * package is missing, in which case it runs anyway so the next `nx` command can
+ * still compute the project graph.
+ */ export const installDependencies = async (tree, preferInstallDependencies, options)=>{
+    const { languages, ensureResolvable = [] } = options;
+    const mustResolve = [
+        ...ensureResolvable,
+        ...languages.flatMap((language)=>LANGUAGE_GRAPH_DEPS[language])
+    ];
+    if (preferInstallDependencies === false && allResolvable(tree.root, mustResolve)) {
+        return;
+    }
+    if (languages.includes('typescript')) {
+        // Force the install: devkit's default only installs when the root
+        // package.json changed, but deps land in per-project manifests.
+        installPackagesTask(tree, true);
+    }
+    if (languages.includes('python')) {
+        await new UVProvider(tree.root, new Logger(), tree).install();
+    }
+};
+
+//# sourceMappingURL=install.js.map

package/src/utils/install.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/install.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport { existsSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { installPackagesTask, type Tree } from '@nx/devkit';\nimport { Logger, UVProvider } from './nxlv-python.js';\nimport type { ITsDepVersion } from './versions.js';\n\n/**\n * Languages whose dependencies a generator may install.\n */\nexport type InstallLanguage = 'typescript' | 'python';\n\nexport interface InstallDependenciesOptions {\n  /** Languages to install dependencies for. */\n  languages: InstallLanguage[];\n  /**\n   * Packages that must resolve from the workspace after this generator, because\n   * a config file it writes (e.g. `vite.config.mts`) imports them and Nx loads\n   * that config when computing the project graph. When the caller prefers to\n   * defer installing, we honour that only if these already resolve.\n   *\n   * The per-language graph deps in `LANGUAGE_GRAPH_DEPS` are always included, so\n   * callers only list packages beyond those.\n   */\n  ensureResolvable?: ITsDepVersion[];\n}\n\n/**\n * Packages each language always needs resolvable for Nx to compute the project\n * graph, so a deferred install still runs whenever it would otherwise break.\n */\nconst LANGUAGE_GRAPH_DEPS: Record<InstallLanguage, string[]> = {\n  typescript: ['vitest'], // every TypeScript project has a `vitest.config.mts`\n  python: ['@nxlv/python'], // every Python project registers this inference plugin\n};\n\n/**\n * Returns true if every package is linked at `<root>/node_modules/<pkg>`.\n *\n * This is the condition Nx's inferred plugins need when they load a generated\n * config (e.g. `vite.config.mts`) during graph computation: the config's\n * imports resolve from inside the workspace's own `node_modules`. We avoid\n * `require.resolve`, which can succeed via an ancestor `node_modules` even when\n * the package isn't linked here. `existsSync` follows symlinks, so pnpm's store\n * links resolve, and Nx always uses a `node_modules` linker (never PnP).\n */\nconst allResolvable = (root: string, packages: string[]): boolean =>\n  packages.every((pkg) => existsSync(join(root, 'node_modules', pkg)));\n\n/**\n * Installs dependencies for the given languages.\n *\n * Call from a generator's returned callback:\n * `return () => installDependencies(tree, options.preferInstallDependencies, { ... })`.\n *\n * `preferInstallDependencies` is a preference: when `false` the install is\n * deferred so a batch installs once at the end — unless an `ensureResolvable`\n * package is missing, in which case it runs anyway so the next `nx` command can\n * still compute the project graph.\n */\nexport const installDependencies = async (\n  tree: Tree,\n  preferInstallDependencies: boolean | undefined,\n  options: InstallDependenciesOptions,\n): Promise<void> => {\n  const { languages, ensureResolvable = [] } = options;\n  const mustResolve = [\n    ...ensureResolvable,\n    ...languages.flatMap((language) => LANGUAGE_GRAPH_DEPS[language]),\n  ];\n  if (\n    preferInstallDependencies === false &&\n    allResolvable(tree.root, mustResolve)\n  ) {\n    return;\n  }\n  if (languages.includes('typescript')) {\n    // Force the install: devkit's default only installs when the root\n    // package.json changed, but deps land in per-project manifests.\n    installPackagesTask(tree, true);\n  }\n  if (languages.includes('python')) {\n    await new UVProvider(tree.root, new Logger(), tree).install();\n  }\n};\n"],"names":["existsSync","join","installPackagesTask","Logger","UVProvider","LANGUAGE_GRAPH_DEPS","typescript","python","allResolvable","root","packages","every","pkg","installDependencies","tree","preferInstallDependencies","options","languages","ensureResolvable","mustResolve","flatMap","language","includes","install"],"mappings":"AAAA;;;CAGC,GACD,SAASA,UAAU,QAAQ,UAAU;AACrC,SAASC,IAAI,QAAQ,YAAY;AACjC,SAASC,mBAAmB,QAAmB,aAAa;AAC5D,SAASC,MAAM,EAAEC,UAAU,QAAQ,mBAAmB;AAuBtD;;;CAGC,GACD,MAAMC,sBAAyD;IAC7DC,YAAY;QAAC;KAAS;IACtBC,QAAQ;QAAC;KAAe;AAC1B;AAEA;;;;;;;;;CASC,GACD,MAAMC,gBAAgB,CAACC,MAAcC,WACnCA,SAASC,KAAK,CAAC,CAACC,MAAQZ,WAAWC,KAAKQ,MAAM,gBAAgBG;AAEhE;;;;;;;;;;CAUC,GACD,OAAO,MAAMC,sBAAsB,OACjCC,MACAC,2BACAC;IAEA,MAAM,EAAEC,SAAS,EAAEC,mBAAmB,EAAE,EAAE,GAAGF;IAC7C,MAAMG,cAAc;WACfD;WACAD,UAAUG,OAAO,CAAC,CAACC,WAAahB,mBAAmB,CAACgB,SAAS;KACjE;IACD,IACEN,8BAA8B,SAC9BP,cAAcM,KAAKL,IAAI,EAAEU,cACzB;QACA;IACF;IACA,IAAIF,UAAUK,QAAQ,CAAC,eAAe;QACpC,kEAAkE;QAClE,gEAAgE;QAChEpB,oBAAoBY,MAAM;IAC5B;IACA,IAAIG,UAAUK,QAAQ,CAAC,WAAW;QAChC,MAAM,IAAIlB,WAAWU,KAAKL,IAAI,EAAE,IAAIN,UAAUW,MAAMS,OAAO;IAC7D;AACF,EAAE"}

package/src/utils/js.js

@@ -1,33 +1,40 @@
-"use strict";
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.importTypeScriptModule = exports.importJavaScriptModule = void 0;
-const tslib_1 = require("tslib");
-const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
-const typescript_1 = tslib_1.__importDefault(require("typescript"));
+ */ import ts from "typescript";
+// A real runtime `import()`, wrapped in `new Function` so transpilers (tsc's
+// CommonJS output, @swc-node/register) cannot rewrite it to `require()` —
+// `require()` cannot load the `data:` urls we import below. Under a test VM
+// (vitest) this `new Function` import has no dynamic-import callback, so we
+// fall back to a literal `import()` which the test runner wires up correctly.
+const nodeImport = new Function('modulePath', 'return import(modulePath);');
+const dynamicImport = async (modulePath)=>{
+    try {
+        return await nodeImport(modulePath);
+    } catch (e) {
+        if (e instanceof TypeError && e.message.includes('dynamic import callback')) {
+            return import(/* @vite-ignore */ modulePath);
+        }
+        throw e;
+    }
+};
 /**
  * Imports a javascript module from a string of js code
- */
-const importJavaScriptModule = async (jsCode) => {
-    // Use nx's dynamic import to ensure that transpilers (namely @swc-node/register) don't process the import and it's
-    // instead processed by node at runtime, which allows for data urls
-    const module = await (0, config_utils_1.dynamicImport)(`data:text/javascript,${encodeURIComponent(jsCode)}`);
+ */ export const importJavaScriptModule = async (jsCode)=>{
+    const module = await dynamicImport(`data:text/javascript,${encodeURIComponent(jsCode)}`);
     // Return the default export if available, otherwise the full module
-    return (module.default ?? module);
+    return module.default ?? module;
 };
-exports.importJavaScriptModule = importJavaScriptModule;
 /**
  * Imports a typescript module from a string of typescript code
- */
-const importTypeScriptModule = async (tsCode) => {
+ */ export const importTypeScriptModule = async (tsCode)=>{
     // Transpile to js and then import as a js module
-    const jsCode = typescript_1.default.transpileModule(tsCode, {
-        compilerOptions: { module: typescript_1.default.ModuleKind.ESNext },
+    const jsCode = ts.transpileModule(tsCode, {
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext
+        }
     }).outputText;
-    return await (0, exports.importJavaScriptModule)(jsCode);
+    return await importJavaScriptModule(jsCode);
 };
-exports.importTypeScriptModule = importTypeScriptModule;
+
 //# sourceMappingURL=js.js.map

package/src/utils/js.js.map

@@ -1 +1 @@
-{"version":3,"file":"js.js","sourceRoot":"","sources":["../../../../../packages/nx-plugin/src/utils/js.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;AAEH,oEAAkE;AAClE,oEAA4B;AAE5B;;GAEG;AACI,MAAM,sBAAsB,GAAG,KAAK,EAAK,MAAc,EAAc,EAAE;IAC5E,mHAAmH;IACnH,mEAAmE;IACnE,MAAM,MAAM,GAAG,MAAM,IAAA,4BAAa,EAChC,wBAAwB,kBAAkB,CAAC,MAAM,CAAC,EAAE,CACrD,CAAC;IAEF,oEAAoE;IACpE,OAAO,CAAC,MAAM,CAAC,OAAO,IAAI,MAAM,CAAM,CAAC;AACzC,CAAC,CAAC;AATW,QAAA,sBAAsB,0BASjC;AAEF;;GAEG;AACI,MAAM,sBAAsB,GAAG,KAAK,EAAK,MAAc,EAAc,EAAE;IAC5E,iDAAiD;IACjD,MAAM,MAAM,GAAG,oBAAE,CAAC,eAAe,CAAC,MAAM,EAAE;QACxC,eAAe,EAAE,EAAE,MAAM,EAAE,oBAAE,CAAC,UAAU,CAAC,MAAM,EAAE;KAClD,CAAC,CAAC,UAAU,CAAC;IACd,OAAO,MAAM,IAAA,8BAAsB,EAAI,MAAM,CAAC,CAAC;AACjD,CAAC,CAAC;AANW,QAAA,sBAAsB,0BAMjC"}
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/js.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport ts from 'typescript';\n\n// A real runtime `import()`, wrapped in `new Function` so transpilers (tsc's\n// CommonJS output, @swc-node/register) cannot rewrite it to `require()` —\n// `require()` cannot load the `data:` urls we import below. Under a test VM\n// (vitest) this `new Function` import has no dynamic-import callback, so we\n// fall back to a literal `import()` which the test runner wires up correctly.\nconst nodeImport = new Function('modulePath', 'return import(modulePath);') as (\n  modulePath: string,\n) => Promise<Record<string, unknown>>;\n\nconst dynamicImport = async (\n  modulePath: string,\n): Promise<Record<string, unknown>> => {\n  try {\n    return await nodeImport(modulePath);\n  } catch (e) {\n    if (\n      e instanceof TypeError &&\n      e.message.includes('dynamic import callback')\n    ) {\n      return import(/* @vite-ignore */ modulePath);\n    }\n    throw e;\n  }\n};\n\n/**\n * Imports a javascript module from a string of js code\n */\nexport const importJavaScriptModule = async <T>(jsCode: string): Promise<T> => {\n  const module = await dynamicImport(\n    `data:text/javascript,${encodeURIComponent(jsCode)}`,\n  );\n\n  // Return the default export if available, otherwise the full module\n  return (module.default ?? module) as T;\n};\n\n/**\n * Imports a typescript module from a string of typescript code\n */\nexport const importTypeScriptModule = async <T>(tsCode: string): Promise<T> => {\n  // Transpile to js and then import as a js module\n  const jsCode = ts.transpileModule(tsCode, {\n    compilerOptions: { module: ts.ModuleKind.ESNext },\n  }).outputText;\n  return await importJavaScriptModule<T>(jsCode);\n};\n"],"names":["ts","nodeImport","Function","dynamicImport","modulePath","e","TypeError","message","includes","importJavaScriptModule","jsCode","module","encodeURIComponent","default","importTypeScriptModule","tsCode","transpileModule","compilerOptions","ModuleKind","ESNext","outputText"],"mappings":"AAAA;;;CAGC,GAED,OAAOA,QAAQ,aAAa;AAE5B,6EAA6E;AAC7E,0EAA0E;AAC1E,4EAA4E;AAC5E,4EAA4E;AAC5E,8EAA8E;AAC9E,MAAMC,aAAa,IAAIC,SAAS,cAAc;AAI9C,MAAMC,gBAAgB,OACpBC;IAEA,IAAI;QACF,OAAO,MAAMH,WAAWG;IAC1B,EAAE,OAAOC,GAAG;QACV,IACEA,aAAaC,aACbD,EAAEE,OAAO,CAACC,QAAQ,CAAC,4BACnB;YACA,OAAO,MAAM,CAAC,gBAAgB,GAAGJ;QACnC;QACA,MAAMC;IACR;AACF;AAEA;;CAEC,GACD,OAAO,MAAMI,yBAAyB,OAAUC;IAC9C,MAAMC,SAAS,MAAMR,cACnB,CAAC,qBAAqB,EAAES,mBAAmBF,SAAS;IAGtD,oEAAoE;IACpE,OAAQC,OAAOE,OAAO,IAAIF;AAC5B,EAAE;AAEF;;CAEC,GACD,OAAO,MAAMG,yBAAyB,OAAUC;IAC9C,iDAAiD;IACjD,MAAML,SAASV,GAAGgB,eAAe,CAACD,QAAQ;QACxCE,iBAAiB;YAAEN,QAAQX,GAAGkB,UAAU,CAACC,MAAM;QAAC;IAClD,GAAGC,UAAU;IACb,OAAO,MAAMX,uBAA0BC;AACzC,EAAE"}

package/src/utils/lambda-runtime-resolution.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ILambdaRuntime } from './versions.js';
+/**
+ * Resolution of the Lambda runtimes and the CPython patch the version update
+ * pins.
+ *
+ * Lives here rather than beside the script so it is covered by the plugin's test
+ * suite; the script supplies the runtime list and the uv output.
+ */
+/** Compare two dotted numeric versions (`24`, `3.14`) ascending. */
+export declare const compareRuntimeVersions: (a: string, b: string) => number;
+/**
+ * The version a managed runtime identifier names, or undefined for one that isn't
+ * a versioned `nodejs`/`python` runtime.
+ *
+ * `nodejs24.x` -> `24`, `python3.14` -> `3.14`. The bare `nodejs` and
+ * `nodejs4.3-edge` style identifiers carry no comparable version and are skipped.
+ */
+export declare const runtimeIdentifierVersion: (identifier: string) => {
+    language: ILambdaRuntime;
+    version: string;
+} | undefined;
+/** Why a language's runtime could not be resolved. */
+export type UnresolvedReason = 'no-runtimes-listed';
+export interface RuntimeResolution {
+    /** Runtime version per language, holding the current pin where unresolved. */
+    readonly versions: Record<string, string>;
+    /** Languages left on their current pin, and why. */
+    readonly unresolved: {
+        readonly language: string;
+        readonly kept: string;
+        readonly reason: UnresolvedReason;
+    }[];
+}
+/**
+ * The latest managed runtime for each language in {@link LAMBDA_RUNTIME_VERSIONS},
+ * from the runtime identifiers `aws-cdk-lib` publishes.
+ *
+ * `Runtime.ALL` is a curated list of the runtimes CDK supports, so a runtime still
+ * in public preview does not appear — which is what makes it a usable source for a
+ * generally-available runtime. Never moves a runtime backwards: a pin ahead of
+ * what CDK offers stays.
+ *
+ * A language the list says nothing about keeps its current pin and is reported
+ * through `unresolved`, so a failure costs this bump alone rather than the whole
+ * version update.
+ */
+export declare const resolveLambdaRuntimes: (identifiers: readonly string[]) => RuntimeResolution;
+/** The warning a language's unresolved runtime reports. */
+export declare const unresolvedRuntimeWarning: (entry: RuntimeResolution["unresolved"][number]) => string;