skuba 13.0.0-custom-conditions-exports-20250730060544 → 13.0.0-custom-conditions-exports-20250923003120

package/template/lambda-sqs-worker-cdk/src/app.ts

@@ -1,7 +1,10 @@
 import { isLambdaHook } from '@seek/aws-codedeploy-hooks';
 import type { SQSEvent } from 'aws-lambda';
 
-import { createHandler } from '#src/framework/handler.js';
+import {
+  createBatchSQSHandler,
+  createHandler,
+} from '#src/framework/handler.js';
 import { logger } from '#src/framework/logging.js';
 import { metricsClient } from '#src/framework/metrics.js';
 import { validateJson } from '#src/framework/validation.js';
@@ -34,19 +37,17 @@ export const handler = createHandler<SQSEvent>(async (event, ctx) => {
 
   const count = event.Records.length;
 
-  if (count !== 1) {
-    throw Error(`Received ${count} records`);
+  if (!count) {
+    throw Error('Received 0 records');
   }
-
   logger.debug({ count }, 'Received jobs');
 
-  metricsClient.distribution('job.received', event.Records.length);
+  metricsClient.distribution('job.received', count);
 
-  const record = event.Records[0];
-  if (!record) {
-    throw new Error('Malformed SQS event with no records');
-  }
+  return recordHandler(event, ctx);
+});
 
+const recordHandler = createBatchSQSHandler(async (record, _ctx) => {
   const { body } = record;
 
   // TODO: this throws an error, which will cause the Lambda function to retry

package/template/lambda-sqs-worker-cdk/src/config.ts

@@ -1,27 +1,25 @@
 import { Env } from 'skuba-dive';
 
 interface Config {
-  environment: Environment;
+  deployment: Deployment;
 
   logLevel: string;
-  metrics: boolean;
   name: string;
   version: string;
 
   destinationSnsTopicArn: string;
 }
 
-type Environment = (typeof environments)[number];
+type Deployment = (typeof deployments)[number];
 
-const environments = ['local', 'test', 'dev', 'prod'] as const;
+const deployments = ['local', 'test', 'dev', 'prod'] as const;
 
-const environment = Env.oneOf(environments)('ENVIRONMENT');
+const deployment = Env.oneOf(deployments)('DEPLOYMENT');
 
 /* istanbul ignore next: config verification makes more sense in a smoke test */
-const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
+const configs: Record<Deployment, () => Omit<Config, 'deployment'>> = {
   local: () => ({
     logLevel: 'debug',
-    metrics: false,
     name: '<%- serviceName %>',
     version: 'local',
 
@@ -30,7 +28,6 @@ const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
 
   test: () => ({
     logLevel: Env.string('LOG_LEVEL', { default: 'debug' }),
-    metrics: false,
     name: '<%- serviceName %>',
     version: 'test',
 
@@ -39,24 +36,22 @@ const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
 
   dev: () => ({
     logLevel: 'debug',
-    metrics: true,
-    name: Env.string('SERVICE'),
-    version: Env.string('VERSION'),
+    name: Env.string('DD_SERVICE'),
+    version: Env.string('DD_VERSION'),
 
     destinationSnsTopicArn: Env.string('DESTINATION_SNS_TOPIC_ARN'),
   }),
 
   prod: () => ({
     logLevel: 'info',
-    metrics: true,
-    name: Env.string('SERVICE'),
-    version: Env.string('VERSION'),
+    name: Env.string('DD_SERVICE'),
+    version: Env.string('DD_VERSION'),
 
     destinationSnsTopicArn: Env.string('DESTINATION_SNS_TOPIC_ARN'),
   }),
 };
 
 export const config: Config = {
-  ...configs[environment](),
-  environment,
+  ...configs[deployment](),
+  deployment,
 };

package/template/lambda-sqs-worker-cdk/src/framework/handler.test.ts

@@ -1,3 +1,5 @@
+import type { SQSEvent } from 'aws-lambda';
+
 import { createHandler } from './handler.js';
 import { logger, stdoutMock } from './logging.js';
 
@@ -6,12 +8,14 @@ import { chance } from '#src/testing/types.js';
 
 describe('createHandler', () => {
   const ctx = createCtx();
-  const input = chance.paragraph();
+  const input: SQSEvent = {
+    Records: [],
+  };
 
   afterEach(stdoutMock.clear);
 
   it('handles happy path', async () => {
-    const output = chance.paragraph();
+    const output = chance.sentence();
 
     const handler = createHandler((event) => {
       expect(event).toBe(input);
@@ -32,7 +36,8 @@ describe('createHandler', () => {
       {
         awsRequestId: '-',
         level: 20,
-        msg: 'Function succeeded',
+        output,
+        msg: 'Function completed',
       },
     ]);
   });
@@ -47,7 +52,7 @@ describe('createHandler', () => {
     expect(stdoutMock.calls).toMatchObject([
       {
         awsRequestId: '-',
-        err: {
+        error: {
           message: err.message,
           type: 'Error',
         },
@@ -69,7 +74,7 @@ describe('createHandler', () => {
     expect(stdoutMock.calls).toMatchObject([
       {
         awsRequestId: '-',
-        err: {
+        error: {
           message: err.message,
           type: 'Error',
         },

package/template/lambda-sqs-worker-cdk/src/framework/handler.ts

@@ -1,40 +1,64 @@
-import type { Context as LambdaContext } from 'aws-lambda';
-import { datadog } from 'datadog-lambda-js';
+import type {
+  Context as LambdaContext,
+  SQSBatchItemFailure,
+  SQSBatchResponse,
+  SQSEvent,
+  SQSRecord,
+} from 'aws-lambda';
 
-import { config } from '#src/config.js';
-import { logger, loggerContext } from '#src/framework/logging.js';
+import {
+  lambdaContext,
+  logger,
+  recordContext,
+} from '#src/framework/logging.js';
 
 type Handler<Event, Output> = (
   event: Event,
   ctx: LambdaContext,
 ) => Promise<Output>;
 
-/**
- * Conditionally applies the Datadog wrapper to a Lambda handler.
- *
- * This also "fixes" its broken type definitions.
- */
-const withDatadog = <Event, Output = unknown>(
-  fn: Handler<Event, Output>,
-): Handler<Event, Output> =>
-  // istanbul ignore next
-  config.metrics ? (datadog(fn) as Handler<Event, Output>) : fn;
-
-export const createHandler = <Event, Output = unknown>(
-  fn: (event: Event, ctx: LambdaContext) => Promise<Output>,
-) =>
-  withDatadog<Event>((event, ctx) =>
-    loggerContext.run({ awsRequestId: ctx.awsRequestId }, async () => {
+export const createHandler =
+  <Event extends SQSEvent, Output = unknown>(
+    fn: (event: Event, ctx: LambdaContext) => Promise<Output>,
+  ): Handler<Event, Output> =>
+  async (event, ctx) =>
+    lambdaContext.run({ awsRequestId: ctx.awsRequestId }, async () => {
       try {
         const output = await fn(event, ctx);
 
-        logger.debug('Function succeeded');
+        logger.debug({ output }, 'Function completed');
 
         return output;
       } catch (err) {
-        logger.error({ err }, 'Function failed');
+        logger.error(err, 'Function failed');
 
         throw new Error('Function failed');
       }
-    }),
-  );
+    });
+
+export const createBatchSQSHandler =
+  (
+    fn: (record: SQSRecord, ctx: LambdaContext) => Promise<unknown>,
+  ): Handler<SQSEvent, SQSBatchResponse> =>
+  async (event, ctx) => {
+    const processRecord = (
+      record: SQSRecord,
+    ): Promise<SQSBatchItemFailure | undefined> =>
+      recordContext.run({ sqsMessageId: record.messageId }, async () => {
+        try {
+          await fn(record, ctx);
+          return;
+        } catch (err) {
+          logger.error(err, 'Processing record failed');
+          return {
+            itemIdentifier: record.messageId,
+          };
+        }
+      });
+
+    const results = await Promise.all(event.Records.map(processRecord));
+
+    return {
+      batchItemFailures: results.filter((item) => item !== undefined),
+    };
+  };

package/template/lambda-sqs-worker-cdk/src/framework/logging.ts

@@ -1,17 +1,22 @@
 import { AsyncLocalStorage } from 'async_hooks';
 
-import createLogger, { createDestination } from '@seek/logger';
+import { createDestination, createLogger } from '@seek/logger';
 
 import { config } from '#src/config.js';
 
-interface LoggerContext {
+interface LambdaContext {
   awsRequestId: string;
 }
 
-export const loggerContext = new AsyncLocalStorage<LoggerContext>();
+interface RecordContext {
+  sqsMessageId: string;
+}
+
+export const lambdaContext = new AsyncLocalStorage<LambdaContext>();
+export const recordContext = new AsyncLocalStorage<RecordContext>();
 
 const { destination, stdoutMock } = createDestination({
-  mock: config.environment === 'test' && {
+  mock: config.deployment === 'test' && {
     redact: ['awsRequestId'],
   },
 });
@@ -20,19 +25,26 @@ export { stdoutMock };
 
 export const logger = createLogger(
   {
-    base: {
-      environment: config.environment,
-      version: config.version,
+    eeeoh: {
+      /**
+       * TODO: choose an appropriate Datadog log tier.
+       *
+       * https://github.com/seek-oss/logger/blob/master/docs/eeeoh.md#datadog-log-tiers
+       */
+      datadog: 'tin',
+      team: '<%- teamName %>',
+      use: 'environment',
     },
 
     level: config.logLevel,
 
-    mixin: () => ({ ...loggerContext.getStore() }),
-
-    name: config.name,
+    mixin: () => ({
+      ...lambdaContext.getStore(),
+      ...recordContext.getStore(),
+    }),
 
     transport:
-      config.environment === 'local' ? { target: 'pino-pretty' } : undefined,
+      config.deployment === 'local' ? { target: 'pino-pretty' } : undefined,
   },
   destination,
 );

package/template/lambda-sqs-worker-cdk/src/framework/metrics.ts

@@ -7,8 +7,5 @@ const prefix = `${config.name}.`;
 export const metricsClient = {
   distribution: (
     ...[name, ...rest]: Parameters<typeof sendDistributionMetric>
-  ) =>
-    config.metrics
-      ? sendDistributionMetric(`${prefix}${name}`, ...rest)
-      : undefined,
+  ) => sendDistributionMetric(`${prefix}${name}`, ...rest),
 };

package/template/lambda-sqs-worker-cdk/src/testing/handler.ts

@@ -9,5 +9,8 @@ export const createCtx = () =>
 
 export const createSqsEvent = (bodies: string[]) =>
   ({
-    Records: bodies.map((body) => ({ body })),
+    Records: bodies.map((body) => ({
+      body,
+      messageId: chance.guid({ version: 4 }),
+    })),
   }) as SQSEvent;

package/template/lambda-sqs-worker-cdk/tsconfig.json

@@ -1,8 +1,7 @@
 {
   "compilerOptions": {
     "customConditions": ["@seek/<%- serviceName %>/source"],
-    "baseUrl": ".",
-    "module": "node18",
+
     "moduleResolution": "node16",
     "lib": ["ES2024"],
     "outDir": "lib",

package/template/oss-npm-package/.github/workflows/release.yml

@@ -18,18 +18,18 @@ jobs:
     timeout-minutes: 20
     steps:
       - name: Check out repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 
+      - name: Set up pnpm
+        uses: pnpm/action-setup@v4
+
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           node-version: ^22.14
 
-      - name: Set up pnpm
-        run: corepack enable pnpm && corepack install
-
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
@@ -37,4 +37,3 @@ jobs:
         run: pnpm release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/template/oss-npm-package/.github/workflows/validate.yml

@@ -16,16 +16,16 @@ jobs:
     timeout-minutes: 20
     steps:
       - name: Check out repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
+
+      - name: Set up pnpm
+        uses: pnpm/action-setup@v4
 
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           node-version: ^22.14
 
-      - name: Set up pnpm
-        run: corepack enable pnpm && corepack install
-
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 

package/template/oss-npm-package/_package.json

@@ -47,8 +47,5 @@
   "packageManager": "pnpm@10.7.0",
   "engines": {
     "node": ">=20.9.0"
-  },
-  "publishConfig": {
-    "provenance": true
   }
 }

package/template/oss-npm-package/skuba.template.js

@@ -2,7 +2,7 @@
  * Run `skuba configure` to finish templating and remove this file.
  */
 
-export default {
+module.exports = {
   entryPoint: 'src/index.ts',
   fields: [
     {

package/lib/cli/lint/internalLints/upgrade/patches/12.0.1/configureTsConfigForESM.d.ts

@@ -1,6 +0,0 @@
-import type { PatchFunction } from '../../index.js';
-export declare const addJestModuleNameMapper: (contents: string, subfolderPaths: string[]) => string;
-export declare const replacePackageJson: (contents: string, repoName: string) => string;
-export declare const replaceTsconfig: (contents: string, repoName: string, isMonoRepo: boolean) => string;
-export declare const tryConfigureTsConfigForESM: PatchFunction;
-export declare const configureTsConfigForESM: PatchFunction;

package/lib/cli/lint/internalLints/upgrade/patches/12.0.1/configureTsConfigForESM.js

@@ -1,249 +0,0 @@
-"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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var configureTsConfigForESM_exports = {};
-__export(configureTsConfigForESM_exports, {
-  addJestModuleNameMapper: () => addJestModuleNameMapper,
-  configureTsConfigForESM: () => configureTsConfigForESM,
-  replacePackageJson: () => replacePackageJson,
-  replaceTsconfig: () => replaceTsconfig,
-  tryConfigureTsConfigForESM: () => tryConfigureTsConfigForESM
-});
-module.exports = __toCommonJS(configureTsConfigForESM_exports);
-var import_util = require("util");
-var import_fast_glob = require("fast-glob");
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_zod = require("zod");
-var import__ = require("../../../../../../index.js");
-var import_logging = require("../../../../../../utils/logging.js");
-const packageJsonSchema = import_zod.z.object({
-  imports: import_zod.z.record(import_zod.z.record(import_zod.z.string())).optional()
-}).passthrough();
-const tsConfigSchema = import_zod.z.object({
-  compilerOptions: import_zod.z.object({
-    customConditions: import_zod.z.array(import_zod.z.string()).optional(),
-    rootDir: import_zod.z.string().optional(),
-    paths: import_zod.z.record(import_zod.z.unknown()).optional()
-  }).passthrough().optional()
-}).passthrough();
-const getRepoName = async () => {
-  try {
-    const dir = process.cwd();
-    const { repo } = await import__.Git.getOwnerAndRepo({ dir });
-    return repo;
-  } catch (error) {
-    import_logging.log.warn(`Error getting repository information: ${String(error)}`);
-    throw error;
-  }
-};
-const fetchFiles = async (files) => Promise.all(
-  files.map(async (file) => {
-    const contents = await import_fs_extra.default.promises.readFile(file, "utf8");
-    return {
-      file,
-      contents
-    };
-  })
-);
-const formatModuleNameMapper = (subfolderPaths) => subfolderPaths.map((subfolderPath) => `<rootDir>/${subfolderPath}/src`);
-const isTypeScriptJestConfig = (contents) => contents.includes("Jest.mergePreset") || contents.includes("export default") || contents.includes("import");
-const addModuleNameMapperToTypeScript = (contents, moduleNameMapper) => {
-  const moduleNameMapperStr = JSON.stringify(moduleNameMapper, null, 2).split("\n").map((line, index) => index === 0 ? line : `  ${line}`).join("\n");
-  const mergePresetRegex = /(Jest\.mergePreset\(\s*\{)/;
-  const match = mergePresetRegex.exec(contents);
-  if (match?.index !== void 0) {
-    const insertIndex = match.index + match[0].length;
-    const before = contents.slice(0, insertIndex);
-    const after = contents.slice(insertIndex);
-    return `${before}
-  moduleNameMapper: ${moduleNameMapperStr},${after}`;
-  }
-  return contents;
-};
-const addJestModuleNameMapper = (contents, subfolderPaths) => {
-  const formattedNames = formatModuleNameMapper(subfolderPaths);
-  const formattedNamesWithPath = formattedNames.map((name) => `${name}/$1`);
-  const moduleNameMapper = {
-    "^(\\.{1,2}/.*)\\.js$": "$1",
-    "^#src$": formattedNames,
-    "^#src/(.*)\\.js$": formattedNamesWithPath,
-    "^#src/(.*)$": formattedNamesWithPath
-  };
-  if (isTypeScriptJestConfig(contents)) {
-    return addModuleNameMapperToTypeScript(contents, moduleNameMapper);
-  }
-  try {
-    const parseResult = packageJsonSchema.safeParse(JSON.parse(contents));
-    if (!parseResult.success) {
-      import_logging.log.warn(
-        `Failed to parse Jest config as JSON: ${parseResult.error.message}`
-      );
-      return contents;
-    }
-    const jestConfig = parseResult.data;
-    jestConfig.moduleNameMapper = moduleNameMapper;
-    return JSON.stringify(jestConfig, null, 2);
-  } catch (error) {
-    import_logging.log.warn(`Failed to parse Jest config: ${String(error)}`);
-    return contents;
-  }
-};
-const replacePackageJson = (contents, repoName) => {
-  try {
-    const parseResult = packageJsonSchema.safeParse(JSON.parse(contents));
-    if (!parseResult.success) {
-      import_logging.log.warn(`Failed to parse package.json: ${parseResult.error.message}`);
-      return contents;
-    }
-    const packageJson = parseResult.data;
-    packageJson.imports = {
-      ...packageJson.imports ?? {},
-      "#src/*": {
-        [`@seek/${repoName}/source`]: "./src/*",
-        default: "./lib/*"
-      }
-    };
-    return JSON.stringify(packageJson, null, 2);
-  } catch (error) {
-    import_logging.log.warn(`Failed to parse package.json as JSON: ${String(error)}`);
-    return contents;
-  }
-};
-const replaceTsconfig = (contents, repoName, isMonoRepo) => {
-  try {
-    const jsonWithNoComments = contents.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, "").trim();
-    const parseResult = tsConfigSchema.safeParse(
-      JSON.parse(jsonWithNoComments)
-    );
-    if (!parseResult.success) {
-      import_logging.log.warn(`Failed to parse tsconfig.json: ${parseResult.error.message}`);
-      return contents;
-    }
-    const tsconfigJson = parseResult.data;
-    if (typeof tsconfigJson.extends === "string" && !tsconfigJson.extends.startsWith("skuba/")) {
-      import_logging.log.subtle(
-        "Skipping tsconfig.json that does not extend skuba/config/tsconfig.json"
-      );
-      return contents;
-    }
-    if (!tsconfigJson.compilerOptions || typeof tsconfigJson.compilerOptions !== "object") {
-      tsconfigJson.compilerOptions = {};
-    }
-    const compilerOptions = tsconfigJson.compilerOptions;
-    if (compilerOptions.paths !== void 0 && !isMonoRepo) {
-      delete compilerOptions.paths;
-    }
-    compilerOptions.customConditions ??= [];
-    if (compilerOptions.customConditions.includes(`@seek/${repoName}/source`)) {
-      import_logging.log.subtle(
-        "Custom condition mapping already exists in tsconfig.json, skipping"
-      );
-      return contents;
-    }
-    compilerOptions.customConditions = [`@seek/${repoName}/source`];
-    compilerOptions.rootDir ??= ".";
-    return JSON.stringify(tsconfigJson, null, 2);
-  } catch (error) {
-    import_logging.log.warn(`Failed to parse tsconfig.json as JSON: ${String(error)}`);
-    return contents;
-  }
-};
-const tryConfigureTsConfigForESM = async ({
-  mode
-}) => {
-  const packageJsonPatterns = ["**/package.*json"];
-  const tsconfigJsonPatterns = ["**/tsconfig.*json"];
-  const jestConfigPatterns = ["**/jest.config.*ts"];
-  const globOptions = {
-    ignore: ["**/node_modules/**", "**/tsconfig.build.json"]
-  };
-  const [packageJsonFiles, tsconfigJsonFiles, jestConfigFiles] = await Promise.all([
-    fetchFiles(await (0, import_fast_glob.glob)(packageJsonPatterns, globOptions)),
-    fetchFiles(await (0, import_fast_glob.glob)(tsconfigJsonPatterns, globOptions)),
-    fetchFiles(await (0, import_fast_glob.glob)(jestConfigPatterns, globOptions))
-  ]);
-  const subfolderPaths = packageJsonFiles.map(({ file }) => file.split("/").slice(0, -1).join("/")).filter((path) => path !== "");
-  const repoName = await getRepoName();
-  if (!repoName) {
-    return { result: "skip", reason: "no repository name found" };
-  }
-  const replacedPackageJsonFiles = packageJsonFiles.map(
-    ({ file, contents }) => ({
-      file,
-      before: contents,
-      after: replacePackageJson(contents, repoName)
-    })
-  );
-  const replacedTsconfigJsonFiles = tsconfigJsonFiles.map(
-    ({ file, contents }) => ({
-      file,
-      before: contents,
-      after: replaceTsconfig(contents, repoName, subfolderPaths.length > 0)
-    })
-  );
-  const replacedJestConfigFiles = subfolderPaths.length > 0 ? jestConfigFiles.map(({ file, contents }) => ({
-    file,
-    before: contents,
-    after: addJestModuleNameMapper(contents, subfolderPaths)
-  })) : [];
-  if (mode === "lint") {
-    return {
-      result: "apply"
-    };
-  }
-  await Promise.all(
-    [
-      ...replacedPackageJsonFiles,
-      ...replacedTsconfigJsonFiles.filter(
-        ({ after }) => typeof after === "string"
-      ),
-      ...replacedJestConfigFiles
-    ].map(async ({ file, after }) => {
-      await import_fs_extra.default.promises.writeFile(file, after);
-    })
-  );
-  return { result: "apply" };
-};
-const configureTsConfigForESM = async (config) => {
-  try {
-    return await tryConfigureTsConfigForESM(config);
-  } catch (err) {
-    import_logging.log.warn("Failed to write configure `tsconfig.json` and `package.json`");
-    import_logging.log.subtle((0, import_util.inspect)(err));
-    return { result: "skip", reason: "due to an error" };
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  addJestModuleNameMapper,
-  configureTsConfigForESM,
-  replacePackageJson,
-  replaceTsconfig,
-  tryConfigureTsConfigForESM
-});
-//# sourceMappingURL=configureTsConfigForESM.js.map