@prisma/composer 0.2.0-dev.1 → 0.2.0-dev.10

package/dist/{app-config-BPb3LCdH-CH7b8Khi.d.mts → app-config-CVyObaOe-PF94uVBK.d.mts}

@@ -5,7 +5,7 @@ import { Input, StackServices } from "alchemy";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { State } from "alchemy/State/State";
-//#region ../../0-framework/1-core/core/dist/app-config-BPb3LCdH.d.mts
+//#region ../../0-framework/1-core/core/dist/app-config-CVyObaOe.d.mts
 //#region src/container-transport.d.ts
 /**
  * Carries resolved containers from the CLI process into the alchemy process
@@ -240,6 +240,14 @@ interface LowerOptions {
 interface Bundle {
   readonly dir: string;
   readonly entry: string;
+  /**
+   * Absolute paths to the USER-BUILT inputs this bundle was assembled from
+   * (ADR-0041). `prisma-composer dev`'s watch loop watches exactly these — a
+   * file entry as a file, a directory entry recursively — and re-runs
+   * assemble on a change. Optional so a build adapter that predates this
+   * field still compiles; a bundle without it is simply not watched.
+   */
+  readonly watch?: readonly string[];
 }
 /** Shared input shape for every extension's build descriptor. */
 interface AssembleInput {
@@ -408,4 +416,4 @@ interface PrismaAppConfig {
 declare function defineConfig(config: PrismaAppConfig): PrismaAppConfig;
 //#endregion
 export { containerEnvVarName as A, ProvisionEdge as C, TeardownInput as D, StateDescriptor as E, lowering as F, mergedProviders as I, resolveStateLayer as L, deserializeContainers as M, joinDeployment as N, buildConfig as O, lower as P, PrismaAppConfig as S, ServiceLowering as T, Lowering as _, Bundle as a, PackageInput as b, DeployedEntity as c, ExtensionDescriptor as d, LocateContainerInput as f, LoweredResult as g, LowerOptions as h, AssembleInput as i, defineConfig as j, containerEnv as k, DeployedNode as l, LowerError as m, ApplicationDescriptor as n, ContainerDescriptor as o, LowerContext as p, Artifact as r, ContainerInstance as s, AlchemyStateLayer as t, DeploymentResult as u, NodeDescriptor as v, ProvisionerDescriptor as w, PreflightInput as x, Outputs as y };
-//# sourceMappingURL=app-config-BPb3LCdH-CH7b8Khi.d.mts.map
+//# sourceMappingURL=app-config-CVyObaOe-PF94uVBK.d.mts.map

package/dist/app-config-CVyObaOe-PF94uVBK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-config-CVyObaOe-PF94uVBK.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/app-config-CVyObaOe.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAmBU;;WAEC;;WAEA;;;;;;;UAOD;WACC,OAAO;;EAEhB;;;;;;;;;;;;UAYQ,oBAAoB,UAAU,oBAAoB;;EAE1D,OAAO,OAAO,uBAAuB,QAAQ;;EAE7C,OAAO,OAAO,uBAAuB,QAAQ;;EAE7C,OAAO,UAAU,IAAI;;EAErB,YAAY,qBAAqB;;;iBAGlB,oBAAoB;;iBAEpB,aAAa,WAAW,oBAAoB,qBAAqB;;UAExE;WACC;WACA,YAAY;;;;;;iBAMN,sBAAsB,qBAAqB,+BAA+B,KAAK,SAAS,sCAAsC,oBAAoB;;;;KAI9J,oBAAoB,MAAM,MAAM,cAAc;;;;;;UAMzC;EACR,UAAU,KAAK,eAAe,OAAO;;;;;;;;UAQ7B;WACC;WACA;WACA;WACA;;WAEA,MAAM;;;UAGP;;EAER,UAAU,MAAM,gBAAgB,OAAO;;;;;;;;;;;;;;UAc/B,gBAAgB,aAAa;;EAErC,UAAU,KAAK,eAAe,OAAO,OAAO;;;;;;EAM5C,UAAU,KAAK,cAAc,aAAa,GAAG,QAAQ,SAAS,OAAO,OAAO;;;;;;EAM5E,QAAQ,KAAK,cAAc,OAAO,eAAe,OAAO,OAAO;;EAE/D,OAAO,KAAK,cAAc,aAAa,GAAG,UAAU,UAAU,YAAY,IAAI,OAAO,OAAO;;;UAGpF;;WAEC,WAAW;;WAEX;;;KAGN,YAAY,KAAK,iBAAiB,OAAO,OAAO;UAC3C;WACC,IAAI;;;;;;WAMJ;WACA,MAAM,cAAc;WACpB,OAAO;WACP,MAAM;;;;;;WAMN;;;;;;;WAOA,WAAW;;WAEX,SAAS,YAAY,QAAQ;;WAE7B,aAAa;;;;;;;;;KASnB,UAAU,SAAS;;;;;;;;;;;;;UAad;WACC;WACA;WACA;WACA,UAAU,SAAS;;;;;;;;;;;;;;UAcpB;WACC,SAAS;WACT,mBAAmB,MAAM;;;UAG1B;WACC;WACA,MAAM,cAAc;WACpB,mBAAmB;;;UAGpB;WACC;WACA,gBAAgB;;UAEjB;;WAEC;WACA,SAAS,eAAe;WACxB;;WAEA,QAAQ;;;;;;;;WAQR,UAAU,QAAQ;;;UAGnB;WACC;WACA;;;;;;;;WAQA;;;UAGD;WACC,OAAO;;WAEP;;WAEA;;;UAGD;WACC;WACA;;cAEG,mBAAmB;EAC/B,YAAY;;;;;;;;;;;;;;iBAcG,YAAY,MAAM,aAAa,IAAI,QAAQ,OAAO,OAAO,SAAS,YAAY,QAAQ,UAAU,aAAa,+BAA+B;;;;;;;;;;;;;;iBAc5I,eAAe,OAAO,OAAO;EAC5C;EACA,mBAAmB;eACN;;;;;;;;iBAQE,kBAAkB,MAAM,cAAc,QAAQ,iBAAiB,YAAY,oBAAoB,qBAAqB;;;;;;iBAMpH,gBAAgB,QAAQ,kBAAkB,MAAM;;;;;iBAKhD,SAAS,MAAM,YAAY,QAAQ,iBAAiB,MAAM,eAAe,OAAO,kBAAkB;;;;;;iBAMlG,MAAM,MAAM,YAAY,QAAQ,iBAAiB,MAAM,eAAe,OAAO,OAAO,QAAQ,uDAAuD;;;;;;;;UAQ1J;;WAEC;;WAEA,OAAO,eAAe;;WAEtB,aAAa,oBAAoB;;WAEjC,cAAc;;WAEd,kBAAkB,MAAM;;;;;;;;WAQxB,aAAa,OAAO,mBAAmB;;;;;;;;;WASvC,YAAY,OAAO,kBAAkB;;;;;;;;WAQrC,YAAY;;;;;;UAMb;;WAEC;;EAET,OAAO,WAAW,gCAAgC;;;UAG1C;;WAEC,OAAO;;WAEP,WAAW;;WAEX;;;UAGD;;WAEC,WAAW;;WAEX;;;;;;;KAON;WACM;IACP;WACO;IACP;WACO;EACT,SAAS,OAAO,gBAAgB,QAAQ;;;;;;;UAOhC;WACC,YAAY;WACZ,OAAO;;;iBAGD,aAAa,QAAQ,kBAAkB"}

package/dist/assertions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.mts","names":[],"sources":["../../../0-framework/0-foundation/foundation/dist/assertions.d.mts"],"mappings":";;;;;;;;;;;;;;;iBAciB,cAAc,GAAG,OAAO,sBAAsB,0BAA0B,SAAS;;;;;;;;;;;;iBAYjF,UAAU,oBAAoB,0BAA0B"}

package/dist/bin.mjs

@@ -88,7 +88,7 @@ function blindCast(input) {
 	return input;
 }
 //#endregion
-//#region ../../0-framework/1-core/core/dist/graph-BmrUEdo9.mjs
+//#region ../../0-framework/1-core/core/dist/graph-CP16cJyH.mjs
 /** Thrown by Load when the graph is malformed. */
 var LoadError = class extends Error {
 	constructor(message) {
@@ -112,6 +112,15 @@ function isParamSource(value) {
 	return typeof value === "object" && value !== null && blindCast(value)[PARAM_SOURCE] === true;
 }
 /**
+* Core's grammar for every name that becomes a config-key segment —
+* addresses, input/param/secret names: ASCII letters and digits only.
+* Conservative by design so any target medium — POSIX env-var keys
+* included — can uppercase and "_"-join segments without escaping.
+*/
+function isConfigKeySegment(name) {
+	return /^[A-Za-z0-9]+$/.test(name);
+}
+/**
 * True if `value` was constructed by this module's factories. Checks the
 * brand only, never a prototype — a graph may mix nodes from a different
 * installed copy of core (dual-package hazard).
@@ -399,7 +408,7 @@ function flatten(moduleNode, address, wiring, secretWiring, paramWiring, nodes,
 		const provisionSecrets = opts?.secrets;
 		const provisionParams = opts?.params;
 		if (typeof id !== "string" || id.length === 0) throw new LoadError(`provision() requires a non-empty id (module "${moduleNode.name}").`);
-		if (id.includes("_") || id.includes(".")) throw new LoadError(`provision() id "${id}" (module "${moduleNode.name}") may not contain "_" or "." — "_" is the config-key separator and "." the node-id path separator; either inside an id collides with the joined form of other names.`);
+		if (!isConfigKeySegment(id)) throw new LoadError(`provision() id "${id}" (module "${moduleNode.name}") must contain only ASCII letters and digits ([A-Za-z0-9]) — the id becomes an address segment, and addresses derive deterministic config keys (segments uppercased and joined with "_"). "${id}" would put "${id.toUpperCase()}" inside the derived key. ("_" collides with the key separator and "." with the address separator.)`);
 		if (localIds.has(id)) throw new LoadError(`Duplicate provision id "${id}" in module "${moduleNode.name}".`);
 		const untrusted = child;
 		if (!isNode(untrusted) || untrusted.kind !== "service" && untrusted.kind !== "resource" && untrusted.kind !== "module") throw new LoadError(`provision("${id}") expects a branded service, resource, or module node (construct it with the service()/resource()/module() factories or a pack's own).`);
@@ -602,7 +611,7 @@ function containerEnv(instances) {
 	return env;
 }
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/cli-Bc6_i0ls.mjs
+//#region ../../0-framework/3-tooling/cli/dist/cli-riJGhp7G.mjs
 /**
 * A user-facing failure with a message that already names the fix (deploy-cli.md
 * § Error surface). `bin.ts` catches this — and any other Error, including
@@ -742,6 +751,41 @@ async function loadAppConfig(configPath) {
 	};
 }
 /**
+* `loadEntry` imports a user's topology with the host runtime's own module
+* loader — under node (the CLI's shebang runtime), that loader strips
+* TypeScript types but has no JSX transform (ADR-0005: the framework
+* doesn't bundle or transform the app's code; deploy loading is no
+* exception). A `.tsx`/`.jsx` file anywhere in the topology's import graph
+* dies with node's raw `ERR_UNKNOWN_FILE_EXTENSION`, which names the file
+* but not the cause or the fix. This turns that one case into a CliError
+* message that does — every other load failure (syntax errors, missing
+* files, non-JSX unknown extensions) is untouched, re-thrown as-is.
+*/
+const UNKNOWN_EXTENSION_CODE = "ERR_UNKNOWN_FILE_EXTENSION";
+const JSX_EXTENSIONS = [".tsx", ".jsx"];
+function errorCode(error) {
+	return "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function unknownExtensionPath(error) {
+	if (!(error instanceof Error)) return void 0;
+	if (errorCode(error) !== UNKNOWN_EXTENSION_CODE) return void 0;
+	return /Unknown file extension "\.\w+" for (.+)$/.exec(error.message)?.[1];
+}
+/**
+* Returns a CliError-ready message when `error` is node's
+* `ERR_UNKNOWN_FILE_EXTENSION` for a `.tsx`/`.jsx` file — `undefined` for
+* every other error (including unknown-extension failures for some other
+* extension), so the caller can fall through to its normal rethrow.
+*/
+function explainJsxLoadError(error, entryPath) {
+	const offendingPath = unknownExtensionPath(error);
+	if (offendingPath === void 0) return void 0;
+	if (!JSX_EXTENSIONS.some((ext) => offendingPath.endsWith(ext))) return void 0;
+	return `"${offendingPath}" can't be loaded: deploy loads "${entryPath}"'s topology with node's own module loader, which strips TypeScript types but has no JSX transform — so a .tsx/.jsx file can't sit anywhere in that import graph.
+
+Precompile that file in your own build (transform the JSX away, keep the real npm packages external) and import the compiled output instead of the raw .tsx/.jsx — see examples/email/scripts/build.ts in the prisma/composer repo for a worked example.`;
+}
+/**
 * Pipeline step 1 (deploy-cli.md § The pipeline): import the entry module
 * (resolved against cwd) and require its default export to be a node — a
 * service or module, branded by core's factories. Whatever this module exports
@@ -749,7 +793,15 @@ async function loadAppConfig(configPath) {
 */
 async function loadEntry(entryArg, cwd) {
 	const resolvedPath = path.resolve(cwd, entryArg);
-	const root = (await import(pathToFileURL(resolvedPath).href)).default;
+	let mod;
+	try {
+		mod = await import(pathToFileURL(resolvedPath).href);
+	} catch (error) {
+		const explained = explainJsxLoadError(error, resolvedPath);
+		if (explained !== void 0) throw new CliError(explained);
+		throw error;
+	}
+	const root = blindCast(mod).default;
 	if (!isNode(root) || root.kind === "dependency" || root.kind === "resource") throw new CliError(`Entry module "${resolvedPath}" must default-export a node (a service or a module) — construct it with service() or module() from @prisma/composer.`);
 	return {
 		path: resolvedPath,