@prisma/composer-cli 0.25.0 → 0.26.0-dev.2

package/dist/{pipeline-C7gNjMzJ-CMqZQxqM.mjs → container-transport-HcvNOGZL-CHqecFc7.mjs}

@@ -1,10 +1,57 @@
-import { c as CliStructuredError, i as effectResolutionDiagnostic, l as InternalError, u as blindCast } from "./result-B874OKwb.mjs";
+import { a as CliStructuredError, l as InternalError, n as configFileMissing, t as checkComposerConfig, u as blindCast } from "./composer-config-CY9fET8H-KpGjlYgO.mjs";
 import * as mod from "node:module";
 import * as fs from "node:fs";
 import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import * as c12 from "c12";
+//#region ../../0-framework/3-tooling/assemble/dist/index.mjs
+/**
+* A user-facing assembly failure, structured at origin (base-type rule 6):
+* a `CliStructuredError` whose code names which way assembly went wrong.
+* This package's second consumer is the programmatic deploy API, not just
+* the CLI — hosts branch on `error.code`, the CLI renders the envelope.
+*/
+var AssembleError = class extends CliStructuredError {
+	constructor(code, summary, options) {
+		super(code, summary, options);
+	}
+};
+/**
+* The registry route for one service's build: extension by
+* `build.extension`, node descriptor by `build.type`, kind must be "build".
+* The CLI's coverage validation reports the same misses earlier with the
+* config fix; these errors are the backstop for programmatic callers.
+*/
+function buildDescriptorAssemble(config, node, address, cwd) {
+	const { extension, type } = node.build;
+	const extensionDescriptor = config.extensions.find((candidate) => candidate.id === extension);
+	if (extensionDescriptor === void 0) throw new AssembleError("ASSEMBLE.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by service "${node.name}"'s build).`, { fix: "Add it to `extensions` in the `composer` section of prisma.config.ts." });
+	const nodeDescriptor = extensionDescriptor.nodes[type];
+	if (nodeDescriptor === void 0) throw new AssembleError("ASSEMBLE.DESCRIPTOR_MISSING", `Extension "${extension}" has no descriptor for build type "${type}".`, { why: `Known types: ${Object.keys(extensionDescriptor.nodes).join(", ")}.` });
+	if (nodeDescriptor.kind !== "build") throw new AssembleError("ASSEMBLE.DESCRIPTOR_KIND_MISMATCH", `Extension "${extension}"'s descriptor for type "${type}" is a "${nodeDescriptor.kind}" descriptor.`, { why: "Assembling a service build needs a \"build\" descriptor." });
+	return nodeDescriptor.assemble({
+		build: node.build,
+		address,
+		cwd
+	});
+}
+async function assembleServices(graph, config, cwd, run) {
+	const runAssembler = run ?? ((node, address, nodeCwd) => buildDescriptorAssemble(config, node, address, nodeCwd));
+	const serviceNodes = graph.nodes.filter((n) => n.node.kind === "service");
+	if (serviceNodes.length === 0) throw new AssembleError("ASSEMBLE.SERVICE_MISSING", "The loaded graph has no service to assemble.");
+	const bundles = {};
+	for (const { id, node } of serviceNodes) try {
+		bundles[id] = await runAssembler(node, id, cwd);
+	} catch (error) {
+		if (CliStructuredError.is(error)) throw error;
+		throw new AssembleError("ASSEMBLE.BUILD_FAILED", error instanceof Error ? error.message : String(error), {
+			meta: { address: id },
+			cause: error
+		});
+	}
+	return { bundles };
+}
+//#endregion
 //#region ../../0-framework/1-core/core/dist/graph-BfKAg2Ap.mjs
 /** The reserved name of a resource's single anonymous output port. Rejected as a user-declared port name (node.ts). */
 const RESOURCE_OUT_PORT = "$out";
@@ -661,7 +708,7 @@ function Load(root, opts) {
 }
 blindCast(Symbol.for("prisma:secret-box"));
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/load-entry-BjRb7YB3.mjs
+//#region ../../0-framework/3-tooling/cli/dist/pipeline-DYvl561J.mjs
 /**
 * Synchronous Node resolve hook so that entry modules may import relative
 * files using the specifier forms TypeScript accepts by default —
@@ -805,291 +852,10 @@ async function loadEntry(entryArg, cwd) {
 		root: blindCast(root)
 	};
 }
-//#endregion
-//#region ../../0-framework/3-tooling/assemble/dist/index.mjs
-/**
-* A user-facing assembly failure, structured at origin (base-type rule 6):
-* a `CliStructuredError` whose code names which way assembly went wrong.
-* This package's second consumer is the programmatic deploy API, not just
-* the CLI — hosts branch on `error.code`, the CLI renders the envelope.
-*/
-var AssembleError = class extends CliStructuredError {
-	constructor(code, summary, options) {
-		super(code, summary, options);
-	}
-};
-/**
-* The registry route for one service's build: extension by
-* `build.extension`, node descriptor by `build.type`, kind must be "build".
-* The CLI's coverage validation reports the same misses earlier with the
-* config fix; these errors are the backstop for programmatic callers.
-*/
-function buildDescriptorAssemble(config, node, address, cwd) {
-	const { extension, type } = node.build;
-	const extensionDescriptor = config.extensions.find((candidate) => candidate.id === extension);
-	if (extensionDescriptor === void 0) throw new AssembleError("ASSEMBLE.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by service "${node.name}"'s build).`, { fix: "Add it to prisma-composer.config.ts's `extensions`." });
-	const nodeDescriptor = extensionDescriptor.nodes[type];
-	if (nodeDescriptor === void 0) throw new AssembleError("ASSEMBLE.DESCRIPTOR_MISSING", `Extension "${extension}" has no descriptor for build type "${type}".`, { why: `Known types: ${Object.keys(extensionDescriptor.nodes).join(", ")}.` });
-	if (nodeDescriptor.kind !== "build") throw new AssembleError("ASSEMBLE.DESCRIPTOR_KIND_MISMATCH", `Extension "${extension}"'s descriptor for type "${type}" is a "${nodeDescriptor.kind}" descriptor.`, { why: "Assembling a service build needs a \"build\" descriptor." });
-	return nodeDescriptor.assemble({
-		build: node.build,
-		address,
-		cwd
-	});
-}
-async function assembleServices(graph, config, cwd, run) {
-	const runAssembler = run ?? ((node, address, nodeCwd) => buildDescriptorAssemble(config, node, address, nodeCwd));
-	const serviceNodes = graph.nodes.filter((n) => n.node.kind === "service");
-	if (serviceNodes.length === 0) throw new AssembleError("ASSEMBLE.SERVICE_MISSING", "The loaded graph has no service to assemble.");
-	const bundles = {};
-	for (const { id, node } of serviceNodes) try {
-		bundles[id] = await runAssembler(node, id, cwd);
-	} catch (error) {
-		if (CliStructuredError.is(error)) throw error;
-		throw new AssembleError("ASSEMBLE.BUILD_FAILED", error instanceof Error ? error.message : String(error), {
-			meta: { address: id },
-			cause: error
-		});
-	}
-	return { bundles };
-}
-//#endregion
-//#region ../../0-framework/3-tooling/cli/dist/pipeline-C7gNjMzJ.mjs
-/**
-* Pipeline step: find and load `prisma-composer.config.ts` (ADR-0017) — the ONE
-* file that imports control-plane code. Discovery is the standard walk-up
-* from the deploy entry's directory (mirrors prisma/orm's config-loader);
-* loading is c12 with that explicit path (rc/global/package.json lookups
-* disabled), so the config file's own static imports resolve from the app
-* root by whatever package manager runs — no specifier construction, no
-* anchoring.
-*
-* Two shapes of the same machinery:
-*
-*   loadAppConfigDiagnostics — returns the evaluated value together with
-*   EVERY problem found, and never throws. This is the shape the engine
-*   command family consumes: the engine renders diagnostics itself and
-*   decides per command whether a broken section is fatal, so a loader that
-*   threw on the first bad field would both hide the rest and bypass that
-*   rendering.
-*
-*   loadAppConfig — the same load, throwing its first diagnostic. The
-*   clipanion CLI still runs on it; it goes when clipanion does.
-*/
-/**
-* Accepted config file names, in precedence order: when several sit in one
-* directory the first one found wins. The JavaScript spellings exist so a
-* project whose own TypeScript build would otherwise compile the config file
-* (no `include`, a `rootDir`, `module: commonjs`) can keep it out of that
-* build's sight.
-*/
-const CONFIG_FILENAMES = [
-	"prisma-composer.config.ts",
-	"prisma-composer.config.mts",
-	"prisma-composer.config.mjs",
-	"prisma-composer.config.js"
-];
-/** The canonical spelling, used in messages and docs. */
-const CONFIG_FILENAME = CONFIG_FILENAMES[0];
-/** The accepted spellings as one glob-like string for messages. */
-const CONFIG_FILENAME_PATTERN = "prisma-composer.config.{ts,mts,mjs,js}";
-/** Walks UP from the entry file's directory looking for one of CONFIG_FILENAMES; undefined when the walk hits the filesystem root. */
-function findConfigPathForEntry(entryPath) {
-	let current = path.dirname(path.resolve(entryPath));
-	while (true) {
-		for (const filename of CONFIG_FILENAMES) {
-			const candidate = path.join(current, filename);
-			if (fs.existsSync(candidate)) return candidate;
-		}
-		const parent = path.dirname(current);
-		if (parent === current) return void 0;
-		current = parent;
-	}
-}
-function missingConfigError(entryPath) {
-	const searchedFrom = path.dirname(path.resolve(entryPath));
-	return new CliStructuredError("CONFIG.FILE_MISSING", `No ${CONFIG_FILENAME_PATTERN} found walking up from "${searchedFrom}".`, {
-		why: "The deploy needs the app's config file.",
-		fix: "Create one next to (or above) the entry, default-exporting defineConfig({ extensions: [...], state: ... }) from '@prisma/composer/config'.",
-		where: { path: searchedFrom }
-	});
-}
-function fieldError(configPath, field, requirement) {
-	return new CliStructuredError("CONFIG.FIELD_INVALID", `${path.basename(configPath)}: \`${field}\` ${requirement}.`, {
-		fix: "See defineConfig() in '@prisma/composer/config'.",
-		meta: { field }
-	});
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-/**
-* Field-by-field validation of the loaded default export — deliberately no
-* schema library: each check is a structured error naming the offending field.
-*
-* Collects rather than throws, so one bad config reports every bad field
-* instead of only the first. The `extensions` and `state` checks are
-* independent, and within `extensions` each entry is judged on its own; a
-* field whose own shape check already failed is not probed further, because
-* anything derived from it would be noise rather than a second finding.
-*/
-function configShapeDiagnostics(loaded, configPath) {
-	if (!isRecord(loaded) || Object.keys(loaded).length === 0) return [new CliStructuredError("CONFIG.EXPORT_INVALID", `"${configPath}" exported no config.`, {
-		fix: "It must default-export defineConfig({ extensions: [...], state: ... }) from '@prisma/composer/config'.",
-		where: { path: configPath }
-	})];
-	const diagnostics = [];
-	const extensions = loaded["extensions"];
-	if (!Array.isArray(extensions)) diagnostics.push(fieldError(configPath, "extensions", "must be an array"));
-	else {
-		const seen = /* @__PURE__ */ new Set();
-		for (const [index, entry] of extensions.entries()) {
-			if (!isRecord(entry)) {
-				diagnostics.push(fieldError(configPath, `extensions[${index}]`, "must be an extension descriptor object"));
-				continue;
-			}
-			const id = entry["id"];
-			if (typeof id !== "string" || id.length === 0) diagnostics.push(fieldError(configPath, `extensions[${index}].id`, "must be a non-empty string (the extension package name)"));
-			else if (seen.has(id)) diagnostics.push(new CliStructuredError("CONFIG.EXTENSION_DUPLICATE", `${path.basename(configPath)}: extension "${id}" is listed more than once in \`extensions\`.`));
-			else seen.add(id);
-			if (!isRecord(entry["nodes"])) diagnostics.push(fieldError(configPath, `extensions[${index}].nodes`, "must be an object (the node-ID → control registry)"));
-		}
-	}
-	const state = loaded["state"];
-	if (!isRecord(state) || typeof state["extension"] !== "string" || typeof state["create"] !== "function") diagnostics.push(fieldError(configPath, "state", "must be a state descriptor (e.g. prismaState())"));
-	return diagnostics;
-}
-/** The throwing form of configShapeDiagnostics: raises the first finding, returns the same object typed. Used by the clipanion pipeline. */
-function validateConfigShape(loaded, configPath) {
-	const [first] = configShapeDiagnostics(loaded, configPath);
-	if (first !== void 0) throw first;
-	return blindCast(loaded);
-}
-/**
-* Evaluates `configPath` with c12 (explicit file; rc / global-rc /
-* package.json lookups disabled). `verifySamePath` runs the same-file check
-* against the discovered path — see loadAppConfigDiagnostics for when it does
-* not apply.
-*/
-async function evaluateConfig(configPath, verifySamePath) {
-	let result;
-	try {
-		result = await c12.loadConfig({
-			name: "prisma-composer",
-			configFile: configPath,
-			cwd: path.dirname(configPath),
-			rcFile: false,
-			globalRc: false,
-			packageJson: false
-		});
-	} catch (error) {
-		return {
-			value: void 0,
-			diagnostics: [new CliStructuredError("CONFIG.EVALUATION_FAILED", `Evaluating "${configPath}" failed: ${error instanceof Error ? error.message : String(error)}`, {
-				where: { path: configPath },
-				cause: error
-			})]
-		};
-	}
-	const loadedFile = result.configFile;
-	if (verifySamePath && (typeof loadedFile !== "string" || fs.realpathSync(loadedFile) !== fs.realpathSync(configPath))) return {
-		value: result.config,
-		diagnostics: [new CliStructuredError("CONFIG.PATH_MISMATCH", `Config loading resolved "${String(loadedFile)}" instead of the discovered "${configPath}".`, {
-			why: "Refusing to deploy against a different file.",
-			where: { path: configPath }
-		})]
-	};
-	return {
-		value: result.config,
-		diagnostics: configShapeDiagnostics(result.config, configPath)
-	};
-}
-/**
-* The front of every config load, shared by the throwing and the
-* diagnostics-list shapes: verify the installed tree can evaluate a config at
-* all, then settle which file to load — the section's path, or the
-* entry-anchored walk.
-*
-* The effect-resolution check comes first because evaluating a config imports
-* alchemy's provider tree: in a tree where alchemy resolves an `effect` we did
-* not pin, nothing downstream can load, so the dependency conflict is the
-* finding with the fix in it and every later failure is its symptom.
-*/
-function configSource(request) {
-	const resolvedEntry = path.resolve(request.entryPath);
-	const effectConflict = effectResolutionDiagnostic(request.cwd ?? path.dirname(resolvedEntry));
-	if (effectConflict !== void 0) return {
-		ok: false,
-		path: void 0,
-		diagnostic: effectConflict
-	};
-	if (request.configPath === void 0) {
-		const discovered = findConfigPathForEntry(resolvedEntry);
-		return discovered === void 0 ? {
-			ok: false,
-			path: void 0,
-			diagnostic: missingConfigError(resolvedEntry)
-		} : {
-			ok: true,
-			path: discovered,
-			explicit: false
-		};
-	}
-	const configPath = request.configPath;
-	if (!path.isAbsolute(configPath)) return {
-		ok: false,
-		path: configPath,
-		diagnostic: new CliStructuredError("CONFIG.PATH_NOT_ABSOLUTE", `The \`composer\` config section's configPath must arrive absolute, and "${configPath}" is relative.`, {
-			why: "The section validator resolves a relative configPath against the config file that declared it; a relative value here means that resolution was skipped.",
-			fix: "Run the configPath through the composer section validator, or resolve it against its declaring file before constructing the load request.",
-			where: { path: configPath }
-		})
-	};
-	if (!fs.existsSync(configPath)) return {
-		ok: false,
-		path: configPath,
-		diagnostic: new CliStructuredError("CONFIG.FILE_MISSING", `The \`composer\` config section points at "${configPath}", which does not exist.`, {
-			why: "An explicit configPath is used as given — there is no walk to fall back on.",
-			fix: "Correct `configPath` in the `composer` section of prisma.config.ts, or remove it to search upward from the entry.",
-			where: { path: configPath }
-		})
-	};
-	return {
-		ok: true,
-		path: configPath,
-		explicit: true
-	};
-}
-/**
-* The throwing form of that front, for the pipeline: the file the load will
-* use, or the finding raised. `explicit` says the section named the file,
-* which is what retires the same-file check for that case.
-*/
-function resolveConfigFile(request) {
-	const source = configSource(request);
-	if (!source.ok) throw source.diagnostic;
-	return {
-		path: source.path,
-		explicit: source.explicit
-	};
-}
-/**
-* Loads + validates the config at `configPath`, throwing its first diagnostic.
-* The clipanion CLI's pipeline runs on this; it goes when clipanion does.
-*/
-async function loadAppConfig(configPath, verifySamePath = true) {
-	const { value, diagnostics } = await evaluateConfig(configPath, verifySamePath);
-	const [first] = diagnostics;
-	if (first !== void 0) throw first;
-	return {
-		path: configPath,
-		config: validateConfigShape(value, configPath)
-	};
-}
 function lookup(extensions, extension, type, expectedKind, what) {
 	const ext = extensions.get(extension);
 	if (ext === void 0) throw new CliStructuredError("CONFIG.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by ${what}).`, {
-		fix: `Add it to ${CONFIG_FILENAME}'s \`extensions\` (import its /control entry and list its descriptor).`,
+		fix: "Add it to `extensions` in the `composer` section of prisma.config.ts (import its /control entry and list its descriptor).",
 		meta: {
 			extension,
 			type
@@ -1124,7 +890,7 @@ function validateRegistryCoverage(graph, config) {
 }
 /**
 * The shared prefix of `deploy`/`destroy`/`dev` (deploy-cli.md § The
-* pipeline; local-dev spec § 6): config discovery/load, entry load, Load,
+* pipeline; local-dev spec § 6): entry load, Load,
 * registry coverage validation, name resolution, assemble. Deploy and dev
 * diverge after this — deploy resolves containers/preflight/stack file
 * against the hosted providers, dev against the local ones — so everything
@@ -1132,50 +898,41 @@ function validateRegistryCoverage(graph, config) {
 * `run()` (main.ts) and `runDev()` (dev/run-dev.ts), so the two pipelines
 * cannot drift.
 */
-/**
-* The config step both pipelines share: the effect-resolution check and the
-* choice of config file (load-config.ts's shared front), then evaluation —
-* unless the caller substituted a config, which replaces the evaluation and
-* nothing before it.
-*/
-async function loadConfigStep(entryPath, cwd, deps) {
-	const { path: configPath, explicit } = resolveConfigFile({
-		entryPath,
-		configPath: deps.configPath,
-		cwd
+function configError(findings, file) {
+	const [first] = findings;
+	return new CliStructuredError(first.code, first.summary, {
+		...first.why === void 0 ? {} : { why: first.why },
+		fix: first.fix,
+		where: { path: first.where ?? file },
+		meta: {
+			...first.field === void 0 ? {} : { field: first.field },
+			findings
+		}
 	});
-	return {
-		configPath,
-		config: deps.config ?? (await loadAppConfig(configPath, !explicit)).config
-	};
 }
 /**
-* The pipeline's front — config discovery/load, entry load, name resolution —
-* WITHOUT Load, coverage, or assemble. `log` needs only who the app is (its
-* config and resolved name) to reach the already-running local instance; it
-* neither builds nor provisions, so it must not require the user's built
-* output the way the full pipeline does.
+* Refuses a caller's config with the same findings, in the same order, as the CLI's section validator.
+* The error is the first finding and carries all of them in `meta.findings`. Returns the config with `file` resolved against `cwd`.
 */
-async function resolveAppIdentity(entry, overrideName, cwd, deps = {}) {
-	const { configPath, config } = await loadConfigStep(path.resolve(cwd, entry), cwd, deps);
-	const entryModule = await loadEntry(entry, cwd);
-	const name = overrideName ?? entryModule.root.name;
-	if (name.length === 0) throw new CliStructuredError("COMPOSE.NAME_MISSING", "The root node has no name.", { fix: "Name it at authoring, or pass --name." });
+function checkConfigSource(source, cwd) {
+	const file = path.resolve(cwd, source.file);
+	if (!fs.existsSync(file)) throw configError([configFileMissing(file)], file);
+	const checked = checkComposerConfig(source.value, file);
+	if (!checked.ok) throw configError(checked.findings, file);
 	return {
-		configPath,
-		config,
-		name
+		value: checked.value,
+		file
 	};
 }
 /**
-* Runs config discovery/load, entry load, Load, registry coverage, name
-* resolution, and assemble — steps 1–6 of `run()`. `onAssembleError`, when
+* Runs entry load, Load, registry coverage, name resolution, and assemble — steps 1–5 of `run()`. `onAssembleError`, when
 * given, lets a caller decorate an assemble failure with command-specific
 * guidance (destroy's "build first" hint) without this shared step knowing
 * about any one command.
 */
-async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError) {
-	const { configPath, config } = await loadConfigStep(path.resolve(cwd, entry), cwd, deps);
+async function runPipeline(entry, overrideName, cwd, source, deps = {}, onAssembleError) {
+	const configSource = checkConfigSource(source, cwd);
+	const config = configSource.value;
 	const entryModule = await loadEntry(entry, cwd);
 	const graph = Load(entryModule.root);
 	if (graph.root.node.kind !== "module") throw new CliStructuredError("COMPOSE.ROOT_NOT_MODULE", "The deploy root must be a module.", { fix: "Wrap your service, e.g. export default module('name', ({ provision }) => { provision(service); })." });
@@ -1190,8 +947,7 @@ async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError)
 		throw error;
 	}
 	return {
-		configPath,
-		config,
+		configSource,
 		entryModule,
 		graph,
 		name,
@@ -1199,6 +955,37 @@ async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError)
 	};
 }
 //#endregion
-export { runPipeline as n, resolveAppIdentity as t };
+//#region ../../0-framework/1-core/core/dist/container-transport-HcvNOGZL.mjs
+/** '@prisma/composer-prisma-cloud' → 'PRISMA_COMPOSER_PRISMA_CLOUD': uppercased, every non-alphanumeric run replaced by one underscore. */
+function envVarSafeExtensionId(extensionId) {
+	return extensionId.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+/** '@prisma/composer-prisma-cloud' → 'PRISMA_COMPOSER_CONTAINER_PRISMA_COMPOSER_PRISMA_CLOUD' */
+function containerEnvVarName(extensionId) {
+	return `PRISMA_COMPOSER_CONTAINER_${envVarSafeExtensionId(extensionId)}`;
+}
+function collisionError(a, b, varName) {
+	return /* @__PURE__ */ new Error(`Extension ids "${a}" and "${b}" both map to the container transport variable "${varName}" — rename one of the extensions.`);
+}
+function emptySerializeError(extensionId) {
+	return /* @__PURE__ */ new Error(`Extension "${extensionId}"'s container instance serialized to an empty string — ContainerInstance.serialize() must return a non-empty string.`);
+}
+/** The env entries the CLI sets on the alchemy process: `{ [containerEnvVarName(id)]: instance.serialize() }` for every resolved instance. */
+function containerEnv(instances) {
+	const env = {};
+	const ownerByVarName = /* @__PURE__ */ new Map();
+	for (const [extensionId, instance] of instances) {
+		const varName = containerEnvVarName(extensionId);
+		const owner = ownerByVarName.get(varName);
+		if (owner !== void 0) throw collisionError(owner, extensionId, varName);
+		ownerByVarName.set(varName, extensionId);
+		const serialized = instance.serialize();
+		if (serialized.length === 0) throw emptySerializeError(extensionId);
+		env[varName] = serialized;
+	}
+	return env;
+}
+//#endregion
+export { envVarSafeExtensionId as n, runPipeline as r, containerEnv as t };
 
-//# sourceMappingURL=pipeline-C7gNjMzJ-CMqZQxqM.mjs.map
+//# sourceMappingURL=container-transport-HcvNOGZL-CHqecFc7.mjs.map